diff --git a/docs/generated/settings/settings-for-tenants.txt b/docs/generated/settings/settings-for-tenants.txt index d051be575d07..6b8ee4dea6f9 100644 --- a/docs/generated/settings/settings-for-tenants.txt +++ b/docs/generated/settings/settings-for-tenants.txt @@ -144,4 +144,4 @@ trace.datadog.project string CockroachDB the project under which traces will be trace.debug.enable boolean false if set, traces for recent requests can be seen at https:///debug/requests trace.lightstep.token string if set, traces go to Lightstep using this token trace.zipkin.collector string if set, traces go to the given Zipkin instance (example: '127.0.0.1:9411'). Only one tracer can be configured at a time. -version version 21.1-118 set the active cluster version in the format '.' +version version 21.1-122 set the active cluster version in the format '.' diff --git a/docs/generated/settings/settings.html b/docs/generated/settings/settings.html index 485517fef82c..b70b9dd3079e 100644 --- a/docs/generated/settings/settings.html +++ b/docs/generated/settings/settings.html @@ -148,6 +148,6 @@ trace.debug.enablebooleanfalseif set, traces for recent requests can be seen at https:///debug/requests trace.lightstep.tokenstringif set, traces go to Lightstep using this token trace.zipkin.collectorstringif set, traces go to the given Zipkin instance (example: '127.0.0.1:9411'). Only one tracer can be configured at a time. -versionversion21.1-118set the active cluster version in the format '.' +versionversion21.1-122set the active cluster version in the format '.' diff --git a/pkg/cli/debug.go b/pkg/cli/debug.go index 123e09700aac..331416d6bb99 100644 --- a/pkg/cli/debug.go +++ b/pkg/cli/debug.go @@ -24,6 +24,8 @@ import ( "sort" "strconv" "strings" + "sync" + "sync/atomic" "time" "github.com/cockroachdb/cockroach/pkg/base" @@ -1316,6 +1318,99 @@ func runDebugMergeLogs(cmd *cobra.Command, args []string) error { return writeLogStream(s, cmd.OutOrStdout(), o.filter, o.prefix, o.keepRedactable) } +var debugIntentCount = &cobra.Command{ + Use: "intent-count ", + Short: "return a count of intents in directory", + Long: ` +Returns a count of interleaved and separated intents in the store directory. +Used to investigate stores with lots of unresolved intents, or to confirm +if the migration away from interleaved intents was successful. +`, + Args: cobra.MinimumNArgs(1), + RunE: runDebugIntentCount, +} + +func runDebugIntentCount(cmd *cobra.Command, args []string) error { + stopper := stop.NewStopper() + ctx := context.Background() + defer stopper.Stop(ctx) + + db, err := OpenExistingStore(args[0], stopper, true /* readOnly */) + if err != nil { + return err + } + defer db.Close() + + var interleavedIntentCount, separatedIntentCount int + var keysCount uint64 + var wg sync.WaitGroup + closer := make(chan bool) + + wg.Add(1) + _ = stopper.RunAsyncTask(ctx, "intent-count-progress-indicator", func(ctx context.Context) { + defer wg.Done() + ctx, cancel := stopper.WithCancelOnQuiesce(ctx) + defer cancel() + + ticker := time.NewTicker(10 * time.Second) + defer ticker.Stop() + + select { + case <-ticker.C: + fmt.Printf("scanned %d keys\n", atomic.LoadUint64(&keysCount)) + case <-ctx.Done(): + return + case <-closer: + return + } + }) + + iter := db.NewEngineIterator(storage.IterOptions{ + LowerBound: roachpb.KeyMin, + UpperBound: roachpb.KeyMax, + }) + defer iter.Close() + valid, err := iter.SeekEngineKeyGE(storage.EngineKey{Key: roachpb.KeyMin}) + var meta enginepb.MVCCMetadata + for ; valid && err == nil; valid, err = iter.NextEngineKey() { + key, err := iter.EngineKey() + if err != nil { + return err + } + atomic.AddUint64(&keysCount, 1) + if key.IsLockTableKey() { + separatedIntentCount++ + continue + } + if !key.IsMVCCKey() { + continue + } + mvccKey, err := key.ToMVCCKey() + if err != nil { + return err + } + if !mvccKey.Timestamp.IsEmpty() { + continue + } + val := iter.UnsafeValue() + if err := protoutil.Unmarshal(val, &meta); err != nil { + return err + } + if meta.IsInline() { + continue + } + interleavedIntentCount++ + } + if err != nil { + return err + } + close(closer) + wg.Wait() + fmt.Printf("interleaved intents: %d\nseparated intents: %d\n", + interleavedIntentCount, separatedIntentCount) + return nil +} + // DebugCmdsForRocksDB lists debug commands that access rocksdb through the engine // and need encryption flags (injected by CCL code). // Note: do NOT include commands that just call rocksdb code without setting up an engine. @@ -1327,6 +1422,7 @@ var DebugCmdsForRocksDB = []*cobra.Command{ debugRaftLogCmd, debugRangeDataCmd, debugRangeDescriptorsCmd, + debugIntentCount, } // All other debug commands go here. diff --git a/pkg/clusterversion/cockroach_versions.go b/pkg/clusterversion/cockroach_versions.go index 49771b3562a9..02983d235a6a 100644 --- a/pkg/clusterversion/cockroach_versions.go +++ b/pkg/clusterversion/cockroach_versions.go @@ -264,6 +264,12 @@ const ( // DatabaseRoleSettings adds the system table for storing per-user and // per-role default session settings. DatabaseRoleSettings + // SeparatedIntentsMigration adds the migration to move over all remaining + // intents to the separated lock table space. + SeparatedIntentsMigration + // PostSeparatedIntentsMigration runs a cleanup migration after the main + // SeparatedIntentsMigration. + PostSeparatedIntentsMigration // Step (1): Add new versions here. ) @@ -421,6 +427,15 @@ var versionsSingleton = keyedVersions{ Key: DatabaseRoleSettings, Version: roachpb.Version{Major: 21, Minor: 1, Internal: 118}, }, + { + Key: SeparatedIntentsMigration, + Version: roachpb.Version{Major: 21, Minor: 1, Internal: 120}, + }, + { + Key: PostSeparatedIntentsMigration, + Version: roachpb.Version{Major: 21, Minor: 1, Internal: 122}, + }, + // Step (2): Add new versions here. } diff --git a/pkg/clusterversion/key_string.go b/pkg/clusterversion/key_string.go index 8d2fdc888409..c741c8d61819 100644 --- a/pkg/clusterversion/key_string.go +++ b/pkg/clusterversion/key_string.go @@ -38,11 +38,13 @@ func _() { _ = x[FixDescriptors-27] _ = x[SQLStatsTable-28] _ = x[DatabaseRoleSettings-29] + _ = x[SeparatedIntentsMigration-30] + _ = x[PostSeparatedIntentsMigration-31] } -const _Key_name = "Start20_2NodeMembershipStatusMinPasswordLengthAbortSpanBytesCreateLoginPrivilegeHBAForNonTLSV20_2Start21_1CPutInlineReplicaVersionsreplacedTruncatedAndRangeAppliedStateMigrationreplacedPostTruncatedAndRangeAppliedStateMigrationTruncatedAndRangeAppliedStateMigrationPostTruncatedAndRangeAppliedStateMigrationSeparatedIntentsTracingVerbosityIndependentSemanticsClosedTimestampsRaftTransportPriorReadSummariesNonVotingReplicasV21_1Start21_1PLUSStart21_2JoinTokensTableAcquisitionTypeInLeaseHistorySerializeViewUDTsExpressionIndexesDeleteDeprecatedNamespaceTableDescriptorMigrationFixDescriptorsSQLStatsTableDatabaseRoleSettings" +const _Key_name = "Start20_2NodeMembershipStatusMinPasswordLengthAbortSpanBytesCreateLoginPrivilegeHBAForNonTLSV20_2Start21_1CPutInlineReplicaVersionsreplacedTruncatedAndRangeAppliedStateMigrationreplacedPostTruncatedAndRangeAppliedStateMigrationTruncatedAndRangeAppliedStateMigrationPostTruncatedAndRangeAppliedStateMigrationSeparatedIntentsTracingVerbosityIndependentSemanticsClosedTimestampsRaftTransportPriorReadSummariesNonVotingReplicasV21_1Start21_1PLUSStart21_2JoinTokensTableAcquisitionTypeInLeaseHistorySerializeViewUDTsExpressionIndexesDeleteDeprecatedNamespaceTableDescriptorMigrationFixDescriptorsSQLStatsTableDatabaseRoleSettingsSeparatedIntentsMigrationPostSeparatedIntentsMigration" -var _Key_index = [...]uint16{0, 9, 29, 46, 60, 80, 92, 97, 106, 116, 131, 177, 227, 265, 307, 323, 359, 388, 406, 423, 428, 441, 450, 465, 494, 511, 528, 577, 591, 604, 624} +var _Key_index = [...]uint16{0, 9, 29, 46, 60, 80, 92, 97, 106, 116, 131, 177, 227, 265, 307, 323, 359, 388, 406, 423, 428, 441, 450, 465, 494, 511, 528, 577, 591, 604, 624, 649, 678} func (i Key) String() string { if i < 0 || i >= Key(len(_Key_index)-1) { diff --git a/pkg/kv/batch.go b/pkg/kv/batch.go index b748fafd9297..123967483b04 100644 --- a/pkg/kv/batch.go +++ b/pkg/kv/batch.go @@ -246,6 +246,17 @@ func (b *Batch) fillResults(ctx context.Context) { if result.Err == nil { result.Keys = reply.(*roachpb.DeleteRangeResponse).Keys } + case *roachpb.ScanInterleavedIntentsRequest: + if result.Err == nil { + t := reply.(*roachpb.ScanInterleavedIntentsResponse) + result.Rows = make([]KeyValue, len(t.IntentRows)) + for j := range t.IntentRows { + src := &t.IntentRows[j] + dst := &result.Rows[j] + dst.Key = src.Key + dst.Value = &src.Value + } + } // Nothing to do for all methods below as they do not generate // any rows. case *roachpb.EndTxnRequest: @@ -271,6 +282,7 @@ func (b *Batch) fillResults(ctx context.Context) { case *roachpb.AddSSTableRequest: case *roachpb.MigrateRequest: case *roachpb.QueryResolvedTimestampRequest: + case *roachpb.BarrierRequest: default: if result.Err == nil { result.Err = errors.Errorf("unsupported reply: %T for %T", @@ -843,3 +855,45 @@ func (b *Batch) queryResolvedTimestamp(s, e interface{}) { b.appendReqs(req) b.initResult(1, 0, notRaw, nil) } + +func (b *Batch) scanInterleavedIntents(s, e interface{}) { + begin, err := marshalKey(s) + if err != nil { + b.initResult(0, 0, notRaw, err) + return + } + end, err := marshalKey(e) + if err != nil { + b.initResult(0, 0, notRaw, err) + return + } + req := &roachpb.ScanInterleavedIntentsRequest{ + RequestHeader: roachpb.RequestHeader{ + Key: begin, + EndKey: end, + }, + } + b.appendReqs(req) + b.initResult(1, 0, notRaw, nil) +} + +func (b *Batch) barrier(s, e interface{}) { + begin, err := marshalKey(s) + if err != nil { + b.initResult(0, 0, notRaw, err) + return + } + end, err := marshalKey(e) + if err != nil { + b.initResult(0, 0, notRaw, err) + return + } + req := &roachpb.BarrierRequest{ + RequestHeader: roachpb.RequestHeader{ + Key: begin, + EndKey: end, + }, + } + b.appendReqs(req) + b.initResult(1, 0, notRaw, nil) +} diff --git a/pkg/kv/db.go b/pkg/kv/db.go index 25f148739354..28b5591be71c 100644 --- a/pkg/kv/db.go +++ b/pkg/kv/db.go @@ -726,6 +726,51 @@ func (db *DB) QueryResolvedTimestamp( return r.ResolvedTS, nil } +// ScanInterleavedIntents is a command that returns all interleaved intents +// encountered in the request span. A resume span is returned if the entirety +// of the request span was not scanned. +func (db *DB) ScanInterleavedIntents( + ctx context.Context, begin, end interface{}, ts hlc.Timestamp, +) ([]roachpb.KeyValue, *roachpb.Span, error) { + b := &Batch{Header: roachpb.Header{Timestamp: ts}} + b.scanInterleavedIntents(begin, end) + result, err := getOneResult(db.Run(ctx, b), b) + if err != nil { + return nil, nil, err + } + responses := b.response.Responses + if len(responses) == 0 { + return nil, nil, errors.Errorf("unexpected empty response for ScanInterleavedIntents") + } + resp, ok := responses[0].GetInner().(*roachpb.ScanInterleavedIntentsResponse) + if !ok { + return nil, nil, errors.Errorf("unexpected response of type %T for ScanInterleavedIntents", + responses[0].GetInner()) + } + return resp.IntentRows, result.ResumeSpan, nil +} + +// Barrier is a command that waits for existing writes on the specified key +// range to finish. +func (db *DB) Barrier(ctx context.Context, begin, end interface{}) (hlc.Timestamp, error) { + b := &Batch{} + b.barrier(begin, end) + err := getOneErr(db.Run(ctx, b), b) + if err != nil { + return hlc.Timestamp{}, err + } + responses := b.response.Responses + if len(responses) == 0 { + return hlc.Timestamp{}, errors.Errorf("unexpected empty response for Barrier") + } + resp, ok := responses[0].GetInner().(*roachpb.BarrierResponse) + if !ok { + return hlc.Timestamp{}, errors.Errorf("unexpected response of type %T for Barrier", + responses[0].GetInner()) + } + return resp.Timestamp, nil +} + // sendAndFill is a helper which sends the given batch and fills its results, // returning the appropriate error which is either from the first failing call, // or an "internal" error. diff --git a/pkg/kv/kvserver/batcheval/BUILD.bazel b/pkg/kv/kvserver/batcheval/BUILD.bazel index 2613721cef06..6b7cd6a662e6 100644 --- a/pkg/kv/kvserver/batcheval/BUILD.bazel +++ b/pkg/kv/kvserver/batcheval/BUILD.bazel @@ -4,6 +4,7 @@ go_library( name = "batcheval", srcs = [ "cmd_add_sstable.go", + "cmd_barrier.go", "cmd_clear_range.go", "cmd_compute_checksum.go", "cmd_conditional_put.go", @@ -36,6 +37,7 @@ go_library( "cmd_reverse_scan.go", "cmd_revert_range.go", "cmd_scan.go", + "cmd_scan_interleaved_intents.go", "cmd_subsume.go", "cmd_truncate_log.go", "command.go", diff --git a/pkg/kv/kvserver/batcheval/cmd_barrier.go b/pkg/kv/kvserver/batcheval/cmd_barrier.go new file mode 100644 index 000000000000..2b7858d61bdd --- /dev/null +++ b/pkg/kv/kvserver/batcheval/cmd_barrier.go @@ -0,0 +1,48 @@ +// Copyright 2021 The Cockroach Authors. +// +// Use of this software is governed by the Business Source License +// included in the file licenses/BSL.txt. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0, included in the file +// licenses/APL.txt. + +package batcheval + +import ( + "context" + + "github.com/cockroachdb/cockroach/pkg/kv/kvserver/batcheval/result" + "github.com/cockroachdb/cockroach/pkg/kv/kvserver/spanset" + "github.com/cockroachdb/cockroach/pkg/roachpb" + "github.com/cockroachdb/cockroach/pkg/storage" + "github.com/cockroachdb/cockroach/pkg/util/hlc" +) + +func init() { + RegisterReadWriteCommand(roachpb.Barrier, declareKeysBarrier, Barrier) +} + +func declareKeysBarrier( + rs ImmutableRangeState, + _ roachpb.Header, + req roachpb.Request, + latchSpans, lockSpans *spanset.SpanSet, +) { + // Barrier is special-cased in the concurrency manager to *not* actually + // grab these latches. Instead, any conflicting latches with these are waited + // on, but new latches aren't inserted. + latchSpans.AddMVCC(spanset.SpanReadOnly, req.Header().Span(), hlc.MaxTimestamp) +} + +// Barrier evaluation is a no-op, as all the latch waiting happens in +// the latch manager. +func Barrier( + _ context.Context, _ storage.ReadWriter, cArgs CommandArgs, response roachpb.Response, +) (result.Result, error) { + resp := response.(*roachpb.BarrierResponse) + resp.Timestamp = cArgs.EvalCtx.Clock().Now() + + return result.Result{}, nil +} diff --git a/pkg/kv/kvserver/batcheval/cmd_migrate.go b/pkg/kv/kvserver/batcheval/cmd_migrate.go index 51d48d1d91f5..288d8330c911 100644 --- a/pkg/kv/kvserver/batcheval/cmd_migrate.go +++ b/pkg/kv/kvserver/batcheval/cmd_migrate.go @@ -55,6 +55,7 @@ type migration func(context.Context, storage.ReadWriter, CommandArgs) (result.Re func init() { registerMigration(clusterversion.TruncatedAndRangeAppliedStateMigration, truncatedAndAppliedStateMigration) + registerMigration(clusterversion.PostSeparatedIntentsMigration, postSeparatedIntentsMigration) } func registerMigration(key clusterversion.Key, migration migration) { @@ -130,6 +131,16 @@ func truncatedAndAppliedStateMigration( return pd, nil } +// postSeparatedIntentsMigration is the below-raft part of the migration for +// interleaved to separated intents. It is a no-op as the only purpose of +// running the Migrate command here is to clear out any orphaned replicas with +// interleaved intents. +func postSeparatedIntentsMigration( + ctx context.Context, readWriter storage.ReadWriter, cArgs CommandArgs, +) (result.Result, error) { + return result.Result{}, nil +} + // TestingRegisterMigrationInterceptor is used in tests to register an // interceptor for a below-raft migration. // diff --git a/pkg/kv/kvserver/batcheval/cmd_scan_interleaved_intents.go b/pkg/kv/kvserver/batcheval/cmd_scan_interleaved_intents.go new file mode 100644 index 000000000000..d45434f09d89 --- /dev/null +++ b/pkg/kv/kvserver/batcheval/cmd_scan_interleaved_intents.go @@ -0,0 +1,109 @@ +// Copyright 2021 The Cockroach Authors. +// +// Use of this software is governed by the Business Source License +// included in the file licenses/BSL.txt. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0, included in the file +// licenses/APL.txt. + +package batcheval + +import ( + "context" + + "github.com/cockroachdb/cockroach/pkg/keys" + "github.com/cockroachdb/cockroach/pkg/kv/kvserver/batcheval/result" + "github.com/cockroachdb/cockroach/pkg/kv/kvserver/spanset" + "github.com/cockroachdb/cockroach/pkg/roachpb" + "github.com/cockroachdb/cockroach/pkg/storage" + "github.com/cockroachdb/cockroach/pkg/storage/enginepb" + "github.com/cockroachdb/cockroach/pkg/util/protoutil" + "github.com/cockroachdb/errors" +) + +func init() { + RegisterReadOnlyCommand(roachpb.ScanInterleavedIntents, declareKeysScanInterleavedIntents, ScanInterleavedIntents) +} + +func declareKeysScanInterleavedIntents( + rs ImmutableRangeState, _ roachpb.Header, _ roachpb.Request, latchSpans, _ *spanset.SpanSet, +) { + latchSpans.AddNonMVCC(spanset.SpanReadOnly, roachpb.Span{Key: keys.RangeDescriptorKey(rs.GetStartKey())}) +} + +// ScanInterleavedIntents returns intents encountered in the provided span. +// These intents are then resolved in the separated intents migration, the +// usual caller for this request. +func ScanInterleavedIntents( + ctx context.Context, reader storage.Reader, cArgs CommandArgs, response roachpb.Response, +) (result.Result, error) { + req := cArgs.Args.(*roachpb.ScanInterleavedIntentsRequest) + resp := response.(*roachpb.ScanInterleavedIntentsResponse) + + // Put a limit on memory usage by scanning for at least maxIntentCount + // intents or maxIntentBytes in intent values, whichever is reached first, + // then returning those. + const maxIntentCount = 1000 + const maxIntentBytes = 1 << 20 // 1MB + iter := reader.NewEngineIterator(storage.IterOptions{ + LowerBound: req.Key, + UpperBound: req.EndKey, + }) + defer iter.Close() + valid, err := iter.SeekEngineKeyGE(storage.EngineKey{Key: req.Key}) + intentCount := 0 + intentBytes := 0 + + for ; valid && err == nil; valid, err = iter.NextEngineKey() { + key, err := iter.EngineKey() + if err != nil { + return result.Result{}, err + } + if !key.IsMVCCKey() { + // This should never happen, as the only non-MVCC keys are lock table + // keys and those are in the local keyspace. Return an error. + return result.Result{}, errors.New("encountered non-MVCC key during lock table migration") + } + mvccKey, err := key.ToMVCCKey() + if err != nil { + return result.Result{}, err + } + if !mvccKey.Timestamp.IsEmpty() { + // Versioned value - not an intent. + // + // TODO(bilal): Explore seeking here in case there are keys with lots of + // versioned values. + continue + } + + val := iter.Value() + meta := enginepb.MVCCMetadata{} + if err := protoutil.Unmarshal(val, &meta); err != nil { + return result.Result{}, err + } + if meta.IsInline() { + // Inlined value - not an intent. + continue + } + + if intentCount >= maxIntentCount || intentBytes >= maxIntentBytes { + // Batch limit reached - cut short this batch here. This kv + // will be added to txnIntents on the next iteration of the outer loop. + resp.ResumeSpan = &roachpb.Span{ + Key: mvccKey.Key, + EndKey: req.EndKey, + } + break + } + resp.IntentRows = append(resp.IntentRows, roachpb.KeyValue{ + Key: mvccKey.Key, + Value: roachpb.Value{RawBytes: val}, + }) + intentCount++ + intentBytes += len(val) + } + + return result.Result{}, nil +} diff --git a/pkg/kv/kvserver/concurrency/concurrency_control.go b/pkg/kv/kvserver/concurrency/concurrency_control.go index 0df0da0e06c4..602444af7f15 100644 --- a/pkg/kv/kvserver/concurrency/concurrency_control.go +++ b/pkg/kv/kvserver/concurrency/concurrency_control.go @@ -455,6 +455,11 @@ type latchManager interface { // causing this request to switch to pessimistic latching. WaitUntilAcquired(ctx context.Context, lg latchGuard) (latchGuard, *Error) + // WaitFor waits for write latches on the specified spans without adding any + // latches itself. Fast path for operations that only require flushing out old + // operations without blocking any new ones. + WaitFor(ctx context.Context, spans *spanset.SpanSet) *Error + // Releases latches, relinquish its protection from conflicting requests. Release(latchGuard) diff --git a/pkg/kv/kvserver/concurrency/concurrency_manager.go b/pkg/kv/kvserver/concurrency/concurrency_manager.go index e43c81dd4e2e..7676c9b4f704 100644 --- a/pkg/kv/kvserver/concurrency/concurrency_manager.go +++ b/pkg/kv/kvserver/concurrency/concurrency_manager.go @@ -223,6 +223,13 @@ func (m *managerImpl) sequenceReqWithGuard(ctx context.Context, g *Guard) (Respo return nil, nil } + // Check if this is a request that waits on latches, but does not acquire + // them. + if shouldWaitOnLatchesWithoutAcquiring(g.Req) { + log.Event(ctx, "waiting on latches without acquiring") + return nil, m.lm.WaitFor(ctx, g.Req.LatchSpans) + } + // Provide the manager with an opportunity to intercept the request. It // may be able to serve the request directly, and even if not, it may be // able to update its internal state based on the request. @@ -346,10 +353,18 @@ func (m *managerImpl) maybeInterceptReq(ctx context.Context, req Request) (Respo return nil, nil } +// shouldWaitOnLatchesWithoutAcquiring determines if this is a request that +// only waits on existing latches without acquiring any new ones. +func shouldWaitOnLatchesWithoutAcquiring(req Request) bool { + return req.isSingle(roachpb.Barrier) +} + // shouldAcquireLatches determines whether the request should acquire latches // before proceeding to evaluate. Latches are used to synchronize with other // conflicting requests, based on the Spans collected for the request. Most -// request types will want to acquire latches. +// request types will want to acquire latches. Note that any requests that +// return true for shouldWaitOnLatchesWithoutAcquiring could also return true +// here, even though latches won't be acquired there. func shouldAcquireLatches(req Request) bool { switch { case req.ReadConsistency != roachpb.CONSISTENT: @@ -628,7 +643,7 @@ func (g *Guard) HoldingLatches() bool { // AssertLatches asserts that the guard is non-nil and holding latches, if the // request is supposed to hold latches while evaluating in the first place. func (g *Guard) AssertLatches() { - if shouldAcquireLatches(g.Req) && !g.HoldingLatches() { + if shouldAcquireLatches(g.Req) && !shouldWaitOnLatchesWithoutAcquiring(g.Req) && !g.HoldingLatches() { panic("expected latches held, found none") } } diff --git a/pkg/kv/kvserver/concurrency/datadriven_util_test.go b/pkg/kv/kvserver/concurrency/datadriven_util_test.go index cd713b1dea20..e9e8f9483a33 100644 --- a/pkg/kv/kvserver/concurrency/datadriven_util_test.go +++ b/pkg/kv/kvserver/concurrency/datadriven_util_test.go @@ -145,6 +145,14 @@ func scanSingleRequest( var r roachpb.RequestLeaseRequest return &r + case "barrier": + var r roachpb.BarrierRequest + r.Key = roachpb.Key(mustGetField("key")) + if v, ok := fields["endkey"]; ok { + r.EndKey = roachpb.Key(v) + } + return &r + default: d.Fatalf(t, "unknown request type: %s", cmd) return nil diff --git a/pkg/kv/kvserver/concurrency/latch_manager.go b/pkg/kv/kvserver/concurrency/latch_manager.go index bec2112be357..b0a4b8eb1073 100644 --- a/pkg/kv/kvserver/concurrency/latch_manager.go +++ b/pkg/kv/kvserver/concurrency/latch_manager.go @@ -50,6 +50,14 @@ func (m *latchManagerImpl) WaitUntilAcquired( return lg, nil } +func (m *latchManagerImpl) WaitFor(ctx context.Context, ss *spanset.SpanSet) *Error { + err := m.m.WaitFor(ctx, ss) + if err != nil { + return roachpb.NewError(err) + } + return nil +} + func (m *latchManagerImpl) Release(lg latchGuard) { m.m.Release(lg.(*spanlatch.Guard)) } diff --git a/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/no_latches b/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/no_latches index 01dce1791cde..6d05384335ef 100644 --- a/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/no_latches +++ b/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/no_latches @@ -49,3 +49,29 @@ finish req=leaseReq reset ---- + +# ------------------------------------------------------------- +# Barrier requests do not acquire latches +# ------------------------------------------------------------- + +new-request name=barrier txn=none ts=10,1 + barrier key=a endKey=f +---- + +sequence req=barrier +---- +[1] sequence barrier: sequencing request +[1] sequence barrier: waiting on latches without acquiring +[1] sequence barrier: sequencing complete, returned guard + +debug-latch-manager +---- +write count: 0 + read count: 0 + +finish req=barrier +---- +[-] finish barrier: finishing request + +reset +---- diff --git a/pkg/kv/kvserver/replica_send.go b/pkg/kv/kvserver/replica_send.go index d6e55d141b3d..f5aea7055624 100644 --- a/pkg/kv/kvserver/replica_send.go +++ b/pkg/kv/kvserver/replica_send.go @@ -343,6 +343,7 @@ func (r *Replica) executeBatchWithConcurrencyRetries( r.concMgr.FinishReq(g) } }() + for { // Exit loop if context has been canceled or timed out. if err := ctx.Err(); err != nil { diff --git a/pkg/kv/kvserver/spanlatch/manager.go b/pkg/kv/kvserver/spanlatch/manager.go index a5c9370b1d0c..92a67b87d8f3 100644 --- a/pkg/kv/kvserver/spanlatch/manager.go +++ b/pkg/kv/kvserver/spanlatch/manager.go @@ -233,6 +233,22 @@ func (m *Manager) AcquireOptimistic(spans *spanset.SpanSet) *Guard { return lg } +// WaitFor waits for conflicting latches on the spans without adding +// any latches itself. Fast path for operations that only require past latches +// to be released without blocking new latches. +func (m *Manager) WaitFor(ctx context.Context, spans *spanset.SpanSet) error { + // The guard is only used to store latches by this request. These latches + // are not actually inserted using insertLocked. + lg := newGuard(spans) + + m.mu.Lock() + snap := m.snapshotLocked(spans) + defer snap.close() + m.mu.Unlock() + + return m.wait(ctx, lg, snap) +} + // CheckOptimisticNoConflicts returns true iff the spans in the provided // spanset do not conflict with any existing latches (in the snapshot created // in AcquireOptimistic). It must only be called after AcquireOptimistic, and diff --git a/pkg/kv/kvserver/spanlatch/manager_test.go b/pkg/kv/kvserver/spanlatch/manager_test.go index c8f461c82d2b..0a36746c10c7 100644 --- a/pkg/kv/kvserver/spanlatch/manager_test.go +++ b/pkg/kv/kvserver/spanlatch/manager_test.go @@ -586,6 +586,40 @@ func TestLatchManagerOptimistic(t *testing.T) { m.Release(lg4) } +func TestLatchManagerWaitFor(t *testing.T) { + defer leaktest.AfterTest(t)() + var m Manager + + // Acquire latches, no conflict. + lg1 := m.AcquireOptimistic(spans("d", "f", write, zeroTS)) + require.True(t, m.CheckOptimisticNoConflicts(lg1, spans("d", "f", write, zeroTS))) + lg1, err := m.WaitUntilAcquired(context.Background(), lg1) + require.NoError(t, err) + + // See if WaitFor waits for above latch. + waitForCh := func() <-chan *Guard { + ch := make(chan *Guard) + go func() { + err := m.WaitFor(context.Background(), spans("a", "e", read, zeroTS)) + require.NoError(t, err) + ch <- &Guard{} + }() + return ch + } + ch2 := waitForCh() + testLatchBlocks(t, ch2) + m.Release(lg1) + testLatchSucceeds(t, ch2) + + // Optimistic acquire should _not_ encounter conflict - as WaitFor should + // not lay any latches. + lg3 := m.AcquireOptimistic(spans("a", "e", write, zeroTS)) + require.True(t, m.CheckOptimisticNoConflicts(lg3, spans("a", "e", write, zeroTS))) + lg3, err = m.WaitUntilAcquired(context.Background(), lg3) + require.NoError(t, err) + m.Release(lg3) +} + func BenchmarkLatchManagerReadOnlyMix(b *testing.B) { for _, size := range []int{1, 4, 16, 64, 128, 256} { b.Run(fmt.Sprintf("size=%d", size), func(b *testing.B) { diff --git a/pkg/migration/BUILD.bazel b/pkg/migration/BUILD.bazel index 67295a3ba331..5444eb8c93ba 100644 --- a/pkg/migration/BUILD.bazel +++ b/pkg/migration/BUILD.bazel @@ -14,12 +14,14 @@ go_library( "//pkg/clusterversion", "//pkg/keys", "//pkg/kv", + "//pkg/kv/kvclient/kvcoord:with-mocks", "//pkg/roachpb:with-mocks", "//pkg/server/serverpb", "//pkg/settings/cluster", "//pkg/sql/catalog/lease", "//pkg/sql/sqlutil", "//pkg/util/log", + "//pkg/util/stop", "@com_github_cockroachdb_logtags//:logtags", ], ) diff --git a/pkg/migration/migrationcluster/BUILD.bazel b/pkg/migration/migrationcluster/BUILD.bazel index 65b18e76898a..c7bf58b5b06d 100644 --- a/pkg/migration/migrationcluster/BUILD.bazel +++ b/pkg/migration/migrationcluster/BUILD.bazel @@ -12,6 +12,7 @@ go_library( deps = [ "//pkg/keys", "//pkg/kv", + "//pkg/kv/kvclient/kvcoord:with-mocks", "//pkg/kv/kvserver/liveness/livenesspb", "//pkg/roachpb:with-mocks", "//pkg/rpc", @@ -19,6 +20,7 @@ go_library( "//pkg/util/ctxgroup", "//pkg/util/log", "//pkg/util/quotapool", + "//pkg/util/stop", "@com_github_cockroachdb_errors//:errors", "@com_github_cockroachdb_redact//:redact", "@org_golang_google_grpc//:go_default_library", diff --git a/pkg/migration/migrationcluster/cluster.go b/pkg/migration/migrationcluster/cluster.go index 6a5aac6ddfba..18b2595576d9 100644 --- a/pkg/migration/migrationcluster/cluster.go +++ b/pkg/migration/migrationcluster/cluster.go @@ -16,6 +16,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/keys" "github.com/cockroachdb/cockroach/pkg/kv" + "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvcoord" "github.com/cockroachdb/cockroach/pkg/kv/kvserver/liveness/livenesspb" "github.com/cockroachdb/cockroach/pkg/roachpb" "github.com/cockroachdb/cockroach/pkg/rpc" @@ -23,6 +24,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/ctxgroup" "github.com/cockroachdb/cockroach/pkg/util/log" "github.com/cockroachdb/cockroach/pkg/util/quotapool" + "github.com/cockroachdb/cockroach/pkg/util/stop" "github.com/cockroachdb/errors" "github.com/cockroachdb/redact" "google.golang.org/grpc" @@ -48,6 +50,13 @@ type ClusterConfig struct { // to expose only relevant, vetted bits of kv.DB. It'll make our tests less // "integration-ey". DB *kv.DB + + // Stopper is a reference to a stop.Stopper for spawning tasks. + Stopper *stop.Stopper + + // DistSender provides access to a DistSender for accessing the distributed kv + // store. + DistSender *kvcoord.DistSender } // NodeDialer abstracts connecting to other nodes in the cluster. @@ -186,3 +195,13 @@ func (c *Cluster) IterateRangeDescriptors( func (c *Cluster) DB() *kv.DB { return c.c.DB } + +// DistSender exposes the underlying *kvcoord.DistSender instance. +func (c *Cluster) DistSender() *kvcoord.DistSender { + return c.c.DistSender +} + +// Stopper exposes the stored Stopper instance. +func (c *Cluster) Stopper() *stop.Stopper { + return c.c.Stopper +} diff --git a/pkg/migration/migrationcluster/tenant_cluster.go b/pkg/migration/migrationcluster/tenant_cluster.go index 090527d568e8..9fbec92fe528 100644 --- a/pkg/migration/migrationcluster/tenant_cluster.go +++ b/pkg/migration/migrationcluster/tenant_cluster.go @@ -14,8 +14,10 @@ import ( "context" "github.com/cockroachdb/cockroach/pkg/kv" + "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvcoord" "github.com/cockroachdb/cockroach/pkg/roachpb" "github.com/cockroachdb/cockroach/pkg/server/serverpb" + "github.com/cockroachdb/cockroach/pkg/util/stop" "github.com/cockroachdb/errors" ) @@ -132,6 +134,16 @@ func (t *TenantCluster) DB() *kv.DB { return t.db } +// DistSender is part of the migration.Cluster interface. +func (t *TenantCluster) DistSender() *kvcoord.DistSender { + return nil +} + +// Stopper is part of the migration.Cluster interface. +func (t *TenantCluster) Stopper() *stop.Stopper { + return nil +} + // ForEveryNode is part of the migration.Cluster interface. func (t *TenantCluster) ForEveryNode( ctx context.Context, op string, fn func(context.Context, serverpb.MigrationClient) error, diff --git a/pkg/migration/migrations/BUILD.bazel b/pkg/migration/migrations/BUILD.bazel index ce51026c597e..07fb60bc378e 100644 --- a/pkg/migration/migrations/BUILD.bazel +++ b/pkg/migration/migrations/BUILD.bazel @@ -8,6 +8,7 @@ go_library( "fix_descriptor_migration.go", "join_tokens.go", "migrations.go", + "separated_intents.go", "sql_stats.go", "truncated_state.go", ], @@ -17,6 +18,8 @@ go_library( "//pkg/clusterversion", "//pkg/keys", "//pkg/kv", + "//pkg/kv/kvclient/kvcoord:with-mocks", + "//pkg/kv/kvserver/intentresolver", "//pkg/migration", "//pkg/roachpb:with-mocks", "//pkg/server/serverpb", @@ -28,10 +31,14 @@ go_library( "//pkg/sql/sem/tree", "//pkg/sql/sqlutil", "//pkg/startupmigrations", + "//pkg/storage/enginepb", "//pkg/util/encoding", "//pkg/util/hlc", "//pkg/util/log", "//pkg/util/protoutil", + "//pkg/util/stop", + "//pkg/util/syncutil", + "//pkg/util/uuid", "@com_github_cockroachdb_errors//:errors", ], ) @@ -42,6 +49,7 @@ go_test( "delete_deprecated_namespace_tabledesc_external_test.go", "fix_descriptor_migration_external_test.go", "main_test.go", + "separated_intents_external_test.go", "truncated_state_external_test.go", ], deps = [ @@ -51,6 +59,7 @@ go_test( "//pkg/kv", "//pkg/kv/kvserver", "//pkg/kv/kvserver/stateloader", + "//pkg/roachpb:with-mocks", "//pkg/security", "//pkg/security/securitytest", "//pkg/server", @@ -59,6 +68,9 @@ go_test( "//pkg/sql/catalog/catalogkv", "//pkg/sql/catalog/descpb", "//pkg/sql/catalog/systemschema", + "//pkg/storage", + "//pkg/storage/enginepb", + "//pkg/testutils", "//pkg/testutils/serverutils", "//pkg/testutils/sqlutils", "//pkg/testutils/testcluster", diff --git a/pkg/migration/migrations/migrations.go b/pkg/migration/migrations/migrations.go index 640eaed8cfd2..3403cff40150 100644 --- a/pkg/migration/migrations/migrations.go +++ b/pkg/migration/migrations/migrations.go @@ -72,6 +72,14 @@ var migrations = []migration.Migration{ toCV(clusterversion.DatabaseRoleSettings), databaseRoleSettingsTableMigration, ), + migration.NewSystemMigration( + "move over all intents to separate lock table", + toCV(clusterversion.SeparatedIntentsMigration), + separatedIntentsMigration), + migration.NewSystemMigration( + "run no-op migrate command on all ranges after lock table migration", + toCV(clusterversion.PostSeparatedIntentsMigration), + postSeparatedIntentsMigration), } func init() { diff --git a/pkg/migration/migrations/separated_intents.go b/pkg/migration/migrations/separated_intents.go new file mode 100644 index 000000000000..90ce3b1d42b7 --- /dev/null +++ b/pkg/migration/migrations/separated_intents.go @@ -0,0 +1,406 @@ +// Copyright 2021 The Cockroach Authors. +// +// Use of this software is governed by the Business Source License +// included in the file licenses/BSL.txt. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0, included in the file +// licenses/APL.txt. + +package migrations + +import ( + "bytes" + "context" + "fmt" + "strings" + "sync" + "sync/atomic" + "time" + + "github.com/cockroachdb/cockroach/pkg/clusterversion" + "github.com/cockroachdb/cockroach/pkg/keys" + "github.com/cockroachdb/cockroach/pkg/kv" + "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvcoord" + "github.com/cockroachdb/cockroach/pkg/kv/kvserver/intentresolver" + "github.com/cockroachdb/cockroach/pkg/migration" + "github.com/cockroachdb/cockroach/pkg/roachpb" + "github.com/cockroachdb/cockroach/pkg/storage/enginepb" + "github.com/cockroachdb/cockroach/pkg/util/hlc" + "github.com/cockroachdb/cockroach/pkg/util/log" + "github.com/cockroachdb/cockroach/pkg/util/protoutil" + "github.com/cockroachdb/cockroach/pkg/util/stop" + "github.com/cockroachdb/cockroach/pkg/util/syncutil" + "github.com/cockroachdb/cockroach/pkg/util/uuid" + "github.com/cockroachdb/errors" +) + +// The number of concurrent migrateLockTableRequests requests to run. This +// is effectively a cluster-wide setting as the actual legwork of the migration +// happens when the destination replica(s) are sending replies back to the +// original node. +// +// TODO(bilal): Add logic to make this concurrency limit a per-leaseholder limit +// as opposed to a cluster-wide limit. That way, we could limit +// migrateLockTableRequests to 1 per leaseholder as opposed to 4 for the entire +// cluster, avoiding the case where all 4 ranges at a time could have the same node +// as their leaseholder. +const concurrentMigrateLockTableRequests = 4 + +// The maximum number of times to retry a migrateLockTableRequest before failing +// the migration. +const migrateLockTableRetries = 3 + +// migrateLockTableRequest represents migration of one slice of the keyspace. As +// part of this request, multiple non-transactional requests would need to be +// run: a Barrier, a ScanInterleavedIntents, then multiple txn pushes and intent +// resolutions. +// +// One request will correspond to one range at the time of running the +// IterateRangeDescriptors command. If range boundaries change during the +// course of the migration, that is okay as the migration logic does not rely on +// that assumption. The debugRangeID is the range ID for this range at the time +// of the range descriptor iteration, and is +// present solely for observability / logging purposes. +type migrateLockTableRequest struct { + start, end roachpb.RKey + debugRangeID roachpb.RangeID + barrierDone bool + barrierTS hlc.Timestamp +} + +type migrateLockTablePool struct { + requests chan migrateLockTableRequest + wg sync.WaitGroup + stopper *stop.Stopper + ir *intentresolver.IntentResolver + db *kv.DB + done chan bool + status [concurrentMigrateLockTableRequests]int64 + + mu struct { + syncutil.Mutex + + errorCount int + combinedErr error + } +} + +func (m *migrateLockTablePool) attemptMigrateRequest( + ctx context.Context, req *migrateLockTableRequest, +) (nextReq *migrateLockTableRequest, err error) { + // The barrier command needs to be invoked if it hasn't been invoked on this + // key range yet. This command does not return a resume span, so once it has + // returned successfully, it doesn't need to be called again unless there's + // an error. + barrierTS := req.barrierTS + if !req.barrierDone { + var err error + barrierTS, err = m.db.Barrier(ctx, req.start, req.end) + if err != nil { + return nil, errors.Wrap(err, "error when invoking Barrier command") + } + } + barrierTS.Forward(m.db.Clock().Now()) + + intents, resumeSpan, err := m.db.ScanInterleavedIntents(ctx, req.start, req.end, barrierTS) + if err != nil { + return nil, errors.Wrap(err, "error when invoking MigrateLockTable command") + } + + var meta enginepb.MVCCMetadata + txnIntents := make(map[uuid.UUID][]roachpb.Intent) + for _, intent := range intents { + if err = protoutil.Unmarshal(intent.Value.RawBytes, &meta); err != nil { + return nil, err + } + txnIntents[meta.Txn.ID] = append(txnIntents[meta.Txn.ID], roachpb.MakeIntent(meta.Txn, intent.Key)) + } + for _, intents := range txnIntents { + txn := &intents[0].Txn + + // Create a request for a PushTxn request of type PUSH_ABORT. If this + // transaction is still running, it will abort. The retry of that + // transaction will then write separated intents. + h := roachpb.Header{ + Timestamp: m.db.Clock().Now(), + UserPriority: roachpb.MinUserPriority, + } + pushedTxn, err := m.ir.PushTransaction(ctx, txn, h, roachpb.PUSH_ABORT) + if err != nil { + return nil, err.GoError() + } + lockUpdates := make([]roachpb.LockUpdate, 0, len(intents)) + for _, intent := range intents { + resolve := roachpb.MakeLockUpdate(pushedTxn, roachpb.Span{Key: intent.Key}) + lockUpdates = append(lockUpdates, resolve) + } + opts := intentresolver.ResolveOptions{Poison: true} + if err := m.ir.ResolveIntents(ctx, lockUpdates, opts); err != nil { + return nil, err.GoError() + } + } + if resumeSpan != nil { + nextReq = req + nextReq.start, err = keys.Addr(resumeSpan.Key) + if err != nil { + return nil, err + } + nextReq.end, err = keys.Addr(resumeSpan.EndKey) + if err != nil { + return nil, err + } + nextReq.barrierDone = true + nextReq.barrierTS = barrierTS + } + return nextReq, nil +} + +func (m *migrateLockTablePool) run(ctx context.Context, workerIdx int) { + defer m.wg.Done() + ctx, cancel := m.stopper.WithCancelOnQuiesce(ctx) + defer cancel() + + var retryRequest *migrateLockTableRequest + retryAttempt := 0 + statusSlot := &m.status[workerIdx] + atomic.StoreInt64(statusSlot, 0) + + for { + if retryRequest == nil { + // Pull a new request out of the channel. + select { + case r, ok := <-m.requests: + if !ok { + return + } + retryRequest = &r + retryAttempt = 0 + case <-ctx.Done(): + log.Warningf(ctx, "lock table migration canceled") + return + } + } + + if ctx.Err() != nil { + log.Warningf(ctx, "lock table migration canceled on range r%d", retryRequest.debugRangeID) + return + } + + atomic.StoreInt64(statusSlot, int64(retryRequest.debugRangeID)) + handleError := func(err error) { + log.Errorf(ctx, "error when running migrate lock table command for range r%d: %s", + retryRequest.debugRangeID, err) + retryAttempt++ + if retryAttempt >= migrateLockTableRetries { + // Report this error to the migration manager. This will cause the + // whole migration to be retried later. In the meantime, continue + // migrating any other ranges in the queue, instead of stalling the + // pipeline. + m.mu.Lock() + // Limit the number of errors chained. This prevents excessive memory + // usage in case of error blowup (rangeCount * migrateLockTableRetries). + if m.mu.errorCount < 16 { + m.mu.combinedErr = errors.CombineErrors(m.mu.combinedErr, err) + } + m.mu.errorCount++ + m.mu.Unlock() + + retryAttempt = 0 + retryRequest = nil + atomic.StoreInt64(statusSlot, 0) + } + } + + nextReq, err := m.attemptMigrateRequest(ctx, retryRequest) + + if err != nil { + handleError(err) + continue + } else { + retryRequest = nextReq + retryAttempt = 0 + atomic.StoreInt64(statusSlot, 0) + } + } +} + +func (m *migrateLockTablePool) startStatusLogger(ctx context.Context) { + m.done = make(chan bool) + _ = m.stopper.RunAsyncTask(ctx, "migrate-lock-table-status", m.runStatusLogger) +} + +func (m *migrateLockTablePool) stopStatusLogger(ctx context.Context) { + close(m.done) +} + +func (m *migrateLockTablePool) runStatusLogger(ctx context.Context) { + ctx, cancel := m.stopper.WithCancelOnQuiesce(ctx) + defer cancel() + + const statusTickDuration = 5 * time.Second + ticker := time.NewTicker(statusTickDuration) + defer ticker.Stop() + + for { + select { + case <-ticker.C: + var ranges strings.Builder + for i := 0; i < concurrentMigrateLockTableRequests; i++ { + rangeID := atomic.LoadInt64(&m.status[i]) + if rangeID == 0 { + continue + } + if ranges.Len() != 0 { + fmt.Fprintf(&ranges, ", ") + } + fmt.Fprintf(&ranges, "%s", roachpb.RangeID(rangeID)) + } + + if ranges.Len() > 0 { + log.Infof(ctx, "currently migrating lock table on ranges %s", ranges.String()) + } + + case <-m.done: + return + case <-ctx.Done(): + return + } + } +} + +func separatedIntentsMigration( + ctx context.Context, cv clusterversion.ClusterVersion, h migration.Cluster, +) error { + var numMigratedRanges int + stopper := h.Stopper() + if stopper == nil { + // This is a SQL-only node and would not need a migration. + log.Infof(ctx, + "skipping separated intents migration as running on a SQL only node", + ) + return nil + } + + ir := intentresolver.New(intentresolver.Config{ + Clock: h.DB().Clock(), + Stopper: h.Stopper(), + RangeDescriptorCache: h.DistSender().RangeDescriptorCache(), + DB: h.DB(), + }) + workerPool := migrateLockTablePool{ + requests: make(chan migrateLockTableRequest), + stopper: h.Stopper(), + db: h.DB(), + ir: ir, + } + + workerPool.wg.Add(concurrentMigrateLockTableRequests) + for i := 0; i < concurrentMigrateLockTableRequests; i++ { + idx := i // Copy for closure below. + taskName := fmt.Sprintf("migrate-lock-table-%d", i) + if err := stopper.RunAsyncTask(ctx, taskName, func(ctx context.Context) { + workerPool.run(ctx, idx) + }); err != nil { + return err + } + } + ri := kvcoord.NewRangeIterator(h.DistSender()) + rs := roachpb.RSpan{Key: roachpb.RKeyMin, EndKey: roachpb.RKeyMax} + for ri.Seek(ctx, roachpb.RKeyMin, kvcoord.Ascending); ri.Valid(); ri.Next(ctx) { + desc := ri.Desc() + start, end := desc.StartKey, desc.EndKey + if bytes.Compare(desc.StartKey, keys.LocalMax) < 0 { + start, _ = keys.Addr(keys.LocalMax) + } + // Check if this range only contains timeseries keys. If it is, we can + // just skip it - it will not contain any intents. + if bytes.HasPrefix(start, keys.TimeseriesPrefix) && bytes.HasPrefix(end, keys.TimeseriesPrefix) { + continue + } + workerPool.requests <- migrateLockTableRequest{ + start: start, + end: end, + debugRangeID: desc.RangeID, + } + + // Also enqueue a request for range local keys. + var rangeKeyStart, rangeKeyEnd roachpb.RKey + var err error + rangeKeyStart, err = keys.Addr(keys.MakeRangeKeyPrefix(start)) + if err != nil { + return errors.Wrap(err, "error when constructing range key") + } + rangeKeyEnd, err = keys.Addr(keys.MakeRangeKeyPrefix(end)) + if err != nil { + return errors.Wrap(err, "error when constructing range key") + } + + workerPool.requests <- migrateLockTableRequest{ + start: rangeKeyStart, + end: rangeKeyEnd, + debugRangeID: desc.RangeID, + } + numMigratedRanges++ + + if !ri.NeedAnother(rs) { + break + } + } + if err := ri.Error(); err != nil { + log.Errorf(ctx, "error when iterating through ranges in lock table migration: %s", err) + close(workerPool.requests) + workerPool.wg.Wait() + return err + } + workerPool.startStatusLogger(ctx) + + close(workerPool.requests) + workerPool.wg.Wait() + workerPool.stopStatusLogger(ctx) + + if workerPool.mu.combinedErr != nil { + return workerPool.mu.combinedErr + } + + log.Infof(ctx, "finished lock table migrations for %d ranges", numMigratedRanges) + return nil +} + +func postSeparatedIntentsMigration( + ctx context.Context, cv clusterversion.ClusterVersion, h migration.Cluster, +) error { + var batchIdx, numMigratedRanges int + init := func() { batchIdx, numMigratedRanges = 1, 0 } + + // Issue no-op Migrate commands to all ranges. This has the only + // purpose of clearing out any orphaned replicas, preventing interleaved + // intents in them from resurfacing. + if err := h.IterateRangeDescriptors(ctx, defaultPageSize, init, func(descriptors ...roachpb.RangeDescriptor) error { + for _, desc := range descriptors { + start, end := desc.StartKey, desc.EndKey + if bytes.Compare(desc.StartKey, keys.LocalMax) < 0 { + start, _ = keys.Addr(keys.LocalMax) + } + // Check if this range is a timeseries range. If it is, we can just skip + // it - it will not contain any intents. + if bytes.HasPrefix(start, keys.TimeseriesPrefix) && bytes.HasPrefix(end, keys.TimeseriesPrefix) { + continue + } + if err := h.DB().Migrate(ctx, start, end, cv.Version); err != nil { + return err + } + } + numMigratedRanges += len(descriptors) + log.Infof(ctx, "[batch %d/??] started no-op migrations for %d ranges", batchIdx, numMigratedRanges) + batchIdx++ + return nil + }); err != nil { + return err + } + + log.Infof(ctx, "[batch %d/%d] finished no-op migrations for %d ranges", batchIdx, batchIdx, numMigratedRanges) + + return nil +} diff --git a/pkg/migration/migrations/separated_intents_external_test.go b/pkg/migration/migrations/separated_intents_external_test.go new file mode 100644 index 000000000000..0fc5fad482ec --- /dev/null +++ b/pkg/migration/migrations/separated_intents_external_test.go @@ -0,0 +1,192 @@ +// Copyright 2021 The Cockroach Authors. +// +// Use of this software is governed by the Business Source License +// included in the file licenses/BSL.txt. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0, included in the file +// licenses/APL.txt. + +package migrations_test + +import ( + "context" + "strconv" + "testing" + "time" + + "github.com/cockroachdb/cockroach/pkg/base" + "github.com/cockroachdb/cockroach/pkg/clusterversion" + "github.com/cockroachdb/cockroach/pkg/kv/kvserver" + "github.com/cockroachdb/cockroach/pkg/roachpb" + "github.com/cockroachdb/cockroach/pkg/server" + "github.com/cockroachdb/cockroach/pkg/settings/cluster" + "github.com/cockroachdb/cockroach/pkg/storage" + "github.com/cockroachdb/cockroach/pkg/storage/enginepb" + "github.com/cockroachdb/cockroach/pkg/testutils" + "github.com/cockroachdb/cockroach/pkg/testutils/testcluster" + "github.com/cockroachdb/cockroach/pkg/util/leaktest" + "github.com/cockroachdb/cockroach/pkg/util/protoutil" + "github.com/cockroachdb/errors" + "github.com/stretchr/testify/require" +) + +func TestSeparatedIntentsMigration(t *testing.T) { + defer leaktest.AfterTest(t)() + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + settings := cluster.MakeTestingClusterSettingsWithVersions( + clusterversion.ByKey(clusterversion.PostSeparatedIntentsMigration), + clusterversion.ByKey(clusterversion.SeparatedIntentsMigration-1), + false, /* initializeVersion */ + ) + storage.SeparatedIntentsEnabled.Override(ctx, &settings.SV, false) + stickyEngineRegistry := server.NewStickyInMemEnginesRegistry() + defer stickyEngineRegistry.CloseAllStickyInMemEngines() + const numServers int = 5 + stickyServerArgs := make(map[int]base.TestServerArgs) + for i := 0; i < numServers; i++ { + stickyServerArgs[i] = base.TestServerArgs{ + Settings: settings, + StoreSpecs: []base.StoreSpec{ + { + InMemory: true, + StickyInMemoryEngineID: strconv.FormatInt(int64(i), 10), + }, + }, + Knobs: base.TestingKnobs{ + Server: &server.TestingKnobs{ + DisableAutomaticVersionUpgrade: 1, + BinaryVersionOverride: clusterversion.ByKey(clusterversion.SeparatedIntentsMigration-1), + StickyEngineRegistry: stickyEngineRegistry, + }, + }, + } + } + + tc := testcluster.StartTestCluster(t, numServers, base.TestClusterArgs{ + ServerArgsPerNode: stickyServerArgs, + }) + defer tc.Stopper().Stop(ctx) + require.NoError(t, tc.WaitForFullReplication()) + + // Create tables and databases, and get their IDs. + tdb := tc.ServerConn(0) + + getIntentCount := func(s *kvserver.Store) int { + db := s.Engine() + count := 0 + + iter := db.NewEngineIterator(storage.IterOptions{ + LowerBound: roachpb.KeyMin, + UpperBound: roachpb.KeyMax, + }) + defer iter.Close() + valid, err := iter.SeekEngineKeyGE(storage.EngineKey{Key: roachpb.KeyMin}) + for ; valid && err == nil; valid, err = iter.NextEngineKey() { + key, err := iter.EngineKey() + if err != nil { + t.Fatal(err) + } + if !key.IsMVCCKey() { + continue + } + mvccKey, err := key.ToMVCCKey() + if err != nil { + t.Fatal(err) + } + if !mvccKey.Timestamp.IsEmpty() { + continue + } + val := iter.Value() + meta := enginepb.MVCCMetadata{} + if err := protoutil.Unmarshal(val, &meta); err != nil { + t.Fatal(err) + } + if meta.IsInline() { + continue + } + count++ + } + + return count + } + + _, err := tdb.Exec("CREATE DATABASE test;") + require.NoError(t, err) + _, err = tdb.Exec("CREATE TABLE test.kv (key INTEGER PRIMARY KEY, val STRING NOT NULL);") + require.NoError(t, err) + + // Create a transaction, write a lot of rows (intents), then kill the + // gateway node before + txn, err := tdb.BeginTx(ctx, nil) + require.NoError(t, err) + _, err = txn.Exec("INSERT INTO test.kv SELECT generate_series(1, 100), 'test123';") + require.NoError(t, err) + + interleavedIntentCount := 0 + for i := 0; i < numServers; i++ { + err := tc.Server(i).GetStores().(*kvserver.Stores).VisitStores(func(s *kvserver.Store) error { + interleavedIntentCount += getIntentCount(s) + return nil + }) + require.NoError(t, err) + if interleavedIntentCount > 0 { + // This is all we care about; no need to waste cycles. + break + } + } + require.Greater(t, interleavedIntentCount, 0) + + storage.SeparatedIntentsEnabled.Override(ctx, &settings.SV, true) + require.NoError(t, tc.Restart()) + time.Sleep(10 * time.Second) + require.NoError(t, tc.WaitForFullReplication()) + tdb = tc.ServerConn(0) + + // Check if the interleaved intent count is still > 0. + interleavedIntentCount = 0 + for i := 0; i < numServers; i++ { + err := tc.Server(i).GetStores().(*kvserver.Stores).VisitStores(func(s *kvserver.Store) error { + interleavedIntentCount += getIntentCount(s) + return nil + }) + require.NoError(t, err) + if interleavedIntentCount > 0 { + // This is all we care about; no need to waste cycles. + break + } + } + require.Greater(t, interleavedIntentCount, 0) + + _, err = tdb.Exec(`SET CLUSTER SETTING version = $1`, + clusterversion.ByKey(clusterversion.PostSeparatedIntentsMigration).String()) + require.NoError(t, err) + + time.Sleep(5 * time.Second) + testutils.SucceedsSoon(t, func() error { + interleavedIntentCount := 0 + for i := 0; i < 5; i++ { + err := tc.Server(i).GetStores().(*kvserver.Stores).VisitStores(func(s *kvserver.Store) error { + s.WaitForInit() + if !s.IsStarted() { + return errors.New("store not started") + } + interleavedIntentCount += getIntentCount(s) + return nil + }) + if err != nil { + return err + } + if interleavedIntentCount > 0 { + // This is all we care about; no need to waste cycles. + break + } + } + if interleavedIntentCount > 0 { + return errors.Errorf("expected 0 interleaved intents, got %d", interleavedIntentCount) + } + return nil + }) +} diff --git a/pkg/migration/system_migration.go b/pkg/migration/system_migration.go index aa972d38e70e..751dec6da938 100644 --- a/pkg/migration/system_migration.go +++ b/pkg/migration/system_migration.go @@ -16,8 +16,10 @@ import ( "github.com/cockroachdb/cockroach/pkg/clusterversion" "github.com/cockroachdb/cockroach/pkg/kv" + "github.com/cockroachdb/cockroach/pkg/kv/kvclient/kvcoord" "github.com/cockroachdb/cockroach/pkg/roachpb" "github.com/cockroachdb/cockroach/pkg/server/serverpb" + "github.com/cockroachdb/cockroach/pkg/util/stop" "github.com/cockroachdb/logtags" ) @@ -28,6 +30,13 @@ type Cluster interface { // DB returns access to the kv. DB() *kv.DB + // DistSender returns access to the DistSender for communicating with the + // kv store. + DistSender() *kvcoord.DistSender + + // Stopper returns a reference to a Stopper for spawning new tasks. + Stopper() *stop.Stopper + // ForEveryNode is a short hand to execute the given closure (named by the // informational parameter op) against every node in the cluster at a given // point in time. Given it's possible for nodes to join or leave the cluster diff --git a/pkg/roachpb/api.go b/pkg/roachpb/api.go index ab8e60db5169..41b6bdcce5b8 100644 --- a/pkg/roachpb/api.go +++ b/pkg/roachpb/api.go @@ -694,6 +694,12 @@ func (*AdminVerifyProtectedTimestampRequest) Method() Method { return AdminVerif // Method implements the Request interface. func (*QueryResolvedTimestampRequest) Method() Method { return QueryResolvedTimestamp } +// Method implements the Request interface. +func (*ScanInterleavedIntentsRequest) Method() Method { return ScanInterleavedIntents } + +// Method implements the Request interface. +func (*BarrierRequest) Method() Method { return Barrier } + // ShallowCopy implements the Request interface. func (gr *GetRequest) ShallowCopy() Request { shallowCopy := *gr @@ -958,6 +964,18 @@ func (r *QueryResolvedTimestampRequest) ShallowCopy() Request { return &shallowCopy } +// ShallowCopy implements the Request interface. +func (r *ScanInterleavedIntentsRequest) ShallowCopy() Request { + shallowCopy := *r + return &shallowCopy +} + +// ShallowCopy implements the Request interface. +func (r *BarrierRequest) ShallowCopy() Request { + shallowCopy := *r + return &shallowCopy +} + // NewGet returns a Request initialized to get the value at key. If // forUpdate is true, an unreplicated, exclusive lock is acquired on on // the key, if it exists. @@ -1302,6 +1320,8 @@ func (r *RefreshRangeRequest) flags() int { func (*SubsumeRequest) flags() int { return isRead | isAlone | updatesTSCache } func (*RangeStatsRequest) flags() int { return isRead } func (*QueryResolvedTimestampRequest) flags() int { return isRead | isRange } +func (*ScanInterleavedIntentsRequest) flags() int { return isRead | isRange } +func (*BarrierRequest) flags() int { return isWrite | isRange } // IsParallelCommit returns whether the EndTxn request is attempting to perform // a parallel commit. See txn_interceptor_committer.go for a discussion about diff --git a/pkg/roachpb/api.pb.go b/pkg/roachpb/api.pb.go index b45dd084a018..3852b54b514a 100644 --- a/pkg/roachpb/api.pb.go +++ b/pkg/roachpb/api.pb.go @@ -369,7 +369,7 @@ func (x AdmissionHeader_Source) String() string { } func (AdmissionHeader_Source) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{97, 0} + return fileDescriptor_e08772acc330f58b, []int{101, 0} } // RequestHeader is supplied with every storage node request. @@ -4955,6 +4955,153 @@ func (m *QueryResolvedTimestampResponse) XXX_DiscardUnknown() { var xxx_messageInfo_QueryResolvedTimestampResponse proto.InternalMessageInfo +// ScanInterleavedIntentsRequest is the request for a ScanInterleavedIntents operation. +// This is a read-only operation that returns all interleaved (non-separated) +// intents found over the request range. +type ScanInterleavedIntentsRequest struct { + RequestHeader `protobuf:"bytes,1,opt,name=header,proto3,embedded=header" json:"header"` +} + +func (m *ScanInterleavedIntentsRequest) Reset() { *m = ScanInterleavedIntentsRequest{} } +func (m *ScanInterleavedIntentsRequest) String() string { return proto.CompactTextString(m) } +func (*ScanInterleavedIntentsRequest) ProtoMessage() {} +func (*ScanInterleavedIntentsRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e08772acc330f58b, []int{94} +} +func (m *ScanInterleavedIntentsRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScanInterleavedIntentsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ScanInterleavedIntentsRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScanInterleavedIntentsRequest.Merge(m, src) +} +func (m *ScanInterleavedIntentsRequest) XXX_Size() int { + return m.Size() +} +func (m *ScanInterleavedIntentsRequest) XXX_DiscardUnknown() { + xxx_messageInfo_ScanInterleavedIntentsRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_ScanInterleavedIntentsRequest proto.InternalMessageInfo + +// ScanInterleavedIntentsResponse is the response to a ScanInterleavedIntents operation. +type ScanInterleavedIntentsResponse struct { + ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3,embedded=header" json:"header"` + // The intent rows encountered in the part of the request span that was + // evaluated. A resume span is set in the response header if the entirety of + // the request span was not evaluated. + IntentRows []KeyValue `protobuf:"bytes,3,rep,name=intent_rows,json=intentRows,proto3" json:"intent_rows"` +} + +func (m *ScanInterleavedIntentsResponse) Reset() { *m = ScanInterleavedIntentsResponse{} } +func (m *ScanInterleavedIntentsResponse) String() string { return proto.CompactTextString(m) } +func (*ScanInterleavedIntentsResponse) ProtoMessage() {} +func (*ScanInterleavedIntentsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e08772acc330f58b, []int{95} +} +func (m *ScanInterleavedIntentsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ScanInterleavedIntentsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ScanInterleavedIntentsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_ScanInterleavedIntentsResponse.Merge(m, src) +} +func (m *ScanInterleavedIntentsResponse) XXX_Size() int { + return m.Size() +} +func (m *ScanInterleavedIntentsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_ScanInterleavedIntentsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_ScanInterleavedIntentsResponse proto.InternalMessageInfo + +// BarrierRequest is the request for a Barrier operation. This goes through Raft +// and has the purpose of waiting until all in-flight write operations on this +// range have completed, without blocking any new operations. +type BarrierRequest struct { + RequestHeader `protobuf:"bytes,1,opt,name=header,proto3,embedded=header" json:"header"` +} + +func (m *BarrierRequest) Reset() { *m = BarrierRequest{} } +func (m *BarrierRequest) String() string { return proto.CompactTextString(m) } +func (*BarrierRequest) ProtoMessage() {} +func (*BarrierRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e08772acc330f58b, []int{96} +} +func (m *BarrierRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BarrierRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *BarrierRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_BarrierRequest.Merge(m, src) +} +func (m *BarrierRequest) XXX_Size() int { + return m.Size() +} +func (m *BarrierRequest) XXX_DiscardUnknown() { + xxx_messageInfo_BarrierRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_BarrierRequest proto.InternalMessageInfo + +// BarrierResponse is the response for a Barrier operation. +type BarrierResponse struct { + ResponseHeader `protobuf:"bytes,1,opt,name=header,proto3,embedded=header" json:"header"` + // Timestamp at which this Barrier was evaluated. Can be used to guarantee + // future operations happen on the same or newer leaseholders. + Timestamp hlc.Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp"` +} + +func (m *BarrierResponse) Reset() { *m = BarrierResponse{} } +func (m *BarrierResponse) String() string { return proto.CompactTextString(m) } +func (*BarrierResponse) ProtoMessage() {} +func (*BarrierResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e08772acc330f58b, []int{97} +} +func (m *BarrierResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BarrierResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *BarrierResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_BarrierResponse.Merge(m, src) +} +func (m *BarrierResponse) XXX_Size() int { + return m.Size() +} +func (m *BarrierResponse) XXX_DiscardUnknown() { + xxx_messageInfo_BarrierResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_BarrierResponse proto.InternalMessageInfo + // A RequestUnion contains exactly one of the requests. // The values added here must match those in ResponseUnion. // @@ -5006,6 +5153,8 @@ type RequestUnion struct { // *RequestUnion_AdminVerifyProtectedTimestamp // *RequestUnion_Migrate // *RequestUnion_QueryResolvedTimestamp + // *RequestUnion_ScanInterleavedIntents + // *RequestUnion_Barrier Value isRequestUnion_Value `protobuf_oneof:"value"` } @@ -5013,7 +5162,7 @@ func (m *RequestUnion) Reset() { *m = RequestUnion{} } func (m *RequestUnion) String() string { return proto.CompactTextString(m) } func (*RequestUnion) ProtoMessage() {} func (*RequestUnion) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{94} + return fileDescriptor_e08772acc330f58b, []int{98} } func (m *RequestUnion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5176,6 +5325,12 @@ type RequestUnion_Migrate struct { type RequestUnion_QueryResolvedTimestamp struct { QueryResolvedTimestamp *QueryResolvedTimestampRequest `protobuf:"bytes,51,opt,name=query_resolved_timestamp,json=queryResolvedTimestamp,proto3,oneof" json:"query_resolved_timestamp,omitempty"` } +type RequestUnion_ScanInterleavedIntents struct { + ScanInterleavedIntents *ScanInterleavedIntentsRequest `protobuf:"bytes,52,opt,name=scan_interleaved_intents,json=scanInterleavedIntents,proto3,oneof" json:"scan_interleaved_intents,omitempty"` +} +type RequestUnion_Barrier struct { + Barrier *BarrierRequest `protobuf:"bytes,53,opt,name=barrier,proto3,oneof" json:"barrier,omitempty"` +} func (*RequestUnion_Get) isRequestUnion_Value() {} func (*RequestUnion_Put) isRequestUnion_Value() {} @@ -5221,6 +5376,8 @@ func (*RequestUnion_RangeStats) isRequestUnion_Value() {} func (*RequestUnion_AdminVerifyProtectedTimestamp) isRequestUnion_Value() {} func (*RequestUnion_Migrate) isRequestUnion_Value() {} func (*RequestUnion_QueryResolvedTimestamp) isRequestUnion_Value() {} +func (*RequestUnion_ScanInterleavedIntents) isRequestUnion_Value() {} +func (*RequestUnion_Barrier) isRequestUnion_Value() {} func (m *RequestUnion) GetValue() isRequestUnion_Value { if m != nil { @@ -5537,6 +5694,20 @@ func (m *RequestUnion) GetQueryResolvedTimestamp() *QueryResolvedTimestampReques return nil } +func (m *RequestUnion) GetScanInterleavedIntents() *ScanInterleavedIntentsRequest { + if x, ok := m.GetValue().(*RequestUnion_ScanInterleavedIntents); ok { + return x.ScanInterleavedIntents + } + return nil +} + +func (m *RequestUnion) GetBarrier() *BarrierRequest { + if x, ok := m.GetValue().(*RequestUnion_Barrier); ok { + return x.Barrier + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*RequestUnion) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -5584,6 +5755,8 @@ func (*RequestUnion) XXX_OneofWrappers() []interface{} { (*RequestUnion_AdminVerifyProtectedTimestamp)(nil), (*RequestUnion_Migrate)(nil), (*RequestUnion_QueryResolvedTimestamp)(nil), + (*RequestUnion_ScanInterleavedIntents)(nil), + (*RequestUnion_Barrier)(nil), } } @@ -5634,6 +5807,8 @@ type ResponseUnion struct { // *ResponseUnion_AdminVerifyProtectedTimestamp // *ResponseUnion_Migrate // *ResponseUnion_QueryResolvedTimestamp + // *ResponseUnion_ScanInterleavedIntents + // *ResponseUnion_Barrier Value isResponseUnion_Value `protobuf_oneof:"value"` } @@ -5641,7 +5816,7 @@ func (m *ResponseUnion) Reset() { *m = ResponseUnion{} } func (m *ResponseUnion) String() string { return proto.CompactTextString(m) } func (*ResponseUnion) ProtoMessage() {} func (*ResponseUnion) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{95} + return fileDescriptor_e08772acc330f58b, []int{99} } func (m *ResponseUnion) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5801,6 +5976,12 @@ type ResponseUnion_Migrate struct { type ResponseUnion_QueryResolvedTimestamp struct { QueryResolvedTimestamp *QueryResolvedTimestampResponse `protobuf:"bytes,51,opt,name=query_resolved_timestamp,json=queryResolvedTimestamp,proto3,oneof" json:"query_resolved_timestamp,omitempty"` } +type ResponseUnion_ScanInterleavedIntents struct { + ScanInterleavedIntents *ScanInterleavedIntentsResponse `protobuf:"bytes,52,opt,name=scan_interleaved_intents,json=scanInterleavedIntents,proto3,oneof" json:"scan_interleaved_intents,omitempty"` +} +type ResponseUnion_Barrier struct { + Barrier *BarrierResponse `protobuf:"bytes,53,opt,name=barrier,proto3,oneof" json:"barrier,omitempty"` +} func (*ResponseUnion_Get) isResponseUnion_Value() {} func (*ResponseUnion_Put) isResponseUnion_Value() {} @@ -5845,6 +6026,8 @@ func (*ResponseUnion_RangeStats) isResponseUnion_Value() {} func (*ResponseUnion_AdminVerifyProtectedTimestamp) isResponseUnion_Value() {} func (*ResponseUnion_Migrate) isResponseUnion_Value() {} func (*ResponseUnion_QueryResolvedTimestamp) isResponseUnion_Value() {} +func (*ResponseUnion_ScanInterleavedIntents) isResponseUnion_Value() {} +func (*ResponseUnion_Barrier) isResponseUnion_Value() {} func (m *ResponseUnion) GetValue() isResponseUnion_Value { if m != nil { @@ -6154,6 +6337,20 @@ func (m *ResponseUnion) GetQueryResolvedTimestamp() *QueryResolvedTimestampRespo return nil } +func (m *ResponseUnion) GetScanInterleavedIntents() *ScanInterleavedIntentsResponse { + if x, ok := m.GetValue().(*ResponseUnion_ScanInterleavedIntents); ok { + return x.ScanInterleavedIntents + } + return nil +} + +func (m *ResponseUnion) GetBarrier() *BarrierResponse { + if x, ok := m.GetValue().(*ResponseUnion_Barrier); ok { + return x.Barrier + } + return nil +} + // XXX_OneofWrappers is for the internal use of the proto package. func (*ResponseUnion) XXX_OneofWrappers() []interface{} { return []interface{}{ @@ -6200,6 +6397,8 @@ func (*ResponseUnion) XXX_OneofWrappers() []interface{} { (*ResponseUnion_AdminVerifyProtectedTimestamp)(nil), (*ResponseUnion_Migrate)(nil), (*ResponseUnion_QueryResolvedTimestamp)(nil), + (*ResponseUnion_ScanInterleavedIntents)(nil), + (*ResponseUnion_Barrier)(nil), } } @@ -6363,7 +6562,7 @@ func (m *Header) Reset() { *m = Header{} } func (m *Header) String() string { return proto.CompactTextString(m) } func (*Header) ProtoMessage() {} func (*Header) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{96} + return fileDescriptor_e08772acc330f58b, []int{100} } func (m *Header) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6404,7 +6603,7 @@ func (m *AdmissionHeader) Reset() { *m = AdmissionHeader{} } func (m *AdmissionHeader) String() string { return proto.CompactTextString(m) } func (*AdmissionHeader) ProtoMessage() {} func (*AdmissionHeader) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{97} + return fileDescriptor_e08772acc330f58b, []int{101} } func (m *AdmissionHeader) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6441,7 +6640,7 @@ type BatchRequest struct { func (m *BatchRequest) Reset() { *m = BatchRequest{} } func (*BatchRequest) ProtoMessage() {} func (*BatchRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{98} + return fileDescriptor_e08772acc330f58b, []int{102} } func (m *BatchRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6478,7 +6677,7 @@ type BatchResponse struct { func (m *BatchResponse) Reset() { *m = BatchResponse{} } func (*BatchResponse) ProtoMessage() {} func (*BatchResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{99} + return fileDescriptor_e08772acc330f58b, []int{103} } func (m *BatchResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6554,7 +6753,7 @@ func (m *BatchResponse_Header) Reset() { *m = BatchResponse_Header{} } func (m *BatchResponse_Header) String() string { return proto.CompactTextString(m) } func (*BatchResponse_Header) ProtoMessage() {} func (*BatchResponse_Header) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{99, 0} + return fileDescriptor_e08772acc330f58b, []int{103, 0} } func (m *BatchResponse_Header) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6592,7 +6791,7 @@ func (m *RangeLookupRequest) Reset() { *m = RangeLookupRequest{} } func (m *RangeLookupRequest) String() string { return proto.CompactTextString(m) } func (*RangeLookupRequest) ProtoMessage() {} func (*RangeLookupRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{100} + return fileDescriptor_e08772acc330f58b, []int{104} } func (m *RangeLookupRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6630,7 +6829,7 @@ func (m *RangeLookupResponse) Reset() { *m = RangeLookupResponse{} } func (m *RangeLookupResponse) String() string { return proto.CompactTextString(m) } func (*RangeLookupResponse) ProtoMessage() {} func (*RangeLookupResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{101} + return fileDescriptor_e08772acc330f58b, []int{105} } func (m *RangeLookupResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6672,7 +6871,7 @@ func (m *RangeFeedRequest) Reset() { *m = RangeFeedRequest{} } func (m *RangeFeedRequest) String() string { return proto.CompactTextString(m) } func (*RangeFeedRequest) ProtoMessage() {} func (*RangeFeedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{102} + return fileDescriptor_e08772acc330f58b, []int{106} } func (m *RangeFeedRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6713,7 +6912,7 @@ func (m *RangeFeedValue) Reset() { *m = RangeFeedValue{} } func (m *RangeFeedValue) String() string { return proto.CompactTextString(m) } func (*RangeFeedValue) ProtoMessage() {} func (*RangeFeedValue) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{103} + return fileDescriptor_e08772acc330f58b, []int{107} } func (m *RangeFeedValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6754,7 +6953,7 @@ func (m *RangeFeedCheckpoint) Reset() { *m = RangeFeedCheckpoint{} } func (m *RangeFeedCheckpoint) String() string { return proto.CompactTextString(m) } func (*RangeFeedCheckpoint) ProtoMessage() {} func (*RangeFeedCheckpoint) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{104} + return fileDescriptor_e08772acc330f58b, []int{108} } func (m *RangeFeedCheckpoint) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6791,7 +6990,7 @@ func (m *RangeFeedError) Reset() { *m = RangeFeedError{} } func (m *RangeFeedError) String() string { return proto.CompactTextString(m) } func (*RangeFeedError) ProtoMessage() {} func (*RangeFeedError) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{105} + return fileDescriptor_e08772acc330f58b, []int{109} } func (m *RangeFeedError) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6828,7 +7027,7 @@ func (m *RangeFeedEvent) Reset() { *m = RangeFeedEvent{} } func (m *RangeFeedEvent) String() string { return proto.CompactTextString(m) } func (*RangeFeedEvent) ProtoMessage() {} func (*RangeFeedEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{106} + return fileDescriptor_e08772acc330f58b, []int{110} } func (m *RangeFeedEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6872,7 +7071,7 @@ func (m *ResetQuorumRequest) Reset() { *m = ResetQuorumRequest{} } func (m *ResetQuorumRequest) String() string { return proto.CompactTextString(m) } func (*ResetQuorumRequest) ProtoMessage() {} func (*ResetQuorumRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{107} + return fileDescriptor_e08772acc330f58b, []int{111} } func (m *ResetQuorumRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6904,7 +7103,7 @@ func (m *ResetQuorumResponse) Reset() { *m = ResetQuorumResponse{} } func (m *ResetQuorumResponse) String() string { return proto.CompactTextString(m) } func (*ResetQuorumResponse) ProtoMessage() {} func (*ResetQuorumResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{108} + return fileDescriptor_e08772acc330f58b, []int{112} } func (m *ResetQuorumResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6945,7 +7144,7 @@ func (m *GossipSubscriptionRequest) Reset() { *m = GossipSubscriptionReq func (m *GossipSubscriptionRequest) String() string { return proto.CompactTextString(m) } func (*GossipSubscriptionRequest) ProtoMessage() {} func (*GossipSubscriptionRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{109} + return fileDescriptor_e08772acc330f58b, []int{113} } func (m *GossipSubscriptionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6985,7 +7184,7 @@ func (m *GossipSubscriptionEvent) Reset() { *m = GossipSubscriptionEvent func (m *GossipSubscriptionEvent) String() string { return proto.CompactTextString(m) } func (*GossipSubscriptionEvent) ProtoMessage() {} func (*GossipSubscriptionEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{110} + return fileDescriptor_e08772acc330f58b, []int{114} } func (m *GossipSubscriptionEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7020,7 +7219,7 @@ func (m *TokenBucketRequest) Reset() { *m = TokenBucketRequest{} } func (m *TokenBucketRequest) String() string { return proto.CompactTextString(m) } func (*TokenBucketRequest) ProtoMessage() {} func (*TokenBucketRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{111} + return fileDescriptor_e08772acc330f58b, []int{115} } func (m *TokenBucketRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7058,7 +7257,7 @@ func (m *TokenBucketRequest_Consumption) Reset() { *m = TokenBucketReque func (m *TokenBucketRequest_Consumption) String() string { return proto.CompactTextString(m) } func (*TokenBucketRequest_Consumption) ProtoMessage() {} func (*TokenBucketRequest_Consumption) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{111, 0} + return fileDescriptor_e08772acc330f58b, []int{115, 0} } func (m *TokenBucketRequest_Consumption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7094,7 +7293,7 @@ func (m *TokenBucketResponse) Reset() { *m = TokenBucketResponse{} } func (m *TokenBucketResponse) String() string { return proto.CompactTextString(m) } func (*TokenBucketResponse) ProtoMessage() {} func (*TokenBucketResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{112} + return fileDescriptor_e08772acc330f58b, []int{116} } func (m *TokenBucketResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7130,7 +7329,7 @@ func (m *JoinNodeRequest) Reset() { *m = JoinNodeRequest{} } func (m *JoinNodeRequest) String() string { return proto.CompactTextString(m) } func (*JoinNodeRequest) ProtoMessage() {} func (*JoinNodeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{113} + return fileDescriptor_e08772acc330f58b, []int{117} } func (m *JoinNodeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7169,7 +7368,7 @@ func (m *JoinNodeResponse) Reset() { *m = JoinNodeResponse{} } func (m *JoinNodeResponse) String() string { return proto.CompactTextString(m) } func (*JoinNodeResponse) ProtoMessage() {} func (*JoinNodeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{114} + return fileDescriptor_e08772acc330f58b, []int{118} } func (m *JoinNodeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7209,7 +7408,7 @@ type ContentionEvent struct { func (m *ContentionEvent) Reset() { *m = ContentionEvent{} } func (*ContentionEvent) ProtoMessage() {} func (*ContentionEvent) Descriptor() ([]byte, []int) { - return fileDescriptor_e08772acc330f58b, []int{115} + return fileDescriptor_e08772acc330f58b, []int{119} } func (m *ContentionEvent) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7351,6 +7550,10 @@ func init() { proto.RegisterType((*MigrateResponse)(nil), "cockroach.roachpb.MigrateResponse") proto.RegisterType((*QueryResolvedTimestampRequest)(nil), "cockroach.roachpb.QueryResolvedTimestampRequest") proto.RegisterType((*QueryResolvedTimestampResponse)(nil), "cockroach.roachpb.QueryResolvedTimestampResponse") + proto.RegisterType((*ScanInterleavedIntentsRequest)(nil), "cockroach.roachpb.ScanInterleavedIntentsRequest") + proto.RegisterType((*ScanInterleavedIntentsResponse)(nil), "cockroach.roachpb.ScanInterleavedIntentsResponse") + proto.RegisterType((*BarrierRequest)(nil), "cockroach.roachpb.BarrierRequest") + proto.RegisterType((*BarrierResponse)(nil), "cockroach.roachpb.BarrierResponse") proto.RegisterType((*RequestUnion)(nil), "cockroach.roachpb.RequestUnion") proto.RegisterType((*ResponseUnion)(nil), "cockroach.roachpb.ResponseUnion") proto.RegisterType((*Header)(nil), "cockroach.roachpb.Header") @@ -7380,538 +7583,546 @@ func init() { func init() { proto.RegisterFile("roachpb/api.proto", fileDescriptor_e08772acc330f58b) } var fileDescriptor_e08772acc330f58b = []byte{ - // 8496 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7d, 0x5f, 0x6c, 0x23, 0x49, - 0x7a, 0x9f, 0x9a, 0xa4, 0x24, 0xf2, 0xa3, 0x44, 0xb6, 0x4a, 0xf3, 0x47, 0xa3, 0xd9, 0x95, 0x66, - 0x7a, 0x76, 0xfe, 0xfa, 0x96, 0xda, 0x99, 0xb9, 0xcb, 0xae, 0x77, 0xd7, 0x7b, 0x16, 0x29, 0xce, - 0x90, 0xd2, 0x48, 0xa3, 0x69, 0x52, 0x33, 0xd8, 0xf5, 0x39, 0xed, 0x56, 0x77, 0x49, 0xea, 0x13, - 0xd9, 0xcd, 0xe9, 0x6e, 0x6a, 0xc4, 0x45, 0xf2, 0x90, 0xc4, 0x70, 0xee, 0x29, 0xb8, 0x00, 0x01, - 0xbc, 0x07, 0x07, 0xc1, 0xf9, 0x0f, 0x92, 0x87, 0x3c, 0x38, 0x48, 0x82, 0x04, 0x0e, 0x92, 0x18, - 0xc9, 0x4b, 0x0e, 0xc1, 0x21, 0x77, 0x7e, 0x33, 0x02, 0x44, 0x71, 0x74, 0x79, 0x88, 0x61, 0x04, - 0x0e, 0x82, 0x00, 0x06, 0x16, 0x48, 0x10, 0xd4, 0x9f, 0xfe, 0x47, 0x36, 0x29, 0x6a, 0xa6, 0x37, - 0x59, 0xe0, 0x5e, 0x24, 0xf6, 0x57, 0xf5, 0x7d, 0x5d, 0xf5, 0x55, 0xd5, 0x57, 0xdf, 0xaf, 0xea, - 0xab, 0x6a, 0x98, 0xb3, 0x2d, 0x55, 0x3b, 0xe8, 0xec, 0xae, 0xa8, 0x1d, 0xa3, 0xd4, 0xb1, 0x2d, - 0xd7, 0x42, 0x73, 0x9a, 0xa5, 0x1d, 0x52, 0x72, 0x89, 0x27, 0x2e, 0x5e, 0xc4, 0xb6, 0x6d, 0xd9, - 0x4e, 0x67, 0x77, 0x85, 0xfd, 0x60, 0x39, 0x17, 0xef, 0x1d, 0x1e, 0xad, 0x1c, 0x1e, 0x39, 0xd8, - 0x3e, 0xc2, 0xf6, 0x8a, 0x66, 0x99, 0x5a, 0xd7, 0xb6, 0xb1, 0xa9, 0xf5, 0x56, 0x5a, 0x96, 0x76, - 0x48, 0xff, 0x18, 0xe6, 0x7e, 0x5c, 0x5e, 0x1b, 0xab, 0xba, 0xd3, 0x6d, 0xb7, 0x55, 0xbb, 0xb7, - 0x42, 0xc5, 0xf2, 0x07, 0x9e, 0x17, 0x79, 0x85, 0xd2, 0x55, 0x57, 0xe5, 0xb4, 0x0b, 0x1e, 0x2d, - 0x52, 0x82, 0x4b, 0x1e, 0xb5, 0x8d, 0x5d, 0x35, 0x94, 0xfb, 0xaa, 0xe3, 0x5a, 0xb6, 0xba, 0x8f, - 0x57, 0xb0, 0xb9, 0x6f, 0x98, 0x98, 0x64, 0x38, 0xd2, 0x34, 0x9e, 0xf8, 0x56, 0x6c, 0xe2, 0x43, - 0x9e, 0xba, 0xd0, 0x75, 0x8d, 0xd6, 0xca, 0x41, 0x4b, 0x5b, 0x71, 0x8d, 0x36, 0x76, 0x5c, 0xb5, - 0xdd, 0xf1, 0xaa, 0x40, 0x53, 0x5c, 0x5b, 0xd5, 0x0c, 0x73, 0xdf, 0xfb, 0xdf, 0xd9, 0x5d, 0xb1, - 0xb1, 0x66, 0xd9, 0x3a, 0xd6, 0x15, 0xa7, 0xa3, 0x9a, 0x5e, 0x71, 0xf7, 0xad, 0x7d, 0x8b, 0xfe, - 0x5c, 0x21, 0xbf, 0x38, 0x75, 0x69, 0xdf, 0xb2, 0xf6, 0x5b, 0x78, 0x85, 0x3e, 0xed, 0x76, 0xf7, - 0x56, 0xf4, 0xae, 0xad, 0xba, 0x86, 0xc5, 0xb9, 0xa4, 0x7f, 0x26, 0xc0, 0xac, 0x8c, 0x5f, 0x76, - 0xb1, 0xe3, 0xd6, 0xb0, 0xaa, 0x63, 0x1b, 0x5d, 0x81, 0xf4, 0x21, 0xee, 0x2d, 0xa4, 0xaf, 0x09, - 0x77, 0x66, 0xca, 0xd3, 0x5f, 0x9e, 0x2c, 0xa7, 0x37, 0x70, 0x4f, 0x26, 0x34, 0x74, 0x0d, 0xa6, - 0xb1, 0xa9, 0x2b, 0x24, 0x39, 0x13, 0x4d, 0x9e, 0xc2, 0xa6, 0xbe, 0x81, 0x7b, 0xe8, 0x3b, 0x90, - 0x75, 0x88, 0x34, 0x53, 0xc3, 0x0b, 0x93, 0xd7, 0x84, 0x3b, 0x93, 0xe5, 0x5f, 0xfe, 0xf2, 0x64, - 0xf9, 0xe3, 0x7d, 0xc3, 0x3d, 0xe8, 0xee, 0x96, 0x34, 0xab, 0xbd, 0xe2, 0x37, 0xb5, 0xbe, 0x1b, - 0xfc, 0x5e, 0xe9, 0x1c, 0xee, 0xaf, 0xf4, 0xeb, 0xa8, 0xd4, 0x3c, 0x36, 0x1b, 0xf8, 0xa5, 0xec, - 0x4b, 0x5c, 0xcf, 0x64, 0x05, 0x31, 0xb5, 0x9e, 0xc9, 0xa6, 0xc4, 0xb4, 0xf4, 0x93, 0x14, 0x14, - 0x64, 0xec, 0x74, 0x2c, 0xd3, 0xc1, 0xbc, 0xe4, 0xef, 0x41, 0xda, 0x3d, 0x36, 0x69, 0xc9, 0xf3, - 0x0f, 0x96, 0x4a, 0x03, 0x9d, 0xaa, 0xd4, 0xb4, 0x55, 0xd3, 0x51, 0x35, 0x52, 0x7d, 0x99, 0x64, - 0x45, 0x1f, 0x40, 0xde, 0xc6, 0x4e, 0xb7, 0x8d, 0xa9, 0x22, 0x69, 0xa5, 0xf2, 0x0f, 0x2e, 0xc7, - 0x70, 0x36, 0x3a, 0xaa, 0x29, 0x03, 0xcb, 0x4b, 0x7e, 0xa3, 0x06, 0xcc, 0x72, 0x4e, 0x1b, 0xab, - 0x8e, 0x65, 0x2e, 0x4c, 0x5f, 0x13, 0xee, 0x14, 0x1e, 0x94, 0x62, 0x78, 0xa3, 0xa5, 0x24, 0x8f, - 0xdd, 0x36, 0x96, 0x29, 0x97, 0x3c, 0x63, 0x87, 0x9e, 0xd0, 0x15, 0xc8, 0x9a, 0xdd, 0x36, 0xd1, - 0xaf, 0x43, 0xb5, 0x97, 0x96, 0xa7, 0xcd, 0x6e, 0x7b, 0x03, 0xf7, 0x1c, 0x74, 0x15, 0x72, 0x24, - 0x69, 0xb7, 0xe7, 0x62, 0x67, 0x21, 0x4b, 0xd3, 0x48, 0xde, 0x32, 0x79, 0x96, 0x3e, 0x81, 0x99, - 0xb0, 0x54, 0x84, 0xa0, 0x20, 0x57, 0x1b, 0x3b, 0x9b, 0x55, 0x65, 0x67, 0x6b, 0x63, 0xeb, 0xe9, - 0x8b, 0x2d, 0x71, 0x02, 0x5d, 0x00, 0x91, 0xd3, 0x36, 0xaa, 0x9f, 0x2a, 0x4f, 0xea, 0x9b, 0xf5, - 0xa6, 0x28, 0x2c, 0x66, 0xbe, 0xf7, 0xbb, 0x4b, 0x13, 0xeb, 0x99, 0xec, 0x94, 0x38, 0x2d, 0xfd, - 0xae, 0x00, 0xf0, 0x18, 0xbb, 0xbc, 0x37, 0xa0, 0x32, 0x4c, 0x1d, 0xd0, 0x12, 0x2f, 0x08, 0x54, - 0x2d, 0xd7, 0x62, 0xab, 0x16, 0xea, 0x39, 0xe5, 0xec, 0x8f, 0x4e, 0x96, 0x27, 0x7e, 0x7a, 0xb2, - 0x2c, 0xc8, 0x9c, 0x13, 0x3d, 0x83, 0xfc, 0x21, 0xee, 0x29, 0x7c, 0x5c, 0x2e, 0xa4, 0xa8, 0x8e, - 0xde, 0x0b, 0x09, 0x3a, 0x3c, 0x2a, 0x79, 0x43, 0xb4, 0x14, 0x1a, 0xce, 0x25, 0xc2, 0x51, 0x6a, - 0xb8, 0x36, 0x36, 0xf7, 0xdd, 0x03, 0x19, 0x0e, 0x71, 0xef, 0x09, 0x93, 0x21, 0xfd, 0xa1, 0x00, - 0x79, 0x5a, 0x4a, 0xa6, 0x54, 0x54, 0xe9, 0x2b, 0xe6, 0xf5, 0x33, 0x5b, 0x20, 0xa6, 0x9c, 0x25, - 0x98, 0x3c, 0x52, 0x5b, 0x5d, 0x4c, 0x4b, 0x98, 0x7f, 0xb0, 0x10, 0x23, 0xe3, 0x39, 0x49, 0x97, - 0x59, 0x36, 0xf4, 0x11, 0xcc, 0x18, 0xa6, 0x8b, 0x4d, 0x57, 0x61, 0x6c, 0xe9, 0x33, 0xd8, 0xf2, - 0x2c, 0x37, 0x7d, 0x90, 0xfe, 0xa9, 0x00, 0xb0, 0xdd, 0x4d, 0x54, 0xcf, 0xdf, 0x1c, 0xb3, 0xfc, - 0xe5, 0x0c, 0x61, 0xf5, 0x6a, 0x71, 0x09, 0xa6, 0x0c, 0xb3, 0x65, 0x98, 0xac, 0xfc, 0x59, 0x99, - 0x3f, 0xa1, 0x0b, 0x30, 0xb9, 0xdb, 0x32, 0x4c, 0x9d, 0x8e, 0x87, 0xac, 0xcc, 0x1e, 0x24, 0x19, - 0xf2, 0xb4, 0xd4, 0x09, 0xea, 0x5d, 0x3a, 0x49, 0xc1, 0xc5, 0x8a, 0x65, 0xea, 0x06, 0x19, 0x92, - 0x6a, 0xeb, 0x6b, 0xa1, 0x95, 0x75, 0xb8, 0xa0, 0xe3, 0x8e, 0x8d, 0x35, 0xd5, 0xc5, 0xba, 0x82, - 0x8f, 0x3b, 0x63, 0xb6, 0x31, 0x0a, 0xb8, 0xaa, 0xc7, 0x1d, 0x4a, 0x23, 0xa3, 0x96, 0x08, 0x60, - 0xa3, 0x76, 0x8a, 0x98, 0x4c, 0x39, 0x8b, 0x8f, 0x3b, 0x74, 0xd4, 0xc6, 0xab, 0x19, 0x7d, 0x13, - 0x2e, 0xab, 0xad, 0x96, 0xf5, 0x4a, 0x31, 0xf6, 0x14, 0xdd, 0xc2, 0x8e, 0x62, 0x5a, 0xae, 0x82, - 0x8f, 0x0d, 0xc7, 0xa5, 0x26, 0x21, 0x2b, 0xcf, 0xd3, 0xe4, 0xfa, 0xde, 0x9a, 0x85, 0x9d, 0x2d, - 0xcb, 0xad, 0x92, 0xa4, 0x50, 0x53, 0x4e, 0x87, 0x9b, 0x52, 0xfa, 0x55, 0xb8, 0xd4, 0xaf, 0xdf, - 0x24, 0xdb, 0xef, 0xc7, 0x02, 0x14, 0xea, 0xa6, 0xe1, 0x7e, 0x2d, 0x1a, 0xce, 0xd7, 0x67, 0x3a, - 0xac, 0xcf, 0x7b, 0x20, 0xee, 0xa9, 0x46, 0xeb, 0xa9, 0xd9, 0xb4, 0xda, 0xbb, 0x8e, 0x6b, 0x99, - 0xd8, 0xe1, 0x0a, 0x1f, 0xa0, 0x4b, 0xcf, 0xa1, 0xe8, 0xd7, 0x26, 0x49, 0x35, 0xb9, 0x20, 0xd6, - 0x4d, 0xcd, 0xc6, 0x6d, 0x6c, 0x26, 0xaa, 0xa7, 0xb7, 0x20, 0x67, 0x78, 0x72, 0xa9, 0xae, 0xd2, - 0x72, 0x40, 0x90, 0xba, 0x30, 0x17, 0x7a, 0x6b, 0x92, 0xe6, 0x92, 0x4c, 0x46, 0xf8, 0x95, 0x12, - 0xb4, 0x11, 0x99, 0x8c, 0xf0, 0x2b, 0x66, 0xde, 0x1a, 0x30, 0xbb, 0x86, 0x5b, 0xd8, 0xc5, 0x09, - 0xd6, 0x54, 0xda, 0x81, 0x82, 0x27, 0x34, 0xc9, 0x86, 0xf9, 0x4d, 0x01, 0x10, 0x97, 0xab, 0x9a, - 0xfb, 0x49, 0x96, 0x18, 0x2d, 0x13, 0xd7, 0xc2, 0xed, 0xda, 0x26, 0x9b, 0xce, 0x59, 0x9f, 0x04, - 0x46, 0xa2, 0x33, 0x7a, 0x30, 0x64, 0x33, 0xe1, 0x21, 0xcb, 0xdd, 0x9b, 0x57, 0x30, 0x1f, 0x29, - 0x58, 0xb2, 0xcd, 0x97, 0xa1, 0x65, 0x4a, 0x5d, 0x4b, 0x87, 0x7d, 0x38, 0x4a, 0x94, 0xbe, 0x10, - 0x60, 0xae, 0xd2, 0xc2, 0xaa, 0x9d, 0xb8, 0x46, 0xbe, 0x0d, 0x59, 0x1d, 0xab, 0x3a, 0xad, 0x32, - 0x1b, 0xd8, 0x6f, 0x87, 0xa4, 0x10, 0x4f, 0xb7, 0x74, 0xd0, 0xd2, 0x4a, 0x4d, 0xcf, 0x07, 0xe6, - 0xa3, 0xdb, 0x67, 0x92, 0x3e, 0x05, 0x14, 0x2e, 0x59, 0x92, 0x1d, 0xe1, 0xf7, 0x52, 0x80, 0x64, - 0x7c, 0x84, 0x6d, 0x37, 0xf1, 0x6a, 0xaf, 0x41, 0xde, 0x55, 0xed, 0x7d, 0xec, 0x2a, 0xc4, 0xbb, - 0x3f, 0x4f, 0xcd, 0x81, 0xf1, 0x11, 0x32, 0x6a, 0xc2, 0x6d, 0x6c, 0xaa, 0xbb, 0x2d, 0x4c, 0xa5, - 0x28, 0xbb, 0x56, 0xd7, 0xd4, 0x15, 0xc3, 0xc5, 0xb6, 0xea, 0x5a, 0xb6, 0x62, 0x75, 0x5c, 0xa3, - 0x6d, 0x7c, 0x4e, 0x1d, 0x7b, 0xde, 0xd5, 0x6e, 0xb0, 0xec, 0x84, 0xb9, 0x4c, 0x32, 0xd7, 0x79, - 0xde, 0xa7, 0xa1, 0xac, 0xa8, 0x04, 0xf3, 0xc6, 0xbe, 0x69, 0xd9, 0x58, 0xd9, 0xd7, 0x14, 0xf7, - 0xc0, 0xc6, 0xce, 0x81, 0xd5, 0xf2, 0x26, 0xa4, 0x39, 0x96, 0xf4, 0x58, 0x6b, 0x7a, 0x09, 0xd2, - 0x67, 0x30, 0x1f, 0xd1, 0x52, 0x92, 0x4d, 0xf0, 0x3f, 0x04, 0xc8, 0x37, 0x34, 0xd5, 0x4c, 0x52, - 0xf7, 0x9f, 0x40, 0xde, 0xd1, 0x54, 0x53, 0xd9, 0xb3, 0xec, 0xb6, 0xea, 0xd2, 0x7a, 0x15, 0x22, - 0xba, 0xf7, 0xfd, 0x7b, 0x4d, 0x35, 0x1f, 0xd1, 0x4c, 0x32, 0x38, 0xfe, 0xef, 0x7e, 0xff, 0x75, - 0xf2, 0xcd, 0xfd, 0x57, 0x36, 0xbc, 0xd7, 0x33, 0xd9, 0xb4, 0x98, 0x91, 0xfe, 0x42, 0x80, 0x19, - 0x56, 0xe5, 0x24, 0x87, 0xf7, 0xb7, 0x20, 0x63, 0x5b, 0xaf, 0xd8, 0xf0, 0xce, 0x3f, 0xb8, 0x1a, - 0x23, 0x62, 0x03, 0xf7, 0xc2, 0xf3, 0x27, 0xcd, 0x8e, 0xca, 0xc0, 0xbd, 0x54, 0x85, 0x72, 0xa7, - 0xc7, 0xe5, 0x06, 0xc6, 0x25, 0x13, 0x19, 0xb7, 0xa1, 0xb8, 0xab, 0xba, 0xda, 0x81, 0x62, 0xf3, - 0x42, 0x92, 0xb9, 0x36, 0x7d, 0x67, 0x46, 0x2e, 0x50, 0xb2, 0x57, 0x74, 0x87, 0xd4, 0x9c, 0x8d, - 0x37, 0x07, 0xff, 0x9c, 0xb5, 0xf9, 0xff, 0x11, 0xf8, 0x18, 0xf2, 0x6a, 0xfe, 0xf3, 0xd6, 0xf4, - 0x3f, 0x48, 0xc1, 0xe5, 0xca, 0x01, 0xd6, 0x0e, 0x2b, 0x96, 0xe9, 0x18, 0x8e, 0x4b, 0x74, 0x97, - 0x64, 0xfb, 0x5f, 0x85, 0xdc, 0x2b, 0xc3, 0x3d, 0x50, 0x74, 0x63, 0x6f, 0x8f, 0x5a, 0xdb, 0xac, - 0x9c, 0x25, 0x84, 0x35, 0x63, 0x6f, 0x0f, 0x3d, 0x84, 0x4c, 0xdb, 0xd2, 0x99, 0x33, 0x5f, 0x78, - 0xb0, 0x1c, 0x23, 0x9e, 0x16, 0xcd, 0xe9, 0xb6, 0x37, 0x2d, 0x1d, 0xcb, 0x34, 0x33, 0x5a, 0x02, - 0xd0, 0x08, 0xb5, 0x63, 0x19, 0xa6, 0xcb, 0x8d, 0x63, 0x88, 0x82, 0x6a, 0x90, 0x73, 0xb1, 0xdd, - 0x36, 0x4c, 0xd5, 0xc5, 0x0b, 0x93, 0x54, 0x79, 0xef, 0xc4, 0x16, 0xbc, 0xd3, 0x32, 0x34, 0x75, - 0x0d, 0x3b, 0x9a, 0x6d, 0x74, 0x5c, 0xcb, 0xe6, 0x5a, 0x0c, 0x98, 0xa5, 0xbf, 0x95, 0x81, 0x85, - 0x41, 0xdd, 0x24, 0xd9, 0x43, 0xb6, 0x61, 0xca, 0xc6, 0x4e, 0xb7, 0xe5, 0xf2, 0x3e, 0xf2, 0x60, - 0x98, 0x0a, 0x62, 0x4a, 0x40, 0x97, 0x2e, 0x5a, 0x2e, 0x2f, 0x36, 0x97, 0xb3, 0xf8, 0x2f, 0x05, - 0x98, 0x62, 0x09, 0xe8, 0x3e, 0x64, 0x6d, 0x32, 0x31, 0x28, 0x86, 0x4e, 0xcb, 0x98, 0x2e, 0x5f, - 0x3a, 0x3d, 0x59, 0x9e, 0xa6, 0x93, 0x45, 0x7d, 0xed, 0xcb, 0xe0, 0xa7, 0x3c, 0x4d, 0xf3, 0xd5, - 0x75, 0xd2, 0x5a, 0x8e, 0xab, 0xda, 0x2e, 0x5d, 0x54, 0x4a, 0x31, 0x84, 0x44, 0x09, 0x1b, 0xb8, - 0x87, 0xd6, 0x61, 0xca, 0x71, 0x55, 0xb7, 0xeb, 0xf0, 0xf6, 0x3a, 0x57, 0x61, 0x1b, 0x94, 0x53, - 0xe6, 0x12, 0x88, 0xbb, 0xa5, 0x63, 0x57, 0x35, 0x5a, 0xb4, 0x01, 0x73, 0x32, 0x7f, 0x92, 0x7e, - 0x4b, 0x80, 0x29, 0x96, 0x15, 0x5d, 0x86, 0x79, 0x79, 0x75, 0xeb, 0x71, 0x55, 0xa9, 0x6f, 0xad, - 0x55, 0x9b, 0x55, 0x79, 0xb3, 0xbe, 0xb5, 0xda, 0xac, 0x8a, 0x13, 0xe8, 0x12, 0x20, 0x2f, 0xa1, - 0xf2, 0x74, 0xab, 0x51, 0x6f, 0x34, 0xab, 0x5b, 0x4d, 0x51, 0xa0, 0x6b, 0x2a, 0x94, 0x1e, 0xa2, - 0xa6, 0xd0, 0x3b, 0x70, 0xad, 0x9f, 0xaa, 0x34, 0x9a, 0xab, 0xcd, 0x86, 0x52, 0x6d, 0x34, 0xeb, - 0x9b, 0xab, 0xcd, 0xea, 0x9a, 0x98, 0x1e, 0x91, 0x8b, 0xbc, 0x44, 0x96, 0xab, 0x95, 0xa6, 0x98, - 0x91, 0x5c, 0xb8, 0x28, 0x63, 0xcd, 0x6a, 0x77, 0xba, 0x2e, 0x26, 0xa5, 0x74, 0x92, 0x1c, 0x29, - 0x97, 0x61, 0x5a, 0xb7, 0x7b, 0x8a, 0xdd, 0x35, 0xf9, 0x38, 0x99, 0xd2, 0xed, 0x9e, 0xdc, 0x35, - 0xa5, 0x7f, 0x24, 0xc0, 0xa5, 0xfe, 0xd7, 0x26, 0xd9, 0x09, 0x9f, 0x41, 0x5e, 0xd5, 0x75, 0xac, - 0x2b, 0x3a, 0x6e, 0xb9, 0x2a, 0x77, 0x89, 0xee, 0x85, 0x24, 0xf1, 0xa5, 0xc0, 0x92, 0xbf, 0x14, - 0xb8, 0xf9, 0xbc, 0x52, 0xa1, 0x05, 0x59, 0x23, 0x1c, 0x9e, 0xf9, 0xa1, 0x42, 0x28, 0x45, 0xfa, - 0x41, 0x06, 0x66, 0xab, 0xa6, 0xde, 0x3c, 0x4e, 0x74, 0x2e, 0xb9, 0x04, 0x53, 0x9a, 0xd5, 0x6e, - 0x1b, 0xae, 0xa7, 0x20, 0xf6, 0x84, 0x7e, 0x31, 0xe4, 0xca, 0xa6, 0xc7, 0x70, 0xe8, 0x02, 0x27, - 0x16, 0xfd, 0x1a, 0x5c, 0x26, 0x56, 0xd3, 0x36, 0xd5, 0x96, 0xc2, 0xa4, 0x29, 0xae, 0x6d, 0xec, - 0xef, 0x63, 0x9b, 0x2f, 0x3f, 0xde, 0x89, 0x29, 0x67, 0x9d, 0x73, 0x54, 0x28, 0x43, 0x93, 0xe5, - 0x97, 0x2f, 0x1a, 0x71, 0x64, 0xf4, 0x31, 0x00, 0x99, 0x8a, 0xe8, 0x92, 0xa6, 0xc3, 0xed, 0xd1, - 0xb0, 0x35, 0x4d, 0xcf, 0x04, 0x11, 0x06, 0xf2, 0xec, 0xa0, 0x67, 0x20, 0x1a, 0xa6, 0xb2, 0xd7, - 0x32, 0xf6, 0x0f, 0x5c, 0xe5, 0x95, 0x6d, 0xb8, 0xd8, 0x59, 0x98, 0xa3, 0x32, 0xe2, 0x9a, 0xba, - 0xc1, 0x97, 0x66, 0xf5, 0x17, 0x24, 0x27, 0x97, 0x56, 0x30, 0xcc, 0x47, 0x94, 0x9f, 0x12, 0x1d, - 0xb4, 0x42, 0xa0, 0xd0, 0xcb, 0xae, 0x61, 0x63, 0xe5, 0x7e, 0x47, 0xa3, 0xeb, 0x20, 0xd9, 0x72, - 0xe1, 0xf4, 0x64, 0x19, 0x64, 0x46, 0xbe, 0xbf, 0x5d, 0x21, 0xd0, 0x88, 0xfd, 0xee, 0x68, 0x44, - 0xed, 0x1d, 0xcb, 0x70, 0x2c, 0x73, 0x21, 0xc7, 0xd4, 0xce, 0x9e, 0xd0, 0x5d, 0x10, 0xdd, 0x63, - 0x53, 0x39, 0xc0, 0xaa, 0xed, 0xee, 0x62, 0xd5, 0x25, 0xf3, 0x33, 0xd0, 0x1c, 0x45, 0xf7, 0xd8, - 0xac, 0x85, 0xc8, 0xeb, 0x99, 0xec, 0xb4, 0x98, 0x5d, 0xcf, 0x64, 0xb3, 0x62, 0x4e, 0xfa, 0x4f, - 0x02, 0x14, 0xbc, 0xbe, 0x91, 0x64, 0x37, 0xbe, 0x03, 0xa2, 0x65, 0x62, 0xa5, 0x73, 0xa0, 0x3a, - 0x98, 0xb7, 0x25, 0x9f, 0x1d, 0x0a, 0x96, 0x89, 0xb7, 0x09, 0x99, 0xb5, 0x0c, 0xda, 0x86, 0x39, - 0xc7, 0x55, 0xf7, 0x0d, 0x73, 0x5f, 0xf1, 0x97, 0xf8, 0xa9, 0x67, 0x31, 0x26, 0x12, 0x10, 0x39, - 0xb7, 0x4f, 0x8f, 0xb8, 0x14, 0x7f, 0x24, 0xc0, 0xdc, 0xaa, 0xde, 0x36, 0xcc, 0x46, 0xa7, 0x65, - 0x24, 0xba, 0xc0, 0xf0, 0x0e, 0xe4, 0x1c, 0x22, 0x33, 0xb0, 0xce, 0x01, 0x5c, 0xcc, 0xd2, 0x14, - 0x62, 0xa6, 0x9f, 0x40, 0x11, 0x1f, 0x77, 0x0c, 0xb6, 0xaf, 0xc0, 0x50, 0x4e, 0x66, 0xfc, 0xba, - 0x15, 0x02, 0x5e, 0x92, 0xc4, 0xeb, 0xf4, 0x29, 0xa0, 0x70, 0x95, 0x92, 0x04, 0x1a, 0x9f, 0xc2, - 0x3c, 0x15, 0xbd, 0x63, 0x3a, 0x09, 0xeb, 0x4b, 0xfa, 0x15, 0xb8, 0x10, 0x15, 0x9d, 0x64, 0xb9, - 0x5f, 0xf0, 0x56, 0xde, 0xc4, 0x76, 0xa2, 0x08, 0xd5, 0xd7, 0x35, 0x17, 0x9c, 0x64, 0x99, 0x7f, - 0x5d, 0x80, 0x2b, 0x54, 0x36, 0xdd, 0x7a, 0xd9, 0xc3, 0xf6, 0x13, 0xac, 0x3a, 0x89, 0xc2, 0xeb, - 0x1b, 0x30, 0xc5, 0x60, 0x32, 0xed, 0x9f, 0x93, 0xe5, 0x3c, 0x71, 0x33, 0x1a, 0xae, 0x65, 0x13, - 0x37, 0x83, 0x27, 0x49, 0x2a, 0x2c, 0xc6, 0x95, 0x22, 0xc9, 0x9a, 0xfe, 0x3d, 0x01, 0xe6, 0xb8, - 0x87, 0x47, 0xba, 0x72, 0xe5, 0x80, 0x38, 0x38, 0xa8, 0x0a, 0x79, 0x8d, 0xfe, 0x52, 0xdc, 0x5e, - 0x07, 0x53, 0xf9, 0x85, 0x51, 0xce, 0x21, 0x63, 0x6b, 0xf6, 0x3a, 0x98, 0x78, 0x98, 0xde, 0x6f, - 0xa2, 0xa8, 0x50, 0x25, 0x47, 0xba, 0x97, 0x74, 0x1c, 0xd1, 0xbc, 0x9e, 0x9f, 0xc6, 0x75, 0xf0, - 0x4f, 0xd2, 0x5c, 0x09, 0xec, 0x1d, 0x3c, 0x7b, 0xa2, 0x0e, 0xc5, 0x67, 0x70, 0x29, 0xb4, 0x74, - 0x1e, 0xae, 0x78, 0xea, 0x1c, 0x15, 0x0f, 0x2d, 0xbf, 0x07, 0x54, 0xf4, 0x29, 0x84, 0x16, 0xd8, - 0x15, 0x56, 0x27, 0x0f, 0xaa, 0x9c, 0x47, 0x1d, 0x73, 0x81, 0x14, 0x46, 0x77, 0x50, 0x05, 0xb2, - 0xf8, 0xb8, 0xa3, 0xe8, 0xd8, 0xd1, 0xb8, 0xe1, 0x92, 0xe2, 0x04, 0x92, 0xa2, 0x0c, 0x38, 0xef, - 0xd3, 0xf8, 0xb8, 0x43, 0x88, 0x68, 0x87, 0xcc, 0x9b, 0xde, 0xbc, 0x4e, 0x8b, 0xed, 0x9c, 0x8d, - 0x05, 0x82, 0x9e, 0xc2, 0xc5, 0x15, 0xfd, 0x29, 0x9d, 0x89, 0x90, 0x7e, 0x28, 0xc0, 0xd5, 0xd8, - 0x56, 0x4b, 0x72, 0x22, 0xfb, 0x18, 0x32, 0xb4, 0xf2, 0xa9, 0x73, 0x56, 0x9e, 0x72, 0x49, 0xdf, - 0x4b, 0xf1, 0x31, 0x2e, 0xe3, 0x96, 0x45, 0x14, 0x9b, 0xf8, 0x12, 0xda, 0x53, 0x98, 0x3d, 0xb2, - 0x5c, 0x6c, 0xfb, 0xcd, 0x9e, 0x3a, 0x77, 0xb3, 0xcf, 0x50, 0x01, 0x5e, 0x8b, 0x3f, 0x87, 0x39, - 0xd3, 0x32, 0x95, 0xa8, 0xd0, 0xf3, 0xf7, 0xa5, 0xa2, 0x69, 0x99, 0xcf, 0x43, 0x72, 0x7d, 0x3b, - 0xd3, 0xa7, 0x89, 0x24, 0xed, 0xcc, 0xf7, 0x05, 0x98, 0xf7, 0x3d, 0x9d, 0x84, 0xdd, 0xdd, 0x6f, - 0x41, 0xda, 0xb4, 0x5e, 0x9d, 0x67, 0x89, 0x92, 0xe4, 0x27, 0xb3, 0x5e, 0xb4, 0x44, 0x49, 0xd6, - 0xf7, 0x5f, 0xa5, 0x20, 0xf7, 0xb8, 0x92, 0x64, 0x2d, 0x3f, 0xe6, 0xcb, 0xdf, 0xac, 0xbd, 0xe3, - 0x7a, 0xbb, 0xff, 0xbe, 0xd2, 0xe3, 0xca, 0x06, 0xee, 0x79, 0xbd, 0x9d, 0x70, 0xa1, 0x55, 0xc8, - 0x45, 0x17, 0x4a, 0xc7, 0xd4, 0x54, 0xc0, 0xb5, 0x88, 0x61, 0x92, 0xca, 0xf5, 0x42, 0x2d, 0x84, - 0x98, 0x50, 0x0b, 0xf2, 0x1a, 0xdf, 0x53, 0x4c, 0x9d, 0xe7, 0x35, 0x21, 0x17, 0x71, 0x52, 0x9c, - 0x92, 0x9e, 0x01, 0x90, 0xea, 0x24, 0xd9, 0x24, 0xbf, 0x91, 0x86, 0xc2, 0x76, 0xd7, 0x39, 0x48, - 0xb8, 0xf7, 0x55, 0x00, 0x3a, 0x5d, 0xe7, 0x80, 0x8c, 0xc8, 0x63, 0x93, 0xd7, 0xf9, 0x8c, 0x28, - 0x0e, 0xaf, 0xd2, 0x8c, 0xaf, 0x79, 0x6c, 0xa2, 0x1a, 0x17, 0x82, 0x95, 0x20, 0x14, 0xe4, 0xc6, - 0x28, 0x64, 0xd9, 0x3c, 0x36, 0x37, 0xb1, 0x0f, 0x29, 0x99, 0x24, 0x4c, 0x24, 0x7d, 0x0c, 0xd3, - 0xe4, 0x41, 0x71, 0xad, 0xf3, 0x34, 0xf3, 0x14, 0xe1, 0x69, 0x5a, 0xe8, 0x23, 0xc8, 0x31, 0x6e, - 0x32, 0xfb, 0x4d, 0xd1, 0xd9, 0x2f, 0xae, 0x2e, 0x5c, 0x8d, 0x74, 0xde, 0xcb, 0x52, 0x56, 0x32, - 0xd7, 0x5d, 0x80, 0xc9, 0x3d, 0xcb, 0xd6, 0xbc, 0xcd, 0x5c, 0xf6, 0xc0, 0xda, 0x93, 0x41, 0x9a, - 0xf5, 0x4c, 0x36, 0x27, 0x82, 0xf4, 0x5b, 0x02, 0x14, 0xfd, 0x86, 0x48, 0x72, 0x42, 0xa8, 0x44, - 0xb4, 0x78, 0xfe, 0xa6, 0x20, 0x0a, 0x94, 0xfe, 0x1d, 0xf5, 0x88, 0x34, 0xeb, 0x88, 0xb6, 0x4c, - 0x92, 0x3d, 0xe5, 0x23, 0x16, 0xe8, 0x93, 0x3a, 0x6f, 0xeb, 0xd2, 0x98, 0x9f, 0xfb, 0x70, 0xc1, - 0x68, 0x13, 0x7b, 0x6e, 0xb8, 0xad, 0x1e, 0x87, 0x6d, 0x2e, 0xf6, 0x76, 0x8d, 0xe7, 0x83, 0xb4, - 0x8a, 0x97, 0x24, 0xfd, 0x1e, 0x5d, 0xad, 0x0e, 0x6a, 0x92, 0xa4, 0xaa, 0xeb, 0x30, 0x6b, 0x33, - 0xd1, 0xc4, 0xad, 0x39, 0xa7, 0xb6, 0x67, 0x7c, 0x56, 0xa2, 0xf0, 0xdf, 0x4e, 0x41, 0xf1, 0x59, - 0x17, 0xdb, 0xbd, 0xaf, 0x93, 0xba, 0x6f, 0x41, 0xf1, 0x95, 0x6a, 0xb8, 0xca, 0x9e, 0x65, 0x2b, - 0xdd, 0x8e, 0xae, 0xba, 0x5e, 0xb4, 0xc9, 0x2c, 0x21, 0x3f, 0xb2, 0xec, 0x1d, 0x4a, 0x44, 0x18, - 0xd0, 0xa1, 0x69, 0xbd, 0x32, 0x15, 0x42, 0xa6, 0x40, 0xf9, 0xd8, 0xe4, 0x4b, 0xc8, 0xe5, 0xf7, - 0xff, 0xe3, 0xc9, 0xf2, 0xc3, 0xb1, 0x62, 0xc8, 0x68, 0xbc, 0x5c, 0xb7, 0x6b, 0xe8, 0xa5, 0x9d, - 0x9d, 0xfa, 0x9a, 0x2c, 0x52, 0x91, 0x2f, 0x98, 0xc4, 0xe6, 0xb1, 0xe9, 0x48, 0x7f, 0x3f, 0x05, - 0x62, 0xa0, 0xa3, 0x24, 0x1b, 0xb2, 0x0a, 0xf9, 0x97, 0x5d, 0x6c, 0x1b, 0xaf, 0xd1, 0x8c, 0xc0, - 0x19, 0x89, 0xd9, 0xb9, 0x07, 0x73, 0xee, 0xb1, 0xa9, 0xb0, 0x08, 0x3f, 0x16, 0xf8, 0xe1, 0x05, - 0x2c, 0x14, 0x5d, 0x52, 0x66, 0x42, 0xa7, 0x41, 0x1f, 0x0e, 0xfa, 0x0c, 0x66, 0x22, 0xda, 0x4a, - 0xbf, 0x99, 0xb6, 0xf2, 0xaf, 0x42, 0x8a, 0xfa, 0x43, 0x01, 0x10, 0x55, 0x54, 0x9d, 0xad, 0xf1, - 0x7f, 0x5d, 0xfa, 0xd3, 0x1d, 0x10, 0x69, 0x3c, 0xa6, 0x62, 0xec, 0x29, 0x6d, 0xc3, 0x71, 0x0c, - 0x73, 0x9f, 0x77, 0xa8, 0x02, 0xa5, 0xd7, 0xf7, 0x36, 0x19, 0x55, 0xfa, 0xab, 0x30, 0x1f, 0xa9, - 0x40, 0x92, 0x8d, 0x7d, 0x1d, 0x66, 0xf6, 0xd8, 0x16, 0x2c, 0x15, 0xce, 0x97, 0x07, 0xf3, 0x94, - 0xc6, 0xde, 0x27, 0xfd, 0x59, 0x0a, 0x2e, 0xc8, 0xd8, 0xb1, 0x5a, 0x47, 0x38, 0x79, 0x15, 0xd6, - 0x80, 0xef, 0xbd, 0x28, 0xaf, 0xa5, 0xc9, 0x1c, 0x63, 0x66, 0xd3, 0x5c, 0x74, 0x8d, 0xfd, 0x9d, - 0xd1, 0x3d, 0x76, 0x70, 0x55, 0x9d, 0xaf, 0xd4, 0x65, 0x22, 0x2b, 0x75, 0x16, 0x14, 0xd9, 0xee, - 0xb1, 0xae, 0x38, 0xf8, 0xa5, 0xd9, 0x6d, 0x7b, 0x60, 0xa8, 0x34, 0xaa, 0x90, 0x75, 0xc6, 0xd2, - 0xc0, 0x2f, 0xb7, 0xba, 0x6d, 0xea, 0x3b, 0x97, 0x2f, 0x91, 0xf2, 0x9e, 0x9e, 0x2c, 0x17, 0x22, - 0x69, 0x8e, 0x5c, 0x30, 0xfc, 0x67, 0x22, 0x5d, 0xfa, 0x0e, 0x5c, 0xec, 0x53, 0x76, 0x92, 0x1e, - 0xcf, 0xbf, 0x48, 0xc3, 0x95, 0xa8, 0xf8, 0xa4, 0x21, 0xce, 0xd7, 0xbd, 0x41, 0x6b, 0x30, 0xdb, - 0x36, 0xcc, 0xd7, 0x5b, 0xbd, 0x9c, 0x69, 0x1b, 0xa6, 0x4f, 0x8b, 0xeb, 0x1a, 0x53, 0x5f, 0x69, - 0xd7, 0x50, 0x61, 0x31, 0xae, 0xed, 0x92, 0xec, 0x1f, 0xdf, 0x13, 0x60, 0x26, 0xe9, 0x65, 0xb9, - 0xd7, 0x8b, 0x82, 0x93, 0x9a, 0x30, 0xfb, 0x15, 0xac, 0xe3, 0xfd, 0xb6, 0x00, 0xa8, 0x69, 0x77, - 0x4d, 0x02, 0x6a, 0x9f, 0x58, 0xfb, 0x49, 0x56, 0xf3, 0x02, 0x4c, 0x1a, 0xa6, 0x8e, 0x8f, 0x69, - 0x35, 0x33, 0x32, 0x7b, 0x88, 0x6c, 0x25, 0xa6, 0xc7, 0xda, 0x4a, 0x94, 0x3e, 0x83, 0xf9, 0x48, - 0x11, 0x93, 0xac, 0xff, 0x9f, 0xa6, 0x60, 0x9e, 0x57, 0x24, 0xf1, 0x15, 0xcc, 0x6f, 0xc2, 0x64, - 0x8b, 0xc8, 0x1c, 0xd1, 0xce, 0xf4, 0x9d, 0x5e, 0x3b, 0xd3, 0xcc, 0xe8, 0x97, 0x00, 0x3a, 0x36, - 0x3e, 0x52, 0x18, 0x6b, 0x7a, 0x2c, 0xd6, 0x1c, 0xe1, 0xa0, 0x04, 0xf4, 0x85, 0x00, 0x45, 0x32, - 0xa0, 0x3b, 0xb6, 0xd5, 0xb1, 0x1c, 0xe2, 0xb3, 0x38, 0xe3, 0xc1, 0x9c, 0x67, 0xa7, 0x27, 0xcb, - 0xb3, 0x9b, 0x86, 0xb9, 0xcd, 0x19, 0x9b, 0x8d, 0xb1, 0x03, 0xfc, 0xbd, 0x63, 0x0e, 0xa5, 0x4a, - 0xcb, 0xd2, 0x0e, 0x83, 0xcd, 0x31, 0x62, 0x59, 0x7c, 0x71, 0x8e, 0xf4, 0x13, 0x01, 0x2e, 0x7c, - 0x65, 0xcb, 0xc5, 0xff, 0x3f, 0x94, 0x2d, 0x3d, 0x07, 0x91, 0xfe, 0xa8, 0x9b, 0x7b, 0x56, 0x92, - 0x0b, 0xf7, 0xff, 0x5b, 0x80, 0xb9, 0x90, 0xe0, 0x24, 0x1d, 0x9c, 0xd7, 0xd5, 0xd3, 0x2c, 0x0b, - 0x87, 0x71, 0xc7, 0x53, 0x95, 0x3c, 0xc3, 0xb3, 0xb3, 0x4e, 0x59, 0x82, 0x19, 0x4c, 0xac, 0x18, - 0x5d, 0xe2, 0xdd, 0x65, 0x87, 0x4c, 0xfa, 0x56, 0xf4, 0xf3, 0x7e, 0x86, 0x72, 0x4f, 0xfa, 0x15, - 0xe2, 0x61, 0x85, 0x07, 0x65, 0x92, 0x43, 0xfe, 0x9f, 0xa7, 0xe0, 0x52, 0x85, 0x6d, 0x81, 0x7b, - 0x31, 0x21, 0x49, 0x76, 0xc4, 0x05, 0x98, 0x3e, 0xc2, 0xb6, 0x63, 0x58, 0x6c, 0xb6, 0x9f, 0x95, - 0xbd, 0x47, 0xb4, 0x08, 0x59, 0xc7, 0x54, 0x3b, 0xce, 0x81, 0xe5, 0x6d, 0x27, 0xfa, 0xcf, 0x7e, - 0xfc, 0xca, 0xe4, 0xeb, 0xc7, 0xaf, 0x4c, 0x8d, 0x8e, 0x5f, 0x99, 0x7e, 0x83, 0xf8, 0x15, 0xbe, - 0x77, 0xf7, 0xef, 0x05, 0xb8, 0x3c, 0xa0, 0xb9, 0x24, 0x3b, 0xe7, 0x77, 0x21, 0xaf, 0x71, 0xc1, - 0x64, 0x7e, 0x60, 0x1b, 0x93, 0x75, 0x92, 0xed, 0x35, 0xa1, 0xcf, 0xe9, 0xc9, 0x32, 0x78, 0x45, - 0xad, 0xaf, 0x71, 0xe5, 0x90, 0xdf, 0xba, 0xf4, 0xdf, 0x01, 0x8a, 0xd5, 0x63, 0xb6, 0x28, 0xdf, - 0x60, 0x5e, 0x09, 0x7a, 0x04, 0xd9, 0x8e, 0x6d, 0x1d, 0x19, 0x5e, 0x35, 0x0a, 0x91, 0xe0, 0x05, - 0xaf, 0x1a, 0x7d, 0x5c, 0xdb, 0x9c, 0x43, 0xf6, 0x79, 0x51, 0x13, 0x72, 0x4f, 0x2c, 0x4d, 0x6d, - 0x3d, 0x32, 0x5a, 0xde, 0x40, 0x7b, 0xef, 0x6c, 0x41, 0x25, 0x9f, 0x67, 0x5b, 0x75, 0x0f, 0xbc, - 0x46, 0xf0, 0x89, 0xa8, 0x0e, 0xd9, 0x9a, 0xeb, 0x76, 0x48, 0x22, 0x1f, 0x7f, 0xb7, 0xc7, 0x10, - 0x4a, 0x58, 0xbc, 0x88, 0x5b, 0x8f, 0x1d, 0x35, 0x61, 0xee, 0x31, 0x3d, 0x3f, 0x56, 0x69, 0x59, - 0x5d, 0xbd, 0x62, 0x99, 0x7b, 0xc6, 0x3e, 0x9f, 0x26, 0x6e, 0x8d, 0x21, 0xf3, 0x71, 0xa5, 0x21, - 0x0f, 0x0a, 0x40, 0xab, 0x90, 0x6d, 0x3c, 0xe4, 0xc2, 0x98, 0x1b, 0x79, 0x73, 0x0c, 0x61, 0x8d, - 0x87, 0xb2, 0xcf, 0x86, 0xd6, 0x21, 0xbf, 0xfa, 0x79, 0xd7, 0xc6, 0x5c, 0xca, 0xd4, 0xd0, 0xc8, - 0x89, 0x7e, 0x29, 0x94, 0x4b, 0x0e, 0x33, 0xa3, 0xef, 0x40, 0x91, 0xe8, 0xad, 0xa9, 0xee, 0xb6, - 0x3c, 0x79, 0x59, 0x2a, 0xef, 0x1b, 0x63, 0xc8, 0xf3, 0x39, 0xbd, 0x2d, 0x81, 0x3e, 0x51, 0x8b, - 0x32, 0xcc, 0x46, 0xda, 0x0b, 0x21, 0xc8, 0x74, 0x48, 0xd3, 0x08, 0x34, 0x0c, 0x89, 0xfe, 0x46, - 0xef, 0xc2, 0xb4, 0x69, 0xe9, 0xd8, 0xeb, 0xcc, 0xb3, 0xe5, 0x0b, 0xa7, 0x27, 0xcb, 0x53, 0x5b, - 0x96, 0xce, 0x7c, 0x1d, 0xfe, 0x4b, 0x9e, 0x22, 0x99, 0xea, 0xfa, 0xe2, 0x35, 0xc8, 0x90, 0x26, - 0x22, 0x36, 0x64, 0x57, 0x75, 0xf0, 0x8e, 0x6d, 0x70, 0x69, 0xde, 0xe3, 0xe2, 0xef, 0xa7, 0x20, - 0xd5, 0x78, 0x48, 0xbc, 0xf9, 0xdd, 0xae, 0x76, 0x88, 0x5d, 0x9e, 0xce, 0x9f, 0xa8, 0x97, 0x6f, - 0xe3, 0x3d, 0x83, 0x39, 0x5d, 0x39, 0x99, 0x3f, 0xa1, 0xb7, 0x01, 0x54, 0x4d, 0xc3, 0x8e, 0xa3, - 0x78, 0x47, 0x00, 0x73, 0x72, 0x8e, 0x51, 0x36, 0x70, 0x8f, 0xb0, 0x39, 0x58, 0xb3, 0xb1, 0xeb, - 0xc5, 0x50, 0xb1, 0x27, 0xc2, 0xe6, 0xe2, 0x76, 0x47, 0x71, 0xad, 0x43, 0x6c, 0xd2, 0x26, 0xcd, - 0x11, 0xab, 0xd0, 0xee, 0x34, 0x09, 0x81, 0x18, 0x34, 0x6c, 0xea, 0x81, 0xf5, 0xc9, 0xc9, 0xfe, - 0x33, 0x11, 0x69, 0xe3, 0x7d, 0x83, 0x1f, 0xa0, 0xcb, 0xc9, 0xfc, 0x89, 0x68, 0x49, 0xed, 0xba, - 0x07, 0xb4, 0x25, 0x72, 0x32, 0xfd, 0x8d, 0x6e, 0x41, 0x91, 0x85, 0x5d, 0x2a, 0xd8, 0xd4, 0x14, - 0x6a, 0x07, 0x73, 0x34, 0x79, 0x96, 0x91, 0xab, 0xa6, 0x46, 0xac, 0x1e, 0x7a, 0x08, 0x9c, 0xa0, - 0x1c, 0xb6, 0x1d, 0xa2, 0x53, 0x20, 0xb9, 0xca, 0xc5, 0xd3, 0x93, 0xe5, 0x7c, 0x83, 0x26, 0x6c, - 0x6c, 0x36, 0xc8, 0x5c, 0xc2, 0x72, 0x6d, 0xb4, 0x9d, 0xba, 0xbe, 0xf8, 0x77, 0x04, 0x48, 0x3f, - 0xae, 0x34, 0xce, 0xad, 0x32, 0xaf, 0xa0, 0xe9, 0x50, 0x41, 0x6f, 0x43, 0x71, 0xd7, 0x68, 0xb5, - 0x0c, 0x73, 0x9f, 0xf8, 0x57, 0xdf, 0xc5, 0x9a, 0xa7, 0xb0, 0x02, 0x27, 0x6f, 0x33, 0x2a, 0xba, - 0x06, 0x79, 0xcd, 0xc6, 0x3a, 0x36, 0x5d, 0x43, 0x6d, 0x39, 0x5c, 0x73, 0x61, 0xd2, 0xe2, 0x5f, - 0x13, 0x60, 0x92, 0x76, 0x56, 0xf4, 0x16, 0xe4, 0x34, 0xcb, 0x74, 0x55, 0xc3, 0xe4, 0x56, 0x27, - 0x27, 0x07, 0x84, 0xa1, 0xc5, 0xbb, 0x0e, 0x33, 0xaa, 0xa6, 0x59, 0x5d, 0xd3, 0x55, 0x4c, 0xb5, - 0x8d, 0x79, 0x31, 0xf3, 0x9c, 0xb6, 0xa5, 0xb6, 0x31, 0x5a, 0x06, 0xef, 0xd1, 0x3f, 0xd9, 0x99, - 0x93, 0x81, 0x93, 0x36, 0x70, 0x6f, 0x11, 0x43, 0xce, 0xef, 0xd5, 0xa4, 0xbe, 0x5d, 0xc7, 0x2f, - 0x01, 0xfd, 0x8d, 0xde, 0x83, 0x0b, 0x2f, 0xbb, 0x6a, 0xcb, 0xd8, 0xa3, 0x8b, 0x5f, 0x34, 0x4a, - 0x9d, 0xbe, 0x8c, 0x15, 0x05, 0xf9, 0x69, 0x54, 0x02, 0x7d, 0xa7, 0x37, 0x08, 0xd2, 0xc1, 0x20, - 0x60, 0x21, 0x3b, 0x52, 0x0f, 0xe6, 0x64, 0xec, 0xda, 0xbd, 0x26, 0x3b, 0xec, 0x5a, 0x3d, 0xc2, - 0xa6, 0x4b, 0xea, 0x6e, 0x75, 0x30, 0x0b, 0x12, 0xf1, 0xea, 0xee, 0x13, 0xd0, 0x4d, 0x28, 0xa8, - 0x2e, 0xe9, 0x6e, 0xae, 0x62, 0x76, 0xdb, 0xbb, 0xd8, 0x66, 0xa1, 0x00, 0xf2, 0x2c, 0xa7, 0x6e, - 0x51, 0x22, 0x3f, 0x91, 0x61, 0xf7, 0x14, 0xba, 0x4e, 0xc4, 0x5f, 0x0d, 0x94, 0x54, 0x25, 0x14, - 0xe9, 0x2e, 0x5c, 0x24, 0xf5, 0xac, 0x9a, 0x9a, 0xdd, 0xeb, 0x10, 0xc9, 0x4f, 0xe9, 0x5f, 0x07, - 0x89, 0xa1, 0x7d, 0x1a, 0xba, 0x3d, 0x23, 0xfd, 0x78, 0x0a, 0x66, 0xab, 0xc7, 0x1d, 0xcb, 0x4e, - 0x74, 0x55, 0xa7, 0x0c, 0xd3, 0x1c, 0xf8, 0x8e, 0xd8, 0x8a, 0xed, 0xb3, 0x40, 0xde, 0x3e, 0x34, - 0x67, 0x44, 0x65, 0x00, 0x16, 0x50, 0x49, 0xe3, 0x70, 0xd2, 0xe7, 0xd8, 0x39, 0xa2, 0x6c, 0xf4, - 0xb0, 0xc1, 0x16, 0xe4, 0xdb, 0x47, 0x9a, 0xa6, 0xec, 0x19, 0x2d, 0x97, 0xc7, 0xa5, 0xc5, 0x87, - 0x50, 0x6f, 0x3e, 0xaf, 0x54, 0x1e, 0xd1, 0x4c, 0x2c, 0x9e, 0x2b, 0x78, 0x96, 0x81, 0x48, 0x60, - 0xbf, 0xd1, 0x37, 0x80, 0x1f, 0x7c, 0x51, 0x1c, 0xef, 0x18, 0x5b, 0x79, 0xf6, 0xf4, 0x64, 0x39, - 0x27, 0x53, 0x6a, 0xa3, 0xd1, 0x94, 0x73, 0x2c, 0x43, 0xc3, 0x71, 0xcf, 0x73, 0xd4, 0x61, 0x7a, - 0xfc, 0xa3, 0x0e, 0x7f, 0x53, 0x80, 0x4b, 0x5c, 0x47, 0xca, 0x2e, 0x0d, 0xef, 0x56, 0x5b, 0x86, - 0xdb, 0x53, 0x0e, 0x8f, 0x16, 0xb2, 0xd4, 0xe5, 0xf9, 0xc5, 0x58, 0x5d, 0x87, 0x9a, 0xb8, 0xe4, - 0x69, 0xbc, 0xf7, 0x84, 0x33, 0x6f, 0x1c, 0x55, 0x4d, 0xd7, 0xee, 0x95, 0x2f, 0x9f, 0x9e, 0x2c, - 0xcf, 0x0f, 0xa6, 0x3e, 0x97, 0xe7, 0x9d, 0x41, 0x16, 0x54, 0x03, 0xc0, 0x7e, 0x17, 0xa3, 0x16, - 0x2c, 0x7e, 0xea, 0x8a, 0xed, 0x8b, 0x72, 0x88, 0x17, 0xdd, 0x01, 0x91, 0x1f, 0x2d, 0xd9, 0x33, - 0x5a, 0x58, 0x71, 0x8c, 0xcf, 0x31, 0xb5, 0x75, 0x69, 0xb9, 0xc0, 0xe8, 0x44, 0x44, 0xc3, 0xf8, - 0x1c, 0xa3, 0xfb, 0x70, 0x31, 0x68, 0x01, 0x65, 0x17, 0xb7, 0xac, 0x57, 0x2c, 0x7b, 0x9e, 0x66, - 0x47, 0xbe, 0xf6, 0xcb, 0x24, 0x89, 0xb0, 0x2c, 0x7e, 0x17, 0x16, 0x86, 0x55, 0x38, 0x3c, 0x20, - 0x72, 0x6c, 0xbf, 0xf2, 0x83, 0xe8, 0x62, 0xc5, 0x18, 0x1d, 0x97, 0x2f, 0x58, 0x7c, 0x98, 0xfa, - 0x40, 0x90, 0xfe, 0x61, 0x0a, 0x66, 0xcb, 0xdd, 0xd6, 0xe1, 0xd3, 0x4e, 0x83, 0x1d, 0xcb, 0x47, - 0x57, 0x21, 0xa7, 0xab, 0xae, 0xca, 0x0a, 0x29, 0xb0, 0x23, 0x66, 0x84, 0x40, 0x6b, 0x73, 0x1b, - 0x8a, 0xa1, 0x58, 0x10, 0x1e, 0xf1, 0x4e, 0xab, 0x1d, 0x90, 0x69, 0x50, 0xfa, 0x07, 0xb0, 0x10, - 0xca, 0x48, 0x57, 0x16, 0x14, 0x6c, 0xba, 0xb6, 0x81, 0xd9, 0xea, 0x58, 0x5a, 0x0e, 0x05, 0xac, - 0xd4, 0x49, 0x72, 0x95, 0xa5, 0xa2, 0x26, 0xcc, 0x90, 0x8c, 0x3d, 0x85, 0x5a, 0x41, 0x6f, 0xf5, - 0xf2, 0x7e, 0x4c, 0xb5, 0x22, 0xe5, 0x2e, 0x51, 0xfd, 0x54, 0x28, 0x0f, 0xfd, 0x29, 0xe7, 0x71, - 0x40, 0x59, 0xfc, 0x04, 0xc4, 0xfe, 0x0c, 0x61, 0x5d, 0x66, 0x98, 0x2e, 0x2f, 0x84, 0x75, 0x99, - 0x0e, 0xe9, 0x69, 0x3d, 0x93, 0xcd, 0x88, 0x93, 0xd2, 0x4f, 0xd2, 0x50, 0xf0, 0x7a, 0x66, 0x92, - 0x6e, 0x75, 0x19, 0x26, 0x49, 0x3f, 0xf2, 0xc2, 0x2b, 0x6e, 0x8d, 0x18, 0x10, 0x3c, 0xc6, 0x9a, - 0xf4, 0x2f, 0x0f, 0x01, 0x52, 0xd6, 0x24, 0xcc, 0xcf, 0xe2, 0x9f, 0x0b, 0x90, 0xa1, 0x9e, 0xec, - 0x7d, 0xc8, 0xd0, 0x73, 0xf9, 0xc2, 0xc8, 0x73, 0xf9, 0xde, 0xf6, 0x3c, 0xc9, 0xea, 0x4f, 0x2c, - 0xa9, 0x90, 0x77, 0x55, 0xa6, 0xf1, 0x3d, 0x96, 0xed, 0x62, 0x9d, 0x7b, 0x8a, 0xd7, 0xce, 0x6a, - 0x47, 0xcf, 0x13, 0xf6, 0xf8, 0xd0, 0x15, 0x48, 0x13, 0xdb, 0x35, 0xcd, 0xb6, 0xea, 0x4f, 0x4f, - 0x96, 0xd3, 0xc4, 0x6a, 0x11, 0x1a, 0x5a, 0x81, 0x7c, 0xd4, 0x9a, 0x10, 0x67, 0x83, 0x9a, 0xc3, - 0x90, 0x25, 0x80, 0x96, 0x3f, 0x84, 0x18, 0x4a, 0x62, 0x6d, 0xc9, 0x37, 0xe9, 0x7f, 0x5d, 0xe0, - 0x31, 0x89, 0x0d, 0x8d, 0xcc, 0x59, 0x76, 0x92, 0x93, 0xca, 0x5d, 0x10, 0x6d, 0xd5, 0xd4, 0xad, - 0xb6, 0xf1, 0x39, 0x66, 0xa8, 0xdc, 0xe1, 0xdb, 0x15, 0x45, 0x9f, 0x4e, 0xe1, 0xb3, 0x23, 0xfd, - 0x37, 0x81, 0xc7, 0x2f, 0xfa, 0xc5, 0x48, 0x76, 0x53, 0x39, 0xcf, 0x97, 0xf4, 0xcc, 0x3d, 0xcb, - 0x0b, 0xbf, 0x78, 0x6b, 0x58, 0xb0, 0x51, 0xdd, 0xdc, 0xb3, 0xbc, 0xed, 0x31, 0xdb, 0x23, 0x38, - 0x8b, 0xbf, 0x0c, 0x93, 0x34, 0xf9, 0x35, 0xfa, 0x86, 0x1f, 0x33, 0x9b, 0x12, 0xd3, 0xd2, 0x9f, - 0xa4, 0xe0, 0x1d, 0x5a, 0xd5, 0xe7, 0xd8, 0x36, 0xf6, 0x7a, 0xdb, 0xb6, 0xe5, 0x62, 0xcd, 0xc5, - 0x7a, 0xb0, 0x2a, 0x95, 0x60, 0x13, 0xe8, 0x90, 0xe3, 0xfb, 0x79, 0x86, 0xce, 0x6f, 0xce, 0x78, - 0xfc, 0x66, 0x68, 0x35, 0xcb, 0xf6, 0x01, 0xeb, 0x6b, 0x72, 0x96, 0x49, 0xae, 0xeb, 0x68, 0x15, - 0x72, 0x1d, 0xaf, 0x1a, 0xe7, 0x0a, 0x19, 0xf1, 0xb9, 0xd0, 0x06, 0x14, 0x79, 0x41, 0xd5, 0x96, - 0x71, 0x84, 0x15, 0xd5, 0x3d, 0xcf, 0x10, 0x9e, 0x65, 0xbc, 0xab, 0x84, 0x75, 0xd5, 0x95, 0xfe, - 0x76, 0x06, 0x6e, 0x9e, 0xa1, 0xe2, 0x24, 0xbb, 0xd7, 0x22, 0x64, 0x8f, 0xc8, 0x8b, 0x0c, 0x5e, - 0xfb, 0xac, 0xec, 0x3f, 0xa3, 0xdd, 0xc8, 0x3c, 0xb0, 0xa7, 0x1a, 0x2d, 0x32, 0x6f, 0xb0, 0x20, - 0xbd, 0xe1, 0x61, 0x40, 0xf1, 0x41, 0x6f, 0xa1, 0x19, 0xe3, 0x11, 0x15, 0x44, 0xb3, 0x39, 0xe8, - 0x7b, 0x02, 0x2c, 0xb2, 0x17, 0xb2, 0x48, 0xb1, 0xbe, 0xd7, 0x64, 0xe8, 0x6b, 0xd6, 0x62, 0x5e, - 0x33, 0x96, 0x8e, 0x4a, 0xa1, 0x77, 0xf1, 0x82, 0x2c, 0x84, 0xdf, 0x16, 0x2e, 0xca, 0xe2, 0x6f, - 0x0a, 0x90, 0x0f, 0x11, 0xd0, 0xad, 0x81, 0x73, 0x39, 0xf9, 0xd3, 0xb8, 0xc3, 0x38, 0x37, 0x07, - 0x0e, 0xe3, 0x94, 0xb3, 0x5f, 0x9e, 0x2c, 0x67, 0x64, 0x16, 0xef, 0xed, 0x1d, 0xcb, 0xb9, 0x1e, - 0x5c, 0x03, 0x93, 0xee, 0xcb, 0xe4, 0xdd, 0x03, 0x43, 0x61, 0x9d, 0xea, 0x6d, 0x23, 0x51, 0x58, - 0x47, 0x9e, 0xa4, 0x1f, 0xa4, 0x60, 0x6e, 0x55, 0xd7, 0x1b, 0x0d, 0x0a, 0x05, 0x92, 0x1c, 0x63, - 0x08, 0x32, 0xc4, 0x3f, 0xe0, 0x67, 0x88, 0xe8, 0x6f, 0xf4, 0x2e, 0x20, 0xdd, 0x70, 0xd8, 0x75, - 0x0a, 0xce, 0x81, 0xaa, 0x5b, 0xaf, 0x82, 0xdd, 0xe2, 0x39, 0x2f, 0xa5, 0xe1, 0x25, 0xa0, 0x06, - 0x50, 0xa7, 0x55, 0x71, 0x5c, 0xd5, 0x5f, 0x0d, 0xbf, 0x39, 0xd6, 0xa9, 0x14, 0xe6, 0xcd, 0xfa, - 0x8f, 0x72, 0x8e, 0xc8, 0xa1, 0x3f, 0x89, 0x8f, 0x66, 0x90, 0x46, 0x71, 0x15, 0xd5, 0xf1, 0xce, - 0x53, 0xb0, 0x8b, 0x1c, 0x0a, 0x8c, 0xbe, 0xea, 0xb0, 0x63, 0x12, 0x2c, 0x0c, 0x3b, 0x50, 0x4d, - 0x92, 0x6b, 0x99, 0xbf, 0x23, 0x40, 0x41, 0xc6, 0x7b, 0x36, 0x76, 0x0e, 0x92, 0xd4, 0xf9, 0x23, - 0x98, 0xb1, 0x99, 0x54, 0x65, 0xcf, 0xb6, 0xda, 0xe7, 0xb1, 0x15, 0x79, 0xce, 0xf8, 0xc8, 0xb6, - 0xda, 0xdc, 0x24, 0x3f, 0x87, 0xa2, 0x5f, 0xc6, 0x24, 0x2b, 0xff, 0x0f, 0xe8, 0x89, 0x4b, 0x26, - 0x38, 0xe9, 0x6d, 0xdb, 0x64, 0x35, 0x40, 0xd7, 0xb3, 0xc3, 0x05, 0x4d, 0x52, 0x0d, 0xff, 0x55, - 0x80, 0x42, 0xa3, 0xbb, 0xcb, 0xae, 0x09, 0x4a, 0x4e, 0x03, 0x55, 0xc8, 0xb5, 0xf0, 0x9e, 0xab, - 0xbc, 0x56, 0x00, 0x71, 0x96, 0xb0, 0xd2, 0xf0, 0xe9, 0xc7, 0x00, 0x36, 0x3d, 0x72, 0x44, 0xe5, - 0xa4, 0xcf, 0x29, 0x27, 0x47, 0x79, 0x09, 0x99, 0xcc, 0x3a, 0x45, 0xbf, 0x9a, 0x49, 0xce, 0x2f, - 0x2f, 0x22, 0xd6, 0x21, 0x7d, 0x1e, 0xeb, 0x30, 0xc7, 0x77, 0xaa, 0xe3, 0x2d, 0x44, 0x09, 0xe6, - 0xa9, 0x5b, 0xa6, 0xa8, 0x9d, 0x4e, 0xcb, 0xf0, 0x70, 0x0a, 0xb5, 0x3f, 0x19, 0x79, 0x8e, 0x26, - 0xad, 0xb2, 0x14, 0x8a, 0x50, 0xd0, 0x6f, 0x08, 0x30, 0xb3, 0x67, 0x63, 0xfc, 0x39, 0x56, 0xa8, - 0x49, 0x1e, 0x6f, 0x2b, 0x7e, 0x8d, 0x94, 0xe1, 0x8d, 0xb7, 0xea, 0xf2, 0xec, 0xc5, 0x0d, 0xf2, - 0x5e, 0xb4, 0x05, 0xa2, 0xd6, 0x62, 0x9b, 0x87, 0x7e, 0x58, 0xc0, 0xd4, 0xf8, 0x03, 0xa0, 0xc8, - 0x98, 0x83, 0xc8, 0x80, 0x67, 0x64, 0x30, 0xa9, 0xba, 0xc2, 0xaf, 0x66, 0xa3, 0xce, 0x76, 0x34, - 0x2c, 0x20, 0x7c, 0xf4, 0x3a, 0x74, 0xa3, 0x5b, 0x49, 0xc6, 0xaa, 0xce, 0x3d, 0x77, 0x32, 0xae, - 0xfc, 0x07, 0x3e, 0xae, 0x5e, 0xc0, 0x1c, 0xed, 0x37, 0x49, 0x9f, 0xa0, 0x94, 0xfe, 0x71, 0x1a, - 0x50, 0x58, 0xf2, 0x57, 0xd7, 0xdf, 0x52, 0xc9, 0xf5, 0xb7, 0x75, 0x90, 0x42, 0xce, 0x50, 0x4b, - 0x75, 0x5c, 0x85, 0xc5, 0x9f, 0x39, 0x4a, 0x07, 0xdb, 0x8a, 0x83, 0x35, 0x8b, 0x5f, 0xa2, 0x23, - 0xc8, 0x4b, 0x41, 0xce, 0x27, 0xaa, 0xe3, 0x3e, 0x63, 0xf9, 0xb6, 0xb1, 0xdd, 0xa0, 0xb9, 0xd0, - 0x43, 0xb8, 0xd4, 0x56, 0x8f, 0xe3, 0xf8, 0x27, 0x29, 0xff, 0x7c, 0x5b, 0x3d, 0x1e, 0x60, 0xfa, - 0x10, 0x16, 0xe3, 0x99, 0x14, 0x07, 0x7b, 0xfb, 0x53, 0x97, 0x62, 0x18, 0x1b, 0xd8, 0x45, 0xab, - 0x00, 0x01, 0x88, 0xe0, 0x73, 0xf4, 0x38, 0x18, 0x22, 0xe7, 0x63, 0x08, 0xe9, 0xfb, 0x02, 0x14, - 0x36, 0x8d, 0x7d, 0x5b, 0x4d, 0xf4, 0x8a, 0x1a, 0xf4, 0x61, 0x74, 0x43, 0x2f, 0xff, 0x60, 0x31, - 0x2e, 0x60, 0x83, 0xe5, 0xf0, 0x16, 0xed, 0x38, 0x03, 0x99, 0xfa, 0xfc, 0x12, 0x25, 0x69, 0xf3, - 0x35, 0x78, 0x9b, 0x86, 0xc0, 0xf1, 0xf8, 0x97, 0xaf, 0x04, 0xdd, 0x48, 0x7f, 0x20, 0xc0, 0xd2, - 0xb0, 0xb7, 0x24, 0x39, 0x20, 0x64, 0x7a, 0x59, 0x1f, 0x7d, 0x83, 0xe2, 0x8f, 0x88, 0x33, 0x2c, - 0x0d, 0xe2, 0x23, 0x01, 0xfc, 0xb2, 0x35, 0xe8, 0x35, 0x7e, 0xec, 0xb7, 0x23, 0xfd, 0xdb, 0x45, - 0x98, 0xe1, 0xf5, 0xdb, 0x31, 0x0d, 0xcb, 0x44, 0xf7, 0x21, 0xbd, 0xcf, 0xd7, 0xfe, 0xf3, 0xb1, - 0x4b, 0x9e, 0xc1, 0x0d, 0x79, 0xb5, 0x09, 0x99, 0xe4, 0x25, 0x2c, 0x9d, 0xae, 0x1b, 0x53, 0x9e, - 0x20, 0xc8, 0x3b, 0xcc, 0xd2, 0xe9, 0xba, 0xa8, 0x01, 0x45, 0x2d, 0xb8, 0x96, 0x4b, 0x21, 0xec, - 0xe9, 0xa1, 0xeb, 0x80, 0xb1, 0x17, 0xa4, 0xd5, 0x26, 0xe4, 0x82, 0x16, 0x49, 0x40, 0x95, 0xf0, - 0x6d, 0x50, 0x99, 0x81, 0x08, 0xb2, 0xe0, 0x2c, 0x71, 0xf4, 0x26, 0xaa, 0xda, 0x44, 0xe8, 0xd2, - 0x28, 0xf4, 0x21, 0x4c, 0xe9, 0xf4, 0xde, 0x21, 0x3e, 0xab, 0xc4, 0x75, 0x88, 0xc8, 0xf5, 0x4e, - 0xb5, 0x09, 0x99, 0x73, 0xa0, 0x75, 0x98, 0x61, 0xbf, 0x18, 0xe6, 0xe1, 0x73, 0xc1, 0xcd, 0xe1, - 0x12, 0x42, 0xde, 0x58, 0x6d, 0x42, 0xce, 0xeb, 0x01, 0x15, 0x3d, 0x86, 0xbc, 0xd6, 0xc2, 0xaa, - 0xcd, 0x45, 0xdd, 0x1a, 0x7a, 0xec, 0x6d, 0xe0, 0xae, 0xa2, 0xda, 0x84, 0x0c, 0x9a, 0x4f, 0x24, - 0x85, 0xb2, 0xe9, 0x95, 0x35, 0x5c, 0xd2, 0x7b, 0x43, 0x0b, 0x35, 0x78, 0xff, 0x4f, 0x8d, 0x7a, - 0x69, 0x3e, 0x15, 0x7d, 0x13, 0x32, 0x8e, 0xa6, 0x9a, 0x7c, 0x62, 0x5a, 0x1a, 0x72, 0xa7, 0x48, - 0xc0, 0x4c, 0x73, 0xa3, 0x8f, 0x18, 0x5c, 0x72, 0x8f, 0xbd, 0xc5, 0xde, 0x38, 0x9d, 0x46, 0xce, - 0xae, 0x13, 0x9d, 0x62, 0x4a, 0x20, 0x7a, 0x50, 0x09, 0x3e, 0x54, 0xe8, 0x81, 0x52, 0xba, 0xba, - 0x1b, 0xaf, 0x87, 0x81, 0x03, 0xc0, 0x35, 0x7a, 0x40, 0xde, 0x23, 0xa2, 0x4d, 0x98, 0x65, 0x82, - 0xba, 0xec, 0x6c, 0xea, 0xc2, 0xca, 0xd0, 0x6d, 0xdc, 0x98, 0xd3, 0xb1, 0xb5, 0x09, 0x79, 0x46, - 0x0d, 0x91, 0x83, 0x72, 0xb5, 0xb1, 0xbd, 0xcf, 0x96, 0x91, 0x47, 0x94, 0x2b, 0x1c, 0x1b, 0xe7, - 0x97, 0x8b, 0x12, 0xd1, 0xaf, 0xc1, 0x05, 0x26, 0xc8, 0xe5, 0x21, 0x3f, 0x3c, 0x72, 0xe4, 0xed, - 0xa1, 0x5b, 0xb0, 0x43, 0xcf, 0x93, 0xd6, 0x26, 0x64, 0xa4, 0x0e, 0x24, 0x22, 0x0d, 0x2e, 0xb2, - 0x37, 0xf0, 0x03, 0x89, 0x36, 0x3f, 0x43, 0xb7, 0x70, 0x83, 0xbe, 0xe2, 0xdd, 0x61, 0xaf, 0x88, - 0x3d, 0x27, 0x59, 0x9b, 0x90, 0xe7, 0xd5, 0xc1, 0xd4, 0xa0, 0x1a, 0x36, 0x3f, 0xfa, 0xc5, 0xbb, - 0xdb, 0xbb, 0xa3, 0xab, 0x11, 0x77, 0x64, 0xce, 0xaf, 0x46, 0x24, 0x91, 0x34, 0xa0, 0x7f, 0xf0, - 0x9d, 0x76, 0xa6, 0x99, 0xa1, 0x0d, 0x18, 0x73, 0x3e, 0x8c, 0x34, 0xe0, 0x41, 0x88, 0x8c, 0x4a, - 0x90, 0xda, 0xd7, 0x16, 0x66, 0x87, 0x4e, 0xa0, 0xfe, 0x19, 0xa8, 0xda, 0x84, 0x9c, 0xda, 0xd7, - 0xd0, 0x27, 0x90, 0x65, 0x07, 0x5a, 0x8e, 0xcd, 0x85, 0xc2, 0x50, 0x23, 0x1e, 0x3d, 0x16, 0x54, - 0x9b, 0x90, 0xe9, 0x19, 0x1a, 0xde, 0x91, 0xf9, 0x61, 0x05, 0x2a, 0xa2, 0x34, 0xe2, 0x1c, 0x6b, - 0xdf, 0x91, 0x11, 0xd2, 0x61, 0x6c, 0x9f, 0x88, 0xb6, 0xa1, 0xc0, 0x0d, 0xb8, 0x17, 0x7c, 0x2d, - 0x0e, 0x0d, 0x72, 0x88, 0x8b, 0xbf, 0xae, 0xd1, 0x85, 0xaa, 0x10, 0x9d, 0xb4, 0x5d, 0x54, 0x22, - 0x6f, 0xbb, 0xb9, 0xa1, 0x6d, 0x37, 0x34, 0x16, 0x98, 0xb4, 0x9d, 0x3d, 0x90, 0x88, 0xde, 0x87, - 0x49, 0x36, 0x4e, 0x10, 0x15, 0x19, 0x17, 0xb7, 0xd3, 0x37, 0x44, 0x58, 0x7e, 0x62, 0xbd, 0x5c, - 0x1e, 0xd3, 0xa8, 0xb4, 0xac, 0xfd, 0x85, 0xf9, 0xa1, 0xd6, 0x6b, 0x30, 0x3a, 0x93, 0x58, 0x2f, - 0x37, 0xa0, 0x92, 0x0e, 0x64, 0xb3, 0x14, 0x3e, 0xc4, 0x2e, 0x0c, 0xed, 0x40, 0x31, 0xa1, 0x8e, - 0x35, 0x7a, 0xda, 0x24, 0x20, 0xfb, 0x86, 0xd5, 0xc1, 0x0a, 0x35, 0x8a, 0x17, 0x47, 0x1b, 0xd6, - 0xc8, 0x45, 0x4f, 0xbe, 0x61, 0x65, 0x54, 0xf4, 0x1c, 0x44, 0x7e, 0xdb, 0x88, 0xe2, 0x85, 0xde, - 0x2c, 0x5c, 0xa2, 0xf2, 0xee, 0xc6, 0x4e, 0x88, 0x71, 0x51, 0x59, 0x35, 0x82, 0x28, 0xa2, 0x29, - 0xe8, 0x53, 0x98, 0xa3, 0xf2, 0x14, 0x2d, 0xb8, 0x20, 0x66, 0x61, 0x61, 0xe0, 0xba, 0x91, 0xe1, - 0x77, 0xc9, 0x78, 0x92, 0x45, 0xad, 0x2f, 0x89, 0x8c, 0x07, 0xc3, 0x34, 0x5c, 0x3a, 0x77, 0x2f, - 0x0e, 0x1d, 0x0f, 0xd1, 0xcb, 0x31, 0xc9, 0x78, 0x30, 0x18, 0x85, 0x74, 0xe3, 0x3e, 0x8b, 0xf7, - 0xd6, 0xd0, 0x6e, 0x3c, 0xc4, 0xd8, 0xcd, 0xba, 0x11, 0x3b, 0xb7, 0x06, 0xc0, 0x70, 0x24, 0x75, - 0x8d, 0x97, 0x86, 0x3a, 0x00, 0xfd, 0xa1, 0x88, 0xc4, 0x01, 0x68, 0x79, 0x34, 0xe2, 0x00, 0xb0, - 0x4d, 0x8f, 0x85, 0x6b, 0xc3, 0x27, 0xab, 0xf0, 0xb6, 0x28, 0x9d, 0xac, 0x28, 0x01, 0xad, 0x42, - 0x8e, 0x38, 0xf5, 0x3d, 0x3a, 0xc2, 0xaf, 0x0f, 0xc5, 0xf0, 0x7d, 0x67, 0x94, 0x6a, 0x13, 0x72, - 0xf6, 0x25, 0x27, 0x91, 0x5e, 0xc5, 0x44, 0xf0, 0xb1, 0x7d, 0x6f, 0x68, 0xaf, 0x1a, 0x3c, 0x9c, - 0x42, 0x7a, 0xd5, 0xcb, 0x80, 0x1a, 0x4c, 0x79, 0x0e, 0xdb, 0xce, 0x58, 0x78, 0x67, 0xf4, 0x94, - 0x17, 0xdd, 0x7c, 0xf1, 0xa7, 0x3c, 0x4e, 0x66, 0x53, 0x9e, 0xae, 0x38, 0x0e, 0x8d, 0x70, 0x58, - 0xb8, 0x39, 0x62, 0xca, 0xeb, 0x5b, 0xe0, 0x64, 0x53, 0x9e, 0xde, 0x60, 0x9c, 0xc4, 0xfb, 0xb3, - 0xbd, 0xdb, 0x75, 0x38, 0xbc, 0xbb, 0x3d, 0xd4, 0xfb, 0x8b, 0xbd, 0xfe, 0x87, 0x78, 0x7f, 0x76, - 0x24, 0x01, 0xfd, 0x12, 0x4c, 0xf3, 0x05, 0xa5, 0x85, 0x3b, 0x23, 0x7c, 0xec, 0xf0, 0x1a, 0x20, - 0xe9, 0x8e, 0x9c, 0x87, 0x19, 0x07, 0xb6, 0x90, 0xc5, 0x8c, 0xdf, 0xdd, 0x11, 0xc6, 0x61, 0x60, - 0x2d, 0x8d, 0x19, 0x87, 0x80, 0x4c, 0x4a, 0xe3, 0xb0, 0x45, 0x98, 0x85, 0x5f, 0x18, 0x5a, 0x9a, - 0xe8, 0x6a, 0x14, 0x29, 0x0d, 0xe7, 0xa1, 0x93, 0x05, 0x9d, 0xab, 0x99, 0x76, 0xbe, 0x31, 0x7c, - 0xb2, 0xe8, 0x87, 0xf5, 0x35, 0x6f, 0xbb, 0x88, 0x69, 0xe5, 0xaf, 0x0b, 0x70, 0x8d, 0xf5, 0x01, - 0xba, 0x58, 0xde, 0x53, 0xfc, 0xbd, 0x8e, 0xd0, 0x9a, 0xc5, 0x7d, 0x2a, 0xfe, 0xfd, 0xf3, 0x2f, - 0xcd, 0x7b, 0x6f, 0x7c, 0x5b, 0x1d, 0x95, 0x8f, 0x28, 0xa3, 0xcd, 0xd0, 0xdd, 0xc2, 0x83, 0xa1, - 0xca, 0x88, 0x22, 0x52, 0xa2, 0x0c, 0xce, 0x83, 0x5a, 0xb0, 0xc0, 0x86, 0x44, 0x80, 0x7e, 0xfc, - 0xa2, 0x3f, 0x1c, 0x1a, 0x34, 0x38, 0x12, 0xf7, 0xd5, 0x26, 0xe4, 0x4b, 0x2f, 0x63, 0x33, 0x94, - 0xa7, 0xf9, 0xe6, 0xb3, 0x7f, 0xd0, 0xb4, 0x28, 0x8a, 0xeb, 0x99, 0xec, 0x65, 0x71, 0x61, 0x3d, - 0x93, 0xbd, 0x22, 0x2e, 0xae, 0x67, 0xb2, 0x57, 0xc5, 0xb7, 0xd6, 0x33, 0xd9, 0x65, 0xf1, 0xda, - 0x7a, 0x26, 0x2b, 0x89, 0x37, 0xa4, 0xdf, 0x59, 0x84, 0x59, 0x0f, 0xbd, 0x31, 0x14, 0xf5, 0x20, - 0x8c, 0xa2, 0x96, 0x86, 0xa1, 0x28, 0x8e, 0xf7, 0x38, 0x8c, 0x7a, 0x10, 0x86, 0x51, 0x4b, 0xc3, - 0x60, 0x54, 0xc0, 0x43, 0x70, 0x54, 0x73, 0x18, 0x8e, 0xba, 0x3b, 0x06, 0x8e, 0xf2, 0x45, 0xf5, - 0x03, 0xa9, 0xb5, 0x41, 0x20, 0xf5, 0xce, 0x68, 0x20, 0xe5, 0x8b, 0x0a, 0x21, 0xa9, 0x8f, 0xfa, - 0x90, 0xd4, 0xf5, 0x11, 0x48, 0xca, 0xe7, 0xf7, 0xa0, 0xd4, 0x46, 0x2c, 0x94, 0xba, 0x75, 0x16, - 0x94, 0xf2, 0xe5, 0x44, 0xb0, 0x54, 0x2d, 0x0e, 0x4b, 0xdd, 0x3c, 0x03, 0x4b, 0xf9, 0xa2, 0xc2, - 0x60, 0x6a, 0x23, 0x16, 0x4c, 0xdd, 0x3a, 0x0b, 0x4c, 0x05, 0xc5, 0x0a, 0xa3, 0xa9, 0x6f, 0x45, - 0xd0, 0xd4, 0xf2, 0x50, 0x34, 0xe5, 0x73, 0x33, 0x38, 0xf5, 0x71, 0x3f, 0x9c, 0xba, 0x3e, 0x02, - 0x4e, 0x05, 0x8a, 0xe5, 0x78, 0xaa, 0x16, 0x87, 0xa7, 0x6e, 0x9e, 0x81, 0xa7, 0x02, 0x5d, 0x84, - 0x00, 0xd5, 0x56, 0x3c, 0xa0, 0xba, 0x7d, 0x26, 0xa0, 0xf2, 0xa5, 0x45, 0x11, 0x55, 0x2d, 0x0e, - 0x51, 0xdd, 0x3c, 0x03, 0x51, 0xf5, 0x95, 0x8c, 0x41, 0x2a, 0x75, 0x24, 0xa4, 0x7a, 0x77, 0x4c, - 0x48, 0xe5, 0x8b, 0x8e, 0xc3, 0x54, 0xfa, 0x68, 0x4c, 0x55, 0x1a, 0x17, 0x53, 0xf9, 0x2f, 0x89, - 0x05, 0x55, 0xea, 0x48, 0x50, 0xf5, 0xee, 0x98, 0xa0, 0xaa, 0xaf, 0x22, 0x51, 0x54, 0xb5, 0x15, - 0x8f, 0xaa, 0x6e, 0x9f, 0x89, 0xaa, 0x82, 0x56, 0x8c, 0xc0, 0xaa, 0x95, 0x10, 0xac, 0x7a, 0x7b, - 0x08, 0xac, 0xf2, 0x59, 0x09, 0xae, 0xfa, 0xf6, 0x00, 0xae, 0x92, 0x46, 0xe1, 0x2a, 0x9f, 0xd7, - 0x07, 0x56, 0xb5, 0x38, 0x60, 0x75, 0xf3, 0x0c, 0x60, 0x15, 0xf4, 0x9b, 0x10, 0xb2, 0x7a, 0x36, - 0x04, 0x59, 0xdd, 0x39, 0x1b, 0x59, 0xf9, 0xf2, 0xfa, 0xa0, 0x95, 0x3a, 0x12, 0x5a, 0xbd, 0x3b, - 0x26, 0xb4, 0x0a, 0x5a, 0x30, 0x06, 0x5b, 0x7d, 0x10, 0xc5, 0x56, 0xd7, 0x86, 0x63, 0x2b, 0x5f, - 0x0c, 0x07, 0x57, 0x1b, 0xb1, 0xe0, 0xea, 0xd6, 0x59, 0xe0, 0x2a, 0xb0, 0x66, 0x61, 0x74, 0xb5, - 0x15, 0x8f, 0xae, 0x6e, 0x9f, 0x89, 0xae, 0x82, 0x8e, 0x14, 0x81, 0x57, 0x1b, 0xb1, 0xf0, 0xea, - 0xd6, 0x59, 0xf0, 0xaa, 0xcf, 0xd4, 0x72, 0x7c, 0xf5, 0x62, 0x28, 0xbe, 0xba, 0x37, 0x0e, 0xbe, - 0xf2, 0x85, 0x0e, 0x00, 0xac, 0xcf, 0x86, 0x03, 0xac, 0x5f, 0x38, 0xc7, 0x65, 0x9d, 0xb1, 0x08, - 0xeb, 0xdb, 0x03, 0x08, 0x4b, 0x1a, 0x85, 0xb0, 0x82, 0x91, 0xe1, 0x41, 0xac, 0x6a, 0x0c, 0x20, - 0x7a, 0x67, 0x34, 0x20, 0x0a, 0x26, 0xf2, 0x00, 0x11, 0x7d, 0xd4, 0x87, 0x88, 0xae, 0x9f, 0x19, - 0x17, 0x17, 0x82, 0x44, 0xe5, 0x41, 0x48, 0x74, 0x63, 0x24, 0x24, 0xf2, 0x25, 0x04, 0x98, 0x68, - 0x23, 0x16, 0x13, 0xdd, 0x3a, 0x0b, 0x13, 0x05, 0x5d, 0x21, 0x0c, 0x8a, 0xb6, 0xe2, 0x41, 0xd1, - 0xed, 0x33, 0x41, 0x51, 0xdf, 0xb4, 0xe5, 0xa1, 0xa2, 0x5a, 0x1c, 0x2a, 0xba, 0x79, 0x06, 0x2a, - 0x0a, 0x4f, 0x5b, 0x3e, 0x2c, 0x6a, 0x0e, 0x83, 0x45, 0x77, 0xc7, 0x80, 0x45, 0x81, 0x33, 0xd7, - 0x87, 0x8b, 0x3e, 0xe9, 0xc7, 0x45, 0xd2, 0x28, 0x5c, 0x14, 0x74, 0x22, 0x0f, 0x18, 0x6d, 0xc5, - 0x03, 0xa3, 0xdb, 0x67, 0x02, 0xa3, 0xf0, 0xb8, 0x0e, 0x21, 0xa3, 0x4f, 0xfa, 0x91, 0x91, 0x34, - 0x0a, 0x19, 0x05, 0xe5, 0xf1, 0xa0, 0x51, 0x2d, 0x0e, 0x1a, 0xdd, 0x3c, 0x03, 0x1a, 0x85, 0xcc, - 0x7d, 0x80, 0x8d, 0xfe, 0xc6, 0xf8, 0xd8, 0xe8, 0x83, 0xd7, 0x0d, 0x5b, 0x3a, 0x1b, 0x1c, 0x7d, - 0xd2, 0x0f, 0x8e, 0xa4, 0x51, 0xe0, 0x28, 0xd0, 0x87, 0x87, 0x8e, 0xda, 0x67, 0xa2, 0xa3, 0xfb, - 0xe7, 0x40, 0x47, 0xbe, 0xfc, 0x37, 0x86, 0x47, 0x6f, 0x89, 0x6f, 0x47, 0x40, 0xd2, 0x9f, 0x4d, - 0xc1, 0x14, 0xff, 0x4e, 0x55, 0xe4, 0x6e, 0x27, 0xe1, 0x75, 0xee, 0x76, 0x42, 0x6b, 0xa4, 0x57, - 0x53, 0x2f, 0xe9, 0xec, 0x1b, 0x01, 0x07, 0xef, 0xac, 0xe3, 0xac, 0xaf, 0x71, 0xc8, 0x1a, 0x7d, - 0x0b, 0x66, 0xbb, 0x0e, 0xb6, 0x95, 0x8e, 0x6d, 0x58, 0xb6, 0xe1, 0xb2, 0xe3, 0x22, 0x42, 0x59, - 0xfc, 0xf2, 0x64, 0x79, 0x66, 0xc7, 0xc1, 0xf6, 0x36, 0xa7, 0xcb, 0x33, 0xdd, 0xd0, 0x93, 0xf7, - 0x69, 0xae, 0xc9, 0xf1, 0x3f, 0xcd, 0xf5, 0x0c, 0x44, 0x1a, 0x0c, 0x10, 0x9e, 0x58, 0xd8, 0x3d, - 0x4a, 0xf1, 0x73, 0xa0, 0xaa, 0x87, 0xe6, 0x0e, 0x7a, 0x9f, 0x52, 0xd1, 0x8e, 0x12, 0x51, 0x03, - 0xe8, 0x0d, 0x27, 0x4a, 0xc7, 0x6a, 0x19, 0x5a, 0x8f, 0xfa, 0x0b, 0xd1, 0x3b, 0xa5, 0x47, 0xde, - 0xec, 0xfe, 0x42, 0x35, 0xdc, 0x6d, 0xca, 0x29, 0xc3, 0x2b, 0xff, 0x37, 0xba, 0x0f, 0x17, 0xdb, - 0xea, 0x31, 0xbd, 0x6c, 0x57, 0xf1, 0x1c, 0x00, 0x7a, 0xbd, 0x18, 0xfb, 0x48, 0x17, 0x6a, 0xab, - 0xc7, 0xf4, 0xe3, 0x61, 0x2c, 0x89, 0x7e, 0xf9, 0xe3, 0x3a, 0xcc, 0xf0, 0xb0, 0x7d, 0xf6, 0x61, - 0xa0, 0x22, 0xcd, 0xc9, 0xbf, 0x12, 0xc1, 0xbe, 0x0d, 0x74, 0x13, 0x0a, 0xba, 0xe1, 0xb8, 0x86, - 0xa9, 0xb9, 0xfc, 0x1e, 0x5f, 0x76, 0x13, 0xee, 0xac, 0x47, 0x65, 0x97, 0xf5, 0x36, 0x61, 0x4e, - 0x6b, 0x19, 0xbe, 0x5b, 0xc5, 0x26, 0xba, 0xb9, 0xa1, 0xc3, 0xa8, 0x42, 0xf3, 0xf6, 0x6f, 0x8d, - 0x17, 0xb5, 0x28, 0x19, 0x55, 0xa0, 0xb8, 0xaf, 0xba, 0xf8, 0x95, 0xda, 0x53, 0xbc, 0x53, 0x69, - 0x79, 0x7a, 0x12, 0xf7, 0xea, 0xe9, 0xc9, 0xf2, 0xec, 0x63, 0x96, 0x34, 0x70, 0x38, 0x6d, 0x76, - 0x3f, 0x94, 0xa0, 0xa3, 0xdb, 0x50, 0x54, 0x9d, 0x9e, 0xa9, 0xd1, 0x06, 0xc4, 0xa6, 0xd3, 0x75, - 0xa8, 0x57, 0x9c, 0x95, 0x0b, 0x94, 0x5c, 0xf1, 0xa8, 0xe8, 0x23, 0x58, 0xe4, 0xd7, 0xf5, 0xbf, - 0x52, 0x6d, 0x5d, 0xa1, 0x8d, 0x1e, 0x0c, 0x0f, 0x91, 0xf2, 0x5c, 0x66, 0xd7, 0xf3, 0x93, 0x0c, - 0xa4, 0xa5, 0xc3, 0xd7, 0xe0, 0xb2, 0x6b, 0x7e, 0x41, 0xcc, 0xaf, 0x67, 0xb2, 0x33, 0xe2, 0xec, - 0x7a, 0x26, 0x5b, 0x10, 0x8b, 0xd2, 0xbf, 0x11, 0xa0, 0x48, 0x0c, 0x94, 0xe3, 0x18, 0x96, 0x59, - 0xf3, 0x03, 0x44, 0xfd, 0x5e, 0x2b, 0xd0, 0x03, 0x42, 0xfe, 0x33, 0x5a, 0xa6, 0x07, 0xb1, 0x88, - 0x23, 0xe8, 0x7f, 0xa4, 0x23, 0x2d, 0x03, 0x23, 0xd1, 0x23, 0x31, 0xab, 0x30, 0xe5, 0x58, 0x5d, - 0x5b, 0xf3, 0xae, 0x8e, 0xbf, 0x3b, 0xc4, 0x22, 0x86, 0x5e, 0x58, 0x6a, 0x50, 0x06, 0x99, 0x33, - 0x4a, 0x25, 0x98, 0x62, 0x14, 0x94, 0x83, 0xc9, 0xa7, 0xcd, 0x5a, 0x55, 0x16, 0x27, 0xd0, 0x0c, - 0x64, 0x1f, 0xc9, 0x4f, 0x37, 0x95, 0xc6, 0xb3, 0x27, 0xa2, 0x80, 0xf2, 0x30, 0x2d, 0x3f, 0x7d, - 0xda, 0x54, 0x36, 0x9e, 0x8b, 0x29, 0xe9, 0x4f, 0x05, 0x98, 0x29, 0xb3, 0xbb, 0xf3, 0xd9, 0x66, - 0xfd, 0x47, 0x7d, 0xbb, 0xe8, 0x57, 0xe2, 0x41, 0x4a, 0xfc, 0xee, 0xf9, 0x2a, 0x64, 0x79, 0xf7, - 0xf4, 0xe2, 0xfb, 0x97, 0x87, 0xbb, 0xa6, 0x74, 0x15, 0xc7, 0x8b, 0xd1, 0xf2, 0xd8, 0x50, 0x03, - 0x44, 0xd5, 0xab, 0xa2, 0xc2, 0x4b, 0x32, 0x3c, 0x52, 0xab, 0x4f, 0x1b, 0x5e, 0x67, 0x53, 0xa3, - 0xe4, 0x0f, 0x33, 0x5f, 0xfc, 0x70, 0x79, 0x42, 0xfa, 0x8b, 0x0c, 0xcc, 0x96, 0xc3, 0xdf, 0x09, - 0x40, 0xf5, 0xbe, 0xca, 0xc6, 0x4d, 0xb8, 0x11, 0x8e, 0xd2, 0x88, 0x2f, 0xb0, 0xe4, 0x82, 0x8f, - 0x12, 0xb0, 0xba, 0x5f, 0x1b, 0x11, 0x80, 0x10, 0xae, 0x7c, 0xc0, 0xb8, 0xf8, 0x1f, 0xd2, 0xbe, - 0x01, 0x2f, 0xc1, 0x24, 0x3b, 0x43, 0x26, 0x0c, 0x1c, 0x6f, 0xa7, 0x26, 0x84, 0x38, 0x84, 0x24, - 0x5d, 0x66, 0xd9, 0x88, 0xc1, 0x6f, 0xbe, 0xd6, 0x65, 0x7e, 0xc1, 0x34, 0x79, 0xfe, 0x6f, 0x1b, - 0x76, 0xd9, 0x65, 0x8e, 0xff, 0x0f, 0x83, 0xc3, 0xc8, 0xfb, 0xd0, 0xaf, 0x42, 0x51, 0xb3, 0x5a, - 0x2d, 0xe6, 0x47, 0x30, 0xd3, 0x35, 0x78, 0xbd, 0x0b, 0x2d, 0x02, 0xff, 0x9c, 0x65, 0xc9, 0xff, - 0xac, 0x65, 0x49, 0xe6, 0x9f, 0xb5, 0x0c, 0x45, 0xee, 0x17, 0x7c, 0x61, 0xcc, 0xe2, 0xf5, 0x1d, - 0x22, 0x98, 0x7e, 0x9d, 0x43, 0x04, 0xec, 0xe8, 0x05, 0xef, 0x79, 0x7f, 0x24, 0xf0, 0x10, 0xae, - 0x27, 0x96, 0x75, 0xd8, 0xf5, 0x03, 0x63, 0x16, 0xc3, 0x57, 0x33, 0x06, 0xf1, 0xcd, 0xf4, 0x7c, - 0x4e, 0xdc, 0xd4, 0x94, 0x7a, 0xb3, 0xa9, 0xe9, 0x3a, 0xcc, 0x74, 0x6c, 0xbc, 0x87, 0x5d, 0xed, - 0x40, 0x31, 0xbb, 0x6d, 0x7e, 0x38, 0x29, 0xef, 0xd1, 0xb6, 0xba, 0x6d, 0x74, 0x17, 0x44, 0x3f, - 0x0b, 0xc7, 0x76, 0xde, 0xbd, 0x60, 0x1e, 0x9d, 0x23, 0x41, 0xe9, 0x7f, 0x0a, 0x30, 0x1f, 0xa9, - 0x13, 0x1f, 0x53, 0xeb, 0x90, 0xd7, 0x7d, 0x67, 0xc0, 0x59, 0x10, 0xce, 0x19, 0xf9, 0x1e, 0x66, - 0x46, 0x0a, 0x5c, 0xf2, 0x5e, 0x4b, 0x2f, 0xf2, 0x0f, 0xc4, 0xa6, 0xce, 0x29, 0xf6, 0x62, 0x20, - 0x67, 0x2d, 0xf4, 0x02, 0x7f, 0x90, 0xa5, 0xc7, 0x1a, 0x64, 0xd2, 0xff, 0x12, 0x40, 0xa4, 0x2f, - 0x78, 0x84, 0xb1, 0x9e, 0x88, 0xc9, 0xf4, 0x8e, 0x98, 0xa4, 0xc6, 0x3f, 0x7e, 0x14, 0xf9, 0xf8, - 0x48, 0xba, 0xef, 0xe3, 0x23, 0x71, 0xf6, 0x33, 0xf3, 0x86, 0xf6, 0x53, 0xfa, 0xa1, 0x00, 0x05, - 0xbf, 0xda, 0xec, 0xab, 0x83, 0x23, 0xae, 0x15, 0x7d, 0xbd, 0x2f, 0xeb, 0x79, 0xd7, 0x9f, 0x8c, - 0xf5, 0x21, 0xc4, 0xf0, 0xf5, 0x27, 0xec, 0x8b, 0x70, 0x7f, 0xd7, 0xeb, 0x8e, 0xa4, 0x88, 0x95, - 0xe0, 0xde, 0x89, 0xd7, 0x38, 0xde, 0xf5, 0x55, 0xc4, 0x80, 0x3d, 0x0a, 0x29, 0x90, 0xf6, 0x28, - 0xa2, 0xa5, 0xb1, 0xec, 0xbb, 0xa7, 0x25, 0xd6, 0x01, 0x7f, 0x1c, 0x6e, 0x09, 0x76, 0x6e, 0xf9, - 0x21, 0xa4, 0x8f, 0xd4, 0xd6, 0xa8, 0xa0, 0xb7, 0x48, 0xcb, 0xc9, 0x24, 0x37, 0x7a, 0x14, 0xb9, - 0xae, 0x23, 0x35, 0x7c, 0xdd, 0x67, 0x50, 0xa5, 0x91, 0x6b, 0x3d, 0xde, 0x8f, 0x0e, 0xa0, 0x91, - 0xaf, 0x0f, 0x8f, 0xa4, 0x0f, 0x33, 0x3f, 0xfa, 0xe1, 0xb2, 0x20, 0x7d, 0x0c, 0x48, 0xc6, 0x0e, - 0x76, 0x9f, 0x75, 0x2d, 0x3b, 0xb8, 0xfa, 0xa4, 0xff, 0x28, 0xc9, 0x64, 0xfc, 0x51, 0x12, 0xe9, - 0x22, 0xcc, 0x47, 0xb8, 0x99, 0x05, 0x92, 0xde, 0x87, 0x2b, 0x8f, 0x2d, 0xc7, 0x31, 0x3a, 0x04, - 0xe1, 0xd2, 0xa1, 0x4e, 0xe6, 0x2b, 0xdf, 0xe6, 0x66, 0x3b, 0x74, 0x51, 0xc1, 0x64, 0xb6, 0x29, - 0x27, 0xfb, 0xcf, 0xd2, 0xbf, 0x16, 0xe0, 0xf2, 0x20, 0x27, 0xd3, 0x72, 0xdc, 0x69, 0xd4, 0x69, - 0xcd, 0x0a, 0x6e, 0xe6, 0x3b, 0xbb, 0xb7, 0x7a, 0xd9, 0x89, 0xdb, 0xca, 0xdf, 0xa9, 0xb4, 0x55, - 0x6a, 0x93, 0xf8, 0x41, 0xf1, 0x02, 0x27, 0x6f, 0x32, 0x6a, 0x60, 0x9e, 0x32, 0xe3, 0x99, 0xa7, - 0xdf, 0x4f, 0x03, 0xa2, 0xd7, 0x21, 0x94, 0xe9, 0x7d, 0x02, 0x5e, 0x9d, 0xef, 0x42, 0xce, 0xc5, - 0xa6, 0x6a, 0xba, 0xde, 0xdd, 0x0f, 0x99, 0xf2, 0xcc, 0xe9, 0xc9, 0x72, 0xb6, 0x49, 0x89, 0xf5, - 0x35, 0x39, 0xcb, 0x92, 0xeb, 0x3a, 0xfa, 0x2b, 0xb0, 0x44, 0x66, 0x9c, 0x6e, 0x9b, 0x56, 0x5d, - 0x71, 0x0c, 0x53, 0xc3, 0x2c, 0x7c, 0x97, 0x7b, 0x68, 0xbc, 0x9f, 0xc5, 0xe1, 0xdd, 0xc1, 0x37, - 0x97, 0x2a, 0x81, 0x2c, 0xae, 0x84, 0xab, 0x21, 0xf1, 0x0d, 0x22, 0xfd, 0x89, 0xea, 0x78, 0xd9, - 0x17, 0xff, 0x5c, 0x80, 0x7c, 0x88, 0x05, 0x15, 0x21, 0x6d, 0x2b, 0x5d, 0xfa, 0x4a, 0x41, 0x4e, - 0xd9, 0x3b, 0xe8, 0x06, 0xcc, 0xd2, 0x59, 0x31, 0xe4, 0x65, 0x0a, 0x77, 0x32, 0x32, 0x0d, 0xe9, - 0x96, 0x3d, 0x17, 0xf2, 0x6d, 0x00, 0x9a, 0x89, 0x01, 0x9f, 0x34, 0xcd, 0x91, 0x23, 0x14, 0x1f, - 0xf6, 0xd0, 0x23, 0x32, 0x81, 0x10, 0x16, 0x05, 0x3f, 0x4b, 0xa9, 0xbe, 0x94, 0x65, 0xc8, 0xb3, - 0x6c, 0x4c, 0xcc, 0x24, 0xcd, 0x03, 0x94, 0xc4, 0xe4, 0x54, 0x60, 0xde, 0x79, 0xd9, 0x52, 0x3a, - 0x96, 0xae, 0x68, 0x9d, 0x2e, 0x8f, 0x2e, 0x66, 0x5f, 0x60, 0x15, 0xe8, 0xdd, 0x1a, 0x62, 0xe3, - 0xd9, 0x93, 0x6d, 0x4b, 0xaf, 0x6c, 0xef, 0xb0, 0xd0, 0x62, 0x47, 0x16, 0x9d, 0x97, 0x2d, 0x42, - 0xe9, 0x74, 0x39, 0x45, 0x6a, 0xc0, 0x7c, 0x44, 0x6d, 0x7c, 0x12, 0xfd, 0x38, 0x6a, 0x1c, 0xc2, - 0x9e, 0xa4, 0xf7, 0xcd, 0xf2, 0x52, 0xd5, 0xd4, 0x2c, 0x9d, 0x8f, 0xaa, 0xa8, 0x91, 0x68, 0x42, - 0x71, 0xdd, 0x32, 0x4c, 0x02, 0x92, 0xbc, 0x2e, 0xb0, 0x0a, 0x85, 0x5d, 0xc3, 0x54, 0xed, 0x9e, - 0xe2, 0xc5, 0x0f, 0x0b, 0x67, 0xc5, 0x0f, 0xcb, 0xb3, 0x8c, 0x83, 0x3f, 0x4a, 0x3f, 0x15, 0x40, - 0x0c, 0xc4, 0xf2, 0x82, 0x7e, 0x03, 0x40, 0x6b, 0x75, 0x1d, 0x17, 0xdb, 0xde, 0x60, 0x9d, 0x61, - 0xe7, 0x94, 0x2a, 0x8c, 0x5a, 0x5f, 0x93, 0x73, 0x3c, 0x43, 0x5d, 0x47, 0x37, 0xa2, 0x57, 0x90, - 0x4c, 0x96, 0xe1, 0x74, 0xe0, 0xe2, 0x11, 0x32, 0xfa, 0x1d, 0xd7, 0xb2, 0xfd, 0x05, 0x03, 0x3e, - 0xfa, 0xbd, 0xcb, 0x99, 0xe8, 0x25, 0x04, 0x98, 0x1e, 0x45, 0x2c, 0x10, 0x57, 0xf4, 0x08, 0xfb, - 0x55, 0xca, 0x9c, 0x5d, 0x25, 0xc6, 0xe1, 0x55, 0xe9, 0x0f, 0x04, 0x28, 0x56, 0xd8, 0xa0, 0xf4, - 0x07, 0xfa, 0x88, 0x89, 0x6d, 0x0d, 0xb2, 0xee, 0xb1, 0xa9, 0xb4, 0xb1, 0xff, 0x3d, 0xa1, 0x73, - 0xdc, 0x9e, 0x38, 0xed, 0xb2, 0x47, 0xfa, 0x89, 0x4a, 0xfe, 0x7d, 0x74, 0x6e, 0x35, 0xaf, 0x94, - 0xd8, 0x07, 0xd4, 0x4b, 0xde, 0x07, 0xd4, 0x4b, 0x6b, 0x3c, 0x03, 0x73, 0x18, 0xbe, 0xf8, 0xcf, - 0xcb, 0x82, 0xec, 0x33, 0x31, 0x9f, 0xf2, 0x5e, 0x83, 0x18, 0xbf, 0x01, 0xaf, 0x0f, 0x15, 0x00, - 0x42, 0x1f, 0x8a, 0xe2, 0x9f, 0xe4, 0x5e, 0x5d, 0x53, 0x76, 0xb6, 0x2a, 0x4f, 0x37, 0x37, 0xeb, - 0xcd, 0x66, 0x75, 0x4d, 0x14, 0x90, 0x08, 0x33, 0x91, 0xcf, 0x4c, 0xa5, 0xd8, 0x47, 0xba, 0xef, - 0xfd, 0x25, 0x80, 0xe0, 0x8b, 0x75, 0x44, 0xd6, 0x46, 0xf5, 0x53, 0xe5, 0xf9, 0xea, 0x93, 0x9d, - 0x6a, 0x43, 0x9c, 0x40, 0x08, 0x0a, 0xe5, 0xd5, 0x66, 0xa5, 0xa6, 0xc8, 0xd5, 0xc6, 0xf6, 0xd3, - 0xad, 0x46, 0xd5, 0xfb, 0xb8, 0xf7, 0xbd, 0x35, 0x98, 0x09, 0xdf, 0x09, 0x85, 0xe6, 0xa1, 0x58, - 0xa9, 0x55, 0x2b, 0x1b, 0xca, 0xf3, 0xfa, 0xaa, 0xf2, 0x6c, 0xa7, 0xba, 0x53, 0x15, 0x27, 0x68, - 0xd1, 0x28, 0xf1, 0xd1, 0xce, 0x13, 0x02, 0x44, 0x8b, 0x90, 0x67, 0xcf, 0xf4, 0x93, 0x54, 0x62, - 0xea, 0xde, 0x26, 0xe4, 0x43, 0x77, 0x55, 0x93, 0xd7, 0x6d, 0xef, 0x34, 0x6a, 0x4a, 0xb3, 0xbe, - 0x59, 0x6d, 0x34, 0x57, 0x37, 0xb7, 0x99, 0x0c, 0x4a, 0x5b, 0x2d, 0x3f, 0x95, 0x9b, 0xa2, 0xe0, - 0x3f, 0x37, 0x9f, 0xee, 0x54, 0x6a, 0x5e, 0x35, 0xa4, 0x4c, 0x36, 0x2d, 0xa6, 0xef, 0x1d, 0xc3, - 0xe5, 0x21, 0xd7, 0x23, 0x11, 0x0c, 0xbc, 0x63, 0xd2, 0x7b, 0x7b, 0xc5, 0x09, 0x34, 0x0b, 0x39, - 0xd2, 0xf5, 0xe8, 0xe1, 0x69, 0x51, 0x40, 0x59, 0xc8, 0x1c, 0xb8, 0x6e, 0x47, 0x4c, 0xa1, 0x29, - 0x48, 0x39, 0x0f, 0xc5, 0x34, 0xf9, 0xbf, 0xef, 0x88, 0x19, 0x02, 0xa9, 0xd5, 0xcf, 0xbb, 0x36, - 0x16, 0x27, 0x09, 0xa4, 0xee, 0x3a, 0xd8, 0xde, 0x33, 0x5a, 0x58, 0x9c, 0x26, 0x2c, 0x66, 0xb7, - 0xd5, 0x12, 0xb3, 0x52, 0x26, 0x3b, 0x25, 0x4e, 0xdd, 0xbb, 0x0e, 0xa1, 0x5b, 0x2a, 0x10, 0xc0, - 0xd4, 0x13, 0xd5, 0xc5, 0x8e, 0x2b, 0x4e, 0xa0, 0x69, 0x48, 0xaf, 0xb6, 0x5a, 0xa2, 0xf0, 0xe0, - 0x8b, 0x49, 0xc8, 0x7a, 0x5f, 0x5c, 0x42, 0x4f, 0x60, 0x92, 0xc2, 0x4c, 0xb4, 0x3c, 0x1c, 0x80, - 0x32, 0x0b, 0x79, 0xed, 0x2c, 0x84, 0x2a, 0x4d, 0xa0, 0xbf, 0x0c, 0xf9, 0x90, 0x63, 0x8e, 0x86, - 0xae, 0xdb, 0x46, 0xc0, 0xc8, 0xe2, 0xad, 0xb3, 0xb2, 0xf9, 0xf2, 0x5f, 0x40, 0xce, 0x9f, 0xd3, - 0xd1, 0x8d, 0x51, 0x33, 0xbe, 0x27, 0x7b, 0xb4, 0x5b, 0x40, 0x86, 0x9d, 0x34, 0xf1, 0x9e, 0x80, - 0x6c, 0x40, 0x83, 0xd3, 0x2f, 0x8a, 0x8b, 0x8d, 0x1c, 0x3a, 0xbf, 0x2f, 0xde, 0x1b, 0x2b, 0x77, - 0xf0, 0x4e, 0xa2, 0xac, 0xc0, 0x87, 0x88, 0x57, 0xd6, 0x80, 0x87, 0x12, 0xaf, 0xac, 0x18, 0x57, - 0x84, 0x36, 0x46, 0xc8, 0xc0, 0xc7, 0xca, 0x1f, 0x9c, 0x37, 0x63, 0xe5, 0xc7, 0xcc, 0x13, 0xd2, - 0x04, 0x7a, 0x06, 0x19, 0x62, 0x94, 0x51, 0x9c, 0x77, 0xdf, 0x37, 0x09, 0x2c, 0xde, 0x18, 0x99, - 0xc7, 0x13, 0x59, 0xbe, 0xfb, 0xa3, 0xff, 0xb2, 0x34, 0xf1, 0xa3, 0xd3, 0x25, 0xe1, 0xa7, 0xa7, - 0x4b, 0xc2, 0x1f, 0x9f, 0x2e, 0x09, 0x7f, 0x72, 0xba, 0x24, 0x7c, 0xff, 0x67, 0x4b, 0x13, 0x3f, - 0xfd, 0xd9, 0xd2, 0xc4, 0x1f, 0xff, 0x6c, 0x69, 0xe2, 0xb3, 0x69, 0xce, 0xbd, 0x3b, 0x45, 0x2d, - 0xd6, 0xc3, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x77, 0xa3, 0x5b, 0x70, 0x83, 0x00, 0x00, + // 8621 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0xbd, 0x6d, 0x6c, 0x23, 0x49, + 0x7a, 0x1f, 0xae, 0x26, 0x29, 0x89, 0x7c, 0x28, 0x91, 0xad, 0xd2, 0xbc, 0x70, 0x35, 0xbb, 0xd2, + 0x4c, 0xcf, 0xce, 0xab, 0x6f, 0xa9, 0x9d, 0x99, 0xdd, 0xff, 0xae, 0x77, 0xd7, 0x7b, 0x16, 0x29, + 0xce, 0x90, 0xd2, 0x48, 0xa3, 0x69, 0x52, 0x33, 0xd8, 0xf5, 0xf9, 0xdf, 0x6e, 0x75, 0x97, 0xa4, + 0x3e, 0x91, 0xdd, 0x9c, 0xee, 0xa6, 0x46, 0x5c, 0x24, 0x1f, 0x92, 0x18, 0xce, 0x7d, 0x0a, 0x2e, + 0x40, 0x00, 0xef, 0xc1, 0x41, 0x70, 0x8e, 0x8d, 0x04, 0x41, 0x3e, 0x38, 0x48, 0x82, 0x04, 0x0e, + 0x92, 0x18, 0xf9, 0x94, 0x43, 0x70, 0xc8, 0xdd, 0x7d, 0x33, 0x02, 0x44, 0x71, 0x74, 0xf9, 0x10, + 0xc3, 0x08, 0x2e, 0x08, 0x02, 0x18, 0x58, 0x20, 0x41, 0x50, 0x2f, 0xfd, 0x42, 0xb2, 0xf9, 0xa2, + 0x99, 0xde, 0x64, 0x01, 0x7f, 0x91, 0xd8, 0x4f, 0xd5, 0xf3, 0x74, 0xd5, 0x53, 0x55, 0x4f, 0x3d, + 0xbf, 0xaa, 0xa7, 0xaa, 0x61, 0xc1, 0xb6, 0x54, 0xed, 0xb0, 0xbd, 0xb7, 0xaa, 0xb6, 0x8d, 0x62, + 0xdb, 0xb6, 0x5c, 0x0b, 0x2d, 0x68, 0x96, 0x76, 0x44, 0xc9, 0x45, 0x9e, 0xb8, 0x74, 0x11, 0xdb, + 0xb6, 0x65, 0x3b, 0xed, 0xbd, 0x55, 0xf6, 0x83, 0xe5, 0x5c, 0xba, 0x7b, 0x74, 0xbc, 0x7a, 0x74, + 0xec, 0x60, 0xfb, 0x18, 0xdb, 0xab, 0x9a, 0x65, 0x6a, 0x1d, 0xdb, 0xc6, 0xa6, 0xd6, 0x5d, 0x6d, + 0x5a, 0xda, 0x11, 0xfd, 0x63, 0x98, 0x07, 0x51, 0x79, 0x6d, 0xac, 0xea, 0x4e, 0xa7, 0xd5, 0x52, + 0xed, 0xee, 0x2a, 0x15, 0xcb, 0x1f, 0x78, 0x5e, 0xe4, 0x15, 0x4a, 0x57, 0x5d, 0x95, 0xd3, 0x2e, + 0x78, 0xb4, 0x9e, 0x12, 0x5c, 0xf2, 0xa8, 0x2d, 0xec, 0xaa, 0xa1, 0xdc, 0x57, 0x1c, 0xd7, 0xb2, + 0xd5, 0x03, 0xbc, 0x8a, 0xcd, 0x03, 0xc3, 0xc4, 0x24, 0xc3, 0xb1, 0xa6, 0xf1, 0xc4, 0x37, 0x23, + 0x13, 0x1f, 0xf0, 0xd4, 0x42, 0xc7, 0x35, 0x9a, 0xab, 0x87, 0x4d, 0x6d, 0xd5, 0x35, 0x5a, 0xd8, + 0x71, 0xd5, 0x56, 0xdb, 0xab, 0x02, 0x4d, 0x71, 0x6d, 0x55, 0x33, 0xcc, 0x03, 0xef, 0x7f, 0x7b, + 0x6f, 0xd5, 0xc6, 0x9a, 0x65, 0xeb, 0x58, 0x57, 0x9c, 0xb6, 0x6a, 0x7a, 0xc5, 0x3d, 0xb0, 0x0e, + 0x2c, 0xfa, 0x73, 0x95, 0xfc, 0xe2, 0xd4, 0xe5, 0x03, 0xcb, 0x3a, 0x68, 0xe2, 0x55, 0xfa, 0xb4, + 0xd7, 0xd9, 0x5f, 0xd5, 0x3b, 0xb6, 0xea, 0x1a, 0x16, 0xe7, 0x92, 0xfe, 0x99, 0x00, 0xf3, 0x32, + 0x7e, 0xd1, 0xc1, 0x8e, 0x5b, 0xc5, 0xaa, 0x8e, 0x6d, 0xf4, 0x06, 0x24, 0x8f, 0x70, 0xb7, 0x90, + 0xbc, 0x2a, 0xdc, 0x9e, 0x2b, 0xcd, 0x7e, 0x75, 0xba, 0x92, 0xdc, 0xc4, 0x5d, 0x99, 0xd0, 0xd0, + 0x55, 0x98, 0xc5, 0xa6, 0xae, 0x90, 0xe4, 0x54, 0x6f, 0xf2, 0x0c, 0x36, 0xf5, 0x4d, 0xdc, 0x45, + 0xdf, 0x81, 0xb4, 0x43, 0xa4, 0x99, 0x1a, 0x2e, 0x4c, 0x5f, 0x15, 0x6e, 0x4f, 0x97, 0x7e, 0xf5, + 0xab, 0xd3, 0x95, 0x4f, 0x0e, 0x0c, 0xf7, 0xb0, 0xb3, 0x57, 0xd4, 0xac, 0xd6, 0xaa, 0xdf, 0xd4, + 0xfa, 0x5e, 0xf0, 0x7b, 0xb5, 0x7d, 0x74, 0xb0, 0xda, 0xaf, 0xa3, 0x62, 0xe3, 0xc4, 0xac, 0xe3, + 0x17, 0xb2, 0x2f, 0x71, 0x23, 0x95, 0x16, 0xc4, 0xc4, 0x46, 0x2a, 0x9d, 0x10, 0x93, 0xd2, 0x4f, + 0x12, 0x90, 0x93, 0xb1, 0xd3, 0xb6, 0x4c, 0x07, 0xf3, 0x92, 0xbf, 0x0b, 0x49, 0xf7, 0xc4, 0xa4, + 0x25, 0xcf, 0xde, 0x5f, 0x2e, 0x0e, 0x74, 0xaa, 0x62, 0xc3, 0x56, 0x4d, 0x47, 0xd5, 0x48, 0xf5, + 0x65, 0x92, 0x15, 0x7d, 0x08, 0x59, 0x1b, 0x3b, 0x9d, 0x16, 0xa6, 0x8a, 0xa4, 0x95, 0xca, 0xde, + 0xbf, 0x1c, 0xc1, 0x59, 0x6f, 0xab, 0xa6, 0x0c, 0x2c, 0x2f, 0xf9, 0x8d, 0xea, 0x30, 0xcf, 0x39, + 0x6d, 0xac, 0x3a, 0x96, 0x59, 0x98, 0xbd, 0x2a, 0xdc, 0xce, 0xdd, 0x2f, 0x46, 0xf0, 0xf6, 0x96, + 0x92, 0x3c, 0x76, 0x5a, 0x58, 0xa6, 0x5c, 0xf2, 0x9c, 0x1d, 0x7a, 0x42, 0x6f, 0x40, 0xda, 0xec, + 0xb4, 0x88, 0x7e, 0x1d, 0xaa, 0xbd, 0xa4, 0x3c, 0x6b, 0x76, 0x5a, 0x9b, 0xb8, 0xeb, 0xa0, 0x2b, + 0x90, 0x21, 0x49, 0x7b, 0x5d, 0x17, 0x3b, 0x85, 0x34, 0x4d, 0x23, 0x79, 0x4b, 0xe4, 0x59, 0xfa, + 0x14, 0xe6, 0xc2, 0x52, 0x11, 0x82, 0x9c, 0x5c, 0xa9, 0xef, 0x6e, 0x55, 0x94, 0xdd, 0xed, 0xcd, + 0xed, 0x27, 0xcf, 0xb7, 0xc5, 0x29, 0x74, 0x01, 0x44, 0x4e, 0xdb, 0xac, 0x7c, 0xa6, 0x3c, 0xae, + 0x6d, 0xd5, 0x1a, 0xa2, 0xb0, 0x94, 0xfa, 0xde, 0xef, 0x2d, 0x4f, 0x6d, 0xa4, 0xd2, 0x33, 0xe2, + 0xac, 0xf4, 0x7b, 0x02, 0xc0, 0x23, 0xec, 0xf2, 0xde, 0x80, 0x4a, 0x30, 0x73, 0x48, 0x4b, 0x5c, + 0x10, 0xa8, 0x5a, 0xae, 0x46, 0x56, 0x2d, 0xd4, 0x73, 0x4a, 0xe9, 0x1f, 0x9d, 0xae, 0x4c, 0xfd, + 0xf4, 0x74, 0x45, 0x90, 0x39, 0x27, 0x7a, 0x0a, 0xd9, 0x23, 0xdc, 0x55, 0xf8, 0xb8, 0x2c, 0x24, + 0xa8, 0x8e, 0xde, 0x0d, 0x09, 0x3a, 0x3a, 0x2e, 0x7a, 0x43, 0xb4, 0x18, 0x1a, 0xce, 0x45, 0xc2, + 0x51, 0xac, 0xbb, 0x36, 0x36, 0x0f, 0xdc, 0x43, 0x19, 0x8e, 0x70, 0xf7, 0x31, 0x93, 0x21, 0xfd, + 0x91, 0x00, 0x59, 0x5a, 0x4a, 0xa6, 0x54, 0x54, 0xee, 0x2b, 0xe6, 0xb5, 0xb1, 0x2d, 0x10, 0x51, + 0xce, 0x22, 0x4c, 0x1f, 0xab, 0xcd, 0x0e, 0xa6, 0x25, 0xcc, 0xde, 0x2f, 0x44, 0xc8, 0x78, 0x46, + 0xd2, 0x65, 0x96, 0x0d, 0x7d, 0x0c, 0x73, 0x86, 0xe9, 0x62, 0xd3, 0x55, 0x18, 0x5b, 0x72, 0x0c, + 0x5b, 0x96, 0xe5, 0xa6, 0x0f, 0xd2, 0x3f, 0x15, 0x00, 0x76, 0x3a, 0xb1, 0xea, 0xf9, 0xbd, 0x09, + 0xcb, 0x5f, 0x4a, 0x11, 0x56, 0xaf, 0x16, 0x97, 0x60, 0xc6, 0x30, 0x9b, 0x86, 0xc9, 0xca, 0x9f, + 0x96, 0xf9, 0x13, 0xba, 0x00, 0xd3, 0x7b, 0x4d, 0xc3, 0xd4, 0xe9, 0x78, 0x48, 0xcb, 0xec, 0x41, + 0x92, 0x21, 0x4b, 0x4b, 0x1d, 0xa3, 0xde, 0xa5, 0xd3, 0x04, 0x5c, 0x2c, 0x5b, 0xa6, 0x6e, 0x90, + 0x21, 0xa9, 0x36, 0xbf, 0x11, 0x5a, 0xd9, 0x80, 0x0b, 0x3a, 0x6e, 0xdb, 0x58, 0x53, 0x5d, 0xac, + 0x2b, 0xf8, 0xa4, 0x3d, 0x61, 0x1b, 0xa3, 0x80, 0xab, 0x72, 0xd2, 0xa6, 0x34, 0x32, 0x6a, 0x89, + 0x00, 0x36, 0x6a, 0x67, 0x88, 0xc9, 0x94, 0xd3, 0xf8, 0xa4, 0x4d, 0x47, 0x6d, 0xb4, 0x9a, 0xd1, + 0x7b, 0x70, 0x59, 0x6d, 0x36, 0xad, 0x97, 0x8a, 0xb1, 0xaf, 0xe8, 0x16, 0x76, 0x14, 0xd3, 0x72, + 0x15, 0x7c, 0x62, 0x38, 0x2e, 0x35, 0x09, 0x69, 0x79, 0x91, 0x26, 0xd7, 0xf6, 0xd7, 0x2d, 0xec, + 0x6c, 0x5b, 0x6e, 0x85, 0x24, 0x85, 0x9a, 0x72, 0x36, 0xdc, 0x94, 0xd2, 0xaf, 0xc3, 0xa5, 0x7e, + 0xfd, 0xc6, 0xd9, 0x7e, 0x3f, 0x16, 0x20, 0x57, 0x33, 0x0d, 0xf7, 0x1b, 0xd1, 0x70, 0xbe, 0x3e, + 0x93, 0x61, 0x7d, 0xde, 0x05, 0x71, 0x5f, 0x35, 0x9a, 0x4f, 0xcc, 0x86, 0xd5, 0xda, 0x73, 0x5c, + 0xcb, 0xc4, 0x0e, 0x57, 0xf8, 0x00, 0x5d, 0x7a, 0x06, 0x79, 0xbf, 0x36, 0x71, 0xaa, 0xc9, 0x05, + 0xb1, 0x66, 0x6a, 0x36, 0x6e, 0x61, 0x33, 0x56, 0x3d, 0xbd, 0x09, 0x19, 0xc3, 0x93, 0x4b, 0x75, + 0x95, 0x94, 0x03, 0x82, 0xd4, 0x81, 0x85, 0xd0, 0x5b, 0xe3, 0x34, 0x97, 0x64, 0x32, 0xc2, 0x2f, + 0x95, 0xa0, 0x8d, 0xc8, 0x64, 0x84, 0x5f, 0x32, 0xf3, 0x56, 0x87, 0xf9, 0x75, 0xdc, 0xc4, 0x2e, + 0x8e, 0xb1, 0xa6, 0xd2, 0x2e, 0xe4, 0x3c, 0xa1, 0x71, 0x36, 0xcc, 0x6f, 0x0b, 0x80, 0xb8, 0x5c, + 0xd5, 0x3c, 0x88, 0xb3, 0xc4, 0x68, 0x85, 0xb8, 0x16, 0x6e, 0xc7, 0x36, 0xd9, 0x74, 0xce, 0xfa, + 0x24, 0x30, 0x12, 0x9d, 0xd1, 0x83, 0x21, 0x9b, 0x0a, 0x0f, 0x59, 0xee, 0xde, 0xbc, 0x84, 0xc5, + 0x9e, 0x82, 0xc5, 0xdb, 0x7c, 0x29, 0x5a, 0xa6, 0xc4, 0xd5, 0x64, 0xd8, 0x87, 0xa3, 0x44, 0xe9, + 0x4b, 0x01, 0x16, 0xca, 0x4d, 0xac, 0xda, 0xb1, 0x6b, 0xe4, 0xdb, 0x90, 0xd6, 0xb1, 0xaa, 0xd3, + 0x2a, 0xb3, 0x81, 0xfd, 0x56, 0x48, 0x0a, 0xf1, 0x74, 0x8b, 0x87, 0x4d, 0xad, 0xd8, 0xf0, 0x7c, + 0x60, 0x3e, 0xba, 0x7d, 0x26, 0xe9, 0x33, 0x40, 0xe1, 0x92, 0xc5, 0xd9, 0x11, 0x7e, 0x3f, 0x01, + 0x48, 0xc6, 0xc7, 0xd8, 0x76, 0x63, 0xaf, 0xf6, 0x3a, 0x64, 0x5d, 0xd5, 0x3e, 0xc0, 0xae, 0x42, + 0xbc, 0xfb, 0xf3, 0xd4, 0x1c, 0x18, 0x1f, 0x21, 0xa3, 0x06, 0xdc, 0xc2, 0xa6, 0xba, 0xd7, 0xc4, + 0x54, 0x8a, 0xb2, 0x67, 0x75, 0x4c, 0x5d, 0x31, 0x5c, 0x6c, 0xab, 0xae, 0x65, 0x2b, 0x56, 0xdb, + 0x35, 0x5a, 0xc6, 0x17, 0xd4, 0xb1, 0xe7, 0x5d, 0xed, 0x3a, 0xcb, 0x4e, 0x98, 0x4b, 0x24, 0x73, + 0x8d, 0xe7, 0x7d, 0x12, 0xca, 0x8a, 0x8a, 0xb0, 0x68, 0x1c, 0x98, 0x96, 0x8d, 0x95, 0x03, 0x4d, + 0x71, 0x0f, 0x6d, 0xec, 0x1c, 0x5a, 0x4d, 0x6f, 0x42, 0x5a, 0x60, 0x49, 0x8f, 0xb4, 0x86, 0x97, + 0x20, 0x7d, 0x0e, 0x8b, 0x3d, 0x5a, 0x8a, 0xb3, 0x09, 0xfe, 0xbb, 0x00, 0xd9, 0xba, 0xa6, 0x9a, + 0x71, 0xea, 0xfe, 0x53, 0xc8, 0x3a, 0x9a, 0x6a, 0x2a, 0xfb, 0x96, 0xdd, 0x52, 0x5d, 0x5a, 0xaf, + 0x5c, 0x8f, 0xee, 0x7d, 0xff, 0x5e, 0x53, 0xcd, 0x87, 0x34, 0x93, 0x0c, 0x8e, 0xff, 0xbb, 0xdf, + 0x7f, 0x9d, 0x7e, 0x7d, 0xff, 0x95, 0x0d, 0xef, 0x8d, 0x54, 0x3a, 0x29, 0xa6, 0xa4, 0x3f, 0x17, + 0x60, 0x8e, 0x55, 0x39, 0xce, 0xe1, 0xfd, 0x3e, 0xa4, 0x6c, 0xeb, 0x25, 0x1b, 0xde, 0xd9, 0xfb, + 0x57, 0x22, 0x44, 0x6c, 0xe2, 0x6e, 0x78, 0xfe, 0xa4, 0xd9, 0x51, 0x09, 0xb8, 0x97, 0xaa, 0x50, + 0xee, 0xe4, 0xa4, 0xdc, 0xc0, 0xb8, 0x64, 0x22, 0xe3, 0x16, 0xe4, 0xf7, 0x54, 0x57, 0x3b, 0x54, + 0x6c, 0x5e, 0x48, 0x32, 0xd7, 0x26, 0x6f, 0xcf, 0xc9, 0x39, 0x4a, 0xf6, 0x8a, 0xee, 0x90, 0x9a, + 0xb3, 0xf1, 0xe6, 0xe0, 0xbf, 0x60, 0x6d, 0xfe, 0xbf, 0x05, 0x3e, 0x86, 0xbc, 0x9a, 0xff, 0x45, + 0x6b, 0xfa, 0x1f, 0x24, 0xe0, 0x72, 0xf9, 0x10, 0x6b, 0x47, 0x65, 0xcb, 0x74, 0x0c, 0xc7, 0x25, + 0xba, 0x8b, 0xb3, 0xfd, 0xaf, 0x40, 0xe6, 0xa5, 0xe1, 0x1e, 0x2a, 0xba, 0xb1, 0xbf, 0x4f, 0xad, + 0x6d, 0x5a, 0x4e, 0x13, 0xc2, 0xba, 0xb1, 0xbf, 0x8f, 0x1e, 0x40, 0xaa, 0x65, 0xe9, 0xcc, 0x99, + 0xcf, 0xdd, 0x5f, 0x89, 0x10, 0x4f, 0x8b, 0xe6, 0x74, 0x5a, 0x5b, 0x96, 0x8e, 0x65, 0x9a, 0x19, + 0x2d, 0x03, 0x68, 0x84, 0xda, 0xb6, 0x0c, 0xd3, 0xe5, 0xc6, 0x31, 0x44, 0x41, 0x55, 0xc8, 0xb8, + 0xd8, 0x6e, 0x19, 0xa6, 0xea, 0xe2, 0xc2, 0x34, 0x55, 0xde, 0xdb, 0x91, 0x05, 0x6f, 0x37, 0x0d, + 0x4d, 0x5d, 0xc7, 0x8e, 0x66, 0x1b, 0x6d, 0xd7, 0xb2, 0xb9, 0x16, 0x03, 0x66, 0xe9, 0x6f, 0xa4, + 0xa0, 0x30, 0xa8, 0x9b, 0x38, 0x7b, 0xc8, 0x0e, 0xcc, 0xd8, 0xd8, 0xe9, 0x34, 0x5d, 0xde, 0x47, + 0xee, 0x0f, 0x53, 0x41, 0x44, 0x09, 0xe8, 0xd2, 0x45, 0xd3, 0xe5, 0xc5, 0xe6, 0x72, 0x96, 0xfe, + 0xa5, 0x00, 0x33, 0x2c, 0x01, 0xdd, 0x83, 0xb4, 0x4d, 0x26, 0x06, 0xc5, 0xd0, 0x69, 0x19, 0x93, + 0xa5, 0x4b, 0x67, 0xa7, 0x2b, 0xb3, 0x74, 0xb2, 0xa8, 0xad, 0x7f, 0x15, 0xfc, 0x94, 0x67, 0x69, + 0xbe, 0x9a, 0x4e, 0x5a, 0xcb, 0x71, 0x55, 0xdb, 0xa5, 0x8b, 0x4a, 0x09, 0x86, 0x90, 0x28, 0x61, + 0x13, 0x77, 0xd1, 0x06, 0xcc, 0x38, 0xae, 0xea, 0x76, 0x1c, 0xde, 0x5e, 0xe7, 0x2a, 0x6c, 0x9d, + 0x72, 0xca, 0x5c, 0x02, 0x71, 0xb7, 0x74, 0xec, 0xaa, 0x46, 0x93, 0x36, 0x60, 0x46, 0xe6, 0x4f, + 0xd2, 0xef, 0x08, 0x30, 0xc3, 0xb2, 0xa2, 0xcb, 0xb0, 0x28, 0xaf, 0x6d, 0x3f, 0xaa, 0x28, 0xb5, + 0xed, 0xf5, 0x4a, 0xa3, 0x22, 0x6f, 0xd5, 0xb6, 0xd7, 0x1a, 0x15, 0x71, 0x0a, 0x5d, 0x02, 0xe4, + 0x25, 0x94, 0x9f, 0x6c, 0xd7, 0x6b, 0xf5, 0x46, 0x65, 0xbb, 0x21, 0x0a, 0x74, 0x4d, 0x85, 0xd2, + 0x43, 0xd4, 0x04, 0x7a, 0x1b, 0xae, 0xf6, 0x53, 0x95, 0x7a, 0x63, 0xad, 0x51, 0x57, 0x2a, 0xf5, + 0x46, 0x6d, 0x6b, 0xad, 0x51, 0x59, 0x17, 0x93, 0x23, 0x72, 0x91, 0x97, 0xc8, 0x72, 0xa5, 0xdc, + 0x10, 0x53, 0x92, 0x0b, 0x17, 0x65, 0xac, 0x59, 0xad, 0x76, 0xc7, 0xc5, 0xa4, 0x94, 0x4e, 0x9c, + 0x23, 0xe5, 0x32, 0xcc, 0xea, 0x76, 0x57, 0xb1, 0x3b, 0x26, 0x1f, 0x27, 0x33, 0xba, 0xdd, 0x95, + 0x3b, 0xa6, 0xf4, 0x8f, 0x04, 0xb8, 0xd4, 0xff, 0xda, 0x38, 0x3b, 0xe1, 0x53, 0xc8, 0xaa, 0xba, + 0x8e, 0x75, 0x45, 0xc7, 0x4d, 0x57, 0xe5, 0x2e, 0xd1, 0xdd, 0x90, 0x24, 0xbe, 0x14, 0x58, 0xf4, + 0x97, 0x02, 0xb7, 0x9e, 0x95, 0xcb, 0xb4, 0x20, 0xeb, 0x84, 0xc3, 0x33, 0x3f, 0x54, 0x08, 0xa5, + 0x48, 0x3f, 0x48, 0xc1, 0x7c, 0xc5, 0xd4, 0x1b, 0x27, 0xb1, 0xce, 0x25, 0x97, 0x60, 0x46, 0xb3, + 0x5a, 0x2d, 0xc3, 0xf5, 0x14, 0xc4, 0x9e, 0xd0, 0x2f, 0x87, 0x5c, 0xd9, 0xe4, 0x04, 0x0e, 0x5d, + 0xe0, 0xc4, 0xa2, 0xdf, 0x80, 0xcb, 0xc4, 0x6a, 0xda, 0xa6, 0xda, 0x54, 0x98, 0x34, 0xc5, 0xb5, + 0x8d, 0x83, 0x03, 0x6c, 0xf3, 0xe5, 0xc7, 0xdb, 0x11, 0xe5, 0xac, 0x71, 0x8e, 0x32, 0x65, 0x68, + 0xb0, 0xfc, 0xf2, 0x45, 0x23, 0x8a, 0x8c, 0x3e, 0x01, 0x20, 0x53, 0x11, 0x5d, 0xd2, 0x74, 0xb8, + 0x3d, 0x1a, 0xb6, 0xa6, 0xe9, 0x99, 0x20, 0xc2, 0x40, 0x9e, 0x1d, 0xf4, 0x14, 0x44, 0xc3, 0x54, + 0xf6, 0x9b, 0xc6, 0xc1, 0xa1, 0xab, 0xbc, 0xb4, 0x0d, 0x17, 0x3b, 0x85, 0x05, 0x2a, 0x23, 0xaa, + 0xa9, 0xeb, 0x7c, 0x69, 0x56, 0x7f, 0x4e, 0x72, 0x72, 0x69, 0x39, 0xc3, 0x7c, 0x48, 0xf9, 0x29, + 0xd1, 0x41, 0xab, 0x04, 0x0a, 0xbd, 0xe8, 0x18, 0x36, 0x56, 0xee, 0xb5, 0x35, 0xba, 0x0e, 0x92, + 0x2e, 0xe5, 0xce, 0x4e, 0x57, 0x40, 0x66, 0xe4, 0x7b, 0x3b, 0x65, 0x02, 0x8d, 0xd8, 0xef, 0xb6, + 0x46, 0xd4, 0xde, 0xb6, 0x0c, 0xc7, 0x32, 0x0b, 0x19, 0xa6, 0x76, 0xf6, 0x84, 0xee, 0x80, 0xe8, + 0x9e, 0x98, 0xca, 0x21, 0x56, 0x6d, 0x77, 0x0f, 0xab, 0x2e, 0x99, 0x9f, 0x81, 0xe6, 0xc8, 0xbb, + 0x27, 0x66, 0x35, 0x44, 0xde, 0x48, 0xa5, 0x67, 0xc5, 0xf4, 0x46, 0x2a, 0x9d, 0x16, 0x33, 0xd2, + 0x7f, 0x14, 0x20, 0xe7, 0xf5, 0x8d, 0x38, 0xbb, 0xf1, 0x6d, 0x10, 0x2d, 0x13, 0x2b, 0xed, 0x43, + 0xd5, 0xc1, 0xbc, 0x2d, 0xf9, 0xec, 0x90, 0xb3, 0x4c, 0xbc, 0x43, 0xc8, 0xac, 0x65, 0xd0, 0x0e, + 0x2c, 0x38, 0xae, 0x7a, 0x60, 0x98, 0x07, 0x8a, 0xbf, 0xc4, 0x4f, 0x3d, 0x8b, 0x09, 0x91, 0x80, + 0xc8, 0xb9, 0x7d, 0x7a, 0x8f, 0x4b, 0xf1, 0x33, 0x01, 0x16, 0xd6, 0xf4, 0x96, 0x61, 0xd6, 0xdb, + 0x4d, 0x23, 0xd6, 0x05, 0x86, 0xb7, 0x21, 0xe3, 0x10, 0x99, 0x81, 0x75, 0x0e, 0xe0, 0x62, 0x9a, + 0xa6, 0x10, 0x33, 0xfd, 0x18, 0xf2, 0xf8, 0xa4, 0x6d, 0xb0, 0x7d, 0x05, 0x86, 0x72, 0x52, 0x93, + 0xd7, 0x2d, 0x17, 0xf0, 0x92, 0x24, 0x5e, 0xa7, 0xcf, 0x00, 0x85, 0xab, 0x14, 0x27, 0xd0, 0xf8, + 0x0c, 0x16, 0xa9, 0xe8, 0x5d, 0xd3, 0x89, 0x59, 0x5f, 0xd2, 0xaf, 0xc1, 0x85, 0x5e, 0xd1, 0x71, + 0x96, 0xfb, 0x39, 0x6f, 0xe5, 0x2d, 0x6c, 0xc7, 0x8a, 0x50, 0x7d, 0x5d, 0x73, 0xc1, 0x71, 0x96, + 0xf9, 0x37, 0x05, 0x78, 0x83, 0xca, 0xa6, 0x5b, 0x2f, 0xfb, 0xd8, 0x7e, 0x8c, 0x55, 0x27, 0x56, + 0x78, 0x7d, 0x1d, 0x66, 0x18, 0x4c, 0xa6, 0xfd, 0x73, 0xba, 0x94, 0x25, 0x6e, 0x46, 0xdd, 0xb5, + 0x6c, 0xe2, 0x66, 0xf0, 0x24, 0x49, 0x85, 0xa5, 0xa8, 0x52, 0xc4, 0x59, 0xd3, 0xbf, 0x23, 0xc0, + 0x02, 0xf7, 0xf0, 0x48, 0x57, 0x2e, 0x1f, 0x12, 0x07, 0x07, 0x55, 0x20, 0xab, 0xd1, 0x5f, 0x8a, + 0xdb, 0x6d, 0x63, 0x2a, 0x3f, 0x37, 0xca, 0x39, 0x64, 0x6c, 0x8d, 0x6e, 0x1b, 0x13, 0x0f, 0xd3, + 0xfb, 0x4d, 0x14, 0x15, 0xaa, 0xe4, 0x48, 0xf7, 0x92, 0x8e, 0x23, 0x9a, 0xd7, 0xf3, 0xd3, 0xb8, + 0x0e, 0xfe, 0x49, 0x92, 0x2b, 0x81, 0xbd, 0x83, 0x67, 0x8f, 0xd5, 0xa1, 0xf8, 0x1c, 0x2e, 0x85, + 0x96, 0xce, 0xc3, 0x15, 0x4f, 0x9c, 0xa3, 0xe2, 0xa1, 0xe5, 0xf7, 0x80, 0x8a, 0x3e, 0x83, 0xd0, + 0x02, 0xbb, 0xc2, 0xea, 0xe4, 0x41, 0x95, 0xf3, 0xa8, 0x63, 0x21, 0x90, 0xc2, 0xe8, 0x0e, 0x2a, + 0x43, 0x1a, 0x9f, 0xb4, 0x15, 0x1d, 0x3b, 0x1a, 0x37, 0x5c, 0x52, 0x94, 0x40, 0x52, 0x94, 0x01, + 0xe7, 0x7d, 0x16, 0x9f, 0xb4, 0x09, 0x11, 0xed, 0x92, 0x79, 0xd3, 0x9b, 0xd7, 0x69, 0xb1, 0x9d, + 0xf1, 0x58, 0x20, 0xe8, 0x29, 0x5c, 0x5c, 0xde, 0x9f, 0xd2, 0x99, 0x08, 0xe9, 0x87, 0x02, 0x5c, + 0x89, 0x6c, 0xb5, 0x38, 0x27, 0xb2, 0x4f, 0x20, 0x45, 0x2b, 0x9f, 0x38, 0x67, 0xe5, 0x29, 0x97, + 0xf4, 0xbd, 0x04, 0x1f, 0xe3, 0x32, 0x6e, 0x5a, 0x44, 0xb1, 0xb1, 0x2f, 0xa1, 0x3d, 0x81, 0xf9, + 0x63, 0xcb, 0xc5, 0xb6, 0xdf, 0xec, 0x89, 0x73, 0x37, 0xfb, 0x1c, 0x15, 0xe0, 0xb5, 0xf8, 0x33, + 0x58, 0x30, 0x2d, 0x53, 0xe9, 0x15, 0x7a, 0xfe, 0xbe, 0x94, 0x37, 0x2d, 0xf3, 0x59, 0x48, 0xae, + 0x6f, 0x67, 0xfa, 0x34, 0x11, 0xa7, 0x9d, 0xf9, 0xbe, 0x00, 0x8b, 0xbe, 0xa7, 0x13, 0xb3, 0xbb, + 0xfb, 0x3e, 0x24, 0x4d, 0xeb, 0xe5, 0x79, 0x96, 0x28, 0x49, 0x7e, 0x32, 0xeb, 0xf5, 0x96, 0x28, + 0xce, 0xfa, 0xfe, 0xab, 0x04, 0x64, 0x1e, 0x95, 0xe3, 0xac, 0xe5, 0x27, 0x7c, 0xf9, 0x9b, 0xb5, + 0x77, 0x54, 0x6f, 0xf7, 0xdf, 0x57, 0x7c, 0x54, 0xde, 0xc4, 0x5d, 0xaf, 0xb7, 0x13, 0x2e, 0xb4, + 0x06, 0x99, 0xde, 0x85, 0xd2, 0x09, 0x35, 0x15, 0x70, 0x2d, 0x61, 0x98, 0xa6, 0x72, 0xbd, 0x50, + 0x0b, 0x21, 0x22, 0xd4, 0x82, 0xbc, 0xc6, 0xf7, 0x14, 0x13, 0xe7, 0x79, 0x4d, 0xc8, 0x45, 0x9c, + 0x16, 0x67, 0xa4, 0xa7, 0x00, 0xa4, 0x3a, 0x71, 0x36, 0xc9, 0x6f, 0x25, 0x21, 0xb7, 0xd3, 0x71, + 0x0e, 0x63, 0xee, 0x7d, 0x65, 0x80, 0x76, 0xc7, 0x39, 0x24, 0x23, 0xf2, 0xc4, 0xe4, 0x75, 0x1e, + 0x13, 0xc5, 0xe1, 0x55, 0x9a, 0xf1, 0x35, 0x4e, 0x4c, 0x54, 0xe5, 0x42, 0xb0, 0x12, 0x84, 0x82, + 0x5c, 0x1f, 0x85, 0x2c, 0x1b, 0x27, 0xe6, 0x16, 0xf6, 0x21, 0x25, 0x93, 0x84, 0x89, 0xa4, 0x4f, + 0x60, 0x96, 0x3c, 0x28, 0xae, 0x75, 0x9e, 0x66, 0x9e, 0x21, 0x3c, 0x0d, 0x0b, 0x7d, 0x0c, 0x19, + 0xc6, 0x4d, 0x66, 0xbf, 0x19, 0x3a, 0xfb, 0x45, 0xd5, 0x85, 0xab, 0x91, 0xce, 0x7b, 0x69, 0xca, + 0x4a, 0xe6, 0xba, 0x0b, 0x30, 0xbd, 0x6f, 0xd9, 0x9a, 0xb7, 0x99, 0xcb, 0x1e, 0x58, 0x7b, 0x32, + 0x48, 0xb3, 0x91, 0x4a, 0x67, 0x44, 0x90, 0x7e, 0x47, 0x80, 0xbc, 0xdf, 0x10, 0x71, 0x4e, 0x08, + 0xe5, 0x1e, 0x2d, 0x9e, 0xbf, 0x29, 0x88, 0x02, 0xa5, 0x7f, 0x4b, 0x3d, 0x22, 0xcd, 0x3a, 0xa6, + 0x2d, 0x13, 0x67, 0x4f, 0xf9, 0x98, 0x05, 0xfa, 0x24, 0xce, 0xdb, 0xba, 0x34, 0xe6, 0xe7, 0x1e, + 0x5c, 0x30, 0x5a, 0xc4, 0x9e, 0x1b, 0x6e, 0xb3, 0xcb, 0x61, 0x9b, 0x8b, 0xbd, 0x5d, 0xe3, 0xc5, + 0x20, 0xad, 0xec, 0x25, 0x49, 0xbf, 0x4f, 0x57, 0xab, 0x83, 0x9a, 0xc4, 0xa9, 0xea, 0x1a, 0xcc, + 0xdb, 0x4c, 0x34, 0x71, 0x6b, 0xce, 0xa9, 0xed, 0x39, 0x9f, 0x95, 0x28, 0xfc, 0x77, 0x13, 0x90, + 0x7f, 0xda, 0xc1, 0x76, 0xf7, 0x9b, 0xa4, 0xee, 0x9b, 0x90, 0x7f, 0xa9, 0x1a, 0xae, 0xb2, 0x6f, + 0xd9, 0x4a, 0xa7, 0xad, 0xab, 0xae, 0x17, 0x6d, 0x32, 0x4f, 0xc8, 0x0f, 0x2d, 0x7b, 0x97, 0x12, + 0x11, 0x06, 0x74, 0x64, 0x5a, 0x2f, 0x4d, 0x85, 0x90, 0x29, 0x50, 0x3e, 0x31, 0xf9, 0x12, 0x72, + 0xe9, 0x83, 0xff, 0x70, 0xba, 0xf2, 0x60, 0xa2, 0x18, 0x32, 0x1a, 0x2f, 0xd7, 0xe9, 0x18, 0x7a, + 0x71, 0x77, 0xb7, 0xb6, 0x2e, 0x8b, 0x54, 0xe4, 0x73, 0x26, 0xb1, 0x71, 0x62, 0x3a, 0xd2, 0xdf, + 0x4b, 0x80, 0x18, 0xe8, 0x28, 0xce, 0x86, 0xac, 0x40, 0xf6, 0x45, 0x07, 0xdb, 0xc6, 0x2b, 0x34, + 0x23, 0x70, 0x46, 0x62, 0x76, 0xee, 0xc2, 0x82, 0x7b, 0x62, 0x2a, 0x2c, 0xc2, 0x8f, 0x05, 0x7e, + 0x78, 0x01, 0x0b, 0x79, 0x97, 0x94, 0x99, 0xd0, 0x69, 0xd0, 0x87, 0x83, 0x3e, 0x87, 0xb9, 0x1e, + 0x6d, 0x25, 0x5f, 0x4f, 0x5b, 0xd9, 0x97, 0x21, 0x45, 0xfd, 0x91, 0x00, 0x88, 0x2a, 0xaa, 0xc6, + 0xd6, 0xf8, 0xbf, 0x29, 0xfd, 0xe9, 0x36, 0x88, 0x34, 0x1e, 0x53, 0x31, 0xf6, 0x95, 0x96, 0xe1, + 0x38, 0x86, 0x79, 0xc0, 0x3b, 0x54, 0x8e, 0xd2, 0x6b, 0xfb, 0x5b, 0x8c, 0x2a, 0xfd, 0x65, 0x58, + 0xec, 0xa9, 0x40, 0x9c, 0x8d, 0x7d, 0x0d, 0xe6, 0xf6, 0xd9, 0x16, 0x2c, 0x15, 0xce, 0x97, 0x07, + 0xb3, 0x94, 0xc6, 0xde, 0x27, 0xfd, 0x59, 0x02, 0x2e, 0xc8, 0xd8, 0xb1, 0x9a, 0xc7, 0x38, 0x7e, + 0x15, 0x56, 0x81, 0xef, 0xbd, 0x28, 0xaf, 0xa4, 0xc9, 0x0c, 0x63, 0x66, 0xd3, 0x5c, 0xef, 0x1a, + 0xfb, 0xdb, 0xa3, 0x7b, 0xec, 0xe0, 0xaa, 0x3a, 0x5f, 0xa9, 0x4b, 0xf5, 0xac, 0xd4, 0x59, 0x90, + 0x67, 0xbb, 0xc7, 0xba, 0xe2, 0xe0, 0x17, 0x66, 0xa7, 0xe5, 0x81, 0xa1, 0xe2, 0xa8, 0x42, 0xd6, + 0x18, 0x4b, 0x1d, 0xbf, 0xd8, 0xee, 0xb4, 0xa8, 0xef, 0x5c, 0xba, 0x44, 0xca, 0x7b, 0x76, 0xba, + 0x92, 0xeb, 0x49, 0x73, 0xe4, 0x9c, 0xe1, 0x3f, 0x13, 0xe9, 0xd2, 0x77, 0xe0, 0x62, 0x9f, 0xb2, + 0xe3, 0xf4, 0x78, 0xfe, 0x45, 0x12, 0xde, 0xe8, 0x15, 0x1f, 0x37, 0xc4, 0xf9, 0xa6, 0x37, 0x68, + 0x15, 0xe6, 0x5b, 0x86, 0xf9, 0x6a, 0xab, 0x97, 0x73, 0x2d, 0xc3, 0xf4, 0x69, 0x51, 0x5d, 0x63, + 0xe6, 0x6b, 0xed, 0x1a, 0x2a, 0x2c, 0x45, 0xb5, 0x5d, 0x9c, 0xfd, 0xe3, 0x7b, 0x02, 0xcc, 0xc5, + 0xbd, 0x2c, 0xf7, 0x6a, 0x51, 0x70, 0x52, 0x03, 0xe6, 0xbf, 0x86, 0x75, 0xbc, 0xdf, 0x15, 0x00, + 0x35, 0xec, 0x8e, 0x49, 0x40, 0xed, 0x63, 0xeb, 0x20, 0xce, 0x6a, 0x5e, 0x80, 0x69, 0xc3, 0xd4, + 0xf1, 0x09, 0xad, 0x66, 0x4a, 0x66, 0x0f, 0x3d, 0x5b, 0x89, 0xc9, 0x89, 0xb6, 0x12, 0xa5, 0xcf, + 0x61, 0xb1, 0xa7, 0x88, 0x71, 0xd6, 0xff, 0x4f, 0x13, 0xb0, 0xc8, 0x2b, 0x12, 0xfb, 0x0a, 0xe6, + 0x7b, 0x30, 0xdd, 0x24, 0x32, 0x47, 0xb4, 0x33, 0x7d, 0xa7, 0xd7, 0xce, 0x34, 0x33, 0xfa, 0x15, + 0x80, 0xb6, 0x8d, 0x8f, 0x15, 0xc6, 0x9a, 0x9c, 0x88, 0x35, 0x43, 0x38, 0x28, 0x01, 0x7d, 0x29, + 0x40, 0x9e, 0x0c, 0xe8, 0xb6, 0x6d, 0xb5, 0x2d, 0x87, 0xf8, 0x2c, 0xce, 0x64, 0x30, 0xe7, 0xe9, + 0xd9, 0xe9, 0xca, 0xfc, 0x96, 0x61, 0xee, 0x70, 0xc6, 0x46, 0x7d, 0xe2, 0x00, 0x7f, 0xef, 0x98, + 0x43, 0xb1, 0xdc, 0xb4, 0xb4, 0xa3, 0x60, 0x73, 0x8c, 0x58, 0x16, 0x5f, 0x9c, 0x23, 0xfd, 0x44, + 0x80, 0x0b, 0x5f, 0xdb, 0x72, 0xf1, 0xff, 0x0b, 0x65, 0x4b, 0xcf, 0x40, 0xa4, 0x3f, 0x6a, 0xe6, + 0xbe, 0x15, 0xe7, 0xc2, 0xfd, 0xff, 0x12, 0x60, 0x21, 0x24, 0x38, 0x4e, 0x07, 0xe7, 0x55, 0xf5, + 0x34, 0xcf, 0xc2, 0x61, 0xdc, 0xc9, 0x54, 0x25, 0xcf, 0xf1, 0xec, 0xac, 0x53, 0x16, 0x61, 0x0e, + 0x13, 0x2b, 0x46, 0x97, 0x78, 0xf7, 0xd8, 0x21, 0x93, 0xbe, 0x15, 0xfd, 0xac, 0x9f, 0xa1, 0xd4, + 0x95, 0x7e, 0x8d, 0x78, 0x58, 0xe1, 0x41, 0x19, 0xe7, 0x90, 0xff, 0xe7, 0x09, 0xb8, 0x54, 0x66, + 0x5b, 0xe0, 0x5e, 0x4c, 0x48, 0x9c, 0x1d, 0xb1, 0x00, 0xb3, 0xc7, 0xd8, 0x76, 0x0c, 0x8b, 0xcd, + 0xf6, 0xf3, 0xb2, 0xf7, 0x88, 0x96, 0x20, 0xed, 0x98, 0x6a, 0xdb, 0x39, 0xb4, 0xbc, 0xed, 0x44, + 0xff, 0xd9, 0x8f, 0x5f, 0x99, 0x7e, 0xf5, 0xf8, 0x95, 0x99, 0xd1, 0xf1, 0x2b, 0xb3, 0xaf, 0x11, + 0xbf, 0xc2, 0xf7, 0xee, 0xfe, 0x9d, 0x00, 0x97, 0x07, 0x34, 0x17, 0x67, 0xe7, 0xfc, 0x2e, 0x64, + 0x35, 0x2e, 0x98, 0xcc, 0x0f, 0x6c, 0x63, 0xb2, 0x46, 0xb2, 0xbd, 0x22, 0xf4, 0x39, 0x3b, 0x5d, + 0x01, 0xaf, 0xa8, 0xb5, 0x75, 0xae, 0x1c, 0xf2, 0x5b, 0x97, 0xfe, 0x1b, 0x40, 0xbe, 0x72, 0xc2, + 0x16, 0xe5, 0xeb, 0xcc, 0x2b, 0x41, 0x0f, 0x21, 0xdd, 0xb6, 0xad, 0x63, 0xc3, 0xab, 0x46, 0xae, + 0x27, 0x78, 0xc1, 0xab, 0x46, 0x1f, 0xd7, 0x0e, 0xe7, 0x90, 0x7d, 0x5e, 0xd4, 0x80, 0xcc, 0x63, + 0x4b, 0x53, 0x9b, 0x0f, 0x8d, 0xa6, 0x37, 0xd0, 0xde, 0x1d, 0x2f, 0xa8, 0xe8, 0xf3, 0xec, 0xa8, + 0xee, 0xa1, 0xd7, 0x08, 0x3e, 0x11, 0xd5, 0x20, 0x5d, 0x75, 0xdd, 0x36, 0x49, 0xe4, 0xe3, 0xef, + 0xd6, 0x04, 0x42, 0x09, 0x8b, 0x17, 0x71, 0xeb, 0xb1, 0xa3, 0x06, 0x2c, 0x3c, 0xa2, 0xe7, 0xc7, + 0xca, 0x4d, 0xab, 0xa3, 0x97, 0x2d, 0x73, 0xdf, 0x38, 0xe0, 0xd3, 0xc4, 0xcd, 0x09, 0x64, 0x3e, + 0x2a, 0xd7, 0xe5, 0x41, 0x01, 0x68, 0x0d, 0xd2, 0xf5, 0x07, 0x5c, 0x18, 0x73, 0x23, 0x6f, 0x4c, + 0x20, 0xac, 0xfe, 0x40, 0xf6, 0xd9, 0xd0, 0x06, 0x64, 0xd7, 0xbe, 0xe8, 0xd8, 0x98, 0x4b, 0x99, + 0x19, 0x1a, 0x39, 0xd1, 0x2f, 0x85, 0x72, 0xc9, 0x61, 0x66, 0xf4, 0x1d, 0xc8, 0x13, 0xbd, 0x35, + 0xd4, 0xbd, 0xa6, 0x27, 0x2f, 0x4d, 0xe5, 0x7d, 0x6b, 0x02, 0x79, 0x3e, 0xa7, 0xb7, 0x25, 0xd0, + 0x27, 0x6a, 0x49, 0x86, 0xf9, 0x9e, 0xf6, 0x42, 0x08, 0x52, 0x6d, 0xd2, 0x34, 0x02, 0x0d, 0x43, + 0xa2, 0xbf, 0xd1, 0x3b, 0x30, 0x6b, 0x5a, 0x3a, 0xf6, 0x3a, 0xf3, 0x7c, 0xe9, 0xc2, 0xd9, 0xe9, + 0xca, 0xcc, 0xb6, 0xa5, 0x33, 0x5f, 0x87, 0xff, 0x92, 0x67, 0x48, 0xa6, 0x9a, 0xbe, 0x74, 0x15, + 0x52, 0xa4, 0x89, 0x88, 0x0d, 0xd9, 0x53, 0x1d, 0xbc, 0x6b, 0x1b, 0x5c, 0x9a, 0xf7, 0xb8, 0xf4, + 0x07, 0x09, 0x48, 0xd4, 0x1f, 0x10, 0x6f, 0x7e, 0xaf, 0xa3, 0x1d, 0x61, 0x97, 0xa7, 0xf3, 0x27, + 0xea, 0xe5, 0xdb, 0x78, 0xdf, 0x60, 0x4e, 0x57, 0x46, 0xe6, 0x4f, 0xe8, 0x2d, 0x00, 0x55, 0xd3, + 0xb0, 0xe3, 0x28, 0xde, 0x11, 0xc0, 0x8c, 0x9c, 0x61, 0x94, 0x4d, 0xdc, 0x25, 0x6c, 0x0e, 0xd6, + 0x6c, 0xec, 0x7a, 0x31, 0x54, 0xec, 0x89, 0xb0, 0xb9, 0xb8, 0xd5, 0x56, 0x5c, 0xeb, 0x08, 0x9b, + 0xb4, 0x49, 0x33, 0xc4, 0x2a, 0xb4, 0xda, 0x0d, 0x42, 0x20, 0x06, 0x0d, 0x9b, 0x7a, 0x60, 0x7d, + 0x32, 0xb2, 0xff, 0x4c, 0x44, 0xda, 0xf8, 0xc0, 0xe0, 0x07, 0xe8, 0x32, 0x32, 0x7f, 0x22, 0x5a, + 0x52, 0x3b, 0xee, 0x21, 0x6d, 0x89, 0x8c, 0x4c, 0x7f, 0xa3, 0x9b, 0x90, 0x67, 0x61, 0x97, 0x0a, + 0x36, 0x35, 0x85, 0xda, 0xc1, 0x0c, 0x4d, 0x9e, 0x67, 0xe4, 0x8a, 0xa9, 0x11, 0xab, 0x87, 0x1e, + 0x00, 0x27, 0x28, 0x47, 0x2d, 0x87, 0xe8, 0x14, 0x48, 0xae, 0x52, 0xfe, 0xec, 0x74, 0x25, 0x5b, + 0xa7, 0x09, 0x9b, 0x5b, 0x75, 0x32, 0x97, 0xb0, 0x5c, 0x9b, 0x2d, 0xa7, 0xa6, 0x2f, 0xfd, 0x2d, + 0x01, 0x92, 0x8f, 0xca, 0xf5, 0x73, 0xab, 0xcc, 0x2b, 0x68, 0x32, 0x54, 0xd0, 0x5b, 0x90, 0xdf, + 0x33, 0x9a, 0x4d, 0xc3, 0x3c, 0x20, 0xfe, 0xd5, 0x77, 0xb1, 0xe6, 0x29, 0x2c, 0xc7, 0xc9, 0x3b, + 0x8c, 0x8a, 0xae, 0x42, 0x56, 0xb3, 0xb1, 0x8e, 0x4d, 0xd7, 0x50, 0x9b, 0x0e, 0xd7, 0x5c, 0x98, + 0xb4, 0xf4, 0x57, 0x04, 0x98, 0xa6, 0x9d, 0x15, 0xbd, 0x09, 0x19, 0xcd, 0x32, 0x5d, 0xd5, 0x30, + 0xb9, 0xd5, 0xc9, 0xc8, 0x01, 0x61, 0x68, 0xf1, 0xae, 0xc1, 0x9c, 0xaa, 0x69, 0x56, 0xc7, 0x74, + 0x15, 0x53, 0x6d, 0x61, 0x5e, 0xcc, 0x2c, 0xa7, 0x6d, 0xab, 0x2d, 0x8c, 0x56, 0xc0, 0x7b, 0xf4, + 0x4f, 0x76, 0x66, 0x64, 0xe0, 0xa4, 0x4d, 0xdc, 0x5d, 0xc2, 0x90, 0xf1, 0x7b, 0x35, 0xa9, 0x6f, + 0xc7, 0xf1, 0x4b, 0x40, 0x7f, 0xa3, 0x77, 0xe1, 0xc2, 0x8b, 0x8e, 0xda, 0x34, 0xf6, 0xe9, 0xe2, + 0x17, 0x8d, 0x52, 0xa7, 0x2f, 0x63, 0x45, 0x41, 0x7e, 0x1a, 0x95, 0x40, 0xdf, 0xe9, 0x0d, 0x82, + 0x64, 0x30, 0x08, 0x58, 0xc8, 0x8e, 0xd4, 0x85, 0x05, 0x19, 0xbb, 0x76, 0xb7, 0xc1, 0x0e, 0xbb, + 0x56, 0x8e, 0xb1, 0xe9, 0x92, 0xba, 0x5b, 0x6d, 0xcc, 0x82, 0x44, 0xbc, 0xba, 0xfb, 0x04, 0x74, + 0x03, 0x72, 0xaa, 0x4b, 0xba, 0x9b, 0xab, 0x98, 0x9d, 0xd6, 0x1e, 0xb6, 0x59, 0x28, 0x80, 0x3c, + 0xcf, 0xa9, 0xdb, 0x94, 0xc8, 0x4f, 0x64, 0xd8, 0x5d, 0x85, 0xae, 0x13, 0xf1, 0x57, 0x03, 0x25, + 0x55, 0x08, 0x45, 0xba, 0x03, 0x17, 0x49, 0x3d, 0x2b, 0xa6, 0x66, 0x77, 0xdb, 0x44, 0xf2, 0x13, + 0xfa, 0xd7, 0x41, 0x62, 0x68, 0x9f, 0x86, 0x6e, 0xcf, 0x48, 0x3f, 0x9e, 0x81, 0xf9, 0xca, 0x49, + 0xdb, 0xb2, 0x63, 0x5d, 0xd5, 0x29, 0xc1, 0x2c, 0x07, 0xbe, 0x23, 0xb6, 0x62, 0xfb, 0x2c, 0x90, + 0xb7, 0x0f, 0xcd, 0x19, 0x51, 0x09, 0x80, 0x05, 0x54, 0xd2, 0x38, 0x9c, 0xe4, 0x39, 0x76, 0x8e, + 0x28, 0x1b, 0x3d, 0x6c, 0xb0, 0x0d, 0xd9, 0xd6, 0xb1, 0xa6, 0x29, 0xfb, 0x46, 0xd3, 0xe5, 0x71, + 0x69, 0xd1, 0x21, 0xd4, 0x5b, 0xcf, 0xca, 0xe5, 0x87, 0x34, 0x13, 0x8b, 0xe7, 0x0a, 0x9e, 0x65, + 0x20, 0x12, 0xd8, 0x6f, 0xf4, 0x2d, 0xe0, 0x07, 0x5f, 0x14, 0xc7, 0x3b, 0xc6, 0x56, 0x9a, 0x3f, + 0x3b, 0x5d, 0xc9, 0xc8, 0x94, 0x5a, 0xaf, 0x37, 0xe4, 0x0c, 0xcb, 0x50, 0x77, 0xdc, 0xf3, 0x1c, + 0x75, 0x98, 0x9d, 0xfc, 0xa8, 0xc3, 0x5f, 0x17, 0xe0, 0x12, 0xd7, 0x91, 0xb2, 0x47, 0xc3, 0xbb, + 0xd5, 0xa6, 0xe1, 0x76, 0x95, 0xa3, 0xe3, 0x42, 0x9a, 0xba, 0x3c, 0xbf, 0x1c, 0xa9, 0xeb, 0x50, + 0x13, 0x17, 0x3d, 0x8d, 0x77, 0x1f, 0x73, 0xe6, 0xcd, 0xe3, 0x8a, 0xe9, 0xda, 0xdd, 0xd2, 0xe5, + 0xb3, 0xd3, 0x95, 0xc5, 0xc1, 0xd4, 0x67, 0xf2, 0xa2, 0x33, 0xc8, 0x82, 0xaa, 0x00, 0xd8, 0xef, + 0x62, 0xd4, 0x82, 0x45, 0x4f, 0x5d, 0x91, 0x7d, 0x51, 0x0e, 0xf1, 0xa2, 0xdb, 0x20, 0xf2, 0xa3, + 0x25, 0xfb, 0x46, 0x13, 0x2b, 0x8e, 0xf1, 0x05, 0xa6, 0xb6, 0x2e, 0x29, 0xe7, 0x18, 0x9d, 0x88, + 0xa8, 0x1b, 0x5f, 0x60, 0x74, 0x0f, 0x2e, 0x06, 0x2d, 0xa0, 0xec, 0xe1, 0xa6, 0xf5, 0x92, 0x65, + 0xcf, 0xd2, 0xec, 0xc8, 0xd7, 0x7e, 0x89, 0x24, 0x11, 0x96, 0xa5, 0xef, 0x42, 0x61, 0x58, 0x85, + 0xc3, 0x03, 0x22, 0xc3, 0xf6, 0x2b, 0x3f, 0xec, 0x5d, 0xac, 0x98, 0xa0, 0xe3, 0xf2, 0x05, 0x8b, + 0x8f, 0x12, 0x1f, 0x0a, 0xd2, 0x3f, 0x4c, 0xc0, 0x7c, 0xa9, 0xd3, 0x3c, 0x7a, 0xd2, 0xae, 0xb3, + 0x63, 0xf9, 0xe8, 0x0a, 0x64, 0x74, 0xd5, 0x55, 0x59, 0x21, 0x05, 0x76, 0xc4, 0x8c, 0x10, 0x68, + 0x6d, 0x6e, 0x41, 0x3e, 0x14, 0x0b, 0xc2, 0x23, 0xde, 0x69, 0xb5, 0x03, 0x32, 0x0d, 0x4a, 0xff, + 0x10, 0x0a, 0xa1, 0x8c, 0x74, 0x65, 0x41, 0xc1, 0xa6, 0x6b, 0x1b, 0x98, 0xad, 0x8e, 0x25, 0xe5, + 0x50, 0xc0, 0x4a, 0x8d, 0x24, 0x57, 0x58, 0x2a, 0x6a, 0xc0, 0x1c, 0xc9, 0xd8, 0x55, 0xa8, 0x15, + 0xf4, 0x56, 0x2f, 0xef, 0x45, 0x54, 0xab, 0xa7, 0xdc, 0x45, 0xaa, 0x9f, 0x32, 0xe5, 0xa1, 0x3f, + 0xe5, 0x2c, 0x0e, 0x28, 0x4b, 0x9f, 0x82, 0xd8, 0x9f, 0x21, 0xac, 0xcb, 0x14, 0xd3, 0xe5, 0x85, + 0xb0, 0x2e, 0x93, 0x21, 0x3d, 0x6d, 0xa4, 0xd2, 0x29, 0x71, 0x5a, 0xfa, 0x49, 0x12, 0x72, 0x5e, + 0xcf, 0x8c, 0xd3, 0xad, 0x2e, 0xc1, 0x34, 0xe9, 0x47, 0x5e, 0x78, 0xc5, 0xcd, 0x11, 0x03, 0x82, + 0xc7, 0x58, 0x93, 0xfe, 0xe5, 0x21, 0x40, 0xca, 0x1a, 0x87, 0xf9, 0x59, 0xfa, 0x85, 0x00, 0x29, + 0xea, 0xc9, 0xde, 0x83, 0x14, 0x3d, 0x97, 0x2f, 0x8c, 0x3c, 0x97, 0xef, 0x6d, 0xcf, 0x93, 0xac, + 0xfe, 0xc4, 0x92, 0x08, 0x79, 0x57, 0x25, 0x1a, 0xdf, 0x63, 0xd9, 0x2e, 0xd6, 0xb9, 0xa7, 0x78, + 0x75, 0x5c, 0x3b, 0x7a, 0x9e, 0xb0, 0xc7, 0x87, 0xde, 0x80, 0x24, 0xb1, 0x5d, 0xb3, 0x6c, 0xab, + 0xfe, 0xec, 0x74, 0x25, 0x49, 0xac, 0x16, 0xa1, 0xa1, 0x55, 0xc8, 0xf6, 0x5a, 0x13, 0xe2, 0x6c, + 0x50, 0x73, 0x18, 0xb2, 0x04, 0xd0, 0xf4, 0x87, 0x10, 0x43, 0x49, 0xac, 0x2d, 0xf9, 0x26, 0xfd, + 0x6f, 0x0a, 0x3c, 0x26, 0xb1, 0xae, 0x91, 0x39, 0xcb, 0x8e, 0x73, 0x52, 0xb9, 0x03, 0xa2, 0xad, + 0x9a, 0xba, 0xd5, 0x32, 0xbe, 0xc0, 0x0c, 0x95, 0x3b, 0x7c, 0xbb, 0x22, 0xef, 0xd3, 0x29, 0x7c, + 0x76, 0xa4, 0xff, 0x2a, 0xf0, 0xf8, 0x45, 0xbf, 0x18, 0xf1, 0x6e, 0x2a, 0x67, 0xf9, 0x92, 0x9e, + 0xb9, 0x6f, 0x79, 0xe1, 0x17, 0x6f, 0x0e, 0x0b, 0x36, 0xaa, 0x99, 0xfb, 0x96, 0xb7, 0x3d, 0x66, + 0x7b, 0x04, 0x67, 0xe9, 0x57, 0x61, 0x9a, 0x26, 0xbf, 0x42, 0xdf, 0xf0, 0x63, 0x66, 0x13, 0x62, + 0x52, 0xfa, 0x93, 0x04, 0xbc, 0x4d, 0xab, 0xfa, 0x0c, 0xdb, 0xc6, 0x7e, 0x77, 0xc7, 0xb6, 0x5c, + 0xac, 0xb9, 0x58, 0x0f, 0x56, 0xa5, 0x62, 0x6c, 0x02, 0x1d, 0x32, 0x7c, 0x3f, 0xcf, 0xd0, 0xf9, + 0xcd, 0x19, 0x8f, 0x5e, 0x0f, 0xad, 0xa6, 0xd9, 0x3e, 0x60, 0x6d, 0x5d, 0x4e, 0x33, 0xc9, 0x35, + 0x1d, 0xad, 0x41, 0xa6, 0xed, 0x55, 0xe3, 0x5c, 0x21, 0x23, 0x3e, 0x17, 0xda, 0x84, 0x3c, 0x2f, + 0xa8, 0xda, 0x34, 0x8e, 0xb1, 0xa2, 0xba, 0xe7, 0x19, 0xc2, 0xf3, 0x8c, 0x77, 0x8d, 0xb0, 0xae, + 0xb9, 0xd2, 0xdf, 0x4c, 0xc1, 0x8d, 0x31, 0x2a, 0x8e, 0xb3, 0x7b, 0x2d, 0x41, 0xfa, 0x98, 0xbc, + 0xc8, 0xe0, 0xb5, 0x4f, 0xcb, 0xfe, 0x33, 0xda, 0xeb, 0x99, 0x07, 0xf6, 0x55, 0xa3, 0x49, 0xe6, + 0x0d, 0x16, 0xa4, 0x37, 0x3c, 0x0c, 0x28, 0x3a, 0xe8, 0x2d, 0x34, 0x63, 0x3c, 0xa4, 0x82, 0x68, + 0x36, 0x07, 0x7d, 0x4f, 0x80, 0x25, 0xf6, 0x42, 0x16, 0x29, 0xd6, 0xf7, 0x9a, 0x14, 0x7d, 0xcd, + 0x7a, 0xc4, 0x6b, 0x26, 0xd2, 0x51, 0x31, 0xf4, 0x2e, 0x5e, 0x90, 0x42, 0xf8, 0x6d, 0xe1, 0xa2, + 0x2c, 0xfd, 0xb6, 0x00, 0xd9, 0x10, 0x01, 0xdd, 0x1c, 0x38, 0x97, 0x93, 0x3d, 0x8b, 0x3a, 0x8c, + 0x73, 0x63, 0xe0, 0x30, 0x4e, 0x29, 0xfd, 0xd5, 0xe9, 0x4a, 0x4a, 0x66, 0xf1, 0xde, 0xde, 0xb1, + 0x9c, 0x6b, 0xc1, 0x35, 0x30, 0xc9, 0xbe, 0x4c, 0xde, 0x3d, 0x30, 0x14, 0xd6, 0xa9, 0xde, 0x36, + 0x12, 0x85, 0x75, 0xe4, 0x49, 0xfa, 0x41, 0x02, 0x16, 0xd6, 0x74, 0xbd, 0x5e, 0xa7, 0x50, 0x20, + 0xce, 0x31, 0x86, 0x20, 0x45, 0xfc, 0x03, 0x7e, 0x86, 0x88, 0xfe, 0x46, 0xef, 0x00, 0xd2, 0x0d, + 0x87, 0x5d, 0xa7, 0xe0, 0x1c, 0xaa, 0xba, 0xf5, 0x32, 0xd8, 0x2d, 0x5e, 0xf0, 0x52, 0xea, 0x5e, + 0x02, 0xaa, 0x03, 0x75, 0x5a, 0x15, 0xc7, 0x55, 0xfd, 0xd5, 0xf0, 0x1b, 0x13, 0x9d, 0x4a, 0x61, + 0xde, 0xac, 0xff, 0x28, 0x67, 0x88, 0x1c, 0xfa, 0x93, 0xf8, 0x68, 0x06, 0x69, 0x14, 0x57, 0x51, + 0x1d, 0xef, 0x3c, 0x05, 0xbb, 0xc8, 0x21, 0xc7, 0xe8, 0x6b, 0x0e, 0x3b, 0x26, 0xc1, 0xc2, 0xb0, + 0x03, 0xd5, 0xc4, 0xb9, 0x96, 0xf9, 0x77, 0x05, 0xc8, 0xc9, 0x78, 0xdf, 0xc6, 0xce, 0x61, 0x9c, + 0x3a, 0x7f, 0x08, 0x73, 0x36, 0x93, 0xaa, 0xec, 0xdb, 0x56, 0xeb, 0x3c, 0xb6, 0x22, 0xcb, 0x19, + 0x1f, 0xda, 0x56, 0x8b, 0x9b, 0xe4, 0x67, 0x90, 0xf7, 0xcb, 0x18, 0x67, 0xe5, 0xff, 0x3e, 0x3d, + 0x71, 0xc9, 0x04, 0xc7, 0xbd, 0x6d, 0x1b, 0xaf, 0x06, 0xe8, 0x7a, 0x76, 0xb8, 0xa0, 0x71, 0xaa, + 0xe1, 0xbf, 0x08, 0x90, 0xab, 0x77, 0xf6, 0xd8, 0x35, 0x41, 0xf1, 0x69, 0xa0, 0x02, 0x99, 0x26, + 0xde, 0x77, 0x95, 0x57, 0x0a, 0x20, 0x4e, 0x13, 0x56, 0x1a, 0x3e, 0xfd, 0x08, 0xc0, 0xa6, 0x47, + 0x8e, 0xa8, 0x9c, 0xe4, 0x39, 0xe5, 0x64, 0x28, 0x2f, 0x21, 0x93, 0x59, 0x27, 0xef, 0x57, 0x33, + 0xce, 0xf9, 0xe5, 0x79, 0x8f, 0x75, 0x48, 0x9e, 0xc7, 0x3a, 0x2c, 0xf0, 0x9d, 0xea, 0x68, 0x0b, + 0x51, 0x84, 0x45, 0xea, 0x96, 0x29, 0x6a, 0xbb, 0xdd, 0x34, 0x3c, 0x9c, 0x42, 0xed, 0x4f, 0x4a, + 0x5e, 0xa0, 0x49, 0x6b, 0x2c, 0x85, 0x22, 0x14, 0xf4, 0x5b, 0x02, 0xcc, 0xed, 0xdb, 0x18, 0x7f, + 0x81, 0x15, 0x6a, 0x92, 0x27, 0xdb, 0x8a, 0x5f, 0x27, 0x65, 0x78, 0xed, 0xad, 0xba, 0x2c, 0x7b, + 0x71, 0x9d, 0xbc, 0x17, 0x6d, 0x83, 0xa8, 0x35, 0xd9, 0xe6, 0xa1, 0x1f, 0x16, 0x30, 0x33, 0xf9, + 0x00, 0xc8, 0x33, 0xe6, 0x20, 0x32, 0xe0, 0x29, 0x19, 0x4c, 0xaa, 0xae, 0xf0, 0xab, 0xd9, 0xa8, + 0xb3, 0xdd, 0x1b, 0x16, 0x10, 0x3e, 0x7a, 0x1d, 0xba, 0xd1, 0xad, 0x28, 0x63, 0x55, 0xe7, 0x9e, + 0x3b, 0x19, 0x57, 0xfe, 0x03, 0x1f, 0x57, 0xcf, 0x61, 0x81, 0xf6, 0x9b, 0xb8, 0x4f, 0x50, 0x4a, + 0xff, 0x38, 0x09, 0x28, 0x2c, 0xf9, 0xeb, 0xeb, 0x6f, 0x89, 0xf8, 0xfa, 0xdb, 0x06, 0x48, 0x21, + 0x67, 0xa8, 0xa9, 0x3a, 0xae, 0xc2, 0xe2, 0xcf, 0x1c, 0xa5, 0x8d, 0x6d, 0xc5, 0xc1, 0x9a, 0xc5, + 0x2f, 0xd1, 0x11, 0xe4, 0xe5, 0x20, 0xe7, 0x63, 0xd5, 0x71, 0x9f, 0xb2, 0x7c, 0x3b, 0xd8, 0xae, + 0xd3, 0x5c, 0xe8, 0x01, 0x5c, 0x6a, 0xa9, 0x27, 0x51, 0xfc, 0xd3, 0x94, 0x7f, 0xb1, 0xa5, 0x9e, + 0x0c, 0x30, 0x7d, 0x04, 0x4b, 0xd1, 0x4c, 0x8a, 0x83, 0xbd, 0xfd, 0xa9, 0x4b, 0x11, 0x8c, 0x75, + 0xec, 0xa2, 0x35, 0x80, 0x00, 0x44, 0xf0, 0x39, 0x7a, 0x12, 0x0c, 0x91, 0xf1, 0x31, 0x84, 0xf4, + 0x7d, 0x01, 0x72, 0x5b, 0xc6, 0x81, 0xad, 0xc6, 0x7a, 0x45, 0x0d, 0xfa, 0xa8, 0x77, 0x43, 0x2f, + 0x7b, 0x7f, 0x29, 0x2a, 0x60, 0x83, 0xe5, 0xf0, 0x16, 0xed, 0x38, 0x03, 0x99, 0xfa, 0xfc, 0x12, + 0xc5, 0x69, 0xf3, 0x35, 0x78, 0x8b, 0x86, 0xc0, 0xf1, 0xf8, 0x97, 0xaf, 0x05, 0xdd, 0x48, 0x7f, + 0x28, 0xc0, 0xf2, 0xb0, 0xb7, 0xc4, 0x39, 0x20, 0x64, 0x7a, 0x59, 0x1f, 0x7d, 0x83, 0xe2, 0x8f, + 0x88, 0x31, 0x96, 0x06, 0xf1, 0x91, 0x00, 0x7e, 0xd9, 0xea, 0xf4, 0x1a, 0x3f, 0xf6, 0xdb, 0x21, + 0x0a, 0xaa, 0x6b, 0xaa, 0x49, 0xcf, 0xd7, 0x36, 0xb1, 0x7a, 0x8c, 0x79, 0xf4, 0x5e, 0xac, 0x56, + 0xe2, 0x1f, 0x08, 0xb0, 0x3c, 0xec, 0x2d, 0xf1, 0xae, 0xdf, 0xbc, 0xf6, 0x35, 0x0e, 0x52, 0x03, + 0x72, 0x25, 0xd5, 0xb6, 0x8d, 0x58, 0xd7, 0x20, 0xa4, 0x1f, 0x08, 0x90, 0xf7, 0xc5, 0xc6, 0x59, + 0xe5, 0xd7, 0x3f, 0x26, 0x21, 0xfd, 0xe2, 0x0a, 0xcc, 0xf1, 0xf2, 0xef, 0x9a, 0x86, 0x65, 0xa2, + 0x7b, 0x90, 0x3c, 0xe0, 0xdb, 0x3f, 0xd9, 0xc8, 0x55, 0xef, 0xe0, 0x92, 0xc4, 0xea, 0x94, 0x4c, + 0xf2, 0x12, 0x96, 0x76, 0xc7, 0x8d, 0x28, 0x40, 0x10, 0xe7, 0x1f, 0x66, 0x69, 0x77, 0x5c, 0x54, + 0x87, 0xbc, 0x16, 0xdc, 0xcc, 0xa6, 0x10, 0xf6, 0xe4, 0xd0, 0xa5, 0xe0, 0xc8, 0x3b, 0xf2, 0xaa, + 0x53, 0x72, 0x4e, 0xeb, 0x49, 0x40, 0xe5, 0xf0, 0x85, 0x60, 0xa9, 0x81, 0x20, 0xc2, 0xe0, 0x38, + 0x79, 0xef, 0x65, 0x64, 0xd5, 0xa9, 0xd0, 0xbd, 0x61, 0xe8, 0x23, 0x98, 0xd1, 0xe9, 0xd5, 0x53, + 0xdc, 0xb1, 0x88, 0x6a, 0xf0, 0x9e, 0x1b, 0xbe, 0xaa, 0x53, 0x32, 0xe7, 0x40, 0x1b, 0x30, 0xc7, + 0x7e, 0x31, 0xd8, 0xcb, 0xdd, 0x81, 0x1b, 0xc3, 0x25, 0x84, 0x1c, 0xf2, 0xea, 0x94, 0x9c, 0xd5, + 0x03, 0x2a, 0x7a, 0x04, 0x59, 0xad, 0x89, 0x55, 0x9b, 0x8b, 0xba, 0x39, 0xf4, 0xe4, 0xe3, 0xc0, + 0x75, 0x55, 0xd5, 0x29, 0x19, 0x34, 0x9f, 0x48, 0x0a, 0x65, 0xd3, 0x5b, 0x8b, 0xb8, 0xa4, 0x77, + 0x87, 0x16, 0x6a, 0xf0, 0x0a, 0xa8, 0x2a, 0x75, 0xd4, 0x7d, 0x2a, 0x7a, 0x0f, 0x52, 0x8e, 0xa6, + 0x9a, 0xdc, 0x37, 0x59, 0x1e, 0x72, 0xad, 0x4c, 0xc0, 0x4c, 0x73, 0xa3, 0x8f, 0x19, 0x62, 0x76, + 0x4f, 0xbc, 0xf5, 0xfe, 0x28, 0x9d, 0xf6, 0x5c, 0x5f, 0x40, 0x74, 0x8a, 0x29, 0x81, 0xe8, 0x41, + 0xd5, 0x5b, 0x86, 0xa9, 0xd0, 0x33, 0xc5, 0x74, 0x81, 0x3f, 0x5a, 0x0f, 0x03, 0x67, 0xc0, 0xab, + 0xf4, 0x8e, 0x04, 0x8f, 0x88, 0xb6, 0x60, 0x9e, 0x09, 0xea, 0xb0, 0xe3, 0xc9, 0x85, 0xd5, 0xa1, + 0x3b, 0xf9, 0x11, 0x07, 0xa4, 0xab, 0x53, 0xf2, 0x9c, 0x1a, 0x22, 0x07, 0xe5, 0x6a, 0x61, 0xfb, + 0x80, 0xed, 0x24, 0x8c, 0x28, 0x57, 0x38, 0x3c, 0xd2, 0x2f, 0x17, 0x25, 0xa2, 0xdf, 0x80, 0x0b, + 0x4c, 0x90, 0xcb, 0xa3, 0xbe, 0x78, 0xf0, 0xd0, 0x5b, 0x43, 0x77, 0xe1, 0x87, 0x1e, 0x29, 0xae, + 0x4e, 0xc9, 0x48, 0x1d, 0x48, 0x44, 0x1a, 0x5c, 0x64, 0x6f, 0xe0, 0x67, 0x52, 0x6d, 0x7e, 0x8c, + 0xb2, 0x70, 0x9d, 0xbe, 0xe2, 0x9d, 0x61, 0xaf, 0x88, 0x3c, 0x2a, 0x5b, 0x9d, 0x92, 0x17, 0xd5, + 0xc1, 0xd4, 0xa0, 0x1a, 0x36, 0x3f, 0xfd, 0xc7, 0xbb, 0xdb, 0x3b, 0xa3, 0xab, 0x11, 0x75, 0x6a, + 0xd2, 0xaf, 0x46, 0x4f, 0x22, 0x69, 0x40, 0xff, 0xee, 0x03, 0xda, 0x99, 0xe6, 0x86, 0x36, 0x60, + 0xc4, 0x11, 0x41, 0xd2, 0x80, 0x87, 0x21, 0x32, 0x2a, 0x42, 0xe2, 0x40, 0x2b, 0xcc, 0x0f, 0xf5, + 0xa1, 0xfc, 0x63, 0x70, 0xd5, 0x29, 0x39, 0x71, 0xa0, 0xa1, 0x4f, 0x21, 0xcd, 0xce, 0x34, 0x9d, + 0x98, 0x85, 0xdc, 0x50, 0x9b, 0xdd, 0x7b, 0x32, 0xac, 0x3a, 0x25, 0xd3, 0x63, 0x54, 0xbc, 0x23, + 0xf3, 0xf3, 0x2a, 0x54, 0x44, 0x71, 0xc4, 0x51, 0xe6, 0xbe, 0x53, 0x43, 0xa4, 0xc3, 0xd8, 0x3e, + 0x11, 0xed, 0x40, 0x8e, 0xcf, 0xe1, 0x5e, 0xfc, 0xbd, 0x38, 0x34, 0xce, 0x25, 0x2a, 0x04, 0xbf, + 0x4a, 0xd7, 0x2a, 0x43, 0x74, 0xd2, 0x76, 0xbd, 0x12, 0x79, 0xdb, 0x2d, 0x0c, 0x6d, 0xbb, 0xa1, + 0xe1, 0xe0, 0xa4, 0xed, 0xec, 0x81, 0x44, 0xf4, 0x01, 0x4c, 0xb3, 0x71, 0x82, 0xa8, 0xc8, 0xa8, + 0xd0, 0xad, 0xbe, 0x21, 0xc2, 0xf2, 0x13, 0xeb, 0xe5, 0xf2, 0xb0, 0x56, 0xa5, 0x69, 0x1d, 0x14, + 0x16, 0x87, 0x5a, 0xaf, 0xc1, 0x00, 0x5d, 0x62, 0xbd, 0xdc, 0x80, 0x4a, 0x3a, 0x90, 0xcd, 0x52, + 0xf8, 0x10, 0xbb, 0x30, 0xb4, 0x03, 0x45, 0x44, 0xbb, 0x56, 0xe9, 0x81, 0xa3, 0x80, 0xec, 0x1b, + 0x56, 0x07, 0x2b, 0xd4, 0x28, 0x5e, 0x1c, 0x6d, 0x58, 0x7b, 0xee, 0xfa, 0xf2, 0x0d, 0x2b, 0xa3, + 0xa2, 0x67, 0x20, 0xf2, 0x0b, 0x67, 0x14, 0x2f, 0xfa, 0xaa, 0x70, 0x89, 0xca, 0xbb, 0x13, 0x39, + 0x21, 0x46, 0x05, 0xe6, 0x55, 0x09, 0xa8, 0xec, 0x4d, 0x41, 0x9f, 0xc1, 0x02, 0x95, 0xa7, 0x68, + 0xc1, 0x1d, 0x41, 0x85, 0xc2, 0xc0, 0x8d, 0x33, 0xc3, 0xaf, 0x13, 0xf2, 0x24, 0x8b, 0x5a, 0x5f, + 0x12, 0x19, 0x0f, 0x86, 0x69, 0xb8, 0x74, 0xee, 0x5e, 0x1a, 0x3a, 0x1e, 0x7a, 0xef, 0x47, 0x25, + 0xe3, 0xc1, 0x60, 0x14, 0xd2, 0x8d, 0xfb, 0x2c, 0xde, 0x9b, 0x43, 0xbb, 0xf1, 0x10, 0x63, 0x37, + 0xef, 0xf6, 0xd8, 0xb9, 0x75, 0x00, 0xb6, 0x94, 0x40, 0xd1, 0xd1, 0xf2, 0x50, 0x07, 0xa0, 0x3f, + 0x1a, 0x95, 0x38, 0x00, 0x4d, 0x8f, 0x46, 0x1c, 0x00, 0xb6, 0xef, 0x55, 0xb8, 0x3a, 0x7c, 0xb2, + 0x0a, 0xef, 0x8c, 0xd3, 0xc9, 0x8a, 0x12, 0x88, 0x43, 0x46, 0x70, 0x5d, 0x97, 0x8e, 0xf0, 0x6b, + 0x43, 0x97, 0x71, 0xfa, 0x8e, 0xa9, 0x55, 0xa7, 0xe4, 0xf4, 0x0b, 0x4e, 0x22, 0xbd, 0x8a, 0x89, + 0xe0, 0x63, 0xfb, 0xee, 0xd0, 0x5e, 0x35, 0x78, 0x3e, 0x89, 0xf4, 0xaa, 0x17, 0x01, 0x35, 0x98, + 0xf2, 0x1c, 0xb6, 0xa3, 0x55, 0x78, 0x7b, 0xf4, 0x94, 0xd7, 0xbb, 0xff, 0xe6, 0x4f, 0x79, 0x9c, + 0xcc, 0xa6, 0x3c, 0x5d, 0x71, 0x1c, 0x1a, 0xe4, 0x52, 0xb8, 0x31, 0x62, 0xca, 0xeb, 0x5b, 0xe3, + 0x66, 0x53, 0x9e, 0x5e, 0x67, 0x9c, 0xc4, 0xfb, 0xb3, 0xbd, 0x0b, 0x96, 0x38, 0xc2, 0xbf, 0x35, + 0xd4, 0xfb, 0x8b, 0xbc, 0x01, 0x8a, 0x78, 0x7f, 0x76, 0x4f, 0x02, 0xfa, 0x15, 0x98, 0xe5, 0x6b, + 0x8a, 0x85, 0xdb, 0x23, 0x5c, 0xea, 0xf0, 0x32, 0x30, 0xe9, 0x8e, 0x9c, 0x87, 0x19, 0x07, 0xb6, + 0x96, 0xc9, 0x8c, 0xdf, 0x9d, 0x11, 0xc6, 0x61, 0x60, 0x39, 0x95, 0x19, 0x87, 0x80, 0x4c, 0x4a, + 0xe3, 0xb0, 0x75, 0xb8, 0xc2, 0x2f, 0x0d, 0x2d, 0x4d, 0xef, 0x82, 0x24, 0x29, 0x0d, 0xe7, 0xa1, + 0x93, 0x05, 0x9d, 0xab, 0x99, 0x76, 0xbe, 0x35, 0x7c, 0xb2, 0xe8, 0x5f, 0xd9, 0xa9, 0x7a, 0x3b, + 0x86, 0x4c, 0x2b, 0x7f, 0x55, 0x80, 0xab, 0xac, 0x0f, 0xd0, 0xfd, 0x92, 0xae, 0xe2, 0x6f, 0x77, + 0x85, 0x96, 0xad, 0xee, 0x51, 0xf1, 0x1f, 0x9c, 0x7f, 0x77, 0xc6, 0x7b, 0xe3, 0x5b, 0xea, 0xa8, + 0x7c, 0x44, 0x19, 0x2d, 0x06, 0xf0, 0x0b, 0xf7, 0x87, 0x2a, 0xa3, 0x77, 0x51, 0x82, 0x28, 0x83, + 0xf3, 0xa0, 0x26, 0x14, 0xd8, 0x90, 0x08, 0x00, 0xb0, 0x5f, 0xf4, 0x07, 0x43, 0xe3, 0x46, 0x47, + 0x42, 0xff, 0xea, 0x94, 0x7c, 0xe9, 0x45, 0x64, 0x06, 0xf2, 0x36, 0x7a, 0x83, 0xa2, 0x11, 0xe0, + 0x55, 0x3e, 0x16, 0x9d, 0xc2, 0x7b, 0x43, 0xdf, 0x36, 0x12, 0x47, 0x93, 0xb7, 0x39, 0x91, 0x19, + 0x88, 0x6a, 0xf6, 0x18, 0x34, 0x2c, 0xbc, 0x3f, 0x54, 0x35, 0xbd, 0x98, 0x94, 0xa8, 0x86, 0xf3, + 0x94, 0x66, 0x79, 0xb0, 0x84, 0x7f, 0x30, 0x3a, 0x2f, 0x8a, 0x1b, 0xa9, 0xf4, 0x65, 0xb1, 0xb0, + 0x91, 0x4a, 0xbf, 0x21, 0x2e, 0x6d, 0xa4, 0xd2, 0x57, 0xc4, 0x37, 0x37, 0x52, 0xe9, 0x15, 0xf1, + 0xea, 0x46, 0x2a, 0x2d, 0x89, 0xd7, 0xa5, 0x9f, 0x5d, 0x81, 0x79, 0x0f, 0x59, 0x32, 0xc8, 0x77, + 0x3f, 0x0c, 0xf9, 0x96, 0x87, 0x41, 0x3e, 0x8e, 0x45, 0x39, 0xe6, 0xbb, 0x1f, 0xc6, 0x7c, 0xcb, + 0xc3, 0x30, 0x5f, 0xc0, 0x43, 0x40, 0x5f, 0x63, 0x18, 0xe8, 0xbb, 0x33, 0x01, 0xe8, 0xf3, 0x45, + 0xf5, 0xa3, 0xbe, 0xf5, 0x41, 0xd4, 0xf7, 0xf6, 0x68, 0xd4, 0xe7, 0x8b, 0x0a, 0xc1, 0xbe, 0x8f, + 0xfb, 0x60, 0xdf, 0xb5, 0x11, 0xb0, 0xcf, 0xe7, 0xf7, 0x70, 0xdf, 0x66, 0x24, 0xee, 0xbb, 0x39, + 0x0e, 0xf7, 0xf9, 0x72, 0x7a, 0x80, 0x5f, 0x35, 0x0a, 0xf8, 0xdd, 0x18, 0x03, 0xfc, 0x7c, 0x51, + 0x61, 0xe4, 0xb7, 0x19, 0x89, 0xfc, 0x6e, 0x8e, 0x43, 0x7e, 0x41, 0xb1, 0xc2, 0xd0, 0xef, 0xfd, + 0x1e, 0xe8, 0xb7, 0x32, 0x14, 0xfa, 0xf9, 0xdc, 0x0c, 0xfb, 0x7d, 0xd2, 0x8f, 0xfd, 0xae, 0x8d, + 0xc0, 0x7e, 0x81, 0x62, 0x39, 0xf8, 0xab, 0x46, 0x81, 0xbf, 0x1b, 0x63, 0xc0, 0x5f, 0xa0, 0x8b, + 0x10, 0xfa, 0xdb, 0x8e, 0x46, 0x7f, 0xb7, 0xc6, 0xa2, 0x3f, 0x5f, 0x5a, 0x2f, 0xfc, 0xab, 0x46, + 0xc1, 0xbf, 0x1b, 0x63, 0xe0, 0x5f, 0x5f, 0xc9, 0x18, 0xfe, 0x53, 0x47, 0xe2, 0xbf, 0x77, 0x26, + 0xc4, 0x7f, 0xbe, 0xe8, 0x28, 0x00, 0xa8, 0x8f, 0x06, 0x80, 0xc5, 0x49, 0x01, 0xa0, 0xff, 0x92, + 0x48, 0x04, 0xa8, 0x8e, 0x44, 0x80, 0xef, 0x4c, 0x88, 0x00, 0xfb, 0x2a, 0xd2, 0x0b, 0x01, 0xb7, + 0xa3, 0x21, 0xe0, 0xad, 0xb1, 0x10, 0x30, 0x68, 0xc5, 0x1e, 0x0c, 0xb8, 0x1a, 0xc2, 0x80, 0x6f, + 0x0d, 0xc1, 0x80, 0x3e, 0x2b, 0x01, 0x81, 0xdf, 0x1e, 0x00, 0x81, 0xd2, 0x28, 0x10, 0xe8, 0xf3, + 0xfa, 0x28, 0xb0, 0x1a, 0x85, 0x02, 0x6f, 0x8c, 0x41, 0x81, 0x41, 0xbf, 0x09, 0xc1, 0xc0, 0xa7, + 0x43, 0x60, 0xe0, 0xed, 0xf1, 0x30, 0xd0, 0x97, 0xd7, 0x87, 0x03, 0xd5, 0x91, 0x38, 0xf0, 0x9d, + 0x09, 0x71, 0x60, 0xd0, 0x82, 0x11, 0x40, 0xf0, 0xc3, 0x5e, 0x20, 0x78, 0x75, 0x38, 0x10, 0xf4, + 0xc5, 0x70, 0x24, 0xb8, 0x19, 0x89, 0x04, 0x6f, 0x8e, 0x43, 0x82, 0x81, 0x35, 0x0b, 0x43, 0xc1, + 0xed, 0x68, 0x28, 0x78, 0x6b, 0x2c, 0x14, 0x0c, 0x3a, 0x52, 0x0f, 0x16, 0xdc, 0x8c, 0xc4, 0x82, + 0x37, 0xc7, 0x61, 0xc1, 0x3e, 0x53, 0xcb, 0xc1, 0xe0, 0xf3, 0xa1, 0x60, 0xf0, 0xee, 0x24, 0x60, + 0xd0, 0x17, 0x3a, 0x80, 0x06, 0x3f, 0x1f, 0x8e, 0x06, 0x7f, 0xe9, 0x1c, 0x97, 0xcb, 0x46, 0xc2, + 0xc1, 0x6f, 0x0f, 0xc0, 0x41, 0x69, 0x14, 0x1c, 0x0c, 0x46, 0x86, 0x87, 0x07, 0x2b, 0x11, 0xe8, + 0xed, 0xed, 0xd1, 0xe8, 0x2d, 0x98, 0xc8, 0x03, 0xf8, 0xf6, 0x71, 0x1f, 0x7c, 0xbb, 0x36, 0x36, + 0x8e, 0x33, 0x84, 0xdf, 0x4a, 0x83, 0xf8, 0xed, 0xfa, 0x48, 0xfc, 0xe6, 0x4b, 0x08, 0x00, 0xdc, + 0x66, 0x24, 0x80, 0xbb, 0x39, 0x0e, 0xc0, 0x05, 0x5d, 0x21, 0x8c, 0xe0, 0xb6, 0xa3, 0x11, 0xdc, + 0xad, 0xb1, 0x08, 0xae, 0x6f, 0xda, 0xf2, 0x20, 0x5c, 0x35, 0x0a, 0xc2, 0xdd, 0x18, 0x03, 0xe1, + 0xc2, 0xd3, 0x96, 0x8f, 0xe1, 0x1a, 0xc3, 0x30, 0xdc, 0x9d, 0x09, 0x30, 0x5c, 0xe0, 0xcc, 0xf5, + 0x81, 0xb8, 0x4f, 0xfb, 0x41, 0x9c, 0x34, 0x0a, 0xc4, 0x05, 0x9d, 0xc8, 0x43, 0x71, 0xdb, 0xd1, + 0x28, 0xee, 0xd6, 0x58, 0x14, 0x17, 0x1e, 0xd7, 0x21, 0x18, 0xf7, 0x69, 0x3f, 0x8c, 0x93, 0x46, + 0xc1, 0xb8, 0xa0, 0x3c, 0x1e, 0x8e, 0xab, 0x46, 0xe1, 0xb8, 0x1b, 0x63, 0x70, 0x5c, 0xc8, 0xdc, + 0x07, 0x40, 0xee, 0xaf, 0x4d, 0x0e, 0xe4, 0x3e, 0x7c, 0xd5, 0x30, 0xbb, 0xf1, 0x48, 0xee, 0xd3, + 0x7e, 0x24, 0x27, 0x8d, 0x42, 0x72, 0x81, 0x3e, 0x3c, 0x28, 0xd7, 0x1a, 0x0b, 0xe5, 0xee, 0x9d, + 0x03, 0xca, 0xf9, 0xf2, 0x87, 0x61, 0xb9, 0xd6, 0x58, 0x2c, 0x77, 0xef, 0x1c, 0x58, 0x2e, 0x78, + 0xdd, 0x10, 0x30, 0xf7, 0x69, 0x3f, 0x98, 0x93, 0x46, 0x81, 0xb9, 0x40, 0x3b, 0xe7, 0x46, 0x73, + 0x6f, 0x8a, 0x6f, 0xf5, 0x60, 0xba, 0x3f, 0x9b, 0x81, 0x99, 0x6a, 0xc4, 0x9e, 0xa0, 0xf0, 0x2a, + 0x7b, 0x82, 0x68, 0x9d, 0x0c, 0x42, 0xea, 0xd4, 0x8d, 0xbf, 0x70, 0x73, 0xf0, 0x4a, 0x48, 0xce, + 0xfa, 0x0a, 0x77, 0x18, 0xa0, 0xf7, 0x61, 0xbe, 0xe3, 0x60, 0x5b, 0x69, 0xdb, 0x86, 0x65, 0x1b, + 0x2e, 0x3b, 0x8d, 0x25, 0x94, 0xc4, 0xaf, 0x4e, 0x57, 0xe6, 0x76, 0x1d, 0x6c, 0xef, 0x70, 0xba, + 0x3c, 0xd7, 0x09, 0x3d, 0x79, 0x5f, 0xbe, 0x9b, 0x9e, 0xfc, 0xcb, 0x77, 0x4f, 0x41, 0xa4, 0xb1, + 0x36, 0xe1, 0x79, 0x90, 0x5d, 0x53, 0x16, 0x3d, 0x65, 0xab, 0x7a, 0x68, 0xaa, 0xa3, 0xd7, 0x95, + 0xe5, 0xed, 0x5e, 0x22, 0xaa, 0x03, 0xbd, 0x40, 0x48, 0x69, 0x5b, 0x4d, 0x43, 0xeb, 0x52, 0xf7, + 0xa6, 0xf7, 0xca, 0xf6, 0x91, 0x1f, 0x4e, 0x78, 0xae, 0x1a, 0xee, 0x0e, 0xe5, 0x94, 0xe1, 0xa5, + 0xff, 0x1b, 0xdd, 0x83, 0x8b, 0x2d, 0xf5, 0x84, 0xde, 0x65, 0xad, 0x78, 0xfe, 0x0a, 0xbd, 0xbd, + 0x8f, 0x7d, 0x03, 0x0f, 0xb5, 0xd4, 0x13, 0xfa, 0x6d, 0x3e, 0x96, 0x44, 0x3f, 0xac, 0x73, 0x0d, + 0xe6, 0xf8, 0xa9, 0x18, 0xf6, 0xdd, 0xad, 0x3c, 0xcd, 0xc9, 0x3f, 0xc2, 0xc2, 0x3e, 0xbd, 0x75, + 0x03, 0x72, 0xba, 0xe1, 0xb8, 0x86, 0xa9, 0xb9, 0xfc, 0x9a, 0x6c, 0x76, 0xd1, 0xf4, 0xbc, 0x47, + 0x65, 0x77, 0x61, 0x37, 0x60, 0x41, 0x6b, 0x1a, 0xbe, 0x17, 0xc8, 0xe6, 0xe5, 0x85, 0xa1, 0xfd, + 0xba, 0x4c, 0xf3, 0xf6, 0x47, 0x9e, 0xe4, 0xb5, 0x5e, 0x32, 0x2a, 0x43, 0xfe, 0x40, 0x75, 0xf1, + 0x4b, 0xb5, 0xab, 0x78, 0x87, 0x3e, 0xb3, 0xf4, 0xa0, 0xfb, 0x95, 0xb3, 0xd3, 0x95, 0xf9, 0x47, + 0x2c, 0x69, 0xe0, 0xec, 0xe7, 0xfc, 0x41, 0x28, 0x41, 0x47, 0xb7, 0x20, 0xaf, 0x3a, 0x5d, 0x53, + 0xa3, 0x0d, 0x88, 0x4d, 0xa7, 0xe3, 0x50, 0x27, 0x3e, 0x2d, 0xe7, 0x28, 0xb9, 0xec, 0x51, 0xd1, + 0xc7, 0xb0, 0xc4, 0xbf, 0x86, 0xf1, 0x52, 0xb5, 0x75, 0x85, 0x36, 0x7a, 0x30, 0x3c, 0x44, 0xca, + 0x73, 0x99, 0x7d, 0xfd, 0x82, 0x64, 0x20, 0x2d, 0x1d, 0xbe, 0x65, 0x9a, 0xdd, 0xa2, 0x0d, 0x62, + 0x76, 0x23, 0x95, 0x9e, 0x13, 0xe7, 0x37, 0x52, 0xe9, 0x9c, 0x98, 0x97, 0xfe, 0x8d, 0x00, 0x79, + 0x62, 0x4f, 0x1d, 0xc7, 0xb0, 0xcc, 0xaa, 0x1f, 0x7f, 0xed, 0xf7, 0x5a, 0x81, 0x9e, 0xbf, 0xf3, + 0x9f, 0xd1, 0x0a, 0x3d, 0xe7, 0x48, 0xfc, 0x56, 0xff, 0x1b, 0x38, 0x49, 0x19, 0x18, 0x89, 0x9e, + 0x38, 0x5b, 0x83, 0x19, 0xc7, 0xea, 0xd8, 0x9a, 0xf7, 0x65, 0x86, 0x3b, 0x43, 0x0c, 0x78, 0xe8, + 0x85, 0xc5, 0x3a, 0x65, 0x90, 0x39, 0xa3, 0x54, 0x84, 0x19, 0x46, 0x41, 0x19, 0x98, 0x7e, 0xd2, + 0xa8, 0x56, 0x64, 0x71, 0x0a, 0xcd, 0x41, 0xfa, 0xa1, 0xfc, 0x64, 0x4b, 0xa9, 0x3f, 0x7d, 0x2c, + 0x0a, 0x28, 0x0b, 0xb3, 0xf2, 0x93, 0x27, 0x0d, 0x65, 0xf3, 0x99, 0x98, 0x90, 0xfe, 0x54, 0x80, + 0xb9, 0x12, 0xfb, 0x34, 0x05, 0x0b, 0x74, 0xf8, 0xb8, 0x2f, 0x20, 0xe1, 0x8d, 0x68, 0x4c, 0x35, + 0x2c, 0x10, 0x21, 0xcd, 0xbb, 0xa7, 0x77, 0x7c, 0x66, 0x65, 0xb8, 0x27, 0x4d, 0x17, 0x9d, 0xbc, + 0x10, 0x48, 0x8f, 0x0d, 0xd5, 0x41, 0x54, 0xbd, 0x2a, 0x2a, 0xbc, 0x24, 0xc3, 0x03, 0x21, 0xfb, + 0xb4, 0xe1, 0x75, 0x36, 0xb5, 0x97, 0xfc, 0x51, 0xea, 0xcb, 0x1f, 0xae, 0x4c, 0x49, 0x7f, 0x9e, + 0x82, 0xf9, 0x52, 0xf8, 0x33, 0x1c, 0xa8, 0xd6, 0x57, 0xd9, 0x5b, 0x91, 0x76, 0x3a, 0xc4, 0x51, + 0x1c, 0xf1, 0x81, 0xa3, 0x4c, 0xf0, 0xcd, 0x0f, 0x56, 0xf7, 0xab, 0x23, 0x62, 0x39, 0xc2, 0x95, + 0x0f, 0x18, 0x97, 0xfe, 0x7d, 0xd2, 0x37, 0xe0, 0x45, 0x98, 0x66, 0x47, 0x34, 0x85, 0x81, 0xdb, + 0x23, 0xa8, 0x09, 0x21, 0xfe, 0x2b, 0x49, 0x97, 0x59, 0x36, 0x62, 0xf0, 0x1b, 0xaf, 0x14, 0x04, + 0x12, 0x4c, 0x93, 0xe7, 0xff, 0x74, 0x68, 0x87, 0xdd, 0x95, 0xfa, 0x7f, 0x31, 0xf6, 0x92, 0xbc, + 0x0f, 0xfd, 0x3a, 0xe4, 0x35, 0xab, 0xd9, 0x64, 0x6e, 0x0f, 0x33, 0x5d, 0x83, 0xb7, 0x27, 0xd1, + 0x22, 0xf0, 0xaf, 0xc5, 0x16, 0xfd, 0xaf, 0xc6, 0x16, 0x65, 0xfe, 0xd5, 0xd8, 0xd0, 0xc1, 0x98, + 0x9c, 0x2f, 0x8c, 0x59, 0xbc, 0xbe, 0x33, 0x3a, 0xb3, 0xaf, 0x72, 0x46, 0x87, 0x9d, 0x6c, 0xe2, + 0x3d, 0xef, 0x67, 0x02, 0x8f, 0x90, 0x7c, 0x6c, 0x59, 0x47, 0x1d, 0x3f, 0xee, 0x6c, 0x29, 0x7c, + 0xf3, 0x69, 0x70, 0x7c, 0x80, 0x1e, 0x7f, 0x8b, 0x9a, 0x9a, 0x12, 0xaf, 0x37, 0x35, 0x5d, 0x83, + 0xb9, 0xb6, 0x8d, 0xf7, 0xb1, 0xab, 0x1d, 0x2a, 0x66, 0xa7, 0xc5, 0xcf, 0xfe, 0x65, 0x3d, 0xda, + 0x76, 0xa7, 0x85, 0xee, 0x80, 0xe8, 0x67, 0xe1, 0x50, 0xd4, 0xbb, 0x76, 0xcf, 0xa3, 0x73, 0xe0, + 0x2a, 0xfd, 0x0f, 0x01, 0x16, 0x7b, 0xea, 0xc4, 0xc7, 0xd4, 0x06, 0x64, 0x75, 0xdf, 0x19, 0x70, + 0x0a, 0xc2, 0x39, 0x0f, 0x96, 0x84, 0x99, 0x91, 0x02, 0x97, 0xbc, 0xd7, 0xd2, 0xef, 0x64, 0x04, + 0x62, 0x13, 0xe7, 0x14, 0x7b, 0x31, 0x90, 0xb3, 0x1e, 0x7a, 0x81, 0x3f, 0xc8, 0x92, 0x13, 0x0d, + 0x32, 0xe9, 0x7f, 0x0a, 0x20, 0xd2, 0x17, 0x3c, 0xc4, 0x58, 0x8f, 0xc5, 0x64, 0x7a, 0x27, 0xb8, + 0x12, 0x93, 0x9f, 0xee, 0xeb, 0xf9, 0xb6, 0x4f, 0xb2, 0xef, 0xdb, 0x3e, 0x51, 0xf6, 0x33, 0xf5, + 0x9a, 0xf6, 0x53, 0xfa, 0xa1, 0x00, 0x39, 0xbf, 0xda, 0xec, 0xa3, 0x9e, 0x23, 0x6e, 0xed, 0x7d, + 0xb5, 0x0f, 0x57, 0x7a, 0xb7, 0x0b, 0x4d, 0xf4, 0x9d, 0xd1, 0xf0, 0xed, 0x42, 0xec, 0x83, 0x8b, + 0x7f, 0xdb, 0xeb, 0x8e, 0xa4, 0x88, 0xe5, 0xe0, 0x5a, 0x97, 0x57, 0x38, 0x3d, 0xf9, 0x75, 0x84, + 0x58, 0x3e, 0x0c, 0x29, 0x90, 0xf6, 0x28, 0xa2, 0xa5, 0x89, 0xec, 0xbb, 0xa7, 0x25, 0xd6, 0x01, + 0x7f, 0x1c, 0x6e, 0x09, 0x76, 0x2d, 0xc0, 0x03, 0x48, 0x1e, 0xab, 0xcd, 0x51, 0xf1, 0x83, 0x3d, + 0x2d, 0x27, 0x93, 0xdc, 0xe8, 0x61, 0xcf, 0x6d, 0x38, 0x89, 0xe1, 0xcb, 0x54, 0x83, 0x2a, 0xed, + 0xb9, 0x35, 0xe7, 0x83, 0xde, 0x01, 0x34, 0xf2, 0xf5, 0xe1, 0x91, 0xf4, 0x51, 0xea, 0x47, 0x3f, + 0x5c, 0x11, 0xa4, 0x4f, 0x00, 0xc9, 0xd8, 0xc1, 0xee, 0xd3, 0x8e, 0x65, 0x07, 0x37, 0x0b, 0xf5, + 0x9f, 0xd4, 0x9a, 0x8e, 0x3e, 0xa9, 0x25, 0x5d, 0x84, 0xc5, 0x1e, 0x6e, 0x66, 0x81, 0xa4, 0x0f, + 0xe0, 0x8d, 0x47, 0x96, 0xe3, 0x18, 0x6d, 0x02, 0xc8, 0xe9, 0x50, 0x27, 0xf3, 0x95, 0x6f, 0x73, + 0xd3, 0x6d, 0xba, 0x06, 0x62, 0x32, 0xdb, 0x94, 0x91, 0xfd, 0x67, 0xe9, 0x5f, 0x0b, 0x70, 0x79, + 0x90, 0x93, 0x69, 0x39, 0xea, 0xb0, 0xf7, 0xac, 0x66, 0x05, 0x17, 0x5f, 0x8e, 0xef, 0xad, 0x5e, + 0x76, 0xe2, 0xb6, 0xf2, 0x77, 0x2a, 0x2d, 0x95, 0xda, 0x24, 0x7e, 0x0f, 0x43, 0x8e, 0x93, 0xb7, + 0x18, 0x35, 0x30, 0x4f, 0xa9, 0xc9, 0xcc, 0xd3, 0x1f, 0x24, 0x01, 0xd1, 0xdb, 0x46, 0x4a, 0xf4, + 0xba, 0x0e, 0xaf, 0xce, 0x77, 0x20, 0xe3, 0x62, 0x53, 0x35, 0x5d, 0xef, 0x6a, 0x95, 0x54, 0x69, + 0xee, 0xec, 0x74, 0x25, 0xdd, 0xa0, 0xc4, 0xda, 0xba, 0x9c, 0x66, 0xc9, 0x35, 0x1d, 0xfd, 0x25, + 0x58, 0x26, 0x33, 0x4e, 0xa7, 0x45, 0xab, 0xae, 0x38, 0x86, 0xa9, 0x61, 0x16, 0x1d, 0xcf, 0x3d, + 0x34, 0xde, 0xcf, 0xa2, 0xf0, 0xf2, 0xe0, 0x9b, 0x8b, 0xe5, 0x40, 0x16, 0x57, 0xc2, 0x95, 0x90, + 0xf8, 0x3a, 0x91, 0xfe, 0x58, 0x75, 0xbc, 0xec, 0x4b, 0xbf, 0x10, 0x20, 0x1b, 0x62, 0x41, 0x79, + 0x48, 0xda, 0x4a, 0x87, 0xbe, 0x52, 0x90, 0x13, 0xf6, 0x2e, 0xba, 0x0e, 0xf3, 0x74, 0x56, 0x0c, + 0x79, 0x99, 0xc2, 0xed, 0x94, 0x4c, 0x4f, 0x4c, 0xc8, 0x9e, 0x0b, 0xf9, 0x16, 0x00, 0xcd, 0xc4, + 0x80, 0x4f, 0x92, 0xe6, 0xc8, 0x10, 0x8a, 0x0f, 0x7b, 0xe8, 0x09, 0xb4, 0x40, 0x08, 0x3b, 0x64, + 0x32, 0x4f, 0xa9, 0xbe, 0x94, 0x15, 0xc8, 0xb2, 0x6c, 0x4c, 0xcc, 0x34, 0xcd, 0x03, 0x94, 0xc4, + 0xe4, 0x94, 0x61, 0xd1, 0x79, 0xd1, 0x54, 0xda, 0x96, 0xae, 0x68, 0xed, 0x0e, 0x0f, 0xde, 0x67, + 0x1f, 0x38, 0x16, 0xe8, 0xd5, 0x35, 0x62, 0xfd, 0xe9, 0xe3, 0x1d, 0x4b, 0x2f, 0xef, 0xec, 0xb2, + 0xc8, 0x7d, 0x47, 0x16, 0x9d, 0x17, 0x4d, 0x42, 0x69, 0x77, 0x38, 0x45, 0xaa, 0xc3, 0x62, 0x8f, + 0xda, 0xf8, 0x24, 0xfa, 0x49, 0xaf, 0x71, 0x08, 0x7b, 0x92, 0xec, 0x3b, 0xfc, 0x74, 0xb7, 0x4c, + 0xb3, 0x74, 0x3e, 0xaa, 0x7a, 0x8d, 0x44, 0x03, 0xf2, 0x1b, 0x96, 0x61, 0x12, 0x90, 0xe4, 0x75, + 0x81, 0x35, 0xc8, 0xed, 0x19, 0xa6, 0x6a, 0x77, 0x15, 0x2f, 0x3c, 0x5f, 0x18, 0x17, 0x9e, 0x2f, + 0xcf, 0x33, 0x0e, 0xfe, 0x28, 0xfd, 0x54, 0x00, 0x31, 0x10, 0xcb, 0x0b, 0xfa, 0x2d, 0x00, 0xad, + 0xd9, 0x71, 0x5c, 0x6c, 0x7b, 0x83, 0x75, 0x8e, 0x1d, 0x03, 0x2c, 0x33, 0x6a, 0x6d, 0x5d, 0xce, + 0xf0, 0x0c, 0x35, 0x1d, 0x5d, 0xef, 0xbd, 0xe1, 0x67, 0xba, 0x04, 0x67, 0x03, 0xf7, 0xfa, 0x90, + 0xd1, 0xef, 0xb8, 0x96, 0xed, 0x2f, 0x18, 0xf0, 0xd1, 0xef, 0xdd, 0x7d, 0x46, 0xef, 0xf8, 0xc0, + 0xf4, 0xa4, 0x6f, 0x8e, 0xb8, 0xa2, 0xc7, 0xd8, 0xaf, 0x52, 0x6a, 0x7c, 0x95, 0x18, 0x87, 0x57, + 0xa5, 0x3f, 0x14, 0x20, 0x5f, 0x66, 0x83, 0xd2, 0x1f, 0xe8, 0x23, 0x26, 0xb6, 0x75, 0x48, 0xbb, + 0x27, 0xa6, 0xd2, 0xc2, 0xfe, 0xe7, 0xba, 0xce, 0x71, 0x39, 0xe9, 0xac, 0xcb, 0x1e, 0xe9, 0x17, + 0x60, 0x3b, 0x76, 0xf0, 0x95, 0x52, 0xe2, 0x30, 0x1c, 0xd0, 0xeb, 0xa1, 0x8a, 0x6d, 0xdb, 0x72, + 0xad, 0xbd, 0xce, 0x7e, 0x71, 0x9d, 0x67, 0x60, 0x0e, 0xc3, 0x97, 0xff, 0x69, 0x45, 0x90, 0x7d, + 0x26, 0xe6, 0x53, 0xde, 0xad, 0x13, 0xe3, 0x37, 0xe0, 0xf5, 0xa1, 0x1c, 0x40, 0xe8, 0x3b, 0x6c, + 0xfc, 0x8b, 0xf7, 0x6b, 0xeb, 0xca, 0xee, 0x76, 0xf9, 0xc9, 0xd6, 0x56, 0xad, 0xd1, 0xa8, 0xac, + 0x8b, 0x02, 0x12, 0x61, 0xae, 0xe7, 0x2b, 0x6e, 0x09, 0xf6, 0x0d, 0xfc, 0xbb, 0xff, 0x1f, 0x40, + 0xf0, 0x41, 0x48, 0x22, 0x6b, 0xb3, 0xf2, 0x99, 0xf2, 0x6c, 0xed, 0xf1, 0x6e, 0xa5, 0x2e, 0x4e, + 0x21, 0x04, 0xb9, 0xd2, 0x5a, 0xa3, 0x5c, 0x55, 0xe4, 0x4a, 0x7d, 0xe7, 0xc9, 0x76, 0xbd, 0xe2, + 0x7d, 0x3b, 0xff, 0xee, 0x3a, 0xcc, 0x85, 0xaf, 0x5c, 0x43, 0x8b, 0x90, 0x2f, 0x57, 0x2b, 0xe5, + 0x4d, 0xe5, 0x59, 0x6d, 0x4d, 0x79, 0xba, 0x5b, 0xd9, 0xad, 0x88, 0x53, 0xb4, 0x68, 0x94, 0xf8, + 0x70, 0xf7, 0x31, 0x01, 0xa2, 0x79, 0xc8, 0xb2, 0x67, 0xfa, 0xc5, 0x37, 0x31, 0x71, 0x77, 0x0b, + 0xb2, 0xa1, 0xab, 0xe0, 0xc9, 0xeb, 0x76, 0x76, 0xeb, 0x55, 0xa5, 0x51, 0xdb, 0xaa, 0xd4, 0x1b, + 0x6b, 0x5b, 0x3b, 0x4c, 0x06, 0xa5, 0xad, 0x95, 0x9e, 0xc8, 0x0d, 0x51, 0xf0, 0x9f, 0x1b, 0x4f, + 0x76, 0xcb, 0x55, 0xaf, 0x1a, 0x52, 0x2a, 0x9d, 0x14, 0x93, 0x77, 0x4f, 0xe0, 0xf2, 0x90, 0xdb, + 0xc7, 0x08, 0x06, 0xde, 0x35, 0xe9, 0xb5, 0xd8, 0xe2, 0x14, 0x9a, 0x87, 0x0c, 0xe9, 0x7a, 0xf4, + 0x6e, 0x02, 0x51, 0x40, 0x69, 0x48, 0x1d, 0xba, 0x6e, 0x5b, 0x4c, 0xa0, 0x19, 0x48, 0x38, 0x0f, + 0xc4, 0x24, 0xf9, 0x7f, 0xe0, 0x88, 0x29, 0x02, 0xa9, 0xd5, 0x2f, 0x3a, 0x36, 0x16, 0xa7, 0x09, + 0xa4, 0xee, 0x38, 0xd8, 0xde, 0x37, 0x9a, 0x58, 0x9c, 0x25, 0x2c, 0x66, 0xa7, 0xd9, 0x14, 0xd3, + 0x52, 0x2a, 0x3d, 0x23, 0xce, 0xdc, 0xbd, 0x06, 0xa1, 0x4b, 0x60, 0x10, 0xc0, 0xcc, 0x63, 0xd5, + 0xc5, 0x8e, 0x2b, 0x4e, 0xa1, 0x59, 0x48, 0xae, 0x35, 0x9b, 0xa2, 0x70, 0xff, 0xcb, 0x69, 0x48, + 0x7b, 0x1f, 0x34, 0x43, 0x8f, 0x61, 0x9a, 0xc2, 0x4c, 0xb4, 0x32, 0x1c, 0x80, 0x32, 0x0b, 0x79, + 0x75, 0x1c, 0x42, 0x95, 0xa6, 0xd0, 0xff, 0x0f, 0xd9, 0x90, 0x63, 0x8e, 0x86, 0x2e, 0x33, 0xf7, + 0x80, 0x91, 0xa5, 0x9b, 0xe3, 0xb2, 0xf9, 0xf2, 0x9f, 0x43, 0xc6, 0x9f, 0xd3, 0xd1, 0xf5, 0x51, + 0x33, 0xbe, 0x27, 0x7b, 0xb4, 0x5b, 0x40, 0x86, 0x9d, 0x34, 0xf5, 0xae, 0x80, 0x6c, 0x40, 0x83, + 0xd3, 0x2f, 0x8a, 0x8a, 0x3b, 0x1d, 0x3a, 0xbf, 0x2f, 0xdd, 0x9d, 0x28, 0x77, 0xf0, 0x4e, 0xa2, + 0xac, 0xc0, 0x87, 0x88, 0x56, 0xd6, 0x80, 0x87, 0x12, 0xad, 0xac, 0x08, 0x57, 0x84, 0x36, 0x46, + 0xc8, 0xc0, 0x47, 0xca, 0x1f, 0x9c, 0x37, 0x23, 0xe5, 0x47, 0xcc, 0x13, 0xd2, 0x14, 0x7a, 0x0a, + 0x29, 0x62, 0x94, 0x51, 0x94, 0x77, 0xdf, 0x37, 0x09, 0x2c, 0x5d, 0x1f, 0x99, 0xc7, 0x13, 0x59, + 0xba, 0xf3, 0xa3, 0xff, 0xbc, 0x3c, 0xf5, 0xa3, 0xb3, 0x65, 0xe1, 0xa7, 0x67, 0xcb, 0xc2, 0x1f, + 0x9f, 0x2d, 0x0b, 0x7f, 0x72, 0xb6, 0x2c, 0x7c, 0xff, 0xe7, 0xcb, 0x53, 0x3f, 0xfd, 0xf9, 0xf2, + 0xd4, 0x1f, 0xff, 0x7c, 0x79, 0xea, 0xf3, 0x59, 0xce, 0xbd, 0x37, 0x43, 0x2d, 0xd6, 0x83, 0xff, + 0x13, 0x00, 0x00, 0xff, 0xff, 0xd3, 0x65, 0x51, 0x92, 0xcf, 0x86, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -13525,6 +13736,162 @@ func (m *QueryResolvedTimestampResponse) MarshalToSizedBuffer(dAtA []byte) (int, return len(dAtA) - i, nil } +func (m *ScanInterleavedIntentsRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ScanInterleavedIntentsRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ScanInterleavedIntentsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.RequestHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *ScanInterleavedIntentsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ScanInterleavedIntentsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ScanInterleavedIntentsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.IntentRows) > 0 { + for iNdEx := len(m.IntentRows) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.IntentRows[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } + { + size, err := m.ResponseHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *BarrierRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BarrierRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BarrierRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.RequestHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + +func (m *BarrierResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BarrierResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BarrierResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + { + size, err := m.ResponseHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func (m *RequestUnion) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -14543,6 +14910,52 @@ func (m *RequestUnion_QueryResolvedTimestamp) MarshalToSizedBuffer(dAtA []byte) } return len(dAtA) - i, nil } +func (m *RequestUnion_ScanInterleavedIntents) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RequestUnion_ScanInterleavedIntents) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ScanInterleavedIntents != nil { + { + size, err := m.ScanInterleavedIntents.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *RequestUnion_Barrier) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RequestUnion_Barrier) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Barrier != nil { + { + size, err := m.Barrier.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} func (m *ResponseUnion) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -15538,6 +15951,52 @@ func (m *ResponseUnion_QueryResolvedTimestamp) MarshalToSizedBuffer(dAtA []byte) } return len(dAtA) - i, nil } +func (m *ResponseUnion_ScanInterleavedIntents) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResponseUnion_ScanInterleavedIntents) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.ScanInterleavedIntents != nil { + { + size, err := m.ScanInterleavedIntents.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xa2 + } + return len(dAtA) - i, nil +} +func (m *ResponseUnion_Barrier) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResponseUnion_Barrier) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + if m.Barrier != nil { + { + size, err := m.Barrier.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x3 + i-- + dAtA[i] = 0xaa + } + return len(dAtA) - i, nil +} func (m *Header) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -16648,12 +17107,12 @@ func (m *ContentionEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - n274, err274 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) - if err274 != nil { - return 0, err274 + n283, err283 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) + if err283 != nil { + return 0, err283 } - i -= n274 - i = encodeVarintApi(dAtA, i, uint64(n274)) + i -= n283 + i = encodeVarintApi(dAtA, i, uint64(n283)) i-- dAtA[i] = 0x1a { @@ -18535,6 +18994,58 @@ func (m *QueryResolvedTimestampResponse) Size() (n int) { return n } +func (m *ScanInterleavedIntentsRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.RequestHeader.Size() + n += 1 + l + sovApi(uint64(l)) + return n +} + +func (m *ScanInterleavedIntentsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ResponseHeader.Size() + n += 1 + l + sovApi(uint64(l)) + if len(m.IntentRows) > 0 { + for _, e := range m.IntentRows { + l = e.Size() + n += 1 + l + sovApi(uint64(l)) + } + } + return n +} + +func (m *BarrierRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.RequestHeader.Size() + n += 1 + l + sovApi(uint64(l)) + return n +} + +func (m *BarrierResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.ResponseHeader.Size() + n += 1 + l + sovApi(uint64(l)) + l = m.Timestamp.Size() + n += 1 + l + sovApi(uint64(l)) + return n +} + func (m *RequestUnion) Size() (n int) { if m == nil { return 0 @@ -19075,6 +19586,30 @@ func (m *RequestUnion_QueryResolvedTimestamp) Size() (n int) { } return n } +func (m *RequestUnion_ScanInterleavedIntents) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ScanInterleavedIntents != nil { + l = m.ScanInterleavedIntents.Size() + n += 2 + l + sovApi(uint64(l)) + } + return n +} +func (m *RequestUnion_Barrier) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Barrier != nil { + l = m.Barrier.Size() + n += 2 + l + sovApi(uint64(l)) + } + return n +} func (m *ResponseUnion) Size() (n int) { if m == nil { return 0 @@ -19603,6 +20138,30 @@ func (m *ResponseUnion_QueryResolvedTimestamp) Size() (n int) { } return n } +func (m *ResponseUnion_ScanInterleavedIntents) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ScanInterleavedIntents != nil { + l = m.ScanInterleavedIntents.Size() + n += 2 + l + sovApi(uint64(l)) + } + return n +} +func (m *ResponseUnion_Barrier) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Barrier != nil { + l = m.Barrier.Size() + n += 2 + l + sovApi(uint64(l)) + } + return n +} func (m *Header) Size() (n int) { if m == nil { return 0 @@ -32696,10 +33255,485 @@ func (m *AddSSTableRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AddSSTableRequest: wiretype end group for non-group") + return fmt.Errorf("proto: AddSSTableRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AddSSTableRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.RequestHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) + if m.Data == nil { + m.Data = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field DisallowShadowing", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.DisallowShadowing = bool(v != 0) + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MVCCStats", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.MVCCStats == nil { + m.MVCCStats = &enginepb.MVCCStats{} + } + if err := m.MVCCStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IngestAsWrites", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IngestAsWrites = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *AddSSTableResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: AddSSTableResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: AddSSTableResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResponseHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RefreshRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RefreshRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RefreshRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RequestHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.RequestHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RefreshFrom", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.RefreshFrom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RefreshResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RefreshResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RefreshResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResponseHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RefreshRangeRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RefreshRangeRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AddSSTableRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RefreshRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -32735,63 +33769,9 @@ func (m *AddSSTableRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) - } - var byteLen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - byteLen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if byteLen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) - if m.Data == nil { - m.Data = []byte{} - } - iNdEx = postIndex case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field DisallowShadowing", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.DisallowShadowing = bool(v != 0) - case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MVCCStats", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RefreshFrom", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -32818,33 +33798,10 @@ func (m *AddSSTableRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.MVCCStats == nil { - m.MVCCStats = &enginepb.MVCCStats{} - } - if err := m.MVCCStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RefreshFrom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field IngestAsWrites", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.IngestAsWrites = bool(v != 0) default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -32866,7 +33823,7 @@ func (m *AddSSTableRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *AddSSTableResponse) Unmarshal(dAtA []byte) error { +func (m *RefreshRangeResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -32889,10 +33846,10 @@ func (m *AddSSTableResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: AddSSTableResponse: wiretype end group for non-group") + return fmt.Errorf("proto: RefreshRangeResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: AddSSTableResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RefreshRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -32949,7 +33906,7 @@ func (m *AddSSTableResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *RefreshRequest) Unmarshal(dAtA []byte) error { +func (m *SubsumeRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -32972,10 +33929,10 @@ func (m *RefreshRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RefreshRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SubsumeRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RefreshRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SubsumeRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -33011,9 +33968,42 @@ func (m *RefreshRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LeftDesc", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.LeftDesc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RefreshFrom", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RightDesc", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33040,7 +34030,7 @@ func (m *RefreshRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.RefreshFrom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RightDesc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -33065,7 +34055,7 @@ func (m *RefreshRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *RefreshResponse) Unmarshal(dAtA []byte) error { +func (m *SubsumeResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -33088,10 +34078,10 @@ func (m *RefreshResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RefreshResponse: wiretype end group for non-group") + return fmt.Errorf("proto: SubsumeResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RefreshResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SubsumeResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -33127,59 +34117,94 @@ func (m *RefreshResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipApi(dAtA[iNdEx:]) - if err != nil { - return err + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MVCCStats", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { return ErrInvalidLengthApi } - if (iNdEx + skippy) > l { + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { return io.ErrUnexpectedEOF } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *RefreshRangeRequest) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi + if err := m.MVCCStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - if iNdEx >= l { + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LeaseAppliedIndex", wireType) + } + m.LeaseAppliedIndex = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LeaseAppliedIndex |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FreezeStart", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { return io.ErrUnexpectedEOF } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + if err := m.FreezeStart.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: RefreshRangeRequest: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RefreshRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + iNdEx = postIndex + case 6: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RequestHeader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClosedTimestamp", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33206,13 +34231,13 @@ func (m *RefreshRangeRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.RequestHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ClosedTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + case 7: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RefreshFrom", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ReadSummary", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33239,7 +34264,10 @@ func (m *RefreshRangeRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.RefreshFrom.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.ReadSummary == nil { + m.ReadSummary = &rspb.ReadSummary{} + } + if err := m.ReadSummary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -33264,7 +34292,7 @@ func (m *RefreshRangeRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *RefreshRangeResponse) Unmarshal(dAtA []byte) error { +func (m *RangeStatsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -33287,15 +34315,15 @@ func (m *RefreshRangeResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RefreshRangeResponse: wiretype end group for non-group") + return fmt.Errorf("proto: RangeStatsRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RefreshRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RangeStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ResponseHeader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RequestHeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33322,7 +34350,7 @@ func (m *RefreshRangeResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ResponseHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RequestHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -33347,7 +34375,7 @@ func (m *RefreshRangeResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *SubsumeRequest) Unmarshal(dAtA []byte) error { +func (m *RangeStatsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -33370,15 +34398,15 @@ func (m *SubsumeRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SubsumeRequest: wiretype end group for non-group") + return fmt.Errorf("proto: RangeStatsResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SubsumeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RangeStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RequestHeader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ResponseHeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33405,13 +34433,13 @@ func (m *SubsumeRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.RequestHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ResponseHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field LeftDesc", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field MVCCStats", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33438,13 +34466,24 @@ func (m *SubsumeRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.LeftDesc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.MVCCStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedLastQueriesPerSecond", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.DeprecatedLastQueriesPerSecond = float64(math.Float64frombits(v)) + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RightDesc", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RangeInfo", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33471,10 +34510,41 @@ func (m *SubsumeRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.RightDesc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RangeInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex + case 5: + if wireType != 1 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxQueriesPerSecond", wireType) + } + var v uint64 + if (iNdEx + 8) > l { + return io.ErrUnexpectedEOF + } + v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) + iNdEx += 8 + m.MaxQueriesPerSecond = float64(math.Float64frombits(v)) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MaxQueriesPerSecondSet", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.MaxQueriesPerSecondSet = bool(v != 0) default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -33496,7 +34566,7 @@ func (m *SubsumeRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *SubsumeResponse) Unmarshal(dAtA []byte) error { +func (m *MigrateRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -33519,15 +34589,15 @@ func (m *SubsumeResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SubsumeResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MigrateRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SubsumeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MigrateRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ResponseHeader", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RequestHeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33554,13 +34624,13 @@ func (m *SubsumeResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ResponseHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RequestHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MVCCStats", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33587,98 +34657,63 @@ func (m *SubsumeResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.MVCCStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field LeaseAppliedIndex", wireType) - } - m.LeaseAppliedIndex = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.LeaseAppliedIndex |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 5: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field FreezeStart", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthApi + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err } - postIndex := iNdEx + msglen - if postIndex < 0 { + if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } - if postIndex > l { + if (iNdEx + skippy) > l { return io.ErrUnexpectedEOF } - if err := m.FreezeStart.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 6: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClosedTimestamp", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthApi + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MigrateResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi } - if postIndex > l { + if iNdEx >= l { return io.ErrUnexpectedEOF } - if err := m.ClosedTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break } - iNdEx = postIndex - case 7: + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MigrateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MigrateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ReadSummary", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ResponseHeader", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33705,10 +34740,7 @@ func (m *SubsumeResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.ReadSummary == nil { - m.ReadSummary = &rspb.ReadSummary{} - } - if err := m.ReadSummary.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ResponseHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -33733,7 +34765,7 @@ func (m *SubsumeResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *RangeStatsRequest) Unmarshal(dAtA []byte) error { +func (m *QueryResolvedTimestampRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -33756,10 +34788,10 @@ func (m *RangeStatsRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RangeStatsRequest: wiretype end group for non-group") + return fmt.Errorf("proto: QueryResolvedTimestampRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RangeStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: QueryResolvedTimestampRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -33816,7 +34848,7 @@ func (m *RangeStatsRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *RangeStatsResponse) Unmarshal(dAtA []byte) error { +func (m *QueryResolvedTimestampResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -33839,10 +34871,10 @@ func (m *RangeStatsResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RangeStatsResponse: wiretype end group for non-group") + return fmt.Errorf("proto: QueryResolvedTimestampResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RangeStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: QueryResolvedTimestampResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -33874,57 +34906,13 @@ func (m *RangeStatsResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ResponseHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field MVCCStats", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.MVCCStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ResponseHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedLastQueriesPerSecond", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF - } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.DeprecatedLastQueriesPerSecond = float64(math.Float64frombits(v)) - case 4: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RangeInfo", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTS", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -33951,41 +34939,10 @@ func (m *RangeStatsResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.RangeInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.ResolvedTS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 5: - if wireType != 1 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxQueriesPerSecond", wireType) - } - var v uint64 - if (iNdEx + 8) > l { - return io.ErrUnexpectedEOF - } - v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:])) - iNdEx += 8 - m.MaxQueriesPerSecond = float64(math.Float64frombits(v)) - case 6: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MaxQueriesPerSecondSet", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - m.MaxQueriesPerSecondSet = bool(v != 0) default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -34007,7 +34964,7 @@ func (m *RangeStatsResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MigrateRequest) Unmarshal(dAtA []byte) error { +func (m *ScanInterleavedIntentsRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -34030,10 +34987,10 @@ func (m *MigrateRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MigrateRequest: wiretype end group for non-group") + return fmt.Errorf("proto: ScanInterleavedIntentsRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MigrateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ScanInterleavedIntentsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -34069,39 +35026,6 @@ func (m *MigrateRequest) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -34123,7 +35047,7 @@ func (m *MigrateRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *MigrateResponse) Unmarshal(dAtA []byte) error { +func (m *ScanInterleavedIntentsResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -34146,10 +35070,10 @@ func (m *MigrateResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MigrateResponse: wiretype end group for non-group") + return fmt.Errorf("proto: ScanInterleavedIntentsResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MigrateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ScanInterleavedIntentsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -34185,6 +35109,40 @@ func (m *MigrateResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field IntentRows", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.IntentRows = append(m.IntentRows, KeyValue{}) + if err := m.IntentRows[len(m.IntentRows)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -34206,7 +35164,7 @@ func (m *MigrateResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *QueryResolvedTimestampRequest) Unmarshal(dAtA []byte) error { +func (m *BarrierRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -34229,10 +35187,10 @@ func (m *QueryResolvedTimestampRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: QueryResolvedTimestampRequest: wiretype end group for non-group") + return fmt.Errorf("proto: BarrierRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: QueryResolvedTimestampRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BarrierRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -34289,7 +35247,7 @@ func (m *QueryResolvedTimestampRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *QueryResolvedTimestampResponse) Unmarshal(dAtA []byte) error { +func (m *BarrierResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -34312,10 +35270,10 @@ func (m *QueryResolvedTimestampResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: QueryResolvedTimestampResponse: wiretype end group for non-group") + return fmt.Errorf("proto: BarrierResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: QueryResolvedTimestampResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: BarrierResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -34353,7 +35311,7 @@ func (m *QueryResolvedTimestampResponse) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ResolvedTS", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -34380,7 +35338,7 @@ func (m *QueryResolvedTimestampResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if err := m.ResolvedTS.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -35974,6 +36932,76 @@ func (m *RequestUnion) Unmarshal(dAtA []byte) error { } m.Value = &RequestUnion_QueryResolvedTimestamp{v} iNdEx = postIndex + case 52: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ScanInterleavedIntents", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ScanInterleavedIntentsRequest{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &RequestUnion_ScanInterleavedIntents{v} + iNdEx = postIndex + case 53: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Barrier", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &BarrierRequest{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &RequestUnion_Barrier{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -37529,6 +38557,76 @@ func (m *ResponseUnion) Unmarshal(dAtA []byte) error { } m.Value = &ResponseUnion_QueryResolvedTimestamp{v} iNdEx = postIndex + case 52: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ScanInterleavedIntents", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &ScanInterleavedIntentsResponse{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &ResponseUnion_ScanInterleavedIntents{v} + iNdEx = postIndex + case 53: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Barrier", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + v := &BarrierResponse{} + if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + m.Value = &ResponseUnion_Barrier{v} + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) diff --git a/pkg/roachpb/api.proto b/pkg/roachpb/api.proto index 8d5535837d27..2d9ec0300377 100644 --- a/pkg/roachpb/api.proto +++ b/pkg/roachpb/api.proto @@ -1782,6 +1782,39 @@ message QueryResolvedTimestampResponse { (gogoproto.nullable) = false, (gogoproto.customname) = "ResolvedTS"]; } +// ScanInterleavedIntentsRequest is the request for a ScanInterleavedIntents operation. +// This is a read-only operation that returns all interleaved (non-separated) +// intents found over the request range. +message ScanInterleavedIntentsRequest { + RequestHeader header = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; +} + +// ScanInterleavedIntentsResponse is the response to a ScanInterleavedIntents operation. +message ScanInterleavedIntentsResponse { + ResponseHeader header = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + + // The intent rows encountered in the part of the request span that was + // evaluated. A resume span is set in the response header if the entirety of + // the request span was not evaluated. + repeated KeyValue intent_rows = 3 [(gogoproto.nullable) = false]; +} + +// BarrierRequest is the request for a Barrier operation. This goes through Raft +// and has the purpose of waiting until all in-flight write operations on this +// range have completed, without blocking any new operations. +message BarrierRequest { + RequestHeader header = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; +} + +// BarrierResponse is the response for a Barrier operation. +message BarrierResponse { + ResponseHeader header = 1 [(gogoproto.nullable) = false, (gogoproto.embed) = true]; + + // Timestamp at which this Barrier was evaluated. Can be used to guarantee + // future operations happen on the same or newer leaseholders. + util.hlc.Timestamp timestamp = 2 [(gogoproto.nullable) = false]; +} + // A RequestUnion contains exactly one of the requests. // The values added here must match those in ResponseUnion. // @@ -1833,6 +1866,8 @@ message RequestUnion { AdminVerifyProtectedTimestampRequest admin_verify_protected_timestamp = 49; MigrateRequest migrate = 50; QueryResolvedTimestampRequest query_resolved_timestamp = 51; + ScanInterleavedIntentsRequest scan_interleaved_intents = 52; + BarrierRequest barrier = 53; } reserved 8, 15, 23, 25, 27, 31, 34; } @@ -1884,6 +1919,8 @@ message ResponseUnion { AdminVerifyProtectedTimestampResponse admin_verify_protected_timestamp = 49; MigrateResponse migrate = 50; QueryResolvedTimestampResponse query_resolved_timestamp = 51; + ScanInterleavedIntentsResponse scan_interleaved_intents = 52; + BarrierResponse barrier = 53; } reserved 8, 15, 23, 25, 27, 28, 31, 34; } diff --git a/pkg/roachpb/batch_generated.go b/pkg/roachpb/batch_generated.go index 1d091d5551f8..c4818ab1346b 100644 --- a/pkg/roachpb/batch_generated.go +++ b/pkg/roachpb/batch_generated.go @@ -168,6 +168,10 @@ func (ru RequestUnion) GetInner() Request { return t.Migrate case *RequestUnion_QueryResolvedTimestamp: return t.QueryResolvedTimestamp + case *RequestUnion_ScanInterleavedIntents: + return t.ScanInterleavedIntents + case *RequestUnion_Barrier: + return t.Barrier default: return nil } @@ -262,6 +266,10 @@ func (ru ResponseUnion) GetInner() Response { return t.Migrate case *ResponseUnion_QueryResolvedTimestamp: return t.QueryResolvedTimestamp + case *ResponseUnion_ScanInterleavedIntents: + return t.ScanInterleavedIntents + case *ResponseUnion_Barrier: + return t.Barrier default: return nil } @@ -431,6 +439,10 @@ func (ru *RequestUnion) MustSetInner(r Request) { union = &RequestUnion_Migrate{t} case *QueryResolvedTimestampRequest: union = &RequestUnion_QueryResolvedTimestamp{t} + case *ScanInterleavedIntentsRequest: + union = &RequestUnion_ScanInterleavedIntents{t} + case *BarrierRequest: + union = &RequestUnion_Barrier{t} default: panic(fmt.Sprintf("unsupported type %T for %T", r, ru)) } @@ -528,13 +540,17 @@ func (ru *ResponseUnion) MustSetInner(r Response) { union = &ResponseUnion_Migrate{t} case *QueryResolvedTimestampResponse: union = &ResponseUnion_QueryResolvedTimestamp{t} + case *ScanInterleavedIntentsResponse: + union = &ResponseUnion_ScanInterleavedIntents{t} + case *BarrierResponse: + union = &ResponseUnion_Barrier{t} default: panic(fmt.Sprintf("unsupported type %T for %T", r, ru)) } ru.Value = union } -type reqCounts [44]int32 +type reqCounts [46]int32 // getReqCounts returns the number of times each // request type appears in the batch. @@ -630,6 +646,10 @@ func (ba *BatchRequest) getReqCounts() reqCounts { counts[42]++ case *RequestUnion_QueryResolvedTimestamp: counts[43]++ + case *RequestUnion_ScanInterleavedIntents: + counts[44]++ + case *RequestUnion_Barrier: + counts[45]++ default: panic(fmt.Sprintf("unsupported request: %+v", ru)) } @@ -682,6 +702,8 @@ var requestNames = []string{ "AdmVerifyProtectedTimestamp", "Migrate", "QueryResolvedTimestamp", + "ScanInterleavedIntents", + "Barrier", } // Summary prints a short summary of the requests in a batch. @@ -889,6 +911,14 @@ type queryResolvedTimestampResponseAlloc struct { union ResponseUnion_QueryResolvedTimestamp resp QueryResolvedTimestampResponse } +type scanInterleavedIntentsResponseAlloc struct { + union ResponseUnion_ScanInterleavedIntents + resp ScanInterleavedIntentsResponse +} +type barrierResponseAlloc struct { + union ResponseUnion_Barrier + resp BarrierResponse +} // CreateReply creates replies for each of the contained requests, wrapped in a // BatchResponse. The response objects are batch allocated to minimize @@ -943,6 +973,8 @@ func (ba *BatchRequest) CreateReply() *BatchResponse { var buf41 []adminVerifyProtectedTimestampResponseAlloc var buf42 []migrateResponseAlloc var buf43 []queryResolvedTimestampResponseAlloc + var buf44 []scanInterleavedIntentsResponseAlloc + var buf45 []barrierResponseAlloc for i, r := range ba.Requests { switch r.GetValue().(type) { @@ -1254,6 +1286,20 @@ func (ba *BatchRequest) CreateReply() *BatchResponse { buf43[0].union.QueryResolvedTimestamp = &buf43[0].resp br.Responses[i].Value = &buf43[0].union buf43 = buf43[1:] + case *RequestUnion_ScanInterleavedIntents: + if buf44 == nil { + buf44 = make([]scanInterleavedIntentsResponseAlloc, counts[44]) + } + buf44[0].union.ScanInterleavedIntents = &buf44[0].resp + br.Responses[i].Value = &buf44[0].union + buf44 = buf44[1:] + case *RequestUnion_Barrier: + if buf45 == nil { + buf45 = make([]barrierResponseAlloc, counts[45]) + } + buf45[0].union.Barrier = &buf45[0].resp + br.Responses[i].Value = &buf45[0].union + buf45 = buf45[1:] default: panic(fmt.Sprintf("unsupported request: %+v", r)) } @@ -1352,6 +1398,10 @@ func CreateRequest(method Method) Request { return &MigrateRequest{} case QueryResolvedTimestamp: return &QueryResolvedTimestampRequest{} + case ScanInterleavedIntents: + return &ScanInterleavedIntentsRequest{} + case Barrier: + return &BarrierRequest{} default: panic(fmt.Sprintf("unsupported method: %+v", method)) } diff --git a/pkg/roachpb/method.go b/pkg/roachpb/method.go index aaad6cbbc271..7e8b7d6bb59d 100644 --- a/pkg/roachpb/method.go +++ b/pkg/roachpb/method.go @@ -162,6 +162,13 @@ const ( // QueryResolvedTimestamp requests the resolved timestamp of the key span it // is issued over. QueryResolvedTimestamp + // ScanInterleavedIntents is a command to return interleaved intents + // encountered over a key range. + ScanInterleavedIntents + // Barrier is a command that ensures all in-flight write operations on this range + // before this command have finished by the time it returns. It does not block + // new operations that started after this command's evaluation. + Barrier // NumMethods represents the total number of API methods. NumMethods ) diff --git a/pkg/roachpb/method_string.go b/pkg/roachpb/method_string.go index c4a2e66741d5..925689e4557f 100644 --- a/pkg/roachpb/method_string.go +++ b/pkg/roachpb/method_string.go @@ -53,12 +53,14 @@ func _() { _ = x[RangeStats-42] _ = x[AdminVerifyProtectedTimestamp-43] _ = x[QueryResolvedTimestamp-44] - _ = x[NumMethods-45] + _ = x[ScanInterleavedIntents-45] + _ = x[Barrier-46] + _ = x[NumMethods-47] } -const _Method_name = "GetPutConditionalPutIncrementDeleteDeleteRangeClearRangeRevertRangeScanReverseScanEndTxnAdminSplitAdminUnsplitAdminMergeAdminTransferLeaseAdminChangeReplicasAdminRelocateRangeHeartbeatTxnGCPushTxnRecoverTxnQueryTxnQueryIntentResolveIntentResolveIntentRangeMergeTruncateLogRequestLeaseTransferLeaseLeaseInfoComputeChecksumCheckConsistencyInitPutWriteBatchExportAdminScatterAddSSTableMigrateRecomputeStatsRefreshRefreshRangeSubsumeRangeStatsAdminVerifyProtectedTimestampQueryResolvedTimestampNumMethods" +const _Method_name = "GetPutConditionalPutIncrementDeleteDeleteRangeClearRangeRevertRangeScanReverseScanEndTxnAdminSplitAdminUnsplitAdminMergeAdminTransferLeaseAdminChangeReplicasAdminRelocateRangeHeartbeatTxnGCPushTxnRecoverTxnQueryTxnQueryIntentResolveIntentResolveIntentRangeMergeTruncateLogRequestLeaseTransferLeaseLeaseInfoComputeChecksumCheckConsistencyInitPutWriteBatchExportAdminScatterAddSSTableMigrateRecomputeStatsRefreshRefreshRangeSubsumeRangeStatsAdminVerifyProtectedTimestampQueryResolvedTimestampScanInterleavedIntentsBarrierNumMethods" -var _Method_index = [...]uint16{0, 3, 6, 20, 29, 35, 46, 56, 67, 71, 82, 88, 98, 110, 120, 138, 157, 175, 187, 189, 196, 206, 214, 225, 238, 256, 261, 272, 284, 297, 306, 321, 337, 344, 354, 360, 372, 382, 389, 403, 410, 422, 429, 439, 468, 490, 500} +var _Method_index = [...]uint16{0, 3, 6, 20, 29, 35, 46, 56, 67, 71, 82, 88, 98, 110, 120, 138, 157, 175, 187, 189, 196, 206, 214, 225, 238, 256, 261, 272, 284, 297, 306, 321, 337, 344, 354, 360, 372, 382, 389, 403, 410, 422, 429, 439, 468, 490, 512, 519, 529} func (i Method) String() string { if i < 0 || i >= Method(len(_Method_index)-1) { diff --git a/pkg/server/server_sql.go b/pkg/server/server_sql.go index 27e512d81170..9929cd01b9d9 100644 --- a/pkg/server/server_sql.go +++ b/pkg/server/server_sql.go @@ -721,6 +721,8 @@ func newSQLServer(ctx context.Context, cfg sqlServerArgs) (*SQLServer, error) { NodeLiveness: nodeLiveness, Dialer: cfg.nodeDialer, DB: cfg.db, + Stopper: cfg.stopper, + DistSender: cfg.distSender, }) } else { c = migrationcluster.NewTenantCluster(cfg.db) diff --git a/pkg/storage/intent_reader_writer.go b/pkg/storage/intent_reader_writer.go index 9bd6e8cb72be..e1c03f514ade 100644 --- a/pkg/storage/intent_reader_writer.go +++ b/pkg/storage/intent_reader_writer.go @@ -42,6 +42,9 @@ import ( // running with this flag set to true for some time, most ranges will only // have separated intents. Similarly, setting this to false will gradually // cause most ranges to only have interleaved intents. +// +// TODO(bilal): Remove this setting and replace it with a testing knob, as we +// no longer expect this setting to be toggled to false outside of tests. var SeparatedIntentsEnabled = settings.RegisterBoolSetting( "storage.transaction.separated_intents.enabled", "if enabled, intents will be written to a separate lock table, instead of being "+ diff --git a/pkg/ts/catalog/chart_catalog.go b/pkg/ts/catalog/chart_catalog.go index 7de59398935f..ea99e4330c05 100644 --- a/pkg/ts/catalog/chart_catalog.go +++ b/pkg/ts/catalog/chart_catalog.go @@ -306,6 +306,7 @@ var charts = []sectionDescription{ "distsender.rpc.leaseinfo.sent", "distsender.rpc.merge.sent", "distsender.rpc.migrate.sent", + "distsender.rpc.migratelocktable.sent", "distsender.rpc.pushtxn.sent", "distsender.rpc.put.sent", "distsender.rpc.queryintent.sent",