From 9fdfdb962a6f38b61dc171d0121371ae7be075a0 Mon Sep 17 00:00:00 2001 From: Manan Gupta <35839558+GuptaManan100@users.noreply.github.com> Date: Fri, 15 Nov 2024 10:07:58 +0530 Subject: [PATCH 1/9] Fix deadlock in messager and health streamer (#17230) Signed-off-by: Manan Gupta --- .../vttablet/tabletserver/health_streamer.go | 60 +++++++++++-------- .../tabletserver/health_streamer_test.go | 40 +++++++++++++ .../vttablet/tabletserver/messager/engine.go | 30 ++++++---- .../tabletserver/messager/engine_test.go | 33 +++++++++- go/vt/vttablet/tabletserver/schema/engine.go | 8 +++ 5 files changed, 134 insertions(+), 37 deletions(-) diff --git a/go/vt/vttablet/tabletserver/health_streamer.go b/go/vt/vttablet/tabletserver/health_streamer.go index cfc5ea5e974..f9f65d197b2 100644 --- a/go/vt/vttablet/tabletserver/health_streamer.go +++ b/go/vt/vttablet/tabletserver/health_streamer.go @@ -66,11 +66,18 @@ type healthStreamer struct { degradedThreshold time.Duration unhealthyThreshold atomic.Int64 - mu sync.Mutex - ctx context.Context - cancel context.CancelFunc - clients map[chan *querypb.StreamHealthResponse]struct{} - state *querypb.StreamHealthResponse + // cancelMu is a mutex used to protect the cancel variable + // and for ensuring we don't call setup functions in parallel. + cancelMu sync.Mutex + ctx context.Context + cancel context.CancelFunc + + // fieldsMu is used to protect access to the fields below. + // We require two separate mutexes, so that we don't have to acquire the same mutex + // in Close and reload that can lead to a deadlock described in https://github.com/vitessio/vitess/issues/17229#issuecomment-2476136610. + fieldsMu sync.Mutex + clients map[chan *querypb.StreamHealthResponse]struct{} + state *querypb.StreamHealthResponse // isServingPrimary stores if this tablet is currently the serving primary or not. isServingPrimary bool @@ -110,8 +117,8 @@ func (hs *healthStreamer) InitDBConfig(target *querypb.Target) { } func (hs *healthStreamer) Open() { - hs.mu.Lock() - defer hs.mu.Unlock() + hs.cancelMu.Lock() + defer hs.cancelMu.Unlock() if hs.cancel != nil { return @@ -120,8 +127,8 @@ func (hs *healthStreamer) Open() { } func (hs *healthStreamer) Close() { - hs.mu.Lock() - defer hs.mu.Unlock() + hs.cancelMu.Lock() + defer hs.cancelMu.Unlock() if hs.cancel != nil { hs.se.UnregisterNotifier("healthStreamer") @@ -158,13 +165,16 @@ func (hs *healthStreamer) Stream(ctx context.Context, callback func(*querypb.Str } func (hs *healthStreamer) register() (chan *querypb.StreamHealthResponse, context.Context) { - hs.mu.Lock() - defer hs.mu.Unlock() + hs.cancelMu.Lock() + defer hs.cancelMu.Unlock() if hs.cancel == nil { return nil, nil } + hs.fieldsMu.Lock() + defer hs.fieldsMu.Unlock() + ch := make(chan *querypb.StreamHealthResponse, streamHealthBufferSize) hs.clients[ch] = struct{}{} @@ -174,15 +184,15 @@ func (hs *healthStreamer) register() (chan *querypb.StreamHealthResponse, contex } func (hs *healthStreamer) unregister(ch chan *querypb.StreamHealthResponse) { - hs.mu.Lock() - defer hs.mu.Unlock() + hs.fieldsMu.Lock() + defer hs.fieldsMu.Unlock() delete(hs.clients, ch) } func (hs *healthStreamer) ChangeState(tabletType topodatapb.TabletType, ptsTimestamp time.Time, lag time.Duration, err error, serving bool) { - hs.mu.Lock() - defer hs.mu.Unlock() + hs.fieldsMu.Lock() + defer hs.fieldsMu.Unlock() hs.state.Target.TabletType = tabletType if tabletType == topodatapb.TabletType_PRIMARY { @@ -236,8 +246,8 @@ func (hs *healthStreamer) broadCastToClients(shr *querypb.StreamHealthResponse) } func (hs *healthStreamer) AppendDetails(details []*kv) []*kv { - hs.mu.Lock() - defer hs.mu.Unlock() + hs.fieldsMu.Lock() + defer hs.fieldsMu.Unlock() if hs.state.Target.TabletType == topodatapb.TabletType_PRIMARY { return details } @@ -282,8 +292,8 @@ func (hs *healthStreamer) SetUnhealthyThreshold(v time.Duration) { // MakePrimary tells the healthstreamer that the current tablet is now the primary, // so it can read and write to the MySQL instance for schema-tracking. func (hs *healthStreamer) MakePrimary(serving bool) { - hs.mu.Lock() - defer hs.mu.Unlock() + hs.fieldsMu.Lock() + defer hs.fieldsMu.Unlock() hs.isServingPrimary = serving // We register for notifications from the schema Engine only when schema tracking is enabled, // and we are going to a serving primary state. @@ -298,15 +308,15 @@ func (hs *healthStreamer) MakePrimary(serving bool) { // MakeNonPrimary tells the healthstreamer that the current tablet is now not a primary. func (hs *healthStreamer) MakeNonPrimary() { - hs.mu.Lock() - defer hs.mu.Unlock() + hs.fieldsMu.Lock() + defer hs.fieldsMu.Unlock() hs.isServingPrimary = false } // reload reloads the schema from the underlying mysql for the tables that we get the alert on. func (hs *healthStreamer) reload(created, altered, dropped []*schema.Table, udfsChanged bool) error { - hs.mu.Lock() - defer hs.mu.Unlock() + hs.fieldsMu.Lock() + defer hs.fieldsMu.Unlock() // Schema Reload to happen only on primary when it is serving. // We can be in a state when the primary is not serving after we have run DemotePrimary. In that case, // we don't want to run any queries in MySQL, so we shouldn't reload anything in the healthStreamer. @@ -349,8 +359,8 @@ func (hs *healthStreamer) reload(created, altered, dropped []*schema.Table, udfs // sendUnresolvedTransactionSignal sends broadcast message about unresolved transactions. func (hs *healthStreamer) sendUnresolvedTransactionSignal() { - hs.mu.Lock() - defer hs.mu.Unlock() + hs.fieldsMu.Lock() + defer hs.fieldsMu.Unlock() // send signal only when primary is serving. if !hs.isServingPrimary { return diff --git a/go/vt/vttablet/tabletserver/health_streamer_test.go b/go/vt/vttablet/tabletserver/health_streamer_test.go index 5cf434e8fa2..3421141ff80 100644 --- a/go/vt/vttablet/tabletserver/health_streamer_test.go +++ b/go/vt/vttablet/tabletserver/health_streamer_test.go @@ -572,3 +572,43 @@ func testStream(hs *healthStreamer) (<-chan *querypb.StreamHealthResponse, conte func testBlpFunc() (int64, int32) { return 1, 2 } + +// TestDeadlockBwCloseAndReload tests the deadlock observed between Close and Reload +// functions. More details can be found in the issue https://github.com/vitessio/vitess/issues/17229#issuecomment-2476136610. +func TestDeadlockBwCloseAndReload(t *testing.T) { + cfg := newConfig(nil) + env := tabletenv.NewEnv(vtenv.NewTestEnv(), cfg, "TestNotServingPrimary") + alias := &topodatapb.TabletAlias{ + Cell: "cell", + Uid: 1, + } + se := schema.NewEngineForTests() + // Create a new health streamer and set it to a serving primary state + hs := newHealthStreamer(env, alias, se) + hs.signalWhenSchemaChange = true + hs.Open() + hs.MakePrimary(true) + defer hs.Close() + + wg := sync.WaitGroup{} + wg.Add(2) + // Try running Close and reload in parallel multiple times. + // This reproduces the deadlock quite readily. + go func() { + defer wg.Done() + for i := 0; i < 100; i++ { + hs.Close() + hs.Open() + } + }() + + go func() { + defer wg.Done() + for i := 0; i < 100; i++ { + se.BroadcastForTesting(nil, nil, nil, true) + } + }() + + // Wait for wait group to finish. + wg.Wait() +} diff --git a/go/vt/vttablet/tabletserver/messager/engine.go b/go/vt/vttablet/tabletserver/messager/engine.go index 2e526fcdc3d..9d8b09e819a 100644 --- a/go/vt/vttablet/tabletserver/messager/engine.go +++ b/go/vt/vttablet/tabletserver/messager/engine.go @@ -52,9 +52,16 @@ type VStreamer interface { // Engine is the engine for handling messages. type Engine struct { - mu sync.Mutex - isOpen bool - managers map[string]*messageManager + // mu is a mutex used to protect the isOpen variable + // and for ensuring we don't call setup functions in parallel. + mu sync.Mutex + isOpen bool + + // managersMu is a mutex used to protect the managers field. + // We require two separate mutexes, so that we don't have to acquire the same mutex + // in Close and schemaChanged which can lead to a deadlock described in https://github.com/vitessio/vitess/issues/17229. + managersMu sync.Mutex + managers map[string]*messageManager tsv TabletService se *schema.Engine @@ -76,15 +83,12 @@ func NewEngine(tsv TabletService, se *schema.Engine, vs VStreamer) *Engine { // Open starts the Engine service. func (me *Engine) Open() { me.mu.Lock() + defer me.mu.Unlock() if me.isOpen { - me.mu.Unlock() return } me.isOpen = true - me.mu.Unlock() log.Info("Messager: opening") - // Unlock before invoking RegisterNotifier because it - // obtains the same lock. me.se.RegisterNotifier("messages", me.schemaChanged, true) } @@ -102,6 +106,8 @@ func (me *Engine) Close() { log.Infof("messager Engine - unregistering notifiers") me.se.UnregisterNotifier("messages") log.Infof("messager Engine - closing all managers") + me.managersMu.Lock() + defer me.managersMu.Unlock() for _, mm := range me.managers { mm.Close() } @@ -110,8 +116,8 @@ func (me *Engine) Close() { } func (me *Engine) GetGenerator(name string) (QueryGenerator, error) { - me.mu.Lock() - defer me.mu.Unlock() + me.managersMu.Lock() + defer me.managersMu.Unlock() mm := me.managers[name] if mm == nil { return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "message table %s not found in schema", name) @@ -132,6 +138,8 @@ func (me *Engine) Subscribe(ctx context.Context, name string, send func(*sqltype if !me.isOpen { return nil, vterrors.Errorf(vtrpcpb.Code_UNAVAILABLE, "messager engine is closed, probably because this is not a primary any more") } + me.managersMu.Lock() + defer me.managersMu.Unlock() mm := me.managers[name] if mm == nil { return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "message table %s not found", name) @@ -140,8 +148,8 @@ func (me *Engine) Subscribe(ctx context.Context, name string, send func(*sqltype } func (me *Engine) schemaChanged(tables map[string]*schema.Table, created, altered, dropped []*schema.Table, _ bool) { - me.mu.Lock() - defer me.mu.Unlock() + me.managersMu.Lock() + defer me.managersMu.Unlock() for _, table := range append(dropped, altered...) { name := table.Name.String() mm := me.managers[name] diff --git a/go/vt/vttablet/tabletserver/messager/engine_test.go b/go/vt/vttablet/tabletserver/messager/engine_test.go index 30e849ac73b..124e6a9a380 100644 --- a/go/vt/vttablet/tabletserver/messager/engine_test.go +++ b/go/vt/vttablet/tabletserver/messager/engine_test.go @@ -19,6 +19,7 @@ package messager import ( "context" "reflect" + "sync" "testing" "vitess.io/vitess/go/sqltypes" @@ -156,7 +157,7 @@ func newTestEngine() *Engine { tsv := &fakeTabletServer{ Env: tabletenv.NewEnv(vtenv.NewTestEnv(), cfg, "MessagerTest"), } - se := schema.NewEngine(tsv) + se := schema.NewEngineForTests() te := NewEngine(tsv, se, newFakeVStreamer()) te.Open() return te @@ -169,3 +170,33 @@ func newEngineReceiver() (f func(qr *sqltypes.Result) error, ch chan *sqltypes.R return nil }, ch } + +// TestDeadlockBwCloseAndSchemaChange tests the deadlock observed between Close and schemaChanged +// functions. More details can be found in the issue https://github.com/vitessio/vitess/issues/17229. +func TestDeadlockBwCloseAndSchemaChange(t *testing.T) { + engine := newTestEngine() + defer engine.Close() + se := engine.se + + wg := sync.WaitGroup{} + wg.Add(2) + // Try running Close and schemaChanged in parallel multiple times. + // This reproduces the deadlock quite readily. + go func() { + defer wg.Done() + for i := 0; i < 100; i++ { + engine.Close() + engine.Open() + } + }() + + go func() { + defer wg.Done() + for i := 0; i < 100; i++ { + se.BroadcastForTesting(nil, nil, nil, true) + } + }() + + // Wait for wait group to finish. + wg.Wait() +} diff --git a/go/vt/vttablet/tabletserver/schema/engine.go b/go/vt/vttablet/tabletserver/schema/engine.go index 09b3a91ffed..fb4a9d9367a 100644 --- a/go/vt/vttablet/tabletserver/schema/engine.go +++ b/go/vt/vttablet/tabletserver/schema/engine.go @@ -865,6 +865,13 @@ func (se *Engine) broadcast(created, altered, dropped []*Table, udfsChanged bool } } +// BroadcastForTesting is meant to be a testing function that triggers a broadcast call. +func (se *Engine) BroadcastForTesting(created, altered, dropped []*Table, udfsChanged bool) { + se.mu.Lock() + defer se.mu.Unlock() + se.broadcast(created, altered, dropped, udfsChanged) +} + // GetTable returns the info for a table. func (se *Engine) GetTable(tableName sqlparser.IdentifierCS) *Table { se.mu.Lock() @@ -951,6 +958,7 @@ func NewEngineForTests() *Engine { tables: make(map[string]*Table), historian: newHistorian(false, 0, nil), env: tabletenv.NewEnv(vtenv.NewTestEnv(), tabletenv.NewDefaultConfig(), "SchemaEngineForTests"), + notifiers: make(map[string]notifier), } return se } From 216fd70be49fa14ddd22ea97d26a9434770c0ca2 Mon Sep 17 00:00:00 2001 From: Matt Lord Date: Fri, 15 Nov 2024 21:39:37 -0500 Subject: [PATCH 2/9] Binlog: Improve ZstdInMemoryDecompressorMaxSize management (#17220) Signed-off-by: Matt Lord --- go/flags/endtoend/vtcombo.txt | 1 + go/flags/endtoend/vttablet.txt | 1 + go/mysql/binlog_event_compression.go | 21 ++++++++++++--------- go/mysql/binlog_event_mysql56_test.go | 8 +++++++- go/vt/vttablet/common/flags.go | 3 +++ 5 files changed, 24 insertions(+), 10 deletions(-) diff --git a/go/flags/endtoend/vtcombo.txt b/go/flags/endtoend/vtcombo.txt index 8c6eafe9c1c..01a391d0cad 100644 --- a/go/flags/endtoend/vtcombo.txt +++ b/go/flags/endtoend/vtcombo.txt @@ -21,6 +21,7 @@ Flags: --backup_storage_compress if set, the backup files will be compressed. (default true) --backup_storage_number_blocks int if backup_storage_compress is true, backup_storage_number_blocks sets the number of blocks that can be processed, in parallel, before the writer blocks, during compression (default is 2). It should be equal to the number of CPUs available for compression. (default 2) --bind-address string Bind address for the server. If empty, the server will listen on all available unicast and anycast IP addresses of the local system. + --binlog-in-memory-decompressor-max-size uint This value sets the uncompressed transaction payload size at which we switch from in-memory buffer based decompression to the slower streaming mode. (default 134217728) --binlog_host string PITR restore parameter: hostname/IP of binlog server. --binlog_password string PITR restore parameter: password of binlog server. --binlog_player_protocol string the protocol to download binlogs from a vttablet (default "grpc") diff --git a/go/flags/endtoend/vttablet.txt b/go/flags/endtoend/vttablet.txt index 35a07b265bc..8be7b620469 100644 --- a/go/flags/endtoend/vttablet.txt +++ b/go/flags/endtoend/vttablet.txt @@ -56,6 +56,7 @@ Flags: --backup_storage_implementation string Which backup storage implementation to use for creating and restoring backups. --backup_storage_number_blocks int if backup_storage_compress is true, backup_storage_number_blocks sets the number of blocks that can be processed, in parallel, before the writer blocks, during compression (default is 2). It should be equal to the number of CPUs available for compression. (default 2) --bind-address string Bind address for the server. If empty, the server will listen on all available unicast and anycast IP addresses of the local system. + --binlog-in-memory-decompressor-max-size uint This value sets the uncompressed transaction payload size at which we switch from in-memory buffer based decompression to the slower streaming mode. (default 134217728) --binlog_host string PITR restore parameter: hostname/IP of binlog server. --binlog_password string PITR restore parameter: password of binlog server. --binlog_player_grpc_ca string the server ca to use to validate servers when connecting diff --git a/go/mysql/binlog_event_compression.go b/go/mysql/binlog_event_compression.go index 1cb38d5cb16..7455218d4b5 100644 --- a/go/mysql/binlog_event_compression.go +++ b/go/mysql/binlog_event_compression.go @@ -58,11 +58,6 @@ const ( // Length of the binlog event header for internal events within // the transaction payload. headerLen = binlogEventLenOffset + eventLenBytes - - // At what size should we switch from the in-memory buffer - // decoding to streaming mode which is much slower, but does - // not require everything be done in memory. - zstdInMemoryDecompressorMaxSize = 128 << (10 * 2) // 128MiB ) var ( @@ -75,13 +70,18 @@ var ( compressedTrxPayloadsInMem = stats.NewCounter("CompressedTransactionPayloadsInMemory", "The number of compressed binlog transaction payloads that were processed in memory") compressedTrxPayloadsUsingStream = stats.NewCounter("CompressedTransactionPayloadsViaStream", "The number of compressed binlog transaction payloads that were processed using a stream") + // At what size should we switch from the in-memory buffer + // decoding to streaming mode which is much slower, but does + // not require everything be done in memory all at once. + ZstdInMemoryDecompressorMaxSize = uint64(128 << (10 * 2)) // 128MiB + // A concurrent stateless decoder that caches decompressors. This is // used for smaller payloads that we want to handle entirely using // in-memory buffers via DecodeAll. statelessDecoder *zstd.Decoder // A pool of stateful decoders for larger payloads that we want to - // stream. The number of large (> zstdInMemoryDecompressorMaxSize) + // stream. The number of large (> ZstdInMemoryDecompressorMaxSize) // payloads should typically be relatively low, but there may be times // where there are many of them -- and users like vstreamer may have // N concurrent streams per tablet which could lead to a lot of @@ -271,7 +271,7 @@ func (tp *TransactionPayload) decode() error { } // decompress decompresses the payload. If the payload is larger than -// zstdInMemoryDecompressorMaxSize then we stream the decompression via +// ZstdInMemoryDecompressorMaxSize then we stream the decompression via // the package's pool of zstd.Decoders, otherwise we use in-memory // buffers with the package's concurrent statelessDecoder. // In either case, we setup the reader that can be used within the @@ -284,7 +284,7 @@ func (tp *TransactionPayload) decompress() error { // Switch to slower but less memory intensive stream mode for // larger payloads. - if tp.uncompressedSize > zstdInMemoryDecompressorMaxSize { + if tp.uncompressedSize > ZstdInMemoryDecompressorMaxSize { in := bytes.NewReader(tp.payload) streamDecoder, err := statefulDecoderPool.Get(in) if err != nil { @@ -366,7 +366,10 @@ func (dp *decoderPool) Get(reader io.Reader) (*zstd.Decoder, error) { return nil, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "[BUG] expected *zstd.Decoder but got %T", pooled) } } else { - d, err := zstd.NewReader(nil, zstd.WithDecoderMaxMemory(zstdInMemoryDecompressorMaxSize)) + // Use the minimum amount of memory we can in processing the transaction by + // setting lowMem to true and limiting the decoder concurrency to 1 so that + // there's no async decoding of multiple windows or blocks. + d, err := zstd.NewReader(nil, zstd.WithDecoderLowmem(true), zstd.WithDecoderConcurrency(1)) if err != nil { // Should only happen e.g. due to ENOMEM return nil, vterrors.Wrap(err, "failed to create stateful stream decoder") } diff --git a/go/mysql/binlog_event_mysql56_test.go b/go/mysql/binlog_event_mysql56_test.go index f173e27e4af..861d98c6e4f 100644 --- a/go/mysql/binlog_event_mysql56_test.go +++ b/go/mysql/binlog_event_mysql56_test.go @@ -141,6 +141,12 @@ func TestMysql56DecodeTransactionPayload(t *testing.T) { }, } + // Ensure that we can process events where the *uncompressed* size is + // larger than ZstdInMemoryDecompressorMaxSize. The *compressed* size + // of the payload in large_compressed_trx_payload.bin is 16KiB so we + // set the max to 2KiB to test this. + ZstdInMemoryDecompressorMaxSize = 2048 + for _, tc := range testCases { memDecodingCnt := compressedTrxPayloadsInMem.Get() streamDecodingCnt := compressedTrxPayloadsUsingStream.Get() @@ -191,7 +197,7 @@ func TestMysql56DecodeTransactionPayload(t *testing.T) { totalSize += len(eventStr) require.True(t, strings.HasPrefix(eventStr, want)) } - require.Greater(t, totalSize, zstdInMemoryDecompressorMaxSize) + require.Greater(t, uint64(totalSize), ZstdInMemoryDecompressorMaxSize) } } } diff --git a/go/vt/vttablet/common/flags.go b/go/vt/vttablet/common/flags.go index f9775b8af3e..3c6141d62eb 100644 --- a/go/vt/vttablet/common/flags.go +++ b/go/vt/vttablet/common/flags.go @@ -21,6 +21,7 @@ import ( "github.com/spf13/pflag" + "vitess.io/vitess/go/mysql" "vitess.io/vitess/go/vt/servenv" ) @@ -94,4 +95,6 @@ func registerFlags(fs *pflag.FlagSet) { fs.BoolVar(&vreplicationStoreCompressedGTID, "vreplication_store_compressed_gtid", vreplicationStoreCompressedGTID, "Store compressed gtids in the pos column of the sidecar database's vreplication table") fs.IntVar(&vreplicationParallelInsertWorkers, "vreplication-parallel-insert-workers", vreplicationParallelInsertWorkers, "Number of parallel insertion workers to use during copy phase. Set <= 1 to disable parallelism, or > 1 to enable concurrent insertion during copy phase.") + + fs.Uint64Var(&mysql.ZstdInMemoryDecompressorMaxSize, "binlog-in-memory-decompressor-max-size", mysql.ZstdInMemoryDecompressorMaxSize, "This value sets the uncompressed transaction payload size at which we switch from in-memory buffer based decompression to the slower streaming mode.") } From 7baa4f28e2e649e73790c319fb7dfbfb05d87bf5 Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Tue, 19 Nov 2024 11:13:33 +0200 Subject: [PATCH 3/9] Handle MySQL handler error codes (#17252) Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> --- go/mysql/sqlerror/constants.go | 190 ++++++++++++++++++ go/mysql/sqlerror/sql_error.go | 12 ++ go/mysql/sqlerror/sql_error_test.go | 21 ++ .../tabletmanager/vreplication/utils.go | 18 ++ .../tabletmanager/vreplication/utils_test.go | 10 + 5 files changed, 251 insertions(+) diff --git a/go/mysql/sqlerror/constants.go b/go/mysql/sqlerror/constants.go index da2351bf00d..5fedf567998 100644 --- a/go/mysql/sqlerror/constants.go +++ b/go/mysql/sqlerror/constants.go @@ -203,6 +203,7 @@ const ( ERBlobKeyWithoutLength = ErrorCode(1170) ERPrimaryCantHaveNull = ErrorCode(1171) ERTooManyRows = ErrorCode(1172) + ERErrorDuringCommit = ErrorCode(1180) ERLockOrActiveTransaction = ErrorCode(1192) ERUnknownSystemVariable = ErrorCode(1193) ERSetConstantsOnly = ErrorCode(1204) @@ -301,6 +302,195 @@ const ( ERServerIsntAvailable = ErrorCode(3168) ) +// HandlerErrorCode is for errors thrown by the handler, and which are then embedded in other errors. +// See https://github.com/mysql/mysql-server/blob/trunk/include/my_base.h +type HandlerErrorCode uint16 + +func (e HandlerErrorCode) ToString() string { + return strconv.FormatUint(uint64(e), 10) +} + +const ( + // Didn't find key on read or update + HaErrKeyNotFound = HandlerErrorCode(120) + // Duplicate key on write + HaErrFoundDuppKey = HandlerErrorCode(121) + // Internal error + HaErrInternalError = HandlerErrorCode(122) + // Uppdate with is recoverable + HaErrRecordChanged = HandlerErrorCode(123) + // Wrong index given to function + HaErrWrongIndex = HandlerErrorCode(124) + // Transaction has been rolled back + HaErrRolledBack = HandlerErrorCode(125) + // Indexfile is crashed + HaErrCrashed = HandlerErrorCode(126) + // Record-file is crashed + HaErrWrongInRecord = HandlerErrorCode(127) + // Record-file is crashed + HaErrOutOfMem = HandlerErrorCode(128) + // not a MYI file - no signature + HaErrNotATable = HandlerErrorCode(130) + // Command not supported + HaErrWrongCommand = HandlerErrorCode(131) + // old database file + HaErrOldFile = HandlerErrorCode(132) + // No record read in update() + HaErrNoActiveRecord = HandlerErrorCode(133) + // A record is not there + HaErrRecordDeleted = HandlerErrorCode(134) + // No more room in file + HaErrRecordFileFull = HandlerErrorCode(135) + // No more room in file + HaErrIndexFileFull = HandlerErrorCode(136) + // end in next/prev/first/last + HaErrEndOfFile = HandlerErrorCode(137) + // unsupported extension used + HaErrUnsupported = HandlerErrorCode(138) + // Too big row + HaErrTooBigRow = HandlerErrorCode(139) + // Wrong create option + HaWrongCreateOption = HandlerErrorCode(140) + // Duplicate unique on write + HaErrFoundDuppUnique = HandlerErrorCode(141) + // Can't open charset + HaErrUnknownCharset = HandlerErrorCode(142) + // conflicting tables in MERGE + HaErrWrongMrgTableDef = HandlerErrorCode(143) + // Last (automatic?) repair failed + HaErrCrashedOnRepair = HandlerErrorCode(144) + // Table must be repaired + HaErrCrashedOnUsage = HandlerErrorCode(145) + // Lock wait timeout + HaErrLockWaitTimeout = HandlerErrorCode(146) + // Lock table is full + HaErrLockTableFull = HandlerErrorCode(147) + // Updates not allowed + HaErrReadOnlyTransaction = HandlerErrorCode(148) + // Deadlock found when trying to get lock + HaErrLockDeadlock = HandlerErrorCode(149) + // Cannot add a foreign key constr. + HaErrCannotAddForeign = HandlerErrorCode(150) + // Cannot add a child row + HaErrNoReferencedRow = HandlerErrorCode(151) + // Cannot delete a parent row + HaErrRowIsReferenced = HandlerErrorCode(152) + // No savepoint with that name + HaErrNoSavepoint = HandlerErrorCode(153) + // Non unique key block size + HaErrNonUniqueBlockSize = HandlerErrorCode(154) + // The table does not exist in engine + HaErrNoSuchTable = HandlerErrorCode(155) + // The table existed in storage engine + HaErrTableExist = HandlerErrorCode(156) + // Could not connect to storage engine + HaErrNoConnection = HandlerErrorCode(157) + // NULLs are not supported in spatial index + HaErrNullInSpatial = HandlerErrorCode(158) + // The table changed in storage engine + HaErrTableDefChanged = HandlerErrorCode(159) + // There's no partition in table for given value + HaErrNoPartitionFound = HandlerErrorCode(160) + // Row-based binlogging of row failed + HaErrRbrLoggingFailed = HandlerErrorCode(161) + // Index needed in foreign key constraint + HaErrDropIndexFk = HandlerErrorCode(162) + // Upholding foreign key constraints would lead to a duplicate key error in some other table. + HaErrForeignDuplicateKey = HandlerErrorCode(163) + // The table changed in storage engine + HaErrTableNeedsUpgrade = HandlerErrorCode(164) + // The table is not writable + HaErrTableReadonly = HandlerErrorCode(165) + // Failed to get next autoinc value + HaErrAutoincReadFailed = HandlerErrorCode(166) + // Failed to set row autoinc value + HaErrAutoincErange = HandlerErrorCode(167) + // Generic error + HaErrGeneric = HandlerErrorCode(168) + // row not actually updated: new values same as the old values + HaErrRecordIsTheSame = HandlerErrorCode(169) + // It is not possible to log this statement + HaErrLoggingImpossible = HandlerErrorCode(170) + // The event was corrupt, leading to illegal data being read + HaErrCorruptEvent = HandlerErrorCode(171) + // New file format + HaErrNewFile = HandlerErrorCode(172) + // The event could not be processed no other handler error happened + HaErrRowsEventApply = HandlerErrorCode(173) + // Error during initialization + HaErrInitialization = HandlerErrorCode(174) + // File too short + HaErrFileTooShort = HandlerErrorCode(175) + // Wrong CRC on page + HaErrWrongCrc = HandlerErrorCode(176) + // Too many active concurrent transactions + HaErrTooManyConcurrentTrxs = HandlerErrorCode(177) + // There's no explicitly listed partition in table for the given value + HaErrNotInLockPartitions = HandlerErrorCode(178) + // Index column length exceeds limit + HaErrIndexColTooLong = HandlerErrorCode(179) + // InnoDB index corrupted + HaErrIndexCorrupt = HandlerErrorCode(180) + // Undo log record too big + HaErrUndoRecTooBig = HandlerErrorCode(181) + // Invalid InnoDB Doc ID + HaFtsInvalidDocid = HandlerErrorCode(182) + // Table being used in foreign key check + HaErrTableInFkCheck = HandlerErrorCode(183) + // The tablespace existed in storage engine + HaErrTablespaceExists = HandlerErrorCode(184) + // Table has too many columns + HaErrTooManyFields = HandlerErrorCode(185) + // Row in wrong partition + HaErrRowInWrongPartition = HandlerErrorCode(186) + // InnoDB is in read only mode. + HaErrInnodbReadOnly = HandlerErrorCode(187) + // FTS query exceeds result cache limit + HaErrFtsExceedResultCacheLimit = HandlerErrorCode(188) + // Temporary file write failure + HaErrTempFileWriteFailure = HandlerErrorCode(189) + // Innodb is in force recovery mode + HaErrInnodbForcedRecovery = HandlerErrorCode(190) + // Too many words in a phrase + HaErrFtsTooManyWordsInPhrase = HandlerErrorCode(191) + // FK cascade depth exceeded + HaErrFkDepthExceeded = HandlerErrorCode(192) + // Option Missing during Create + HaMissingCreateOption = HandlerErrorCode(193) + // Out of memory in storage engine + HaErrSeOutOfMemory = HandlerErrorCode(194) + // Table/Clustered index is corrupted. + HaErrTableCorrupt = HandlerErrorCode(195) + // The query was interrupted + HaErrQueryInterrupted = HandlerErrorCode(196) + // Missing Tablespace + HaErrTablespaceMissing = HandlerErrorCode(197) + // Tablespace is not empty + HaErrTablespaceIsNotEmpty = HandlerErrorCode(198) + // Invalid Filename + HaErrWrongFileName = HandlerErrorCode(199) + // Operation is not allowed + HaErrNotAllowedCommand = HandlerErrorCode(200) + // Compute generated column value failed + HaErrComputeFailed = HandlerErrorCode(201) + // Table's row format has changed in the storage engine. Information in the data-dictionary needs to be updated. + HaErrRowFormatChanged = HandlerErrorCode(202) + // Don't wait for record lock + HaErrNoWaitLock = HandlerErrorCode(203) + // No more room in disk + HaErrDiskFullNowait = HandlerErrorCode(204) + // No session temporary space available + HaErrNoSessionTemp = HandlerErrorCode(205) + // Wrong or Invalid table name + HaErrWrongTableName = HandlerErrorCode(206) + // Path is too long for the OS + HaErrTooLongPath = HandlerErrorCode(207) + // Histogram sampling initialization failed + HaErrSamplingInitFailed = HandlerErrorCode(208) + // Too many sub-expression in search string + HaErrFtsTooManyNestedExp = HandlerErrorCode(209) +) + // Sql states for errors. // Originally found in include/mysql/sql_state.h const ( diff --git a/go/mysql/sqlerror/sql_error.go b/go/mysql/sqlerror/sql_error.go index f2a5fb46388..4600f0927cc 100644 --- a/go/mysql/sqlerror/sql_error.go +++ b/go/mysql/sqlerror/sql_error.go @@ -53,6 +53,18 @@ func NewSQLError(number ErrorCode, sqlState string, msg string) *SQLError { } } +var handlerErrExtract = regexp.MustCompile(`Got error ([0-9]*) [-] .* (from storage engine|during COMMIT|during ROLLBACK)`) + +func (se *SQLError) HaErrorCode() HandlerErrorCode { + match := handlerErrExtract.FindStringSubmatch(se.Message) + if len(match) >= 1 { + if code, err := strconv.ParseUint(match[1], 10, 16); err == nil { + return HandlerErrorCode(code) + } + } + return 0 +} + // Error implements the error interface func (se *SQLError) Error() string { var buf strings.Builder diff --git a/go/mysql/sqlerror/sql_error_test.go b/go/mysql/sqlerror/sql_error_test.go index b38cec26388..9e73138d60f 100644 --- a/go/mysql/sqlerror/sql_error_test.go +++ b/go/mysql/sqlerror/sql_error_test.go @@ -57,6 +57,7 @@ func TestNewSQLErrorFromError(t *testing.T) { var tCases = []struct { err error num ErrorCode + ha HandlerErrorCode ss string }{ { @@ -179,6 +180,24 @@ func TestNewSQLErrorFromError(t *testing.T) { num: ERDupEntry, ss: SSConstraintViolation, }, + { + err: fmt.Errorf("ERROR HY000: Got error 204 - 'No more room in disk' during COMMIT"), + num: ERUnknownError, + ss: SSUnknownSQLState, + ha: HaErrDiskFullNowait, + }, + { + err: fmt.Errorf("COMMIT failed w/ error: Got error 204 - 'No more room in disk' during COMMIT (errno 1180) (sqlstate HY000) during query: commit"), + num: ERErrorDuringCommit, + ss: SSUnknownSQLState, + ha: HaErrDiskFullNowait, + }, + { + err: fmt.Errorf("COMMIT failed w/ error: Got error 149 - 'Lock deadlock; Retry transaction' during COMMIT (errno 1180) (sqlstate HY000) during query: commit"), + num: ERErrorDuringCommit, + ss: SSUnknownSQLState, + ha: HaErrLockDeadlock, + }, } for _, tc := range tCases { @@ -187,6 +206,8 @@ func TestNewSQLErrorFromError(t *testing.T) { require.ErrorAs(t, NewSQLErrorFromError(tc.err), &err) assert.Equal(t, tc.num, err.Number()) assert.Equal(t, tc.ss, err.SQLState()) + ha := err.HaErrorCode() + assert.Equal(t, tc.ha, ha) }) } } diff --git a/go/vt/vttablet/tabletmanager/vreplication/utils.go b/go/vt/vttablet/tabletmanager/vreplication/utils.go index bb1c469cc93..67b52c56261 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/utils.go +++ b/go/vt/vttablet/tabletmanager/vreplication/utils.go @@ -232,6 +232,24 @@ func isUnrecoverableError(err error) bool { sqlerror.ERWrongValueCountOnRow: log.Errorf("Got unrecoverable error: %v", sqlErr) return true + case sqlerror.ERErrorDuringCommit: + switch sqlErr.HaErrorCode() { + case + 0, // Not really a HA error. + sqlerror.HaErrLockDeadlock, + sqlerror.HaErrLockTableFull, + sqlerror.HaErrLockWaitTimeout, + sqlerror.HaErrNotInLockPartitions, + sqlerror.HaErrQueryInterrupted, + sqlerror.HaErrRolledBack, + sqlerror.HaErrTooManyConcurrentTrxs, + sqlerror.HaErrUndoRecTooBig: + // These are recoverable errors. + return false + default: + log.Errorf("Got unrecoverable error: %v", sqlErr) + return true + } } return false } diff --git a/go/vt/vttablet/tabletmanager/vreplication/utils_test.go b/go/vt/vttablet/tabletmanager/vreplication/utils_test.go index 69a57c34341..15093e299fc 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/utils_test.go +++ b/go/vt/vttablet/tabletmanager/vreplication/utils_test.go @@ -152,6 +152,16 @@ func TestIsUnrecoverableError(t *testing.T) { err: sqlerror.NewSQLError(sqlerror.ERDataOutOfRange, "data out of range", "test"), expected: true, }, + { + name: "SQL error with HaErrDiskFullNowait error", + err: sqlerror.NewSQLError(sqlerror.ERErrorDuringCommit, "unknown", "ERROR HY000: Got error 204 - 'No more room in disk' during COMMIT"), + expected: true, + }, + { + name: "SQL error with HaErrLockDeadlock error", + err: sqlerror.NewSQLError(sqlerror.ERErrorDuringCommit, "unknown", "ERROR HY000: Got error 149 - 'Lock deadlock; Retry transaction' during COMMIT"), + expected: false, + }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { From ea600c3d3569d826710cf9e262967511152e390a Mon Sep 17 00:00:00 2001 From: Florent Poinsard <35779988+frouioui@users.noreply.github.com> Date: Tue, 19 Nov 2024 12:54:29 -0600 Subject: [PATCH 4/9] Use proper keyspace when updating the query graph of a reference DML (#17226) Signed-off-by: Florent Poinsard --- .../queries/reference/reference_test.go | 9 +++++++ go/vt/vtgate/planbuilder/operators/delete.go | 2 +- go/vt/vtgate/planbuilder/plan_test.go | 1 + .../dml_cases_with_user_as_default.json | 24 +++++++++++++++++++ 4 files changed, 35 insertions(+), 1 deletion(-) create mode 100644 go/vt/vtgate/planbuilder/testdata/dml_cases_with_user_as_default.json diff --git a/go/test/endtoend/vtgate/queries/reference/reference_test.go b/go/test/endtoend/vtgate/queries/reference/reference_test.go index 08e9cbe13b1..66d46dfaf15 100644 --- a/go/test/endtoend/vtgate/queries/reference/reference_test.go +++ b/go/test/endtoend/vtgate/queries/reference/reference_test.go @@ -171,3 +171,12 @@ func TestMultiReferenceQuery(t *testing.T) { utils.Exec(t, conn, query) } + +func TestDMLReferenceUsingShardedKS(t *testing.T) { + utils.SkipIfBinaryIsBelowVersion(t, 22, "vtgate") + conn, closer := start(t) + defer closer() + + utils.Exec(t, conn, "use sks") + utils.Exec(t, conn, "update zip_detail set zip_id = 1 where id = 1") +} diff --git a/go/vt/vtgate/planbuilder/operators/delete.go b/go/vt/vtgate/planbuilder/operators/delete.go index 4d30d9b9cc1..81e36d54315 100644 --- a/go/vt/vtgate/planbuilder/operators/delete.go +++ b/go/vt/vtgate/planbuilder/operators/delete.go @@ -328,7 +328,7 @@ func updateQueryGraphWithSource(ctx *plancontext.PlanningContext, input Operator if tbl.ID != tblID { continue } - tbl.Alias = sqlparser.NewAliasedTableExpr(sqlparser.NewTableName(vTbl.Name.String()), tbl.Alias.As.String()) + tbl.Alias = sqlparser.NewAliasedTableExpr(sqlparser.NewTableNameWithQualifier(vTbl.Name.String(), vTbl.Keyspace.Name), tbl.Alias.As.String()) tbl.Table, _ = tbl.Alias.TableName() } return op, Rewrote("change query table point to source table") diff --git a/go/vt/vtgate/planbuilder/plan_test.go b/go/vt/vtgate/planbuilder/plan_test.go index 9cf92a91ddf..acba2caf937 100644 --- a/go/vt/vtgate/planbuilder/plan_test.go +++ b/go/vt/vtgate/planbuilder/plan_test.go @@ -557,6 +557,7 @@ func (s *planTestSuite) TestWithUserDefaultKeyspaceFromFileSharded() { } s.testFile("select_cases_with_user_as_default.json", vschema, false) + s.testFile("dml_cases_with_user_as_default.json", vschema, false) } func (s *planTestSuite) TestWithSystemSchemaAsDefaultKeyspace() { diff --git a/go/vt/vtgate/planbuilder/testdata/dml_cases_with_user_as_default.json b/go/vt/vtgate/planbuilder/testdata/dml_cases_with_user_as_default.json new file mode 100644 index 00000000000..ff66967c2ce --- /dev/null +++ b/go/vt/vtgate/planbuilder/testdata/dml_cases_with_user_as_default.json @@ -0,0 +1,24 @@ +[ + { + "comment": "Update reference table from sharded keyspace to unsharded keyspace", + "query": "update ambiguous_ref_with_source set done = true where id = 1;", + "plan": { + "QueryType": "UPDATE", + "Original": "update ambiguous_ref_with_source set done = true where id = 1;", + "Instructions": { + "OperatorType": "Update", + "Variant": "Unsharded", + "Keyspace": { + "Name": "main", + "Sharded": false + }, + "TargetTabletType": "PRIMARY", + "Query": "update ambiguous_ref_with_source set done = true where id = 1", + "Table": "ambiguous_ref_with_source" + }, + "TablesUsed": [ + "main.ambiguous_ref_with_source" + ] + } + } +] \ No newline at end of file From d2815bfb23594106fdb396e3372936abc98cf490 Mon Sep 17 00:00:00 2001 From: Gabriel Parreiras Date: Tue, 19 Nov 2024 19:30:49 +0000 Subject: [PATCH 5/9] Add support for receiving `grpc_bind_adress` on `vttestserver` (#17231) Signed-off-by: Gabriel Parreiras --- go/vt/servenv/grpc_server.go | 5 ++++ go/vt/vttest/local_cluster.go | 1 + go/vt/vttest/vtprocess.go | 50 ++++++++++++++++++++++------------- 3 files changed, 37 insertions(+), 19 deletions(-) diff --git a/go/vt/servenv/grpc_server.go b/go/vt/servenv/grpc_server.go index 96fe3c25ea9..8d30ee6d253 100644 --- a/go/vt/servenv/grpc_server.go +++ b/go/vt/servenv/grpc_server.go @@ -169,6 +169,11 @@ func GRPCPort() int { return gRPCPort } +// GRPCPort returns the value of the `--grpc_bind_address` flag. +func GRPCBindAddress() string { + return gRPCBindAddress +} + // isGRPCEnabled returns true if gRPC server is set func isGRPCEnabled() bool { if gRPCPort != 0 { diff --git a/go/vt/vttest/local_cluster.go b/go/vt/vttest/local_cluster.go index 576a78bb761..fa7e40feb12 100644 --- a/go/vt/vttest/local_cluster.go +++ b/go/vt/vttest/local_cluster.go @@ -660,6 +660,7 @@ func (db *LocalCluster) JSONConfig() any { config := map[string]any{ "bind_address": db.vt.BindAddress, "port": db.vt.Port, + "grpc_bind_address": db.vt.BindAddressGprc, "socket": db.mysql.UnixSocket(), "vtcombo_mysql_port": db.Env.PortForProtocol("vtcombo_mysql_port", ""), "mysql": db.Env.PortForProtocol("mysql", ""), diff --git a/go/vt/vttest/vtprocess.go b/go/vt/vttest/vtprocess.go index 3f34994bb75..6371811a60e 100644 --- a/go/vt/vttest/vtprocess.go +++ b/go/vt/vttest/vtprocess.go @@ -44,16 +44,17 @@ type HealthChecker func(addr string) bool // It can be spawned manually or through one of the available // helper methods. type VtProcess struct { - Name string - Directory string - LogDirectory string - Binary string - ExtraArgs []string - Env []string - BindAddress string - Port int - PortGrpc int - HealthCheck HealthChecker + Name string + Directory string + LogDirectory string + Binary string + ExtraArgs []string + Env []string + BindAddress string + BindAddressGprc string + Port int + PortGrpc int + HealthCheck HealthChecker proc *exec.Cmd exit chan error @@ -139,6 +140,11 @@ func (vtp *VtProcess) WaitStart() (err error) { vtp.proc.Args = append(vtp.proc.Args, fmt.Sprintf("%d", vtp.PortGrpc)) } + if vtp.BindAddressGprc != "" { + vtp.proc.Args = append(vtp.proc.Args, "--grpc_bind_address") + vtp.proc.Args = append(vtp.proc.Args, vtp.BindAddressGprc) + } + vtp.proc.Args = append(vtp.proc.Args, vtp.ExtraArgs...) vtp.proc.Env = append(vtp.proc.Env, os.Environ()...) vtp.proc.Env = append(vtp.proc.Env, vtp.Env...) @@ -199,16 +205,22 @@ func VtcomboProcess(environment Environment, args *Config, mysql MySQLManager) ( if args.VtComboBindAddress != "" { vtcomboBindAddress = args.VtComboBindAddress } + grpcBindAddress := "127.0.0.1" + if servenv.GRPCBindAddress() != "" { + grpcBindAddress = servenv.GRPCBindAddress() + } + vt := &VtProcess{ - Name: "vtcombo", - Directory: environment.Directory(), - LogDirectory: environment.LogDirectory(), - Binary: environment.BinaryPath("vtcombo"), - BindAddress: vtcomboBindAddress, - Port: environment.PortForProtocol("vtcombo", ""), - PortGrpc: environment.PortForProtocol("vtcombo", "grpc"), - HealthCheck: environment.ProcessHealthCheck("vtcombo"), - Env: environment.EnvVars(), + Name: "vtcombo", + Directory: environment.Directory(), + LogDirectory: environment.LogDirectory(), + Binary: environment.BinaryPath("vtcombo"), + BindAddress: vtcomboBindAddress, + BindAddressGprc: grpcBindAddress, + Port: environment.PortForProtocol("vtcombo", ""), + PortGrpc: environment.PortForProtocol("vtcombo", "grpc"), + HealthCheck: environment.ProcessHealthCheck("vtcombo"), + Env: environment.EnvVars(), } user, pass := mysql.Auth() From 626b16ff12a328e8a114f431b2ab51a472afcee9 Mon Sep 17 00:00:00 2001 From: Derek Perkins Date: Tue, 19 Nov 2024 18:00:11 -0700 Subject: [PATCH 6/9] sqltypes: add ToTime conversion funcs (#17178) Signed-off-by: Derek Perkins --- go/sqltypes/value.go | 95 +++++++++++++++++ go/sqltypes/value_test.go | 151 +++++++++++++++++++++++++++ go/vt/vitessdriver/convert.go | 6 +- go/vt/vitessdriver/time.go | 71 ------------- go/vt/vitessdriver/time_test.go | 175 -------------------------------- 5 files changed, 248 insertions(+), 250 deletions(-) delete mode 100644 go/vt/vitessdriver/time_test.go diff --git a/go/sqltypes/value.go b/go/sqltypes/value.go index 438b51a13ba..7fb6fa80396 100644 --- a/go/sqltypes/value.go +++ b/go/sqltypes/value.go @@ -26,6 +26,7 @@ import ( "math/big" "strconv" "strings" + "time" "google.golang.org/protobuf/encoding/protowire" @@ -435,6 +436,100 @@ func (v Value) String() string { return fmt.Sprintf("%v(%s)", Type(v.typ), v.val) } +// ToTime returns the value as a time.Time in UTC. +// NULL values are returned as zero time. +func (v Value) ToTime() (time.Time, error) { + return v.ToTimeInLocation(time.UTC) +} + +// ToTimeInLocation returns the value as a time.Time in the provided location. +// NULL values are returned as zero time. +func (v Value) ToTimeInLocation(loc *time.Location) (time.Time, error) { + if v.Type() == Null { + return time.Time{}, nil + } + switch v.Type() { + case Datetime, Timestamp: + return datetimeToNative(v, loc) + case Date: + return dateToNative(v, loc) + default: + return time.Time{}, ErrIncompatibleTypeCast + } +} + +// ErrInvalidTime is returned when we fail to parse a datetime +// string from MySQL. This should never happen unless things are +// seriously messed up. +var ErrInvalidTime = errors.New("invalid MySQL time string") + +var isoTimeFormat = "2006-01-02 15:04:05.999999" +var isoNullTime = "0000-00-00 00:00:00.000000" +var isoTimeLength = len(isoTimeFormat) + +// parseISOTime pases a time string in MySQL's textual datetime format. +// This is very similar to ISO8601, with some differences: +// +// - There is no T separator between the date and time sections; +// a space is used instead. +// - There is never a timezone section in the string, as these datetimes +// are not timezone-aware. There isn't a Z value for UTC times for +// the same reason. +// +// Note that this function can handle both DATE (which should _always_ have +// a length of 10) and DATETIME strings (which have a variable length, 18+ +// depending on the number of decimal sub-second places). +// +// Also note that this function handles the case where MySQL returns a NULL +// time (with a string where all sections are zeroes) by returning a zeroed +// out time.Time object. NULL time strings are not considered a parsing error. +// +// See: isoTimeFormat +func parseISOTime(tstr string, loc *time.Location, minLen, maxLen int) (t time.Time, err error) { + tlen := len(tstr) + if tlen < minLen || tlen > maxLen { + err = ErrInvalidTime + return + } + + if tstr == isoNullTime[:tlen] { + // This is what MySQL would send when the date is NULL, + // so return an empty time.Time instead. + // This is not a parsing error + return + } + + if loc == nil { + loc = time.UTC + } + + // Since the time format returned from MySQL never has a Timezone + // section, ParseInLocation will initialize the time.Time struct + // with the default `loc` we're passing here. + return time.ParseInLocation(isoTimeFormat[:tlen], tstr, loc) +} + +// datetimeToNative converts a Datetime Value into a time.Time +func datetimeToNative(v Value, loc *time.Location) (time.Time, error) { + // Valid format string offsets for a DATETIME + // |DATETIME |19+ + // |------------------|------| + // "2006-01-02 15:04:05.999999" + return parseISOTime(v.ToString(), loc, 19, isoTimeLength) +} + +// dateToNative converts a Date Value into a time.Time. +// Note that there's no specific type in the Go stdlib to represent +// dates without time components, so the returned Time will have +// their hours/mins/seconds zeroed out. +func dateToNative(v Value, loc *time.Location) (time.Time, error) { + // Valid format string offsets for a DATE + // |DATE |10 + // |---------| + // "2006-01-02 00:00:00.000000" + return parseISOTime(v.ToString(), loc, 10, 10) +} + // EncodeSQL encodes the value into an SQL statement. Can be binary. func (v Value) EncodeSQL(b BinWriter) { switch { diff --git a/go/sqltypes/value_test.go b/go/sqltypes/value_test.go index fbf9be5b19b..99f8566472e 100644 --- a/go/sqltypes/value_test.go +++ b/go/sqltypes/value_test.go @@ -18,8 +18,10 @@ package sqltypes import ( "math" + "reflect" "strings" "testing" + "time" "github.com/stretchr/testify/assert" @@ -611,6 +613,155 @@ func TestToUint32(t *testing.T) { } } +var randomLocation = time.FixedZone("Nowhere", 3*60*60) + +func DatetimeValue(str string) Value { + return TestValue(Datetime, str) +} + +func DateValue(str string) Value { + return TestValue(Date, str) +} + +func TestDatetimeToNative(t *testing.T) { + tcases := []struct { + val Value + loc *time.Location + out time.Time + err bool + }{{ + val: DatetimeValue("1899-08-24 17:20:00"), + out: time.Date(1899, 8, 24, 17, 20, 0, 0, time.UTC), + }, { + val: DatetimeValue("1952-03-11 01:02:03"), + loc: time.Local, + out: time.Date(1952, 3, 11, 1, 2, 3, 0, time.Local), + }, { + val: DatetimeValue("1952-03-11 01:02:03"), + loc: randomLocation, + out: time.Date(1952, 3, 11, 1, 2, 3, 0, randomLocation), + }, { + val: DatetimeValue("1952-03-11 01:02:03"), + loc: time.UTC, + out: time.Date(1952, 3, 11, 1, 2, 3, 0, time.UTC), + }, { + val: DatetimeValue("1899-08-24 17:20:00.000000"), + out: time.Date(1899, 8, 24, 17, 20, 0, 0, time.UTC), + }, { + val: DatetimeValue("1899-08-24 17:20:00.000001"), + out: time.Date(1899, 8, 24, 17, 20, 0, int(1*time.Microsecond), time.UTC), + }, { + val: DatetimeValue("1899-08-24 17:20:00.123456"), + out: time.Date(1899, 8, 24, 17, 20, 0, int(123456*time.Microsecond), time.UTC), + }, { + val: DatetimeValue("1899-08-24 17:20:00.222"), + out: time.Date(1899, 8, 24, 17, 20, 0, int(222*time.Millisecond), time.UTC), + }, { + val: DatetimeValue("1899-08-24 17:20:00.1234567"), + err: true, + }, { + val: DatetimeValue("1899-08-24 17:20:00.1"), + out: time.Date(1899, 8, 24, 17, 20, 0, int(100*time.Millisecond), time.UTC), + }, { + val: DatetimeValue("0000-00-00 00:00:00"), + out: time.Time{}, + }, { + val: DatetimeValue("0000-00-00 00:00:00.0"), + out: time.Time{}, + }, { + val: DatetimeValue("0000-00-00 00:00:00.000"), + out: time.Time{}, + }, { + val: DatetimeValue("0000-00-00 00:00:00.000000"), + out: time.Time{}, + }, { + val: DatetimeValue("0000-00-00 00:00:00.0000000"), + err: true, + }, { + val: DatetimeValue("1899-08-24T17:20:00.000000"), + err: true, + }, { + val: DatetimeValue("1899-02-31 17:20:00.000000"), + err: true, + }, { + val: DatetimeValue("1899-08-24 17:20:00."), + out: time.Date(1899, 8, 24, 17, 20, 0, 0, time.UTC), + }, { + val: DatetimeValue("0000-00-00 00:00:00.000001"), + err: true, + }, { + val: DatetimeValue("1899-08-24 17:20:00 +02:00"), + err: true, + }, { + val: DatetimeValue("1899-08-24"), + err: true, + }, { + val: DatetimeValue("This is not a valid timestamp"), + err: true, + }} + + for _, tcase := range tcases { + got, err := datetimeToNative(tcase.val, tcase.loc) + if tcase.err && err == nil { + t.Errorf("datetimeToNative(%v, %#v) succeeded; expected error", tcase.val, tcase.loc) + } + if !tcase.err && err != nil { + t.Errorf("datetimeToNative(%v, %#v) failed: %v", tcase.val, tcase.loc, err) + } + if !reflect.DeepEqual(got, tcase.out) { + t.Errorf("datetimeToNative(%v, %#v): %v, want %v", tcase.val, tcase.loc, got, tcase.out) + } + } +} + +func TestDateToNative(t *testing.T) { + tcases := []struct { + val Value + loc *time.Location + out time.Time + err bool + }{{ + val: DateValue("1899-08-24"), + out: time.Date(1899, 8, 24, 0, 0, 0, 0, time.UTC), + }, { + val: DateValue("1952-03-11"), + loc: time.Local, + out: time.Date(1952, 3, 11, 0, 0, 0, 0, time.Local), + }, { + val: DateValue("1952-03-11"), + loc: randomLocation, + out: time.Date(1952, 3, 11, 0, 0, 0, 0, randomLocation), + }, { + val: DateValue("0000-00-00"), + out: time.Time{}, + }, { + val: DateValue("1899-02-31"), + err: true, + }, { + val: DateValue("1899-08-24 17:20:00"), + err: true, + }, { + val: DateValue("0000-00-00 00:00:00"), + err: true, + }, { + val: DateValue("This is not a valid timestamp"), + err: true, + }} + + for _, tcase := range tcases { + got, err := dateToNative(tcase.val, tcase.loc) + if tcase.err && err == nil { + t.Errorf("dateToNative(%v, %#v) succeeded; expected error", tcase.val, tcase.loc) + } + if !tcase.err && err != nil { + t.Errorf("dateToNative(%v, %#v) failed: %v", tcase.val, tcase.loc, err) + } + if !reflect.DeepEqual(got, tcase.out) { + t.Errorf("dateToNative(%v, %#v): %v, want %v", tcase.val, tcase.loc, got, tcase.out) + } + } +} + func TestEncodeSQLStringBuilder(t *testing.T) { testcases := []struct { in Value diff --git a/go/vt/vitessdriver/convert.go b/go/vt/vitessdriver/convert.go index 7ba95db4147..aa8bcedc7ee 100644 --- a/go/vt/vitessdriver/convert.go +++ b/go/vt/vitessdriver/convert.go @@ -43,10 +43,8 @@ func (cv *converter) ToNative(v sqltypes.Value) (any, error) { return v.ToUint64() case v.IsFloat(): return v.ToFloat64() - case v.Type() == sqltypes.Datetime, v.Type() == sqltypes.Timestamp: - return datetimeToNative(v, cv.location) - case v.Type() == sqltypes.Date: - return dateToNative(v, cv.location) + case v.Type() == sqltypes.Datetime, v.Type() == sqltypes.Timestamp, v.Type() == sqltypes.Date: + return v.ToTimeInLocation(cv.location) case v.IsQuoted() || v.Type() == sqltypes.Bit || v.Type() == sqltypes.Decimal: out, err = v.ToBytes() case v.Type() == sqltypes.Expression: diff --git a/go/vt/vitessdriver/time.go b/go/vt/vitessdriver/time.go index 70ec2d679ae..c6526197d9d 100644 --- a/go/vt/vitessdriver/time.go +++ b/go/vt/vitessdriver/time.go @@ -17,83 +17,12 @@ limitations under the License. package vitessdriver import ( - "errors" "time" "vitess.io/vitess/go/sqltypes" ) -// ErrInvalidTime is returned when we fail to parse a datetime -// string from MySQL. This should never happen unless things are -// seriously messed up. -var ErrInvalidTime = errors.New("invalid MySQL time string") - var isoTimeFormat = "2006-01-02 15:04:05.999999" -var isoNullTime = "0000-00-00 00:00:00.000000" -var isoTimeLength = len(isoTimeFormat) - -// parseISOTime pases a time string in MySQL's textual datetime format. -// This is very similar to ISO8601, with some differences: -// -// - There is no T separator between the date and time sections; -// a space is used instead. -// - There is never a timezone section in the string, as these datetimes -// are not timezone-aware. There isn't a Z value for UTC times for -// the same reason. -// -// Note that this function can handle both DATE (which should _always_ have -// a length of 10) and DATETIME strings (which have a variable length, 18+ -// depending on the number of decimal sub-second places). -// -// Also note that this function handles the case where MySQL returns a NULL -// time (with a string where all sections are zeroes) by returning a zeroed -// out time.Time object. NULL time strings are not considered a parsing error. -// -// See: isoTimeFormat -func parseISOTime(tstr string, loc *time.Location, minLen, maxLen int) (t time.Time, err error) { - tlen := len(tstr) - if tlen < minLen || tlen > maxLen { - err = ErrInvalidTime - return - } - - if tstr == isoNullTime[:tlen] { - // This is what MySQL would send when the date is NULL, - // so return an empty time.Time instead. - // This is not a parsing error - return - } - - if loc == nil { - loc = time.UTC - } - - // Since the time format returned from MySQL never has a Timezone - // section, ParseInLocation will initialize the time.Time struct - // with the default `loc` we're passing here. - return time.ParseInLocation(isoTimeFormat[:tlen], tstr, loc) -} - -// datetimeToNative converts a Datetime Value into a time.Time -func datetimeToNative(v sqltypes.Value, loc *time.Location) (time.Time, error) { - // Valid format string offsets for a DATETIME - // |DATETIME |19+ - // |------------------|------| - // "2006-01-02 15:04:05.999999" - return parseISOTime(v.ToString(), loc, 19, isoTimeLength) -} - -// dateToNative converts a Date Value into a time.Time. -// Note that there's no specific type in the Go stdlib to represent -// dates without time components, so the returned Time will have -// their hours/mins/seconds zeroed out. -func dateToNative(v sqltypes.Value, loc *time.Location) (time.Time, error) { - // Valid format string offsets for a DATE - // |DATE |10 - // |---------| - // "2006-01-02 00:00:00.000000" - return parseISOTime(v.ToString(), loc, 10, 10) -} // NewDatetime builds a Datetime Value func NewDatetime(t time.Time, defaultLoc *time.Location) sqltypes.Value { diff --git a/go/vt/vitessdriver/time_test.go b/go/vt/vitessdriver/time_test.go deleted file mode 100644 index 949d8f43354..00000000000 --- a/go/vt/vitessdriver/time_test.go +++ /dev/null @@ -1,175 +0,0 @@ -/* -Copyright 2019 The Vitess Authors. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. -*/ - -package vitessdriver - -import ( - "reflect" - "testing" - "time" - - "vitess.io/vitess/go/sqltypes" -) - -var randomLocation = time.FixedZone("Nowhere", 3*60*60) - -func DatetimeValue(str string) sqltypes.Value { - return sqltypes.TestValue(sqltypes.Datetime, str) -} - -func DateValue(str string) sqltypes.Value { - return sqltypes.TestValue(sqltypes.Date, str) -} - -func TestDatetimeToNative(t *testing.T) { - - tcases := []struct { - val sqltypes.Value - loc *time.Location - out time.Time - err bool - }{{ - val: DatetimeValue("1899-08-24 17:20:00"), - out: time.Date(1899, 8, 24, 17, 20, 0, 0, time.UTC), - }, { - val: DatetimeValue("1952-03-11 01:02:03"), - loc: time.Local, - out: time.Date(1952, 3, 11, 1, 2, 3, 0, time.Local), - }, { - val: DatetimeValue("1952-03-11 01:02:03"), - loc: randomLocation, - out: time.Date(1952, 3, 11, 1, 2, 3, 0, randomLocation), - }, { - val: DatetimeValue("1952-03-11 01:02:03"), - loc: time.UTC, - out: time.Date(1952, 3, 11, 1, 2, 3, 0, time.UTC), - }, { - val: DatetimeValue("1899-08-24 17:20:00.000000"), - out: time.Date(1899, 8, 24, 17, 20, 0, 0, time.UTC), - }, { - val: DatetimeValue("1899-08-24 17:20:00.000001"), - out: time.Date(1899, 8, 24, 17, 20, 0, int(1*time.Microsecond), time.UTC), - }, { - val: DatetimeValue("1899-08-24 17:20:00.123456"), - out: time.Date(1899, 8, 24, 17, 20, 0, int(123456*time.Microsecond), time.UTC), - }, { - val: DatetimeValue("1899-08-24 17:20:00.222"), - out: time.Date(1899, 8, 24, 17, 20, 0, int(222*time.Millisecond), time.UTC), - }, { - val: DatetimeValue("1899-08-24 17:20:00.1234567"), - err: true, - }, { - val: DatetimeValue("1899-08-24 17:20:00.1"), - out: time.Date(1899, 8, 24, 17, 20, 0, int(100*time.Millisecond), time.UTC), - }, { - val: DatetimeValue("0000-00-00 00:00:00"), - out: time.Time{}, - }, { - val: DatetimeValue("0000-00-00 00:00:00.0"), - out: time.Time{}, - }, { - val: DatetimeValue("0000-00-00 00:00:00.000"), - out: time.Time{}, - }, { - val: DatetimeValue("0000-00-00 00:00:00.000000"), - out: time.Time{}, - }, { - val: DatetimeValue("0000-00-00 00:00:00.0000000"), - err: true, - }, { - val: DatetimeValue("1899-08-24T17:20:00.000000"), - err: true, - }, { - val: DatetimeValue("1899-02-31 17:20:00.000000"), - err: true, - }, { - val: DatetimeValue("1899-08-24 17:20:00."), - out: time.Date(1899, 8, 24, 17, 20, 0, 0, time.UTC), - }, { - val: DatetimeValue("0000-00-00 00:00:00.000001"), - err: true, - }, { - val: DatetimeValue("1899-08-24 17:20:00 +02:00"), - err: true, - }, { - val: DatetimeValue("1899-08-24"), - err: true, - }, { - val: DatetimeValue("This is not a valid timestamp"), - err: true, - }} - - for _, tcase := range tcases { - got, err := datetimeToNative(tcase.val, tcase.loc) - if tcase.err && err == nil { - t.Errorf("datetimeToNative(%v, %#v) succeeded; expected error", tcase.val, tcase.loc) - } - if !tcase.err && err != nil { - t.Errorf("datetimeToNative(%v, %#v) failed: %v", tcase.val, tcase.loc, err) - } - if !reflect.DeepEqual(got, tcase.out) { - t.Errorf("datetimeToNative(%v, %#v): %v, want %v", tcase.val, tcase.loc, got, tcase.out) - } - } -} - -func TestDateToNative(t *testing.T) { - tcases := []struct { - val sqltypes.Value - loc *time.Location - out time.Time - err bool - }{{ - val: DateValue("1899-08-24"), - out: time.Date(1899, 8, 24, 0, 0, 0, 0, time.UTC), - }, { - val: DateValue("1952-03-11"), - loc: time.Local, - out: time.Date(1952, 3, 11, 0, 0, 0, 0, time.Local), - }, { - val: DateValue("1952-03-11"), - loc: randomLocation, - out: time.Date(1952, 3, 11, 0, 0, 0, 0, randomLocation), - }, { - val: DateValue("0000-00-00"), - out: time.Time{}, - }, { - val: DateValue("1899-02-31"), - err: true, - }, { - val: DateValue("1899-08-24 17:20:00"), - err: true, - }, { - val: DateValue("0000-00-00 00:00:00"), - err: true, - }, { - val: DateValue("This is not a valid timestamp"), - err: true, - }} - - for _, tcase := range tcases { - got, err := dateToNative(tcase.val, tcase.loc) - if tcase.err && err == nil { - t.Errorf("dateToNative(%v, %#v) succeeded; expected error", tcase.val, tcase.loc) - } - if !tcase.err && err != nil { - t.Errorf("dateToNative(%v, %#v) failed: %v", tcase.val, tcase.loc, err) - } - if !reflect.DeepEqual(got, tcase.out) { - t.Errorf("dateToNative(%v, %#v): %v, want %v", tcase.val, tcase.loc, got, tcase.out) - } - } -} From 2c6e053e5078197ad20742b79215239d156fb46e Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Wed, 20 Nov 2024 08:39:26 +0200 Subject: [PATCH 7/9] VReplication: recover from closed connection (#17249) Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> --- go/vt/binlog/binlogplayer/dbclient.go | 5 +++++ go/vt/binlog/binlogplayer/fake_dbclient.go | 4 ++++ go/vt/binlog/binlogplayer/mock_dbclient.go | 4 ++++ .../vttablet/tabletmanager/vdiff/framework_test.go | 4 ++++ .../tabletmanager/vreplication/framework_test.go | 4 ++++ .../tabletmanager/vreplication/vreplicator.go | 13 ++++++++++--- go/vt/wrangler/fake_dbclient_test.go | 4 ++++ 7 files changed, 35 insertions(+), 3 deletions(-) diff --git a/go/vt/binlog/binlogplayer/dbclient.go b/go/vt/binlog/binlogplayer/dbclient.go index c3463b4cc2c..4cbfd962528 100644 --- a/go/vt/binlog/binlogplayer/dbclient.go +++ b/go/vt/binlog/binlogplayer/dbclient.go @@ -40,6 +40,7 @@ type DBClient interface { Commit() error Rollback() error Close() + IsClosed() bool ExecuteFetch(query string, maxrows int) (qr *sqltypes.Result, err error) ExecuteFetchMulti(query string, maxrows int) (qrs []*sqltypes.Result, err error) SupportsCapability(capability capabilities.FlavorCapability) (bool, error) @@ -125,6 +126,10 @@ func (dc *dbClientImpl) Close() { dc.dbConn.Close() } +func (dc *dbClientImpl) IsClosed() bool { + return dc.dbConn.IsClosed() +} + func (dc *dbClientImpl) SupportsCapability(capability capabilities.FlavorCapability) (bool, error) { return dc.dbConn.SupportsCapability(capability) } diff --git a/go/vt/binlog/binlogplayer/fake_dbclient.go b/go/vt/binlog/binlogplayer/fake_dbclient.go index 234dfd528e0..69bbd06f7c6 100644 --- a/go/vt/binlog/binlogplayer/fake_dbclient.go +++ b/go/vt/binlog/binlogplayer/fake_dbclient.go @@ -56,6 +56,10 @@ func (dc *fakeDBClient) Rollback() error { func (dc *fakeDBClient) Close() { } +func (dc *fakeDBClient) IsClosed() bool { + return false +} + func (dc *fakeDBClient) ExecuteFetch(query string, maxrows int) (qr *sqltypes.Result, err error) { query = strings.ToLower(query) switch { diff --git a/go/vt/binlog/binlogplayer/mock_dbclient.go b/go/vt/binlog/binlogplayer/mock_dbclient.go index f0a811a30cf..12005a16c2e 100644 --- a/go/vt/binlog/binlogplayer/mock_dbclient.go +++ b/go/vt/binlog/binlogplayer/mock_dbclient.go @@ -181,6 +181,10 @@ func (dc *MockDBClient) Rollback() error { func (dc *MockDBClient) Close() { } +func (dc *MockDBClient) IsClosed() bool { + return false +} + // ExecuteFetch is part of the DBClient interface func (dc *MockDBClient) ExecuteFetch(query string, maxrows int) (qr *sqltypes.Result, err error) { // Serialize ExecuteFetch to enforce a strict order on shared dbClients. diff --git a/go/vt/vttablet/tabletmanager/vdiff/framework_test.go b/go/vt/vttablet/tabletmanager/vdiff/framework_test.go index 33a0da8e23f..7d4cdb78c20 100644 --- a/go/vt/vttablet/tabletmanager/vdiff/framework_test.go +++ b/go/vt/vttablet/tabletmanager/vdiff/framework_test.go @@ -396,6 +396,10 @@ func (dbc *realDBClient) Close() { dbc.conn.Close() } +func (dbc *realDBClient) IsClosed() bool { + return dbc.conn.IsClosed() +} + func (dbc *realDBClient) ExecuteFetch(query string, maxrows int) (*sqltypes.Result, error) { // Use Clone() because the contents of memory region referenced by // string can change when clients (e.g. vcopier) use unsafe string methods. diff --git a/go/vt/vttablet/tabletmanager/vreplication/framework_test.go b/go/vt/vttablet/tabletmanager/vreplication/framework_test.go index 12d20e3a867..fe8b62d3cef 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/framework_test.go +++ b/go/vt/vttablet/tabletmanager/vreplication/framework_test.go @@ -479,6 +479,10 @@ func (dbc *realDBClient) Close() { dbc.conn.Close() } +func (dbc *realDBClient) IsClosed() bool { + return dbc.conn.IsClosed() +} + func (dbc *realDBClient) ExecuteFetch(query string, maxrows int) (*sqltypes.Result, error) { // Use Clone() because the contents of memory region referenced by // string can change when clients (e.g. vcopier) use unsafe string methods. diff --git a/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go b/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go index 0c5c0b5b334..9ec274ab0ea 100644 --- a/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go +++ b/go/vt/vttablet/tabletmanager/vreplication/vreplicator.go @@ -186,11 +186,18 @@ func newVReplicator(id int32, source *binlogdatapb.BinlogSource, sourceVStreamer // code. func (vr *vreplicator) Replicate(ctx context.Context) error { err := vr.replicate(ctx) - if err != nil { - if err := vr.setMessage(err.Error()); err != nil { - binlogplayer.LogError("Failed to set error state", err) + if err == nil { + return nil + } + if vr.dbClient.IsClosed() { + // Connection was possible terminated by the server. We should renew it. + if cerr := vr.dbClient.Connect(); cerr != nil { + return vterrors.Wrapf(err, "failed to reconnect to the database: %v", cerr) } } + if err := vr.setMessage(err.Error()); err != nil { + binlogplayer.LogError("Failed to set error state", err) + } return err } diff --git a/go/vt/wrangler/fake_dbclient_test.go b/go/vt/wrangler/fake_dbclient_test.go index 14ef0913383..02ee79210d7 100644 --- a/go/vt/wrangler/fake_dbclient_test.go +++ b/go/vt/wrangler/fake_dbclient_test.go @@ -153,6 +153,10 @@ func (dc *fakeDBClient) Rollback() error { func (dc *fakeDBClient) Close() { } +func (dc *fakeDBClient) IsClosed() bool { + return false +} + // ExecuteFetch is part of the DBClient interface func (dc *fakeDBClient) ExecuteFetch(query string, maxrows int) (*sqltypes.Result, error) { dc.mu.Lock() From fb79106214a55e9ce0031fe50eaec0f83e46f0eb Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Wed, 20 Nov 2024 09:11:57 +0200 Subject: [PATCH 8/9] Tablet throttler: read and use MySQL host metrics (#16904) Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> --- go/osutil/loadavg.go | 33 ++++ go/osutil/loadavg_darwin.go | 40 +++++ go/osutil/loadavg_linux.go | 33 ++++ go/osutil/loadavg_other.go | 25 +++ go/osutil/loadavg_test.go | 77 +++++++++ .../throttler_topo/throttler_test.go | 64 +++++-- go/test/endtoend/throttler/util.go | 8 +- go/textutil/strings.go | 13 ++ go/textutil/strings_test.go | 58 +++++++ go/vt/mysqlctl/mysqld.go | 14 +- .../throttle/base/metric_cache.go | 5 +- .../tabletserver/throttle/base/metric_name.go | 12 +- .../throttle/base/metric_name_test.go | 24 +++ .../tabletserver/throttle/base/self_metric.go | 11 +- .../throttle/base/self_metric_custom_query.go | 6 +- .../throttle/base/self_metric_default.go | 4 +- .../throttle/base/self_metric_lag.go | 5 +- .../throttle/base/self_metric_loadavg.go | 49 +++--- .../throttle/base/self_metric_mysqld.go | 156 ++++++++++++++++++ .../throttle/base/self_metric_mysqld_test.go | 72 ++++++++ .../base/self_metric_threads_running.go | 6 +- .../base/throttler_metrics_publisher.go | 4 +- go/vt/vttablet/tabletserver/throttle/check.go | 8 +- .../tabletserver/throttle/throttler.go | 52 +++--- .../tabletserver/throttle/throttler_test.go | 74 +++++++-- 25 files changed, 735 insertions(+), 118 deletions(-) create mode 100644 go/osutil/loadavg.go create mode 100644 go/osutil/loadavg_darwin.go create mode 100644 go/osutil/loadavg_linux.go create mode 100644 go/osutil/loadavg_other.go create mode 100644 go/osutil/loadavg_test.go create mode 100644 go/vt/vttablet/tabletserver/throttle/base/self_metric_mysqld.go create mode 100644 go/vt/vttablet/tabletserver/throttle/base/self_metric_mysqld_test.go diff --git a/go/osutil/loadavg.go b/go/osutil/loadavg.go new file mode 100644 index 00000000000..0c71f9e18b1 --- /dev/null +++ b/go/osutil/loadavg.go @@ -0,0 +1,33 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package osutil + +import ( + "fmt" + "strconv" + "strings" +) + +// parseLoadAvg parses the load average from the content of /proc/loadavg or sysctl output. +// Input such as "1.00 0.99 0.98 1/1 1", "2.83 3.01 3.36" +func parseLoadAvg(content string) (float64, error) { + fields := strings.Fields(content) + if len(fields) == 0 { + return 0, fmt.Errorf("unexpected loadavg content: %s", content) + } + return strconv.ParseFloat(fields[0], 64) +} diff --git a/go/osutil/loadavg_darwin.go b/go/osutil/loadavg_darwin.go new file mode 100644 index 00000000000..f7b5b6e492a --- /dev/null +++ b/go/osutil/loadavg_darwin.go @@ -0,0 +1,40 @@ +//go:build darwin + +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package osutil + +import ( + "fmt" + "os/exec" +) + +// LoadAvg returns the past 1 minute system load average. This works on linux and darwin systems. +// On other systems, it returns 0 with no error. +func LoadAvg() (float64, error) { + cmd := exec.Command("sysctl", "-n", "vm.loadavg") + // Sample output: `{ 2.83 3.01 3.36 }` + output, err := cmd.CombinedOutput() + if err != nil { + return 0, err + } + if len(output) < 1 { + return 0, fmt.Errorf("unexpected sysctl output: %q", output) + } + output = output[1:] // Remove the leading `{ ` + return parseLoadAvg(string(output)) +} diff --git a/go/osutil/loadavg_linux.go b/go/osutil/loadavg_linux.go new file mode 100644 index 00000000000..7663bf60ab7 --- /dev/null +++ b/go/osutil/loadavg_linux.go @@ -0,0 +1,33 @@ +//go:build linux + +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package osutil + +import ( + "os" +) + +// LoadAvg returns the past 1 minute system load average. This works on linux and darwin systems. +// On other systems, it returns 0 with no error. +func LoadAvg() (float64, error) { + content, err := os.ReadFile("/proc/loadavg") + if err != nil { + return 0, err + } + return parseLoadAvg(string(content)) +} diff --git a/go/osutil/loadavg_other.go b/go/osutil/loadavg_other.go new file mode 100644 index 00000000000..a516cb46a66 --- /dev/null +++ b/go/osutil/loadavg_other.go @@ -0,0 +1,25 @@ +//go:build !linux && !darwin + +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package osutil + +// LoadAvg returns the past 1 minute system load average. This works on linux and darwin systems. +// On other systems, it returns 0 with no error. +func LoadAvg() (float64, error) { + return 0, nil +} diff --git a/go/osutil/loadavg_test.go b/go/osutil/loadavg_test.go new file mode 100644 index 00000000000..5f3831648c6 --- /dev/null +++ b/go/osutil/loadavg_test.go @@ -0,0 +1,77 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package osutil + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestLoadAvgValue(t *testing.T) { + tcases := []struct { + input string + loadavg float64 + isError bool + }{ + { + input: "", + isError: true, + }, + { + input: "{}", + isError: true, + }, + { + input: "{ x y z }", + isError: true, + }, + { + input: "1", + loadavg: 1.0, + }, + { + input: "0.00 0.00 0.00 1/1 1", + loadavg: 0.0, + }, + { + input: "2.72 2.89 3.17", + loadavg: 2.72, + }, + { + input: " 2.72 2.89 3.17", + loadavg: 2.72, + }, + } + for _, tcase := range tcases { + t.Run(tcase.input, func(t *testing.T) { + loadavg, err := parseLoadAvg(tcase.input) + if tcase.isError { + assert.Error(t, err) + } else { + assert.NoError(t, err) + assert.Equal(t, tcase.loadavg, loadavg) + } + }) + } +} + +func TestLoadAvg(t *testing.T) { + loadavg, err := LoadAvg() + assert.NoError(t, err) + assert.GreaterOrEqual(t, loadavg, 0.0) +} diff --git a/go/test/endtoend/tabletmanager/throttler_topo/throttler_test.go b/go/test/endtoend/tabletmanager/throttler_topo/throttler_test.go index 08cea643940..f96069c81b8 100644 --- a/go/test/endtoend/tabletmanager/throttler_topo/throttler_test.go +++ b/go/test/endtoend/tabletmanager/throttler_topo/throttler_test.go @@ -215,7 +215,7 @@ func warmUpHeartbeat(t *testing.T) tabletmanagerdatapb.CheckThrottlerResponseCod } // waitForThrottleCheckStatus waits for the tablet to return the provided HTTP code in a throttle check -func waitForThrottleCheckStatus(t *testing.T, tablet *cluster.Vttablet, wantCode tabletmanagerdatapb.CheckThrottlerResponseCode) bool { +func waitForThrottleCheckStatus(t *testing.T, tablet *cluster.Vttablet, wantCode tabletmanagerdatapb.CheckThrottlerResponseCode) (*tabletmanagerdatapb.CheckThrottlerResponse, bool) { _ = warmUpHeartbeat(t) ctx, cancel := context.WithTimeout(context.Background(), onDemandHeartbeatDuration*4) defer cancel() @@ -229,11 +229,11 @@ func waitForThrottleCheckStatus(t *testing.T, tablet *cluster.Vttablet, wantCode if wantCode == resp.Check.ResponseCode { // Wait for any cached check values to be cleared and the new // status value to be in effect everywhere before returning. - return true + return resp.Check, true } select { case <-ctx.Done(): - return assert.EqualValues(t, wantCode, resp.Check.StatusCode, "response: %+v", resp) + return resp.Check, false case <-ticker.C: } } @@ -779,16 +779,16 @@ func TestUpdateAppCheckedMetrics(t *testing.T) { } waitForThrottleCheckStatus(t, primaryTablet, tabletmanagerdatapb.CheckThrottlerResponseCode_THRESHOLD_EXCEEDED) }) - t.Run("assigning 'loadavg' metrics to 'test' app", func(t *testing.T) { + t.Run("assigning 'threads_running' metrics to 'test' app", func(t *testing.T) { { - req := &vtctldatapb.UpdateThrottlerConfigRequest{MetricName: "loadavg", Threshold: 7777} + req := &vtctldatapb.UpdateThrottlerConfigRequest{MetricName: base.ThreadsRunningMetricName.String(), Threshold: 7777} _, err := throttler.UpdateThrottlerTopoConfig(clusterInstance, req, nil, nil) assert.NoError(t, err) } { req := &vtctldatapb.UpdateThrottlerConfigRequest{} appCheckedMetrics := map[string]*topodatapb.ThrottlerConfig_MetricNames{ - testAppName.String(): {Names: []string{"loadavg"}}, + testAppName.String(): {Names: []string{base.ThreadsRunningMetricName.String()}}, } _, err := throttler.UpdateThrottlerTopoConfig(clusterInstance, req, nil, appCheckedMetrics) assert.NoError(t, err) @@ -802,18 +802,18 @@ func TestUpdateAppCheckedMetrics(t *testing.T) { for _, tablet := range []cluster.Vttablet{*primaryTablet, *replicaTablet} { throttler.WaitForThrottlerStatusEnabled(t, &clusterInstance.VtctldClientProcess, &tablet, true, &throttler.Config{Query: throttler.DefaultQuery, Threshold: unreasonablyLowThreshold.Seconds()}, throttlerEnabledTimeout) } - t.Run("validating OK response from throttler since it's checking loadavg", func(t *testing.T) { - if !waitForThrottleCheckStatus(t, primaryTablet, tabletmanagerdatapb.CheckThrottlerResponseCode_OK) { + t.Run("validating OK response from throttler since it's checking threads_running", func(t *testing.T) { + if _, ok := waitForThrottleCheckStatus(t, primaryTablet, tabletmanagerdatapb.CheckThrottlerResponseCode_OK); !ok { t.Logf("throttler primary status: %+v", throttleStatus(t, primaryTablet)) t.Logf("throttler replica status: %+v", throttleStatus(t, replicaTablet)) } }) }) - t.Run("assigning 'loadavg,lag' metrics to 'test' app", func(t *testing.T) { + t.Run("assigning 'threads_running,lag' metrics to 'test' app", func(t *testing.T) { { req := &vtctldatapb.UpdateThrottlerConfigRequest{} appCheckedMetrics := map[string]*topodatapb.ThrottlerConfig_MetricNames{ - testAppName.String(): {Names: []string{"loadavg,lag"}}, + testAppName.String(): {Names: []string{base.ThreadsRunningMetricName.String(), base.LagMetricName.String()}}, } _, err := throttler.UpdateThrottlerTopoConfig(clusterInstance, req, nil, appCheckedMetrics) assert.NoError(t, err) @@ -831,9 +831,51 @@ func TestUpdateAppCheckedMetrics(t *testing.T) { waitForThrottleCheckStatus(t, primaryTablet, tabletmanagerdatapb.CheckThrottlerResponseCode_THRESHOLD_EXCEEDED) }) }) + t.Run("assigning 'mysqld-loadavg,mysqld-datadir-used-ratio' metrics to 'test' app", func(t *testing.T) { + { + req := &vtctldatapb.UpdateThrottlerConfigRequest{MetricName: base.MysqldDatadirUsedRatioMetricName.String(), Threshold: 0.9999} + _, err := throttler.UpdateThrottlerTopoConfig(clusterInstance, req, nil, nil) + assert.NoError(t, err) + } + { + req := &vtctldatapb.UpdateThrottlerConfigRequest{MetricName: base.MysqldLoadAvgMetricName.String(), Threshold: 5555} + _, err := throttler.UpdateThrottlerTopoConfig(clusterInstance, req, nil, nil) + assert.NoError(t, err) + } + { + req := &vtctldatapb.UpdateThrottlerConfigRequest{} + appCheckedMetrics := map[string]*topodatapb.ThrottlerConfig_MetricNames{ + testAppName.String(): {Names: []string{base.MysqldDatadirUsedRatioMetricName.String(), base.MysqldLoadAvgMetricName.String()}}, + } + _, err := throttler.UpdateThrottlerTopoConfig(clusterInstance, req, nil, appCheckedMetrics) + assert.NoError(t, err) + } + { + req := &vtctldatapb.UpdateThrottlerConfigRequest{Threshold: extremelyHighThreshold.Seconds()} + _, err := throttler.UpdateThrottlerTopoConfig(clusterInstance, req, nil, nil) + assert.NoError(t, err) + } + // Wait for the throttler to be enabled everywhere with new config. + for _, tablet := range []cluster.Vttablet{*primaryTablet, *replicaTablet} { + throttler.WaitForThrottlerStatusEnabled(t, &clusterInstance.VtctldClientProcess, &tablet, true, &throttler.Config{Query: throttler.DefaultQuery, Threshold: extremelyHighThreshold.Seconds()}, throttlerEnabledTimeout) + } + t.Run("validating OK response from throttler since it's checking mysqld-loadavg,mysqld-datadir-used-ratio", func(t *testing.T) { + resp, ok := waitForThrottleCheckStatus(t, primaryTablet, tabletmanagerdatapb.CheckThrottlerResponseCode_OK) + if !ok { + t.Logf("response: %+v", resp) + t.Logf("throttler primary status: %+v", throttleStatus(t, primaryTablet)) + t.Logf("throttler replica status: %+v", throttleStatus(t, replicaTablet)) + } + require.Contains(t, resp.Metrics, base.MysqldDatadirUsedRatioMetricName.String()) + require.Contains(t, resp.Metrics, base.MysqldLoadAvgMetricName.String()) + assert.NotContains(t, resp.Metrics, base.ThreadsRunningMetricName.String()) + + assert.NotZero(t, resp.Metrics[base.MysqldDatadirUsedRatioMetricName.String()].Value) + }) + }) t.Run("removing assignment from 'test' app and restoring defaults", func(t *testing.T) { { - req := &vtctldatapb.UpdateThrottlerConfigRequest{MetricName: "loadavg", Threshold: 0} + req := &vtctldatapb.UpdateThrottlerConfigRequest{MetricName: base.ThreadsRunningMetricName.String(), Threshold: 0} _, err := throttler.UpdateThrottlerTopoConfig(clusterInstance, req, nil, nil) assert.NoError(t, err) } diff --git a/go/test/endtoend/throttler/util.go b/go/test/endtoend/throttler/util.go index fccad19c324..a426355e01c 100644 --- a/go/test/endtoend/throttler/util.go +++ b/go/test/endtoend/throttler/util.go @@ -529,7 +529,7 @@ func WaitForValidData(t *testing.T, tablet *cluster.Vttablet, timeout time.Durat selfCheckURL := fmt.Sprintf("http://localhost:%d/throttler/check-self", tablet.HTTPPort) ctx, cancel := context.WithTimeout(context.Background(), timeout) defer cancel() - ticker := time.NewTicker(500 * time.Millisecond) + ticker := time.NewTicker(time.Second) defer ticker.Stop() for { @@ -548,8 +548,10 @@ func WaitForValidData(t *testing.T, tablet *cluster.Vttablet, timeout time.Durat } select { case <-ctx.Done(): - t.Errorf("timed out waiting for %s tablet's throttler to return a valid result after %v; last seen value: %+v", - tablet.Alias, timeout, checkResp) + respByte, _ := io.ReadAll(checkResp.Body) + body := string(respByte) + require.Failf(t, "time out", "waiting for %s tablet's throttler to return a valid result after %v; last seen result: %+v", + tablet.Alias, timeout, body) return case <-ticker.C: } diff --git a/go/textutil/strings.go b/go/textutil/strings.go index 2a923cd3259..a17daf8d382 100644 --- a/go/textutil/strings.go +++ b/go/textutil/strings.go @@ -90,6 +90,19 @@ func SingleWordCamel(w string) string { return strings.ToUpper(w[0:1]) + strings.ToLower(w[1:]) } +var multiWordSplitterRegexp = regexp.MustCompile(`[-_.\s]+`) + +// PascalCase turns a string into PascalCase by splitting it into words and +// capitalizing the first letter of each word. +func PascalCase(w string) string { + var b strings.Builder + words := multiWordSplitterRegexp.Split(w, -1) + for _, word := range words { + b.WriteString(SingleWordCamel(word)) + } + return b.String() +} + // ValueIsSimulatedNull returns true if the slice value represents // a NULL or unknown/unspecified value. This is used to distinguish // between a zero value empty slice and a user provided value of an diff --git a/go/textutil/strings_test.go b/go/textutil/strings_test.go index d65c187c4cb..828f39847cf 100644 --- a/go/textutil/strings_test.go +++ b/go/textutil/strings_test.go @@ -122,6 +122,64 @@ func TestSingleWordCamel(t *testing.T) { } } +func TestPascalCase(t *testing.T) { + tt := []struct { + word string + expect string + }{ + { + word: "", + expect: "", + }, + { + word: "_", + expect: "", + }, + { + word: "_a", + expect: "A", + }, + { + word: "A", + expect: "A", + }, + { + word: "mysql", + expect: "Mysql", + }, + { + word: "mySQL", + expect: "Mysql", + }, + { + word: "foo-bar", + expect: "FooBar", + }, + { + word: "mysql-server", + expect: "MysqlServer", + }, + { + word: "io_util", + expect: "IoUtil", + }, + { + word: "there and back again", + expect: "ThereAndBackAgain", + }, + { + word: "combine_all_OF the\tabove", + expect: "CombineAllOfTheAbove", + }, + } + for _, tc := range tt { + t.Run(tc.word, func(t *testing.T) { + pascal := PascalCase(tc.word) + assert.Equal(t, tc.expect, pascal) + }) + } +} + func TestValueIsSimulatedNull(t *testing.T) { tt := []struct { name string diff --git a/go/vt/mysqlctl/mysqld.go b/go/vt/mysqlctl/mysqld.go index 72c1d8f6658..d7435705a8a 100644 --- a/go/vt/mysqlctl/mysqld.go +++ b/go/vt/mysqlctl/mysqld.go @@ -47,6 +47,7 @@ import ( "vitess.io/vitess/config" "vitess.io/vitess/go/mysql" "vitess.io/vitess/go/mysql/sqlerror" + "vitess.io/vitess/go/osutil" "vitess.io/vitess/go/protoutil" "vitess.io/vitess/go/sqltypes" "vitess.io/vitess/go/vt/dbconfigs" @@ -1332,18 +1333,7 @@ func hostMetrics(ctx context.Context, cnf *Mycnf) (*mysqlctlpb.HostMetricsRespon _ = func() error { metric := newMetric("loadavg") - if runtime.GOOS != "linux" { - return withError(metric, fmt.Errorf("loadavg metric is only available on Linux")) - } - content, err := os.ReadFile("/proc/loadavg") - if err != nil { - return withError(metric, err) - } - fields := strings.Fields(string(content)) - if len(fields) == 0 { - return withError(metric, fmt.Errorf("unexpected /proc/loadavg content")) - } - loadAvg, err := strconv.ParseFloat(fields[0], 64) + loadAvg, err := osutil.LoadAvg() if err != nil { return withError(metric, err) } diff --git a/go/vt/vttablet/tabletserver/throttle/base/metric_cache.go b/go/vt/vttablet/tabletserver/throttle/base/metric_cache.go index 8695cb83229..faad65ca79e 100644 --- a/go/vt/vttablet/tabletserver/throttle/base/metric_cache.go +++ b/go/vt/vttablet/tabletserver/throttle/base/metric_cache.go @@ -49,6 +49,7 @@ import ( "github.com/patrickmn/go-cache" "vitess.io/vitess/go/stats" + "vitess.io/vitess/go/vt/vttablet/tmclient" ) // MetricsQueryType indicates the type of metrics query on MySQL backend. See following. @@ -142,13 +143,13 @@ func (metric *ThrottleMetric) WithError(err error) *ThrottleMetric { // ReadThrottleMetrics returns a metric for the given probe. Either by explicit query // or via SHOW REPLICA STATUS -func ReadThrottleMetrics(ctx context.Context, probe *Probe, metricsFunc func(context.Context) ThrottleMetrics) ThrottleMetrics { +func ReadThrottleMetrics(ctx context.Context, probe *Probe, tmClient tmclient.TabletManagerClient, metricsFunc func(context.Context, tmclient.TabletManagerClient) ThrottleMetrics) ThrottleMetrics { if metrics := getCachedThrottleMetrics(probe); metrics != nil { return metrics } started := time.Now() - throttleMetrics := metricsFunc(ctx) + throttleMetrics := metricsFunc(ctx, tmClient) go func(metrics ThrottleMetrics, started time.Time) { stats.GetOrNewGauge("ThrottlerProbesLatency", "probes latency").Set(time.Since(started).Nanoseconds()) diff --git a/go/vt/vttablet/tabletserver/throttle/base/metric_name.go b/go/vt/vttablet/tabletserver/throttle/base/metric_name.go index 98e1288fb23..607192b9c0c 100644 --- a/go/vt/vttablet/tabletserver/throttle/base/metric_name.go +++ b/go/vt/vttablet/tabletserver/throttle/base/metric_name.go @@ -60,11 +60,13 @@ func (names MetricNames) Unique() MetricNames { } const ( - DefaultMetricName MetricName = "default" - LagMetricName MetricName = "lag" - ThreadsRunningMetricName MetricName = "threads_running" - CustomMetricName MetricName = "custom" - LoadAvgMetricName MetricName = "loadavg" + DefaultMetricName MetricName = "default" + LagMetricName MetricName = "lag" + ThreadsRunningMetricName MetricName = "threads_running" + CustomMetricName MetricName = "custom" + LoadAvgMetricName MetricName = "loadavg" + MysqldLoadAvgMetricName MetricName = "mysqld-loadavg" + MysqldDatadirUsedRatioMetricName MetricName = "mysqld-datadir-used-ratio" ) func (metric MetricName) DefaultScope() Scope { diff --git a/go/vt/vttablet/tabletserver/throttle/base/metric_name_test.go b/go/vt/vttablet/tabletserver/throttle/base/metric_name_test.go index 9867ca18db3..ffd7f674cc2 100644 --- a/go/vt/vttablet/tabletserver/throttle/base/metric_name_test.go +++ b/go/vt/vttablet/tabletserver/throttle/base/metric_name_test.go @@ -21,6 +21,9 @@ import ( "testing" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + + "vitess.io/vitess/go/textutil" ) func TestAggregateName(t *testing.T) { @@ -238,4 +241,25 @@ func TestKnownMetricNames(t *testing.T) { assert.Contains(t, KnownMetricNames, LoadAvgMetricName) assert.Contains(t, KnownMetricNames, CustomMetricName) assert.Contains(t, KnownMetricNames, DefaultMetricName) + assert.Contains(t, KnownMetricNames, MysqldLoadAvgMetricName) + assert.Contains(t, KnownMetricNames, MysqldDatadirUsedRatioMetricName) +} + +func TestSingleWordCamelKnownMetricNames(t *testing.T) { + expectCases := map[MetricName]string{ + LagMetricName: "Lag", + ThreadsRunningMetricName: "ThreadsRunning", + LoadAvgMetricName: "Loadavg", + CustomMetricName: "Custom", + DefaultMetricName: "Default", + MysqldLoadAvgMetricName: "MysqldLoadavg", + MysqldDatadirUsedRatioMetricName: "MysqldDatadirUsedRatio", + } + for _, metricName := range KnownMetricNames { + t.Run(metricName.String(), func(t *testing.T) { + expect, ok := expectCases[metricName] + require.True(t, ok) + assert.Equal(t, expect, textutil.PascalCase(metricName.String())) + }) + } } diff --git a/go/vt/vttablet/tabletserver/throttle/base/self_metric.go b/go/vt/vttablet/tabletserver/throttle/base/self_metric.go index 220dfa6bf60..88fbe2bdd13 100644 --- a/go/vt/vttablet/tabletserver/throttle/base/self_metric.go +++ b/go/vt/vttablet/tabletserver/throttle/base/self_metric.go @@ -21,15 +21,24 @@ import ( "fmt" "strconv" + "vitess.io/vitess/go/vt/topo" "vitess.io/vitess/go/vt/vttablet/tabletserver/connpool" + "vitess.io/vitess/go/vt/vttablet/tmclient" ) +type SelfMetricReadParams struct { + Throttler metricsPublisher + Conn *connpool.Conn + TmClient tmclient.TabletManagerClient + TabletInfo *topo.TabletInfo +} + type SelfMetric interface { Name() MetricName DefaultScope() Scope DefaultThreshold() float64 RequiresConn() bool - Read(ctx context.Context, throttler ThrottlerMetricsPublisher, conn *connpool.Conn) *ThrottleMetric + Read(ctx context.Context, params *SelfMetricReadParams) *ThrottleMetric } var ( diff --git a/go/vt/vttablet/tabletserver/throttle/base/self_metric_custom_query.go b/go/vt/vttablet/tabletserver/throttle/base/self_metric_custom_query.go index 585e63ea285..88f789e5dcd 100644 --- a/go/vt/vttablet/tabletserver/throttle/base/self_metric_custom_query.go +++ b/go/vt/vttablet/tabletserver/throttle/base/self_metric_custom_query.go @@ -18,8 +18,6 @@ package base import ( "context" - - "vitess.io/vitess/go/vt/vttablet/tabletserver/connpool" ) var _ SelfMetric = registerSelfMetric(&CustomQuerySelfMetric{}) @@ -43,6 +41,6 @@ func (m *CustomQuerySelfMetric) RequiresConn() bool { return true } -func (m *CustomQuerySelfMetric) Read(ctx context.Context, throttler ThrottlerMetricsPublisher, conn *connpool.Conn) *ThrottleMetric { - return ReadSelfMySQLThrottleMetric(ctx, conn, throttler.GetCustomMetricsQuery()) +func (m *CustomQuerySelfMetric) Read(ctx context.Context, params *SelfMetricReadParams) *ThrottleMetric { + return ReadSelfMySQLThrottleMetric(ctx, params.Conn, params.Throttler.GetCustomMetricsQuery()) } diff --git a/go/vt/vttablet/tabletserver/throttle/base/self_metric_default.go b/go/vt/vttablet/tabletserver/throttle/base/self_metric_default.go index 8bce295da7c..97309fa6ea9 100644 --- a/go/vt/vttablet/tabletserver/throttle/base/self_metric_default.go +++ b/go/vt/vttablet/tabletserver/throttle/base/self_metric_default.go @@ -19,8 +19,6 @@ package base import ( "context" "fmt" - - "vitess.io/vitess/go/vt/vttablet/tabletserver/connpool" ) var _ SelfMetric = registerSelfMetric(&DefaultSelfMetric{}) @@ -44,7 +42,7 @@ func (m *DefaultSelfMetric) RequiresConn() bool { return false } -func (m *DefaultSelfMetric) Read(ctx context.Context, throttler ThrottlerMetricsPublisher, conn *connpool.Conn) *ThrottleMetric { +func (m *DefaultSelfMetric) Read(ctx context.Context, params *SelfMetricReadParams) *ThrottleMetric { return &ThrottleMetric{ Err: fmt.Errorf("unexpected direct call to DefaultSelfMetric.Read"), } diff --git a/go/vt/vttablet/tabletserver/throttle/base/self_metric_lag.go b/go/vt/vttablet/tabletserver/throttle/base/self_metric_lag.go index dc25ee5622a..3d0e4beebe1 100644 --- a/go/vt/vttablet/tabletserver/throttle/base/self_metric_lag.go +++ b/go/vt/vttablet/tabletserver/throttle/base/self_metric_lag.go @@ -23,7 +23,6 @@ import ( "vitess.io/vitess/go/constants/sidecar" "vitess.io/vitess/go/vt/sqlparser" - "vitess.io/vitess/go/vt/vttablet/tabletserver/connpool" ) var ( @@ -65,6 +64,6 @@ func (m *LagSelfMetric) RequiresConn() bool { return true } -func (m *LagSelfMetric) Read(ctx context.Context, throttler ThrottlerMetricsPublisher, conn *connpool.Conn) *ThrottleMetric { - return ReadSelfMySQLThrottleMetric(ctx, conn, m.GetQuery()) +func (m *LagSelfMetric) Read(ctx context.Context, params *SelfMetricReadParams) *ThrottleMetric { + return ReadSelfMySQLThrottleMetric(ctx, params.Conn, m.GetQuery()) } diff --git a/go/vt/vttablet/tabletserver/throttle/base/self_metric_loadavg.go b/go/vt/vttablet/tabletserver/throttle/base/self_metric_loadavg.go index 40a2878421a..2d880169020 100644 --- a/go/vt/vttablet/tabletserver/throttle/base/self_metric_loadavg.go +++ b/go/vt/vttablet/tabletserver/throttle/base/self_metric_loadavg.go @@ -18,20 +18,16 @@ package base import ( "context" - "fmt" - "os" "runtime" - "strconv" - "strings" + "sync/atomic" + "time" - "vitess.io/vitess/go/vt/vttablet/tabletserver/connpool" + "vitess.io/vitess/go/osutil" ) var ( - loadavgOnlyAvailableOnLinuxMetric = &ThrottleMetric{ - Scope: SelfScope, - Err: fmt.Errorf("loadavg metric is only available on Linux"), - } + cachedLoadAvgMetric atomic.Pointer[ThrottleMetric] + loadAvgCacheDuration = 1 * time.Second ) var _ SelfMetric = registerSelfMetric(&LoadAvgSelfMetric{}) @@ -55,27 +51,26 @@ func (m *LoadAvgSelfMetric) RequiresConn() bool { return false } -func (m *LoadAvgSelfMetric) Read(ctx context.Context, throttler ThrottlerMetricsPublisher, conn *connpool.Conn) *ThrottleMetric { - if runtime.GOOS != "linux" { - return loadavgOnlyAvailableOnLinuxMetric +func (m *LoadAvgSelfMetric) Read(ctx context.Context, params *SelfMetricReadParams) *ThrottleMetric { + // This function will be called sequentially, and therefore does not need strong mutex protection. Still, we use atomics + // to ensure correctness in case an external goroutine tries to read the metric concurrently. + metric := cachedLoadAvgMetric.Load() + if metric != nil { + return metric } - metric := &ThrottleMetric{ + metric = &ThrottleMetric{ Scope: SelfScope, } - { - content, err := os.ReadFile("/proc/loadavg") - if err != nil { - return metric.WithError(err) - } - fields := strings.Fields(string(content)) - if len(fields) == 0 { - return metric.WithError(fmt.Errorf("unexpected /proc/loadavg content")) - } - loadAvg, err := strconv.ParseFloat(fields[0], 64) - if err != nil { - return metric.WithError(err) - } - metric.Value = loadAvg / float64(runtime.NumCPU()) + val, err := osutil.LoadAvg() + if err != nil { + return metric.WithError(err) } + metric.Value = val / float64(runtime.NumCPU()) + + cachedLoadAvgMetric.Store(metric) + time.AfterFunc(loadAvgCacheDuration, func() { + cachedLoadAvgMetric.Store(nil) + }) + return metric } diff --git a/go/vt/vttablet/tabletserver/throttle/base/self_metric_mysqld.go b/go/vt/vttablet/tabletserver/throttle/base/self_metric_mysqld.go new file mode 100644 index 00000000000..321837d86b4 --- /dev/null +++ b/go/vt/vttablet/tabletserver/throttle/base/self_metric_mysqld.go @@ -0,0 +1,156 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package base + +import ( + "context" + "errors" + "fmt" + "sync/atomic" + "time" + + "vitess.io/vitess/go/timer" + + tabletmanagerdatapb "vitess.io/vitess/go/vt/proto/tabletmanagerdata" +) + +var ( + mysqlHostMetricsRpcTimeout = 5 * time.Second + mysqlHostMetricsRateLimit = 10 * time.Second + mysqlHostMetricsRateLimiter atomic.Pointer[timer.RateLimiter] + lastMySQLHostMetricsResponse atomic.Pointer[tabletmanagerdatapb.MysqlHostMetricsResponse] +) + +// getMysqlMetricsRateLimiter returns a rate limiter that is active until the given context is cancelled. +// This function will be called sequentially, but nonetheless it offers _some_ concurrent safety. Namely, +// that a created rate limiter is guaranteed to be cleaned up +func getMysqlMetricsRateLimiter(ctx context.Context, rateLimit time.Duration) *timer.RateLimiter { + rateLimiter := mysqlHostMetricsRateLimiter.Load() + if rateLimiter == nil { + rateLimiter = timer.NewRateLimiter(rateLimit) + go func() { + defer mysqlHostMetricsRateLimiter.Store(nil) + defer rateLimiter.Stop() + <-ctx.Done() + }() + mysqlHostMetricsRateLimiter.Store(rateLimiter) + } + return rateLimiter +} + +// readMysqlHostMetrics reads MySQL host metrics sporadically from the tablet manager (which in turn reads +// them from mysql deamon). The metrics are then cached, whether successful or not. +// This idea is that is is very wasteful to read these metrics for every single query. E.g. right now the throttler +// can issue 4 reads per second, which is wasteful to go through two RPCs to get the disk space usage for example. Even the load +// average on the MySQL server is not that susceptible to change. +func readMysqlHostMetrics(ctx context.Context, params *SelfMetricReadParams) error { + if params.TmClient == nil { + return fmt.Errorf("tmClient is nil") + } + if params.TabletInfo == nil { + return fmt.Errorf("tabletInfo is nil") + } + rateLimiter := getMysqlMetricsRateLimiter(ctx, mysqlHostMetricsRateLimit) + err := rateLimiter.Do(func() error { + ctx, cancel := context.WithTimeout(ctx, mysqlHostMetricsRpcTimeout) + defer cancel() + + resp, err := params.TmClient.MysqlHostMetrics(ctx, params.TabletInfo.Tablet, &tabletmanagerdatapb.MysqlHostMetricsRequest{}) + if err != nil { + return err + } + lastMySQLHostMetricsResponse.Store(resp) + return nil + }) + return err +} + +// getMysqlHostMetric gets a metric from the last read MySQL host metrics. The metric will either be directly read from +// tablet manager (which then reads it from the mysql deamon), or from the cache. +func getMysqlHostMetric(ctx context.Context, params *SelfMetricReadParams, mysqlHostMetricName string) *ThrottleMetric { + metric := &ThrottleMetric{ + Scope: SelfScope, + } + if err := readMysqlHostMetrics(ctx, params); err != nil { + return metric.WithError(err) + } + resp := lastMySQLHostMetricsResponse.Load() + if resp == nil { + return metric.WithError(ErrNoResultYet) + } + mysqlMetric := resp.HostMetrics.Metrics[mysqlHostMetricName] + if mysqlMetric == nil { + return metric.WithError(ErrNoSuchMetric) + } + metric.Value = mysqlMetric.Value + if mysqlMetric.Error != nil { + metric.Err = errors.New(mysqlMetric.Error.Message) + } + return metric +} + +var _ SelfMetric = registerSelfMetric(&MysqldLoadAvgSelfMetric{}) +var _ SelfMetric = registerSelfMetric(&MysqldDatadirUsedRatioSelfMetric{}) + +// MysqldLoadAvgSelfMetric stands for the load average per cpu, on the MySQL host. +type MysqldLoadAvgSelfMetric struct { +} + +func (m *MysqldLoadAvgSelfMetric) Name() MetricName { + return MysqldLoadAvgMetricName +} + +func (m *MysqldLoadAvgSelfMetric) DefaultScope() Scope { + return SelfScope +} + +func (m *MysqldLoadAvgSelfMetric) DefaultThreshold() float64 { + return 1.0 +} + +func (m *MysqldLoadAvgSelfMetric) RequiresConn() bool { + return false +} + +func (m *MysqldLoadAvgSelfMetric) Read(ctx context.Context, params *SelfMetricReadParams) *ThrottleMetric { + return getMysqlHostMetric(ctx, params, "loadavg") +} + +// MysqldDatadirUsedRatioSelfMetric stands for the disk space usage of the mount where MySQL's datadir is located. +// Range: 0.0 (empty) - 1.0 (full) +type MysqldDatadirUsedRatioSelfMetric struct { +} + +func (m *MysqldDatadirUsedRatioSelfMetric) Name() MetricName { + return MysqldDatadirUsedRatioMetricName +} + +func (m *MysqldDatadirUsedRatioSelfMetric) DefaultScope() Scope { + return SelfScope +} + +func (m *MysqldDatadirUsedRatioSelfMetric) DefaultThreshold() float64 { + return 0.98 +} + +func (m *MysqldDatadirUsedRatioSelfMetric) RequiresConn() bool { + return false +} + +func (m *MysqldDatadirUsedRatioSelfMetric) Read(ctx context.Context, params *SelfMetricReadParams) *ThrottleMetric { + return getMysqlHostMetric(ctx, params, "datadir-used-ratio") +} diff --git a/go/vt/vttablet/tabletserver/throttle/base/self_metric_mysqld_test.go b/go/vt/vttablet/tabletserver/throttle/base/self_metric_mysqld_test.go new file mode 100644 index 00000000000..39d3f3f5ec2 --- /dev/null +++ b/go/vt/vttablet/tabletserver/throttle/base/self_metric_mysqld_test.go @@ -0,0 +1,72 @@ +/* +Copyright 2024 The Vitess Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package base + +import ( + "context" + "fmt" + "testing" + "time" + + "github.com/stretchr/testify/assert" +) + +func TestGetMysqlMetricsRateLimiter(t *testing.T) { + rateLimit := 10 * time.Millisecond + for i := range 3 { + testName := fmt.Sprintf("iteration %d", i) + t.Run(testName, func(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + { + rateLimiter := mysqlHostMetricsRateLimiter.Load() + assert.Nil(t, rateLimiter) + } + rateLimiter := getMysqlMetricsRateLimiter(ctx, rateLimit) + assert.NotNil(t, rateLimiter) + for range 5 { + r := getMysqlMetricsRateLimiter(ctx, rateLimit) + // Returning the same rate limiter + assert.Equal(t, rateLimiter, r) + } + val := 0 + incr := func() error { + val++ + return nil + } + for range 10 { + rateLimiter.Do(incr) + time.Sleep(2 * rateLimit) + } + assert.EqualValues(t, 10, val) + cancel() + // There can be a race condition where the rate limiter still emits one final tick after the context is cancelled. + // So we wait enough time to ensure that tick is "wasted". + time.Sleep(2 * rateLimit) + // Now that the rate limited was stopped (we invoked `cancel()`), its `Do()` should not invoke the function anymore. + for range 7 { + rateLimiter.Do(incr) + time.Sleep(time.Millisecond) + } + assert.EqualValues(t, 10, val) // Same "10" value as before. + { + rateLimiter := mysqlHostMetricsRateLimiter.Load() + assert.Nil(t, rateLimiter) + } + }) + } +} diff --git a/go/vt/vttablet/tabletserver/throttle/base/self_metric_threads_running.go b/go/vt/vttablet/tabletserver/throttle/base/self_metric_threads_running.go index 08f7d408d1c..cb59547a768 100644 --- a/go/vt/vttablet/tabletserver/throttle/base/self_metric_threads_running.go +++ b/go/vt/vttablet/tabletserver/throttle/base/self_metric_threads_running.go @@ -18,8 +18,6 @@ package base import ( "context" - - "vitess.io/vitess/go/vt/vttablet/tabletserver/connpool" ) var ( @@ -47,6 +45,6 @@ func (m *ThreadsRunningSelfMetric) RequiresConn() bool { return true } -func (m *ThreadsRunningSelfMetric) Read(ctx context.Context, throttler ThrottlerMetricsPublisher, conn *connpool.Conn) *ThrottleMetric { - return ReadSelfMySQLThrottleMetric(ctx, conn, threadsRunningMetricQuery) +func (m *ThreadsRunningSelfMetric) Read(ctx context.Context, params *SelfMetricReadParams) *ThrottleMetric { + return ReadSelfMySQLThrottleMetric(ctx, params.Conn, threadsRunningMetricQuery) } diff --git a/go/vt/vttablet/tabletserver/throttle/base/throttler_metrics_publisher.go b/go/vt/vttablet/tabletserver/throttle/base/throttler_metrics_publisher.go index 1d2d4d0652c..10020af27e6 100644 --- a/go/vt/vttablet/tabletserver/throttle/base/throttler_metrics_publisher.go +++ b/go/vt/vttablet/tabletserver/throttle/base/throttler_metrics_publisher.go @@ -16,8 +16,8 @@ limitations under the License. package base -// ThrottlerMetricsPublisher is implemented by throttler.Throttler and is used by SelfMetric +// metricsPublisher is implemented by throttler.Throttler and is used by SelfMetric // implementations to query the throttler. -type ThrottlerMetricsPublisher interface { +type metricsPublisher interface { GetCustomMetricsQuery() string } diff --git a/go/vt/vttablet/tabletserver/throttle/check.go b/go/vt/vttablet/tabletserver/throttle/check.go index ccdfcb2ce23..d7f43d85e9d 100644 --- a/go/vt/vttablet/tabletserver/throttle/check.go +++ b/go/vt/vttablet/tabletserver/throttle/check.go @@ -188,9 +188,9 @@ func (check *ThrottlerCheck) Check(ctx context.Context, appName string, scope ba // Out of abundance of caution, we will protect against such a scenario. return } - stats.GetOrNewCounter(fmt.Sprintf("ThrottlerCheck%s%sTotal", textutil.SingleWordCamel(metricScope.String()), textutil.SingleWordCamel(metricName.String())), "").Add(1) + stats.GetOrNewCounter(fmt.Sprintf("ThrottlerCheck%s%sTotal", textutil.PascalCase(metricScope.String()), textutil.PascalCase(metricName.String())), "").Add(1) if !metricCheckResult.IsOK() { - stats.GetOrNewCounter(fmt.Sprintf("ThrottlerCheck%s%sError", textutil.SingleWordCamel(metricScope.String()), textutil.SingleWordCamel(metricName.String())), "").Add(1) + stats.GetOrNewCounter(fmt.Sprintf("ThrottlerCheck%s%sError", textutil.PascalCase(metricScope.String()), textutil.PascalCase(metricName.String())), "").Add(1) } }(metricCheckResult) } @@ -249,7 +249,7 @@ func (check *ThrottlerCheck) localCheck(ctx context.Context, aggregatedMetricNam check.throttler.markMetricHealthy(aggregatedMetricName) } if timeSinceHealthy, found := check.throttler.timeSinceMetricHealthy(aggregatedMetricName); found { - go stats.GetOrNewGauge(fmt.Sprintf("ThrottlerCheck%sSecondsSinceHealthy", textutil.SingleWordCamel(scope.String())), fmt.Sprintf("seconds since last healthy check for %v", scope)).Set(int64(timeSinceHealthy.Seconds())) + go stats.GetOrNewGauge(fmt.Sprintf("ThrottlerCheck%sSecondsSinceHealthy", textutil.PascalCase(scope.String())), fmt.Sprintf("seconds since last healthy check for %v", scope)).Set(int64(timeSinceHealthy.Seconds())) } return checkResult @@ -261,7 +261,7 @@ func (check *ThrottlerCheck) reportAggregated(aggregatedMetricName string, metri return } if value, err := metricResult.Get(); err == nil { - stats.GetOrNewGaugeFloat64(fmt.Sprintf("ThrottlerAggregated%s%s", textutil.SingleWordCamel(scope.String()), textutil.SingleWordCamel(metricName.String())), fmt.Sprintf("aggregated value for %v", scope)).Set(value) + stats.GetOrNewGaugeFloat64(fmt.Sprintf("ThrottlerAggregated%s%s", textutil.PascalCase(scope.String()), textutil.PascalCase(metricName.String())), fmt.Sprintf("aggregated value for %v", scope)).Set(value) } } diff --git a/go/vt/vttablet/tabletserver/throttle/throttler.go b/go/vt/vttablet/tabletserver/throttle/throttler.go index af7f59abb7e..839ba9d43b8 100644 --- a/go/vt/vttablet/tabletserver/throttle/throttler.go +++ b/go/vt/vttablet/tabletserver/throttle/throttler.go @@ -95,7 +95,6 @@ const ( DefaultThrottleRatio = 1.0 defaultReplicationLagQuery = "select unix_timestamp(now(6))-max(ts/1000000000) as replication_lag from %s.heartbeat" - threadsRunningQuery = "show global status like 'threads_running'" inventoryPrefix = "inventory/" throttlerConfigPrefix = "config/" @@ -137,6 +136,7 @@ type Throttler struct { keyspace string shard string tabletAlias *topodatapb.TabletAlias + tabletInfo atomic.Pointer[topo.TabletInfo] check *ThrottlerCheck isEnabled atomic.Bool @@ -190,7 +190,7 @@ type Throttler struct { cancelEnableContext context.CancelFunc throttledAppsMutex sync.Mutex - readSelfThrottleMetrics func(context.Context) base.ThrottleMetrics // overwritten by unit test + readSelfThrottleMetrics func(context.Context, tmclient.TabletManagerClient) base.ThrottleMetrics // overwritten by unit test } // ThrottlerStatus published some status values from the throttler @@ -262,8 +262,8 @@ func NewThrottler(env tabletenv.Env, srvTopoServer srvtopo.Server, ts *topo.Serv } throttler.StoreMetricsThreshold(base.RegisteredSelfMetrics[base.LagMetricName].DefaultThreshold()) - throttler.readSelfThrottleMetrics = func(ctx context.Context) base.ThrottleMetrics { - return throttler.readSelfThrottleMetricsInternal(ctx) + throttler.readSelfThrottleMetrics = func(ctx context.Context, tmClient tmclient.TabletManagerClient) base.ThrottleMetrics { + return throttler.readSelfThrottleMetricsInternal(ctx, tmClient) } return throttler } @@ -338,6 +338,15 @@ func (throttler *Throttler) initConfig() { // readThrottlerConfig proactively reads the throttler's config from SrvKeyspace in local topo func (throttler *Throttler) readThrottlerConfig(ctx context.Context) (*topodatapb.ThrottlerConfig, error) { + // since we're reading from topo, let's seize this opportunity to read table info as well + if throttler.tabletInfo.Load() == nil { + if ti, err := throttler.ts.GetTablet(ctx, throttler.tabletAlias); err == nil { + throttler.tabletInfo.Store(ti) + } else { + log.Errorf("Throttler: error reading tablet info: %v", err) + } + } + srvks, err := throttler.ts.GetSrvKeyspace(ctx, throttler.tabletAlias.Cell, throttler.keyspace) if err != nil { return nil, err @@ -804,7 +813,7 @@ func (throttler *Throttler) Operate(ctx context.Context, wg *sync.WaitGroup) { if throttler.IsOpen() { // frequent // Always collect self metrics: - throttler.collectSelfMetrics(ctx) + throttler.collectSelfMetrics(ctx, tmClient) if !throttler.isDormant() { throttler.collectShardMetrics(ctx, tmClient) } @@ -869,7 +878,7 @@ func (throttler *Throttler) Operate(ctx context.Context, wg *sync.WaitGroup) { }() } -func (throttler *Throttler) generateTabletProbeFunction(scope base.Scope, tmClient tmclient.TabletManagerClient, probe *base.Probe) (probeFunc func(context.Context) base.ThrottleMetrics) { +func (throttler *Throttler) generateTabletProbeFunction(scope base.Scope, probe *base.Probe) (probeFunc func(context.Context, tmclient.TabletManagerClient) base.ThrottleMetrics) { metricsWithError := func(err error) base.ThrottleMetrics { metrics := base.ThrottleMetrics{} for _, metricName := range base.KnownMetricNames { @@ -882,7 +891,7 @@ func (throttler *Throttler) generateTabletProbeFunction(scope base.Scope, tmClie } return metrics } - return func(ctx context.Context) base.ThrottleMetrics { + return func(ctx context.Context, tmClient tmclient.TabletManagerClient) base.ThrottleMetrics { // Some reasonable timeout, to ensure we release connections even if they're hanging (otherwise grpc-go keeps polling those connections forever) ctx, cancel := context.WithTimeout(ctx, 4*activeCollectInterval) defer cancel() @@ -940,7 +949,7 @@ func (throttler *Throttler) generateTabletProbeFunction(scope base.Scope, tmClie // readSelfThrottleMetricsInternal rreads all registsred self metrics on this tablet (or backend MySQL server). // This is the actual place where metrics are read, to be later aggregated and/or propagated to other tablets. -func (throttler *Throttler) readSelfThrottleMetricsInternal(ctx context.Context) base.ThrottleMetrics { +func (throttler *Throttler) readSelfThrottleMetricsInternal(ctx context.Context, tmClient tmclient.TabletManagerClient) base.ThrottleMetrics { result := make(base.ThrottleMetrics, len(base.RegisteredSelfMetrics)) writeMetric := func(metric *base.ThrottleMetric) { select { @@ -950,15 +959,20 @@ func (throttler *Throttler) readSelfThrottleMetricsInternal(ctx context.Context) } } readMetric := func(selfMetric base.SelfMetric) *base.ThrottleMetric { - if !selfMetric.RequiresConn() { - return selfMetric.Read(ctx, throttler, nil) + params := &base.SelfMetricReadParams{ + Throttler: throttler, + TmClient: tmClient, + TabletInfo: throttler.tabletInfo.Load(), } - conn, err := throttler.pool.Get(ctx, nil) - if err != nil { - return &base.ThrottleMetric{Err: err} + if selfMetric.RequiresConn() { + conn, err := throttler.pool.Get(ctx, nil) + if err != nil { + return &base.ThrottleMetric{Err: err} + } + defer conn.Recycle() + params.Conn = conn.Conn } - defer conn.Recycle() - return selfMetric.Read(ctx, throttler, conn.Conn) + return selfMetric.Read(ctx, params) } for metricName, selfMetric := range base.RegisteredSelfMetrics { if metricName == base.DefaultMetricName { @@ -975,7 +989,7 @@ func (throttler *Throttler) readSelfThrottleMetricsInternal(ctx context.Context) return result } -func (throttler *Throttler) collectSelfMetrics(ctx context.Context) { +func (throttler *Throttler) collectSelfMetrics(ctx context.Context, tmClient tmclient.TabletManagerClient) { probe := throttler.inventory.ClustersProbes[throttler.tabletAliasString()] if probe == nil { // probe not created yet @@ -990,7 +1004,7 @@ func (throttler *Throttler) collectSelfMetrics(ctx context.Context) { defer atomic.StoreInt64(&probe.QueryInProgress, 0) // Throttler is probing its own tablet's metrics: - _ = base.ReadThrottleMetrics(ctx, probe, throttler.readSelfThrottleMetrics) + _ = base.ReadThrottleMetrics(ctx, probe, tmClient, throttler.readSelfThrottleMetrics) }() } @@ -1011,9 +1025,9 @@ func (throttler *Throttler) collectShardMetrics(ctx context.Context, tmClient tm defer atomic.StoreInt64(&probe.QueryInProgress, 0) // Throttler probing other tablets: - throttleMetricFunc := throttler.generateTabletProbeFunction(base.ShardScope, tmClient, probe) + throttleMetricFunc := throttler.generateTabletProbeFunction(base.ShardScope, probe) - throttleMetrics := base.ReadThrottleMetrics(ctx, probe, throttleMetricFunc) + throttleMetrics := base.ReadThrottleMetrics(ctx, probe, tmClient, throttleMetricFunc) for _, metric := range throttleMetrics { select { case <-ctx.Done(): diff --git a/go/vt/vttablet/tabletserver/throttle/throttler_test.go b/go/vt/vttablet/tabletserver/throttle/throttler_test.go index fd7921899da..0a1162b02d3 100644 --- a/go/vt/vttablet/tabletserver/throttle/throttler_test.go +++ b/go/vt/vttablet/tabletserver/throttle/throttler_test.go @@ -71,6 +71,18 @@ var ( Value: 2.718, Err: nil, }, + base.MysqldLoadAvgMetricName: &base.ThrottleMetric{ + Scope: base.SelfScope, + Alias: "", + Value: 0.3311, + Err: nil, + }, + base.MysqldDatadirUsedRatioMetricName: &base.ThrottleMetric{ + Scope: base.SelfScope, + Alias: "", + Value: 0.85, + Err: nil, + }, } replicaMetrics = map[string]*MetricResult{ base.LagMetricName.String(): { @@ -93,6 +105,16 @@ var ( ResponseCode: tabletmanagerdatapb.CheckThrottlerResponseCode_OK, Value: 5.1, }, + base.MysqldLoadAvgMetricName.String(): { + StatusCode: http.StatusOK, + ResponseCode: tabletmanagerdatapb.CheckThrottlerResponseCode_OK, + Value: 0.2211, + }, + base.MysqldDatadirUsedRatioMetricName.String(): { + StatusCode: http.StatusOK, + ResponseCode: tabletmanagerdatapb.CheckThrottlerResponseCode_OK, + Value: 0.87, + }, } nonPrimaryTabletType atomic.Int32 ) @@ -283,7 +305,7 @@ func newTestThrottler() *Throttler { throttler.recentCheckDormantDiff = int64(throttler.dormantPeriod / recentCheckRateLimiterInterval) throttler.recentCheckDiff = int64(3 * time.Second / recentCheckRateLimiterInterval) - throttler.readSelfThrottleMetrics = func(ctx context.Context) base.ThrottleMetrics { + throttler.readSelfThrottleMetrics = func(ctx context.Context, tmClient tmclient.TabletManagerClient) base.ThrottleMetrics { for _, metric := range selfMetrics { go func() { select { @@ -1827,10 +1849,12 @@ func TestChecks(t *testing.T) { assert.Equal(t, testAppName.String(), checkResult.AppName) assert.Equal(t, len(base.KnownMetricNames), len(checkResult.Metrics)) - assert.EqualValues(t, 0.3, checkResult.Metrics[base.LagMetricName.String()].Value) // self lag value, because flags.Scope is set - assert.EqualValues(t, 26, checkResult.Metrics[base.ThreadsRunningMetricName.String()].Value) // self value, because flags.Scope is set - assert.EqualValues(t, 17, checkResult.Metrics[base.CustomMetricName.String()].Value) // self value, because flags.Scope is set - assert.EqualValues(t, 2.718, checkResult.Metrics[base.LoadAvgMetricName.String()].Value) // self value, because flags.Scope is set + assert.EqualValues(t, 0.3, checkResult.Metrics[base.LagMetricName.String()].Value) // self lag value, because flags.Scope is set + assert.EqualValues(t, 26, checkResult.Metrics[base.ThreadsRunningMetricName.String()].Value) // self value, because flags.Scope is set + assert.EqualValues(t, 17, checkResult.Metrics[base.CustomMetricName.String()].Value) // self value, because flags.Scope is set + assert.EqualValues(t, 2.718, checkResult.Metrics[base.LoadAvgMetricName.String()].Value) // self value, because flags.Scope is set + assert.EqualValues(t, 0.3311, checkResult.Metrics[base.MysqldLoadAvgMetricName.String()].Value) // self value, because flags.Scope is set + assert.EqualValues(t, 0.85, checkResult.Metrics[base.MysqldDatadirUsedRatioMetricName.String()].Value) // self value, because flags.Scope is set for _, metric := range checkResult.Metrics { assert.EqualValues(t, base.SelfScope.String(), metric.Scope) } @@ -1886,10 +1910,12 @@ func TestChecks(t *testing.T) { assert.Equal(t, testAppName.String(), checkResult.AppName) assert.Equal(t, len(base.KnownMetricNames), len(checkResult.Metrics)) - assert.EqualValues(t, 0.9, checkResult.Metrics[base.LagMetricName.String()].Value) // shard lag value, because flags.Scope is set - assert.EqualValues(t, 26, checkResult.Metrics[base.ThreadsRunningMetricName.String()].Value) // shard value, because flags.Scope is set - assert.EqualValues(t, 17, checkResult.Metrics[base.CustomMetricName.String()].Value) // shard value, because flags.Scope is set - assert.EqualValues(t, 5.1, checkResult.Metrics[base.LoadAvgMetricName.String()].Value) // shard value, because flags.Scope is set + assert.EqualValues(t, 0.9, checkResult.Metrics[base.LagMetricName.String()].Value) // shard lag value, because flags.Scope is set + assert.EqualValues(t, 26, checkResult.Metrics[base.ThreadsRunningMetricName.String()].Value) // shard value, because flags.Scope is set + assert.EqualValues(t, 17, checkResult.Metrics[base.CustomMetricName.String()].Value) // shard value, because flags.Scope is set + assert.EqualValues(t, 5.1, checkResult.Metrics[base.LoadAvgMetricName.String()].Value) // shard value, because flags.Scope is set + assert.EqualValues(t, 0.3311, checkResult.Metrics[base.MysqldLoadAvgMetricName.String()].Value) // shard value, because flags.Scope is set + assert.EqualValues(t, 0.87, checkResult.Metrics[base.MysqldDatadirUsedRatioMetricName.String()].Value) // shard value, because flags.Scope is set for _, metric := range checkResult.Metrics { assert.EqualValues(t, base.ShardScope.String(), metric.Scope) } @@ -1918,14 +1944,18 @@ func TestChecks(t *testing.T) { assert.ErrorIs(t, checkResult.Error, base.ErrThresholdExceeded) assert.Equal(t, len(base.KnownMetricNames), len(checkResult.Metrics)) - assert.EqualValues(t, 0.9, checkResult.Metrics[base.LagMetricName.String()].Value) // shard lag value, because "shard" is the default scope for lag - assert.EqualValues(t, 26, checkResult.Metrics[base.ThreadsRunningMetricName.String()].Value) // self value, because "self" is the default scope for threads_running - assert.EqualValues(t, 17, checkResult.Metrics[base.CustomMetricName.String()].Value) // self value, because "self" is the default scope for custom - assert.EqualValues(t, 2.718, checkResult.Metrics[base.LoadAvgMetricName.String()].Value) // self value, because "self" is the default scope for loadavg + assert.EqualValues(t, 0.9, checkResult.Metrics[base.LagMetricName.String()].Value) // shard lag value, because "shard" is the default scope for lag + assert.EqualValues(t, 26, checkResult.Metrics[base.ThreadsRunningMetricName.String()].Value) // self value, because "self" is the default scope for threads_running + assert.EqualValues(t, 17, checkResult.Metrics[base.CustomMetricName.String()].Value) // self value, because "self" is the default scope for custom + assert.EqualValues(t, 2.718, checkResult.Metrics[base.LoadAvgMetricName.String()].Value) // self value, because "self" is the default scope for loadavg + assert.EqualValues(t, 0.3311, checkResult.Metrics[base.MysqldLoadAvgMetricName.String()].Value) // self value, because "self" is the default scope for loadavg + assert.EqualValues(t, 0.85, checkResult.Metrics[base.MysqldDatadirUsedRatioMetricName.String()].Value) // self value, because "self" is the default scope for loadavg assert.EqualValues(t, base.ShardScope.String(), checkResult.Metrics[base.LagMetricName.String()].Scope) assert.EqualValues(t, base.SelfScope.String(), checkResult.Metrics[base.ThreadsRunningMetricName.String()].Scope) assert.EqualValues(t, base.SelfScope.String(), checkResult.Metrics[base.CustomMetricName.String()].Scope) assert.EqualValues(t, base.SelfScope.String(), checkResult.Metrics[base.LoadAvgMetricName.String()].Scope) + assert.EqualValues(t, base.SelfScope.String(), checkResult.Metrics[base.MysqldLoadAvgMetricName.String()].Scope) + assert.EqualValues(t, base.SelfScope.String(), checkResult.Metrics[base.MysqldDatadirUsedRatioMetricName.String()].Scope) }) }) t.Run("checks, defined scope masks explicit scope metrics", func(t *testing.T) { @@ -1939,6 +1969,8 @@ func TestChecks(t *testing.T) { base.MetricName("self/threads_running"), base.MetricName("custom"), base.MetricName("shard/loadavg"), + base.MetricName("shard/mysqld-loadavg"), + base.MetricName("self/mysqld-datadir-used-ratio"), base.MetricName("default"), } checkResult := throttler.Check(ctx, testAppName.String(), metricNames, flags) @@ -1950,10 +1982,12 @@ func TestChecks(t *testing.T) { assert.ErrorIs(t, checkResult.Error, base.ErrThresholdExceeded) assert.Equal(t, len(metricNames), len(checkResult.Metrics)) - assert.EqualValues(t, 0.9, checkResult.Metrics[base.LagMetricName.String()].Value) // shard lag value, even though scope name is in metric name - assert.EqualValues(t, 26, checkResult.Metrics[base.ThreadsRunningMetricName.String()].Value) // shard value, even though scope name is in metric name - assert.EqualValues(t, 17, checkResult.Metrics[base.CustomMetricName.String()].Value) // shard value because flags.Scope is set - assert.EqualValues(t, 5.1, checkResult.Metrics[base.LoadAvgMetricName.String()].Value) // shard value, not because scope name is in metric name but because flags.Scope is set + assert.EqualValues(t, 0.9, checkResult.Metrics[base.LagMetricName.String()].Value) // shard lag value, even though scope name is in metric name + assert.EqualValues(t, 26, checkResult.Metrics[base.ThreadsRunningMetricName.String()].Value) // shard value, even though scope name is in metric name + assert.EqualValues(t, 17, checkResult.Metrics[base.CustomMetricName.String()].Value) // shard value because flags.Scope is set + assert.EqualValues(t, 5.1, checkResult.Metrics[base.LoadAvgMetricName.String()].Value) // shard value, not because scope name is in metric name but because flags.Scope is set + assert.EqualValues(t, 0.3311, checkResult.Metrics[base.MysqldLoadAvgMetricName.String()].Value) // shard value, not because scope name is in metric name but because flags.Scope is set + assert.EqualValues(t, 0.87, checkResult.Metrics[base.MysqldDatadirUsedRatioMetricName.String()].Value) // shard value, even though scope name is in metric name for _, metric := range checkResult.Metrics { assert.EqualValues(t, base.ShardScope.String(), metric.Scope) } @@ -2222,8 +2256,12 @@ func TestReplica(t *testing.T) { base.DefaultMetricName: assert.Error(t, metricResult.Error, "metricName=%v, value=%v, threshold=%v", metricName, metricResult.Value, metricResult.Threshold) assert.ErrorIs(t, metricResult.Error, base.ErrThresholdExceeded) - case base.ThreadsRunningMetricName: + case base.ThreadsRunningMetricName, + base.MysqldLoadAvgMetricName, + base.MysqldDatadirUsedRatioMetricName: assert.NoError(t, metricResult.Error, "metricName=%v, value=%v, threshold=%v", metricName, metricResult.Value, metricResult.Threshold) + default: + assert.Fail(t, "unexpected metric", "name=%v", metricName) } } }) From c5d0eccd8735719f94fbae147cedddf6b53ad044 Mon Sep 17 00:00:00 2001 From: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> Date: Wed, 20 Nov 2024 09:48:26 +0200 Subject: [PATCH 9/9] Online DDL: dynamic cut-over threshold via `ALTER VITESS_MIGRATION ... CUTOVER_THRESHOLD ...` command (#17126) Signed-off-by: Shlomi Noach <2607934+shlomi-noach@users.noreply.github.com> --- .../scheduler/onlineddl_scheduler_test.go | 29 +- go/test/endtoend/onlineddl/vtgate_util.go | 10 + go/vt/schema/online_ddl.go | 2 + .../schema/onlineddl/schema_migrations.sql | 1 + go/vt/sqlparser/ast.go | 11 +- go/vt/sqlparser/ast_equals.go | 1 + go/vt/sqlparser/ast_format.go | 5 + go/vt/sqlparser/ast_format_fast.go | 7 + go/vt/sqlparser/cached_size.go | 4 +- go/vt/sqlparser/constants.go | 1 + go/vt/sqlparser/keywords.go | 1 + go/vt/sqlparser/parse_test.go | 2 + go/vt/sqlparser/sql.go | 18434 ++++++++-------- go/vt/sqlparser/sql.y | 11 +- go/vt/vttablet/onlineddl/executor.go | 109 +- go/vt/vttablet/onlineddl/executor_test.go | 57 + go/vt/vttablet/onlineddl/schema.go | 9 +- go/vt/vttablet/tabletserver/query_executor.go | 2 + 18 files changed, 9469 insertions(+), 9227 deletions(-) diff --git a/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go b/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go index 7b8180e80fb..53a1c8137fd 100644 --- a/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go +++ b/go/test/endtoend/onlineddl/scheduler/onlineddl_scheduler_test.go @@ -484,7 +484,7 @@ func testScheduler(t *testing.T) { testTableSequentialTimes(t, t1uuid, t2uuid) }) t.Run("Postpone launch CREATE", func(t *testing.T) { - t1uuid = testOnlineDDLStatement(t, createParams(createT1IfNotExistsStatement, ddlStrategy+" --postpone-launch", "vtgate", "", "", true)) // skip wait + t1uuid = testOnlineDDLStatement(t, createParams(createT1IfNotExistsStatement, ddlStrategy+" --postpone-launch --cut-over-threshold=14s", "vtgate", "", "", true)) // skip wait time.Sleep(2 * time.Second) rs := onlineddl.ReadMigrations(t, &vtParams, t1uuid) require.NotNil(t, rs) @@ -501,6 +501,10 @@ func testScheduler(t *testing.T) { for _, row := range rs.Named().Rows { postponeLaunch := row.AsInt64("postpone_launch", 0) assert.Equal(t, int64(0), postponeLaunch) + + cutOverThresholdSeconds := row.AsInt64("cutover_threshold_seconds", 0) + // Threshold supplied in DDL strategy + assert.EqualValues(t, 14, cutOverThresholdSeconds) } status := onlineddl.WaitForMigrationStatus(t, &vtParams, shards, t1uuid, normalWaitTime, schema.OnlineDDLStatusComplete, schema.OnlineDDLStatusFailed) fmt.Printf("# Migration status (for debug purposes): <%s>\n", status) @@ -580,6 +584,9 @@ func testScheduler(t *testing.T) { assert.Equal(t, int64(1), postponeCompletion) } }) + t.Run("set cut-over threshold", func(t *testing.T) { + onlineddl.CheckSetMigrationCutOverThreshold(t, &vtParams, shards, t1uuid, 17700*time.Millisecond, "") + }) t.Run("complete", func(t *testing.T) { onlineddl.CheckCompleteMigration(t, &vtParams, shards, t1uuid, true) status := onlineddl.WaitForMigrationStatus(t, &vtParams, shards, t1uuid, normalWaitTime, schema.OnlineDDLStatusComplete, schema.OnlineDDLStatusFailed) @@ -592,6 +599,11 @@ func testScheduler(t *testing.T) { for _, row := range rs.Named().Rows { postponeCompletion := row.AsInt64("postpone_completion", 0) assert.Equal(t, int64(0), postponeCompletion) + + cutOverThresholdSeconds := row.AsInt64("cutover_threshold_seconds", 0) + // Expect 17800*time.Millisecond to be truncated to 17 seconds + assert.EqualValues(t, 17, cutOverThresholdSeconds) + assert.False(t, row["shadow_analyzed_timestamp"].IsNull()) } }) @@ -1062,6 +1074,10 @@ func testScheduler(t *testing.T) { for _, row := range rs.Named().Rows { retries := row.AsInt64("retries", 0) assert.Greater(t, retries, int64(0)) + + cutOverThresholdSeconds := row.AsInt64("cutover_threshold_seconds", 0) + // No explicit cut-over threshold given. Expect the default 10s + assert.EqualValues(t, 10, cutOverThresholdSeconds) } }) }) @@ -1088,6 +1104,13 @@ func testScheduler(t *testing.T) { executedUUID := testOnlineDDLStatement(t, createParams(trivialAlterT1Statement, ddlStrategy, "vtctl", "", "", true)) // skip wait require.Equal(t, uuid, executedUUID) + t.Run("set low cut-over threshold", func(t *testing.T) { + onlineddl.CheckSetMigrationCutOverThreshold(t, &vtParams, shards, uuid, 2*time.Second, "cut-over min value") + }) + t.Run("set high cut-over threshold", func(t *testing.T) { + onlineddl.CheckSetMigrationCutOverThreshold(t, &vtParams, shards, uuid, 2000*time.Second, "cut-over max value") + }) + // expect it to complete status := onlineddl.WaitForMigrationStatus(t, &vtParams, shards, uuid, normalWaitTime, schema.OnlineDDLStatusComplete, schema.OnlineDDLStatusFailed) fmt.Printf("# Migration status (for debug purposes): <%s>\n", status) @@ -1098,6 +1121,10 @@ func testScheduler(t *testing.T) { for _, row := range rs.Named().Rows { retries := row.AsInt64("retries", 0) assert.Greater(t, retries, int64(0)) + + cutOverThresholdSeconds := row.AsInt64("cutover_threshold_seconds", 0) + // Teh default remains unchanged. + assert.EqualValues(t, 10, cutOverThresholdSeconds) } }) }) diff --git a/go/test/endtoend/onlineddl/vtgate_util.go b/go/test/endtoend/onlineddl/vtgate_util.go index 639b3ce8eb4..ffb6423a346 100644 --- a/go/test/endtoend/onlineddl/vtgate_util.go +++ b/go/test/endtoend/onlineddl/vtgate_util.go @@ -255,6 +255,16 @@ func CheckForceMigrationCutOver(t *testing.T, vtParams *mysql.ConnParams, shards } } +// CheckSetMigrationCutOverThreshold sets the cut-over threshold for a given migration. +func CheckSetMigrationCutOverThreshold(t *testing.T, vtParams *mysql.ConnParams, shards []cluster.Shard, uuid string, threshold time.Duration, expectError string) { + query, err := sqlparser.ParseAndBind("alter vitess_migration %a cutover_threshold %a", + sqltypes.StringBindVariable(uuid), + sqltypes.StringBindVariable(threshold.String()), + ) + require.NoError(t, err) + _ = VtgateExecQuery(t, vtParams, query, expectError) +} + // CheckMigrationStatus verifies that the migration indicated by given UUID has the given expected status func CheckMigrationStatus(t *testing.T, vtParams *mysql.ConnParams, shards []cluster.Shard, uuid string, expectStatuses ...schema.OnlineDDLStatus) bool { ksName := shards[0].PrimaryTablet().VttabletProcess.Keyspace diff --git a/go/vt/schema/online_ddl.go b/go/vt/schema/online_ddl.go index 59363b00889..8de54d98b1e 100644 --- a/go/vt/schema/online_ddl.go +++ b/go/vt/schema/online_ddl.go @@ -24,6 +24,7 @@ import ( "regexp" "strconv" "strings" + "time" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" "vitess.io/vitess/go/vt/sqlparser" @@ -116,6 +117,7 @@ type OnlineDDL struct { Retries int64 `json:"retries,omitempty"` ReadyToComplete int64 `json:"ready_to_complete,omitempty"` WasReadyToComplete int64 `json:"was_ready_to_complete,omitempty"` + CutOverThreshold time.Duration `json:"cutover_threshold,omitempty"` } // ParseOnlineDDLStatement parses the given SQL into a statement and returns the action type of the DDL statement, or error diff --git a/go/vt/sidecardb/schema/onlineddl/schema_migrations.sql b/go/vt/sidecardb/schema/onlineddl/schema_migrations.sql index e0b4e27b180..91c0323e54b 100644 --- a/go/vt/sidecardb/schema/onlineddl/schema_migrations.sql +++ b/go/vt/sidecardb/schema/onlineddl/schema_migrations.sql @@ -76,6 +76,7 @@ CREATE TABLE IF NOT EXISTS schema_migrations `removed_foreign_key_names` text NOT NULL, `last_cutover_attempt_timestamp` timestamp NULL DEFAULT NULL, `force_cutover` tinyint unsigned NOT NULL DEFAULT '0', + `cutover_threshold_seconds` int unsigned NOT NULL DEFAULT '0', PRIMARY KEY (`id`), UNIQUE KEY `uuid_idx` (`migration_uuid`), KEY `keyspace_shard_idx` (`keyspace`(64), `shard`(64)), diff --git a/go/vt/sqlparser/ast.go b/go/vt/sqlparser/ast.go index 3d4f56ef628..92c67d55999 100644 --- a/go/vt/sqlparser/ast.go +++ b/go/vt/sqlparser/ast.go @@ -491,11 +491,12 @@ type ( // AlterMigration represents a ALTER VITESS_MIGRATION statement AlterMigration struct { - Type AlterMigrationType - UUID string - Expire string - Ratio *Literal - Shards string + Type AlterMigrationType + UUID string + Expire string + Ratio *Literal + Threshold string + Shards string } // AlterTable represents a ALTER TABLE statement. diff --git a/go/vt/sqlparser/ast_equals.go b/go/vt/sqlparser/ast_equals.go index 502a4a78d88..c4c0b34c271 100644 --- a/go/vt/sqlparser/ast_equals.go +++ b/go/vt/sqlparser/ast_equals.go @@ -1790,6 +1790,7 @@ func (cmp *Comparator) RefOfAlterMigration(a, b *AlterMigration) bool { } return a.UUID == b.UUID && a.Expire == b.Expire && + a.Threshold == b.Threshold && a.Shards == b.Shards && a.Type == b.Type && cmp.RefOfLiteral(a.Ratio, b.Ratio) diff --git a/go/vt/sqlparser/ast_format.go b/go/vt/sqlparser/ast_format.go index b9af85d410e..dff17911d8e 100644 --- a/go/vt/sqlparser/ast_format.go +++ b/go/vt/sqlparser/ast_format.go @@ -322,8 +322,13 @@ func (node *AlterMigration) Format(buf *TrackedBuffer) { alterType = "force_cutover" case ForceCutOverAllMigrationType: alterType = "force_cutover all" + case SetCutOverThresholdMigrationType: + alterType = "cutover_threshold" } buf.astPrintf(node, " %#s", alterType) + if node.Threshold != "" { + buf.astPrintf(node, " '%#s'", node.Threshold) + } if node.Expire != "" { buf.astPrintf(node, " expire '%#s'", node.Expire) } diff --git a/go/vt/sqlparser/ast_format_fast.go b/go/vt/sqlparser/ast_format_fast.go index 1950a79a613..9855c70a21d 100644 --- a/go/vt/sqlparser/ast_format_fast.go +++ b/go/vt/sqlparser/ast_format_fast.go @@ -448,9 +448,16 @@ func (node *AlterMigration) FormatFast(buf *TrackedBuffer) { alterType = "force_cutover" case ForceCutOverAllMigrationType: alterType = "force_cutover all" + case SetCutOverThresholdMigrationType: + alterType = "cutover_threshold" } buf.WriteByte(' ') buf.WriteString(alterType) + if node.Threshold != "" { + buf.WriteString(" '") + buf.WriteString(node.Threshold) + buf.WriteByte('\'') + } if node.Expire != "" { buf.WriteString(" expire '") buf.WriteString(node.Expire) diff --git a/go/vt/sqlparser/cached_size.go b/go/vt/sqlparser/cached_size.go index 9703d189b7a..524291a03b4 100644 --- a/go/vt/sqlparser/cached_size.go +++ b/go/vt/sqlparser/cached_size.go @@ -208,7 +208,7 @@ func (cached *AlterMigration) CachedSize(alloc bool) int64 { } size := int64(0) if alloc { - size += int64(64) + size += int64(80) } // field UUID string size += hack.RuntimeAllocSize(int64(len(cached.UUID))) @@ -216,6 +216,8 @@ func (cached *AlterMigration) CachedSize(alloc bool) int64 { size += hack.RuntimeAllocSize(int64(len(cached.Expire))) // field Ratio *vitess.io/vitess/go/vt/sqlparser.Literal size += cached.Ratio.CachedSize(true) + // field Threshold string + size += hack.RuntimeAllocSize(int64(len(cached.Threshold))) // field Shards string size += hack.RuntimeAllocSize(int64(len(cached.Shards))) return size diff --git a/go/vt/sqlparser/constants.go b/go/vt/sqlparser/constants.go index 1c8f831274c..bdf35a2654d 100644 --- a/go/vt/sqlparser/constants.go +++ b/go/vt/sqlparser/constants.go @@ -915,6 +915,7 @@ const ( UnthrottleAllMigrationType ForceCutOverMigrationType ForceCutOverAllMigrationType + SetCutOverThresholdMigrationType ) // ColumnStorage constants diff --git a/go/vt/sqlparser/keywords.go b/go/vt/sqlparser/keywords.go index e32d7d0b72a..5c1b881df30 100644 --- a/go/vt/sqlparser/keywords.go +++ b/go/vt/sqlparser/keywords.go @@ -205,6 +205,7 @@ var keywords = []keyword{ {"current_timestamp", CURRENT_TIMESTAMP}, {"current_user", CURRENT_USER}, {"cursor", UNUSED}, + {"cutover_threshold", CUTOVER_THRESHOLD}, {"data", DATA}, {"database", DATABASE}, {"databases", DATABASES}, diff --git a/go/vt/sqlparser/parse_test.go b/go/vt/sqlparser/parse_test.go index 3a769f05688..d3d5fd469e7 100644 --- a/go/vt/sqlparser/parse_test.go +++ b/go/vt/sqlparser/parse_test.go @@ -2482,6 +2482,8 @@ var ( input: "alter vitess_migration force_cutover all", }, { input: "alter vitess_migration '9748c3b7_7fdb_11eb_ac2c_f875a4d24e90' force_cutover", + }, { + input: "alter vitess_migration '9748c3b7_7fdb_11eb_ac2c_f875a4d24e90' cutover_threshold '17s'", }, { input: "alter vitess_migration '9748c3b7_7fdb_11eb_ac2c_f875a4d24e90' FORCE_CUTOVER", output: "alter vitess_migration '9748c3b7_7fdb_11eb_ac2c_f875a4d24e90' force_cutover", diff --git a/go/vt/sqlparser/sql.go b/go/vt/sqlparser/sql.go index 682efc9f6ec..befd9b44c3b 100644 --- a/go/vt/sqlparser/sql.go +++ b/go/vt/sqlparser/sql.go @@ -340,431 +340,432 @@ const CLEANUP = 57647 const THROTTLE = 57648 const UNTHROTTLE = 57649 const FORCE_CUTOVER = 57650 -const EXPIRE = 57651 -const RATIO = 57652 -const VITESS_THROTTLER = 57653 -const BEGIN = 57654 -const START = 57655 -const TRANSACTION = 57656 -const COMMIT = 57657 -const ROLLBACK = 57658 -const SAVEPOINT = 57659 -const RELEASE = 57660 -const WORK = 57661 -const CONSISTENT = 57662 -const SNAPSHOT = 57663 -const UNRESOLVED = 57664 -const TRANSACTIONS = 57665 -const BIT = 57666 -const TINYINT = 57667 -const SMALLINT = 57668 -const MEDIUMINT = 57669 -const INT = 57670 -const INTEGER = 57671 -const BIGINT = 57672 -const INTNUM = 57673 -const REAL = 57674 -const DOUBLE = 57675 -const FLOAT_TYPE = 57676 -const FLOAT4_TYPE = 57677 -const FLOAT8_TYPE = 57678 -const DECIMAL_TYPE = 57679 -const NUMERIC = 57680 -const TIME = 57681 -const TIMESTAMP = 57682 -const DATETIME = 57683 -const YEAR = 57684 -const CHAR = 57685 -const VARCHAR = 57686 -const BOOL = 57687 -const CHARACTER = 57688 -const VARBINARY = 57689 -const NCHAR = 57690 -const TEXT = 57691 -const TINYTEXT = 57692 -const MEDIUMTEXT = 57693 -const LONGTEXT = 57694 -const BLOB = 57695 -const TINYBLOB = 57696 -const MEDIUMBLOB = 57697 -const LONGBLOB = 57698 -const JSON = 57699 -const JSON_SCHEMA_VALID = 57700 -const JSON_SCHEMA_VALIDATION_REPORT = 57701 -const ENUM = 57702 -const GEOMETRY = 57703 -const POINT = 57704 -const LINESTRING = 57705 -const POLYGON = 57706 -const GEOMCOLLECTION = 57707 -const GEOMETRYCOLLECTION = 57708 -const MULTIPOINT = 57709 -const MULTILINESTRING = 57710 -const MULTIPOLYGON = 57711 -const ASCII = 57712 -const UNICODE = 57713 -const VECTOR = 57714 -const NULLX = 57715 -const AUTO_INCREMENT = 57716 -const APPROXNUM = 57717 -const SIGNED = 57718 -const UNSIGNED = 57719 -const ZEROFILL = 57720 -const PURGE = 57721 -const BEFORE = 57722 -const CODE = 57723 -const COLLATION = 57724 -const COLUMNS = 57725 -const DATABASES = 57726 -const ENGINES = 57727 -const EVENT = 57728 -const EXTENDED = 57729 -const FIELDS = 57730 -const FULL = 57731 -const FUNCTION = 57732 -const GTID_EXECUTED = 57733 -const KEYSPACES = 57734 -const OPEN = 57735 -const PLUGINS = 57736 -const PRIVILEGES = 57737 -const PROCESSLIST = 57738 -const SCHEMAS = 57739 -const TABLES = 57740 -const TRIGGERS = 57741 -const USER = 57742 -const VGTID_EXECUTED = 57743 -const VITESS_KEYSPACES = 57744 -const VITESS_METADATA = 57745 -const VITESS_MIGRATIONS = 57746 -const VITESS_REPLICATION_STATUS = 57747 -const VITESS_SHARDS = 57748 -const VITESS_TABLETS = 57749 -const VITESS_TARGET = 57750 -const VSCHEMA = 57751 -const VITESS_THROTTLED_APPS = 57752 -const NAMES = 57753 -const GLOBAL = 57754 -const SESSION = 57755 -const ISOLATION = 57756 -const LEVEL = 57757 -const READ = 57758 -const WRITE = 57759 -const ONLY = 57760 -const REPEATABLE = 57761 -const COMMITTED = 57762 -const UNCOMMITTED = 57763 -const SERIALIZABLE = 57764 -const ADDDATE = 57765 -const CURRENT_TIMESTAMP = 57766 -const DATABASE = 57767 -const CURRENT_DATE = 57768 -const CURDATE = 57769 -const DATE_ADD = 57770 -const DATE_SUB = 57771 -const NOW = 57772 -const SUBDATE = 57773 -const CURTIME = 57774 -const CURRENT_TIME = 57775 -const LOCALTIME = 57776 -const LOCALTIMESTAMP = 57777 -const CURRENT_USER = 57778 -const UTC_DATE = 57779 -const UTC_TIME = 57780 -const UTC_TIMESTAMP = 57781 -const SYSDATE = 57782 -const DAY = 57783 -const DAY_HOUR = 57784 -const DAY_MICROSECOND = 57785 -const DAY_MINUTE = 57786 -const DAY_SECOND = 57787 -const HOUR = 57788 -const HOUR_MICROSECOND = 57789 -const HOUR_MINUTE = 57790 -const HOUR_SECOND = 57791 -const MICROSECOND = 57792 -const MINUTE = 57793 -const MINUTE_MICROSECOND = 57794 -const MINUTE_SECOND = 57795 -const MONTH = 57796 -const QUARTER = 57797 -const SECOND = 57798 -const SECOND_MICROSECOND = 57799 -const YEAR_MONTH = 57800 -const WEEK = 57801 -const SQL_TSI_DAY = 57802 -const SQL_TSI_WEEK = 57803 -const SQL_TSI_HOUR = 57804 -const SQL_TSI_MINUTE = 57805 -const SQL_TSI_MONTH = 57806 -const SQL_TSI_QUARTER = 57807 -const SQL_TSI_SECOND = 57808 -const SQL_TSI_MICROSECOND = 57809 -const SQL_TSI_YEAR = 57810 -const REPLACE = 57811 -const CONVERT = 57812 -const CAST = 57813 -const SUBSTR = 57814 -const SUBSTRING = 57815 -const MID = 57816 -const SEPARATOR = 57817 -const TIMESTAMPADD = 57818 -const TIMESTAMPDIFF = 57819 -const WEIGHT_STRING = 57820 -const LTRIM = 57821 -const RTRIM = 57822 -const TRIM = 57823 -const JSON_ARRAY = 57824 -const JSON_OBJECT = 57825 -const JSON_QUOTE = 57826 -const JSON_DEPTH = 57827 -const JSON_TYPE = 57828 -const JSON_LENGTH = 57829 -const JSON_VALID = 57830 -const JSON_ARRAY_APPEND = 57831 -const JSON_ARRAY_INSERT = 57832 -const JSON_INSERT = 57833 -const JSON_MERGE = 57834 -const JSON_MERGE_PATCH = 57835 -const JSON_MERGE_PRESERVE = 57836 -const JSON_REMOVE = 57837 -const JSON_REPLACE = 57838 -const JSON_SET = 57839 -const JSON_UNQUOTE = 57840 -const COUNT = 57841 -const AVG = 57842 -const MAX = 57843 -const MIN = 57844 -const SUM = 57845 -const GROUP_CONCAT = 57846 -const BIT_AND = 57847 -const BIT_OR = 57848 -const BIT_XOR = 57849 -const STD = 57850 -const STDDEV = 57851 -const STDDEV_POP = 57852 -const STDDEV_SAMP = 57853 -const VAR_POP = 57854 -const VAR_SAMP = 57855 -const VARIANCE = 57856 -const ANY_VALUE = 57857 -const REGEXP_INSTR = 57858 -const REGEXP_LIKE = 57859 -const REGEXP_REPLACE = 57860 -const REGEXP_SUBSTR = 57861 -const ExtractValue = 57862 -const UpdateXML = 57863 -const GET_LOCK = 57864 -const RELEASE_LOCK = 57865 -const RELEASE_ALL_LOCKS = 57866 -const IS_FREE_LOCK = 57867 -const IS_USED_LOCK = 57868 -const LOCATE = 57869 -const POSITION = 57870 -const ST_GeometryCollectionFromText = 57871 -const ST_GeometryFromText = 57872 -const ST_LineStringFromText = 57873 -const ST_MultiLineStringFromText = 57874 -const ST_MultiPointFromText = 57875 -const ST_MultiPolygonFromText = 57876 -const ST_PointFromText = 57877 -const ST_PolygonFromText = 57878 -const ST_GeometryCollectionFromWKB = 57879 -const ST_GeometryFromWKB = 57880 -const ST_LineStringFromWKB = 57881 -const ST_MultiLineStringFromWKB = 57882 -const ST_MultiPointFromWKB = 57883 -const ST_MultiPolygonFromWKB = 57884 -const ST_PointFromWKB = 57885 -const ST_PolygonFromWKB = 57886 -const ST_AsBinary = 57887 -const ST_AsText = 57888 -const ST_Dimension = 57889 -const ST_Envelope = 57890 -const ST_IsSimple = 57891 -const ST_IsEmpty = 57892 -const ST_GeometryType = 57893 -const ST_X = 57894 -const ST_Y = 57895 -const ST_Latitude = 57896 -const ST_Longitude = 57897 -const ST_EndPoint = 57898 -const ST_IsClosed = 57899 -const ST_Length = 57900 -const ST_NumPoints = 57901 -const ST_StartPoint = 57902 -const ST_PointN = 57903 -const ST_Area = 57904 -const ST_Centroid = 57905 -const ST_ExteriorRing = 57906 -const ST_InteriorRingN = 57907 -const ST_NumInteriorRings = 57908 -const ST_NumGeometries = 57909 -const ST_GeometryN = 57910 -const ST_LongFromGeoHash = 57911 -const ST_PointFromGeoHash = 57912 -const ST_LatFromGeoHash = 57913 -const ST_GeoHash = 57914 -const ST_AsGeoJSON = 57915 -const ST_GeomFromGeoJSON = 57916 -const MATCH = 57917 -const AGAINST = 57918 -const BOOLEAN = 57919 -const LANGUAGE = 57920 -const WITH = 57921 -const QUERY = 57922 -const EXPANSION = 57923 -const WITHOUT = 57924 -const VALIDATION = 57925 -const ROLLUP = 57926 -const UNUSED = 57927 -const ARRAY = 57928 -const BYTE = 57929 -const CUME_DIST = 57930 -const DESCRIPTION = 57931 -const DENSE_RANK = 57932 -const EMPTY = 57933 -const EXCEPT = 57934 -const FIRST_VALUE = 57935 -const GROUPING = 57936 -const GROUPS = 57937 -const JSON_TABLE = 57938 -const LAG = 57939 -const LAST_VALUE = 57940 -const LATERAL = 57941 -const LEAD = 57942 -const NTH_VALUE = 57943 -const NTILE = 57944 -const OF = 57945 -const OVER = 57946 -const PERCENT_RANK = 57947 -const RANK = 57948 -const RECURSIVE = 57949 -const ROW_NUMBER = 57950 -const SYSTEM = 57951 -const WINDOW = 57952 -const ACTIVE = 57953 -const ADMIN = 57954 -const AUTOEXTEND_SIZE = 57955 -const BUCKETS = 57956 -const CLONE = 57957 -const COLUMN_FORMAT = 57958 -const COMPONENT = 57959 -const DEFINITION = 57960 -const ENFORCED = 57961 -const ENGINE_ATTRIBUTE = 57962 -const EXCLUDE = 57963 -const FOLLOWING = 57964 -const GET_MASTER_PUBLIC_KEY = 57965 -const HISTOGRAM = 57966 -const HISTORY = 57967 -const INACTIVE = 57968 -const INVISIBLE = 57969 -const LOCKED = 57970 -const MASTER_COMPRESSION_ALGORITHMS = 57971 -const MASTER_PUBLIC_KEY_PATH = 57972 -const MASTER_TLS_CIPHERSUITES = 57973 -const MASTER_ZSTD_COMPRESSION_LEVEL = 57974 -const NESTED = 57975 -const NETWORK_NAMESPACE = 57976 -const NOWAIT = 57977 -const NULLS = 57978 -const OJ = 57979 -const OLD = 57980 -const OPTIONAL = 57981 -const ORDINALITY = 57982 -const ORGANIZATION = 57983 -const OTHERS = 57984 -const PARTIAL = 57985 -const PATH = 57986 -const PERSIST = 57987 -const PERSIST_ONLY = 57988 -const PRECEDING = 57989 -const PRIVILEGE_CHECKS_USER = 57990 -const PROCESS = 57991 -const RANDOM = 57992 -const REFERENCE = 57993 -const REQUIRE_ROW_FORMAT = 57994 -const RESOURCE = 57995 -const RESPECT = 57996 -const RESTART = 57997 -const RETAIN = 57998 -const REUSE = 57999 -const ROLE = 58000 -const SECONDARY = 58001 -const SECONDARY_ENGINE = 58002 -const SECONDARY_ENGINE_ATTRIBUTE = 58003 -const SECONDARY_LOAD = 58004 -const SECONDARY_UNLOAD = 58005 -const SIMPLE = 58006 -const SKIP = 58007 -const SRID = 58008 -const THREAD_PRIORITY = 58009 -const TIES = 58010 -const UNBOUNDED = 58011 -const VCPU = 58012 -const VISIBLE = 58013 -const RETURNING = 58014 -const FORMAT_BYTES = 58015 -const FORMAT_PICO_TIME = 58016 -const PS_CURRENT_THREAD_ID = 58017 -const PS_THREAD_ID = 58018 -const GTID_SUBSET = 58019 -const GTID_SUBTRACT = 58020 -const WAIT_FOR_EXECUTED_GTID_SET = 58021 -const WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS = 58022 -const FORMAT = 58023 -const TREE = 58024 -const VITESS = 58025 -const TRADITIONAL = 58026 -const VTEXPLAIN = 58027 -const VEXPLAIN = 58028 -const PLAN = 58029 -const LOCAL = 58030 -const LOW_PRIORITY = 58031 -const NO_WRITE_TO_BINLOG = 58032 -const LOGS = 58033 -const ERROR = 58034 -const GENERAL = 58035 -const HOSTS = 58036 -const OPTIMIZER_COSTS = 58037 -const USER_RESOURCES = 58038 -const SLOW = 58039 -const CHANNEL = 58040 -const RELAY = 58041 -const EXPORT = 58042 -const CURRENT = 58043 -const ROW = 58044 -const ROWS = 58045 -const AVG_ROW_LENGTH = 58046 -const CONNECTION = 58047 -const CHECKSUM = 58048 -const DELAY_KEY_WRITE = 58049 -const ENCRYPTION = 58050 -const ENGINE = 58051 -const INSERT_METHOD = 58052 -const MAX_ROWS = 58053 -const MIN_ROWS = 58054 -const PACK_KEYS = 58055 -const PASSWORD = 58056 -const FIXED = 58057 -const DYNAMIC = 58058 -const COMPRESSED = 58059 -const REDUNDANT = 58060 -const COMPACT = 58061 -const ROW_FORMAT = 58062 -const STATS_AUTO_RECALC = 58063 -const STATS_PERSISTENT = 58064 -const STATS_SAMPLE_PAGES = 58065 -const STORAGE = 58066 -const MEMORY = 58067 -const DISK = 58068 -const PARTITIONS = 58069 -const LINEAR = 58070 -const RANGE = 58071 -const LIST = 58072 -const SUBPARTITION = 58073 -const SUBPARTITIONS = 58074 -const HASH = 58075 +const CUTOVER_THRESHOLD = 57651 +const EXPIRE = 57652 +const RATIO = 57653 +const VITESS_THROTTLER = 57654 +const BEGIN = 57655 +const START = 57656 +const TRANSACTION = 57657 +const COMMIT = 57658 +const ROLLBACK = 57659 +const SAVEPOINT = 57660 +const RELEASE = 57661 +const WORK = 57662 +const CONSISTENT = 57663 +const SNAPSHOT = 57664 +const UNRESOLVED = 57665 +const TRANSACTIONS = 57666 +const BIT = 57667 +const TINYINT = 57668 +const SMALLINT = 57669 +const MEDIUMINT = 57670 +const INT = 57671 +const INTEGER = 57672 +const BIGINT = 57673 +const INTNUM = 57674 +const REAL = 57675 +const DOUBLE = 57676 +const FLOAT_TYPE = 57677 +const FLOAT4_TYPE = 57678 +const FLOAT8_TYPE = 57679 +const DECIMAL_TYPE = 57680 +const NUMERIC = 57681 +const TIME = 57682 +const TIMESTAMP = 57683 +const DATETIME = 57684 +const YEAR = 57685 +const CHAR = 57686 +const VARCHAR = 57687 +const BOOL = 57688 +const CHARACTER = 57689 +const VARBINARY = 57690 +const NCHAR = 57691 +const TEXT = 57692 +const TINYTEXT = 57693 +const MEDIUMTEXT = 57694 +const LONGTEXT = 57695 +const BLOB = 57696 +const TINYBLOB = 57697 +const MEDIUMBLOB = 57698 +const LONGBLOB = 57699 +const JSON = 57700 +const JSON_SCHEMA_VALID = 57701 +const JSON_SCHEMA_VALIDATION_REPORT = 57702 +const ENUM = 57703 +const GEOMETRY = 57704 +const POINT = 57705 +const LINESTRING = 57706 +const POLYGON = 57707 +const GEOMCOLLECTION = 57708 +const GEOMETRYCOLLECTION = 57709 +const MULTIPOINT = 57710 +const MULTILINESTRING = 57711 +const MULTIPOLYGON = 57712 +const ASCII = 57713 +const UNICODE = 57714 +const VECTOR = 57715 +const NULLX = 57716 +const AUTO_INCREMENT = 57717 +const APPROXNUM = 57718 +const SIGNED = 57719 +const UNSIGNED = 57720 +const ZEROFILL = 57721 +const PURGE = 57722 +const BEFORE = 57723 +const CODE = 57724 +const COLLATION = 57725 +const COLUMNS = 57726 +const DATABASES = 57727 +const ENGINES = 57728 +const EVENT = 57729 +const EXTENDED = 57730 +const FIELDS = 57731 +const FULL = 57732 +const FUNCTION = 57733 +const GTID_EXECUTED = 57734 +const KEYSPACES = 57735 +const OPEN = 57736 +const PLUGINS = 57737 +const PRIVILEGES = 57738 +const PROCESSLIST = 57739 +const SCHEMAS = 57740 +const TABLES = 57741 +const TRIGGERS = 57742 +const USER = 57743 +const VGTID_EXECUTED = 57744 +const VITESS_KEYSPACES = 57745 +const VITESS_METADATA = 57746 +const VITESS_MIGRATIONS = 57747 +const VITESS_REPLICATION_STATUS = 57748 +const VITESS_SHARDS = 57749 +const VITESS_TABLETS = 57750 +const VITESS_TARGET = 57751 +const VSCHEMA = 57752 +const VITESS_THROTTLED_APPS = 57753 +const NAMES = 57754 +const GLOBAL = 57755 +const SESSION = 57756 +const ISOLATION = 57757 +const LEVEL = 57758 +const READ = 57759 +const WRITE = 57760 +const ONLY = 57761 +const REPEATABLE = 57762 +const COMMITTED = 57763 +const UNCOMMITTED = 57764 +const SERIALIZABLE = 57765 +const ADDDATE = 57766 +const CURRENT_TIMESTAMP = 57767 +const DATABASE = 57768 +const CURRENT_DATE = 57769 +const CURDATE = 57770 +const DATE_ADD = 57771 +const DATE_SUB = 57772 +const NOW = 57773 +const SUBDATE = 57774 +const CURTIME = 57775 +const CURRENT_TIME = 57776 +const LOCALTIME = 57777 +const LOCALTIMESTAMP = 57778 +const CURRENT_USER = 57779 +const UTC_DATE = 57780 +const UTC_TIME = 57781 +const UTC_TIMESTAMP = 57782 +const SYSDATE = 57783 +const DAY = 57784 +const DAY_HOUR = 57785 +const DAY_MICROSECOND = 57786 +const DAY_MINUTE = 57787 +const DAY_SECOND = 57788 +const HOUR = 57789 +const HOUR_MICROSECOND = 57790 +const HOUR_MINUTE = 57791 +const HOUR_SECOND = 57792 +const MICROSECOND = 57793 +const MINUTE = 57794 +const MINUTE_MICROSECOND = 57795 +const MINUTE_SECOND = 57796 +const MONTH = 57797 +const QUARTER = 57798 +const SECOND = 57799 +const SECOND_MICROSECOND = 57800 +const YEAR_MONTH = 57801 +const WEEK = 57802 +const SQL_TSI_DAY = 57803 +const SQL_TSI_WEEK = 57804 +const SQL_TSI_HOUR = 57805 +const SQL_TSI_MINUTE = 57806 +const SQL_TSI_MONTH = 57807 +const SQL_TSI_QUARTER = 57808 +const SQL_TSI_SECOND = 57809 +const SQL_TSI_MICROSECOND = 57810 +const SQL_TSI_YEAR = 57811 +const REPLACE = 57812 +const CONVERT = 57813 +const CAST = 57814 +const SUBSTR = 57815 +const SUBSTRING = 57816 +const MID = 57817 +const SEPARATOR = 57818 +const TIMESTAMPADD = 57819 +const TIMESTAMPDIFF = 57820 +const WEIGHT_STRING = 57821 +const LTRIM = 57822 +const RTRIM = 57823 +const TRIM = 57824 +const JSON_ARRAY = 57825 +const JSON_OBJECT = 57826 +const JSON_QUOTE = 57827 +const JSON_DEPTH = 57828 +const JSON_TYPE = 57829 +const JSON_LENGTH = 57830 +const JSON_VALID = 57831 +const JSON_ARRAY_APPEND = 57832 +const JSON_ARRAY_INSERT = 57833 +const JSON_INSERT = 57834 +const JSON_MERGE = 57835 +const JSON_MERGE_PATCH = 57836 +const JSON_MERGE_PRESERVE = 57837 +const JSON_REMOVE = 57838 +const JSON_REPLACE = 57839 +const JSON_SET = 57840 +const JSON_UNQUOTE = 57841 +const COUNT = 57842 +const AVG = 57843 +const MAX = 57844 +const MIN = 57845 +const SUM = 57846 +const GROUP_CONCAT = 57847 +const BIT_AND = 57848 +const BIT_OR = 57849 +const BIT_XOR = 57850 +const STD = 57851 +const STDDEV = 57852 +const STDDEV_POP = 57853 +const STDDEV_SAMP = 57854 +const VAR_POP = 57855 +const VAR_SAMP = 57856 +const VARIANCE = 57857 +const ANY_VALUE = 57858 +const REGEXP_INSTR = 57859 +const REGEXP_LIKE = 57860 +const REGEXP_REPLACE = 57861 +const REGEXP_SUBSTR = 57862 +const ExtractValue = 57863 +const UpdateXML = 57864 +const GET_LOCK = 57865 +const RELEASE_LOCK = 57866 +const RELEASE_ALL_LOCKS = 57867 +const IS_FREE_LOCK = 57868 +const IS_USED_LOCK = 57869 +const LOCATE = 57870 +const POSITION = 57871 +const ST_GeometryCollectionFromText = 57872 +const ST_GeometryFromText = 57873 +const ST_LineStringFromText = 57874 +const ST_MultiLineStringFromText = 57875 +const ST_MultiPointFromText = 57876 +const ST_MultiPolygonFromText = 57877 +const ST_PointFromText = 57878 +const ST_PolygonFromText = 57879 +const ST_GeometryCollectionFromWKB = 57880 +const ST_GeometryFromWKB = 57881 +const ST_LineStringFromWKB = 57882 +const ST_MultiLineStringFromWKB = 57883 +const ST_MultiPointFromWKB = 57884 +const ST_MultiPolygonFromWKB = 57885 +const ST_PointFromWKB = 57886 +const ST_PolygonFromWKB = 57887 +const ST_AsBinary = 57888 +const ST_AsText = 57889 +const ST_Dimension = 57890 +const ST_Envelope = 57891 +const ST_IsSimple = 57892 +const ST_IsEmpty = 57893 +const ST_GeometryType = 57894 +const ST_X = 57895 +const ST_Y = 57896 +const ST_Latitude = 57897 +const ST_Longitude = 57898 +const ST_EndPoint = 57899 +const ST_IsClosed = 57900 +const ST_Length = 57901 +const ST_NumPoints = 57902 +const ST_StartPoint = 57903 +const ST_PointN = 57904 +const ST_Area = 57905 +const ST_Centroid = 57906 +const ST_ExteriorRing = 57907 +const ST_InteriorRingN = 57908 +const ST_NumInteriorRings = 57909 +const ST_NumGeometries = 57910 +const ST_GeometryN = 57911 +const ST_LongFromGeoHash = 57912 +const ST_PointFromGeoHash = 57913 +const ST_LatFromGeoHash = 57914 +const ST_GeoHash = 57915 +const ST_AsGeoJSON = 57916 +const ST_GeomFromGeoJSON = 57917 +const MATCH = 57918 +const AGAINST = 57919 +const BOOLEAN = 57920 +const LANGUAGE = 57921 +const WITH = 57922 +const QUERY = 57923 +const EXPANSION = 57924 +const WITHOUT = 57925 +const VALIDATION = 57926 +const ROLLUP = 57927 +const UNUSED = 57928 +const ARRAY = 57929 +const BYTE = 57930 +const CUME_DIST = 57931 +const DESCRIPTION = 57932 +const DENSE_RANK = 57933 +const EMPTY = 57934 +const EXCEPT = 57935 +const FIRST_VALUE = 57936 +const GROUPING = 57937 +const GROUPS = 57938 +const JSON_TABLE = 57939 +const LAG = 57940 +const LAST_VALUE = 57941 +const LATERAL = 57942 +const LEAD = 57943 +const NTH_VALUE = 57944 +const NTILE = 57945 +const OF = 57946 +const OVER = 57947 +const PERCENT_RANK = 57948 +const RANK = 57949 +const RECURSIVE = 57950 +const ROW_NUMBER = 57951 +const SYSTEM = 57952 +const WINDOW = 57953 +const ACTIVE = 57954 +const ADMIN = 57955 +const AUTOEXTEND_SIZE = 57956 +const BUCKETS = 57957 +const CLONE = 57958 +const COLUMN_FORMAT = 57959 +const COMPONENT = 57960 +const DEFINITION = 57961 +const ENFORCED = 57962 +const ENGINE_ATTRIBUTE = 57963 +const EXCLUDE = 57964 +const FOLLOWING = 57965 +const GET_MASTER_PUBLIC_KEY = 57966 +const HISTOGRAM = 57967 +const HISTORY = 57968 +const INACTIVE = 57969 +const INVISIBLE = 57970 +const LOCKED = 57971 +const MASTER_COMPRESSION_ALGORITHMS = 57972 +const MASTER_PUBLIC_KEY_PATH = 57973 +const MASTER_TLS_CIPHERSUITES = 57974 +const MASTER_ZSTD_COMPRESSION_LEVEL = 57975 +const NESTED = 57976 +const NETWORK_NAMESPACE = 57977 +const NOWAIT = 57978 +const NULLS = 57979 +const OJ = 57980 +const OLD = 57981 +const OPTIONAL = 57982 +const ORDINALITY = 57983 +const ORGANIZATION = 57984 +const OTHERS = 57985 +const PARTIAL = 57986 +const PATH = 57987 +const PERSIST = 57988 +const PERSIST_ONLY = 57989 +const PRECEDING = 57990 +const PRIVILEGE_CHECKS_USER = 57991 +const PROCESS = 57992 +const RANDOM = 57993 +const REFERENCE = 57994 +const REQUIRE_ROW_FORMAT = 57995 +const RESOURCE = 57996 +const RESPECT = 57997 +const RESTART = 57998 +const RETAIN = 57999 +const REUSE = 58000 +const ROLE = 58001 +const SECONDARY = 58002 +const SECONDARY_ENGINE = 58003 +const SECONDARY_ENGINE_ATTRIBUTE = 58004 +const SECONDARY_LOAD = 58005 +const SECONDARY_UNLOAD = 58006 +const SIMPLE = 58007 +const SKIP = 58008 +const SRID = 58009 +const THREAD_PRIORITY = 58010 +const TIES = 58011 +const UNBOUNDED = 58012 +const VCPU = 58013 +const VISIBLE = 58014 +const RETURNING = 58015 +const FORMAT_BYTES = 58016 +const FORMAT_PICO_TIME = 58017 +const PS_CURRENT_THREAD_ID = 58018 +const PS_THREAD_ID = 58019 +const GTID_SUBSET = 58020 +const GTID_SUBTRACT = 58021 +const WAIT_FOR_EXECUTED_GTID_SET = 58022 +const WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS = 58023 +const FORMAT = 58024 +const TREE = 58025 +const VITESS = 58026 +const TRADITIONAL = 58027 +const VTEXPLAIN = 58028 +const VEXPLAIN = 58029 +const PLAN = 58030 +const LOCAL = 58031 +const LOW_PRIORITY = 58032 +const NO_WRITE_TO_BINLOG = 58033 +const LOGS = 58034 +const ERROR = 58035 +const GENERAL = 58036 +const HOSTS = 58037 +const OPTIMIZER_COSTS = 58038 +const USER_RESOURCES = 58039 +const SLOW = 58040 +const CHANNEL = 58041 +const RELAY = 58042 +const EXPORT = 58043 +const CURRENT = 58044 +const ROW = 58045 +const ROWS = 58046 +const AVG_ROW_LENGTH = 58047 +const CONNECTION = 58048 +const CHECKSUM = 58049 +const DELAY_KEY_WRITE = 58050 +const ENCRYPTION = 58051 +const ENGINE = 58052 +const INSERT_METHOD = 58053 +const MAX_ROWS = 58054 +const MIN_ROWS = 58055 +const PACK_KEYS = 58056 +const PASSWORD = 58057 +const FIXED = 58058 +const DYNAMIC = 58059 +const COMPRESSED = 58060 +const REDUNDANT = 58061 +const COMPACT = 58062 +const ROW_FORMAT = 58063 +const STATS_AUTO_RECALC = 58064 +const STATS_PERSISTENT = 58065 +const STATS_SAMPLE_PAGES = 58066 +const STORAGE = 58067 +const MEMORY = 58068 +const DISK = 58069 +const PARTITIONS = 58070 +const LINEAR = 58071 +const RANGE = 58072 +const LIST = 58073 +const SUBPARTITION = 58074 +const SUBPARTITIONS = 58075 +const HASH = 58076 var yyToknames = [...]string{ "$end", @@ -1092,6 +1093,7 @@ var yyToknames = [...]string{ "THROTTLE", "UNTHROTTLE", "FORCE_CUTOVER", + "CUTOVER_THRESHOLD", "EXPIRE", "RATIO", "VITESS_THROTTLER", @@ -1537,29 +1539,29 @@ var yyExca = [...]int{ -2, 40, -1, 52, 1, 157, - 751, 157, + 752, 157, -2, 165, -1, 53, 149, 165, 191, 165, - 363, 165, + 364, 165, -2, 523, -1, 61, - 38, 783, - 254, 783, - 265, 783, - 300, 797, - 301, 797, - -2, 785, + 38, 784, + 254, 784, + 265, 784, + 300, 798, + 301, 798, + -2, 786, -1, 66, - 256, 821, - -2, 819, + 256, 822, + -2, 820, -1, 122, - 253, 1620, + 253, 1621, -2, 131, -1, 124, 1, 158, - 751, 158, + 752, 158, -2, 165, -1, 135, 150, 408, @@ -1568,214 +1570,214 @@ var yyExca = [...]int{ -1, 154, 149, 165, 191, 165, - 363, 165, + 364, 165, -2, 532, - -1, 748, + -1, 749, 177, 41, -2, 43, - -1, 957, - 95, 1637, - -2, 1481, -1, 958, 95, 1638, - 236, 1642, -2, 1482, -1, 959, - 236, 1641, + 95, 1639, + 236, 1643, + -2, 1483, + -1, 960, + 236, 1642, -2, 42, - -1, 1043, - 65, 895, - -2, 908, - -1, 1131, - 264, 1108, - 269, 1108, + -1, 1044, + 65, 896, + -2, 909, + -1, 1132, + 264, 1109, + 269, 1109, -2, 419, - -1, 1216, + -1, 1217, 1, 580, - 751, 580, + 752, 580, -2, 165, - -1, 1527, - 236, 1642, - -2, 1482, - -1, 1739, - 65, 896, - -2, 912, + -1, 1528, + 236, 1643, + -2, 1483, -1, 1740, 65, 897, -2, 913, - -1, 1800, + -1, 1741, + 65, 898, + -2, 914, + -1, 1801, 149, 165, 191, 165, - 363, 165, + 364, 165, -2, 458, - -1, 1883, + -1, 1884, 150, 408, 259, 408, -2, 512, - -1, 1892, - 264, 1109, - 269, 1109, + -1, 1893, + 264, 1110, + 269, 1110, -2, 420, - -1, 2341, - 236, 1646, - -2, 1640, -1, 2342, - 236, 1642, - -2, 1638, - -1, 2445, + 236, 1647, + -2, 1641, + -1, 2343, + 236, 1643, + -2, 1639, + -1, 2446, 149, 165, 191, 165, - 363, 165, + 364, 165, -2, 459, - -1, 2452, + -1, 2453, 28, 186, -2, 188, - -1, 2915, + -1, 2917, 86, 96, 96, 96, - -2, 975, - -1, 2983, - 726, 701, - -2, 675, - -1, 3207, - 55, 1585, - -2, 1579, - -1, 4044, - 726, 701, - -2, 689, - -1, 4136, - 98, 633, - 104, 633, - 114, 633, - 193, 633, - 194, 633, - 195, 633, - 196, 633, - 197, 633, - 198, 633, - 199, 633, - 200, 633, - 201, 633, - 202, 633, - 203, 633, - 204, 633, - 205, 633, - 206, 633, - 207, 633, - 208, 633, - 209, 633, - 210, 633, - 211, 633, - 212, 633, - 213, 633, - 214, 633, - 215, 633, - 216, 633, - 217, 633, - 218, 633, - 219, 633, - 220, 633, - 221, 633, - 222, 633, - 223, 633, - 224, 633, - 225, 633, - 226, 633, - 227, 633, - 228, 633, - 229, 633, - 230, 633, - 231, 633, - 232, 633, - 233, 633, - 234, 633, - -2, 2017, + -2, 976, + -1, 2985, + 727, 702, + -2, 676, + -1, 3210, + 55, 1586, + -2, 1580, + -1, 4047, + 727, 702, + -2, 690, + -1, 4139, + 98, 634, + 104, 634, + 114, 634, + 193, 634, + 194, 634, + 195, 634, + 196, 634, + 197, 634, + 198, 634, + 199, 634, + 200, 634, + 201, 634, + 202, 634, + 203, 634, + 204, 634, + 205, 634, + 206, 634, + 207, 634, + 208, 634, + 209, 634, + 210, 634, + 211, 634, + 212, 634, + 213, 634, + 214, 634, + 215, 634, + 216, 634, + 217, 634, + 218, 634, + 219, 634, + 220, 634, + 221, 634, + 222, 634, + 223, 634, + 224, 634, + 225, 634, + 226, 634, + 227, 634, + 228, 634, + 229, 634, + 230, 634, + 231, 634, + 232, 634, + 233, 634, + 234, 634, + -2, 2019, } const yyPrivate = 57344 -const yyLast = 56607 +const yyLast = 57002 var yyAct = [...]int{ - 973, 3695, 3696, 87, 3694, 4025, 4179, 4211, 961, 4115, - 4134, 2146, 3358, 2370, 4007, 4224, 4103, 1282, 4178, 1284, - 968, 3644, 960, 2134, 3259, 2442, 3266, 2072, 3930, 3220, - 5, 3307, 3494, 3316, 3321, 4005, 3318, 3317, 3315, 3320, - 3319, 3073, 3631, 2372, 3158, 3336, 3274, 2517, 2013, 752, - 3335, 3224, 3221, 3534, 3047, 3072, 3540, 3218, 2875, 3737, - 2397, 747, 3338, 3208, 3524, 2480, 746, 922, 2949, 3365, - 1860, 1803, 780, 3029, 2504, 2980, 2485, 1759, 1093, 4076, - 921, 2951, 2950, 2430, 163, 2413, 1041, 2548, 87, 2881, - 2418, 1061, 1038, 1068, 2867, 1908, 2851, 2900, 2326, 2416, - 926, 41, 1163, 42, 1139, 2130, 2294, 1041, 2080, 2417, - 2293, 2526, 3021, 2503, 43, 3562, 2168, 2405, 1890, 2487, - 2565, 2942, 1103, 1126, 1121, 149, 1792, 2917, 1772, 2420, - 100, 1720, 1540, 2174, 104, 105, 2105, 2094, 1465, 1448, - 2009, 1897, 1100, 1097, 1869, 3223, 762, 1132, 1989, 2476, - 1101, 1127, 1128, 1791, 2477, 1777, 1078, 1129, 757, 1080, - 1742, 1050, 2201, 1523, 2182, 2888, 3732, 1499, 749, 1047, - 2849, 2071, 85, 107, 1272, 2021, 167, 127, 2398, 125, - 126, 3495, 1882, 1060, 132, 3724, 1040, 133, 1044, 1045, - 1073, 1212, 93, 923, 3551, 99, 1549, 1036, 1048, 98, - 4212, 750, 1046, 739, 1544, 3632, 1072, 1063, 1280, 3304, - 2519, 1258, 84, 2519, 2520, 2521, 4060, 3003, 3002, 2563, - 2971, 106, 1466, 3624, 1035, 4161, 3037, 3038, 3587, 128, - 1053, 4055, 4056, 2367, 2368, 2087, 134, 3699, 3699, 1168, - 682, 1143, 4061, 1094, 2086, 2085, 2084, 2083, 2082, 2052, - 1228, 679, 2847, 680, 1165, 2616, 3204, 3162, 4234, 2552, - 4177, 4182, 4202, 1176, 4155, 1110, 1105, 1182, 1183, 1184, - 3498, 1187, 1188, 1189, 1190, 1087, 740, 1193, 1194, 1195, - 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, - 1206, 1207, 1208, 1209, 1142, 1088, 1054, 1763, 1039, 1062, - 1753, 128, 1117, 2551, 1116, 1115, 1037, 1118, 2, 1761, - 1482, 95, 3326, 1169, 1172, 1173, 1974, 4034, 95, 2877, - 724, 3497, 3326, 1229, 2394, 4217, 2973, 1764, 1462, 2393, - 1476, 1459, 4056, 3698, 3698, 3323, 2996, 4008, 724, 1762, - 2391, 2812, 95, 4165, 2092, 3384, 1185, 4130, 2993, 1034, - 4216, 4163, 927, 111, 112, 113, 3926, 116, 3925, 1167, - 122, 718, 2108, 191, 1166, 4192, 674, 95, 4164, 128, - 190, 3936, 3324, 1086, 1090, 925, 4162, 3637, 737, 738, - 3638, 4159, 3324, 86, 976, 977, 978, 718, 1029, 1030, - 1031, 1032, 86, 129, 3656, 1043, 86, 1450, 3645, 4104, - 4112, 3330, 2545, 1119, 2623, 3935, 2891, 2139, 4139, 172, - 3410, 3330, 976, 977, 978, 1871, 3256, 3257, 2848, 1086, - 1090, 925, 718, 1075, 1076, 2926, 3655, 1793, 2925, 1794, - 713, 2927, 2437, 2438, 2892, 3255, 1461, 3036, 4116, 2064, - 2065, 2620, 1472, 2550, 2436, 1464, 3020, 3751, 1248, 1253, - 1254, 1277, 1027, 1026, 4026, 2931, 2974, 1211, 1236, 1479, - 1249, 1480, 1481, 1237, 1242, 2938, 95, 718, 718, 169, - 718, 1478, 170, 2017, 2621, 95, 2455, 2454, 698, 95, - 1236, 718, 3362, 3360, 3392, 1237, 1114, 3094, 1221, 1222, - 3390, 696, 4144, 1235, 1443, 1234, 2884, 2885, 189, 2614, - 2063, 732, 2067, 736, 4039, 1995, 2369, 2210, 730, 718, - 2401, 3366, 4142, 1724, 4120, 4183, 3327, 3022, 2572, 2527, - 1224, 2496, 4148, 4149, 2401, 86, 3327, 1789, 88, 2981, - 1964, 693, 3276, 3277, 2566, 3978, 4184, 3979, 3006, 4143, - 708, 1460, 4120, 1466, 1112, 2490, 3353, 1990, 2590, 4214, - 2591, 1186, 2592, 1269, 3354, 703, 1442, 1255, 1250, 1274, - 1449, 1257, 1243, 1500, 1276, 1217, 706, 1256, 2570, 716, - 1275, 1251, 1252, 2573, 1965, 719, 1966, 717, 3363, 3361, - 2617, 3024, 2618, 2568, 3626, 3381, 3625, 1501, 1502, 1503, - 1504, 1505, 1506, 1507, 1509, 1508, 1510, 1511, 2593, 1192, - 1191, 719, 3910, 1727, 1079, 1152, 2202, 1141, 95, 1141, - 2569, 2204, 1150, 173, 2018, 2209, 2205, 2530, 3622, 2206, - 2207, 2208, 179, 2571, 2203, 2211, 2212, 2213, 2214, 2215, - 2216, 2217, 2218, 2219, 1122, 3703, 719, 683, 1123, 685, - 699, 3275, 721, 2414, 720, 689, 1123, 687, 691, 700, - 692, 1476, 686, 3278, 697, 3095, 1875, 688, 701, 702, - 705, 709, 710, 711, 707, 704, 4156, 695, 722, 1162, - 1161, 3161, 3010, 1514, 3011, 1160, 1113, 1159, 1158, 3537, - 1157, 719, 719, 1156, 719, 2579, 2575, 2577, 2578, 2576, - 2580, 2581, 2582, 1155, 1154, 719, 3278, 1149, 2489, 4235, - 4189, 1089, 1083, 1081, 1098, 2399, 2400, 1098, 1171, 1135, - 1140, 1096, 1140, 1281, 1134, 1281, 1281, 1098, 1170, 2399, - 2400, 1134, 2010, 719, 1074, 1999, 1870, 1997, 1998, 1996, - 2000, 2001, 2002, 3621, 3025, 2556, 2555, 2006, 1471, 1468, - 1469, 1470, 1475, 1477, 1474, 1451, 1473, 1089, 1083, 1081, - 164, 3189, 1179, 3187, 3298, 1153, 1467, 3005, 1790, 3041, - 1868, 2975, 1151, 1472, 1867, 1041, 1524, 1529, 1530, 1866, - 1533, 1535, 1536, 1537, 1538, 1539, 2991, 1542, 1543, 1545, - 1545, 2007, 1545, 1545, 1550, 1550, 1550, 1553, 1554, 1555, + 974, 3698, 3699, 87, 3697, 4137, 4214, 4028, 4118, 3361, + 4227, 4181, 4106, 3647, 4182, 969, 1285, 961, 3262, 2135, + 2014, 2443, 2170, 3269, 2371, 1283, 3497, 4010, 2147, 3933, + 3319, 3310, 3324, 3321, 3320, 3318, 3323, 3322, 2073, 3223, + 4008, 5, 3634, 2373, 3161, 3076, 3339, 3277, 2518, 753, + 3338, 3227, 3224, 3543, 962, 3221, 3740, 3050, 3537, 923, + 747, 3211, 2877, 3075, 1804, 2398, 2481, 781, 2414, 1760, + 748, 2951, 4079, 3032, 3368, 1861, 3527, 2417, 2982, 922, + 3341, 2505, 2486, 3565, 2952, 2549, 1042, 1164, 87, 163, + 1094, 927, 2953, 2431, 42, 1062, 1039, 743, 2883, 1069, + 1909, 2902, 2419, 2869, 41, 2418, 2853, 1042, 2327, 2294, + 2169, 2295, 2131, 3023, 2527, 149, 43, 1891, 2504, 2081, + 2406, 2488, 1104, 2944, 1122, 2566, 1127, 1793, 2919, 1773, + 2421, 1721, 2890, 1541, 2175, 100, 2106, 2095, 104, 105, + 1466, 1449, 1898, 2010, 1101, 1098, 3226, 763, 1133, 1870, + 1102, 2477, 1990, 1128, 1130, 1129, 2478, 1792, 1079, 1778, + 1081, 1051, 758, 1140, 750, 2399, 1743, 2183, 3735, 2202, + 1048, 2851, 1524, 85, 2072, 2022, 1061, 1041, 107, 1045, + 3727, 1500, 99, 1273, 167, 3554, 3498, 1883, 127, 125, + 126, 132, 1046, 1213, 1037, 133, 924, 1049, 1064, 751, + 1074, 84, 1545, 98, 1047, 106, 4215, 1281, 3635, 3307, + 1259, 740, 1073, 93, 2520, 2521, 2522, 4063, 1550, 2520, + 3005, 3004, 2564, 2973, 3627, 1036, 4164, 683, 3040, 3590, + 3041, 4059, 2368, 2369, 4058, 1054, 2088, 128, 2087, 1166, + 2086, 134, 2085, 4064, 1169, 2084, 1095, 3329, 2083, 2053, + 1229, 4158, 1183, 1184, 1185, 2849, 1188, 1189, 1190, 1191, + 3326, 2618, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, + 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1088, + 3207, 4185, 1089, 1055, 741, 2, 680, 1040, 681, 1764, + 1038, 1143, 95, 1975, 1119, 2553, 1762, 3702, 3702, 3329, + 1144, 2879, 4220, 725, 3165, 1111, 2392, 3327, 4237, 128, + 1170, 1173, 1174, 1118, 1117, 1116, 95, 4037, 95, 1765, + 1063, 1463, 1177, 1106, 1460, 2975, 1763, 4219, 4180, 1230, + 111, 112, 113, 1186, 116, 4059, 3333, 122, 725, 2552, + 191, 1483, 95, 675, 4205, 3501, 928, 3500, 4168, 4166, + 1035, 2395, 2394, 2995, 2998, 738, 739, 190, 4011, 3327, + 719, 1754, 2109, 2814, 2093, 1030, 1031, 1032, 1033, 1087, + 1091, 926, 1044, 4167, 4165, 3387, 4133, 128, 3929, 3928, + 129, 1168, 190, 1167, 977, 978, 979, 719, 3333, 977, + 978, 979, 3640, 3701, 3701, 3641, 172, 1451, 4195, 3939, + 1076, 1077, 1120, 4147, 86, 129, 1087, 1091, 926, 4162, + 3659, 3648, 4107, 4115, 2546, 86, 86, 3938, 719, 2625, + 2140, 172, 4142, 4145, 3413, 1872, 3012, 2850, 3013, 1462, + 714, 3259, 3260, 4151, 4152, 2551, 2438, 2439, 4119, 2893, + 3258, 1479, 2933, 3279, 3280, 1794, 1115, 1795, 1222, 1223, + 4146, 3330, 2065, 2066, 3039, 719, 169, 3658, 2928, 170, + 2622, 2927, 2437, 3022, 2929, 1278, 3754, 2894, 1254, 1255, + 1249, 1028, 1110, 1027, 1237, 1112, 4029, 2940, 699, 1238, + 1225, 169, 1250, 1243, 170, 189, 2018, 95, 719, 2623, + 1480, 697, 1481, 1482, 2456, 2455, 3365, 1212, 95, 95, + 719, 3395, 1237, 3330, 1113, 2370, 719, 1238, 3363, 4042, + 189, 2886, 2887, 1444, 4123, 1236, 2616, 1235, 3393, 4123, + 2068, 1790, 2064, 733, 737, 731, 3097, 3369, 2528, 3024, + 1187, 694, 1996, 1725, 1461, 4186, 3981, 3356, 3982, 2983, + 709, 3008, 2567, 2402, 2573, 3357, 1965, 86, 4217, 2592, + 88, 2593, 3278, 2594, 1991, 704, 4187, 1266, 1270, 1268, + 1450, 1252, 1253, 2569, 3281, 1443, 1275, 707, 2211, 1218, + 717, 1258, 2497, 3027, 1115, 720, 1107, 1256, 718, 1277, + 3913, 1251, 1244, 1109, 1108, 1276, 2619, 1257, 2620, 1501, + 1966, 3629, 1967, 3366, 3628, 2595, 2491, 1265, 1267, 2574, + 173, 1080, 720, 3625, 1142, 3364, 1142, 1193, 1192, 179, + 1153, 3384, 1151, 1502, 1503, 1504, 1505, 1506, 1507, 1508, + 1510, 1509, 1511, 1512, 2531, 173, 1728, 1123, 2019, 2571, + 95, 1124, 1113, 720, 179, 3281, 3706, 1114, 684, 2415, + 686, 700, 1124, 722, 1162, 721, 690, 1161, 688, 692, + 701, 693, 1160, 687, 4159, 698, 1159, 1158, 689, 702, + 703, 706, 710, 711, 712, 708, 705, 2203, 696, 723, + 720, 2570, 2205, 1157, 1156, 1155, 2210, 2206, 1150, 1876, + 2207, 2208, 2209, 1163, 2572, 2204, 2212, 2213, 2214, 2215, + 2216, 2217, 2218, 2219, 2220, 3098, 3540, 1099, 1090, 1084, + 1082, 1099, 1136, 720, 2976, 1097, 4238, 1141, 1263, 1141, + 4192, 1099, 1264, 1075, 1282, 720, 1282, 1282, 3624, 3164, + 1135, 720, 1269, 2580, 2576, 2578, 2579, 2577, 2581, 2582, + 2583, 2584, 2011, 1871, 3028, 1090, 1084, 1082, 164, 2400, + 2401, 2557, 3173, 2556, 2007, 1452, 1180, 1262, 3192, 2490, + 3190, 3301, 2000, 1791, 1998, 1999, 1997, 2001, 2002, 2003, + 1154, 3007, 1152, 164, 1869, 1114, 1042, 1525, 1530, 1531, + 1868, 1534, 1536, 1537, 1538, 1539, 1540, 1867, 1543, 1544, + 1546, 1546, 3010, 1546, 1546, 1551, 1551, 1551, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, @@ -1788,1079 +1790,1090 @@ var yyAct = [...]int{ 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, - 1676, 1521, 3697, 3697, 1270, 1677, 4033, 1679, 1680, 1681, - 1682, 1683, 2549, 1440, 1441, 2972, 3585, 3586, 1439, 1550, - 1550, 1550, 1550, 1550, 1550, 974, 2940, 1120, 3654, 1534, - 1223, 1220, 974, 723, 1690, 1691, 1692, 1693, 1694, 1695, - 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 2995, 1525, - 1517, 1518, 1519, 1520, 714, 4118, 974, 94, 1514, 2621, - 1531, 4079, 2852, 2854, 2622, 1717, 94, 1864, 1082, 715, - 94, 1551, 1552, 1227, 1546, 1896, 1547, 1548, 3538, 165, - 3328, 3329, 1215, 4118, 1458, 3482, 177, 4117, 1141, 89, - 3328, 3329, 2994, 3332, 1233, 3382, 673, 1232, 4157, 1238, - 1239, 1240, 1241, 3332, 1976, 1975, 1977, 1978, 1979, 3170, - 3019, 1515, 1516, 3018, 1082, 4117, 4147, 3008, 2547, 1723, - 4021, 2493, 190, 1278, 1279, 3576, 3558, 185, 1041, 2922, - 1752, 3028, 1041, 2887, 1141, 2824, 1246, 1109, 1041, 2142, - 1111, 1265, 1781, 1267, 2638, 129, 1678, 1226, 3169, 1471, - 1468, 1469, 1470, 1475, 1477, 1474, 4228, 1473, 2882, 681, - 4146, 172, 2494, 2443, 1714, 1715, 1178, 1467, 2166, 2492, - 166, 171, 168, 174, 175, 176, 178, 180, 181, 182, - 183, 1264, 1266, 1141, 1895, 1514, 184, 186, 187, 188, - 124, 1140, 1506, 1507, 1509, 1508, 1510, 1511, 1994, 94, - 1511, 3254, 2649, 2495, 1259, 1141, 1753, 1494, 2183, 1057, - 119, 2022, 1273, 2491, 4047, 1684, 1685, 1686, 1687, 1688, - 1689, 169, 1733, 1734, 170, 2184, 104, 105, 1731, 1164, - 3031, 3617, 1735, 1715, 3550, 3030, 2853, 1140, 1040, 1114, - 2110, 1106, 1144, 1134, 1114, 1210, 1721, 1146, 1108, 1107, - 189, 1147, 1145, 2567, 2111, 1512, 1513, 2109, 1141, 2076, - 2003, 1795, 2175, 1231, 3068, 107, 4193, 2158, 2147, 2148, - 2149, 2150, 2160, 2151, 2152, 2153, 2165, 2161, 2154, 2155, - 2162, 2163, 2164, 2156, 2157, 2159, 1140, 1482, 120, 1141, - 2649, 1262, 1134, 1137, 1138, 1263, 1098, 1112, 1888, 2509, - 1131, 1135, 3031, 1481, 2175, 1268, 2658, 3030, 1140, 1214, - 1729, 1872, 1873, 1874, 1134, 1137, 1138, 3746, 1098, 1718, - 1730, 1130, 1131, 1135, 3592, 2546, 3591, 1732, 2534, 1959, - 1261, 1755, 1898, 1898, 1905, 1910, 2015, 1911, 1758, 1913, - 1915, 1881, 1941, 1919, 1921, 1923, 1925, 1927, 1900, 3262, - 1039, 1037, 1245, 1991, 1904, 1992, 1786, 1787, 1993, 1281, - 2169, 1140, 1260, 1247, 2181, 173, 1144, 1134, 1855, 2023, - 1899, 1146, 1480, 1481, 179, 1147, 1145, 1894, 1949, 1950, - 1753, 2539, 1500, 1216, 1955, 1956, 1863, 2539, 4226, 1482, - 2544, 4227, 1140, 4225, 1177, 2542, 1148, 1878, 1174, 1879, - 3263, 1152, 1877, 1891, 1150, 4236, 1501, 1502, 1503, 1504, - 1505, 1506, 1507, 1509, 1508, 1510, 1511, 1230, 1213, 2098, - 2099, 2096, 2097, 4185, 2543, 3265, 1902, 3577, 1052, 1113, - 2541, 3048, 1753, 1984, 1113, 742, 1479, 4230, 1480, 1481, - 2180, 1736, 4080, 724, 4013, 3260, 2095, 3651, 1945, 3652, - 3918, 1482, 3917, 1937, 2011, 3908, 1940, 1982, 1942, 2098, - 2099, 2628, 2629, 3668, 1971, 3276, 3277, 976, 977, 978, - 3667, 3599, 3261, 1502, 1503, 1504, 1505, 1506, 1507, 1509, - 1508, 1510, 1511, 128, 1117, 3598, 1116, 1115, 3588, 1482, - 1789, 4081, 1500, 4014, 3305, 1496, 3294, 1497, 2947, 2946, - 2945, 4237, 164, 2499, 1983, 1985, 3267, 1969, 1482, 1968, - 2028, 1498, 1512, 1513, 1495, 3050, 1501, 1502, 1503, 1504, - 1505, 1506, 1507, 1509, 1508, 1510, 1511, 1967, 1981, 1281, - 1281, 1957, 1951, 1948, 2050, 1970, 2024, 2025, 1479, 1947, - 1480, 1481, 2331, 4198, 1753, 87, 2328, 3070, 87, 1946, - 2029, 1500, 4186, 3040, 1917, 2330, 1728, 2036, 2037, 2038, - 1482, 3582, 2331, 724, 2929, 3357, 724, 2049, 2515, 1482, - 2514, 972, 1445, 4042, 3275, 1501, 1502, 1503, 1504, 1505, - 1506, 1507, 1509, 1508, 1510, 1511, 3278, 2166, 3060, 3059, - 3058, 1500, 2513, 3052, 2512, 3056, 2511, 3051, 2510, 3049, - 1479, 4187, 1480, 1481, 3054, 1504, 1505, 1506, 1507, 1509, - 1508, 1510, 1511, 3053, 4041, 1501, 1502, 1503, 1504, 1505, - 1506, 1507, 1509, 1508, 1510, 1511, 2137, 2137, 2135, 2135, - 2138, 1482, 3055, 3057, 101, 4017, 2697, 2100, 1479, 4016, - 1480, 1481, 1482, 4015, 102, 42, 1478, 1753, 42, 1482, - 2873, 4213, 4196, 1753, 1482, 3913, 2026, 1479, 1766, 1480, - 1481, 4126, 1753, 2030, 1482, 2032, 2033, 2034, 2035, 4173, - 1753, 3399, 2039, 3897, 2221, 1488, 1489, 1490, 1491, 1492, - 1493, 1487, 1484, 3896, 2051, 3745, 2158, 2147, 2148, 2149, - 2150, 2160, 2151, 2152, 2153, 2165, 2161, 2154, 2155, 2162, - 2163, 2164, 2156, 2157, 2159, 1753, 3264, 1767, 3743, 1479, - 3664, 1480, 1481, 1713, 85, 2873, 1753, 85, 1479, 2077, - 1480, 1481, 1712, 4124, 1753, 1753, 1714, 1715, 1711, 1482, - 1478, 1753, 2107, 3596, 4122, 1753, 4035, 2057, 2058, 110, - 3581, 165, 1753, 101, 2170, 3367, 3991, 1753, 177, 103, - 109, 3364, 108, 102, 2112, 3297, 2113, 4030, 2115, 2116, - 2117, 2118, 2119, 2120, 2122, 2124, 2125, 2126, 2127, 2128, - 2129, 1710, 3296, 2956, 1482, 2943, 1708, 1710, 2141, 1704, - 1479, 1706, 1480, 1481, 1707, 1705, 2339, 1709, 2341, 185, - 2114, 1479, 1482, 1480, 1481, 2873, 4111, 3945, 1479, 2245, - 1480, 1481, 1482, 1479, 2611, 1480, 1481, 2603, 1525, 2185, - 2186, 2187, 2188, 1479, 1753, 1480, 1481, 2340, 2406, 2407, - 2602, 3989, 1753, 2199, 2220, 1753, 2176, 2329, 2327, 1482, - 1500, 2561, 166, 171, 168, 174, 175, 176, 178, 180, - 181, 182, 183, 2237, 2560, 1482, 2873, 4090, 184, 186, - 187, 188, 2699, 1482, 1501, 1502, 1503, 1504, 1505, 1506, - 1507, 1509, 1508, 1510, 1511, 1482, 3986, 1753, 3944, 1482, - 2873, 4086, 3998, 1753, 1500, 2396, 2637, 2422, 1479, 2375, - 1480, 1481, 3635, 4032, 2338, 3921, 1753, 2344, 2345, 2339, - 1482, 2341, 2873, 3909, 3968, 1753, 104, 105, 1501, 1502, - 1503, 1504, 1505, 1506, 1507, 1509, 1508, 1510, 1511, 2053, - 1482, 2647, 3635, 1753, 2873, 3633, 3901, 104, 105, 2452, - 2411, 2646, 2386, 1479, 2019, 1480, 1481, 2539, 1753, 3900, - 2374, 3556, 1753, 1482, 2685, 2779, 1753, 3940, 2106, 3287, - 3286, 1479, 103, 1480, 1481, 3523, 1753, 2695, 3268, 1980, - 1103, 1479, 3272, 1480, 1481, 3284, 3285, 3516, 1753, 3271, - 1972, 3513, 1753, 3282, 3283, 2461, 2462, 2463, 2464, 2456, - 2447, 2457, 2458, 2459, 2460, 2446, 1053, 2424, 1479, 1962, - 1480, 1481, 3511, 1753, 1103, 2466, 2428, 1958, 2468, 2469, - 2470, 2471, 2387, 3273, 1479, 1954, 1480, 1481, 3269, 3282, - 3281, 2362, 1479, 3270, 1480, 1481, 2380, 1753, 2381, 2389, - 2482, 1953, 1482, 1952, 1479, 2450, 1480, 1481, 1479, 2870, - 1480, 1481, 1482, 2488, 2409, 2528, 1753, 86, 44, 45, - 88, 2897, 1753, 103, 2434, 2433, 1768, 1087, 2432, 1479, - 1271, 1480, 1481, 2449, 2448, 2918, 92, 1482, 2621, 3004, - 48, 76, 77, 2889, 74, 78, 2525, 1088, 1482, 1479, - 3643, 1480, 1481, 1859, 2985, 2982, 75, 3553, 2498, 1501, - 1502, 1503, 1504, 1505, 1506, 1507, 1509, 1508, 1510, 1511, - 2918, 1143, 1479, 2961, 1480, 1481, 2978, 2979, 109, 2483, - 3219, 1898, 2479, 2472, 2474, 2475, 1482, 2868, 62, 2502, - 2497, 3549, 2501, 2533, 3474, 1753, 2536, 2889, 2537, 2553, - 95, 1482, 3249, 2919, 3472, 1753, 2873, 2872, 2140, 1753, - 1859, 1858, 2621, 2921, 1482, 2483, 2532, 2540, 2535, 2531, - 2897, 1482, 1801, 1800, 1142, 3552, 2896, 2451, 3549, 3468, - 1753, 2557, 190, 2554, 1478, 2558, 2559, 1482, 2919, 4074, - 3465, 1753, 4046, 2976, 2873, 2897, 3502, 110, 2621, 1482, - 83, 1479, 1478, 1480, 1481, 129, 1482, 151, 109, 3600, - 108, 1479, 3284, 1480, 1481, 3192, 1754, 1756, 103, 1482, - 1770, 172, 2435, 2626, 3549, 2779, 2564, 2682, 3463, 1753, - 2645, 2539, 1041, 1041, 1041, 2681, 1479, 2897, 1480, 1481, - 2539, 2522, 2404, 3461, 1753, 1757, 2365, 1479, 2140, 1480, - 1481, 1482, 1535, 2078, 1535, 162, 3459, 1753, 2062, 2005, - 1933, 150, 1788, 3457, 1753, 1125, 3601, 3602, 3603, 1124, - 2641, 1042, 1482, 95, 4152, 4093, 3932, 1760, 2596, 3455, - 1753, 169, 3898, 1753, 170, 1479, 3758, 1480, 1481, 1482, - 2644, 1769, 2341, 3616, 3613, 51, 54, 57, 56, 59, - 1479, 73, 1480, 1481, 82, 79, 1884, 1885, 161, 160, - 189, 3453, 1753, 1479, 1482, 1480, 1481, 1934, 1935, 1936, - 1479, 2340, 1480, 1481, 3594, 3415, 3414, 1861, 61, 91, - 90, 2481, 2613, 71, 72, 58, 1479, 1482, 1480, 1481, - 3355, 80, 81, 3451, 1753, 3310, 1482, 2619, 1479, 3306, - 1480, 1481, 1482, 2986, 95, 1479, 1482, 1480, 1481, 2478, - 1482, 2473, 2467, 2627, 3449, 1753, 1482, 2465, 1479, 1987, - 1480, 1481, 1893, 1889, 1716, 1857, 2633, 121, 2630, 2631, - 2632, 3447, 1753, 1482, 63, 64, 2107, 65, 66, 67, - 68, 3308, 2953, 2952, 1215, 3359, 3563, 3564, 3933, 2496, - 1479, 2378, 1480, 1481, 2055, 4208, 3445, 1753, 4206, 2634, - 4180, 2636, 155, 1886, 158, 4054, 1883, 3973, 156, 157, - 2639, 1479, 2640, 1480, 1481, 173, 3566, 1482, 3302, 3443, - 1753, 1482, 3301, 3569, 179, 3300, 3219, 2657, 1479, 3905, - 1480, 1481, 3568, 2635, 3441, 1753, 1482, 2953, 3439, 1753, - 1482, 60, 3437, 1753, 2965, 2597, 1482, 3238, 3435, 1753, - 3237, 2384, 1482, 1479, 2642, 1480, 1481, 1482, 3241, 3239, - 2823, 2056, 1482, 3242, 3240, 3421, 1753, 1482, 2605, 2606, - 4050, 1482, 3723, 2608, 3722, 1482, 1479, 678, 1480, 1481, - 3934, 1765, 2609, 2693, 2395, 1479, 2811, 1480, 1481, 2654, - 3557, 1479, 2855, 1480, 1481, 1479, 3197, 1480, 1481, 1479, - 3196, 1480, 1481, 1482, 3542, 1479, 1055, 1480, 1481, 3397, - 1753, 1041, 3541, 2844, 1753, 4012, 3736, 2137, 3738, 2135, - 2858, 3545, 1479, 2004, 1480, 1481, 3206, 3721, 2842, 1753, - 1025, 89, 2817, 1753, 2894, 2895, 1482, 2856, 2794, 1753, - 1058, 1482, 3280, 2422, 2786, 1753, 1041, 2914, 1059, 2777, - 1753, 741, 164, 2936, 2775, 1753, 2957, 1056, 2589, 2762, - 1753, 2893, 2183, 2859, 3618, 2861, 1479, 2653, 1480, 1481, - 1479, 1482, 1480, 1481, 3209, 3211, 1482, 2874, 3375, 2184, - 1482, 2588, 2106, 3212, 1482, 1479, 1067, 1480, 1481, 1479, - 2587, 1480, 1481, 2586, 2585, 1479, 2948, 1480, 1481, 2584, - 1066, 1479, 1482, 1480, 1481, 3604, 1479, 1482, 1480, 1481, - 2883, 1479, 1482, 1480, 1481, 1721, 1479, 2846, 1480, 1481, - 1479, 1181, 1480, 1481, 1479, 1929, 1480, 1481, 2760, 1753, - 2583, 1180, 1482, 3571, 42, 2952, 2866, 101, 2939, 2941, - 3034, 94, 2912, 2911, 1715, 1482, 2913, 102, 159, 1444, - 2932, 1482, 1479, 2886, 1480, 1481, 2916, 2871, 3605, 3606, - 3607, 2990, 3547, 2758, 1753, 2103, 2101, 2102, 2756, 1753, - 2992, 129, 2754, 1753, 103, 1482, 3518, 2920, 1930, 1931, - 1932, 2488, 2923, 1482, 4222, 1479, 2969, 1480, 1481, 2930, - 1479, 2933, 1480, 1481, 2752, 1753, 2406, 2407, 2600, 2750, - 1753, 4129, 4031, 3001, 2748, 1753, 2178, 3525, 3928, 2944, - 3279, 2179, 2955, 2910, 2390, 1482, 2625, 2958, 2959, 1482, - 1479, 2061, 1480, 1481, 3514, 1479, 2954, 1480, 1481, 1479, - 2060, 1480, 1481, 1479, 108, 1480, 1481, 3480, 2962, 2966, - 2967, 2968, 2963, 2746, 1753, 1482, 3997, 3195, 70, 2241, - 2998, 1479, 109, 1480, 1481, 3194, 1479, 152, 1480, 1481, - 153, 1479, 3996, 1480, 1481, 3976, 3744, 3476, 1881, 1482, - 3742, 3044, 3045, 2987, 2988, 2744, 1753, 3243, 3741, 2906, - 2907, 1479, 101, 1480, 1481, 2997, 3734, 3614, 103, 3546, - 3544, 165, 102, 110, 1479, 3311, 1480, 1481, 177, 2523, - 1479, 1876, 1480, 1481, 109, 110, 108, 2742, 1753, 1065, - 3733, 2740, 1753, 3535, 1482, 2889, 109, 3707, 1482, 3042, - 3023, 3061, 2870, 1482, 1479, 3026, 1480, 1481, 4209, 2324, - 3098, 2683, 1479, 2376, 1480, 1481, 1482, 2738, 1753, 185, - 4210, 4209, 3, 1482, 1782, 3079, 3080, 3081, 3082, 3083, - 3084, 3085, 3086, 3087, 3088, 1774, 114, 115, 1482, 2356, - 4210, 2736, 1753, 4018, 1479, 3096, 1480, 1481, 1479, 2999, - 1480, 1481, 3580, 3062, 97, 2075, 1754, 2363, 10, 1, - 1033, 1447, 166, 171, 168, 174, 175, 176, 178, 180, - 181, 182, 183, 1446, 1479, 3584, 1480, 1481, 184, 186, - 187, 188, 2073, 4141, 694, 9, 2734, 1753, 2366, 2074, - 2732, 1753, 8, 1719, 4181, 3412, 2388, 4137, 1479, 4138, - 1480, 1481, 1973, 3100, 1963, 3646, 1716, 2292, 2730, 1753, - 3046, 3929, 3314, 3156, 2529, 3411, 3032, 3612, 3063, 3033, - 2486, 1133, 154, 1482, 2444, 2445, 4106, 1482, 118, 1091, - 2728, 1753, 2902, 2905, 2906, 2907, 2903, 117, 2904, 2908, - 3043, 1136, 3174, 1479, 1244, 1480, 1481, 1479, 2524, 1480, - 1481, 3636, 1479, 2235, 1480, 1481, 3163, 2937, 2453, 1807, - 1805, 3165, 1806, 1482, 2977, 1479, 1804, 1480, 1481, 1809, - 1808, 2422, 1479, 1482, 1480, 1481, 4078, 3089, 3383, 2684, - 3481, 2066, 2329, 2327, 2329, 2327, 3136, 1479, 1482, 1480, - 1481, 731, 2909, 3226, 1482, 87, 725, 192, 2422, 2422, - 2422, 2422, 2422, 2500, 1796, 3174, 3146, 3147, 3148, 3149, - 3150, 110, 1775, 2059, 3164, 3403, 3166, 1175, 2422, 2723, - 1753, 2422, 109, 684, 108, 3288, 3231, 1482, 2562, 3248, - 690, 1482, 103, 2318, 2319, 2320, 2321, 2322, 1532, 2054, - 3173, 3193, 2015, 1482, 2924, 1085, 1077, 3185, 2377, 2860, - 2343, 3191, 1482, 2346, 2347, 2719, 1753, 3186, 3188, 3190, - 1482, 3198, 3200, 1084, 3906, 2717, 1753, 3227, 3213, 3214, - 3201, 2424, 1479, 3539, 1480, 1481, 1479, 3205, 1480, 1481, - 2710, 1753, 3207, 2876, 3331, 3210, 2708, 1753, 2364, 3233, - 3234, 3230, 3236, 3203, 3339, 1044, 1045, 1482, 2424, 2424, - 2424, 2424, 2424, 104, 105, 3252, 3244, 3232, 4011, 1046, - 3235, 3735, 1479, 1482, 1480, 1481, 3258, 3250, 2424, 3401, - 3251, 2424, 1479, 2840, 1480, 1481, 4091, 2934, 1771, 1482, - 3501, 2656, 3290, 3199, 3291, 2839, 3289, 1479, 2173, 1480, - 1481, 1522, 756, 1479, 2835, 1480, 1481, 1482, 2421, 3702, - 2093, 754, 2834, 1482, 753, 3292, 3293, 3312, 751, 2862, - 2488, 3343, 3333, 1482, 2890, 1486, 3340, 1482, 1485, 962, - 2850, 1783, 3216, 3350, 3344, 1482, 1479, 2901, 1480, 1481, - 1479, 2899, 1480, 1481, 2898, 3222, 2598, 2429, 3565, 2833, - 3222, 3561, 1479, 3368, 1480, 1481, 3371, 1482, 4133, 2423, - 3370, 1479, 3378, 1480, 1481, 2832, 2419, 2869, 913, 1479, - 912, 1480, 1481, 763, 755, 745, 975, 911, 3388, 3385, - 3386, 2831, 3387, 910, 3341, 3389, 3342, 3391, 3007, 3393, - 3404, 3405, 3406, 3407, 3408, 3356, 3009, 2935, 3352, 2830, - 1463, 1738, 1741, 2385, 1104, 2821, 1479, 3380, 1480, 1481, - 2902, 2905, 2906, 2907, 2903, 2820, 2904, 2908, 4037, 2819, - 3563, 3564, 1479, 2624, 1480, 1481, 3409, 2818, 1535, 1737, - 4044, 3322, 1535, 3630, 3303, 3313, 2983, 2516, 1479, 69, - 1480, 1481, 2643, 46, 4006, 4075, 2648, 905, 3526, 2815, - 3528, 902, 3704, 3705, 3706, 3159, 1479, 3160, 1480, 1481, - 3496, 4057, 1479, 4058, 1480, 1481, 901, 3500, 4059, 2651, - 2230, 2652, 1479, 1457, 1480, 1481, 1479, 2660, 1480, 1481, - 1454, 2662, 2663, 4154, 1479, 2068, 1480, 1481, 96, 36, - 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2677, 2678, - 35, 2680, 34, 3379, 33, 3225, 1479, 32, 1480, 1481, - 2422, 26, 25, 3527, 24, 3529, 23, 22, 29, 3531, - 19, 21, 3536, 3578, 2686, 2687, 2688, 2689, 20, 2691, - 2692, 3543, 2694, 1482, 18, 3325, 2696, 4176, 3548, 4221, - 2701, 2702, 123, 2703, 55, 1482, 2706, 2707, 2709, 2711, - 2712, 2713, 2714, 2715, 2716, 2718, 2720, 2721, 2722, 2724, - 743, 2726, 2727, 2729, 2731, 2733, 2735, 2737, 2739, 2741, - 2743, 2745, 2747, 2749, 2751, 2753, 2755, 2757, 2759, 2761, - 2763, 2764, 2765, 3570, 2767, 3579, 2769, 3334, 2771, 2772, - 3343, 2774, 2776, 2778, 3572, 3340, 3503, 2781, 3505, 3506, - 3507, 2785, 3595, 3344, 3597, 2790, 2791, 2792, 2793, 3573, - 2424, 3567, 1482, 52, 3640, 3641, 3373, 3374, 2804, 2805, - 2806, 2807, 2808, 2809, 3533, 2810, 2813, 2814, 50, 131, - 130, 1482, 53, 49, 2816, 3589, 3590, 2803, 1218, 2822, - 47, 31, 1482, 30, 2825, 2826, 2827, 2828, 2829, 1482, - 17, 16, 15, 14, 1482, 2836, 2837, 3560, 2838, 1482, - 13, 2841, 2843, 2388, 12, 2845, 11, 7, 1482, 1064, - 6, 39, 1070, 1070, 1482, 2857, 3574, 3575, 1482, 38, - 37, 28, 1479, 27, 1480, 1481, 40, 3623, 4, 3642, - 2970, 3627, 3628, 3629, 1479, 2518, 1480, 1481, 0, 0, - 0, 0, 0, 0, 2802, 0, 0, 3658, 0, 0, - 0, 0, 0, 2664, 0, 0, 0, 1482, 0, 0, - 0, 0, 1482, 2801, 0, 0, 0, 0, 0, 1482, - 2679, 0, 3669, 0, 2800, 0, 1482, 0, 0, 0, - 1482, 2799, 0, 0, 1482, 0, 2798, 0, 1482, 0, - 0, 2797, 1482, 0, 0, 0, 1482, 0, 0, 0, - 2796, 1479, 0, 1480, 1481, 0, 2795, 0, 1482, 0, - 2789, 0, 0, 0, 0, 3710, 0, 3711, 3712, 3713, - 1479, 0, 1480, 1481, 0, 3720, 0, 1482, 3727, 0, - 3729, 1479, 0, 1480, 1481, 0, 0, 3700, 1479, 0, - 1480, 1481, 1482, 1479, 3730, 1480, 1481, 0, 1479, 2788, - 1480, 1481, 0, 3226, 2787, 0, 87, 1479, 3226, 1480, - 1481, 2784, 0, 1479, 0, 1480, 1481, 1479, 2783, 1480, - 1481, 0, 2782, 0, 0, 0, 2780, 0, 0, 0, - 2773, 0, 1482, 3752, 2770, 0, 0, 3731, 2768, 0, - 0, 0, 2137, 3663, 2135, 3760, 3740, 3750, 3739, 0, - 2766, 0, 3747, 0, 3749, 0, 1479, 0, 1480, 1481, - 1482, 1479, 0, 1480, 1481, 0, 0, 0, 1479, 2725, - 1480, 1481, 0, 3912, 0, 1479, 0, 1480, 1481, 1479, - 3764, 1480, 1481, 1479, 2705, 1480, 1481, 1479, 0, 1480, - 1481, 1479, 0, 1480, 1481, 1479, 0, 1480, 1481, 0, - 0, 3619, 3620, 0, 0, 0, 42, 1479, 0, 1480, - 1481, 0, 3904, 3931, 3903, 0, 0, 0, 0, 0, - 0, 0, 0, 3919, 2704, 0, 1479, 0, 1480, 1481, - 3923, 3924, 0, 0, 0, 0, 3902, 0, 0, 0, - 0, 1479, 0, 1480, 1481, 0, 3970, 3971, 0, 0, - 0, 0, 2700, 3754, 0, 3074, 3075, 3076, 3077, 3078, - 0, 0, 0, 0, 3728, 0, 0, 0, 0, 0, - 2137, 0, 2135, 3974, 0, 3093, 0, 3914, 3915, 3916, - 0, 1479, 0, 1480, 1481, 0, 0, 0, 3761, 3762, - 0, 0, 0, 3222, 0, 0, 0, 0, 0, 3977, - 0, 4019, 3226, 3980, 0, 0, 0, 0, 3756, 1479, - 0, 1480, 1481, 0, 0, 0, 1553, 1554, 1555, 1556, - 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, 1565, 1566, - 1567, 1568, 1569, 1570, 1571, 1573, 1574, 1575, 1576, 1577, - 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, - 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, 1596, 1597, - 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, - 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, - 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, 1627, - 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, - 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1646, 1647, - 1648, 1649, 1650, 1652, 1653, 1654, 1655, 1656, 1657, 1658, - 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1673, - 1674, 1675, 1676, 1690, 1691, 1692, 1693, 1694, 1695, 1696, - 1697, 1698, 1699, 1700, 1701, 1702, 1703, 4020, 4004, 0, - 3975, 4003, 0, 0, 0, 3225, 3994, 0, 0, 1482, - 3225, 4038, 0, 4000, 0, 4002, 0, 0, 1482, 0, - 0, 3064, 0, 0, 1743, 0, 0, 0, 0, 87, - 0, 0, 0, 0, 1743, 3228, 0, 0, 1751, 1482, - 4023, 1744, 0, 1482, 0, 0, 0, 0, 1751, 4022, - 0, 1744, 0, 3246, 0, 0, 4045, 3907, 4040, 4027, - 0, 0, 1482, 0, 4043, 0, 2382, 2383, 1750, 1748, - 1749, 1745, 0, 1746, 0, 3911, 1739, 1740, 1750, 1748, - 1749, 1745, 0, 1746, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1747, 0, 0, 0, - 0, 2698, 0, 0, 0, 0, 1747, 0, 0, 0, - 2690, 0, 0, 0, 0, 0, 0, 0, 0, 4063, - 0, 0, 4064, 0, 0, 0, 0, 4088, 0, 42, - 0, 2661, 87, 0, 0, 2655, 0, 0, 0, 0, - 4073, 0, 0, 0, 0, 1483, 0, 0, 4082, 0, - 0, 0, 0, 3138, 2650, 3140, 0, 0, 1479, 4092, - 1480, 1481, 0, 0, 3931, 4108, 4094, 1479, 4119, 1480, - 1481, 3151, 3152, 3153, 3154, 4105, 1541, 0, 4097, 4102, - 3377, 4099, 4098, 4096, 4101, 4100, 0, 0, 1479, 4127, - 1480, 1481, 1479, 0, 1480, 1481, 0, 0, 0, 4024, - 0, 4132, 3394, 3395, 3225, 3396, 3398, 3400, 0, 4150, - 0, 1479, 0, 1480, 1481, 0, 4140, 0, 4145, 0, - 0, 0, 0, 0, 4158, 4119, 4160, 0, 0, 0, - 4171, 0, 42, 3413, 0, 0, 0, 0, 3416, 0, - 3418, 3419, 3420, 3422, 3423, 3424, 3425, 3426, 3427, 3428, - 3429, 3430, 3431, 3432, 3433, 3434, 3436, 3438, 3440, 3442, - 3444, 3446, 3448, 3450, 3452, 3454, 3456, 3458, 3460, 3462, - 3464, 3466, 3467, 3469, 3470, 3471, 3473, 2015, 4194, 3475, - 4191, 3477, 3478, 3479, 4201, 4205, 3483, 3484, 3485, 3486, - 3487, 3488, 3489, 3490, 3491, 3492, 3493, 2137, 4207, 2135, - 4204, 4203, 4119, 4215, 4200, 3499, 4190, 4175, 4170, 3504, - 4223, 4089, 3222, 3508, 3509, 4084, 3510, 3512, 0, 3515, - 3517, 4231, 3519, 3520, 3521, 3522, 4229, 0, 4174, 0, - 0, 0, 3530, 0, 0, 0, 0, 1825, 0, 4029, - 4240, 4241, 3971, 4239, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2137, 0, 2135, 4238, 0, - 0, 0, 0, 4036, 0, 0, 0, 3554, 3555, 0, - 0, 3559, 0, 4048, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1825, 0, 0, 4166, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 4083, 0, 0, 0, 0, 0, 1773, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3634, 0, 0, 0, - 0, 0, 1722, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1812, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1862, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3653, 0, 0, 3657, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 676, 0, 1812, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3670, 0, - 0, 1028, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1826, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4188, 0, 0, 0, 1716, 0, 0, - 0, 0, 0, 1099, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3693, 0, 0, 0, 0, 1826, 0, 0, - 0, 0, 2020, 0, 0, 3701, 0, 0, 0, 0, - 0, 0, 3708, 1839, 1842, 1843, 1844, 1845, 1846, 1847, - 0, 1848, 1849, 1851, 1852, 1850, 1853, 1854, 1827, 1828, - 1829, 1830, 1810, 1811, 1840, 0, 1813, 0, 1814, 1815, - 1816, 1817, 1818, 1819, 1820, 1821, 1822, 0, 0, 1823, - 1831, 1832, 1833, 1834, 0, 1835, 1836, 1837, 1838, 0, - 0, 1824, 1839, 1842, 1843, 1844, 1845, 1846, 1847, 0, - 1848, 1849, 1851, 1852, 1850, 1853, 1854, 1827, 1828, 1829, - 1830, 1810, 1811, 1840, 0, 1813, 0, 1814, 1815, 1816, - 1817, 1818, 1819, 1820, 1821, 1822, 0, 0, 1823, 1831, - 1832, 1833, 1834, 0, 1835, 1836, 1837, 1838, 0, 0, - 1824, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3920, 0, 0, 0, 0, 0, 0, 0, 0, - 3927, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3937, 3938, 3939, 0, 3941, 0, 3942, 3943, 0, 0, - 0, 0, 3946, 3947, 3948, 3949, 3950, 3951, 3952, 3953, - 3954, 3955, 3956, 3957, 3958, 3959, 3960, 3961, 3962, 3963, - 3964, 3965, 3966, 3967, 0, 3969, 3972, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3691, 0, 0, - 0, 3981, 3982, 3983, 3984, 3985, 3987, 3988, 3990, 3992, - 3993, 3995, 0, 0, 0, 3999, 0, 0, 0, 4001, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2088, - 2089, 2090, 2091, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2104, 1841, 0, 0, 0, - 0, 0, 0, 0, 4028, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2143, 2144, 0, 0, 0, 0, 2167, 0, 0, 2171, - 2172, 0, 0, 0, 2177, 1841, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2189, - 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 0, - 2200, 0, 0, 0, 2222, 2223, 2224, 2225, 2226, 2227, - 2228, 2229, 2231, 0, 2236, 0, 2238, 2239, 2240, 0, - 2242, 2243, 2244, 0, 2246, 2247, 2248, 2249, 2250, 2251, - 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261, - 2262, 2263, 2264, 2265, 2266, 2267, 2268, 2269, 2270, 2271, - 2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281, - 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, - 2295, 2296, 2297, 2298, 2299, 2300, 2301, 2302, 2303, 2304, - 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313, 2314, - 2315, 2316, 2317, 0, 0, 0, 0, 0, 2323, 0, - 2325, 0, 2332, 2333, 2334, 2335, 2336, 2337, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 0, - 2357, 2358, 2359, 2360, 2361, 4010, 0, 0, 0, 0, - 0, 4053, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 4068, 0, 0, 0, 1070, - 0, 4071, 0, 4072, 0, 0, 0, 0, 0, 0, - 0, 0, 190, 0, 0, 0, 1219, 0, 1225, 0, - 0, 0, 0, 0, 0, 0, 4087, 0, 0, 0, - 2402, 2403, 0, 0, 0, 129, 0, 151, 958, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 172, 4113, 4114, 0, 0, 2441, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 4121, 4123, 4125, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1453, 0, 0, 0, 4131, 162, 0, 0, 0, 0, - 0, 150, 0, 0, 195, 0, 4153, 195, 0, 0, - 0, 729, 0, 0, 0, 0, 735, 0, 0, 0, - 0, 169, 0, 0, 170, 0, 0, 195, 2484, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 195, 4172, 0, 138, 139, 161, 160, - 189, 0, 0, 1716, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 735, 195, - 735, 0, 0, 0, 0, 0, 0, 0, 4195, 4197, - 4199, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 4052, - 0, 4220, 0, 0, 0, 0, 0, 4062, 0, 0, - 0, 0, 0, 0, 0, 95, 0, 0, 1023, 4232, - 4233, 0, 0, 963, 1024, 976, 977, 978, 964, 0, - 0, 965, 966, 0, 967, 0, 0, 0, 0, 0, - 0, 0, 155, 136, 158, 143, 135, 0, 156, 157, - 972, 0, 979, 980, 0, 173, 0, 0, 0, 0, - 0, 0, 0, 0, 179, 144, 0, 0, 0, 1716, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 147, - 145, 140, 141, 142, 146, 0, 0, 0, 0, 0, - 0, 137, 0, 0, 0, 0, 0, 0, 0, 0, - 148, 3345, 3346, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 981, 982, 983, 984, 985, 986, 987, + 1676, 1677, 1440, 1522, 1271, 2550, 1678, 4036, 1680, 1681, + 1682, 1683, 1684, 1441, 1442, 2974, 3331, 3332, 3588, 3589, + 1551, 1551, 1551, 1551, 1551, 1551, 1535, 1121, 4150, 3335, + 1515, 975, 4082, 975, 724, 1691, 1692, 1693, 1694, 1695, + 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1518, + 1519, 1520, 1521, 1526, 2997, 715, 4121, 975, 1515, 1532, + 3657, 4121, 1467, 3700, 3700, 1083, 1718, 165, 3331, 3332, + 716, 1224, 4149, 1547, 177, 1548, 1549, 1234, 1459, 94, + 2624, 3335, 1977, 1976, 1978, 1979, 1980, 1717, 4120, 1221, + 94, 94, 165, 4120, 1552, 1553, 3541, 1216, 2996, 177, + 2977, 1897, 1083, 2993, 1233, 1142, 1239, 1240, 1241, 1242, + 2008, 1865, 89, 1172, 2623, 185, 3044, 3485, 1228, 1135, + 1724, 674, 3385, 1171, 1753, 4160, 2548, 2854, 2856, 1042, + 1279, 1280, 3021, 1042, 4024, 3020, 1467, 1516, 1517, 1042, + 185, 4231, 3579, 3561, 2640, 2924, 2889, 2826, 2143, 1782, + 3031, 719, 1679, 1179, 1227, 1142, 1715, 3172, 166, 171, + 168, 174, 175, 176, 178, 180, 181, 182, 183, 1716, + 1477, 1247, 2884, 2494, 184, 186, 187, 188, 1142, 682, + 2444, 1515, 124, 166, 171, 168, 174, 175, 176, 178, + 180, 181, 182, 183, 2402, 3257, 1512, 1142, 2184, 184, + 186, 187, 188, 2651, 1260, 1495, 3265, 1058, 1141, 1274, + 1896, 2176, 4050, 1165, 2495, 2185, 119, 3620, 3553, 1754, + 1732, 2493, 94, 1232, 1736, 2023, 2568, 1734, 1735, 2077, + 1041, 104, 105, 2004, 1796, 3071, 2510, 1716, 1685, 1686, + 1687, 1688, 1689, 1690, 1477, 1995, 4196, 3749, 1722, 1507, + 1508, 1510, 1509, 1511, 1512, 2496, 1482, 3266, 1141, 1115, + 1211, 3595, 4188, 1145, 1135, 2492, 1481, 1482, 1147, 3594, + 2535, 107, 1148, 1146, 1906, 1483, 1142, 2176, 1905, 2660, + 1895, 1141, 3268, 1473, 2540, 3034, 1465, 1135, 1138, 1139, + 3033, 1099, 2540, 1149, 120, 1132, 1136, 1873, 1874, 1875, + 1141, 2855, 3263, 2651, 1730, 1142, 1135, 1138, 1139, 2545, + 1099, 1889, 2543, 1153, 1132, 1136, 1131, 1151, 1053, 1756, + 3580, 3034, 3279, 3280, 1215, 1733, 3033, 2544, 1719, 3264, + 1960, 4233, 1882, 2547, 2016, 2542, 1038, 4083, 1759, 4016, + 1040, 1911, 1731, 1912, 1985, 1914, 1916, 3921, 1901, 1920, + 1922, 1924, 1926, 1928, 2182, 1942, 3920, 1473, 3051, 2332, + 1282, 1983, 1261, 3270, 1950, 1951, 720, 1787, 1788, 2167, + 1956, 1957, 1900, 4229, 1856, 1217, 4230, 1231, 4228, 1141, + 2111, 1178, 3654, 2024, 3655, 1175, 4084, 1246, 4017, 1864, + 2400, 2401, 1899, 1899, 2112, 1513, 1514, 2110, 1248, 4239, + 1992, 3911, 1993, 1879, 3671, 1994, 3670, 1880, 1141, 1892, + 3602, 1878, 2332, 1145, 1135, 1984, 2329, 1972, 1147, 1737, + 3601, 1754, 1148, 1146, 1480, 2331, 1481, 1482, 725, 2181, + 1903, 3278, 1982, 3073, 1214, 3591, 1946, 2099, 2100, 2097, + 2098, 973, 3053, 3281, 977, 978, 979, 1483, 3308, 3297, + 1114, 2949, 1483, 2099, 2100, 2630, 2631, 1938, 2012, 1483, + 1941, 2948, 1943, 2947, 2096, 2500, 2697, 1986, 2159, 2148, + 2149, 2150, 2151, 2161, 2152, 2153, 2154, 2166, 2162, 2155, + 2156, 2163, 2164, 2165, 2157, 2158, 2160, 1483, 1971, 1970, + 190, 1969, 128, 1483, 1968, 4240, 1118, 1117, 1116, 1483, + 1958, 2978, 1505, 1506, 1507, 1508, 1510, 1509, 1511, 1512, + 1790, 2029, 1952, 129, 1949, 151, 3063, 3062, 3061, 2407, + 2408, 3055, 1948, 3059, 1947, 3054, 1918, 3052, 1729, 172, + 1282, 1282, 3057, 1483, 3360, 1446, 2025, 2026, 1483, 4201, + 1754, 3056, 2875, 4216, 2051, 1754, 87, 4189, 4045, 87, + 2030, 4199, 1754, 3552, 3585, 3402, 725, 2037, 2038, 2039, + 3058, 3060, 4044, 162, 3267, 4020, 2931, 2050, 725, 150, + 1489, 1490, 1491, 1492, 1493, 1494, 1488, 1485, 4019, 1472, + 1469, 1470, 1471, 1476, 1478, 1475, 2516, 1474, 2515, 169, + 4018, 3943, 170, 1754, 1767, 2699, 1480, 1468, 1481, 1482, + 2514, 1480, 2513, 1481, 1482, 1479, 1754, 2942, 1480, 101, + 1481, 1482, 4176, 1754, 1885, 1886, 161, 160, 189, 102, + 3916, 1483, 2138, 2138, 2136, 2136, 1754, 2139, 2875, 1754, + 4129, 1754, 1483, 2512, 3900, 2511, 1480, 42, 1481, 1482, + 42, 3899, 1480, 1768, 1481, 1482, 3748, 2101, 1480, 1717, + 1481, 1482, 1483, 1472, 1469, 1470, 1471, 1476, 1478, 1475, + 3746, 1474, 4038, 2027, 1479, 1754, 2875, 4114, 2875, 4093, + 2031, 1468, 2033, 2034, 2035, 2036, 2687, 3667, 1501, 2040, + 1754, 1497, 1480, 1498, 1481, 1482, 1714, 1480, 1713, 1481, + 1482, 2052, 2222, 1483, 2875, 4089, 2236, 1499, 1513, 1514, + 1496, 1712, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1510, + 1509, 1511, 1512, 4127, 1754, 1483, 85, 3599, 1715, 85, + 155, 1887, 158, 2078, 1884, 1754, 156, 157, 4001, 1754, + 3948, 1716, 3584, 173, 2108, 3370, 1483, 2058, 2059, 2171, + 3638, 4035, 179, 1503, 1504, 1505, 1506, 1507, 1508, 1510, + 1509, 1511, 1512, 2114, 1483, 2116, 2117, 2118, 2119, 2120, + 2121, 2123, 2125, 2126, 2127, 2128, 2129, 2130, 1483, 2113, + 1480, 3367, 1481, 1482, 3300, 2649, 2319, 2320, 2321, 2322, + 2323, 1480, 2656, 1481, 1482, 2648, 2342, 110, 2142, 2115, + 2341, 3924, 1754, 2344, 2246, 2340, 2347, 2348, 109, 101, + 108, 1480, 3299, 1481, 1482, 103, 3271, 4125, 1754, 102, + 3275, 3025, 1526, 2186, 2187, 2188, 2189, 3274, 2875, 3912, + 3947, 2328, 2330, 3638, 1754, 2875, 3636, 2200, 3994, 1754, + 2177, 2365, 2221, 2540, 1754, 3559, 1754, 2781, 1754, 3904, + 2238, 1483, 1480, 2958, 1481, 1482, 3992, 1754, 3290, 3289, + 3903, 3276, 2945, 2920, 1483, 1711, 3272, 3287, 3288, 103, + 2655, 3273, 3285, 3286, 1480, 2647, 1481, 1482, 3285, 3284, + 1754, 164, 1483, 1754, 2899, 1754, 2623, 3006, 2423, 2339, + 1705, 1711, 2345, 2346, 1483, 1480, 1709, 1481, 1482, 2342, + 2613, 1707, 1483, 2412, 1708, 1706, 2605, 1710, 2340, 1860, + 2987, 104, 105, 1480, 2604, 1481, 1482, 2980, 2981, 3646, + 1501, 2562, 3043, 1771, 2561, 1483, 2453, 1480, 2397, 1481, + 1482, 2921, 104, 105, 1754, 2375, 1483, 2376, 1501, 2387, + 2054, 2923, 2020, 2107, 1502, 1503, 1504, 1505, 1506, 1507, + 1508, 1510, 1509, 1511, 1512, 1981, 3989, 1754, 2875, 2874, + 2701, 1104, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1510, + 1509, 1511, 1512, 1973, 3971, 1754, 2984, 159, 1963, 2425, + 2963, 2462, 2463, 2464, 2465, 2457, 3574, 2458, 2459, 2460, + 2461, 2447, 1054, 2448, 1770, 1104, 2891, 2872, 1959, 2363, + 1480, 2467, 1481, 1482, 2469, 2470, 2471, 2472, 2429, 2388, + 2381, 103, 2382, 1480, 1955, 1481, 1482, 3526, 1754, 2452, + 2390, 1954, 2483, 2141, 1754, 95, 1953, 1769, 3521, 2451, + 109, 1480, 1272, 1481, 1482, 3556, 1501, 2529, 2639, 2410, + 1483, 2489, 2891, 1480, 1483, 1481, 1482, 1479, 2434, 2435, + 2433, 1480, 1088, 1481, 1482, 1089, 2450, 2920, 2449, 2541, + 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1510, 1509, 1511, + 1512, 1860, 1859, 2899, 1480, 2870, 1481, 1482, 4077, 2526, + 1802, 1801, 2499, 2898, 4049, 1480, 152, 1481, 1482, 153, + 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1510, 1509, 1511, + 1512, 3222, 2484, 3555, 1479, 2480, 2473, 2475, 2476, 2875, + 2899, 2498, 3552, 2534, 1483, 2503, 2537, 2502, 2538, 3552, + 165, 3252, 3505, 2540, 3287, 2921, 3195, 177, 3603, 2436, + 2781, 2623, 2554, 4190, 2684, 2623, 3519, 1754, 2484, 2533, + 2536, 2532, 1143, 2683, 2899, 1501, 2540, 1483, 2523, 2405, + 1758, 1144, 1483, 2366, 2141, 2079, 2063, 2555, 1483, 2558, + 2006, 1899, 1483, 2559, 2560, 1789, 1483, 1126, 185, 1502, + 1503, 1504, 1505, 1506, 1507, 1508, 1510, 1509, 1511, 1512, + 1483, 1755, 1757, 1125, 1483, 3604, 3605, 3606, 1483, 1480, + 4155, 1481, 1482, 1480, 2628, 1481, 1482, 4096, 3935, 1043, + 1761, 3901, 3311, 1042, 1042, 1042, 3516, 1754, 2565, 3761, + 3619, 166, 171, 168, 174, 175, 176, 178, 180, 181, + 182, 183, 110, 1536, 3616, 1536, 3597, 184, 186, 187, + 188, 3418, 1483, 109, 3417, 108, 1862, 2482, 3572, 3514, + 1754, 2643, 3358, 103, 3477, 1754, 3313, 3309, 2988, 1483, + 3475, 1754, 2598, 1483, 3471, 1754, 2479, 2955, 3468, 1754, + 2342, 1501, 1483, 1480, 2341, 1481, 1482, 1483, 2474, 2646, + 2468, 1483, 3466, 1754, 2466, 1483, 3464, 1754, 1988, 1483, + 3462, 1754, 95, 1894, 1483, 1502, 1503, 1504, 1505, 1506, + 1507, 1508, 1510, 1509, 1511, 1512, 1480, 1890, 1481, 1482, + 1483, 1480, 1858, 1481, 1482, 2615, 2666, 1480, 1754, 1481, + 1482, 1480, 121, 1481, 1482, 1480, 1216, 1481, 1482, 2954, + 2621, 3566, 3567, 2681, 3460, 1754, 3362, 3936, 1483, 1480, + 2497, 1481, 1482, 1480, 2629, 1481, 1482, 1480, 1934, 1481, + 1482, 3458, 1754, 2379, 4211, 3456, 1754, 2635, 2056, 4209, + 2632, 2633, 2634, 1483, 3454, 1754, 4053, 1483, 2108, 3452, + 1754, 1483, 4183, 3450, 1754, 679, 4057, 3448, 1754, 3976, + 1483, 3446, 1754, 2955, 1483, 3569, 2636, 4033, 2638, 3305, + 3304, 1480, 1483, 1481, 1482, 3303, 3222, 2641, 2967, 2642, + 1483, 2599, 3444, 1754, 1483, 1935, 1936, 1937, 1480, 1766, + 1481, 1482, 1480, 3244, 1481, 1482, 3571, 1483, 3245, 2659, + 3241, 1480, 2637, 1481, 1482, 2057, 1480, 3240, 1481, 1482, + 1480, 3908, 1481, 1482, 1480, 1056, 1481, 1482, 1480, 3242, + 1481, 1482, 3937, 1480, 3243, 1481, 1482, 1483, 2644, 742, + 2396, 2825, 2385, 1483, 3560, 3442, 1754, 3200, 3199, 1480, + 3621, 1481, 1482, 3440, 1754, 2607, 2608, 4015, 1483, 3739, + 2610, 3548, 3438, 1754, 3545, 2695, 3517, 2167, 1483, 2611, + 3741, 2813, 3544, 2857, 3424, 1754, 1057, 1480, 3209, 1481, + 1482, 2005, 3400, 1754, 1026, 3283, 2846, 1754, 3246, 2938, + 2908, 2909, 1042, 2138, 3726, 2136, 3725, 2860, 1483, 2844, + 1754, 2959, 1480, 2184, 1481, 1482, 1480, 2591, 1481, 1482, + 1480, 1483, 1481, 1482, 2590, 2896, 2897, 1182, 2858, 1480, + 2185, 1481, 1482, 1480, 2423, 1481, 1482, 1042, 2916, 2819, + 1754, 1480, 2589, 1481, 1482, 2796, 1754, 2588, 2861, 1480, + 2863, 1481, 1482, 1480, 2587, 1481, 1482, 1059, 1483, 3724, + 2788, 1754, 1483, 2895, 2586, 1060, 1480, 2107, 1481, 1482, + 2779, 1754, 1483, 2876, 2585, 1181, 2159, 2148, 2149, 2150, + 2151, 2161, 2152, 2153, 2154, 2166, 2162, 2155, 2156, 2163, + 2164, 2165, 2157, 2158, 2160, 3378, 1480, 2954, 1481, 1482, + 2777, 1754, 1480, 3037, 1481, 1482, 1483, 1722, 2848, 1445, + 2885, 2914, 1068, 2764, 1754, 2994, 42, 1480, 129, 1481, + 1482, 101, 3550, 1483, 103, 2913, 1067, 1480, 2915, 1481, + 1482, 102, 2868, 4225, 2941, 2943, 2971, 1483, 1716, 3212, + 3214, 1483, 2104, 2102, 2103, 2888, 2934, 1483, 3215, 2873, + 2762, 1754, 2992, 1483, 2760, 1754, 101, 1480, 2918, 1481, + 1482, 2602, 103, 4132, 2758, 1754, 102, 4034, 3931, 2922, + 1480, 3528, 1481, 1482, 2925, 1483, 110, 2407, 2408, 2489, + 2932, 3282, 2912, 2391, 1483, 2935, 2627, 109, 2957, 108, + 3003, 2179, 3198, 2960, 2961, 2062, 2180, 103, 2756, 1754, + 3197, 2061, 2946, 108, 4000, 3999, 3607, 1480, 1483, 1481, + 1482, 1480, 3979, 1481, 1482, 2754, 1754, 1483, 3747, 2956, + 3745, 1480, 3744, 1481, 1482, 1483, 3737, 3736, 3617, 2752, + 1754, 3549, 2964, 3483, 2242, 2968, 2969, 2970, 2965, 2750, + 1754, 110, 1483, 3547, 3000, 2748, 1754, 1483, 3314, 1882, + 2524, 1483, 109, 1930, 108, 1480, 1877, 1481, 1482, 3608, + 3609, 3610, 110, 2989, 2990, 1066, 109, 2746, 1754, 3538, + 4212, 2891, 1480, 109, 1481, 1482, 2744, 1754, 3710, 2999, + 3047, 3048, 4213, 4212, 4213, 3067, 1480, 2872, 1481, 1482, + 1480, 1483, 1481, 1482, 3101, 1483, 1480, 2685, 1481, 1482, + 2742, 1754, 1480, 1483, 1481, 1482, 1931, 1932, 1933, 2740, + 1754, 2377, 1483, 3026, 2325, 1783, 3064, 2738, 1754, 1483, + 3045, 1775, 114, 115, 1480, 4021, 1481, 1482, 3029, 1483, + 3583, 3, 97, 1480, 3479, 1481, 1482, 1, 2076, 2736, + 1754, 10, 1034, 3415, 2357, 3082, 3083, 3084, 3085, 3086, + 3087, 3088, 3089, 3090, 3091, 2074, 1448, 1480, 9, 1481, + 1482, 1755, 2364, 3001, 2075, 3099, 1480, 8, 1481, 1482, + 1447, 3587, 3065, 4144, 1480, 695, 1481, 1482, 2367, 1720, + 4184, 4140, 4141, 2734, 1754, 1974, 1964, 2732, 1754, 3649, + 2293, 1480, 1483, 1481, 1482, 3414, 1480, 3932, 1481, 1482, + 1480, 2389, 1481, 1482, 2730, 1754, 1483, 3317, 2530, 3615, + 1483, 2725, 1754, 2487, 1483, 1134, 154, 3141, 3049, 3143, + 2445, 3406, 3103, 2446, 1483, 3159, 3066, 3035, 4109, 118, + 3036, 1092, 117, 1137, 1483, 3154, 3155, 3156, 3157, 1245, + 1480, 2979, 1481, 1482, 1480, 2525, 1481, 1482, 1483, 3639, + 3046, 2939, 1480, 2454, 1481, 1482, 1808, 1806, 1807, 1805, + 1810, 1480, 3177, 1481, 1482, 1809, 4081, 3386, 1480, 2686, + 1481, 1482, 3166, 3168, 3484, 2067, 732, 2911, 1480, 726, + 1481, 1482, 192, 2423, 2721, 1754, 3092, 2328, 2330, 2328, + 2330, 1483, 1797, 1776, 2060, 1176, 685, 3291, 2719, 1754, + 2563, 691, 3404, 3139, 1533, 3229, 2842, 87, 2501, 2055, + 2423, 2423, 2423, 2423, 2423, 3196, 2841, 3149, 3150, 3151, + 3152, 3153, 2926, 1086, 1078, 3177, 2712, 1754, 2378, 2862, + 2423, 1085, 3909, 2423, 3230, 3542, 3167, 3208, 3169, 3210, + 2837, 1480, 1483, 1481, 1482, 2878, 3176, 1483, 3234, 3213, + 3206, 2016, 3251, 4014, 3738, 1480, 4094, 1481, 1482, 1480, + 3204, 1481, 1482, 1480, 2936, 1481, 1482, 1483, 3194, 3188, + 1772, 1483, 3504, 1480, 2425, 1481, 1482, 1483, 2658, 2174, + 3203, 1523, 3201, 1480, 2950, 1481, 1482, 757, 2422, 3216, + 3217, 3705, 2094, 755, 754, 752, 3334, 1480, 1045, 1481, + 1482, 2425, 2425, 2425, 2425, 2425, 3342, 3253, 3233, 1483, + 3254, 1046, 3202, 3236, 3237, 3235, 3239, 1483, 3238, 104, + 105, 2425, 3247, 1047, 2425, 1483, 2864, 3255, 3189, 3191, + 3193, 2892, 1487, 3261, 2710, 1754, 1486, 963, 2852, 2836, + 1480, 1784, 1481, 1482, 1483, 2903, 3292, 2901, 3294, 2900, + 2600, 2430, 3295, 3296, 3568, 3293, 1483, 3564, 4136, 2835, + 2424, 2420, 2871, 2834, 914, 3346, 913, 764, 756, 2833, + 746, 976, 912, 3343, 911, 3344, 3345, 3219, 3009, 2489, + 3336, 3315, 3359, 3011, 2937, 3347, 3355, 1464, 3353, 1739, + 1742, 1480, 2386, 1481, 1482, 1105, 1480, 3383, 1481, 1482, + 3225, 2832, 4040, 2626, 3412, 3225, 1483, 1738, 4047, 2823, + 3325, 3371, 3374, 3373, 3633, 3306, 1480, 2822, 1481, 1482, + 1480, 2985, 1481, 1482, 3381, 2517, 1480, 69, 1481, 1482, + 46, 4009, 3391, 4078, 906, 903, 2821, 3388, 3389, 3707, + 3390, 3708, 3709, 3392, 3162, 3394, 3163, 3396, 2820, 4060, + 4061, 3407, 3408, 3409, 3410, 3411, 902, 4062, 1480, 2231, + 1481, 1482, 1458, 1455, 4157, 2069, 1480, 96, 1481, 1482, + 36, 35, 34, 33, 1480, 32, 1481, 1482, 26, 25, + 24, 1536, 23, 22, 29, 1536, 19, 2645, 21, 20, + 3316, 2650, 18, 1480, 3328, 1481, 1482, 4179, 2817, 4224, + 123, 3529, 55, 3531, 52, 1480, 50, 1481, 1482, 131, + 130, 53, 49, 1219, 2653, 47, 2654, 3499, 31, 30, + 17, 16, 2662, 15, 3503, 14, 2664, 2665, 13, 12, + 11, 7, 6, 39, 38, 2671, 2672, 2673, 2674, 2675, + 2676, 2677, 2678, 2679, 2680, 37, 2682, 28, 27, 40, + 4, 3228, 2972, 2519, 3382, 1480, 0, 1481, 1482, 0, + 0, 0, 1717, 2423, 0, 0, 3534, 1483, 0, 2688, + 2689, 2690, 2691, 744, 2693, 2694, 3581, 2696, 3530, 3539, + 3532, 2698, 3546, 0, 0, 2703, 2704, 0, 2705, 3551, + 0, 2708, 2709, 2711, 2713, 2714, 2715, 2716, 2717, 2718, + 2720, 2722, 2723, 2724, 2726, 3337, 2728, 2729, 2731, 2733, + 2735, 2737, 2739, 2741, 2743, 2745, 2747, 2749, 2751, 2753, + 2755, 2757, 2759, 2761, 2763, 2765, 2766, 2767, 3573, 2769, + 3575, 2771, 3570, 2773, 2774, 3346, 2776, 2778, 2780, 0, + 3576, 0, 2783, 3343, 3536, 3506, 2787, 3508, 3509, 3510, + 2792, 2793, 2794, 2795, 2425, 3347, 3582, 1483, 0, 2812, + 3598, 0, 3600, 2806, 2807, 2808, 2809, 2810, 2811, 1483, + 0, 2815, 2816, 3592, 3593, 3376, 3377, 3563, 1483, 2818, + 0, 0, 1065, 1483, 2824, 1071, 1071, 0, 1483, 2827, + 2828, 2829, 2830, 2831, 0, 0, 3577, 3578, 0, 0, + 2838, 2839, 0, 2840, 0, 1483, 2843, 2845, 2389, 1483, + 2847, 0, 0, 3643, 3644, 0, 1480, 0, 1481, 1482, + 2859, 1483, 0, 0, 0, 3626, 0, 1483, 0, 3630, + 3631, 3632, 1483, 0, 3645, 0, 1483, 0, 0, 0, + 0, 1483, 0, 0, 2904, 2907, 2908, 2909, 2905, 2805, + 2906, 2910, 0, 0, 3566, 3567, 0, 0, 0, 0, + 1483, 2804, 0, 0, 0, 3661, 0, 1483, 0, 0, + 2803, 1483, 0, 0, 0, 2802, 0, 0, 0, 0, + 2801, 0, 0, 1483, 0, 0, 0, 0, 1483, 0, + 0, 0, 0, 3672, 0, 0, 0, 2800, 0, 1483, + 0, 2799, 0, 1483, 0, 0, 1480, 0, 1481, 1482, + 0, 0, 3694, 2798, 0, 0, 0, 0, 1480, 2797, + 1481, 1482, 1483, 0, 2791, 0, 0, 1480, 2790, 1481, + 1482, 0, 1480, 2789, 1481, 1482, 1483, 1480, 3723, 1481, + 1482, 3730, 0, 3732, 0, 3713, 0, 3714, 3715, 3716, + 1483, 0, 2786, 3703, 1480, 1483, 1481, 1482, 1480, 2785, + 1481, 1482, 0, 2784, 0, 0, 3229, 0, 3733, 87, + 1480, 3229, 1481, 1482, 0, 2782, 1480, 0, 1481, 1482, + 2775, 1480, 0, 1481, 1482, 1480, 1483, 1481, 1482, 0, + 1480, 2772, 1481, 1482, 0, 2770, 0, 1483, 0, 3666, + 2138, 1483, 2136, 0, 3763, 3734, 3743, 3755, 3742, 1480, + 3753, 1481, 1482, 0, 2768, 3750, 1480, 3752, 1481, 1482, + 1480, 0, 1481, 1482, 1483, 0, 0, 0, 2727, 0, + 3622, 3623, 1480, 0, 1481, 1482, 3915, 1480, 0, 1481, + 1482, 0, 2707, 3767, 0, 0, 0, 2706, 1480, 0, + 1481, 1482, 1480, 0, 1481, 1482, 0, 0, 0, 0, + 42, 2904, 2907, 2908, 2909, 2905, 0, 2906, 2910, 0, + 0, 1480, 0, 1481, 1482, 0, 3907, 3906, 2702, 0, + 0, 0, 0, 0, 3934, 1480, 3922, 1481, 1482, 2700, + 0, 3905, 0, 2692, 3926, 3927, 0, 0, 0, 1480, + 0, 1481, 1482, 0, 1480, 0, 1481, 1482, 0, 3973, + 3974, 3077, 3078, 3079, 3080, 3081, 2663, 3757, 3764, 3765, + 0, 0, 3731, 0, 0, 3917, 3918, 3919, 2138, 0, + 2136, 3096, 3977, 0, 0, 1480, 0, 1481, 1482, 0, + 0, 0, 0, 0, 0, 0, 1480, 0, 1481, 1482, + 1480, 0, 1481, 1482, 0, 0, 0, 0, 0, 3225, + 0, 0, 3980, 0, 4022, 3229, 3983, 0, 3759, 0, + 4013, 0, 0, 1480, 0, 1481, 1482, 0, 0, 1554, + 1555, 1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564, + 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1574, 1575, + 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, + 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1594, 1595, + 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, + 1606, 1607, 1608, 1609, 1610, 1611, 1612, 1613, 1614, 1615, + 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625, + 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, + 1636, 1637, 1638, 1639, 1640, 1641, 1642, 1643, 1644, 1645, + 1646, 1647, 1648, 1649, 1650, 1651, 1653, 1654, 1655, 1656, + 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, + 1667, 1668, 1674, 1675, 1676, 1677, 1691, 1692, 1693, 1694, + 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, + 3978, 4023, 3228, 4007, 3997, 4006, 1483, 3228, 1744, 0, + 0, 4003, 0, 4005, 4041, 0, 0, 0, 0, 0, + 0, 0, 1752, 0, 0, 1745, 3910, 0, 0, 0, + 0, 3231, 87, 0, 0, 0, 4026, 0, 1717, 1483, + 0, 0, 0, 4025, 0, 0, 1744, 0, 0, 3249, + 2383, 2384, 1751, 1749, 1750, 1746, 0, 1747, 0, 4030, + 1752, 4043, 0, 1745, 0, 0, 0, 4046, 0, 0, + 4048, 0, 3914, 0, 0, 0, 0, 0, 0, 0, + 1748, 0, 0, 0, 0, 0, 0, 0, 1740, 1741, + 1751, 1749, 1750, 1746, 4055, 1747, 0, 0, 2657, 0, + 0, 0, 4065, 0, 0, 0, 0, 0, 0, 1484, + 0, 0, 0, 0, 0, 0, 0, 0, 1748, 0, + 0, 0, 0, 42, 0, 0, 4066, 0, 0, 4067, + 4091, 2652, 0, 0, 0, 87, 0, 0, 0, 0, + 1542, 0, 0, 0, 0, 0, 0, 0, 4076, 0, + 0, 0, 0, 0, 0, 1480, 0, 1481, 1482, 0, + 0, 4085, 0, 0, 1717, 0, 0, 0, 4027, 4097, + 0, 0, 0, 4095, 0, 3934, 4111, 3380, 4100, 4108, + 4105, 4102, 4101, 4099, 4104, 4103, 0, 0, 1480, 0, + 1481, 1482, 0, 0, 0, 0, 0, 0, 0, 3397, + 3398, 3228, 3399, 3401, 3403, 4130, 0, 0, 4153, 0, + 0, 0, 0, 4143, 0, 4135, 0, 4122, 4148, 0, + 0, 0, 0, 0, 4161, 0, 42, 0, 4163, 0, + 3416, 0, 0, 4174, 0, 3419, 0, 3421, 3422, 3423, + 3425, 3426, 3427, 3428, 3429, 3430, 3431, 3432, 3433, 3434, + 3435, 3436, 3437, 3439, 3441, 3443, 3445, 3447, 3449, 3451, + 3453, 3455, 3457, 3459, 3461, 3463, 3465, 3467, 3469, 3470, + 3472, 3473, 3474, 3476, 4122, 4194, 3478, 2016, 3480, 3481, + 3482, 4193, 4204, 3486, 3487, 3488, 3489, 3490, 3491, 3492, + 3493, 3494, 3495, 3496, 4210, 2138, 4208, 2136, 4197, 4207, + 4206, 4203, 3502, 4178, 4173, 4218, 3507, 4092, 4032, 4087, + 3511, 3512, 0, 3513, 3515, 4226, 3518, 3520, 3225, 3522, + 3523, 3524, 3525, 4234, 4232, 0, 0, 0, 0, 3533, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 4051, 4243, 4244, 3974, 4242, 0, 0, 0, + 0, 4122, 0, 2138, 0, 2136, 0, 4241, 0, 0, + 4039, 0, 0, 0, 3557, 3558, 0, 0, 3562, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 4169, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4086, + 1774, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 86, 44, 45, 88, 0, 0, 1863, 0, + 0, 0, 0, 3637, 0, 0, 0, 0, 0, 0, + 0, 92, 0, 0, 0, 48, 76, 77, 0, 74, + 78, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 75, 0, 0, 0, 0, 0, 1723, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3656, 0, + 0, 3660, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 62, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 95, 0, 1024, 0, 0, + 2332, 0, 0, 1025, 0, 3673, 0, 0, 0, 0, + 0, 0, 4191, 2137, 0, 0, 677, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1029, 0, 0, 0, + 0, 0, 0, 0, 0, 83, 2021, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3696, + 0, 0, 0, 0, 0, 0, 0, 0, 1100, 0, + 0, 0, 3704, 0, 0, 0, 0, 0, 0, 3711, + 0, 0, 982, 983, 984, 985, 986, 987, 988, 989, + 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, + 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, + 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, + 1020, 1021, 1022, 1023, 0, 0, 0, 0, 0, 0, + 51, 54, 57, 56, 59, 0, 73, 0, 0, 82, + 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 61, 91, 90, 0, 0, 71, 72, + 58, 0, 0, 0, 0, 0, 80, 81, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3923, 0, + 0, 0, 0, 0, 0, 0, 0, 3930, 0, 0, + 63, 64, 0, 65, 66, 67, 68, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3940, 3941, 3942, + 0, 3944, 0, 3945, 3946, 0, 0, 0, 0, 3949, + 3950, 3951, 3952, 3953, 3954, 3955, 3956, 3957, 3958, 3959, + 3960, 3961, 3962, 3963, 3964, 3965, 3966, 3967, 3968, 3969, + 3970, 0, 3972, 3975, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2089, 2090, 2091, 2092, 60, 3984, 3985, + 3986, 3987, 3988, 3990, 3991, 3993, 3995, 3996, 3998, 2105, + 0, 0, 4002, 0, 0, 0, 4004, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2144, 2145, 0, 0, 0, 0, + 2168, 4031, 0, 2172, 2173, 0, 0, 0, 2178, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2190, 2191, 2192, 2193, 2194, 2195, 2196, + 2197, 2198, 2199, 0, 2201, 0, 0, 89, 2223, 2224, + 2225, 2226, 2227, 2228, 2229, 2230, 2232, 0, 2237, 0, + 2239, 2240, 2241, 0, 2243, 2244, 2245, 0, 2247, 2248, + 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, + 2259, 2260, 2261, 2262, 2263, 2264, 2265, 2266, 2267, 2268, + 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, + 2279, 2280, 2281, 2282, 2283, 2284, 2285, 2286, 2287, 2288, + 2289, 2290, 2291, 2292, 2296, 2297, 2298, 2299, 2300, 2301, + 2302, 2303, 2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, + 2312, 2313, 2314, 2315, 2316, 2317, 2318, 0, 0, 0, + 0, 0, 2324, 0, 2326, 0, 2333, 2334, 2335, 2336, + 2337, 2338, 0, 0, 0, 0, 0, 94, 0, 0, + 0, 0, 0, 0, 0, 2349, 2350, 2351, 2352, 2353, + 2354, 2355, 2356, 0, 2358, 2359, 2360, 2361, 2362, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 190, 0, 0, 1071, 4177, 0, 0, 0, 4056, 0, + 0, 0, 0, 1826, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 129, 0, 151, 0, 0, 0, 0, + 0, 0, 4071, 0, 2403, 2404, 0, 0, 4074, 172, + 4075, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 70, 0, 0, 0, 0, 0, + 2442, 0, 0, 4090, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 162, 0, 190, 0, 0, 1826, 150, + 0, 0, 1220, 0, 1226, 0, 1881, 0, 0, 4116, + 4117, 0, 0, 0, 959, 0, 0, 0, 129, 169, + 151, 0, 170, 4124, 4126, 4128, 0, 0, 0, 0, + 0, 0, 0, 0, 172, 0, 0, 0, 0, 0, + 0, 4134, 2485, 0, 138, 139, 161, 160, 189, 0, + 0, 0, 0, 4156, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1454, 0, 162, 0, + 195, 0, 0, 195, 150, 0, 0, 730, 0, 0, + 0, 0, 736, 0, 0, 0, 0, 0, 0, 0, + 1813, 4175, 0, 195, 169, 0, 0, 170, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 195, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1885, + 1886, 161, 160, 189, 0, 4198, 4200, 4202, 0, 0, + 0, 0, 0, 0, 736, 195, 736, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 155, 136, 158, 143, 135, 1813, 156, 157, 4223, 0, + 0, 0, 0, 173, 0, 0, 0, 0, 0, 0, + 0, 0, 179, 144, 1827, 0, 4235, 4236, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 147, 145, 140, + 141, 142, 146, 0, 0, 0, 0, 0, 0, 137, + 0, 0, 0, 0, 0, 0, 0, 0, 148, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 155, 1887, 158, 0, 1884, + 0, 156, 157, 0, 0, 0, 0, 0, 173, 1827, + 1840, 1843, 1844, 1845, 1846, 1847, 1848, 179, 1849, 1850, + 1852, 1853, 1851, 1854, 1855, 1828, 1829, 1830, 1831, 1811, + 1812, 1841, 0, 1814, 0, 1815, 1816, 1817, 1818, 1819, + 1820, 1821, 1822, 1823, 0, 0, 1824, 1832, 1833, 1834, + 1835, 0, 1836, 1837, 1838, 1839, 0, 0, 1825, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 164, 0, 0, 0, 1840, 1843, 1844, 1845, 1846, + 1847, 1848, 0, 1849, 1850, 1852, 1853, 1851, 1854, 1855, + 1828, 1829, 1830, 1831, 1811, 1812, 1841, 0, 1814, 0, + 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 0, + 0, 1824, 1832, 1833, 1834, 1835, 0, 1836, 1837, 1838, + 1839, 0, 0, 1825, 0, 0, 0, 0, 0, 0, + 2661, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2667, 2668, 2669, 2670, 0, 0, 164, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 159, 0, 0, + 0, 0, 1786, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1542, 0, 0, 0, 0, + 0, 1803, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 159, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1842, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1944, 0, 152, 0, 0, 153, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1989, + 165, 0, 0, 0, 0, 0, 0, 177, 0, 0, + 0, 0, 0, 0, 0, 0, 2017, 0, 1842, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2028, 0, 0, 0, 0, 0, 0, 2032, + 0, 152, 0, 0, 153, 0, 0, 0, 185, 1774, + 2043, 2044, 2045, 2046, 2047, 2048, 2049, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 165, 0, 0, 0, 0, + 0, 0, 177, 0, 0, 0, 0, 0, 0, 0, + 0, 166, 171, 168, 174, 175, 176, 178, 180, 181, + 182, 183, 0, 0, 0, 0, 0, 184, 186, 187, + 188, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 185, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 195, + 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 166, 171, 168, 174, + 175, 176, 178, 180, 181, 182, 183, 0, 0, 0, + 0, 0, 184, 186, 187, 188, 0, 0, 736, 0, + 736, 736, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 736, 195, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1528, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2082, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3042, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3068, + 3069, 3070, 0, 0, 3072, 0, 0, 3074, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3093, 3094, 3095, + 0, 0, 0, 0, 0, 0, 3100, 0, 0, 0, + 0, 3102, 0, 0, 3104, 3105, 3106, 0, 0, 0, + 3107, 3108, 0, 0, 3109, 0, 3110, 0, 0, 0, + 0, 0, 0, 3111, 0, 3112, 0, 0, 0, 3113, + 0, 3114, 0, 0, 3115, 0, 3116, 0, 3117, 0, + 3118, 0, 3119, 0, 3120, 0, 3121, 0, 3122, 0, + 3123, 0, 3124, 0, 3125, 0, 3126, 0, 3127, 0, + 3128, 0, 3129, 0, 3130, 0, 3131, 0, 3132, 0, + 0, 0, 3133, 0, 3134, 0, 3135, 0, 0, 3136, + 0, 3137, 0, 3138, 0, 2296, 3140, 0, 0, 3142, + 0, 0, 3144, 3145, 3146, 3147, 0, 0, 0, 0, + 3148, 2296, 2296, 2296, 2296, 2296, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3158, 0, 0, 0, + 0, 0, 0, 0, 3171, 0, 0, 3175, 0, 0, + 0, 0, 0, 0, 0, 0, 3178, 3179, 3180, 3181, + 3182, 3183, 0, 0, 0, 3184, 3185, 0, 3186, 0, + 3187, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 195, 0, 0, 0, 736, 736, 0, 0, + 0, 0, 0, 0, 1071, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3220, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 736, 0, 0, 195, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3250, 736, 0, 2409, 0, 0, 0, 0, 195, 0, + 0, 2413, 736, 2416, 0, 0, 2082, 0, 0, 0, + 0, 0, 736, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 736, 0, 736, 0, 0, + 0, 0, 0, 0, 0, 736, 0, 0, 1528, 736, + 3312, 0, 736, 736, 736, 736, 0, 736, 0, 736, + 736, 0, 736, 736, 736, 736, 736, 736, 0, 0, + 0, 0, 0, 0, 0, 1528, 736, 736, 1528, 736, + 1528, 195, 736, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 736, 0, 195, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 736, 0, 0, + 736, 0, 195, 195, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3405, 0, 195, + 0, 0, 0, 0, 0, 0, 195, 0, 0, 0, + 0, 0, 0, 0, 0, 195, 195, 195, 195, 195, + 195, 195, 195, 195, 736, 3420, 0, 0, 0, 1024, + 0, 0, 0, 0, 0, 1025, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 2137, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2082, 0, 0, 0, + 0, 0, 0, 2575, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2596, 2597, 0, 0, 2601, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2606, 0, 0, 0, 0, 0, 0, 2609, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2612, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, - 1018, 1019, 1020, 1021, 1022, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 164, 0, 0, 0, 3347, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1785, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1802, 2659, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2665, 2666, 2667, 2668, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3348, 3349, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 159, 0, - 0, 1541, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1943, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1988, 0, 0, 0, 0, 0, 0, - 0, 928, 0, 0, 0, 0, 0, 932, 0, 0, - 2016, 929, 930, 0, 0, 0, 931, 933, 0, 0, - 0, 0, 0, 0, 0, 0, 2027, 0, 0, 0, - 0, 0, 0, 2031, 0, 0, 0, 152, 0, 0, - 153, 0, 0, 0, 2042, 2043, 2044, 2045, 2046, 2047, - 2048, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 165, 0, 0, 0, 0, 0, 0, 177, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1773, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 185, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 190, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1880, 0, 0, 0, - 0, 0, 195, 0, 195, 0, 0, 0, 129, 0, - 151, 0, 166, 171, 168, 174, 175, 176, 178, 180, - 181, 182, 183, 0, 172, 0, 0, 0, 184, 186, - 187, 188, 1023, 0, 0, 2331, 0, 0, 1024, 0, - 0, 735, 0, 735, 735, 0, 0, 0, 2136, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 162, 0, - 0, 0, 0, 0, 150, 735, 195, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 169, 0, 0, 170, 0, 0, - 0, 0, 0, 0, 1527, 0, 0, 2081, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1884, - 1885, 161, 160, 189, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 981, 982, 983, - 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, - 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, - 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, - 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 0, - 0, 0, 0, 0, 0, 0, 0, 3039, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3065, 3066, 3067, 0, 0, 3069, - 0, 0, 3071, 0, 0, 155, 1886, 158, 0, 1883, - 0, 156, 157, 0, 0, 0, 0, 0, 173, 0, - 0, 0, 3090, 3091, 3092, 0, 0, 179, 0, 0, - 0, 3097, 0, 0, 0, 0, 3099, 0, 0, 3101, - 3102, 3103, 0, 0, 0, 3104, 3105, 0, 0, 3106, - 0, 3107, 0, 0, 0, 0, 0, 0, 3108, 0, - 3109, 0, 0, 0, 3110, 0, 3111, 0, 0, 3112, - 0, 3113, 0, 3114, 0, 3115, 0, 3116, 0, 3117, - 0, 3118, 0, 3119, 0, 3120, 0, 3121, 0, 3122, - 0, 3123, 0, 3124, 0, 3125, 0, 3126, 0, 3127, - 0, 3128, 0, 3129, 0, 0, 0, 3130, 0, 3131, - 0, 3132, 0, 0, 3133, 0, 3134, 0, 3135, 0, - 2295, 3137, 0, 0, 3139, 0, 0, 3141, 3142, 3143, - 3144, 0, 0, 0, 0, 3145, 2295, 2295, 2295, 2295, - 2295, 0, 0, 0, 0, 195, 0, 0, 0, 735, - 735, 3155, 0, 0, 0, 164, 0, 0, 0, 3168, - 0, 0, 3172, 0, 0, 0, 0, 0, 195, 0, - 0, 3175, 3176, 3177, 3178, 3179, 3180, 0, 0, 0, - 3181, 3182, 0, 3183, 0, 3184, 0, 0, 0, 735, - 0, 0, 195, 0, 0, 0, 0, 2408, 0, 0, - 0, 0, 0, 0, 735, 2412, 0, 2415, 0, 1070, - 2081, 195, 0, 0, 0, 735, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 735, 0, 0, 0, 0, - 3217, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 735, 0, - 735, 159, 0, 0, 0, 3247, 0, 0, 735, 0, - 0, 1527, 735, 0, 0, 735, 735, 735, 735, 0, - 735, 0, 735, 735, 0, 735, 735, 735, 735, 735, - 735, 0, 0, 0, 0, 0, 0, 0, 1527, 735, - 735, 1527, 735, 1527, 195, 735, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 195, 3309, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 735, 0, 195, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 735, 0, 0, 735, 0, 195, 195, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 152, 0, 195, 153, 0, 0, 0, 0, 0, 195, - 0, 0, 0, 0, 0, 0, 0, 0, 195, 195, - 195, 195, 195, 195, 195, 195, 195, 735, 0, 0, - 0, 0, 0, 0, 165, 0, 0, 0, 0, 0, - 0, 177, 0, 0, 0, 0, 0, 0, 0, 0, - 2081, 3402, 0, 0, 1023, 0, 0, 2574, 0, 0, - 1024, 0, 0, 0, 0, 0, 0, 0, 2594, 2595, - 2136, 0, 2599, 0, 0, 0, 0, 0, 0, 3417, - 0, 0, 185, 0, 2604, 0, 0, 0, 0, 0, - 0, 2607, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2610, 0, 0, - 0, 0, 0, 0, 0, 166, 171, 168, 174, 175, - 176, 178, 180, 181, 182, 183, 0, 0, 0, 0, - 0, 184, 186, 187, 188, 0, 0, 0, 0, 981, - 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, - 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, - 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, - 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, - 1022, 0, 0, 0, 0, 0, 0, 735, 735, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, + 1018, 1019, 1020, 1021, 1022, 1023, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 736, 736, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3618, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1527, 0, 0, 0, 3615, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1527, 0, 957, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3642, 0, 0, 0, + 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1528, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3639, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3662, 0, 3663, 0, 3664, 0, + 3665, 0, 0, 0, 0, 0, 0, 0, 3668, 3669, + 0, 0, 0, 0, 0, 0, 0, 0, 3674, 0, + 0, 958, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3675, 0, 3676, 0, 3677, 0, 3678, 0, + 3679, 0, 3680, 0, 3681, 0, 3682, 0, 3683, 0, + 3684, 0, 3685, 0, 3686, 0, 3687, 0, 3688, 0, + 3689, 0, 3690, 0, 0, 3691, 0, 0, 0, 3692, + 0, 3693, 0, 0, 0, 0, 0, 3695, 0, 0, + 0, 0, 0, 713, 0, 0, 0, 0, 0, 735, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3712, + 0, 0, 0, 0, 2343, 0, 0, 0, 3717, 0, + 3718, 3719, 0, 3720, 0, 3721, 0, 0, 0, 0, + 3722, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 735, 0, 735, 0, 0, 0, 3751, 195, 0, + 0, 0, 0, 736, 0, 0, 0, 0, 0, 0, + 3760, 0, 0, 3762, 0, 0, 2917, 0, 0, 0, + 0, 0, 0, 0, 0, 3766, 0, 0, 0, 0, + 0, 0, 0, 195, 0, 0, 736, 0, 0, 0, + 0, 3902, 0, 0, 0, 0, 0, 0, 0, 0, + 195, 0, 0, 0, 736, 0, 0, 2343, 195, 0, + 195, 0, 195, 195, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 712, 0, 0, 0, 0, - 0, 734, 0, 0, 0, 0, 0, 0, 3659, 0, - 3660, 0, 3661, 0, 3662, 0, 0, 0, 0, 0, - 0, 0, 3665, 3666, 0, 0, 0, 0, 0, 0, - 0, 0, 3671, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3672, 0, 3673, 0, - 3674, 0, 3675, 734, 3676, 734, 3677, 0, 3678, 0, - 3679, 0, 3680, 0, 3681, 0, 3682, 2342, 3683, 0, - 3684, 0, 3685, 0, 3686, 0, 3687, 0, 0, 3688, - 0, 0, 0, 3689, 0, 3690, 0, 0, 0, 0, - 0, 3692, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 2966, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 195, 0, 3709, 0, 0, 735, 0, 0, 0, - 2915, 0, 3714, 0, 3715, 3716, 0, 3717, 0, 3718, - 0, 0, 0, 0, 3719, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 195, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3748, 0, 195, 0, 0, 0, 735, 0, 0, - 2342, 195, 0, 195, 3757, 195, 195, 3759, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3763, - 735, 0, 0, 0, 0, 2964, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 3899, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 736, 0, 0, 0, 0, + 0, 0, 736, 736, 736, 195, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3014, 3015, 3016, + 3017, 3018, 3019, 736, 0, 0, 0, 0, 0, 736, + 736, 0, 0, 736, 0, 736, 0, 0, 0, 0, + 4012, 736, 0, 0, 0, 0, 2082, 3030, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 735, 0, - 0, 0, 0, 0, 0, 735, 735, 735, 195, 0, - 0, 3012, 3013, 3014, 3015, 3016, 3017, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 735, 0, 0, 0, - 0, 0, 735, 735, 0, 0, 735, 0, 735, 2081, - 3027, 0, 0, 0, 735, 0, 0, 0, 0, 0, + 0, 3038, 0, 0, 0, 0, 736, 0, 0, 0, + 0, 736, 0, 0, 0, 736, 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3035, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 735, - 0, 0, 0, 0, 735, 0, 0, 0, 735, 735, - 0, 0, 0, 0, 4009, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 195, 195, 0, 0, 195, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 195, 0, 0, 0, 914, 0, 0, 195, 0, 0, + 0, 195, 195, 0, 0, 195, 0, 195, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 195, 0, 0, + 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, - 195, 0, 0, 0, 0, 735, 0, 0, 0, 0, + 195, 0, 0, 0, 0, 0, 0, 195, 0, 0, + 0, 0, 736, 95, 0, 0, 1024, 0, 0, 0, + 0, 964, 1025, 977, 978, 979, 965, 0, 0, 966, + 967, 0, 968, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 973, 0, + 980, 981, 0, 0, 0, 0, 0, 4054, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1528, 0, 2343, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3348, + 3349, 0, 0, 4068, 0, 0, 4069, 0, 4070, 0, + 0, 982, 983, 984, 985, 986, 987, 988, 989, 990, + 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, + 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, + 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, + 1021, 1022, 1023, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 733, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3350, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 4154, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3302, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 4170, + 0, 4171, 0, 4172, 0, 0, 0, 0, 0, 0, + 0, 3340, 0, 0, 0, 735, 1439, 735, 735, 0, + 0, 0, 0, 0, 0, 3354, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3351, 3352, 0, 0, 735, + 0, 0, 0, 0, 0, 0, 3372, 0, 0, 3375, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1527, - 0, 2342, 0, 0, 1095, 0, 1102, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1527, 0, + 0, 195, 0, 4221, 0, 4222, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 4051, 0, 0, 0, 0, 0, 0, 0, 0, + 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 929, 0, 0, 0, 0, 0, 933, 0, 195, 0, + 930, 931, 0, 195, 0, 932, 934, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 4065, 0, 0, - 4066, 0, 4067, 0, 0, 0, 0, 0, 0, 0, + 915, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 734, 1438, 734, 734, - 0, 0, 0, 0, 0, 0, 0, 0, 3299, 0, + 0, 0, 736, 0, 0, 0, 0, 0, 195, 0, + 0, 0, 0, 0, 3535, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 734, 736, + 0, 0, 0, 0, 0, 0, 736, 0, 0, 0, + 736, 736, 0, 0, 0, 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3337, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3351, 1526, - 0, 0, 0, 0, 4151, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3369, 0, - 0, 3372, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4167, 0, 4168, 0, 4169, 0, 0, + 0, 1528, 736, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 195, 195, 195, 195, 195, 195, + 1096, 0, 1103, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3596, + 0, 0, 0, 195, 195, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3611, + 0, 3612, 3613, 3614, 0, 0, 0, 0, 195, 0, + 0, 0, 0, 735, 735, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, - 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 735, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 735, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 735, + 0, 0, 0, 0, 736, 0, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 4218, 0, 4219, - 0, 195, 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 735, 0, 735, 0, 0, 0, 0, 0, + 0, 0, 735, 0, 0, 1527, 735, 0, 0, 735, + 735, 735, 735, 0, 735, 0, 735, 735, 0, 735, + 735, 735, 735, 735, 735, 0, 0, 0, 0, 0, + 0, 0, 1527, 735, 735, 1527, 735, 1527, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 735, 0, 0, 0, 0, 0, 0, 0, 736, + 0, 0, 0, 0, 735, 0, 0, 735, 0, 0, + 0, 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 735, 3532, 0, 0, 0, - 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 736, 0, 0, 0, 0, 0, 0, 0, + 0, 735, 0, 0, 0, 0, 0, 195, 0, 0, + 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 736, 0, 0, 0, 1528, 0, + 0, 736, 736, 1528, 195, 195, 195, 195, 195, 0, + 0, 0, 0, 0, 0, 0, 195, 0, 0, 0, + 0, 0, 195, 0, 195, 0, 0, 195, 195, 195, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 735, 0, 0, 0, 0, 0, 0, 735, - 0, 0, 0, 735, 735, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1527, 735, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 195, 195, 195, - 195, 195, 195, 0, 734, 734, 0, 0, 0, 0, - 0, 3593, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 195, 195, 0, 0, 0, - 0, 3608, 0, 3609, 3610, 3611, 0, 0, 0, 0, - 0, 0, 0, 0, 734, 0, 0, 0, 0, 0, - 195, 0, 0, 0, 0, 0, 0, 0, 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 734, 0, 0, 0, 0, 0, 735, 0, 0, 0, - 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 736, 0, 0, 1528, 0, + 0, 0, 0, 736, 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 734, 0, 734, 0, 0, 0, 0, - 0, 0, 0, 734, 0, 0, 1526, 734, 0, 0, - 734, 734, 734, 734, 0, 734, 735, 734, 734, 0, - 734, 734, 734, 734, 734, 734, 0, 0, 0, 0, - 0, 0, 0, 1526, 734, 734, 1526, 734, 1526, 0, - 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1283, 0, 1283, - 1283, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 734, 0, 0, 0, 0, 0, 0, 0, - 0, 1452, 0, 0, 0, 734, 0, 0, 734, 0, + 0, 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 195, 0, 0, 195, 0, 0, 0, + 0, 735, 735, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 735, 734, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 735, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1527, 0, 0, + 0, 0, 0, 0, 0, 0, 2146, 0, 0, 0, + 0, 0, 0, 0, 0, 1527, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 736, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1284, 0, 1284, 1284, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1453, 0, + 0, 195, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 916, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 4052, 0, 0, 195, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 735, 0, 0, 0, 0, 195, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 193, 0, 0, 678, 0, 0, 195, 0, 195, 195, + 195, 0, 0, 0, 0, 0, 0, 0, 736, 736, + 0, 0, 0, 678, 0, 0, 0, 0, 0, 0, + 735, 0, 0, 0, 0, 0, 0, 0, 0, 1052, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1072, 1072, 0, 0, + 0, 0, 0, 735, 0, 678, 0, 736, 736, 736, + 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 735, 0, 0, 735, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 735, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 195, - 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 735, 0, 0, 0, - 1527, 0, 0, 735, 735, 1527, 195, 195, 195, 195, - 195, 0, 0, 0, 0, 0, 0, 0, 195, 0, - 0, 0, 0, 0, 195, 0, 195, 0, 0, 195, - 195, 195, 915, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 195, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 735, 193, 0, - 1527, 677, 734, 734, 0, 735, 0, 0, 0, 0, - 195, 0, 0, 0, 0, 0, 0, 734, 0, 0, - 0, 677, 0, 0, 195, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1051, 0, 0, - 0, 0, 0, 0, 195, 0, 0, 195, 0, 0, - 0, 0, 0, 0, 1071, 1071, 0, 0, 0, 0, - 0, 0, 0, 677, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1725, 1726, 0, 734, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1526, 0, - 0, 0, 0, 0, 0, 0, 0, 2145, 0, 0, - 0, 0, 0, 0, 0, 0, 1526, 0, 0, 0, - 0, 0, 0, 0, 0, 1779, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1797, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1856, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1865, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1095, 735, 1892, 0, 0, 0, - 0, 0, 0, 0, 1901, 0, 0, 0, 1903, 0, - 0, 1906, 1907, 1909, 1909, 0, 1909, 0, 1909, 1909, - 0, 1918, 1909, 1909, 1909, 1909, 1909, 0, 0, 0, - 0, 0, 195, 0, 0, 1938, 1939, 0, 1095, 0, - 0, 1944, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 734, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1986, 0, 0, 4049, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2008, 0, 195, 2012, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 734, 0, 0, 0, 0, 0, 195, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1283, 0, 0, 0, 195, 0, 195, - 195, 195, 0, 0, 734, 0, 0, 0, 0, 735, - 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 734, 0, 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 734, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 735, 735, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 735, 0, 0, 0, 0, 0, 0, 735, 735, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 735, 0, 1726, 1727, 0, 0, 735, 735, 0, 0, + 735, 0, 735, 0, 0, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 734, 0, 0, 0, 0, 0, 0, - 734, 734, 734, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1780, 0, 736, 0, 736, 0, 195, 0, + 0, 0, 0, 735, 0, 0, 0, 1798, 735, 0, + 0, 0, 735, 735, 0, 0, 0, 1528, 1857, 0, + 0, 195, 0, 0, 736, 0, 736, 0, 1866, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 734, 0, 0, 0, 0, 0, 734, 734, 0, - 0, 734, 0, 734, 0, 0, 0, 0, 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1283, 1283, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2069, 0, - 0, 0, 0, 0, 734, 0, 0, 0, 0, 734, - 0, 0, 0, 734, 734, 0, 0, 0, 0, 0, + 0, 1096, 0, 1893, 0, 0, 0, 0, 0, 0, + 0, 1902, 0, 0, 0, 1904, 0, 0, 1907, 1908, + 1910, 1910, 0, 1910, 0, 1910, 1910, 0, 1919, 1910, + 1910, 1910, 1910, 1910, 736, 0, 0, 0, 0, 0, + 0, 0, 1939, 1940, 0, 1096, 0, 195, 1945, 0, + 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 736, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 735, + 1987, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2009, 0, 0, 2013, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 735, 0, 735, 0, 195, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2131, - 0, 0, 0, 0, 0, 0, 0, 0, 1527, 0, - 0, 0, 195, 0, 0, 735, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 736, 0, + 1284, 0, 0, 0, 0, 736, 0, 736, 0, 0, + 0, 0, 0, 1527, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 677, 0, 677, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 734, 0, 0, 0, 0, 735, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 195, 0, - 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 677, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1526, 0, 734, 0, 1528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1283, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 735, - 0, 0, 0, 0, 0, 0, 735, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2379, 0, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2392, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1779, 0, 0, 1283, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1095, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1284, 1284, 0, 0, 0, 0, 736, 0, 0, 0, + 0, 0, 0, 0, 0, 2070, 0, 0, 0, 678, + 0, 678, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 736, 195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1102, 0, 0, 0, 0, 0, - 0, 2505, 2506, 2507, 0, 0, 0, 735, 0, 0, + 0, 0, 0, 0, 0, 0, 2132, 0, 0, 0, + 0, 0, 0, 678, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1095, 195, 0, 0, 0, 0, 1102, 1901, - 0, 0, 1901, 0, 1901, 0, 0, 0, 734, 0, - 2538, 735, 195, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 734, 0, 0, 0, 0, 0, 0, 677, + 0, 735, 0, 0, 0, 0, 736, 0, 0, 0, + 0, 1529, 0, 0, 0, 0, 736, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1528, 736, 0, 736, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1095, 0, 0, 0, 0, - 2131, 0, 1051, 0, 2131, 2131, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2928, 0, 0, - 0, 0, 0, 0, 0, 0, 677, 735, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 735, 0, 0, - 0, 0, 0, 0, 0, 677, 0, 1527, 735, 0, + 0, 0, 0, 0, 0, 0, 2930, 0, 0, 0, + 0, 0, 0, 0, 736, 2343, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 195, 736, 0, 0, 735, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 735, 0, 0, 0, + 0, 0, 0, 735, 0, 0, 736, 735, 735, 0, + 1284, 0, 735, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1527, 735, + 736, 0, 0, 0, 0, 195, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 736, + 0, 736, 0, 0, 0, 0, 0, 0, 0, 2380, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2393, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1780, 0, 0, 1284, 0, 0, 0, 0, 0, 0, + 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1096, 0, 0, 0, 0, 0, 0, + 0, 0, 678, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1052, 0, 0, 0, 0, + 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 678, + 0, 1103, 0, 0, 0, 0, 0, 0, 2506, 2507, + 2508, 0, 0, 0, 0, 0, 0, 0, 678, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1096, + 0, 0, 0, 0, 0, 1103, 1902, 0, 0, 1902, + 0, 1902, 0, 0, 0, 0, 0, 2539, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1529, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1096, 0, 0, 0, 0, 2132, 0, 0, + 0, 2132, 2132, 0, 0, 1529, 735, 0, 1529, 0, + 1529, 678, 0, 0, 0, 0, 0, 0, 735, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1961, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 678, 0, 0, 735, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2015, 678, 0, 0, 0, 735, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 678, + 0, 735, 0, 0, 0, 1527, 678, 0, 735, 735, + 1527, 0, 0, 0, 0, 2041, 2042, 678, 678, 678, + 678, 678, 678, 678, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2617, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3298, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 735, 0, 0, 1527, 0, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1284, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 734, 0, 0, 0, 0, 735, 2342, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1528, 0, 734, 0, 0, - 0, 0, 0, 0, 734, 0, 0, 0, 734, 734, - 0, 0, 0, 734, 0, 0, 195, 735, 0, 0, - 0, 2615, 1528, 0, 0, 1528, 0, 1528, 677, 1526, - 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1960, 0, - 0, 0, 0, 0, 0, 0, 0, 735, 0, 0, - 0, 0, 0, 677, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2014, - 677, 735, 0, 0, 0, 0, 195, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 677, 1283, 0, 0, - 735, 0, 735, 677, 0, 0, 0, 0, 0, 0, - 0, 0, 2040, 2041, 677, 677, 677, 677, 677, 677, - 677, 734, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3379, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, + 1529, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1529, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2865, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 734, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 734, 0, + 2880, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3586, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 677, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 734, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2863, - 0, 0, 0, 0, 0, 0, 0, 734, 0, 0, - 0, 0, 0, 2878, 0, 0, 0, 0, 0, 0, - 0, 734, 0, 0, 0, 1526, 0, 0, 734, 734, - 1526, 0, 0, 0, 0, 0, 0, 1528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 735, 735, 0, 0, 0, + 0, 0, 0, 0, 2015, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3295, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2962, 0, + 0, 0, 0, 0, 735, 735, 735, 735, 1961, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2960, 734, 0, 0, 1526, 0, 0, 0, 0, - 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2392, 0, - 0, 0, 0, 0, 0, 2984, 0, 0, 0, 1901, - 1901, 0, 0, 0, 2989, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1072, 2393, 0, 0, 0, 0, + 0, 0, 2986, 0, 0, 0, 1902, 1902, 0, 0, + 0, 2991, 0, 1052, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3002, 0, + 678, 0, 0, 0, 0, 0, 0, 2015, 678, 0, + 678, 0, 678, 2432, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3000, 3376, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2014, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1960, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1071, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2131, 0, 0, 0, 0, 0, 0, 0, - 1051, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 677, 0, 0, - 734, 0, 0, 0, 2014, 677, 0, 677, 0, 677, - 2431, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2131, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2132, 0, 0, 0, 0, 2509, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 735, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1527, 0, 0, 0, 0, 0, + 2132, 735, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2508, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3583, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3157, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1283, - 0, 0, 0, 0, 734, 734, 0, 0, 0, 0, + 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 678, 0, 0, 0, 735, 0, 0, + 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 735, 678, 678, 0, 0, 678, 0, 2603, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 678, 0, 0, + 0, 0, 0, 0, 678, 3160, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1284, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 678, 0, 0, 0, 0, 0, 0, 2614, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1910, 0, + 0, 0, 0, 0, 0, 735, 0, 0, 0, 0, + 0, 0, 735, 0, 735, 0, 3205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1284, 0, 0, 0, 0, 0, 0, 3232, 1910, 0, + 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1529, 0, 2015, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1909, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3202, 0, - 0, 0, 0, 734, 734, 734, 734, 0, 0, 0, - 677, 0, 1283, 0, 0, 0, 0, 677, 0, 3229, - 1909, 0, 0, 0, 0, 0, 0, 0, 677, 677, - 0, 0, 677, 0, 2601, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 677, 0, 0, 0, 0, 0, - 0, 677, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 677, 0, 0, - 0, 0, 0, 0, 2612, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1095, 0, 0, 0, 0, 0, 0, - 0, 2392, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1096, 0, 0, 0, 0, 0, 0, 0, 2393, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1528, 0, 2014, 0, 0, 0, 0, - 734, 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1526, 0, 0, 0, 0, 0, 0, - 734, 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 734, 0, 0, 0, - 0, 1856, 0, 0, 0, 0, 0, 0, 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, + 0, 678, 0, 735, 0, 0, 0, 0, 0, 1961, + 1857, 0, 0, 1527, 735, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 734, 0, 0, 0, 0, 0, - 0, 734, 0, 734, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 677, 0, - 0, 0, 0, 0, 0, 0, 1960, 0, 0, 0, - 0, 0, 734, 0, 0, 0, 0, 0, 0, 0, + 0, 735, 735, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 678, 0, + 0, 0, 0, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2392, 2392, 0, 0, 0, - 0, 0, 0, 0, 0, 677, 0, 0, 0, 0, - 677, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3647, 3648, 3649, 3650, 0, 0, + 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 678, 0, + 0, 0, 0, 0, 0, 0, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2393, 2393, 735, 0, 735, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 677, 0, 0, 0, 0, + 0, 1529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 678, 678, 678, 678, 678, 678, + 0, 0, 0, 3650, 3651, 3652, 3653, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 734, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 678, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 734, 0, 1528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 677, 677, 677, 677, 677, 677, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 677, - 677, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 734, 0, 677, 0, 0, 0, 0, 0, - 0, 3725, 734, 3725, 0, 0, 0, 0, 0, 0, - 0, 0, 1526, 734, 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 3753, 0, 3755, 0, 0, 0, 0, 0, 0, - 734, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 734, 0, 0, 0, 0, 0, 0, 0, - 0, 2392, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3922, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1283, 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 734, 0, 734, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3728, 0, 3728, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 3725, 0, 0, 0, 0, - 0, 0, 3725, 0, 3725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3756, 0, 3758, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 2392, 0, 0, 0, 0, 0, 0, - 0, 1071, 0, 677, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1528, 0, 0, 0, 0, 1528, - 677, 677, 677, 677, 677, 0, 0, 0, 0, 0, - 0, 0, 3245, 0, 0, 0, 0, 0, 1960, 0, - 677, 0, 0, 677, 3253, 2014, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 677, 0, + 2393, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3925, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1284, + 0, 0, 0, 0, 0, 1072, 0, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1528, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 677, 0, 0, 0, 0, 0, - 0, 0, 0, 2392, 0, 0, 0, 0, 677, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1529, 0, + 0, 0, 0, 1529, 678, 678, 678, 678, 678, 0, + 0, 0, 0, 0, 0, 0, 3248, 0, 0, 0, + 0, 0, 1961, 0, 678, 0, 0, 678, 3256, 2015, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 677, 0, - 0, 677, 0, 0, 0, 0, 0, 2392, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3785, - 3787, 3786, 3852, 3853, 3854, 3855, 3856, 3857, 3858, 3788, - 3789, 805, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3728, 0, 0, 0, 0, 0, + 0, 3728, 0, 3728, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 678, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2393, 0, 0, 0, 0, 0, 1529, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4069, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4077, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2392, 0, 4085, 0, 0, 0, + 0, 0, 0, 678, 0, 0, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1283, 1283, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4135, 0, 0, 677, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 4077, 0, 0, 0, 0, 0, 0, + 0, 0, 2393, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 677, 0, 0, 0, 0, 2392, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1856, 0, 4135, 0, - 0, 677, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3793, 0, 0, 0, 0, 0, 0, 0, - 0, 677, 0, 677, 677, 677, 0, 3801, 3802, 0, - 0, 3877, 3876, 3875, 0, 0, 3873, 3874, 3872, 0, + 0, 0, 0, 0, 0, 0, 2393, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3878, 928, 0, 781, 782, 3879, 3880, 932, - 3881, 784, 785, 929, 930, 0, 779, 783, 931, 933, + 0, 0, 4072, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 4080, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2393, 0, 4088, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1284, 1284, 3788, 3790, 3789, 3855, 3856, 3857, 3858, 3859, + 3860, 3861, 3791, 3792, 806, 0, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 678, 0, 678, 678, + 678, 0, 4138, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 3782, 3783, 3784, 3790, 3791, - 3792, 3803, 3850, 3851, 3859, 3861, 884, 3860, 3862, 3863, - 3864, 3867, 3868, 3869, 3870, 3865, 3866, 3871, 3765, 3769, - 3766, 3767, 3768, 3780, 3770, 3771, 3772, 3773, 3774, 3775, - 3776, 3777, 3778, 3779, 3781, 3882, 3883, 3884, 3885, 3886, - 3887, 3796, 3800, 3799, 3797, 3798, 3794, 3795, 3822, 3821, - 3823, 3824, 3825, 3826, 3827, 3828, 3830, 3829, 3831, 3832, - 3833, 3834, 3835, 3836, 3804, 3805, 3808, 3809, 3807, 3806, - 3810, 3819, 3820, 3811, 3812, 3813, 3814, 3815, 3816, 3818, - 3817, 3837, 3838, 3839, 3840, 3841, 3843, 3842, 3846, 3847, - 3845, 3844, 3849, 3848, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1960, 0, 0, 0, 934, 0, 935, - 0, 0, 939, 0, 0, 0, 941, 940, 0, 942, - 904, 903, 1528, 0, 936, 937, 1960, 938, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 4080, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2393, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1857, 0, 4138, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3888, 3889, 3890, 3891, 3892, 3893, 3894, 3895, - 0, 0, 1960, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -2870,1620 +2883,1793 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3796, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3804, 3805, 0, 0, 3880, 3879, 3878, 1961, 0, + 3876, 3877, 3875, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1529, 0, 0, + 0, 1961, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3881, 929, 0, 782, + 783, 3882, 3883, 933, 3884, 785, 786, 930, 931, 0, + 780, 784, 932, 934, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1961, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3785, + 3786, 3787, 3793, 3794, 3795, 3806, 3853, 3854, 3862, 3864, + 885, 3863, 3865, 3866, 3867, 3870, 3871, 3872, 3873, 3868, + 3869, 3874, 3768, 3772, 3769, 3770, 3771, 3783, 3773, 3774, + 3775, 3776, 3777, 3778, 3779, 3780, 3781, 3782, 3784, 3885, + 3886, 3887, 3888, 3889, 3890, 3799, 3803, 3802, 3800, 3801, + 3797, 3798, 3825, 3824, 3826, 3827, 3828, 3829, 3830, 3831, + 3833, 3832, 3834, 3835, 3836, 3837, 3838, 3839, 3807, 3808, + 3811, 3812, 3810, 3809, 3813, 3822, 3823, 3814, 3815, 3816, + 3817, 3818, 3819, 3821, 3820, 3840, 3841, 3842, 3843, 3844, + 3846, 3845, 3849, 3850, 3848, 3847, 3852, 3851, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 935, 0, 936, 0, 0, 940, 0, 0, 0, + 942, 941, 0, 943, 905, 904, 0, 0, 937, 938, + 0, 939, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3891, 3892, 3893, 3894, + 3895, 3896, 3897, 3898, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1961, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 678, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1960, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 677, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1529, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4110, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1528, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 4107, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1960, 0, 0, 396, 0, 0, 0, 0, 0, 0, - 1421, 1405, 528, 0, 1347, 1424, 1315, 1334, 1434, 1337, - 1340, 1384, 1293, 1362, 416, 1331, 1319, 1288, 1326, 1289, - 1317, 1349, 270, 1314, 1407, 1366, 1423, 366, 267, 1295, - 1286, 204, 505, 1320, 430, 1336, 203, 1386, 487, 252, - 377, 374, 583, 282, 273, 269, 250, 317, 385, 428, - 518, 422, 1430, 370, 1372, 0, 497, 401, 0, 0, - 2014, 1411, 1410, 1341, 1351, 1413, 1360, 1398, 1346, 1385, - 1303, 1371, 1425, 1332, 1381, 1426, 323, 248, 325, 202, - 413, 498, 286, 0, 0, 0, 0, 4109, 507, 959, - 0, 0, 0, 0, 4110, 0, 0, 0, 0, 238, - 0, 0, 245, 0, 0, 0, 351, 360, 359, 339, - 340, 342, 344, 350, 357, 363, 336, 345, 1328, 1378, - 609, 1420, 1329, 1380, 265, 321, 272, 264, 580, 1431, - 1412, 1292, 1359, 1419, 1354, 596, 0, 0, 229, 1422, - 1353, 0, 1383, 0, 1437, 1287, 1374, 0, 1290, 1294, - 1433, 1417, 1323, 275, 0, 0, 0, 0, 0, 0, - 0, 1350, 1361, 1395, 1399, 1344, 0, 0, 0, 0, - 0, 0, 0, 0, 1321, 0, 1370, 0, 0, 0, - 1299, 1291, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1348, 0, 0, 0, 0, 1302, - 0, 1322, 1396, 0, 1285, 297, 1296, 402, 257, 0, - 453, 1403, 1416, 1345, 629, 1418, 1343, 1342, 1390, 1300, - 1409, 1335, 365, 1298, 330, 197, 225, 0, 1333, 412, - 461, 473, 1408, 1318, 1327, 253, 1325, 471, 426, 604, - 233, 284, 458, 432, 469, 440, 287, 1369, 1388, 470, - 372, 585, 450, 601, 630, 631, 263, 406, 615, 522, - 623, 648, 226, 260, 420, 506, 607, 494, 397, 581, - 582, 329, 493, 295, 201, 369, 636, 224, 479, 371, - 242, 231, 587, 612, 299, 289, 456, 643, 213, 517, - 598, 239, 483, 0, 0, 651, 247, 504, 610, 599, - 215, 594, 503, 393, 326, 327, 214, 0, 457, 268, - 293, 0, 0, 258, 415, 589, 590, 256, 652, 228, - 622, 220, 1297, 621, 408, 584, 595, 394, 383, 219, - 593, 392, 382, 334, 355, 356, 280, 307, 447, 375, - 448, 306, 308, 404, 403, 405, 207, 608, 626, 0, - 208, 0, 499, 611, 653, 452, 212, 234, 235, 237, - 1313, 279, 283, 291, 294, 303, 304, 313, 367, 419, - 446, 442, 451, 1404, 579, 602, 616, 628, 634, 635, - 637, 638, 639, 640, 641, 644, 642, 407, 311, 495, - 333, 373, 1393, 1436, 425, 472, 240, 606, 496, 199, - 1307, 1312, 1305, 0, 254, 255, 1375, 575, 1308, 1306, - 1364, 1365, 1309, 1427, 1428, 1429, 1414, 654, 655, 656, - 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, - 667, 668, 669, 670, 671, 649, 508, 514, 509, 510, - 511, 512, 513, 0, 515, 1397, 1301, 0, 1310, 1311, - 398, 1406, 591, 592, 672, 384, 486, 603, 335, 349, - 352, 341, 361, 0, 362, 337, 338, 343, 346, 347, - 348, 353, 354, 358, 364, 249, 210, 390, 399, 578, - 312, 216, 217, 218, 524, 525, 526, 527, 619, 620, - 624, 205, 462, 463, 464, 465, 292, 614, 309, 468, - 467, 331, 332, 379, 449, 540, 542, 553, 557, 559, - 561, 567, 570, 541, 543, 554, 558, 560, 562, 568, - 571, 530, 532, 534, 536, 549, 548, 545, 573, 574, - 551, 556, 535, 547, 552, 565, 572, 569, 529, 533, - 537, 546, 564, 563, 544, 555, 566, 550, 538, 531, - 539, 1368, 196, 221, 368, 1432, 454, 288, 650, 618, - 484, 613, 206, 223, 1304, 262, 1316, 1324, 0, 1330, - 1338, 1339, 1352, 1355, 1356, 1357, 1358, 1376, 1377, 1379, - 1387, 1389, 1392, 1394, 1401, 1415, 1435, 198, 200, 209, - 222, 232, 236, 243, 261, 276, 278, 285, 298, 310, - 318, 319, 322, 328, 380, 386, 387, 388, 389, 409, - 410, 411, 414, 417, 418, 421, 423, 424, 427, 431, - 435, 436, 437, 439, 441, 443, 455, 460, 474, 475, - 476, 477, 478, 481, 482, 488, 489, 490, 491, 492, - 500, 501, 516, 586, 588, 605, 625, 632, 480, 301, - 302, 444, 445, 314, 315, 646, 647, 300, 600, 633, - 597, 645, 627, 438, 378, 1367, 1373, 381, 281, 305, - 320, 1382, 617, 502, 227, 466, 290, 251, 1400, 1402, - 211, 246, 230, 259, 274, 277, 324, 391, 400, 429, - 434, 296, 271, 244, 459, 241, 485, 519, 520, 521, - 523, 395, 266, 433, 1363, 1391, 376, 576, 577, 316, - 396, 0, 0, 0, 0, 0, 0, 1421, 1405, 528, - 0, 1347, 1424, 1315, 1334, 1434, 1337, 1340, 1384, 1293, - 1362, 416, 1331, 1319, 1288, 1326, 1289, 1317, 1349, 270, - 1314, 1407, 1366, 1423, 366, 267, 1295, 1286, 204, 505, - 1320, 430, 1336, 203, 1386, 487, 252, 377, 374, 583, - 282, 273, 269, 250, 317, 385, 428, 518, 422, 1430, - 370, 1372, 0, 497, 401, 0, 0, 0, 1411, 1410, - 1341, 1351, 1413, 1360, 1398, 1346, 1385, 1303, 1371, 1425, - 1332, 1381, 1426, 323, 248, 325, 202, 413, 498, 286, - 0, 0, 0, 0, 0, 507, 194, 0, 0, 0, + 0, 0, 0, 0, 0, 1961, 0, 0, 397, 0, + 0, 0, 0, 0, 0, 1422, 1406, 529, 0, 1348, + 1425, 1316, 1335, 1435, 1338, 1341, 1385, 1294, 1363, 417, + 1332, 1320, 1289, 1327, 1290, 1318, 1350, 271, 1315, 1408, + 1367, 1424, 367, 268, 1296, 1287, 204, 506, 1321, 431, + 1337, 203, 1387, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 1431, 371, 1373, + 0, 498, 402, 0, 0, 2015, 1412, 1411, 1342, 1352, + 1414, 1361, 1399, 1347, 1386, 1304, 1372, 1426, 1333, 1382, + 1427, 324, 248, 326, 202, 414, 499, 287, 0, 0, + 0, 0, 4112, 508, 960, 0, 0, 0, 0, 4113, + 0, 0, 0, 0, 238, 0, 0, 245, 0, 0, + 0, 352, 361, 360, 340, 341, 343, 345, 351, 358, + 364, 337, 346, 1329, 1379, 610, 1421, 1330, 1381, 266, + 322, 273, 265, 581, 1432, 1413, 1293, 1360, 1420, 1355, + 597, 0, 0, 229, 1423, 1354, 0, 1384, 0, 1438, + 1288, 1375, 0, 1291, 1295, 1434, 1418, 1324, 276, 0, + 0, 0, 0, 0, 0, 0, 1351, 1362, 1396, 1400, + 1345, 0, 0, 0, 0, 0, 0, 0, 0, 1322, + 0, 1371, 0, 0, 0, 1300, 1292, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1349, + 0, 0, 0, 0, 1303, 0, 1323, 1397, 0, 1286, + 298, 1297, 403, 258, 0, 454, 1404, 1417, 1346, 630, + 1419, 1344, 1343, 1391, 1301, 1410, 1336, 366, 1299, 331, + 197, 225, 0, 1334, 413, 462, 474, 1409, 1319, 1328, + 254, 1326, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 1370, 1389, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 590, 591, 257, 653, 228, 623, 220, 1298, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 356, 357, 281, 308, 448, 376, 449, 307, 309, 405, + 404, 406, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 1314, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 1405, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 1394, 1437, + 426, 473, 240, 607, 497, 199, 1308, 1313, 1306, 0, + 255, 256, 1376, 576, 1309, 1307, 1365, 1366, 1310, 1428, + 1429, 1430, 1415, 655, 656, 657, 658, 659, 660, 661, + 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 1398, 1302, 0, 1311, 1312, 399, 1407, 592, 593, + 673, 385, 487, 604, 336, 350, 353, 342, 362, 0, + 363, 338, 339, 344, 347, 348, 349, 354, 355, 359, + 365, 249, 210, 391, 400, 579, 313, 216, 217, 218, + 525, 526, 527, 528, 620, 621, 625, 205, 463, 464, + 465, 466, 293, 615, 310, 469, 468, 332, 333, 380, + 450, 541, 543, 554, 558, 560, 562, 568, 571, 542, + 544, 555, 559, 561, 563, 569, 572, 531, 533, 535, + 537, 550, 549, 546, 574, 575, 552, 557, 536, 548, + 553, 566, 573, 570, 530, 534, 538, 547, 565, 564, + 545, 556, 567, 551, 539, 532, 540, 1369, 196, 221, + 369, 1433, 455, 289, 651, 619, 485, 614, 206, 223, + 1305, 263, 1317, 1325, 0, 1331, 1339, 1340, 1353, 1356, + 1357, 1358, 1359, 1377, 1378, 1380, 1388, 1390, 1393, 1395, + 1402, 1416, 1436, 198, 200, 209, 222, 232, 236, 243, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 302, 303, 445, 446, 315, + 316, 647, 648, 301, 601, 634, 598, 646, 628, 439, + 379, 1368, 1374, 382, 282, 306, 321, 1383, 618, 503, + 227, 467, 291, 251, 1401, 1403, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 1364, 1392, 377, 577, 578, 317, 397, 0, 0, 0, + 0, 0, 0, 1422, 1406, 529, 0, 1348, 1425, 1316, + 1335, 1435, 1338, 1341, 1385, 1294, 1363, 417, 1332, 1320, + 1289, 1327, 1290, 1318, 1350, 271, 1315, 1408, 1367, 1424, + 367, 268, 1296, 1287, 204, 506, 1321, 431, 1337, 203, + 1387, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 1431, 371, 1373, 0, 498, + 402, 0, 0, 0, 1412, 1411, 1342, 1352, 1414, 1361, + 1399, 1347, 1386, 1304, 1372, 1426, 1333, 1382, 1427, 324, + 248, 326, 202, 414, 499, 287, 0, 0, 0, 0, + 0, 508, 194, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 238, 0, 0, 245, 0, 0, 0, 352, + 361, 360, 340, 341, 343, 345, 351, 358, 364, 337, + 346, 1329, 1379, 610, 1421, 1330, 1381, 266, 322, 273, + 265, 581, 1432, 1413, 1293, 1360, 1420, 1355, 597, 0, + 0, 229, 1423, 1354, 0, 1384, 0, 1438, 1288, 1375, + 0, 1291, 1295, 1434, 1418, 1324, 276, 0, 0, 0, + 0, 0, 0, 0, 1351, 1362, 1396, 1400, 1345, 0, + 0, 0, 0, 0, 0, 3257, 0, 1322, 0, 1371, + 0, 0, 0, 1300, 1292, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1349, 0, 0, + 0, 0, 1303, 0, 1323, 1397, 0, 1286, 298, 1297, + 403, 258, 0, 454, 1404, 1417, 1346, 630, 1419, 1344, + 1343, 1391, 1301, 1410, 1336, 366, 1299, 331, 197, 225, + 0, 1334, 413, 462, 474, 1409, 1319, 1328, 254, 1326, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 1370, 1389, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 590, + 591, 257, 653, 228, 623, 220, 1298, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 356, 357, + 281, 308, 448, 376, 449, 307, 309, 405, 404, 406, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 1314, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 1405, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 1394, 1437, 426, 473, + 240, 607, 497, 199, 1308, 1313, 1306, 0, 255, 256, + 1376, 576, 1309, 1307, 1365, 1366, 1310, 1428, 1429, 1430, + 1415, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 1398, + 1302, 0, 1311, 1312, 399, 1407, 592, 593, 673, 385, + 487, 604, 336, 350, 353, 342, 362, 0, 363, 338, + 339, 344, 347, 348, 349, 354, 355, 359, 365, 249, + 210, 391, 400, 579, 313, 216, 217, 218, 525, 526, + 527, 528, 620, 621, 625, 205, 463, 464, 465, 466, + 293, 615, 310, 469, 468, 332, 333, 380, 450, 541, + 543, 554, 558, 560, 562, 568, 571, 542, 544, 555, + 559, 561, 563, 569, 572, 531, 533, 535, 537, 550, + 549, 546, 574, 575, 552, 557, 536, 548, 553, 566, + 573, 570, 530, 534, 538, 547, 565, 564, 545, 556, + 567, 551, 539, 532, 540, 1369, 196, 221, 369, 1433, + 455, 289, 651, 619, 485, 614, 206, 223, 1305, 263, + 1317, 1325, 0, 1331, 1339, 1340, 1353, 1356, 1357, 1358, + 1359, 1377, 1378, 1380, 1388, 1390, 1393, 1395, 1402, 1416, + 1436, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 302, 303, 445, 446, 315, 316, 647, + 648, 301, 601, 634, 598, 646, 628, 439, 379, 1368, + 1374, 382, 282, 306, 321, 1383, 618, 503, 227, 467, + 291, 251, 1401, 1403, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 1364, 1392, + 377, 577, 578, 317, 397, 0, 0, 0, 0, 0, + 0, 1422, 1406, 529, 0, 1348, 1425, 1316, 1335, 1435, + 1338, 1341, 1385, 1294, 1363, 417, 1332, 1320, 1289, 1327, + 1290, 1318, 1350, 271, 1315, 1408, 1367, 1424, 367, 268, + 1296, 1287, 204, 506, 1321, 431, 1337, 203, 1387, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 1431, 371, 1373, 0, 498, 402, 0, + 0, 0, 1412, 1411, 1342, 1352, 1414, 1361, 1399, 1347, + 1386, 1304, 1372, 1426, 1333, 1382, 1427, 324, 248, 326, + 202, 414, 499, 287, 0, 0, 0, 0, 0, 508, + 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 238, 0, 0, 245, 0, 0, 0, 352, 361, 360, + 340, 341, 343, 345, 351, 358, 364, 337, 346, 1329, + 1379, 610, 1421, 1330, 1381, 266, 322, 273, 265, 581, + 1432, 1413, 1293, 1360, 1420, 1355, 597, 0, 0, 229, + 1423, 1354, 0, 1384, 0, 1438, 1288, 1375, 0, 1291, + 1295, 1434, 1418, 1324, 276, 0, 0, 0, 0, 0, + 0, 0, 1351, 1362, 1396, 1400, 1345, 0, 0, 0, + 0, 0, 0, 3218, 0, 1322, 0, 1371, 0, 0, + 0, 1300, 1292, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1349, 0, 0, 0, 0, + 1303, 0, 1323, 1397, 0, 1286, 298, 1297, 403, 258, + 0, 454, 1404, 1417, 1346, 630, 1419, 1344, 1343, 1391, + 1301, 1410, 1336, 366, 1299, 331, 197, 225, 0, 1334, + 413, 462, 474, 1409, 1319, 1328, 254, 1326, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 1370, 1389, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 590, 591, 257, + 653, 228, 623, 220, 1298, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 356, 357, 281, 308, + 448, 376, 449, 307, 309, 405, 404, 406, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 1314, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 1405, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 1394, 1437, 426, 473, 240, 607, + 497, 199, 1308, 1313, 1306, 0, 255, 256, 1376, 576, + 1309, 1307, 1365, 1366, 1310, 1428, 1429, 1430, 1415, 655, + 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 1398, 1302, 0, + 1311, 1312, 399, 1407, 592, 593, 673, 385, 487, 604, + 336, 350, 353, 342, 362, 0, 363, 338, 339, 344, + 347, 348, 349, 354, 355, 359, 365, 249, 210, 391, + 400, 579, 313, 216, 217, 218, 525, 526, 527, 528, + 620, 621, 625, 205, 463, 464, 465, 466, 293, 615, + 310, 469, 468, 332, 333, 380, 450, 541, 543, 554, + 558, 560, 562, 568, 571, 542, 544, 555, 559, 561, + 563, 569, 572, 531, 533, 535, 537, 550, 549, 546, + 574, 575, 552, 557, 536, 548, 553, 566, 573, 570, + 530, 534, 538, 547, 565, 564, 545, 556, 567, 551, + 539, 532, 540, 1369, 196, 221, 369, 1433, 455, 289, + 651, 619, 485, 614, 206, 223, 1305, 263, 1317, 1325, + 0, 1331, 1339, 1340, 1353, 1356, 1357, 1358, 1359, 1377, + 1378, 1380, 1388, 1390, 1393, 1395, 1402, 1416, 1436, 198, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 302, 303, 445, 446, 315, 316, 647, 648, 301, + 601, 634, 598, 646, 628, 439, 379, 1368, 1374, 382, + 282, 306, 321, 1383, 618, 503, 227, 467, 291, 251, + 1401, 1403, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 1364, 1392, 377, 577, + 578, 317, 397, 0, 0, 0, 0, 0, 0, 1422, + 1406, 529, 0, 1348, 1425, 1316, 1335, 1435, 1338, 1341, + 1385, 1294, 1363, 417, 1332, 1320, 1289, 1327, 1290, 1318, + 1350, 271, 1315, 1408, 1367, 1424, 367, 268, 1296, 1287, + 204, 506, 1321, 431, 1337, 203, 1387, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 1431, 371, 1373, 0, 498, 402, 0, 0, 0, + 1412, 1411, 1342, 1352, 1414, 1361, 1399, 1347, 1386, 1304, + 1372, 1426, 1333, 1382, 1427, 324, 248, 326, 202, 414, + 499, 287, 0, 0, 0, 0, 0, 508, 960, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, + 0, 245, 0, 0, 0, 352, 361, 360, 340, 341, + 343, 345, 351, 358, 364, 337, 346, 1329, 1379, 610, + 1421, 1330, 1381, 266, 322, 273, 265, 581, 1432, 1413, + 1293, 1360, 1420, 1355, 597, 0, 0, 229, 1423, 1354, + 0, 1384, 0, 1438, 1288, 1375, 0, 1291, 1295, 1434, + 1418, 1324, 276, 0, 0, 0, 0, 0, 0, 0, + 1351, 1362, 1396, 1400, 1345, 0, 0, 0, 0, 0, + 0, 2411, 0, 1322, 0, 1371, 0, 0, 0, 1300, + 1292, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1349, 0, 0, 0, 0, 1303, 0, + 1323, 1397, 0, 1286, 298, 1297, 403, 258, 0, 454, + 1404, 1417, 1346, 630, 1419, 1344, 1343, 1391, 1301, 1410, + 1336, 366, 1299, 331, 197, 225, 0, 1334, 413, 462, + 474, 1409, 1319, 1328, 254, 1326, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 1370, 1389, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 590, 591, 257, 653, 228, + 623, 220, 1298, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 356, 357, 281, 308, 448, 376, + 449, 307, 309, 405, 404, 406, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 1314, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 1405, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 1394, 1437, 426, 473, 240, 607, 497, 199, + 1308, 1313, 1306, 0, 255, 256, 1376, 576, 1309, 1307, + 1365, 1366, 1310, 1428, 1429, 1430, 1415, 655, 656, 657, + 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 1398, 1302, 0, 1311, 1312, + 399, 1407, 592, 593, 673, 385, 487, 604, 336, 350, + 353, 342, 362, 0, 363, 338, 339, 344, 347, 348, + 349, 354, 355, 359, 365, 249, 210, 391, 400, 579, + 313, 216, 217, 218, 525, 526, 527, 528, 620, 621, + 625, 205, 463, 464, 465, 466, 293, 615, 310, 469, + 468, 332, 333, 380, 450, 541, 543, 554, 558, 560, + 562, 568, 571, 542, 544, 555, 559, 561, 563, 569, + 572, 531, 533, 535, 537, 550, 549, 546, 574, 575, + 552, 557, 536, 548, 553, 566, 573, 570, 530, 534, + 538, 547, 565, 564, 545, 556, 567, 551, 539, 532, + 540, 1369, 196, 221, 369, 1433, 455, 289, 651, 619, + 485, 614, 206, 223, 1305, 263, 1317, 1325, 0, 1331, + 1339, 1340, 1353, 1356, 1357, 1358, 1359, 1377, 1378, 1380, + 1388, 1390, 1393, 1395, 1402, 1416, 1436, 198, 200, 209, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 302, + 303, 445, 446, 315, 316, 647, 648, 301, 601, 634, + 598, 646, 628, 439, 379, 1368, 1374, 382, 282, 306, + 321, 1383, 618, 503, 227, 467, 291, 251, 1401, 1403, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 1364, 1392, 377, 577, 578, 317, + 397, 0, 0, 0, 0, 0, 0, 1422, 1406, 529, + 0, 1348, 1425, 1316, 1335, 1435, 1338, 1341, 1385, 1294, + 1363, 417, 1332, 1320, 1289, 1327, 1290, 1318, 1350, 271, + 1315, 1408, 1367, 1424, 367, 268, 1296, 1287, 204, 506, + 1321, 431, 1337, 203, 1387, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 1431, + 371, 1373, 0, 498, 402, 0, 0, 0, 1412, 1411, + 1342, 1352, 1414, 1361, 1399, 1347, 1386, 1304, 1372, 1426, + 1333, 1382, 1427, 324, 248, 326, 202, 414, 499, 287, + 0, 95, 0, 0, 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, - 0, 0, 0, 351, 360, 359, 339, 340, 342, 344, - 350, 357, 363, 336, 345, 1328, 1378, 609, 1420, 1329, - 1380, 265, 321, 272, 264, 580, 1431, 1412, 1292, 1359, - 1419, 1354, 596, 0, 0, 229, 1422, 1353, 0, 1383, - 0, 1437, 1287, 1374, 0, 1290, 1294, 1433, 1417, 1323, - 275, 0, 0, 0, 0, 0, 0, 0, 1350, 1361, - 1395, 1399, 1344, 0, 0, 0, 0, 0, 0, 3254, - 0, 1321, 0, 1370, 0, 0, 0, 1299, 1291, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1348, 0, 0, 0, 0, 1302, 0, 1322, 1396, - 0, 1285, 297, 1296, 402, 257, 0, 453, 1403, 1416, - 1345, 629, 1418, 1343, 1342, 1390, 1300, 1409, 1335, 365, - 1298, 330, 197, 225, 0, 1333, 412, 461, 473, 1408, - 1318, 1327, 253, 1325, 471, 426, 604, 233, 284, 458, - 432, 469, 440, 287, 1369, 1388, 470, 372, 585, 450, - 601, 630, 631, 263, 406, 615, 522, 623, 648, 226, - 260, 420, 506, 607, 494, 397, 581, 582, 329, 493, - 295, 201, 369, 636, 224, 479, 371, 242, 231, 587, - 612, 299, 289, 456, 643, 213, 517, 598, 239, 483, - 0, 0, 651, 247, 504, 610, 599, 215, 594, 503, - 393, 326, 327, 214, 0, 457, 268, 293, 0, 0, - 258, 415, 589, 590, 256, 652, 228, 622, 220, 1297, - 621, 408, 584, 595, 394, 383, 219, 593, 392, 382, - 334, 355, 356, 280, 307, 447, 375, 448, 306, 308, - 404, 403, 405, 207, 608, 626, 0, 208, 0, 499, - 611, 653, 452, 212, 234, 235, 237, 1313, 279, 283, - 291, 294, 303, 304, 313, 367, 419, 446, 442, 451, - 1404, 579, 602, 616, 628, 634, 635, 637, 638, 639, - 640, 641, 644, 642, 407, 311, 495, 333, 373, 1393, - 1436, 425, 472, 240, 606, 496, 199, 1307, 1312, 1305, - 0, 254, 255, 1375, 575, 1308, 1306, 1364, 1365, 1309, - 1427, 1428, 1429, 1414, 654, 655, 656, 657, 658, 659, + 0, 0, 0, 352, 361, 360, 340, 341, 343, 345, + 351, 358, 364, 337, 346, 1329, 1379, 610, 1421, 1330, + 1381, 266, 322, 273, 265, 581, 1432, 1413, 1293, 1360, + 1420, 1355, 597, 0, 0, 229, 1423, 1354, 0, 1384, + 0, 1438, 1288, 1375, 0, 1291, 1295, 1434, 1418, 1324, + 276, 0, 0, 0, 0, 0, 0, 0, 1351, 1362, + 1396, 1400, 1345, 0, 0, 0, 0, 0, 0, 0, + 0, 1322, 0, 1371, 0, 0, 0, 1300, 1292, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1349, 0, 0, 0, 0, 1303, 0, 1323, 1397, + 0, 1286, 298, 1297, 403, 258, 0, 454, 1404, 1417, + 1346, 630, 1419, 1344, 1343, 1391, 1301, 1410, 1336, 366, + 1299, 331, 197, 225, 0, 1334, 413, 462, 474, 1409, + 1319, 1328, 254, 1326, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 1370, 1389, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 590, 591, 257, 653, 228, 623, 220, + 1298, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 356, 357, 281, 308, 448, 376, 449, 307, + 309, 405, 404, 406, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 1314, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 1405, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 1394, 1437, 426, 473, 240, 607, 497, 199, 1308, 1313, + 1306, 0, 255, 256, 1376, 576, 1309, 1307, 1365, 1366, + 1310, 1428, 1429, 1430, 1415, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, - 670, 671, 649, 508, 514, 509, 510, 511, 512, 513, - 0, 515, 1397, 1301, 0, 1310, 1311, 398, 1406, 591, - 592, 672, 384, 486, 603, 335, 349, 352, 341, 361, - 0, 362, 337, 338, 343, 346, 347, 348, 353, 354, - 358, 364, 249, 210, 390, 399, 578, 312, 216, 217, - 218, 524, 525, 526, 527, 619, 620, 624, 205, 462, - 463, 464, 465, 292, 614, 309, 468, 467, 331, 332, - 379, 449, 540, 542, 553, 557, 559, 561, 567, 570, - 541, 543, 554, 558, 560, 562, 568, 571, 530, 532, - 534, 536, 549, 548, 545, 573, 574, 551, 556, 535, - 547, 552, 565, 572, 569, 529, 533, 537, 546, 564, - 563, 544, 555, 566, 550, 538, 531, 539, 1368, 196, - 221, 368, 1432, 454, 288, 650, 618, 484, 613, 206, - 223, 1304, 262, 1316, 1324, 0, 1330, 1338, 1339, 1352, - 1355, 1356, 1357, 1358, 1376, 1377, 1379, 1387, 1389, 1392, - 1394, 1401, 1415, 1435, 198, 200, 209, 222, 232, 236, - 243, 261, 276, 278, 285, 298, 310, 318, 319, 322, - 328, 380, 386, 387, 388, 389, 409, 410, 411, 414, - 417, 418, 421, 423, 424, 427, 431, 435, 436, 437, - 439, 441, 443, 455, 460, 474, 475, 476, 477, 478, - 481, 482, 488, 489, 490, 491, 492, 500, 501, 516, - 586, 588, 605, 625, 632, 480, 301, 302, 444, 445, - 314, 315, 646, 647, 300, 600, 633, 597, 645, 627, - 438, 378, 1367, 1373, 381, 281, 305, 320, 1382, 617, - 502, 227, 466, 290, 251, 1400, 1402, 211, 246, 230, - 259, 274, 277, 324, 391, 400, 429, 434, 296, 271, - 244, 459, 241, 485, 519, 520, 521, 523, 395, 266, - 433, 1363, 1391, 376, 576, 577, 316, 396, 0, 0, - 0, 0, 0, 0, 1421, 1405, 528, 0, 1347, 1424, - 1315, 1334, 1434, 1337, 1340, 1384, 1293, 1362, 416, 1331, - 1319, 1288, 1326, 1289, 1317, 1349, 270, 1314, 1407, 1366, - 1423, 366, 267, 1295, 1286, 204, 505, 1320, 430, 1336, - 203, 1386, 487, 252, 377, 374, 583, 282, 273, 269, - 250, 317, 385, 428, 518, 422, 1430, 370, 1372, 0, - 497, 401, 0, 0, 0, 1411, 1410, 1341, 1351, 1413, - 1360, 1398, 1346, 1385, 1303, 1371, 1425, 1332, 1381, 1426, - 323, 248, 325, 202, 413, 498, 286, 0, 0, 0, - 0, 0, 507, 724, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 238, 0, 0, 245, 0, 0, 0, - 351, 360, 359, 339, 340, 342, 344, 350, 357, 363, - 336, 345, 1328, 1378, 609, 1420, 1329, 1380, 265, 321, - 272, 264, 580, 1431, 1412, 1292, 1359, 1419, 1354, 596, - 0, 0, 229, 1422, 1353, 0, 1383, 0, 1437, 1287, - 1374, 0, 1290, 1294, 1433, 1417, 1323, 275, 0, 0, - 0, 0, 0, 0, 0, 1350, 1361, 1395, 1399, 1344, - 0, 0, 0, 0, 0, 0, 3215, 0, 1321, 0, - 1370, 0, 0, 0, 1299, 1291, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1348, 0, - 0, 0, 0, 1302, 0, 1322, 1396, 0, 1285, 297, - 1296, 402, 257, 0, 453, 1403, 1416, 1345, 629, 1418, - 1343, 1342, 1390, 1300, 1409, 1335, 365, 1298, 330, 197, - 225, 0, 1333, 412, 461, 473, 1408, 1318, 1327, 253, - 1325, 471, 426, 604, 233, 284, 458, 432, 469, 440, - 287, 1369, 1388, 470, 372, 585, 450, 601, 630, 631, - 263, 406, 615, 522, 623, 648, 226, 260, 420, 506, - 607, 494, 397, 581, 582, 329, 493, 295, 201, 369, - 636, 224, 479, 371, 242, 231, 587, 612, 299, 289, - 456, 643, 213, 517, 598, 239, 483, 0, 0, 651, - 247, 504, 610, 599, 215, 594, 503, 393, 326, 327, - 214, 0, 457, 268, 293, 0, 0, 258, 415, 589, - 590, 256, 652, 228, 622, 220, 1297, 621, 408, 584, - 595, 394, 383, 219, 593, 392, 382, 334, 355, 356, - 280, 307, 447, 375, 448, 306, 308, 404, 403, 405, - 207, 608, 626, 0, 208, 0, 499, 611, 653, 452, - 212, 234, 235, 237, 1313, 279, 283, 291, 294, 303, - 304, 313, 367, 419, 446, 442, 451, 1404, 579, 602, - 616, 628, 634, 635, 637, 638, 639, 640, 641, 644, - 642, 407, 311, 495, 333, 373, 1393, 1436, 425, 472, - 240, 606, 496, 199, 1307, 1312, 1305, 0, 254, 255, - 1375, 575, 1308, 1306, 1364, 1365, 1309, 1427, 1428, 1429, - 1414, 654, 655, 656, 657, 658, 659, 660, 661, 662, - 663, 664, 665, 666, 667, 668, 669, 670, 671, 649, - 508, 514, 509, 510, 511, 512, 513, 0, 515, 1397, - 1301, 0, 1310, 1311, 398, 1406, 591, 592, 672, 384, - 486, 603, 335, 349, 352, 341, 361, 0, 362, 337, - 338, 343, 346, 347, 348, 353, 354, 358, 364, 249, - 210, 390, 399, 578, 312, 216, 217, 218, 524, 525, - 526, 527, 619, 620, 624, 205, 462, 463, 464, 465, - 292, 614, 309, 468, 467, 331, 332, 379, 449, 540, - 542, 553, 557, 559, 561, 567, 570, 541, 543, 554, - 558, 560, 562, 568, 571, 530, 532, 534, 536, 549, - 548, 545, 573, 574, 551, 556, 535, 547, 552, 565, - 572, 569, 529, 533, 537, 546, 564, 563, 544, 555, - 566, 550, 538, 531, 539, 1368, 196, 221, 368, 1432, - 454, 288, 650, 618, 484, 613, 206, 223, 1304, 262, - 1316, 1324, 0, 1330, 1338, 1339, 1352, 1355, 1356, 1357, - 1358, 1376, 1377, 1379, 1387, 1389, 1392, 1394, 1401, 1415, - 1435, 198, 200, 209, 222, 232, 236, 243, 261, 276, - 278, 285, 298, 310, 318, 319, 322, 328, 380, 386, - 387, 388, 389, 409, 410, 411, 414, 417, 418, 421, - 423, 424, 427, 431, 435, 436, 437, 439, 441, 443, - 455, 460, 474, 475, 476, 477, 478, 481, 482, 488, - 489, 490, 491, 492, 500, 501, 516, 586, 588, 605, - 625, 632, 480, 301, 302, 444, 445, 314, 315, 646, - 647, 300, 600, 633, 597, 645, 627, 438, 378, 1367, - 1373, 381, 281, 305, 320, 1382, 617, 502, 227, 466, - 290, 251, 1400, 1402, 211, 246, 230, 259, 274, 277, - 324, 391, 400, 429, 434, 296, 271, 244, 459, 241, - 485, 519, 520, 521, 523, 395, 266, 433, 1363, 1391, - 376, 576, 577, 316, 396, 0, 0, 0, 0, 0, - 0, 1421, 1405, 528, 0, 1347, 1424, 1315, 1334, 1434, - 1337, 1340, 1384, 1293, 1362, 416, 1331, 1319, 1288, 1326, - 1289, 1317, 1349, 270, 1314, 1407, 1366, 1423, 366, 267, - 1295, 1286, 204, 505, 1320, 430, 1336, 203, 1386, 487, - 252, 377, 374, 583, 282, 273, 269, 250, 317, 385, - 428, 518, 422, 1430, 370, 1372, 0, 497, 401, 0, - 0, 0, 1411, 1410, 1341, 1351, 1413, 1360, 1398, 1346, - 1385, 1303, 1371, 1425, 1332, 1381, 1426, 323, 248, 325, - 202, 413, 498, 286, 0, 0, 0, 0, 0, 507, - 959, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 238, 0, 0, 245, 0, 0, 0, 351, 360, 359, - 339, 340, 342, 344, 350, 357, 363, 336, 345, 1328, - 1378, 609, 1420, 1329, 1380, 265, 321, 272, 264, 580, - 1431, 1412, 1292, 1359, 1419, 1354, 596, 0, 0, 229, - 1422, 1353, 0, 1383, 0, 1437, 1287, 1374, 0, 1290, - 1294, 1433, 1417, 1323, 275, 0, 0, 0, 0, 0, - 0, 0, 1350, 1361, 1395, 1399, 1344, 0, 0, 0, - 0, 0, 0, 2410, 0, 1321, 0, 1370, 0, 0, - 0, 1299, 1291, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1348, 0, 0, 0, 0, - 1302, 0, 1322, 1396, 0, 1285, 297, 1296, 402, 257, - 0, 453, 1403, 1416, 1345, 629, 1418, 1343, 1342, 1390, - 1300, 1409, 1335, 365, 1298, 330, 197, 225, 0, 1333, - 412, 461, 473, 1408, 1318, 1327, 253, 1325, 471, 426, - 604, 233, 284, 458, 432, 469, 440, 287, 1369, 1388, - 470, 372, 585, 450, 601, 630, 631, 263, 406, 615, - 522, 623, 648, 226, 260, 420, 506, 607, 494, 397, - 581, 582, 329, 493, 295, 201, 369, 636, 224, 479, - 371, 242, 231, 587, 612, 299, 289, 456, 643, 213, - 517, 598, 239, 483, 0, 0, 651, 247, 504, 610, - 599, 215, 594, 503, 393, 326, 327, 214, 0, 457, - 268, 293, 0, 0, 258, 415, 589, 590, 256, 652, - 228, 622, 220, 1297, 621, 408, 584, 595, 394, 383, - 219, 593, 392, 382, 334, 355, 356, 280, 307, 447, - 375, 448, 306, 308, 404, 403, 405, 207, 608, 626, - 0, 208, 0, 499, 611, 653, 452, 212, 234, 235, - 237, 1313, 279, 283, 291, 294, 303, 304, 313, 367, - 419, 446, 442, 451, 1404, 579, 602, 616, 628, 634, - 635, 637, 638, 639, 640, 641, 644, 642, 407, 311, - 495, 333, 373, 1393, 1436, 425, 472, 240, 606, 496, - 199, 1307, 1312, 1305, 0, 254, 255, 1375, 575, 1308, - 1306, 1364, 1365, 1309, 1427, 1428, 1429, 1414, 654, 655, - 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, - 666, 667, 668, 669, 670, 671, 649, 508, 514, 509, - 510, 511, 512, 513, 0, 515, 1397, 1301, 0, 1310, - 1311, 398, 1406, 591, 592, 672, 384, 486, 603, 335, - 349, 352, 341, 361, 0, 362, 337, 338, 343, 346, - 347, 348, 353, 354, 358, 364, 249, 210, 390, 399, - 578, 312, 216, 217, 218, 524, 525, 526, 527, 619, - 620, 624, 205, 462, 463, 464, 465, 292, 614, 309, - 468, 467, 331, 332, 379, 449, 540, 542, 553, 557, - 559, 561, 567, 570, 541, 543, 554, 558, 560, 562, - 568, 571, 530, 532, 534, 536, 549, 548, 545, 573, - 574, 551, 556, 535, 547, 552, 565, 572, 569, 529, - 533, 537, 546, 564, 563, 544, 555, 566, 550, 538, - 531, 539, 1368, 196, 221, 368, 1432, 454, 288, 650, - 618, 484, 613, 206, 223, 1304, 262, 1316, 1324, 0, - 1330, 1338, 1339, 1352, 1355, 1356, 1357, 1358, 1376, 1377, - 1379, 1387, 1389, 1392, 1394, 1401, 1415, 1435, 198, 200, - 209, 222, 232, 236, 243, 261, 276, 278, 285, 298, - 310, 318, 319, 322, 328, 380, 386, 387, 388, 389, - 409, 410, 411, 414, 417, 418, 421, 423, 424, 427, - 431, 435, 436, 437, 439, 441, 443, 455, 460, 474, - 475, 476, 477, 478, 481, 482, 488, 489, 490, 491, - 492, 500, 501, 516, 586, 588, 605, 625, 632, 480, - 301, 302, 444, 445, 314, 315, 646, 647, 300, 600, - 633, 597, 645, 627, 438, 378, 1367, 1373, 381, 281, - 305, 320, 1382, 617, 502, 227, 466, 290, 251, 1400, - 1402, 211, 246, 230, 259, 274, 277, 324, 391, 400, - 429, 434, 296, 271, 244, 459, 241, 485, 519, 520, - 521, 523, 395, 266, 433, 1363, 1391, 376, 576, 577, - 316, 396, 0, 0, 0, 0, 0, 0, 1421, 1405, - 528, 0, 1347, 1424, 1315, 1334, 1434, 1337, 1340, 1384, - 1293, 1362, 416, 1331, 1319, 1288, 1326, 1289, 1317, 1349, - 270, 1314, 1407, 1366, 1423, 366, 267, 1295, 1286, 204, - 505, 1320, 430, 1336, 203, 1386, 487, 252, 377, 374, - 583, 282, 273, 269, 250, 317, 385, 428, 518, 422, - 1430, 370, 1372, 0, 497, 401, 0, 0, 0, 1411, - 1410, 1341, 1351, 1413, 1360, 1398, 1346, 1385, 1303, 1371, - 1425, 1332, 1381, 1426, 323, 248, 325, 202, 413, 498, - 286, 0, 95, 0, 0, 0, 507, 724, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, - 245, 0, 0, 0, 351, 360, 359, 339, 340, 342, - 344, 350, 357, 363, 336, 345, 1328, 1378, 609, 1420, - 1329, 1380, 265, 321, 272, 264, 580, 1431, 1412, 1292, - 1359, 1419, 1354, 596, 0, 0, 229, 1422, 1353, 0, - 1383, 0, 1437, 1287, 1374, 0, 1290, 1294, 1433, 1417, - 1323, 275, 0, 0, 0, 0, 0, 0, 0, 1350, - 1361, 1395, 1399, 1344, 0, 0, 0, 0, 0, 0, - 0, 0, 1321, 0, 1370, 0, 0, 0, 1299, 1291, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1348, 0, 0, 0, 0, 1302, 0, 1322, - 1396, 0, 1285, 297, 1296, 402, 257, 0, 453, 1403, - 1416, 1345, 629, 1418, 1343, 1342, 1390, 1300, 1409, 1335, - 365, 1298, 330, 197, 225, 0, 1333, 412, 461, 473, - 1408, 1318, 1327, 253, 1325, 471, 426, 604, 233, 284, - 458, 432, 469, 440, 287, 1369, 1388, 470, 372, 585, - 450, 601, 630, 631, 263, 406, 615, 522, 623, 648, - 226, 260, 420, 506, 607, 494, 397, 581, 582, 329, - 493, 295, 201, 369, 636, 224, 479, 371, 242, 231, - 587, 612, 299, 289, 456, 643, 213, 517, 598, 239, - 483, 0, 0, 651, 247, 504, 610, 599, 215, 594, - 503, 393, 326, 327, 214, 0, 457, 268, 293, 0, - 0, 258, 415, 589, 590, 256, 652, 228, 622, 220, - 1297, 621, 408, 584, 595, 394, 383, 219, 593, 392, - 382, 334, 355, 356, 280, 307, 447, 375, 448, 306, - 308, 404, 403, 405, 207, 608, 626, 0, 208, 0, - 499, 611, 653, 452, 212, 234, 235, 237, 1313, 279, - 283, 291, 294, 303, 304, 313, 367, 419, 446, 442, - 451, 1404, 579, 602, 616, 628, 634, 635, 637, 638, - 639, 640, 641, 644, 642, 407, 311, 495, 333, 373, - 1393, 1436, 425, 472, 240, 606, 496, 199, 1307, 1312, - 1305, 0, 254, 255, 1375, 575, 1308, 1306, 1364, 1365, - 1309, 1427, 1428, 1429, 1414, 654, 655, 656, 657, 658, - 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, - 669, 670, 671, 649, 508, 514, 509, 510, 511, 512, - 513, 0, 515, 1397, 1301, 0, 1310, 1311, 398, 1406, - 591, 592, 672, 384, 486, 603, 335, 349, 352, 341, - 361, 0, 362, 337, 338, 343, 346, 347, 348, 353, - 354, 358, 364, 249, 210, 390, 399, 578, 312, 216, - 217, 218, 524, 525, 526, 527, 619, 620, 624, 205, - 462, 463, 464, 465, 292, 614, 309, 468, 467, 331, - 332, 379, 449, 540, 542, 553, 557, 559, 561, 567, - 570, 541, 543, 554, 558, 560, 562, 568, 571, 530, - 532, 534, 536, 549, 548, 545, 573, 574, 551, 556, - 535, 547, 552, 565, 572, 569, 529, 533, 537, 546, - 564, 563, 544, 555, 566, 550, 538, 531, 539, 1368, - 196, 221, 368, 1432, 454, 288, 650, 618, 484, 613, - 206, 223, 1304, 262, 1316, 1324, 0, 1330, 1338, 1339, - 1352, 1355, 1356, 1357, 1358, 1376, 1377, 1379, 1387, 1389, - 1392, 1394, 1401, 1415, 1435, 198, 200, 209, 222, 232, - 236, 243, 261, 276, 278, 285, 298, 310, 318, 319, - 322, 328, 380, 386, 387, 388, 389, 409, 410, 411, - 414, 417, 418, 421, 423, 424, 427, 431, 435, 436, - 437, 439, 441, 443, 455, 460, 474, 475, 476, 477, - 478, 481, 482, 488, 489, 490, 491, 492, 500, 501, - 516, 586, 588, 605, 625, 632, 480, 301, 302, 444, - 445, 314, 315, 646, 647, 300, 600, 633, 597, 645, - 627, 438, 378, 1367, 1373, 381, 281, 305, 320, 1382, - 617, 502, 227, 466, 290, 251, 1400, 1402, 211, 246, - 230, 259, 274, 277, 324, 391, 400, 429, 434, 296, - 271, 244, 459, 241, 485, 519, 520, 521, 523, 395, - 266, 433, 1363, 1391, 376, 576, 577, 316, 396, 0, - 0, 0, 0, 0, 0, 1421, 1405, 528, 0, 1347, - 1424, 1315, 1334, 1434, 1337, 1340, 1384, 1293, 1362, 416, - 1331, 1319, 1288, 1326, 1289, 1317, 1349, 270, 1314, 1407, - 1366, 1423, 366, 267, 1295, 1286, 204, 505, 1320, 430, - 1336, 203, 1386, 487, 252, 377, 374, 583, 282, 273, - 269, 250, 317, 385, 428, 518, 422, 1430, 370, 1372, - 0, 497, 401, 0, 0, 0, 1411, 1410, 1341, 1351, - 1413, 1360, 1398, 1346, 1385, 1303, 1371, 1425, 1332, 1381, - 1426, 323, 248, 325, 202, 413, 498, 286, 0, 0, - 0, 0, 0, 507, 194, 0, 0, 0, 0, 0, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 1398, 1302, 0, 1311, 1312, 399, 1407, + 592, 593, 673, 385, 487, 604, 336, 350, 353, 342, + 362, 0, 363, 338, 339, 344, 347, 348, 349, 354, + 355, 359, 365, 249, 210, 391, 400, 579, 313, 216, + 217, 218, 525, 526, 527, 528, 620, 621, 625, 205, + 463, 464, 465, 466, 293, 615, 310, 469, 468, 332, + 333, 380, 450, 541, 543, 554, 558, 560, 562, 568, + 571, 542, 544, 555, 559, 561, 563, 569, 572, 531, + 533, 535, 537, 550, 549, 546, 574, 575, 552, 557, + 536, 548, 553, 566, 573, 570, 530, 534, 538, 547, + 565, 564, 545, 556, 567, 551, 539, 532, 540, 1369, + 196, 221, 369, 1433, 455, 289, 651, 619, 485, 614, + 206, 223, 1305, 263, 1317, 1325, 0, 1331, 1339, 1340, + 1353, 1356, 1357, 1358, 1359, 1377, 1378, 1380, 1388, 1390, + 1393, 1395, 1402, 1416, 1436, 198, 200, 209, 222, 232, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 302, 303, 445, + 446, 315, 316, 647, 648, 301, 601, 634, 598, 646, + 628, 439, 379, 1368, 1374, 382, 282, 306, 321, 1383, + 618, 503, 227, 467, 291, 251, 1401, 1403, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 1364, 1392, 377, 577, 578, 317, 397, 0, + 0, 0, 0, 0, 0, 1422, 1406, 529, 0, 1348, + 1425, 1316, 1335, 1435, 1338, 1341, 1385, 1294, 1363, 417, + 1332, 1320, 1289, 1327, 1290, 1318, 1350, 271, 1315, 1408, + 1367, 1424, 367, 268, 1296, 1287, 204, 506, 1321, 431, + 1337, 203, 1387, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 1431, 371, 1373, + 0, 498, 402, 0, 0, 0, 1412, 1411, 1342, 1352, + 1414, 1361, 1399, 1347, 1386, 1304, 1372, 1426, 1333, 1382, + 1427, 324, 248, 326, 202, 414, 499, 287, 0, 0, + 0, 0, 0, 508, 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, 0, 0, - 0, 351, 360, 359, 339, 340, 342, 344, 350, 357, - 363, 336, 345, 1328, 1378, 609, 1420, 1329, 1380, 265, - 321, 272, 264, 580, 1431, 1412, 1292, 1359, 1419, 1354, - 596, 0, 0, 229, 1422, 1353, 0, 1383, 0, 1437, - 1287, 1374, 0, 1290, 1294, 1433, 1417, 1323, 275, 0, - 0, 0, 0, 0, 0, 0, 1350, 1361, 1395, 1399, - 1344, 0, 0, 0, 0, 0, 0, 0, 0, 1321, - 0, 1370, 0, 0, 0, 1299, 1291, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1348, - 0, 0, 0, 0, 1302, 0, 1322, 1396, 0, 1285, - 297, 1296, 402, 257, 0, 453, 1403, 1416, 1345, 629, - 1418, 1343, 1342, 1390, 1300, 1409, 1335, 365, 1298, 330, - 197, 225, 0, 1333, 412, 461, 473, 1408, 1318, 1327, - 253, 1325, 471, 426, 604, 233, 284, 458, 432, 469, - 440, 287, 1369, 1388, 470, 372, 585, 450, 601, 630, - 631, 263, 406, 615, 522, 623, 648, 226, 260, 420, - 506, 607, 494, 397, 581, 582, 329, 493, 295, 201, - 369, 636, 224, 479, 371, 242, 231, 587, 612, 299, - 289, 456, 643, 213, 517, 598, 239, 483, 0, 0, - 651, 247, 504, 610, 599, 215, 594, 503, 393, 326, - 327, 214, 0, 457, 268, 293, 0, 0, 258, 415, - 589, 590, 256, 652, 228, 622, 220, 1297, 621, 408, - 584, 595, 394, 383, 219, 593, 392, 382, 334, 355, - 356, 280, 307, 447, 375, 448, 306, 308, 404, 403, - 405, 207, 608, 626, 0, 208, 0, 499, 611, 653, - 452, 212, 234, 235, 237, 1313, 279, 283, 291, 294, - 303, 304, 313, 367, 419, 446, 442, 451, 1404, 579, - 602, 616, 628, 634, 635, 637, 638, 639, 640, 641, - 644, 642, 407, 311, 495, 333, 373, 1393, 1436, 425, - 472, 240, 606, 496, 199, 1307, 1312, 1305, 0, 254, - 255, 1375, 575, 1308, 1306, 1364, 1365, 1309, 1427, 1428, - 1429, 1414, 654, 655, 656, 657, 658, 659, 660, 661, + 0, 352, 361, 360, 340, 341, 343, 345, 351, 358, + 364, 337, 346, 1329, 1379, 610, 1421, 1330, 1381, 266, + 322, 273, 265, 581, 1432, 1413, 1293, 1360, 1420, 1355, + 597, 0, 0, 229, 1423, 1354, 0, 1384, 0, 1438, + 1288, 1375, 0, 1291, 1295, 1434, 1418, 1324, 276, 0, + 0, 0, 0, 0, 0, 0, 1351, 1362, 1396, 1400, + 1345, 0, 0, 0, 0, 0, 0, 0, 0, 1322, + 0, 1371, 0, 0, 0, 1300, 1292, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1349, + 0, 0, 0, 0, 1303, 0, 1323, 1397, 0, 1286, + 298, 1297, 403, 258, 0, 454, 1404, 1417, 1346, 630, + 1419, 1344, 1343, 1391, 1301, 1410, 1336, 366, 1299, 331, + 197, 225, 0, 1334, 413, 462, 474, 1409, 1319, 1328, + 254, 1326, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 1370, 1389, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 590, 591, 257, 653, 228, 623, 220, 1298, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 356, 357, 281, 308, 448, 376, 449, 307, 309, 405, + 404, 406, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 1314, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 1405, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 1394, 1437, + 426, 473, 240, 607, 497, 199, 1308, 1313, 1306, 0, + 255, 256, 1376, 576, 1309, 1307, 1365, 1366, 1310, 1428, + 1429, 1430, 1415, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, - 649, 508, 514, 509, 510, 511, 512, 513, 0, 515, - 1397, 1301, 0, 1310, 1311, 398, 1406, 591, 592, 672, - 384, 486, 603, 335, 349, 352, 341, 361, 0, 362, - 337, 338, 343, 346, 347, 348, 353, 354, 358, 364, - 249, 210, 390, 399, 578, 312, 216, 217, 218, 524, - 525, 526, 527, 619, 620, 624, 205, 462, 463, 464, - 465, 292, 614, 309, 468, 467, 331, 332, 379, 449, - 540, 542, 553, 557, 559, 561, 567, 570, 541, 543, - 554, 558, 560, 562, 568, 571, 530, 532, 534, 536, - 549, 548, 545, 573, 574, 551, 556, 535, 547, 552, - 565, 572, 569, 529, 533, 537, 546, 564, 563, 544, - 555, 566, 550, 538, 531, 539, 1368, 196, 221, 368, - 1432, 454, 288, 650, 618, 484, 613, 206, 223, 1304, - 262, 1316, 1324, 0, 1330, 1338, 1339, 1352, 1355, 1356, - 1357, 1358, 1376, 1377, 1379, 1387, 1389, 1392, 1394, 1401, - 1415, 1435, 198, 200, 209, 222, 232, 236, 243, 261, - 276, 278, 285, 298, 310, 318, 319, 322, 328, 380, - 386, 387, 388, 389, 409, 410, 411, 414, 417, 418, - 421, 423, 424, 427, 431, 435, 436, 437, 439, 441, - 443, 455, 460, 474, 475, 476, 477, 478, 481, 482, - 488, 489, 490, 491, 492, 500, 501, 516, 586, 588, - 605, 625, 632, 480, 301, 302, 444, 445, 314, 315, - 646, 647, 300, 600, 633, 597, 645, 627, 438, 378, - 1367, 1373, 381, 281, 305, 320, 1382, 617, 502, 227, - 466, 290, 251, 1400, 1402, 211, 246, 230, 259, 274, - 277, 324, 391, 400, 429, 434, 296, 271, 244, 459, - 241, 485, 519, 520, 521, 523, 395, 266, 433, 1363, - 1391, 376, 576, 577, 316, 396, 0, 0, 0, 0, - 0, 0, 1421, 1405, 528, 0, 1347, 1424, 1315, 1334, - 1434, 1337, 1340, 1384, 1293, 1362, 416, 1331, 1319, 1288, - 1326, 1289, 1317, 1349, 270, 1314, 1407, 1366, 1423, 366, - 267, 1295, 1286, 204, 505, 1320, 430, 1336, 203, 1386, - 487, 252, 377, 374, 583, 282, 273, 269, 250, 317, - 385, 428, 518, 422, 1430, 370, 1372, 0, 497, 401, - 0, 0, 0, 1411, 1410, 1341, 1351, 1413, 1360, 1398, - 1346, 1385, 1303, 1371, 1425, 1332, 1381, 1426, 323, 248, - 325, 202, 413, 498, 286, 0, 0, 0, 0, 0, - 507, 724, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 238, 0, 0, 245, 0, 0, 0, 351, 360, - 359, 339, 340, 342, 344, 350, 357, 363, 336, 345, - 1328, 1378, 609, 1420, 1329, 1380, 265, 321, 272, 264, - 580, 1431, 1412, 1292, 1359, 1419, 1354, 596, 0, 0, - 229, 1422, 1353, 0, 1383, 0, 1437, 1287, 1374, 0, - 1290, 1294, 1433, 1417, 1323, 275, 0, 0, 0, 0, - 0, 0, 0, 1350, 1361, 1395, 1399, 1344, 0, 0, - 0, 0, 0, 0, 0, 0, 1321, 0, 1370, 0, - 0, 0, 1299, 1291, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1348, 0, 0, 0, - 0, 1302, 0, 1322, 1396, 0, 1285, 297, 1296, 402, - 257, 0, 453, 1403, 1416, 1345, 629, 1418, 1343, 1342, - 1390, 1300, 1409, 1335, 365, 1298, 330, 197, 225, 0, - 1333, 412, 461, 473, 1408, 1318, 1327, 253, 1325, 471, - 426, 604, 233, 284, 458, 432, 469, 440, 287, 1369, - 1388, 470, 372, 585, 450, 601, 630, 631, 263, 406, - 615, 522, 623, 648, 226, 260, 420, 506, 607, 494, - 397, 581, 582, 329, 493, 295, 201, 369, 636, 224, - 479, 371, 242, 231, 587, 612, 299, 289, 456, 643, - 213, 517, 598, 239, 483, 0, 0, 651, 247, 504, - 610, 599, 215, 594, 503, 393, 326, 327, 214, 0, - 457, 268, 293, 0, 0, 258, 415, 589, 590, 256, - 652, 228, 622, 220, 1297, 621, 408, 584, 595, 394, - 383, 219, 593, 392, 382, 334, 355, 356, 280, 307, - 447, 375, 448, 306, 308, 404, 403, 405, 207, 608, - 626, 0, 208, 0, 499, 611, 653, 452, 212, 234, - 235, 237, 1313, 279, 283, 291, 294, 303, 304, 313, - 367, 419, 446, 442, 451, 1404, 579, 602, 616, 628, - 634, 635, 637, 638, 639, 640, 641, 644, 642, 407, - 311, 495, 333, 373, 1393, 1436, 425, 472, 240, 606, - 496, 199, 1307, 1312, 1305, 0, 254, 255, 1375, 575, - 1308, 1306, 1364, 1365, 1309, 1427, 1428, 1429, 1414, 654, - 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, - 665, 666, 667, 668, 669, 670, 671, 649, 508, 514, - 509, 510, 511, 512, 513, 0, 515, 1397, 1301, 0, - 1310, 1311, 398, 1406, 591, 592, 672, 384, 486, 603, - 335, 349, 352, 341, 361, 0, 362, 337, 338, 343, - 346, 347, 348, 353, 354, 358, 364, 249, 210, 390, - 399, 578, 312, 216, 217, 218, 524, 525, 526, 527, - 619, 620, 624, 205, 462, 463, 464, 465, 292, 614, - 309, 468, 467, 331, 332, 379, 449, 540, 542, 553, - 557, 559, 561, 567, 570, 541, 543, 554, 558, 560, - 562, 568, 571, 530, 532, 534, 536, 549, 548, 545, - 573, 574, 551, 556, 535, 547, 552, 565, 572, 569, - 529, 533, 537, 546, 564, 563, 544, 555, 566, 550, - 538, 531, 539, 1368, 196, 221, 368, 1432, 454, 288, - 650, 618, 484, 613, 206, 223, 1304, 262, 1316, 1324, - 0, 1330, 1338, 1339, 1352, 1355, 1356, 1357, 1358, 1376, - 1377, 1379, 1387, 1389, 1392, 1394, 1401, 1415, 1435, 198, - 200, 209, 222, 232, 236, 243, 261, 276, 278, 285, - 298, 310, 318, 319, 322, 328, 380, 386, 387, 388, - 389, 409, 410, 411, 414, 417, 418, 421, 423, 424, - 427, 431, 435, 436, 437, 439, 441, 443, 455, 460, - 474, 475, 476, 477, 478, 481, 482, 488, 489, 490, - 491, 492, 500, 501, 516, 586, 588, 605, 625, 632, - 480, 301, 302, 444, 445, 314, 315, 646, 647, 300, - 600, 633, 597, 645, 627, 438, 378, 1367, 1373, 381, - 281, 305, 320, 1382, 617, 502, 227, 466, 290, 251, - 1400, 1402, 211, 246, 230, 259, 274, 277, 324, 391, - 400, 429, 434, 296, 271, 244, 459, 241, 485, 519, - 520, 521, 523, 395, 266, 433, 1363, 1391, 376, 576, - 577, 316, 396, 0, 0, 0, 0, 0, 0, 1421, - 1405, 528, 0, 1347, 1424, 1315, 1334, 1434, 1337, 1340, - 1384, 1293, 1362, 416, 1331, 1319, 1288, 1326, 1289, 1317, - 1349, 270, 1314, 1407, 1366, 1423, 366, 267, 1295, 1286, - 204, 505, 1320, 430, 1336, 203, 1386, 487, 252, 377, - 374, 583, 282, 273, 269, 250, 317, 385, 428, 518, - 422, 1430, 370, 1372, 0, 497, 401, 0, 0, 0, - 1411, 1410, 1341, 1351, 1413, 1360, 1398, 1346, 1385, 1303, - 1371, 1425, 1332, 1381, 1426, 323, 248, 325, 202, 413, - 498, 286, 0, 0, 0, 0, 0, 507, 959, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, - 0, 245, 0, 0, 0, 351, 360, 359, 339, 340, - 342, 344, 350, 357, 363, 336, 345, 1328, 1378, 609, - 1420, 1329, 1380, 265, 321, 272, 264, 580, 1431, 1412, - 1292, 1359, 1419, 1354, 596, 0, 0, 229, 1422, 1353, - 0, 1383, 0, 1437, 1287, 1374, 0, 1290, 1294, 1433, - 1417, 1323, 275, 0, 0, 0, 0, 0, 0, 0, - 1350, 1361, 1395, 1399, 1344, 0, 0, 0, 0, 0, - 0, 0, 0, 1321, 0, 1370, 0, 0, 0, 1299, - 1291, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1348, 0, 0, 0, 0, 1302, 0, - 1322, 1396, 0, 1285, 297, 1296, 402, 257, 0, 453, - 1403, 1416, 1345, 629, 1418, 1343, 1342, 1390, 1300, 1409, - 1335, 365, 1298, 330, 197, 225, 0, 1333, 412, 461, - 473, 1408, 1318, 1327, 253, 1325, 471, 426, 604, 233, - 284, 458, 432, 469, 440, 287, 1369, 1388, 470, 372, - 585, 450, 601, 630, 631, 263, 406, 615, 522, 623, - 648, 226, 260, 420, 506, 607, 494, 397, 581, 582, - 329, 493, 295, 201, 369, 636, 224, 479, 371, 242, - 231, 587, 612, 299, 289, 456, 643, 213, 517, 598, - 239, 483, 0, 0, 651, 247, 504, 610, 599, 215, - 594, 503, 393, 326, 327, 214, 0, 457, 268, 293, - 0, 0, 258, 415, 589, 590, 256, 652, 228, 622, - 220, 1297, 621, 408, 584, 595, 394, 383, 219, 593, - 392, 382, 334, 355, 356, 280, 307, 447, 375, 448, - 306, 308, 404, 403, 405, 207, 608, 626, 0, 208, - 0, 499, 611, 653, 452, 212, 234, 235, 237, 1313, - 279, 283, 291, 294, 303, 304, 313, 367, 419, 446, - 442, 451, 1404, 579, 602, 616, 628, 634, 635, 637, - 638, 639, 640, 641, 644, 642, 407, 311, 495, 333, - 373, 1393, 1436, 425, 472, 240, 606, 496, 199, 1307, - 1312, 1305, 0, 254, 255, 1375, 575, 1308, 1306, 1364, - 1365, 1309, 1427, 1428, 1429, 1414, 654, 655, 656, 657, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 1398, 1302, 0, 1311, 1312, 399, 1407, 592, 593, + 673, 385, 487, 604, 336, 350, 353, 342, 362, 0, + 363, 338, 339, 344, 347, 348, 349, 354, 355, 359, + 365, 249, 210, 391, 400, 579, 313, 216, 217, 218, + 525, 526, 527, 528, 620, 621, 625, 205, 463, 464, + 465, 466, 293, 615, 310, 469, 468, 332, 333, 380, + 450, 541, 543, 554, 558, 560, 562, 568, 571, 542, + 544, 555, 559, 561, 563, 569, 572, 531, 533, 535, + 537, 550, 549, 546, 574, 575, 552, 557, 536, 548, + 553, 566, 573, 570, 530, 534, 538, 547, 565, 564, + 545, 556, 567, 551, 539, 532, 540, 1369, 196, 221, + 369, 1433, 455, 289, 651, 619, 485, 614, 206, 223, + 1305, 263, 1317, 1325, 0, 1331, 1339, 1340, 1353, 1356, + 1357, 1358, 1359, 1377, 1378, 1380, 1388, 1390, 1393, 1395, + 1402, 1416, 1436, 198, 200, 209, 222, 232, 236, 243, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 302, 303, 445, 446, 315, + 316, 647, 648, 301, 601, 634, 598, 646, 628, 439, + 379, 1368, 1374, 382, 282, 306, 321, 1383, 618, 503, + 227, 467, 291, 251, 1401, 1403, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 1364, 1392, 377, 577, 578, 317, 397, 0, 0, 0, + 0, 0, 0, 1422, 1406, 529, 0, 1348, 1425, 1316, + 1335, 1435, 1338, 1341, 1385, 1294, 1363, 417, 1332, 1320, + 1289, 1327, 1290, 1318, 1350, 271, 1315, 1408, 1367, 1424, + 367, 268, 1296, 1287, 204, 506, 1321, 431, 1337, 203, + 1387, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 1431, 371, 1373, 0, 498, + 402, 0, 0, 0, 1412, 1411, 1342, 1352, 1414, 1361, + 1399, 1347, 1386, 1304, 1372, 1426, 1333, 1382, 1427, 324, + 248, 326, 202, 414, 499, 287, 0, 0, 0, 0, + 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 238, 0, 0, 245, 0, 0, 0, 352, + 361, 360, 340, 341, 343, 345, 351, 358, 364, 337, + 346, 1329, 1379, 610, 1421, 1330, 1381, 266, 322, 273, + 265, 581, 1432, 1413, 1293, 1360, 1420, 1355, 597, 0, + 0, 229, 1423, 1354, 0, 1384, 0, 1438, 1288, 1375, + 0, 1291, 1295, 1434, 1418, 1324, 276, 0, 0, 0, + 0, 0, 0, 0, 1351, 1362, 1396, 1400, 1345, 0, + 0, 0, 0, 0, 0, 0, 0, 1322, 0, 1371, + 0, 0, 0, 1300, 1292, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1349, 0, 0, + 0, 0, 1303, 0, 1323, 1397, 0, 1286, 298, 1297, + 403, 258, 0, 454, 1404, 1417, 1346, 630, 1419, 1344, + 1343, 1391, 1301, 1410, 1336, 366, 1299, 331, 197, 225, + 0, 1334, 413, 462, 474, 1409, 1319, 1328, 254, 1326, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 1370, 1389, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 590, + 591, 257, 653, 228, 623, 220, 1298, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 356, 357, + 281, 308, 448, 376, 449, 307, 309, 405, 404, 406, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 1314, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 1405, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 1394, 1437, 426, 473, + 240, 607, 497, 199, 1308, 1313, 1306, 0, 255, 256, + 1376, 576, 1309, 1307, 1365, 1366, 1310, 1428, 1429, 1430, + 1415, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 1398, + 1302, 0, 1311, 1312, 399, 1407, 592, 593, 673, 385, + 487, 604, 336, 350, 353, 342, 362, 0, 363, 338, + 339, 344, 347, 348, 349, 354, 355, 359, 365, 249, + 210, 391, 400, 579, 313, 216, 217, 218, 525, 526, + 527, 528, 620, 621, 625, 205, 463, 464, 465, 466, + 293, 615, 310, 469, 468, 332, 333, 380, 450, 541, + 543, 554, 558, 560, 562, 568, 571, 542, 544, 555, + 559, 561, 563, 569, 572, 531, 533, 535, 537, 550, + 549, 546, 574, 575, 552, 557, 536, 548, 553, 566, + 573, 570, 530, 534, 538, 547, 565, 564, 545, 556, + 567, 551, 539, 532, 540, 1369, 196, 221, 369, 1433, + 455, 289, 651, 619, 485, 614, 206, 223, 1305, 263, + 1317, 1325, 0, 1331, 1339, 1340, 1353, 1356, 1357, 1358, + 1359, 1377, 1378, 1380, 1388, 1390, 1393, 1395, 1402, 1416, + 1436, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 302, 303, 445, 446, 315, 316, 647, + 648, 301, 601, 634, 598, 646, 628, 439, 379, 1368, + 1374, 382, 282, 306, 321, 1383, 618, 503, 227, 467, + 291, 251, 1401, 1403, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 1364, 1392, + 377, 577, 578, 317, 397, 0, 0, 0, 0, 0, + 0, 1422, 1406, 529, 0, 1348, 1425, 1316, 1335, 1435, + 1338, 1341, 1385, 1294, 1363, 417, 1332, 1320, 1289, 1327, + 1290, 1318, 1350, 271, 1315, 1408, 1367, 1424, 367, 268, + 1296, 1287, 204, 506, 1321, 431, 1337, 203, 1387, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 1431, 371, 1373, 0, 498, 402, 0, + 0, 0, 1412, 1411, 1342, 1352, 1414, 1361, 1399, 1347, + 1386, 1304, 1372, 1426, 1333, 1382, 1427, 324, 248, 326, + 202, 414, 499, 287, 0, 0, 0, 0, 0, 508, + 960, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 238, 0, 0, 245, 0, 0, 0, 352, 361, 360, + 340, 341, 343, 345, 351, 358, 364, 337, 346, 1329, + 1379, 610, 1421, 1330, 1381, 266, 322, 273, 265, 581, + 1432, 1413, 1293, 1360, 1420, 1355, 597, 0, 0, 229, + 1423, 1354, 0, 1384, 0, 1438, 1288, 1375, 0, 1291, + 1295, 1434, 1418, 1324, 276, 0, 0, 0, 0, 0, + 0, 0, 1351, 1362, 1396, 1400, 1345, 0, 0, 0, + 0, 0, 0, 0, 0, 1322, 0, 1371, 0, 0, + 0, 1300, 1292, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1349, 0, 0, 0, 0, + 1303, 0, 1323, 1397, 0, 1286, 298, 1297, 403, 258, + 0, 454, 1404, 1417, 1346, 630, 1419, 1344, 1343, 1391, + 1301, 1410, 1336, 366, 1299, 331, 197, 225, 0, 1334, + 413, 462, 474, 1409, 1319, 1328, 254, 1326, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 1370, 1389, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 590, 591, 257, + 653, 228, 623, 220, 1298, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 356, 357, 281, 308, + 448, 376, 449, 307, 309, 405, 404, 406, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 1314, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 1405, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 1394, 1437, 426, 473, 240, 607, + 497, 199, 1308, 1313, 1306, 0, 255, 256, 1376, 576, + 1309, 1307, 1365, 1366, 1310, 1428, 1429, 1430, 1415, 655, + 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 1398, 1302, 0, + 1311, 1312, 399, 1407, 592, 593, 673, 385, 487, 604, + 336, 350, 353, 342, 362, 0, 363, 338, 339, 344, + 347, 348, 349, 354, 355, 359, 365, 249, 210, 391, + 400, 579, 313, 216, 217, 218, 525, 526, 527, 528, + 620, 621, 625, 205, 463, 464, 465, 466, 293, 615, + 310, 469, 468, 332, 333, 380, 450, 541, 543, 554, + 558, 560, 562, 568, 571, 542, 544, 555, 559, 561, + 563, 569, 572, 531, 533, 535, 537, 550, 549, 546, + 574, 575, 552, 557, 536, 548, 553, 566, 573, 570, + 530, 534, 538, 547, 565, 564, 545, 556, 567, 551, + 539, 532, 540, 1369, 196, 221, 369, 1433, 455, 289, + 651, 619, 485, 614, 206, 223, 1305, 263, 1317, 1325, + 0, 1331, 1339, 1340, 1353, 1356, 1357, 1358, 1359, 1377, + 1378, 1380, 1388, 1390, 1393, 1395, 1402, 1416, 1436, 198, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 302, 303, 445, 446, 315, 316, 647, 648, 301, + 601, 634, 598, 646, 628, 439, 379, 1368, 1374, 382, + 282, 306, 321, 1383, 618, 503, 227, 467, 291, 251, + 1401, 1403, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 1364, 1392, 377, 577, + 578, 317, 397, 0, 0, 0, 0, 0, 0, 0, + 0, 529, 0, 778, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 765, 0, 0, + 0, 271, 770, 0, 0, 0, 367, 268, 0, 0, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 777, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 772, 773, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 95, 0, 0, 1024, 508, 960, 749, + 926, 964, 1025, 977, 978, 979, 965, 0, 238, 966, + 967, 245, 968, 0, 925, 808, 810, 809, 875, 876, + 877, 878, 879, 880, 881, 811, 812, 806, 973, 610, + 980, 981, 0, 266, 322, 273, 265, 581, 0, 0, + 2233, 2234, 2235, 0, 597, 0, 0, 229, 0, 0, + 0, 0, 0, 0, 0, 745, 762, 0, 776, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 759, + 760, 0, 0, 0, 0, 920, 0, 761, 0, 0, + 769, 982, 983, 984, 985, 986, 987, 988, 989, 990, + 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, + 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, + 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, + 1021, 1022, 1023, 771, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 298, 0, 403, 258, 0, 454, + 919, 0, 0, 630, 0, 0, 917, 0, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 970, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 971, 972, 257, 653, 816, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 824, 825, 281, 308, 901, 900, + 899, 307, 309, 897, 898, 896, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 907, + 929, 918, 782, 783, 908, 909, 933, 910, 785, 786, + 930, 931, 779, 780, 784, 932, 934, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, - 668, 669, 670, 671, 649, 508, 514, 509, 510, 511, - 512, 513, 0, 515, 1397, 1301, 0, 1310, 1311, 398, - 1406, 591, 592, 672, 384, 486, 603, 335, 349, 352, - 341, 361, 0, 362, 337, 338, 343, 346, 347, 348, - 353, 354, 358, 364, 249, 210, 390, 399, 578, 312, - 216, 217, 218, 524, 525, 526, 527, 619, 620, 624, - 205, 462, 463, 464, 465, 292, 614, 309, 468, 467, - 331, 332, 379, 449, 540, 542, 553, 557, 559, 561, - 567, 570, 541, 543, 554, 558, 560, 562, 568, 571, - 530, 532, 534, 536, 549, 548, 545, 573, 574, 551, - 556, 535, 547, 552, 565, 572, 569, 529, 533, 537, - 546, 564, 563, 544, 555, 566, 550, 538, 531, 539, - 1368, 196, 221, 368, 1432, 454, 288, 650, 618, 484, - 613, 206, 223, 1304, 262, 1316, 1324, 0, 1330, 1338, - 1339, 1352, 1355, 1356, 1357, 1358, 1376, 1377, 1379, 1387, - 1389, 1392, 1394, 1401, 1415, 1435, 198, 200, 209, 222, - 232, 236, 243, 261, 276, 278, 285, 298, 310, 318, - 319, 322, 328, 380, 386, 387, 388, 389, 409, 410, - 411, 414, 417, 418, 421, 423, 424, 427, 431, 435, - 436, 437, 439, 441, 443, 455, 460, 474, 475, 476, - 477, 478, 481, 482, 488, 489, 490, 491, 492, 500, - 501, 516, 586, 588, 605, 625, 632, 480, 301, 302, - 444, 445, 314, 315, 646, 647, 300, 600, 633, 597, - 645, 627, 438, 378, 1367, 1373, 381, 281, 305, 320, - 1382, 617, 502, 227, 466, 290, 251, 1400, 1402, 211, - 246, 230, 259, 274, 277, 324, 391, 400, 429, 434, - 296, 271, 244, 459, 241, 485, 519, 520, 521, 523, - 395, 266, 433, 1363, 1391, 376, 576, 577, 316, 396, - 0, 0, 0, 0, 0, 0, 0, 0, 528, 0, - 777, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 416, 0, 0, 0, 764, 0, 0, 0, 270, 769, - 0, 0, 0, 366, 267, 0, 0, 204, 505, 0, - 430, 0, 203, 0, 487, 252, 377, 374, 583, 282, - 273, 269, 250, 317, 385, 428, 518, 422, 776, 370, - 0, 0, 497, 401, 0, 0, 0, 0, 0, 0, - 0, 0, 771, 772, 0, 0, 0, 0, 0, 0, - 0, 0, 323, 248, 325, 202, 413, 498, 286, 0, - 95, 0, 0, 1023, 507, 959, 748, 925, 963, 1024, - 976, 977, 978, 964, 0, 238, 965, 966, 245, 967, - 0, 924, 807, 809, 808, 874, 875, 876, 877, 878, - 879, 880, 810, 811, 805, 972, 609, 979, 980, 0, - 265, 321, 272, 264, 580, 0, 0, 2232, 2233, 2234, - 0, 596, 0, 0, 229, 0, 0, 0, 0, 0, - 0, 0, 744, 761, 0, 775, 0, 0, 0, 275, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 758, 759, 0, 0, - 0, 0, 919, 0, 760, 0, 0, 768, 981, 982, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 921, 768, 767, 0, 774, + 775, 0, 804, 805, 807, 813, 814, 815, 826, 873, + 874, 882, 884, 885, 883, 886, 887, 888, 891, 892, + 893, 894, 889, 890, 895, 787, 791, 788, 789, 790, + 802, 792, 793, 794, 795, 796, 797, 798, 799, 800, + 801, 803, 944, 945, 946, 947, 948, 949, 819, 823, + 822, 820, 821, 817, 818, 845, 844, 846, 847, 848, + 849, 850, 851, 853, 852, 854, 855, 856, 857, 858, + 859, 827, 828, 831, 832, 830, 829, 833, 842, 843, + 834, 835, 836, 837, 838, 839, 841, 840, 860, 861, + 862, 863, 864, 866, 865, 869, 870, 868, 867, 872, + 871, 766, 196, 221, 369, 0, 455, 289, 651, 619, + 485, 614, 206, 223, 935, 263, 936, 0, 0, 940, + 0, 0, 0, 942, 941, 0, 943, 905, 904, 0, + 0, 937, 938, 0, 939, 0, 0, 198, 200, 209, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 950, + 951, 952, 953, 954, 955, 956, 957, 301, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 975, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 778, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 765, + 0, 0, 0, 271, 770, 0, 0, 0, 367, 268, + 0, 0, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 777, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 772, 773, 0, + 0, 0, 0, 0, 0, 2440, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 95, 0, 0, 1024, 508, + 960, 749, 926, 964, 1025, 977, 978, 979, 965, 0, + 238, 966, 967, 245, 968, 0, 925, 808, 810, 809, + 875, 876, 877, 878, 879, 880, 881, 811, 812, 806, + 973, 610, 980, 981, 2441, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 745, 762, 0, + 776, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 759, 760, 0, 0, 0, 0, 920, 0, 761, + 0, 0, 769, 982, 983, 984, 985, 986, 987, 988, + 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, + 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, + 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, + 1019, 1020, 1021, 1022, 1023, 771, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 919, 0, 0, 630, 0, 0, 917, 0, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 970, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 971, 972, 257, + 653, 816, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 824, 825, 281, 308, + 901, 900, 899, 307, 309, 897, 898, 896, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 907, 929, 918, 782, 783, 908, 909, 933, 910, + 785, 786, 930, 931, 779, 780, 784, 932, 934, 655, + 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 921, 768, 767, + 0, 774, 775, 0, 804, 805, 807, 813, 814, 815, + 826, 873, 874, 882, 884, 885, 883, 886, 887, 888, + 891, 892, 893, 894, 889, 890, 895, 787, 791, 788, + 789, 790, 802, 792, 793, 794, 795, 796, 797, 798, + 799, 800, 801, 803, 944, 945, 946, 947, 948, 949, + 819, 823, 822, 820, 821, 817, 818, 845, 844, 846, + 847, 848, 849, 850, 851, 853, 852, 854, 855, 856, + 857, 858, 859, 827, 828, 831, 832, 830, 829, 833, + 842, 843, 834, 835, 836, 837, 838, 839, 841, 840, + 860, 861, 862, 863, 864, 866, 865, 869, 870, 868, + 867, 872, 871, 766, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 935, 263, 936, 0, + 0, 940, 0, 0, 0, 942, 941, 0, 943, 905, + 904, 0, 0, 937, 938, 0, 939, 0, 0, 198, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 950, 951, 952, 953, 954, 955, 956, 957, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 975, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 397, 0, 377, 577, + 578, 317, 0, 0, 86, 529, 0, 778, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, + 0, 765, 0, 0, 0, 271, 770, 0, 0, 0, + 367, 268, 0, 0, 204, 506, 0, 431, 0, 203, + 0, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 777, 371, 0, 0, 498, + 402, 0, 0, 0, 0, 0, 0, 0, 0, 772, + 773, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 248, 326, 202, 414, 499, 287, 0, 95, 0, 0, + 1024, 508, 960, 749, 926, 964, 1025, 977, 978, 979, + 965, 0, 238, 966, 967, 245, 968, 0, 925, 808, + 810, 809, 875, 876, 877, 878, 879, 880, 881, 811, + 812, 806, 973, 610, 980, 981, 0, 266, 322, 273, + 265, 581, 0, 0, 0, 0, 0, 0, 597, 0, + 0, 229, 0, 0, 0, 0, 0, 0, 0, 745, + 762, 0, 776, 0, 0, 0, 276, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 759, 760, 0, 0, 0, 0, 920, + 0, 761, 0, 0, 769, 982, 983, 984, 985, 986, + 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, + 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, + 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, + 1017, 1018, 1019, 1020, 1021, 1022, 1023, 771, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 403, 258, 0, 454, 919, 0, 0, 630, 0, 0, + 917, 0, 0, 0, 0, 366, 0, 331, 197, 225, + 0, 0, 413, 462, 474, 0, 0, 0, 970, 0, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 0, 0, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 971, + 972, 257, 653, 816, 623, 220, 0, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 824, 825, + 281, 308, 901, 900, 899, 307, 309, 897, 898, 896, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 0, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 0, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 0, 0, 426, 473, + 240, 607, 497, 907, 929, 918, 782, 783, 908, 909, + 933, 910, 785, 786, 930, 931, 779, 780, 784, 932, + 934, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 921, + 768, 767, 0, 774, 775, 0, 804, 805, 807, 813, + 814, 815, 826, 873, 874, 882, 884, 885, 883, 886, + 887, 888, 891, 892, 893, 894, 889, 890, 895, 787, + 791, 788, 789, 790, 802, 792, 793, 794, 795, 796, + 797, 798, 799, 800, 801, 803, 944, 945, 946, 947, + 948, 949, 819, 823, 822, 820, 821, 817, 818, 845, + 844, 846, 847, 848, 849, 850, 851, 853, 852, 854, + 855, 856, 857, 858, 859, 827, 828, 831, 832, 830, + 829, 833, 842, 843, 834, 835, 836, 837, 838, 839, + 841, 840, 860, 861, 862, 863, 864, 866, 865, 869, + 870, 868, 867, 872, 871, 766, 196, 221, 369, 94, + 455, 289, 651, 619, 485, 614, 206, 223, 935, 263, + 936, 0, 0, 940, 0, 0, 0, 942, 941, 0, + 943, 905, 904, 0, 0, 937, 938, 0, 939, 0, + 0, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 950, 951, 952, 953, 954, 955, 956, + 957, 301, 601, 634, 598, 646, 628, 439, 379, 0, + 0, 382, 282, 306, 321, 0, 618, 503, 227, 467, + 291, 251, 975, 0, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 397, 0, + 377, 577, 578, 317, 0, 0, 0, 529, 0, 778, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 765, 0, 0, 0, 271, 770, 0, + 0, 0, 367, 268, 0, 0, 204, 506, 0, 431, + 0, 203, 0, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 777, 371, 0, + 0, 498, 402, 0, 0, 0, 0, 0, 0, 0, + 0, 772, 773, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 248, 326, 202, 414, 499, 287, 0, 95, + 0, 0, 1024, 508, 960, 749, 926, 964, 1025, 977, + 978, 979, 965, 0, 238, 966, 967, 245, 968, 0, + 925, 808, 810, 809, 875, 876, 877, 878, 879, 880, + 881, 811, 812, 806, 973, 610, 980, 981, 0, 266, + 322, 273, 265, 581, 0, 0, 0, 0, 0, 0, + 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, + 0, 745, 762, 0, 776, 0, 0, 0, 276, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 759, 760, 0, 0, 0, + 0, 920, 0, 761, 0, 0, 769, 982, 983, 984, + 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, + 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, + 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, + 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 771, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 298, 0, 403, 258, 0, 454, 919, 0, 0, 630, + 0, 0, 917, 0, 0, 0, 0, 366, 0, 331, + 197, 225, 0, 0, 413, 462, 474, 0, 0, 0, + 970, 0, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 4098, 0, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 971, 972, 257, 653, 816, 623, 220, 0, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 824, 825, 281, 308, 901, 900, 899, 307, 309, 897, + 898, 896, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 0, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 0, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 0, 0, + 426, 473, 240, 607, 497, 907, 929, 918, 782, 783, + 908, 909, 933, 910, 785, 786, 930, 931, 779, 780, + 784, 932, 934, 655, 656, 657, 658, 659, 660, 661, + 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 921, 768, 767, 0, 774, 775, 0, 804, 805, + 807, 813, 814, 815, 826, 873, 874, 882, 884, 885, + 883, 886, 887, 888, 891, 892, 893, 894, 889, 890, + 895, 787, 791, 788, 789, 790, 802, 792, 793, 794, + 795, 796, 797, 798, 799, 800, 801, 803, 944, 945, + 946, 947, 948, 949, 819, 823, 822, 820, 821, 817, + 818, 845, 844, 846, 847, 848, 849, 850, 851, 853, + 852, 854, 855, 856, 857, 858, 859, 827, 828, 831, + 832, 830, 829, 833, 842, 843, 834, 835, 836, 837, + 838, 839, 841, 840, 860, 861, 862, 863, 864, 866, + 865, 869, 870, 868, 867, 872, 871, 766, 196, 221, + 369, 0, 455, 289, 651, 619, 485, 614, 206, 223, + 935, 263, 936, 0, 0, 940, 0, 0, 0, 942, + 941, 0, 943, 905, 904, 0, 0, 937, 938, 0, + 939, 0, 0, 198, 200, 209, 222, 232, 236, 243, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 950, 951, 952, 953, 954, + 955, 956, 957, 301, 601, 634, 598, 646, 628, 439, + 379, 0, 0, 382, 282, 306, 321, 0, 618, 503, + 227, 467, 291, 251, 975, 0, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 397, 0, 377, 577, 578, 317, 0, 0, 0, 529, + 0, 778, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 0, 765, 0, 0, 0, 271, + 770, 0, 0, 0, 367, 268, 0, 0, 204, 506, + 0, 431, 0, 203, 0, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 777, + 371, 0, 0, 498, 402, 0, 0, 0, 0, 0, + 0, 0, 0, 772, 773, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 248, 326, 202, 414, 499, 287, + 0, 95, 0, 1754, 1024, 508, 960, 749, 926, 964, + 1025, 977, 978, 979, 965, 0, 238, 966, 967, 245, + 968, 0, 925, 808, 810, 809, 875, 876, 877, 878, + 879, 880, 881, 811, 812, 806, 973, 610, 980, 981, + 0, 266, 322, 273, 265, 581, 0, 0, 0, 0, + 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, + 0, 0, 0, 745, 762, 0, 776, 0, 0, 0, + 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 759, 760, 0, + 0, 0, 0, 920, 0, 761, 0, 0, 769, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, - 770, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 297, 0, 402, 257, 0, 453, 918, 0, 0, - 629, 0, 0, 916, 0, 0, 0, 0, 365, 0, - 330, 197, 225, 0, 0, 412, 461, 473, 0, 0, - 0, 969, 0, 471, 426, 604, 233, 284, 458, 432, - 469, 440, 287, 0, 0, 470, 372, 585, 450, 601, - 630, 631, 263, 406, 615, 522, 623, 648, 226, 260, - 420, 506, 607, 494, 397, 581, 582, 329, 493, 295, - 201, 369, 636, 224, 479, 371, 242, 231, 587, 612, - 299, 289, 456, 643, 213, 517, 598, 239, 483, 0, - 0, 651, 247, 504, 610, 599, 215, 594, 503, 393, - 326, 327, 214, 0, 457, 268, 293, 0, 0, 258, - 415, 970, 971, 256, 652, 815, 622, 220, 0, 621, - 408, 584, 595, 394, 383, 219, 593, 392, 382, 334, - 823, 824, 280, 307, 900, 899, 898, 306, 308, 896, - 897, 895, 207, 608, 626, 0, 208, 0, 499, 611, - 653, 452, 212, 234, 235, 237, 0, 279, 283, 291, - 294, 303, 304, 313, 367, 419, 446, 442, 451, 0, - 579, 602, 616, 628, 634, 635, 637, 638, 639, 640, - 641, 644, 642, 407, 311, 495, 333, 373, 0, 0, - 425, 472, 240, 606, 496, 906, 928, 917, 781, 782, - 907, 908, 932, 909, 784, 785, 929, 930, 778, 779, - 783, 931, 933, 654, 655, 656, 657, 658, 659, 660, - 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, - 671, 649, 508, 514, 509, 510, 511, 512, 513, 0, - 515, 920, 767, 766, 0, 773, 774, 0, 803, 804, - 806, 812, 813, 814, 825, 872, 873, 881, 883, 884, - 882, 885, 886, 887, 890, 891, 892, 893, 888, 889, - 894, 786, 790, 787, 788, 789, 801, 791, 792, 793, - 794, 795, 796, 797, 798, 799, 800, 802, 943, 944, - 945, 946, 947, 948, 818, 822, 821, 819, 820, 816, - 817, 844, 843, 845, 846, 847, 848, 849, 850, 852, - 851, 853, 854, 855, 856, 857, 858, 826, 827, 830, - 831, 829, 828, 832, 841, 842, 833, 834, 835, 836, - 837, 838, 840, 839, 859, 860, 861, 862, 863, 865, - 864, 868, 869, 867, 866, 871, 870, 765, 196, 221, - 368, 0, 454, 288, 650, 618, 484, 613, 206, 223, - 934, 262, 935, 0, 0, 939, 0, 0, 0, 941, - 940, 0, 942, 904, 903, 0, 0, 936, 937, 0, - 938, 0, 0, 198, 200, 209, 222, 232, 236, 243, - 261, 276, 278, 285, 298, 310, 318, 319, 322, 328, - 380, 386, 387, 388, 389, 409, 410, 411, 414, 417, - 418, 421, 423, 424, 427, 431, 435, 436, 437, 439, - 441, 443, 455, 460, 474, 475, 476, 477, 478, 481, - 482, 488, 489, 490, 491, 492, 500, 501, 516, 586, - 588, 605, 625, 632, 480, 949, 950, 951, 952, 953, - 954, 955, 956, 300, 600, 633, 597, 645, 627, 438, - 378, 0, 0, 381, 281, 305, 320, 0, 617, 502, - 227, 466, 290, 251, 974, 0, 211, 246, 230, 259, - 274, 277, 324, 391, 400, 429, 434, 296, 271, 244, - 459, 241, 485, 519, 520, 521, 523, 395, 266, 433, - 396, 0, 376, 576, 577, 316, 0, 0, 0, 528, - 0, 777, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 416, 0, 0, 0, 764, 0, 0, 0, 270, - 769, 0, 0, 0, 366, 267, 0, 0, 204, 505, - 0, 430, 0, 203, 0, 487, 252, 377, 374, 583, - 282, 273, 269, 250, 317, 385, 428, 518, 422, 776, - 370, 0, 0, 497, 401, 0, 0, 0, 0, 0, - 0, 0, 0, 771, 772, 0, 0, 0, 0, 0, - 0, 2439, 0, 323, 248, 325, 202, 413, 498, 286, - 0, 95, 0, 0, 1023, 507, 959, 748, 925, 963, - 1024, 976, 977, 978, 964, 0, 238, 965, 966, 245, - 967, 0, 924, 807, 809, 808, 874, 875, 876, 877, - 878, 879, 880, 810, 811, 805, 972, 609, 979, 980, - 2440, 265, 321, 272, 264, 580, 0, 0, 0, 0, - 0, 0, 596, 0, 0, 229, 0, 0, 0, 0, - 0, 0, 0, 744, 761, 0, 775, 0, 0, 0, - 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 758, 759, 0, - 0, 0, 0, 919, 0, 760, 0, 0, 768, 981, - 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, - 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, - 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, - 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, - 1022, 770, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 297, 0, 402, 257, 0, 453, 918, 0, - 0, 629, 0, 0, 916, 0, 0, 0, 0, 365, - 0, 330, 197, 225, 0, 0, 412, 461, 473, 0, - 0, 0, 969, 0, 471, 426, 604, 233, 284, 458, - 432, 469, 440, 287, 0, 0, 470, 372, 585, 450, - 601, 630, 631, 263, 406, 615, 522, 623, 648, 226, - 260, 420, 506, 607, 494, 397, 581, 582, 329, 493, - 295, 201, 369, 636, 224, 479, 371, 242, 231, 587, - 612, 299, 289, 456, 643, 213, 517, 598, 239, 483, - 0, 0, 651, 247, 504, 610, 599, 215, 594, 503, - 393, 326, 327, 214, 0, 457, 268, 293, 0, 0, - 258, 415, 970, 971, 256, 652, 815, 622, 220, 0, - 621, 408, 584, 595, 394, 383, 219, 593, 392, 382, - 334, 823, 824, 280, 307, 900, 899, 898, 306, 308, - 896, 897, 895, 207, 608, 626, 0, 208, 0, 499, - 611, 653, 452, 212, 234, 235, 237, 0, 279, 283, - 291, 294, 303, 304, 313, 367, 419, 446, 442, 451, - 0, 579, 602, 616, 628, 634, 635, 637, 638, 639, - 640, 641, 644, 642, 407, 311, 495, 333, 373, 0, - 0, 425, 472, 240, 606, 496, 906, 928, 917, 781, - 782, 907, 908, 932, 909, 784, 785, 929, 930, 778, - 779, 783, 931, 933, 654, 655, 656, 657, 658, 659, + 1023, 771, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 298, 0, 403, 258, 0, 454, 919, 0, + 0, 630, 0, 0, 917, 0, 0, 0, 0, 366, + 0, 331, 197, 225, 0, 0, 413, 462, 474, 0, + 0, 0, 970, 0, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 0, 0, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 971, 972, 257, 653, 816, 623, 220, + 0, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 824, 825, 281, 308, 901, 900, 899, 307, + 309, 897, 898, 896, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 0, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 0, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 0, 0, 426, 473, 240, 607, 497, 907, 929, 918, + 782, 783, 908, 909, 933, 910, 785, 786, 930, 931, + 779, 780, 784, 932, 934, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, - 670, 671, 649, 508, 514, 509, 510, 511, 512, 513, - 0, 515, 920, 767, 766, 0, 773, 774, 0, 803, - 804, 806, 812, 813, 814, 825, 872, 873, 881, 883, - 884, 882, 885, 886, 887, 890, 891, 892, 893, 888, - 889, 894, 786, 790, 787, 788, 789, 801, 791, 792, - 793, 794, 795, 796, 797, 798, 799, 800, 802, 943, - 944, 945, 946, 947, 948, 818, 822, 821, 819, 820, - 816, 817, 844, 843, 845, 846, 847, 848, 849, 850, - 852, 851, 853, 854, 855, 856, 857, 858, 826, 827, - 830, 831, 829, 828, 832, 841, 842, 833, 834, 835, - 836, 837, 838, 840, 839, 859, 860, 861, 862, 863, - 865, 864, 868, 869, 867, 866, 871, 870, 765, 196, - 221, 368, 0, 454, 288, 650, 618, 484, 613, 206, - 223, 934, 262, 935, 0, 0, 939, 0, 0, 0, - 941, 940, 0, 942, 904, 903, 0, 0, 936, 937, - 0, 938, 0, 0, 198, 200, 209, 222, 232, 236, - 243, 261, 276, 278, 285, 298, 310, 318, 319, 322, - 328, 380, 386, 387, 388, 389, 409, 410, 411, 414, - 417, 418, 421, 423, 424, 427, 431, 435, 436, 437, - 439, 441, 443, 455, 460, 474, 475, 476, 477, 478, - 481, 482, 488, 489, 490, 491, 492, 500, 501, 516, - 586, 588, 605, 625, 632, 480, 949, 950, 951, 952, - 953, 954, 955, 956, 300, 600, 633, 597, 645, 627, - 438, 378, 0, 0, 381, 281, 305, 320, 0, 617, - 502, 227, 466, 290, 251, 974, 0, 211, 246, 230, - 259, 274, 277, 324, 391, 400, 429, 434, 296, 271, - 244, 459, 241, 485, 519, 520, 521, 523, 395, 266, - 433, 396, 0, 376, 576, 577, 316, 0, 0, 86, - 528, 0, 777, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 416, 0, 0, 0, 764, 0, 0, 0, - 270, 769, 0, 0, 0, 366, 267, 0, 0, 204, - 505, 0, 430, 0, 203, 0, 487, 252, 377, 374, - 583, 282, 273, 269, 250, 317, 385, 428, 518, 422, - 776, 370, 0, 0, 497, 401, 0, 0, 0, 0, - 0, 0, 0, 0, 771, 772, 0, 0, 0, 0, - 0, 0, 0, 0, 323, 248, 325, 202, 413, 498, - 286, 0, 95, 0, 0, 1023, 507, 959, 748, 925, - 963, 1024, 976, 977, 978, 964, 0, 238, 965, 966, - 245, 967, 0, 924, 807, 809, 808, 874, 875, 876, - 877, 878, 879, 880, 810, 811, 805, 972, 609, 979, - 980, 0, 265, 321, 272, 264, 580, 0, 0, 0, - 0, 0, 0, 596, 0, 0, 229, 0, 0, 0, - 0, 0, 0, 0, 744, 761, 0, 775, 0, 0, - 0, 275, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 758, 759, - 0, 0, 0, 0, 919, 0, 760, 0, 0, 768, - 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 921, 768, 767, 0, 774, 775, 0, + 804, 805, 807, 813, 814, 815, 826, 873, 874, 882, + 884, 885, 883, 886, 887, 888, 891, 892, 893, 894, + 889, 890, 895, 787, 791, 788, 789, 790, 802, 792, + 793, 794, 795, 796, 797, 798, 799, 800, 801, 803, + 944, 945, 946, 947, 948, 949, 819, 823, 822, 820, + 821, 817, 818, 845, 844, 846, 847, 848, 849, 850, + 851, 853, 852, 854, 855, 856, 857, 858, 859, 827, + 828, 831, 832, 830, 829, 833, 842, 843, 834, 835, + 836, 837, 838, 839, 841, 840, 860, 861, 862, 863, + 864, 866, 865, 869, 870, 868, 867, 872, 871, 766, + 196, 221, 369, 0, 455, 289, 651, 619, 485, 614, + 206, 223, 935, 263, 936, 0, 0, 940, 0, 0, + 0, 942, 941, 0, 943, 905, 904, 0, 0, 937, + 938, 0, 939, 0, 0, 198, 200, 209, 222, 232, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 950, 951, 952, + 953, 954, 955, 956, 957, 301, 601, 634, 598, 646, + 628, 439, 379, 0, 0, 382, 282, 306, 321, 0, + 618, 503, 227, 467, 291, 251, 975, 0, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 397, 0, 377, 577, 578, 317, 0, 0, + 0, 529, 0, 778, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 765, 0, 0, + 0, 271, 770, 0, 0, 0, 367, 268, 0, 0, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 777, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 772, 773, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 95, 0, 0, 1024, 508, 960, 749, + 926, 964, 1025, 977, 978, 979, 965, 0, 238, 966, + 967, 245, 968, 0, 925, 808, 810, 809, 875, 876, + 877, 878, 879, 880, 881, 811, 812, 806, 973, 610, + 980, 981, 0, 266, 322, 273, 265, 581, 0, 0, + 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, + 0, 0, 0, 0, 0, 745, 762, 0, 776, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 759, + 760, 1070, 0, 0, 0, 920, 0, 761, 0, 0, + 769, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, - 1021, 1022, 770, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 297, 0, 402, 257, 0, 453, 918, - 0, 0, 629, 0, 0, 916, 0, 0, 0, 0, - 365, 0, 330, 197, 225, 0, 0, 412, 461, 473, - 0, 0, 0, 969, 0, 471, 426, 604, 233, 284, - 458, 432, 469, 440, 287, 0, 0, 470, 372, 585, - 450, 601, 630, 631, 263, 406, 615, 522, 623, 648, - 226, 260, 420, 506, 607, 494, 397, 581, 582, 329, - 493, 295, 201, 369, 636, 224, 479, 371, 242, 231, - 587, 612, 299, 289, 456, 643, 213, 517, 598, 239, - 483, 0, 0, 651, 247, 504, 610, 599, 215, 594, - 503, 393, 326, 327, 214, 0, 457, 268, 293, 0, - 0, 258, 415, 970, 971, 256, 652, 815, 622, 220, - 0, 621, 408, 584, 595, 394, 383, 219, 593, 392, - 382, 334, 823, 824, 280, 307, 900, 899, 898, 306, - 308, 896, 897, 895, 207, 608, 626, 0, 208, 0, - 499, 611, 653, 452, 212, 234, 235, 237, 0, 279, - 283, 291, 294, 303, 304, 313, 367, 419, 446, 442, - 451, 0, 579, 602, 616, 628, 634, 635, 637, 638, - 639, 640, 641, 644, 642, 407, 311, 495, 333, 373, - 0, 0, 425, 472, 240, 606, 496, 906, 928, 917, - 781, 782, 907, 908, 932, 909, 784, 785, 929, 930, - 778, 779, 783, 931, 933, 654, 655, 656, 657, 658, - 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, - 669, 670, 671, 649, 508, 514, 509, 510, 511, 512, - 513, 0, 515, 920, 767, 766, 0, 773, 774, 0, - 803, 804, 806, 812, 813, 814, 825, 872, 873, 881, - 883, 884, 882, 885, 886, 887, 890, 891, 892, 893, - 888, 889, 894, 786, 790, 787, 788, 789, 801, 791, - 792, 793, 794, 795, 796, 797, 798, 799, 800, 802, - 943, 944, 945, 946, 947, 948, 818, 822, 821, 819, - 820, 816, 817, 844, 843, 845, 846, 847, 848, 849, - 850, 852, 851, 853, 854, 855, 856, 857, 858, 826, - 827, 830, 831, 829, 828, 832, 841, 842, 833, 834, - 835, 836, 837, 838, 840, 839, 859, 860, 861, 862, - 863, 865, 864, 868, 869, 867, 866, 871, 870, 765, - 196, 221, 368, 94, 454, 288, 650, 618, 484, 613, - 206, 223, 934, 262, 935, 0, 0, 939, 0, 0, - 0, 941, 940, 0, 942, 904, 903, 0, 0, 936, - 937, 0, 938, 0, 0, 198, 200, 209, 222, 232, - 236, 243, 261, 276, 278, 285, 298, 310, 318, 319, - 322, 328, 380, 386, 387, 388, 389, 409, 410, 411, - 414, 417, 418, 421, 423, 424, 427, 431, 435, 436, - 437, 439, 441, 443, 455, 460, 474, 475, 476, 477, - 478, 481, 482, 488, 489, 490, 491, 492, 500, 501, - 516, 586, 588, 605, 625, 632, 480, 949, 950, 951, - 952, 953, 954, 955, 956, 300, 600, 633, 597, 645, - 627, 438, 378, 0, 0, 381, 281, 305, 320, 0, - 617, 502, 227, 466, 290, 251, 974, 0, 211, 246, - 230, 259, 274, 277, 324, 391, 400, 429, 434, 296, - 271, 244, 459, 241, 485, 519, 520, 521, 523, 395, - 266, 433, 396, 0, 376, 576, 577, 316, 0, 0, - 0, 528, 0, 777, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 416, 0, 0, 0, 764, 0, 0, - 0, 270, 769, 0, 0, 0, 366, 267, 0, 0, - 204, 505, 0, 430, 0, 203, 0, 487, 252, 377, - 374, 583, 282, 273, 269, 250, 317, 385, 428, 518, - 422, 776, 370, 0, 0, 497, 401, 0, 0, 0, - 0, 0, 0, 0, 0, 771, 772, 0, 0, 0, - 0, 0, 0, 0, 0, 323, 248, 325, 202, 413, - 498, 286, 0, 95, 0, 0, 1023, 507, 959, 748, - 925, 963, 1024, 976, 977, 978, 964, 0, 238, 965, - 966, 245, 967, 0, 924, 807, 809, 808, 874, 875, - 876, 877, 878, 879, 880, 810, 811, 805, 972, 609, - 979, 980, 0, 265, 321, 272, 264, 580, 0, 0, - 0, 0, 0, 0, 596, 0, 0, 229, 0, 0, - 0, 0, 0, 0, 0, 744, 761, 0, 775, 0, - 0, 0, 275, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 758, - 759, 0, 0, 0, 0, 919, 0, 760, 0, 0, - 768, 981, 982, 983, 984, 985, 986, 987, 988, 989, - 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, - 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, - 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, - 1020, 1021, 1022, 770, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 297, 0, 402, 257, 0, 453, - 918, 0, 0, 629, 0, 0, 916, 0, 0, 0, - 0, 365, 0, 330, 197, 225, 0, 0, 412, 461, - 473, 0, 0, 0, 969, 0, 471, 426, 604, 233, - 284, 458, 432, 469, 440, 287, 4095, 0, 470, 372, - 585, 450, 601, 630, 631, 263, 406, 615, 522, 623, - 648, 226, 260, 420, 506, 607, 494, 397, 581, 582, - 329, 493, 295, 201, 369, 636, 224, 479, 371, 242, - 231, 587, 612, 299, 289, 456, 643, 213, 517, 598, - 239, 483, 0, 0, 651, 247, 504, 610, 599, 215, - 594, 503, 393, 326, 327, 214, 0, 457, 268, 293, - 0, 0, 258, 415, 970, 971, 256, 652, 815, 622, - 220, 0, 621, 408, 584, 595, 394, 383, 219, 593, - 392, 382, 334, 823, 824, 280, 307, 900, 899, 898, - 306, 308, 896, 897, 895, 207, 608, 626, 0, 208, - 0, 499, 611, 653, 452, 212, 234, 235, 237, 0, - 279, 283, 291, 294, 303, 304, 313, 367, 419, 446, - 442, 451, 0, 579, 602, 616, 628, 634, 635, 637, - 638, 639, 640, 641, 644, 642, 407, 311, 495, 333, - 373, 0, 0, 425, 472, 240, 606, 496, 906, 928, - 917, 781, 782, 907, 908, 932, 909, 784, 785, 929, - 930, 778, 779, 783, 931, 933, 654, 655, 656, 657, + 1021, 1022, 1023, 771, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 298, 0, 403, 258, 0, 454, + 919, 0, 0, 630, 0, 0, 917, 0, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 970, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 971, 972, 257, 653, 816, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 824, 825, 281, 308, 901, 900, + 899, 307, 309, 897, 898, 896, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 907, + 929, 918, 782, 783, 908, 909, 933, 910, 785, 786, + 930, 931, 779, 780, 784, 932, 934, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, - 668, 669, 670, 671, 649, 508, 514, 509, 510, 511, - 512, 513, 0, 515, 920, 767, 766, 0, 773, 774, - 0, 803, 804, 806, 812, 813, 814, 825, 872, 873, - 881, 883, 884, 882, 885, 886, 887, 890, 891, 892, - 893, 888, 889, 894, 786, 790, 787, 788, 789, 801, - 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, - 802, 943, 944, 945, 946, 947, 948, 818, 822, 821, - 819, 820, 816, 817, 844, 843, 845, 846, 847, 848, - 849, 850, 852, 851, 853, 854, 855, 856, 857, 858, - 826, 827, 830, 831, 829, 828, 832, 841, 842, 833, - 834, 835, 836, 837, 838, 840, 839, 859, 860, 861, - 862, 863, 865, 864, 868, 869, 867, 866, 871, 870, - 765, 196, 221, 368, 0, 454, 288, 650, 618, 484, - 613, 206, 223, 934, 262, 935, 0, 0, 939, 0, - 0, 0, 941, 940, 0, 942, 904, 903, 0, 0, - 936, 937, 0, 938, 0, 0, 198, 200, 209, 222, - 232, 236, 243, 261, 276, 278, 285, 298, 310, 318, - 319, 322, 328, 380, 386, 387, 388, 389, 409, 410, - 411, 414, 417, 418, 421, 423, 424, 427, 431, 435, - 436, 437, 439, 441, 443, 455, 460, 474, 475, 476, - 477, 478, 481, 482, 488, 489, 490, 491, 492, 500, - 501, 516, 586, 588, 605, 625, 632, 480, 949, 950, - 951, 952, 953, 954, 955, 956, 300, 600, 633, 597, - 645, 627, 438, 378, 0, 0, 381, 281, 305, 320, - 0, 617, 502, 227, 466, 290, 251, 974, 0, 211, - 246, 230, 259, 274, 277, 324, 391, 400, 429, 434, - 296, 271, 244, 459, 241, 485, 519, 520, 521, 523, - 395, 266, 433, 396, 0, 376, 576, 577, 316, 0, - 0, 0, 528, 0, 777, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 416, 0, 0, 0, 764, 0, - 0, 0, 270, 769, 0, 0, 0, 366, 267, 0, - 0, 204, 505, 0, 430, 0, 203, 0, 487, 252, - 377, 374, 583, 282, 273, 269, 250, 317, 385, 428, - 518, 422, 776, 370, 0, 0, 497, 401, 0, 0, - 0, 0, 0, 0, 0, 0, 771, 772, 0, 0, - 0, 0, 0, 0, 0, 0, 323, 248, 325, 202, - 413, 498, 286, 0, 95, 0, 1753, 1023, 507, 959, - 748, 925, 963, 1024, 976, 977, 978, 964, 0, 238, - 965, 966, 245, 967, 0, 924, 807, 809, 808, 874, - 875, 876, 877, 878, 879, 880, 810, 811, 805, 972, - 609, 979, 980, 0, 265, 321, 272, 264, 580, 0, - 0, 0, 0, 0, 0, 596, 0, 0, 229, 0, - 0, 0, 0, 0, 0, 0, 744, 761, 0, 775, - 0, 0, 0, 275, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 758, 759, 0, 0, 0, 0, 919, 0, 760, 0, - 0, 768, 981, 982, 983, 984, 985, 986, 987, 988, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 921, 768, 767, 0, 774, + 775, 0, 804, 805, 807, 813, 814, 815, 826, 873, + 874, 882, 884, 885, 883, 886, 887, 888, 891, 892, + 893, 894, 889, 890, 895, 787, 791, 788, 789, 790, + 802, 792, 793, 794, 795, 796, 797, 798, 799, 800, + 801, 803, 944, 945, 946, 947, 948, 949, 819, 823, + 822, 820, 821, 817, 818, 845, 844, 846, 847, 848, + 849, 850, 851, 853, 852, 854, 855, 856, 857, 858, + 859, 827, 828, 831, 832, 830, 829, 833, 842, 843, + 834, 835, 836, 837, 838, 839, 841, 840, 860, 861, + 862, 863, 864, 866, 865, 869, 870, 868, 867, 872, + 871, 766, 196, 221, 369, 0, 455, 289, 651, 619, + 485, 614, 206, 223, 935, 263, 936, 0, 0, 940, + 0, 0, 0, 942, 941, 0, 943, 905, 904, 0, + 0, 937, 938, 0, 939, 0, 0, 198, 200, 209, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 950, + 951, 952, 953, 954, 955, 956, 957, 301, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 975, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 778, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 765, + 0, 0, 0, 271, 770, 0, 0, 0, 367, 268, + 0, 0, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 777, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 772, 773, 0, + 0, 0, 0, 0, 0, 0, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 95, 0, 0, 1024, 508, + 960, 749, 926, 964, 1025, 977, 978, 979, 965, 0, + 238, 966, 967, 245, 968, 0, 925, 808, 810, 809, + 875, 876, 877, 878, 879, 880, 881, 811, 812, 806, + 973, 610, 980, 981, 0, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 745, 762, 0, + 776, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 759, 760, 0, 0, 0, 0, 920, 0, 761, + 0, 0, 769, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, - 1019, 1020, 1021, 1022, 770, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 297, 0, 402, 257, 0, - 453, 918, 0, 0, 629, 0, 0, 916, 0, 0, - 0, 0, 365, 0, 330, 197, 225, 0, 0, 412, - 461, 473, 0, 0, 0, 969, 0, 471, 426, 604, - 233, 284, 458, 432, 469, 440, 287, 0, 0, 470, - 372, 585, 450, 601, 630, 631, 263, 406, 615, 522, - 623, 648, 226, 260, 420, 506, 607, 494, 397, 581, - 582, 329, 493, 295, 201, 369, 636, 224, 479, 371, - 242, 231, 587, 612, 299, 289, 456, 643, 213, 517, - 598, 239, 483, 0, 0, 651, 247, 504, 610, 599, - 215, 594, 503, 393, 326, 327, 214, 0, 457, 268, - 293, 0, 0, 258, 415, 970, 971, 256, 652, 815, - 622, 220, 0, 621, 408, 584, 595, 394, 383, 219, - 593, 392, 382, 334, 823, 824, 280, 307, 900, 899, - 898, 306, 308, 896, 897, 895, 207, 608, 626, 0, - 208, 0, 499, 611, 653, 452, 212, 234, 235, 237, - 0, 279, 283, 291, 294, 303, 304, 313, 367, 419, - 446, 442, 451, 0, 579, 602, 616, 628, 634, 635, - 637, 638, 639, 640, 641, 644, 642, 407, 311, 495, - 333, 373, 0, 0, 425, 472, 240, 606, 496, 906, - 928, 917, 781, 782, 907, 908, 932, 909, 784, 785, - 929, 930, 778, 779, 783, 931, 933, 654, 655, 656, - 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, - 667, 668, 669, 670, 671, 649, 508, 514, 509, 510, - 511, 512, 513, 0, 515, 920, 767, 766, 0, 773, - 774, 0, 803, 804, 806, 812, 813, 814, 825, 872, - 873, 881, 883, 884, 882, 885, 886, 887, 890, 891, - 892, 893, 888, 889, 894, 786, 790, 787, 788, 789, - 801, 791, 792, 793, 794, 795, 796, 797, 798, 799, - 800, 802, 943, 944, 945, 946, 947, 948, 818, 822, - 821, 819, 820, 816, 817, 844, 843, 845, 846, 847, - 848, 849, 850, 852, 851, 853, 854, 855, 856, 857, - 858, 826, 827, 830, 831, 829, 828, 832, 841, 842, - 833, 834, 835, 836, 837, 838, 840, 839, 859, 860, - 861, 862, 863, 865, 864, 868, 869, 867, 866, 871, - 870, 765, 196, 221, 368, 0, 454, 288, 650, 618, - 484, 613, 206, 223, 934, 262, 935, 0, 0, 939, - 0, 0, 0, 941, 940, 0, 942, 904, 903, 0, - 0, 936, 937, 0, 938, 0, 0, 198, 200, 209, - 222, 232, 236, 243, 261, 276, 278, 285, 298, 310, - 318, 319, 322, 328, 380, 386, 387, 388, 389, 409, - 410, 411, 414, 417, 418, 421, 423, 424, 427, 431, - 435, 436, 437, 439, 441, 443, 455, 460, 474, 475, - 476, 477, 478, 481, 482, 488, 489, 490, 491, 492, - 500, 501, 516, 586, 588, 605, 625, 632, 480, 949, - 950, 951, 952, 953, 954, 955, 956, 300, 600, 633, - 597, 645, 627, 438, 378, 0, 0, 381, 281, 305, - 320, 0, 617, 502, 227, 466, 290, 251, 974, 0, - 211, 246, 230, 259, 274, 277, 324, 391, 400, 429, - 434, 296, 271, 244, 459, 241, 485, 519, 520, 521, - 523, 395, 266, 433, 396, 0, 376, 576, 577, 316, - 0, 0, 0, 528, 0, 777, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 416, 0, 0, 0, 764, - 0, 0, 0, 270, 769, 0, 0, 0, 366, 267, - 0, 0, 204, 505, 0, 430, 0, 203, 0, 487, - 252, 377, 374, 583, 282, 273, 269, 250, 317, 385, - 428, 518, 422, 776, 370, 0, 0, 497, 401, 0, - 0, 0, 0, 0, 0, 0, 0, 771, 772, 0, - 0, 0, 0, 0, 0, 0, 0, 323, 248, 325, - 202, 413, 498, 286, 0, 95, 0, 0, 1023, 507, - 959, 748, 925, 963, 1024, 976, 977, 978, 964, 0, - 238, 965, 966, 245, 967, 0, 924, 807, 809, 808, - 874, 875, 876, 877, 878, 879, 880, 810, 811, 805, - 972, 609, 979, 980, 0, 265, 321, 272, 264, 580, - 0, 0, 0, 0, 0, 0, 596, 0, 0, 229, - 0, 0, 0, 0, 0, 0, 0, 744, 761, 0, - 775, 0, 0, 0, 275, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 758, 759, 1069, 0, 0, 0, 919, 0, 760, - 0, 0, 768, 981, 982, 983, 984, 985, 986, 987, - 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, - 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, - 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, - 1018, 1019, 1020, 1021, 1022, 770, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 297, 0, 402, 257, - 0, 453, 918, 0, 0, 629, 0, 0, 916, 0, - 0, 0, 0, 365, 0, 330, 197, 225, 0, 0, - 412, 461, 473, 0, 0, 0, 969, 0, 471, 426, - 604, 233, 284, 458, 432, 469, 440, 287, 0, 0, - 470, 372, 585, 450, 601, 630, 631, 263, 406, 615, - 522, 623, 648, 226, 260, 420, 506, 607, 494, 397, - 581, 582, 329, 493, 295, 201, 369, 636, 224, 479, - 371, 242, 231, 587, 612, 299, 289, 456, 643, 213, - 517, 598, 239, 483, 0, 0, 651, 247, 504, 610, - 599, 215, 594, 503, 393, 326, 327, 214, 0, 457, - 268, 293, 0, 0, 258, 415, 970, 971, 256, 652, - 815, 622, 220, 0, 621, 408, 584, 595, 394, 383, - 219, 593, 392, 382, 334, 823, 824, 280, 307, 900, - 899, 898, 306, 308, 896, 897, 895, 207, 608, 626, - 0, 208, 0, 499, 611, 653, 452, 212, 234, 235, - 237, 0, 279, 283, 291, 294, 303, 304, 313, 367, - 419, 446, 442, 451, 0, 579, 602, 616, 628, 634, - 635, 637, 638, 639, 640, 641, 644, 642, 407, 311, - 495, 333, 373, 0, 0, 425, 472, 240, 606, 496, - 906, 928, 917, 781, 782, 907, 908, 932, 909, 784, - 785, 929, 930, 778, 779, 783, 931, 933, 654, 655, + 1019, 1020, 1021, 1022, 1023, 771, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 919, 0, 0, 630, 0, 0, 917, 0, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 970, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 971, 972, 257, + 653, 816, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 824, 825, 281, 308, + 901, 900, 899, 307, 309, 897, 898, 896, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 907, 929, 918, 782, 783, 908, 909, 933, 910, + 785, 786, 930, 931, 779, 780, 784, 932, 934, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, - 666, 667, 668, 669, 670, 671, 649, 508, 514, 509, - 510, 511, 512, 513, 0, 515, 920, 767, 766, 0, - 773, 774, 0, 803, 804, 806, 812, 813, 814, 825, - 872, 873, 881, 883, 884, 882, 885, 886, 887, 890, - 891, 892, 893, 888, 889, 894, 786, 790, 787, 788, - 789, 801, 791, 792, 793, 794, 795, 796, 797, 798, - 799, 800, 802, 943, 944, 945, 946, 947, 948, 818, - 822, 821, 819, 820, 816, 817, 844, 843, 845, 846, - 847, 848, 849, 850, 852, 851, 853, 854, 855, 856, - 857, 858, 826, 827, 830, 831, 829, 828, 832, 841, - 842, 833, 834, 835, 836, 837, 838, 840, 839, 859, - 860, 861, 862, 863, 865, 864, 868, 869, 867, 866, - 871, 870, 765, 196, 221, 368, 0, 454, 288, 650, - 618, 484, 613, 206, 223, 934, 262, 935, 0, 0, - 939, 0, 0, 0, 941, 940, 0, 942, 904, 903, - 0, 0, 936, 937, 0, 938, 0, 0, 198, 200, - 209, 222, 232, 236, 243, 261, 276, 278, 285, 298, - 310, 318, 319, 322, 328, 380, 386, 387, 388, 389, - 409, 410, 411, 414, 417, 418, 421, 423, 424, 427, - 431, 435, 436, 437, 439, 441, 443, 455, 460, 474, - 475, 476, 477, 478, 481, 482, 488, 489, 490, 491, - 492, 500, 501, 516, 586, 588, 605, 625, 632, 480, - 949, 950, 951, 952, 953, 954, 955, 956, 300, 600, - 633, 597, 645, 627, 438, 378, 0, 0, 381, 281, - 305, 320, 0, 617, 502, 227, 466, 290, 251, 974, - 0, 211, 246, 230, 259, 274, 277, 324, 391, 400, - 429, 434, 296, 271, 244, 459, 241, 485, 519, 520, - 521, 523, 395, 266, 433, 396, 0, 376, 576, 577, - 316, 0, 0, 0, 528, 0, 777, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 416, 0, 0, 0, - 764, 0, 0, 0, 270, 769, 0, 0, 0, 366, - 267, 0, 0, 204, 505, 0, 430, 0, 203, 0, - 487, 252, 377, 374, 583, 282, 273, 269, 250, 317, - 385, 428, 518, 422, 776, 370, 0, 0, 497, 401, - 0, 0, 0, 0, 0, 0, 0, 0, 771, 772, - 0, 0, 0, 0, 0, 0, 0, 0, 323, 248, - 325, 202, 413, 498, 286, 0, 95, 0, 0, 1023, - 507, 959, 748, 925, 963, 1024, 976, 977, 978, 964, - 0, 238, 965, 966, 245, 967, 0, 924, 807, 809, - 808, 874, 875, 876, 877, 878, 879, 880, 810, 811, - 805, 972, 609, 979, 980, 0, 265, 321, 272, 264, - 580, 0, 0, 0, 0, 0, 0, 596, 0, 0, - 229, 0, 0, 0, 0, 0, 0, 0, 744, 761, - 0, 775, 0, 0, 0, 275, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 758, 759, 0, 0, 0, 0, 919, 0, - 760, 0, 0, 768, 981, 982, 983, 984, 985, 986, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 921, 768, 767, + 0, 774, 775, 0, 804, 805, 807, 813, 814, 815, + 826, 873, 874, 882, 884, 885, 883, 886, 887, 888, + 891, 892, 893, 894, 889, 890, 895, 787, 791, 788, + 789, 790, 802, 792, 793, 794, 795, 796, 797, 798, + 799, 800, 801, 803, 944, 945, 946, 947, 948, 949, + 819, 823, 822, 820, 821, 817, 818, 845, 844, 846, + 847, 848, 849, 850, 851, 853, 852, 854, 855, 856, + 857, 858, 859, 827, 828, 831, 832, 830, 829, 833, + 842, 843, 834, 835, 836, 837, 838, 839, 841, 840, + 860, 861, 862, 863, 864, 866, 865, 869, 870, 868, + 867, 872, 871, 766, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 935, 263, 936, 0, + 0, 940, 0, 0, 0, 942, 941, 0, 943, 905, + 904, 0, 0, 937, 938, 0, 939, 0, 0, 198, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 950, 951, 952, 953, 954, 955, 956, 957, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 975, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 397, 0, 377, 577, + 578, 317, 0, 0, 0, 529, 0, 778, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, + 0, 765, 0, 0, 0, 271, 770, 0, 0, 0, + 367, 268, 0, 0, 204, 506, 0, 431, 0, 203, + 0, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 777, 371, 0, 0, 498, + 402, 0, 0, 0, 0, 0, 0, 0, 0, 772, + 773, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 248, 326, 202, 414, 499, 287, 0, 95, 0, 0, + 1024, 508, 960, 749, 926, 964, 1025, 977, 978, 979, + 965, 0, 238, 966, 967, 245, 968, 0, 925, 808, + 810, 809, 875, 876, 877, 878, 879, 880, 881, 811, + 812, 806, 973, 610, 980, 981, 0, 266, 322, 273, + 265, 581, 0, 0, 0, 0, 0, 0, 597, 0, + 0, 229, 0, 0, 0, 0, 0, 0, 0, 745, + 762, 0, 776, 0, 0, 0, 276, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 759, 760, 0, 0, 0, 0, 920, + 0, 761, 0, 0, 769, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, - 1017, 1018, 1019, 1020, 1021, 1022, 770, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 297, 0, 402, - 257, 0, 453, 918, 0, 0, 629, 0, 0, 916, - 0, 0, 0, 0, 365, 0, 330, 197, 225, 0, - 0, 412, 461, 473, 0, 0, 0, 969, 0, 471, - 426, 604, 233, 284, 458, 432, 469, 440, 287, 0, - 0, 470, 372, 585, 450, 601, 630, 631, 263, 406, - 615, 522, 623, 648, 226, 260, 420, 506, 607, 494, - 397, 581, 582, 329, 493, 295, 201, 369, 636, 224, - 479, 371, 242, 231, 587, 612, 299, 289, 456, 643, - 213, 517, 598, 239, 483, 0, 0, 651, 247, 504, - 610, 599, 215, 594, 503, 393, 326, 327, 214, 0, - 457, 268, 293, 0, 0, 258, 415, 970, 971, 256, - 652, 815, 622, 220, 0, 621, 408, 584, 595, 394, - 383, 219, 593, 392, 382, 334, 823, 824, 280, 307, - 900, 899, 898, 306, 308, 896, 897, 895, 207, 608, - 626, 0, 208, 0, 499, 611, 653, 452, 212, 234, - 235, 237, 0, 279, 283, 291, 294, 303, 304, 313, - 367, 419, 446, 442, 451, 0, 579, 602, 616, 628, - 634, 635, 637, 638, 639, 640, 641, 644, 642, 407, - 311, 495, 333, 373, 0, 0, 425, 472, 240, 606, - 496, 906, 928, 917, 781, 782, 907, 908, 932, 909, - 784, 785, 929, 930, 778, 779, 783, 931, 933, 654, - 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, - 665, 666, 667, 668, 669, 670, 671, 649, 508, 514, - 509, 510, 511, 512, 513, 0, 515, 920, 767, 766, - 0, 773, 774, 0, 803, 804, 806, 812, 813, 814, - 825, 872, 873, 881, 883, 884, 882, 885, 886, 887, - 890, 891, 892, 893, 888, 889, 894, 786, 790, 787, - 788, 789, 801, 791, 792, 793, 794, 795, 796, 797, - 798, 799, 800, 802, 943, 944, 945, 946, 947, 948, - 818, 822, 821, 819, 820, 816, 817, 844, 843, 845, - 846, 847, 848, 849, 850, 852, 851, 853, 854, 855, - 856, 857, 858, 826, 827, 830, 831, 829, 828, 832, - 841, 842, 833, 834, 835, 836, 837, 838, 840, 839, - 859, 860, 861, 862, 863, 865, 864, 868, 869, 867, - 866, 871, 870, 765, 196, 221, 368, 0, 454, 288, - 650, 618, 484, 613, 206, 223, 934, 262, 935, 0, - 0, 939, 0, 0, 0, 941, 940, 0, 942, 904, - 903, 0, 0, 936, 937, 0, 938, 0, 0, 198, - 200, 209, 222, 232, 236, 243, 261, 276, 278, 285, - 298, 310, 318, 319, 322, 328, 380, 386, 387, 388, - 389, 409, 410, 411, 414, 417, 418, 421, 423, 424, - 427, 431, 435, 436, 437, 439, 441, 443, 455, 460, - 474, 475, 476, 477, 478, 481, 482, 488, 489, 490, - 491, 492, 500, 501, 516, 586, 588, 605, 625, 632, - 480, 949, 950, 951, 952, 953, 954, 955, 956, 300, - 600, 633, 597, 645, 627, 438, 378, 0, 0, 381, - 281, 305, 320, 0, 617, 502, 227, 466, 290, 251, - 974, 0, 211, 246, 230, 259, 274, 277, 324, 391, - 400, 429, 434, 296, 271, 244, 459, 241, 485, 519, - 520, 521, 523, 395, 266, 433, 396, 0, 376, 576, - 577, 316, 0, 0, 0, 528, 0, 777, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 416, 0, 0, - 0, 764, 0, 0, 0, 270, 769, 0, 0, 0, - 366, 267, 0, 0, 204, 505, 0, 430, 0, 203, - 0, 487, 252, 377, 374, 583, 282, 273, 269, 250, - 317, 385, 428, 518, 422, 776, 370, 0, 0, 497, - 401, 0, 0, 0, 0, 0, 0, 0, 0, 771, - 772, 0, 0, 0, 0, 0, 0, 0, 0, 323, - 248, 325, 202, 413, 498, 286, 0, 95, 0, 0, - 1023, 507, 959, 748, 925, 963, 1024, 976, 977, 978, - 964, 0, 238, 965, 966, 245, 967, 0, 924, 807, - 809, 808, 874, 875, 876, 877, 878, 879, 880, 810, - 811, 805, 972, 609, 979, 980, 0, 265, 321, 272, - 264, 580, 0, 0, 0, 0, 0, 0, 596, 0, - 0, 229, 0, 0, 0, 0, 0, 0, 0, 744, - 761, 0, 775, 0, 0, 0, 275, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 758, 759, 0, 0, 0, 0, 919, - 0, 760, 0, 0, 768, 981, 982, 983, 984, 985, - 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, - 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, - 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, - 1016, 1017, 1018, 1019, 1020, 1021, 1022, 3171, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 297, 0, - 402, 257, 0, 453, 918, 0, 0, 629, 0, 0, - 916, 0, 0, 0, 0, 365, 0, 330, 197, 225, - 0, 0, 412, 461, 473, 0, 0, 0, 969, 0, - 471, 426, 604, 233, 284, 458, 432, 469, 440, 287, - 0, 0, 470, 372, 585, 450, 601, 630, 631, 263, - 406, 615, 522, 623, 648, 226, 260, 420, 506, 607, - 494, 397, 581, 582, 329, 493, 295, 201, 369, 636, - 224, 479, 371, 242, 231, 587, 612, 299, 289, 456, - 643, 213, 517, 598, 239, 483, 0, 0, 651, 247, - 504, 610, 599, 215, 594, 503, 393, 326, 327, 214, - 0, 457, 268, 293, 0, 0, 258, 415, 970, 971, - 256, 652, 815, 622, 220, 0, 621, 408, 584, 595, - 394, 383, 219, 593, 392, 382, 334, 823, 824, 280, - 307, 900, 899, 898, 306, 308, 896, 897, 895, 207, - 608, 626, 0, 208, 0, 499, 611, 653, 452, 212, - 234, 235, 237, 0, 279, 283, 291, 294, 303, 304, - 313, 367, 419, 446, 442, 451, 0, 579, 602, 616, - 628, 634, 635, 637, 638, 639, 640, 641, 644, 642, - 407, 311, 495, 333, 373, 0, 0, 425, 472, 240, - 606, 496, 906, 928, 917, 781, 782, 907, 908, 932, - 909, 784, 785, 929, 930, 778, 779, 783, 931, 933, - 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, - 664, 665, 666, 667, 668, 669, 670, 671, 649, 508, - 514, 509, 510, 511, 512, 513, 0, 515, 920, 767, - 766, 0, 773, 774, 0, 803, 804, 806, 812, 813, - 814, 825, 872, 873, 881, 883, 884, 882, 885, 886, - 887, 890, 891, 892, 893, 888, 889, 894, 786, 790, - 787, 788, 789, 801, 791, 792, 793, 794, 795, 796, - 797, 798, 799, 800, 802, 943, 944, 945, 946, 947, - 948, 818, 822, 821, 819, 820, 816, 817, 844, 843, - 845, 846, 847, 848, 849, 850, 852, 851, 853, 854, - 855, 856, 857, 858, 826, 827, 830, 831, 829, 828, - 832, 841, 842, 833, 834, 835, 836, 837, 838, 840, - 839, 859, 860, 861, 862, 863, 865, 864, 868, 869, - 867, 866, 871, 870, 765, 196, 221, 368, 0, 454, - 288, 650, 618, 484, 613, 206, 223, 934, 262, 935, - 0, 0, 939, 0, 0, 0, 941, 940, 0, 942, - 904, 903, 0, 0, 936, 937, 0, 938, 0, 0, - 198, 200, 209, 222, 232, 236, 243, 261, 276, 278, - 285, 298, 310, 318, 319, 322, 328, 380, 386, 387, - 388, 389, 409, 410, 411, 414, 417, 418, 421, 423, - 424, 427, 431, 435, 436, 437, 439, 441, 443, 455, - 460, 474, 475, 476, 477, 478, 481, 482, 488, 489, - 490, 491, 492, 500, 501, 516, 586, 588, 605, 625, - 632, 480, 949, 950, 951, 952, 953, 954, 955, 956, - 300, 600, 633, 597, 645, 627, 438, 378, 0, 0, - 381, 281, 305, 320, 0, 617, 502, 227, 466, 290, - 251, 974, 0, 211, 246, 230, 259, 274, 277, 324, - 391, 400, 429, 434, 296, 271, 244, 459, 241, 485, - 519, 520, 521, 523, 395, 266, 433, 396, 0, 376, - 576, 577, 316, 0, 0, 0, 528, 0, 777, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 416, 0, - 0, 0, 764, 0, 0, 0, 270, 769, 0, 0, - 0, 366, 267, 0, 0, 204, 505, 0, 430, 0, - 203, 0, 487, 252, 377, 374, 583, 282, 273, 269, - 250, 317, 385, 428, 518, 422, 776, 370, 0, 0, - 497, 401, 0, 0, 0, 0, 0, 0, 0, 0, - 771, 772, 0, 0, 0, 0, 0, 0, 0, 0, - 323, 248, 325, 202, 413, 498, 286, 0, 95, 0, - 0, 1023, 507, 959, 748, 925, 963, 1024, 976, 977, - 978, 964, 0, 238, 965, 966, 245, 967, 0, 924, - 807, 809, 808, 874, 875, 876, 877, 878, 879, 880, - 810, 811, 805, 972, 609, 979, 980, 0, 265, 321, - 272, 264, 580, 0, 0, 0, 0, 0, 0, 596, - 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, - 744, 761, 0, 775, 0, 0, 0, 275, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 758, 759, 0, 0, 0, 0, - 919, 0, 760, 0, 0, 768, 981, 982, 983, 984, + 1017, 1018, 1019, 1020, 1021, 1022, 1023, 3174, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 403, 258, 0, 454, 919, 0, 0, 630, 0, 0, + 917, 0, 0, 0, 0, 366, 0, 331, 197, 225, + 0, 0, 413, 462, 474, 0, 0, 0, 970, 0, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 0, 0, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 971, + 972, 257, 653, 816, 623, 220, 0, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 824, 825, + 281, 308, 901, 900, 899, 307, 309, 897, 898, 896, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 0, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 0, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 0, 0, 426, 473, + 240, 607, 497, 907, 929, 918, 782, 783, 908, 909, + 933, 910, 785, 786, 930, 931, 779, 780, 784, 932, + 934, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 921, + 768, 767, 0, 774, 775, 0, 804, 805, 807, 813, + 814, 815, 826, 873, 874, 882, 884, 885, 883, 886, + 887, 888, 891, 892, 893, 894, 889, 890, 895, 787, + 791, 788, 789, 790, 802, 792, 793, 794, 795, 796, + 797, 798, 799, 800, 801, 803, 944, 945, 946, 947, + 948, 949, 819, 823, 822, 820, 821, 817, 818, 845, + 844, 846, 847, 848, 849, 850, 851, 853, 852, 854, + 855, 856, 857, 858, 859, 827, 828, 831, 832, 830, + 829, 833, 842, 843, 834, 835, 836, 837, 838, 839, + 841, 840, 860, 861, 862, 863, 864, 866, 865, 869, + 870, 868, 867, 872, 871, 766, 196, 221, 369, 0, + 455, 289, 651, 619, 485, 614, 206, 223, 935, 263, + 936, 0, 0, 940, 0, 0, 0, 942, 941, 0, + 943, 905, 904, 0, 0, 937, 938, 0, 939, 0, + 0, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 950, 951, 952, 953, 954, 955, 956, + 957, 301, 601, 634, 598, 646, 628, 439, 379, 0, + 0, 382, 282, 306, 321, 0, 618, 503, 227, 467, + 291, 251, 975, 0, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 397, 0, + 377, 577, 578, 317, 0, 0, 0, 529, 0, 778, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 765, 0, 0, 0, 271, 770, 0, + 0, 0, 367, 268, 0, 0, 204, 506, 0, 431, + 0, 203, 0, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 777, 371, 0, + 0, 498, 402, 0, 0, 0, 0, 0, 0, 0, + 0, 772, 773, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 248, 326, 202, 414, 499, 287, 0, 95, + 0, 0, 1024, 508, 960, 749, 926, 964, 1025, 977, + 978, 979, 965, 0, 238, 966, 967, 245, 968, 0, + 925, 808, 810, 809, 875, 876, 877, 878, 879, 880, + 881, 811, 812, 806, 973, 610, 980, 981, 0, 266, + 322, 273, 265, 581, 0, 0, 0, 0, 0, 0, + 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, + 0, 745, 762, 0, 776, 0, 0, 0, 276, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 759, 760, 0, 0, 0, + 0, 920, 0, 761, 0, 0, 769, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, - 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 3167, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 297, - 0, 402, 257, 0, 453, 918, 0, 0, 629, 0, - 0, 916, 0, 0, 0, 0, 365, 0, 330, 197, - 225, 0, 0, 412, 461, 473, 0, 0, 0, 969, - 0, 471, 426, 604, 233, 284, 458, 432, 469, 440, - 287, 0, 0, 470, 372, 585, 450, 601, 630, 631, - 263, 406, 615, 522, 623, 648, 226, 260, 420, 506, - 607, 494, 397, 581, 582, 329, 493, 295, 201, 369, - 636, 224, 479, 371, 242, 231, 587, 612, 299, 289, - 456, 643, 213, 517, 598, 239, 483, 0, 0, 651, - 247, 504, 610, 599, 215, 594, 503, 393, 326, 327, - 214, 0, 457, 268, 293, 0, 0, 258, 415, 970, - 971, 256, 652, 815, 622, 220, 0, 621, 408, 584, - 595, 394, 383, 219, 593, 392, 382, 334, 823, 824, - 280, 307, 900, 899, 898, 306, 308, 896, 897, 895, - 207, 608, 626, 0, 208, 0, 499, 611, 653, 452, - 212, 234, 235, 237, 0, 279, 283, 291, 294, 303, - 304, 313, 367, 419, 446, 442, 451, 0, 579, 602, - 616, 628, 634, 635, 637, 638, 639, 640, 641, 644, - 642, 407, 311, 495, 333, 373, 0, 0, 425, 472, - 240, 606, 496, 906, 928, 917, 781, 782, 907, 908, - 932, 909, 784, 785, 929, 930, 778, 779, 783, 931, - 933, 654, 655, 656, 657, 658, 659, 660, 661, 662, - 663, 664, 665, 666, 667, 668, 669, 670, 671, 649, - 508, 514, 509, 510, 511, 512, 513, 0, 515, 920, - 767, 766, 0, 773, 774, 0, 803, 804, 806, 812, - 813, 814, 825, 872, 873, 881, 883, 884, 882, 885, - 886, 887, 890, 891, 892, 893, 888, 889, 894, 786, - 790, 787, 788, 789, 801, 791, 792, 793, 794, 795, - 796, 797, 798, 799, 800, 802, 943, 944, 945, 946, - 947, 948, 818, 822, 821, 819, 820, 816, 817, 844, - 843, 845, 846, 847, 848, 849, 850, 852, 851, 853, - 854, 855, 856, 857, 858, 826, 827, 830, 831, 829, - 828, 832, 841, 842, 833, 834, 835, 836, 837, 838, - 840, 839, 859, 860, 861, 862, 863, 865, 864, 868, - 869, 867, 866, 871, 870, 765, 196, 221, 368, 0, - 454, 288, 650, 618, 484, 613, 206, 223, 934, 262, - 935, 0, 0, 939, 0, 0, 0, 941, 940, 0, - 942, 904, 903, 0, 0, 936, 937, 0, 938, 0, - 0, 198, 200, 209, 222, 232, 236, 243, 261, 276, - 278, 285, 298, 310, 318, 319, 322, 328, 380, 386, - 387, 388, 389, 409, 410, 411, 414, 417, 418, 421, - 423, 424, 427, 431, 435, 436, 437, 439, 441, 443, - 455, 460, 474, 475, 476, 477, 478, 481, 482, 488, - 489, 490, 491, 492, 500, 501, 516, 586, 588, 605, - 625, 632, 480, 949, 950, 951, 952, 953, 954, 955, - 956, 300, 600, 633, 597, 645, 627, 438, 378, 0, - 0, 381, 281, 305, 320, 0, 617, 502, 227, 466, - 290, 251, 974, 0, 211, 246, 230, 259, 274, 277, - 324, 391, 400, 429, 434, 296, 271, 244, 459, 241, - 485, 519, 520, 521, 523, 395, 266, 433, 396, 0, - 376, 576, 577, 316, 0, 0, 0, 528, 0, 777, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 416, - 0, 0, 0, 764, 0, 0, 0, 270, 769, 0, - 0, 0, 366, 267, 0, 0, 204, 505, 0, 430, - 0, 203, 0, 487, 252, 377, 374, 583, 282, 273, - 269, 250, 317, 385, 428, 518, 422, 776, 370, 0, - 0, 497, 401, 0, 0, 0, 0, 0, 0, 0, - 0, 771, 772, 0, 0, 0, 0, 0, 0, 0, - 0, 323, 248, 325, 202, 413, 498, 286, 0, 95, - 0, 0, 1023, 507, 959, 1090, 925, 963, 1024, 976, - 977, 978, 964, 0, 238, 965, 966, 245, 967, 0, - 924, 807, 809, 808, 874, 875, 876, 877, 878, 879, - 880, 810, 811, 805, 972, 609, 979, 980, 0, 265, - 321, 272, 264, 580, 0, 0, 0, 0, 0, 0, - 596, 0, 0, 229, 0, 0, 0, 0, 0, 0, - 0, 0, 761, 0, 775, 0, 0, 0, 275, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 758, 759, 0, 0, 0, - 0, 919, 0, 760, 0, 0, 768, 981, 982, 983, - 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, - 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, - 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, - 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 770, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 297, 0, 402, 257, 0, 453, 918, 0, 0, 629, - 0, 0, 916, 0, 0, 0, 0, 365, 0, 330, - 197, 225, 0, 0, 412, 461, 473, 0, 0, 0, - 969, 0, 471, 426, 604, 233, 284, 458, 432, 469, - 440, 287, 0, 0, 470, 372, 585, 450, 601, 630, - 631, 263, 406, 615, 522, 623, 648, 226, 260, 420, - 506, 607, 494, 397, 581, 582, 329, 493, 295, 201, - 369, 636, 224, 479, 371, 242, 231, 587, 612, 299, - 289, 456, 643, 213, 517, 598, 239, 483, 0, 0, - 651, 247, 504, 610, 599, 215, 594, 503, 393, 326, - 327, 214, 0, 457, 268, 293, 0, 0, 258, 415, - 970, 971, 256, 652, 815, 622, 220, 0, 621, 408, - 584, 595, 394, 383, 219, 593, 392, 382, 334, 823, - 824, 280, 307, 900, 899, 898, 306, 308, 896, 897, - 895, 207, 608, 626, 0, 208, 0, 499, 611, 653, - 452, 212, 234, 235, 237, 0, 279, 283, 291, 294, - 303, 304, 313, 367, 419, 446, 442, 451, 0, 579, - 602, 616, 628, 634, 635, 637, 638, 639, 640, 641, - 644, 642, 407, 311, 495, 333, 373, 0, 0, 425, - 472, 240, 606, 496, 906, 928, 917, 781, 782, 907, - 908, 932, 909, 784, 785, 929, 930, 778, 779, 783, - 931, 933, 654, 655, 656, 657, 658, 659, 660, 661, + 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 3170, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 298, 0, 403, 258, 0, 454, 919, 0, 0, 630, + 0, 0, 917, 0, 0, 0, 0, 366, 0, 331, + 197, 225, 0, 0, 413, 462, 474, 0, 0, 0, + 970, 0, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 0, 0, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 971, 972, 257, 653, 816, 623, 220, 0, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 824, 825, 281, 308, 901, 900, 899, 307, 309, 897, + 898, 896, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 0, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 0, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 0, 0, + 426, 473, 240, 607, 497, 907, 929, 918, 782, 783, + 908, 909, 933, 910, 785, 786, 930, 931, 779, 780, + 784, 932, 934, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, - 649, 508, 514, 509, 510, 511, 512, 513, 0, 515, - 920, 767, 766, 0, 773, 774, 0, 803, 804, 806, - 812, 813, 814, 825, 872, 873, 881, 883, 884, 882, - 885, 886, 887, 890, 891, 892, 893, 888, 889, 894, - 786, 790, 787, 788, 789, 801, 791, 792, 793, 794, - 795, 796, 797, 798, 799, 800, 802, 943, 944, 945, - 946, 947, 948, 818, 822, 821, 819, 820, 816, 817, - 844, 843, 845, 846, 847, 848, 849, 850, 852, 851, - 853, 854, 855, 856, 857, 858, 826, 827, 830, 831, - 829, 828, 832, 841, 842, 833, 834, 835, 836, 837, - 838, 840, 839, 859, 860, 861, 862, 863, 865, 864, - 868, 869, 867, 866, 871, 870, 765, 196, 221, 368, - 0, 454, 288, 650, 618, 484, 613, 206, 223, 934, - 262, 935, 0, 0, 939, 0, 0, 0, 941, 940, - 0, 942, 904, 903, 0, 0, 936, 937, 0, 938, - 0, 0, 198, 200, 209, 222, 232, 236, 243, 261, - 276, 278, 285, 298, 310, 318, 319, 322, 328, 380, - 386, 387, 388, 389, 409, 410, 411, 414, 417, 418, - 421, 423, 424, 427, 431, 435, 436, 437, 439, 441, - 443, 455, 460, 474, 475, 476, 477, 478, 481, 482, - 488, 489, 490, 491, 492, 500, 501, 516, 586, 588, - 605, 625, 632, 480, 949, 950, 951, 952, 953, 954, - 955, 956, 300, 600, 633, 597, 645, 627, 438, 378, - 0, 0, 381, 281, 305, 320, 0, 617, 502, 227, - 466, 290, 251, 974, 0, 211, 246, 230, 259, 274, - 277, 324, 391, 400, 429, 434, 296, 271, 244, 459, - 241, 485, 519, 520, 521, 523, 395, 266, 433, 396, - 0, 376, 576, 577, 316, 0, 0, 0, 528, 0, - 777, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 416, 0, 0, 0, 764, 0, 0, 0, 270, 769, - 0, 0, 0, 366, 267, 0, 0, 204, 505, 0, - 430, 0, 203, 0, 487, 252, 377, 374, 583, 282, - 273, 269, 250, 317, 385, 428, 518, 422, 776, 370, - 0, 0, 497, 401, 0, 0, 0, 0, 0, 0, - 0, 0, 771, 772, 0, 0, 0, 0, 0, 0, - 0, 0, 323, 248, 325, 202, 413, 498, 286, 0, - 95, 0, 0, 1023, 507, 959, 1090, 925, 963, 1024, - 976, 977, 978, 964, 0, 238, 965, 966, 245, 967, - 0, 924, 807, 809, 808, 874, 875, 876, 877, 878, - 879, 880, 810, 811, 805, 972, 609, 979, 980, 0, - 265, 321, 272, 264, 580, 0, 0, 0, 0, 0, - 0, 596, 0, 0, 229, 0, 0, 0, 0, 0, - 0, 0, 0, 761, 0, 775, 0, 0, 0, 275, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 758, 759, 0, 0, - 0, 0, 919, 0, 760, 0, 0, 768, 981, 982, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 921, 768, 767, 0, 774, 775, 0, 804, 805, + 807, 813, 814, 815, 826, 873, 874, 882, 884, 885, + 883, 886, 887, 888, 891, 892, 893, 894, 889, 890, + 895, 787, 791, 788, 789, 790, 802, 792, 793, 794, + 795, 796, 797, 798, 799, 800, 801, 803, 944, 945, + 946, 947, 948, 949, 819, 823, 822, 820, 821, 817, + 818, 845, 844, 846, 847, 848, 849, 850, 851, 853, + 852, 854, 855, 856, 857, 858, 859, 827, 828, 831, + 832, 830, 829, 833, 842, 843, 834, 835, 836, 837, + 838, 839, 841, 840, 860, 861, 862, 863, 864, 866, + 865, 869, 870, 868, 867, 872, 871, 766, 196, 221, + 369, 0, 455, 289, 651, 619, 485, 614, 206, 223, + 935, 263, 936, 0, 0, 940, 0, 0, 0, 942, + 941, 0, 943, 905, 904, 0, 0, 937, 938, 0, + 939, 0, 0, 198, 200, 209, 222, 232, 236, 243, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 950, 951, 952, 953, 954, + 955, 956, 957, 301, 601, 634, 598, 646, 628, 439, + 379, 0, 0, 382, 282, 306, 321, 0, 618, 503, + 227, 467, 291, 251, 975, 0, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 397, 0, 377, 577, 578, 317, 0, 0, 0, 529, + 0, 778, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 0, 765, 0, 0, 0, 271, + 770, 0, 0, 0, 367, 268, 0, 0, 204, 506, + 0, 431, 0, 203, 0, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 777, + 371, 0, 0, 498, 402, 0, 0, 0, 0, 0, + 0, 0, 0, 772, 773, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 248, 326, 202, 414, 499, 287, + 0, 95, 0, 0, 1024, 508, 960, 1091, 926, 964, + 1025, 977, 978, 979, 965, 0, 238, 966, 967, 245, + 968, 0, 925, 808, 810, 809, 875, 876, 877, 878, + 879, 880, 881, 811, 812, 806, 973, 610, 980, 981, + 0, 266, 322, 273, 265, 581, 0, 0, 0, 0, + 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, + 0, 0, 0, 0, 762, 0, 776, 0, 0, 0, + 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 759, 760, 0, + 0, 0, 0, 920, 0, 761, 0, 0, 769, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, - 2123, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 297, 0, 402, 257, 0, 453, 918, 0, 0, - 629, 0, 0, 916, 0, 0, 0, 0, 365, 0, - 330, 197, 225, 0, 0, 412, 461, 473, 0, 0, - 0, 969, 0, 471, 426, 604, 233, 284, 458, 432, - 469, 440, 287, 0, 0, 470, 372, 585, 450, 601, - 630, 631, 263, 406, 615, 522, 623, 648, 226, 260, - 420, 506, 607, 494, 397, 581, 582, 329, 493, 295, - 201, 369, 636, 224, 479, 371, 242, 231, 587, 612, - 299, 289, 456, 643, 213, 517, 598, 239, 483, 0, - 0, 651, 247, 504, 610, 599, 215, 594, 503, 393, - 326, 327, 214, 0, 457, 268, 293, 0, 0, 258, - 415, 970, 971, 256, 652, 815, 622, 220, 0, 621, - 408, 584, 595, 394, 383, 219, 593, 392, 382, 334, - 823, 824, 280, 307, 900, 899, 898, 306, 308, 896, - 897, 895, 207, 608, 626, 0, 208, 0, 499, 611, - 653, 452, 212, 234, 235, 237, 0, 279, 283, 291, - 294, 303, 304, 313, 367, 419, 446, 442, 451, 0, - 579, 602, 616, 628, 634, 635, 637, 638, 639, 640, - 641, 644, 642, 407, 311, 495, 333, 373, 0, 0, - 425, 472, 240, 606, 496, 906, 928, 917, 781, 782, - 907, 908, 932, 909, 784, 785, 929, 930, 778, 779, - 783, 931, 933, 654, 655, 656, 657, 658, 659, 660, - 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, - 671, 649, 508, 514, 509, 510, 511, 512, 513, 0, - 515, 920, 767, 766, 0, 773, 774, 0, 803, 804, - 806, 812, 813, 814, 825, 872, 873, 881, 883, 884, - 882, 885, 886, 887, 890, 891, 892, 893, 888, 889, - 894, 786, 790, 787, 788, 789, 801, 791, 792, 793, - 794, 795, 796, 797, 798, 799, 800, 802, 943, 944, - 945, 946, 947, 948, 818, 822, 821, 819, 820, 816, - 817, 844, 843, 845, 846, 847, 848, 849, 850, 852, - 851, 853, 854, 855, 856, 857, 858, 826, 827, 830, - 831, 829, 828, 832, 841, 842, 833, 834, 835, 836, - 837, 838, 840, 839, 859, 860, 861, 862, 863, 865, - 864, 868, 869, 867, 866, 871, 870, 765, 196, 221, - 368, 0, 454, 288, 650, 618, 484, 613, 206, 223, - 934, 262, 935, 0, 0, 939, 0, 0, 0, 941, - 940, 0, 942, 904, 903, 0, 0, 936, 937, 0, - 938, 0, 0, 198, 200, 209, 222, 232, 236, 243, - 261, 276, 278, 285, 298, 310, 318, 319, 322, 328, - 380, 386, 387, 388, 389, 409, 410, 411, 414, 417, - 418, 421, 423, 424, 427, 431, 435, 436, 437, 439, - 441, 443, 455, 460, 474, 475, 476, 477, 478, 481, - 482, 488, 489, 490, 491, 492, 500, 501, 516, 586, - 588, 605, 625, 632, 480, 949, 950, 951, 952, 953, - 954, 955, 956, 300, 600, 633, 597, 645, 627, 438, - 378, 0, 0, 381, 281, 305, 320, 0, 617, 502, - 227, 466, 290, 251, 974, 0, 211, 246, 230, 259, - 274, 277, 324, 391, 400, 429, 434, 296, 271, 244, - 459, 241, 485, 519, 520, 521, 523, 395, 266, 433, - 396, 0, 376, 576, 577, 316, 0, 0, 0, 528, - 0, 777, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 416, 0, 0, 0, 764, 0, 0, 0, 270, - 769, 0, 0, 0, 366, 267, 0, 0, 204, 505, - 0, 430, 0, 203, 0, 487, 252, 377, 374, 583, - 282, 273, 269, 250, 317, 385, 428, 518, 422, 776, - 370, 0, 0, 497, 401, 0, 0, 0, 0, 0, - 0, 0, 0, 771, 772, 0, 0, 0, 0, 0, - 0, 0, 0, 323, 248, 325, 202, 413, 498, 286, - 0, 95, 0, 0, 1023, 507, 959, 1090, 925, 963, - 1024, 976, 977, 978, 964, 0, 238, 965, 966, 245, - 967, 0, 924, 807, 809, 808, 874, 875, 876, 877, - 878, 879, 880, 810, 811, 805, 972, 609, 979, 980, - 0, 265, 321, 272, 264, 580, 0, 0, 0, 0, - 0, 0, 596, 0, 0, 229, 0, 0, 0, 0, - 0, 0, 0, 0, 761, 0, 775, 0, 0, 0, - 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 758, 759, 0, - 0, 0, 0, 919, 0, 760, 0, 0, 768, 981, - 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, - 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, - 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, - 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, - 1022, 2121, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 297, 0, 402, 257, 0, 453, 918, 0, - 0, 629, 0, 0, 916, 0, 0, 0, 0, 365, - 0, 330, 197, 225, 0, 0, 412, 461, 473, 0, - 0, 0, 969, 0, 471, 426, 604, 233, 284, 458, - 432, 469, 440, 287, 0, 0, 470, 372, 585, 450, - 601, 630, 631, 263, 406, 615, 522, 623, 648, 226, - 260, 420, 506, 607, 494, 397, 581, 582, 329, 493, - 295, 201, 369, 636, 224, 479, 371, 242, 231, 587, - 612, 299, 289, 456, 643, 213, 517, 598, 239, 483, - 0, 0, 651, 247, 504, 610, 599, 215, 594, 503, - 393, 326, 327, 214, 0, 457, 268, 293, 0, 0, - 258, 415, 970, 971, 256, 652, 815, 622, 220, 0, - 621, 408, 584, 595, 394, 383, 219, 593, 392, 382, - 334, 823, 824, 280, 307, 900, 899, 898, 306, 308, - 896, 897, 895, 207, 608, 626, 0, 208, 0, 499, - 611, 653, 452, 212, 234, 235, 237, 0, 279, 283, - 291, 294, 303, 304, 313, 367, 419, 446, 442, 451, - 0, 579, 602, 616, 628, 634, 635, 637, 638, 639, - 640, 641, 644, 642, 407, 311, 495, 333, 373, 0, - 0, 425, 472, 240, 606, 496, 906, 928, 917, 781, - 782, 907, 908, 932, 909, 784, 785, 929, 930, 778, - 779, 783, 931, 933, 654, 655, 656, 657, 658, 659, + 1023, 771, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 298, 0, 403, 258, 0, 454, 919, 0, + 0, 630, 0, 0, 917, 0, 0, 0, 0, 366, + 0, 331, 197, 225, 0, 0, 413, 462, 474, 0, + 0, 0, 970, 0, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 0, 0, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 971, 972, 257, 653, 816, 623, 220, + 0, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 824, 825, 281, 308, 901, 900, 899, 307, + 309, 897, 898, 896, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 0, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 0, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 0, 0, 426, 473, 240, 607, 497, 907, 929, 918, + 782, 783, 908, 909, 933, 910, 785, 786, 930, 931, + 779, 780, 784, 932, 934, 655, 656, 657, 658, 659, + 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 921, 768, 767, 0, 774, 775, 0, + 804, 805, 807, 813, 814, 815, 826, 873, 874, 882, + 884, 885, 883, 886, 887, 888, 891, 892, 893, 894, + 889, 890, 895, 787, 791, 788, 789, 790, 802, 792, + 793, 794, 795, 796, 797, 798, 799, 800, 801, 803, + 944, 945, 946, 947, 948, 949, 819, 823, 822, 820, + 821, 817, 818, 845, 844, 846, 847, 848, 849, 850, + 851, 853, 852, 854, 855, 856, 857, 858, 859, 827, + 828, 831, 832, 830, 829, 833, 842, 843, 834, 835, + 836, 837, 838, 839, 841, 840, 860, 861, 862, 863, + 864, 866, 865, 869, 870, 868, 867, 872, 871, 766, + 196, 221, 369, 0, 455, 289, 651, 619, 485, 614, + 206, 223, 935, 263, 936, 0, 0, 940, 0, 0, + 0, 942, 941, 0, 943, 905, 904, 0, 0, 937, + 938, 0, 939, 0, 0, 198, 200, 209, 222, 232, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 950, 951, 952, + 953, 954, 955, 956, 957, 301, 601, 634, 598, 646, + 628, 439, 379, 0, 0, 382, 282, 306, 321, 0, + 618, 503, 227, 467, 291, 251, 975, 0, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 397, 0, 377, 577, 578, 317, 0, 0, + 0, 529, 0, 778, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 765, 0, 0, + 0, 271, 770, 0, 0, 0, 367, 268, 0, 0, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 777, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 772, 773, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 95, 0, 0, 1024, 508, 960, 1091, + 926, 964, 1025, 977, 978, 979, 965, 0, 238, 966, + 967, 245, 968, 0, 925, 808, 810, 809, 875, 876, + 877, 878, 879, 880, 881, 811, 812, 806, 973, 610, + 980, 981, 0, 266, 322, 273, 265, 581, 0, 0, + 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, + 0, 0, 0, 0, 0, 0, 762, 0, 776, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 759, + 760, 0, 0, 0, 0, 920, 0, 761, 0, 0, + 769, 982, 983, 984, 985, 986, 987, 988, 989, 990, + 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, + 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, + 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, + 1021, 1022, 1023, 2124, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 298, 0, 403, 258, 0, 454, + 919, 0, 0, 630, 0, 0, 917, 0, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 970, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 971, 972, 257, 653, 816, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 824, 825, 281, 308, 901, 900, + 899, 307, 309, 897, 898, 896, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 907, + 929, 918, 782, 783, 908, 909, 933, 910, 785, 786, + 930, 931, 779, 780, 784, 932, 934, 655, 656, 657, + 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 921, 768, 767, 0, 774, + 775, 0, 804, 805, 807, 813, 814, 815, 826, 873, + 874, 882, 884, 885, 883, 886, 887, 888, 891, 892, + 893, 894, 889, 890, 895, 787, 791, 788, 789, 790, + 802, 792, 793, 794, 795, 796, 797, 798, 799, 800, + 801, 803, 944, 945, 946, 947, 948, 949, 819, 823, + 822, 820, 821, 817, 818, 845, 844, 846, 847, 848, + 849, 850, 851, 853, 852, 854, 855, 856, 857, 858, + 859, 827, 828, 831, 832, 830, 829, 833, 842, 843, + 834, 835, 836, 837, 838, 839, 841, 840, 860, 861, + 862, 863, 864, 866, 865, 869, 870, 868, 867, 872, + 871, 766, 196, 221, 369, 0, 455, 289, 651, 619, + 485, 614, 206, 223, 935, 263, 936, 0, 0, 940, + 0, 0, 0, 942, 941, 0, 943, 905, 904, 0, + 0, 937, 938, 0, 939, 0, 0, 198, 200, 209, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 950, + 951, 952, 953, 954, 955, 956, 957, 301, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 975, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 778, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 765, + 0, 0, 0, 271, 770, 0, 0, 0, 367, 268, + 0, 0, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 777, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 772, 773, 0, + 0, 0, 0, 0, 0, 0, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 95, 0, 0, 1024, 508, + 960, 1091, 926, 964, 1025, 977, 978, 979, 965, 0, + 238, 966, 967, 245, 968, 0, 925, 808, 810, 809, + 875, 876, 877, 878, 879, 880, 881, 811, 812, 806, + 973, 610, 980, 981, 0, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 0, 762, 0, + 776, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 759, 760, 0, 0, 0, 0, 920, 0, 761, + 0, 0, 769, 982, 983, 984, 985, 986, 987, 988, + 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, + 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, + 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, + 1019, 1020, 1021, 1022, 1023, 2122, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 919, 0, 0, 630, 0, 0, 917, 0, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 970, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 971, 972, 257, + 653, 816, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 824, 825, 281, 308, + 901, 900, 899, 307, 309, 897, 898, 896, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 907, 929, 918, 782, 783, 908, 909, 933, 910, + 785, 786, 930, 931, 779, 780, 784, 932, 934, 655, + 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 921, 768, 767, + 0, 774, 775, 0, 804, 805, 807, 813, 814, 815, + 826, 873, 874, 882, 884, 885, 883, 886, 887, 888, + 891, 892, 893, 894, 889, 890, 895, 787, 791, 788, + 789, 790, 802, 792, 793, 794, 795, 796, 797, 798, + 799, 800, 801, 803, 944, 945, 946, 947, 948, 949, + 819, 823, 822, 820, 821, 817, 818, 845, 844, 846, + 847, 848, 849, 850, 851, 853, 852, 854, 855, 856, + 857, 858, 859, 827, 828, 831, 832, 830, 829, 833, + 842, 843, 834, 835, 836, 837, 838, 839, 841, 840, + 860, 861, 862, 863, 864, 866, 865, 869, 870, 868, + 867, 872, 871, 766, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 935, 263, 936, 0, + 0, 940, 0, 0, 0, 942, 941, 0, 943, 905, + 904, 0, 0, 937, 938, 0, 939, 0, 0, 198, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 950, 951, 952, 953, 954, 955, 956, 957, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 975, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 397, 0, 377, 577, + 578, 317, 0, 0, 0, 529, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, + 0, 0, 0, 0, 0, 271, 0, 0, 0, 0, + 367, 268, 0, 0, 204, 506, 0, 431, 0, 203, + 0, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 0, 371, 0, 0, 498, + 402, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 248, 326, 202, 414, 499, 287, 0, 0, 0, 0, + 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 238, 0, 0, 245, 0, 0, 0, 352, + 361, 360, 340, 341, 343, 345, 351, 358, 364, 337, + 346, 0, 0, 610, 0, 0, 0, 266, 322, 273, + 265, 581, 0, 0, 0, 0, 0, 0, 597, 0, + 0, 229, 0, 1142, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 403, 258, 0, 454, 0, 0, 1141, 630, 0, 0, + 0, 0, 0, 1138, 1139, 366, 1099, 331, 197, 225, + 1132, 1136, 413, 462, 474, 0, 0, 0, 254, 0, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 0, 0, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 590, + 591, 257, 653, 228, 623, 220, 0, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 356, 357, + 281, 308, 448, 376, 449, 307, 309, 405, 404, 406, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 0, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 0, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 0, 0, 426, 473, + 240, 607, 497, 199, 0, 0, 0, 0, 255, 256, + 0, 576, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 0, + 0, 0, 0, 0, 399, 0, 592, 593, 673, 385, + 487, 604, 336, 350, 353, 342, 362, 0, 363, 338, + 339, 344, 347, 348, 349, 354, 355, 359, 365, 249, + 210, 391, 400, 579, 313, 216, 217, 218, 525, 526, + 527, 528, 620, 621, 625, 205, 463, 464, 465, 466, + 293, 615, 310, 469, 468, 332, 333, 380, 450, 541, + 543, 554, 558, 560, 562, 568, 571, 542, 544, 555, + 559, 561, 563, 569, 572, 531, 533, 535, 537, 550, + 549, 546, 574, 575, 552, 557, 536, 548, 553, 566, + 573, 570, 530, 534, 538, 547, 565, 564, 545, 556, + 567, 551, 539, 532, 540, 0, 196, 221, 369, 0, + 455, 289, 651, 619, 485, 614, 206, 223, 0, 263, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 302, 303, 445, 446, 315, 316, 647, + 648, 301, 601, 634, 598, 646, 628, 439, 379, 0, + 0, 382, 282, 306, 321, 0, 618, 503, 227, 467, + 291, 251, 0, 0, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 397, 0, + 377, 577, 578, 317, 0, 0, 86, 529, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 0, 0, 0, 0, 271, 0, 0, + 0, 0, 367, 268, 0, 0, 204, 506, 0, 431, + 0, 203, 0, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 0, 371, 0, + 0, 498, 402, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 248, 326, 202, 414, 499, 287, 0, 95, + 0, 0, 0, 508, 194, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 238, 0, 0, 245, 0, 0, + 0, 352, 361, 360, 340, 341, 343, 345, 351, 358, + 364, 337, 346, 0, 0, 610, 0, 0, 0, 266, + 322, 273, 265, 581, 0, 0, 0, 0, 0, 0, + 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 276, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 298, 0, 403, 258, 0, 454, 0, 0, 0, 630, + 0, 0, 0, 0, 0, 0, 0, 366, 0, 331, + 197, 225, 0, 0, 413, 462, 474, 0, 0, 0, + 254, 0, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 0, 0, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 590, 591, 257, 653, 228, 623, 220, 0, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 356, 357, 281, 308, 448, 376, 449, 307, 309, 405, + 404, 406, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 0, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 0, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 0, 0, + 426, 473, 240, 607, 497, 199, 0, 0, 0, 0, + 255, 256, 0, 576, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, + 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 0, 0, 0, 0, 0, 399, 0, 592, 593, + 673, 385, 487, 604, 336, 350, 353, 342, 362, 0, + 363, 338, 339, 344, 347, 348, 349, 354, 355, 359, + 365, 249, 210, 391, 400, 579, 313, 216, 217, 218, + 525, 526, 527, 528, 620, 621, 625, 205, 463, 464, + 465, 466, 293, 615, 310, 469, 468, 332, 333, 380, + 450, 541, 543, 554, 558, 560, 562, 568, 571, 542, + 544, 555, 559, 561, 563, 569, 572, 531, 533, 535, + 537, 550, 549, 546, 574, 575, 552, 557, 536, 548, + 553, 566, 573, 570, 530, 534, 538, 547, 565, 564, + 545, 556, 567, 551, 539, 532, 540, 0, 196, 221, + 369, 94, 455, 289, 651, 619, 485, 614, 206, 223, + 0, 263, 0, 0, 0, 0, 0, 0, 2427, 0, + 0, 2426, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 198, 200, 209, 222, 232, 236, 243, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 302, 303, 445, 446, 315, + 316, 647, 648, 301, 601, 634, 598, 646, 628, 439, + 379, 0, 0, 382, 282, 306, 321, 0, 618, 503, + 227, 467, 291, 251, 0, 0, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 1777, 0, 377, 577, 578, 317, 0, 0, 0, 529, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 1779, 0, 0, 0, 0, 271, + 0, 0, 0, 0, 367, 268, 0, 0, 204, 506, + 0, 431, 0, 203, 0, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 0, + 371, 0, 0, 498, 402, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 248, 326, 202, 414, 499, 287, + 0, 0, 0, 0, 1781, 508, 725, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, + 0, 0, 0, 352, 361, 360, 340, 341, 343, 345, + 351, 358, 364, 337, 346, 0, 0, 610, 0, 0, + 0, 266, 322, 273, 265, 581, 0, 0, 0, 0, + 0, 0, 597, 0, 0, 229, 0, 0, 0, 1480, + 0, 1481, 1482, 0, 0, 0, 0, 0, 0, 0, + 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 298, 0, 403, 258, 0, 454, 0, 0, + 0, 630, 0, 0, 0, 0, 0, 0, 0, 366, + 0, 331, 197, 225, 0, 0, 413, 462, 474, 0, + 0, 0, 254, 0, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 0, 0, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 590, 591, 257, 653, 228, 623, 220, + 0, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 356, 357, 281, 308, 448, 376, 449, 307, + 309, 405, 404, 406, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 0, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 0, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 0, 0, 426, 473, 240, 607, 497, 199, 0, 0, + 0, 0, 255, 256, 0, 576, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, - 670, 671, 649, 508, 514, 509, 510, 511, 512, 513, - 0, 515, 920, 767, 766, 0, 773, 774, 0, 803, - 804, 806, 812, 813, 814, 825, 872, 873, 881, 883, - 884, 882, 885, 886, 887, 890, 891, 892, 893, 888, - 889, 894, 786, 790, 787, 788, 789, 801, 791, 792, - 793, 794, 795, 796, 797, 798, 799, 800, 802, 943, - 944, 945, 946, 947, 948, 818, 822, 821, 819, 820, - 816, 817, 844, 843, 845, 846, 847, 848, 849, 850, - 852, 851, 853, 854, 855, 856, 857, 858, 826, 827, - 830, 831, 829, 828, 832, 841, 842, 833, 834, 835, - 836, 837, 838, 840, 839, 859, 860, 861, 862, 863, - 865, 864, 868, 869, 867, 866, 871, 870, 765, 196, - 221, 368, 0, 454, 288, 650, 618, 484, 613, 206, - 223, 934, 262, 935, 0, 0, 939, 0, 0, 0, - 941, 940, 0, 942, 904, 903, 0, 0, 936, 937, - 0, 938, 0, 0, 198, 200, 209, 222, 232, 236, - 243, 261, 276, 278, 285, 298, 310, 318, 319, 322, - 328, 380, 386, 387, 388, 389, 409, 410, 411, 414, - 417, 418, 421, 423, 424, 427, 431, 435, 436, 437, - 439, 441, 443, 455, 460, 474, 475, 476, 477, 478, - 481, 482, 488, 489, 490, 491, 492, 500, 501, 516, - 586, 588, 605, 625, 632, 480, 949, 950, 951, 952, - 953, 954, 955, 956, 300, 600, 633, 597, 645, 627, - 438, 378, 0, 0, 381, 281, 305, 320, 0, 617, - 502, 227, 466, 290, 251, 974, 0, 211, 246, 230, - 259, 274, 277, 324, 391, 400, 429, 434, 296, 271, - 244, 459, 241, 485, 519, 520, 521, 523, 395, 266, - 433, 396, 0, 376, 576, 577, 316, 0, 0, 0, - 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 416, 0, 0, 0, 0, 0, 0, 0, - 270, 0, 0, 0, 0, 366, 267, 0, 0, 204, - 505, 0, 430, 0, 203, 0, 487, 252, 377, 374, - 583, 282, 273, 269, 250, 317, 385, 428, 518, 422, - 0, 370, 0, 0, 497, 401, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 323, 248, 325, 202, 413, 498, - 286, 0, 0, 0, 0, 0, 507, 724, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, - 245, 0, 0, 0, 351, 360, 359, 339, 340, 342, - 344, 350, 357, 363, 336, 345, 0, 0, 609, 0, - 0, 0, 265, 321, 272, 264, 580, 0, 0, 0, - 0, 0, 0, 596, 0, 0, 229, 0, 1141, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 275, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 297, 0, 402, 257, 0, 453, 0, - 0, 1140, 629, 0, 0, 0, 0, 0, 1137, 1138, - 365, 1098, 330, 197, 225, 1131, 1135, 412, 461, 473, - 0, 0, 0, 253, 0, 471, 426, 604, 233, 284, - 458, 432, 469, 440, 287, 0, 0, 470, 372, 585, - 450, 601, 630, 631, 263, 406, 615, 522, 623, 648, - 226, 260, 420, 506, 607, 494, 397, 581, 582, 329, - 493, 295, 201, 369, 636, 224, 479, 371, 242, 231, - 587, 612, 299, 289, 456, 643, 213, 517, 598, 239, - 483, 0, 0, 651, 247, 504, 610, 599, 215, 594, - 503, 393, 326, 327, 214, 0, 457, 268, 293, 0, - 0, 258, 415, 589, 590, 256, 652, 228, 622, 220, - 0, 621, 408, 584, 595, 394, 383, 219, 593, 392, - 382, 334, 355, 356, 280, 307, 447, 375, 448, 306, - 308, 404, 403, 405, 207, 608, 626, 0, 208, 0, - 499, 611, 653, 452, 212, 234, 235, 237, 0, 279, - 283, 291, 294, 303, 304, 313, 367, 419, 446, 442, - 451, 0, 579, 602, 616, 628, 634, 635, 637, 638, - 639, 640, 641, 644, 642, 407, 311, 495, 333, 373, - 0, 0, 425, 472, 240, 606, 496, 199, 0, 0, - 0, 0, 254, 255, 0, 575, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 654, 655, 656, 657, 658, - 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, - 669, 670, 671, 649, 508, 514, 509, 510, 511, 512, - 513, 0, 515, 0, 0, 0, 0, 0, 398, 0, - 591, 592, 672, 384, 486, 603, 335, 349, 352, 341, - 361, 0, 362, 337, 338, 343, 346, 347, 348, 353, - 354, 358, 364, 249, 210, 390, 399, 578, 312, 216, - 217, 218, 524, 525, 526, 527, 619, 620, 624, 205, - 462, 463, 464, 465, 292, 614, 309, 468, 467, 331, - 332, 379, 449, 540, 542, 553, 557, 559, 561, 567, - 570, 541, 543, 554, 558, 560, 562, 568, 571, 530, - 532, 534, 536, 549, 548, 545, 573, 574, 551, 556, - 535, 547, 552, 565, 572, 569, 529, 533, 537, 546, - 564, 563, 544, 555, 566, 550, 538, 531, 539, 0, - 196, 221, 368, 0, 454, 288, 650, 618, 484, 613, - 206, 223, 0, 262, 0, 0, 0, 0, 0, 0, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 0, 0, 0, 0, 0, 399, 0, + 592, 593, 673, 385, 487, 604, 336, 350, 353, 342, + 362, 0, 363, 338, 339, 344, 347, 348, 349, 354, + 355, 359, 365, 249, 210, 391, 400, 579, 313, 216, + 217, 218, 525, 526, 527, 528, 620, 621, 625, 205, + 463, 464, 465, 466, 293, 615, 310, 469, 468, 332, + 333, 380, 450, 541, 543, 554, 558, 560, 562, 568, + 571, 542, 544, 555, 559, 561, 563, 569, 572, 531, + 533, 535, 537, 550, 549, 546, 574, 575, 552, 557, + 536, 548, 553, 566, 573, 570, 530, 534, 538, 547, + 565, 564, 545, 556, 567, 551, 539, 532, 540, 0, + 196, 221, 369, 0, 455, 289, 651, 619, 485, 614, + 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, - 236, 243, 261, 276, 278, 285, 298, 310, 318, 319, - 322, 328, 380, 386, 387, 388, 389, 409, 410, 411, - 414, 417, 418, 421, 423, 424, 427, 431, 435, 436, - 437, 439, 441, 443, 455, 460, 474, 475, 476, 477, - 478, 481, 482, 488, 489, 490, 491, 492, 500, 501, - 516, 586, 588, 605, 625, 632, 480, 301, 302, 444, - 445, 314, 315, 646, 647, 300, 600, 633, 597, 645, - 627, 438, 378, 0, 0, 381, 281, 305, 320, 0, - 617, 502, 227, 466, 290, 251, 0, 0, 211, 246, - 230, 259, 274, 277, 324, 391, 400, 429, 434, 296, - 271, 244, 459, 241, 485, 519, 520, 521, 523, 395, - 266, 433, 396, 0, 376, 576, 577, 316, 0, 0, - 86, 528, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 416, 0, 0, 0, 0, 0, 0, - 0, 270, 0, 0, 0, 0, 366, 267, 0, 0, - 204, 505, 0, 430, 0, 203, 0, 487, 252, 377, - 374, 583, 282, 273, 269, 250, 317, 385, 428, 518, - 422, 0, 370, 0, 0, 497, 401, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 323, 248, 325, 202, 413, - 498, 286, 0, 95, 0, 0, 0, 507, 194, 0, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 302, 303, 445, + 446, 315, 316, 647, 648, 301, 601, 634, 598, 646, + 628, 439, 379, 0, 0, 382, 282, 306, 321, 0, + 618, 503, 227, 467, 291, 251, 0, 0, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 397, 0, 377, 577, 578, 317, 0, 0, + 86, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 0, 0, 0, + 0, 271, 0, 0, 0, 0, 367, 268, 0, 0, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 0, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 95, 0, 1754, 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, - 0, 245, 0, 0, 0, 351, 360, 359, 339, 340, - 342, 344, 350, 357, 363, 336, 345, 0, 0, 609, - 0, 0, 0, 265, 321, 272, 264, 580, 0, 0, - 0, 0, 0, 0, 596, 0, 0, 229, 0, 0, + 0, 245, 0, 0, 0, 352, 361, 360, 340, 341, + 343, 345, 351, 358, 364, 337, 346, 0, 0, 610, + 0, 0, 0, 266, 322, 273, 265, 581, 0, 0, + 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 275, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -4491,1184 +4677,963 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 297, 0, 402, 257, 0, 453, - 0, 0, 0, 629, 0, 0, 0, 0, 0, 0, - 0, 365, 0, 330, 197, 225, 0, 0, 412, 461, - 473, 0, 0, 0, 253, 0, 471, 426, 604, 233, - 284, 458, 432, 469, 440, 287, 0, 0, 470, 372, - 585, 450, 601, 630, 631, 263, 406, 615, 522, 623, - 648, 226, 260, 420, 506, 607, 494, 397, 581, 582, - 329, 493, 295, 201, 369, 636, 224, 479, 371, 242, - 231, 587, 612, 299, 289, 456, 643, 213, 517, 598, - 239, 483, 0, 0, 651, 247, 504, 610, 599, 215, - 594, 503, 393, 326, 327, 214, 0, 457, 268, 293, - 0, 0, 258, 415, 589, 590, 256, 652, 228, 622, - 220, 0, 621, 408, 584, 595, 394, 383, 219, 593, - 392, 382, 334, 355, 356, 280, 307, 447, 375, 448, - 306, 308, 404, 403, 405, 207, 608, 626, 0, 208, - 0, 499, 611, 653, 452, 212, 234, 235, 237, 0, - 279, 283, 291, 294, 303, 304, 313, 367, 419, 446, - 442, 451, 0, 579, 602, 616, 628, 634, 635, 637, - 638, 639, 640, 641, 644, 642, 407, 311, 495, 333, - 373, 0, 0, 425, 472, 240, 606, 496, 199, 0, - 0, 0, 0, 254, 255, 0, 575, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 654, 655, 656, 657, + 0, 0, 0, 0, 298, 0, 403, 258, 0, 454, + 0, 0, 0, 630, 0, 0, 0, 0, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 254, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 590, 591, 257, 653, 228, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 356, 357, 281, 308, 448, 376, + 449, 307, 309, 405, 404, 406, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 199, + 0, 0, 0, 0, 255, 256, 0, 576, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, - 668, 669, 670, 671, 649, 508, 514, 509, 510, 511, - 512, 513, 0, 515, 0, 0, 0, 0, 0, 398, - 0, 591, 592, 672, 384, 486, 603, 335, 349, 352, - 341, 361, 0, 362, 337, 338, 343, 346, 347, 348, - 353, 354, 358, 364, 249, 210, 390, 399, 578, 312, - 216, 217, 218, 524, 525, 526, 527, 619, 620, 624, - 205, 462, 463, 464, 465, 292, 614, 309, 468, 467, - 331, 332, 379, 449, 540, 542, 553, 557, 559, 561, - 567, 570, 541, 543, 554, 558, 560, 562, 568, 571, - 530, 532, 534, 536, 549, 548, 545, 573, 574, 551, - 556, 535, 547, 552, 565, 572, 569, 529, 533, 537, - 546, 564, 563, 544, 555, 566, 550, 538, 531, 539, - 0, 196, 221, 368, 94, 454, 288, 650, 618, 484, - 613, 206, 223, 0, 262, 0, 0, 0, 0, 0, - 0, 2426, 0, 0, 2425, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, - 232, 236, 243, 261, 276, 278, 285, 298, 310, 318, - 319, 322, 328, 380, 386, 387, 388, 389, 409, 410, - 411, 414, 417, 418, 421, 423, 424, 427, 431, 435, - 436, 437, 439, 441, 443, 455, 460, 474, 475, 476, - 477, 478, 481, 482, 488, 489, 490, 491, 492, 500, - 501, 516, 586, 588, 605, 625, 632, 480, 301, 302, - 444, 445, 314, 315, 646, 647, 300, 600, 633, 597, - 645, 627, 438, 378, 0, 0, 381, 281, 305, 320, - 0, 617, 502, 227, 466, 290, 251, 0, 0, 211, - 246, 230, 259, 274, 277, 324, 391, 400, 429, 434, - 296, 271, 244, 459, 241, 485, 519, 520, 521, 523, - 395, 266, 433, 1776, 0, 376, 576, 577, 316, 0, - 0, 0, 528, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 416, 0, 0, 1778, 0, 0, - 0, 0, 270, 0, 0, 0, 0, 366, 267, 0, - 0, 204, 505, 0, 430, 0, 203, 0, 487, 252, - 377, 374, 583, 282, 273, 269, 250, 317, 385, 428, - 518, 422, 0, 370, 0, 0, 497, 401, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 323, 248, 325, 202, - 413, 498, 286, 0, 0, 0, 0, 1780, 507, 724, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, - 0, 0, 245, 0, 0, 0, 351, 360, 359, 339, - 340, 342, 344, 350, 357, 363, 336, 345, 0, 0, - 609, 0, 0, 0, 265, 321, 272, 264, 580, 0, - 0, 0, 0, 0, 0, 596, 0, 0, 229, 0, - 0, 0, 1479, 0, 1480, 1481, 0, 0, 0, 0, - 0, 0, 0, 275, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 297, 0, 402, 257, 0, - 453, 0, 0, 0, 629, 0, 0, 0, 0, 0, - 0, 0, 365, 0, 330, 197, 225, 0, 0, 412, - 461, 473, 0, 0, 0, 253, 0, 471, 426, 604, - 233, 284, 458, 432, 469, 440, 287, 0, 0, 470, - 372, 585, 450, 601, 630, 631, 263, 406, 615, 522, - 623, 648, 226, 260, 420, 506, 607, 494, 397, 581, - 582, 329, 493, 295, 201, 369, 636, 224, 479, 371, - 242, 231, 587, 612, 299, 289, 456, 643, 213, 517, - 598, 239, 483, 0, 0, 651, 247, 504, 610, 599, - 215, 594, 503, 393, 326, 327, 214, 0, 457, 268, - 293, 0, 0, 258, 415, 589, 590, 256, 652, 228, - 622, 220, 0, 621, 408, 584, 595, 394, 383, 219, - 593, 392, 382, 334, 355, 356, 280, 307, 447, 375, - 448, 306, 308, 404, 403, 405, 207, 608, 626, 0, - 208, 0, 499, 611, 653, 452, 212, 234, 235, 237, - 0, 279, 283, 291, 294, 303, 304, 313, 367, 419, - 446, 442, 451, 0, 579, 602, 616, 628, 634, 635, - 637, 638, 639, 640, 641, 644, 642, 407, 311, 495, - 333, 373, 0, 0, 425, 472, 240, 606, 496, 199, - 0, 0, 0, 0, 254, 255, 0, 575, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 654, 655, 656, - 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, - 667, 668, 669, 670, 671, 649, 508, 514, 509, 510, - 511, 512, 513, 0, 515, 0, 0, 0, 0, 0, - 398, 0, 591, 592, 672, 384, 486, 603, 335, 349, - 352, 341, 361, 0, 362, 337, 338, 343, 346, 347, - 348, 353, 354, 358, 364, 249, 210, 390, 399, 578, - 312, 216, 217, 218, 524, 525, 526, 527, 619, 620, - 624, 205, 462, 463, 464, 465, 292, 614, 309, 468, - 467, 331, 332, 379, 449, 540, 542, 553, 557, 559, - 561, 567, 570, 541, 543, 554, 558, 560, 562, 568, - 571, 530, 532, 534, 536, 549, 548, 545, 573, 574, - 551, 556, 535, 547, 552, 565, 572, 569, 529, 533, - 537, 546, 564, 563, 544, 555, 566, 550, 538, 531, - 539, 0, 196, 221, 368, 0, 454, 288, 650, 618, - 484, 613, 206, 223, 0, 262, 0, 0, 0, 0, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 0, 0, 0, 0, 0, + 399, 0, 592, 593, 673, 385, 487, 604, 336, 350, + 353, 342, 362, 0, 363, 338, 339, 344, 347, 348, + 349, 354, 355, 359, 365, 249, 210, 391, 400, 579, + 313, 216, 217, 218, 525, 526, 527, 528, 620, 621, + 625, 205, 463, 464, 465, 466, 293, 615, 310, 469, + 468, 332, 333, 380, 450, 541, 543, 554, 558, 560, + 562, 568, 571, 542, 544, 555, 559, 561, 563, 569, + 572, 531, 533, 535, 537, 550, 549, 546, 574, 575, + 552, 557, 536, 548, 553, 566, 573, 570, 530, 534, + 538, 547, 565, 564, 545, 556, 567, 551, 539, 532, + 540, 0, 196, 221, 369, 94, 455, 289, 651, 619, + 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, - 222, 232, 236, 243, 261, 276, 278, 285, 298, 310, - 318, 319, 322, 328, 380, 386, 387, 388, 389, 409, - 410, 411, 414, 417, 418, 421, 423, 424, 427, 431, - 435, 436, 437, 439, 441, 443, 455, 460, 474, 475, - 476, 477, 478, 481, 482, 488, 489, 490, 491, 492, - 500, 501, 516, 586, 588, 605, 625, 632, 480, 301, - 302, 444, 445, 314, 315, 646, 647, 300, 600, 633, - 597, 645, 627, 438, 378, 0, 0, 381, 281, 305, - 320, 0, 617, 502, 227, 466, 290, 251, 0, 0, - 211, 246, 230, 259, 274, 277, 324, 391, 400, 429, - 434, 296, 271, 244, 459, 241, 485, 519, 520, 521, - 523, 395, 266, 433, 396, 0, 376, 576, 577, 316, - 0, 0, 86, 528, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 416, 0, 0, 0, 0, - 0, 0, 0, 270, 0, 0, 0, 0, 366, 267, - 0, 0, 204, 505, 0, 430, 0, 203, 0, 487, - 252, 377, 374, 583, 282, 273, 269, 250, 317, 385, - 428, 518, 422, 0, 370, 0, 0, 497, 401, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 323, 248, 325, - 202, 413, 498, 286, 0, 95, 0, 1753, 0, 507, - 724, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 238, 0, 0, 245, 0, 0, 0, 351, 360, 359, - 339, 340, 342, 344, 350, 357, 363, 336, 345, 0, - 0, 609, 0, 0, 0, 265, 321, 272, 264, 580, - 0, 0, 0, 0, 0, 0, 596, 0, 0, 229, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 275, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 297, 0, 402, 257, - 0, 453, 0, 0, 0, 629, 0, 0, 0, 0, - 0, 0, 0, 365, 0, 330, 197, 225, 0, 0, - 412, 461, 473, 0, 0, 0, 253, 0, 471, 426, - 604, 233, 284, 458, 432, 469, 440, 287, 0, 0, - 470, 372, 585, 450, 601, 630, 631, 263, 406, 615, - 522, 623, 648, 226, 260, 420, 506, 607, 494, 397, - 581, 582, 329, 493, 295, 201, 369, 636, 224, 479, - 371, 242, 231, 587, 612, 299, 289, 456, 643, 213, - 517, 598, 239, 483, 0, 0, 651, 247, 504, 610, - 599, 215, 594, 503, 393, 326, 327, 214, 0, 457, - 268, 293, 0, 0, 258, 415, 589, 590, 256, 652, - 228, 622, 220, 0, 621, 408, 584, 595, 394, 383, - 219, 593, 392, 382, 334, 355, 356, 280, 307, 447, - 375, 448, 306, 308, 404, 403, 405, 207, 608, 626, - 0, 208, 0, 499, 611, 653, 452, 212, 234, 235, - 237, 0, 279, 283, 291, 294, 303, 304, 313, 367, - 419, 446, 442, 451, 0, 579, 602, 616, 628, 634, - 635, 637, 638, 639, 640, 641, 644, 642, 407, 311, - 495, 333, 373, 0, 0, 425, 472, 240, 606, 496, - 199, 0, 0, 0, 0, 254, 255, 0, 575, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 654, 655, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 302, + 303, 445, 446, 315, 316, 647, 648, 301, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 0, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 0, + 0, 0, 0, 271, 0, 0, 0, 0, 367, 268, + 0, 0, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 0, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 95, 0, 0, 0, 508, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 238, 0, 0, 245, 0, 0, 0, 352, 361, 360, + 340, 341, 343, 345, 351, 358, 364, 337, 346, 0, + 0, 610, 0, 0, 0, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 0, 0, 0, 630, 0, 0, 0, 0, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 254, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 590, 591, 257, + 653, 228, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 356, 357, 281, 308, + 448, 376, 449, 307, 309, 405, 404, 406, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 199, 0, 0, 0, 0, 255, 256, 0, 576, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, - 666, 667, 668, 669, 670, 671, 649, 508, 514, 509, - 510, 511, 512, 513, 0, 515, 0, 0, 0, 0, - 0, 398, 0, 591, 592, 672, 384, 486, 603, 335, - 349, 352, 341, 361, 0, 362, 337, 338, 343, 346, - 347, 348, 353, 354, 358, 364, 249, 210, 390, 399, - 578, 312, 216, 217, 218, 524, 525, 526, 527, 619, - 620, 624, 205, 462, 463, 464, 465, 292, 614, 309, - 468, 467, 331, 332, 379, 449, 540, 542, 553, 557, - 559, 561, 567, 570, 541, 543, 554, 558, 560, 562, - 568, 571, 530, 532, 534, 536, 549, 548, 545, 573, - 574, 551, 556, 535, 547, 552, 565, 572, 569, 529, - 533, 537, 546, 564, 563, 544, 555, 566, 550, 538, - 531, 539, 0, 196, 221, 368, 94, 454, 288, 650, - 618, 484, 613, 206, 223, 0, 262, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, - 209, 222, 232, 236, 243, 261, 276, 278, 285, 298, - 310, 318, 319, 322, 328, 380, 386, 387, 388, 389, - 409, 410, 411, 414, 417, 418, 421, 423, 424, 427, - 431, 435, 436, 437, 439, 441, 443, 455, 460, 474, - 475, 476, 477, 478, 481, 482, 488, 489, 490, 491, - 492, 500, 501, 516, 586, 588, 605, 625, 632, 480, - 301, 302, 444, 445, 314, 315, 646, 647, 300, 600, - 633, 597, 645, 627, 438, 378, 0, 0, 381, 281, - 305, 320, 0, 617, 502, 227, 466, 290, 251, 0, - 0, 211, 246, 230, 259, 274, 277, 324, 391, 400, - 429, 434, 296, 271, 244, 459, 241, 485, 519, 520, - 521, 523, 395, 266, 433, 396, 0, 376, 576, 577, - 316, 0, 0, 0, 528, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 416, 0, 0, 0, - 0, 0, 0, 0, 270, 0, 0, 0, 0, 366, - 267, 0, 0, 204, 505, 0, 430, 0, 203, 0, - 487, 252, 377, 374, 583, 282, 273, 269, 250, 317, - 385, 428, 518, 422, 0, 370, 0, 0, 497, 401, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 323, 248, - 325, 202, 413, 498, 286, 0, 95, 0, 0, 0, - 507, 194, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 238, 0, 0, 245, 0, 0, 0, 351, 360, - 359, 339, 340, 342, 344, 350, 357, 363, 336, 345, - 0, 0, 609, 0, 0, 0, 265, 321, 272, 264, - 580, 0, 0, 0, 0, 0, 0, 596, 0, 0, - 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 275, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 297, 0, 402, - 257, 0, 453, 0, 0, 0, 629, 0, 0, 0, - 0, 0, 0, 0, 365, 0, 330, 197, 225, 0, - 0, 412, 461, 473, 0, 0, 0, 253, 0, 471, - 426, 604, 233, 284, 458, 432, 469, 440, 287, 0, - 0, 470, 372, 585, 450, 601, 630, 631, 263, 406, - 615, 522, 623, 648, 226, 260, 420, 506, 607, 494, - 397, 581, 582, 329, 493, 295, 201, 369, 636, 224, - 479, 371, 242, 231, 587, 612, 299, 289, 456, 643, - 213, 517, 598, 239, 483, 0, 0, 651, 247, 504, - 610, 599, 215, 594, 503, 393, 326, 327, 214, 0, - 457, 268, 293, 0, 0, 258, 415, 589, 590, 256, - 652, 228, 622, 220, 0, 621, 408, 584, 595, 394, - 383, 219, 593, 392, 382, 334, 355, 356, 280, 307, - 447, 375, 448, 306, 308, 404, 403, 405, 207, 608, - 626, 0, 208, 0, 499, 611, 653, 452, 212, 234, - 235, 237, 0, 279, 283, 291, 294, 303, 304, 313, - 367, 419, 446, 442, 451, 0, 579, 602, 616, 628, - 634, 635, 637, 638, 639, 640, 641, 644, 642, 407, - 311, 495, 333, 373, 0, 0, 425, 472, 240, 606, - 496, 199, 0, 0, 0, 0, 254, 255, 0, 575, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 654, - 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, - 665, 666, 667, 668, 669, 670, 671, 649, 508, 514, - 509, 510, 511, 512, 513, 0, 515, 0, 0, 0, - 0, 0, 398, 0, 591, 592, 672, 384, 486, 603, - 335, 349, 352, 341, 361, 0, 362, 337, 338, 343, - 346, 347, 348, 353, 354, 358, 364, 249, 210, 390, - 399, 578, 312, 216, 217, 218, 524, 525, 526, 527, - 619, 620, 624, 205, 462, 463, 464, 465, 292, 614, - 309, 468, 467, 331, 332, 379, 449, 540, 542, 553, - 557, 559, 561, 567, 570, 541, 543, 554, 558, 560, - 562, 568, 571, 530, 532, 534, 536, 549, 548, 545, - 573, 574, 551, 556, 535, 547, 552, 565, 572, 569, - 529, 533, 537, 546, 564, 563, 544, 555, 566, 550, - 538, 531, 539, 0, 196, 221, 368, 0, 454, 288, - 650, 618, 484, 613, 206, 223, 0, 262, 0, 0, - 0, 0, 0, 0, 2426, 0, 0, 2425, 0, 0, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 0, 0, 0, + 0, 0, 399, 0, 592, 593, 673, 385, 487, 604, + 336, 350, 353, 342, 362, 0, 363, 338, 339, 344, + 347, 348, 349, 354, 355, 359, 365, 249, 210, 391, + 400, 579, 313, 216, 217, 218, 525, 526, 527, 528, + 620, 621, 625, 205, 463, 464, 465, 466, 293, 615, + 310, 469, 468, 332, 333, 380, 450, 541, 543, 554, + 558, 560, 562, 568, 571, 542, 544, 555, 559, 561, + 563, 569, 572, 531, 533, 535, 537, 550, 549, 546, + 574, 575, 552, 557, 536, 548, 553, 566, 573, 570, + 530, 534, 538, 547, 565, 564, 545, 556, 567, 551, + 539, 532, 540, 0, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 0, 263, 0, 0, + 0, 0, 0, 0, 2427, 0, 0, 2426, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 209, 222, 232, 236, 243, 261, 276, 278, 285, - 298, 310, 318, 319, 322, 328, 380, 386, 387, 388, - 389, 409, 410, 411, 414, 417, 418, 421, 423, 424, - 427, 431, 435, 436, 437, 439, 441, 443, 455, 460, - 474, 475, 476, 477, 478, 481, 482, 488, 489, 490, - 491, 492, 500, 501, 516, 586, 588, 605, 625, 632, - 480, 301, 302, 444, 445, 314, 315, 646, 647, 300, - 600, 633, 597, 645, 627, 438, 378, 0, 0, 381, - 281, 305, 320, 0, 617, 502, 227, 466, 290, 251, - 0, 0, 211, 246, 230, 259, 274, 277, 324, 391, - 400, 429, 434, 296, 271, 244, 459, 241, 485, 519, - 520, 521, 523, 395, 266, 433, 396, 0, 376, 576, - 577, 316, 0, 0, 0, 528, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 416, 0, 0, - 2373, 0, 0, 0, 0, 270, 0, 0, 0, 0, - 366, 267, 0, 0, 204, 505, 0, 430, 0, 203, - 0, 487, 252, 377, 374, 583, 282, 273, 269, 250, - 317, 385, 428, 518, 422, 0, 370, 0, 0, 497, - 401, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 323, - 248, 325, 202, 413, 498, 286, 0, 0, 0, 0, - 1961, 507, 194, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 238, 0, 0, 245, 0, 0, 0, 351, - 360, 359, 339, 340, 342, 344, 350, 357, 363, 336, - 345, 0, 0, 609, 0, 0, 0, 265, 321, 272, - 264, 580, 0, 0, 0, 0, 0, 0, 596, 0, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 302, 303, 445, 446, 315, 316, 647, 648, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 0, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 397, 0, 377, 577, + 578, 317, 0, 0, 0, 529, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, + 2374, 0, 0, 0, 0, 271, 0, 0, 0, 0, + 367, 268, 0, 0, 204, 506, 0, 431, 0, 203, + 0, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 0, 371, 0, 0, 498, + 402, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 248, 326, 202, 414, 499, 287, 0, 0, 0, 0, + 1962, 508, 194, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 238, 0, 0, 245, 0, 0, 0, 352, + 361, 360, 340, 341, 343, 345, 351, 358, 364, 337, + 346, 0, 0, 610, 0, 0, 0, 266, 322, 273, + 265, 581, 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 275, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 297, 0, - 402, 257, 0, 453, 0, 0, 0, 629, 0, 0, - 0, 0, 0, 0, 0, 365, 0, 330, 197, 225, - 0, 0, 412, 461, 473, 0, 0, 0, 253, 0, - 471, 426, 604, 233, 284, 458, 432, 469, 440, 287, - 0, 2371, 470, 372, 585, 450, 601, 630, 631, 263, - 406, 615, 522, 623, 648, 226, 260, 420, 506, 607, - 494, 397, 581, 582, 329, 493, 295, 201, 369, 636, - 224, 479, 371, 242, 231, 587, 612, 299, 289, 456, - 643, 213, 517, 598, 239, 483, 0, 0, 651, 247, - 504, 610, 599, 215, 594, 503, 393, 326, 327, 214, - 0, 457, 268, 293, 0, 0, 258, 415, 589, 590, - 256, 652, 228, 622, 220, 0, 621, 408, 584, 595, - 394, 383, 219, 593, 392, 382, 334, 355, 356, 280, - 307, 447, 375, 448, 306, 308, 404, 403, 405, 207, - 608, 626, 0, 208, 0, 499, 611, 653, 452, 212, - 234, 235, 237, 0, 279, 283, 291, 294, 303, 304, - 313, 367, 419, 446, 442, 451, 0, 579, 602, 616, - 628, 634, 635, 637, 638, 639, 640, 641, 644, 642, - 407, 311, 495, 333, 373, 0, 0, 425, 472, 240, - 606, 496, 199, 0, 0, 0, 0, 254, 255, 0, - 575, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, - 664, 665, 666, 667, 668, 669, 670, 671, 649, 508, - 514, 509, 510, 511, 512, 513, 0, 515, 0, 0, - 0, 0, 0, 398, 0, 591, 592, 672, 384, 486, - 603, 335, 349, 352, 341, 361, 0, 362, 337, 338, - 343, 346, 347, 348, 353, 354, 358, 364, 249, 210, - 390, 399, 578, 312, 216, 217, 218, 524, 525, 526, - 527, 619, 620, 624, 205, 462, 463, 464, 465, 292, - 614, 309, 468, 467, 331, 332, 379, 449, 540, 542, - 553, 557, 559, 561, 567, 570, 541, 543, 554, 558, - 560, 562, 568, 571, 530, 532, 534, 536, 549, 548, - 545, 573, 574, 551, 556, 535, 547, 552, 565, 572, - 569, 529, 533, 537, 546, 564, 563, 544, 555, 566, - 550, 538, 531, 539, 0, 196, 221, 368, 0, 454, - 288, 650, 618, 484, 613, 206, 223, 0, 262, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 198, 200, 209, 222, 232, 236, 243, 261, 276, 278, - 285, 298, 310, 318, 319, 322, 328, 380, 386, 387, - 388, 389, 409, 410, 411, 414, 417, 418, 421, 423, - 424, 427, 431, 435, 436, 437, 439, 441, 443, 455, - 460, 474, 475, 476, 477, 478, 481, 482, 488, 489, - 490, 491, 492, 500, 501, 516, 586, 588, 605, 625, - 632, 480, 301, 302, 444, 445, 314, 315, 646, 647, - 300, 600, 633, 597, 645, 627, 438, 378, 0, 0, - 381, 281, 305, 320, 0, 617, 502, 227, 466, 290, - 251, 0, 0, 211, 246, 230, 259, 274, 277, 324, - 391, 400, 429, 434, 296, 271, 244, 459, 241, 485, - 519, 520, 521, 523, 395, 266, 433, 396, 0, 376, - 576, 577, 316, 0, 0, 0, 528, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 416, 0, - 0, 0, 0, 0, 0, 0, 270, 0, 0, 0, - 0, 366, 267, 0, 0, 204, 505, 0, 430, 0, - 203, 0, 487, 252, 377, 374, 583, 282, 273, 269, - 250, 317, 385, 428, 518, 422, 0, 370, 0, 0, - 497, 401, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 323, 248, 325, 202, 413, 498, 286, 0, 0, 0, - 0, 0, 507, 724, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 238, 0, 0, 245, 0, 0, 0, - 351, 360, 359, 339, 340, 342, 344, 350, 357, 363, - 336, 345, 0, 0, 609, 0, 0, 0, 265, 321, - 272, 264, 580, 0, 0, 0, 0, 0, 0, 596, - 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 275, 0, 0, - 0, 0, 0, 0, 0, 0, 1092, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 297, - 0, 402, 257, 0, 453, 0, 0, 0, 629, 0, - 0, 0, 0, 0, 0, 0, 365, 1098, 330, 197, - 225, 1096, 0, 412, 461, 473, 0, 0, 0, 253, - 0, 471, 426, 604, 233, 284, 458, 432, 469, 440, - 287, 0, 0, 470, 372, 585, 450, 601, 630, 631, - 263, 406, 615, 522, 623, 648, 226, 260, 420, 506, - 607, 494, 397, 581, 582, 329, 493, 295, 201, 369, - 636, 224, 479, 371, 242, 231, 587, 612, 299, 289, - 456, 643, 213, 517, 598, 239, 483, 0, 0, 651, - 247, 504, 610, 599, 215, 594, 503, 393, 326, 327, - 214, 0, 457, 268, 293, 0, 0, 258, 415, 589, - 590, 256, 652, 228, 622, 220, 0, 621, 408, 584, - 595, 394, 383, 219, 593, 392, 382, 334, 355, 356, - 280, 307, 447, 375, 448, 306, 308, 404, 403, 405, - 207, 608, 626, 0, 208, 0, 499, 611, 653, 452, - 212, 234, 235, 237, 0, 279, 283, 291, 294, 303, - 304, 313, 367, 419, 446, 442, 451, 0, 579, 602, - 616, 628, 634, 635, 637, 638, 639, 640, 641, 644, - 642, 407, 311, 495, 333, 373, 0, 0, 425, 472, - 240, 606, 496, 199, 0, 0, 0, 0, 254, 255, - 0, 575, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 654, 655, 656, 657, 658, 659, 660, 661, 662, - 663, 664, 665, 666, 667, 668, 669, 670, 671, 649, - 508, 514, 509, 510, 511, 512, 513, 0, 515, 0, - 0, 0, 0, 0, 398, 0, 591, 592, 672, 384, - 486, 603, 335, 349, 352, 341, 361, 0, 362, 337, - 338, 343, 346, 347, 348, 353, 354, 358, 364, 249, - 210, 390, 399, 578, 312, 216, 217, 218, 524, 525, - 526, 527, 619, 620, 624, 205, 462, 463, 464, 465, - 292, 614, 309, 468, 467, 331, 332, 379, 449, 540, - 542, 553, 557, 559, 561, 567, 570, 541, 543, 554, - 558, 560, 562, 568, 571, 530, 532, 534, 536, 549, - 548, 545, 573, 574, 551, 556, 535, 547, 552, 565, - 572, 569, 529, 533, 537, 546, 564, 563, 544, 555, - 566, 550, 538, 531, 539, 0, 196, 221, 368, 0, - 454, 288, 650, 618, 484, 613, 206, 223, 0, 262, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 198, 200, 209, 222, 232, 236, 243, 261, 276, - 278, 285, 298, 310, 318, 319, 322, 328, 380, 386, - 387, 388, 389, 409, 410, 411, 414, 417, 418, 421, - 423, 424, 427, 431, 435, 436, 437, 439, 441, 443, - 455, 460, 474, 475, 476, 477, 478, 481, 482, 488, - 489, 490, 491, 492, 500, 501, 516, 586, 588, 605, - 625, 632, 480, 301, 302, 444, 445, 314, 315, 646, - 647, 300, 600, 633, 597, 645, 627, 438, 378, 0, - 0, 381, 281, 305, 320, 0, 617, 502, 227, 466, - 290, 251, 0, 0, 211, 246, 230, 259, 274, 277, - 324, 391, 400, 429, 434, 296, 271, 244, 459, 241, - 485, 519, 520, 521, 523, 395, 266, 433, 396, 0, - 376, 576, 577, 316, 0, 0, 0, 528, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 416, - 0, 0, 2373, 0, 0, 0, 0, 270, 0, 0, - 0, 0, 366, 267, 0, 0, 204, 505, 0, 430, - 0, 203, 0, 487, 252, 377, 374, 583, 282, 273, - 269, 250, 317, 385, 428, 518, 422, 0, 370, 0, - 0, 497, 401, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 323, 248, 325, 202, 413, 498, 286, 0, 0, - 0, 0, 1961, 507, 194, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 403, 258, 0, 454, 0, 0, 0, 630, 0, 0, + 0, 0, 0, 0, 0, 366, 0, 331, 197, 225, + 0, 0, 413, 462, 474, 0, 0, 0, 254, 0, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 0, 2372, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 590, + 591, 257, 653, 228, 623, 220, 0, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 356, 357, + 281, 308, 448, 376, 449, 307, 309, 405, 404, 406, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 0, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 0, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 0, 0, 426, 473, + 240, 607, 497, 199, 0, 0, 0, 0, 255, 256, + 0, 576, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 0, + 0, 0, 0, 0, 399, 0, 592, 593, 673, 385, + 487, 604, 336, 350, 353, 342, 362, 0, 363, 338, + 339, 344, 347, 348, 349, 354, 355, 359, 365, 249, + 210, 391, 400, 579, 313, 216, 217, 218, 525, 526, + 527, 528, 620, 621, 625, 205, 463, 464, 465, 466, + 293, 615, 310, 469, 468, 332, 333, 380, 450, 541, + 543, 554, 558, 560, 562, 568, 571, 542, 544, 555, + 559, 561, 563, 569, 572, 531, 533, 535, 537, 550, + 549, 546, 574, 575, 552, 557, 536, 548, 553, 566, + 573, 570, 530, 534, 538, 547, 565, 564, 545, 556, + 567, 551, 539, 532, 540, 0, 196, 221, 369, 0, + 455, 289, 651, 619, 485, 614, 206, 223, 0, 263, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 302, 303, 445, 446, 315, 316, 647, + 648, 301, 601, 634, 598, 646, 628, 439, 379, 0, + 0, 382, 282, 306, 321, 0, 618, 503, 227, 467, + 291, 251, 0, 0, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 397, 0, + 377, 577, 578, 317, 0, 0, 0, 529, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 0, 0, 0, 0, 271, 0, 0, + 0, 0, 367, 268, 0, 0, 204, 506, 0, 431, + 0, 203, 0, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 0, 371, 0, + 0, 498, 402, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 248, 326, 202, 414, 499, 287, 0, 0, + 0, 0, 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, 0, 0, - 0, 351, 360, 359, 339, 340, 342, 344, 350, 357, - 363, 336, 345, 0, 0, 609, 0, 0, 0, 265, - 321, 272, 264, 580, 0, 0, 0, 0, 0, 0, - 596, 0, 0, 229, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 275, 0, + 0, 352, 361, 360, 340, 341, 343, 345, 351, 358, + 364, 337, 346, 0, 0, 610, 0, 0, 0, 266, + 322, 273, 265, 581, 0, 0, 0, 0, 0, 0, + 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 276, 0, + 0, 0, 0, 0, 0, 0, 0, 1093, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 298, 0, 403, 258, 0, 454, 0, 0, 0, 630, + 0, 0, 0, 0, 0, 0, 0, 366, 1099, 331, + 197, 225, 1097, 0, 413, 462, 474, 0, 0, 0, + 254, 0, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 0, 0, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 590, 591, 257, 653, 228, 623, 220, 0, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 356, 357, 281, 308, 448, 376, 449, 307, 309, 405, + 404, 406, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 0, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 0, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 0, 0, + 426, 473, 240, 607, 497, 199, 0, 0, 0, 0, + 255, 256, 0, 576, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, + 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 0, 0, 0, 0, 0, 399, 0, 592, 593, + 673, 385, 487, 604, 336, 350, 353, 342, 362, 0, + 363, 338, 339, 344, 347, 348, 349, 354, 355, 359, + 365, 249, 210, 391, 400, 579, 313, 216, 217, 218, + 525, 526, 527, 528, 620, 621, 625, 205, 463, 464, + 465, 466, 293, 615, 310, 469, 468, 332, 333, 380, + 450, 541, 543, 554, 558, 560, 562, 568, 571, 542, + 544, 555, 559, 561, 563, 569, 572, 531, 533, 535, + 537, 550, 549, 546, 574, 575, 552, 557, 536, 548, + 553, 566, 573, 570, 530, 534, 538, 547, 565, 564, + 545, 556, 567, 551, 539, 532, 540, 0, 196, 221, + 369, 0, 455, 289, 651, 619, 485, 614, 206, 223, + 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 198, 200, 209, 222, 232, 236, 243, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 302, 303, 445, 446, 315, + 316, 647, 648, 301, 601, 634, 598, 646, 628, 439, + 379, 0, 0, 382, 282, 306, 321, 0, 618, 503, + 227, 467, 291, 251, 0, 0, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 397, 0, 377, 577, 578, 317, 0, 0, 0, 529, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 2374, 0, 0, 0, 0, 271, + 0, 0, 0, 0, 367, 268, 0, 0, 204, 506, + 0, 431, 0, 203, 0, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 0, + 371, 0, 0, 498, 402, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 248, 326, 202, 414, 499, 287, + 0, 0, 0, 0, 1962, 508, 194, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, + 0, 0, 0, 352, 361, 360, 340, 341, 343, 345, + 351, 358, 364, 337, 346, 0, 0, 610, 0, 0, + 0, 266, 322, 273, 265, 581, 0, 0, 0, 0, + 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 298, 0, 403, 258, 0, 454, 0, 0, + 0, 630, 0, 0, 0, 0, 0, 0, 0, 366, + 0, 331, 197, 225, 0, 0, 413, 462, 474, 0, + 0, 0, 254, 0, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 0, 0, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 590, 591, 257, 653, 228, 623, 220, + 0, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 356, 357, 281, 308, 448, 376, 449, 307, + 309, 405, 404, 406, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 0, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 0, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 0, 0, 426, 473, 240, 607, 497, 199, 0, 0, + 0, 0, 255, 256, 0, 576, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, + 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 0, 0, 0, 0, 0, 399, 0, + 592, 593, 673, 385, 487, 604, 336, 350, 353, 342, + 362, 0, 363, 338, 339, 344, 347, 348, 349, 354, + 355, 359, 365, 249, 210, 391, 400, 579, 313, 216, + 217, 218, 525, 526, 527, 528, 620, 621, 625, 205, + 463, 464, 465, 466, 293, 615, 310, 469, 468, 332, + 333, 380, 450, 541, 543, 554, 558, 560, 562, 568, + 571, 542, 544, 555, 559, 561, 563, 569, 572, 531, + 533, 535, 537, 550, 549, 546, 574, 575, 552, 557, + 536, 548, 553, 566, 573, 570, 530, 534, 538, 547, + 565, 564, 545, 556, 567, 551, 539, 532, 540, 0, + 196, 221, 369, 0, 455, 289, 651, 619, 485, 614, + 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 302, 303, 445, + 446, 315, 316, 647, 648, 301, 601, 634, 598, 646, + 628, 439, 379, 0, 0, 382, 282, 306, 321, 0, + 618, 503, 227, 467, 291, 251, 0, 0, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 397, 0, 377, 577, 578, 317, 0, 0, + 0, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 0, 0, 0, + 0, 271, 0, 0, 0, 0, 367, 268, 0, 0, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 0, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 0, 0, 1754, 0, 508, 725, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, + 0, 245, 0, 0, 0, 352, 361, 360, 340, 341, + 343, 345, 351, 358, 364, 337, 346, 0, 0, 610, + 0, 0, 0, 266, 322, 273, 265, 581, 0, 0, + 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 297, 0, 402, 257, 0, 453, 0, 0, 0, 629, - 0, 0, 0, 0, 0, 0, 0, 365, 0, 330, - 197, 225, 0, 0, 412, 461, 473, 0, 0, 0, - 253, 0, 471, 426, 604, 233, 284, 458, 432, 469, - 440, 287, 0, 0, 470, 372, 585, 450, 601, 630, - 631, 263, 406, 615, 522, 623, 648, 226, 260, 420, - 506, 607, 494, 397, 581, 582, 329, 493, 295, 201, - 369, 636, 224, 479, 371, 242, 231, 587, 612, 299, - 289, 456, 643, 213, 517, 598, 239, 483, 0, 0, - 651, 247, 504, 610, 599, 215, 594, 503, 393, 326, - 327, 214, 0, 457, 268, 293, 0, 0, 258, 415, - 589, 590, 256, 652, 228, 622, 220, 0, 621, 408, - 584, 595, 394, 383, 219, 593, 392, 382, 334, 355, - 356, 280, 307, 447, 375, 448, 306, 308, 404, 403, - 405, 207, 608, 626, 0, 208, 0, 499, 611, 653, - 452, 212, 234, 235, 237, 0, 279, 283, 291, 294, - 303, 304, 313, 367, 419, 446, 442, 451, 0, 579, - 602, 616, 628, 634, 635, 637, 638, 639, 640, 641, - 644, 642, 407, 311, 495, 333, 373, 0, 0, 425, - 472, 240, 606, 496, 199, 0, 0, 0, 0, 254, - 255, 0, 575, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 654, 655, 656, 657, 658, 659, 660, 661, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 298, 0, 403, 258, 0, 454, + 0, 0, 0, 630, 0, 0, 0, 3729, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 254, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 590, 591, 257, 653, 228, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 356, 357, 281, 308, 448, 376, + 449, 307, 309, 405, 404, 406, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 199, + 0, 0, 0, 0, 255, 256, 0, 576, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, + 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 0, 0, 0, 0, 0, + 399, 0, 592, 593, 673, 385, 487, 604, 336, 350, + 353, 342, 362, 0, 363, 338, 339, 344, 347, 348, + 349, 354, 355, 359, 365, 249, 210, 391, 400, 579, + 313, 216, 217, 218, 525, 526, 527, 528, 620, 621, + 625, 205, 463, 464, 465, 466, 293, 615, 310, 469, + 468, 332, 333, 380, 450, 541, 543, 554, 558, 560, + 562, 568, 571, 542, 544, 555, 559, 561, 563, 569, + 572, 531, 533, 535, 537, 550, 549, 546, 574, 575, + 552, 557, 536, 548, 553, 566, 573, 570, 530, 534, + 538, 547, 565, 564, 545, 556, 567, 551, 539, 532, + 540, 0, 196, 221, 369, 0, 455, 289, 651, 619, + 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 302, + 303, 445, 446, 315, 316, 647, 648, 301, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 0, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 0, + 0, 0, 0, 271, 0, 0, 0, 0, 367, 268, + 0, 0, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 0, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 0, 0, 0, 2133, 508, + 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 238, 0, 0, 245, 0, 0, 0, 352, 361, 360, + 340, 341, 343, 345, 351, 358, 364, 337, 346, 0, + 0, 610, 0, 0, 0, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2134, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 0, 0, 0, 630, 0, 0, 0, 0, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 254, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 590, 591, 257, + 653, 228, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 356, 357, 281, 308, + 448, 376, 449, 307, 309, 405, 404, 406, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 199, 0, 0, 0, 0, 255, 256, 0, 576, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 655, + 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 0, 0, 0, + 0, 0, 399, 0, 592, 593, 673, 385, 487, 604, + 336, 350, 353, 342, 362, 0, 363, 338, 339, 344, + 347, 348, 349, 354, 355, 359, 365, 249, 210, 391, + 400, 579, 313, 216, 217, 218, 525, 526, 527, 528, + 620, 621, 625, 205, 463, 464, 465, 466, 293, 615, + 310, 469, 468, 332, 333, 380, 450, 541, 543, 554, + 558, 560, 562, 568, 571, 542, 544, 555, 559, 561, + 563, 569, 572, 531, 533, 535, 537, 550, 549, 546, + 574, 575, 552, 557, 536, 548, 553, 566, 573, 570, + 530, 534, 538, 547, 565, 564, 545, 556, 567, 551, + 539, 532, 540, 0, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 0, 263, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 302, 303, 445, 446, 315, 316, 647, 648, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 0, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 397, 0, 377, 577, + 578, 317, 0, 0, 0, 529, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, + 0, 0, 0, 0, 0, 271, 0, 0, 0, 0, + 367, 268, 0, 0, 204, 506, 0, 431, 0, 203, + 0, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 0, 371, 0, 0, 498, + 402, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 248, 326, 202, 414, 499, 287, 0, 0, 0, 0, + 2881, 508, 725, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 238, 0, 0, 245, 0, 0, 0, 352, + 361, 360, 340, 341, 343, 345, 351, 358, 364, 337, + 346, 0, 0, 610, 0, 0, 0, 266, 322, 273, + 265, 581, 0, 0, 0, 0, 0, 0, 597, 0, + 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2882, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 403, 258, 0, 454, 0, 0, 0, 630, 0, 0, + 0, 0, 0, 0, 0, 366, 0, 331, 197, 225, + 0, 0, 413, 462, 474, 0, 0, 0, 254, 0, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 0, 0, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 590, + 591, 257, 653, 228, 623, 220, 0, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 356, 357, + 281, 308, 448, 376, 449, 307, 309, 405, 404, 406, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 0, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 0, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 0, 0, 426, 473, + 240, 607, 497, 199, 0, 0, 0, 0, 255, 256, + 0, 576, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 0, + 0, 0, 0, 0, 399, 0, 592, 593, 673, 385, + 487, 604, 336, 350, 353, 342, 362, 0, 363, 338, + 339, 344, 347, 348, 349, 354, 355, 359, 365, 249, + 210, 391, 400, 579, 313, 216, 217, 218, 525, 526, + 527, 528, 620, 621, 625, 205, 463, 464, 465, 466, + 293, 615, 310, 469, 468, 332, 333, 380, 450, 541, + 543, 554, 558, 560, 562, 568, 571, 542, 544, 555, + 559, 561, 563, 569, 572, 531, 533, 535, 537, 550, + 549, 546, 574, 575, 552, 557, 536, 548, 553, 566, + 573, 570, 530, 534, 538, 547, 565, 564, 545, 556, + 567, 551, 539, 532, 540, 0, 196, 221, 369, 0, + 455, 289, 651, 619, 485, 614, 206, 223, 0, 263, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 302, 303, 445, 446, 315, 316, 647, + 648, 301, 601, 634, 598, 646, 628, 439, 379, 0, + 0, 382, 282, 306, 321, 0, 618, 503, 227, 467, + 291, 251, 0, 0, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 397, 0, + 377, 577, 578, 317, 0, 0, 0, 529, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 0, 0, 0, 0, 271, 0, 0, + 0, 0, 367, 268, 0, 0, 204, 506, 0, 431, + 0, 203, 0, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 0, 371, 0, + 0, 498, 402, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 248, 326, 202, 414, 499, 287, 0, 0, + 0, 0, 0, 508, 725, 0, 0, 0, 0, 2866, + 0, 0, 0, 0, 238, 0, 0, 245, 2867, 0, + 0, 352, 361, 360, 340, 341, 343, 345, 351, 358, + 364, 337, 346, 0, 0, 610, 0, 0, 0, 266, + 322, 273, 265, 581, 0, 0, 0, 0, 0, 0, + 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 276, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 298, 0, 403, 258, 0, 454, 0, 0, 0, 630, + 0, 0, 0, 0, 0, 0, 0, 366, 0, 331, + 197, 225, 0, 0, 413, 462, 474, 0, 0, 0, + 254, 0, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 0, 0, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 590, 591, 257, 653, 228, 623, 220, 0, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 356, 357, 281, 308, 448, 376, 449, 307, 309, 405, + 404, 406, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 0, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 0, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 0, 0, + 426, 473, 240, 607, 497, 199, 0, 0, 0, 0, + 255, 256, 0, 576, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, - 649, 508, 514, 509, 510, 511, 512, 513, 0, 515, - 0, 0, 0, 0, 0, 398, 0, 591, 592, 672, - 384, 486, 603, 335, 349, 352, 341, 361, 0, 362, - 337, 338, 343, 346, 347, 348, 353, 354, 358, 364, - 249, 210, 390, 399, 578, 312, 216, 217, 218, 524, - 525, 526, 527, 619, 620, 624, 205, 462, 463, 464, - 465, 292, 614, 309, 468, 467, 331, 332, 379, 449, - 540, 542, 553, 557, 559, 561, 567, 570, 541, 543, - 554, 558, 560, 562, 568, 571, 530, 532, 534, 536, - 549, 548, 545, 573, 574, 551, 556, 535, 547, 552, - 565, 572, 569, 529, 533, 537, 546, 564, 563, 544, - 555, 566, 550, 538, 531, 539, 0, 196, 221, 368, - 0, 454, 288, 650, 618, 484, 613, 206, 223, 0, - 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 198, 200, 209, 222, 232, 236, 243, 261, - 276, 278, 285, 298, 310, 318, 319, 322, 328, 380, - 386, 387, 388, 389, 409, 410, 411, 414, 417, 418, - 421, 423, 424, 427, 431, 435, 436, 437, 439, 441, - 443, 455, 460, 474, 475, 476, 477, 478, 481, 482, - 488, 489, 490, 491, 492, 500, 501, 516, 586, 588, - 605, 625, 632, 480, 301, 302, 444, 445, 314, 315, - 646, 647, 300, 600, 633, 597, 645, 627, 438, 378, - 0, 0, 381, 281, 305, 320, 0, 617, 502, 227, - 466, 290, 251, 0, 0, 211, 246, 230, 259, 274, - 277, 324, 391, 400, 429, 434, 296, 271, 244, 459, - 241, 485, 519, 520, 521, 523, 395, 266, 433, 396, - 0, 376, 576, 577, 316, 0, 0, 0, 528, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 416, 0, 0, 0, 0, 0, 0, 0, 270, 0, - 0, 0, 0, 366, 267, 0, 0, 204, 505, 0, - 430, 0, 203, 0, 487, 252, 377, 374, 583, 282, - 273, 269, 250, 317, 385, 428, 518, 422, 0, 370, - 0, 0, 497, 401, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 323, 248, 325, 202, 413, 498, 286, 0, - 0, 0, 1753, 0, 507, 724, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 238, 0, 0, 245, 0, - 0, 0, 351, 360, 359, 339, 340, 342, 344, 350, - 357, 363, 336, 345, 0, 0, 609, 0, 0, 0, - 265, 321, 272, 264, 580, 0, 0, 0, 0, 0, - 0, 596, 0, 0, 229, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 275, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 297, 0, 402, 257, 0, 453, 0, 0, 0, - 629, 0, 0, 0, 3726, 0, 0, 0, 365, 0, - 330, 197, 225, 0, 0, 412, 461, 473, 0, 0, - 0, 253, 0, 471, 426, 604, 233, 284, 458, 432, - 469, 440, 287, 0, 0, 470, 372, 585, 450, 601, - 630, 631, 263, 406, 615, 522, 623, 648, 226, 260, - 420, 506, 607, 494, 397, 581, 582, 329, 493, 295, - 201, 369, 636, 224, 479, 371, 242, 231, 587, 612, - 299, 289, 456, 643, 213, 517, 598, 239, 483, 0, - 0, 651, 247, 504, 610, 599, 215, 594, 503, 393, - 326, 327, 214, 0, 457, 268, 293, 0, 0, 258, - 415, 589, 590, 256, 652, 228, 622, 220, 0, 621, - 408, 584, 595, 394, 383, 219, 593, 392, 382, 334, - 355, 356, 280, 307, 447, 375, 448, 306, 308, 404, - 403, 405, 207, 608, 626, 0, 208, 0, 499, 611, - 653, 452, 212, 234, 235, 237, 0, 279, 283, 291, - 294, 303, 304, 313, 367, 419, 446, 442, 451, 0, - 579, 602, 616, 628, 634, 635, 637, 638, 639, 640, - 641, 644, 642, 407, 311, 495, 333, 373, 0, 0, - 425, 472, 240, 606, 496, 199, 0, 0, 0, 0, - 254, 255, 0, 575, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 654, 655, 656, 657, 658, 659, 660, - 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, - 671, 649, 508, 514, 509, 510, 511, 512, 513, 0, - 515, 0, 0, 0, 0, 0, 398, 0, 591, 592, - 672, 384, 486, 603, 335, 349, 352, 341, 361, 0, - 362, 337, 338, 343, 346, 347, 348, 353, 354, 358, - 364, 249, 210, 390, 399, 578, 312, 216, 217, 218, - 524, 525, 526, 527, 619, 620, 624, 205, 462, 463, - 464, 465, 292, 614, 309, 468, 467, 331, 332, 379, - 449, 540, 542, 553, 557, 559, 561, 567, 570, 541, - 543, 554, 558, 560, 562, 568, 571, 530, 532, 534, - 536, 549, 548, 545, 573, 574, 551, 556, 535, 547, - 552, 565, 572, 569, 529, 533, 537, 546, 564, 563, - 544, 555, 566, 550, 538, 531, 539, 0, 196, 221, - 368, 0, 454, 288, 650, 618, 484, 613, 206, 223, - 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 0, 0, 0, 0, 0, 399, 0, 592, 593, + 673, 385, 487, 604, 336, 350, 353, 342, 362, 0, + 363, 338, 339, 344, 347, 348, 349, 354, 355, 359, + 365, 249, 210, 391, 400, 579, 313, 216, 217, 218, + 525, 526, 527, 528, 620, 621, 625, 205, 463, 464, + 465, 466, 293, 615, 310, 469, 468, 332, 333, 380, + 450, 541, 543, 554, 558, 560, 562, 568, 571, 542, + 544, 555, 559, 561, 563, 569, 572, 531, 533, 535, + 537, 550, 549, 546, 574, 575, 552, 557, 536, 548, + 553, 566, 573, 570, 530, 534, 538, 547, 565, 564, + 545, 556, 567, 551, 539, 532, 540, 0, 196, 221, + 369, 0, 455, 289, 651, 619, 485, 614, 206, 223, + 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, 236, 243, - 261, 276, 278, 285, 298, 310, 318, 319, 322, 328, - 380, 386, 387, 388, 389, 409, 410, 411, 414, 417, - 418, 421, 423, 424, 427, 431, 435, 436, 437, 439, - 441, 443, 455, 460, 474, 475, 476, 477, 478, 481, - 482, 488, 489, 490, 491, 492, 500, 501, 516, 586, - 588, 605, 625, 632, 480, 301, 302, 444, 445, 314, - 315, 646, 647, 300, 600, 633, 597, 645, 627, 438, - 378, 0, 0, 381, 281, 305, 320, 0, 617, 502, - 227, 466, 290, 251, 0, 0, 211, 246, 230, 259, - 274, 277, 324, 391, 400, 429, 434, 296, 271, 244, - 459, 241, 485, 519, 520, 521, 523, 395, 266, 433, - 396, 0, 376, 576, 577, 316, 0, 0, 0, 528, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 416, 0, 0, 0, 0, 0, 0, 0, 270, - 0, 0, 0, 0, 366, 267, 0, 0, 204, 505, - 0, 430, 0, 203, 0, 487, 252, 377, 374, 583, - 282, 273, 269, 250, 317, 385, 428, 518, 422, 0, - 370, 0, 0, 497, 401, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 323, 248, 325, 202, 413, 498, 286, - 0, 0, 0, 0, 2132, 507, 724, 0, 0, 0, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 302, 303, 445, 446, 315, + 316, 647, 648, 301, 601, 634, 598, 646, 628, 439, + 379, 0, 0, 382, 282, 306, 321, 0, 618, 503, + 227, 467, 291, 251, 0, 0, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 397, 0, 377, 577, 578, 317, 0, 0, 0, 529, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 0, 0, 0, 0, 0, 271, + 1800, 0, 0, 0, 367, 268, 0, 0, 204, 506, + 0, 431, 0, 203, 0, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 0, + 371, 0, 0, 498, 402, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 248, 326, 202, 414, 499, 287, + 0, 0, 0, 0, 1799, 508, 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, - 0, 0, 0, 351, 360, 359, 339, 340, 342, 344, - 350, 357, 363, 336, 345, 0, 0, 609, 0, 0, - 0, 265, 321, 272, 264, 580, 0, 0, 0, 0, - 0, 0, 596, 0, 0, 229, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2133, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 297, 0, 402, 257, 0, 453, 0, 0, - 0, 629, 0, 0, 0, 0, 0, 0, 0, 365, - 0, 330, 197, 225, 0, 0, 412, 461, 473, 0, - 0, 0, 253, 0, 471, 426, 604, 233, 284, 458, - 432, 469, 440, 287, 0, 0, 470, 372, 585, 450, - 601, 630, 631, 263, 406, 615, 522, 623, 648, 226, - 260, 420, 506, 607, 494, 397, 581, 582, 329, 493, - 295, 201, 369, 636, 224, 479, 371, 242, 231, 587, - 612, 299, 289, 456, 643, 213, 517, 598, 239, 483, - 0, 0, 651, 247, 504, 610, 599, 215, 594, 503, - 393, 326, 327, 214, 0, 457, 268, 293, 0, 0, - 258, 415, 589, 590, 256, 652, 228, 622, 220, 0, - 621, 408, 584, 595, 394, 383, 219, 593, 392, 382, - 334, 355, 356, 280, 307, 447, 375, 448, 306, 308, - 404, 403, 405, 207, 608, 626, 0, 208, 0, 499, - 611, 653, 452, 212, 234, 235, 237, 0, 279, 283, - 291, 294, 303, 304, 313, 367, 419, 446, 442, 451, - 0, 579, 602, 616, 628, 634, 635, 637, 638, 639, - 640, 641, 644, 642, 407, 311, 495, 333, 373, 0, - 0, 425, 472, 240, 606, 496, 199, 0, 0, 0, - 0, 254, 255, 0, 575, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 654, 655, 656, 657, 658, 659, + 0, 0, 0, 352, 361, 360, 340, 341, 343, 345, + 351, 358, 364, 337, 346, 0, 0, 610, 0, 0, + 0, 266, 322, 273, 265, 581, 0, 0, 0, 0, + 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 298, 0, 403, 258, 0, 454, 0, 0, + 0, 630, 0, 0, 0, 0, 0, 0, 0, 366, + 0, 331, 197, 225, 0, 0, 413, 462, 474, 0, + 0, 0, 254, 0, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 0, 0, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 590, 591, 257, 653, 228, 623, 220, + 0, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 356, 357, 281, 308, 448, 376, 449, 307, + 309, 405, 404, 406, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 0, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 0, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 0, 0, 426, 473, 240, 607, 497, 199, 0, 0, + 0, 0, 255, 256, 0, 576, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, - 670, 671, 649, 508, 514, 509, 510, 511, 512, 513, - 0, 515, 0, 0, 0, 0, 0, 398, 0, 591, - 592, 672, 384, 486, 603, 335, 349, 352, 341, 361, - 0, 362, 337, 338, 343, 346, 347, 348, 353, 354, - 358, 364, 249, 210, 390, 399, 578, 312, 216, 217, - 218, 524, 525, 526, 527, 619, 620, 624, 205, 462, - 463, 464, 465, 292, 614, 309, 468, 467, 331, 332, - 379, 449, 540, 542, 553, 557, 559, 561, 567, 570, - 541, 543, 554, 558, 560, 562, 568, 571, 530, 532, - 534, 536, 549, 548, 545, 573, 574, 551, 556, 535, - 547, 552, 565, 572, 569, 529, 533, 537, 546, 564, - 563, 544, 555, 566, 550, 538, 531, 539, 0, 196, - 221, 368, 0, 454, 288, 650, 618, 484, 613, 206, - 223, 0, 262, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 209, 222, 232, 236, - 243, 261, 276, 278, 285, 298, 310, 318, 319, 322, - 328, 380, 386, 387, 388, 389, 409, 410, 411, 414, - 417, 418, 421, 423, 424, 427, 431, 435, 436, 437, - 439, 441, 443, 455, 460, 474, 475, 476, 477, 478, - 481, 482, 488, 489, 490, 491, 492, 500, 501, 516, - 586, 588, 605, 625, 632, 480, 301, 302, 444, 445, - 314, 315, 646, 647, 300, 600, 633, 597, 645, 627, - 438, 378, 0, 0, 381, 281, 305, 320, 0, 617, - 502, 227, 466, 290, 251, 0, 0, 211, 246, 230, - 259, 274, 277, 324, 391, 400, 429, 434, 296, 271, - 244, 459, 241, 485, 519, 520, 521, 523, 395, 266, - 433, 396, 0, 376, 576, 577, 316, 0, 0, 0, - 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 416, 0, 0, 0, 0, 0, 0, 0, - 270, 0, 0, 0, 0, 366, 267, 0, 0, 204, - 505, 0, 430, 0, 203, 0, 487, 252, 377, 374, - 583, 282, 273, 269, 250, 317, 385, 428, 518, 422, - 0, 370, 0, 0, 497, 401, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 323, 248, 325, 202, 413, 498, - 286, 0, 0, 0, 0, 2879, 507, 724, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, - 245, 0, 0, 0, 351, 360, 359, 339, 340, 342, - 344, 350, 357, 363, 336, 345, 0, 0, 609, 0, - 0, 0, 265, 321, 272, 264, 580, 0, 0, 0, - 0, 0, 0, 596, 0, 0, 229, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 275, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2880, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 297, 0, 402, 257, 0, 453, 0, - 0, 0, 629, 0, 0, 0, 0, 0, 0, 0, - 365, 0, 330, 197, 225, 0, 0, 412, 461, 473, - 0, 0, 0, 253, 0, 471, 426, 604, 233, 284, - 458, 432, 469, 440, 287, 0, 0, 470, 372, 585, - 450, 601, 630, 631, 263, 406, 615, 522, 623, 648, - 226, 260, 420, 506, 607, 494, 397, 581, 582, 329, - 493, 295, 201, 369, 636, 224, 479, 371, 242, 231, - 587, 612, 299, 289, 456, 643, 213, 517, 598, 239, - 483, 0, 0, 651, 247, 504, 610, 599, 215, 594, - 503, 393, 326, 327, 214, 0, 457, 268, 293, 0, - 0, 258, 415, 589, 590, 256, 652, 228, 622, 220, - 0, 621, 408, 584, 595, 394, 383, 219, 593, 392, - 382, 334, 355, 356, 280, 307, 447, 375, 448, 306, - 308, 404, 403, 405, 207, 608, 626, 0, 208, 0, - 499, 611, 653, 452, 212, 234, 235, 237, 0, 279, - 283, 291, 294, 303, 304, 313, 367, 419, 446, 442, - 451, 0, 579, 602, 616, 628, 634, 635, 637, 638, - 639, 640, 641, 644, 642, 407, 311, 495, 333, 373, - 0, 0, 425, 472, 240, 606, 496, 199, 0, 0, - 0, 0, 254, 255, 0, 575, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 654, 655, 656, 657, 658, - 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, - 669, 670, 671, 649, 508, 514, 509, 510, 511, 512, - 513, 0, 515, 0, 0, 0, 0, 0, 398, 0, - 591, 592, 672, 384, 486, 603, 335, 349, 352, 341, - 361, 0, 362, 337, 338, 343, 346, 347, 348, 353, - 354, 358, 364, 249, 210, 390, 399, 578, 312, 216, - 217, 218, 524, 525, 526, 527, 619, 620, 624, 205, - 462, 463, 464, 465, 292, 614, 309, 468, 467, 331, - 332, 379, 449, 540, 542, 553, 557, 559, 561, 567, - 570, 541, 543, 554, 558, 560, 562, 568, 571, 530, - 532, 534, 536, 549, 548, 545, 573, 574, 551, 556, - 535, 547, 552, 565, 572, 569, 529, 533, 537, 546, - 564, 563, 544, 555, 566, 550, 538, 531, 539, 0, - 196, 221, 368, 0, 454, 288, 650, 618, 484, 613, - 206, 223, 0, 262, 0, 0, 0, 0, 0, 0, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 0, 0, 0, 0, 0, 399, 0, + 592, 593, 673, 385, 487, 604, 336, 350, 353, 342, + 362, 0, 363, 338, 339, 344, 347, 348, 349, 354, + 355, 359, 365, 249, 210, 391, 400, 579, 313, 216, + 217, 218, 525, 526, 527, 528, 620, 621, 625, 205, + 463, 464, 465, 466, 293, 615, 310, 469, 468, 332, + 333, 380, 450, 541, 543, 554, 558, 560, 562, 568, + 571, 542, 544, 555, 559, 561, 563, 569, 572, 531, + 533, 535, 537, 550, 549, 546, 574, 575, 552, 557, + 536, 548, 553, 566, 573, 570, 530, 534, 538, 547, + 565, 564, 545, 556, 567, 551, 539, 532, 540, 0, + 196, 221, 369, 0, 455, 289, 651, 619, 485, 614, + 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, - 236, 243, 261, 276, 278, 285, 298, 310, 318, 319, - 322, 328, 380, 386, 387, 388, 389, 409, 410, 411, - 414, 417, 418, 421, 423, 424, 427, 431, 435, 436, - 437, 439, 441, 443, 455, 460, 474, 475, 476, 477, - 478, 481, 482, 488, 489, 490, 491, 492, 500, 501, - 516, 586, 588, 605, 625, 632, 480, 301, 302, 444, - 445, 314, 315, 646, 647, 300, 600, 633, 597, 645, - 627, 438, 378, 0, 0, 381, 281, 305, 320, 0, - 617, 502, 227, 466, 290, 251, 0, 0, 211, 246, - 230, 259, 274, 277, 324, 391, 400, 429, 434, 296, - 271, 244, 459, 241, 485, 519, 520, 521, 523, 395, - 266, 433, 396, 0, 376, 576, 577, 316, 0, 0, - 0, 528, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 416, 0, 0, 0, 0, 0, 0, - 0, 270, 0, 0, 0, 0, 366, 267, 0, 0, - 204, 505, 0, 430, 0, 203, 0, 487, 252, 377, - 374, 583, 282, 273, 269, 250, 317, 385, 428, 518, - 422, 0, 370, 0, 0, 497, 401, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 323, 248, 325, 202, 413, - 498, 286, 0, 0, 0, 0, 0, 507, 724, 0, - 0, 0, 0, 2864, 0, 0, 0, 0, 238, 0, - 0, 245, 2865, 0, 0, 351, 360, 359, 339, 340, - 342, 344, 350, 357, 363, 336, 345, 0, 0, 609, - 0, 0, 0, 265, 321, 272, 264, 580, 0, 0, - 0, 0, 0, 0, 596, 0, 0, 229, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 275, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 297, 0, 402, 257, 0, 453, - 0, 0, 0, 629, 0, 0, 0, 0, 0, 0, - 0, 365, 0, 330, 197, 225, 0, 0, 412, 461, - 473, 0, 0, 0, 253, 0, 471, 426, 604, 233, - 284, 458, 432, 469, 440, 287, 0, 0, 470, 372, - 585, 450, 601, 630, 631, 263, 406, 615, 522, 623, - 648, 226, 260, 420, 506, 607, 494, 397, 581, 582, - 329, 493, 295, 201, 369, 636, 224, 479, 371, 242, - 231, 587, 612, 299, 289, 456, 643, 213, 517, 598, - 239, 483, 0, 0, 651, 247, 504, 610, 599, 215, - 594, 503, 393, 326, 327, 214, 0, 457, 268, 293, - 0, 0, 258, 415, 589, 590, 256, 652, 228, 622, - 220, 0, 621, 408, 584, 595, 394, 383, 219, 593, - 392, 382, 334, 355, 356, 280, 307, 447, 375, 448, - 306, 308, 404, 403, 405, 207, 608, 626, 0, 208, - 0, 499, 611, 653, 452, 212, 234, 235, 237, 0, - 279, 283, 291, 294, 303, 304, 313, 367, 419, 446, - 442, 451, 0, 579, 602, 616, 628, 634, 635, 637, - 638, 639, 640, 641, 644, 642, 407, 311, 495, 333, - 373, 0, 0, 425, 472, 240, 606, 496, 199, 0, - 0, 0, 0, 254, 255, 0, 575, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 654, 655, 656, 657, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 302, 303, 445, + 446, 315, 316, 647, 648, 301, 601, 634, 598, 646, + 628, 439, 379, 0, 0, 382, 282, 306, 321, 0, + 618, 503, 227, 467, 291, 251, 0, 0, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 397, 0, 377, 577, 578, 317, 0, 0, + 0, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 0, 0, 0, + 0, 271, 0, 0, 0, 0, 367, 268, 0, 0, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 0, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 0, 0, 0, 0, 508, 727, 728, + 729, 0, 0, 0, 0, 0, 0, 0, 238, 0, + 0, 245, 0, 0, 0, 352, 361, 360, 340, 341, + 343, 345, 351, 358, 364, 337, 346, 0, 0, 610, + 0, 0, 0, 266, 322, 273, 265, 581, 0, 0, + 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 298, 0, 403, 258, 0, 454, + 0, 0, 0, 630, 0, 0, 0, 0, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 254, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 590, 591, 257, 653, 228, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 356, 357, 281, 308, 448, 376, + 449, 307, 309, 405, 404, 406, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 199, + 0, 0, 0, 0, 255, 256, 0, 576, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, - 668, 669, 670, 671, 649, 508, 514, 509, 510, 511, - 512, 513, 0, 515, 0, 0, 0, 0, 0, 398, - 0, 591, 592, 672, 384, 486, 603, 335, 349, 352, - 341, 361, 0, 362, 337, 338, 343, 346, 347, 348, - 353, 354, 358, 364, 249, 210, 390, 399, 578, 312, - 216, 217, 218, 524, 525, 526, 527, 619, 620, 624, - 205, 462, 463, 464, 465, 292, 614, 309, 468, 467, - 331, 332, 379, 449, 540, 542, 553, 557, 559, 561, - 567, 570, 541, 543, 554, 558, 560, 562, 568, 571, - 530, 532, 534, 536, 549, 548, 545, 573, 574, 551, - 556, 535, 547, 552, 565, 572, 569, 529, 533, 537, - 546, 564, 563, 544, 555, 566, 550, 538, 531, 539, - 0, 196, 221, 368, 0, 454, 288, 650, 618, 484, - 613, 206, 223, 0, 262, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, - 232, 236, 243, 261, 276, 278, 285, 298, 310, 318, - 319, 322, 328, 380, 386, 387, 388, 389, 409, 410, - 411, 414, 417, 418, 421, 423, 424, 427, 431, 435, - 436, 437, 439, 441, 443, 455, 460, 474, 475, 476, - 477, 478, 481, 482, 488, 489, 490, 491, 492, 500, - 501, 516, 586, 588, 605, 625, 632, 480, 301, 302, - 444, 445, 314, 315, 646, 647, 300, 600, 633, 597, - 645, 627, 438, 378, 0, 0, 381, 281, 305, 320, - 0, 617, 502, 227, 466, 290, 251, 0, 0, 211, - 246, 230, 259, 274, 277, 324, 391, 400, 429, 434, - 296, 271, 244, 459, 241, 485, 519, 520, 521, 523, - 395, 266, 433, 396, 0, 376, 576, 577, 316, 0, - 0, 0, 528, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 416, 0, 0, 0, 0, 0, - 0, 0, 270, 1799, 0, 0, 0, 366, 267, 0, - 0, 204, 505, 0, 430, 0, 203, 0, 487, 252, - 377, 374, 583, 282, 273, 269, 250, 317, 385, 428, - 518, 422, 0, 370, 0, 0, 497, 401, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 323, 248, 325, 202, - 413, 498, 286, 0, 0, 0, 0, 1798, 507, 724, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, - 0, 0, 245, 0, 0, 0, 351, 360, 359, 339, - 340, 342, 344, 350, 357, 363, 336, 345, 0, 0, - 609, 0, 0, 0, 265, 321, 272, 264, 580, 0, - 0, 0, 0, 0, 0, 596, 0, 0, 229, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 275, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 297, 0, 402, 257, 0, - 453, 0, 0, 0, 629, 0, 0, 0, 0, 0, - 0, 0, 365, 0, 330, 197, 225, 0, 0, 412, - 461, 473, 0, 0, 0, 253, 0, 471, 426, 604, - 233, 284, 458, 432, 469, 440, 287, 0, 0, 470, - 372, 585, 450, 601, 630, 631, 263, 406, 615, 522, - 623, 648, 226, 260, 420, 506, 607, 494, 397, 581, - 582, 329, 493, 295, 201, 369, 636, 224, 479, 371, - 242, 231, 587, 612, 299, 289, 456, 643, 213, 517, - 598, 239, 483, 0, 0, 651, 247, 504, 610, 599, - 215, 594, 503, 393, 326, 327, 214, 0, 457, 268, - 293, 0, 0, 258, 415, 589, 590, 256, 652, 228, - 622, 220, 0, 621, 408, 584, 595, 394, 383, 219, - 593, 392, 382, 334, 355, 356, 280, 307, 447, 375, - 448, 306, 308, 404, 403, 405, 207, 608, 626, 0, - 208, 0, 499, 611, 653, 452, 212, 234, 235, 237, - 0, 279, 283, 291, 294, 303, 304, 313, 367, 419, - 446, 442, 451, 0, 579, 602, 616, 628, 634, 635, - 637, 638, 639, 640, 641, 644, 642, 407, 311, 495, - 333, 373, 0, 0, 425, 472, 240, 606, 496, 199, - 0, 0, 0, 0, 254, 255, 0, 575, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 654, 655, 656, - 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, - 667, 668, 669, 670, 671, 649, 508, 514, 509, 510, - 511, 512, 513, 0, 515, 0, 0, 0, 0, 0, - 398, 0, 591, 592, 672, 384, 486, 603, 335, 349, - 352, 341, 361, 0, 362, 337, 338, 343, 346, 347, - 348, 353, 354, 358, 364, 249, 210, 390, 399, 578, - 312, 216, 217, 218, 524, 525, 526, 527, 619, 620, - 624, 205, 462, 463, 464, 465, 292, 614, 309, 468, - 467, 331, 332, 379, 449, 540, 542, 553, 557, 559, - 561, 567, 570, 541, 543, 554, 558, 560, 562, 568, - 571, 530, 532, 534, 536, 549, 548, 545, 573, 574, - 551, 556, 535, 547, 552, 565, 572, 569, 529, 533, - 537, 546, 564, 563, 544, 555, 566, 550, 538, 531, - 539, 0, 196, 221, 368, 0, 454, 288, 650, 618, - 484, 613, 206, 223, 0, 262, 0, 0, 0, 0, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 0, 0, 0, 0, 0, + 399, 0, 592, 593, 673, 385, 487, 604, 336, 350, + 353, 342, 362, 0, 363, 338, 339, 344, 347, 348, + 349, 354, 355, 359, 365, 249, 210, 391, 400, 579, + 313, 216, 217, 218, 525, 526, 527, 528, 620, 621, + 625, 205, 463, 464, 465, 466, 293, 615, 310, 469, + 468, 332, 333, 380, 450, 541, 543, 554, 558, 560, + 562, 568, 571, 542, 544, 555, 559, 561, 563, 569, + 572, 531, 533, 535, 537, 550, 549, 546, 574, 575, + 552, 557, 536, 548, 553, 566, 573, 570, 530, 534, + 538, 547, 565, 564, 545, 556, 567, 551, 539, 532, + 540, 0, 196, 221, 369, 0, 455, 289, 651, 619, + 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, - 222, 232, 236, 243, 261, 276, 278, 285, 298, 310, - 318, 319, 322, 328, 380, 386, 387, 388, 389, 409, - 410, 411, 414, 417, 418, 421, 423, 424, 427, 431, - 435, 436, 437, 439, 441, 443, 455, 460, 474, 475, - 476, 477, 478, 481, 482, 488, 489, 490, 491, 492, - 500, 501, 516, 586, 588, 605, 625, 632, 480, 301, - 302, 444, 445, 314, 315, 646, 647, 300, 600, 633, - 597, 645, 627, 438, 378, 0, 0, 381, 281, 305, - 320, 0, 617, 502, 227, 466, 290, 251, 0, 0, - 211, 246, 230, 259, 274, 277, 324, 391, 400, 429, - 434, 296, 271, 244, 459, 241, 485, 519, 520, 521, - 523, 395, 266, 433, 396, 0, 376, 576, 577, 316, - 0, 0, 0, 528, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 416, 0, 0, 0, 0, - 0, 0, 0, 270, 0, 0, 0, 0, 366, 267, - 0, 0, 204, 505, 0, 430, 0, 203, 0, 487, - 252, 377, 374, 583, 282, 273, 269, 250, 317, 385, - 428, 518, 422, 0, 370, 0, 0, 497, 401, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 323, 248, 325, - 202, 413, 498, 286, 0, 0, 0, 0, 0, 507, - 726, 727, 728, 0, 0, 0, 0, 0, 0, 0, - 238, 0, 0, 245, 0, 0, 0, 351, 360, 359, - 339, 340, 342, 344, 350, 357, 363, 336, 345, 0, - 0, 609, 0, 0, 0, 265, 321, 272, 264, 580, - 0, 0, 0, 0, 0, 0, 596, 0, 0, 229, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 275, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 297, 0, 402, 257, - 0, 453, 0, 0, 0, 629, 0, 0, 0, 0, - 0, 0, 0, 365, 0, 330, 197, 225, 0, 0, - 412, 461, 473, 0, 0, 0, 253, 0, 471, 426, - 604, 233, 284, 458, 432, 469, 440, 287, 0, 0, - 470, 372, 585, 450, 601, 630, 631, 263, 406, 615, - 522, 623, 648, 226, 260, 420, 506, 607, 494, 397, - 581, 582, 329, 493, 295, 201, 369, 636, 224, 479, - 371, 242, 231, 587, 612, 299, 289, 456, 643, 213, - 517, 598, 239, 483, 0, 0, 651, 247, 504, 610, - 599, 215, 594, 503, 393, 326, 327, 214, 0, 457, - 268, 293, 0, 0, 258, 415, 589, 590, 256, 652, - 228, 622, 220, 0, 621, 408, 584, 595, 394, 383, - 219, 593, 392, 382, 334, 355, 356, 280, 307, 447, - 375, 448, 306, 308, 404, 403, 405, 207, 608, 626, - 0, 208, 0, 499, 611, 653, 452, 212, 234, 235, - 237, 0, 279, 283, 291, 294, 303, 304, 313, 367, - 419, 446, 442, 451, 0, 579, 602, 616, 628, 634, - 635, 637, 638, 639, 640, 641, 644, 642, 407, 311, - 495, 333, 373, 0, 0, 425, 472, 240, 606, 496, - 199, 0, 0, 0, 0, 254, 255, 0, 575, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 654, 655, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 302, + 303, 445, 446, 315, 316, 647, 648, 301, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 0, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 0, + 0, 0, 0, 271, 0, 0, 0, 0, 367, 268, + 0, 0, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 0, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 0, 0, 0, 0, 508, + 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 238, 0, 0, 245, 0, 0, 0, 352, 361, 360, + 340, 341, 343, 345, 351, 358, 364, 337, 346, 0, + 0, 610, 0, 0, 0, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 0, 0, 0, 630, 0, 0, 0, 4073, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 254, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 590, 591, 257, + 653, 228, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 356, 357, 281, 308, + 448, 376, 449, 307, 309, 405, 404, 406, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 199, 0, 0, 0, 0, 255, 256, 0, 576, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, - 666, 667, 668, 669, 670, 671, 649, 508, 514, 509, - 510, 511, 512, 513, 0, 515, 0, 0, 0, 0, - 0, 398, 0, 591, 592, 672, 384, 486, 603, 335, - 349, 352, 341, 361, 0, 362, 337, 338, 343, 346, - 347, 348, 353, 354, 358, 364, 249, 210, 390, 399, - 578, 312, 216, 217, 218, 524, 525, 526, 527, 619, - 620, 624, 205, 462, 463, 464, 465, 292, 614, 309, - 468, 467, 331, 332, 379, 449, 540, 542, 553, 557, - 559, 561, 567, 570, 541, 543, 554, 558, 560, 562, - 568, 571, 530, 532, 534, 536, 549, 548, 545, 573, - 574, 551, 556, 535, 547, 552, 565, 572, 569, 529, - 533, 537, 546, 564, 563, 544, 555, 566, 550, 538, - 531, 539, 0, 196, 221, 368, 0, 454, 288, 650, - 618, 484, 613, 206, 223, 0, 262, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, - 209, 222, 232, 236, 243, 261, 276, 278, 285, 298, - 310, 318, 319, 322, 328, 380, 386, 387, 388, 389, - 409, 410, 411, 414, 417, 418, 421, 423, 424, 427, - 431, 435, 436, 437, 439, 441, 443, 455, 460, 474, - 475, 476, 477, 478, 481, 482, 488, 489, 490, 491, - 492, 500, 501, 516, 586, 588, 605, 625, 632, 480, - 301, 302, 444, 445, 314, 315, 646, 647, 300, 600, - 633, 597, 645, 627, 438, 378, 0, 0, 381, 281, - 305, 320, 0, 617, 502, 227, 466, 290, 251, 0, - 0, 211, 246, 230, 259, 274, 277, 324, 391, 400, - 429, 434, 296, 271, 244, 459, 241, 485, 519, 520, - 521, 523, 395, 266, 433, 396, 0, 376, 576, 577, - 316, 0, 0, 0, 528, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 416, 0, 0, 0, - 0, 0, 0, 0, 270, 0, 0, 0, 0, 366, - 267, 0, 0, 204, 505, 0, 430, 0, 203, 0, - 487, 252, 377, 374, 583, 282, 273, 269, 250, 317, - 385, 428, 518, 422, 0, 370, 0, 0, 497, 401, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 323, 248, - 325, 202, 413, 498, 286, 0, 0, 0, 0, 0, - 507, 724, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 238, 0, 0, 245, 0, 0, 0, 351, 360, - 359, 339, 340, 342, 344, 350, 357, 363, 336, 345, - 0, 0, 609, 0, 0, 0, 265, 321, 272, 264, - 580, 0, 0, 0, 0, 0, 0, 596, 0, 0, - 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 275, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 297, 0, 402, - 257, 0, 453, 0, 0, 0, 629, 0, 0, 0, - 4070, 0, 0, 0, 365, 0, 330, 197, 225, 0, - 0, 412, 461, 473, 0, 0, 0, 253, 0, 471, - 426, 604, 233, 284, 458, 432, 469, 440, 287, 0, - 0, 470, 372, 585, 450, 601, 630, 631, 263, 406, - 615, 522, 623, 648, 226, 260, 420, 506, 607, 494, - 397, 581, 582, 329, 493, 295, 201, 369, 636, 224, - 479, 371, 242, 231, 587, 612, 299, 289, 456, 643, - 213, 517, 598, 239, 483, 0, 0, 651, 247, 504, - 610, 599, 215, 594, 503, 393, 326, 327, 214, 0, - 457, 268, 293, 0, 0, 258, 415, 589, 590, 256, - 652, 228, 622, 220, 0, 621, 408, 584, 595, 394, - 383, 219, 593, 392, 382, 334, 355, 356, 280, 307, - 447, 375, 448, 306, 308, 404, 403, 405, 207, 608, - 626, 0, 208, 0, 499, 611, 653, 452, 212, 234, - 235, 237, 0, 279, 283, 291, 294, 303, 304, 313, - 367, 419, 446, 442, 451, 0, 579, 602, 616, 628, - 634, 635, 637, 638, 639, 640, 641, 644, 642, 407, - 311, 495, 333, 373, 0, 0, 425, 472, 240, 606, - 496, 199, 0, 0, 0, 0, 254, 255, 0, 575, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 654, - 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, - 665, 666, 667, 668, 669, 670, 671, 649, 508, 514, - 509, 510, 511, 512, 513, 0, 515, 0, 0, 0, - 0, 0, 398, 0, 591, 592, 672, 384, 486, 603, - 335, 349, 352, 341, 361, 0, 362, 337, 338, 343, - 346, 347, 348, 353, 354, 358, 364, 249, 210, 390, - 399, 578, 312, 216, 217, 218, 524, 525, 526, 527, - 619, 620, 624, 205, 462, 463, 464, 465, 292, 614, - 309, 468, 467, 331, 332, 379, 449, 540, 542, 553, - 557, 559, 561, 567, 570, 541, 543, 554, 558, 560, - 562, 568, 571, 530, 532, 534, 536, 549, 548, 545, - 573, 574, 551, 556, 535, 547, 552, 565, 572, 569, - 529, 533, 537, 546, 564, 563, 544, 555, 566, 550, - 538, 531, 539, 0, 196, 221, 368, 0, 454, 288, - 650, 618, 484, 613, 206, 223, 0, 262, 0, 0, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 0, 0, 0, + 0, 0, 399, 0, 592, 593, 673, 385, 487, 604, + 336, 350, 353, 342, 362, 0, 363, 338, 339, 344, + 347, 348, 349, 354, 355, 359, 365, 249, 210, 391, + 400, 579, 313, 216, 217, 218, 525, 526, 527, 528, + 620, 621, 625, 205, 463, 464, 465, 466, 293, 615, + 310, 469, 468, 332, 333, 380, 450, 541, 543, 554, + 558, 560, 562, 568, 571, 542, 544, 555, 559, 561, + 563, 569, 572, 531, 533, 535, 537, 550, 549, 546, + 574, 575, 552, 557, 536, 548, 553, 566, 573, 570, + 530, 534, 538, 547, 565, 564, 545, 556, 567, 551, + 539, 532, 540, 0, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 209, 222, 232, 236, 243, 261, 276, 278, 285, - 298, 310, 318, 319, 322, 328, 380, 386, 387, 388, - 389, 409, 410, 411, 414, 417, 418, 421, 423, 424, - 427, 431, 435, 436, 437, 439, 441, 443, 455, 460, - 474, 475, 476, 477, 478, 481, 482, 488, 489, 490, - 491, 492, 500, 501, 516, 586, 588, 605, 625, 632, - 480, 301, 302, 444, 445, 314, 315, 646, 647, 300, - 600, 633, 597, 645, 627, 438, 378, 0, 0, 381, - 281, 305, 320, 0, 617, 502, 227, 466, 290, 251, - 0, 0, 211, 246, 230, 259, 274, 277, 324, 391, - 400, 429, 434, 296, 271, 244, 459, 241, 485, 519, - 520, 521, 523, 395, 266, 433, 396, 0, 376, 576, - 577, 316, 0, 0, 0, 528, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 416, 0, 0, - 0, 0, 0, 0, 0, 270, 0, 0, 0, 0, - 366, 267, 0, 0, 204, 505, 0, 430, 0, 203, - 0, 487, 252, 377, 374, 583, 282, 273, 269, 250, - 317, 385, 428, 518, 422, 0, 370, 0, 0, 497, - 401, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 323, - 248, 325, 202, 413, 498, 286, 0, 0, 0, 0, - 1961, 507, 194, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 238, 0, 0, 245, 0, 0, 0, 351, - 360, 359, 339, 340, 342, 344, 350, 357, 363, 336, - 345, 0, 0, 609, 0, 0, 0, 265, 321, 272, - 264, 580, 0, 0, 0, 0, 0, 0, 596, 0, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 302, 303, 445, 446, 315, 316, 647, 648, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 0, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 397, 0, 377, 577, + 578, 317, 0, 0, 0, 529, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, + 0, 0, 0, 0, 0, 271, 0, 0, 0, 0, + 367, 268, 0, 0, 204, 506, 0, 431, 0, 203, + 0, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 0, 371, 0, 0, 498, + 402, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 248, 326, 202, 414, 499, 287, 0, 0, 0, 0, + 1962, 508, 194, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 238, 0, 0, 245, 0, 0, 0, 352, + 361, 360, 340, 341, 343, 345, 351, 358, 364, 337, + 346, 0, 0, 610, 0, 0, 0, 266, 322, 273, + 265, 581, 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 275, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 297, 0, - 402, 257, 0, 453, 0, 0, 0, 629, 0, 0, - 0, 0, 0, 0, 0, 365, 0, 330, 197, 225, - 0, 0, 412, 461, 473, 0, 0, 0, 253, 0, - 471, 426, 604, 233, 284, 458, 432, 469, 440, 287, - 0, 0, 470, 372, 585, 450, 601, 630, 631, 263, - 406, 615, 522, 623, 648, 226, 260, 420, 506, 607, - 494, 397, 581, 582, 329, 493, 295, 201, 369, 636, - 224, 479, 371, 242, 231, 587, 612, 299, 289, 456, - 643, 213, 517, 598, 239, 483, 0, 0, 651, 247, - 504, 610, 599, 215, 594, 503, 393, 326, 327, 214, - 0, 457, 268, 293, 0, 0, 258, 415, 589, 590, - 256, 652, 228, 622, 220, 0, 621, 408, 584, 595, - 394, 383, 219, 593, 392, 382, 334, 355, 356, 280, - 307, 447, 375, 448, 306, 308, 404, 403, 405, 207, - 608, 626, 0, 208, 0, 499, 611, 653, 452, 212, - 234, 235, 237, 0, 279, 283, 291, 294, 303, 304, - 313, 367, 419, 446, 442, 451, 0, 579, 602, 616, - 628, 634, 635, 637, 638, 639, 640, 641, 644, 642, - 407, 311, 495, 333, 373, 0, 0, 425, 472, 240, - 606, 496, 199, 0, 0, 0, 0, 254, 255, 0, - 575, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, - 664, 665, 666, 667, 668, 669, 670, 671, 649, 508, - 514, 509, 510, 511, 512, 513, 0, 515, 0, 0, - 0, 0, 0, 398, 0, 591, 592, 672, 384, 486, - 603, 335, 349, 352, 341, 361, 0, 362, 337, 338, - 343, 346, 347, 348, 353, 354, 358, 364, 249, 210, - 390, 399, 578, 312, 216, 217, 218, 524, 525, 526, - 527, 619, 620, 624, 205, 462, 463, 464, 465, 292, - 614, 309, 468, 467, 331, 332, 379, 449, 540, 542, - 553, 557, 559, 561, 567, 570, 541, 543, 554, 558, - 560, 562, 568, 571, 530, 532, 534, 536, 549, 548, - 545, 573, 574, 551, 556, 535, 547, 552, 565, 572, - 569, 529, 533, 537, 546, 564, 563, 544, 555, 566, - 550, 538, 531, 539, 0, 196, 221, 368, 0, 454, - 288, 650, 618, 484, 613, 206, 223, 0, 262, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 198, 200, 209, 222, 232, 236, 243, 261, 276, 278, - 285, 298, 310, 318, 319, 322, 328, 380, 386, 387, - 388, 389, 409, 410, 411, 414, 417, 418, 421, 423, - 424, 427, 431, 435, 436, 437, 439, 441, 443, 455, - 460, 474, 475, 476, 477, 478, 481, 482, 488, 489, - 490, 491, 492, 500, 501, 516, 586, 588, 605, 625, - 632, 480, 301, 302, 444, 445, 314, 315, 646, 647, - 300, 600, 633, 597, 645, 627, 438, 378, 0, 0, - 381, 281, 305, 320, 0, 617, 502, 227, 466, 290, - 251, 0, 0, 211, 246, 230, 259, 274, 277, 324, - 391, 400, 429, 434, 296, 271, 244, 459, 241, 485, - 519, 520, 521, 523, 395, 266, 433, 396, 0, 376, - 576, 577, 316, 0, 0, 0, 528, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 416, 0, - 0, 0, 0, 0, 0, 0, 270, 0, 0, 0, - 0, 366, 267, 0, 0, 204, 505, 0, 430, 0, - 203, 0, 487, 252, 377, 374, 583, 282, 273, 269, - 250, 317, 385, 428, 518, 422, 0, 370, 0, 0, - 497, 401, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 323, 248, 325, 202, 413, 498, 286, 0, 0, 0, - 0, 0, 507, 724, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 238, 0, 0, 245, 0, 0, 0, - 351, 360, 359, 339, 340, 342, 344, 350, 357, 363, - 336, 345, 0, 0, 609, 0, 0, 0, 265, 321, - 272, 264, 580, 0, 0, 0, 0, 0, 0, 596, - 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 275, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 297, - 0, 402, 257, 0, 453, 0, 0, 0, 629, 0, - 0, 0, 3726, 0, 0, 0, 365, 0, 330, 197, - 225, 0, 0, 412, 461, 473, 0, 0, 0, 253, - 0, 471, 426, 604, 233, 284, 458, 432, 469, 440, - 287, 0, 0, 470, 372, 585, 450, 601, 630, 631, - 263, 406, 615, 522, 623, 648, 226, 260, 420, 506, - 607, 494, 397, 581, 582, 329, 493, 295, 201, 369, - 636, 224, 479, 371, 242, 231, 587, 612, 299, 289, - 456, 643, 213, 517, 598, 239, 483, 0, 0, 651, - 247, 504, 610, 599, 215, 594, 503, 393, 326, 327, - 214, 0, 457, 268, 293, 0, 0, 258, 415, 589, - 590, 256, 652, 228, 622, 220, 0, 621, 408, 584, - 595, 394, 383, 219, 593, 392, 382, 334, 355, 356, - 280, 307, 447, 375, 448, 306, 308, 404, 403, 405, - 207, 608, 626, 0, 208, 0, 499, 611, 653, 452, - 212, 234, 235, 237, 0, 279, 283, 291, 294, 303, - 304, 313, 367, 419, 446, 442, 451, 0, 579, 602, - 616, 628, 634, 635, 637, 638, 639, 640, 641, 644, - 642, 407, 311, 495, 333, 373, 0, 0, 425, 472, - 240, 606, 496, 199, 0, 0, 0, 0, 254, 255, - 0, 575, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 654, 655, 656, 657, 658, 659, 660, 661, 662, - 663, 664, 665, 666, 667, 668, 669, 670, 671, 649, - 508, 514, 509, 510, 511, 512, 513, 0, 515, 0, - 0, 0, 0, 0, 398, 0, 591, 592, 672, 384, - 486, 603, 335, 349, 352, 341, 361, 0, 362, 337, - 338, 343, 346, 347, 348, 353, 354, 358, 364, 249, - 210, 390, 399, 578, 312, 216, 217, 218, 524, 525, - 526, 527, 619, 620, 624, 205, 462, 463, 464, 465, - 292, 614, 309, 468, 467, 331, 332, 379, 449, 540, - 542, 553, 557, 559, 561, 567, 570, 541, 543, 554, - 558, 560, 562, 568, 571, 530, 532, 534, 536, 549, - 548, 545, 573, 574, 551, 556, 535, 547, 552, 565, - 572, 569, 529, 533, 537, 546, 564, 563, 544, 555, - 566, 550, 538, 531, 539, 0, 196, 221, 368, 0, - 454, 288, 650, 618, 484, 613, 206, 223, 0, 262, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 198, 200, 209, 222, 232, 236, 243, 261, 276, - 278, 285, 298, 310, 318, 319, 322, 328, 380, 386, - 387, 388, 389, 409, 410, 411, 414, 417, 418, 421, - 423, 424, 427, 431, 435, 436, 437, 439, 441, 443, - 455, 460, 474, 475, 476, 477, 478, 481, 482, 488, - 489, 490, 491, 492, 500, 501, 516, 586, 588, 605, - 625, 632, 480, 301, 302, 444, 445, 314, 315, 646, - 647, 300, 600, 633, 597, 645, 627, 438, 378, 0, - 0, 381, 281, 305, 320, 0, 617, 502, 227, 466, - 290, 251, 0, 0, 211, 246, 230, 259, 274, 277, - 324, 391, 400, 429, 434, 296, 271, 244, 459, 241, - 485, 519, 520, 521, 523, 395, 266, 433, 396, 0, - 376, 576, 577, 316, 0, 0, 0, 528, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 416, - 0, 0, 0, 0, 0, 0, 0, 270, 0, 0, - 0, 0, 366, 267, 0, 0, 204, 505, 0, 430, - 0, 203, 0, 487, 252, 377, 374, 583, 282, 273, - 269, 250, 317, 385, 428, 518, 422, 0, 370, 0, - 0, 497, 401, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 323, 248, 325, 202, 413, 498, 286, 0, 95, - 0, 0, 0, 507, 724, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 403, 258, 0, 454, 0, 0, 0, 630, 0, 0, + 0, 0, 0, 0, 0, 366, 0, 331, 197, 225, + 0, 0, 413, 462, 474, 0, 0, 0, 254, 0, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 0, 0, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 590, + 591, 257, 653, 228, 623, 220, 0, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 356, 357, + 281, 308, 448, 376, 449, 307, 309, 405, 404, 406, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 0, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 0, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 0, 0, 426, 473, + 240, 607, 497, 199, 0, 0, 0, 0, 255, 256, + 0, 576, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 0, + 0, 0, 0, 0, 399, 0, 592, 593, 673, 385, + 487, 604, 336, 350, 353, 342, 362, 0, 363, 338, + 339, 344, 347, 348, 349, 354, 355, 359, 365, 249, + 210, 391, 400, 579, 313, 216, 217, 218, 525, 526, + 527, 528, 620, 621, 625, 205, 463, 464, 465, 466, + 293, 615, 310, 469, 468, 332, 333, 380, 450, 541, + 543, 554, 558, 560, 562, 568, 571, 542, 544, 555, + 559, 561, 563, 569, 572, 531, 533, 535, 537, 550, + 549, 546, 574, 575, 552, 557, 536, 548, 553, 566, + 573, 570, 530, 534, 538, 547, 565, 564, 545, 556, + 567, 551, 539, 532, 540, 0, 196, 221, 369, 0, + 455, 289, 651, 619, 485, 614, 206, 223, 0, 263, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 302, 303, 445, 446, 315, 316, 647, + 648, 301, 601, 634, 598, 646, 628, 439, 379, 0, + 0, 382, 282, 306, 321, 0, 618, 503, 227, 467, + 291, 251, 0, 0, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 397, 0, + 377, 577, 578, 317, 0, 0, 0, 529, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 0, 0, 0, 0, 271, 0, 0, + 0, 0, 367, 268, 0, 0, 204, 506, 0, 431, + 0, 203, 0, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 0, 371, 0, + 0, 498, 402, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 248, 326, 202, 414, 499, 287, 0, 0, + 0, 0, 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, 0, 0, - 0, 351, 360, 359, 339, 340, 342, 344, 350, 357, - 363, 336, 345, 0, 0, 609, 0, 0, 0, 265, - 321, 272, 264, 580, 0, 0, 0, 0, 0, 0, - 596, 0, 0, 229, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 275, 0, + 0, 352, 361, 360, 340, 341, 343, 345, 351, 358, + 364, 337, 346, 0, 0, 610, 0, 0, 0, 266, + 322, 273, 265, 581, 0, 0, 0, 0, 0, 0, + 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5677,147 +5642,73 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 297, 0, 402, 257, 0, 453, 0, 0, 0, 629, - 0, 0, 0, 0, 0, 0, 0, 365, 0, 330, - 197, 225, 0, 0, 412, 461, 473, 0, 0, 0, - 253, 0, 471, 426, 604, 233, 284, 458, 432, 469, - 440, 287, 0, 0, 470, 372, 585, 450, 601, 630, - 631, 263, 406, 615, 522, 623, 648, 226, 260, 420, - 506, 607, 494, 397, 581, 582, 329, 493, 295, 201, - 369, 636, 224, 479, 371, 242, 231, 587, 612, 299, - 289, 456, 643, 213, 517, 598, 239, 483, 0, 0, - 651, 247, 504, 610, 599, 215, 594, 503, 393, 326, - 327, 214, 0, 457, 268, 293, 0, 0, 258, 415, - 589, 590, 256, 652, 228, 622, 220, 0, 621, 408, - 584, 595, 394, 383, 219, 593, 392, 382, 334, 355, - 356, 280, 307, 447, 375, 448, 306, 308, 404, 403, - 405, 207, 608, 626, 0, 208, 0, 499, 611, 653, - 452, 212, 234, 235, 237, 0, 279, 283, 291, 294, - 303, 304, 313, 367, 419, 446, 442, 451, 0, 579, - 602, 616, 628, 634, 635, 637, 638, 639, 640, 641, - 644, 642, 407, 311, 495, 333, 373, 0, 0, 425, - 472, 240, 606, 496, 199, 0, 0, 0, 0, 254, - 255, 0, 575, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 654, 655, 656, 657, 658, 659, 660, 661, + 298, 0, 403, 258, 0, 454, 0, 0, 0, 630, + 0, 0, 0, 3729, 0, 0, 0, 366, 0, 331, + 197, 225, 0, 0, 413, 462, 474, 0, 0, 0, + 254, 0, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 0, 0, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 590, 591, 257, 653, 228, 623, 220, 0, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 356, 357, 281, 308, 448, 376, 449, 307, 309, 405, + 404, 406, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 0, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 0, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 0, 0, + 426, 473, 240, 607, 497, 199, 0, 0, 0, 0, + 255, 256, 0, 576, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, - 649, 508, 514, 509, 510, 511, 512, 513, 0, 515, - 0, 0, 0, 0, 0, 398, 0, 591, 592, 672, - 384, 486, 603, 335, 349, 352, 341, 361, 0, 362, - 337, 338, 343, 346, 347, 348, 353, 354, 358, 364, - 249, 210, 390, 399, 578, 312, 216, 217, 218, 524, - 525, 526, 527, 619, 620, 624, 205, 462, 463, 464, - 465, 292, 614, 309, 468, 467, 331, 332, 379, 449, - 540, 542, 553, 557, 559, 561, 567, 570, 541, 543, - 554, 558, 560, 562, 568, 571, 530, 532, 534, 536, - 549, 548, 545, 573, 574, 551, 556, 535, 547, 552, - 565, 572, 569, 529, 533, 537, 546, 564, 563, 544, - 555, 566, 550, 538, 531, 539, 0, 196, 221, 368, - 0, 454, 288, 650, 618, 484, 613, 206, 223, 0, - 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 198, 200, 209, 222, 232, 236, 243, 261, - 276, 278, 285, 298, 310, 318, 319, 322, 328, 380, - 386, 387, 388, 389, 409, 410, 411, 414, 417, 418, - 421, 423, 424, 427, 431, 435, 436, 437, 439, 441, - 443, 455, 460, 474, 475, 476, 477, 478, 481, 482, - 488, 489, 490, 491, 492, 500, 501, 516, 586, 588, - 605, 625, 632, 480, 301, 302, 444, 445, 314, 315, - 646, 647, 300, 600, 633, 597, 645, 627, 438, 378, - 0, 0, 381, 281, 305, 320, 0, 617, 502, 227, - 466, 290, 251, 0, 0, 211, 246, 230, 259, 274, - 277, 324, 391, 400, 429, 434, 296, 271, 244, 459, - 241, 485, 519, 520, 521, 523, 395, 266, 433, 396, - 0, 376, 576, 577, 316, 0, 0, 0, 528, 0, - 0, 0, 0, 2427, 0, 0, 0, 0, 0, 0, - 416, 0, 0, 0, 0, 0, 0, 0, 270, 0, - 0, 0, 0, 366, 267, 0, 0, 204, 505, 0, - 430, 0, 203, 0, 487, 252, 377, 374, 583, 282, - 273, 269, 250, 317, 385, 428, 518, 422, 0, 370, - 0, 0, 497, 401, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 323, 248, 325, 202, 413, 498, 286, 0, - 0, 0, 0, 0, 507, 194, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 238, 0, 0, 245, 0, - 0, 0, 351, 360, 359, 339, 340, 342, 344, 350, - 357, 363, 336, 345, 0, 0, 609, 0, 0, 0, - 265, 321, 272, 264, 580, 0, 0, 0, 0, 0, - 0, 596, 0, 0, 229, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 275, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 297, 0, 402, 257, 0, 453, 0, 0, 0, - 629, 0, 0, 0, 0, 0, 0, 0, 365, 0, - 330, 197, 225, 0, 0, 412, 461, 473, 0, 0, - 0, 253, 0, 471, 426, 604, 233, 284, 458, 432, - 469, 440, 287, 0, 0, 470, 372, 585, 450, 601, - 630, 631, 263, 406, 615, 522, 623, 648, 226, 260, - 420, 506, 607, 494, 397, 581, 582, 329, 493, 295, - 201, 369, 636, 224, 479, 371, 242, 231, 587, 612, - 299, 289, 456, 643, 213, 517, 598, 239, 483, 0, - 0, 651, 247, 504, 610, 599, 215, 594, 503, 393, - 326, 327, 214, 0, 457, 268, 293, 0, 0, 258, - 415, 589, 590, 256, 652, 228, 622, 220, 0, 621, - 408, 584, 595, 394, 383, 219, 593, 392, 382, 334, - 355, 356, 280, 307, 447, 375, 448, 306, 308, 404, - 403, 405, 207, 608, 626, 0, 208, 0, 499, 611, - 653, 452, 212, 234, 235, 237, 0, 279, 283, 291, - 294, 303, 304, 313, 367, 419, 446, 442, 451, 0, - 579, 602, 616, 628, 634, 635, 637, 638, 639, 640, - 641, 644, 642, 407, 311, 495, 333, 373, 0, 0, - 425, 472, 240, 606, 496, 199, 0, 0, 0, 0, - 254, 255, 0, 575, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 654, 655, 656, 657, 658, 659, 660, - 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, - 671, 649, 508, 514, 509, 510, 511, 512, 513, 0, - 515, 0, 0, 0, 0, 0, 398, 0, 591, 592, - 672, 384, 486, 603, 335, 349, 352, 341, 361, 0, - 362, 337, 338, 343, 346, 347, 348, 353, 354, 358, - 364, 249, 210, 390, 399, 578, 312, 216, 217, 218, - 524, 525, 526, 527, 619, 620, 624, 205, 462, 463, - 464, 465, 292, 614, 309, 468, 467, 331, 332, 379, - 449, 540, 542, 553, 557, 559, 561, 567, 570, 541, - 543, 554, 558, 560, 562, 568, 571, 530, 532, 534, - 536, 549, 548, 545, 573, 574, 551, 556, 535, 547, - 552, 565, 572, 569, 529, 533, 537, 546, 564, 563, - 544, 555, 566, 550, 538, 531, 539, 0, 196, 221, - 368, 0, 454, 288, 650, 618, 484, 613, 206, 223, - 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 0, 0, 0, 0, 0, 399, 0, 592, 593, + 673, 385, 487, 604, 336, 350, 353, 342, 362, 0, + 363, 338, 339, 344, 347, 348, 349, 354, 355, 359, + 365, 249, 210, 391, 400, 579, 313, 216, 217, 218, + 525, 526, 527, 528, 620, 621, 625, 205, 463, 464, + 465, 466, 293, 615, 310, 469, 468, 332, 333, 380, + 450, 541, 543, 554, 558, 560, 562, 568, 571, 542, + 544, 555, 559, 561, 563, 569, 572, 531, 533, 535, + 537, 550, 549, 546, 574, 575, 552, 557, 536, 548, + 553, 566, 573, 570, 530, 534, 538, 547, 565, 564, + 545, 556, 567, 551, 539, 532, 540, 0, 196, 221, + 369, 0, 455, 289, 651, 619, 485, 614, 206, 223, + 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, 236, 243, - 261, 276, 278, 285, 298, 310, 318, 319, 322, 328, - 380, 386, 387, 388, 389, 409, 410, 411, 414, 417, - 418, 421, 423, 424, 427, 431, 435, 436, 437, 439, - 441, 443, 455, 460, 474, 475, 476, 477, 478, 481, - 482, 488, 489, 490, 491, 492, 500, 501, 516, 586, - 588, 605, 625, 632, 480, 301, 302, 444, 445, 314, - 315, 646, 647, 300, 600, 633, 597, 645, 627, 438, - 378, 0, 0, 381, 281, 305, 320, 0, 617, 502, - 227, 466, 290, 251, 0, 0, 211, 246, 230, 259, - 274, 277, 324, 391, 400, 429, 434, 296, 271, 244, - 459, 241, 485, 519, 520, 521, 523, 395, 266, 433, - 396, 0, 376, 576, 577, 316, 0, 0, 0, 528, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 416, 0, 0, 0, 0, 0, 0, 0, 270, - 0, 0, 0, 0, 366, 267, 0, 0, 204, 505, - 0, 430, 0, 203, 0, 487, 252, 377, 374, 583, - 282, 273, 269, 250, 317, 385, 428, 518, 422, 0, - 370, 0, 0, 497, 401, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 323, 248, 325, 202, 413, 498, 286, - 0, 0, 0, 0, 1780, 507, 724, 0, 0, 0, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 302, 303, 445, 446, 315, + 316, 647, 648, 301, 601, 634, 598, 646, 628, 439, + 379, 0, 0, 382, 282, 306, 321, 0, 618, 503, + 227, 467, 291, 251, 0, 0, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 397, 0, 377, 577, 578, 317, 0, 0, 0, 529, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 0, 0, 0, 0, 0, 271, + 0, 0, 0, 0, 367, 268, 0, 0, 204, 506, + 0, 431, 0, 203, 0, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 0, + 371, 0, 0, 498, 402, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 248, 326, 202, 414, 499, 287, + 0, 95, 0, 0, 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, - 0, 0, 0, 351, 360, 359, 339, 340, 342, 344, - 350, 357, 363, 336, 345, 0, 0, 609, 0, 0, - 0, 265, 321, 272, 264, 580, 0, 0, 0, 0, - 0, 0, 596, 0, 0, 229, 0, 0, 0, 0, + 0, 0, 0, 352, 361, 360, 340, 341, 343, 345, + 351, 358, 364, 337, 346, 0, 0, 610, 0, 0, + 0, 266, 322, 273, 265, 581, 0, 0, 0, 0, + 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5825,147 +5716,73 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 297, 0, 402, 257, 0, 453, 0, 0, - 0, 629, 0, 0, 0, 0, 0, 0, 0, 365, - 0, 330, 197, 225, 0, 0, 412, 461, 473, 0, - 0, 0, 253, 0, 471, 426, 604, 233, 284, 458, - 432, 469, 440, 287, 0, 0, 470, 372, 585, 450, - 601, 630, 631, 263, 406, 615, 522, 623, 648, 226, - 260, 420, 506, 607, 494, 397, 581, 582, 329, 493, - 295, 201, 369, 636, 224, 479, 371, 242, 231, 587, - 612, 299, 289, 456, 643, 213, 517, 598, 239, 483, - 0, 0, 651, 247, 504, 610, 599, 215, 594, 503, - 393, 326, 327, 214, 0, 457, 268, 293, 0, 0, - 258, 415, 589, 590, 256, 652, 228, 622, 220, 0, - 621, 408, 584, 595, 394, 383, 219, 593, 392, 382, - 334, 355, 356, 280, 307, 447, 375, 448, 306, 308, - 404, 403, 405, 207, 608, 626, 0, 208, 0, 499, - 611, 653, 452, 212, 234, 235, 237, 0, 279, 283, - 291, 294, 303, 304, 313, 367, 419, 446, 442, 451, - 0, 579, 602, 616, 628, 634, 635, 637, 638, 639, - 640, 641, 644, 642, 407, 311, 495, 333, 373, 0, - 0, 425, 472, 240, 606, 496, 199, 0, 0, 0, - 0, 254, 255, 0, 575, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 654, 655, 656, 657, 658, 659, + 0, 0, 298, 0, 403, 258, 0, 454, 0, 0, + 0, 630, 0, 0, 0, 0, 0, 0, 0, 366, + 0, 331, 197, 225, 0, 0, 413, 462, 474, 0, + 0, 0, 254, 0, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 0, 0, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 590, 591, 257, 653, 228, 623, 220, + 0, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 356, 357, 281, 308, 448, 376, 449, 307, + 309, 405, 404, 406, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 0, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 0, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 0, 0, 426, 473, 240, 607, 497, 199, 0, 0, + 0, 0, 255, 256, 0, 576, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, - 670, 671, 649, 508, 514, 509, 510, 511, 512, 513, - 0, 515, 0, 0, 0, 0, 0, 398, 0, 591, - 592, 672, 384, 486, 603, 335, 349, 352, 341, 361, - 0, 362, 337, 338, 343, 346, 347, 348, 353, 354, - 358, 364, 249, 210, 390, 399, 578, 312, 216, 217, - 218, 524, 525, 526, 527, 619, 620, 624, 205, 462, - 463, 464, 465, 292, 614, 309, 468, 467, 331, 332, - 379, 449, 540, 542, 553, 557, 559, 561, 567, 570, - 541, 543, 554, 558, 560, 562, 568, 571, 530, 532, - 534, 536, 549, 548, 545, 573, 574, 551, 556, 535, - 547, 552, 565, 572, 569, 529, 533, 537, 546, 564, - 563, 544, 555, 566, 550, 538, 531, 539, 0, 196, - 221, 368, 0, 454, 288, 650, 618, 484, 613, 206, - 223, 0, 262, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 209, 222, 232, 236, - 243, 261, 276, 278, 285, 298, 310, 318, 319, 322, - 328, 380, 386, 387, 388, 389, 409, 410, 411, 414, - 417, 418, 421, 423, 424, 427, 431, 435, 436, 437, - 439, 441, 443, 455, 460, 474, 475, 476, 477, 478, - 481, 482, 488, 489, 490, 491, 492, 500, 501, 516, - 586, 588, 605, 625, 632, 480, 301, 302, 444, 445, - 314, 315, 646, 647, 300, 600, 633, 597, 645, 627, - 438, 378, 0, 0, 381, 281, 305, 320, 0, 617, - 502, 227, 466, 290, 251, 0, 0, 211, 246, 230, - 259, 274, 277, 324, 391, 400, 429, 434, 296, 271, - 244, 459, 241, 485, 519, 520, 521, 523, 395, 266, - 433, 396, 0, 376, 576, 577, 316, 0, 0, 0, - 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 416, 0, 0, 0, 0, 0, 0, 0, - 270, 0, 0, 0, 0, 366, 267, 0, 0, 204, - 505, 0, 430, 0, 203, 0, 487, 252, 377, 374, - 583, 282, 273, 269, 250, 317, 385, 428, 518, 422, - 0, 370, 0, 0, 497, 401, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 323, 248, 325, 202, 413, 498, - 286, 0, 0, 0, 0, 0, 507, 194, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, - 245, 0, 0, 0, 351, 360, 359, 339, 340, 342, - 344, 350, 357, 363, 336, 345, 0, 0, 609, 0, - 0, 0, 265, 321, 272, 264, 580, 0, 0, 0, - 0, 0, 0, 596, 0, 0, 229, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 275, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 297, 0, 402, 257, 0, 453, 0, - 0, 0, 629, 0, 0, 0, 0, 0, 0, 0, - 365, 0, 330, 197, 225, 0, 0, 412, 461, 473, - 0, 0, 0, 253, 0, 471, 426, 604, 233, 284, - 458, 432, 469, 440, 287, 0, 0, 470, 372, 585, - 450, 601, 630, 631, 263, 406, 615, 522, 623, 648, - 226, 260, 420, 506, 607, 494, 397, 581, 582, 329, - 493, 295, 201, 369, 636, 224, 479, 371, 242, 231, - 587, 612, 299, 289, 456, 643, 213, 517, 598, 239, - 483, 0, 0, 651, 247, 504, 610, 599, 215, 594, - 503, 393, 326, 327, 214, 0, 457, 268, 293, 0, - 0, 258, 415, 589, 590, 256, 652, 228, 622, 220, - 0, 621, 408, 584, 595, 394, 383, 219, 593, 392, - 382, 334, 355, 356, 280, 307, 447, 375, 448, 306, - 308, 404, 403, 405, 207, 608, 626, 0, 208, 0, - 499, 611, 653, 452, 212, 234, 235, 237, 0, 279, - 283, 291, 294, 303, 304, 313, 367, 419, 446, 442, - 451, 0, 579, 602, 616, 628, 634, 635, 637, 638, - 639, 640, 641, 644, 642, 407, 311, 495, 333, 373, - 0, 0, 425, 472, 240, 606, 496, 199, 0, 0, - 0, 0, 254, 255, 0, 575, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 654, 655, 656, 657, 658, - 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, - 669, 670, 671, 649, 508, 514, 509, 510, 511, 512, - 513, 0, 515, 0, 0, 0, 0, 0, 398, 0, - 591, 592, 672, 384, 486, 603, 335, 349, 352, 341, - 361, 0, 362, 337, 338, 343, 346, 347, 348, 353, - 354, 358, 364, 249, 210, 390, 399, 578, 312, 216, - 217, 218, 524, 525, 526, 527, 619, 620, 624, 205, - 462, 463, 464, 465, 292, 614, 309, 468, 467, 331, - 332, 379, 449, 540, 542, 553, 557, 559, 561, 567, - 570, 541, 543, 554, 558, 560, 562, 568, 571, 530, - 532, 534, 536, 549, 548, 545, 573, 574, 551, 556, - 535, 547, 552, 565, 572, 569, 529, 533, 537, 546, - 564, 563, 544, 555, 566, 550, 538, 531, 539, 0, - 196, 221, 368, 2079, 454, 288, 650, 618, 484, 613, - 206, 223, 0, 262, 0, 0, 0, 0, 0, 0, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 0, 0, 0, 0, 0, 399, 0, + 592, 593, 673, 385, 487, 604, 336, 350, 353, 342, + 362, 0, 363, 338, 339, 344, 347, 348, 349, 354, + 355, 359, 365, 249, 210, 391, 400, 579, 313, 216, + 217, 218, 525, 526, 527, 528, 620, 621, 625, 205, + 463, 464, 465, 466, 293, 615, 310, 469, 468, 332, + 333, 380, 450, 541, 543, 554, 558, 560, 562, 568, + 571, 542, 544, 555, 559, 561, 563, 569, 572, 531, + 533, 535, 537, 550, 549, 546, 574, 575, 552, 557, + 536, 548, 553, 566, 573, 570, 530, 534, 538, 547, + 565, 564, 545, 556, 567, 551, 539, 532, 540, 0, + 196, 221, 369, 0, 455, 289, 651, 619, 485, 614, + 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, - 236, 243, 261, 276, 278, 285, 298, 310, 318, 319, - 322, 328, 380, 386, 387, 388, 389, 409, 410, 411, - 414, 417, 418, 421, 423, 424, 427, 431, 435, 436, - 437, 439, 441, 443, 455, 460, 474, 475, 476, 477, - 478, 481, 482, 488, 489, 490, 491, 492, 500, 501, - 516, 586, 588, 605, 625, 632, 480, 301, 302, 444, - 445, 314, 315, 646, 647, 300, 600, 633, 597, 645, - 627, 438, 378, 0, 0, 381, 281, 305, 320, 0, - 617, 502, 227, 466, 290, 251, 0, 0, 211, 246, - 230, 259, 274, 277, 324, 391, 400, 429, 434, 296, - 271, 244, 459, 241, 485, 519, 520, 521, 523, 395, - 266, 433, 396, 0, 376, 576, 577, 316, 0, 0, - 0, 528, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 416, 0, 0, 0, 0, 0, 0, - 0, 270, 0, 0, 0, 0, 366, 267, 0, 0, - 204, 505, 0, 430, 0, 203, 0, 487, 252, 377, - 374, 583, 282, 273, 269, 250, 317, 385, 428, 518, - 422, 0, 370, 0, 0, 497, 401, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 323, 248, 325, 202, 413, - 498, 286, 0, 0, 0, 0, 2070, 507, 724, 0, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 302, 303, 445, + 446, 315, 316, 647, 648, 301, 601, 634, 598, 646, + 628, 439, 379, 0, 0, 382, 282, 306, 321, 0, + 618, 503, 227, 467, 291, 251, 0, 0, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 397, 0, 377, 577, 578, 317, 0, 0, + 0, 529, 0, 0, 0, 0, 2428, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 0, 0, 0, + 0, 271, 0, 0, 0, 0, 367, 268, 0, 0, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 0, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 0, 0, 0, 0, 508, 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, - 0, 245, 0, 0, 0, 351, 360, 359, 339, 340, - 342, 344, 350, 357, 363, 336, 345, 0, 0, 609, - 0, 0, 0, 265, 321, 272, 264, 580, 0, 0, - 0, 0, 0, 0, 596, 0, 0, 229, 0, 0, + 0, 245, 0, 0, 0, 352, 361, 360, 340, 341, + 343, 345, 351, 358, 364, 337, 346, 0, 0, 610, + 0, 0, 0, 266, 322, 273, 265, 581, 0, 0, + 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 275, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -5973,443 +5790,221 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 297, 0, 402, 257, 0, 453, - 0, 0, 0, 629, 0, 0, 0, 0, 0, 0, - 0, 365, 0, 330, 197, 225, 0, 0, 412, 461, - 473, 0, 0, 0, 253, 0, 471, 426, 604, 233, - 284, 458, 432, 469, 440, 287, 0, 0, 470, 372, - 585, 450, 601, 630, 631, 263, 406, 615, 522, 623, - 648, 226, 260, 420, 506, 607, 494, 397, 581, 582, - 329, 493, 295, 201, 369, 636, 224, 479, 371, 242, - 231, 587, 612, 299, 289, 456, 643, 213, 517, 598, - 239, 483, 0, 0, 651, 247, 504, 610, 599, 215, - 594, 503, 393, 326, 327, 214, 0, 457, 268, 293, - 0, 0, 258, 415, 589, 590, 256, 652, 228, 622, - 220, 0, 621, 408, 584, 595, 394, 383, 219, 593, - 392, 382, 334, 355, 356, 280, 307, 447, 375, 448, - 306, 308, 404, 403, 405, 207, 608, 626, 0, 208, - 0, 499, 611, 653, 452, 212, 234, 235, 237, 0, - 279, 283, 291, 294, 303, 304, 313, 367, 419, 446, - 442, 451, 0, 579, 602, 616, 628, 634, 635, 637, - 638, 639, 640, 641, 644, 642, 407, 311, 495, 333, - 373, 0, 0, 425, 472, 240, 606, 496, 199, 0, - 0, 0, 0, 254, 255, 0, 575, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 654, 655, 656, 657, + 0, 0, 0, 0, 298, 0, 403, 258, 0, 454, + 0, 0, 0, 630, 0, 0, 0, 0, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 254, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 590, 591, 257, 653, 228, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 356, 357, 281, 308, 448, 376, + 449, 307, 309, 405, 404, 406, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 199, + 0, 0, 0, 0, 255, 256, 0, 576, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, - 668, 669, 670, 671, 649, 508, 514, 509, 510, 511, - 512, 513, 0, 515, 0, 0, 0, 0, 0, 398, - 0, 591, 592, 672, 384, 486, 603, 335, 349, 352, - 341, 361, 0, 362, 337, 338, 343, 346, 347, 348, - 353, 354, 358, 364, 249, 210, 390, 399, 578, 312, - 216, 217, 218, 524, 525, 526, 527, 619, 620, 624, - 205, 462, 463, 464, 465, 292, 614, 309, 468, 467, - 331, 332, 379, 449, 540, 542, 553, 557, 559, 561, - 567, 570, 541, 543, 554, 558, 560, 562, 568, 571, - 530, 532, 534, 536, 549, 548, 545, 573, 574, 551, - 556, 535, 547, 552, 565, 572, 569, 529, 533, 537, - 546, 564, 563, 544, 555, 566, 550, 538, 531, 539, - 0, 196, 221, 368, 0, 454, 288, 650, 618, 484, - 613, 206, 223, 0, 262, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, - 232, 236, 243, 261, 276, 278, 285, 298, 310, 318, - 319, 322, 328, 380, 386, 387, 388, 389, 409, 410, - 411, 414, 417, 418, 421, 423, 424, 427, 431, 435, - 436, 437, 439, 441, 443, 455, 460, 474, 475, 476, - 477, 478, 481, 482, 488, 489, 490, 491, 492, 500, - 501, 516, 586, 588, 605, 625, 632, 480, 301, 302, - 444, 445, 314, 315, 646, 647, 300, 600, 633, 597, - 645, 627, 438, 378, 0, 0, 381, 281, 305, 320, - 0, 617, 502, 227, 466, 290, 251, 0, 0, 211, - 246, 230, 259, 274, 277, 324, 391, 400, 429, 434, - 296, 271, 244, 459, 241, 485, 519, 520, 521, 523, - 395, 266, 433, 396, 0, 376, 576, 577, 316, 0, - 0, 0, 528, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 416, 0, 0, 0, 0, 0, - 0, 0, 270, 0, 0, 0, 0, 366, 267, 0, - 1928, 204, 505, 0, 430, 0, 203, 0, 487, 252, - 377, 374, 583, 282, 273, 269, 250, 317, 385, 428, - 518, 422, 0, 370, 0, 0, 497, 401, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 323, 248, 325, 202, - 413, 498, 286, 0, 0, 0, 0, 0, 507, 724, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, - 0, 0, 245, 0, 0, 0, 351, 360, 359, 339, - 340, 342, 344, 350, 357, 363, 336, 345, 0, 0, - 609, 0, 0, 0, 265, 321, 272, 264, 580, 0, - 0, 0, 0, 0, 0, 596, 0, 0, 229, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 275, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 297, 0, 402, 257, 0, - 453, 0, 0, 0, 629, 0, 0, 0, 0, 0, - 0, 0, 365, 0, 330, 197, 225, 0, 0, 412, - 461, 473, 0, 0, 0, 253, 0, 471, 426, 604, - 233, 284, 458, 432, 469, 440, 287, 0, 0, 470, - 372, 585, 450, 601, 630, 631, 263, 406, 615, 522, - 623, 648, 226, 260, 420, 506, 607, 494, 397, 581, - 582, 329, 493, 295, 201, 369, 636, 224, 479, 371, - 242, 231, 587, 612, 299, 289, 456, 643, 213, 517, - 598, 239, 483, 0, 0, 651, 247, 504, 610, 599, - 215, 594, 503, 393, 326, 327, 214, 0, 457, 268, - 293, 0, 0, 258, 415, 589, 590, 256, 652, 228, - 622, 220, 0, 621, 408, 584, 595, 394, 383, 219, - 593, 392, 382, 334, 355, 356, 280, 307, 447, 375, - 448, 306, 308, 404, 403, 405, 207, 608, 626, 0, - 208, 0, 499, 611, 653, 452, 212, 234, 235, 237, - 0, 279, 283, 291, 294, 303, 304, 313, 367, 419, - 446, 442, 451, 0, 579, 602, 616, 628, 634, 635, - 637, 638, 639, 640, 641, 644, 642, 407, 311, 495, - 333, 373, 0, 0, 425, 472, 240, 606, 496, 199, - 0, 0, 0, 0, 254, 255, 0, 575, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 654, 655, 656, - 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, - 667, 668, 669, 670, 671, 649, 508, 514, 509, 510, - 511, 512, 513, 0, 515, 0, 0, 0, 0, 0, - 398, 0, 591, 592, 672, 384, 486, 603, 335, 349, - 352, 341, 361, 0, 362, 337, 338, 343, 346, 347, - 348, 353, 354, 358, 364, 249, 210, 390, 399, 578, - 312, 216, 217, 218, 524, 525, 526, 527, 619, 620, - 624, 205, 462, 463, 464, 465, 292, 614, 309, 468, - 467, 331, 332, 379, 449, 540, 542, 553, 557, 559, - 561, 567, 570, 541, 543, 554, 558, 560, 562, 568, - 571, 530, 532, 534, 536, 549, 548, 545, 573, 574, - 551, 556, 535, 547, 552, 565, 572, 569, 529, 533, - 537, 546, 564, 563, 544, 555, 566, 550, 538, 531, - 539, 0, 196, 221, 368, 0, 454, 288, 650, 618, - 484, 613, 206, 223, 0, 262, 0, 0, 0, 0, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 0, 0, 0, 0, 0, + 399, 0, 592, 593, 673, 385, 487, 604, 336, 350, + 353, 342, 362, 0, 363, 338, 339, 344, 347, 348, + 349, 354, 355, 359, 365, 249, 210, 391, 400, 579, + 313, 216, 217, 218, 525, 526, 527, 528, 620, 621, + 625, 205, 463, 464, 465, 466, 293, 615, 310, 469, + 468, 332, 333, 380, 450, 541, 543, 554, 558, 560, + 562, 568, 571, 542, 544, 555, 559, 561, 563, 569, + 572, 531, 533, 535, 537, 550, 549, 546, 574, 575, + 552, 557, 536, 548, 553, 566, 573, 570, 530, 534, + 538, 547, 565, 564, 545, 556, 567, 551, 539, 532, + 540, 0, 196, 221, 369, 0, 455, 289, 651, 619, + 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, - 222, 232, 236, 243, 261, 276, 278, 285, 298, 310, - 318, 319, 322, 328, 380, 386, 387, 388, 389, 409, - 410, 411, 414, 417, 418, 421, 423, 424, 427, 431, - 435, 436, 437, 439, 441, 443, 455, 460, 474, 475, - 476, 477, 478, 481, 482, 488, 489, 490, 491, 492, - 500, 501, 516, 586, 588, 605, 625, 632, 480, 301, - 302, 444, 445, 314, 315, 646, 647, 300, 600, 633, - 597, 645, 627, 438, 378, 0, 0, 381, 281, 305, - 320, 0, 617, 502, 227, 466, 290, 251, 0, 0, - 211, 246, 230, 259, 274, 277, 324, 391, 400, 429, - 434, 296, 271, 244, 459, 241, 485, 519, 520, 521, - 523, 395, 266, 433, 396, 0, 376, 576, 577, 316, - 0, 0, 0, 528, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 416, 0, 0, 0, 0, - 0, 0, 0, 270, 0, 0, 0, 0, 366, 267, - 0, 1926, 204, 505, 0, 430, 0, 203, 0, 487, - 252, 377, 374, 583, 282, 273, 269, 250, 317, 385, - 428, 518, 422, 0, 370, 0, 0, 497, 401, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 323, 248, 325, - 202, 413, 498, 286, 0, 0, 0, 0, 0, 507, - 724, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 238, 0, 0, 245, 0, 0, 0, 351, 360, 359, - 339, 340, 342, 344, 350, 357, 363, 336, 345, 0, - 0, 609, 0, 0, 0, 265, 321, 272, 264, 580, - 0, 0, 0, 0, 0, 0, 596, 0, 0, 229, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 275, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 297, 0, 402, 257, - 0, 453, 0, 0, 0, 629, 0, 0, 0, 0, - 0, 0, 0, 365, 0, 330, 197, 225, 0, 0, - 412, 461, 473, 0, 0, 0, 253, 0, 471, 426, - 604, 233, 284, 458, 432, 469, 440, 287, 0, 0, - 470, 372, 585, 450, 601, 630, 631, 263, 406, 615, - 522, 623, 648, 226, 260, 420, 506, 607, 494, 397, - 581, 582, 329, 493, 295, 201, 369, 636, 224, 479, - 371, 242, 231, 587, 612, 299, 289, 456, 643, 213, - 517, 598, 239, 483, 0, 0, 651, 247, 504, 610, - 599, 215, 594, 503, 393, 326, 327, 214, 0, 457, - 268, 293, 0, 0, 258, 415, 589, 590, 256, 652, - 228, 622, 220, 0, 621, 408, 584, 595, 394, 383, - 219, 593, 392, 382, 334, 355, 356, 280, 307, 447, - 375, 448, 306, 308, 404, 403, 405, 207, 608, 626, - 0, 208, 0, 499, 611, 653, 452, 212, 234, 235, - 237, 0, 279, 283, 291, 294, 303, 304, 313, 367, - 419, 446, 442, 451, 0, 579, 602, 616, 628, 634, - 635, 637, 638, 639, 640, 641, 644, 642, 407, 311, - 495, 333, 373, 0, 0, 425, 472, 240, 606, 496, - 199, 0, 0, 0, 0, 254, 255, 0, 575, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 654, 655, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 302, + 303, 445, 446, 315, 316, 647, 648, 301, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 0, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 0, + 0, 0, 0, 271, 0, 0, 0, 0, 367, 268, + 0, 0, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 0, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 0, 0, 0, 1781, 508, + 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 238, 0, 0, 245, 0, 0, 0, 352, 361, 360, + 340, 341, 343, 345, 351, 358, 364, 337, 346, 0, + 0, 610, 0, 0, 0, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 0, 0, 0, 630, 0, 0, 0, 0, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 254, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 590, 591, 257, + 653, 228, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 356, 357, 281, 308, + 448, 376, 449, 307, 309, 405, 404, 406, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 199, 0, 0, 0, 0, 255, 256, 0, 576, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, - 666, 667, 668, 669, 670, 671, 649, 508, 514, 509, - 510, 511, 512, 513, 0, 515, 0, 0, 0, 0, - 0, 398, 0, 591, 592, 672, 384, 486, 603, 335, - 349, 352, 341, 361, 0, 362, 337, 338, 343, 346, - 347, 348, 353, 354, 358, 364, 249, 210, 390, 399, - 578, 312, 216, 217, 218, 524, 525, 526, 527, 619, - 620, 624, 205, 462, 463, 464, 465, 292, 614, 309, - 468, 467, 331, 332, 379, 449, 540, 542, 553, 557, - 559, 561, 567, 570, 541, 543, 554, 558, 560, 562, - 568, 571, 530, 532, 534, 536, 549, 548, 545, 573, - 574, 551, 556, 535, 547, 552, 565, 572, 569, 529, - 533, 537, 546, 564, 563, 544, 555, 566, 550, 538, - 531, 539, 0, 196, 221, 368, 0, 454, 288, 650, - 618, 484, 613, 206, 223, 0, 262, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, - 209, 222, 232, 236, 243, 261, 276, 278, 285, 298, - 310, 318, 319, 322, 328, 380, 386, 387, 388, 389, - 409, 410, 411, 414, 417, 418, 421, 423, 424, 427, - 431, 435, 436, 437, 439, 441, 443, 455, 460, 474, - 475, 476, 477, 478, 481, 482, 488, 489, 490, 491, - 492, 500, 501, 516, 586, 588, 605, 625, 632, 480, - 301, 302, 444, 445, 314, 315, 646, 647, 300, 600, - 633, 597, 645, 627, 438, 378, 0, 0, 381, 281, - 305, 320, 0, 617, 502, 227, 466, 290, 251, 0, - 0, 211, 246, 230, 259, 274, 277, 324, 391, 400, - 429, 434, 296, 271, 244, 459, 241, 485, 519, 520, - 521, 523, 395, 266, 433, 396, 0, 376, 576, 577, - 316, 0, 0, 0, 528, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 416, 0, 0, 0, - 0, 0, 0, 0, 270, 0, 0, 0, 0, 366, - 267, 0, 1924, 204, 505, 0, 430, 0, 203, 0, - 487, 252, 377, 374, 583, 282, 273, 269, 250, 317, - 385, 428, 518, 422, 0, 370, 0, 0, 497, 401, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 323, 248, - 325, 202, 413, 498, 286, 0, 0, 0, 0, 0, - 507, 724, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 238, 0, 0, 245, 0, 0, 0, 351, 360, - 359, 339, 340, 342, 344, 350, 357, 363, 336, 345, - 0, 0, 609, 0, 0, 0, 265, 321, 272, 264, - 580, 0, 0, 0, 0, 0, 0, 596, 0, 0, - 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 275, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 297, 0, 402, - 257, 0, 453, 0, 0, 0, 629, 0, 0, 0, - 0, 0, 0, 0, 365, 0, 330, 197, 225, 0, - 0, 412, 461, 473, 0, 0, 0, 253, 0, 471, - 426, 604, 233, 284, 458, 432, 469, 440, 287, 0, - 0, 470, 372, 585, 450, 601, 630, 631, 263, 406, - 615, 522, 623, 648, 226, 260, 420, 506, 607, 494, - 397, 581, 582, 329, 493, 295, 201, 369, 636, 224, - 479, 371, 242, 231, 587, 612, 299, 289, 456, 643, - 213, 517, 598, 239, 483, 0, 0, 651, 247, 504, - 610, 599, 215, 594, 503, 393, 326, 327, 214, 0, - 457, 268, 293, 0, 0, 258, 415, 589, 590, 256, - 652, 228, 622, 220, 0, 621, 408, 584, 595, 394, - 383, 219, 593, 392, 382, 334, 355, 356, 280, 307, - 447, 375, 448, 306, 308, 404, 403, 405, 207, 608, - 626, 0, 208, 0, 499, 611, 653, 452, 212, 234, - 235, 237, 0, 279, 283, 291, 294, 303, 304, 313, - 367, 419, 446, 442, 451, 0, 579, 602, 616, 628, - 634, 635, 637, 638, 639, 640, 641, 644, 642, 407, - 311, 495, 333, 373, 0, 0, 425, 472, 240, 606, - 496, 199, 0, 0, 0, 0, 254, 255, 0, 575, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 654, - 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, - 665, 666, 667, 668, 669, 670, 671, 649, 508, 514, - 509, 510, 511, 512, 513, 0, 515, 0, 0, 0, - 0, 0, 398, 0, 591, 592, 672, 384, 486, 603, - 335, 349, 352, 341, 361, 0, 362, 337, 338, 343, - 346, 347, 348, 353, 354, 358, 364, 249, 210, 390, - 399, 578, 312, 216, 217, 218, 524, 525, 526, 527, - 619, 620, 624, 205, 462, 463, 464, 465, 292, 614, - 309, 468, 467, 331, 332, 379, 449, 540, 542, 553, - 557, 559, 561, 567, 570, 541, 543, 554, 558, 560, - 562, 568, 571, 530, 532, 534, 536, 549, 548, 545, - 573, 574, 551, 556, 535, 547, 552, 565, 572, 569, - 529, 533, 537, 546, 564, 563, 544, 555, 566, 550, - 538, 531, 539, 0, 196, 221, 368, 0, 454, 288, - 650, 618, 484, 613, 206, 223, 0, 262, 0, 0, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 0, 0, 0, + 0, 0, 399, 0, 592, 593, 673, 385, 487, 604, + 336, 350, 353, 342, 362, 0, 363, 338, 339, 344, + 347, 348, 349, 354, 355, 359, 365, 249, 210, 391, + 400, 579, 313, 216, 217, 218, 525, 526, 527, 528, + 620, 621, 625, 205, 463, 464, 465, 466, 293, 615, + 310, 469, 468, 332, 333, 380, 450, 541, 543, 554, + 558, 560, 562, 568, 571, 542, 544, 555, 559, 561, + 563, 569, 572, 531, 533, 535, 537, 550, 549, 546, + 574, 575, 552, 557, 536, 548, 553, 566, 573, 570, + 530, 534, 538, 547, 565, 564, 545, 556, 567, 551, + 539, 532, 540, 0, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, - 200, 209, 222, 232, 236, 243, 261, 276, 278, 285, - 298, 310, 318, 319, 322, 328, 380, 386, 387, 388, - 389, 409, 410, 411, 414, 417, 418, 421, 423, 424, - 427, 431, 435, 436, 437, 439, 441, 443, 455, 460, - 474, 475, 476, 477, 478, 481, 482, 488, 489, 490, - 491, 492, 500, 501, 516, 586, 588, 605, 625, 632, - 480, 301, 302, 444, 445, 314, 315, 646, 647, 300, - 600, 633, 597, 645, 627, 438, 378, 0, 0, 381, - 281, 305, 320, 0, 617, 502, 227, 466, 290, 251, - 0, 0, 211, 246, 230, 259, 274, 277, 324, 391, - 400, 429, 434, 296, 271, 244, 459, 241, 485, 519, - 520, 521, 523, 395, 266, 433, 396, 0, 376, 576, - 577, 316, 0, 0, 0, 528, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 416, 0, 0, - 0, 0, 0, 0, 0, 270, 0, 0, 0, 0, - 366, 267, 0, 1922, 204, 505, 0, 430, 0, 203, - 0, 487, 252, 377, 374, 583, 282, 273, 269, 250, - 317, 385, 428, 518, 422, 0, 370, 0, 0, 497, - 401, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 323, - 248, 325, 202, 413, 498, 286, 0, 0, 0, 0, - 0, 507, 724, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 238, 0, 0, 245, 0, 0, 0, 351, - 360, 359, 339, 340, 342, 344, 350, 357, 363, 336, - 345, 0, 0, 609, 0, 0, 0, 265, 321, 272, - 264, 580, 0, 0, 0, 0, 0, 0, 596, 0, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 302, 303, 445, 446, 315, 316, 647, 648, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 0, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 397, 0, 377, 577, + 578, 317, 0, 0, 0, 529, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, + 0, 0, 0, 0, 0, 271, 0, 0, 0, 0, + 367, 268, 0, 0, 204, 506, 0, 431, 0, 203, + 0, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 0, 371, 0, 0, 498, + 402, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 248, 326, 202, 414, 499, 287, 0, 0, 0, 0, + 0, 508, 194, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 238, 0, 0, 245, 0, 0, 0, 352, + 361, 360, 340, 341, 343, 345, 351, 358, 364, 337, + 346, 0, 0, 610, 0, 0, 0, 266, 322, 273, + 265, 581, 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 275, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 297, 0, - 402, 257, 0, 453, 0, 0, 0, 629, 0, 0, - 0, 0, 0, 0, 0, 365, 0, 330, 197, 225, - 0, 0, 412, 461, 473, 0, 0, 0, 253, 0, - 471, 426, 604, 233, 284, 458, 432, 469, 440, 287, - 0, 0, 470, 372, 585, 450, 601, 630, 631, 263, - 406, 615, 522, 623, 648, 226, 260, 420, 506, 607, - 494, 397, 581, 582, 329, 493, 295, 201, 369, 636, - 224, 479, 371, 242, 231, 587, 612, 299, 289, 456, - 643, 213, 517, 598, 239, 483, 0, 0, 651, 247, - 504, 610, 599, 215, 594, 503, 393, 326, 327, 214, - 0, 457, 268, 293, 0, 0, 258, 415, 589, 590, - 256, 652, 228, 622, 220, 0, 621, 408, 584, 595, - 394, 383, 219, 593, 392, 382, 334, 355, 356, 280, - 307, 447, 375, 448, 306, 308, 404, 403, 405, 207, - 608, 626, 0, 208, 0, 499, 611, 653, 452, 212, - 234, 235, 237, 0, 279, 283, 291, 294, 303, 304, - 313, 367, 419, 446, 442, 451, 0, 579, 602, 616, - 628, 634, 635, 637, 638, 639, 640, 641, 644, 642, - 407, 311, 495, 333, 373, 0, 0, 425, 472, 240, - 606, 496, 199, 0, 0, 0, 0, 254, 255, 0, - 575, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, - 664, 665, 666, 667, 668, 669, 670, 671, 649, 508, - 514, 509, 510, 511, 512, 513, 0, 515, 0, 0, - 0, 0, 0, 398, 0, 591, 592, 672, 384, 486, - 603, 335, 349, 352, 341, 361, 0, 362, 337, 338, - 343, 346, 347, 348, 353, 354, 358, 364, 249, 210, - 390, 399, 578, 312, 216, 217, 218, 524, 525, 526, - 527, 619, 620, 624, 205, 462, 463, 464, 465, 292, - 614, 309, 468, 467, 331, 332, 379, 449, 540, 542, - 553, 557, 559, 561, 567, 570, 541, 543, 554, 558, - 560, 562, 568, 571, 530, 532, 534, 536, 549, 548, - 545, 573, 574, 551, 556, 535, 547, 552, 565, 572, - 569, 529, 533, 537, 546, 564, 563, 544, 555, 566, - 550, 538, 531, 539, 0, 196, 221, 368, 0, 454, - 288, 650, 618, 484, 613, 206, 223, 0, 262, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 198, 200, 209, 222, 232, 236, 243, 261, 276, 278, - 285, 298, 310, 318, 319, 322, 328, 380, 386, 387, - 388, 389, 409, 410, 411, 414, 417, 418, 421, 423, - 424, 427, 431, 435, 436, 437, 439, 441, 443, 455, - 460, 474, 475, 476, 477, 478, 481, 482, 488, 489, - 490, 491, 492, 500, 501, 516, 586, 588, 605, 625, - 632, 480, 301, 302, 444, 445, 314, 315, 646, 647, - 300, 600, 633, 597, 645, 627, 438, 378, 0, 0, - 381, 281, 305, 320, 0, 617, 502, 227, 466, 290, - 251, 0, 0, 211, 246, 230, 259, 274, 277, 324, - 391, 400, 429, 434, 296, 271, 244, 459, 241, 485, - 519, 520, 521, 523, 395, 266, 433, 396, 0, 376, - 576, 577, 316, 0, 0, 0, 528, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 416, 0, - 0, 0, 0, 0, 0, 0, 270, 0, 0, 0, - 0, 366, 267, 0, 1920, 204, 505, 0, 430, 0, - 203, 0, 487, 252, 377, 374, 583, 282, 273, 269, - 250, 317, 385, 428, 518, 422, 0, 370, 0, 0, - 497, 401, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 323, 248, 325, 202, 413, 498, 286, 0, 0, 0, - 0, 0, 507, 724, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 238, 0, 0, 245, 0, 0, 0, - 351, 360, 359, 339, 340, 342, 344, 350, 357, 363, - 336, 345, 0, 0, 609, 0, 0, 0, 265, 321, - 272, 264, 580, 0, 0, 0, 0, 0, 0, 596, - 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 275, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 297, - 0, 402, 257, 0, 453, 0, 0, 0, 629, 0, - 0, 0, 0, 0, 0, 0, 365, 0, 330, 197, - 225, 0, 0, 412, 461, 473, 0, 0, 0, 253, - 0, 471, 426, 604, 233, 284, 458, 432, 469, 440, - 287, 0, 0, 470, 372, 585, 450, 601, 630, 631, - 263, 406, 615, 522, 623, 648, 226, 260, 420, 506, - 607, 494, 397, 581, 582, 329, 493, 295, 201, 369, - 636, 224, 479, 371, 242, 231, 587, 612, 299, 289, - 456, 643, 213, 517, 598, 239, 483, 0, 0, 651, - 247, 504, 610, 599, 215, 594, 503, 393, 326, 327, - 214, 0, 457, 268, 293, 0, 0, 258, 415, 589, - 590, 256, 652, 228, 622, 220, 0, 621, 408, 584, - 595, 394, 383, 219, 593, 392, 382, 334, 355, 356, - 280, 307, 447, 375, 448, 306, 308, 404, 403, 405, - 207, 608, 626, 0, 208, 0, 499, 611, 653, 452, - 212, 234, 235, 237, 0, 279, 283, 291, 294, 303, - 304, 313, 367, 419, 446, 442, 451, 0, 579, 602, - 616, 628, 634, 635, 637, 638, 639, 640, 641, 644, - 642, 407, 311, 495, 333, 373, 0, 0, 425, 472, - 240, 606, 496, 199, 0, 0, 0, 0, 254, 255, - 0, 575, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 654, 655, 656, 657, 658, 659, 660, 661, 662, - 663, 664, 665, 666, 667, 668, 669, 670, 671, 649, - 508, 514, 509, 510, 511, 512, 513, 0, 515, 0, - 0, 0, 0, 0, 398, 0, 591, 592, 672, 384, - 486, 603, 335, 349, 352, 341, 361, 0, 362, 337, - 338, 343, 346, 347, 348, 353, 354, 358, 364, 249, - 210, 390, 399, 578, 312, 216, 217, 218, 524, 525, - 526, 527, 619, 620, 624, 205, 462, 463, 464, 465, - 292, 614, 309, 468, 467, 331, 332, 379, 449, 540, - 542, 553, 557, 559, 561, 567, 570, 541, 543, 554, - 558, 560, 562, 568, 571, 530, 532, 534, 536, 549, - 548, 545, 573, 574, 551, 556, 535, 547, 552, 565, - 572, 569, 529, 533, 537, 546, 564, 563, 544, 555, - 566, 550, 538, 531, 539, 0, 196, 221, 368, 0, - 454, 288, 650, 618, 484, 613, 206, 223, 0, 262, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 198, 200, 209, 222, 232, 236, 243, 261, 276, - 278, 285, 298, 310, 318, 319, 322, 328, 380, 386, - 387, 388, 389, 409, 410, 411, 414, 417, 418, 421, - 423, 424, 427, 431, 435, 436, 437, 439, 441, 443, - 455, 460, 474, 475, 476, 477, 478, 481, 482, 488, - 489, 490, 491, 492, 500, 501, 516, 586, 588, 605, - 625, 632, 480, 301, 302, 444, 445, 314, 315, 646, - 647, 300, 600, 633, 597, 645, 627, 438, 378, 0, - 0, 381, 281, 305, 320, 0, 617, 502, 227, 466, - 290, 251, 0, 0, 211, 246, 230, 259, 274, 277, - 324, 391, 400, 429, 434, 296, 271, 244, 459, 241, - 485, 519, 520, 521, 523, 395, 266, 433, 396, 0, - 376, 576, 577, 316, 0, 0, 0, 528, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 416, - 0, 0, 0, 0, 0, 0, 0, 270, 0, 0, - 0, 0, 366, 267, 0, 1916, 204, 505, 0, 430, - 0, 203, 0, 487, 252, 377, 374, 583, 282, 273, - 269, 250, 317, 385, 428, 518, 422, 0, 370, 0, - 0, 497, 401, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 323, 248, 325, 202, 413, 498, 286, 0, 0, - 0, 0, 0, 507, 724, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 403, 258, 0, 454, 0, 0, 0, 630, 0, 0, + 0, 0, 0, 0, 0, 366, 0, 331, 197, 225, + 0, 0, 413, 462, 474, 0, 0, 0, 254, 0, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 0, 0, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 590, + 591, 257, 653, 228, 623, 220, 0, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 356, 357, + 281, 308, 448, 376, 449, 307, 309, 405, 404, 406, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 0, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 0, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 0, 0, 426, 473, + 240, 607, 497, 199, 0, 0, 0, 0, 255, 256, + 0, 576, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 0, + 0, 0, 0, 0, 399, 0, 592, 593, 673, 385, + 487, 604, 336, 350, 353, 342, 362, 0, 363, 338, + 339, 344, 347, 348, 349, 354, 355, 359, 365, 249, + 210, 391, 400, 579, 313, 216, 217, 218, 525, 526, + 527, 528, 620, 621, 625, 205, 463, 464, 465, 466, + 293, 615, 310, 469, 468, 332, 333, 380, 450, 541, + 543, 554, 558, 560, 562, 568, 571, 542, 544, 555, + 559, 561, 563, 569, 572, 531, 533, 535, 537, 550, + 549, 546, 574, 575, 552, 557, 536, 548, 553, 566, + 573, 570, 530, 534, 538, 547, 565, 564, 545, 556, + 567, 551, 539, 532, 540, 0, 196, 221, 369, 2080, + 455, 289, 651, 619, 485, 614, 206, 223, 0, 263, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 302, 303, 445, 446, 315, 316, 647, + 648, 301, 601, 634, 598, 646, 628, 439, 379, 0, + 0, 382, 282, 306, 321, 0, 618, 503, 227, 467, + 291, 251, 0, 0, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 397, 0, + 377, 577, 578, 317, 0, 0, 0, 529, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 0, 0, 0, 0, 271, 0, 0, + 0, 0, 367, 268, 0, 0, 204, 506, 0, 431, + 0, 203, 0, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 0, 371, 0, + 0, 498, 402, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 248, 326, 202, 414, 499, 287, 0, 0, + 0, 0, 2071, 508, 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, 0, 0, - 0, 351, 360, 359, 339, 340, 342, 344, 350, 357, - 363, 336, 345, 0, 0, 609, 0, 0, 0, 265, - 321, 272, 264, 580, 0, 0, 0, 0, 0, 0, - 596, 0, 0, 229, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 275, 0, + 0, 352, 361, 360, 340, 341, 343, 345, 351, 358, + 364, 337, 346, 0, 0, 610, 0, 0, 0, 266, + 322, 273, 265, 581, 0, 0, 0, 0, 0, 0, + 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6418,147 +6013,73 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 297, 0, 402, 257, 0, 453, 0, 0, 0, 629, - 0, 0, 0, 0, 0, 0, 0, 365, 0, 330, - 197, 225, 0, 0, 412, 461, 473, 0, 0, 0, - 253, 0, 471, 426, 604, 233, 284, 458, 432, 469, - 440, 287, 0, 0, 470, 372, 585, 450, 601, 630, - 631, 263, 406, 615, 522, 623, 648, 226, 260, 420, - 506, 607, 494, 397, 581, 582, 329, 493, 295, 201, - 369, 636, 224, 479, 371, 242, 231, 587, 612, 299, - 289, 456, 643, 213, 517, 598, 239, 483, 0, 0, - 651, 247, 504, 610, 599, 215, 594, 503, 393, 326, - 327, 214, 0, 457, 268, 293, 0, 0, 258, 415, - 589, 590, 256, 652, 228, 622, 220, 0, 621, 408, - 584, 595, 394, 383, 219, 593, 392, 382, 334, 355, - 356, 280, 307, 447, 375, 448, 306, 308, 404, 403, - 405, 207, 608, 626, 0, 208, 0, 499, 611, 653, - 452, 212, 234, 235, 237, 0, 279, 283, 291, 294, - 303, 304, 313, 367, 419, 446, 442, 451, 0, 579, - 602, 616, 628, 634, 635, 637, 638, 639, 640, 641, - 644, 642, 407, 311, 495, 333, 373, 0, 0, 425, - 472, 240, 606, 496, 199, 0, 0, 0, 0, 254, - 255, 0, 575, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 654, 655, 656, 657, 658, 659, 660, 661, + 298, 0, 403, 258, 0, 454, 0, 0, 0, 630, + 0, 0, 0, 0, 0, 0, 0, 366, 0, 331, + 197, 225, 0, 0, 413, 462, 474, 0, 0, 0, + 254, 0, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 0, 0, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 590, 591, 257, 653, 228, 623, 220, 0, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 356, 357, 281, 308, 448, 376, 449, 307, 309, 405, + 404, 406, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 0, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 0, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 0, 0, + 426, 473, 240, 607, 497, 199, 0, 0, 0, 0, + 255, 256, 0, 576, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, - 649, 508, 514, 509, 510, 511, 512, 513, 0, 515, - 0, 0, 0, 0, 0, 398, 0, 591, 592, 672, - 384, 486, 603, 335, 349, 352, 341, 361, 0, 362, - 337, 338, 343, 346, 347, 348, 353, 354, 358, 364, - 249, 210, 390, 399, 578, 312, 216, 217, 218, 524, - 525, 526, 527, 619, 620, 624, 205, 462, 463, 464, - 465, 292, 614, 309, 468, 467, 331, 332, 379, 449, - 540, 542, 553, 557, 559, 561, 567, 570, 541, 543, - 554, 558, 560, 562, 568, 571, 530, 532, 534, 536, - 549, 548, 545, 573, 574, 551, 556, 535, 547, 552, - 565, 572, 569, 529, 533, 537, 546, 564, 563, 544, - 555, 566, 550, 538, 531, 539, 0, 196, 221, 368, - 0, 454, 288, 650, 618, 484, 613, 206, 223, 0, - 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 198, 200, 209, 222, 232, 236, 243, 261, - 276, 278, 285, 298, 310, 318, 319, 322, 328, 380, - 386, 387, 388, 389, 409, 410, 411, 414, 417, 418, - 421, 423, 424, 427, 431, 435, 436, 437, 439, 441, - 443, 455, 460, 474, 475, 476, 477, 478, 481, 482, - 488, 489, 490, 491, 492, 500, 501, 516, 586, 588, - 605, 625, 632, 480, 301, 302, 444, 445, 314, 315, - 646, 647, 300, 600, 633, 597, 645, 627, 438, 378, - 0, 0, 381, 281, 305, 320, 0, 617, 502, 227, - 466, 290, 251, 0, 0, 211, 246, 230, 259, 274, - 277, 324, 391, 400, 429, 434, 296, 271, 244, 459, - 241, 485, 519, 520, 521, 523, 395, 266, 433, 396, - 0, 376, 576, 577, 316, 0, 0, 0, 528, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 416, 0, 0, 0, 0, 0, 0, 0, 270, 0, - 0, 0, 0, 366, 267, 0, 1914, 204, 505, 0, - 430, 0, 203, 0, 487, 252, 377, 374, 583, 282, - 273, 269, 250, 317, 385, 428, 518, 422, 0, 370, - 0, 0, 497, 401, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 323, 248, 325, 202, 413, 498, 286, 0, - 0, 0, 0, 0, 507, 724, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 238, 0, 0, 245, 0, - 0, 0, 351, 360, 359, 339, 340, 342, 344, 350, - 357, 363, 336, 345, 0, 0, 609, 0, 0, 0, - 265, 321, 272, 264, 580, 0, 0, 0, 0, 0, - 0, 596, 0, 0, 229, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 275, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 297, 0, 402, 257, 0, 453, 0, 0, 0, - 629, 0, 0, 0, 0, 0, 0, 0, 365, 0, - 330, 197, 225, 0, 0, 412, 461, 473, 0, 0, - 0, 253, 0, 471, 426, 604, 233, 284, 458, 432, - 469, 440, 287, 0, 0, 470, 372, 585, 450, 601, - 630, 631, 263, 406, 615, 522, 623, 648, 226, 260, - 420, 506, 607, 494, 397, 581, 582, 329, 493, 295, - 201, 369, 636, 224, 479, 371, 242, 231, 587, 612, - 299, 289, 456, 643, 213, 517, 598, 239, 483, 0, - 0, 651, 247, 504, 610, 599, 215, 594, 503, 393, - 326, 327, 214, 0, 457, 268, 293, 0, 0, 258, - 415, 589, 590, 256, 652, 228, 622, 220, 0, 621, - 408, 584, 595, 394, 383, 219, 593, 392, 382, 334, - 355, 356, 280, 307, 447, 375, 448, 306, 308, 404, - 403, 405, 207, 608, 626, 0, 208, 0, 499, 611, - 653, 452, 212, 234, 235, 237, 0, 279, 283, 291, - 294, 303, 304, 313, 367, 419, 446, 442, 451, 0, - 579, 602, 616, 628, 634, 635, 637, 638, 639, 640, - 641, 644, 642, 407, 311, 495, 333, 373, 0, 0, - 425, 472, 240, 606, 496, 199, 0, 0, 0, 0, - 254, 255, 0, 575, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 654, 655, 656, 657, 658, 659, 660, - 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, - 671, 649, 508, 514, 509, 510, 511, 512, 513, 0, - 515, 0, 0, 0, 0, 0, 398, 0, 591, 592, - 672, 384, 486, 603, 335, 349, 352, 341, 361, 0, - 362, 337, 338, 343, 346, 347, 348, 353, 354, 358, - 364, 249, 210, 390, 399, 578, 312, 216, 217, 218, - 524, 525, 526, 527, 619, 620, 624, 205, 462, 463, - 464, 465, 292, 614, 309, 468, 467, 331, 332, 379, - 449, 540, 542, 553, 557, 559, 561, 567, 570, 541, - 543, 554, 558, 560, 562, 568, 571, 530, 532, 534, - 536, 549, 548, 545, 573, 574, 551, 556, 535, 547, - 552, 565, 572, 569, 529, 533, 537, 546, 564, 563, - 544, 555, 566, 550, 538, 531, 539, 0, 196, 221, - 368, 0, 454, 288, 650, 618, 484, 613, 206, 223, - 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 0, 0, 0, 0, 0, 399, 0, 592, 593, + 673, 385, 487, 604, 336, 350, 353, 342, 362, 0, + 363, 338, 339, 344, 347, 348, 349, 354, 355, 359, + 365, 249, 210, 391, 400, 579, 313, 216, 217, 218, + 525, 526, 527, 528, 620, 621, 625, 205, 463, 464, + 465, 466, 293, 615, 310, 469, 468, 332, 333, 380, + 450, 541, 543, 554, 558, 560, 562, 568, 571, 542, + 544, 555, 559, 561, 563, 569, 572, 531, 533, 535, + 537, 550, 549, 546, 574, 575, 552, 557, 536, 548, + 553, 566, 573, 570, 530, 534, 538, 547, 565, 564, + 545, 556, 567, 551, 539, 532, 540, 0, 196, 221, + 369, 0, 455, 289, 651, 619, 485, 614, 206, 223, + 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, 236, 243, - 261, 276, 278, 285, 298, 310, 318, 319, 322, 328, - 380, 386, 387, 388, 389, 409, 410, 411, 414, 417, - 418, 421, 423, 424, 427, 431, 435, 436, 437, 439, - 441, 443, 455, 460, 474, 475, 476, 477, 478, 481, - 482, 488, 489, 490, 491, 492, 500, 501, 516, 586, - 588, 605, 625, 632, 480, 301, 302, 444, 445, 314, - 315, 646, 647, 300, 600, 633, 597, 645, 627, 438, - 378, 0, 0, 381, 281, 305, 320, 0, 617, 502, - 227, 466, 290, 251, 0, 0, 211, 246, 230, 259, - 274, 277, 324, 391, 400, 429, 434, 296, 271, 244, - 459, 241, 485, 519, 520, 521, 523, 395, 266, 433, - 396, 0, 376, 576, 577, 316, 0, 0, 0, 528, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 416, 0, 0, 0, 0, 0, 0, 0, 270, - 0, 0, 0, 0, 366, 267, 0, 1912, 204, 505, - 0, 430, 0, 203, 0, 487, 252, 377, 374, 583, - 282, 273, 269, 250, 317, 385, 428, 518, 422, 0, - 370, 0, 0, 497, 401, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 323, 248, 325, 202, 413, 498, 286, - 0, 0, 0, 0, 0, 507, 724, 0, 0, 0, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 302, 303, 445, 446, 315, + 316, 647, 648, 301, 601, 634, 598, 646, 628, 439, + 379, 0, 0, 382, 282, 306, 321, 0, 618, 503, + 227, 467, 291, 251, 0, 0, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 397, 0, 377, 577, 578, 317, 0, 0, 0, 529, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 0, 0, 0, 0, 0, 271, + 0, 0, 0, 0, 367, 268, 0, 1929, 204, 506, + 0, 431, 0, 203, 0, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 0, + 371, 0, 0, 498, 402, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 248, 326, 202, 414, 499, 287, + 0, 0, 0, 0, 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, - 0, 0, 0, 351, 360, 359, 339, 340, 342, 344, - 350, 357, 363, 336, 345, 0, 0, 609, 0, 0, - 0, 265, 321, 272, 264, 580, 0, 0, 0, 0, - 0, 0, 596, 0, 0, 229, 0, 0, 0, 0, + 0, 0, 0, 352, 361, 360, 340, 341, 343, 345, + 351, 358, 364, 337, 346, 0, 0, 610, 0, 0, + 0, 266, 322, 273, 265, 581, 0, 0, 0, 0, + 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6566,147 +6087,73 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 297, 0, 402, 257, 0, 453, 0, 0, - 0, 629, 0, 0, 0, 0, 0, 0, 0, 365, - 0, 330, 197, 225, 0, 0, 412, 461, 473, 0, - 0, 0, 253, 0, 471, 426, 604, 233, 284, 458, - 432, 469, 440, 287, 0, 0, 470, 372, 585, 450, - 601, 630, 631, 263, 406, 615, 522, 623, 648, 226, - 260, 420, 506, 607, 494, 397, 581, 582, 329, 493, - 295, 201, 369, 636, 224, 479, 371, 242, 231, 587, - 612, 299, 289, 456, 643, 213, 517, 598, 239, 483, - 0, 0, 651, 247, 504, 610, 599, 215, 594, 503, - 393, 326, 327, 214, 0, 457, 268, 293, 0, 0, - 258, 415, 589, 590, 256, 652, 228, 622, 220, 0, - 621, 408, 584, 595, 394, 383, 219, 593, 392, 382, - 334, 355, 356, 280, 307, 447, 375, 448, 306, 308, - 404, 403, 405, 207, 608, 626, 0, 208, 0, 499, - 611, 653, 452, 212, 234, 235, 237, 0, 279, 283, - 291, 294, 303, 304, 313, 367, 419, 446, 442, 451, - 0, 579, 602, 616, 628, 634, 635, 637, 638, 639, - 640, 641, 644, 642, 407, 311, 495, 333, 373, 0, - 0, 425, 472, 240, 606, 496, 199, 0, 0, 0, - 0, 254, 255, 0, 575, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 654, 655, 656, 657, 658, 659, + 0, 0, 298, 0, 403, 258, 0, 454, 0, 0, + 0, 630, 0, 0, 0, 0, 0, 0, 0, 366, + 0, 331, 197, 225, 0, 0, 413, 462, 474, 0, + 0, 0, 254, 0, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 0, 0, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 590, 591, 257, 653, 228, 623, 220, + 0, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 356, 357, 281, 308, 448, 376, 449, 307, + 309, 405, 404, 406, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 0, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 0, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 0, 0, 426, 473, 240, 607, 497, 199, 0, 0, + 0, 0, 255, 256, 0, 576, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, - 670, 671, 649, 508, 514, 509, 510, 511, 512, 513, - 0, 515, 0, 0, 0, 0, 0, 398, 0, 591, - 592, 672, 384, 486, 603, 335, 349, 352, 341, 361, - 0, 362, 337, 338, 343, 346, 347, 348, 353, 354, - 358, 364, 249, 210, 390, 399, 578, 312, 216, 217, - 218, 524, 525, 526, 527, 619, 620, 624, 205, 462, - 463, 464, 465, 292, 614, 309, 468, 467, 331, 332, - 379, 449, 540, 542, 553, 557, 559, 561, 567, 570, - 541, 543, 554, 558, 560, 562, 568, 571, 530, 532, - 534, 536, 549, 548, 545, 573, 574, 551, 556, 535, - 547, 552, 565, 572, 569, 529, 533, 537, 546, 564, - 563, 544, 555, 566, 550, 538, 531, 539, 0, 196, - 221, 368, 0, 454, 288, 650, 618, 484, 613, 206, - 223, 0, 262, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 209, 222, 232, 236, - 243, 261, 276, 278, 285, 298, 310, 318, 319, 322, - 328, 380, 386, 387, 388, 389, 409, 410, 411, 414, - 417, 418, 421, 423, 424, 427, 431, 435, 436, 437, - 439, 441, 443, 455, 460, 474, 475, 476, 477, 478, - 481, 482, 488, 489, 490, 491, 492, 500, 501, 516, - 586, 588, 605, 625, 632, 480, 301, 302, 444, 445, - 314, 315, 646, 647, 300, 600, 633, 597, 645, 627, - 438, 378, 0, 0, 381, 281, 305, 320, 0, 617, - 502, 227, 466, 290, 251, 0, 0, 211, 246, 230, - 259, 274, 277, 324, 391, 400, 429, 434, 296, 271, - 244, 459, 241, 485, 519, 520, 521, 523, 395, 266, - 433, 396, 0, 376, 576, 577, 316, 0, 0, 0, - 528, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 416, 0, 0, 0, 0, 0, 0, 0, - 270, 0, 0, 0, 0, 366, 267, 0, 0, 204, - 505, 0, 430, 0, 203, 0, 487, 252, 377, 374, - 583, 282, 273, 269, 250, 317, 385, 428, 518, 422, - 0, 370, 0, 0, 497, 401, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 323, 248, 325, 202, 413, 498, - 286, 0, 1887, 0, 0, 0, 507, 724, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 238, 0, 0, - 245, 0, 0, 0, 351, 360, 359, 339, 340, 342, - 344, 350, 357, 363, 336, 345, 0, 0, 609, 0, - 0, 0, 265, 321, 272, 264, 580, 0, 0, 0, - 0, 0, 0, 596, 0, 0, 229, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 275, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 297, 0, 402, 257, 0, 453, 0, - 0, 0, 629, 0, 0, 0, 0, 0, 0, 0, - 365, 0, 330, 197, 225, 0, 0, 412, 461, 473, - 0, 0, 0, 253, 0, 471, 426, 604, 233, 284, - 458, 432, 469, 440, 287, 0, 0, 470, 372, 585, - 450, 601, 630, 631, 263, 406, 615, 522, 623, 648, - 226, 260, 420, 506, 607, 494, 397, 581, 582, 329, - 493, 295, 201, 369, 636, 224, 479, 371, 242, 231, - 587, 612, 299, 289, 456, 643, 213, 517, 598, 239, - 483, 0, 0, 651, 247, 504, 610, 599, 215, 594, - 503, 393, 326, 327, 214, 0, 457, 268, 293, 0, - 0, 258, 415, 589, 590, 256, 652, 228, 622, 220, - 0, 621, 408, 584, 595, 394, 383, 219, 593, 392, - 382, 334, 355, 356, 280, 307, 447, 375, 448, 306, - 308, 404, 403, 405, 207, 608, 626, 0, 208, 0, - 499, 611, 653, 452, 212, 234, 235, 237, 0, 279, - 283, 291, 294, 303, 304, 313, 367, 419, 446, 442, - 451, 0, 579, 602, 616, 628, 634, 635, 637, 638, - 639, 640, 641, 644, 642, 407, 311, 495, 333, 373, - 0, 0, 425, 472, 240, 606, 496, 199, 0, 0, - 0, 0, 254, 255, 0, 575, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 654, 655, 656, 657, 658, - 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, - 669, 670, 671, 649, 508, 514, 509, 510, 511, 512, - 513, 0, 515, 0, 0, 0, 0, 0, 398, 0, - 591, 592, 672, 384, 486, 603, 335, 349, 352, 341, - 361, 0, 362, 337, 338, 343, 346, 347, 348, 353, - 354, 358, 364, 249, 210, 390, 399, 578, 312, 216, - 217, 218, 524, 525, 526, 527, 619, 620, 624, 205, - 462, 463, 464, 465, 292, 614, 309, 468, 467, 331, - 332, 379, 449, 540, 542, 553, 557, 559, 561, 567, - 570, 541, 543, 554, 558, 560, 562, 568, 571, 530, - 532, 534, 536, 549, 548, 545, 573, 574, 551, 556, - 535, 547, 552, 565, 572, 569, 529, 533, 537, 546, - 564, 563, 544, 555, 566, 550, 538, 531, 539, 0, - 196, 221, 368, 0, 454, 288, 650, 618, 484, 613, - 206, 223, 0, 262, 0, 0, 0, 0, 0, 0, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 0, 0, 0, 0, 0, 399, 0, + 592, 593, 673, 385, 487, 604, 336, 350, 353, 342, + 362, 0, 363, 338, 339, 344, 347, 348, 349, 354, + 355, 359, 365, 249, 210, 391, 400, 579, 313, 216, + 217, 218, 525, 526, 527, 528, 620, 621, 625, 205, + 463, 464, 465, 466, 293, 615, 310, 469, 468, 332, + 333, 380, 450, 541, 543, 554, 558, 560, 562, 568, + 571, 542, 544, 555, 559, 561, 563, 569, 572, 531, + 533, 535, 537, 550, 549, 546, 574, 575, 552, 557, + 536, 548, 553, 566, 573, 570, 530, 534, 538, 547, + 565, 564, 545, 556, 567, 551, 539, 532, 540, 0, + 196, 221, 369, 0, 455, 289, 651, 619, 485, 614, + 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, - 236, 243, 261, 276, 278, 285, 298, 310, 318, 319, - 322, 328, 380, 386, 387, 388, 389, 409, 410, 411, - 414, 417, 418, 421, 423, 424, 427, 431, 435, 436, - 437, 439, 441, 443, 455, 460, 474, 475, 476, 477, - 478, 481, 482, 488, 489, 490, 491, 492, 500, 501, - 516, 586, 588, 605, 625, 632, 480, 301, 302, 444, - 445, 314, 315, 646, 647, 300, 600, 633, 597, 645, - 627, 438, 378, 0, 0, 381, 281, 305, 320, 0, - 617, 502, 227, 466, 290, 251, 0, 0, 211, 246, - 230, 259, 274, 277, 324, 391, 400, 429, 434, 296, - 271, 244, 459, 241, 485, 519, 520, 521, 523, 395, - 266, 433, 396, 0, 376, 576, 577, 316, 0, 0, - 0, 528, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 416, 0, 0, 0, 0, 0, 0, - 1784, 270, 0, 0, 0, 0, 366, 267, 0, 0, - 204, 505, 0, 430, 0, 203, 0, 487, 252, 377, - 374, 583, 282, 273, 269, 250, 317, 385, 428, 518, - 422, 0, 370, 0, 0, 497, 401, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 323, 248, 325, 202, 413, - 498, 286, 0, 0, 0, 0, 0, 507, 194, 0, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 302, 303, 445, + 446, 315, 316, 647, 648, 301, 601, 634, 598, 646, + 628, 439, 379, 0, 0, 382, 282, 306, 321, 0, + 618, 503, 227, 467, 291, 251, 0, 0, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 397, 0, 377, 577, 578, 317, 0, 0, + 0, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 0, 0, 0, + 0, 271, 0, 0, 0, 0, 367, 268, 0, 1927, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 0, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 0, 0, 0, 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, - 0, 245, 0, 0, 0, 351, 360, 359, 339, 340, - 342, 344, 350, 357, 363, 336, 345, 0, 0, 609, - 0, 0, 0, 265, 321, 272, 264, 580, 0, 0, - 0, 0, 0, 0, 596, 0, 0, 229, 0, 0, + 0, 245, 0, 0, 0, 352, 361, 360, 340, 341, + 343, 345, 351, 358, 364, 337, 346, 0, 0, 610, + 0, 0, 0, 266, 322, 273, 265, 581, 0, 0, + 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 275, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6714,147 +6161,221 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 297, 0, 402, 257, 0, 453, - 0, 0, 0, 629, 0, 0, 0, 0, 0, 0, - 0, 365, 0, 330, 197, 225, 0, 0, 412, 461, - 473, 0, 0, 0, 253, 0, 471, 426, 604, 233, - 284, 458, 432, 469, 440, 287, 0, 0, 470, 372, - 585, 450, 601, 630, 631, 263, 406, 615, 522, 623, - 648, 226, 260, 420, 506, 607, 494, 397, 581, 582, - 329, 493, 295, 201, 369, 636, 224, 479, 371, 242, - 231, 587, 612, 299, 289, 456, 643, 213, 517, 598, - 239, 483, 0, 0, 651, 247, 504, 610, 599, 215, - 594, 503, 393, 326, 327, 214, 0, 457, 268, 293, - 0, 0, 258, 415, 589, 590, 256, 652, 228, 622, - 220, 0, 621, 408, 584, 595, 394, 383, 219, 593, - 392, 382, 334, 355, 356, 280, 307, 447, 375, 448, - 306, 308, 404, 403, 405, 207, 608, 626, 0, 208, - 0, 499, 611, 653, 452, 212, 234, 235, 237, 0, - 279, 283, 291, 294, 303, 304, 313, 367, 419, 446, - 442, 451, 0, 579, 602, 616, 628, 634, 635, 637, - 638, 639, 640, 641, 644, 642, 407, 311, 495, 333, - 373, 0, 0, 425, 472, 240, 606, 496, 199, 0, - 0, 0, 0, 254, 255, 0, 575, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 654, 655, 656, 657, + 0, 0, 0, 0, 298, 0, 403, 258, 0, 454, + 0, 0, 0, 630, 0, 0, 0, 0, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 254, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 590, 591, 257, 653, 228, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 356, 357, 281, 308, 448, 376, + 449, 307, 309, 405, 404, 406, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 199, + 0, 0, 0, 0, 255, 256, 0, 576, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, - 668, 669, 670, 671, 649, 508, 514, 509, 510, 511, - 512, 513, 0, 515, 0, 0, 0, 0, 0, 398, - 0, 591, 592, 672, 384, 486, 603, 335, 349, 352, - 341, 361, 0, 362, 337, 338, 343, 346, 347, 348, - 353, 354, 358, 364, 249, 210, 390, 399, 578, 312, - 216, 217, 218, 524, 525, 526, 527, 619, 620, 624, - 205, 462, 463, 464, 465, 292, 614, 309, 468, 467, - 331, 332, 379, 449, 540, 542, 553, 557, 559, 561, - 567, 570, 541, 543, 554, 558, 560, 562, 568, 571, - 530, 532, 534, 536, 549, 548, 545, 573, 574, 551, - 556, 535, 547, 552, 565, 572, 569, 529, 533, 537, - 546, 564, 563, 544, 555, 566, 550, 538, 531, 539, - 0, 196, 221, 368, 0, 454, 288, 650, 618, 484, - 613, 206, 223, 0, 262, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 198, 200, 209, 222, - 232, 236, 243, 261, 276, 278, 285, 298, 310, 318, - 319, 322, 328, 380, 386, 387, 388, 389, 409, 410, - 411, 414, 417, 418, 421, 423, 424, 427, 431, 435, - 436, 437, 439, 441, 443, 455, 460, 474, 475, 476, - 477, 478, 481, 482, 488, 489, 490, 491, 492, 500, - 501, 516, 586, 588, 605, 625, 632, 480, 301, 302, - 444, 445, 314, 315, 646, 647, 300, 600, 633, 597, - 645, 627, 438, 378, 0, 0, 381, 281, 305, 320, - 0, 617, 502, 227, 466, 290, 251, 0, 0, 211, - 246, 230, 259, 274, 277, 324, 391, 400, 429, 434, - 296, 271, 244, 459, 241, 485, 519, 520, 521, 523, - 395, 266, 433, 396, 0, 376, 576, 577, 316, 0, - 0, 0, 528, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 416, 0, 0, 0, 0, 0, - 0, 0, 270, 0, 0, 0, 0, 366, 267, 0, - 0, 204, 505, 0, 430, 0, 203, 0, 487, 252, - 377, 374, 583, 282, 273, 269, 250, 317, 385, 428, - 518, 422, 0, 370, 0, 0, 497, 401, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 323, 248, 325, 202, - 413, 498, 286, 0, 95, 0, 0, 0, 507, 959, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 238, - 0, 0, 245, 0, 0, 0, 351, 360, 359, 339, - 340, 342, 344, 350, 357, 363, 336, 345, 0, 0, - 609, 0, 0, 0, 265, 321, 272, 264, 580, 0, - 0, 0, 0, 0, 0, 596, 0, 0, 229, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 275, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 297, 0, 402, 257, 0, - 453, 0, 0, 0, 629, 0, 0, 0, 0, 0, - 0, 0, 365, 0, 330, 197, 225, 0, 0, 412, - 461, 473, 0, 0, 0, 253, 0, 471, 426, 604, - 233, 284, 458, 432, 469, 440, 287, 0, 0, 470, - 372, 585, 450, 601, 630, 631, 263, 406, 615, 522, - 623, 648, 226, 260, 420, 506, 607, 494, 397, 581, - 582, 329, 493, 295, 201, 369, 636, 224, 479, 371, - 242, 231, 587, 612, 299, 289, 456, 643, 213, 517, - 598, 239, 483, 0, 0, 651, 247, 504, 610, 599, - 215, 594, 503, 393, 326, 327, 214, 0, 457, 268, - 293, 0, 0, 258, 415, 589, 590, 256, 652, 228, - 622, 220, 0, 621, 408, 584, 595, 394, 383, 219, - 593, 392, 382, 334, 355, 356, 280, 307, 447, 375, - 448, 306, 308, 404, 403, 405, 207, 608, 626, 0, - 208, 0, 499, 611, 653, 452, 212, 234, 235, 237, - 0, 279, 283, 291, 294, 303, 304, 313, 367, 419, - 446, 442, 451, 0, 579, 602, 616, 628, 634, 635, - 637, 638, 639, 640, 641, 644, 642, 407, 311, 495, - 333, 373, 0, 0, 425, 472, 240, 606, 496, 199, - 0, 0, 0, 0, 254, 255, 0, 575, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 654, 655, 656, - 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, - 667, 668, 669, 670, 671, 649, 508, 514, 509, 510, - 511, 512, 513, 0, 515, 0, 0, 0, 0, 0, - 398, 0, 591, 592, 672, 384, 486, 603, 335, 349, - 352, 341, 361, 0, 362, 337, 338, 343, 346, 347, - 348, 353, 354, 358, 364, 249, 210, 390, 399, 578, - 312, 216, 217, 218, 524, 525, 526, 527, 619, 620, - 624, 205, 462, 463, 464, 465, 292, 614, 309, 468, - 467, 331, 332, 379, 449, 540, 542, 553, 557, 559, - 561, 567, 570, 541, 543, 554, 558, 560, 562, 568, - 571, 530, 532, 534, 536, 549, 548, 545, 573, 574, - 551, 556, 535, 547, 552, 565, 572, 569, 529, 533, - 537, 546, 564, 563, 544, 555, 566, 550, 538, 531, - 539, 0, 196, 221, 368, 0, 454, 288, 650, 618, - 484, 613, 206, 223, 0, 262, 0, 0, 0, 0, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 0, 0, 0, 0, 0, + 399, 0, 592, 593, 673, 385, 487, 604, 336, 350, + 353, 342, 362, 0, 363, 338, 339, 344, 347, 348, + 349, 354, 355, 359, 365, 249, 210, 391, 400, 579, + 313, 216, 217, 218, 525, 526, 527, 528, 620, 621, + 625, 205, 463, 464, 465, 466, 293, 615, 310, 469, + 468, 332, 333, 380, 450, 541, 543, 554, 558, 560, + 562, 568, 571, 542, 544, 555, 559, 561, 563, 569, + 572, 531, 533, 535, 537, 550, 549, 546, 574, 575, + 552, 557, 536, 548, 553, 566, 573, 570, 530, 534, + 538, 547, 565, 564, 545, 556, 567, 551, 539, 532, + 540, 0, 196, 221, 369, 0, 455, 289, 651, 619, + 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, - 222, 232, 236, 243, 261, 276, 278, 285, 298, 310, - 318, 319, 322, 328, 380, 386, 387, 388, 389, 409, - 410, 411, 414, 417, 418, 421, 423, 424, 427, 431, - 435, 436, 437, 439, 441, 443, 455, 460, 474, 475, - 476, 477, 478, 481, 482, 488, 489, 490, 491, 492, - 500, 501, 516, 586, 588, 605, 625, 632, 480, 301, - 302, 444, 445, 314, 315, 646, 647, 300, 600, 633, - 597, 645, 627, 438, 378, 0, 0, 381, 281, 305, - 320, 0, 617, 502, 227, 466, 290, 251, 0, 0, - 211, 246, 230, 259, 274, 277, 324, 391, 400, 429, - 434, 296, 271, 244, 459, 241, 485, 519, 520, 521, - 523, 395, 266, 433, 396, 0, 376, 576, 577, 316, - 0, 0, 0, 528, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 416, 0, 0, 0, 0, - 0, 0, 0, 270, 0, 0, 0, 0, 366, 267, - 0, 0, 204, 505, 0, 430, 0, 203, 0, 487, - 252, 377, 374, 583, 282, 273, 269, 250, 317, 385, - 428, 518, 422, 0, 370, 0, 0, 497, 401, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 323, 248, 325, - 202, 413, 498, 286, 0, 0, 0, 0, 0, 507, - 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 238, 0, 0, 245, 0, 0, 0, 351, 360, 359, - 339, 340, 342, 344, 350, 357, 363, 336, 345, 0, - 0, 609, 0, 0, 0, 265, 321, 272, 264, 580, - 0, 0, 0, 0, 0, 0, 596, 0, 0, 229, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 302, + 303, 445, 446, 315, 316, 647, 648, 301, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 0, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 0, + 0, 0, 0, 271, 0, 0, 0, 0, 367, 268, + 0, 1925, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 0, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 0, 0, 0, 0, 508, + 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 238, 0, 0, 245, 0, 0, 0, 352, 361, 360, + 340, 341, 343, 345, 351, 358, 364, 337, 346, 0, + 0, 610, 0, 0, 0, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 0, 0, 0, 630, 0, 0, 0, 0, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 254, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 590, 591, 257, + 653, 228, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 356, 357, 281, 308, + 448, 376, 449, 307, 309, 405, 404, 406, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 199, 0, 0, 0, 0, 255, 256, 0, 576, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 655, + 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 0, 0, 0, + 0, 0, 399, 0, 592, 593, 673, 385, 487, 604, + 336, 350, 353, 342, 362, 0, 363, 338, 339, 344, + 347, 348, 349, 354, 355, 359, 365, 249, 210, 391, + 400, 579, 313, 216, 217, 218, 525, 526, 527, 528, + 620, 621, 625, 205, 463, 464, 465, 466, 293, 615, + 310, 469, 468, 332, 333, 380, 450, 541, 543, 554, + 558, 560, 562, 568, 571, 542, 544, 555, 559, 561, + 563, 569, 572, 531, 533, 535, 537, 550, 549, 546, + 574, 575, 552, 557, 536, 548, 553, 566, 573, 570, + 530, 534, 538, 547, 565, 564, 545, 556, 567, 551, + 539, 532, 540, 0, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 275, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 302, 303, 445, 446, 315, 316, 647, 648, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 0, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 397, 0, 377, 577, + 578, 317, 0, 0, 0, 529, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, + 0, 0, 0, 0, 0, 271, 0, 0, 0, 0, + 367, 268, 0, 1923, 204, 506, 0, 431, 0, 203, + 0, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 0, 371, 0, 0, 498, + 402, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 248, 326, 202, 414, 499, 287, 0, 0, 0, 0, + 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 238, 0, 0, 245, 0, 0, 0, 352, + 361, 360, 340, 341, 343, 345, 351, 358, 364, 337, + 346, 0, 0, 610, 0, 0, 0, 266, 322, 273, + 265, 581, 0, 0, 0, 0, 0, 0, 597, 0, + 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 403, 258, 0, 454, 0, 0, 0, 630, 0, 0, + 0, 0, 0, 0, 0, 366, 0, 331, 197, 225, + 0, 0, 413, 462, 474, 0, 0, 0, 254, 0, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 0, 0, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 590, + 591, 257, 653, 228, 623, 220, 0, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 356, 357, + 281, 308, 448, 376, 449, 307, 309, 405, 404, 406, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 0, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 0, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 0, 0, 426, 473, + 240, 607, 497, 199, 0, 0, 0, 0, 255, 256, + 0, 576, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 0, + 0, 0, 0, 0, 399, 0, 592, 593, 673, 385, + 487, 604, 336, 350, 353, 342, 362, 0, 363, 338, + 339, 344, 347, 348, 349, 354, 355, 359, 365, 249, + 210, 391, 400, 579, 313, 216, 217, 218, 525, 526, + 527, 528, 620, 621, 625, 205, 463, 464, 465, 466, + 293, 615, 310, 469, 468, 332, 333, 380, 450, 541, + 543, 554, 558, 560, 562, 568, 571, 542, 544, 555, + 559, 561, 563, 569, 572, 531, 533, 535, 537, 550, + 549, 546, 574, 575, 552, 557, 536, 548, 553, 566, + 573, 570, 530, 534, 538, 547, 565, 564, 545, 556, + 567, 551, 539, 532, 540, 0, 196, 221, 369, 0, + 455, 289, 651, 619, 485, 614, 206, 223, 0, 263, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 302, 303, 445, 446, 315, 316, 647, + 648, 301, 601, 634, 598, 646, 628, 439, 379, 0, + 0, 382, 282, 306, 321, 0, 618, 503, 227, 467, + 291, 251, 0, 0, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 397, 0, + 377, 577, 578, 317, 0, 0, 0, 529, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 0, 0, 0, 0, 271, 0, 0, + 0, 0, 367, 268, 0, 1921, 204, 506, 0, 431, + 0, 203, 0, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 0, 371, 0, + 0, 498, 402, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 248, 326, 202, 414, 499, 287, 0, 0, + 0, 0, 0, 508, 725, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 238, 0, 0, 245, 0, 0, + 0, 352, 361, 360, 340, 341, 343, 345, 351, 358, + 364, 337, 346, 0, 0, 610, 0, 0, 0, 266, + 322, 273, 265, 581, 0, 0, 0, 0, 0, 0, + 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6862,525 +6383,1049 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1456, 0, 297, 0, 402, 257, - 0, 453, 0, 0, 0, 629, 0, 0, 0, 0, - 0, 0, 0, 365, 0, 330, 197, 225, 0, 0, - 412, 461, 473, 0, 0, 0, 253, 0, 471, 426, - 604, 233, 284, 458, 432, 469, 440, 287, 0, 0, - 470, 372, 585, 450, 601, 630, 631, 263, 406, 615, - 522, 623, 648, 226, 260, 420, 506, 607, 494, 397, - 581, 582, 329, 493, 295, 201, 369, 636, 224, 479, - 371, 242, 231, 587, 612, 299, 289, 456, 643, 213, - 517, 598, 239, 483, 0, 0, 651, 247, 504, 610, - 599, 215, 594, 503, 393, 326, 327, 214, 0, 457, - 268, 293, 0, 0, 258, 415, 589, 590, 256, 652, - 228, 622, 220, 0, 621, 408, 584, 595, 394, 383, - 219, 593, 392, 382, 334, 355, 356, 280, 307, 447, - 375, 448, 306, 308, 404, 403, 405, 207, 608, 626, - 0, 208, 0, 499, 611, 653, 452, 212, 234, 235, - 237, 0, 279, 283, 291, 294, 303, 304, 313, 367, - 419, 446, 442, 451, 0, 579, 602, 616, 628, 634, - 635, 637, 638, 639, 640, 641, 644, 642, 407, 311, - 495, 333, 373, 0, 0, 425, 472, 240, 606, 496, - 199, 0, 0, 0, 0, 254, 255, 0, 575, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 654, 655, - 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, - 666, 667, 668, 669, 670, 671, 649, 508, 514, 509, - 510, 511, 512, 513, 0, 515, 0, 0, 0, 0, - 0, 398, 0, 591, 592, 672, 384, 486, 603, 335, - 349, 352, 341, 361, 0, 362, 337, 338, 343, 346, - 347, 348, 353, 354, 358, 364, 249, 210, 390, 399, - 578, 312, 216, 217, 218, 524, 525, 526, 527, 619, - 620, 624, 205, 462, 463, 464, 465, 292, 614, 309, - 468, 467, 331, 332, 379, 449, 540, 542, 553, 557, - 559, 561, 567, 570, 541, 543, 554, 558, 560, 562, - 568, 571, 530, 532, 534, 536, 549, 548, 545, 573, - 574, 551, 556, 535, 547, 552, 565, 572, 569, 529, - 533, 537, 546, 564, 563, 544, 555, 566, 550, 538, - 531, 539, 0, 196, 221, 368, 0, 454, 288, 650, - 618, 484, 613, 206, 223, 0, 262, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 198, 200, - 209, 222, 232, 236, 243, 261, 276, 278, 285, 298, - 310, 318, 319, 322, 328, 380, 386, 387, 388, 389, - 409, 410, 411, 414, 417, 418, 421, 423, 424, 427, - 431, 435, 436, 437, 439, 441, 443, 455, 460, 474, - 475, 476, 477, 478, 481, 482, 488, 489, 490, 491, - 492, 500, 501, 516, 586, 588, 605, 625, 632, 480, - 301, 302, 444, 445, 314, 315, 646, 647, 1455, 600, - 633, 597, 645, 627, 438, 378, 0, 0, 381, 281, - 305, 320, 0, 617, 502, 227, 466, 290, 251, 0, - 0, 211, 246, 230, 259, 274, 277, 324, 391, 400, - 429, 434, 296, 271, 244, 459, 241, 485, 519, 520, - 521, 523, 395, 266, 433, 396, 0, 376, 576, 577, - 316, 0, 0, 0, 528, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 416, 0, 0, 0, - 0, 0, 0, 0, 270, 0, 0, 0, 0, 366, - 267, 0, 0, 204, 505, 0, 430, 0, 203, 0, - 487, 252, 377, 374, 583, 282, 273, 269, 250, 317, - 385, 428, 518, 422, 0, 370, 0, 0, 497, 401, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 323, 248, - 325, 202, 413, 498, 286, 0, 0, 0, 0, 0, - 507, 194, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 238, 0, 0, 245, 0, 0, 0, 351, 360, - 359, 339, 340, 342, 344, 350, 357, 363, 336, 345, - 0, 0, 609, 0, 0, 0, 265, 321, 272, 264, - 580, 0, 0, 0, 0, 0, 0, 596, 0, 0, - 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 275, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 297, 0, 402, - 257, 0, 453, 0, 0, 0, 629, 0, 0, 0, - 0, 0, 0, 0, 365, 0, 330, 197, 225, 0, - 0, 412, 461, 473, 0, 0, 0, 253, 0, 471, - 426, 604, 233, 284, 458, 432, 469, 440, 287, 0, - 0, 470, 372, 585, 450, 601, 630, 631, 263, 406, - 615, 522, 623, 648, 226, 260, 420, 506, 607, 494, - 397, 581, 582, 329, 493, 295, 201, 369, 636, 224, - 479, 371, 242, 231, 587, 612, 299, 289, 456, 643, - 213, 517, 598, 239, 483, 0, 0, 651, 247, 504, - 610, 599, 215, 594, 503, 393, 326, 327, 214, 0, - 457, 268, 293, 0, 0, 258, 415, 589, 590, 256, - 652, 228, 622, 220, 0, 621, 408, 584, 595, 394, - 383, 219, 593, 392, 382, 334, 355, 356, 280, 307, - 447, 375, 448, 306, 308, 404, 403, 405, 207, 608, - 626, 0, 208, 0, 499, 611, 653, 452, 212, 234, - 235, 237, 0, 279, 283, 291, 294, 303, 304, 313, - 367, 419, 446, 442, 451, 0, 579, 602, 616, 628, - 634, 635, 637, 638, 639, 640, 641, 644, 642, 407, - 311, 495, 333, 373, 0, 0, 425, 472, 240, 606, - 496, 199, 0, 0, 0, 0, 254, 255, 0, 575, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 654, - 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, - 665, 666, 667, 668, 669, 670, 671, 649, 508, 514, - 509, 510, 511, 512, 513, 0, 515, 0, 0, 0, - 0, 0, 398, 0, 591, 592, 672, 384, 486, 603, - 335, 349, 352, 341, 361, 0, 362, 337, 338, 343, - 346, 347, 348, 353, 354, 358, 364, 249, 210, 390, - 399, 578, 312, 216, 217, 218, 524, 525, 526, 527, - 619, 620, 624, 205, 462, 463, 464, 465, 292, 614, - 309, 468, 467, 331, 332, 379, 449, 540, 542, 553, - 557, 559, 561, 567, 570, 541, 543, 554, 558, 560, - 562, 568, 571, 530, 532, 534, 536, 549, 548, 545, - 573, 574, 551, 556, 535, 547, 552, 565, 572, 569, - 529, 533, 537, 546, 564, 563, 544, 555, 566, 550, - 538, 531, 539, 0, 196, 221, 368, 0, 454, 288, - 650, 618, 484, 613, 206, 223, 0, 262, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1049, 0, 0, 0, 198, - 200, 209, 222, 232, 236, 243, 261, 276, 278, 285, - 298, 310, 318, 319, 322, 328, 380, 386, 387, 388, - 389, 409, 410, 411, 414, 417, 418, 421, 423, 424, - 427, 431, 435, 436, 437, 439, 441, 443, 455, 460, - 474, 475, 476, 477, 478, 481, 482, 488, 489, 490, - 491, 492, 500, 501, 516, 586, 588, 605, 625, 632, - 480, 301, 302, 444, 445, 314, 315, 646, 647, 300, - 600, 633, 597, 645, 627, 438, 378, 0, 0, 381, - 281, 305, 320, 0, 617, 502, 227, 466, 290, 251, - 0, 0, 211, 246, 230, 259, 274, 277, 324, 391, - 400, 429, 434, 296, 271, 244, 459, 241, 485, 519, - 520, 521, 523, 395, 266, 433, 396, 0, 376, 576, - 577, 316, 0, 0, 0, 528, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 416, 0, 0, - 0, 0, 0, 0, 0, 270, 0, 0, 0, 0, - 366, 267, 0, 0, 204, 505, 0, 430, 0, 203, - 0, 487, 252, 377, 374, 583, 282, 273, 269, 250, - 317, 385, 428, 518, 422, 0, 370, 0, 0, 497, - 401, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 323, - 248, 325, 202, 413, 498, 286, 0, 0, 0, 0, - 0, 507, 194, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 238, 0, 0, 245, 0, 0, 0, 351, - 360, 359, 339, 340, 342, 344, 350, 357, 363, 336, - 345, 0, 0, 609, 0, 0, 0, 265, 321, 272, - 264, 580, 0, 0, 0, 0, 0, 0, 596, 0, - 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 275, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 297, 0, - 402, 257, 0, 453, 0, 675, 0, 629, 0, 0, - 0, 0, 0, 0, 0, 365, 0, 330, 197, 225, - 0, 0, 412, 461, 473, 0, 0, 0, 253, 0, - 471, 426, 604, 233, 284, 458, 432, 469, 440, 287, - 0, 0, 470, 372, 585, 450, 601, 630, 631, 263, - 406, 615, 522, 623, 648, 226, 260, 420, 506, 607, - 494, 397, 581, 582, 329, 493, 295, 201, 369, 636, - 224, 479, 371, 242, 231, 587, 612, 299, 289, 456, - 643, 213, 517, 598, 239, 483, 0, 0, 651, 247, - 504, 610, 599, 215, 594, 503, 393, 326, 327, 214, - 0, 457, 268, 293, 0, 0, 258, 415, 589, 590, - 256, 652, 228, 622, 220, 0, 621, 408, 584, 595, - 394, 383, 219, 593, 392, 382, 334, 355, 356, 280, - 307, 447, 375, 448, 306, 308, 404, 403, 405, 207, - 608, 626, 0, 208, 0, 499, 611, 653, 452, 212, - 234, 235, 237, 0, 279, 283, 291, 294, 303, 304, - 313, 367, 419, 446, 442, 451, 0, 579, 602, 616, - 628, 634, 635, 637, 638, 639, 640, 641, 644, 642, - 407, 311, 495, 333, 373, 0, 0, 425, 472, 240, - 606, 496, 199, 0, 0, 0, 0, 254, 255, 0, - 575, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, - 664, 665, 666, 667, 668, 669, 670, 671, 649, 508, - 514, 509, 510, 511, 512, 513, 0, 515, 0, 0, - 0, 0, 0, 398, 0, 591, 592, 672, 384, 486, - 603, 335, 349, 352, 341, 361, 0, 362, 337, 338, - 343, 346, 347, 348, 353, 354, 358, 364, 249, 210, - 390, 399, 578, 312, 216, 217, 218, 524, 525, 526, - 527, 619, 620, 624, 205, 462, 463, 464, 465, 292, - 614, 309, 468, 467, 331, 332, 379, 449, 540, 542, - 553, 557, 559, 561, 567, 570, 541, 543, 554, 558, - 560, 562, 568, 571, 530, 532, 534, 536, 549, 548, - 545, 573, 574, 551, 556, 535, 547, 552, 565, 572, - 569, 529, 533, 537, 546, 564, 563, 544, 555, 566, - 550, 538, 531, 539, 0, 196, 221, 368, 0, 454, - 288, 650, 618, 484, 613, 206, 223, 0, 262, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 198, 200, 209, 222, 232, 236, 243, 261, 276, 278, - 285, 298, 310, 318, 319, 322, 328, 380, 386, 387, - 388, 389, 409, 410, 411, 414, 417, 418, 421, 423, - 424, 427, 431, 435, 436, 437, 439, 441, 443, 455, - 460, 474, 475, 476, 477, 478, 481, 482, 488, 489, - 490, 491, 492, 500, 501, 516, 586, 588, 605, 625, - 632, 480, 301, 302, 444, 445, 314, 315, 646, 647, - 300, 600, 633, 597, 645, 627, 438, 378, 0, 0, - 381, 281, 305, 320, 0, 617, 502, 227, 466, 290, - 251, 0, 0, 211, 246, 230, 259, 274, 277, 324, - 391, 400, 429, 434, 296, 271, 244, 459, 241, 485, - 519, 520, 521, 523, 395, 266, 433, 396, 0, 376, - 576, 577, 316, 0, 0, 0, 528, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 416, 0, - 0, 0, 0, 0, 0, 0, 270, 0, 0, 0, - 0, 366, 267, 0, 0, 204, 505, 0, 430, 0, - 203, 0, 487, 252, 377, 374, 583, 282, 273, 269, - 250, 317, 385, 428, 518, 422, 0, 370, 0, 0, - 497, 401, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 323, 248, 325, 202, 413, 498, 286, 0, 0, 0, - 0, 0, 507, 724, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 238, 0, 0, 245, 0, 0, 0, - 351, 360, 359, 339, 340, 342, 344, 350, 357, 363, - 336, 345, 0, 0, 609, 0, 0, 0, 265, 321, - 272, 264, 580, 0, 0, 0, 0, 0, 0, 596, - 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 275, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 297, - 0, 402, 257, 0, 453, 0, 0, 0, 629, 0, - 0, 0, 0, 0, 0, 0, 365, 0, 330, 197, - 225, 0, 0, 412, 461, 473, 0, 0, 0, 253, - 0, 471, 426, 604, 233, 284, 458, 432, 469, 440, - 287, 0, 0, 470, 372, 585, 450, 601, 630, 631, - 263, 406, 615, 522, 623, 648, 226, 260, 420, 506, - 607, 494, 397, 581, 582, 329, 493, 295, 201, 369, - 636, 224, 479, 371, 242, 231, 587, 612, 299, 289, - 456, 643, 213, 517, 598, 239, 483, 0, 0, 651, - 247, 504, 610, 599, 215, 594, 503, 393, 326, 327, - 214, 0, 457, 268, 293, 0, 0, 258, 415, 589, - 590, 256, 652, 228, 622, 220, 0, 621, 408, 584, - 595, 394, 383, 219, 593, 392, 382, 334, 355, 356, - 280, 307, 447, 375, 448, 306, 308, 404, 403, 405, - 207, 608, 626, 0, 208, 0, 499, 611, 653, 452, - 212, 234, 235, 237, 0, 279, 283, 291, 294, 303, - 304, 313, 367, 419, 446, 442, 451, 0, 579, 602, - 616, 628, 634, 635, 637, 638, 639, 640, 641, 644, - 642, 407, 311, 495, 333, 373, 0, 0, 425, 472, - 240, 606, 496, 199, 0, 0, 0, 0, 254, 255, - 0, 575, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 654, 655, 656, 657, 658, 659, 660, 661, 662, - 663, 664, 665, 666, 667, 668, 669, 670, 671, 649, - 508, 514, 509, 510, 511, 512, 513, 0, 515, 0, - 0, 0, 0, 0, 398, 0, 591, 592, 672, 384, - 486, 603, 335, 349, 352, 341, 361, 0, 362, 337, - 338, 343, 346, 347, 348, 353, 354, 358, 364, 249, - 210, 390, 399, 578, 312, 216, 217, 218, 524, 525, - 526, 527, 619, 620, 624, 205, 462, 463, 464, 465, - 292, 614, 309, 468, 467, 331, 332, 379, 449, 540, - 542, 553, 557, 559, 561, 567, 570, 541, 543, 554, - 558, 560, 562, 568, 571, 530, 532, 534, 536, 549, - 548, 545, 573, 574, 551, 556, 535, 547, 552, 565, - 572, 569, 529, 533, 537, 546, 564, 563, 544, 555, - 566, 550, 538, 531, 539, 0, 196, 221, 368, 0, - 454, 288, 650, 618, 484, 613, 206, 223, 0, 262, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 198, 200, 209, 222, 232, 236, 243, 261, 276, - 278, 285, 298, 310, 318, 319, 322, 328, 380, 386, - 387, 388, 389, 4136, 410, 411, 414, 417, 418, 421, - 423, 424, 427, 431, 435, 436, 437, 439, 441, 443, - 455, 460, 474, 475, 476, 477, 478, 481, 482, 488, - 489, 490, 491, 492, 500, 501, 516, 586, 588, 605, - 625, 632, 480, 301, 302, 444, 445, 314, 315, 646, - 647, 300, 600, 633, 597, 645, 627, 438, 378, 0, - 0, 381, 281, 305, 320, 0, 617, 502, 227, 466, - 290, 251, 0, 0, 211, 246, 230, 259, 274, 277, - 324, 391, 400, 429, 434, 296, 271, 244, 459, 241, - 485, 519, 520, 521, 523, 395, 266, 433, 396, 0, - 376, 576, 577, 316, 0, 0, 0, 528, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 416, - 0, 0, 0, 0, 0, 0, 0, 270, 0, 0, - 0, 0, 366, 267, 0, 0, 204, 505, 0, 430, - 0, 203, 0, 487, 252, 377, 374, 583, 282, 273, - 269, 250, 317, 385, 428, 518, 422, 0, 370, 0, - 0, 497, 401, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 323, 248, 325, 202, 413, 498, 286, 0, 0, - 0, 0, 0, 507, 724, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 238, 0, 0, 245, 0, 0, - 0, 351, 360, 359, 339, 340, 342, 344, 350, 357, - 363, 336, 345, 0, 0, 609, 0, 0, 0, 265, - 321, 272, 264, 580, 0, 0, 0, 0, 0, 0, - 596, 0, 0, 229, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 298, 0, 403, 258, 0, 454, 0, 0, 0, 630, + 0, 0, 0, 0, 0, 0, 0, 366, 0, 331, + 197, 225, 0, 0, 413, 462, 474, 0, 0, 0, + 254, 0, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 0, 0, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 590, 591, 257, 653, 228, 623, 220, 0, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 356, 357, 281, 308, 448, 376, 449, 307, 309, 405, + 404, 406, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 0, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 0, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 0, 0, + 426, 473, 240, 607, 497, 199, 0, 0, 0, 0, + 255, 256, 0, 576, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, + 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 0, 0, 0, 0, 0, 399, 0, 592, 593, + 673, 385, 487, 604, 336, 350, 353, 342, 362, 0, + 363, 338, 339, 344, 347, 348, 349, 354, 355, 359, + 365, 249, 210, 391, 400, 579, 313, 216, 217, 218, + 525, 526, 527, 528, 620, 621, 625, 205, 463, 464, + 465, 466, 293, 615, 310, 469, 468, 332, 333, 380, + 450, 541, 543, 554, 558, 560, 562, 568, 571, 542, + 544, 555, 559, 561, 563, 569, 572, 531, 533, 535, + 537, 550, 549, 546, 574, 575, 552, 557, 536, 548, + 553, 566, 573, 570, 530, 534, 538, 547, 565, 564, + 545, 556, 567, 551, 539, 532, 540, 0, 196, 221, + 369, 0, 455, 289, 651, 619, 485, 614, 206, 223, + 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 198, 200, 209, 222, 232, 236, 243, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 302, 303, 445, 446, 315, + 316, 647, 648, 301, 601, 634, 598, 646, 628, 439, + 379, 0, 0, 382, 282, 306, 321, 0, 618, 503, + 227, 467, 291, 251, 0, 0, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 397, 0, 377, 577, 578, 317, 0, 0, 0, 529, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 0, 0, 0, 0, 0, 271, + 0, 0, 0, 0, 367, 268, 0, 1917, 204, 506, + 0, 431, 0, 203, 0, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 0, + 371, 0, 0, 498, 402, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 248, 326, 202, 414, 499, 287, + 0, 0, 0, 0, 0, 508, 725, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, + 0, 0, 0, 352, 361, 360, 340, 341, 343, 345, + 351, 358, 364, 337, 346, 0, 0, 610, 0, 0, + 0, 266, 322, 273, 265, 581, 0, 0, 0, 0, + 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 297, 0, 402, 257, 0, 453, 0, 0, 0, 629, - 0, 0, 0, 0, 0, 0, 0, 365, 0, 330, - 197, 225, 0, 0, 412, 461, 473, 0, 0, 0, - 253, 0, 471, 426, 604, 233, 284, 458, 432, 469, - 440, 287, 0, 0, 470, 372, 585, 450, 601, 630, - 631, 263, 406, 615, 522, 623, 648, 226, 260, 420, - 506, 607, 494, 397, 581, 582, 329, 493, 295, 201, - 369, 636, 224, 479, 371, 242, 231, 587, 612, 299, - 289, 456, 643, 213, 517, 598, 239, 483, 0, 0, - 651, 247, 504, 610, 599, 215, 594, 503, 393, 326, - 327, 214, 0, 457, 268, 293, 0, 0, 258, 415, - 589, 590, 256, 652, 228, 622, 220, 0, 621, 408, - 584, 595, 394, 383, 219, 593, 392, 382, 334, 355, - 356, 280, 307, 447, 375, 448, 306, 308, 404, 403, - 405, 207, 608, 626, 0, 208, 0, 499, 611, 653, - 452, 212, 234, 235, 237, 0, 279, 283, 291, 294, - 303, 304, 313, 367, 419, 446, 442, 451, 0, 579, - 602, 616, 628, 634, 635, 637, 638, 639, 640, 641, - 644, 642, 407, 311, 495, 333, 373, 0, 0, 425, - 472, 240, 606, 496, 199, 0, 0, 0, 0, 254, - 255, 0, 575, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 654, 655, 656, 657, 658, 659, 660, 661, - 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, - 649, 508, 514, 509, 510, 511, 512, 513, 0, 515, - 0, 0, 0, 0, 0, 398, 0, 591, 592, 672, - 384, 486, 603, 335, 349, 352, 341, 361, 0, 362, - 337, 338, 343, 346, 347, 348, 353, 354, 358, 364, - 249, 210, 390, 399, 578, 312, 216, 217, 218, 524, - 525, 526, 527, 619, 620, 624, 205, 462, 463, 464, - 465, 292, 614, 309, 468, 467, 331, 332, 379, 449, - 540, 542, 553, 557, 559, 561, 567, 570, 541, 543, - 554, 558, 560, 562, 568, 571, 530, 532, 534, 536, - 549, 548, 545, 573, 574, 551, 556, 535, 547, 552, - 565, 572, 569, 529, 533, 537, 546, 564, 563, 544, - 555, 566, 550, 538, 531, 539, 0, 196, 221, 368, - 0, 454, 288, 650, 618, 484, 613, 206, 223, 0, - 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 198, 200, 209, 222, 232, 236, 243, 261, - 276, 278, 285, 298, 310, 318, 319, 322, 328, 380, - 386, 387, 388, 389, 409, 410, 411, 414, 417, 418, - 421, 423, 424, 427, 431, 435, 436, 437, 439, 441, - 443, 455, 460, 474, 475, 476, 477, 478, 481, 482, - 488, 489, 490, 491, 492, 500, 501, 516, 586, 588, - 605, 625, 632, 480, 301, 302, 444, 445, 314, 315, - 646, 647, 300, 600, 633, 597, 645, 627, 438, 378, - 0, 0, 381, 281, 305, 320, 0, 617, 502, 227, - 466, 290, 251, 0, 0, 211, 246, 230, 259, 274, - 277, 324, 391, 400, 429, 434, 296, 271, 244, 459, - 241, 485, 519, 520, 521, 523, 395, 266, 433, 396, - 0, 376, 576, 577, 316, 0, 0, 0, 528, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 416, 0, 0, 0, 0, 0, 0, 0, 270, 0, - 0, 0, 0, 366, 267, 0, 0, 204, 505, 0, - 430, 0, 203, 0, 487, 252, 377, 374, 583, 282, - 273, 269, 250, 317, 385, 428, 518, 422, 0, 370, - 0, 0, 497, 401, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 323, 248, 325, 202, 413, 498, 286, 0, - 0, 0, 0, 0, 507, 959, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 238, 0, 0, 245, 0, - 0, 0, 351, 360, 359, 339, 340, 342, 344, 350, - 357, 363, 336, 345, 0, 0, 609, 0, 0, 0, - 265, 321, 272, 264, 580, 0, 0, 0, 0, 0, - 0, 596, 0, 0, 229, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 275, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 297, 0, 402, 257, 0, 453, 0, 0, 0, - 629, 0, 0, 0, 0, 0, 0, 0, 365, 0, - 330, 197, 225, 0, 0, 412, 461, 473, 0, 0, - 0, 253, 0, 471, 426, 604, 233, 284, 458, 432, - 469, 440, 287, 0, 0, 470, 372, 585, 450, 601, - 630, 631, 263, 406, 615, 522, 623, 648, 226, 260, - 420, 506, 607, 494, 397, 581, 582, 329, 493, 295, - 201, 369, 636, 224, 479, 371, 242, 231, 587, 612, - 299, 289, 456, 643, 213, 517, 598, 239, 483, 0, - 0, 651, 247, 504, 610, 599, 215, 594, 503, 393, - 326, 327, 214, 0, 457, 268, 293, 0, 0, 258, - 415, 589, 590, 256, 652, 228, 622, 220, 0, 621, - 408, 584, 595, 394, 383, 219, 593, 392, 382, 334, - 355, 356, 280, 307, 447, 375, 448, 306, 308, 404, - 403, 405, 207, 608, 626, 0, 208, 0, 499, 611, - 653, 452, 212, 234, 235, 237, 0, 279, 283, 291, - 294, 303, 304, 313, 367, 419, 446, 442, 451, 0, - 579, 602, 616, 628, 634, 635, 637, 638, 639, 640, - 641, 644, 642, 407, 311, 495, 333, 373, 0, 0, - 425, 472, 240, 606, 496, 199, 0, 0, 0, 0, - 254, 255, 0, 575, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 654, 655, 656, 657, 658, 659, 660, - 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, - 671, 649, 508, 514, 509, 510, 511, 512, 513, 0, - 515, 0, 0, 0, 0, 0, 398, 0, 591, 592, - 672, 384, 486, 603, 335, 349, 352, 341, 361, 0, - 362, 337, 338, 343, 346, 347, 348, 353, 354, 358, - 364, 249, 210, 390, 399, 578, 312, 216, 217, 218, - 524, 525, 526, 527, 619, 620, 624, 205, 462, 463, - 464, 465, 292, 614, 309, 468, 467, 331, 332, 379, - 449, 540, 542, 553, 557, 559, 561, 567, 570, 541, - 543, 554, 558, 560, 562, 568, 571, 530, 532, 534, - 536, 549, 548, 545, 573, 574, 551, 556, 535, 547, - 552, 565, 572, 569, 529, 533, 537, 546, 564, 563, - 544, 555, 566, 550, 538, 531, 539, 0, 196, 221, - 368, 0, 454, 288, 650, 618, 484, 613, 206, 223, - 0, 262, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 198, 200, 209, 222, 232, 236, 243, - 261, 276, 278, 285, 298, 310, 318, 319, 322, 328, - 380, 386, 387, 388, 389, 409, 410, 411, 414, 417, - 418, 421, 423, 424, 427, 431, 435, 436, 437, 439, - 441, 443, 455, 460, 474, 475, 476, 477, 478, 481, - 482, 488, 489, 490, 491, 492, 500, 501, 516, 586, - 588, 605, 625, 632, 480, 301, 302, 444, 445, 314, - 315, 646, 647, 300, 600, 633, 597, 645, 627, 438, - 378, 0, 0, 381, 281, 305, 320, 0, 617, 502, - 227, 466, 290, 251, 0, 0, 211, 246, 230, 259, - 274, 277, 324, 391, 400, 429, 434, 296, 271, 244, - 459, 241, 485, 519, 520, 521, 523, 395, 266, 433, - 396, 0, 376, 576, 577, 316, 0, 0, 0, 528, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 416, 0, 0, 0, 0, 0, 0, 0, 270, - 0, 0, 0, 0, 366, 267, 0, 0, 204, 505, - 0, 430, 0, 203, 0, 487, 252, 377, 374, 583, - 282, 273, 269, 250, 317, 385, 428, 518, 422, 0, - 370, 0, 0, 497, 401, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 323, 248, 325, 202, 413, 498, 286, - 0, 0, 0, 0, 0, 507, 194, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, - 0, 0, 0, 351, 360, 359, 339, 340, 342, 344, - 350, 357, 363, 336, 345, 0, 0, 609, 0, 0, - 0, 265, 321, 272, 264, 580, 0, 0, 0, 0, - 0, 0, 596, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 275, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 298, 0, 403, 258, 0, 454, 0, 0, + 0, 630, 0, 0, 0, 0, 0, 0, 0, 366, + 0, 331, 197, 225, 0, 0, 413, 462, 474, 0, + 0, 0, 254, 0, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 0, 0, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 590, 591, 257, 653, 228, 623, 220, + 0, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 356, 357, 281, 308, 448, 376, 449, 307, + 309, 405, 404, 406, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 0, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 0, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 0, 0, 426, 473, 240, 607, 497, 199, 0, 0, + 0, 0, 255, 256, 0, 576, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, + 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 0, 0, 0, 0, 0, 399, 0, + 592, 593, 673, 385, 487, 604, 336, 350, 353, 342, + 362, 0, 363, 338, 339, 344, 347, 348, 349, 354, + 355, 359, 365, 249, 210, 391, 400, 579, 313, 216, + 217, 218, 525, 526, 527, 528, 620, 621, 625, 205, + 463, 464, 465, 466, 293, 615, 310, 469, 468, 332, + 333, 380, 450, 541, 543, 554, 558, 560, 562, 568, + 571, 542, 544, 555, 559, 561, 563, 569, 572, 531, + 533, 535, 537, 550, 549, 546, 574, 575, 552, 557, + 536, 548, 553, 566, 573, 570, 530, 534, 538, 547, + 565, 564, 545, 556, 567, 551, 539, 532, 540, 0, + 196, 221, 369, 0, 455, 289, 651, 619, 485, 614, + 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 302, 303, 445, + 446, 315, 316, 647, 648, 301, 601, 634, 598, 646, + 628, 439, 379, 0, 0, 382, 282, 306, 321, 0, + 618, 503, 227, 467, 291, 251, 0, 0, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 397, 0, 377, 577, 578, 317, 0, 0, + 0, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 0, 0, 0, + 0, 271, 0, 0, 0, 0, 367, 268, 0, 1915, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 0, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 0, 0, 0, 0, 508, 725, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, + 0, 245, 0, 0, 0, 352, 361, 360, 340, 341, + 343, 345, 351, 358, 364, 337, 346, 0, 0, 610, + 0, 0, 0, 266, 322, 273, 265, 581, 0, 0, + 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 297, 0, 402, 257, 0, 453, 0, 0, - 0, 629, 0, 0, 0, 0, 0, 0, 0, 365, - 0, 330, 197, 225, 0, 0, 412, 461, 473, 0, - 0, 0, 253, 0, 471, 426, 604, 233, 284, 458, - 432, 469, 440, 287, 0, 0, 470, 372, 585, 450, - 601, 630, 631, 263, 406, 615, 522, 623, 648, 226, - 260, 420, 506, 607, 494, 397, 581, 582, 329, 493, - 295, 201, 369, 636, 224, 479, 371, 242, 231, 587, - 612, 299, 289, 456, 643, 213, 517, 598, 239, 483, - 0, 0, 651, 247, 504, 610, 599, 215, 594, 503, - 393, 326, 327, 214, 0, 457, 268, 293, 0, 0, - 258, 415, 589, 590, 256, 652, 228, 622, 220, 0, - 621, 408, 584, 595, 394, 383, 219, 593, 392, 382, - 334, 355, 356, 280, 307, 447, 375, 448, 306, 308, - 404, 403, 405, 207, 608, 626, 0, 208, 0, 499, - 611, 653, 452, 212, 234, 235, 237, 0, 279, 283, - 291, 294, 303, 304, 313, 367, 419, 446, 442, 451, - 0, 579, 602, 616, 628, 634, 635, 637, 638, 639, - 640, 641, 644, 642, 407, 311, 495, 333, 373, 0, - 0, 425, 472, 240, 606, 496, 199, 0, 0, 0, - 0, 254, 255, 0, 575, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 654, 655, 656, 657, 658, 659, - 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, - 670, 671, 649, 508, 514, 509, 510, 511, 512, 513, - 0, 515, 0, 0, 0, 0, 0, 398, 0, 591, - 592, 672, 384, 486, 603, 335, 349, 352, 341, 361, - 0, 362, 337, 338, 343, 346, 347, 348, 353, 354, - 358, 364, 249, 210, 390, 399, 578, 312, 216, 217, - 218, 524, 525, 526, 527, 619, 620, 624, 205, 462, - 463, 464, 465, 292, 614, 309, 468, 467, 331, 332, - 379, 449, 540, 542, 553, 557, 559, 561, 567, 570, - 541, 543, 554, 558, 560, 562, 568, 571, 530, 532, - 534, 536, 549, 548, 545, 573, 574, 551, 556, 535, - 547, 552, 565, 572, 569, 529, 533, 537, 546, 564, - 563, 544, 555, 566, 550, 538, 531, 539, 0, 196, - 221, 368, 0, 454, 288, 650, 618, 484, 613, 206, - 223, 0, 262, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 198, 200, 209, 222, 232, 236, - 243, 261, 276, 278, 285, 298, 310, 318, 319, 322, - 328, 380, 386, 387, 388, 389, 409, 410, 411, 414, - 417, 418, 421, 423, 424, 427, 431, 435, 436, 437, - 439, 441, 443, 455, 460, 474, 475, 476, 477, 478, - 481, 482, 488, 489, 490, 491, 492, 500, 501, 516, - 586, 588, 605, 625, 632, 480, 301, 302, 444, 445, - 314, 315, 646, 647, 300, 600, 633, 597, 645, 627, - 438, 378, 0, 0, 381, 281, 305, 320, 0, 617, - 502, 227, 466, 290, 251, 0, 0, 211, 246, 230, - 259, 274, 277, 324, 391, 400, 429, 434, 296, 271, - 244, 459, 241, 485, 519, 520, 521, 523, 395, 266, - 433, 0, 0, 376, 576, 577, 316, -} - -var yyPact = [...]int{ - -1000, -1000, 1925, -1000, -552, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 298, 0, 403, 258, 0, 454, + 0, 0, 0, 630, 0, 0, 0, 0, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 254, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 590, 591, 257, 653, 228, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 356, 357, 281, 308, 448, 376, + 449, 307, 309, 405, 404, 406, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 199, + 0, 0, 0, 0, 255, 256, 0, 576, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, + 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 0, 0, 0, 0, 0, + 399, 0, 592, 593, 673, 385, 487, 604, 336, 350, + 353, 342, 362, 0, 363, 338, 339, 344, 347, 348, + 349, 354, 355, 359, 365, 249, 210, 391, 400, 579, + 313, 216, 217, 218, 525, 526, 527, 528, 620, 621, + 625, 205, 463, 464, 465, 466, 293, 615, 310, 469, + 468, 332, 333, 380, 450, 541, 543, 554, 558, 560, + 562, 568, 571, 542, 544, 555, 559, 561, 563, 569, + 572, 531, 533, 535, 537, 550, 549, 546, 574, 575, + 552, 557, 536, 548, 553, 566, 573, 570, 530, 534, + 538, 547, 565, 564, 545, 556, 567, 551, 539, 532, + 540, 0, 196, 221, 369, 0, 455, 289, 651, 619, + 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 302, + 303, 445, 446, 315, 316, 647, 648, 301, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 0, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 0, + 0, 0, 0, 271, 0, 0, 0, 0, 367, 268, + 0, 1913, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 0, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 0, 0, 0, 0, 508, + 725, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 238, 0, 0, 245, 0, 0, 0, 352, 361, 360, + 340, 341, 343, 345, 351, 358, 364, 337, 346, 0, + 0, 610, 0, 0, 0, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 0, 0, 0, 630, 0, 0, 0, 0, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 254, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 590, 591, 257, + 653, 228, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 356, 357, 281, 308, + 448, 376, 449, 307, 309, 405, 404, 406, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 199, 0, 0, 0, 0, 255, 256, 0, 576, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 655, + 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 0, 0, 0, + 0, 0, 399, 0, 592, 593, 673, 385, 487, 604, + 336, 350, 353, 342, 362, 0, 363, 338, 339, 344, + 347, 348, 349, 354, 355, 359, 365, 249, 210, 391, + 400, 579, 313, 216, 217, 218, 525, 526, 527, 528, + 620, 621, 625, 205, 463, 464, 465, 466, 293, 615, + 310, 469, 468, 332, 333, 380, 450, 541, 543, 554, + 558, 560, 562, 568, 571, 542, 544, 555, 559, 561, + 563, 569, 572, 531, 533, 535, 537, 550, 549, 546, + 574, 575, 552, 557, 536, 548, 553, 566, 573, 570, + 530, 534, 538, 547, 565, 564, 545, 556, 567, 551, + 539, 532, 540, 0, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 0, 263, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 302, 303, 445, 446, 315, 316, 647, 648, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 0, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 397, 0, 377, 577, + 578, 317, 0, 0, 0, 529, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, + 0, 0, 0, 0, 0, 271, 0, 0, 0, 0, + 367, 268, 0, 0, 204, 506, 0, 431, 0, 203, + 0, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 0, 371, 0, 0, 498, + 402, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 248, 326, 202, 414, 499, 287, 0, 1888, 0, 0, + 0, 508, 725, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 238, 0, 0, 245, 0, 0, 0, 352, + 361, 360, 340, 341, 343, 345, 351, 358, 364, 337, + 346, 0, 0, 610, 0, 0, 0, 266, 322, 273, + 265, 581, 0, 0, 0, 0, 0, 0, 597, 0, + 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 403, 258, 0, 454, 0, 0, 0, 630, 0, 0, + 0, 0, 0, 0, 0, 366, 0, 331, 197, 225, + 0, 0, 413, 462, 474, 0, 0, 0, 254, 0, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 0, 0, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 590, + 591, 257, 653, 228, 623, 220, 0, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 356, 357, + 281, 308, 448, 376, 449, 307, 309, 405, 404, 406, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 0, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 0, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 0, 0, 426, 473, + 240, 607, 497, 199, 0, 0, 0, 0, 255, 256, + 0, 576, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 0, + 0, 0, 0, 0, 399, 0, 592, 593, 673, 385, + 487, 604, 336, 350, 353, 342, 362, 0, 363, 338, + 339, 344, 347, 348, 349, 354, 355, 359, 365, 249, + 210, 391, 400, 579, 313, 216, 217, 218, 525, 526, + 527, 528, 620, 621, 625, 205, 463, 464, 465, 466, + 293, 615, 310, 469, 468, 332, 333, 380, 450, 541, + 543, 554, 558, 560, 562, 568, 571, 542, 544, 555, + 559, 561, 563, 569, 572, 531, 533, 535, 537, 550, + 549, 546, 574, 575, 552, 557, 536, 548, 553, 566, + 573, 570, 530, 534, 538, 547, 565, 564, 545, 556, + 567, 551, 539, 532, 540, 0, 196, 221, 369, 0, + 455, 289, 651, 619, 485, 614, 206, 223, 0, 263, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 302, 303, 445, 446, 315, 316, 647, + 648, 301, 601, 634, 598, 646, 628, 439, 379, 0, + 0, 382, 282, 306, 321, 0, 618, 503, 227, 467, + 291, 251, 0, 0, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 397, 0, + 377, 577, 578, 317, 0, 0, 0, 529, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 0, 0, 0, 1785, 271, 0, 0, + 0, 0, 367, 268, 0, 0, 204, 506, 0, 431, + 0, 203, 0, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 0, 371, 0, + 0, 498, 402, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 248, 326, 202, 414, 499, 287, 0, 0, + 0, 0, 0, 508, 194, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 238, 0, 0, 245, 0, 0, + 0, 352, 361, 360, 340, 341, 343, 345, 351, 358, + 364, 337, 346, 0, 0, 610, 0, 0, 0, 266, + 322, 273, 265, 581, 0, 0, 0, 0, 0, 0, + 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 276, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 298, 0, 403, 258, 0, 454, 0, 0, 0, 630, + 0, 0, 0, 0, 0, 0, 0, 366, 0, 331, + 197, 225, 0, 0, 413, 462, 474, 0, 0, 0, + 254, 0, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 0, 0, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 590, 591, 257, 653, 228, 623, 220, 0, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 356, 357, 281, 308, 448, 376, 449, 307, 309, 405, + 404, 406, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 0, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 0, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 0, 0, + 426, 473, 240, 607, 497, 199, 0, 0, 0, 0, + 255, 256, 0, 576, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, + 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 0, 0, 0, 0, 0, 399, 0, 592, 593, + 673, 385, 487, 604, 336, 350, 353, 342, 362, 0, + 363, 338, 339, 344, 347, 348, 349, 354, 355, 359, + 365, 249, 210, 391, 400, 579, 313, 216, 217, 218, + 525, 526, 527, 528, 620, 621, 625, 205, 463, 464, + 465, 466, 293, 615, 310, 469, 468, 332, 333, 380, + 450, 541, 543, 554, 558, 560, 562, 568, 571, 542, + 544, 555, 559, 561, 563, 569, 572, 531, 533, 535, + 537, 550, 549, 546, 574, 575, 552, 557, 536, 548, + 553, 566, 573, 570, 530, 534, 538, 547, 565, 564, + 545, 556, 567, 551, 539, 532, 540, 0, 196, 221, + 369, 0, 455, 289, 651, 619, 485, 614, 206, 223, + 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 198, 200, 209, 222, 232, 236, 243, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 410, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 302, 303, 445, 446, 315, + 316, 647, 648, 301, 601, 634, 598, 646, 628, 439, + 379, 0, 0, 382, 282, 306, 321, 0, 618, 503, + 227, 467, 291, 251, 0, 0, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 397, 0, 377, 577, 578, 317, 0, 0, 0, 529, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 0, 0, 0, 0, 0, 271, + 0, 0, 0, 0, 367, 268, 0, 0, 204, 506, + 0, 431, 0, 203, 0, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 0, + 371, 0, 0, 498, 402, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 248, 326, 202, 414, 499, 287, + 0, 95, 0, 0, 0, 508, 960, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, + 0, 0, 0, 352, 361, 360, 340, 341, 343, 345, + 351, 358, 364, 337, 346, 0, 0, 610, 0, 0, + 0, 266, 322, 273, 265, 581, 0, 0, 0, 0, + 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 298, 0, 403, 258, 0, 454, 0, 0, + 0, 630, 0, 0, 0, 0, 0, 0, 0, 366, + 0, 331, 197, 225, 0, 0, 413, 462, 474, 0, + 0, 0, 254, 0, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 0, 0, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 590, 591, 257, 653, 228, 623, 220, + 0, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 356, 357, 281, 308, 448, 376, 449, 307, + 309, 405, 404, 406, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 0, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 0, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 0, 0, 426, 473, 240, 607, 497, 199, 0, 0, + 0, 0, 255, 256, 0, 576, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, + 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 0, 0, 0, 0, 0, 399, 0, + 592, 593, 673, 385, 487, 604, 336, 350, 353, 342, + 362, 0, 363, 338, 339, 344, 347, 348, 349, 354, + 355, 359, 365, 249, 210, 391, 400, 579, 313, 216, + 217, 218, 525, 526, 527, 528, 620, 621, 625, 205, + 463, 464, 465, 466, 293, 615, 310, 469, 468, 332, + 333, 380, 450, 541, 543, 554, 558, 560, 562, 568, + 571, 542, 544, 555, 559, 561, 563, 569, 572, 531, + 533, 535, 537, 550, 549, 546, 574, 575, 552, 557, + 536, 548, 553, 566, 573, 570, 530, 534, 538, 547, + 565, 564, 545, 556, 567, 551, 539, 532, 540, 0, + 196, 221, 369, 0, 455, 289, 651, 619, 485, 614, + 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 302, 303, 445, + 446, 315, 316, 647, 648, 301, 601, 634, 598, 646, + 628, 439, 379, 0, 0, 382, 282, 306, 321, 0, + 618, 503, 227, 467, 291, 251, 0, 0, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 397, 0, 377, 577, 578, 317, 0, 0, + 0, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 0, 0, 0, + 0, 271, 0, 0, 0, 0, 367, 268, 0, 0, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 0, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 0, 0, 0, 0, 508, 194, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, + 0, 245, 0, 0, 0, 352, 361, 360, 340, 341, + 343, 345, 351, 358, 364, 337, 346, 0, 0, 610, + 0, 0, 0, 266, 322, 273, 265, 581, 0, 0, + 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1457, 0, 298, 0, 403, 258, 0, 454, + 0, 0, 0, 630, 0, 0, 0, 0, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 254, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 590, 591, 257, 653, 228, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 356, 357, 281, 308, 448, 376, + 449, 307, 309, 405, 404, 406, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 199, + 0, 0, 0, 0, 255, 256, 0, 576, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, + 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 0, 0, 0, 0, 0, + 399, 0, 592, 593, 673, 385, 487, 604, 336, 350, + 353, 342, 362, 0, 363, 338, 339, 344, 347, 348, + 349, 354, 355, 359, 365, 249, 210, 391, 400, 579, + 313, 216, 217, 218, 525, 526, 527, 528, 620, 621, + 625, 205, 463, 464, 465, 466, 293, 615, 310, 469, + 468, 332, 333, 380, 450, 541, 543, 554, 558, 560, + 562, 568, 571, 542, 544, 555, 559, 561, 563, 569, + 572, 531, 533, 535, 537, 550, 549, 546, 574, 575, + 552, 557, 536, 548, 553, 566, 573, 570, 530, 534, + 538, 547, 565, 564, 545, 556, 567, 551, 539, 532, + 540, 0, 196, 221, 369, 0, 455, 289, 651, 619, + 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 302, + 303, 445, 446, 315, 316, 647, 648, 1456, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 0, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 0, + 0, 0, 0, 271, 0, 0, 0, 0, 367, 268, + 0, 0, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 0, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 0, 0, 0, 0, 508, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 238, 0, 0, 245, 0, 0, 0, 352, 361, 360, + 340, 341, 343, 345, 351, 358, 364, 337, 346, 0, + 0, 610, 0, 0, 0, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 0, 0, 0, 630, 0, 0, 0, 0, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 254, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 590, 591, 257, + 653, 228, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 356, 357, 281, 308, + 448, 376, 449, 307, 309, 405, 404, 406, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 199, 0, 0, 0, 0, 255, 256, 0, 576, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 655, + 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 0, 0, 0, + 0, 0, 399, 0, 592, 593, 673, 385, 487, 604, + 336, 350, 353, 342, 362, 0, 363, 338, 339, 344, + 347, 348, 349, 354, 355, 359, 365, 249, 210, 391, + 400, 579, 313, 216, 217, 218, 525, 526, 527, 528, + 620, 621, 625, 205, 463, 464, 465, 466, 293, 615, + 310, 469, 468, 332, 333, 380, 450, 541, 543, 554, + 558, 560, 562, 568, 571, 542, 544, 555, 559, 561, + 563, 569, 572, 531, 533, 535, 537, 550, 549, 546, + 574, 575, 552, 557, 536, 548, 553, 566, 573, 570, + 530, 534, 538, 547, 565, 564, 545, 556, 567, 551, + 539, 532, 540, 0, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 0, 263, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1050, 0, 0, 0, 198, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 302, 303, 445, 446, 315, 316, 647, 648, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 0, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 397, 0, 377, 577, + 578, 317, 0, 0, 0, 529, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 417, 0, 0, + 0, 0, 0, 0, 0, 271, 0, 0, 0, 0, + 367, 268, 0, 0, 204, 506, 0, 431, 0, 203, + 0, 488, 253, 378, 375, 584, 283, 274, 270, 250, + 318, 386, 429, 519, 423, 0, 371, 0, 0, 498, + 402, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 324, + 248, 326, 202, 414, 499, 287, 0, 0, 0, 0, + 0, 508, 194, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 238, 0, 0, 245, 0, 0, 0, 352, + 361, 360, 340, 341, 343, 345, 351, 358, 364, 337, + 346, 0, 0, 610, 0, 0, 0, 266, 322, 273, + 265, 581, 0, 0, 0, 0, 0, 0, 597, 0, + 0, 229, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 276, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 298, 0, + 403, 258, 0, 454, 0, 676, 0, 630, 0, 0, + 0, 0, 0, 0, 0, 366, 0, 331, 197, 225, + 0, 0, 413, 462, 474, 0, 0, 0, 254, 0, + 472, 427, 605, 233, 285, 459, 433, 470, 441, 288, + 0, 0, 471, 373, 586, 451, 602, 631, 632, 264, + 407, 616, 523, 624, 649, 226, 261, 421, 507, 608, + 495, 398, 582, 583, 330, 494, 296, 201, 370, 637, + 224, 480, 372, 242, 231, 588, 613, 300, 252, 290, + 457, 644, 213, 518, 599, 239, 484, 0, 0, 652, + 247, 505, 611, 600, 215, 595, 504, 394, 327, 328, + 214, 0, 458, 269, 294, 0, 0, 259, 416, 590, + 591, 257, 653, 228, 623, 220, 0, 622, 409, 585, + 596, 395, 384, 219, 594, 393, 383, 335, 356, 357, + 281, 308, 448, 376, 449, 307, 309, 405, 404, 406, + 207, 609, 627, 0, 208, 0, 500, 612, 654, 453, + 212, 234, 235, 237, 0, 280, 284, 292, 295, 304, + 305, 314, 368, 420, 447, 443, 452, 0, 580, 603, + 617, 629, 635, 636, 638, 639, 640, 641, 642, 645, + 643, 408, 312, 496, 334, 374, 0, 0, 426, 473, + 240, 607, 497, 199, 0, 0, 0, 0, 255, 256, + 0, 576, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 655, 656, 657, 658, 659, 660, 661, 662, 663, + 664, 665, 666, 667, 668, 669, 670, 671, 672, 650, + 509, 515, 510, 511, 512, 513, 514, 0, 516, 0, + 0, 0, 0, 0, 399, 0, 592, 593, 673, 385, + 487, 604, 336, 350, 353, 342, 362, 0, 363, 338, + 339, 344, 347, 348, 349, 354, 355, 359, 365, 249, + 210, 391, 400, 579, 313, 216, 217, 218, 525, 526, + 527, 528, 620, 621, 625, 205, 463, 464, 465, 466, + 293, 615, 310, 469, 468, 332, 333, 380, 450, 541, + 543, 554, 558, 560, 562, 568, 571, 542, 544, 555, + 559, 561, 563, 569, 572, 531, 533, 535, 537, 550, + 549, 546, 574, 575, 552, 557, 536, 548, 553, 566, + 573, 570, 530, 534, 538, 547, 565, 564, 545, 556, + 567, 551, 539, 532, 540, 0, 196, 221, 369, 0, + 455, 289, 651, 619, 485, 614, 206, 223, 0, 263, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 198, 200, 209, 222, 232, 236, 243, 262, 277, + 279, 286, 299, 311, 319, 320, 323, 329, 381, 387, + 388, 389, 390, 410, 411, 412, 415, 418, 419, 422, + 424, 425, 428, 432, 436, 437, 438, 440, 442, 444, + 456, 461, 475, 476, 477, 478, 479, 482, 483, 489, + 490, 491, 492, 493, 501, 502, 517, 587, 589, 606, + 626, 633, 481, 302, 303, 445, 446, 315, 316, 647, + 648, 301, 601, 634, 598, 646, 628, 439, 379, 0, + 0, 382, 282, 306, 321, 0, 618, 503, 227, 467, + 291, 251, 0, 0, 211, 246, 230, 260, 275, 278, + 325, 392, 401, 430, 435, 297, 272, 244, 460, 241, + 486, 520, 521, 522, 524, 396, 267, 434, 397, 0, + 377, 577, 578, 317, 0, 0, 0, 529, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 417, + 0, 0, 0, 0, 0, 0, 0, 271, 0, 0, + 0, 0, 367, 268, 0, 0, 204, 506, 0, 431, + 0, 203, 0, 488, 253, 378, 375, 584, 283, 274, + 270, 250, 318, 386, 429, 519, 423, 0, 371, 0, + 0, 498, 402, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 324, 248, 326, 202, 414, 499, 287, 0, 0, + 0, 0, 0, 508, 725, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 238, 0, 0, 245, 0, 0, + 0, 352, 361, 360, 340, 341, 343, 345, 351, 358, + 364, 337, 346, 0, 0, 610, 0, 0, 0, 266, + 322, 273, 265, 581, 0, 0, 0, 0, 0, 0, + 597, 0, 0, 229, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 276, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 298, 0, 403, 258, 0, 454, 0, 0, 0, 630, + 0, 0, 0, 0, 0, 0, 0, 366, 0, 331, + 197, 225, 0, 0, 413, 462, 474, 0, 0, 0, + 254, 0, 472, 427, 605, 233, 285, 459, 433, 470, + 441, 288, 0, 0, 471, 373, 586, 451, 602, 631, + 632, 264, 407, 616, 523, 624, 649, 226, 261, 421, + 507, 608, 495, 398, 582, 583, 330, 494, 296, 201, + 370, 637, 224, 480, 372, 242, 231, 588, 613, 300, + 252, 290, 457, 644, 213, 518, 599, 239, 484, 0, + 0, 652, 247, 505, 611, 600, 215, 595, 504, 394, + 327, 328, 214, 0, 458, 269, 294, 0, 0, 259, + 416, 590, 591, 257, 653, 228, 623, 220, 0, 622, + 409, 585, 596, 395, 384, 219, 594, 393, 383, 335, + 356, 357, 281, 308, 448, 376, 449, 307, 309, 405, + 404, 406, 207, 609, 627, 0, 208, 0, 500, 612, + 654, 453, 212, 234, 235, 237, 0, 280, 284, 292, + 295, 304, 305, 314, 368, 420, 447, 443, 452, 0, + 580, 603, 617, 629, 635, 636, 638, 639, 640, 641, + 642, 645, 643, 408, 312, 496, 334, 374, 0, 0, + 426, 473, 240, 607, 497, 199, 0, 0, 0, 0, + 255, 256, 0, 576, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 655, 656, 657, 658, 659, 660, 661, + 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, + 672, 650, 509, 515, 510, 511, 512, 513, 514, 0, + 516, 0, 0, 0, 0, 0, 399, 0, 592, 593, + 673, 385, 487, 604, 336, 350, 353, 342, 362, 0, + 363, 338, 339, 344, 347, 348, 349, 354, 355, 359, + 365, 249, 210, 391, 400, 579, 313, 216, 217, 218, + 525, 526, 527, 528, 620, 621, 625, 205, 463, 464, + 465, 466, 293, 615, 310, 469, 468, 332, 333, 380, + 450, 541, 543, 554, 558, 560, 562, 568, 571, 542, + 544, 555, 559, 561, 563, 569, 572, 531, 533, 535, + 537, 550, 549, 546, 574, 575, 552, 557, 536, 548, + 553, 566, 573, 570, 530, 534, 538, 547, 565, 564, + 545, 556, 567, 551, 539, 532, 540, 0, 196, 221, + 369, 0, 455, 289, 651, 619, 485, 614, 206, 223, + 0, 263, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 198, 200, 209, 222, 232, 236, 243, + 262, 277, 279, 286, 299, 311, 319, 320, 323, 329, + 381, 387, 388, 389, 390, 4139, 411, 412, 415, 418, + 419, 422, 424, 425, 428, 432, 436, 437, 438, 440, + 442, 444, 456, 461, 475, 476, 477, 478, 479, 482, + 483, 489, 490, 491, 492, 493, 501, 502, 517, 587, + 589, 606, 626, 633, 481, 302, 303, 445, 446, 315, + 316, 647, 648, 301, 601, 634, 598, 646, 628, 439, + 379, 0, 0, 382, 282, 306, 321, 0, 618, 503, + 227, 467, 291, 251, 0, 0, 211, 246, 230, 260, + 275, 278, 325, 392, 401, 430, 435, 297, 272, 244, + 460, 241, 486, 520, 521, 522, 524, 396, 267, 434, + 397, 0, 377, 577, 578, 317, 0, 0, 0, 529, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 417, 0, 0, 0, 0, 0, 0, 0, 271, + 0, 0, 0, 0, 367, 268, 0, 0, 204, 506, + 0, 431, 0, 203, 0, 488, 253, 378, 375, 584, + 283, 274, 270, 250, 318, 386, 429, 519, 423, 0, + 371, 0, 0, 498, 402, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 324, 248, 326, 202, 414, 499, 287, + 0, 0, 0, 0, 0, 508, 725, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 238, 0, 0, 245, + 0, 0, 0, 352, 361, 360, 340, 341, 343, 345, + 351, 358, 364, 337, 346, 0, 0, 610, 0, 0, + 0, 266, 322, 273, 265, 581, 0, 0, 0, 0, + 0, 0, 597, 0, 0, 229, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 276, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 298, 0, 403, 258, 0, 454, 0, 0, + 0, 630, 0, 0, 0, 0, 0, 0, 0, 366, + 0, 331, 197, 225, 0, 0, 413, 462, 474, 0, + 0, 0, 254, 0, 472, 427, 605, 233, 285, 459, + 433, 470, 441, 288, 0, 0, 471, 373, 586, 451, + 602, 631, 632, 264, 407, 616, 523, 624, 649, 226, + 261, 421, 507, 608, 495, 398, 582, 583, 330, 494, + 296, 201, 370, 637, 224, 480, 372, 242, 231, 588, + 613, 300, 252, 290, 457, 644, 213, 518, 599, 239, + 484, 0, 0, 652, 247, 505, 611, 600, 215, 595, + 504, 394, 327, 328, 214, 0, 458, 269, 294, 0, + 0, 259, 416, 590, 591, 257, 653, 228, 623, 220, + 0, 622, 409, 585, 596, 395, 384, 219, 594, 393, + 383, 335, 356, 357, 281, 308, 448, 376, 449, 307, + 309, 405, 404, 406, 207, 609, 627, 0, 208, 0, + 500, 612, 654, 453, 212, 234, 235, 237, 0, 280, + 284, 292, 295, 304, 305, 314, 368, 420, 447, 443, + 452, 0, 580, 603, 617, 629, 635, 636, 638, 639, + 640, 641, 642, 645, 643, 408, 312, 496, 334, 374, + 0, 0, 426, 473, 240, 607, 497, 199, 0, 0, + 0, 0, 255, 256, 0, 576, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 655, 656, 657, 658, 659, + 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, + 670, 671, 672, 650, 509, 515, 510, 511, 512, 513, + 514, 0, 516, 0, 0, 0, 0, 0, 399, 0, + 592, 593, 673, 385, 487, 604, 336, 350, 353, 342, + 362, 0, 363, 338, 339, 344, 347, 348, 349, 354, + 355, 359, 365, 249, 210, 391, 400, 579, 313, 216, + 217, 218, 525, 526, 527, 528, 620, 621, 625, 205, + 463, 464, 465, 466, 293, 615, 310, 469, 468, 332, + 333, 380, 450, 541, 543, 554, 558, 560, 562, 568, + 571, 542, 544, 555, 559, 561, 563, 569, 572, 531, + 533, 535, 537, 550, 549, 546, 574, 575, 552, 557, + 536, 548, 553, 566, 573, 570, 530, 534, 538, 547, + 565, 564, 545, 556, 567, 551, 539, 532, 540, 0, + 196, 221, 369, 0, 455, 289, 651, 619, 485, 614, + 206, 223, 0, 263, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 198, 200, 209, 222, 232, + 236, 243, 262, 277, 279, 286, 299, 311, 319, 320, + 323, 329, 381, 387, 388, 389, 390, 410, 411, 412, + 415, 418, 419, 422, 424, 425, 428, 432, 436, 437, + 438, 440, 442, 444, 456, 461, 475, 476, 477, 478, + 479, 482, 483, 489, 490, 491, 492, 493, 501, 502, + 517, 587, 589, 606, 626, 633, 481, 302, 303, 445, + 446, 315, 316, 647, 648, 301, 601, 634, 598, 646, + 628, 439, 379, 0, 0, 382, 282, 306, 321, 0, + 618, 503, 227, 467, 291, 251, 0, 0, 211, 246, + 230, 260, 275, 278, 325, 392, 401, 430, 435, 297, + 272, 244, 460, 241, 486, 520, 521, 522, 524, 396, + 267, 434, 397, 0, 377, 577, 578, 317, 0, 0, + 0, 529, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 417, 0, 0, 0, 0, 0, 0, + 0, 271, 0, 0, 0, 0, 367, 268, 0, 0, + 204, 506, 0, 431, 0, 203, 0, 488, 253, 378, + 375, 584, 283, 274, 270, 250, 318, 386, 429, 519, + 423, 0, 371, 0, 0, 498, 402, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 324, 248, 326, 202, 414, + 499, 287, 0, 0, 0, 0, 0, 508, 960, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 238, 0, + 0, 245, 0, 0, 0, 352, 361, 360, 340, 341, + 343, 345, 351, 358, 364, 337, 346, 0, 0, 610, + 0, 0, 0, 266, 322, 273, 265, 581, 0, 0, + 0, 0, 0, 0, 597, 0, 0, 229, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 276, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 298, 0, 403, 258, 0, 454, + 0, 0, 0, 630, 0, 0, 0, 0, 0, 0, + 0, 366, 0, 331, 197, 225, 0, 0, 413, 462, + 474, 0, 0, 0, 254, 0, 472, 427, 605, 233, + 285, 459, 433, 470, 441, 288, 0, 0, 471, 373, + 586, 451, 602, 631, 632, 264, 407, 616, 523, 624, + 649, 226, 261, 421, 507, 608, 495, 398, 582, 583, + 330, 494, 296, 201, 370, 637, 224, 480, 372, 242, + 231, 588, 613, 300, 252, 290, 457, 644, 213, 518, + 599, 239, 484, 0, 0, 652, 247, 505, 611, 600, + 215, 595, 504, 394, 327, 328, 214, 0, 458, 269, + 294, 0, 0, 259, 416, 590, 591, 257, 653, 228, + 623, 220, 0, 622, 409, 585, 596, 395, 384, 219, + 594, 393, 383, 335, 356, 357, 281, 308, 448, 376, + 449, 307, 309, 405, 404, 406, 207, 609, 627, 0, + 208, 0, 500, 612, 654, 453, 212, 234, 235, 237, + 0, 280, 284, 292, 295, 304, 305, 314, 368, 420, + 447, 443, 452, 0, 580, 603, 617, 629, 635, 636, + 638, 639, 640, 641, 642, 645, 643, 408, 312, 496, + 334, 374, 0, 0, 426, 473, 240, 607, 497, 199, + 0, 0, 0, 0, 255, 256, 0, 576, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 655, 656, 657, + 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, + 668, 669, 670, 671, 672, 650, 509, 515, 510, 511, + 512, 513, 514, 0, 516, 0, 0, 0, 0, 0, + 399, 0, 592, 593, 673, 385, 487, 604, 336, 350, + 353, 342, 362, 0, 363, 338, 339, 344, 347, 348, + 349, 354, 355, 359, 365, 249, 210, 391, 400, 579, + 313, 216, 217, 218, 525, 526, 527, 528, 620, 621, + 625, 205, 463, 464, 465, 466, 293, 615, 310, 469, + 468, 332, 333, 380, 450, 541, 543, 554, 558, 560, + 562, 568, 571, 542, 544, 555, 559, 561, 563, 569, + 572, 531, 533, 535, 537, 550, 549, 546, 574, 575, + 552, 557, 536, 548, 553, 566, 573, 570, 530, 534, + 538, 547, 565, 564, 545, 556, 567, 551, 539, 532, + 540, 0, 196, 221, 369, 0, 455, 289, 651, 619, + 485, 614, 206, 223, 0, 263, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 198, 200, 209, + 222, 232, 236, 243, 262, 277, 279, 286, 299, 311, + 319, 320, 323, 329, 381, 387, 388, 389, 390, 410, + 411, 412, 415, 418, 419, 422, 424, 425, 428, 432, + 436, 437, 438, 440, 442, 444, 456, 461, 475, 476, + 477, 478, 479, 482, 483, 489, 490, 491, 492, 493, + 501, 502, 517, 587, 589, 606, 626, 633, 481, 302, + 303, 445, 446, 315, 316, 647, 648, 301, 601, 634, + 598, 646, 628, 439, 379, 0, 0, 382, 282, 306, + 321, 0, 618, 503, 227, 467, 291, 251, 0, 0, + 211, 246, 230, 260, 275, 278, 325, 392, 401, 430, + 435, 297, 272, 244, 460, 241, 486, 520, 521, 522, + 524, 396, 267, 434, 397, 0, 377, 577, 578, 317, + 0, 0, 0, 529, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 417, 0, 0, 0, 0, + 0, 0, 0, 271, 0, 0, 0, 0, 367, 268, + 0, 0, 204, 506, 0, 431, 0, 203, 0, 488, + 253, 378, 375, 584, 283, 274, 270, 250, 318, 386, + 429, 519, 423, 0, 371, 0, 0, 498, 402, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 324, 248, 326, + 202, 414, 499, 287, 0, 0, 0, 0, 0, 508, + 194, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 238, 0, 0, 245, 0, 0, 0, 352, 361, 360, + 340, 341, 343, 345, 351, 358, 364, 337, 346, 0, + 0, 610, 0, 0, 0, 266, 322, 273, 265, 581, + 0, 0, 0, 0, 0, 0, 597, 0, 0, 229, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 276, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 298, 0, 403, 258, + 0, 454, 0, 0, 0, 630, 0, 0, 0, 0, + 0, 0, 0, 366, 0, 331, 197, 225, 0, 0, + 413, 462, 474, 0, 0, 0, 254, 0, 472, 427, + 605, 233, 285, 459, 433, 470, 441, 288, 0, 0, + 471, 373, 586, 451, 602, 631, 632, 264, 407, 616, + 523, 624, 649, 226, 261, 421, 507, 608, 495, 398, + 582, 583, 330, 494, 296, 201, 370, 637, 224, 480, + 372, 242, 231, 588, 613, 300, 252, 290, 457, 644, + 213, 518, 599, 239, 484, 0, 0, 652, 247, 505, + 611, 600, 215, 595, 504, 394, 327, 328, 214, 0, + 458, 269, 294, 0, 0, 259, 416, 590, 591, 257, + 653, 228, 623, 220, 0, 622, 409, 585, 596, 395, + 384, 219, 594, 393, 383, 335, 356, 357, 281, 308, + 448, 376, 449, 307, 309, 405, 404, 406, 207, 609, + 627, 0, 208, 0, 500, 612, 654, 453, 212, 234, + 235, 237, 0, 280, 284, 292, 295, 304, 305, 314, + 368, 420, 447, 443, 452, 0, 580, 603, 617, 629, + 635, 636, 638, 639, 640, 641, 642, 645, 643, 408, + 312, 496, 334, 374, 0, 0, 426, 473, 240, 607, + 497, 199, 0, 0, 0, 0, 255, 256, 0, 576, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 655, + 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, + 666, 667, 668, 669, 670, 671, 672, 650, 509, 515, + 510, 511, 512, 513, 514, 0, 516, 0, 0, 0, + 0, 0, 399, 0, 592, 593, 673, 385, 487, 604, + 336, 350, 353, 342, 362, 0, 363, 338, 339, 344, + 347, 348, 349, 354, 355, 359, 365, 249, 210, 391, + 400, 579, 313, 216, 217, 218, 525, 526, 527, 528, + 620, 621, 625, 205, 463, 464, 465, 466, 293, 615, + 310, 469, 468, 332, 333, 380, 450, 541, 543, 554, + 558, 560, 562, 568, 571, 542, 544, 555, 559, 561, + 563, 569, 572, 531, 533, 535, 537, 550, 549, 546, + 574, 575, 552, 557, 536, 548, 553, 566, 573, 570, + 530, 534, 538, 547, 565, 564, 545, 556, 567, 551, + 539, 532, 540, 0, 196, 221, 369, 0, 455, 289, + 651, 619, 485, 614, 206, 223, 0, 263, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 198, + 200, 209, 222, 232, 236, 243, 262, 277, 279, 286, + 299, 311, 319, 320, 323, 329, 381, 387, 388, 389, + 390, 410, 411, 412, 415, 418, 419, 422, 424, 425, + 428, 432, 436, 437, 438, 440, 442, 444, 456, 461, + 475, 476, 477, 478, 479, 482, 483, 489, 490, 491, + 492, 493, 501, 502, 517, 587, 589, 606, 626, 633, + 481, 302, 303, 445, 446, 315, 316, 647, 648, 301, + 601, 634, 598, 646, 628, 439, 379, 0, 0, 382, + 282, 306, 321, 0, 618, 503, 227, 467, 291, 251, + 0, 0, 211, 246, 230, 260, 275, 278, 325, 392, + 401, 430, 435, 297, 272, 244, 460, 241, 486, 520, + 521, 522, 524, 396, 267, 434, 0, 0, 377, 577, + 578, 317, +} + +var yyPact = [...]int{ + -1000, -1000, 4350, -1000, -549, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, 2520, 2555, -1000, -1000, -1000, -1000, 2696, -1000, 1031, + 2117, -1000, 2474, 4989, -1000, 56250, 778, -1000, 53282, -420, + 897, 238, 36958, -1000, 193, -1000, 186, 54766, 189, -1000, + -1000, -1000, -1000, -420, 22860, 2334, 57, 55, 56250, -1000, + -1000, -1000, -1000, -373, 2641, 2087, -1000, 392, -1000, -1000, + -1000, -1000, -1000, -1000, 52540, -1000, 1119, -1000, -1000, 2482, + 2485, 2309, 941, 2399, -1000, 2569, 2087, -1000, 22860, 2632, + 2475, 22118, 22118, 456, -1000, -1000, 269, -1000, -1000, 31764, + 56250, 39926, 322, -1000, 2474, -1000, -1000, -1000, 211, -1000, + 342, 1987, -1000, 1971, -1000, 937, 914, 389, 473, 471, + 386, 385, 384, 368, 367, 363, 358, 355, 399, -1000, + 958, 958, -218, -220, 371, 769, 460, 460, 1035, 490, + 2427, 2379, -1000, -1000, 958, 958, 958, 339, 958, 958, + 958, 958, 311, 310, 958, 958, 958, 958, 958, 958, + 958, 958, 958, 958, 958, 958, 958, 958, 958, 958, + 958, 917, 2474, 270, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 2636, 2900, -1000, -1000, -1000, -1000, 2720, -1000, 1025, - 2152, -1000, 2517, 5041, -1000, 55856, 753, -1000, 52892, -454, - 877, 238, 36590, -1000, 177, -1000, 165, 54374, 169, -1000, - -1000, -1000, -1000, -454, 22511, 2360, 38, 37, 55856, -1000, - -1000, -1000, -1000, -373, 2674, 2129, -1000, 380, -1000, -1000, - -1000, -1000, -1000, -1000, 52151, -1000, 1229, -1000, -1000, 2522, - 2491, 2370, 943, 2372, -1000, 2590, 2129, -1000, 22511, 2666, - 2439, 21770, 21770, 467, -1000, -1000, 273, -1000, -1000, 31403, - 55856, 39554, 897, -1000, 2517, -1000, -1000, -1000, 212, -1000, - 349, 2043, -1000, 2039, -1000, 942, 1017, 408, 473, 466, - 405, 404, 394, 391, 389, 388, 386, 381, 385, -1000, - 974, 974, -236, -241, 1021, 454, 461, 461, 1048, 496, - 2473, 2463, -1000, -1000, 974, 974, 974, 360, 974, 974, - 974, 974, 303, 302, 974, 974, 974, 974, 974, 974, - 974, 974, 974, 974, 974, 974, 974, 974, 974, 974, - 974, 902, 2517, 266, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, @@ -7425,70 +7470,70 @@ var yyPact = [...]int{ -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, 56250, 194, 56250, -1000, 828, 775, + -1000, -1000, -459, 1114, 1114, 101, 1114, 1114, 1114, 1114, + 183, 1043, 54, -1000, 182, 261, 168, 271, 1096, 304, + -1000, -1000, 257, 1096, 1834, -1000, 946, 266, 169, -1000, + 1114, 1114, -1000, 15416, 203, 15416, 15416, 265, 172, -1000, + 2464, -1000, -1000, -1000, -1000, -1000, 1344, -1000, -1000, -1000, + -1000, -37, 489, -1000, -1000, -1000, -1000, 54766, 51798, 283, + -1000, -1000, 780, 1851, 1393, 22860, 1315, 938, -1000, -1000, + 1434, 900, -1000, -1000, -1000, -1000, -1000, 809, -1000, 25086, + 25086, 25086, 25086, -1000, -1000, 1830, 51056, 1830, 1830, 25086, + 1830, 25086, 1830, 1830, 1830, 1830, 22860, 1830, 1830, 1830, + 1830, -1000, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, -1000, -1000, -1000, -1000, 1830, 826, 1830, 1830, 1830, + 1830, 1830, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1830, + 1830, 1830, 1830, 1830, 1830, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, -1000, -1000, + -1000, 1692, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1693, + 1513, 1500, 1498, -1000, 19892, 1830, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 55856, 234, 55856, -1000, 821, 730, -1000, - -1000, -458, 1154, 1154, 80, 1154, 1154, 1154, 1154, 164, - 1008, 33, -1000, 160, 271, 149, 261, 1096, 798, -1000, - -1000, 252, 1096, 1852, -1000, 949, 259, 155, -1000, 1154, - 1154, -1000, 15077, 220, 15077, 15077, 256, 154, -1000, 2494, - -1000, -1000, -1000, -1000, -1000, 1381, -1000, -1000, -1000, -1000, - -36, 489, -1000, -1000, -1000, -1000, 54374, 51410, 290, -1000, - -1000, 30, 1958, 1395, 22511, 1420, 940, -1000, -1000, 1248, - 904, -1000, -1000, -1000, -1000, -1000, 783, -1000, 24734, 24734, - 24734, 24734, -1000, -1000, 2048, 50669, 2048, 2048, 24734, 2048, - 24734, 2048, 2048, 2048, 2048, 22511, 2048, 2048, 2048, 2048, - -1000, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - -1000, -1000, -1000, -1000, 2048, 820, 2048, 2048, 2048, 2048, - 2048, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 2048, 2048, - 2048, 2048, 2048, 2048, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, -1000, -1000, -1000, - 1591, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1583, 1540, - 1534, 1525, -1000, 19547, 2048, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 56250, -1000, 1830, + 216, 54766, 54766, 340, 1333, -1000, -1000, 2569, 2087, -1000, + 2641, 2620, 392, -1000, 3919, 2111, 1683, 1406, 2087, 1954, + 56250, -1000, 2005, -1000, -1000, -1000, -357, -364, 2232, 1455, + 1829, -1000, -1000, -1000, -1000, 1798, 22860, -1000, -1000, 2693, + -1000, 28796, 823, 2687, 50314, -1000, 456, 456, 1969, 421, + 13, -1000, -1000, -1000, -1000, 979, 36216, -1000, -1000, -1000, + -1000, -1000, 1884, 56250, -1000, -1000, 5043, 54766, -1000, 2107, + -1000, 1875, -1000, 2041, 22860, 2126, 768, 54766, 523, 516, + 510, 475, -62, -1000, -1000, -1000, -1000, -1000, -1000, 958, + 958, 958, -1000, 395, 2623, 4989, 5064, -1000, -1000, -1000, + 49572, 2102, 54766, -1000, 2088, -1000, 1039, 861, 864, 864, + 54766, -1000, -1000, 55508, 54766, 1037, 1033, 54766, 54766, 54766, + 54766, -1000, 48830, -1000, 48088, 47346, 1331, 54766, 46604, 45862, + 45120, 44378, 43636, -1000, 2609, -1000, 2204, -1000, -1000, -1000, + 55508, 54766, 54766, 55508, 54766, 55508, 56250, 54766, -1000, -1000, + 357, -1000, -1000, 1329, 1327, 1319, 958, 958, 1317, 1828, + 1823, 1816, 958, 958, 1305, 1800, 38442, 1780, 276, 1299, + 1296, 1294, 1293, 1775, 259, 1757, 1237, 1220, 1272, 54766, + 2083, 56250, -1000, 250, 1070, 434, 978, 2474, 2331, 1964, + 488, 767, 54766, 474, 474, 54766, -1000, 16164, 56250, 230, + -1000, 1744, 22860, -1000, 1117, 1096, 1096, -1000, -1000, -1000, + -1000, -1000, -1000, 1114, 56250, 1117, -1000, -1000, -1000, 1096, + 1114, 56250, 1114, 1114, 1114, 1114, 1096, 1096, 1096, 1114, + 56250, 56250, 56250, 56250, 56250, 56250, 56250, 56250, 56250, 15416, + 946, 1114, -460, -1000, 1742, -1000, -1000, -1000, 2230, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, 55856, -1000, 2048, 196, - 54374, 54374, 317, 1361, -1000, -1000, 2590, 2129, -1000, 2674, - 2662, 380, -1000, 3907, 2056, 1627, 1538, 2129, 2019, 55856, - -1000, 2052, -1000, -1000, -1000, -343, -355, 2294, 1519, 1848, - -1000, -1000, -1000, -1000, 2065, 22511, -1000, -1000, 2717, -1000, - 28439, 816, 2706, 49928, -1000, 467, 467, 2036, 427, -4, - -1000, -1000, -1000, -1000, 1006, 35849, -1000, -1000, -1000, -1000, - -1000, 1946, 55856, -1000, -1000, 4251, 54374, -1000, 2150, -1000, - 1934, -1000, 2102, 22511, 2174, 724, 54374, 515, 510, 506, - 468, -71, -1000, -1000, -1000, -1000, -1000, -1000, 974, 974, - 974, -1000, 372, 2658, 5041, 5724, -1000, -1000, -1000, 49187, - 2148, 54374, -1000, 2147, -1000, 1136, 835, 847, 847, 54374, - -1000, -1000, 55115, 54374, 1113, 1093, 54374, 54374, 54374, 54374, - -1000, 48446, -1000, 47705, 46964, 1359, 54374, 46223, 45482, 44741, - 44000, 43259, -1000, 2471, -1000, 2096, -1000, -1000, -1000, 55115, - 54374, 54374, 55115, 54374, 55115, 55856, 54374, -1000, -1000, 321, - -1000, -1000, 1354, 1344, 1338, 974, 974, 1337, 1825, 1823, - 1807, 974, 974, 1336, 1799, 38072, 1791, 260, 1332, 1314, - 1312, 1340, 1772, 282, 1761, 1333, 1309, 1310, 54374, 2144, - 55856, -1000, 243, 1023, 407, 1005, 2517, 2353, 2033, 481, - 528, 54374, 464, 464, 54374, -1000, 15824, 55856, 217, -1000, - 1736, 22511, -1000, 1103, 1096, 1096, -1000, -1000, -1000, -1000, - -1000, -1000, 1154, 55856, 1103, -1000, -1000, -1000, 1096, 1154, - 55856, 1154, 1154, 1154, 1154, 1096, 1096, 1096, 1154, 55856, - 55856, 55856, 55856, 55856, 55856, 55856, 55856, 55856, 15077, 949, - 1154, -459, -1000, 1721, -1000, -1000, -1000, 2256, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, @@ -7501,340 +7546,337 @@ var yyPact = [...]int{ -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 15416, + 15416, -1000, -1000, 2565, 2559, -1000, -1000, -1000, 1960, -1000, + 184, 17, 185, -1000, 42894, 535, 974, -1000, 535, -1000, + -1000, -1000, -1000, -1000, 1959, 42152, -1000, -461, -464, -467, + -469, -1000, -1000, -1000, -471, -473, -1000, -1000, -1000, 22860, + 22860, 22860, 22860, -257, -1000, 1217, 25086, 2491, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 22860, 247, 1131, 25086, 25086, + 25086, 25086, 25086, 25086, 25086, 26570, 25828, 25086, 25086, 25086, + 25086, 25086, 25086, -1000, -1000, 33990, 6271, 6271, 900, 900, + 900, 900, -1000, -174, 1958, 55508, -1000, -1000, -1000, 822, + 22860, 22860, 900, -1000, 1238, 2007, 19892, 22860, 22860, 22860, + 22860, 960, 1393, 55508, 22860, -1000, 1406, -1000, -1000, -1000, + -1000, 1234, -1000, -1000, 1081, 2376, 2376, 2376, 2376, 22860, + 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 2376, + 22860, 208, 208, 919, 22860, 22860, 22860, 22860, 22860, 22860, + 22860, 22860, 18408, 22860, 22860, 25086, 22860, 22860, 22860, 1406, + 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, + 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, + 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, + 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, + 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, + 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, + 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, + 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 1406, + 22860, 1221, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 17660, + 22860, 22860, 22860, 22860, 22860, -1000, -1000, -1000, -1000, -1000, + -1000, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 22860, 1406, + 22860, 22860, 22860, 22860, 22860, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 1686, 1493, 1478, 22860, -1000, + 1957, -1000, -202, 31022, 22860, 1739, 2683, 2157, 54766, -1000, + -1000, -1000, -1000, 2569, -1000, 2569, 1686, 3881, 2277, 22118, + -1000, -1000, 3881, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, 1737, -1000, 56250, 1954, + 2545, 54766, -1000, -294, -1000, -295, 2272, 1730, 351, -1000, + 22860, 22860, 1953, -1000, 1399, 56250, -1000, -257, -1000, 41410, + -1000, -1000, 14668, 56250, 350, 56250, -1000, 30280, 40668, 306, + -1000, 13, 1933, -1000, 29, 1, 19150, 899, -1000, -1000, + -1000, 371, 27312, 1822, 899, 100, -1000, -1000, -1000, 2041, + -1000, 2041, 2041, 2041, 2041, 351, 351, 351, 351, -1000, + -1000, -1000, -1000, -1000, 2079, 2041, 2075, -1000, 2041, 2041, + 2041, 2041, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 2073, + 2073, 2073, 2061, 2061, 2042, 2042, 447, -1000, 22860, 486, + 39926, 2537, 1270, 1538, 250, 475, 2144, 54766, 54766, 54766, + 56250, 989, -1000, 1445, 1412, 1398, -1000, -532, 1952, -1000, + -1000, 2617, -1000, -1000, 956, 1088, 1084, 1064, 54766, 214, + 335, -1000, 433, -1000, 39926, 54766, 1029, 864, 54766, -1000, + 54766, -1000, -1000, -1000, -1000, -1000, 54766, -1000, -1000, 1950, + -1000, 1927, 1106, 1083, 1098, 1080, 1950, -1000, -1000, -183, + 1950, -1000, 1950, -1000, 1950, -1000, 1950, -1000, 1950, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1001, 278, + -350, 54766, 214, 487, -1000, 485, 33990, -1000, -1000, -1000, + 33990, 33990, -1000, -1000, -1000, -1000, 1726, 1723, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -520, 56250, -1000, + 236, 971, 268, 376, 291, 56250, 405, 2423, 2413, 2403, + 2396, 2391, 2373, 2366, 242, 298, 56250, 56250, 474, 2206, + 56250, 2522, 56250, -1000, -1000, -1000, -1000, -1000, 1716, 1708, + -1000, 1393, 56250, -1000, -1000, 1114, 1114, -1000, -1000, 56250, + 1114, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1114, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 15077, 15077, - -1000, -1000, 2584, 2575, -1000, -1000, -1000, 2032, -1000, 163, - 5, 168, -1000, 42518, 513, 1004, -1000, 513, -1000, -1000, - -1000, -1000, -1000, 2027, 41777, -1000, -460, -461, -462, -463, - -1000, -1000, -1000, -464, -473, -1000, -1000, -1000, 22511, 22511, - 22511, 22511, -276, -1000, 1199, 24734, 2504, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, 22511, 247, 991, 24734, 24734, 24734, - 24734, 24734, 24734, 24734, 26216, 25475, 24734, 24734, 24734, 24734, - 24734, 24734, -1000, -1000, 33626, 6276, 6276, 904, 904, 904, - 904, -1000, -186, 2022, 55115, -1000, -1000, -1000, 813, 22511, - 22511, 904, -1000, 1253, 1138, 19547, 22511, 22511, 22511, 22511, - 1011, 1395, 55115, 22511, -1000, 1538, -1000, -1000, -1000, -1000, - 1245, -1000, -1000, 1091, 2415, 2415, 2415, 2415, 22511, 22511, - 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 2415, 22511, - 148, 148, 719, 22511, 22511, 22511, 22511, 22511, 22511, 22511, - 22511, 18065, 22511, 22511, 24734, 22511, 22511, 22511, 1538, 22511, - 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, - 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, - 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, - 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, - 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, - 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, - 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, - 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 1538, 22511, - 1351, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 17318, 22511, - 22511, 22511, 22511, 22511, -1000, -1000, -1000, -1000, -1000, -1000, - 22511, 22511, 22511, 22511, 22511, 22511, 22511, 22511, 1538, 22511, - 22511, 22511, 22511, 22511, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, 1638, 1518, 1544, 22511, -1000, 2020, - -1000, -200, 30662, 22511, 1691, 2695, 2185, 54374, -1000, -1000, - -1000, -1000, 2590, -1000, 2590, 1638, 3897, 2266, 21770, -1000, - -1000, 3897, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, 1820, -1000, 55856, 2019, 2566, - 54374, -1000, -316, -1000, -321, 2296, 1687, 318, -1000, 22511, - 22511, 2016, -1000, 1698, 55856, -1000, -276, -1000, 41036, -1000, - -1000, 14330, 55856, 354, 55856, -1000, 29921, 40295, 319, -1000, - -4, 1996, -1000, 12, -2, 18806, 882, -1000, -1000, -1000, - 1021, 26957, 1950, 882, 83, -1000, -1000, -1000, 2102, -1000, - 2102, 2102, 2102, 2102, 318, 318, 318, 318, -1000, -1000, - -1000, -1000, -1000, 2142, 2102, 2137, -1000, 2102, 2102, 2102, - 2102, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 2136, 2136, - 2136, 2134, 2134, 2106, 2106, 453, -1000, 22511, 435, 39554, - 2546, 1308, 1193, 243, 468, 2183, 54374, 54374, 54374, 55856, - 1052, -1000, 1408, 1404, 1380, -1000, -532, 2015, -1000, -1000, - 2656, -1000, -1000, 964, 1175, 1172, 893, 54374, 205, 328, - -1000, 440, -1000, 39554, 54374, 1087, 847, 54374, -1000, 54374, - -1000, -1000, -1000, -1000, -1000, 54374, -1000, -1000, 2014, -1000, - 2005, 1201, 1166, 1195, 1161, 2014, -1000, -1000, -194, 2014, - -1000, 2014, -1000, 2014, -1000, 2014, -1000, 2014, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 993, 286, -385, - 54374, 205, 480, -1000, 479, 33626, -1000, -1000, -1000, 33626, - 33626, -1000, -1000, -1000, -1000, 1656, 1643, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, 56250, -1000, -1000, -1000, -1000, + 1702, -1000, 56250, -37, 177, -1000, -1000, 54766, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -114, -1000, 854, + 26, 393, -1000, -1000, -1000, -1000, -1000, 2550, -1000, 1393, + 1021, 1010, -1000, 1830, -1000, -1000, 1233, -1000, -1000, -1000, + -1000, -1000, 1830, 1830, 1830, -1000, -1000, -1000, -1000, -1000, + 247, 25086, 25086, 25086, 1782, 777, 1891, 1812, 1474, 1231, + 1231, 976, 25086, 976, 25086, 918, 918, 918, 918, 918, + -1000, -1000, -1000, -1000, -1000, -1000, 1692, -1000, 1667, -1000, + 1830, 55508, 1827, 17660, 1747, 1599, 1406, 932, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 3935, 1406, + 1851, 1406, 1674, 3902, 1026, -1000, 22860, 1406, 3610, -1000, + -1000, 1406, 1406, 22860, -1000, -1000, 22860, 22860, 22860, 22860, + 1538, 1538, 1538, 1538, 1538, 1538, 1538, 1538, 1538, 1538, + 22860, 1538, 1947, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -522, 55856, -1000, 228, - 998, 288, 315, 265, 55856, 367, 2469, 2438, 2433, 2432, - 2429, 2420, 2397, 241, 301, 55856, 55856, 464, 2240, 55856, - 2549, 55856, -1000, -1000, -1000, -1000, -1000, 1632, 1619, -1000, - 1395, 55856, -1000, -1000, 1154, 1154, -1000, -1000, 55856, 1154, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1154, -1000, + -1000, 1938, 2669, 1558, 1538, 1538, 1538, 1538, 3587, 1538, + 1538, 22860, 1358, -1000, -1000, -1000, 1419, 3583, 1684, 3572, + 1538, 1538, -1000, 1538, 3541, 3536, 1406, 2928, 2820, 1538, + 1538, 1538, 1538, 1538, 2792, 2778, 1538, 1538, 2705, 1538, + 3522, 1538, 2698, 2681, 2677, 2633, 2611, 2603, 2594, 2570, + 2561, 2539, 2533, 2523, 2509, 2492, 2458, 2448, 2444, 2407, + 1538, 1538, 1538, 3508, 1538, 3489, 1538, 3485, 1538, 1538, + 3474, 2394, 2364, 1406, 1934, -1000, 3469, 1538, 3457, 3453, + 3446, 2354, 3427, 3422, 3418, 1538, 1538, 1538, 2339, 3413, + 3407, 3395, 3391, 3374, 3369, 3364, 3355, 3343, 1538, 1478, + 1478, 1478, 1478, 1478, 3253, -259, 1538, 1406, -1000, -1000, + -1000, -1000, -1000, 3092, 2333, 3042, 3030, 3011, 3003, 1406, + 1830, 821, -1000, -1000, 1478, 1406, 1406, 1478, 1478, 2995, + 2963, 2957, 2953, 2933, 2834, 1538, 1538, -1000, 1538, 2810, + 2800, 2303, 2290, 1406, -1000, 1478, 56250, -1000, -451, -1000, + -8, 954, 1830, -1000, 38442, 1406, -1000, 4349, -1000, 1168, + -1000, -1000, -1000, -1000, -1000, 35474, 1879, -1000, -1000, -1000, + -1000, 1830, 1762, -1000, -1000, -1000, -1000, 351, 73, 34732, + 890, 890, 123, 1393, 1393, 22860, -1000, -1000, -1000, -1000, + -1000, -1000, 820, 2642, 404, 1830, -1000, 1948, 3576, -1000, + -1000, -1000, 2544, 28054, -1000, -1000, 1830, 1830, 56250, 1939, + 1745, -1000, 819, -1000, 1320, 1933, 13, 24, -1000, -1000, + -1000, -1000, 1393, -1000, 1378, 353, 346, -1000, 437, -1000, + -1000, -1000, -1000, 2343, 81, -1000, -1000, -1000, 912, 351, + -1000, -1000, -1000, -1000, -1000, -1000, 1664, -1000, 1664, -1000, + -1000, -1000, -1000, -1000, 1268, -1000, -1000, -1000, -1000, 1266, + -1000, -1000, 1256, -1000, -1000, 2877, 2183, 486, -1000, -1000, + 958, 1655, -1000, -1000, 2356, 958, 958, 54766, -1000, -1000, + 1783, 2537, 236, 56250, 2203, -1000, 2144, 2144, 2144, -1000, + 2497, -1000, -1000, -1000, -1000, -1000, -1000, -522, 174, 609, + -1000, -1000, -1000, 1389, 54766, 1721, -1000, 224, -1000, 1779, + -1000, 54766, -1000, 1713, 2053, 54766, 54766, -1000, -1000, -1000, + 54766, 1830, -1000, -1000, -1000, -1000, 760, 2471, 319, -1000, + -1000, -283, -1000, -1000, 214, 224, 55508, 54766, 899, -1000, + -1000, -1000, -1000, -1000, -523, 1690, 506, 228, 328, 56250, + 56250, 56250, 56250, 56250, 56250, 800, -1000, -1000, 39, -1000, + -1000, 202, -1000, -1000, 1623, -1000, -1000, -1000, -1000, 202, + -1000, -1000, -1000, -1000, -1000, 275, 478, -1000, 56250, 56250, + 964, -1000, -1000, -1000, -1000, -1000, 1096, -1000, -1000, 1096, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, 55856, -1000, -1000, -1000, -1000, 1616, - -1000, 55856, -36, 161, -1000, -1000, 54374, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -119, -1000, 351, 8, - 378, -1000, -1000, -1000, -1000, -1000, 2570, -1000, 1395, 1127, - 1057, -1000, 2048, -1000, -1000, 1239, -1000, -1000, -1000, -1000, - -1000, 2048, 2048, 2048, -1000, -1000, -1000, -1000, -1000, 247, - 24734, 24734, 24734, 1630, 777, 1347, 1801, 1204, 1334, 1334, - 919, 24734, 919, 24734, 922, 922, 922, 922, 922, -1000, - -1000, -1000, -1000, -1000, -1000, 1591, -1000, 1589, -1000, 2048, - 55115, 1932, 17318, 2072, 1735, 1538, 931, -1000, -1000, -1000, + -1000, -1000, 2457, 56250, 20, -490, -1000, -486, 22860, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, 1666, 749, 1891, 25086, + 25086, 2007, 2007, 25086, -1000, -1000, -1000, 1076, 1076, 33990, + -1000, 25086, 22860, -1000, -1000, 22860, 22860, 22860, 981, -1000, + 22860, 1181, -1000, 22860, -1000, -259, 1478, 1538, 1538, 1538, + 1538, -259, -259, -259, -259, -259, -259, -259, -259, -259, + -259, 1908, -1000, 22860, 22860, 22860, 1406, 334, -1000, -1000, + -1000, -259, 22860, -1000, -1000, 2666, -1000, 22860, -1000, 33990, + 22860, 22860, 22860, -1000, -1000, -1000, 22860, 22860, -1000, -1000, + 22860, -1000, 22860, -1000, -1000, -1000, -1000, -1000, -1000, 22860, + -1000, 22860, -1000, -1000, -1000, 22860, -1000, 22860, -1000, -1000, + 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, + 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, + 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, + 22860, -1000, 22860, -1000, 22860, -1000, -1000, -1000, 22860, -1000, + 22860, -1000, 22860, -1000, -1000, 22860, -1000, 22860, -1000, 22860, + -1000, 22860, 22860, -1000, 22860, 22860, 22860, -1000, 22860, 22860, + 22860, 22860, -1000, -1000, -1000, -1000, 22860, 22860, 22860, 22860, + 22860, 22860, 22860, 22860, 22860, 22860, -1000, -1000, -1000, -1000, + -1000, -1000, 22860, -1000, 39926, 47, -259, 1221, 47, 1221, + 24344, 832, 507, 23602, -1000, 22860, 16912, -1000, -1000, -1000, + -1000, -1000, 22860, 22860, 22860, 22860, 22860, 22860, -1000, -1000, + -1000, 22860, 22860, -1000, 22860, -1000, 22860, -1000, -1000, -1000, + -1000, -1000, 954, -1000, 455, 453, 864, 54766, -1000, -1000, + -1000, -1000, 1930, -1000, 2564, -1000, 2285, 2284, 2659, 2642, + 22118, -1000, 30280, -1000, -1000, 54766, -419, -1000, 2326, 2476, + 890, 890, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 13920, + 2569, 22860, 2201, 55508, 223, -1000, 29538, 54766, 55508, 30280, + 30280, 30280, 30280, 30280, -1000, 2242, 2235, -1000, 2254, 2228, + 2313, 56250, -1000, 1686, 1688, -1000, 22860, 32506, 1935, 30280, + -1000, -1000, 30280, 56250, 13172, -1000, -1000, 6, -7, -1000, + -1000, -1000, -1000, 371, -1000, -1000, 1082, 2543, 2338, -1000, + -1000, -1000, -1000, -1000, 1682, -1000, 1676, 1928, 1671, 1662, + 278, -1000, 2067, 2451, 958, 958, -1000, 1254, -1000, 1238, + 1614, 1586, -1000, -1000, -1000, 496, -1000, 56250, 2200, 2195, + 2194, -1000, -540, 1253, 2052, 2012, 22860, 2051, 2615, 1913, + 54766, -1000, -1000, 55508, -1000, 197, -1000, 486, 54766, -1000, + -1000, -1000, 335, 56250, -1000, 7068, -1000, -1000, -1000, 224, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 56250, 233, -1000, + 2047, 1343, -1000, -1000, 2140, -1000, -1000, -1000, -1000, -1000, + 213, 201, 1583, 199, 1547, -1000, 199, -1000, 56250, 928, + 2183, 56250, -1000, -1000, -1000, 1114, 1114, -1000, -1000, 2449, + -1000, 1238, 1538, 25086, 25086, -1000, 900, -1000, -1000, 435, + -229, 2041, 2041, -1000, 2041, 2042, -1000, 2041, 171, 2041, + 154, 2041, -1000, -1000, 1406, 1406, -1000, 1478, 2286, 1439, + 2796, -1000, 1393, 22860, 2715, -1000, -1000, -259, -259, -259, + -259, -259, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -69, 2689, 2637, 1538, -1000, 2039, 2036, -1000, + 1538, 22860, 1538, 1406, 2278, 1538, 1538, 1538, 1538, 1538, + 1538, 1538, 1538, 1538, 1538, 1538, 1538, 2266, 2257, 2249, + 2196, 2175, 2171, 2167, 2163, 2158, 2149, 2145, 2128, 2084, + 2080, 2076, 2062, 1538, 1538, 2058, 1538, 2054, 2048, -1000, + 1393, 1478, 2628, 1478, 1538, 1538, 2527, 337, 1538, 1651, + 1651, 1651, 1651, 1651, 1478, 1478, 1478, 1478, 1538, 54766, + -1000, -259, -1000, -1000, -307, -309, -1000, 1406, -259, 1926, + 25086, 1538, 25086, 25086, 25086, 1538, 1406, -1000, 2043, 2010, + 2270, 1940, 1538, 1832, 1538, 1538, 1538, 1821, -1000, 2535, + 1830, 2535, 1830, 2535, 1647, 1168, 56250, -1000, -1000, -1000, + -1000, 2642, 2639, -1000, 1914, -1000, 73, 639, -1000, 2311, + 2476, -1000, 2610, 2306, 2598, -1000, -1000, -1000, -1000, -1000, + 1393, -1000, 2479, 1916, -1000, 963, 1907, -1000, -1000, 21376, + 1649, 2281, 817, 1647, 1923, 3576, 2136, 2190, 3359, -1000, + -1000, -1000, -1000, 2231, -1000, 2063, -1000, -1000, 2005, -1000, + 1790, 350, 30280, 1877, 1877, -1000, 816, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, 1100, 7068, 2704, -1000, 1544, -1000, + 1366, 195, 1240, -1000, -1000, 958, 958, -1000, 1028, 1020, + -1000, 56250, 2031, -1000, 351, 1529, 351, 1225, -1000, -1000, + 1215, -1000, -1000, -1000, -1000, 1994, 2562, -1000, -1000, -1000, + -1000, 56250, -1000, 56250, 56250, 56250, 2029, 2595, -1000, 22860, + 2015, 962, 2253, 54766, 54766, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, 427, 958, -503, 297, + 294, 958, 958, 958, -541, -1000, -1000, 1639, 1637, -1000, + -205, -1000, 22860, -1000, -1000, -1000, -1000, -1000, 1249, 1249, + 1513, 1500, 1498, -1000, 2005, -1000, -1000, -1000, 1722, -1000, + -1000, -186, 54766, 54766, 54766, 54766, -1000, -1000, -1000, 1187, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 3958, 1538, 1958, - 1538, 2351, 3939, 1053, -1000, 22511, 1538, 3935, -1000, -1000, - 1538, 1538, 22511, -1000, -1000, 22511, 22511, 22511, 22511, 1193, - 1193, 1193, 1193, 1193, 1193, 1193, 1193, 1193, 1193, 22511, - 1193, 2009, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, 900, 1406, 375, -188, 1406, -1000, -1000, 351, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - 2001, 2693, 1816, 1193, 1193, 1193, 1193, 3914, 1193, 1193, - 22511, 1839, -1000, -1000, -1000, 1460, 3905, 1586, 3606, 1193, - 1193, -1000, 1193, 3578, 3538, 1538, 2890, 2884, 1193, 1193, - 1193, 1193, 1193, 2869, 2859, 1193, 1193, 2823, 1193, 3523, - 1193, 2734, 2712, 2694, 2690, 2645, 2621, 2595, 2591, 2559, - 2527, 2488, 2483, 2478, 2456, 2452, 2447, 2412, 2343, 1193, - 1193, 1193, 3504, 1193, 3492, 1193, 3488, 1193, 1193, 3484, - 2338, 2333, 1538, 1999, -1000, 3480, 1193, 3476, 3472, 3465, - 2328, 3458, 3453, 3414, 1193, 1193, 1193, 2322, 3410, 3404, - 3395, 3390, 3385, 3378, 3367, 3348, 3281, 1193, 1544, 1544, - 1544, 1544, 1544, 3269, -280, 1193, 1538, -1000, -1000, -1000, - -1000, -1000, 3093, 2316, 3071, 3063, 3059, 3049, 1538, 2048, - 809, -1000, -1000, 1544, 1538, 1538, 1544, 1544, 3043, 3025, - 3009, 2993, 2956, 2948, 1193, 1193, -1000, 1193, 2939, 2927, - 2312, 2297, 1538, -1000, 1544, 55856, -1000, -453, -1000, -16, - 889, 2048, -1000, 38072, 1538, -1000, 5684, -1000, 1371, -1000, - -1000, -1000, -1000, -1000, 35108, 1911, -1000, -1000, -1000, -1000, - 2048, 1930, -1000, -1000, -1000, -1000, 318, 58, 34367, 876, - 876, 109, 1395, 1395, 22511, -1000, -1000, -1000, -1000, -1000, - -1000, 807, 2676, 371, 2048, -1000, 2011, 2757, -1000, -1000, - -1000, 2565, 27698, -1000, -1000, 2048, 2048, 55856, 1972, 1937, - -1000, 803, -1000, 1300, 1996, -4, -8, -1000, -1000, -1000, - -1000, 1395, -1000, 1376, 357, 359, -1000, 443, -1000, -1000, - -1000, -1000, 2387, 70, -1000, -1000, -1000, 332, 318, -1000, - -1000, -1000, -1000, -1000, -1000, 1587, -1000, 1587, -1000, -1000, - -1000, -1000, -1000, 1305, -1000, -1000, -1000, -1000, 1304, -1000, - -1000, 1303, -1000, -1000, 2379, 2227, 435, -1000, -1000, 974, - 1585, -1000, -1000, 2391, 974, 974, 54374, -1000, -1000, 1896, - 2546, 228, 55856, 2239, -1000, 2183, 2183, 2183, -1000, 2537, - -1000, -1000, -1000, -1000, -1000, -1000, -524, 175, 361, -1000, - -1000, -1000, 2041, 54374, 1900, -1000, 214, -1000, 1878, -1000, - 54374, -1000, 1877, 2128, 54374, 54374, -1000, -1000, -1000, 54374, - 2048, -1000, -1000, -1000, -1000, 523, 2516, 314, -1000, -1000, - -300, -1000, -1000, 205, 214, 55115, 54374, 882, -1000, -1000, - -1000, -1000, -1000, -525, 1862, 502, 225, 574, 55856, 55856, - 55856, 55856, 55856, 55856, 778, -1000, -1000, 23, -1000, -1000, - 191, -1000, -1000, -1000, -1000, -1000, -1000, 191, -1000, -1000, - -1000, -1000, -1000, 283, 478, -1000, 55856, 55856, 945, -1000, - -1000, -1000, -1000, -1000, 1096, -1000, -1000, 1096, -1000, -1000, + 22860, -1000, 22860, -1000, 22860, 1393, 22860, -1000, -1000, -1000, + -1000, -1000, 2569, 1489, 22860, 22860, -1000, 1211, 1209, -259, + 1538, -1000, -1000, -1000, 22860, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 22860, -1000, + 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, + 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, + 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, 22860, -1000, + -1000, 22860, -1000, -1000, -1000, 22860, -1000, 22860, -1000, 22860, + -1000, -1000, -1000, 22860, 264, 1076, -1000, -1000, -1000, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1406, 347, -1000, + -1000, -1000, 2650, -1000, 1406, 22860, 2007, -1000, 2007, 2007, + 2007, -1000, -1000, -1000, 22860, -1000, 22860, 22860, -1000, 22860, + -1000, 22860, -1000, -1000, -1000, -1000, 22860, 1830, 2374, 39184, + 1830, 39184, 1830, 32506, -1000, -1000, 2639, 2596, 2593, 2300, + 2312, 2312, 2311, -1000, 2589, 2587, -1000, 1472, 2585, 1458, + 1006, -1000, 55508, 22860, -1000, 223, 38442, -1000, 403, 54766, + 223, 54766, -1000, 2634, -1000, -1000, 22860, 2014, -1000, 22860, + -1000, -1000, -1000, -1000, 6271, 2642, 1877, -1000, -1000, 922, + -1000, 22860, -1000, 11485, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, -1000, 1453, 1446, -1000, -1000, 2006, 22860, -1000, -1000, + -1000, 1663, 1652, -1000, -1000, -1000, -1000, -1000, -1000, -1000, + -1000, 2005, -1000, -1000, -1000, -1000, 335, -527, 2224, 54766, + 1206, -1000, 1632, 1913, 288, 223, 1432, 958, 958, 958, + 1161, 1152, 38442, 1605, -1000, 54766, 364, -1000, 335, -1000, + -222, -223, 1538, -1000, -1000, 2530, -1000, -1000, 16912, -1000, + -1000, 2003, 2141, -1000, -1000, -1000, -1000, 2264, -179, -200, + -1000, -1000, 1538, 1538, 1538, 1405, 1406, -1000, 1538, 1538, + 1633, 1543, -1000, -1000, 1538, 1538, 1538, 1538, 1538, 1538, + 1538, 1538, 1538, 1538, 1538, 1538, 1538, 1538, 1538, 1538, + 1538, 1538, 1538, 1538, 1478, 1778, -1000, 264, 1406, 2184, + -1000, -1000, 6271, -1000, -1000, 2634, 2579, 47, -1000, -1000, + 222, 47, 1393, 1032, 1406, 1406, 1032, 1760, 1538, 1660, + 1642, 1538, 1538, 33248, -1000, 2572, 2571, 1542, -1000, -1000, + 39184, 1542, 39184, 954, 2596, -270, 22860, 22860, 2297, 1164, + -1000, -1000, -1000, -1000, 1402, 1390, -1000, 1377, -1000, 2699, + -1000, 1393, -1000, 1830, 223, -1000, 808, 1907, -1000, 2569, + 1393, 54766, 1393, 75, 2634, -1000, 1538, -1000, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, + 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, 1830, -1000, + -1000, 54766, 2180, -1000, -1000, 2529, 1554, 166, -1000, 1475, + 1913, -1000, -1000, 221, -1000, 22860, -1000, 38442, 1374, 1360, + -1000, -1000, -1000, -1000, -541, -1000, -1000, -1000, -1000, -1000, + -1000, 392, 1888, -1000, 957, 54766, 56250, -1000, 2188, -1000, + -1000, -1000, -1000, 22860, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - 2484, 55856, 4, -491, -1000, -488, 22511, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, 1307, 482, 1347, 24734, 24734, 1138, - 1138, 24734, -1000, -1000, -1000, 1149, 1149, 33626, -1000, 24734, - 22511, -1000, -1000, 22511, 22511, 22511, 1010, -1000, 22511, 1295, - -1000, 22511, -1000, -280, 1544, 1193, 1193, 1193, 1193, -280, - -280, -280, -280, -280, -280, -280, -280, -280, -280, 1976, - -1000, 22511, 22511, 22511, 1538, 295, -1000, -1000, -1000, -280, - 22511, -1000, -1000, 2692, -1000, 22511, -1000, 33626, 22511, 22511, - 22511, -1000, -1000, -1000, 22511, 22511, -1000, -1000, 22511, -1000, - 22511, -1000, -1000, -1000, -1000, -1000, -1000, 22511, -1000, 22511, - -1000, -1000, -1000, 22511, -1000, 22511, -1000, -1000, 22511, -1000, - 22511, -1000, 22511, -1000, 22511, -1000, 22511, -1000, 22511, -1000, - 22511, -1000, 22511, -1000, 22511, -1000, 22511, -1000, 22511, -1000, - 22511, -1000, 22511, -1000, 22511, -1000, 22511, -1000, 22511, -1000, - 22511, -1000, 22511, -1000, -1000, -1000, 22511, -1000, 22511, -1000, - 22511, -1000, -1000, 22511, -1000, 22511, -1000, 22511, -1000, 22511, - 22511, -1000, 22511, 22511, 22511, -1000, 22511, 22511, 22511, 22511, - -1000, -1000, -1000, -1000, 22511, 22511, 22511, 22511, 22511, 22511, - 22511, 22511, 22511, 22511, -1000, -1000, -1000, -1000, -1000, -1000, - 22511, -1000, 39554, 0, -280, 1351, 0, 1351, 23993, 823, - 784, 23252, -1000, 22511, 16571, -1000, -1000, -1000, -1000, -1000, - 22511, 22511, 22511, 22511, 22511, 22511, -1000, -1000, -1000, 22511, - 22511, -1000, 22511, -1000, 22511, -1000, -1000, -1000, -1000, -1000, - 889, -1000, 458, 456, 847, 54374, -1000, -1000, -1000, -1000, - 1989, -1000, 2609, -1000, 2317, 2313, 2684, 2676, 21770, -1000, - 29921, -1000, -1000, 54374, -442, -1000, 2354, 2401, 876, 876, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 13583, 2590, 22511, - 2221, 55115, 223, -1000, 29180, 54374, 55115, 29921, 29921, 29921, - 29921, 29921, -1000, 2255, 2252, -1000, 2264, 2263, 2582, 55856, - -1000, 1638, 1845, -1000, 22511, 32144, 1936, 29921, -1000, -1000, - 29921, 55856, 12836, -1000, -1000, 2, -21, -1000, -1000, -1000, - -1000, 1021, -1000, -1000, 1225, 2562, 2375, -1000, -1000, -1000, - -1000, -1000, 1813, -1000, 1777, 1986, 1769, 1753, 286, -1000, - 2172, 2479, 974, 974, -1000, 1301, -1000, 1253, 1584, 1567, - -1000, -1000, -1000, 499, -1000, 55856, 2220, 2217, 2213, -1000, - -539, 1299, 2124, 2171, 22511, 2120, 2652, 1968, 54374, -1000, - -1000, 55115, -1000, 272, -1000, 435, 54374, -1000, -1000, -1000, - 328, 55856, -1000, 5160, -1000, -1000, -1000, 214, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, 55856, 242, -1000, 2115, 1374, - -1000, -1000, 2179, -1000, -1000, -1000, -1000, -1000, 188, 187, - 1563, 184, 1557, 184, -1000, 55856, 873, 2227, 55856, -1000, - -1000, -1000, 1154, 1154, -1000, -1000, 2422, -1000, 1253, 1193, - 24734, 24734, -1000, 904, -1000, -1000, 409, -258, 2102, 2102, - -1000, 2102, 2106, -1000, 2102, 144, 2102, 138, 2102, -1000, - -1000, 1538, 1538, -1000, 1544, 2293, 1555, 2923, -1000, 1395, - 22511, 2819, -1000, -1000, -280, -280, -280, -280, -280, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -82, - 2719, 2699, 1193, -1000, 2101, 2100, -1000, 1193, 22511, 1193, - 1538, 2249, 1193, 1193, 1193, 1193, 1193, 1193, 1193, 1193, - 1193, 1193, 1193, 1193, 2232, 2226, 2222, 2218, 2203, 2180, - 2155, 2138, 2117, 2085, 2053, 2037, 2030, 2017, 2002, 1964, - 1193, 1193, 1953, 1193, 1928, 1918, -1000, 1395, 1544, 2551, - 1544, 1193, 1193, 2521, 306, 1193, 1749, 1749, 1749, 1749, - 1749, 1544, 1544, 1544, 1544, 1193, 54374, -1000, -280, -1000, - -1000, -332, -383, -1000, 1538, -280, 1970, 24734, 1193, 24734, - 24734, 24734, 1193, 1538, -1000, 1796, 1775, 2508, 1771, 1193, - 2460, 1193, 1193, 1193, 1759, -1000, 2561, 2048, 2561, 2048, - 2561, 1741, 1371, 55856, -1000, -1000, -1000, -1000, 2676, 2673, - -1000, 1969, -1000, 58, 622, -1000, 2331, 2401, -1000, 2647, - 2346, 2646, -1000, -1000, -1000, -1000, -1000, 1395, -1000, 2509, - 1915, -1000, 979, 1949, -1000, -1000, 21029, 1745, 2307, 800, - 1741, 1998, 2757, 2181, 2211, 3075, -1000, -1000, -1000, -1000, - 2237, -1000, 2228, -1000, -1000, 2052, -1000, 2417, 354, 29921, - 1944, 1944, -1000, 799, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, 1207, 5160, 2736, -1000, 1552, -1000, 1373, 194, 1293, - -1000, -1000, 974, 974, -1000, 1085, 1083, -1000, 55856, 2099, - -1000, 318, 1545, 318, 1290, -1000, -1000, 1276, -1000, -1000, - -1000, -1000, 2045, 2451, -1000, -1000, -1000, -1000, 55856, -1000, - 55856, 55856, 55856, 2069, 2644, -1000, 22511, 2068, 976, 2347, - 54374, 54374, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, 442, 974, -503, 289, 287, 974, 974, - 974, -543, -1000, -1000, 1728, 1726, -1000, -219, -1000, 22511, - -1000, -1000, -1000, -1000, -1000, 1272, 1272, 1540, 1534, 1525, - -1000, 2052, -1000, -1000, -1000, 1873, -1000, -1000, -198, 54374, - 54374, 54374, 54374, -1000, -1000, -1000, 1252, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 904, - 1538, 344, -203, 1538, -1000, -1000, 318, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, 22511, -1000, 22511, - -1000, 22511, 1395, 22511, -1000, -1000, -1000, -1000, -1000, 2590, - 1522, 22511, 22511, -1000, 1275, 1268, -280, 1193, -1000, -1000, - -1000, 22511, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, 22511, -1000, 22511, -1000, 22511, - -1000, 22511, -1000, 22511, -1000, 22511, -1000, 22511, -1000, 22511, - -1000, 22511, -1000, 22511, -1000, 22511, -1000, 22511, -1000, 22511, - -1000, 22511, -1000, 22511, -1000, 22511, -1000, -1000, 22511, -1000, - -1000, -1000, 22511, -1000, 22511, -1000, 22511, -1000, -1000, -1000, - 22511, 203, 1149, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, 1538, 346, -1000, -1000, -1000, 2679, - -1000, 1538, 22511, 1138, -1000, 1138, 1138, 1138, -1000, -1000, - -1000, 22511, -1000, 22511, 22511, -1000, 22511, -1000, 22511, -1000, - -1000, -1000, -1000, 22511, 2048, 2332, 38813, 2048, 38813, 2048, - 32144, -1000, -1000, 2673, 2669, 2643, 2337, 2340, 2340, 2331, - -1000, 2635, 2627, -1000, 1520, 2623, 1497, 1076, -1000, 55115, - 22511, -1000, 223, 38072, -1000, 384, 54374, 223, 54374, -1000, - 2610, -1000, -1000, 22511, 2061, -1000, 22511, -1000, -1000, -1000, - -1000, 6276, 2676, 1944, -1000, -1000, 928, -1000, 22511, -1000, - 10932, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1495, - 1485, -1000, -1000, 2057, 22511, -1000, -1000, -1000, 1742, 1729, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 2052, -1000, - -1000, -1000, -1000, 328, -535, 2212, 54374, 1260, -1000, 1706, - 1968, 310, 223, 1467, 974, 974, 974, 1257, 1255, 38072, - 1699, -1000, 54374, 425, -1000, 328, -1000, -242, -244, 1193, - -1000, -1000, 2560, -1000, -1000, 16571, -1000, -1000, 2051, 2182, - -1000, -1000, -1000, -1000, 2292, -190, -227, -1000, -1000, 1193, - 1193, 1193, 1751, 1538, -1000, 1193, 1193, 1681, 1610, -1000, - -1000, 1193, 1193, 1193, 1193, 1193, 1193, 1193, 1193, 1193, - 1193, 1193, 1193, 1193, 1193, 1193, 1193, 1193, 1193, 1193, - 1193, 1544, 1708, -1000, 203, 1538, 2202, -1000, -1000, 6276, - -1000, -1000, 2610, 2622, 0, -1000, -1000, 221, 0, 1395, - 1019, 1538, 1538, 1019, 1680, 1193, 1635, 1560, 1193, 1193, - 32885, -1000, 2619, 2603, 1686, -1000, -1000, 38813, 1686, 38813, - 889, 2669, -290, 22511, 22511, 2335, 1269, -1000, -1000, -1000, - -1000, 1455, 1451, -1000, 1447, -1000, 2727, -1000, 1395, -1000, - 2048, 223, -1000, 794, 1949, -1000, 2590, 1395, 54374, 1395, - 54, 2610, -1000, 1193, -1000, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, 2048, - 2048, 2048, 2048, 2048, 2048, 2048, -1000, -1000, 54374, 1570, - -1000, -1000, 2554, 1696, 166, -1000, 1549, 1968, -1000, -1000, - 216, -1000, 22511, -1000, 38072, 1426, 1385, -1000, -1000, -1000, - -1000, -543, -1000, -1000, -1000, -1000, -1000, -1000, 380, 1966, - -1000, 959, 54374, 55856, -1000, 2282, -1000, -1000, -1000, -1000, - 22511, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 22511, -1000, - 1538, 2200, -1000, -377, -1000, -504, 22511, -280, -1000, -1000, - -280, -1000, -1000, -1000, -1000, -1000, 22511, -1000, -1000, 22511, - -1000, 22511, -1000, -1000, 1686, -1000, -1000, -1000, 37331, -1000, - 1686, -1000, 1686, -1000, -290, -1000, 1963, -1000, 54374, 1395, - 375, -1000, 1267, -1000, -1000, -1000, -1000, -1000, 55115, 54374, - 1949, 54374, -1000, -1000, 1684, 1538, 2048, 2590, -1000, 1660, - -1000, 380, -1000, 2050, 2171, -1000, -1000, -1000, 20288, -1000, - -1000, -1000, -1000, -1000, 262, -197, 16571, 12089, 1609, -1000, - -196, 1193, 1544, -1000, -477, -1000, -1000, -1000, -1000, 279, - -1000, -1000, 1958, -1000, -1000, 1548, 1537, 1475, -1000, -1000, - -1000, -1000, -1000, -1000, -290, -1000, -1000, 2553, -1000, -254, - -1000, -1000, 1952, 1529, -1000, -1000, -1000, 32144, 53633, -1000, - -184, 382, -197, 22511, 2049, 1538, -1000, -1000, -1000, -1000, - -1000, -1000, -1000, -1000, -39, -1000, -1000, 772, -1000, -1000, - -1000, 2179, -216, -1000, -1000, -1000, 307, -494, -288, -296, - 24734, -1000, 22511, -1000, 22511, -1000, 22511, -1000, 54374, 2048, - -1000, -1000, -1000, 1483, -1000, 4202, -401, 2195, -1000, -145, - -1000, -1000, -1000, 1203, 1364, -1000, -1000, -1000, -1000, -1000, - -1000, 1414, 54374, -1000, 436, -1000, -1000, 15824, -198, -233, - 1020, -1000, -1000, -1000, -1000, -1000, 1138, 1466, 1357, 1193, - -1000, 54374, -1000, 53633, -395, 882, 6276, -1000, 2193, 2190, - 2704, -1000, -1000, -1000, -1000, -1000, -1000, -549, 1464, 244, - -1000, -1000, -1000, 307, -314, -1000, 22511, -1000, 22511, -1000, - 1538, -1000, -1000, 2535, 54, -1000, 2724, -1000, 2691, 1031, - 1031, -1000, 1242, -549, -1000, -1000, -1000, -1000, 1193, 1193, - -1000, -403, -1000, -1000, -1000, -1000, -1000, 433, 1281, -1000, - -1000, -1000, -1000, -1000, 6276, -1000, -1000, -1000, 204, 204, - -1000, -1000, + -1000, 22860, -1000, 1406, 2181, -1000, -375, -1000, -504, 22860, + -259, -1000, -1000, -259, -1000, -1000, -1000, -1000, -1000, 22860, + -1000, -1000, 22860, -1000, 22860, -1000, -1000, 1542, -1000, -1000, + -1000, 37700, -1000, 1542, -1000, 1542, -1000, -270, -1000, 1882, + -1000, 54766, 1393, 345, -1000, 1162, -1000, -1000, -1000, -1000, + -1000, 55508, 54766, 1907, 54766, -1000, -1000, 1508, 1406, 1830, + 2569, -1000, 1482, -1000, 392, -1000, 2002, 2012, -1000, -1000, + -1000, 20634, -1000, -1000, -1000, -1000, -1000, 249, -185, 16912, + 12424, 1480, -1000, -184, 1538, 1478, -1000, -479, -1000, -1000, + -1000, -1000, 279, -1000, -1000, 1851, -1000, -1000, 1621, 1527, + 1444, -1000, -1000, -1000, -1000, -1000, -1000, -270, -1000, -1000, + 2525, -1000, -226, -1000, -1000, 1367, 1442, -1000, -1000, -1000, + 32506, 54024, -1000, -171, 293, -185, 22860, 1995, 1406, -1000, + -1000, -1000, -1000, -1000, -1000, -1000, -1000, -52, -1000, -1000, + 799, -1000, -1000, -1000, 2140, -189, -1000, -1000, -1000, 284, + -494, -291, -292, 25086, -1000, 22860, -1000, 22860, -1000, 22860, + -1000, 54766, 1830, -1000, -1000, -1000, 1426, -1000, 4978, -334, + 2177, -1000, -126, -1000, -1000, -1000, 1042, 1359, -1000, -1000, + -1000, -1000, -1000, -1000, 1936, 54766, -1000, 446, -1000, -1000, + 16164, -186, -201, 1000, -1000, -1000, -1000, -1000, -1000, 2007, + 1365, 1353, 1538, -1000, 54766, -1000, 54024, -314, 899, 6271, + -1000, 2164, 2159, 2656, -1000, -1000, -1000, -1000, -1000, -1000, + -544, 1356, 243, -1000, -1000, -1000, 284, -338, -1000, 22860, + -1000, 22860, -1000, 1406, -1000, -1000, 2494, 75, -1000, 2658, + -1000, 2643, 1016, 1016, -1000, 1136, -544, -1000, -1000, -1000, + -1000, 1538, 1538, -1000, -354, -1000, -1000, -1000, -1000, -1000, + 440, 1275, -1000, -1000, -1000, -1000, -1000, 6271, -1000, -1000, + -1000, 263, 263, -1000, -1000, } var yyPgo = [...]int{ - 0, 3435, 3430, 31, 7, 40, 39, 3428, 3426, 3423, - 171, 3421, 3420, 3419, 3411, 3410, 3407, 2789, 2782, 2755, - 3406, 3404, 3400, 3393, 3392, 3391, 3390, 3383, 3381, 27, - 114, 100, 101, 212, 192, 3380, 169, 161, 198, 3378, - 3373, 3372, 125, 182, 82, 81, 187, 3370, 3369, 68, - 3368, 3353, 3284, 180, 179, 177, 1100, 3282, 176, 111, - 47, 3279, 3277, 3275, 3274, 3268, 3261, 3260, 3258, 3257, - 3256, 3254, 3252, 3251, 3247, 3244, 3242, 3240, 3229, 308, - 3228, 3225, 16, 3223, 73, 3220, 3213, 3210, 3208, 3206, - 9, 3203, 3201, 32, 41, 55, 3197, 3195, 44, 3194, - 3193, 3192, 3191, 3187, 79, 3185, 14, 3184, 35, 3183, - 3179, 124, 3177, 3176, 3174, 42, 3173, 3171, 3170, 11, - 162, 3169, 3166, 138, 3163, 3158, 3147, 164, 221, 3144, - 2357, 3143, 93, 3142, 3141, 3140, 160, 191, 3138, 120, - 3137, 3136, 3135, 148, 3128, 3300, 3126, 3124, 67, 62, - 168, 3123, 3117, 201, 80, 8, 3116, 22, 23, 3115, - 3114, 72, 61, 3113, 98, 3110, 3108, 94, 99, 3107, - 109, 90, 3106, 3099, 10, 5, 3098, 1, 4, 2, - 115, 3091, 3088, 108, 3087, 3086, 3084, 97, 3081, 3077, - 4382, 3071, 83, 129, 96, 64, 3070, 170, 165, 3069, - 3068, 3065, 3064, 3059, 3058, 49, 3054, 3051, 3050, 136, - 1270, 116, 3049, 145, 352, 51, 146, 3048, 193, 75, - 3042, 163, 3041, 3038, 133, 132, 3031, 3030, 53, 166, - 197, 3028, 92, 128, 117, 183, 91, 130, 3027, 3026, - 59, 58, 3011, 3008, 2993, 2985, 167, 2983, 2982, 63, - 2977, 56, 2973, 195, 2967, 340, 77, 2964, 185, 158, - 2963, 66, 2949, 2948, 85, 95, 57, 29, 2946, 153, - 159, 126, 178, 2945, 2944, 52, 2941, 2939, 2938, 190, - 319, 2930, 2928, 323, 174, 140, 144, 87, 2925, 266, - 2923, 2917, 2913, 19, 5078, 7104, 181, 17, 155, 2912, - 2904, 8002, 48, 43, 13, 2897, 211, 2896, 194, 2892, - 2891, 2881, 203, 208, 105, 156, 54, 2880, 2879, 2878, - 2876, 71, 2870, 2869, 2866, 2862, 2860, 2859, 38, 37, - 36, 70, 196, 60, 25, 89, 154, 149, 65, 2858, - 2857, 2851, 121, 78, 2848, 152, 151, 123, 104, 2844, - 175, 141, 118, 2841, 102, 34, 2837, 2829, 2828, 2826, - 84, 2825, 2824, 2822, 2821, 150, 142, 119, 74, 2820, - 76, 113, 147, 143, 50, 2817, 45, 2814, 2812, 33, - 184, 28, 2811, 21, 106, 110, 2807, 6623, 2805, 12, - 265, 157, 2804, 2802, 15, 18, 6, 2799, 2797, 2794, - 2793, 131, 2788, 2784, 2783, 2775, 26, 46, 24, 20, - 112, 137, 69, 2773, 2761, 139, 2760, 2759, 2754, 0, - 1040, 127, 2722, 204, + 0, 3243, 3242, 31, 6, 37, 36, 3240, 3239, 3238, + 174, 3237, 3235, 3224, 3223, 3222, 3221, 2754, 2745, 2728, + 3220, 3219, 3218, 3215, 3213, 3211, 3210, 3209, 3208, 38, + 116, 91, 104, 201, 213, 3205, 170, 161, 197, 3203, + 3202, 3201, 115, 187, 84, 92, 195, 3200, 3199, 71, + 3196, 3194, 3192, 190, 189, 188, 1092, 3190, 184, 114, + 48, 3189, 3187, 3184, 3182, 3179, 3178, 3176, 3174, 3173, + 3172, 3170, 3169, 3168, 3165, 3163, 3162, 3161, 3160, 285, + 3157, 3155, 12, 3154, 73, 3153, 3152, 3149, 3147, 3146, + 8, 3140, 3139, 26, 45, 63, 3136, 3134, 44, 3132, + 3131, 3129, 3125, 3124, 72, 3123, 27, 3121, 40, 3120, + 3117, 124, 3115, 3111, 3105, 42, 3104, 3100, 3098, 28, + 169, 3097, 3094, 140, 3093, 3092, 3087, 167, 205, 3085, + 2265, 3082, 99, 3080, 3079, 3077, 166, 193, 3076, 125, + 3074, 3073, 3072, 152, 3068, 3263, 3066, 3065, 59, 80, + 164, 3064, 3062, 199, 79, 54, 3061, 17, 19, 3060, + 3058, 67, 70, 3057, 108, 3056, 3054, 103, 77, 3052, + 105, 102, 3051, 3050, 5, 7, 3048, 1, 4, 2, + 83, 3047, 3044, 119, 3041, 3040, 3039, 101, 3037, 3035, + 4407, 3031, 93, 130, 106, 76, 3028, 171, 132, 3027, + 3026, 3022, 3021, 3016, 2985, 49, 2984, 2983, 2982, 136, + 22, 110, 2981, 146, 346, 51, 147, 2978, 196, 78, + 2977, 172, 2971, 2969, 134, 133, 2968, 2962, 58, 168, + 194, 2960, 96, 129, 120, 176, 95, 135, 2954, 2946, + 56, 62, 2944, 2943, 2940, 2939, 181, 2935, 2929, 61, + 2927, 53, 2925, 182, 2924, 306, 69, 2922, 180, 162, + 2921, 60, 2919, 2918, 68, 100, 55, 39, 2914, 157, + 160, 127, 165, 2913, 2912, 52, 2905, 2899, 2894, 200, + 301, 2891, 2890, 329, 183, 143, 149, 85, 2887, 323, + 2886, 2885, 2884, 16, 5094, 7550, 186, 25, 159, 2883, + 2882, 8334, 20, 43, 24, 2872, 210, 2869, 185, 2867, + 2866, 2865, 211, 207, 112, 158, 57, 2864, 2859, 2857, + 2856, 64, 2855, 2850, 2849, 2848, 2847, 2846, 35, 34, + 33, 75, 218, 65, 21, 98, 156, 151, 66, 2843, + 2841, 2839, 123, 90, 2835, 155, 153, 126, 163, 2829, + 175, 142, 117, 2823, 87, 32, 2822, 2821, 2819, 2818, + 89, 2813, 2810, 2806, 2805, 150, 144, 121, 81, 2803, + 82, 118, 148, 145, 50, 2799, 46, 2798, 2797, 30, + 191, 29, 2787, 13, 111, 109, 2780, 6691, 2779, 9, + 305, 154, 2776, 2775, 10, 11, 14, 2772, 2771, 2770, + 2769, 131, 2768, 2765, 2763, 2761, 23, 47, 18, 15, + 113, 137, 74, 2760, 2746, 141, 2732, 2727, 2722, 0, + 1034, 128, 2721, 202, } -//line sql.y:8755 +//line sql.y:8764 type yySymType struct { union any empty struct{} @@ -8594,63 +8636,63 @@ var yyR1 = [...]int{ 43, 43, 43, 43, 43, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, - 23, 23, 23, 23, 23, 23, 23, 23, 111, 111, - 112, 112, 112, 112, 114, 114, 114, 375, 375, 60, - 60, 3, 3, 173, 175, 176, 176, 174, 174, 174, - 174, 174, 174, 62, 62, 61, 61, 178, 177, 179, - 179, 179, 1, 1, 2, 2, 4, 4, 380, 380, + 23, 23, 23, 23, 23, 23, 23, 23, 23, 111, + 111, 112, 112, 112, 112, 114, 114, 114, 375, 375, + 60, 60, 3, 3, 173, 175, 176, 176, 174, 174, + 174, 174, 174, 174, 62, 62, 61, 61, 178, 177, + 179, 179, 179, 1, 1, 2, 2, 4, 4, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, 380, - 341, 341, 341, 374, 374, 376, 113, 113, 113, 113, - 113, 113, 113, 113, 113, 113, 117, 116, 116, 115, - 118, 118, 118, 118, 118, 118, 118, 118, 378, 378, - 378, 63, 63, 379, 328, 329, 330, 5, 6, 355, - 377, 125, 125, 24, 39, 39, 25, 25, 25, 25, - 26, 26, 64, 67, 67, 65, 65, 65, 65, 65, + 380, 341, 341, 341, 374, 374, 376, 113, 113, 113, + 113, 113, 113, 113, 113, 113, 113, 117, 116, 116, + 115, 118, 118, 118, 118, 118, 118, 118, 118, 378, + 378, 378, 63, 63, 379, 328, 329, 330, 5, 6, + 355, 377, 125, 125, 24, 39, 39, 25, 25, 25, + 25, 26, 26, 64, 67, 67, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, - 65, 292, 292, 281, 281, 290, 290, 280, 280, 306, - 306, 306, 283, 283, 283, 284, 284, 403, 403, 403, - 277, 277, 66, 66, 66, 307, 307, 307, 307, 69, - 69, 413, 413, 414, 414, 415, 415, 415, 70, 71, - 71, 310, 310, 311, 311, 72, 73, 85, 85, 85, - 85, 85, 86, 86, 86, 86, 86, 86, 110, 110, - 110, 10, 10, 10, 10, 81, 81, 81, 9, 9, - 11, 68, 68, 75, 400, 400, 401, 402, 402, 402, - 402, 76, 78, 27, 27, 27, 27, 27, 27, 135, - 135, 123, 123, 123, 123, 123, 123, 123, 123, 123, - 123, 123, 123, 130, 130, 130, 124, 124, 422, 79, - 80, 80, 128, 128, 128, 121, 121, 121, 127, 127, - 127, 12, 12, 13, 263, 263, 14, 14, 134, 134, - 133, 133, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 131, 131, 132, 132, 132, 132, 299, - 299, 299, 298, 298, 167, 167, 169, 168, 168, 170, - 170, 171, 171, 171, 171, 217, 217, 193, 193, 256, - 256, 257, 257, 255, 255, 262, 262, 258, 258, 258, - 258, 265, 265, 172, 172, 172, 172, 180, 180, 181, - 181, 182, 182, 309, 309, 304, 304, 304, 303, 303, - 186, 186, 186, 188, 187, 187, 187, 187, 189, 189, - 191, 191, 190, 190, 192, 197, 197, 196, 196, 194, - 194, 194, 194, 194, 194, 195, 195, 195, 195, 198, - 198, 145, 145, 145, 145, 145, 145, 145, 145, 411, - 411, 159, 159, 159, 159, 159, 159, 159, 162, 162, - 162, 162, 162, 162, 162, 162, 162, 162, 162, 246, - 246, 150, 150, 150, 150, 150, 150, 150, 150, 150, - 150, 150, 150, 150, 150, 150, 153, 153, 153, 153, + 65, 65, 292, 292, 281, 281, 290, 290, 280, 280, + 306, 306, 306, 283, 283, 283, 284, 284, 403, 403, + 403, 277, 277, 66, 66, 66, 307, 307, 307, 307, + 69, 69, 413, 413, 414, 414, 415, 415, 415, 70, + 71, 71, 310, 310, 311, 311, 72, 73, 85, 85, + 85, 85, 85, 86, 86, 86, 86, 86, 86, 110, + 110, 110, 10, 10, 10, 10, 81, 81, 81, 9, + 9, 11, 68, 68, 75, 400, 400, 401, 402, 402, + 402, 402, 76, 78, 27, 27, 27, 27, 27, 27, + 135, 135, 123, 123, 123, 123, 123, 123, 123, 123, + 123, 123, 123, 123, 130, 130, 130, 124, 124, 422, + 79, 80, 80, 128, 128, 128, 121, 121, 121, 127, + 127, 127, 12, 12, 13, 263, 263, 14, 14, 134, + 134, 133, 133, 136, 136, 136, 136, 136, 136, 136, + 136, 136, 136, 136, 131, 131, 132, 132, 132, 132, + 299, 299, 299, 298, 298, 167, 167, 169, 168, 168, + 170, 170, 171, 171, 171, 171, 217, 217, 193, 193, + 256, 256, 257, 257, 255, 255, 262, 262, 258, 258, + 258, 258, 265, 265, 172, 172, 172, 172, 180, 180, + 181, 181, 182, 182, 309, 309, 304, 304, 304, 303, + 303, 186, 186, 186, 188, 187, 187, 187, 187, 189, + 189, 191, 191, 190, 190, 192, 197, 197, 196, 196, + 194, 194, 194, 194, 194, 194, 195, 195, 195, 195, + 198, 198, 145, 145, 145, 145, 145, 145, 145, 145, + 411, 411, 159, 159, 159, 159, 159, 159, 159, 162, + 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, + 246, 246, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, 153, - 153, 222, 222, 221, 221, 87, 87, 87, 88, 88, - 89, 89, 89, 89, 89, 90, 90, 90, 90, 90, - 90, 90, 92, 92, 91, 91, 212, 212, 296, 296, - 93, 94, 94, 95, 95, 98, 98, 97, 96, 96, - 102, 102, 99, 99, 101, 101, 100, 103, 103, 104, - 105, 105, 278, 278, 199, 199, 208, 208, 208, 208, - 200, 200, 201, 201, 201, 201, 201, 201, 209, 209, - 209, 216, 210, 210, 206, 206, 204, 204, 204, 204, - 204, 204, 204, 204, 204, 204, 204, 205, 205, 205, + 153, 153, 222, 222, 221, 221, 87, 87, 87, 88, + 88, 89, 89, 89, 89, 89, 90, 90, 90, 90, + 90, 90, 90, 92, 92, 91, 91, 212, 212, 296, + 296, 93, 94, 94, 95, 95, 98, 98, 97, 96, + 96, 102, 102, 99, 99, 101, 101, 100, 103, 103, + 104, 105, 105, 278, 278, 199, 199, 208, 208, 208, + 208, 200, 200, 201, 201, 201, 201, 201, 201, 209, + 209, 209, 216, 210, 210, 206, 206, 204, 204, 204, + 204, 204, 204, 204, 204, 204, 204, 204, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, @@ -8670,36 +8712,36 @@ var yyR1 = [...]int{ 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, 205, - 164, 164, 164, 164, 227, 227, 151, 151, 151, 151, + 205, 164, 164, 164, 164, 227, 227, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, - 151, 152, 152, 165, 165, 165, 165, 166, 166, 166, - 166, 166, 166, 166, 317, 317, 119, 119, 119, 119, + 151, 151, 152, 152, 165, 165, 165, 165, 166, 166, + 166, 166, 166, 166, 166, 317, 317, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, 119, - 119, 119, 119, 119, 119, 119, 120, 120, 120, 120, + 119, 119, 119, 119, 119, 119, 119, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, - 120, 120, 120, 120, 423, 423, 332, 332, 332, 207, - 207, 207, 207, 207, 126, 126, 126, 126, 126, 314, - 314, 314, 318, 318, 318, 316, 316, 316, 316, 316, + 120, 120, 120, 120, 120, 423, 423, 332, 332, 332, + 207, 207, 207, 207, 207, 126, 126, 126, 126, 126, + 314, 314, 314, 318, 318, 318, 316, 316, 316, 316, 316, 316, 316, 316, 316, 316, 316, 316, 316, 316, - 319, 319, 225, 225, 122, 122, 223, 223, 224, 226, - 226, 218, 218, 218, 218, 220, 220, 203, 203, 203, - 228, 228, 320, 320, 229, 229, 106, 107, 107, 108, - 108, 230, 230, 232, 231, 231, 233, 234, 234, 234, - 235, 235, 236, 236, 236, 49, 49, 49, 49, 49, - 44, 44, 44, 44, 45, 45, 45, 45, 137, 137, - 137, 137, 139, 139, 138, 138, 82, 82, 83, 83, - 83, 143, 143, 144, 144, 144, 141, 141, 142, 142, - 253, 253, 253, 253, 253, 253, 253, 237, 237, 237, - 244, 244, 244, 240, 240, 242, 242, 242, 243, 243, - 243, 241, 250, 250, 252, 252, 251, 251, 247, 247, - 248, 248, 249, 249, 249, 245, 245, 202, 202, 202, - 202, 202, 254, 254, 254, 254, 308, 308, 308, 266, - 266, 213, 213, 215, 215, 214, 214, 163, 267, 267, - 275, 272, 272, 273, 273, 300, 300, 300, 276, 276, - 289, 289, 285, 285, 286, 286, 279, 279, 291, 291, - 291, 77, 211, 211, 371, 371, 368, 295, 295, 297, - 297, 301, 301, 305, 305, 302, 302, 8, 416, 416, - 416, 293, 293, 293, 293, 293, 293, 293, 293, 293, + 316, 319, 319, 225, 225, 122, 122, 223, 223, 224, + 226, 226, 218, 218, 218, 218, 220, 220, 203, 203, + 203, 228, 228, 320, 320, 229, 229, 106, 107, 107, + 108, 108, 230, 230, 232, 231, 231, 233, 234, 234, + 234, 235, 235, 236, 236, 236, 49, 49, 49, 49, + 49, 44, 44, 44, 44, 45, 45, 45, 45, 137, + 137, 137, 137, 139, 139, 138, 138, 82, 82, 83, + 83, 83, 143, 143, 144, 144, 144, 141, 141, 142, + 142, 253, 253, 253, 253, 253, 253, 253, 237, 237, + 237, 244, 244, 244, 240, 240, 242, 242, 242, 243, + 243, 243, 241, 250, 250, 252, 252, 251, 251, 247, + 247, 248, 248, 249, 249, 249, 245, 245, 202, 202, + 202, 202, 202, 254, 254, 254, 254, 308, 308, 308, + 266, 266, 213, 213, 215, 215, 214, 214, 163, 267, + 267, 275, 272, 272, 273, 273, 300, 300, 300, 276, + 276, 289, 289, 285, 285, 286, 286, 279, 279, 291, + 291, 291, 77, 211, 211, 371, 371, 368, 295, 295, + 297, 297, 301, 301, 305, 305, 302, 302, 8, 416, + 416, 416, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, @@ -8714,7 +8756,7 @@ var yyR1 = [...]int{ 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, 293, - 293, 293, 293, 293, 294, 294, 294, 294, 294, 294, + 293, 293, 293, 293, 293, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, @@ -8762,7 +8804,7 @@ var yyR1 = [...]int{ 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, 294, - 294, 419, 420, 312, 313, 313, 313, + 294, 294, 294, 419, 420, 312, 313, 313, 313, } var yyR2 = [...]int{ @@ -8826,111 +8868,111 @@ var yyR2 = [...]int{ 3, 3, 3, 2, 2, 3, 4, 4, 2, 11, 3, 6, 8, 6, 6, 6, 13, 8, 6, 6, 10, 7, 5, 5, 5, 5, 7, 5, 5, 5, - 5, 5, 7, 7, 5, 5, 5, 5, 0, 6, - 5, 6, 4, 5, 0, 8, 9, 0, 3, 0, - 1, 0, 3, 8, 4, 1, 3, 3, 6, 7, - 7, 8, 4, 0, 1, 0, 1, 3, 3, 1, - 1, 2, 1, 1, 0, 2, 0, 2, 5, 3, - 7, 4, 4, 4, 4, 3, 3, 3, 7, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, - 0, 2, 2, 1, 3, 2, 0, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 3, 1, 3, 3, - 0, 2, 2, 2, 2, 2, 2, 2, 4, 4, - 3, 0, 1, 4, 3, 4, 4, 3, 3, 3, - 2, 1, 3, 3, 3, 5, 7, 7, 6, 5, - 3, 2, 4, 5, 5, 3, 3, 7, 3, 3, - 3, 3, 4, 7, 5, 2, 4, 4, 4, 4, - 4, 5, 5, 4, 4, 4, 4, 4, 4, 4, - 4, 2, 2, 4, 4, 4, 4, 4, 2, 3, - 3, 3, 3, 3, 5, 2, 3, 3, 2, 3, - 4, 4, 4, 3, 4, 4, 5, 3, 5, 3, - 5, 0, 1, 0, 1, 0, 1, 1, 1, 0, - 2, 2, 0, 2, 2, 0, 2, 0, 1, 1, - 1, 1, 2, 1, 3, 1, 1, 1, 1, 1, - 3, 0, 1, 1, 3, 3, 2, 2, 1, 1, - 5, 0, 1, 0, 1, 2, 3, 0, 3, 3, - 3, 1, 0, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 0, 1, 1, 4, 4, - 4, 2, 2, 3, 1, 3, 2, 1, 2, 1, - 2, 2, 4, 3, 3, 6, 4, 7, 6, 1, - 3, 2, 2, 2, 2, 1, 1, 1, 3, 2, - 1, 1, 1, 0, 1, 1, 0, 3, 0, 2, - 0, 2, 1, 2, 2, 0, 1, 1, 0, 1, - 1, 5, 5, 4, 0, 2, 4, 4, 0, 1, - 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 3, 1, 2, 3, 5, 0, - 1, 2, 1, 1, 0, 1, 2, 1, 3, 1, - 1, 1, 4, 3, 1, 1, 2, 3, 7, 0, - 3, 0, 1, 1, 3, 1, 3, 1, 1, 3, - 3, 1, 3, 4, 4, 4, 3, 2, 4, 0, - 1, 0, 2, 0, 1, 0, 1, 2, 1, 1, - 1, 2, 2, 1, 2, 3, 2, 3, 2, 2, - 2, 1, 1, 3, 3, 0, 1, 1, 2, 6, - 5, 6, 6, 5, 5, 0, 2, 3, 3, 0, - 2, 3, 3, 3, 2, 3, 1, 3, 6, 1, - 1, 3, 4, 3, 4, 4, 4, 1, 3, 4, - 5, 6, 3, 4, 5, 6, 3, 4, 1, 1, - 1, 3, 3, 3, 3, 3, 3, 5, 5, 3, - 3, 3, 3, 3, 3, 1, 1, 1, 1, 1, - 3, 1, 1, 1, 2, 2, 2, 2, 1, 1, - 2, 7, 7, 6, 6, 2, 2, 5, 6, 3, - 3, 1, 3, 1, 3, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, - 2, 4, 0, 1, 2, 5, 0, 3, 0, 1, - 4, 4, 2, 1, 0, 0, 1, 1, 2, 2, - 1, 1, 2, 2, 0, 1, 1, 1, 1, 5, - 1, 3, 0, 3, 1, 1, 1, 2, 1, 2, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 3, 4, 6, 4, 4, 8, 8, - 6, 8, 6, 5, 4, 10, 2, 2, 1, 2, - 2, 2, 2, 2, 5, 6, 6, 6, 6, 6, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 8, 4, 8, 8, 6, 5, 4, 4, 4, 5, - 7, 4, 4, 7, 4, 4, 6, 6, 6, 8, - 6, 6, 4, 4, 3, 4, 6, 6, 4, 4, - 6, 4, 6, 4, 4, 4, 4, 4, 4, 6, - 4, 6, 4, 4, 4, 6, 4, 6, 4, 4, - 6, 4, 6, 4, 6, 8, 4, 6, 8, 4, + 5, 5, 7, 7, 5, 5, 5, 5, 6, 0, + 6, 5, 6, 4, 5, 0, 8, 9, 0, 3, + 0, 1, 0, 3, 8, 4, 1, 3, 3, 6, + 7, 7, 8, 4, 0, 1, 0, 1, 3, 3, + 1, 1, 2, 1, 1, 0, 2, 0, 2, 5, + 3, 7, 4, 4, 4, 4, 3, 3, 3, 7, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 2, 0, 2, 2, 1, 3, 2, 0, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 3, 1, 3, + 3, 0, 2, 2, 2, 2, 2, 2, 2, 4, + 4, 3, 0, 1, 4, 3, 4, 4, 3, 3, + 3, 2, 1, 3, 3, 3, 5, 7, 7, 6, + 5, 3, 2, 4, 5, 5, 3, 3, 7, 3, + 3, 3, 3, 4, 7, 5, 2, 4, 4, 4, + 4, 4, 5, 5, 4, 4, 4, 4, 4, 4, + 4, 4, 2, 2, 4, 4, 4, 4, 4, 2, + 3, 3, 3, 3, 3, 5, 2, 3, 3, 2, + 3, 4, 4, 4, 3, 4, 4, 5, 3, 5, + 3, 5, 0, 1, 0, 1, 0, 1, 1, 1, + 0, 2, 2, 0, 2, 2, 0, 2, 0, 1, + 1, 1, 1, 2, 1, 3, 1, 1, 1, 1, + 1, 3, 0, 1, 1, 3, 3, 2, 2, 1, + 1, 5, 0, 1, 0, 1, 2, 3, 0, 3, + 3, 3, 1, 0, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 0, 1, 1, 4, + 4, 4, 2, 2, 3, 1, 3, 2, 1, 2, + 1, 2, 2, 4, 3, 3, 6, 4, 7, 6, + 1, 3, 2, 2, 2, 2, 1, 1, 1, 3, + 2, 1, 1, 1, 0, 1, 1, 0, 3, 0, + 2, 0, 2, 1, 2, 2, 0, 1, 1, 0, + 1, 1, 5, 5, 4, 0, 2, 4, 4, 0, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 3, 1, 2, 3, 5, + 0, 1, 2, 1, 1, 0, 1, 2, 1, 3, + 1, 1, 1, 4, 3, 1, 1, 2, 3, 7, + 0, 3, 0, 1, 1, 3, 1, 3, 1, 1, + 3, 3, 1, 3, 4, 4, 4, 3, 2, 4, + 0, 1, 0, 2, 0, 1, 0, 1, 2, 1, + 1, 1, 2, 2, 1, 2, 3, 2, 3, 2, + 2, 2, 1, 1, 3, 3, 0, 1, 1, 2, + 6, 5, 6, 6, 5, 5, 0, 2, 3, 3, + 0, 2, 3, 3, 3, 2, 3, 1, 3, 6, + 1, 1, 3, 4, 3, 4, 4, 4, 1, 3, + 4, 5, 6, 3, 4, 5, 6, 3, 4, 1, + 1, 1, 3, 3, 3, 3, 3, 3, 5, 5, + 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, + 1, 3, 1, 1, 1, 2, 2, 2, 2, 1, + 1, 2, 7, 7, 6, 6, 2, 2, 5, 6, + 3, 3, 1, 3, 1, 3, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, + 4, 2, 4, 0, 1, 2, 5, 0, 3, 0, + 1, 4, 4, 2, 1, 0, 0, 1, 1, 2, + 2, 1, 1, 2, 2, 0, 1, 1, 1, 1, + 5, 1, 3, 0, 3, 1, 1, 1, 2, 1, + 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 3, 4, 6, 4, 4, 8, + 8, 6, 8, 6, 5, 4, 10, 2, 2, 1, + 2, 2, 2, 2, 2, 5, 6, 6, 6, 6, + 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 8, 4, 8, 8, 6, 5, 4, 4, 4, + 5, 7, 4, 4, 7, 4, 4, 6, 6, 6, + 8, 6, 6, 4, 4, 3, 4, 6, 6, 4, + 4, 6, 4, 6, 4, 4, 4, 4, 4, 4, + 6, 4, 6, 4, 4, 4, 6, 4, 6, 4, + 4, 6, 4, 6, 4, 6, 8, 4, 6, 8, + 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, 8, 4, - 6, 8, 4, 6, 8, 4, 6, 8, 4, 6, - 8, 4, 4, 4, 6, 4, 6, 4, 8, 6, - 4, 4, 6, 4, 6, 8, 4, 6, 8, 4, - 4, 6, 8, 6, 4, 6, 6, 8, 10, 7, - 8, 8, 9, 4, 4, 4, 4, 6, 6, 6, - 6, 6, 6, 6, 6, 6, 6, 4, 4, 4, - 4, 4, 4, 6, 4, 6, 5, 9, 6, 9, - 8, 6, 8, 8, 8, 6, 1, 1, 1, 1, - 1, 1, 1, 1, 0, 2, 6, 8, 10, 12, - 14, 6, 8, 8, 10, 12, 14, 6, 8, 10, - 12, 6, 8, 4, 4, 3, 4, 6, 6, 4, - 6, 4, 6, 8, 0, 2, 1, 1, 1, 1, + 6, 8, 4, 4, 4, 6, 4, 6, 4, 8, + 6, 4, 4, 6, 4, 6, 8, 4, 6, 8, + 4, 4, 6, 8, 6, 4, 6, 6, 8, 10, + 7, 8, 8, 9, 4, 4, 4, 4, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 4, 4, + 4, 4, 4, 4, 6, 4, 6, 5, 9, 6, + 9, 8, 6, 8, 8, 8, 6, 1, 1, 1, + 1, 1, 1, 1, 1, 0, 2, 6, 8, 10, + 12, 14, 6, 8, 8, 10, 12, 14, 6, 8, + 10, 12, 6, 8, 4, 4, 3, 4, 6, 6, + 4, 6, 4, 6, 8, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 0, 2, 0, 2, 3, 4, - 4, 4, 4, 4, 0, 3, 4, 7, 3, 1, - 1, 1, 0, 5, 5, 2, 3, 1, 2, 2, - 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, - 0, 1, 0, 1, 0, 2, 1, 2, 4, 0, - 2, 1, 1, 3, 5, 1, 1, 1, 2, 2, - 0, 4, 0, 2, 0, 2, 2, 1, 3, 0, - 1, 0, 1, 3, 1, 3, 2, 0, 1, 1, - 0, 1, 2, 4, 4, 0, 2, 2, 1, 1, - 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, - 3, 3, 0, 3, 1, 1, 0, 4, 0, 1, - 1, 0, 3, 1, 3, 2, 1, 1, 0, 1, - 2, 3, 4, 2, 3, 4, 4, 9, 3, 5, - 0, 3, 3, 0, 1, 0, 2, 2, 0, 2, - 2, 2, 0, 2, 1, 2, 3, 3, 0, 2, - 1, 2, 3, 4, 3, 0, 1, 3, 1, 6, - 5, 4, 1, 3, 3, 5, 0, 2, 5, 0, - 5, 1, 3, 1, 2, 3, 4, 1, 1, 3, - 3, 1, 2, 1, 1, 1, 1, 1, 1, 1, - 0, 1, 0, 2, 0, 3, 0, 1, 0, 1, - 1, 5, 0, 1, 0, 1, 2, 1, 1, 1, - 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, + 1, 1, 1, 1, 1, 0, 2, 0, 2, 3, + 4, 4, 4, 4, 4, 0, 3, 4, 7, 3, + 1, 1, 1, 0, 5, 5, 2, 3, 1, 2, + 2, 1, 2, 1, 2, 2, 1, 2, 2, 1, + 1, 0, 1, 0, 1, 0, 2, 1, 2, 4, + 0, 2, 1, 1, 3, 5, 1, 1, 1, 2, + 2, 0, 4, 0, 2, 0, 2, 2, 1, 3, + 0, 1, 0, 1, 3, 1, 3, 2, 0, 1, + 1, 0, 1, 2, 4, 4, 0, 2, 2, 1, + 1, 3, 3, 3, 3, 3, 3, 3, 3, 0, + 3, 3, 3, 0, 3, 1, 1, 0, 4, 0, + 1, 1, 0, 3, 1, 3, 2, 1, 1, 0, + 1, 2, 3, 4, 2, 3, 4, 4, 9, 3, + 5, 0, 3, 3, 0, 1, 0, 2, 2, 0, + 2, 2, 2, 0, 2, 1, 2, 3, 3, 0, + 2, 1, 2, 3, 4, 3, 0, 1, 3, 1, + 6, 5, 4, 1, 3, 3, 5, 0, 2, 5, + 0, 5, 1, 3, 1, 2, 3, 4, 1, 1, + 3, 3, 1, 2, 1, 1, 1, 1, 1, 1, + 1, 0, 1, 0, 2, 0, 3, 0, 1, 0, + 1, 1, 5, 0, 1, 0, 1, 2, 1, 1, + 1, 1, 1, 1, 0, 1, 1, 1, 3, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -8994,7 +9036,7 @@ var yyR2 = [...]int{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 0, 0, 1, 1, + 1, 1, 1, 1, 1, 0, 0, 1, 1, } var yyChk = [...]int{ @@ -9004,157 +9046,156 @@ var yyChk = [...]int{ -27, -28, -74, -75, -76, -77, -78, -12, -13, -14, -8, -32, -31, -30, 13, 14, -109, -35, 35, -40, -50, 240, -51, -41, 241, -52, 243, 242, 280, 244, - 396, 273, 83, 329, 330, 332, 333, 334, 335, -110, - 703, 278, 279, 246, 39, 51, 36, 37, 40, 250, - 286, 287, 249, 145, -33, -36, 12, -419, 15, 486, - 275, 274, 31, -34, 596, 95, -80, -418, 751, -253, + 397, 273, 83, 330, 331, 333, 334, 335, 336, -110, + 704, 278, 279, 246, 39, 51, 36, 37, 40, 250, + 286, 287, 249, 145, -33, -36, 12, -419, 15, 487, + 275, 274, 31, -34, 597, 95, -80, -418, 752, -253, -237, 26, 36, 32, -236, -232, -128, -237, 24, 22, 11, -79, -79, -79, 16, 17, -79, -356, -358, 95, 173, 95, -79, -57, -56, -54, -53, -55, -58, 34, -47, -48, -380, -46, -43, 245, 242, 290, 135, 136, 280, 281, 282, 244, 264, 279, 283, 278, 299, -42, - 90, 36, 596, 599, -363, 241, 247, 248, 243, 487, - 138, 137, 84, -360, 391, 630, 721, -58, 723, 110, - 113, 722, 50, 254, 724, 725, 726, 637, 727, 263, - 728, 729, 730, 731, 737, 678, 738, 739, 740, 139, - 11, -79, -305, -301, 100, -294, 593, 266, 628, 440, - 629, 315, 90, 47, 42, 532, 603, 387, 391, 630, - 517, 721, 397, 329, 347, 341, 522, 523, 524, 370, - 362, 594, 631, 604, 318, 267, 303, 715, 360, 149, - 723, 322, 632, 281, 398, 399, 633, 400, 110, 332, - 437, 736, 321, 634, 734, 113, 722, 337, 88, 516, - 57, 718, 50, 276, 445, 446, 358, 249, 354, 724, - 304, 635, 606, 297, 138, 135, 743, 39, 350, 56, - 33, 733, 137, 55, 725, 164, 636, 726, 637, 402, - 377, 709, 54, 403, 282, 638, 93, 287, 598, 326, - 717, 404, 537, 351, 405, 314, 732, 246, 639, 325, - 698, 690, 691, 406, 407, 710, 382, 378, 383, 539, - 640, 429, 521, 408, 694, 695, 750, 58, 641, 642, - 711, 136, 643, 87, 727, 89, 345, 346, 644, 312, - 265, 542, 543, 431, 374, 499, 127, 506, 507, 120, - 121, 502, 122, 508, 123, 128, 509, 510, 511, 500, - 124, 117, 501, 512, 513, 375, 376, 125, 514, 119, - 118, 503, 505, 126, 515, 263, 38, 409, 595, 316, - 64, 320, 291, 432, 52, 380, 747, 51, 705, 544, - 645, 708, 373, 369, 496, 59, 646, 647, 648, 649, - 518, 728, 372, 344, 368, 742, 4, 309, 491, 519, - 729, 68, 248, 385, 384, 386, 298, 428, 365, 650, - 651, 652, 270, 91, 653, 355, 25, 654, 655, 410, - 305, 656, 62, 657, 658, 435, 279, 659, 60, 730, - 45, 660, 284, 744, 731, 661, 662, 663, 704, 664, - 286, 665, 412, 666, 692, 693, 411, 379, 381, 545, - 293, 413, 396, 251, 597, 667, 327, 349, 283, 735, - 668, 271, 533, 534, 535, 536, 716, 541, 540, 285, - 290, 278, 436, 272, 669, 670, 671, 672, 673, 319, - 689, 674, 675, 333, 601, 737, 497, 49, 676, 677, - 678, 679, 680, 313, 308, 430, 439, 67, 92, 393, - 681, 682, 714, 343, 338, 43, 306, 99, 477, 479, - 480, 481, 482, 483, 478, 485, 683, 330, 61, 738, - 739, 740, 300, 741, 525, 526, 527, 528, 13, 579, - 562, 590, 563, 580, 564, 573, 565, 581, 589, 591, - 546, 554, 547, 555, 585, 568, 582, 574, 567, 566, - 588, 571, 575, 548, 556, 586, 572, 549, 557, 550, - 558, 551, 559, 584, 583, 576, 587, 552, 560, 578, - 553, 561, 577, 569, 570, 448, 748, 749, 520, 415, - 139, 310, 311, 53, 366, 292, 684, 323, 685, 356, - 357, 493, 494, 371, 342, 367, 146, 701, 331, 340, - 699, 294, 416, 498, 280, 686, 438, 307, 388, 131, - 339, 394, 324, 602, 538, 299, 417, 713, 600, 529, - 530, 364, 361, 301, 531, 687, 389, 703, 418, 255, - 295, 296, 688, 700, 419, 420, 317, 421, 422, 423, - 424, 425, 427, 328, 426, 702, 696, 697, 302, 476, - 599, 336, 359, 395, 458, 459, 460, 461, 462, 463, + 90, 36, 597, 600, -363, 241, 247, 248, 243, 488, + 138, 137, 84, -360, 392, 631, 722, -58, 724, 110, + 113, 723, 50, 254, 725, 726, 727, 638, 728, 263, + 729, 730, 731, 732, 738, 679, 739, 740, 741, 139, + 11, -79, -305, -301, 100, -294, 594, 266, 629, 441, + 630, 315, 90, 47, 42, 533, 604, 388, 392, 631, + 518, 722, 398, 330, 348, 342, 523, 524, 525, 371, + 363, 595, 632, 605, 318, 267, 303, 716, 361, 149, + 724, 322, 633, 281, 399, 400, 634, 401, 110, 333, + 438, 737, 321, 635, 735, 113, 723, 338, 88, 517, + 57, 719, 326, 50, 276, 446, 447, 359, 249, 355, + 725, 304, 636, 607, 297, 138, 135, 744, 39, 351, + 56, 33, 734, 137, 55, 726, 164, 637, 727, 638, + 403, 378, 710, 54, 404, 282, 639, 93, 287, 599, + 327, 718, 405, 538, 352, 406, 314, 733, 246, 640, + 325, 699, 691, 692, 407, 408, 711, 383, 379, 384, + 540, 641, 430, 522, 409, 695, 696, 751, 58, 642, + 643, 712, 136, 644, 87, 728, 89, 346, 347, 645, + 312, 265, 543, 544, 432, 375, 500, 127, 507, 508, + 120, 121, 503, 122, 509, 123, 128, 510, 511, 512, + 501, 124, 117, 502, 513, 514, 376, 377, 125, 515, + 119, 118, 504, 506, 126, 516, 263, 38, 410, 596, + 316, 64, 320, 291, 433, 52, 381, 748, 51, 706, + 545, 646, 709, 374, 370, 497, 59, 647, 648, 649, + 650, 519, 729, 373, 345, 369, 743, 4, 309, 492, + 520, 730, 68, 248, 386, 385, 387, 298, 429, 366, + 651, 652, 653, 270, 91, 654, 356, 25, 655, 656, + 411, 305, 657, 62, 658, 659, 436, 279, 660, 60, + 731, 45, 661, 284, 745, 732, 662, 663, 664, 705, + 665, 286, 666, 413, 667, 693, 694, 412, 380, 382, + 546, 293, 414, 397, 251, 598, 668, 328, 350, 283, + 736, 669, 271, 534, 535, 536, 537, 717, 542, 541, + 285, 290, 278, 437, 272, 670, 671, 672, 673, 674, + 319, 690, 675, 676, 334, 602, 738, 498, 49, 677, + 678, 679, 680, 681, 313, 308, 431, 440, 67, 92, + 394, 682, 683, 715, 344, 339, 43, 306, 99, 478, + 480, 481, 482, 483, 484, 479, 486, 684, 331, 61, + 739, 740, 741, 300, 742, 526, 527, 528, 529, 13, + 580, 563, 591, 564, 581, 565, 574, 566, 582, 590, + 592, 547, 555, 548, 556, 586, 569, 583, 575, 568, + 567, 589, 572, 576, 549, 557, 587, 573, 550, 558, + 551, 559, 552, 560, 585, 584, 577, 588, 553, 561, + 579, 554, 562, 578, 570, 571, 449, 749, 750, 521, + 416, 139, 310, 311, 53, 367, 292, 685, 323, 686, + 357, 358, 494, 495, 372, 343, 368, 146, 702, 332, + 341, 700, 294, 417, 499, 280, 687, 439, 307, 389, + 131, 340, 395, 324, 603, 539, 299, 418, 714, 601, + 530, 531, 365, 362, 301, 532, 688, 390, 704, 419, + 255, 295, 296, 689, 701, 420, 421, 317, 422, 423, + 424, 425, 426, 428, 329, 427, 703, 697, 698, 302, + 477, 600, 337, 360, 396, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, - 474, 475, 495, 253, -79, 253, -190, -301, -130, 705, - 707, 192, -272, 399, -290, 401, 414, 409, 419, 407, - -281, 410, 412, 293, -403, 429, 253, 416, 240, 402, - 411, 420, 421, 317, 427, 422, 328, 426, 302, 423, - 424, 425, -387, 192, 726, 741, 331, 339, 149, 363, - 406, 404, 430, 705, 100, -307, 100, 101, 102, -294, - 331, -310, 336, -295, -387, -294, 334, -79, -79, -312, - -312, -130, -210, -145, 157, -159, -261, -162, 101, -150, - -153, -204, -205, -206, -207, -160, -220, -259, 181, 182, - 189, 158, -216, -163, 29, 592, 488, 487, 192, 34, - 235, 77, 78, 490, 491, 160, 63, 15, 453, 454, - -161, 443, 444, 455, 449, 450, 516, 518, 519, 520, - 517, 522, 523, 524, 525, 526, 527, 528, 529, 530, - 531, 521, 532, 493, 494, 129, 495, 117, 119, 118, - 127, 128, 496, 497, 498, 360, 544, 545, 539, 542, - 543, 541, 540, 375, 376, 499, 562, 563, 567, 566, - 564, 565, 568, 571, 572, 573, 574, 575, 576, 578, - 577, 569, 570, 547, 546, 548, 549, 550, 551, 552, - 553, 555, 554, 556, 557, 558, 559, 560, 561, 579, - 580, 581, 582, 583, 585, 584, 589, 588, 586, 587, - 591, 590, 500, 501, 120, 121, 122, 123, 124, 125, - 126, 502, 505, 503, 504, 506, 507, 508, 513, 514, - 509, 510, 511, 512, 515, 386, 384, 385, 381, 380, - 379, -89, -102, 619, 618, -103, 440, 445, 446, 448, - -151, -152, -165, -166, -295, -301, 258, 442, 252, 187, - 486, -154, -148, -218, 116, 102, -31, -214, 441, 451, - 452, 456, 447, 457, 605, 607, 622, 623, 625, 610, - 615, 614, 617, 533, 534, 535, 536, 537, 538, 690, - 691, 692, 693, 694, 695, 696, 697, -387, -294, 100, - -157, -155, -199, 103, 108, 111, 112, 114, -409, 276, - 356, 357, 130, -419, 719, -156, 105, 106, 107, 132, - 133, 193, 194, 195, 196, 197, 198, 199, 200, 201, - 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, - 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 233, 234, 98, 104, 50, 415, 415, -190, -79, - -79, -79, -79, -416, 722, 597, -230, -128, -232, -33, - -31, -419, 12, -79, -31, -32, -30, -36, -38, 624, - -37, -301, 109, -237, -253, 16, 67, 176, 48, 56, - -235, -236, -34, -31, -145, 23, 41, 27, -132, 183, - -145, -301, -132, -279, 257, -79, -79, -268, -315, 331, - -270, 430, 705, 429, -260, -273, 100, -259, -272, 428, - 101, -357, 173, -343, -347, -295, 268, -373, 264, -190, - -366, -365, -295, -419, -129, -289, 254, 262, 261, 150, - -390, 153, 310, 442, 252, -53, -54, -55, -272, 191, - 725, -111, 285, 289, 96, 96, -347, -346, -345, -391, - 289, 268, -372, -364, 260, 269, -353, 261, 262, -348, - 254, 151, -391, -348, 259, 269, 264, 268, 289, 289, - 139, 289, 139, 289, 289, 289, 289, 289, 289, 289, - 289, 289, 284, -354, 165, -354, 600, 600, -360, -391, - 264, 254, -391, -391, 260, -291, -348, 256, 28, 256, - 38, 38, -354, -354, -354, -272, 191, -354, -354, -354, - -354, 297, 297, -354, -354, -354, -354, -354, -354, -354, + 474, 475, 476, 496, 253, -79, 253, -190, -301, -130, + 706, 708, 192, -272, 400, -290, 402, 415, 410, 420, + 408, -281, 411, 413, 293, -403, 430, 253, 417, 240, + 403, 412, 421, 422, 317, 428, 423, 329, 427, 302, + 424, 425, 426, -387, 192, 727, 742, 332, 340, 149, + 364, 407, 405, 431, 706, 100, -307, 100, 101, 102, + -294, 332, -310, 337, -295, -387, -294, 335, -79, -79, + -312, -312, -130, -210, -145, 157, -159, -261, -162, 101, + -150, -153, -204, -205, -206, -207, -160, -220, -259, 181, + 182, 189, 158, -216, -163, 29, 593, 489, 488, 192, + 34, 235, 77, 78, 491, 492, 160, 63, 15, 454, + 455, -161, 444, 445, 456, 450, 451, 517, 519, 520, + 521, 518, 523, 524, 525, 526, 527, 528, 529, 530, + 531, 532, 522, 533, 494, 495, 129, 496, 117, 119, + 118, 127, 128, 497, 498, 499, 361, 545, 546, 540, + 543, 544, 542, 541, 376, 377, 500, 563, 564, 568, + 567, 565, 566, 569, 572, 573, 574, 575, 576, 577, + 579, 578, 570, 571, 548, 547, 549, 550, 551, 552, + 553, 554, 556, 555, 557, 558, 559, 560, 561, 562, + 580, 581, 582, 583, 584, 586, 585, 590, 589, 587, + 588, 592, 591, 501, 502, 120, 121, 122, 123, 124, + 125, 126, 503, 506, 504, 505, 507, 508, 509, 514, + 515, 510, 511, 512, 513, 516, 387, 385, 386, 382, + 381, 380, -89, -102, 620, 619, -103, 441, 446, 447, + 449, -151, -152, -165, -166, -295, -301, 258, 443, 252, + 187, 487, -154, -148, -218, 116, 102, -31, -214, 442, + 452, 453, 457, 448, 458, 606, 608, 623, 624, 626, + 611, 616, 615, 618, 534, 535, 536, 537, 538, 539, + 691, 692, 693, 694, 695, 696, 697, 698, -387, -294, + 100, -157, -155, -199, 103, 108, 111, 112, 114, -409, + 276, 357, 358, 130, -419, 720, -156, 105, 106, 107, + 132, 133, 193, 194, 195, 196, 197, 198, 199, 200, + 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 233, 234, 98, 104, 50, 416, 416, -190, + -79, -79, -79, -79, -416, 723, 598, -230, -128, -232, + -33, -31, -419, 12, -79, -31, -32, -30, -36, -38, + 625, -37, -301, 109, -237, -253, 16, 67, 176, 48, + 56, -235, -236, -34, -31, -145, 23, 41, 27, -132, + 183, -145, -301, -132, -279, 257, -79, -79, -268, -315, + 332, -270, 431, 706, 430, -260, -273, 100, -259, -272, + 429, 101, -357, 173, -343, -347, -295, 268, -373, 264, + -190, -366, -365, -295, -419, -129, -289, 254, 262, 261, + 150, -390, 153, 310, 443, 252, -53, -54, -55, -272, + 191, 726, -111, 285, 289, 96, 96, -347, -346, -345, + -391, 289, 268, -372, -364, 260, 269, -353, 261, 262, + -348, 254, 151, -391, -348, 259, 269, 264, 268, 289, + 289, 139, 289, 139, 289, 289, 289, 289, 289, 289, + 289, 289, 289, 284, -354, 165, -354, 601, 601, -360, + -391, 264, 254, -391, -391, 260, -291, -348, 256, 28, + 256, 38, 38, -354, -354, -354, -272, 191, -354, -354, + -354, -354, 297, 297, -354, -354, -354, -354, -354, -354, -354, -354, -354, -354, -354, -354, -354, -354, -354, -354, - 253, -390, -137, 426, 317, 90, -56, 299, -39, -190, - -289, 254, 255, -390, 286, -190, 236, 253, 708, -283, - 173, 19, -283, -280, 415, 413, 400, 405, -283, -283, - -283, -283, 300, 398, -349, 254, 38, 265, 415, 300, - 398, 300, 301, 300, 301, 408, 418, 300, -306, 18, - 176, 442, 403, 407, 293, 253, 294, 255, 417, 301, - -306, 98, -284, 173, 300, 415, 409, 296, -283, -283, - -313, -419, -297, -295, -293, 245, 41, 156, 28, 30, - 159, 192, 142, 23, 160, 40, 247, 363, 264, 191, - 260, 487, 240, 81, 605, 443, 450, 441, 449, 453, - 489, 490, 442, 401, 34, 17, 607, 31, 274, 27, - 44, 185, 242, 163, 608, 277, 29, 275, 129, 133, - 610, 26, 84, 269, 18, 262, 46, 20, 611, 612, - 21, 74, 258, 257, 176, 254, 79, 15, 235, 32, - 172, 75, 613, 151, 145, 614, 615, 616, 617, 143, - 77, 173, 24, 745, 451, 452, 36, 706, 592, 288, - 187, 82, 65, 707, 157, 447, 618, 619, 130, 620, - 134, 85, 712, 153, 22, 80, 48, 621, 289, 622, - 259, 746, 623, 433, 624, 174, 243, 486, 78, 175, - 719, 625, 720, 252, 414, 12, 492, 35, 273, 261, - 73, 72, 141, 76, 457, 626, 253, 162, 256, 144, - 132, 11, 150, 37, 16, 83, 86, 454, 455, 456, - 63, 140, 596, 161, 19, 627, 434, 155, -387, 708, - -313, -313, 300, 340, 35, 101, -413, -414, -415, 596, - 433, 256, -295, -190, -85, 698, 244, -86, 704, 41, - 251, 146, 38, -135, 415, -123, 192, 726, 709, 710, - 711, 708, 412, 716, 714, 712, 300, 713, 96, 153, - 155, 156, 4, -145, 172, -200, -201, 171, 165, 166, - 167, 168, 169, 170, 177, 176, 157, 159, 173, -246, - 154, 178, 179, 180, 181, 182, 183, 184, 186, 185, - 187, 188, 174, 175, 191, 238, 239, -153, -153, -153, - -153, -216, -222, -221, -419, -218, -387, -294, -301, -419, - -419, -153, -278, -419, -150, -419, -419, -419, -419, -419, - -225, -145, -419, -419, -423, -419, -423, -423, -423, -332, - -419, -332, -332, -419, -419, -419, -419, -419, -419, -419, - -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, + -354, 253, -390, -137, 427, 317, 90, -56, 299, -39, + -190, -289, 254, 255, -390, 286, -190, 236, 253, 709, + -283, 173, 19, -283, -280, 416, 414, 401, 406, -283, + -283, -283, -283, 300, 399, -349, 254, 38, 265, 416, + 300, 399, 300, 301, 300, 301, 409, 419, 300, -306, + 18, 176, 443, 404, 408, 293, 253, 294, 255, 418, + 301, -306, 98, -284, 173, 300, 416, 410, 296, -283, + -283, -313, -419, -297, -295, -293, 245, 41, 156, 28, + 30, 159, 192, 142, 23, 160, 40, 247, 364, 264, + 191, 260, 488, 240, 81, 606, 444, 451, 442, 450, + 454, 490, 491, 443, 402, 34, 17, 608, 31, 274, + 27, 44, 185, 242, 163, 609, 277, 29, 275, 129, + 133, 611, 26, 84, 269, 18, 262, 46, 20, 612, + 613, 21, 74, 258, 257, 176, 254, 79, 15, 235, + 32, 172, 75, 614, 151, 145, 615, 616, 617, 618, + 143, 77, 173, 24, 746, 452, 453, 36, 707, 593, + 288, 187, 82, 65, 708, 157, 448, 619, 620, 130, + 621, 134, 85, 713, 153, 22, 80, 48, 622, 289, + 623, 259, 747, 624, 434, 625, 174, 243, 487, 78, + 175, 720, 626, 721, 252, 415, 12, 493, 35, 273, + 261, 73, 72, 141, 76, 458, 627, 253, 162, 256, + 144, 132, 11, 150, 37, 16, 83, 86, 455, 456, + 457, 63, 140, 597, 161, 19, 628, 435, 155, -387, + 709, -313, -313, 300, 341, 35, 101, -413, -414, -415, + 597, 434, 256, -295, -190, -85, 699, 244, -86, 705, + 41, 251, 146, 38, -135, 416, -123, 192, 727, 710, + 711, 712, 709, 413, 717, 715, 713, 300, 714, 96, + 153, 155, 156, 4, -145, 172, -200, -201, 171, 165, + 166, 167, 168, 169, 170, 177, 176, 157, 159, 173, + -246, 154, 178, 179, 180, 181, 182, 183, 184, 186, + 185, 187, 188, 174, 175, 191, 238, 239, -153, -153, + -153, -153, -216, -222, -221, -419, -218, -387, -294, -301, + -419, -419, -153, -278, -419, -150, -419, -419, -419, -419, + -419, -225, -145, -419, -419, -423, -419, -423, -423, -423, + -332, -419, -332, -332, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, @@ -9165,396 +9206,397 @@ var yyChk = [...]int{ -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, - -419, -419, -419, -419, -419, -419, -419, -419, 236, -419, - -419, -419, -419, -419, -332, -332, -332, -332, -332, -332, -419, -419, -419, -419, -419, -419, -419, -419, -419, -419, - -419, -419, -419, -419, 98, 112, 108, 111, 103, 114, - 98, 98, 98, 98, -31, -32, -210, -419, -312, -400, - -401, -193, -190, -419, 317, -295, -295, 286, 105, -235, - -34, -31, -230, -236, -232, -31, -79, -121, -134, 69, - 70, -133, -136, 27, 44, 74, 76, 99, 72, 73, - 71, 41, -420, 97, -420, -253, -420, 96, -38, -256, - 95, 652, 682, 652, 682, 67, 49, 98, 98, 96, - 25, -231, -233, -145, 18, -299, 4, -298, 28, -295, - 98, 236, 18, -191, 32, -190, -279, -279, 96, 100, - 331, -269, -271, 431, 433, 165, -300, -295, 98, 34, - 97, 96, -190, -321, -324, -326, -325, -327, -322, -323, - 360, 361, 192, 364, 366, 367, 368, 369, 370, 371, - 372, 373, 374, 377, 389, 35, 276, 356, 357, 358, - 359, 378, 379, 380, 381, 383, 384, 385, 386, 341, - 362, 594, 342, 343, 344, 345, 346, 347, 349, 350, - 353, 351, 352, 354, 355, -296, -295, 95, 97, 96, - -331, 95, -145, -137, 253, -295, 254, 254, 254, -286, - 258, 486, -354, -354, -354, 284, 23, -46, -43, -380, - 22, -42, -43, 245, 135, 136, 242, 95, -343, 95, - -352, -296, -295, 95, 151, 259, 150, -351, -348, -351, - -352, -295, -218, -295, 151, 151, -295, -295, -265, -295, - -265, -265, 41, -265, 41, -265, 41, 105, -295, -265, - 41, -265, 41, -265, 41, -265, 41, -265, 41, 34, - 87, 88, 89, 34, 91, 92, 93, -218, -295, -295, - -218, -343, -218, -190, -295, -272, 105, 105, 105, -354, - -354, 105, 98, 98, 98, -354, -354, 105, 98, -303, - -301, 98, 98, -392, 270, 314, 316, 105, 105, 105, - 105, 34, 98, -393, 34, 733, 732, 734, 735, 736, - 98, 105, 34, 105, 34, 105, -295, 95, -190, -143, - 304, 240, 242, 245, 85, 98, 322, 320, 321, 318, - 323, 324, 325, 165, 50, 96, 256, 253, -295, -285, - 258, -285, -295, -302, -301, -293, -190, 256, 397, 98, - -145, -350, 18, 176, -306, -306, -283, -190, -350, -306, - -283, -190, -283, -283, -283, -283, -306, -306, -306, -283, - -301, -301, -190, -190, -190, -190, -190, -190, -190, -313, - -284, -283, 708, 98, -277, 18, 85, -313, -313, -292, - 26, 26, 96, 337, 434, 435, -311, 334, -81, -295, - 98, -10, -29, -18, -17, -19, 165, -10, 96, 596, - -183, -190, 708, 708, 708, 708, 708, 708, -145, -145, - -145, -145, 620, -208, -411, 157, 132, 133, 130, 131, - -162, 42, 43, 41, -145, -209, -214, -216, 115, 176, - 159, 173, -246, -150, -153, -150, -150, -150, -150, -150, - -150, 235, -150, 235, -150, -150, -150, -150, -150, -150, - -314, -295, 98, 192, -158, -157, 114, -409, -158, 593, - 96, -221, 236, -145, -145, -387, -119, 459, 460, 461, - 462, 464, 465, 466, 469, 470, 474, 475, 458, 476, - 463, 468, 471, 472, 473, 467, 359, -145, -211, -210, - -211, -145, -145, -223, -224, 161, -218, -145, -420, -420, - 105, 183, -127, 27, 44, -127, -127, -127, -127, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -145, -127, - -145, -120, 458, 476, 463, 468, 471, 472, 473, 467, - 359, 477, 478, 479, 480, 481, 482, 483, 484, 485, - -120, -119, -145, -145, -145, -145, -145, -145, -145, -145, - -87, -145, 142, 143, 144, -210, -145, -150, -145, -145, - -145, -420, -145, -145, -145, -211, -145, -145, -145, -145, + -419, -419, -419, -419, -419, -419, -419, -419, -419, 236, + -419, -419, -419, -419, -419, -332, -332, -332, -332, -332, + -332, -419, -419, -419, -419, -419, -419, -419, -419, -419, + -419, -419, -419, -419, -419, 98, 112, 108, 111, 103, + 114, 98, 98, 98, 98, -31, -32, -210, -419, -312, + -400, -401, -193, -190, -419, 317, -295, -295, 286, 105, + -235, -34, -31, -230, -236, -232, -31, -79, -121, -134, + 69, 70, -133, -136, 27, 44, 74, 76, 99, 72, + 73, 71, 41, -420, 97, -420, -253, -420, 96, -38, + -256, 95, 653, 683, 653, 683, 67, 49, 98, 98, + 96, 25, -231, -233, -145, 18, -299, 4, -298, 28, + -295, 98, 236, 18, -191, 32, -190, -279, -279, 96, + 100, 332, -269, -271, 432, 434, 165, -300, -295, 98, + 34, 97, 96, -190, -321, -324, -326, -325, -327, -322, + -323, 361, 362, 192, 365, 367, 368, 369, 370, 371, + 372, 373, 374, 375, 378, 390, 35, 276, 357, 358, + 359, 360, 379, 380, 381, 382, 384, 385, 386, 387, + 342, 363, 595, 343, 344, 345, 346, 347, 348, 350, + 351, 354, 352, 353, 355, 356, -296, -295, 95, 97, + 96, -331, 95, -145, -137, 253, -295, 254, 254, 254, + -286, 258, 487, -354, -354, -354, 284, 23, -46, -43, + -380, 22, -42, -43, 245, 135, 136, 242, 95, -343, + 95, -352, -296, -295, 95, 151, 259, 150, -351, -348, + -351, -352, -295, -218, -295, 151, 151, -295, -295, -265, + -295, -265, -265, 41, -265, 41, -265, 41, 105, -295, + -265, 41, -265, 41, -265, 41, -265, 41, -265, 41, + 34, 87, 88, 89, 34, 91, 92, 93, -218, -295, + -295, -218, -343, -218, -190, -295, -272, 105, 105, 105, + -354, -354, 105, 98, 98, 98, -354, -354, 105, 98, + -303, -301, 98, 98, -392, 270, 314, 316, 105, 105, + 105, 105, 34, 98, -393, 34, 734, 733, 735, 736, + 737, 98, 105, 34, 105, 34, 105, -295, 95, -190, + -143, 304, 240, 242, 245, 85, 98, 322, 320, 321, + 318, 323, 324, 325, 165, 50, 96, 256, 253, -295, + -285, 258, -285, -295, -302, -301, -293, -190, 256, 398, + 98, -145, -350, 18, 176, -306, -306, -283, -190, -350, + -306, -283, -190, -283, -283, -283, -283, -306, -306, -306, + -283, -301, -301, -190, -190, -190, -190, -190, -190, -190, + -313, -284, -283, 709, 98, -277, 18, 85, -313, -313, + -292, 26, 26, 96, 338, 435, 436, -311, 335, -81, + -295, 98, -10, -29, -18, -17, -19, 165, -10, 96, + 597, -183, -190, 709, 709, 709, 709, 709, 709, -145, + -145, -145, -145, 621, -208, -411, 157, 132, 133, 130, + 131, -162, 42, 43, 41, -145, -209, -214, -216, 115, + 176, 159, 173, -246, -150, -153, -150, -150, -150, -150, + -150, -150, 235, -150, 235, -150, -150, -150, -150, -150, + -150, -314, -295, 98, 192, -158, -157, 114, -409, -158, + 594, 96, -221, 236, -145, -145, -387, -119, 460, 461, + 462, 463, 465, 466, 467, 470, 471, 475, 476, 459, + 477, 464, 469, 472, 473, 474, 468, 360, -145, -211, + -210, -211, -145, -145, -223, -224, 161, -218, -145, -420, + -420, 105, 183, -127, 27, 44, -127, -127, -127, -127, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, + -127, -145, -120, 459, 477, 464, 469, 472, 473, 474, + 468, 360, 478, 479, 480, 481, 482, 483, 484, 485, + 486, -120, -119, -145, -145, -145, -145, -145, -145, -145, + -145, -87, -145, 142, 143, 144, -210, -145, -150, -145, + -145, -145, -420, -145, -145, -145, -211, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -386, -385, -384, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -145, -145, -210, -210, - -210, -210, -210, -145, -420, -145, -164, -148, 105, -261, - 114, 101, -145, -145, -145, -145, -145, -145, -211, -297, - -302, -293, -294, -210, -211, -211, -210, -210, -145, -145, - -145, -145, -145, -145, -145, -145, -420, -145, -145, -145, - -145, -145, -253, -420, -210, 96, -402, 433, 434, 706, - -304, 289, -303, 28, -211, 98, 18, -263, 86, -295, - -235, -235, 69, 70, 65, -131, -132, -136, -420, -37, - 28, -255, -295, 645, 645, 68, 98, -333, -272, 387, - 388, 192, -145, -145, 96, -234, 30, 31, -190, -298, - 183, -302, -190, -264, 289, -190, -168, -170, -171, -172, - -193, -217, -419, -173, -31, 616, 613, 18, -183, -184, - -192, -301, -270, -315, -269, 96, 432, 434, 435, 85, - 134, -145, -334, 191, -362, -361, -360, -343, -345, -346, - -347, 97, -334, -339, 394, 393, -331, -331, -331, -331, - -331, -333, -333, -333, -333, 95, -331, 95, -331, -331, - -331, -331, -336, 95, -336, -336, -337, -336, 95, -337, - -338, 95, -338, -373, -145, -370, -369, -367, -368, 263, - 110, 688, 644, 596, 637, 678, 86, -365, -234, 105, - -420, -143, -286, -371, -368, -295, -295, -295, -301, 157, - 100, 98, 100, 98, 100, 98, -112, -60, -1, 745, - 746, 747, 96, 23, -344, -343, -59, 314, -376, -377, - 289, -372, -366, -352, 151, -351, -352, -352, -295, 96, - 32, 139, 139, 139, 139, 596, 242, 35, -287, 636, - 157, 688, 644, -343, -59, 256, 256, -314, -314, -314, - 98, 98, -282, 741, -183, -139, 306, 165, 295, 295, - 253, 308, 253, 308, -190, 319, 322, 320, 321, 318, - 323, 324, 325, 41, 41, 41, 41, 41, 41, 41, - 307, 309, 311, 297, -190, -190, -285, 85, -185, -190, - 29, -301, 98, 98, -190, -283, -283, -190, -283, -283, - -190, 98, -301, -415, 338, -295, 374, 699, 701, -123, - 433, 96, 596, 26, -124, 26, -419, -411, 132, 133, - -216, -216, -216, -209, -150, -153, -150, 156, 277, -150, - -150, -419, -218, -420, -297, 28, 96, 86, -420, 181, - 96, -420, -420, 96, 18, 96, -226, -224, 163, -145, - -420, 96, -420, -420, -210, -145, -145, -145, -145, -420, - -420, -420, -420, -420, -420, -420, -420, -420, -420, -210, - -420, 96, 96, 18, -318, 28, -420, -420, -420, -420, - 96, -420, -420, -225, -420, 18, -420, 86, 96, 176, - 96, -420, -420, -420, 96, 96, -420, -420, 96, -420, - 96, -420, -420, -420, -420, -420, -420, 96, -420, 96, - -420, -420, -420, 96, -420, 96, -420, -420, 96, -420, + -145, -145, -145, -386, -385, -384, -145, -145, -145, -145, + -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, + -145, -145, -145, -145, -145, -145, -145, -145, -145, -210, + -210, -210, -210, -210, -145, -420, -145, -164, -148, 105, + -261, 114, 101, -145, -145, -145, -145, -145, -145, -211, + -297, -302, -293, -294, -210, -211, -211, -210, -210, -145, + -145, -145, -145, -145, -145, -145, -145, -420, -145, -145, + -145, -145, -145, -253, -420, -210, 96, -402, 434, 435, + 707, -304, 289, -303, 28, -211, 98, 18, -263, 86, + -295, -235, -235, 69, 70, 65, -131, -132, -136, -420, + -37, 28, -255, -295, 646, 646, 68, 98, -333, -272, + 388, 389, 192, -145, -145, 96, -234, 30, 31, -190, + -298, 183, -302, -190, -264, 289, -190, -168, -170, -171, + -172, -193, -217, -419, -173, -31, 617, 614, 18, -183, + -184, -192, -301, -270, -315, -269, 96, 433, 435, 436, + 85, 134, -145, -334, 191, -362, -361, -360, -343, -345, + -346, -347, 97, -334, -339, 395, 394, -331, -331, -331, + -331, -331, -333, -333, -333, -333, 95, -331, 95, -331, + -331, -331, -331, -336, 95, -336, -336, -337, -336, 95, + -337, -338, 95, -338, -373, -145, -370, -369, -367, -368, + 263, 110, 689, 645, 597, 638, 679, 86, -365, -234, + 105, -420, -143, -286, -371, -368, -295, -295, -295, -301, + 157, 100, 98, 100, 98, 100, 98, -112, -60, -1, + 746, 747, 748, 96, 23, -344, -343, -59, 314, -376, + -377, 289, -372, -366, -352, 151, -351, -352, -352, -295, + 96, 32, 139, 139, 139, 139, 597, 242, 35, -287, + 637, 157, 689, 645, -343, -59, 256, 256, -314, -314, + -314, 98, 98, -282, 742, -183, -139, 306, 165, 295, + 295, 253, 308, 253, 308, -190, 319, 322, 320, 321, + 318, 323, 324, 325, 326, 41, 41, 41, 41, 41, + 41, 41, 307, 309, 311, 297, -190, -190, -285, 85, + -185, -190, 29, -301, 98, 98, -190, -283, -283, -190, + -283, -283, -190, 98, -301, -415, 339, -295, 375, 700, + 702, -123, 434, 96, 597, 26, -124, 26, -419, -411, + 132, 133, -216, -216, -216, -209, -150, -153, -150, 156, + 277, -150, -150, -419, -218, -420, -297, 28, 96, 86, + -420, 181, 96, -420, -420, 96, 18, 96, -226, -224, + 163, -145, -420, 96, -420, -420, -210, -145, -145, -145, + -145, -420, -420, -420, -420, -420, -420, -420, -420, -420, + -420, -210, -420, 96, 96, 18, -318, 28, -420, -420, + -420, -420, 96, -420, -420, -225, -420, 18, -420, 86, + 96, 176, 96, -420, -420, -420, 96, 96, -420, -420, + 96, -420, 96, -420, -420, -420, -420, -420, -420, 96, + -420, 96, -420, -420, -420, 96, -420, 96, -420, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, - 96, -420, 96, -420, -420, -420, 96, -420, 96, -420, - 96, -420, -420, 96, -420, 96, -420, 96, -420, 96, - 96, -420, 96, 96, 96, -420, 96, 96, 96, 96, - -420, -420, -420, -420, 96, 96, 96, 96, 96, 96, - 96, 96, 96, 96, -420, -420, -420, -420, -420, -420, - 96, -94, 621, -420, -420, 96, -420, 96, 96, 96, - 96, 96, -420, -419, 236, -420, -420, -420, -420, -420, - 96, 96, 96, 96, 96, 96, -420, -420, -420, 96, - 96, -420, 96, -420, 96, -420, -401, 705, 434, -197, - -196, -194, 83, 257, 84, -419, -303, -420, -158, -261, - -262, -261, -203, -295, 105, 114, -237, -167, 96, -169, - 18, -216, 97, 96, -333, -241, -247, -280, -295, 98, - 192, -335, 192, -335, 387, 388, -233, 236, -198, 19, - -202, 35, 63, -29, -419, -419, 35, 96, -186, -188, - -187, -189, 75, 79, 81, 76, 77, 78, 82, -309, - 28, -31, -168, -31, -419, -190, -183, -421, 18, 86, - -421, 96, 236, -271, -274, 436, 433, 439, -387, 98, - -111, 96, -360, -347, -238, -140, 46, -340, 395, -333, - 604, -333, -342, 98, -342, 105, 105, 105, 97, -49, - -44, -45, 36, 90, -367, -354, 98, 45, -354, -354, - -295, 97, -234, -139, -190, 85, -371, -371, -371, 29, - -2, 744, 750, 151, 95, 400, 22, -255, 96, 97, - -219, 315, 97, -113, -295, 97, 95, -352, -352, -295, - -419, 253, 34, 34, 688, 644, 636, -59, -219, -218, - -295, -334, 743, 742, 97, 255, 313, -144, 453, -141, - 98, 100, -190, -190, -190, -190, -190, -190, 245, 242, - 423, -410, 326, -410, 298, 256, -183, -190, 96, -84, - 272, 267, -306, -306, 36, -190, 433, 717, 715, -145, - 156, 277, -162, -153, -119, -119, -150, -316, 192, 360, - 276, 358, 354, 374, 365, 393, 356, 394, 351, 350, - 349, -316, -314, -150, -210, -145, -145, -145, 164, -145, - 162, -145, -95, -94, -420, -420, -420, -420, -420, -95, - -95, -95, -95, -95, -95, -95, -95, -95, -95, -230, - -145, -145, -145, -420, 192, 360, -95, -145, 18, -145, - -314, -145, -145, -145, -145, -145, -145, -145, -145, -145, + 96, -420, 96, -420, 96, -420, -420, -420, 96, -420, + 96, -420, 96, -420, -420, 96, -420, 96, -420, 96, + -420, 96, 96, -420, 96, 96, 96, -420, 96, 96, + 96, 96, -420, -420, -420, -420, 96, 96, 96, 96, + 96, 96, 96, 96, 96, 96, -420, -420, -420, -420, + -420, -420, 96, -94, 622, -420, -420, 96, -420, 96, + 96, 96, 96, 96, -420, -419, 236, -420, -420, -420, + -420, -420, 96, 96, 96, 96, 96, 96, -420, -420, + -420, 96, 96, -420, 96, -420, 96, -420, -401, 706, + 435, -197, -196, -194, 83, 257, 84, -419, -303, -420, + -158, -261, -262, -261, -203, -295, 105, 114, -237, -167, + 96, -169, 18, -216, 97, 96, -333, -241, -247, -280, + -295, 98, 192, -335, 192, -335, 388, 389, -233, 236, + -198, 19, -202, 35, 63, -29, -419, -419, 35, 96, + -186, -188, -187, -189, 75, 79, 81, 76, 77, 78, + 82, -309, 28, -31, -168, -31, -419, -190, -183, -421, + 18, 86, -421, 96, 236, -271, -274, 437, 434, 440, + -387, 98, -111, 96, -360, -347, -238, -140, 46, -340, + 396, -333, 605, -333, -342, 98, -342, 105, 105, 105, + 97, -49, -44, -45, 36, 90, -367, -354, 98, 45, + -354, -354, -295, 97, -234, -139, -190, 85, -371, -371, + -371, 29, -2, 745, 751, 151, 95, 401, 22, -255, + 96, 97, -219, 315, 97, -113, -295, 97, 95, -352, + -352, -295, -419, 253, 34, 34, 689, 645, 637, -59, + -219, -218, -295, -334, 744, 743, 97, 255, 313, -144, + 454, -141, 98, 100, -190, -190, -190, -190, -190, -190, + 245, 242, 424, -410, 327, 98, -410, 298, 256, -183, + -190, 96, -84, 272, 267, -306, -306, 36, -190, 434, + 718, 716, -145, 156, 277, -162, -153, -119, -119, -150, + -316, 192, 361, 276, 359, 355, 375, 366, 394, 357, + 395, 352, 351, 350, -316, -314, -150, -210, -145, -145, + -145, 164, -145, 162, -145, -95, -94, -420, -420, -420, + -420, -420, -95, -95, -95, -95, -95, -95, -95, -95, + -95, -95, -230, -145, -145, -145, -420, 192, 361, -95, + -145, 18, -145, -314, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -145, -384, -145, -210, -145, - -210, -145, -145, -145, -145, -145, -385, -385, -385, -385, - -385, -210, -210, -210, -210, -145, -419, -295, -98, -97, - -96, 671, 257, -94, -164, -98, -164, 235, -145, 235, - 235, 235, -145, -211, -297, -145, -145, -145, -145, -145, - -145, -145, -145, -145, -145, -194, -348, 295, -348, 295, - -348, -265, 96, -276, 26, 18, 63, 63, -167, -198, - -132, -168, -295, -244, 698, -250, 52, -248, -249, 53, - -245, 54, 62, -335, -335, 183, -235, -145, -266, 85, - -267, -275, -218, -213, -215, -214, -419, -254, -420, -295, - -265, -267, -170, -171, -171, -170, -171, 75, 75, 75, - 80, 75, 80, 75, -187, -301, -420, -145, -304, 86, - -168, -168, -192, -301, 183, 433, 437, 438, -360, -408, - 130, 157, 34, 85, 391, 110, -406, 191, 633, 683, - 688, 644, 637, 678, -407, 259, 150, 151, 271, 28, - 47, 97, 96, 97, 96, 97, 97, 96, -288, -287, - -45, -44, -354, -354, 105, -387, 98, 98, 255, -190, - 85, 85, 85, -114, 748, 105, 95, -3, 90, -145, - 95, 23, -343, -218, -378, -328, -379, -329, -330, -5, - -6, -355, -117, 63, 110, -63, 50, 254, 728, 729, - 139, -419, 741, -370, -255, -374, -376, -190, -149, -419, - -161, -147, -146, -148, -154, 181, 182, 276, 356, 357, - -219, -190, -138, 304, 312, 95, -142, 101, -389, 86, - 295, 391, 295, 391, 98, -412, 327, 98, -412, -190, - -84, -49, -190, -283, -283, 36, -387, -420, -162, -153, - -126, 176, 596, -319, 603, -331, -331, -331, -338, -331, - 346, -331, 346, -331, -420, -420, -420, 96, -420, 26, - -420, 96, -145, 96, -95, -95, -95, -95, -95, -122, - 492, 96, 96, -420, 95, 95, -420, -145, -420, -420, - -420, 96, -420, -420, -420, -420, -420, -420, -420, -420, - -420, -420, -420, -420, -420, 96, -420, 96, -420, 96, - -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, - -420, 96, -420, 96, -420, 96, -420, 96, -420, 96, - -420, 96, -420, 96, -420, 96, -420, -420, 96, -420, - -420, -420, 96, -420, 96, -420, 96, -420, -420, -420, - 96, -317, 689, -420, -420, -420, -420, -420, -420, -420, - -420, -420, -420, -420, -93, -296, -94, 653, 653, -420, - -94, -227, 96, -150, -420, -150, -150, -150, -420, -420, - -420, 96, -420, 96, 96, -420, 96, -420, 96, -420, - -420, -420, -420, 96, -195, 26, -419, -195, -419, -195, - -420, -261, -190, -198, -228, 20, -241, 57, 366, -252, - -251, 61, 53, -249, 23, 55, 23, 33, -266, 96, - 165, -308, 96, 28, -420, -420, 96, 63, 236, -420, - -198, -181, -180, 85, 86, -182, 85, -180, 75, 75, - -256, 96, -264, -168, -198, -198, 236, 130, -419, -149, - 16, 98, 98, -387, -405, 732, 733, 34, 105, -354, - -354, 151, 151, -190, 95, -333, 98, -333, 105, 105, - 34, 91, 92, 93, 34, 87, 88, 89, -190, -190, - -190, -190, -375, 95, 23, -145, 95, 165, 97, -255, - -255, 291, 176, -354, 726, 297, 297, -354, -354, -354, - -116, -115, 748, 97, -420, 96, -341, 596, 599, -145, - -155, -155, -256, 97, -383, 596, -388, -295, -295, -295, - -295, 105, 107, -420, 594, 82, 597, -420, -333, -145, - -145, -145, -145, -235, 98, -145, -145, 105, 105, -95, - -420, -145, -145, -145, -145, -145, -145, -145, -145, -145, + -145, -145, -145, -145, -145, -145, -145, -145, -145, -384, + -145, -210, -145, -210, -145, -145, -145, -145, -145, -385, + -385, -385, -385, -385, -210, -210, -210, -210, -145, -419, + -295, -98, -97, -96, 672, 257, -94, -164, -98, -164, + 235, -145, 235, 235, 235, -145, -211, -297, -145, -145, + -145, -145, -145, -145, -145, -145, -145, -145, -194, -348, + 295, -348, 295, -348, -265, 96, -276, 26, 18, 63, + 63, -167, -198, -132, -168, -295, -244, 699, -250, 52, + -248, -249, 53, -245, 54, 62, -335, -335, 183, -235, + -145, -266, 85, -267, -275, -218, -213, -215, -214, -419, + -254, -420, -295, -265, -267, -170, -171, -171, -170, -171, + 75, 75, 75, 80, 75, 80, 75, -187, -301, -420, + -145, -304, 86, -168, -168, -192, -301, 183, 434, 438, + 439, -360, -408, 130, 157, 34, 85, 392, 110, -406, + 191, 634, 684, 689, 645, 638, 679, -407, 259, 150, + 151, 271, 28, 47, 97, 96, 97, 96, 97, 97, + 96, -288, -287, -45, -44, -354, -354, 105, -387, 98, + 98, 255, -190, 85, 85, 85, -114, 749, 105, 95, + -3, 90, -145, 95, 23, -343, -218, -378, -328, -379, + -329, -330, -5, -6, -355, -117, 63, 110, -63, 50, + 254, 729, 730, 139, -419, 742, -370, -255, -374, -376, + -190, -149, -419, -161, -147, -146, -148, -154, 181, 182, + 276, 357, 358, -219, -190, -138, 304, 312, 95, -142, + 101, -389, 86, 295, 392, 295, 392, 98, -412, 328, + 98, -412, -190, -84, -49, -190, -283, -283, 36, -387, + -420, -162, -153, -126, 176, 597, -319, 604, -331, -331, + -331, -338, -331, 347, -331, 347, -331, -420, -420, -420, + 96, -420, 26, -420, 96, -145, 96, -95, -95, -95, + -95, -95, -122, 493, 96, 96, -420, 95, 95, -420, + -145, -420, -420, -420, 96, -420, -420, -420, -420, -420, + -420, -420, -420, -420, -420, -420, -420, -420, 96, -420, + 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, + 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, + 96, -420, 96, -420, 96, -420, 96, -420, 96, -420, + -420, 96, -420, -420, -420, 96, -420, 96, -420, 96, + -420, -420, -420, 96, -317, 690, -420, -420, -420, -420, + -420, -420, -420, -420, -420, -420, -420, -93, -296, -94, + 654, 654, -420, -94, -227, 96, -150, -420, -150, -150, + -150, -420, -420, -420, 96, -420, 96, 96, -420, 96, + -420, 96, -420, -420, -420, -420, 96, -195, 26, -419, + -195, -419, -195, -420, -261, -190, -198, -228, 20, -241, + 57, 367, -252, -251, 61, 53, -249, 23, 55, 23, + 33, -266, 96, 165, -308, 96, 28, -420, -420, 96, + 63, 236, -420, -198, -181, -180, 85, 86, -182, 85, + -180, 75, 75, -256, 96, -264, -168, -198, -198, 236, + 130, -419, -149, 16, 98, 98, -387, -405, 733, 734, + 34, 105, -354, -354, 151, 151, -190, 95, -333, 98, + -333, 105, 105, 34, 91, 92, 93, 34, 87, 88, + 89, -190, -190, -190, -190, -375, 95, 23, -145, 95, + 165, 97, -255, -255, 291, 176, -354, 727, 297, 297, + -354, -354, -354, -116, -115, 749, 97, -420, 96, -341, + 597, 600, -145, -155, -155, -256, 97, -383, 597, -388, + -295, -295, -295, -295, 105, 107, -420, 595, 82, 598, + -420, -333, -145, -145, -145, -145, -235, 98, -145, -145, + 105, 105, -95, -420, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, -145, - -145, -210, -145, -420, -178, -177, -179, 709, 130, 34, - -316, -420, -212, 289, -101, -100, -99, 18, -420, -145, - -119, -119, -119, -119, -145, -145, -145, -145, -145, -145, - -419, 75, 22, 20, -258, -295, 259, -419, -258, -419, - -304, -228, -229, 21, 23, -242, 59, -240, 58, -240, - -251, 23, 23, 98, 23, 98, 151, -275, -145, -215, - -303, 63, -29, -295, -213, -295, -230, -145, 95, -145, - -158, -198, -198, -145, -205, 516, 518, 519, 520, 517, - 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, - 521, 532, 493, 494, 495, 117, 119, 118, 127, 128, - 496, 497, 498, 360, 544, 545, 539, 542, 543, 541, - 540, 375, 376, 499, 562, 563, 567, 566, 564, 565, - 568, 571, 572, 573, 574, 575, 576, 578, 577, 569, - 570, 547, 546, 548, 549, 550, 551, 552, 553, 555, - 554, 556, 557, 558, 559, 560, 561, 579, 580, 581, - 582, 583, 585, 584, 589, 588, 586, 587, 591, 590, - 500, 501, 120, 121, 122, 123, 124, 125, 126, 502, - 505, 503, 506, 507, 508, 513, 514, 509, 510, 511, - 512, 515, 386, 384, 385, 381, 380, 379, 440, 445, - 446, 448, 533, 534, 535, 536, 537, 538, 690, 691, - 692, 693, 694, 695, 696, 697, 98, 98, 95, -145, - 97, 97, -256, -374, -60, 97, -257, -255, 105, 97, - 292, -214, -419, 98, -354, -354, -354, 105, 105, -303, - -420, 96, -295, -407, -376, 600, 600, -420, 28, -382, - -381, -297, 95, 86, 68, 595, 598, -420, -420, -420, - 96, -420, -420, -420, 97, 97, -420, -420, -420, -420, + -145, -145, -145, -145, -210, -145, -420, -178, -177, -179, + 710, 130, 34, -316, -420, -212, 289, -101, -100, -99, + 18, -420, -145, -119, -119, -119, -119, -145, -145, -145, + -145, -145, -145, -419, 75, 22, 20, -258, -295, 259, + -419, -258, -419, -304, -228, -229, 21, 23, -242, 59, + -240, 58, -240, -251, 23, 23, 98, 23, 98, 151, + -275, -145, -215, -303, 63, -29, -295, -213, -295, -230, + -145, 95, -145, -158, -198, -198, -145, -205, 517, 519, + 520, 521, 518, 523, 524, 525, 526, 527, 528, 529, + 530, 531, 532, 522, 533, 494, 495, 496, 117, 119, + 118, 127, 128, 497, 498, 499, 361, 545, 546, 540, + 543, 544, 542, 541, 376, 377, 500, 563, 564, 568, + 567, 565, 566, 569, 572, 573, 574, 575, 576, 577, + 579, 578, 570, 571, 548, 547, 549, 550, 551, 552, + 553, 554, 556, 555, 557, 558, 559, 560, 561, 562, + 580, 581, 582, 583, 584, 586, 585, 590, 589, 587, + 588, 592, 591, 501, 502, 120, 121, 122, 123, 124, + 125, 126, 503, 506, 504, 507, 508, 509, 514, 515, + 510, 511, 512, 513, 516, 387, 385, 386, 382, 381, + 380, 441, 446, 447, 449, 534, 535, 536, 537, 538, + 539, 691, 692, 693, 694, 695, 696, 697, 698, 98, + 98, 95, -145, 97, 97, -256, -374, -60, 97, -257, + -255, 105, 97, 292, -214, -419, 98, -354, -354, -354, + 105, 105, -303, -420, 96, -295, -407, -376, 601, 601, + -420, 28, -382, -381, -297, 95, 86, 68, 596, 599, + -420, -420, -420, 96, -420, -420, -420, 97, 97, -420, -420, -420, -420, -420, -420, -420, -420, -420, -420, -420, - -420, -420, -420, -420, -420, -420, -420, -420, 96, -420, - -177, -179, -420, 85, -158, -230, 23, -98, 314, 316, - -98, -420, -420, -420, -420, -420, 96, -420, -420, 96, - -420, 96, -420, -420, -258, -420, 23, 23, 96, -420, - -258, -420, -258, -197, -229, -108, -107, -106, 627, -145, - -210, -243, 60, 85, 134, 98, 98, 98, 16, -419, - -213, 236, -308, -235, -255, -175, 400, -230, -420, -255, - 97, 28, 97, 750, 151, 97, -214, -125, -419, 288, - -303, 98, 98, -115, -118, -29, 96, 165, -255, -190, - 68, -145, -210, -420, 85, 608, 709, -92, -91, -88, - 720, 746, -210, -94, -94, -145, -145, -145, -420, -295, - 259, -420, -420, -108, 96, -105, -104, -295, -320, 596, - 85, 134, -267, -255, -308, -295, 97, -420, -419, -235, - 97, -239, -29, 95, -3, 288, -328, -379, -329, -330, - -5, -6, -355, -82, 596, -381, -359, -301, -297, 98, - 105, 97, 596, -420, -420, -90, 159, 718, 686, -155, - 235, -420, 96, -420, 96, -420, 96, -106, 96, 28, - 601, -420, -304, -176, -174, -295, 650, -398, -397, 592, - -408, -404, 130, 157, 110, -406, 688, 644, 140, 141, - -82, -145, 95, -420, -83, 303, 705, 236, -389, 597, - -90, 719, 664, 639, 664, 639, -150, -145, -145, -145, - -104, -419, -420, 96, 26, -321, -62, 661, -395, -396, - 85, -399, 406, 660, 681, 130, 98, 97, -255, 264, - -302, -383, 598, 156, -119, -420, 96, -420, 96, -420, - -93, -174, 657, -334, -158, -396, 85, -395, 85, 17, - 16, -4, 749, 97, 305, -90, 664, 639, -145, -145, - -420, -61, 29, -175, -394, 272, 267, 270, 35, -394, - 105, -4, -420, -420, 661, 266, 34, 130, -158, -178, - -177, -177, + -420, -420, -420, -420, -420, -420, -420, -420, -420, -420, + -420, 96, -420, -177, -179, -420, 85, -158, -230, 23, + -98, 314, 316, -98, -420, -420, -420, -420, -420, 96, + -420, -420, 96, -420, 96, -420, -420, -258, -420, 23, + 23, 96, -420, -258, -420, -258, -197, -229, -108, -107, + -106, 628, -145, -210, -243, 60, 85, 134, 98, 98, + 98, 16, -419, -213, 236, -308, -235, -255, -175, 401, + -230, -420, -255, 97, 28, 97, 751, 151, 97, -214, + -125, -419, 288, -303, 98, 98, -115, -118, -29, 96, + 165, -255, -190, 68, -145, -210, -420, 85, 609, 710, + -92, -91, -88, 721, 747, -210, -94, -94, -145, -145, + -145, -420, -295, 259, -420, -420, -108, 96, -105, -104, + -295, -320, 597, 85, 134, -267, -255, -308, -295, 97, + -420, -419, -235, 97, -239, -29, 95, -3, 288, -328, + -379, -329, -330, -5, -6, -355, -82, 597, -381, -359, + -301, -297, 98, 105, 97, 597, -420, -420, -90, 159, + 719, 687, -155, 235, -420, 96, -420, 96, -420, 96, + -106, 96, 28, 602, -420, -304, -176, -174, -295, 651, + -398, -397, 593, -408, -404, 130, 157, 110, -406, 689, + 645, 140, 141, -82, -145, 95, -420, -83, 303, 706, + 236, -389, 598, -90, 720, 665, 640, 665, 640, -150, + -145, -145, -145, -104, -419, -420, 96, 26, -321, -62, + 662, -395, -396, 85, -399, 407, 661, 682, 130, 98, + 97, -255, 264, -302, -383, 599, 156, -119, -420, 96, + -420, 96, -420, -93, -174, 658, -334, -158, -396, 85, + -395, 85, 17, 16, -4, 750, 97, 305, -90, 665, + 640, -145, -145, -420, -61, 29, -175, -394, 272, 267, + 270, 35, -394, 105, -4, -420, -420, 662, 266, 34, + 130, -158, -178, -177, -177, } var yyDef = [...]int{ - 888, -2, -2, 890, 2, 4, 5, 6, 7, 8, + 889, -2, -2, 891, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, - 39, 70, 72, 73, 888, 888, 888, 0, 888, 0, - 0, 888, -2, -2, 888, 1643, 0, 888, 0, 883, - 0, -2, 803, 809, 0, 818, -2, 0, 0, 888, - 888, 2283, 2283, 883, 0, 0, 0, 0, 0, 888, - 888, 888, 888, 1648, 1501, 50, 888, 0, 85, 86, - 838, 839, 840, 65, 0, 2281, 889, 1, 3, 71, - 75, 0, 0, 0, 58, 1510, 0, 78, 0, 0, - 892, 0, 0, 1626, 888, 888, 0, 126, 127, 0, + 39, 70, 72, 73, 889, 889, 889, 0, 889, 0, + 0, 889, -2, -2, 889, 1644, 0, 889, 0, 884, + 0, -2, 804, 810, 0, 819, -2, 0, 0, 889, + 889, 2285, 2285, 884, 0, 0, 0, 0, 0, 889, + 889, 889, 889, 1649, 1502, 50, 889, 0, 85, 86, + 839, 840, 841, 65, 0, 2283, 890, 1, 3, 71, + 75, 0, 0, 0, 58, 1511, 0, 78, 0, 0, + 893, 0, 0, 1627, 889, 889, 0, 126, 127, 0, 0, 0, -2, 130, -2, 159, 160, 161, 0, 166, - 608, 526, 578, 524, 563, -2, 512, 0, 0, 0, + 609, 526, 578, 524, 563, -2, 512, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 529, - 401, 401, 0, 0, -2, 512, 512, 512, 1628, 0, + 401, 401, 0, 0, -2, 512, 512, 512, 1629, 0, 0, 0, 560, 463, 401, 401, 401, 0, 401, 401, 401, 401, 0, 0, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, 401, - 401, 1528, 165, 1644, 1641, 1642, 1804, 1805, 1806, 1807, - 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, - 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, - 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, - 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, - 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, - 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, - 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, - 1878, 1879, 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1887, - 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, - 1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, - 1908, 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, - 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, - 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, - 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, - 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, - 1958, 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, - 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, - 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, - 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, - 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, - 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, - 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, - 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, - 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, - 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, - 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, - 2068, 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, - 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, - 2088, 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, - 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107, - 2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, - 2118, 2119, 2120, 2121, 2122, 2123, 2124, 2125, 2126, 2127, - 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, - 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, - 2148, 2149, 2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, - 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, - 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, - 2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185, 2186, 2187, - 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, - 2198, 2199, 2200, 2201, 2202, 2203, 2204, 2205, 2206, 2207, - 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, - 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, - 2228, 2229, 2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, - 2238, 2239, 2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247, - 2248, 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, - 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265, 2266, 2267, - 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, - 2278, 2279, 2280, 0, 1620, 0, 721, 992, 0, 884, - 885, 0, 792, 792, 0, 792, 792, 792, 792, 0, - 0, 0, 735, 0, 0, 0, 0, 789, 0, 751, - 752, 0, 789, 0, 758, 795, 0, 0, 765, 792, - 792, 768, 2284, 0, 2284, 2284, 0, 0, 1611, 0, - 786, 784, 798, 799, 42, 802, 805, 806, 807, 808, - 811, 0, 822, 825, 1637, 1638, 0, 827, 832, 851, - 852, 0, 45, 1152, 0, 1016, 0, 1027, -2, 1038, - 1055, 1056, 1057, 1058, 1059, 1061, 1062, 1063, 0, 0, - 0, 0, 1068, 1069, 0, 0, 0, 0, 0, 1132, - 0, 0, 0, 0, 2006, 1472, 0, 0, 1434, 1434, - 1168, 1434, 1434, 1436, 1436, 1436, 1857, 1998, 2007, 2186, - 1818, 1824, 1825, 1826, 2132, 2133, 2134, 2135, 2227, 2228, - 2232, 1920, 1813, 2199, 2200, 0, 2280, 1959, 1967, 1968, - 1944, 1953, 1992, 2094, 2211, 1836, 1987, 2057, 1917, 1939, - 1940, 2075, 2076, 1963, 1964, 1943, 2138, 2140, 2156, 2157, - 2142, 2144, 2153, 2159, 2164, 2143, 2155, 2160, 2173, 2177, - 2180, 2181, 2182, 2150, 2148, 2161, 2165, 2167, 2169, 2175, - 2178, 2151, 2149, 2162, 2166, 2168, 2170, 2176, 2179, 2137, - 2141, 2145, 2154, 2172, 2152, 2171, 2146, 2158, 2163, 2174, - 2147, 2139, 1957, 1960, 1947, 1948, 1950, 1952, 1958, 1965, - 1971, 1949, 1970, 1969, 0, 1945, 1946, 1951, 1962, 1966, - 1954, 1955, 1956, 1961, 1972, 2013, 2012, 2011, 2056, 1983, - 2055, 0, 0, 0, 0, 0, 1807, 1862, 1863, 2183, - 1356, 1357, 1358, 1359, 0, 0, 0, 0, 0, 0, - 0, 290, 291, 1485, 1486, 44, 1151, 1607, 1436, 1436, - 1436, 1436, 1436, 1436, 1090, 1091, 1092, 1093, 1094, 1120, - 1121, 1127, 1128, 2070, 2071, 2072, 2073, 1900, 2222, 1909, - 1910, 2052, 2053, 1922, 1923, 2254, 2255, -2, -2, -2, - 232, 233, 234, 235, 236, 237, 238, 239, 0, 1861, - 2197, 2198, 228, 0, 0, 295, 292, 293, 294, 1134, - 1135, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 297, 298, 2283, 0, 861, 0, 0, - 0, 0, 0, 0, 1649, 1650, 1510, 0, 1502, 1501, - 63, 0, 888, -2, 0, 0, 0, 0, 47, 0, - 52, 949, 891, 77, 76, 1550, 1553, 0, 0, 0, - 59, 1511, 67, 69, 1512, 0, 893, 894, 0, 925, - 929, 0, 0, 0, 1627, 1626, 1626, 102, 0, 0, - 103, 123, 124, 125, 0, 0, 109, 110, 1613, 1614, - 43, 0, 0, 177, 178, 0, 1108, 428, 0, 173, - 0, 421, 360, 0, 1528, 0, 0, 0, 0, 0, - 1624, 0, 1621, 154, 155, 162, 163, 164, 401, 401, - 401, 575, 0, 0, 165, 165, 533, 534, 535, 0, - 0, -2, 426, 0, 513, 0, 0, 415, 415, 419, - 417, 418, 0, 0, 0, 0, 0, 0, 0, 0, - 552, 0, 553, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 669, 0, 402, 0, 573, 574, 464, 0, - 0, 0, 0, 0, 0, 0, 0, 1629, 1630, 0, - 550, 551, 0, 0, 0, 401, 401, 0, 0, 0, - 0, 401, 401, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 153, 1541, 0, 0, 0, -2, 0, 713, 0, - 0, 0, 1622, 1622, 0, 720, 0, 0, 0, 725, - 0, 0, 726, 0, 789, 789, 787, 788, 728, 729, - 730, 731, 792, 0, 0, 410, 411, 412, 789, 792, - 0, 792, 792, 792, 792, 789, 789, 789, 792, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2284, 795, - 792, 0, 759, 0, 760, 761, 762, 763, 766, 767, - 769, 2285, 2286, 1639, 1640, 1651, 1652, 1653, 1654, 1655, + 401, 1529, 165, 1645, 1642, 1643, 1805, 1806, 1807, 1808, + 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, + 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, + 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, + 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, + 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, + 1859, 1860, 1861, 1862, 1863, 1864, 1865, 1866, 1867, 1868, + 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, + 1879, 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, + 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897, 1898, + 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, + 1909, 1910, 1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, + 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, + 1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, + 1939, 1940, 1941, 1942, 1943, 1944, 1945, 1946, 1947, 1948, + 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, + 1959, 1960, 1961, 1962, 1963, 1964, 1965, 1966, 1967, 1968, + 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, + 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, + 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, + 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, + 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, + 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, + 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, + 2039, 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, + 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057, 2058, + 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, + 2069, 2070, 2071, 2072, 2073, 2074, 2075, 2076, 2077, 2078, + 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, + 2089, 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, + 2099, 2100, 2101, 2102, 2103, 2104, 2105, 2106, 2107, 2108, + 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, + 2119, 2120, 2121, 2122, 2123, 2124, 2125, 2126, 2127, 2128, + 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137, 2138, + 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, + 2149, 2150, 2151, 2152, 2153, 2154, 2155, 2156, 2157, 2158, + 2159, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, + 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, + 2179, 2180, 2181, 2182, 2183, 2184, 2185, 2186, 2187, 2188, + 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, + 2199, 2200, 2201, 2202, 2203, 2204, 2205, 2206, 2207, 2208, + 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217, 2218, + 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, + 2229, 2230, 2231, 2232, 2233, 2234, 2235, 2236, 2237, 2238, + 2239, 2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247, 2248, + 2249, 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, + 2259, 2260, 2261, 2262, 2263, 2264, 2265, 2266, 2267, 2268, + 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, + 2279, 2280, 2281, 2282, 0, 1621, 0, 722, 993, 0, + 885, 886, 0, 793, 793, 0, 793, 793, 793, 793, + 0, 0, 0, 736, 0, 0, 0, 0, 790, 0, + 752, 753, 0, 790, 0, 759, 796, 0, 0, 766, + 793, 793, 769, 2286, 0, 2286, 2286, 0, 0, 1612, + 0, 787, 785, 799, 800, 42, 803, 806, 807, 808, + 809, 812, 0, 823, 826, 1638, 1639, 0, 828, 833, + 852, 853, 0, 45, 1153, 0, 1017, 0, 1028, -2, + 1039, 1056, 1057, 1058, 1059, 1060, 1062, 1063, 1064, 0, + 0, 0, 0, 1069, 1070, 0, 0, 0, 0, 0, + 1133, 0, 0, 0, 0, 2008, 1473, 0, 0, 1435, + 1435, 1169, 1435, 1435, 1437, 1437, 1437, 1858, 2000, 2009, + 2188, 1819, 1825, 1826, 1827, 2134, 2135, 2136, 2137, 2229, + 2230, 2234, 1922, 1814, 2201, 2202, 0, 2282, 1961, 1969, + 1970, 1946, 1955, 1994, 2096, 2213, 1837, 1989, 2059, 1919, + 1941, 1942, 2077, 2078, 1965, 1966, 1945, 2140, 2142, 2158, + 2159, 2144, 2146, 2155, 2161, 2166, 2145, 2157, 2162, 2175, + 2179, 2182, 2183, 2184, 2152, 2150, 2163, 2167, 2169, 2171, + 2177, 2180, 2153, 2151, 2164, 2168, 2170, 2172, 2178, 2181, + 2139, 2143, 2147, 2156, 2174, 2154, 2173, 2148, 2160, 2165, + 2176, 2149, 2141, 1959, 1962, 1949, 1950, 1952, 1954, 1960, + 1967, 1973, 1951, 1972, 1971, 0, 1947, 1948, 1953, 1964, + 1968, 1956, 1957, 1958, 1963, 1974, 2015, 2014, 2013, 2058, + 1985, 2057, 0, 0, 0, 0, 0, 1808, 1864, 1865, + 2185, 1357, 1358, 1359, 1360, 0, 0, 0, 0, 0, + 0, 0, 290, 291, 1486, 1487, 44, 1152, 1608, 1437, + 1437, 1437, 1437, 1437, 1437, 1091, 1092, 1093, 1094, 1095, + 1121, 1122, 1128, 1129, 2072, 2073, 2074, 2075, 1902, 2224, + 1911, 1912, 2054, 2055, 1924, 1925, 2256, 2257, -2, -2, + -2, 232, 233, 234, 235, 236, 237, 238, 239, 0, + 1863, 2199, 2200, 228, 0, 0, 295, 292, 293, 294, + 1135, 1136, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 286, 287, 288, 289, 297, 298, 2285, 0, 862, 0, + 0, 0, 0, 0, 0, 1650, 1651, 1511, 0, 1503, + 1502, 63, 0, 889, -2, 0, 0, 0, 0, 47, + 0, 52, 950, 892, 77, 76, 1551, 1554, 0, 0, + 0, 59, 1512, 67, 69, 1513, 0, 894, 895, 0, + 926, 930, 0, 0, 0, 1628, 1627, 1627, 102, 0, + 0, 103, 123, 124, 125, 0, 0, 109, 110, 1614, + 1615, 43, 0, 0, 177, 178, 0, 1109, 428, 0, + 173, 0, 421, 360, 0, 1529, 0, 0, 0, 0, + 0, 1625, 0, 1622, 154, 155, 162, 163, 164, 401, + 401, 401, 575, 0, 0, 165, 165, 533, 534, 535, + 0, 0, -2, 426, 0, 513, 0, 0, 415, 415, + 419, 417, 418, 0, 0, 0, 0, 0, 0, 0, + 0, 552, 0, 553, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 670, 0, 402, 0, 573, 574, 464, + 0, 0, 0, 0, 0, 0, 0, 0, 1630, 1631, + 0, 550, 551, 0, 0, 0, 401, 401, 0, 0, + 0, 0, 401, 401, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 153, 1542, 0, 0, 0, -2, 0, 714, + 0, 0, 0, 1623, 1623, 0, 721, 0, 0, 0, + 726, 0, 0, 727, 0, 790, 790, 788, 789, 729, + 730, 731, 732, 793, 0, 0, 410, 411, 412, 790, + 793, 0, 793, 793, 793, 793, 790, 790, 790, 793, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2286, + 796, 793, 0, 760, 0, 761, 762, 763, 764, 767, + 768, 770, 2287, 2288, 1640, 1641, 1652, 1653, 1654, 1655, 1656, 1657, 1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, @@ -9569,288 +9611,288 @@ var yyDef = [...]int{ 1766, 1767, 1768, 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785, 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, - 1796, 1797, 1798, 1799, 1800, 1801, 1802, 1803, 2284, 2284, - 773, 777, 781, 779, 1612, 804, 810, 812, 813, 0, - 0, 823, 826, 845, 49, 1908, 831, 49, 833, 834, - 835, 836, 837, 863, 864, 869, 0, 0, 0, 0, - 875, 876, 877, 0, 0, 880, 881, 882, 0, 0, - 0, 0, 0, 1014, 0, 0, 1140, 1141, 1142, 1143, - 1144, 1145, 1146, 1147, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1039, 1040, 0, 0, 0, 1064, 1065, 1066, - 1067, 1070, 0, 1081, 0, 1083, 1481, -2, 0, 0, - 0, 1075, 1076, 0, 0, 0, 1632, 1632, 0, 0, - 0, 1473, 0, 0, 1166, 0, 1167, 1169, 1170, 1171, - 0, 1172, 1173, 898, 898, 898, 898, 898, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 898, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1632, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 141, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1632, 0, 0, - 1632, 1632, 0, 0, 220, 221, 222, 223, 224, 225, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 296, 240, 241, 242, 243, 244, - 299, 245, 246, 247, 1151, 0, 0, 0, 46, 853, - 854, 0, 975, 1632, 0, 0, 904, 0, 1647, 57, - 66, 68, 1510, 61, 1510, 0, 908, 0, 0, -2, - -2, 909, 910, 914, 915, 916, 917, 918, 919, 920, - 921, 922, 54, 2282, 55, 0, 74, 0, 48, 0, - 0, 1551, 0, 1554, 0, 0, 0, 374, 1558, 0, - 0, 1503, 1504, 1507, 0, 926, 2004, 930, 0, 932, - 933, 0, 0, 100, 0, 991, 0, 0, 0, 111, - 0, 113, 114, 0, 0, 0, 385, 1615, 1616, 1617, - -2, 408, 0, 385, 369, 307, 308, 309, 360, 311, - 360, 360, 360, 360, 374, 374, 374, 374, 342, 343, - 344, 345, 346, 0, 360, 0, 328, 360, 360, 360, - 360, 350, 351, 352, 353, 354, 355, 356, 357, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 362, 362, - 362, 362, 362, 366, 366, 0, 1109, 0, 389, 0, - 1507, 0, 0, 1541, 1624, 1634, 0, 0, 0, 0, - 0, 132, 0, 0, 0, 576, 619, 527, 564, 577, - 0, 530, 531, -2, 0, 0, 512, 0, 514, 0, - 409, 0, -2, 0, 419, 0, 415, 419, 416, 419, - 407, 420, 554, 555, 556, 0, 558, 559, 649, 961, - 0, 0, 0, 0, 0, 655, 656, 657, 0, 659, - 660, 661, 662, 663, 664, 665, 666, 667, 668, 565, - 566, 567, 568, 569, 570, 571, 572, 0, 0, 0, - 0, 514, 0, 561, 0, 0, 465, 466, 467, 0, - 0, 470, 471, 472, 473, 0, 0, 476, 477, 478, - 978, 979, 479, 480, 505, 506, 507, 481, 482, 483, - 484, 485, 486, 487, 499, 500, 501, 502, 503, 504, - 488, 489, 490, 491, 492, 493, 496, 0, 147, 1532, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1622, 0, 0, - 0, 0, 907, 993, 1645, 1646, 722, 0, 0, 793, - 794, 0, 413, 414, 792, 792, 732, 774, 0, 792, - 736, 775, 737, 739, 738, 740, 753, 754, 792, 743, - 790, 791, 744, 745, 746, 747, 748, 749, 750, 770, - 755, 756, 757, 796, 0, 800, 801, 771, 772, 0, - 782, 0, 0, 0, 816, 817, 0, 824, 848, 846, - 847, 849, 841, 842, 843, 844, 0, 850, 0, 0, - 866, 96, 871, 872, 873, 874, 886, 879, 1153, 1011, - 1012, 1013, 0, 1015, 1021, 0, 1136, 1138, 1019, 1020, - 1023, 0, 0, 0, 1017, 1028, 1148, 1149, 1150, 0, - 0, 0, 0, 0, 1032, 1036, 1041, 1042, 1043, 1044, - 1045, 0, 1046, 0, 1049, 1050, 1051, 1052, 1053, 1054, - 1060, 1449, 1450, 1451, 1079, 300, 301, 0, 1080, 0, - 0, 0, 0, 0, 0, 0, 0, 1396, 1397, 1398, + 1796, 1797, 1798, 1799, 1800, 1801, 1802, 1803, 1804, 2286, + 2286, 774, 778, 782, 780, 1613, 805, 811, 813, 814, + 0, 0, 824, 827, 846, 49, 1910, 832, 49, 834, + 835, 836, 837, 838, 864, 865, 870, 0, 0, 0, + 0, 876, 877, 878, 0, 0, 881, 882, 883, 0, + 0, 0, 0, 0, 1015, 0, 0, 1141, 1142, 1143, + 1144, 1145, 1146, 1147, 1148, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1040, 1041, 0, 0, 0, 1065, 1066, + 1067, 1068, 1071, 0, 1082, 0, 1084, 1482, -2, 0, + 0, 0, 1076, 1077, 0, 0, 0, 1633, 1633, 0, + 0, 0, 1474, 0, 0, 1167, 0, 1168, 1170, 1171, + 1172, 0, 1173, 1174, 899, 899, 899, 899, 899, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 899, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1633, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 141, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1633, 0, + 0, 1633, 1633, 0, 0, 220, 221, 222, 223, 224, + 225, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 296, 240, 241, 242, 243, + 244, 299, 245, 246, 247, 1152, 0, 0, 0, 46, + 854, 855, 0, 976, 1633, 0, 0, 905, 0, 1648, + 57, 66, 68, 1511, 61, 1511, 0, 909, 0, 0, + -2, -2, 910, 911, 915, 916, 917, 918, 919, 920, + 921, 922, 923, 54, 2284, 55, 0, 74, 0, 48, + 0, 0, 1552, 0, 1555, 0, 0, 0, 374, 1559, + 0, 0, 1504, 1505, 1508, 0, 927, 2006, 931, 0, + 933, 934, 0, 0, 100, 0, 992, 0, 0, 0, + 111, 0, 113, 114, 0, 0, 0, 385, 1616, 1617, + 1618, -2, 408, 0, 385, 369, 307, 308, 309, 360, + 311, 360, 360, 360, 360, 374, 374, 374, 374, 342, + 343, 344, 345, 346, 0, 360, 0, 328, 360, 360, + 360, 360, 350, 351, 352, 353, 354, 355, 356, 357, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 362, + 362, 362, 362, 362, 366, 366, 0, 1110, 0, 389, + 0, 1508, 0, 0, 1542, 1625, 1635, 0, 0, 0, + 0, 0, 132, 0, 0, 0, 576, 620, 527, 564, + 577, 0, 530, 531, -2, 0, 0, 512, 0, 514, + 0, 409, 0, -2, 0, 419, 0, 415, 419, 416, + 419, 407, 420, 554, 555, 556, 0, 558, 559, 650, + 962, 0, 0, 0, 0, 0, 656, 657, 658, 0, + 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, + 565, 566, 567, 568, 569, 570, 571, 572, 0, 0, + 0, 0, 514, 0, 561, 0, 0, 465, 466, 467, + 0, 0, 470, 471, 472, 473, 0, 0, 476, 477, + 478, 979, 980, 479, 480, 505, 506, 507, 481, 482, + 483, 484, 485, 486, 487, 499, 500, 501, 502, 503, + 504, 488, 489, 490, 491, 492, 493, 496, 0, 147, + 1533, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1623, 0, + 0, 0, 0, 908, 994, 1646, 1647, 723, 0, 0, + 794, 795, 0, 413, 414, 793, 793, 733, 775, 0, + 793, 737, 776, 738, 740, 739, 741, 754, 755, 793, + 744, 791, 792, 745, 746, 747, 748, 749, 750, 751, + 771, 756, 757, 758, 797, 0, 801, 802, 772, 773, + 0, 783, 0, 0, 0, 817, 818, 0, 825, 849, + 847, 848, 850, 842, 843, 844, 845, 0, 851, 0, + 0, 867, 96, 872, 873, 874, 875, 887, 880, 1154, + 1012, 1013, 1014, 0, 1016, 1022, 0, 1137, 1139, 1020, + 1021, 1024, 0, 0, 0, 1018, 1029, 1149, 1150, 1151, + 0, 0, 0, 0, 0, 1033, 1037, 1042, 1043, 1044, + 1045, 1046, 0, 1047, 0, 1050, 1051, 1052, 1053, 1054, + 1055, 1061, 1450, 1451, 1452, 1080, 300, 301, 0, 1081, + 0, 0, 0, 0, 0, 0, 0, 0, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, - 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1152, 0, 1633, - 0, 0, 0, 1479, 1476, 0, 0, 0, 1435, 1437, - 0, 0, 0, 899, 900, 0, 0, 0, 0, 0, + 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1153, 0, + 1634, 0, 0, 0, 1480, 1477, 0, 0, 0, 1436, + 1438, 0, 0, 0, 900, 901, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, + 0, 0, 0, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, - 0, 0, 1452, 0, 0, 0, 0, 0, 0, 0, - 1472, 0, 1085, 1086, 1087, 0, 0, 0, 0, 0, - 0, 1214, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 142, 143, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1360, 1361, 1362, - 1363, 41, 0, 0, 0, 0, 0, 0, 0, 1483, - 0, -2, -2, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1385, 0, 0, 0, - 0, 0, 0, 1605, 0, 0, 856, 857, 859, 0, - 995, 0, 976, 0, 0, 862, 0, 903, 0, 906, - 60, 62, 912, 913, 0, 934, 923, 911, 56, 51, - 0, 0, 953, 1552, 1555, 1556, 374, 1578, 0, 383, - 383, 380, 1513, 1514, 0, 1506, 1508, 1509, 79, 931, - 927, 0, 1009, 0, 0, 990, 0, 937, 939, 940, - 941, 973, 0, 944, 945, 0, 0, 0, 0, 0, - 98, 992, 104, 0, 112, 0, 0, 117, 118, 105, - 106, 107, 108, 0, 608, -2, 460, 179, 181, 182, - 183, 174, -2, 372, 370, 371, 310, 374, 374, 336, - 337, 338, 339, 340, 341, 0, 348, 0, 329, 330, - 331, 332, 321, 0, 322, 323, 324, 364, 0, 325, - 326, 0, 327, 427, 0, 1515, 390, 391, 393, 401, - 0, 396, 397, 0, 401, 401, 0, 422, 423, 0, - 1507, 1532, 0, 0, 1635, 1634, 1634, 1634, 152, 0, - 167, 168, 169, 170, 171, 172, 644, 0, 0, 620, - 642, 643, 165, 0, 0, 175, 516, 515, 0, 676, - 0, 425, 0, 0, 419, 419, 404, 405, 557, 0, - 0, 651, 652, 653, 654, 0, 0, 0, 543, 454, - 0, 544, 545, 514, 516, 0, 0, 385, 468, 469, - 474, 475, 494, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 592, 593, 595, 598, 600, - 518, 604, 606, 594, 597, 599, 601, 518, 605, 607, - 1529, 1530, 1531, 0, 0, 714, 0, 0, 451, 94, - 1623, 719, 723, 724, 789, 742, 776, 789, 734, 741, - 764, 778, 780, 814, 815, 820, 828, 829, 830, 870, - 0, 0, 0, 0, 878, 0, 0, 1022, 1137, 1139, - 1024, 1025, 1026, 1029, 0, 1033, 1037, 0, 0, 0, - 0, 0, 1084, 1082, 1483, 0, 0, 0, 1133, 0, - 0, 1156, 1157, 0, 0, 0, 0, 1477, 0, 0, - 1164, 0, 1438, 1114, 0, 0, 0, 0, 0, 1114, - 1114, 1114, 1114, 1114, 1114, 1114, 1114, 1114, 1114, 1501, - 1191, 0, 0, 0, 0, 0, 1196, 1197, 1198, 1114, - 0, 1201, 1202, 0, 1204, 0, 1205, 0, 0, 0, - 0, 1212, 1213, 1215, 0, 0, 1218, 1219, 0, 1221, - 0, 1223, 1224, 1225, 1226, 1227, 1228, 0, 1230, 0, - 1232, 1233, 1234, 0, 1236, 0, 1238, 1239, 0, 1241, - 0, 1243, 0, 1246, 0, 1249, 0, 1252, 0, 1255, - 0, 1258, 0, 1261, 0, 1264, 0, 1267, 0, 1270, - 0, 1273, 0, 1276, 0, 1279, 0, 1282, 0, 1285, - 0, 1288, 0, 1291, 1292, 1293, 0, 1295, 0, 1297, - 0, 1300, 1301, 0, 1303, 0, 1306, 0, 1309, 0, - 0, 1310, 0, 0, 0, 1314, 0, 0, 0, 0, - 1323, 1324, 1325, 1326, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1337, 1338, 1339, 1340, 1341, 1342, - 0, 1344, 0, 1115, 0, 0, 1115, 0, 0, 0, - 0, 0, 1154, 1632, 0, 1439, 1440, 1441, 1442, 1443, - 0, 0, 0, 0, 0, 0, 1383, 1384, 1386, 0, - 0, 1389, 0, 1391, 0, 1606, 855, 858, 860, 947, - 996, 997, 0, 0, 0, 0, 977, 1631, 901, 902, - 905, 955, 0, 1487, 0, 0, 934, 1009, 0, 935, - 0, 53, 950, 0, 1560, 1559, 1572, 1585, 383, 383, - 377, 378, 384, 379, 381, 382, 1505, 0, 1510, 0, - 1599, 0, 0, 1588, 0, 0, 0, 0, 0, 0, - 0, 0, 980, 0, 0, 983, 0, 0, 0, 0, - 974, 945, 0, 946, 0, -2, 0, 0, 92, 93, - 0, 0, 0, 115, 116, 0, 0, 122, 386, 387, - 156, 165, 462, 180, 435, 0, 0, 306, 373, 333, - 334, 335, 0, 358, 0, 0, 0, 0, 456, 128, - 1519, 1518, 401, 401, 392, 0, 395, 0, 0, 0, - 1636, 361, 424, 0, 146, 0, 0, 0, 0, 1625, - 614, 0, 0, 621, 0, 0, 0, 525, 0, 536, - 537, 0, 648, -2, 710, 389, 0, 403, 406, 962, - 0, 0, 538, 0, 541, 542, 455, 516, 547, 548, - 562, 549, 497, 498, 495, 0, 0, 1542, 1543, 1548, - 1546, 1547, 133, 583, 585, 589, 584, 588, 0, 0, - 0, 520, 0, 520, 581, 0, 451, 1515, 0, 718, - 452, 453, 792, 792, 865, 97, 0, 868, 0, 0, - 0, 0, 1030, 1034, 1047, 1048, 1444, 1470, 360, 360, - 1457, 360, 366, 1460, 360, 1462, 360, 1465, 360, 1468, - 1469, 0, 0, 1077, 0, 0, 0, 0, 1163, 1480, - 0, 0, 1174, 1113, 1114, 1114, 1114, 1114, 1114, 1180, - 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1474, - 0, 0, 0, 1195, 0, 0, 1199, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 144, 145, 0, 0, - 0, 0, 0, 0, 1394, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1108, 1112, 0, 1116, - 1117, 0, 0, 1346, 0, 0, 1364, 0, 0, 0, - 0, 0, 0, 0, 1484, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 998, 1005, 0, 1005, 0, - 1005, 0, 0, 0, 1618, 1619, 1488, 1489, 1009, 1490, - 924, 936, 954, 1578, 0, 1571, 0, -2, 1580, 0, - 0, 0, 1586, 375, 376, 928, 80, 1010, 83, 0, - 1599, 1608, 0, 1596, 1601, 1603, 0, 0, 0, 1592, - 0, 1009, 938, 969, 971, 0, 966, 981, 982, 984, - 0, 986, 0, 988, 989, 949, 943, 0, 100, 0, - 1009, 1009, 99, 0, 994, 119, 120, 121, 461, 184, - 189, 0, 0, 0, 194, 0, 196, 0, 0, 0, - 201, 202, 401, 401, 436, 0, 303, 305, 0, 0, - 187, 374, 0, 374, 0, 365, 367, 0, 437, 457, - 1516, 1517, 0, 0, 394, 398, 399, 400, 0, 148, - 0, 0, 0, 617, 0, 645, 0, 0, 0, 0, - 0, 0, 176, 517, 677, 678, 679, 680, 681, 682, - 683, 684, 685, 0, 401, 0, 0, 0, 401, 401, - 401, 0, 702, 388, 0, 0, 673, 670, 539, 0, - 218, 219, 226, 227, 229, 0, 0, 0, 0, 0, - 546, 949, 1533, 1534, 1535, 0, 1545, 1549, 136, 0, - 0, 0, 0, 591, 596, 602, 0, 519, 603, 715, - 716, 717, 95, 727, 733, 867, 887, 1018, 1031, 1035, - 0, 0, 0, 0, 1471, 1455, 374, 1458, 1459, 1461, - 1463, 1464, 1466, 1467, 1073, 1074, 1078, 0, 1160, 0, - 1162, 0, 1478, 0, 1175, 1176, 1177, 1178, 1179, 1510, - 0, 0, 0, 1194, 0, 0, 1114, 0, 1207, 1206, - 1208, 0, 1210, 1211, 1216, 1217, 1220, 1222, 1229, 1231, - 1235, 1237, 1240, 1242, 1244, 0, 1247, 0, 1250, 0, - 1253, 0, 1256, 0, 1259, 0, 1262, 0, 1265, 0, - 1268, 0, 1271, 0, 1274, 0, 1277, 0, 1280, 0, - 1283, 0, 1286, 0, 1289, 0, 1294, 1296, 0, 1299, - 1302, 1304, 0, 1307, 0, 1311, 0, 1313, 1315, 1316, - 0, 0, 0, 1327, 1328, 1329, 1330, 1331, 1332, 1333, - 1334, 1335, 1336, 1343, 0, 1106, 1345, 1118, 1119, 1124, - 1348, 0, 0, 0, 1351, 0, 0, 0, 1355, 1155, - 1366, 0, 1371, 0, 0, 1377, 0, 1381, 0, 1387, - 1388, 1390, 1392, 0, 0, 0, 0, 0, 0, 0, - 975, 956, 64, 1490, 1494, 0, 1565, 1563, 1563, 1573, - 1574, 0, 0, 1581, 0, 0, 0, 0, 84, 0, - 0, 1587, 0, 0, 1604, 0, 0, 0, 0, 101, - 1501, 963, 970, 0, 0, 964, 0, 965, 985, 987, - 942, 0, 1009, 1009, 90, 91, 0, 190, 0, 192, - 0, 195, 197, 198, 199, 205, 206, 207, 200, 0, - 0, 302, 304, 0, 0, 347, 359, 349, 0, 0, - 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 949, 149, - 150, 151, 609, 0, 619, 0, 951, 0, 612, 0, - 528, 0, 0, 0, 401, 401, 401, 0, 0, 0, - 0, 687, 0, 0, 650, 0, 658, 0, 0, 0, - 230, 231, 0, 1544, 582, 0, 134, 135, 0, 0, - 587, 521, 522, 1071, 0, 0, 0, 1072, 1456, 0, - 0, 0, 0, 0, 1475, 0, 0, 0, 0, 1200, - 1203, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1319, 0, 0, 0, 639, 640, 0, - 1395, 1111, 1501, 0, 1115, 1125, 1126, 0, 1115, 1365, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1006, 0, 0, 0, 957, 958, 0, 0, 0, - 995, 1494, 1499, 0, 0, 1568, 0, 1561, 1564, 1562, - 1575, 0, 0, 1582, 0, 1584, 0, 1609, 1610, 1602, - 1597, 0, 1591, 1594, 1596, 1593, 1510, 967, 0, 972, - 0, 1501, 89, 0, 193, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 203, 204, 0, 0, - 363, 368, 0, 0, 0, 610, 0, 952, 622, 613, - 0, 700, 0, 704, 0, 0, 0, 707, 708, 709, - 686, 0, 690, 429, 674, 671, 672, 540, 0, 137, - 138, 0, 0, 0, 1445, 0, 1448, 1158, 1161, 1159, - 0, 1190, 1192, 1193, 1453, 1454, 1209, 1245, 1248, 1251, - 1254, 1257, 1260, 1263, 1266, 1269, 1272, 1275, 1278, 1281, - 1284, 1287, 1290, 1298, 1305, 1308, 1312, 1317, 0, 1320, - 0, 0, 1321, 0, 641, 1102, 0, 0, 1122, 1123, - 0, 1350, 1352, 1353, 1354, 1367, 0, 1372, 1373, 0, - 1378, 0, 1382, 1393, 0, 1000, 1007, 1008, 0, 1003, - 0, 1004, 0, 948, 1499, 82, 1500, 1497, 0, 1495, - 1492, 1557, 0, 1566, 1567, 1576, 1577, 1583, 0, 0, - 1596, 0, 1590, 87, 0, 0, 0, 1510, 191, 0, - 210, 0, 618, 0, 621, 611, 698, 699, 0, 711, - 703, 705, 706, 688, -2, 1536, 0, 0, 0, 590, - 1446, 0, 0, 1322, 0, 637, 638, 1110, 1103, 0, - 1088, 1089, 1107, 1347, 1349, 0, 0, 0, 999, 959, - 960, 1001, 1002, 81, 0, 1496, 1130, 0, 1491, 0, - 1569, 1570, 1600, 0, 1589, 1595, 968, 975, 0, 88, - 442, 435, 1536, 0, 0, 0, 691, 692, 693, 694, - 695, 696, 697, 579, 1538, 139, 140, 0, 509, 510, - 511, 133, 0, 1165, 1318, 1104, 0, 0, 0, 0, - 0, 1368, 0, 1374, 0, 1379, 0, 1498, 0, 0, - 1493, 1598, 623, 0, 625, 0, -2, 430, 443, 0, - 185, 211, 212, 0, 0, 215, 216, 217, 208, 209, - 129, 0, 0, 712, 0, 1539, 1540, 0, 136, 0, - 0, 1095, 1096, 1097, 1098, 1100, 0, 0, 0, 0, - 1131, 1108, 624, 0, 0, 385, 0, 634, 431, 432, - 0, 438, 439, 440, 441, 213, 214, 646, 0, 0, - 508, 586, 1447, 0, 0, 1369, 0, 1375, 0, 1380, - 0, 626, 627, 635, 0, 433, 0, 434, 0, 0, - 0, 615, 0, 646, 1537, 1105, 1099, 1101, 0, 0, - 1129, 0, 636, 632, 444, 446, 447, 0, 0, 445, - 647, 616, 1370, 1376, 0, 448, 449, 450, 628, 629, - 630, 631, + 1434, 0, 0, 1453, 0, 0, 0, 0, 0, 0, + 0, 1473, 0, 1086, 1087, 1088, 0, 0, 0, 0, + 0, 0, 1215, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 142, 143, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1361, 1362, + 1363, 1364, 41, 0, 0, 0, 0, 0, 0, 0, + 1484, 0, -2, -2, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1386, 0, 0, + 0, 0, 0, 0, 1606, 0, 0, 857, 858, 860, + 0, 996, 0, 977, 0, 0, 863, 0, 904, 0, + 907, 60, 62, 913, 914, 0, 935, 924, 912, 56, + 51, 0, 0, 954, 1553, 1556, 1557, 374, 1579, 0, + 383, 383, 380, 1514, 1515, 0, 1507, 1509, 1510, 79, + 932, 928, 0, 1010, 0, 0, 991, 0, 938, 940, + 941, 942, 974, 0, 945, 946, 0, 0, 0, 0, + 0, 98, 993, 104, 0, 112, 0, 0, 117, 118, + 105, 106, 107, 108, 0, 609, -2, 460, 179, 181, + 182, 183, 174, -2, 372, 370, 371, 310, 374, 374, + 336, 337, 338, 339, 340, 341, 0, 348, 0, 329, + 330, 331, 332, 321, 0, 322, 323, 324, 364, 0, + 325, 326, 0, 327, 427, 0, 1516, 390, 391, 393, + 401, 0, 396, 397, 0, 401, 401, 0, 422, 423, + 0, 1508, 1533, 0, 0, 1636, 1635, 1635, 1635, 152, + 0, 167, 168, 169, 170, 171, 172, 645, 0, 0, + 621, 643, 644, 165, 0, 0, 175, 516, 515, 0, + 677, 0, 425, 0, 0, 419, 419, 404, 405, 557, + 0, 0, 652, 653, 654, 655, 0, 0, 0, 543, + 454, 0, 544, 545, 514, 516, 0, 0, 385, 468, + 469, 474, 475, 494, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 592, 593, 595, 598, + 600, 518, 604, 606, 0, 594, 597, 599, 601, 518, + 605, 607, 1530, 1531, 1532, 0, 0, 715, 0, 0, + 451, 94, 1624, 720, 724, 725, 790, 743, 777, 790, + 735, 742, 765, 779, 781, 815, 816, 821, 829, 830, + 831, 871, 0, 0, 0, 0, 879, 0, 0, 1023, + 1138, 1140, 1025, 1026, 1027, 1030, 0, 1034, 1038, 0, + 0, 0, 0, 0, 1085, 1083, 1484, 0, 0, 0, + 1134, 0, 0, 1157, 1158, 0, 0, 0, 0, 1478, + 0, 0, 1165, 0, 1439, 1115, 0, 0, 0, 0, + 0, 1115, 1115, 1115, 1115, 1115, 1115, 1115, 1115, 1115, + 1115, 1502, 1192, 0, 0, 0, 0, 0, 1197, 1198, + 1199, 1115, 0, 1202, 1203, 0, 1205, 0, 1206, 0, + 0, 0, 0, 1213, 1214, 1216, 0, 0, 1219, 1220, + 0, 1222, 0, 1224, 1225, 1226, 1227, 1228, 1229, 0, + 1231, 0, 1233, 1234, 1235, 0, 1237, 0, 1239, 1240, + 0, 1242, 0, 1244, 0, 1247, 0, 1250, 0, 1253, + 0, 1256, 0, 1259, 0, 1262, 0, 1265, 0, 1268, + 0, 1271, 0, 1274, 0, 1277, 0, 1280, 0, 1283, + 0, 1286, 0, 1289, 0, 1292, 1293, 1294, 0, 1296, + 0, 1298, 0, 1301, 1302, 0, 1304, 0, 1307, 0, + 1310, 0, 0, 1311, 0, 0, 0, 1315, 0, 0, + 0, 0, 1324, 1325, 1326, 1327, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1338, 1339, 1340, 1341, + 1342, 1343, 0, 1345, 0, 1116, 0, 0, 1116, 0, + 0, 0, 0, 0, 1155, 1633, 0, 1440, 1441, 1442, + 1443, 1444, 0, 0, 0, 0, 0, 0, 1384, 1385, + 1387, 0, 0, 1390, 0, 1392, 0, 1607, 856, 859, + 861, 948, 997, 998, 0, 0, 0, 0, 978, 1632, + 902, 903, 906, 956, 0, 1488, 0, 0, 935, 1010, + 0, 936, 0, 53, 951, 0, 1561, 1560, 1573, 1586, + 383, 383, 377, 378, 384, 379, 381, 382, 1506, 0, + 1511, 0, 1600, 0, 0, 1589, 0, 0, 0, 0, + 0, 0, 0, 0, 981, 0, 0, 984, 0, 0, + 0, 0, 975, 946, 0, 947, 0, -2, 0, 0, + 92, 93, 0, 0, 0, 115, 116, 0, 0, 122, + 386, 387, 156, 165, 462, 180, 435, 0, 0, 306, + 373, 333, 334, 335, 0, 358, 0, 0, 0, 0, + 456, 128, 1520, 1519, 401, 401, 392, 0, 395, 0, + 0, 0, 1637, 361, 424, 0, 146, 0, 0, 0, + 0, 1626, 615, 0, 0, 622, 0, 0, 0, 525, + 0, 536, 537, 0, 649, -2, 711, 389, 0, 403, + 406, 963, 0, 0, 538, 0, 541, 542, 455, 516, + 547, 548, 562, 549, 497, 498, 495, 0, 0, 1543, + 1544, 1549, 1547, 1548, 133, 583, 585, 589, 584, 588, + 0, 0, 0, 520, 0, 608, 520, 581, 0, 451, + 1516, 0, 719, 452, 453, 793, 793, 866, 97, 0, + 869, 0, 0, 0, 0, 1031, 1035, 1048, 1049, 1445, + 1471, 360, 360, 1458, 360, 366, 1461, 360, 1463, 360, + 1466, 360, 1469, 1470, 0, 0, 1078, 0, 0, 0, + 0, 1164, 1481, 0, 0, 1175, 1114, 1115, 1115, 1115, + 1115, 1115, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, + 1189, 1190, 1475, 0, 0, 0, 1196, 0, 0, 1200, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 144, + 145, 0, 0, 0, 0, 0, 0, 1395, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1109, + 1113, 0, 1117, 1118, 0, 0, 1347, 0, 0, 1365, + 0, 0, 0, 0, 0, 0, 0, 1485, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 999, 1006, + 0, 1006, 0, 1006, 0, 0, 0, 1619, 1620, 1489, + 1490, 1010, 1491, 925, 937, 955, 1579, 0, 1572, 0, + -2, 1581, 0, 0, 0, 1587, 375, 376, 929, 80, + 1011, 83, 0, 1600, 1609, 0, 1597, 1602, 1604, 0, + 0, 0, 1593, 0, 1010, 939, 970, 972, 0, 967, + 982, 983, 985, 0, 987, 0, 989, 990, 950, 944, + 0, 100, 0, 1010, 1010, 99, 0, 995, 119, 120, + 121, 461, 184, 189, 0, 0, 0, 194, 0, 196, + 0, 0, 0, 201, 202, 401, 401, 436, 0, 303, + 305, 0, 0, 187, 374, 0, 374, 0, 365, 367, + 0, 437, 457, 1517, 1518, 0, 0, 394, 398, 399, + 400, 0, 148, 0, 0, 0, 618, 0, 646, 0, + 0, 0, 0, 0, 0, 176, 517, 678, 679, 680, + 681, 682, 683, 684, 685, 686, 0, 401, 0, 0, + 0, 401, 401, 401, 0, 703, 388, 0, 0, 674, + 671, 539, 0, 218, 219, 226, 227, 229, 0, 0, + 0, 0, 0, 546, 950, 1534, 1535, 1536, 0, 1546, + 1550, 136, 0, 0, 0, 0, 591, 596, 602, 0, + 519, 603, 716, 717, 718, 95, 728, 734, 868, 888, + 1019, 1032, 1036, 0, 0, 0, 0, 1472, 1456, 374, + 1459, 1460, 1462, 1464, 1465, 1467, 1468, 1074, 1075, 1079, + 0, 1161, 0, 1163, 0, 1479, 0, 1176, 1177, 1178, + 1179, 1180, 1511, 0, 0, 0, 1195, 0, 0, 1115, + 0, 1208, 1207, 1209, 0, 1211, 1212, 1217, 1218, 1221, + 1223, 1230, 1232, 1236, 1238, 1241, 1243, 1245, 0, 1248, + 0, 1251, 0, 1254, 0, 1257, 0, 1260, 0, 1263, + 0, 1266, 0, 1269, 0, 1272, 0, 1275, 0, 1278, + 0, 1281, 0, 1284, 0, 1287, 0, 1290, 0, 1295, + 1297, 0, 1300, 1303, 1305, 0, 1308, 0, 1312, 0, + 1314, 1316, 1317, 0, 0, 0, 1328, 1329, 1330, 1331, + 1332, 1333, 1334, 1335, 1336, 1337, 1344, 0, 1107, 1346, + 1119, 1120, 1125, 1349, 0, 0, 0, 1352, 0, 0, + 0, 1356, 1156, 1367, 0, 1372, 0, 0, 1378, 0, + 1382, 0, 1388, 1389, 1391, 1393, 0, 0, 0, 0, + 0, 0, 0, 976, 957, 64, 1491, 1495, 0, 1566, + 1564, 1564, 1574, 1575, 0, 0, 1582, 0, 0, 0, + 0, 84, 0, 0, 1588, 0, 0, 1605, 0, 0, + 0, 0, 101, 1502, 964, 971, 0, 0, 965, 0, + 966, 986, 988, 943, 0, 1010, 1010, 90, 91, 0, + 190, 0, 192, 0, 195, 197, 198, 199, 205, 206, + 207, 200, 0, 0, 302, 304, 0, 0, 347, 359, + 349, 0, 0, 1521, 1522, 1523, 1524, 1525, 1526, 1527, + 1528, 950, 149, 150, 151, 610, 0, 620, 0, 952, + 0, 613, 0, 528, 0, 0, 0, 401, 401, 401, + 0, 0, 0, 0, 688, 0, 0, 651, 0, 659, + 0, 0, 0, 230, 231, 0, 1545, 582, 0, 134, + 135, 0, 0, 587, 521, 522, 1072, 0, 0, 0, + 1073, 1457, 0, 0, 0, 0, 0, 1476, 0, 0, + 0, 0, 1201, 1204, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1320, 0, 0, 0, + 640, 641, 0, 1396, 1112, 1502, 0, 1116, 1126, 1127, + 0, 1116, 1366, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1007, 0, 0, 0, 958, 959, + 0, 0, 0, 996, 1495, 1500, 0, 0, 1569, 0, + 1562, 1565, 1563, 1576, 0, 0, 1583, 0, 1585, 0, + 1610, 1611, 1603, 1598, 0, 1592, 1595, 1597, 1594, 1511, + 968, 0, 973, 0, 1502, 89, 0, 193, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 203, + 204, 0, 0, 363, 368, 0, 0, 0, 611, 0, + 953, 623, 614, 0, 701, 0, 705, 0, 0, 0, + 708, 709, 710, 687, 0, 691, 429, 675, 672, 673, + 540, 0, 137, 138, 0, 0, 0, 1446, 0, 1449, + 1159, 1162, 1160, 0, 1191, 1193, 1194, 1454, 1455, 1210, + 1246, 1249, 1252, 1255, 1258, 1261, 1264, 1267, 1270, 1273, + 1276, 1279, 1282, 1285, 1288, 1291, 1299, 1306, 1309, 1313, + 1318, 0, 1321, 0, 0, 1322, 0, 642, 1103, 0, + 0, 1123, 1124, 0, 1351, 1353, 1354, 1355, 1368, 0, + 1373, 1374, 0, 1379, 0, 1383, 1394, 0, 1001, 1008, + 1009, 0, 1004, 0, 1005, 0, 949, 1500, 82, 1501, + 1498, 0, 1496, 1493, 1558, 0, 1567, 1568, 1577, 1578, + 1584, 0, 0, 1597, 0, 1591, 87, 0, 0, 0, + 1511, 191, 0, 210, 0, 619, 0, 622, 612, 699, + 700, 0, 712, 704, 706, 707, 689, -2, 1537, 0, + 0, 0, 590, 1447, 0, 0, 1323, 0, 638, 639, + 1111, 1104, 0, 1089, 1090, 1108, 1348, 1350, 0, 0, + 0, 1000, 960, 961, 1002, 1003, 81, 0, 1497, 1131, + 0, 1492, 0, 1570, 1571, 1601, 0, 1590, 1596, 969, + 976, 0, 88, 442, 435, 1537, 0, 0, 0, 692, + 693, 694, 695, 696, 697, 698, 579, 1539, 139, 140, + 0, 509, 510, 511, 133, 0, 1166, 1319, 1105, 0, + 0, 0, 0, 0, 1369, 0, 1375, 0, 1380, 0, + 1499, 0, 0, 1494, 1599, 624, 0, 626, 0, -2, + 430, 443, 0, 185, 211, 212, 0, 0, 215, 216, + 217, 208, 209, 129, 0, 0, 713, 0, 1540, 1541, + 0, 136, 0, 0, 1096, 1097, 1098, 1099, 1101, 0, + 0, 0, 0, 1132, 1109, 625, 0, 0, 385, 0, + 635, 431, 432, 0, 438, 439, 440, 441, 213, 214, + 647, 0, 0, 508, 586, 1448, 0, 0, 1370, 0, + 1376, 0, 1381, 0, 627, 628, 636, 0, 433, 0, + 434, 0, 0, 0, 616, 0, 647, 1538, 1106, 1100, + 1102, 0, 0, 1130, 0, 637, 633, 444, 446, 447, + 0, 0, 445, 648, 617, 1371, 1377, 0, 448, 449, + 450, 629, 630, 631, 632, } var yyTok1 = [...]int{ @@ -9859,7 +9901,7 @@ var yyTok1 = [...]int{ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 158, 3, 3, 3, 186, 178, 3, 95, 97, 183, 181, 96, 182, 236, 184, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 751, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 752, 166, 165, 167, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, @@ -9994,7 +10036,7 @@ var yyTok3 = [...]int{ 58060, 735, 58061, 736, 58062, 737, 58063, 738, 58064, 739, 58065, 740, 58066, 741, 58067, 742, 58068, 743, 58069, 744, 58070, 745, 58071, 746, 58072, 747, 58073, 748, 58074, 749, - 58075, 750, 0, + 58075, 750, 58076, 751, 0, } var yyErrorMessages = [...]struct { @@ -14615,17 +14657,29 @@ yydefault: } yyVAL.union = yyLOCAL case 608: + yyDollar = yyS[yypt-6 : yypt+1] + var yyLOCAL Statement +//line sql.y:3411 + { + yyLOCAL = &AlterMigration{ + Type: SetCutOverThresholdMigrationType, + UUID: string(yyDollar[4].str), + Threshold: yyDollar[6].str, + } + } + yyVAL.union = yyLOCAL + case 609: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3412 +//line sql.y:3420 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 609: + case 610: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3416 +//line sql.y:3424 { yyDollar[3].partitionOptionUnion().Partitions = yyDollar[4].integerUnion() yyDollar[3].partitionOptionUnion().SubPartition = yyDollar[5].subPartitionUnion() @@ -14633,10 +14687,10 @@ yydefault: yyLOCAL = yyDollar[3].partitionOptionUnion() } yyVAL.union = yyLOCAL - case 610: + case 611: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3425 +//line sql.y:3433 { yyLOCAL = &PartitionOption{ IsLinear: yyDollar[1].booleanUnion(), @@ -14645,10 +14699,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 611: + case 612: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3433 +//line sql.y:3441 { yyLOCAL = &PartitionOption{ IsLinear: yyDollar[1].booleanUnion(), @@ -14658,10 +14712,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 612: + case 613: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3442 +//line sql.y:3450 { yyLOCAL = &PartitionOption{ Type: yyDollar[1].partitionByTypeUnion(), @@ -14669,10 +14723,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 613: + case 614: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *PartitionOption -//line sql.y:3449 +//line sql.y:3457 { yyLOCAL = &PartitionOption{ Type: yyDollar[1].partitionByTypeUnion(), @@ -14680,18 +14734,18 @@ yydefault: } } yyVAL.union = yyLOCAL - case 614: + case 615: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *SubPartition -//line sql.y:3457 +//line sql.y:3465 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 615: + case 616: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL *SubPartition -//line sql.y:3461 +//line sql.y:3469 { yyLOCAL = &SubPartition{ IsLinear: yyDollar[3].booleanUnion(), @@ -14701,10 +14755,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 616: + case 617: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL *SubPartition -//line sql.y:3470 +//line sql.y:3478 { yyLOCAL = &SubPartition{ IsLinear: yyDollar[3].booleanUnion(), @@ -14715,678 +14769,678 @@ yydefault: } } yyVAL.union = yyLOCAL - case 617: + case 618: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []*PartitionDefinition -//line sql.y:3481 +//line sql.y:3489 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 618: + case 619: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL []*PartitionDefinition -//line sql.y:3485 +//line sql.y:3493 { yyLOCAL = yyDollar[2].partDefsUnion() } yyVAL.union = yyLOCAL - case 619: + case 620: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:3490 +//line sql.y:3498 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 620: + case 621: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:3494 +//line sql.y:3502 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 621: + case 622: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int -//line sql.y:3499 +//line sql.y:3507 { yyLOCAL = 0 } yyVAL.union = yyLOCAL - case 622: + case 623: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int -//line sql.y:3503 +//line sql.y:3511 { yyLOCAL = convertStringToInt(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 623: + case 624: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL TableExpr -//line sql.y:3509 +//line sql.y:3517 { yyLOCAL = &JSONTableExpr{Expr: yyDollar[3].exprUnion(), Filter: yyDollar[5].exprUnion(), Columns: yyDollar[6].jtColumnListUnion(), Alias: yyDollar[8].identifierCS} } yyVAL.union = yyLOCAL - case 624: + case 625: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL []*JtColumnDefinition -//line sql.y:3515 +//line sql.y:3523 { yyLOCAL = yyDollar[3].jtColumnListUnion() } yyVAL.union = yyLOCAL - case 625: + case 626: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*JtColumnDefinition -//line sql.y:3521 +//line sql.y:3529 { yyLOCAL = []*JtColumnDefinition{yyDollar[1].jtColumnDefinitionUnion()} } yyVAL.union = yyLOCAL - case 626: + case 627: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3525 +//line sql.y:3533 { yySLICE := (*[]*JtColumnDefinition)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].jtColumnDefinitionUnion()) } - case 627: + case 628: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3531 +//line sql.y:3539 { yyLOCAL = &JtColumnDefinition{JtOrdinal: &JtOrdinalColDef{Name: yyDollar[1].identifierCI}} } yyVAL.union = yyLOCAL - case 628: + case 629: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3535 +//line sql.y:3543 { yyDollar[2].columnType.Options = &ColumnTypeOptions{Collate: yyDollar[3].str} jtPath := &JtPathColDef{Name: yyDollar[1].identifierCI, Type: yyDollar[2].columnType, JtColExists: yyDollar[4].booleanUnion(), Path: yyDollar[6].exprUnion()} yyLOCAL = &JtColumnDefinition{JtPath: jtPath} } yyVAL.union = yyLOCAL - case 629: + case 630: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3541 +//line sql.y:3549 { yyDollar[2].columnType.Options = &ColumnTypeOptions{Collate: yyDollar[3].str} jtPath := &JtPathColDef{Name: yyDollar[1].identifierCI, Type: yyDollar[2].columnType, JtColExists: yyDollar[4].booleanUnion(), Path: yyDollar[6].exprUnion(), EmptyOnResponse: yyDollar[7].jtOnResponseUnion()} yyLOCAL = &JtColumnDefinition{JtPath: jtPath} } yyVAL.union = yyLOCAL - case 630: + case 631: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3547 +//line sql.y:3555 { yyDollar[2].columnType.Options = &ColumnTypeOptions{Collate: yyDollar[3].str} jtPath := &JtPathColDef{Name: yyDollar[1].identifierCI, Type: yyDollar[2].columnType, JtColExists: yyDollar[4].booleanUnion(), Path: yyDollar[6].exprUnion(), ErrorOnResponse: yyDollar[7].jtOnResponseUnion()} yyLOCAL = &JtColumnDefinition{JtPath: jtPath} } yyVAL.union = yyLOCAL - case 631: + case 632: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3553 +//line sql.y:3561 { yyDollar[2].columnType.Options = &ColumnTypeOptions{Collate: yyDollar[3].str} jtPath := &JtPathColDef{Name: yyDollar[1].identifierCI, Type: yyDollar[2].columnType, JtColExists: yyDollar[4].booleanUnion(), Path: yyDollar[6].exprUnion(), EmptyOnResponse: yyDollar[7].jtOnResponseUnion(), ErrorOnResponse: yyDollar[8].jtOnResponseUnion()} yyLOCAL = &JtColumnDefinition{JtPath: jtPath} } yyVAL.union = yyLOCAL - case 632: + case 633: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *JtColumnDefinition -//line sql.y:3559 +//line sql.y:3567 { jtNestedPath := &JtNestedPathColDef{Path: yyDollar[3].exprUnion(), Columns: yyDollar[4].jtColumnListUnion()} yyLOCAL = &JtColumnDefinition{JtNestedPath: jtNestedPath} } yyVAL.union = yyLOCAL - case 633: + case 634: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:3565 +//line sql.y:3573 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 634: + case 635: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:3569 +//line sql.y:3577 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 635: + case 636: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:3573 +//line sql.y:3581 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 636: + case 637: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:3577 +//line sql.y:3585 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 637: + case 638: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *JtOnResponse -//line sql.y:3583 +//line sql.y:3591 { yyLOCAL = yyDollar[1].jtOnResponseUnion() } yyVAL.union = yyLOCAL - case 638: + case 639: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *JtOnResponse -//line sql.y:3589 +//line sql.y:3597 { yyLOCAL = yyDollar[1].jtOnResponseUnion() } yyVAL.union = yyLOCAL - case 639: + case 640: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *JtOnResponse -//line sql.y:3595 +//line sql.y:3603 { yyLOCAL = &JtOnResponse{ResponseType: ErrorJSONType} } yyVAL.union = yyLOCAL - case 640: + case 641: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *JtOnResponse -//line sql.y:3599 +//line sql.y:3607 { yyLOCAL = &JtOnResponse{ResponseType: NullJSONType} } yyVAL.union = yyLOCAL - case 641: + case 642: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *JtOnResponse -//line sql.y:3603 +//line sql.y:3611 { yyLOCAL = &JtOnResponse{ResponseType: DefaultJSONType, Expr: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 642: + case 643: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL PartitionByType -//line sql.y:3609 +//line sql.y:3617 { yyLOCAL = RangeType } yyVAL.union = yyLOCAL - case 643: + case 644: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL PartitionByType -//line sql.y:3613 +//line sql.y:3621 { yyLOCAL = ListType } yyVAL.union = yyLOCAL - case 644: + case 645: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int -//line sql.y:3618 +//line sql.y:3626 { yyLOCAL = -1 } yyVAL.union = yyLOCAL - case 645: + case 646: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL int -//line sql.y:3622 +//line sql.y:3630 { yyLOCAL = convertStringToInt(yyDollar[2].str) } yyVAL.union = yyLOCAL - case 646: + case 647: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int -//line sql.y:3627 +//line sql.y:3635 { yyLOCAL = -1 } yyVAL.union = yyLOCAL - case 647: + case 648: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL int -//line sql.y:3631 +//line sql.y:3639 { yyLOCAL = convertStringToInt(yyDollar[2].str) } yyVAL.union = yyLOCAL - case 648: + case 649: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3637 +//line sql.y:3645 { yyLOCAL = &PartitionSpec{Action: AddAction, Definitions: []*PartitionDefinition{yyDollar[4].partDefUnion()}} } yyVAL.union = yyLOCAL - case 649: + case 650: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3641 +//line sql.y:3649 { yyLOCAL = &PartitionSpec{Action: DropAction, Names: yyDollar[3].partitionsUnion()} } yyVAL.union = yyLOCAL - case 650: + case 651: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3645 +//line sql.y:3653 { yyLOCAL = &PartitionSpec{Action: ReorganizeAction, Names: yyDollar[3].partitionsUnion(), Definitions: yyDollar[6].partDefsUnion()} } yyVAL.union = yyLOCAL - case 651: + case 652: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3649 +//line sql.y:3657 { yyLOCAL = &PartitionSpec{Action: DiscardAction, Names: yyDollar[3].partitionsUnion()} } yyVAL.union = yyLOCAL - case 652: + case 653: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3653 +//line sql.y:3661 { yyLOCAL = &PartitionSpec{Action: DiscardAction, IsAll: true} } yyVAL.union = yyLOCAL - case 653: + case 654: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3657 +//line sql.y:3665 { yyLOCAL = &PartitionSpec{Action: ImportAction, Names: yyDollar[3].partitionsUnion()} } yyVAL.union = yyLOCAL - case 654: + case 655: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3661 +//line sql.y:3669 { yyLOCAL = &PartitionSpec{Action: ImportAction, IsAll: true} } yyVAL.union = yyLOCAL - case 655: + case 656: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3665 +//line sql.y:3673 { yyLOCAL = &PartitionSpec{Action: TruncateAction, Names: yyDollar[3].partitionsUnion()} } yyVAL.union = yyLOCAL - case 656: + case 657: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3669 +//line sql.y:3677 { yyLOCAL = &PartitionSpec{Action: TruncateAction, IsAll: true} } yyVAL.union = yyLOCAL - case 657: + case 658: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3673 +//line sql.y:3681 { yyLOCAL = &PartitionSpec{Action: CoalesceAction, Number: NewIntLiteral(yyDollar[3].str)} } yyVAL.union = yyLOCAL - case 658: + case 659: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3677 +//line sql.y:3685 { yyLOCAL = &PartitionSpec{Action: ExchangeAction, Names: Partitions{yyDollar[3].identifierCI}, TableName: yyDollar[6].tableName, WithoutValidation: yyDollar[7].booleanUnion()} } yyVAL.union = yyLOCAL - case 659: + case 660: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3681 +//line sql.y:3689 { yyLOCAL = &PartitionSpec{Action: AnalyzeAction, Names: yyDollar[3].partitionsUnion()} } yyVAL.union = yyLOCAL - case 660: + case 661: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3685 +//line sql.y:3693 { yyLOCAL = &PartitionSpec{Action: AnalyzeAction, IsAll: true} } yyVAL.union = yyLOCAL - case 661: + case 662: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3689 +//line sql.y:3697 { yyLOCAL = &PartitionSpec{Action: CheckAction, Names: yyDollar[3].partitionsUnion()} } yyVAL.union = yyLOCAL - case 662: + case 663: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3693 +//line sql.y:3701 { yyLOCAL = &PartitionSpec{Action: CheckAction, IsAll: true} } yyVAL.union = yyLOCAL - case 663: + case 664: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3697 +//line sql.y:3705 { yyLOCAL = &PartitionSpec{Action: OptimizeAction, Names: yyDollar[3].partitionsUnion()} } yyVAL.union = yyLOCAL - case 664: + case 665: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3701 +//line sql.y:3709 { yyLOCAL = &PartitionSpec{Action: OptimizeAction, IsAll: true} } yyVAL.union = yyLOCAL - case 665: + case 666: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3705 +//line sql.y:3713 { yyLOCAL = &PartitionSpec{Action: RebuildAction, Names: yyDollar[3].partitionsUnion()} } yyVAL.union = yyLOCAL - case 666: + case 667: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3709 +//line sql.y:3717 { yyLOCAL = &PartitionSpec{Action: RebuildAction, IsAll: true} } yyVAL.union = yyLOCAL - case 667: + case 668: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3713 +//line sql.y:3721 { yyLOCAL = &PartitionSpec{Action: RepairAction, Names: yyDollar[3].partitionsUnion()} } yyVAL.union = yyLOCAL - case 668: + case 669: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3717 +//line sql.y:3725 { yyLOCAL = &PartitionSpec{Action: RepairAction, IsAll: true} } yyVAL.union = yyLOCAL - case 669: + case 670: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionSpec -//line sql.y:3721 +//line sql.y:3729 { yyLOCAL = &PartitionSpec{Action: UpgradeAction} } yyVAL.union = yyLOCAL - case 670: + case 671: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:3726 +//line sql.y:3734 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 671: + case 672: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:3730 +//line sql.y:3738 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 672: + case 673: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:3734 +//line sql.y:3742 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 673: + case 674: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*PartitionDefinition -//line sql.y:3740 +//line sql.y:3748 { yyLOCAL = []*PartitionDefinition{yyDollar[1].partDefUnion()} } yyVAL.union = yyLOCAL - case 674: + case 675: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3744 +//line sql.y:3752 { yySLICE := (*[]*PartitionDefinition)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].partDefUnion()) } - case 675: + case 676: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3750 +//line sql.y:3758 { yyVAL.partDefUnion().Options = yyDollar[2].partitionDefinitionOptionsUnion() } - case 676: + case 677: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3755 +//line sql.y:3763 { yyLOCAL = &PartitionDefinitionOptions{} } yyVAL.union = yyLOCAL - case 677: + case 678: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3759 +//line sql.y:3767 { yyDollar[1].partitionDefinitionOptionsUnion().ValueRange = yyDollar[2].partitionValueRangeUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 678: + case 679: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3764 +//line sql.y:3772 { yyDollar[1].partitionDefinitionOptionsUnion().Comment = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 679: + case 680: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3769 +//line sql.y:3777 { yyDollar[1].partitionDefinitionOptionsUnion().Engine = yyDollar[2].partitionEngineUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 680: + case 681: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3774 +//line sql.y:3782 { yyDollar[1].partitionDefinitionOptionsUnion().DataDirectory = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 681: + case 682: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3779 +//line sql.y:3787 { yyDollar[1].partitionDefinitionOptionsUnion().IndexDirectory = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 682: + case 683: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3784 +//line sql.y:3792 { yyDollar[1].partitionDefinitionOptionsUnion().MaxRows = ptr.Of(yyDollar[2].integerUnion()) yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 683: + case 684: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3789 +//line sql.y:3797 { yyDollar[1].partitionDefinitionOptionsUnion().MinRows = ptr.Of(yyDollar[2].integerUnion()) yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 684: + case 685: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3794 +//line sql.y:3802 { yyDollar[1].partitionDefinitionOptionsUnion().TableSpace = yyDollar[2].str yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 685: + case 686: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinitionOptions -//line sql.y:3799 +//line sql.y:3807 { yyDollar[1].partitionDefinitionOptionsUnion().SubPartitionDefinitions = yyDollar[2].subPartitionDefinitionsUnion() yyLOCAL = yyDollar[1].partitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 686: + case 687: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SubPartitionDefinitions -//line sql.y:3805 +//line sql.y:3813 { yyLOCAL = yyDollar[2].subPartitionDefinitionsUnion() } yyVAL.union = yyLOCAL - case 687: + case 688: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SubPartitionDefinitions -//line sql.y:3811 +//line sql.y:3819 { yyLOCAL = SubPartitionDefinitions{yyDollar[1].subPartitionDefinitionUnion()} } yyVAL.union = yyLOCAL - case 688: + case 689: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3815 +//line sql.y:3823 { yySLICE := (*SubPartitionDefinitions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].subPartitionDefinitionUnion()) } - case 689: + case 690: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *SubPartitionDefinition -//line sql.y:3821 +//line sql.y:3829 { yyLOCAL = &SubPartitionDefinition{Name: yyDollar[2].identifierCI, Options: yyDollar[3].subPartitionDefinitionOptionsUnion()} } yyVAL.union = yyLOCAL - case 690: + case 691: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3826 +//line sql.y:3834 { yyLOCAL = &SubPartitionDefinitionOptions{} } yyVAL.union = yyLOCAL - case 691: + case 692: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3830 +//line sql.y:3838 { yyDollar[1].subPartitionDefinitionOptionsUnion().Comment = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 692: + case 693: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3835 +//line sql.y:3843 { yyDollar[1].subPartitionDefinitionOptionsUnion().Engine = yyDollar[2].partitionEngineUnion() yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 693: + case 694: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3840 +//line sql.y:3848 { yyDollar[1].subPartitionDefinitionOptionsUnion().DataDirectory = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 694: + case 695: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3845 +//line sql.y:3853 { yyDollar[1].subPartitionDefinitionOptionsUnion().IndexDirectory = yyDollar[2].literalUnion() yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 695: + case 696: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3850 +//line sql.y:3858 { yyDollar[1].subPartitionDefinitionOptionsUnion().MaxRows = ptr.Of(yyDollar[2].integerUnion()) yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 696: + case 697: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3855 +//line sql.y:3863 { yyDollar[1].subPartitionDefinitionOptionsUnion().MinRows = ptr.Of(yyDollar[2].integerUnion()) yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 697: + case 698: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *SubPartitionDefinitionOptions -//line sql.y:3860 +//line sql.y:3868 { yyDollar[1].subPartitionDefinitionOptionsUnion().TableSpace = yyDollar[2].str yyLOCAL = yyDollar[1].subPartitionDefinitionOptionsUnion() } yyVAL.union = yyLOCAL - case 698: + case 699: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionValueRange -//line sql.y:3867 +//line sql.y:3875 { yyLOCAL = &PartitionValueRange{ Type: LessThanType, @@ -15394,10 +15448,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 699: + case 700: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionValueRange -//line sql.y:3874 +//line sql.y:3882 { yyLOCAL = &PartitionValueRange{ Type: LessThanType, @@ -15405,10 +15459,10 @@ yydefault: } } yyVAL.union = yyLOCAL - case 700: + case 701: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *PartitionValueRange -//line sql.y:3881 +//line sql.y:3889 { yyLOCAL = &PartitionValueRange{ Type: InType, @@ -15416,131 +15470,131 @@ yydefault: } } yyVAL.union = yyLOCAL - case 701: + case 702: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:3889 +//line sql.y:3897 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 702: + case 703: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:3893 +//line sql.y:3901 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 703: + case 704: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *PartitionEngine -//line sql.y:3899 +//line sql.y:3907 { yyLOCAL = &PartitionEngine{Storage: yyDollar[1].booleanUnion(), Name: yyDollar[4].identifierCS.String()} } yyVAL.union = yyLOCAL - case 704: + case 705: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *Literal -//line sql.y:3905 +//line sql.y:3913 { yyLOCAL = NewStrLiteral(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 705: + case 706: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Literal -//line sql.y:3911 +//line sql.y:3919 { yyLOCAL = NewStrLiteral(yyDollar[4].str) } yyVAL.union = yyLOCAL - case 706: + case 707: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Literal -//line sql.y:3917 +//line sql.y:3925 { yyLOCAL = NewStrLiteral(yyDollar[4].str) } yyVAL.union = yyLOCAL - case 707: + case 708: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int -//line sql.y:3923 +//line sql.y:3931 { yyLOCAL = convertStringToInt(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 708: + case 709: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int -//line sql.y:3929 +//line sql.y:3937 { yyLOCAL = convertStringToInt(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 709: + case 710: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3935 +//line sql.y:3943 { yyVAL.str = yyDollar[3].identifierCS.String() } - case 710: + case 711: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *PartitionDefinition -//line sql.y:3941 +//line sql.y:3949 { yyLOCAL = &PartitionDefinition{Name: yyDollar[2].identifierCI} } yyVAL.union = yyLOCAL - case 711: + case 712: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3947 +//line sql.y:3955 { yyVAL.str = "" } - case 712: + case 713: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3951 +//line sql.y:3959 { yyVAL.str = "" } - case 713: + case 714: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:3957 +//line sql.y:3965 { yyLOCAL = &RenameTable{TablePairs: yyDollar[3].renameTablePairsUnion()} } yyVAL.union = yyLOCAL - case 714: + case 715: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL []*RenameTablePair -//line sql.y:3963 +//line sql.y:3971 { yyLOCAL = []*RenameTablePair{{FromTable: yyDollar[1].tableName, ToTable: yyDollar[3].tableName}} } yyVAL.union = yyLOCAL - case 715: + case 716: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3967 +//line sql.y:3975 { yySLICE := (*[]*RenameTablePair)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, &RenameTablePair{FromTable: yyDollar[3].tableName, ToTable: yyDollar[5].tableName}) } - case 716: + case 717: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:3973 +//line sql.y:3981 { yyLOCAL = &DropTable{FromTables: yyDollar[6].tableNamesUnion(), IfExists: yyDollar[5].booleanUnion(), Comments: Comments(yyDollar[2].strs).Parsed(), Temp: yyDollar[3].booleanUnion()} } yyVAL.union = yyLOCAL - case 717: + case 718: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:3977 +//line sql.y:3985 { // Change this to an alter statement if yyDollar[4].identifierCI.Lowered() == "primary" { @@ -15550,1377 +15604,1377 @@ yydefault: } } yyVAL.union = yyLOCAL - case 718: + case 719: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:3986 +//line sql.y:3994 { yyLOCAL = &DropView{FromTables: yyDollar[5].tableNamesUnion(), Comments: Comments(yyDollar[2].strs).Parsed(), IfExists: yyDollar[4].booleanUnion()} } yyVAL.union = yyLOCAL - case 719: + case 720: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:3990 +//line sql.y:3998 { yyLOCAL = &DropDatabase{Comments: Comments(yyDollar[2].strs).Parsed(), DBName: yyDollar[5].identifierCS, IfExists: yyDollar[4].booleanUnion()} } yyVAL.union = yyLOCAL - case 720: + case 721: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:3996 +//line sql.y:4004 { yyLOCAL = &TruncateTable{Table: yyDollar[3].tableName} } yyVAL.union = yyLOCAL - case 721: + case 722: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4000 +//line sql.y:4008 { yyLOCAL = &TruncateTable{Table: yyDollar[2].tableName} } yyVAL.union = yyLOCAL - case 722: + case 723: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4006 +//line sql.y:4014 { yyLOCAL = &Analyze{IsLocal: yyDollar[2].booleanUnion(), Table: yyDollar[4].tableName} } yyVAL.union = yyLOCAL - case 723: + case 724: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4012 +//line sql.y:4020 { yyLOCAL = &PurgeBinaryLogs{To: string(yyDollar[5].str)} } yyVAL.union = yyLOCAL - case 724: + case 725: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4016 +//line sql.y:4024 { yyLOCAL = &PurgeBinaryLogs{Before: string(yyDollar[5].str)} } yyVAL.union = yyLOCAL - case 725: + case 726: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4022 +//line sql.y:4030 { yyLOCAL = &Show{&ShowBasic{Command: Charset, Filter: yyDollar[3].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 726: + case 727: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4026 +//line sql.y:4034 { yyLOCAL = &Show{&ShowBasic{Command: Collation, Filter: yyDollar[3].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 727: + case 728: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:4030 +//line sql.y:4038 { yyLOCAL = &Show{&ShowBasic{Full: yyDollar[2].booleanUnion(), Command: Column, Tbl: yyDollar[5].tableName, DbName: yyDollar[6].identifierCS, Filter: yyDollar[7].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 728: + case 729: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4034 +//line sql.y:4042 { yyLOCAL = &Show{&ShowBasic{Command: Database, Filter: yyDollar[3].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 729: + case 730: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4038 +//line sql.y:4046 { yyLOCAL = &Show{&ShowBasic{Command: Database, Filter: yyDollar[3].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 730: + case 731: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4042 +//line sql.y:4050 { yyLOCAL = &Show{&ShowBasic{Command: Keyspace, Filter: yyDollar[3].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 731: + case 732: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4046 +//line sql.y:4054 { yyLOCAL = &Show{&ShowBasic{Command: Keyspace, Filter: yyDollar[3].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 732: + case 733: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4050 +//line sql.y:4058 { yyLOCAL = &Show{&ShowBasic{Command: Function, Filter: yyDollar[4].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 733: + case 734: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:4054 +//line sql.y:4062 { yyLOCAL = &Show{&ShowBasic{Command: Index, Tbl: yyDollar[5].tableName, DbName: yyDollar[6].identifierCS, Filter: yyDollar[7].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 734: + case 735: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4058 +//line sql.y:4066 { yyLOCAL = &Show{&ShowBasic{Command: OpenTable, DbName: yyDollar[4].identifierCS, Filter: yyDollar[5].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 735: + case 736: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4062 +//line sql.y:4070 { yyLOCAL = &Show{&ShowBasic{Command: Privilege}} } yyVAL.union = yyLOCAL - case 736: + case 737: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4066 +//line sql.y:4074 { yyLOCAL = &Show{&ShowBasic{Command: Procedure, Filter: yyDollar[4].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 737: + case 738: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4070 +//line sql.y:4078 { yyLOCAL = &Show{&ShowBasic{Command: StatusSession, Filter: yyDollar[4].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 738: + case 739: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4074 +//line sql.y:4082 { yyLOCAL = &Show{&ShowBasic{Command: StatusGlobal, Filter: yyDollar[4].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 739: + case 740: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4078 +//line sql.y:4086 { yyLOCAL = &Show{&ShowBasic{Command: VariableSession, Filter: yyDollar[4].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 740: + case 741: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4082 +//line sql.y:4090 { yyLOCAL = &Show{&ShowBasic{Command: VariableGlobal, Filter: yyDollar[4].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 741: + case 742: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4086 +//line sql.y:4094 { yyLOCAL = &Show{&ShowBasic{Command: TableStatus, DbName: yyDollar[4].identifierCS, Filter: yyDollar[5].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 742: + case 743: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4090 +//line sql.y:4098 { yyLOCAL = &Show{&ShowBasic{Command: Table, Full: yyDollar[2].booleanUnion(), DbName: yyDollar[4].identifierCS, Filter: yyDollar[5].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 743: + case 744: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4094 +//line sql.y:4102 { yyLOCAL = &Show{&ShowBasic{Command: Trigger, DbName: yyDollar[3].identifierCS, Filter: yyDollar[4].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 744: + case 745: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4098 +//line sql.y:4106 { yyLOCAL = &Show{&ShowCreate{Command: CreateDb, Op: yyDollar[4].tableName}} } yyVAL.union = yyLOCAL - case 745: + case 746: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4102 +//line sql.y:4110 { yyLOCAL = &Show{&ShowCreate{Command: CreateE, Op: yyDollar[4].tableName}} } yyVAL.union = yyLOCAL - case 746: + case 747: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4106 +//line sql.y:4114 { yyLOCAL = &Show{&ShowCreate{Command: CreateF, Op: yyDollar[4].tableName}} } yyVAL.union = yyLOCAL - case 747: + case 748: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4110 +//line sql.y:4118 { yyLOCAL = &Show{&ShowCreate{Command: CreateProc, Op: yyDollar[4].tableName}} } yyVAL.union = yyLOCAL - case 748: + case 749: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4114 +//line sql.y:4122 { yyLOCAL = &Show{&ShowCreate{Command: CreateTbl, Op: yyDollar[4].tableName}} } yyVAL.union = yyLOCAL - case 749: + case 750: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4118 +//line sql.y:4126 { yyLOCAL = &Show{&ShowCreate{Command: CreateTr, Op: yyDollar[4].tableName}} } yyVAL.union = yyLOCAL - case 750: + case 751: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4122 +//line sql.y:4130 { yyLOCAL = &Show{&ShowCreate{Command: CreateV, Op: yyDollar[4].tableName}} } yyVAL.union = yyLOCAL - case 751: + case 752: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4126 +//line sql.y:4134 { yyLOCAL = &Show{&ShowBasic{Command: Engines}} } yyVAL.union = yyLOCAL - case 752: + case 753: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4130 +//line sql.y:4138 { yyLOCAL = &Show{&ShowBasic{Command: Plugins}} } yyVAL.union = yyLOCAL - case 753: + case 754: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4134 +//line sql.y:4142 { yyLOCAL = &Show{&ShowBasic{Command: GtidExecGlobal, DbName: yyDollar[4].identifierCS}} } yyVAL.union = yyLOCAL - case 754: + case 755: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4138 +//line sql.y:4146 { yyLOCAL = &Show{&ShowBasic{Command: VGtidExecGlobal, DbName: yyDollar[4].identifierCS}} } yyVAL.union = yyLOCAL - case 755: + case 756: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4142 +//line sql.y:4150 { yyLOCAL = &Show{&ShowBasic{Command: VitessVariables, Filter: yyDollar[4].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 756: + case 757: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4146 +//line sql.y:4154 { yyLOCAL = &Show{&ShowBasic{Command: VitessMigrations, Filter: yyDollar[4].showFilterUnion(), DbName: yyDollar[3].identifierCS}} } yyVAL.union = yyLOCAL - case 757: + case 758: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4150 +//line sql.y:4158 { yyLOCAL = &ShowMigrationLogs{UUID: string(yyDollar[3].str)} } yyVAL.union = yyLOCAL - case 758: + case 759: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4154 +//line sql.y:4162 { yyLOCAL = &ShowThrottledApps{} } yyVAL.union = yyLOCAL - case 759: + case 760: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4158 +//line sql.y:4166 { yyLOCAL = &Show{&ShowBasic{Command: VitessReplicationStatus, Filter: yyDollar[3].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 760: + case 761: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4162 +//line sql.y:4170 { yyLOCAL = &ShowThrottlerStatus{} } yyVAL.union = yyLOCAL - case 761: + case 762: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4166 +//line sql.y:4174 { yyLOCAL = &Show{&ShowBasic{Command: VschemaTables}} } yyVAL.union = yyLOCAL - case 762: + case 763: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4170 +//line sql.y:4178 { yyLOCAL = &Show{&ShowBasic{Command: VschemaKeyspaces}} } yyVAL.union = yyLOCAL - case 763: + case 764: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4174 +//line sql.y:4182 { yyLOCAL = &Show{&ShowBasic{Command: VschemaVindexes}} } yyVAL.union = yyLOCAL - case 764: + case 765: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4178 +//line sql.y:4186 { yyLOCAL = &Show{&ShowBasic{Command: VschemaVindexes, Tbl: yyDollar[5].tableName}} } yyVAL.union = yyLOCAL - case 765: + case 766: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4182 +//line sql.y:4190 { yyLOCAL = &Show{&ShowBasic{Command: Warnings}} } yyVAL.union = yyLOCAL - case 766: + case 767: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4186 +//line sql.y:4194 { yyLOCAL = &Show{&ShowBasic{Command: VitessShards, Filter: yyDollar[3].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 767: + case 768: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4190 +//line sql.y:4198 { yyLOCAL = &Show{&ShowBasic{Command: VitessTablets, Filter: yyDollar[3].showFilterUnion()}} } yyVAL.union = yyLOCAL - case 768: + case 769: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4194 +//line sql.y:4202 { yyLOCAL = &Show{&ShowBasic{Command: VitessTarget}} } yyVAL.union = yyLOCAL - case 769: + case 770: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4201 +//line sql.y:4209 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].identifierCI.String())}} } yyVAL.union = yyLOCAL - case 770: + case 771: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4205 +//line sql.y:4213 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str) + " " + string(yyDollar[3].str)}} } yyVAL.union = yyLOCAL - case 771: + case 772: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4209 +//line sql.y:4217 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str) + " " + yyDollar[3].identifierCI.String()}} } yyVAL.union = yyLOCAL - case 772: + case 773: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4213 +//line sql.y:4221 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str) + " " + string(yyDollar[3].str)}} } yyVAL.union = yyLOCAL - case 773: + case 774: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4217 +//line sql.y:4225 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str)}} } yyVAL.union = yyLOCAL - case 774: + case 775: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4221 +//line sql.y:4229 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str) + " " + string(yyDollar[3].str) + " " + String(yyDollar[4].tableName)}} } yyVAL.union = yyLOCAL - case 775: + case 776: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4225 +//line sql.y:4233 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str) + " " + string(yyDollar[3].str) + " " + String(yyDollar[4].tableName)}} } yyVAL.union = yyLOCAL - case 776: + case 777: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4229 +//line sql.y:4237 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[3].str)}} } yyVAL.union = yyLOCAL - case 777: + case 778: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4233 +//line sql.y:4241 { yyLOCAL = &Show{&ShowOther{Command: string(yyDollar[2].str)}} } yyVAL.union = yyLOCAL - case 778: + case 779: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4237 +//line sql.y:4245 { yyLOCAL = &Show{&ShowTransactionStatus{TransactionID: string(yyDollar[5].str)}} } yyVAL.union = yyLOCAL - case 779: + case 780: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4241 +//line sql.y:4249 { yyLOCAL = &Show{&ShowTransactionStatus{}} } yyVAL.union = yyLOCAL - case 780: + case 781: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4245 +//line sql.y:4253 { yyLOCAL = &Show{&ShowTransactionStatus{Keyspace: yyDollar[5].identifierCS.String()}} } yyVAL.union = yyLOCAL - case 781: + case 782: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4250 +//line sql.y:4258 { } - case 782: + case 783: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4252 +//line sql.y:4260 { } - case 783: + case 784: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4256 +//line sql.y:4264 { yyVAL.str = "" } - case 784: + case 785: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4260 +//line sql.y:4268 { yyVAL.str = "extended " } - case 785: + case 786: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:4266 +//line sql.y:4274 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 786: + case 787: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4270 +//line sql.y:4278 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 787: + case 788: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4276 +//line sql.y:4284 { yyVAL.str = string(yyDollar[1].str) } - case 788: + case 789: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4280 +//line sql.y:4288 { yyVAL.str = string(yyDollar[1].str) } - case 789: + case 790: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4286 +//line sql.y:4294 { yyVAL.identifierCS = NewIdentifierCS("") } - case 790: + case 791: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4290 +//line sql.y:4298 { yyVAL.identifierCS = yyDollar[2].identifierCS } - case 791: + case 792: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4294 +//line sql.y:4302 { yyVAL.identifierCS = yyDollar[2].identifierCS } - case 792: + case 793: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ShowFilter -//line sql.y:4300 +//line sql.y:4308 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 793: + case 794: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ShowFilter -//line sql.y:4304 +//line sql.y:4312 { yyLOCAL = &ShowFilter{Like: string(yyDollar[2].str)} } yyVAL.union = yyLOCAL - case 794: + case 795: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ShowFilter -//line sql.y:4308 +//line sql.y:4316 { yyLOCAL = &ShowFilter{Filter: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 795: + case 796: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ShowFilter -//line sql.y:4314 +//line sql.y:4322 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 796: + case 797: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ShowFilter -//line sql.y:4318 +//line sql.y:4326 { yyLOCAL = &ShowFilter{Like: string(yyDollar[2].str)} } yyVAL.union = yyLOCAL - case 797: + case 798: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4324 +//line sql.y:4332 { yyVAL.empty = struct{}{} } - case 798: + case 799: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4328 +//line sql.y:4336 { yyVAL.empty = struct{}{} } - case 799: + case 800: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4332 +//line sql.y:4340 { yyVAL.empty = struct{}{} } - case 800: + case 801: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4338 +//line sql.y:4346 { yyVAL.str = string(yyDollar[1].str) } - case 801: + case 802: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4342 +//line sql.y:4350 { yyVAL.str = string(yyDollar[1].str) } - case 802: + case 803: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4348 +//line sql.y:4356 { yyLOCAL = &Use{DBName: yyDollar[2].identifierCS} } yyVAL.union = yyLOCAL - case 803: + case 804: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4352 +//line sql.y:4360 { yyLOCAL = &Use{DBName: IdentifierCS{v: ""}} } yyVAL.union = yyLOCAL - case 804: + case 805: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4356 +//line sql.y:4364 { yyLOCAL = &Use{DBName: NewIdentifierCS(yyDollar[2].identifierCS.String() + "@" + string(yyDollar[3].str))} } yyVAL.union = yyLOCAL - case 805: + case 806: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4363 +//line sql.y:4371 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } - case 806: + case 807: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4367 +//line sql.y:4375 { yyVAL.identifierCS = NewIdentifierCS("@" + string(yyDollar[1].str)) } - case 807: + case 808: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4371 +//line sql.y:4379 { yyVAL.identifierCS = NewIdentifierCS("@@" + string(yyDollar[1].str)) } - case 808: + case 809: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4375 +//line sql.y:4383 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } - case 809: + case 810: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4382 +//line sql.y:4390 { yyLOCAL = &Begin{} } yyVAL.union = yyLOCAL - case 810: + case 811: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4386 +//line sql.y:4394 { yyLOCAL = &Begin{TxAccessModes: yyDollar[3].txAccessModesUnion()} } yyVAL.union = yyLOCAL - case 811: + case 812: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []TxAccessMode -//line sql.y:4391 +//line sql.y:4399 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 812: + case 813: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []TxAccessMode -//line sql.y:4395 +//line sql.y:4403 { yyLOCAL = yyDollar[1].txAccessModesUnion() } yyVAL.union = yyLOCAL - case 813: + case 814: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []TxAccessMode -//line sql.y:4401 +//line sql.y:4409 { yyLOCAL = []TxAccessMode{yyDollar[1].txAccessModeUnion()} } yyVAL.union = yyLOCAL - case 814: + case 815: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4405 +//line sql.y:4413 { yySLICE := (*[]TxAccessMode)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].txAccessModeUnion()) } - case 815: + case 816: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL TxAccessMode -//line sql.y:4411 +//line sql.y:4419 { yyLOCAL = WithConsistentSnapshot } yyVAL.union = yyLOCAL - case 816: + case 817: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL TxAccessMode -//line sql.y:4415 +//line sql.y:4423 { yyLOCAL = ReadWrite } yyVAL.union = yyLOCAL - case 817: + case 818: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL TxAccessMode -//line sql.y:4419 +//line sql.y:4427 { yyLOCAL = ReadOnly } yyVAL.union = yyLOCAL - case 818: + case 819: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4426 +//line sql.y:4434 { yyLOCAL = &Commit{} } yyVAL.union = yyLOCAL - case 819: + case 820: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4432 +//line sql.y:4440 { yyLOCAL = &Rollback{} } yyVAL.union = yyLOCAL - case 820: + case 821: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4436 +//line sql.y:4444 { yyLOCAL = &SRollback{Name: yyDollar[5].identifierCI} } yyVAL.union = yyLOCAL - case 821: + case 822: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4441 +//line sql.y:4449 { yyVAL.empty = struct{}{} } - case 822: + case 823: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4443 +//line sql.y:4451 { yyVAL.empty = struct{}{} } - case 823: + case 824: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4446 +//line sql.y:4454 { yyVAL.empty = struct{}{} } - case 824: + case 825: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4448 +//line sql.y:4456 { yyVAL.empty = struct{}{} } - case 825: + case 826: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4452 +//line sql.y:4460 { yyLOCAL = &Savepoint{Name: yyDollar[2].identifierCI} } yyVAL.union = yyLOCAL - case 826: + case 827: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4458 +//line sql.y:4466 { yyLOCAL = &Release{Name: yyDollar[3].identifierCI} } yyVAL.union = yyLOCAL - case 827: + case 828: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL ExplainType -//line sql.y:4463 +//line sql.y:4471 { yyLOCAL = EmptyType } yyVAL.union = yyLOCAL - case 828: + case 829: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ExplainType -//line sql.y:4467 +//line sql.y:4475 { yyLOCAL = JSONType } yyVAL.union = yyLOCAL - case 829: + case 830: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ExplainType -//line sql.y:4471 +//line sql.y:4479 { yyLOCAL = TreeType } yyVAL.union = yyLOCAL - case 830: + case 831: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ExplainType -//line sql.y:4475 +//line sql.y:4483 { yyLOCAL = TraditionalType } yyVAL.union = yyLOCAL - case 831: + case 832: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ExplainType -//line sql.y:4479 +//line sql.y:4487 { yyLOCAL = AnalyzeType } yyVAL.union = yyLOCAL - case 832: + case 833: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL VExplainType -//line sql.y:4484 +//line sql.y:4492 { yyLOCAL = PlanVExplainType } yyVAL.union = yyLOCAL - case 833: + case 834: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL VExplainType -//line sql.y:4488 +//line sql.y:4496 { yyLOCAL = PlanVExplainType } yyVAL.union = yyLOCAL - case 834: + case 835: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL VExplainType -//line sql.y:4492 +//line sql.y:4500 { yyLOCAL = AllVExplainType } yyVAL.union = yyLOCAL - case 835: + case 836: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL VExplainType -//line sql.y:4496 +//line sql.y:4504 { yyLOCAL = QueriesVExplainType } yyVAL.union = yyLOCAL - case 836: + case 837: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL VExplainType -//line sql.y:4500 +//line sql.y:4508 { yyLOCAL = TraceVExplainType } yyVAL.union = yyLOCAL - case 837: + case 838: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL VExplainType -//line sql.y:4504 +//line sql.y:4512 { yyLOCAL = KeysVExplainType } yyVAL.union = yyLOCAL - case 838: + case 839: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4510 +//line sql.y:4518 { yyVAL.str = yyDollar[1].str } - case 839: + case 840: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4514 +//line sql.y:4522 { yyVAL.str = yyDollar[1].str } - case 840: + case 841: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4518 +//line sql.y:4526 { yyVAL.str = yyDollar[1].str } - case 841: + case 842: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4524 +//line sql.y:4532 { yyLOCAL = yyDollar[1].selStmtUnion() } yyVAL.union = yyLOCAL - case 842: + case 843: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4528 +//line sql.y:4536 { yyLOCAL = yyDollar[1].statementUnion() } yyVAL.union = yyLOCAL - case 843: + case 844: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4532 +//line sql.y:4540 { yyLOCAL = yyDollar[1].statementUnion() } yyVAL.union = yyLOCAL - case 844: + case 845: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Statement -//line sql.y:4536 +//line sql.y:4544 { yyLOCAL = yyDollar[1].statementUnion() } yyVAL.union = yyLOCAL - case 845: + case 846: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4541 +//line sql.y:4549 { yyVAL.str = "" } - case 846: + case 847: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4545 +//line sql.y:4553 { yyVAL.str = yyDollar[1].identifierCI.val } - case 847: + case 848: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4549 +//line sql.y:4557 { yyVAL.str = encodeSQLString(yyDollar[1].str) } - case 848: + case 849: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4555 +//line sql.y:4563 { yyLOCAL = &ExplainTab{Table: yyDollar[3].tableName, Wild: yyDollar[4].str} } yyVAL.union = yyLOCAL - case 849: + case 850: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4559 +//line sql.y:4567 { yyLOCAL = &ExplainStmt{Type: yyDollar[3].explainTypeUnion(), Statement: yyDollar[4].statementUnion(), Comments: Comments(yyDollar[2].strs).Parsed()} } yyVAL.union = yyLOCAL - case 850: + case 851: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4565 +//line sql.y:4573 { yyLOCAL = &VExplainStmt{Type: yyDollar[3].vexplainTypeUnion(), Statement: yyDollar[4].statementUnion(), Comments: Comments(yyDollar[2].strs).Parsed()} } yyVAL.union = yyLOCAL - case 851: + case 852: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4571 +//line sql.y:4579 { yyLOCAL = &OtherAdmin{} } yyVAL.union = yyLOCAL - case 852: + case 853: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4575 +//line sql.y:4583 { yyLOCAL = &OtherAdmin{} } yyVAL.union = yyLOCAL - case 853: + case 854: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4581 +//line sql.y:4589 { yyLOCAL = &LockTables{Tables: yyDollar[3].tableAndLockTypesUnion()} } yyVAL.union = yyLOCAL - case 854: + case 855: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableAndLockTypes -//line sql.y:4587 +//line sql.y:4595 { yyLOCAL = TableAndLockTypes{yyDollar[1].tableAndLockTypeUnion()} } yyVAL.union = yyLOCAL - case 855: + case 856: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4591 +//line sql.y:4599 { yySLICE := (*TableAndLockTypes)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].tableAndLockTypeUnion()) } - case 856: + case 857: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *TableAndLockType -//line sql.y:4597 +//line sql.y:4605 { yyLOCAL = &TableAndLockType{Table: yyDollar[1].aliasedTableNameUnion(), Lock: yyDollar[2].lockTypeUnion()} } yyVAL.union = yyLOCAL - case 857: + case 858: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL LockType -//line sql.y:4603 +//line sql.y:4611 { yyLOCAL = Read } yyVAL.union = yyLOCAL - case 858: + case 859: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL LockType -//line sql.y:4607 +//line sql.y:4615 { yyLOCAL = ReadLocal } yyVAL.union = yyLOCAL - case 859: + case 860: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL LockType -//line sql.y:4611 +//line sql.y:4619 { yyLOCAL = Write } yyVAL.union = yyLOCAL - case 860: + case 861: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL LockType -//line sql.y:4615 +//line sql.y:4623 { yyLOCAL = LowPriorityWrite } yyVAL.union = yyLOCAL - case 861: + case 862: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Statement -//line sql.y:4621 +//line sql.y:4629 { yyLOCAL = &UnlockTables{} } yyVAL.union = yyLOCAL - case 862: + case 863: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4627 +//line sql.y:4635 { yyLOCAL = &RevertMigration{Comments: Comments(yyDollar[2].strs).Parsed(), UUID: string(yyDollar[4].str)} } yyVAL.union = yyLOCAL - case 863: + case 864: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4633 +//line sql.y:4641 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion(), FlushOptions: yyDollar[3].strs} } yyVAL.union = yyLOCAL - case 864: + case 865: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:4637 +//line sql.y:4645 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion()} } yyVAL.union = yyLOCAL - case 865: + case 866: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:4641 +//line sql.y:4649 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion(), WithLock: true} } yyVAL.union = yyLOCAL - case 866: + case 867: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4645 +//line sql.y:4653 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion(), TableNames: yyDollar[4].tableNamesUnion()} } yyVAL.union = yyLOCAL - case 867: + case 868: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Statement -//line sql.y:4649 +//line sql.y:4657 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion(), TableNames: yyDollar[4].tableNamesUnion(), WithLock: true} } yyVAL.union = yyLOCAL - case 868: + case 869: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Statement -//line sql.y:4653 +//line sql.y:4661 { yyLOCAL = &Flush{IsLocal: yyDollar[2].booleanUnion(), TableNames: yyDollar[4].tableNamesUnion(), ForExport: true} } yyVAL.union = yyLOCAL - case 869: + case 870: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4659 +//line sql.y:4667 { yyVAL.strs = []string{yyDollar[1].str} } - case 870: + case 871: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4663 +//line sql.y:4671 { yyVAL.strs = append(yyDollar[1].strs, yyDollar[3].str) } - case 871: - yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4669 - { - yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) - } case 872: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4673 +//line sql.y:4677 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 873: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4677 +//line sql.y:4681 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 874: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4681 +//line sql.y:4685 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 875: - yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4685 + yyDollar = yyS[yypt-2 : yypt+1] +//line sql.y:4689 { - yyVAL.str = string(yyDollar[1].str) + yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) } case 876: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4689 +//line sql.y:4693 { yyVAL.str = string(yyDollar[1].str) } case 877: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4693 +//line sql.y:4697 { yyVAL.str = string(yyDollar[1].str) } case 878: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql.y:4701 + { + yyVAL.str = string(yyDollar[1].str) + } + case 879: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4697 +//line sql.y:4705 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) + yyDollar[3].str } - case 879: + case 880: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4701 +//line sql.y:4709 { yyVAL.str = string(yyDollar[1].str) + " " + string(yyDollar[2].str) } - case 880: + case 881: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4705 +//line sql.y:4713 { yyVAL.str = string(yyDollar[1].str) } - case 881: + case 882: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4709 +//line sql.y:4717 { yyVAL.str = string(yyDollar[1].str) } - case 882: + case 883: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4713 +//line sql.y:4721 { yyVAL.str = string(yyDollar[1].str) } - case 883: + case 884: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:4718 +//line sql.y:4726 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 884: + case 885: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4722 +//line sql.y:4730 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 885: + case 886: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4726 +//line sql.y:4734 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 886: + case 887: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4731 +//line sql.y:4739 { yyVAL.str = "" } - case 887: + case 888: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4735 +//line sql.y:4743 { yyVAL.str = " " + string(yyDollar[1].str) + " " + string(yyDollar[2].str) + " " + yyDollar[3].identifierCI.String() } - case 888: + case 889: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4740 +//line sql.y:4748 { setAllowComments(yylex, true) } - case 889: + case 890: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4744 +//line sql.y:4752 { yyVAL.strs = yyDollar[2].strs setAllowComments(yylex, false) } - case 890: + case 891: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4750 +//line sql.y:4758 { yyVAL.strs = nil } - case 891: + case 892: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4754 +//line sql.y:4762 { yyVAL.strs = append(yyDollar[1].strs, yyDollar[2].str) } - case 892: + case 893: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4760 +//line sql.y:4768 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 893: + case 894: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:4764 +//line sql.y:4772 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 894: + case 895: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:4768 +//line sql.y:4776 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 895: + case 896: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4773 +//line sql.y:4781 { yyVAL.str = "" } - case 896: + case 897: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4777 +//line sql.y:4785 { yyVAL.str = SQLNoCacheStr } - case 897: + case 898: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4781 +//line sql.y:4789 { yyVAL.str = SQLCacheStr } - case 898: + case 899: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:4786 +//line sql.y:4794 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 899: + case 900: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4790 +//line sql.y:4798 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 900: + case 901: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:4794 +//line sql.y:4802 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 901: + case 902: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4800 +//line sql.y:4808 { yyLOCAL = &PrepareStmt{Name: yyDollar[3].identifierCI, Comments: Comments(yyDollar[2].strs).Parsed(), Statement: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 902: + case 903: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:4804 +//line sql.y:4812 { yyLOCAL = &PrepareStmt{ Name: yyDollar[3].identifierCI, @@ -16929,597 +16983,597 @@ yydefault: } } yyVAL.union = yyLOCAL - case 903: + case 904: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4814 +//line sql.y:4822 { yyLOCAL = &ExecuteStmt{Name: yyDollar[3].identifierCI, Comments: Comments(yyDollar[2].strs).Parsed(), Arguments: yyDollar[4].variablesUnion()} } yyVAL.union = yyLOCAL - case 904: + case 905: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []*Variable -//line sql.y:4819 +//line sql.y:4827 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 905: + case 906: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL []*Variable -//line sql.y:4823 +//line sql.y:4831 { yyLOCAL = yyDollar[2].variablesUnion() } yyVAL.union = yyLOCAL - case 906: + case 907: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4829 +//line sql.y:4837 { yyLOCAL = &DeallocateStmt{Comments: Comments(yyDollar[2].strs).Parsed(), Name: yyDollar[4].identifierCI} } yyVAL.union = yyLOCAL - case 907: + case 908: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Statement -//line sql.y:4833 +//line sql.y:4841 { yyLOCAL = &DeallocateStmt{Comments: Comments(yyDollar[2].strs).Parsed(), Name: yyDollar[4].identifierCI} } yyVAL.union = yyLOCAL - case 908: + case 909: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4838 +//line sql.y:4846 { yyVAL.strs = nil } - case 909: + case 910: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4842 +//line sql.y:4850 { yyVAL.strs = yyDollar[1].strs } - case 910: + case 911: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4848 +//line sql.y:4856 { yyVAL.strs = []string{yyDollar[1].str} } - case 911: + case 912: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4852 +//line sql.y:4860 { yyVAL.strs = append(yyDollar[1].strs, yyDollar[2].str) } - case 912: + case 913: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4858 +//line sql.y:4866 { yyVAL.str = SQLNoCacheStr } - case 913: + case 914: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4862 +//line sql.y:4870 { yyVAL.str = SQLCacheStr } - case 914: + case 915: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4866 +//line sql.y:4874 { yyVAL.str = DistinctStr } - case 915: + case 916: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4870 +//line sql.y:4878 { yyVAL.str = DistinctStr } - case 916: + case 917: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4874 +//line sql.y:4882 { yyVAL.str = HighPriorityStr } - case 917: + case 918: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4878 +//line sql.y:4886 { yyVAL.str = StraightJoinHint } - case 918: + case 919: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4882 +//line sql.y:4890 { yyVAL.str = SQLBufferResultStr } - case 919: + case 920: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4886 +//line sql.y:4894 { yyVAL.str = SQLSmallResultStr } - case 920: + case 921: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4890 +//line sql.y:4898 { yyVAL.str = SQLBigResultStr } - case 921: + case 922: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4894 +//line sql.y:4902 { yyVAL.str = SQLCalcFoundRowsStr } - case 922: + case 923: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4898 +//line sql.y:4906 { yyVAL.str = AllStr // These are not picked up by NewSelect, and so ALL will be dropped. But this is OK, since it's redundant anyway } - case 923: + case 924: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectExprs -//line sql.y:4904 +//line sql.y:4912 { yyLOCAL = SelectExprs{yyDollar[1].selectExprUnion()} } yyVAL.union = yyLOCAL - case 924: + case 925: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4908 +//line sql.y:4916 { yySLICE := (*SelectExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].selectExprUnion()) } - case 925: + case 926: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4914 +//line sql.y:4922 { yyLOCAL = &StarExpr{} } yyVAL.union = yyLOCAL - case 926: + case 927: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4918 +//line sql.y:4926 { yyLOCAL = &AliasedExpr{Expr: yyDollar[1].exprUnion(), As: yyDollar[2].identifierCI} } yyVAL.union = yyLOCAL - case 927: + case 928: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4922 +//line sql.y:4930 { yyLOCAL = &StarExpr{TableName: TableName{Name: yyDollar[1].identifierCS}} } yyVAL.union = yyLOCAL - case 928: + case 929: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL SelectExpr -//line sql.y:4926 +//line sql.y:4934 { yyLOCAL = &StarExpr{TableName: TableName{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCS}} } yyVAL.union = yyLOCAL - case 929: + case 930: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4931 +//line sql.y:4939 { yyVAL.identifierCI = IdentifierCI{} } - case 930: + case 931: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4935 +//line sql.y:4943 { yyVAL.identifierCI = yyDollar[1].identifierCI } - case 931: + case 932: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4939 +//line sql.y:4947 { yyVAL.identifierCI = yyDollar[2].identifierCI } - case 933: + case 934: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4946 +//line sql.y:4954 { yyVAL.identifierCI = NewIdentifierCI(string(yyDollar[1].str)) } - case 934: + case 935: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4951 +//line sql.y:4959 { yyLOCAL = TableExprs{&AliasedTableExpr{Expr: TableName{Name: NewIdentifierCS("dual")}}} } yyVAL.union = yyLOCAL - case 935: + case 936: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4955 +//line sql.y:4963 { yyLOCAL = yyDollar[1].tableExprsUnion() } yyVAL.union = yyLOCAL - case 936: + case 937: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4961 +//line sql.y:4969 { yyLOCAL = yyDollar[2].tableExprsUnion() } yyVAL.union = yyLOCAL - case 937: + case 938: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExprs -//line sql.y:4967 +//line sql.y:4975 { yyLOCAL = TableExprs{yyDollar[1].tableExprUnion()} } yyVAL.union = yyLOCAL - case 938: + case 939: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4971 +//line sql.y:4979 { yySLICE := (*TableExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].tableExprUnion()) } - case 941: + case 942: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4981 +//line sql.y:4989 { yyLOCAL = yyDollar[1].aliasedTableNameUnion() } yyVAL.union = yyLOCAL - case 942: + case 943: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4985 +//line sql.y:4993 { yyLOCAL = &AliasedTableExpr{Expr: yyDollar[1].derivedTableUnion(), As: yyDollar[3].identifierCS, Columns: yyDollar[4].columnsUnion()} } yyVAL.union = yyLOCAL - case 943: + case 944: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4989 +//line sql.y:4997 { yyLOCAL = &ParenTableExpr{Exprs: yyDollar[2].tableExprsUnion()} } yyVAL.union = yyLOCAL - case 944: + case 945: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TableExpr -//line sql.y:4993 +//line sql.y:5001 { yyLOCAL = yyDollar[1].tableExprUnion() } yyVAL.union = yyLOCAL - case 945: + case 946: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *DerivedTable -//line sql.y:4999 +//line sql.y:5007 { yyLOCAL = &DerivedTable{Lateral: false, Select: yyDollar[1].selStmtUnion()} } yyVAL.union = yyLOCAL - case 946: + case 947: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *DerivedTable -//line sql.y:5003 +//line sql.y:5011 { yyLOCAL = &DerivedTable{Lateral: true, Select: yyDollar[2].selStmtUnion()} } yyVAL.union = yyLOCAL - case 947: + case 948: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *AliasedTableExpr -//line sql.y:5009 +//line sql.y:5017 { yyLOCAL = &AliasedTableExpr{Expr: yyDollar[1].tableName, As: yyDollar[2].identifierCS, Hints: yyDollar[3].indexHintsUnion()} } yyVAL.union = yyLOCAL - case 948: + case 949: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL *AliasedTableExpr -//line sql.y:5013 +//line sql.y:5021 { yyLOCAL = &AliasedTableExpr{Expr: yyDollar[1].tableName, Partitions: yyDollar[4].partitionsUnion(), As: yyDollar[6].identifierCS, Hints: yyDollar[7].indexHintsUnion()} } yyVAL.union = yyLOCAL - case 949: + case 950: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Columns -//line sql.y:5018 +//line sql.y:5026 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 950: + case 951: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Columns -//line sql.y:5022 +//line sql.y:5030 { yyLOCAL = yyDollar[2].columnsUnion() } yyVAL.union = yyLOCAL - case 951: + case 952: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Columns -//line sql.y:5027 +//line sql.y:5035 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 952: + case 953: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:5031 +//line sql.y:5039 { yyLOCAL = yyDollar[1].columnsUnion() } yyVAL.union = yyLOCAL - case 953: + case 954: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:5037 +//line sql.y:5045 { yyLOCAL = Columns{yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL - case 954: + case 955: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5041 +//line sql.y:5049 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) } - case 955: + case 956: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*Variable -//line sql.y:5047 +//line sql.y:5055 { yyLOCAL = []*Variable{yyDollar[1].variableUnion()} } yyVAL.union = yyLOCAL - case 956: + case 957: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5051 +//line sql.y:5059 { yySLICE := (*[]*Variable)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].variableUnion()) } - case 957: + case 958: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:5057 +//line sql.y:5065 { yyLOCAL = Columns{yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL - case 958: + case 959: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:5061 +//line sql.y:5069 { yyLOCAL = Columns{NewIdentifierCI(string(yyDollar[1].str))} } yyVAL.union = yyLOCAL - case 959: + case 960: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5065 +//line sql.y:5073 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) } - case 960: + case 961: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5069 +//line sql.y:5077 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, NewIdentifierCI(string(yyDollar[3].str))) } - case 961: + case 962: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Partitions -//line sql.y:5075 +//line sql.y:5083 { yyLOCAL = Partitions{yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL - case 962: + case 963: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5079 +//line sql.y:5087 { yySLICE := (*Partitions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) } - case 963: + case 964: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5092 +//line sql.y:5100 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion(), Condition: yyDollar[4].joinCondition} } yyVAL.union = yyLOCAL - case 964: + case 965: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5096 +//line sql.y:5104 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion(), Condition: yyDollar[4].joinCondition} } yyVAL.union = yyLOCAL - case 965: + case 966: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5100 +//line sql.y:5108 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion(), Condition: yyDollar[4].joinCondition} } yyVAL.union = yyLOCAL - case 966: + case 967: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL TableExpr -//line sql.y:5104 +//line sql.y:5112 { yyLOCAL = &JoinTableExpr{LeftExpr: yyDollar[1].tableExprUnion(), Join: yyDollar[2].joinTypeUnion(), RightExpr: yyDollar[3].tableExprUnion()} } yyVAL.union = yyLOCAL - case 967: + case 968: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5110 +//line sql.y:5118 { yyVAL.joinCondition = &JoinCondition{On: yyDollar[2].exprUnion()} } - case 968: + case 969: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5112 +//line sql.y:5120 { yyVAL.joinCondition = &JoinCondition{Using: yyDollar[3].columnsUnion()} } - case 969: + case 970: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5116 +//line sql.y:5124 { yyVAL.joinCondition = &JoinCondition{} } - case 970: + case 971: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5118 +//line sql.y:5126 { yyVAL.joinCondition = yyDollar[1].joinCondition } - case 971: + case 972: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5122 +//line sql.y:5130 { yyVAL.joinCondition = &JoinCondition{} } - case 972: + case 973: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5124 +//line sql.y:5132 { yyVAL.joinCondition = &JoinCondition{On: yyDollar[2].exprUnion()} } - case 973: + case 974: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5127 +//line sql.y:5135 { yyVAL.empty = struct{}{} } - case 974: + case 975: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5129 +//line sql.y:5137 { yyVAL.empty = struct{}{} } - case 975: + case 976: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5132 +//line sql.y:5140 { yyVAL.identifierCS = NewIdentifierCS("") } - case 976: + case 977: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5136 +//line sql.y:5144 { yyVAL.identifierCS = yyDollar[1].identifierCS } - case 977: + case 978: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5140 +//line sql.y:5148 { yyVAL.identifierCS = yyDollar[2].identifierCS } - case 979: + case 980: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5147 +//line sql.y:5155 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } - case 980: + case 981: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL JoinType -//line sql.y:5153 +//line sql.y:5161 { yyLOCAL = NormalJoinType } yyVAL.union = yyLOCAL - case 981: + case 982: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5157 +//line sql.y:5165 { yyLOCAL = NormalJoinType } yyVAL.union = yyLOCAL - case 982: + case 983: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5161 +//line sql.y:5169 { yyLOCAL = NormalJoinType } yyVAL.union = yyLOCAL - case 983: + case 984: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL JoinType -//line sql.y:5167 +//line sql.y:5175 { yyLOCAL = StraightJoinType } yyVAL.union = yyLOCAL - case 984: + case 985: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5173 +//line sql.y:5181 { yyLOCAL = LeftJoinType } yyVAL.union = yyLOCAL - case 985: + case 986: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL JoinType -//line sql.y:5177 +//line sql.y:5185 { yyLOCAL = LeftJoinType } yyVAL.union = yyLOCAL - case 986: + case 987: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5181 +//line sql.y:5189 { yyLOCAL = RightJoinType } yyVAL.union = yyLOCAL - case 987: + case 988: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL JoinType -//line sql.y:5185 +//line sql.y:5193 { yyLOCAL = RightJoinType } yyVAL.union = yyLOCAL - case 988: + case 989: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5191 +//line sql.y:5199 { yyLOCAL = NaturalJoinType } yyVAL.union = yyLOCAL - case 989: + case 990: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL JoinType -//line sql.y:5195 +//line sql.y:5203 { if yyDollar[2].joinTypeUnion() == LeftJoinType { yyLOCAL = NaturalLeftJoinType @@ -17528,667 +17582,667 @@ yydefault: } } yyVAL.union = yyLOCAL - case 990: + case 991: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5205 +//line sql.y:5213 { yyVAL.tableName = yyDollar[2].tableName } - case 991: + case 992: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5209 +//line sql.y:5217 { yyVAL.tableName = yyDollar[1].tableName } - case 992: + case 993: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5215 +//line sql.y:5223 { yyVAL.tableName = TableName{Name: yyDollar[1].identifierCS} } - case 993: + case 994: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5219 +//line sql.y:5227 { yyVAL.tableName = TableName{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCS} } - case 994: + case 995: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5225 +//line sql.y:5233 { yyVAL.tableName = TableName{Name: yyDollar[1].identifierCS} } - case 995: + case 996: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL IndexHints -//line sql.y:5230 +//line sql.y:5238 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 996: + case 997: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IndexHints -//line sql.y:5234 +//line sql.y:5242 { yyLOCAL = yyDollar[1].indexHintsUnion() } yyVAL.union = yyLOCAL - case 997: + case 998: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IndexHints -//line sql.y:5240 +//line sql.y:5248 { yyLOCAL = IndexHints{yyDollar[1].indexHintUnion()} } yyVAL.union = yyLOCAL - case 998: + case 999: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5244 +//line sql.y:5252 { yySLICE := (*IndexHints)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].indexHintUnion()) } - case 999: + case 1000: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5250 +//line sql.y:5258 { yyLOCAL = &IndexHint{Type: UseOp, ForType: yyDollar[3].indexHintForTypeUnion(), Indexes: yyDollar[5].columnsUnion()} } yyVAL.union = yyLOCAL - case 1000: + case 1001: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5254 +//line sql.y:5262 { yyLOCAL = &IndexHint{Type: UseOp, ForType: yyDollar[3].indexHintForTypeUnion()} } yyVAL.union = yyLOCAL - case 1001: + case 1002: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5258 +//line sql.y:5266 { yyLOCAL = &IndexHint{Type: IgnoreOp, ForType: yyDollar[3].indexHintForTypeUnion(), Indexes: yyDollar[5].columnsUnion()} } yyVAL.union = yyLOCAL - case 1002: + case 1003: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5262 +//line sql.y:5270 { yyLOCAL = &IndexHint{Type: ForceOp, ForType: yyDollar[3].indexHintForTypeUnion(), Indexes: yyDollar[5].columnsUnion()} } yyVAL.union = yyLOCAL - case 1003: + case 1004: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5266 +//line sql.y:5274 { yyLOCAL = &IndexHint{Type: UseVindexOp, Indexes: yyDollar[4].columnsUnion()} } yyVAL.union = yyLOCAL - case 1004: + case 1005: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *IndexHint -//line sql.y:5270 +//line sql.y:5278 { yyLOCAL = &IndexHint{Type: IgnoreVindexOp, Indexes: yyDollar[4].columnsUnion()} } yyVAL.union = yyLOCAL - case 1005: + case 1006: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5275 +//line sql.y:5283 { yyLOCAL = NoForType } yyVAL.union = yyLOCAL - case 1006: + case 1007: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5279 +//line sql.y:5287 { yyLOCAL = JoinForType } yyVAL.union = yyLOCAL - case 1007: + case 1008: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5283 +//line sql.y:5291 { yyLOCAL = OrderByForType } yyVAL.union = yyLOCAL - case 1008: + case 1009: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL IndexHintForType -//line sql.y:5287 +//line sql.y:5295 { yyLOCAL = GroupByForType } yyVAL.union = yyLOCAL - case 1009: + case 1010: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:5293 +//line sql.y:5301 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1010: + case 1011: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5297 +//line sql.y:5305 { yyLOCAL = yyDollar[2].exprUnion() } yyVAL.union = yyLOCAL - case 1011: + case 1012: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5304 +//line sql.y:5312 { yyLOCAL = &OrExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1012: + case 1013: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5308 +//line sql.y:5316 { yyLOCAL = &XorExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1013: + case 1014: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5312 +//line sql.y:5320 { yyLOCAL = &AndExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1014: + case 1015: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5316 +//line sql.y:5324 { yyLOCAL = &NotExpr{Expr: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1015: + case 1016: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5320 +//line sql.y:5328 { yyLOCAL = &IsExpr{Left: yyDollar[1].exprUnion(), Right: yyDollar[3].isExprOperatorUnion()} } yyVAL.union = yyLOCAL - case 1016: + case 1017: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5324 +//line sql.y:5332 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1017: + case 1018: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5328 +//line sql.y:5336 { yyLOCAL = &AssignmentExpr{Left: yyDollar[1].variableUnion(), Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1018: + case 1019: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5332 +//line sql.y:5340 { yyLOCAL = &MemberOfExpr{Value: yyDollar[1].exprUnion(), JSONArr: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1019: + case 1020: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5338 +//line sql.y:5346 { } - case 1020: + case 1021: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5341 +//line sql.y:5349 { } - case 1021: + case 1022: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5346 +//line sql.y:5354 { yyLOCAL = &IsExpr{Left: yyDollar[1].exprUnion(), Right: IsNullOp} } yyVAL.union = yyLOCAL - case 1022: + case 1023: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5350 +//line sql.y:5358 { yyLOCAL = &IsExpr{Left: yyDollar[1].exprUnion(), Right: IsNotNullOp} } yyVAL.union = yyLOCAL - case 1023: + case 1024: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5354 +//line sql.y:5362 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: yyDollar[2].comparisonExprOperatorUnion(), Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1024: + case 1025: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5358 +//line sql.y:5366 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: yyDollar[2].comparisonExprOperatorUnion(), Modifier: Any, Right: yyDollar[4].subqueryUnion()} } yyVAL.union = yyLOCAL - case 1025: + case 1026: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5362 +//line sql.y:5370 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: yyDollar[2].comparisonExprOperatorUnion(), Modifier: Any, Right: yyDollar[4].subqueryUnion()} } yyVAL.union = yyLOCAL - case 1026: + case 1027: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5366 +//line sql.y:5374 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: yyDollar[2].comparisonExprOperatorUnion(), Modifier: All, Right: yyDollar[4].subqueryUnion()} } yyVAL.union = yyLOCAL - case 1027: + case 1028: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5370 +//line sql.y:5378 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1028: + case 1029: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5376 +//line sql.y:5384 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: InOp, Right: yyDollar[3].colTupleUnion()} } yyVAL.union = yyLOCAL - case 1029: + case 1030: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5380 +//line sql.y:5388 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotInOp, Right: yyDollar[4].colTupleUnion()} } yyVAL.union = yyLOCAL - case 1030: + case 1031: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5384 +//line sql.y:5392 { yyLOCAL = &BetweenExpr{Left: yyDollar[1].exprUnion(), IsBetween: true, From: yyDollar[3].exprUnion(), To: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1031: + case 1032: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5388 +//line sql.y:5396 { yyLOCAL = &BetweenExpr{Left: yyDollar[1].exprUnion(), IsBetween: false, From: yyDollar[4].exprUnion(), To: yyDollar[6].exprUnion()} } yyVAL.union = yyLOCAL - case 1032: + case 1033: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5392 +//line sql.y:5400 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: LikeOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1033: + case 1034: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5396 +//line sql.y:5404 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotLikeOp, Right: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1034: + case 1035: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5400 +//line sql.y:5408 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: LikeOp, Right: yyDollar[3].exprUnion(), Escape: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1035: + case 1036: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5404 +//line sql.y:5412 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotLikeOp, Right: yyDollar[4].exprUnion(), Escape: yyDollar[6].exprUnion()} } yyVAL.union = yyLOCAL - case 1036: + case 1037: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5408 +//line sql.y:5416 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: RegexpOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1037: + case 1038: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5412 +//line sql.y:5420 { yyLOCAL = &ComparisonExpr{Left: yyDollar[1].exprUnion(), Operator: NotRegexpOp, Right: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1038: + case 1039: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5416 +//line sql.y:5424 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1039: + case 1040: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5422 +//line sql.y:5430 { } - case 1040: + case 1041: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5425 +//line sql.y:5433 { } - case 1041: + case 1042: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5431 +//line sql.y:5439 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: BitOrOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1042: + case 1043: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5435 +//line sql.y:5443 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: BitAndOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1043: + case 1044: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5439 +//line sql.y:5447 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ShiftLeftOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1044: + case 1045: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5443 +//line sql.y:5451 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ShiftRightOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1045: + case 1046: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5447 +//line sql.y:5455 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: PlusOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1046: + case 1047: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5451 +//line sql.y:5459 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: MinusOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1047: + case 1048: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5455 +//line sql.y:5463 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprBinaryAdd, Date: yyDollar[1].exprUnion(), Unit: yyDollar[5].intervalTypeUnion(), Interval: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1048: + case 1049: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5459 +//line sql.y:5467 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprBinarySub, Date: yyDollar[1].exprUnion(), Unit: yyDollar[5].intervalTypeUnion(), Interval: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1049: + case 1050: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5463 +//line sql.y:5471 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: MultOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1050: + case 1051: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5467 +//line sql.y:5475 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: DivOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1051: + case 1052: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5471 +//line sql.y:5479 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ModOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1052: + case 1053: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5475 +//line sql.y:5483 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: IntDivOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1053: + case 1054: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5479 +//line sql.y:5487 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: ModOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1054: + case 1055: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5483 +//line sql.y:5491 { yyLOCAL = &BinaryExpr{Left: yyDollar[1].exprUnion(), Operator: BitXorOp, Right: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1055: + case 1056: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5487 +//line sql.y:5495 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1056: + case 1057: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5493 +//line sql.y:5501 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1057: + case 1058: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5497 +//line sql.y:5505 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1058: + case 1059: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5501 +//line sql.y:5509 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1059: + case 1060: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5505 +//line sql.y:5513 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1060: + case 1061: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5509 +//line sql.y:5517 { yyLOCAL = &CollateExpr{Expr: yyDollar[1].exprUnion(), Collation: yyDollar[3].str} } yyVAL.union = yyLOCAL - case 1061: + case 1062: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5513 +//line sql.y:5521 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1062: + case 1063: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5517 +//line sql.y:5525 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1063: + case 1064: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5521 +//line sql.y:5529 { yyLOCAL = yyDollar[1].variableUnion() } yyVAL.union = yyLOCAL - case 1064: + case 1065: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5525 +//line sql.y:5533 { yyLOCAL = yyDollar[2].exprUnion() // TODO: do we really want to ignore unary '+' before any kind of literals? } yyVAL.union = yyLOCAL - case 1065: + case 1066: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5529 +//line sql.y:5537 { yyLOCAL = &UnaryExpr{Operator: UMinusOp, Expr: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1066: + case 1067: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5533 +//line sql.y:5541 { yyLOCAL = &UnaryExpr{Operator: TildaOp, Expr: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1067: + case 1068: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5537 +//line sql.y:5545 { yyLOCAL = &UnaryExpr{Operator: BangOp, Expr: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1068: + case 1069: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5541 +//line sql.y:5549 { yyLOCAL = yyDollar[1].subqueryUnion() } yyVAL.union = yyLOCAL - case 1069: + case 1070: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:5545 +//line sql.y:5553 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1070: + case 1071: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5549 +//line sql.y:5557 { yyLOCAL = &ExistsExpr{Subquery: yyDollar[2].subqueryUnion()} } yyVAL.union = yyLOCAL - case 1071: + case 1072: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:5553 +//line sql.y:5561 { yyLOCAL = &MatchExpr{Columns: yyDollar[2].colNamesUnion(), Expr: yyDollar[5].exprUnion(), Option: yyDollar[6].matchExprOptionUnion()} } yyVAL.union = yyLOCAL - case 1072: + case 1073: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:5557 +//line sql.y:5565 { yyLOCAL = &CastExpr{Expr: yyDollar[3].exprUnion(), Type: yyDollar[5].convertTypeUnion(), Array: yyDollar[6].booleanUnion()} } yyVAL.union = yyLOCAL - case 1073: + case 1074: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5561 +//line sql.y:5569 { yyLOCAL = &ConvertExpr{Expr: yyDollar[3].exprUnion(), Type: yyDollar[5].convertTypeUnion()} } yyVAL.union = yyLOCAL - case 1074: + case 1075: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5565 +//line sql.y:5573 { yyLOCAL = &ConvertUsingExpr{Expr: yyDollar[3].exprUnion(), Type: yyDollar[5].str} } yyVAL.union = yyLOCAL - case 1075: + case 1076: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5569 +//line sql.y:5577 { // From: https://dev.mysql.com/doc/refman/8.0/en/cast-functions.html#operator_binary // To convert a string expression to a binary string, these constructs are equivalent: @@ -18197,3218 +18251,3218 @@ yydefault: yyLOCAL = &ConvertExpr{Expr: yyDollar[2].exprUnion(), Type: &ConvertType{Type: yyDollar[1].str}} } yyVAL.union = yyLOCAL - case 1076: + case 1077: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:5577 +//line sql.y:5585 { yyLOCAL = &Default{ColName: yyDollar[2].str} } yyVAL.union = yyLOCAL - case 1077: + case 1078: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5581 +//line sql.y:5589 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprBinaryAddLeft, Date: yyDollar[5].exprUnion(), Unit: yyDollar[3].intervalTypeUnion(), Interval: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1078: + case 1079: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5585 +//line sql.y:5593 { yyLOCAL = &IntervalFuncExpr{Expr: yyDollar[3].exprUnion(), Exprs: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1079: + case 1080: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5589 +//line sql.y:5597 { yyLOCAL = &JSONExtractExpr{JSONDoc: yyDollar[1].exprUnion(), PathList: []Expr{yyDollar[3].exprUnion()}} } yyVAL.union = yyLOCAL - case 1080: + case 1081: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:5593 +//line sql.y:5601 { yyLOCAL = &JSONUnquoteExpr{JSONValue: &JSONExtractExpr{JSONDoc: yyDollar[1].exprUnion(), PathList: []Expr{yyDollar[3].exprUnion()}}} } yyVAL.union = yyLOCAL - case 1081: + case 1082: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*ColName -//line sql.y:5599 +//line sql.y:5607 { yyLOCAL = yyDollar[1].colNamesUnion() } yyVAL.union = yyLOCAL - case 1082: + case 1083: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL []*ColName -//line sql.y:5603 +//line sql.y:5611 { yyLOCAL = yyDollar[2].colNamesUnion() } yyVAL.union = yyLOCAL - case 1083: + case 1084: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*ColName -//line sql.y:5609 +//line sql.y:5617 { yyLOCAL = []*ColName{yyDollar[1].colNameUnion()} } yyVAL.union = yyLOCAL - case 1084: + case 1085: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5613 +//line sql.y:5621 { yySLICE := (*[]*ColName)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].colNameUnion()) } - case 1085: + case 1086: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TrimType -//line sql.y:5619 +//line sql.y:5627 { yyLOCAL = BothTrimType } yyVAL.union = yyLOCAL - case 1086: + case 1087: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TrimType -//line sql.y:5623 +//line sql.y:5631 { yyLOCAL = LeadingTrimType } yyVAL.union = yyLOCAL - case 1087: + case 1088: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL TrimType -//line sql.y:5627 +//line sql.y:5635 { yyLOCAL = TrailingTrimType } yyVAL.union = yyLOCAL - case 1088: + case 1089: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FrameUnitType -//line sql.y:5633 +//line sql.y:5641 { yyLOCAL = FrameRowsType } yyVAL.union = yyLOCAL - case 1089: + case 1090: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FrameUnitType -//line sql.y:5637 +//line sql.y:5645 { yyLOCAL = FrameRangeType } yyVAL.union = yyLOCAL - case 1090: + case 1091: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5644 +//line sql.y:5652 { yyLOCAL = CumeDistExprType } yyVAL.union = yyLOCAL - case 1091: + case 1092: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5648 +//line sql.y:5656 { yyLOCAL = DenseRankExprType } yyVAL.union = yyLOCAL - case 1092: + case 1093: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5652 +//line sql.y:5660 { yyLOCAL = PercentRankExprType } yyVAL.union = yyLOCAL - case 1093: + case 1094: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5656 +//line sql.y:5664 { yyLOCAL = RankExprType } yyVAL.union = yyLOCAL - case 1094: + case 1095: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ArgumentLessWindowExprType -//line sql.y:5660 +//line sql.y:5668 { yyLOCAL = RowNumberExprType } yyVAL.union = yyLOCAL - case 1095: + case 1096: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5666 +//line sql.y:5674 { yyLOCAL = &FramePoint{Type: CurrentRowType} } yyVAL.union = yyLOCAL - case 1096: + case 1097: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5670 +//line sql.y:5678 { yyLOCAL = &FramePoint{Type: UnboundedPrecedingType} } yyVAL.union = yyLOCAL - case 1097: + case 1098: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5674 +//line sql.y:5682 { yyLOCAL = &FramePoint{Type: UnboundedFollowingType} } yyVAL.union = yyLOCAL - case 1098: + case 1099: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5678 +//line sql.y:5686 { yyLOCAL = &FramePoint{Type: ExprPrecedingType, Expr: yyDollar[1].exprUnion()} } yyVAL.union = yyLOCAL - case 1099: + case 1100: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5682 +//line sql.y:5690 { yyLOCAL = &FramePoint{Type: ExprPrecedingType, Expr: yyDollar[2].exprUnion(), Unit: yyDollar[3].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1100: + case 1101: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5686 +//line sql.y:5694 { yyLOCAL = &FramePoint{Type: ExprFollowingType, Expr: yyDollar[1].exprUnion()} } yyVAL.union = yyLOCAL - case 1101: + case 1102: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *FramePoint -//line sql.y:5690 +//line sql.y:5698 { yyLOCAL = &FramePoint{Type: ExprFollowingType, Expr: yyDollar[2].exprUnion(), Unit: yyDollar[3].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1102: + case 1103: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5695 +//line sql.y:5703 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1103: + case 1104: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5699 +//line sql.y:5707 { yyLOCAL = yyDollar[1].frameClauseUnion() } yyVAL.union = yyLOCAL - case 1104: + case 1105: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5705 +//line sql.y:5713 { yyLOCAL = &FrameClause{Unit: yyDollar[1].frameUnitTypeUnion(), Start: yyDollar[2].framePointUnion()} } yyVAL.union = yyLOCAL - case 1105: + case 1106: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *FrameClause -//line sql.y:5709 +//line sql.y:5717 { yyLOCAL = &FrameClause{Unit: yyDollar[1].frameUnitTypeUnion(), Start: yyDollar[3].framePointUnion(), End: yyDollar[5].framePointUnion()} } yyVAL.union = yyLOCAL - case 1106: + case 1107: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Exprs -//line sql.y:5714 +//line sql.y:5722 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1107: + case 1108: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Exprs -//line sql.y:5718 +//line sql.y:5726 { yyLOCAL = yyDollar[3].exprsUnion() } yyVAL.union = yyLOCAL - case 1108: + case 1109: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5723 +//line sql.y:5731 { yyVAL.identifierCI = IdentifierCI{} } - case 1109: + case 1110: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5727 +//line sql.y:5735 { yyVAL.identifierCI = yyDollar[1].identifierCI } - case 1110: + case 1111: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *WindowSpecification -//line sql.y:5733 +//line sql.y:5741 { yyLOCAL = &WindowSpecification{Name: yyDollar[1].identifierCI, PartitionClause: yyDollar[2].exprsUnion(), OrderClause: yyDollar[3].orderByUnion(), FrameClause: yyDollar[4].frameClauseUnion()} } yyVAL.union = yyLOCAL - case 1111: + case 1112: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *OverClause -//line sql.y:5739 +//line sql.y:5747 { yyLOCAL = &OverClause{WindowSpec: yyDollar[3].windowSpecificationUnion()} } yyVAL.union = yyLOCAL - case 1112: + case 1113: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *OverClause -//line sql.y:5743 +//line sql.y:5751 { yyLOCAL = &OverClause{WindowName: yyDollar[2].identifierCI} } yyVAL.union = yyLOCAL - case 1113: + case 1114: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *OverClause -//line sql.y:5749 +//line sql.y:5757 { yyLOCAL = yyDollar[1].overClauseUnion() } yyVAL.union = yyLOCAL - case 1114: + case 1115: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *OverClause -//line sql.y:5753 +//line sql.y:5761 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1115: + case 1116: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *NullTreatmentClause -//line sql.y:5758 +//line sql.y:5766 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1117: + case 1118: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *NullTreatmentClause -//line sql.y:5765 +//line sql.y:5773 { yyLOCAL = &NullTreatmentClause{yyDollar[1].nullTreatmentTypeUnion()} } yyVAL.union = yyLOCAL - case 1118: + case 1119: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL NullTreatmentType -//line sql.y:5771 +//line sql.y:5779 { yyLOCAL = RespectNullsType } yyVAL.union = yyLOCAL - case 1119: + case 1120: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL NullTreatmentType -//line sql.y:5775 +//line sql.y:5783 { yyLOCAL = IgnoreNullsType } yyVAL.union = yyLOCAL - case 1120: + case 1121: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FirstOrLastValueExprType -//line sql.y:5781 +//line sql.y:5789 { yyLOCAL = FirstValueExprType } yyVAL.union = yyLOCAL - case 1121: + case 1122: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL FirstOrLastValueExprType -//line sql.y:5785 +//line sql.y:5793 { yyLOCAL = LastValueExprType } yyVAL.union = yyLOCAL - case 1122: + case 1123: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL FromFirstLastType -//line sql.y:5791 +//line sql.y:5799 { yyLOCAL = FromFirstType } yyVAL.union = yyLOCAL - case 1123: + case 1124: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL FromFirstLastType -//line sql.y:5795 +//line sql.y:5803 { yyLOCAL = FromLastType } yyVAL.union = yyLOCAL - case 1124: + case 1125: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *FromFirstLastClause -//line sql.y:5800 +//line sql.y:5808 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1126: + case 1127: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *FromFirstLastClause -//line sql.y:5807 +//line sql.y:5815 { yyLOCAL = &FromFirstLastClause{yyDollar[1].fromFirstLastTypeUnion()} } yyVAL.union = yyLOCAL - case 1127: + case 1128: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL LagLeadExprType -//line sql.y:5813 +//line sql.y:5821 { yyLOCAL = LagExprType } yyVAL.union = yyLOCAL - case 1128: + case 1129: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL LagLeadExprType -//line sql.y:5817 +//line sql.y:5825 { yyLOCAL = LeadExprType } yyVAL.union = yyLOCAL - case 1129: + case 1130: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *WindowDefinition -//line sql.y:5823 +//line sql.y:5831 { yyLOCAL = &WindowDefinition{Name: yyDollar[1].identifierCI, WindowSpec: yyDollar[4].windowSpecificationUnion()} } yyVAL.union = yyLOCAL - case 1130: + case 1131: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL WindowDefinitions -//line sql.y:5829 +//line sql.y:5837 { yyLOCAL = WindowDefinitions{yyDollar[1].windowDefinitionUnion()} } yyVAL.union = yyLOCAL - case 1131: + case 1132: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5833 +//line sql.y:5841 { yySLICE := (*WindowDefinitions)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].windowDefinitionUnion()) } - case 1132: + case 1133: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:5839 +//line sql.y:5847 { yyVAL.str = "" } - case 1133: + case 1134: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5843 +//line sql.y:5851 { yyVAL.str = string(yyDollar[2].identifierCI.String()) } - case 1134: + case 1135: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL BoolVal -//line sql.y:5849 +//line sql.y:5857 { yyLOCAL = BoolVal(true) } yyVAL.union = yyLOCAL - case 1135: + case 1136: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL BoolVal -//line sql.y:5853 +//line sql.y:5861 { yyLOCAL = BoolVal(false) } yyVAL.union = yyLOCAL - case 1136: + case 1137: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5860 +//line sql.y:5868 { yyLOCAL = IsTrueOp } yyVAL.union = yyLOCAL - case 1137: + case 1138: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5864 +//line sql.y:5872 { yyLOCAL = IsNotTrueOp } yyVAL.union = yyLOCAL - case 1138: + case 1139: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5868 +//line sql.y:5876 { yyLOCAL = IsFalseOp } yyVAL.union = yyLOCAL - case 1139: + case 1140: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL IsExprOperator -//line sql.y:5872 +//line sql.y:5880 { yyLOCAL = IsNotFalseOp } yyVAL.union = yyLOCAL - case 1140: + case 1141: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5878 +//line sql.y:5886 { yyLOCAL = yyDollar[1].comparisonExprOperatorUnion() } yyVAL.union = yyLOCAL - case 1141: + case 1142: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5882 +//line sql.y:5890 { yyLOCAL = NullSafeEqualOp } yyVAL.union = yyLOCAL - case 1142: + case 1143: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5888 +//line sql.y:5896 { yyLOCAL = EqualOp } yyVAL.union = yyLOCAL - case 1143: + case 1144: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5892 +//line sql.y:5900 { yyLOCAL = LessThanOp } yyVAL.union = yyLOCAL - case 1144: + case 1145: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5896 +//line sql.y:5904 { yyLOCAL = GreaterThanOp } yyVAL.union = yyLOCAL - case 1145: + case 1146: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5900 +//line sql.y:5908 { yyLOCAL = LessEqualOp } yyVAL.union = yyLOCAL - case 1146: + case 1147: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5904 +//line sql.y:5912 { yyLOCAL = GreaterEqualOp } yyVAL.union = yyLOCAL - case 1147: + case 1148: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ComparisonExprOperator -//line sql.y:5908 +//line sql.y:5916 { yyLOCAL = NotEqualOp } yyVAL.union = yyLOCAL - case 1148: + case 1149: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColTuple -//line sql.y:5914 +//line sql.y:5922 { yyLOCAL = yyDollar[1].valTupleUnion() } yyVAL.union = yyLOCAL - case 1149: + case 1150: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColTuple -//line sql.y:5918 +//line sql.y:5926 { yyLOCAL = yyDollar[1].subqueryUnion() } yyVAL.union = yyLOCAL - case 1150: + case 1151: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ColTuple -//line sql.y:5922 +//line sql.y:5930 { yyLOCAL = ListArg(yyDollar[1].str[2:]) markBindVariable(yylex, yyDollar[1].str[2:]) } yyVAL.union = yyLOCAL - case 1151: + case 1152: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Subquery -//line sql.y:5929 +//line sql.y:5937 { yyLOCAL = &Subquery{yyDollar[1].selStmtUnion()} } yyVAL.union = yyLOCAL - case 1152: + case 1153: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Exprs -//line sql.y:5935 +//line sql.y:5943 { yyLOCAL = Exprs{yyDollar[1].exprUnion()} } yyVAL.union = yyLOCAL - case 1153: + case 1154: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5939 +//line sql.y:5947 { yySLICE := (*Exprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].exprUnion()) } - case 1154: + case 1155: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5949 +//line sql.y:5957 { yyLOCAL = &FuncExpr{Name: yyDollar[1].identifierCI, Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1155: + case 1156: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5953 +//line sql.y:5961 { yyLOCAL = &FuncExpr{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCI, Exprs: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1156: + case 1157: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5963 +//line sql.y:5971 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("left"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1157: + case 1158: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5967 +//line sql.y:5975 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("right"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1158: + case 1159: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:5971 +//line sql.y:5979 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion(), To: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1159: + case 1160: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:5975 +//line sql.y:5983 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion(), To: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1160: + case 1161: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5979 +//line sql.y:5987 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1161: + case 1162: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:5983 +//line sql.y:5991 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion(), To: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1162: + case 1163: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:5987 +//line sql.y:5995 { yyLOCAL = &SubstrExpr{Name: yyDollar[3].exprUnion(), From: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1163: + case 1164: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:5991 +//line sql.y:5999 { yyLOCAL = &CaseExpr{Expr: yyDollar[2].exprUnion(), Whens: yyDollar[3].whensUnion(), Else: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1164: + case 1165: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:5995 +//line sql.y:6003 { yyLOCAL = &ValuesFuncExpr{Name: yyDollar[3].colNameUnion()} } yyVAL.union = yyLOCAL - case 1165: + case 1166: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:5999 +//line sql.y:6007 { yyLOCAL = &InsertExpr{Str: yyDollar[3].exprUnion(), Pos: yyDollar[5].exprUnion(), Len: yyDollar[7].exprUnion(), NewStr: yyDollar[9].exprUnion()} } yyVAL.union = yyLOCAL - case 1166: + case 1167: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:6003 +//line sql.y:6011 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1167: + case 1168: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:6014 +//line sql.y:6022 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("utc_date")} } yyVAL.union = yyLOCAL - case 1168: + case 1169: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6018 +//line sql.y:6026 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1169: + case 1170: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:6024 +//line sql.y:6032 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("current_date")} } yyVAL.union = yyLOCAL - case 1170: + case 1171: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:6028 +//line sql.y:6036 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("curdate")} } yyVAL.union = yyLOCAL - case 1171: + case 1172: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:6032 +//line sql.y:6040 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("utc_time"), Fsp: yyDollar[2].integerUnion()} } yyVAL.union = yyLOCAL - case 1172: + case 1173: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:6037 +//line sql.y:6045 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("curtime"), Fsp: yyDollar[2].integerUnion()} } yyVAL.union = yyLOCAL - case 1173: + case 1174: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:6042 +//line sql.y:6050 { yyLOCAL = &CurTimeFuncExpr{Name: NewIdentifierCI("current_time"), Fsp: yyDollar[2].integerUnion()} } yyVAL.union = yyLOCAL - case 1174: + case 1175: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6046 +//line sql.y:6054 { yyLOCAL = &CountStar{OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1175: + case 1176: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6050 +//line sql.y:6058 { yyLOCAL = &Count{Distinct: yyDollar[3].booleanUnion(), Args: yyDollar[4].exprsUnion(), OverClause: yyDollar[6].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1176: + case 1177: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6054 +//line sql.y:6062 { yyLOCAL = &Max{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion(), OverClause: yyDollar[6].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1177: + case 1178: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6058 +//line sql.y:6066 { yyLOCAL = &Min{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion(), OverClause: yyDollar[6].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1178: + case 1179: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6062 +//line sql.y:6070 { yyLOCAL = &Sum{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion(), OverClause: yyDollar[6].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1179: + case 1180: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6066 +//line sql.y:6074 { yyLOCAL = &Avg{Distinct: yyDollar[3].booleanUnion(), Arg: yyDollar[4].exprUnion(), OverClause: yyDollar[6].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1180: + case 1181: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6070 +//line sql.y:6078 { yyLOCAL = &BitAnd{Arg: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1181: + case 1182: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6074 +//line sql.y:6082 { yyLOCAL = &BitOr{Arg: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1182: + case 1183: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6078 +//line sql.y:6086 { yyLOCAL = &BitXor{Arg: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1183: + case 1184: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6082 +//line sql.y:6090 { yyLOCAL = &Std{Arg: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1184: + case 1185: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6086 +//line sql.y:6094 { yyLOCAL = &StdDev{Arg: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1185: + case 1186: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6090 +//line sql.y:6098 { yyLOCAL = &StdPop{Arg: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1186: + case 1187: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6094 +//line sql.y:6102 { yyLOCAL = &StdSamp{Arg: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1187: + case 1188: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6098 +//line sql.y:6106 { yyLOCAL = &VarPop{Arg: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1188: + case 1189: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6102 +//line sql.y:6110 { yyLOCAL = &VarSamp{Arg: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1189: + case 1190: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6106 +//line sql.y:6114 { yyLOCAL = &Variance{Arg: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1190: + case 1191: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6110 +//line sql.y:6118 { yyLOCAL = &GroupConcatExpr{Distinct: yyDollar[3].booleanUnion(), Exprs: yyDollar[4].exprsUnion(), OrderBy: yyDollar[5].orderByUnion(), Separator: yyDollar[6].str, Limit: yyDollar[7].limitUnion()} } yyVAL.union = yyLOCAL - case 1191: + case 1192: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6114 +//line sql.y:6122 { yyLOCAL = &AnyValue{Arg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1192: + case 1193: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6118 +//line sql.y:6126 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprTimestampadd, Date: yyDollar[7].exprUnion(), Interval: yyDollar[5].exprUnion(), Unit: yyDollar[3].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1193: + case 1194: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6122 +//line sql.y:6130 { yyLOCAL = &TimestampDiffExpr{Unit: yyDollar[3].intervalTypeUnion(), Expr1: yyDollar[5].exprUnion(), Expr2: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1194: + case 1195: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6126 +//line sql.y:6134 { yyLOCAL = &ExtractFuncExpr{IntervalType: yyDollar[3].intervalTypeUnion(), Expr: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1195: + case 1196: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6130 +//line sql.y:6138 { yyLOCAL = &WeightStringFuncExpr{Expr: yyDollar[3].exprUnion(), As: yyDollar[4].convertTypeUnion()} } yyVAL.union = yyLOCAL - case 1196: + case 1197: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6134 +//line sql.y:6142 { yyLOCAL = &JSONPrettyExpr{JSONVal: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1197: + case 1198: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6138 +//line sql.y:6146 { yyLOCAL = &JSONStorageFreeExpr{JSONVal: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1198: + case 1199: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6142 +//line sql.y:6150 { yyLOCAL = &JSONStorageSizeExpr{JSONVal: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1199: + case 1200: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6146 +//line sql.y:6154 { yyLOCAL = &JSONArrayAgg{Expr: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1200: + case 1201: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:6150 +//line sql.y:6158 { yyLOCAL = &JSONObjectAgg{Key: yyDollar[3].exprUnion(), Value: yyDollar[5].exprUnion(), OverClause: yyDollar[7].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1201: + case 1202: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6154 +//line sql.y:6162 { yyLOCAL = &TrimFuncExpr{TrimFuncType: LTrimType, Type: LeadingTrimType, StringArg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1202: + case 1203: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6158 +//line sql.y:6166 { yyLOCAL = &TrimFuncExpr{TrimFuncType: RTrimType, Type: TrailingTrimType, StringArg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1203: + case 1204: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:6162 +//line sql.y:6170 { yyLOCAL = &TrimFuncExpr{Type: yyDollar[3].trimTypeUnion(), TrimArg: yyDollar[4].exprUnion(), StringArg: yyDollar[6].exprUnion()} } yyVAL.union = yyLOCAL - case 1204: + case 1205: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6166 +//line sql.y:6174 { yyLOCAL = &TrimFuncExpr{StringArg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1205: + case 1206: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6170 +//line sql.y:6178 { yyLOCAL = &CharExpr{Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1206: + case 1207: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6174 +//line sql.y:6182 { yyLOCAL = &CharExpr{Exprs: yyDollar[3].exprsUnion(), Charset: yyDollar[5].str} } yyVAL.union = yyLOCAL - case 1207: + case 1208: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6178 +//line sql.y:6186 { yyLOCAL = &TrimFuncExpr{TrimArg: yyDollar[3].exprUnion(), StringArg: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1208: + case 1209: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6182 +//line sql.y:6190 { yyLOCAL = &LocateExpr{SubStr: yyDollar[3].exprUnion(), Str: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1209: + case 1210: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6186 +//line sql.y:6194 { yyLOCAL = &LocateExpr{SubStr: yyDollar[3].exprUnion(), Str: yyDollar[5].exprUnion(), Pos: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1210: + case 1211: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6190 +//line sql.y:6198 { yyLOCAL = &LocateExpr{SubStr: yyDollar[3].exprUnion(), Str: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1211: + case 1212: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6194 +//line sql.y:6202 { yyLOCAL = &LockingFunc{Type: GetLock, Name: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1212: + case 1213: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6198 +//line sql.y:6206 { yyLOCAL = &LockingFunc{Type: IsFreeLock, Name: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1213: + case 1214: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6202 +//line sql.y:6210 { yyLOCAL = &LockingFunc{Type: IsUsedLock, Name: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1214: + case 1215: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:6206 +//line sql.y:6214 { yyLOCAL = &LockingFunc{Type: ReleaseAllLocks} } yyVAL.union = yyLOCAL - case 1215: + case 1216: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6210 +//line sql.y:6218 { yyLOCAL = &LockingFunc{Type: ReleaseLock, Name: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1216: + case 1217: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6214 +//line sql.y:6222 { yyLOCAL = &JSONSchemaValidFuncExpr{Schema: yyDollar[3].exprUnion(), Document: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1217: + case 1218: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6218 +//line sql.y:6226 { yyLOCAL = &JSONSchemaValidationReportFuncExpr{Schema: yyDollar[3].exprUnion(), Document: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1218: + case 1219: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6222 +//line sql.y:6230 { yyLOCAL = &JSONArrayExpr{Params: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1219: + case 1220: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6226 +//line sql.y:6234 { yyLOCAL = &GeomFormatExpr{FormatType: BinaryFormat, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1220: + case 1221: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6230 +//line sql.y:6238 { yyLOCAL = &GeomFormatExpr{FormatType: BinaryFormat, Geom: yyDollar[3].exprUnion(), AxisOrderOpt: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1221: + case 1222: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6234 +//line sql.y:6242 { yyLOCAL = &GeomFormatExpr{FormatType: TextFormat, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1222: + case 1223: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6238 +//line sql.y:6246 { yyLOCAL = &GeomFormatExpr{FormatType: TextFormat, Geom: yyDollar[3].exprUnion(), AxisOrderOpt: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1223: + case 1224: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6242 +//line sql.y:6250 { yyLOCAL = &GeomPropertyFuncExpr{Property: IsEmpty, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1224: + case 1225: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6246 +//line sql.y:6254 { yyLOCAL = &GeomPropertyFuncExpr{Property: IsSimple, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1225: + case 1226: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6250 +//line sql.y:6258 { yyLOCAL = &GeomPropertyFuncExpr{Property: Dimension, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1226: + case 1227: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6254 +//line sql.y:6262 { yyLOCAL = &GeomPropertyFuncExpr{Property: Envelope, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1227: + case 1228: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6258 +//line sql.y:6266 { yyLOCAL = &GeomPropertyFuncExpr{Property: GeometryType, Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1228: + case 1229: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6262 +//line sql.y:6270 { yyLOCAL = &PointPropertyFuncExpr{Property: Latitude, Point: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1229: + case 1230: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6266 +//line sql.y:6274 { yyLOCAL = &PointPropertyFuncExpr{Property: Latitude, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1230: + case 1231: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6270 +//line sql.y:6278 { yyLOCAL = &PointPropertyFuncExpr{Property: Longitude, Point: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1231: + case 1232: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6274 +//line sql.y:6282 { yyLOCAL = &PointPropertyFuncExpr{Property: Longitude, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1232: + case 1233: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6278 +//line sql.y:6286 { yyLOCAL = &LinestrPropertyFuncExpr{Property: EndPoint, Linestring: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1233: + case 1234: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6282 +//line sql.y:6290 { yyLOCAL = &LinestrPropertyFuncExpr{Property: IsClosed, Linestring: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1234: + case 1235: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6286 +//line sql.y:6294 { yyLOCAL = &LinestrPropertyFuncExpr{Property: Length, Linestring: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1235: + case 1236: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6290 +//line sql.y:6298 { yyLOCAL = &LinestrPropertyFuncExpr{Property: Length, Linestring: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1236: + case 1237: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6294 +//line sql.y:6302 { yyLOCAL = &LinestrPropertyFuncExpr{Property: NumPoints, Linestring: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1237: + case 1238: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6298 +//line sql.y:6306 { yyLOCAL = &LinestrPropertyFuncExpr{Property: PointN, Linestring: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1238: + case 1239: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6302 +//line sql.y:6310 { yyLOCAL = &LinestrPropertyFuncExpr{Property: StartPoint, Linestring: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1239: + case 1240: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6306 +//line sql.y:6314 { yyLOCAL = &PointPropertyFuncExpr{Property: XCordinate, Point: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1240: + case 1241: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6310 +//line sql.y:6318 { yyLOCAL = &PointPropertyFuncExpr{Property: XCordinate, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1241: + case 1242: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6314 +//line sql.y:6322 { yyLOCAL = &PointPropertyFuncExpr{Property: YCordinate, Point: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1242: + case 1243: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6318 +//line sql.y:6326 { yyLOCAL = &PointPropertyFuncExpr{Property: YCordinate, Point: yyDollar[3].exprUnion(), ValueToSet: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1243: + case 1244: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6322 +//line sql.y:6330 { yyLOCAL = &GeomFromTextExpr{Type: GeometryFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1244: + case 1245: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6326 +//line sql.y:6334 { yyLOCAL = &GeomFromTextExpr{Type: GeometryFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1245: + case 1246: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6330 +//line sql.y:6338 { yyLOCAL = &GeomFromTextExpr{Type: GeometryFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1246: + case 1247: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6334 +//line sql.y:6342 { yyLOCAL = &GeomFromTextExpr{Type: GeometryCollectionFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1247: + case 1248: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6338 +//line sql.y:6346 { yyLOCAL = &GeomFromTextExpr{Type: GeometryCollectionFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1248: + case 1249: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6342 +//line sql.y:6350 { yyLOCAL = &GeomFromTextExpr{Type: GeometryCollectionFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1249: + case 1250: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6346 +//line sql.y:6354 { yyLOCAL = &GeomFromTextExpr{Type: LineStringFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1250: + case 1251: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6350 +//line sql.y:6358 { yyLOCAL = &GeomFromTextExpr{Type: LineStringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1251: + case 1252: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6354 +//line sql.y:6362 { yyLOCAL = &GeomFromTextExpr{Type: LineStringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1252: + case 1253: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6358 +//line sql.y:6366 { yyLOCAL = &GeomFromTextExpr{Type: MultiLinestringFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1253: + case 1254: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6362 +//line sql.y:6370 { yyLOCAL = &GeomFromTextExpr{Type: MultiLinestringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1254: + case 1255: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6366 +//line sql.y:6374 { yyLOCAL = &GeomFromTextExpr{Type: MultiLinestringFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1255: + case 1256: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6370 +//line sql.y:6378 { yyLOCAL = &GeomFromTextExpr{Type: MultiPointFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1256: + case 1257: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6374 +//line sql.y:6382 { yyLOCAL = &GeomFromTextExpr{Type: MultiPointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1257: + case 1258: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6378 +//line sql.y:6386 { yyLOCAL = &GeomFromTextExpr{Type: MultiPointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1258: + case 1259: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6382 +//line sql.y:6390 { yyLOCAL = &GeomFromTextExpr{Type: MultiPolygonFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1259: + case 1260: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6386 +//line sql.y:6394 { yyLOCAL = &GeomFromTextExpr{Type: MultiPolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1260: + case 1261: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6390 +//line sql.y:6398 { yyLOCAL = &GeomFromTextExpr{Type: MultiPolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1261: + case 1262: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6394 +//line sql.y:6402 { yyLOCAL = &GeomFromTextExpr{Type: PointFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1262: + case 1263: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6398 +//line sql.y:6406 { yyLOCAL = &GeomFromTextExpr{Type: PointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1263: + case 1264: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6402 +//line sql.y:6410 { yyLOCAL = &GeomFromTextExpr{Type: PointFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1264: + case 1265: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6406 +//line sql.y:6414 { yyLOCAL = &GeomFromTextExpr{Type: PolygonFromText, WktText: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1265: + case 1266: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6410 +//line sql.y:6418 { yyLOCAL = &GeomFromTextExpr{Type: PolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1266: + case 1267: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6414 +//line sql.y:6422 { yyLOCAL = &GeomFromTextExpr{Type: PolygonFromText, WktText: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1267: + case 1268: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6418 +//line sql.y:6426 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1268: + case 1269: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6422 +//line sql.y:6430 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1269: + case 1270: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6426 +//line sql.y:6434 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1270: + case 1271: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6430 +//line sql.y:6438 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryCollectionFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1271: + case 1272: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6434 +//line sql.y:6442 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryCollectionFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1272: + case 1273: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6438 +//line sql.y:6446 { yyLOCAL = &GeomFromWKBExpr{Type: GeometryCollectionFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1273: + case 1274: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6442 +//line sql.y:6450 { yyLOCAL = &GeomFromWKBExpr{Type: LineStringFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1274: + case 1275: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6446 +//line sql.y:6454 { yyLOCAL = &GeomFromWKBExpr{Type: LineStringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1275: + case 1276: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6450 +//line sql.y:6458 { yyLOCAL = &GeomFromWKBExpr{Type: LineStringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1276: + case 1277: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6454 +//line sql.y:6462 { yyLOCAL = &GeomFromWKBExpr{Type: MultiLinestringFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1277: + case 1278: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6458 +//line sql.y:6466 { yyLOCAL = &GeomFromWKBExpr{Type: MultiLinestringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1278: + case 1279: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6462 +//line sql.y:6470 { yyLOCAL = &GeomFromWKBExpr{Type: MultiLinestringFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1279: + case 1280: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6466 +//line sql.y:6474 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPointFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1280: + case 1281: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6470 +//line sql.y:6478 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1281: + case 1282: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6474 +//line sql.y:6482 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1282: + case 1283: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6478 +//line sql.y:6486 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPolygonFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1283: + case 1284: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6482 +//line sql.y:6490 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1284: + case 1285: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6486 +//line sql.y:6494 { yyLOCAL = &GeomFromWKBExpr{Type: MultiPolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1285: + case 1286: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6490 +//line sql.y:6498 { yyLOCAL = &GeomFromWKBExpr{Type: PointFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1286: + case 1287: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6494 +//line sql.y:6502 { yyLOCAL = &GeomFromWKBExpr{Type: PointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1287: + case 1288: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6498 +//line sql.y:6506 { yyLOCAL = &GeomFromWKBExpr{Type: PointFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1288: + case 1289: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6502 +//line sql.y:6510 { yyLOCAL = &GeomFromWKBExpr{Type: PolygonFromWKB, WkbBlob: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1289: + case 1290: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6506 +//line sql.y:6514 { yyLOCAL = &GeomFromWKBExpr{Type: PolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1290: + case 1291: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6510 +//line sql.y:6518 { yyLOCAL = &GeomFromWKBExpr{Type: PolygonFromWKB, WkbBlob: yyDollar[3].exprUnion(), Srid: yyDollar[5].exprUnion(), AxisOrderOpt: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1291: + case 1292: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6514 +//line sql.y:6522 { yyLOCAL = &PolygonPropertyFuncExpr{Property: Area, Polygon: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1292: + case 1293: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6518 +//line sql.y:6526 { yyLOCAL = &PolygonPropertyFuncExpr{Property: Centroid, Polygon: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1293: + case 1294: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6522 +//line sql.y:6530 { yyLOCAL = &PolygonPropertyFuncExpr{Property: ExteriorRing, Polygon: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1294: + case 1295: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6526 +//line sql.y:6534 { yyLOCAL = &PolygonPropertyFuncExpr{Property: InteriorRingN, Polygon: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1295: + case 1296: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6530 +//line sql.y:6538 { yyLOCAL = &PolygonPropertyFuncExpr{Property: NumInteriorRings, Polygon: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1296: + case 1297: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6534 +//line sql.y:6542 { yyLOCAL = &GeomCollPropertyFuncExpr{Property: GeometryN, GeomColl: yyDollar[3].exprUnion(), PropertyDefArg: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1297: + case 1298: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6538 +//line sql.y:6546 { yyLOCAL = &GeomCollPropertyFuncExpr{Property: NumGeometries, GeomColl: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1298: + case 1299: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6542 +//line sql.y:6550 { yyLOCAL = &GeoHashFromLatLongExpr{Longitude: yyDollar[3].exprUnion(), Latitude: yyDollar[5].exprUnion(), MaxLength: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1299: + case 1300: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6546 +//line sql.y:6554 { yyLOCAL = &GeoHashFromPointExpr{Point: yyDollar[3].exprUnion(), MaxLength: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1300: + case 1301: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6550 +//line sql.y:6558 { yyLOCAL = &GeomFromGeoHashExpr{GeomType: LatitudeFromHash, GeoHash: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1301: + case 1302: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6554 +//line sql.y:6562 { yyLOCAL = &GeomFromGeoHashExpr{GeomType: LongitudeFromHash, GeoHash: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1302: + case 1303: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6558 +//line sql.y:6566 { yyLOCAL = &GeomFromGeoHashExpr{GeomType: PointFromHash, GeoHash: yyDollar[3].exprUnion(), SridOpt: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1303: + case 1304: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6562 +//line sql.y:6570 { yyLOCAL = &GeomFromGeoJSONExpr{GeoJSON: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1304: + case 1305: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6566 +//line sql.y:6574 { yyLOCAL = &GeomFromGeoJSONExpr{GeoJSON: yyDollar[3].exprUnion(), HigherDimHandlerOpt: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1305: + case 1306: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6570 +//line sql.y:6578 { yyLOCAL = &GeomFromGeoJSONExpr{GeoJSON: yyDollar[3].exprUnion(), HigherDimHandlerOpt: yyDollar[5].exprUnion(), Srid: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1306: + case 1307: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6574 +//line sql.y:6582 { yyLOCAL = &GeoJSONFromGeomExpr{Geom: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1307: + case 1308: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6578 +//line sql.y:6586 { yyLOCAL = &GeoJSONFromGeomExpr{Geom: yyDollar[3].exprUnion(), MaxDecimalDigits: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1308: + case 1309: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6582 +//line sql.y:6590 { yyLOCAL = &GeoJSONFromGeomExpr{Geom: yyDollar[3].exprUnion(), MaxDecimalDigits: yyDollar[5].exprUnion(), Bitmask: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1309: + case 1310: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6586 +//line sql.y:6594 { yyLOCAL = &JSONObjectExpr{Params: yyDollar[3].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1310: + case 1311: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6590 +//line sql.y:6598 { yyLOCAL = &JSONQuoteExpr{StringArg: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1311: + case 1312: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6594 +//line sql.y:6602 { yyLOCAL = &JSONContainsExpr{Target: yyDollar[3].exprUnion(), Candidate: yyDollar[5].exprsUnion()[0], PathList: yyDollar[5].exprsUnion()[1:]} } yyVAL.union = yyLOCAL - case 1312: + case 1313: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6598 +//line sql.y:6606 { yyLOCAL = &JSONContainsPathExpr{JSONDoc: yyDollar[3].exprUnion(), OneOrAll: yyDollar[5].exprUnion(), PathList: yyDollar[7].exprsUnion()} } yyVAL.union = yyLOCAL - case 1313: + case 1314: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6602 +//line sql.y:6610 { yyLOCAL = &JSONExtractExpr{JSONDoc: yyDollar[3].exprUnion(), PathList: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1314: + case 1315: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6606 +//line sql.y:6614 { yyLOCAL = &JSONKeysExpr{JSONDoc: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1315: + case 1316: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6610 +//line sql.y:6618 { yyLOCAL = &JSONKeysExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1316: + case 1317: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6614 +//line sql.y:6622 { yyLOCAL = &JSONOverlapsExpr{JSONDoc1: yyDollar[3].exprUnion(), JSONDoc2: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1317: + case 1318: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6618 +//line sql.y:6626 { yyLOCAL = &JSONSearchExpr{JSONDoc: yyDollar[3].exprUnion(), OneOrAll: yyDollar[5].exprUnion(), SearchStr: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1318: + case 1319: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6622 +//line sql.y:6630 { yyLOCAL = &JSONSearchExpr{JSONDoc: yyDollar[3].exprUnion(), OneOrAll: yyDollar[5].exprUnion(), SearchStr: yyDollar[7].exprUnion(), EscapeChar: yyDollar[9].exprsUnion()[0], PathList: yyDollar[9].exprsUnion()[1:]} } yyVAL.union = yyLOCAL - case 1319: + case 1320: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL Expr -//line sql.y:6626 +//line sql.y:6634 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion()} } yyVAL.union = yyLOCAL - case 1320: + case 1321: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6630 +//line sql.y:6638 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion(), EmptyOnResponse: yyDollar[7].jtOnResponseUnion()} } yyVAL.union = yyLOCAL - case 1321: + case 1322: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6634 +//line sql.y:6642 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion(), ErrorOnResponse: yyDollar[7].jtOnResponseUnion()} } yyVAL.union = yyLOCAL - case 1322: + case 1323: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL Expr -//line sql.y:6638 +//line sql.y:6646 { yyLOCAL = &JSONValueExpr{JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion(), ReturningType: yyDollar[6].convertTypeUnion(), EmptyOnResponse: yyDollar[7].jtOnResponseUnion(), ErrorOnResponse: yyDollar[8].jtOnResponseUnion()} } yyVAL.union = yyLOCAL - case 1323: + case 1324: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6642 +//line sql.y:6650 { yyLOCAL = &JSONAttributesExpr{Type: DepthAttributeType, JSONDoc: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1324: + case 1325: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6646 +//line sql.y:6654 { yyLOCAL = &JSONAttributesExpr{Type: ValidAttributeType, JSONDoc: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1325: + case 1326: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6650 +//line sql.y:6658 { yyLOCAL = &JSONAttributesExpr{Type: TypeAttributeType, JSONDoc: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1326: + case 1327: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6654 +//line sql.y:6662 { yyLOCAL = &JSONAttributesExpr{Type: LengthAttributeType, JSONDoc: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1327: + case 1328: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6658 +//line sql.y:6666 { yyLOCAL = &JSONAttributesExpr{Type: LengthAttributeType, JSONDoc: yyDollar[3].exprUnion(), Path: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1328: + case 1329: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6662 +//line sql.y:6670 { yyLOCAL = &JSONValueModifierExpr{Type: JSONArrayAppendType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1329: + case 1330: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6666 +//line sql.y:6674 { yyLOCAL = &JSONValueModifierExpr{Type: JSONArrayInsertType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1330: + case 1331: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6670 +//line sql.y:6678 { yyLOCAL = &JSONValueModifierExpr{Type: JSONInsertType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1331: + case 1332: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6674 +//line sql.y:6682 { yyLOCAL = &JSONValueModifierExpr{Type: JSONReplaceType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1332: + case 1333: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6678 +//line sql.y:6686 { yyLOCAL = &JSONValueModifierExpr{Type: JSONSetType, JSONDoc: yyDollar[3].exprUnion(), Params: yyDollar[5].jsonObjectParamsUnion()} } yyVAL.union = yyLOCAL - case 1333: + case 1334: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6682 +//line sql.y:6690 { yyLOCAL = &JSONValueMergeExpr{Type: JSONMergeType, JSONDoc: yyDollar[3].exprUnion(), JSONDocList: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1334: + case 1335: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6686 +//line sql.y:6694 { yyLOCAL = &JSONValueMergeExpr{Type: JSONMergePatchType, JSONDoc: yyDollar[3].exprUnion(), JSONDocList: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1335: + case 1336: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6690 +//line sql.y:6698 { yyLOCAL = &JSONValueMergeExpr{Type: JSONMergePreserveType, JSONDoc: yyDollar[3].exprUnion(), JSONDocList: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1336: + case 1337: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6694 +//line sql.y:6702 { yyLOCAL = &JSONRemoveExpr{JSONDoc: yyDollar[3].exprUnion(), PathList: yyDollar[5].exprsUnion()} } yyVAL.union = yyLOCAL - case 1337: + case 1338: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6698 +//line sql.y:6706 { yyLOCAL = &JSONUnquoteExpr{JSONValue: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1338: + case 1339: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6702 +//line sql.y:6710 { yyLOCAL = &MultiPolygonExpr{PolygonParams: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1339: + case 1340: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6706 +//line sql.y:6714 { yyLOCAL = &MultiPointExpr{PointParams: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1340: + case 1341: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6710 +//line sql.y:6718 { yyLOCAL = &MultiLinestringExpr{LinestringParams: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1341: + case 1342: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6714 +//line sql.y:6722 { yyLOCAL = &PolygonExpr{LinestringParams: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1342: + case 1343: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6718 +//line sql.y:6726 { yyLOCAL = &LineStringExpr{PointParams: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1343: + case 1344: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6722 +//line sql.y:6730 { yyLOCAL = &PointExpr{XCordinate: yyDollar[3].exprUnion(), YCordinate: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1344: + case 1345: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6726 +//line sql.y:6734 { yyLOCAL = &ArgumentLessWindowExpr{Type: yyDollar[1].argumentLessWindowExprTypeUnion(), OverClause: yyDollar[4].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1345: + case 1346: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6730 +//line sql.y:6738 { yyLOCAL = &FirstOrLastValueExpr{Type: yyDollar[1].firstOrLastValueExprTypeUnion(), Expr: yyDollar[3].exprUnion(), NullTreatmentClause: yyDollar[5].nullTreatmentClauseUnion(), OverClause: yyDollar[6].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1346: + case 1347: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Expr -//line sql.y:6734 +//line sql.y:6742 { yyLOCAL = &NtileExpr{N: yyDollar[3].exprUnion(), OverClause: yyDollar[5].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1347: + case 1348: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL Expr -//line sql.y:6738 +//line sql.y:6746 { yyLOCAL = &NTHValueExpr{Expr: yyDollar[3].exprUnion(), N: yyDollar[5].exprUnion(), FromFirstLastClause: yyDollar[7].fromFirstLastClauseUnion(), NullTreatmentClause: yyDollar[8].nullTreatmentClauseUnion(), OverClause: yyDollar[9].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1348: + case 1349: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6742 +//line sql.y:6750 { yyLOCAL = &LagLeadExpr{Type: yyDollar[1].lagLeadExprTypeUnion(), Expr: yyDollar[3].exprUnion(), NullTreatmentClause: yyDollar[5].nullTreatmentClauseUnion(), OverClause: yyDollar[6].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1349: + case 1350: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL Expr -//line sql.y:6746 +//line sql.y:6754 { yyLOCAL = &LagLeadExpr{Type: yyDollar[1].lagLeadExprTypeUnion(), Expr: yyDollar[3].exprUnion(), N: yyDollar[5].exprUnion(), Default: yyDollar[6].exprUnion(), NullTreatmentClause: yyDollar[8].nullTreatmentClauseUnion(), OverClause: yyDollar[9].overClauseUnion()} } yyVAL.union = yyLOCAL - case 1350: + case 1351: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6750 +//line sql.y:6758 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprAdddate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1351: + case 1352: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6754 +//line sql.y:6762 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprAdddate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[5].exprUnion(), Unit: IntervalNone} } yyVAL.union = yyLOCAL - case 1352: + case 1353: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6758 +//line sql.y:6766 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprDateAdd, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1353: + case 1354: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6762 +//line sql.y:6770 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprDateSub, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1354: + case 1355: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6766 +//line sql.y:6774 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprSubdate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[6].exprUnion(), Unit: yyDollar[7].intervalTypeUnion()} } yyVAL.union = yyLOCAL - case 1355: + case 1356: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6770 +//line sql.y:6778 { yyLOCAL = &IntervalDateExpr{Syntax: IntervalDateExprSubdate, Date: yyDollar[3].exprUnion(), Interval: yyDollar[5].exprUnion(), Unit: IntervalNone} } yyVAL.union = yyLOCAL - case 1360: + case 1361: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6780 +//line sql.y:6788 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1361: + case 1362: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6784 +//line sql.y:6792 { yyLOCAL = NewIntLiteral(yyDollar[1].str) } yyVAL.union = yyLOCAL - case 1362: + case 1363: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6788 +//line sql.y:6796 { yyLOCAL = yyDollar[1].variableUnion() } yyVAL.union = yyLOCAL - case 1363: + case 1364: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:6792 +//line sql.y:6800 { yyLOCAL = parseBindVariable(yylex, yyDollar[1].str[1:]) } yyVAL.union = yyLOCAL - case 1364: + case 1365: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:6797 +//line sql.y:6805 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1365: + case 1366: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:6801 +//line sql.y:6809 { yyLOCAL = yyDollar[2].exprUnion() } yyVAL.union = yyLOCAL - case 1366: + case 1367: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6807 +//line sql.y:6815 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1367: + case 1368: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6811 +//line sql.y:6819 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1368: + case 1369: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6815 +//line sql.y:6823 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion()} } yyVAL.union = yyLOCAL - case 1369: + case 1370: yyDollar = yyS[yypt-12 : yypt+1] var yyLOCAL Expr -//line sql.y:6819 +//line sql.y:6827 { yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion(), ReturnOption: yyDollar[11].exprUnion()} } yyVAL.union = yyLOCAL - case 1370: + case 1371: yyDollar = yyS[yypt-14 : yypt+1] var yyLOCAL Expr -//line sql.y:6823 +//line sql.y:6831 { // Match type is kept expression as TRIM( ' m ') is accepted yyLOCAL = &RegexpInstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion(), ReturnOption: yyDollar[11].exprUnion(), MatchType: yyDollar[13].exprUnion()} } yyVAL.union = yyLOCAL - case 1371: + case 1372: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6828 +//line sql.y:6836 { yyLOCAL = &RegexpLikeExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1372: + case 1373: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6832 +//line sql.y:6840 { yyLOCAL = &RegexpLikeExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), MatchType: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1373: + case 1374: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6836 +//line sql.y:6844 { yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1374: + case 1375: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6840 +//line sql.y:6848 { yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion(), Position: yyDollar[9].exprUnion()} } yyVAL.union = yyLOCAL - case 1375: + case 1376: yyDollar = yyS[yypt-12 : yypt+1] var yyLOCAL Expr -//line sql.y:6844 +//line sql.y:6852 { yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion(), Position: yyDollar[9].exprUnion(), Occurrence: yyDollar[11].exprUnion()} } yyVAL.union = yyLOCAL - case 1376: + case 1377: yyDollar = yyS[yypt-14 : yypt+1] var yyLOCAL Expr -//line sql.y:6848 +//line sql.y:6856 { // Match type is kept expression as TRIM( ' m ') is accepted yyLOCAL = &RegexpReplaceExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Repl: yyDollar[7].exprUnion(), Position: yyDollar[9].exprUnion(), Occurrence: yyDollar[11].exprUnion(), MatchType: yyDollar[13].exprUnion()} } yyVAL.union = yyLOCAL - case 1377: + case 1378: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6853 +//line sql.y:6861 { yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1378: + case 1379: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6857 +//line sql.y:6865 { yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1379: + case 1380: yyDollar = yyS[yypt-10 : yypt+1] var yyLOCAL Expr -//line sql.y:6861 +//line sql.y:6869 { yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion()} } yyVAL.union = yyLOCAL - case 1380: + case 1381: yyDollar = yyS[yypt-12 : yypt+1] var yyLOCAL Expr -//line sql.y:6865 +//line sql.y:6873 { // Match type is kept expression as TRIM( ' m ') is accepted yyLOCAL = &RegexpSubstrExpr{Expr: yyDollar[3].exprUnion(), Pattern: yyDollar[5].exprUnion(), Position: yyDollar[7].exprUnion(), Occurrence: yyDollar[9].exprUnion(), MatchType: yyDollar[11].exprUnion()} } yyVAL.union = yyLOCAL - case 1381: + case 1382: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6872 +//line sql.y:6880 { yyLOCAL = &ExtractValueExpr{Fragment: yyDollar[3].exprUnion(), XPathExpr: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1382: + case 1383: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6876 +//line sql.y:6884 { yyLOCAL = &UpdateXMLExpr{Target: yyDollar[3].exprUnion(), XPathExpr: yyDollar[5].exprUnion(), NewXML: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1383: + case 1384: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6882 +//line sql.y:6890 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: FormatBytesType, Argument: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1384: + case 1385: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6886 +//line sql.y:6894 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: FormatPicoTimeType, Argument: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1385: + case 1386: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Expr -//line sql.y:6890 +//line sql.y:6898 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: PsCurrentThreadIDType} } yyVAL.union = yyLOCAL - case 1386: + case 1387: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6894 +//line sql.y:6902 { yyLOCAL = &PerformanceSchemaFuncExpr{Type: PsThreadIDType, Argument: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1387: + case 1388: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6900 +//line sql.y:6908 { yyLOCAL = >IDFuncExpr{Type: GTIDSubsetType, Set1: yyDollar[3].exprUnion(), Set2: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1388: + case 1389: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6904 +//line sql.y:6912 { yyLOCAL = >IDFuncExpr{Type: GTIDSubtractType, Set1: yyDollar[3].exprUnion(), Set2: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1389: + case 1390: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6908 +//line sql.y:6916 { yyLOCAL = >IDFuncExpr{Type: WaitForExecutedGTIDSetType, Set1: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1390: + case 1391: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6912 +//line sql.y:6920 { yyLOCAL = >IDFuncExpr{Type: WaitForExecutedGTIDSetType, Set1: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1391: + case 1392: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:6916 +//line sql.y:6924 { yyLOCAL = >IDFuncExpr{Type: WaitUntilSQLThreadAfterGTIDSType, Set1: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1392: + case 1393: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL Expr -//line sql.y:6920 +//line sql.y:6928 { yyLOCAL = >IDFuncExpr{Type: WaitUntilSQLThreadAfterGTIDSType, Set1: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion()} } yyVAL.union = yyLOCAL - case 1393: + case 1394: yyDollar = yyS[yypt-8 : yypt+1] var yyLOCAL Expr -//line sql.y:6924 +//line sql.y:6932 { yyLOCAL = >IDFuncExpr{Type: WaitUntilSQLThreadAfterGTIDSType, Set1: yyDollar[3].exprUnion(), Timeout: yyDollar[5].exprUnion(), Channel: yyDollar[7].exprUnion()} } yyVAL.union = yyLOCAL - case 1394: + case 1395: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:6929 +//line sql.y:6937 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1395: + case 1396: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:6933 +//line sql.y:6941 { yyLOCAL = yyDollar[2].convertTypeUnion() } yyVAL.union = yyLOCAL - case 1396: + case 1397: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6939 +//line sql.y:6947 { yyLOCAL = IntervalDayHour } yyVAL.union = yyLOCAL - case 1397: + case 1398: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6943 +//line sql.y:6951 { yyLOCAL = IntervalDayMicrosecond } yyVAL.union = yyLOCAL - case 1398: + case 1399: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6947 +//line sql.y:6955 { yyLOCAL = IntervalDayMinute } yyVAL.union = yyLOCAL - case 1399: + case 1400: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6951 +//line sql.y:6959 { yyLOCAL = IntervalDaySecond } yyVAL.union = yyLOCAL - case 1400: + case 1401: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6955 +//line sql.y:6963 { yyLOCAL = IntervalHourMicrosecond } yyVAL.union = yyLOCAL - case 1401: + case 1402: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6959 +//line sql.y:6967 { yyLOCAL = IntervalHourMinute } yyVAL.union = yyLOCAL - case 1402: + case 1403: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6963 +//line sql.y:6971 { yyLOCAL = IntervalHourSecond } yyVAL.union = yyLOCAL - case 1403: + case 1404: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6967 +//line sql.y:6975 { yyLOCAL = IntervalMinuteMicrosecond } yyVAL.union = yyLOCAL - case 1404: + case 1405: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6971 +//line sql.y:6979 { yyLOCAL = IntervalMinuteSecond } yyVAL.union = yyLOCAL - case 1405: + case 1406: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6975 +//line sql.y:6983 { yyLOCAL = IntervalSecondMicrosecond } yyVAL.union = yyLOCAL - case 1406: + case 1407: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6979 +//line sql.y:6987 { yyLOCAL = IntervalYearMonth } yyVAL.union = yyLOCAL - case 1407: + case 1408: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6983 +//line sql.y:6991 { yyLOCAL = IntervalDay } yyVAL.union = yyLOCAL - case 1408: + case 1409: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6987 +//line sql.y:6995 { yyLOCAL = IntervalWeek } yyVAL.union = yyLOCAL - case 1409: + case 1410: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6991 +//line sql.y:6999 { yyLOCAL = IntervalHour } yyVAL.union = yyLOCAL - case 1410: + case 1411: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6995 +//line sql.y:7003 { yyLOCAL = IntervalMinute } yyVAL.union = yyLOCAL - case 1411: + case 1412: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:6999 +//line sql.y:7007 { yyLOCAL = IntervalMonth } yyVAL.union = yyLOCAL - case 1412: + case 1413: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7003 +//line sql.y:7011 { yyLOCAL = IntervalQuarter } yyVAL.union = yyLOCAL - case 1413: + case 1414: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7007 +//line sql.y:7015 { yyLOCAL = IntervalSecond } yyVAL.union = yyLOCAL - case 1414: + case 1415: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7011 +//line sql.y:7019 { yyLOCAL = IntervalMicrosecond } yyVAL.union = yyLOCAL - case 1415: + case 1416: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7015 +//line sql.y:7023 { yyLOCAL = IntervalYear } yyVAL.union = yyLOCAL - case 1416: + case 1417: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7021 +//line sql.y:7029 { yyLOCAL = IntervalDay } yyVAL.union = yyLOCAL - case 1417: + case 1418: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7025 +//line sql.y:7033 { yyLOCAL = IntervalWeek } yyVAL.union = yyLOCAL - case 1418: + case 1419: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7029 +//line sql.y:7037 { yyLOCAL = IntervalHour } yyVAL.union = yyLOCAL - case 1419: + case 1420: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7033 +//line sql.y:7041 { yyLOCAL = IntervalMinute } yyVAL.union = yyLOCAL - case 1420: + case 1421: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7037 +//line sql.y:7045 { yyLOCAL = IntervalMonth } yyVAL.union = yyLOCAL - case 1421: + case 1422: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7041 +//line sql.y:7049 { yyLOCAL = IntervalQuarter } yyVAL.union = yyLOCAL - case 1422: + case 1423: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7045 +//line sql.y:7053 { yyLOCAL = IntervalSecond } yyVAL.union = yyLOCAL - case 1423: + case 1424: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7049 +//line sql.y:7057 { yyLOCAL = IntervalMicrosecond } yyVAL.union = yyLOCAL - case 1424: + case 1425: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7053 +//line sql.y:7061 { yyLOCAL = IntervalYear } yyVAL.union = yyLOCAL - case 1425: + case 1426: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7057 +//line sql.y:7065 { yyLOCAL = IntervalDay } yyVAL.union = yyLOCAL - case 1426: + case 1427: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7061 +//line sql.y:7069 { yyLOCAL = IntervalWeek } yyVAL.union = yyLOCAL - case 1427: + case 1428: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7065 +//line sql.y:7073 { yyLOCAL = IntervalHour } yyVAL.union = yyLOCAL - case 1428: + case 1429: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7069 +//line sql.y:7077 { yyLOCAL = IntervalMinute } yyVAL.union = yyLOCAL - case 1429: + case 1430: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7073 +//line sql.y:7081 { yyLOCAL = IntervalMonth } yyVAL.union = yyLOCAL - case 1430: + case 1431: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7077 +//line sql.y:7085 { yyLOCAL = IntervalQuarter } yyVAL.union = yyLOCAL - case 1431: + case 1432: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7081 +//line sql.y:7089 { yyLOCAL = IntervalSecond } yyVAL.union = yyLOCAL - case 1432: + case 1433: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7085 +//line sql.y:7093 { yyLOCAL = IntervalMicrosecond } yyVAL.union = yyLOCAL - case 1433: + case 1434: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL IntervalType -//line sql.y:7089 +//line sql.y:7097 { yyLOCAL = IntervalYear } yyVAL.union = yyLOCAL - case 1436: + case 1437: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL int -//line sql.y:7099 +//line sql.y:7107 { yyLOCAL = 0 } yyVAL.union = yyLOCAL - case 1437: + case 1438: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL int -//line sql.y:7103 +//line sql.y:7111 { yyLOCAL = 0 } yyVAL.union = yyLOCAL - case 1438: + case 1439: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL int -//line sql.y:7107 +//line sql.y:7115 { yyLOCAL = convertStringToInt(yyDollar[2].str) } yyVAL.union = yyLOCAL - case 1439: + case 1440: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7117 +//line sql.y:7125 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("if"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1440: + case 1441: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7121 +//line sql.y:7129 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("database"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1441: + case 1442: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7125 +//line sql.y:7133 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("schema"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1442: + case 1443: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7129 +//line sql.y:7137 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("mod"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1443: + case 1444: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Expr -//line sql.y:7133 +//line sql.y:7141 { yyLOCAL = &FuncExpr{Name: NewIdentifierCI("replace"), Exprs: yyDollar[3].exprsUnion()} } yyVAL.union = yyLOCAL - case 1444: + case 1445: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7139 +//line sql.y:7147 { yyLOCAL = NoOption } yyVAL.union = yyLOCAL - case 1445: + case 1446: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7143 +//line sql.y:7151 { yyLOCAL = BooleanModeOpt } yyVAL.union = yyLOCAL - case 1446: + case 1447: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7147 +//line sql.y:7155 { yyLOCAL = NaturalLanguageModeOpt } yyVAL.union = yyLOCAL - case 1447: + case 1448: yyDollar = yyS[yypt-7 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7151 +//line sql.y:7159 { yyLOCAL = NaturalLanguageModeWithQueryExpansionOpt } yyVAL.union = yyLOCAL - case 1448: + case 1449: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL MatchExprOption -//line sql.y:7155 +//line sql.y:7163 { yyLOCAL = QueryExpansionOpt } yyVAL.union = yyLOCAL - case 1449: + case 1450: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7161 +//line sql.y:7169 { yyVAL.str = string(yyDollar[1].identifierCI.String()) } - case 1450: + case 1451: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7165 +//line sql.y:7173 { yyVAL.str = string(yyDollar[1].str) } - case 1451: + case 1452: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7169 +//line sql.y:7177 { yyVAL.str = string(yyDollar[1].str) } - case 1452: + case 1453: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7175 +//line sql.y:7183 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1453: + case 1454: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7179 +//line sql.y:7187 { yyLOCAL = &ConvertType{Type: string(yyDollar[2].str), Length: ptr.Of(convertStringToInt(yyDollar[4].str))} } yyVAL.union = yyLOCAL - case 1454: + case 1455: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7183 +//line sql.y:7191 { yyLOCAL = &ConvertType{Type: string(yyDollar[2].str), Length: ptr.Of(convertStringToInt(yyDollar[4].str))} } yyVAL.union = yyLOCAL - case 1455: + case 1456: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7189 +//line sql.y:7197 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL - case 1456: + case 1457: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7193 +//line sql.y:7201 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion(), Charset: yyDollar[3].columnCharset} } yyVAL.union = yyLOCAL - case 1457: + case 1458: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7197 +//line sql.y:7205 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1458: + case 1459: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7201 +//line sql.y:7209 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL - case 1459: + case 1460: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7205 +//line sql.y:7213 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} yyLOCAL.Length = yyDollar[2].LengthScaleOption.Length yyLOCAL.Scale = yyDollar[2].LengthScaleOption.Scale } yyVAL.union = yyLOCAL - case 1460: + case 1461: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7211 +//line sql.y:7219 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1461: + case 1462: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7215 +//line sql.y:7223 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL - case 1462: + case 1463: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7219 +//line sql.y:7227 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1463: + case 1464: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7223 +//line sql.y:7231 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1464: + case 1465: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7227 +//line sql.y:7235 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL - case 1465: + case 1466: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7231 +//line sql.y:7239 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1466: + case 1467: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7235 +//line sql.y:7243 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1467: + case 1468: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7239 +//line sql.y:7247 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str), Length: yyDollar[2].intPtrUnion()} } yyVAL.union = yyLOCAL - case 1468: + case 1469: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7243 +//line sql.y:7251 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1469: + case 1470: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ConvertType -//line sql.y:7247 +//line sql.y:7255 { yyLOCAL = &ConvertType{Type: string(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1470: + case 1471: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7253 +//line sql.y:7261 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1471: + case 1472: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:7257 +//line sql.y:7265 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1472: + case 1473: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:7262 +//line sql.y:7270 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1473: + case 1474: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7266 +//line sql.y:7274 { yyLOCAL = yyDollar[1].exprUnion() } yyVAL.union = yyLOCAL - case 1474: + case 1475: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7271 +//line sql.y:7279 { yyVAL.str = string("") } - case 1475: + case 1476: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7275 +//line sql.y:7283 { yyVAL.str = encodeSQLString(yyDollar[2].str) } - case 1476: + case 1477: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*When -//line sql.y:7281 +//line sql.y:7289 { yyLOCAL = []*When{yyDollar[1].whenUnion()} } yyVAL.union = yyLOCAL - case 1477: + case 1478: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7285 +//line sql.y:7293 { yySLICE := (*[]*When)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[2].whenUnion()) } - case 1478: + case 1479: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *When -//line sql.y:7291 +//line sql.y:7299 { yyLOCAL = &When{Cond: yyDollar[2].exprUnion(), Val: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1479: + case 1480: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:7296 +//line sql.y:7304 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1480: + case 1481: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7300 +//line sql.y:7308 { yyLOCAL = yyDollar[2].exprUnion() } yyVAL.union = yyLOCAL - case 1481: + case 1482: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ColName -//line sql.y:7306 +//line sql.y:7314 { yyLOCAL = &ColName{Name: yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL - case 1482: + case 1483: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *ColName -//line sql.y:7310 +//line sql.y:7318 { yyLOCAL = &ColName{Name: NewIdentifierCI(string(yyDollar[1].str))} } yyVAL.union = yyLOCAL - case 1483: + case 1484: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *ColName -//line sql.y:7314 +//line sql.y:7322 { yyLOCAL = &ColName{Qualifier: TableName{Name: yyDollar[1].identifierCS}, Name: yyDollar[3].identifierCI} } yyVAL.union = yyLOCAL - case 1484: + case 1485: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *ColName -//line sql.y:7318 +//line sql.y:7326 { yyLOCAL = &ColName{Qualifier: TableName{Qualifier: yyDollar[1].identifierCS, Name: yyDollar[3].identifierCS}, Name: yyDollar[5].identifierCI} } yyVAL.union = yyLOCAL - case 1485: + case 1486: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7324 +//line sql.y:7332 { yyLOCAL = yyDollar[1].colNameUnion() } yyVAL.union = yyLOCAL - case 1486: + case 1487: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7328 +//line sql.y:7336 { yyLOCAL = &Offset{V: convertStringToInt(yyDollar[1].str)} } yyVAL.union = yyLOCAL - case 1487: + case 1488: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7334 +//line sql.y:7342 { // TODO(sougou): Deprecate this construct. if yyDollar[1].identifierCI.Lowered() != "value" { @@ -21418,442 +21472,442 @@ yydefault: yyLOCAL = NewIntLiteral("1") } yyVAL.union = yyLOCAL - case 1488: + case 1489: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7343 +//line sql.y:7351 { yyLOCAL = NewIntLiteral(yyDollar[1].str) } yyVAL.union = yyLOCAL - case 1489: + case 1490: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7347 +//line sql.y:7355 { yyLOCAL = parseBindVariable(yylex, yyDollar[1].str[1:]) } yyVAL.union = yyLOCAL - case 1490: + case 1491: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *GroupBy -//line sql.y:7352 +//line sql.y:7360 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1491: + case 1492: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *GroupBy -//line sql.y:7356 +//line sql.y:7364 { yyLOCAL = &GroupBy{Exprs: yyDollar[3].exprsUnion(), WithRollup: yyDollar[4].booleanUnion()} } yyVAL.union = yyLOCAL - case 1492: + case 1493: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7361 +//line sql.y:7369 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1493: + case 1494: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:7365 +//line sql.y:7373 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1494: + case 1495: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Expr -//line sql.y:7371 +//line sql.y:7379 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1495: + case 1496: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Expr -//line sql.y:7375 +//line sql.y:7383 { yyLOCAL = yyDollar[2].exprUnion() } yyVAL.union = yyLOCAL - case 1496: + case 1497: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *NamedWindow -//line sql.y:7381 +//line sql.y:7389 { yyLOCAL = &NamedWindow{yyDollar[2].windowDefinitionsUnion()} } yyVAL.union = yyLOCAL - case 1497: + case 1498: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL NamedWindows -//line sql.y:7387 +//line sql.y:7395 { yyLOCAL = NamedWindows{yyDollar[1].namedWindowUnion()} } yyVAL.union = yyLOCAL - case 1498: + case 1499: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7391 +//line sql.y:7399 { yySLICE := (*NamedWindows)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].namedWindowUnion()) } - case 1499: + case 1500: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL NamedWindows -//line sql.y:7396 +//line sql.y:7404 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1500: + case 1501: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL NamedWindows -//line sql.y:7400 +//line sql.y:7408 { yyLOCAL = yyDollar[1].namedWindowsUnion() } yyVAL.union = yyLOCAL - case 1501: + case 1502: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7405 +//line sql.y:7413 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1502: + case 1503: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7409 +//line sql.y:7417 { yyLOCAL = yyDollar[1].orderByUnion() } yyVAL.union = yyLOCAL - case 1503: + case 1504: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7415 +//line sql.y:7423 { yyLOCAL = yyDollar[3].orderByUnion() } yyVAL.union = yyLOCAL - case 1504: + case 1505: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderBy -//line sql.y:7421 +//line sql.y:7429 { yyLOCAL = OrderBy{yyDollar[1].orderUnion()} } yyVAL.union = yyLOCAL - case 1505: + case 1506: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7425 +//line sql.y:7433 { yySLICE := (*OrderBy)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].orderUnion()) } - case 1506: + case 1507: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Order -//line sql.y:7431 +//line sql.y:7439 { yyLOCAL = &Order{Expr: yyDollar[1].exprUnion(), Direction: yyDollar[2].orderDirectionUnion()} } yyVAL.union = yyLOCAL - case 1507: + case 1508: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL OrderDirection -//line sql.y:7436 +//line sql.y:7444 { yyLOCAL = AscOrder } yyVAL.union = yyLOCAL - case 1508: + case 1509: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderDirection -//line sql.y:7440 +//line sql.y:7448 { yyLOCAL = AscOrder } yyVAL.union = yyLOCAL - case 1509: + case 1510: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL OrderDirection -//line sql.y:7444 +//line sql.y:7452 { yyLOCAL = DescOrder } yyVAL.union = yyLOCAL - case 1510: + case 1511: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *Limit -//line sql.y:7449 +//line sql.y:7457 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1511: + case 1512: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Limit -//line sql.y:7453 +//line sql.y:7461 { yyLOCAL = yyDollar[1].limitUnion() } yyVAL.union = yyLOCAL - case 1512: + case 1513: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Limit -//line sql.y:7459 +//line sql.y:7467 { yyLOCAL = &Limit{Rowcount: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1513: + case 1514: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Limit -//line sql.y:7463 +//line sql.y:7471 { yyLOCAL = &Limit{Offset: yyDollar[2].exprUnion(), Rowcount: yyDollar[4].exprUnion()} } yyVAL.union = yyLOCAL - case 1514: + case 1515: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Limit -//line sql.y:7467 +//line sql.y:7475 { yyLOCAL = &Limit{Offset: yyDollar[4].exprUnion(), Rowcount: yyDollar[2].exprUnion()} } yyVAL.union = yyLOCAL - case 1515: + case 1516: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7472 +//line sql.y:7480 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1516: + case 1517: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7476 +//line sql.y:7484 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion(), yyDollar[2].alterOptionUnion()} } yyVAL.union = yyLOCAL - case 1517: + case 1518: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7480 +//line sql.y:7488 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion(), yyDollar[2].alterOptionUnion()} } yyVAL.union = yyLOCAL - case 1518: + case 1519: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7484 +//line sql.y:7492 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion()} } yyVAL.union = yyLOCAL - case 1519: + case 1520: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []AlterOption -//line sql.y:7488 +//line sql.y:7496 { yyLOCAL = []AlterOption{yyDollar[1].alterOptionUnion()} } yyVAL.union = yyLOCAL - case 1520: + case 1521: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7495 +//line sql.y:7503 { yyLOCAL = &LockOption{Type: DefaultType} } yyVAL.union = yyLOCAL - case 1521: + case 1522: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7499 +//line sql.y:7507 { yyLOCAL = &LockOption{Type: NoneType} } yyVAL.union = yyLOCAL - case 1522: + case 1523: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7503 +//line sql.y:7511 { yyLOCAL = &LockOption{Type: SharedType} } yyVAL.union = yyLOCAL - case 1523: + case 1524: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7507 +//line sql.y:7515 { yyLOCAL = &LockOption{Type: ExclusiveType} } yyVAL.union = yyLOCAL - case 1524: + case 1525: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7513 +//line sql.y:7521 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 1525: + case 1526: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7517 +//line sql.y:7525 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 1526: + case 1527: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7521 +//line sql.y:7529 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 1527: + case 1528: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL AlterOption -//line sql.y:7525 +//line sql.y:7533 { yyLOCAL = AlgorithmValue(yyDollar[3].str) } yyVAL.union = yyLOCAL - case 1528: + case 1529: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7530 +//line sql.y:7538 { yyVAL.str = "" } - case 1529: + case 1530: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7534 +//line sql.y:7542 { yyVAL.str = string(yyDollar[3].str) } - case 1530: + case 1531: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7538 +//line sql.y:7546 { yyVAL.str = string(yyDollar[3].str) } - case 1531: + case 1532: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7542 +//line sql.y:7550 { yyVAL.str = string(yyDollar[3].str) } - case 1532: + case 1533: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7547 +//line sql.y:7555 { yyVAL.str = "" } - case 1533: + case 1534: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7551 +//line sql.y:7559 { yyVAL.str = yyDollar[3].str } - case 1534: + case 1535: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7557 +//line sql.y:7565 { yyVAL.str = string(yyDollar[1].str) } - case 1535: + case 1536: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7561 +//line sql.y:7569 { yyVAL.str = string(yyDollar[1].str) } - case 1536: + case 1537: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7566 +//line sql.y:7574 { yyVAL.str = "" } - case 1537: + case 1538: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7570 +//line sql.y:7578 { yyVAL.str = yyDollar[2].str } - case 1538: + case 1539: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7575 +//line sql.y:7583 { yyVAL.str = "cascaded" } - case 1539: + case 1540: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7579 +//line sql.y:7587 { yyVAL.str = string(yyDollar[1].str) } - case 1540: + case 1541: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7583 +//line sql.y:7591 { yyVAL.str = string(yyDollar[1].str) } - case 1541: + case 1542: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *Definer -//line sql.y:7588 +//line sql.y:7596 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1542: + case 1543: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *Definer -//line sql.y:7592 +//line sql.y:7600 { yyLOCAL = yyDollar[3].definerUnion() } yyVAL.union = yyLOCAL - case 1543: + case 1544: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Definer -//line sql.y:7598 +//line sql.y:7606 { yyLOCAL = &Definer{ Name: string(yyDollar[1].str), } } yyVAL.union = yyLOCAL - case 1544: + case 1545: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *Definer -//line sql.y:7604 +//line sql.y:7612 { yyLOCAL = &Definer{ Name: string(yyDollar[1].str), } } yyVAL.union = yyLOCAL - case 1545: + case 1546: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *Definer -//line sql.y:7610 +//line sql.y:7618 { yyLOCAL = &Definer{ Name: yyDollar[1].str, @@ -21861,433 +21915,433 @@ yydefault: } } yyVAL.union = yyLOCAL - case 1546: + case 1547: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7619 +//line sql.y:7627 { yyVAL.str = encodeSQLString(yyDollar[1].str) } - case 1547: + case 1548: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7623 +//line sql.y:7631 { yyVAL.str = formatIdentifier(yyDollar[1].str) } - case 1548: + case 1549: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7628 +//line sql.y:7636 { yyVAL.str = "" } - case 1549: + case 1550: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7632 +//line sql.y:7640 { yyVAL.str = formatAddress(yyDollar[1].str) } - case 1550: + case 1551: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Lock -//line sql.y:7638 +//line sql.y:7646 { yyLOCAL = ForUpdateLock } yyVAL.union = yyLOCAL - case 1551: + case 1552: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Lock -//line sql.y:7642 +//line sql.y:7650 { yyLOCAL = ForUpdateLockNoWait } yyVAL.union = yyLOCAL - case 1552: + case 1553: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Lock -//line sql.y:7646 +//line sql.y:7654 { yyLOCAL = ForUpdateLockSkipLocked } yyVAL.union = yyLOCAL - case 1553: + case 1554: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL Lock -//line sql.y:7650 +//line sql.y:7658 { yyLOCAL = ForShareLock } yyVAL.union = yyLOCAL - case 1554: + case 1555: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Lock -//line sql.y:7654 +//line sql.y:7662 { yyLOCAL = ForShareLockNoWait } yyVAL.union = yyLOCAL - case 1555: + case 1556: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Lock -//line sql.y:7658 +//line sql.y:7666 { yyLOCAL = ForShareLockSkipLocked } yyVAL.union = yyLOCAL - case 1556: + case 1557: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL Lock -//line sql.y:7662 +//line sql.y:7670 { yyLOCAL = ShareModeLock } yyVAL.union = yyLOCAL - case 1557: + case 1558: yyDollar = yyS[yypt-9 : yypt+1] var yyLOCAL *SelectInto -//line sql.y:7668 +//line sql.y:7676 { yyLOCAL = &SelectInto{Type: IntoOutfileS3, FileName: encodeSQLString(yyDollar[4].str), Charset: yyDollar[5].columnCharset, FormatOption: yyDollar[6].str, ExportOption: yyDollar[7].str, Manifest: yyDollar[8].str, Overwrite: yyDollar[9].str} } yyVAL.union = yyLOCAL - case 1558: + case 1559: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *SelectInto -//line sql.y:7672 +//line sql.y:7680 { yyLOCAL = &SelectInto{Type: IntoDumpfile, FileName: encodeSQLString(yyDollar[3].str), Charset: ColumnCharset{}, FormatOption: "", ExportOption: "", Manifest: "", Overwrite: ""} } yyVAL.union = yyLOCAL - case 1559: + case 1560: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *SelectInto -//line sql.y:7676 +//line sql.y:7684 { yyLOCAL = &SelectInto{Type: IntoOutfile, FileName: encodeSQLString(yyDollar[3].str), Charset: yyDollar[4].columnCharset, FormatOption: "", ExportOption: yyDollar[5].str, Manifest: "", Overwrite: ""} } yyVAL.union = yyLOCAL - case 1560: + case 1561: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7681 +//line sql.y:7689 { yyVAL.str = "" } - case 1561: + case 1562: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7685 +//line sql.y:7693 { yyVAL.str = " format csv" + yyDollar[3].str } - case 1562: + case 1563: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7689 +//line sql.y:7697 { yyVAL.str = " format text" + yyDollar[3].str } - case 1563: + case 1564: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7694 +//line sql.y:7702 { yyVAL.str = "" } - case 1564: + case 1565: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7698 +//line sql.y:7706 { yyVAL.str = " header" } - case 1565: + case 1566: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7703 +//line sql.y:7711 { yyVAL.str = "" } - case 1566: + case 1567: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7707 +//line sql.y:7715 { yyVAL.str = " manifest on" } - case 1567: + case 1568: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7711 +//line sql.y:7719 { yyVAL.str = " manifest off" } - case 1568: + case 1569: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7716 +//line sql.y:7724 { yyVAL.str = "" } - case 1569: + case 1570: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7720 +//line sql.y:7728 { yyVAL.str = " overwrite on" } - case 1570: + case 1571: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7724 +//line sql.y:7732 { yyVAL.str = " overwrite off" } - case 1571: + case 1572: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7730 +//line sql.y:7738 { yyVAL.str = yyDollar[1].str + yyDollar[2].str } - case 1572: + case 1573: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7735 +//line sql.y:7743 { yyVAL.str = "" } - case 1573: + case 1574: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7739 +//line sql.y:7747 { yyVAL.str = " lines" + yyDollar[2].str } - case 1574: + case 1575: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7745 +//line sql.y:7753 { yyVAL.str = yyDollar[1].str } - case 1575: + case 1576: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7749 +//line sql.y:7757 { yyVAL.str = yyDollar[1].str + yyDollar[2].str } - case 1576: + case 1577: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7755 +//line sql.y:7763 { yyVAL.str = " starting by " + encodeSQLString(yyDollar[3].str) } - case 1577: + case 1578: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7759 +//line sql.y:7767 { yyVAL.str = " terminated by " + encodeSQLString(yyDollar[3].str) } - case 1578: + case 1579: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7764 +//line sql.y:7772 { yyVAL.str = "" } - case 1579: + case 1580: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7768 +//line sql.y:7776 { yyVAL.str = " " + yyDollar[1].str + yyDollar[2].str } - case 1580: + case 1581: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7774 +//line sql.y:7782 { yyVAL.str = yyDollar[1].str } - case 1581: + case 1582: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7778 +//line sql.y:7786 { yyVAL.str = yyDollar[1].str + yyDollar[2].str } - case 1582: + case 1583: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7784 +//line sql.y:7792 { yyVAL.str = " terminated by " + encodeSQLString(yyDollar[3].str) } - case 1583: + case 1584: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7788 +//line sql.y:7796 { yyVAL.str = yyDollar[1].str + " enclosed by " + encodeSQLString(yyDollar[4].str) } - case 1584: + case 1585: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7792 +//line sql.y:7800 { yyVAL.str = " escaped by " + encodeSQLString(yyDollar[3].str) } - case 1585: + case 1586: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7797 +//line sql.y:7805 { yyVAL.str = "" } - case 1586: + case 1587: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7801 +//line sql.y:7809 { yyVAL.str = " optionally" } - case 1587: + case 1588: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *Insert -//line sql.y:7814 +//line sql.y:7822 { yyLOCAL = &Insert{Rows: yyDollar[2].valuesUnion(), RowAlias: yyDollar[3].rowAliasUnion()} } yyVAL.union = yyLOCAL - case 1588: + case 1589: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL *Insert -//line sql.y:7818 +//line sql.y:7826 { yyLOCAL = &Insert{Rows: yyDollar[1].selStmtUnion()} } yyVAL.union = yyLOCAL - case 1589: + case 1590: yyDollar = yyS[yypt-6 : yypt+1] var yyLOCAL *Insert -//line sql.y:7822 +//line sql.y:7830 { yyLOCAL = &Insert{Columns: yyDollar[2].columnsUnion(), Rows: yyDollar[5].valuesUnion(), RowAlias: yyDollar[6].rowAliasUnion()} } yyVAL.union = yyLOCAL - case 1590: + case 1591: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *Insert -//line sql.y:7826 +//line sql.y:7834 { yyLOCAL = &Insert{Columns: []IdentifierCI{}, Rows: yyDollar[4].valuesUnion(), RowAlias: yyDollar[5].rowAliasUnion()} } yyVAL.union = yyLOCAL - case 1591: + case 1592: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL *Insert -//line sql.y:7830 +//line sql.y:7838 { yyLOCAL = &Insert{Columns: yyDollar[2].columnsUnion(), Rows: yyDollar[4].selStmtUnion()} } yyVAL.union = yyLOCAL - case 1592: + case 1593: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Columns -//line sql.y:7836 +//line sql.y:7844 { yyLOCAL = Columns{yyDollar[1].identifierCI} } yyVAL.union = yyLOCAL - case 1593: + case 1594: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Columns -//line sql.y:7840 +//line sql.y:7848 { yyLOCAL = Columns{yyDollar[3].identifierCI} } yyVAL.union = yyLOCAL - case 1594: + case 1595: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7844 +//line sql.y:7852 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].identifierCI) } - case 1595: + case 1596: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7848 +//line sql.y:7856 { yySLICE := (*Columns)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[5].identifierCI) } - case 1596: + case 1597: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL *RowAlias -//line sql.y:7853 +//line sql.y:7861 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1597: + case 1598: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *RowAlias -//line sql.y:7857 +//line sql.y:7865 { yyLOCAL = &RowAlias{TableName: yyDollar[2].identifierCS} } yyVAL.union = yyLOCAL - case 1598: + case 1599: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL *RowAlias -//line sql.y:7861 +//line sql.y:7869 { yyLOCAL = &RowAlias{TableName: yyDollar[2].identifierCS, Columns: yyDollar[4].columnsUnion()} } yyVAL.union = yyLOCAL - case 1599: + case 1600: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL UpdateExprs -//line sql.y:7866 +//line sql.y:7874 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1600: + case 1601: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL UpdateExprs -//line sql.y:7870 +//line sql.y:7878 { yyLOCAL = yyDollar[5].updateExprsUnion() } yyVAL.union = yyLOCAL - case 1601: + case 1602: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Values -//line sql.y:7876 +//line sql.y:7884 { yyLOCAL = Values{yyDollar[1].valTupleUnion()} } yyVAL.union = yyLOCAL - case 1602: + case 1603: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7880 +//line sql.y:7888 { yySLICE := (*Values)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].valTupleUnion()) } - case 1603: + case 1604: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7886 +//line sql.y:7894 { yyLOCAL = yyDollar[1].valTupleUnion() } yyVAL.union = yyLOCAL - case 1604: + case 1605: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7890 +//line sql.y:7898 { yyLOCAL = ValTuple{} } yyVAL.union = yyLOCAL - case 1605: + case 1606: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7896 +//line sql.y:7904 { yyLOCAL = ValTuple(yyDollar[2].exprsUnion()) } yyVAL.union = yyLOCAL - case 1606: + case 1607: yyDollar = yyS[yypt-4 : yypt+1] var yyLOCAL ValTuple -//line sql.y:7900 +//line sql.y:7908 { yyLOCAL = ValTuple(yyDollar[3].exprsUnion()) } yyVAL.union = yyLOCAL - case 1607: + case 1608: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7905 +//line sql.y:7913 { if len(yyDollar[1].valTupleUnion()) == 1 { yyLOCAL = yyDollar[1].valTupleUnion()[0] @@ -22296,300 +22350,300 @@ yydefault: } } yyVAL.union = yyLOCAL - case 1608: + case 1609: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL UpdateExprs -//line sql.y:7915 +//line sql.y:7923 { yyLOCAL = UpdateExprs{yyDollar[1].updateExprUnion()} } yyVAL.union = yyLOCAL - case 1609: + case 1610: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7919 +//line sql.y:7927 { yySLICE := (*UpdateExprs)(yyIaddr(yyVAL.union)) *yySLICE = append(*yySLICE, yyDollar[3].updateExprUnion()) } - case 1610: + case 1611: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL *UpdateExpr -//line sql.y:7925 +//line sql.y:7933 { yyLOCAL = &UpdateExpr{Name: yyDollar[1].colNameUnion(), Expr: yyDollar[3].exprUnion()} } yyVAL.union = yyLOCAL - case 1612: + case 1613: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7932 +//line sql.y:7940 { yyVAL.str = "charset" } - case 1615: + case 1616: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7942 +//line sql.y:7950 { yyLOCAL = NewStrLiteral(yyDollar[1].identifierCI.String()) } yyVAL.union = yyLOCAL - case 1616: + case 1617: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7946 +//line sql.y:7954 { yyLOCAL = NewStrLiteral(yyDollar[1].str) } yyVAL.union = yyLOCAL - case 1617: + case 1618: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Expr -//line sql.y:7950 +//line sql.y:7958 { yyLOCAL = &Default{} } yyVAL.union = yyLOCAL - case 1620: + case 1621: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7959 +//line sql.y:7967 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1621: + case 1622: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL bool -//line sql.y:7961 +//line sql.y:7969 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1622: + case 1623: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7964 +//line sql.y:7972 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1623: + case 1624: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL bool -//line sql.y:7966 +//line sql.y:7974 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1624: + case 1625: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL bool -//line sql.y:7969 +//line sql.y:7977 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1625: + case 1626: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL bool -//line sql.y:7971 +//line sql.y:7979 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1626: + case 1627: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Ignore -//line sql.y:7974 +//line sql.y:7982 { yyLOCAL = false } yyVAL.union = yyLOCAL - case 1627: + case 1628: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Ignore -//line sql.y:7976 +//line sql.y:7984 { yyLOCAL = true } yyVAL.union = yyLOCAL - case 1628: + case 1629: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:7979 +//line sql.y:7987 { yyVAL.empty = struct{}{} } - case 1629: + case 1630: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7981 +//line sql.y:7989 { yyVAL.empty = struct{}{} } - case 1630: + case 1631: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7983 +//line sql.y:7991 { yyVAL.empty = struct{}{} } - case 1631: + case 1632: yyDollar = yyS[yypt-5 : yypt+1] var yyLOCAL Statement -//line sql.y:7987 +//line sql.y:7995 { yyLOCAL = &CallProc{Name: yyDollar[2].tableName, Params: yyDollar[4].exprsUnion()} } yyVAL.union = yyLOCAL - case 1632: + case 1633: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL Exprs -//line sql.y:7992 +//line sql.y:8000 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1633: + case 1634: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL Exprs -//line sql.y:7996 +//line sql.y:8004 { yyLOCAL = yyDollar[1].exprsUnion() } yyVAL.union = yyLOCAL - case 1634: + case 1635: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL []*IndexOption -//line sql.y:8001 +//line sql.y:8009 { yyLOCAL = nil } yyVAL.union = yyLOCAL - case 1635: + case 1636: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL []*IndexOption -//line sql.y:8003 +//line sql.y:8011 { yyLOCAL = []*IndexOption{yyDollar[1].indexOptionUnion()} } yyVAL.union = yyLOCAL - case 1636: + case 1637: yyDollar = yyS[yypt-2 : yypt+1] var yyLOCAL *IndexOption -//line sql.y:8007 +//line sql.y:8015 { yyLOCAL = &IndexOption{Name: string(yyDollar[1].str), String: string(yyDollar[2].identifierCI.String())} } yyVAL.union = yyLOCAL - case 1637: + case 1638: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8013 +//line sql.y:8021 { yyVAL.identifierCI = yyDollar[1].identifierCI } - case 1638: + case 1639: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8017 +//line sql.y:8025 { yyVAL.identifierCI = NewIdentifierCI(string(yyDollar[1].str)) } - case 1640: + case 1641: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8024 +//line sql.y:8032 { yyVAL.identifierCI = NewIdentifierCI(string(yyDollar[1].str)) } - case 1641: + case 1642: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8030 +//line sql.y:8038 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } - case 1642: + case 1643: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8034 +//line sql.y:8042 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } - case 1643: + case 1644: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:8040 +//line sql.y:8048 { yyVAL.identifierCS = NewIdentifierCS("") } - case 1644: + case 1645: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8044 +//line sql.y:8052 { yyVAL.identifierCS = yyDollar[1].identifierCS } - case 1646: + case 1647: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8051 +//line sql.y:8059 { yyVAL.identifierCS = NewIdentifierCS(string(yyDollar[1].str)) } - case 1647: + case 1648: yyDollar = yyS[yypt-3 : yypt+1] var yyLOCAL Statement -//line sql.y:8057 +//line sql.y:8065 { yyLOCAL = &Kill{Type: yyDollar[2].killTypeUnion(), ProcesslistID: convertStringToUInt64(yyDollar[3].str)} } yyVAL.union = yyLOCAL - case 1648: + case 1649: yyDollar = yyS[yypt-0 : yypt+1] var yyLOCAL KillType -//line sql.y:8063 +//line sql.y:8071 { yyLOCAL = ConnectionType } yyVAL.union = yyLOCAL - case 1649: + case 1650: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL KillType -//line sql.y:8067 +//line sql.y:8075 { yyLOCAL = ConnectionType } yyVAL.union = yyLOCAL - case 1650: + case 1651: yyDollar = yyS[yypt-1 : yypt+1] var yyLOCAL KillType -//line sql.y:8071 +//line sql.y:8079 { yyLOCAL = QueryType } yyVAL.union = yyLOCAL - case 2281: + case 2283: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8730 +//line sql.y:8739 { } - case 2282: + case 2284: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8735 +//line sql.y:8744 { } - case 2283: + case 2285: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:8739 +//line sql.y:8748 { skipToEnd(yylex) } - case 2284: + case 2286: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:8744 +//line sql.y:8753 { skipToEnd(yylex) } - case 2285: + case 2287: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8748 +//line sql.y:8757 { skipToEnd(yylex) } - case 2286: + case 2288: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8752 +//line sql.y:8761 { skipToEnd(yylex) } diff --git a/go/vt/sqlparser/sql.y b/go/vt/sqlparser/sql.y index 18db4d2eb08..bf1a793e7e8 100644 --- a/go/vt/sqlparser/sql.y +++ b/go/vt/sqlparser/sql.y @@ -329,7 +329,7 @@ func markBindVariable(yylex yyLexer, bvar string) { %token SEQUENCE MERGE TEMPORARY TEMPTABLE INVOKER SECURITY FIRST AFTER LAST // Migration tokens -%token VITESS_MIGRATION CANCEL RETRY LAUNCH COMPLETE CLEANUP THROTTLE UNTHROTTLE FORCE_CUTOVER EXPIRE RATIO +%token VITESS_MIGRATION CANCEL RETRY LAUNCH COMPLETE CLEANUP THROTTLE UNTHROTTLE FORCE_CUTOVER CUTOVER_THRESHOLD EXPIRE RATIO // Throttler tokens %token VITESS_THROTTLER @@ -3407,6 +3407,14 @@ alter_statement: Type: ForceCutOverAllMigrationType, } } +| ALTER comment_opt VITESS_MIGRATION STRING CUTOVER_THRESHOLD STRING + { + $$ = &AlterMigration{ + Type: SetCutOverThresholdMigrationType, + UUID: string($4), + Threshold: $6, + } + } partitions_options_opt: { @@ -8301,6 +8309,7 @@ non_reserved_keyword: | COUNT %prec FUNCTION_CALL_NON_KEYWORD | CSV | CURRENT +| CUTOVER_THRESHOLD | DATA | DATE %prec STRING_TYPE_PREFIX_NON_KEYWORD | DATE_ADD %prec FUNCTION_CALL_NON_KEYWORD diff --git a/go/vt/vttablet/onlineddl/executor.go b/go/vt/vttablet/onlineddl/executor.go index 555cadd53ea..002cd1fb6d0 100644 --- a/go/vt/vttablet/onlineddl/executor.go +++ b/go/vt/vttablet/onlineddl/executor.go @@ -94,13 +94,18 @@ var ( ptOSCBinaryPath = "/usr/bin/pt-online-schema-change" migrationCheckInterval = 1 * time.Minute retainOnlineDDLTables = 24 * time.Hour - defaultCutOverThreshold = 10 * time.Second maxConcurrentOnlineDDLs = 256 migrationNextCheckIntervals = []time.Duration{1 * time.Second, 5 * time.Second, 10 * time.Second, 20 * time.Second} cutoverIntervals = []time.Duration{0, 1 * time.Minute, 5 * time.Minute, 10 * time.Minute, 30 * time.Minute} ) +const ( + defaultCutOverThreshold = 10 * time.Second + minCutOverThreshold = 5 * time.Second + maxCutOverThreshold = 30 * time.Second +) + func init() { servenv.OnParseFor("vtcombo", registerOnlineDDLFlags) servenv.OnParseFor("vttablet", registerOnlineDDLFlags) @@ -199,13 +204,19 @@ func newGCTableRetainTime() time.Time { return time.Now().UTC().Add(retainOnlineDDLTables) } -// getMigrationCutOverThreshold returns the cut-over threshold for the given migration. The migration's -// DDL Strategy may explicitly set the threshold; otherwise, we return the default cut-over threshold. -func getMigrationCutOverThreshold(onlineDDL *schema.OnlineDDL) time.Duration { - if threshold, _ := onlineDDL.StrategySetting().CutOverThreshold(); threshold != 0 { - return threshold +// safeMigrationCutOverThreshold receives a desired threshold, and returns a cut-over threshold that +// is reasonable to use +func safeMigrationCutOverThreshold(threshold time.Duration) (time.Duration, error) { + switch { + case threshold == 0: + return defaultCutOverThreshold, nil + case threshold < minCutOverThreshold: + return defaultCutOverThreshold, vterrors.Errorf(vtrpcpb.Code_FAILED_PRECONDITION, "cut-over min value is %v", minCutOverThreshold) + case threshold > maxCutOverThreshold: + return defaultCutOverThreshold, vterrors.Errorf(vtrpcpb.Code_FAILED_PRECONDITION, "cut-over max value is %v", maxCutOverThreshold) + default: + return threshold, nil } - return defaultCutOverThreshold } // NewExecutor creates a new gh-ost executor. @@ -890,8 +901,6 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh var sentryTableName string - migrationCutOverThreshold := getMigrationCutOverThreshold(onlineDDL) - waitForPos := func(s *VReplStream, pos replication.Position, timeout time.Duration) error { ctx, cancel := context.WithTimeout(ctx, timeout) defer cancel() @@ -951,8 +960,8 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh } defer preparationsConn.Recycle() // Set large enough `@@lock_wait_timeout` so that it does not interfere with the cut-over operation. - // The code will ensure everything that needs to be terminated by `migrationCutOverThreshold` will be terminated. - preparationConnRestoreLockWaitTimeout, err := e.initConnectionLockWaitTimeout(ctx, preparationsConn.Conn, 3*migrationCutOverThreshold) + // The code will ensure everything that needs to be terminated by `onlineDDL.CutOverThreshold` will be terminated. + preparationConnRestoreLockWaitTimeout, err := e.initConnectionLockWaitTimeout(ctx, preparationsConn.Conn, 3*onlineDDL.CutOverThreshold) if err != nil { return vterrors.Wrap(err, "failed setting lock_wait_timeout on locking connection") } @@ -989,7 +998,7 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh // impacts query serving so we wait for a multiple of the cutover threshold here, with // that variable primarily serving to limit the max time we later spend waiting for // a position again AFTER we've taken the locks and table access is blocked. - if err := waitForPos(s, postSentryPos, migrationCutOverThreshold*3); err != nil { + if err := waitForPos(s, postSentryPos, onlineDDL.CutOverThreshold*3); err != nil { return vterrors.Wrapf(err, "failed waiting for pos after sentry creation") } e.updateMigrationStage(ctx, onlineDDL.UUID, "post-sentry pos reached") @@ -1001,8 +1010,8 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh } defer lockConn.Recycle() // Set large enough `@@lock_wait_timeout` so that it does not interfere with the cut-over operation. - // The code will ensure everything that needs to be terminated by `migrationCutOverThreshold` will be terminated. - lockConnRestoreLockWaitTimeout, err := e.initConnectionLockWaitTimeout(ctx, lockConn.Conn, 5*migrationCutOverThreshold) + // The code will ensure everything that needs to be terminated by `onlineDDL.CutOverThreshold` will be terminated. + lockConnRestoreLockWaitTimeout, err := e.initConnectionLockWaitTimeout(ctx, lockConn.Conn, 5*onlineDDL.CutOverThreshold) if err != nil { return vterrors.Wrapf(err, "failed setting lock_wait_timeout on locking connection") } @@ -1016,8 +1025,8 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh return vterrors.Wrapf(err, "failed getting rename connection") } // Set large enough `@@lock_wait_timeout` so that it does not interfere with the cut-over operation. - // The code will ensure everything that needs to be terminated by `migrationCutOverThreshold` will be terminated. - renameConnRestoreLockWaitTimeout, err := e.initConnectionLockWaitTimeout(ctx, renameConn.Conn, 5*migrationCutOverThreshold*4) + // The code will ensure everything that needs to be terminated by `onlineDDL.CutOverThreshold` will be terminated. + renameConnRestoreLockWaitTimeout, err := e.initConnectionLockWaitTimeout(ctx, renameConn.Conn, 5*onlineDDL.CutOverThreshold*4) if err != nil { return vterrors.Wrapf(err, "failed setting lock_wait_timeout on rename connection") } @@ -1052,7 +1061,7 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh // This function waits until it finds the RENAME TABLE... query running in MySQL's PROCESSLIST, or until timeout // The function assumes that one of the renamed tables is locked, thus causing the RENAME to block. If nothing // is locked, then the RENAME will be near-instantaneous and it's unlikely that the function will find it. - renameWaitCtx, cancel := context.WithTimeout(ctx, migrationCutOverThreshold) + renameWaitCtx, cancel := context.WithTimeout(ctx, onlineDDL.CutOverThreshold) defer cancel() for { @@ -1081,7 +1090,7 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh // Preparation is complete. We proceed to cut-over. toggleBuffering := func(bufferQueries bool) error { log.Infof("toggling buffering: %t in migration %v", bufferQueries, onlineDDL.UUID) - timeout := migrationCutOverThreshold + qrBufferExtraTimeout + timeout := onlineDDL.CutOverThreshold + qrBufferExtraTimeout e.toggleBufferTableFunc(bufferingCtx, onlineDDL.Table, timeout, bufferQueries) if !bufferQueries { @@ -1147,7 +1156,7 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh // real production e.updateMigrationStage(ctx, onlineDDL.UUID, "locking tables") - lockCtx, cancel := context.WithTimeout(ctx, migrationCutOverThreshold) + lockCtx, cancel := context.WithTimeout(ctx, onlineDDL.CutOverThreshold) defer cancel() lockTableQuery := sqlparser.BuildParsedQuery(sqlLockTwoTablesWrite, sentryTableName, onlineDDL.Table) if _, err := lockConn.Conn.Exec(lockCtx, lockTableQuery.Query, 1, false); err != nil { @@ -1187,7 +1196,7 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh } e.updateMigrationStage(ctx, onlineDDL.UUID, "waiting for post-lock pos: %v", replication.EncodePosition(postWritesPos)) - if err := waitForPos(s, postWritesPos, migrationCutOverThreshold); err != nil { + if err := waitForPos(s, postWritesPos, onlineDDL.CutOverThreshold); err != nil { e.updateMigrationStage(ctx, onlineDDL.UUID, "timeout while waiting for post-lock pos: %v", err) return vterrors.Wrapf(err, "failed waiting for pos after locking") } @@ -1220,14 +1229,14 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh { dropTableQuery := sqlparser.BuildParsedQuery(sqlDropTable, sentryTableName) - lockCtx, cancel := context.WithTimeout(ctx, migrationCutOverThreshold) + lockCtx, cancel := context.WithTimeout(ctx, onlineDDL.CutOverThreshold) defer cancel() if _, err := lockConn.Conn.Exec(lockCtx, dropTableQuery.Query, 1, false); err != nil { return vterrors.Wrapf(err, "failed dropping sentry table") } } { - lockCtx, cancel := context.WithTimeout(ctx, migrationCutOverThreshold) + lockCtx, cancel := context.WithTimeout(ctx, onlineDDL.CutOverThreshold) defer cancel() e.updateMigrationStage(ctx, onlineDDL.UUID, "unlocking tables") if _, err := lockConn.Conn.Exec(lockCtx, sqlUnlockTables, 1, false); err != nil { @@ -1235,7 +1244,7 @@ func (e *Executor) cutOverVReplMigration(ctx context.Context, s *VReplStream, sh } } { - lockCtx, cancel := context.WithTimeout(ctx, migrationCutOverThreshold) + lockCtx, cancel := context.WithTimeout(ctx, onlineDDL.CutOverThreshold) defer cancel() e.updateMigrationStage(lockCtx, onlineDDL.UUID, "waiting for RENAME to complete") if err := <-renameCompleteChan; err != nil { @@ -2034,7 +2043,9 @@ func (e *Executor) readMigration(ctx context.Context, uuid string) (onlineDDL *s WasReadyToComplete: row.AsInt64("was_ready_to_complete", 0), TabletAlias: row["tablet"].ToString(), MigrationContext: row["migration_context"].ToString(), + CutOverThreshold: time.Second * time.Duration(row.AsInt64("cutover_threshold_seconds", 0)), } + onlineDDL.CutOverThreshold, _ = safeMigrationCutOverThreshold(onlineDDL.CutOverThreshold) return onlineDDL, row, nil } @@ -3585,17 +3596,15 @@ func (e *Executor) isVReplMigrationReadyToCutOver(ctx context.Context, onlineDDL durationDiff := func(t1, t2 time.Time) time.Duration { return t1.Sub(t2).Abs() } - migrationCutOverThreshold := getMigrationCutOverThreshold(onlineDDL) - timeNow := time.Now() timeUpdated := time.Unix(s.timeUpdated, 0) - if durationDiff(timeNow, timeUpdated) > migrationCutOverThreshold { + if durationDiff(timeNow, timeUpdated) > onlineDDL.CutOverThreshold { return false, nil } // Let's look at transaction timestamp. This gets written by any ongoing // writes on the server (whether on this table or any other table) transactionTimestamp := time.Unix(s.transactionTimestamp, 0) - if durationDiff(timeNow, transactionTimestamp) > migrationCutOverThreshold { + if durationDiff(timeNow, transactionTimestamp) > onlineDDL.CutOverThreshold { return false, nil } } @@ -4747,6 +4756,42 @@ func (e *Executor) ForceCutOverPendingMigrations(ctx context.Context) (result *s return result, nil } +func (e *Executor) SetMigrationCutOverThreshold(ctx context.Context, uuid string, thresholdString string) (result *sqltypes.Result, err error) { + if atomic.LoadInt64(&e.isOpen) == 0 { + return nil, vterrors.New(vtrpcpb.Code_FAILED_PRECONDITION, schema.ErrOnlineDDLDisabled.Error()) + } + if !schema.IsOnlineDDLUUID(uuid) { + return nil, vterrors.Errorf(vtrpcpb.Code_UNKNOWN, "Not a valid migration ID in FORCE_CUTOVER: %s", uuid) + } + threshold, err := time.ParseDuration(thresholdString) + if err != nil { + return nil, vterrors.Errorf(vtrpcpb.Code_INVALID_ARGUMENT, "invalid cut-over threshold value: %s. Try '5s' to '30s'", thresholdString) + } + + log.Infof("SetMigrationCutOverThreshold: request to set cut-over threshold to %v on migration %s", threshold, uuid) + e.migrationMutex.Lock() + defer e.migrationMutex.Unlock() + + threshold, err = safeMigrationCutOverThreshold(threshold) + if err != nil { + return nil, err + } + query, err := sqlparser.ParseAndBind(sqlUpdateCutOverThresholdSeconds, + sqltypes.Int64BindVariable(int64(threshold.Seconds())), + sqltypes.StringBindVariable(uuid), + ) + if err != nil { + return nil, err + } + rs, err := e.execQuery(ctx, query) + if err != nil { + return nil, err + } + e.triggerNextCheckInterval() + log.Infof("SetMigrationCutOverThreshold: migration %s cut-over threshold was set to", uuid, threshold) + return rs, nil +} + // CompleteMigration clears the postpone_completion flag for a given migration, assuming it was set in the first place func (e *Executor) CompleteMigration(ctx context.Context, uuid string) (result *sqltypes.Result, err error) { if atomic.LoadInt64(&e.isOpen) == 0 { @@ -5032,7 +5077,14 @@ func (e *Executor) SubmitMigration( // Explicit retention indicated by `--retain-artifact` DDL strategy flag for this migration. Override! retainArtifactsSeconds = int64((retainArtifacts).Seconds()) } - + cutoverThreshold, err := onlineDDL.StrategySetting().CutOverThreshold() + if err != nil { + return nil, vterrors.Wrapf(err, "parsing cut-over threshold in migration %v", onlineDDL.UUID) + } + cutoverThreshold, err = safeMigrationCutOverThreshold(cutoverThreshold) + if err != nil { + return nil, vterrors.Wrapf(err, "validating cut-over threshold in migration %v", onlineDDL.UUID) + } _, allowConcurrentMigration := e.allowConcurrentMigration(onlineDDL) submitQuery, err := sqlparser.ParseAndBind(sqlInsertMigration, sqltypes.StringBindVariable(onlineDDL.UUID), @@ -5048,6 +5100,7 @@ func (e *Executor) SubmitMigration( sqltypes.StringBindVariable(string(schema.OnlineDDLStatusQueued)), sqltypes.StringBindVariable(e.TabletAliasString()), sqltypes.Int64BindVariable(retainArtifactsSeconds), + sqltypes.Int64BindVariable(int64(cutoverThreshold.Seconds())), sqltypes.BoolBindVariable(onlineDDL.StrategySetting().IsPostponeLaunch()), sqltypes.BoolBindVariable(onlineDDL.StrategySetting().IsPostponeCompletion()), sqltypes.BoolBindVariable(allowConcurrentMigration), diff --git a/go/vt/vttablet/onlineddl/executor_test.go b/go/vt/vttablet/onlineddl/executor_test.go index 2533f3a4b48..105da7fc1e3 100644 --- a/go/vt/vttablet/onlineddl/executor_test.go +++ b/go/vt/vttablet/onlineddl/executor_test.go @@ -25,6 +25,7 @@ import ( "time" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestShouldCutOverAccordingToBackoff(t *testing.T) { @@ -164,3 +165,59 @@ func TestShouldCutOverAccordingToBackoff(t *testing.T) { }) } } + +func TestSafeMigrationCutOverThreshold(t *testing.T) { + require.NotZero(t, defaultCutOverThreshold) + require.GreaterOrEqual(t, defaultCutOverThreshold, minCutOverThreshold) + require.LessOrEqual(t, defaultCutOverThreshold, maxCutOverThreshold) + + tcases := []struct { + threshold time.Duration + expect time.Duration + isErr bool + }{ + { + threshold: 0, + expect: defaultCutOverThreshold, + }, + { + threshold: 2 * time.Second, + expect: defaultCutOverThreshold, + isErr: true, + }, + { + threshold: 75 * time.Second, + expect: defaultCutOverThreshold, + isErr: true, + }, + { + threshold: defaultCutOverThreshold, + expect: defaultCutOverThreshold, + }, + { + threshold: 5 * time.Second, + expect: 5 * time.Second, + }, + { + threshold: 15 * time.Second, + expect: 15 * time.Second, + }, + { + threshold: 25 * time.Second, + expect: 25 * time.Second, + }, + } + for _, tcase := range tcases { + t.Run(tcase.threshold.String(), func(t *testing.T) { + threshold, err := safeMigrationCutOverThreshold(tcase.threshold) + if tcase.isErr { + assert.Error(t, err) + require.Equal(t, tcase.expect, defaultCutOverThreshold) + // And keep testing, because we then also expect the threshold to be the default + } else { + assert.NoError(t, err) + } + assert.Equal(t, tcase.expect, threshold) + }) + } +} diff --git a/go/vt/vttablet/onlineddl/schema.go b/go/vt/vttablet/onlineddl/schema.go index 1b120dfa58c..bc3fa4f2bc9 100644 --- a/go/vt/vttablet/onlineddl/schema.go +++ b/go/vt/vttablet/onlineddl/schema.go @@ -32,13 +32,14 @@ const ( migration_status, tablet, retain_artifacts_seconds, + cutover_threshold_seconds, postpone_launch, postpone_completion, allow_concurrent, reverted_uuid, is_view ) VALUES ( - %a, %a, %a, %a, %a, %a, %a, %a, %a, NOW(6), %a, %a, %a, %a, %a, %a, %a, %a, %a + %a, %a, %a, %a, %a, %a, %a, %a, %a, NOW(6), %a, %a, %a, %a, %a, %a, %a, %a, %a, %a )` sqlSelectQueuedMigrations = `SELECT @@ -181,6 +182,11 @@ const ( WHERE migration_uuid=%a ` + sqlUpdateCutOverThresholdSeconds = `UPDATE _vt.schema_migrations + SET cutover_threshold_seconds=%a + WHERE + migration_uuid=%a + ` sqlUpdateLaunchMigration = `UPDATE _vt.schema_migrations SET postpone_launch=0 WHERE @@ -429,6 +435,7 @@ const ( removed_unique_keys, migration_context, retain_artifacts_seconds, + cutover_threshold_seconds, is_view, ready_to_complete, ready_to_complete_timestamp is not null as was_ready_to_complete, diff --git a/go/vt/vttablet/tabletserver/query_executor.go b/go/vt/vttablet/tabletserver/query_executor.go index abf296c0583..519b60b79d6 100644 --- a/go/vt/vttablet/tabletserver/query_executor.go +++ b/go/vt/vttablet/tabletserver/query_executor.go @@ -991,6 +991,8 @@ func (qre *QueryExecutor) execAlterMigration() (*sqltypes.Result, error) { return qre.tsv.onlineDDLExecutor.ForceCutOverMigration(qre.ctx, alterMigration.UUID) case sqlparser.ForceCutOverAllMigrationType: return qre.tsv.onlineDDLExecutor.ForceCutOverPendingMigrations(qre.ctx) + case sqlparser.SetCutOverThresholdMigrationType: + return qre.tsv.onlineDDLExecutor.SetMigrationCutOverThreshold(qre.ctx, alterMigration.UUID, alterMigration.Threshold) } return nil, vterrors.New(vtrpcpb.Code_UNIMPLEMENTED, "ALTER VITESS_MIGRATION not implemented") }