From 77405a5e377c3052c2cc83de845a73a81ca258db Mon Sep 17 00:00:00 2001 From: Nathan VanBenschoten Date: Fri, 23 Jul 2021 22:04:57 -0400 Subject: [PATCH] kv: add LockTimeout option to BatchRequest Informs #67513. This commit introduces a new `lock_timeout` field on the BatchRequest Header struct. lock_timeout specifies the maximum amount of time that the batch request will wait while attempting to acquire a lock on a key or while blocking on an existing lock in order to perform a non-locking read on a key. The time limit applies separately to each lock acquisition attempt. If the timeout elapses when waiting for a lock, a WriteIntentError will be returned. Unlike in some other systems like PostgreSQL, where non-locking reads do not wait on conflicting locks, in CockroachDB, non-locking reads do wait for conflicting locks to be released. Because of this, the lock_timeout configuration applies to non-locking reads in read-write and read-only transactions as well. Only the (default) Block wait policy will allow a request to wait on conflicting locks, so the timeout only makes sense in conjunction with the Block wait policy. The Error wait policy will throw an error immediately if a conflicting lock held by an active transaction is encountered, so this timeout can never be hit with an Error wait policy. A value of zero disables the timeout. --- pkg/kv/kvclient/kvcoord/testdata/savepoints | 47 +- .../txn_coord_sender_savepoints_test.go | 7 + pkg/kv/kvclient/kvcoord/txn_test.go | 25 +- .../concurrency/concurrency_control.go | 6 + .../concurrency/concurrency_manager_test.go | 12 +- .../kvserver/concurrency/lock_table_waiter.go | 249 +++- .../concurrency/lock_table_waiter_test.go | 255 +++- .../testdata/concurrency_manager/lock_timeout | 276 ++++ .../concurrency_manager/queue_length_exceeded | 2 +- .../concurrency_manager/wait_policy_error | 6 +- pkg/kv/kvserver/replica_send.go | 1 + pkg/kv/kvserver/testing_knobs.go | 2 + pkg/roachpb/api.pb.go | 1167 +++++++++-------- pkg/roachpb/api.proto | 21 + pkg/roachpb/errors.go | 13 + pkg/roachpb/errors.pb.go | 483 ++++--- pkg/roachpb/errors.proto | 18 + pkg/testutils/lint/lint_test.go | 5 +- 18 files changed, 1766 insertions(+), 829 deletions(-) create mode 100644 pkg/kv/kvserver/concurrency/testdata/concurrency_manager/lock_timeout diff --git a/pkg/kv/kvclient/kvcoord/testdata/savepoints b/pkg/kv/kvclient/kvcoord/testdata/savepoints index b90703d42fe4..55c076058e71 100644 --- a/pkg/kv/kvclient/kvcoord/testdata/savepoints +++ b/pkg/kv/kvclient/kvcoord/testdata/savepoints @@ -368,7 +368,7 @@ subtest end -subtest rollback_after_write_intent_error +subtest rollback_after_wait_policy_write_intent_error # Write intent errors are white-listed to allow a rollback to savepoint afterwards. # They make their way back up to the kv client when requests are run with an Error # wait policy. @@ -391,7 +391,7 @@ savepoint x get conflict-key locking nowait ---- -(*roachpb.WriteIntentError) conflicting intents on "conflict-key" +(*roachpb.WriteIntentError) conflicting intents on "conflict-key" [reason=wait_policy] rollback x ---- @@ -399,7 +399,48 @@ rollback x put conflict-key b nowait ---- -(*roachpb.WriteIntentError) conflicting intents on "conflict-key" +(*roachpb.WriteIntentError) conflicting intents on "conflict-key" [reason=wait_policy] + +rollback x +---- +1 [1-1] + +subtest end + + + +subtest rollback_after_lock_timeout_write_intent_error +# Write intent errors are white-listed to allow a rollback to savepoint afterwards. +# They make their way back up to the kv client when requests are run with a lock +# timeout. + +# NB: we're going to leak this txn, so write to an otherwise unused key. +begin +---- +0 + +put conflict-key-2 a +---- + +begin +---- +0 + +savepoint x +---- +0 + +get conflict-key-2 lock-timeout +---- +(*roachpb.WriteIntentError) conflicting intents on "conflict-key-2" [reason=lock_timeout] + +rollback x +---- +0 + +put conflict-key-2 b lock-timeout +---- +(*roachpb.WriteIntentError) conflicting intents on "conflict-key-2" [reason=lock_timeout] rollback x ---- diff --git a/pkg/kv/kvclient/kvcoord/txn_coord_sender_savepoints_test.go b/pkg/kv/kvclient/kvcoord/txn_coord_sender_savepoints_test.go index 92c960d96768..6ac9624b0095 100644 --- a/pkg/kv/kvclient/kvcoord/txn_coord_sender_savepoints_test.go +++ b/pkg/kv/kvclient/kvcoord/txn_coord_sender_savepoints_test.go @@ -16,6 +16,7 @@ import ( "strings" "sync/atomic" "testing" + "time" "github.com/cockroachdb/cockroach/pkg/base" "github.com/cockroachdb/cockroach/pkg/kv" @@ -128,6 +129,9 @@ func TestSavepoints(t *testing.T) { if td.HasArg("nowait") { b.Header.WaitPolicy = lock.WaitPolicy_Error } + if td.HasArg("lock-timeout") { + b.Header.LockTimeout = 1 * time.Nanosecond + } if err := txn.Run(ctx, b); err != nil { fmt.Fprintf(&buf, "(%T) %v\n", err, err) } @@ -163,6 +167,9 @@ func TestSavepoints(t *testing.T) { if td.HasArg("nowait") { b.Header.WaitPolicy = lock.WaitPolicy_Error } + if td.HasArg("lock-timeout") { + b.Header.LockTimeout = 1 * time.Nanosecond + } if err := txn.Run(ctx, b); err != nil { fmt.Fprintf(&buf, "(%T) %v\n", err, err) } else { diff --git a/pkg/kv/kvclient/kvcoord/txn_test.go b/pkg/kv/kvclient/kvcoord/txn_test.go index f9a0968097d3..8a286075f9ba 100644 --- a/pkg/kv/kvclient/kvcoord/txn_test.go +++ b/pkg/kv/kvclient/kvcoord/txn_test.go @@ -803,7 +803,9 @@ func TestTxnWaitPolicies(t *testing.T) { // Priority does not matter. err := <-errorC require.NotNil(t, err) - require.IsType(t, &roachpb.WriteIntentError{}, err) + wiErr := new(roachpb.WriteIntentError) + require.True(t, errors.As(err, &wiErr)) + require.Equal(t, roachpb.WriteIntentError_REASON_WAIT_POLICY, wiErr.Reason) // Let blocked requests proceed. require.NoError(t, txn.Commit(ctx)) @@ -813,6 +815,27 @@ func TestTxnWaitPolicies(t *testing.T) { }) } +func TestTxnLockTimeout(t *testing.T) { + defer leaktest.AfterTest(t)() + defer log.Scope(t).Close(t) + ctx := context.Background() + s := createTestDB(t) + defer s.Stop() + + key := []byte("b") + txn := s.DB.NewTxn(ctx, "test txn") + require.NoError(t, txn.Put(ctx, key, "new value")) + + var b kv.Batch + b.Header.LockTimeout = 25 * time.Millisecond + b.Get(key) + err := s.DB.Run(ctx, &b) + require.NotNil(t, err) + wiErr := new(roachpb.WriteIntentError) + require.True(t, errors.As(err, &wiErr)) + require.Equal(t, roachpb.WriteIntentError_REASON_LOCK_TIMEOUT, wiErr.Reason) +} + // TestTxnReturnsWriteTooOldErrorOnConflictingDeleteRange tests that if two // transactions issue delete range operations over the same keys, the later // transaction eagerly returns a WriteTooOld error instead of deferring the diff --git a/pkg/kv/kvserver/concurrency/concurrency_control.go b/pkg/kv/kvserver/concurrency/concurrency_control.go index 0df0da0e06c4..db6f984f4624 100644 --- a/pkg/kv/kvserver/concurrency/concurrency_control.go +++ b/pkg/kv/kvserver/concurrency/concurrency_control.go @@ -15,6 +15,7 @@ package concurrency import ( "context" + "time" "github.com/cockroachdb/cockroach/pkg/kv/kvserver/concurrency/lock" "github.com/cockroachdb/cockroach/pkg/kv/kvserver/spanset" @@ -371,6 +372,11 @@ type Request struct { // transactions. WaitPolicy lock.WaitPolicy + // The maximum amount of time that the batch request will wait while + // attempting to acquire a lock on a key or while blocking on an + // existing lock in order to perform a non-locking read on a key. + LockTimeout time.Duration + // The maximum length of a lock wait-queue that the request is willing // to enter and wait in. Used to provide a release valve and ensure some // level of quality-of-service under severe per-key contention. If set diff --git a/pkg/kv/kvserver/concurrency/concurrency_manager_test.go b/pkg/kv/kvserver/concurrency/concurrency_manager_test.go index d2df4d4414c0..d6b5baf36c7b 100644 --- a/pkg/kv/kvserver/concurrency/concurrency_manager_test.go +++ b/pkg/kv/kvserver/concurrency/concurrency_manager_test.go @@ -53,7 +53,7 @@ import ( // The input files use the following DSL: // // new-txn name= ts=[,] epoch= [uncertainty-limit=[,]] -// new-request name= txn=|none ts=[,] [priority] [inconsistent] [wait-policy=] [max-lock-wait-queue-length=] +// new-request name= txn=|none ts=[,] [priority] [inconsistent] [wait-policy=] [lock-timeout] [max-lock-wait-queue-length=] // [=...] (hint: see scanSingleRequest) // sequence req= [eval-kind= @@ -154,6 +154,15 @@ func TestConcurrencyManagerBasic(t *testing.T) { waitPolicy := scanWaitPolicy(t, d, false /* required */) + var lockTimeout time.Duration + if d.HasArg("lock-timeout") { + // A lock timeout of 1ns will be considered immediately expired + // without a delay by the lockTableWaiter, ensuring that the lock + // timeout logic deterministically fires. + // See (*lockTableWaiterImpl).timeUntilDeadline. + lockTimeout = 1 * time.Nanosecond + } + var maxLockWaitQueueLength int if d.HasArg("max-lock-wait-queue-length") { d.ScanArgs(t, "max-lock-wait-queue-length", &maxLockWaitQueueLength) @@ -169,6 +178,7 @@ func TestConcurrencyManagerBasic(t *testing.T) { // TODO(nvanbenschoten): test Priority ReadConsistency: readConsistency, WaitPolicy: waitPolicy, + LockTimeout: lockTimeout, MaxLockWaitQueueLength: maxLockWaitQueueLength, Requests: reqUnions, LatchSpans: latchSpans, diff --git a/pkg/kv/kvserver/concurrency/lock_table_waiter.go b/pkg/kv/kvserver/concurrency/lock_table_waiter.go index 675468157aa7..748c6a31f24f 100644 --- a/pkg/kv/kvserver/concurrency/lock_table_waiter.go +++ b/pkg/kv/kvserver/concurrency/lock_table_waiter.go @@ -106,6 +106,8 @@ type lockTableWaiterImpl struct { // When set, called just before each ContentionEvent is emitted. // Is allowed to mutate the event. onContentionEvent func(ev *roachpb.ContentionEvent) + // When set, called just before each push timer event is processed. + onPushTimer func() } // IntentResolver is an interface used by lockTableWaiterImpl to push @@ -138,6 +140,8 @@ func (w *lockTableWaiterImpl) WaitOn( var timer *timeutil.Timer var timerC <-chan time.Time var timerWaitingState waitingState + // Used to enforce lock timeouts. + var lockDeadline time.Time h := contentionEventHelper{ sp: tracing.SpanFromContext(ctx), @@ -170,7 +174,7 @@ func (w *lockTableWaiterImpl) WaitOn( if state.held { err = w.pushLockTxn(ctx, req, state) } else { - err = newWriteIntentErr(req, state) + err = newWriteIntentErr(req, state, reasonWaitPolicy) } if err != nil { return err @@ -213,9 +217,14 @@ func (w *lockTableWaiterImpl) WaitOn( deadlockPush = false } - // If the request doesn't want to perform a push for either - // reason, continue waiting. - if !livenessPush && !deadlockPush { + // For requests that have a lock timeout, push after the timeout to + // determine whether the lock is abandoned or whether its holder is + // still active. + timeoutPush := req.LockTimeout != 0 + + // If the request doesn't want to perform a delayed push for any + // reason, continue waiting without a timer. + if !livenessPush && !deadlockPush && !timeoutPush { continue } @@ -231,6 +240,17 @@ func (w *lockTableWaiterImpl) WaitOn( if deadlockPush { delay = minDuration(delay, LockTableDeadlockDetectionPushDelay.Get(&w.st.SV)) } + if timeoutPush { + // Only reset the lock timeout deadline if this is the first time + // seeing this lock. Specifically, reset the deadline if this is a + // new key or if this is a new transaction for the same key. + oldState := timerWaitingState // empty on first pass + newLock := !oldState.key.Equal(state.key) || oldState.txn.ID != state.txn.ID + if newLock { + lockDeadline = w.clock.PhysicalTime().Add(req.LockTimeout) + } + delay = minDuration(delay, w.timeUntilDeadline(lockDeadline)) + } // However, if the pushee has the minimum priority or if the // pusher has the maximum priority, push immediately. @@ -272,6 +292,13 @@ func (w *lockTableWaiterImpl) WaitOn( // this completes, the request should stop waiting on this // lockTableGuard, as it will no longer observe lock-table state // transitions. + if req.LockTimeout != 0 { + return doWithTimeoutAndFallback( + ctx, req.LockTimeout, + func(ctx context.Context) *Error { return w.pushLockTxn(ctx, req, state) }, + func(ctx context.Context) *Error { return w.pushLockTxnAfterTimeout(ctx, req, state) }, + ) + } return w.pushLockTxn(ctx, req, state) case waitSelf: @@ -284,7 +311,7 @@ func (w *lockTableWaiterImpl) WaitOn( // The request attempted to wait in a lock wait-queue whose length was // already equal to or exceeding the request's configured maximum. As a // result, the request was rejected. - return newWriteIntentErr(req, state) + return newWriteIntentErr(req, state, reasonWaitQueueMaxLengthExceeded) case doneWaiting: // The request has waited for all conflicting locks to be released @@ -320,40 +347,80 @@ func (w *lockTableWaiterImpl) WaitOn( if timer != nil { timer.Read = true } + if w.onPushTimer != nil { + w.onPushTimer() + } - // If the request is conflicting with a held lock then it pushes its - // holder synchronously - there is no way it will be able to proceed - // until the lock's transaction undergoes a state transition (either - // completing or being pushed) and then updates the lock's state - // through intent resolution. The request has a dependency on the - // entire conflicting transaction. - // - // However, if the request is conflicting with another request (a - // reservation holder) then it pushes the reservation holder - // asynchronously while continuing to listen to state transition in - // the lockTable. This allows the request to cancel its push if the - // conflicting reservation exits the lock wait-queue without leaving - // behind a lock. In this case, the request has a dependency on the - // conflicting request but not necessarily the entire conflicting - // transaction. - if timerWaitingState.held { - err = w.pushLockTxn(ctx, req, timerWaitingState) - } else { - // It would be more natural to launch an async task for the push - // and continue listening on this goroutine for lockTable state - // transitions, but doing so is harder to test against. Instead, - // we launch an async task to listen to lockTable state and - // synchronously push. If the watcher goroutine detects a - // lockTable change, it cancels the context on the push. + // push with the option to wait on the conflict if active. + pushWait := func(ctx context.Context) *Error { + // If the request is conflicting with a held lock then it pushes its + // holder synchronously - there is no way it will be able to proceed + // until the lock's transaction undergoes a state transition (either + // completing or being pushed) and then updates the lock's state + // through intent resolution. The request has a dependency on the + // entire conflicting transaction. + // + // However, if the request is conflicting with another request (a + // reservation holder) then it pushes the reservation holder + // asynchronously while continuing to listen to state transition in + // the lockTable. This allows the request to cancel its push if the + // conflicting reservation exits the lock wait-queue without leaving + // behind a lock. In this case, the request has a dependency on the + // conflicting request but not necessarily the entire conflicting + // transaction. + if timerWaitingState.held { + return w.pushLockTxn(ctx, req, timerWaitingState) + } + + // It would be more natural to launch an async task for the push and + // continue listening on this goroutine for lockTable state transitions, + // but doing so is harder to test against. Instead, we launch an async + // task to listen to lockTable state and synchronously push. If the + // watcher goroutine detects a lockTable change, it cancels the context + // on the push. pushCtx, pushCancel := context.WithCancel(ctx) - go w.watchForNotifications(pushCtx, pushCancel, newStateC) - err = w.pushRequestTxn(pushCtx, req, timerWaitingState) + defer pushCancel() + go watchForNotifications(pushCtx, pushCancel, newStateC) + err := w.pushRequestTxn(pushCtx, req, timerWaitingState) if errors.Is(pushCtx.Err(), context.Canceled) { // Ignore the context canceled error. If this was for the // parent context then we'll notice on the next select. + // + // NOTE: we look at pushCtx.Err() and not err to avoid the + // potential for bugs if context cancellation is not + // propagated correctly on some error paths. err = nil } - pushCancel() + return err + } + + // push without the option to wait on the conflict if active. + pushNoWait := func(ctx context.Context) *Error { + // Resolve the conflict without waiting. If the conflict is a lock + // then push the lock holder's transaction using a PUSH_TOUCH to + // determine whether the lock is abandoned or whether its holder is + // still active. If the conflict is a reservation holder, raise an + // error immediately, we know the reservation holder is active. + if timerWaitingState.held { + return w.pushLockTxnAfterTimeout(ctx, req, timerWaitingState) + } + return newWriteIntentErr(req, timerWaitingState, reasonLockTimeout) + } + + // We push with or without the option to wait on the conflict, + // depending on the state of the lock timeout, if one exists. + if !lockDeadline.IsZero() { + untilDeadline := w.timeUntilDeadline(lockDeadline) + if untilDeadline == 0 { + // Deadline already exceeded. + err = pushNoWait(ctx) + } else { + // Deadline not yet exceeded. + err = doWithTimeoutAndFallback(ctx, untilDeadline, pushWait, pushNoWait) + } + } else { + // No deadline. + err = pushWait(ctx) } if err != nil { return err @@ -376,27 +443,43 @@ func (w *lockTableWaiterImpl) WaitOnLock( if err != nil { return roachpb.NewError(err) } - return w.pushLockTxn(ctx, req, waitingState{ + state := waitingState{ kind: waitFor, txn: &intent.Txn, key: intent.Key, held: true, guardAccess: sa, - }) + } + if req.LockTimeout != 0 { + return doWithTimeoutAndFallback( + ctx, req.LockTimeout, + func(ctx context.Context) *Error { return w.pushLockTxn(ctx, req, state) }, + func(ctx context.Context) *Error { return w.pushLockTxnAfterTimeout(ctx, req, state) }, + ) + } + return w.pushLockTxn(ctx, req, state) } // pushLockTxn pushes the holder of the provided lock. // -// The method blocks until the lock holder transaction experiences a state -// transition such that it no longer conflicts with the pusher's request. The -// method then synchronously updates the lock to trigger a state transition in -// the lockTable that will free up the request to proceed. If the method returns -// successfully then the caller can expect to have an updated waitingState. +// If a Block wait policy is set on the request, method blocks until the lock +// holder transaction experiences a state transition such that it no longer +// conflicts with the pusher's request. The method then synchronously updates +// the lock to trigger a state transition in the lockTable that will free up the +// request to proceed. If the method returns successfully then the caller can +// expect to have an updated waitingState. +// +// If an Error wait policy is set on the request, the method checks if the lock +// holder transaction is abandoned. If so, the method synchronously updates the +// lock to trigger a state transition in the lockTable that will free up the +// request to proceed. If the method returns successfully then the caller can +// expect to have an updated waitingState. Otherwise, the method returns with a +// WriteIntentError and without blocking on the lock holder transaction. func (w *lockTableWaiterImpl) pushLockTxn( ctx context.Context, req Request, ws waitingState, ) *Error { if w.disableTxnPushing { - return newWriteIntentErr(req, ws) + return newWriteIntentErr(req, ws, reasonWaitPolicy) } // Construct the request header and determine which form of push to use. @@ -438,7 +521,7 @@ func (w *lockTableWaiterImpl) pushLockTxn( // If pushing with an Error WaitPolicy and the push fails, then the lock // holder is still active. Transform the error into a WriteIntentError. if _, ok := err.GetDetail().(*roachpb.TransactionPushError); ok && req.WaitPolicy == lock.WaitPolicy_Error { - err = newWriteIntentErr(req, ws) + err = newWriteIntentErr(req, ws, reasonWaitPolicy) } return err } @@ -486,6 +569,22 @@ func (w *lockTableWaiterImpl) pushLockTxn( return w.ir.ResolveIntent(ctx, resolve, opts) } +// pushLockTxnAfterTimeout is like pushLockTxn, but it sets the Error wait +// policy on its request so that the request will not block on the lock holder +// if it is still active. It is meant to be used after a lock timeout has been +// elapsed, and returns a WriteIntentErrors with a LOCK_TIMEOUT reason if the +// lock holder is not abandoned. +func (w *lockTableWaiterImpl) pushLockTxnAfterTimeout( + ctx context.Context, req Request, ws waitingState, +) *Error { + req.WaitPolicy = lock.WaitPolicy_Error + err := w.pushLockTxn(ctx, req, ws) + if _, ok := err.GetDetail().(*roachpb.WriteIntentError); ok { + err = newWriteIntentErr(req, ws, reasonLockTimeout) + } + return err +} + // pushRequestTxn pushes the owner of the provided request. // // The method blocks until either the pusher's transaction is aborted or the @@ -631,6 +730,21 @@ func (w *lockTableWaiterImpl) pushHeader(req Request) roachpb.Header { return h } +// timeUntilDeadline computes the duration until the specified deadline is +// reached. If the deadline has already been reached, the method returns 0. As +// an optimization and as a convenience for tests, if the deadline is within a +// threshold such that it does not make sense to begin an expensive operation +// that is limited by the deadline, the method considers the deadline to have +// already been reached. +func (w *lockTableWaiterImpl) timeUntilDeadline(deadline time.Time) time.Duration { + dur := deadline.Sub(w.clock.PhysicalTime()) + const soon = 250 * time.Microsecond + if dur <= soon { + return 0 + } + return dur +} + // ResolveDeferredIntents implements the lockTableWaiter interface. func (w *lockTableWaiterImpl) ResolveDeferredIntents( ctx context.Context, deferredResolution []roachpb.LockUpdate, @@ -643,12 +757,46 @@ func (w *lockTableWaiterImpl) ResolveDeferredIntents( return w.ir.ResolveIntents(ctx, deferredResolution, opts) } +// doWithTimeoutAndFallback runs the withTimeout function with the specified +// timeout. If the function completes before hitting the timeout, its result +// is returned. Otherwise, the afterTimeout function is run without a timeout +// and its result is returned. +// +// The function is called in a few locations to run a blocking push with a +// timeout and then to fall back to a non-blocking push if that timeout is +// reached. This pattern is used because on a timeout, we don't know whether a +// blocking PUSH_TIMESTAMP / PUSH_ABORT push actually got to the point of +// proving that the pushee was active and began waiting in its txnwait.Queue. +// The push may have timed out before this point due to a slow network, slow +// CPU, or for some other reason. But just like with WaitPolicy_Error, we don't +// want to throw a WriteIntentError on abandoned locks. So on timeout, we issue +// a PUSH_TOUCH request (like we do for WaitPolicy_Error) that is not subject to +// the lock_timeout to check with certainty whether the conflict is active or +// not, but without blocking if it happens to be active. +func doWithTimeoutAndFallback( + ctx context.Context, + timeout time.Duration, + withTimeout, afterTimeout func(ctx context.Context) *Error, +) *Error { + timeoutCtx, timeoutCancel := context.WithTimeout(ctx, timeout) // nolint:context + defer timeoutCancel() + err := withTimeout(timeoutCtx) + if !errors.Is(timeoutCtx.Err(), context.DeadlineExceeded) { + // If the context deadline was not exceeded, return the result. + // + // NOTE: we look at timeoutCtx.Err() and not err to avoid the + // potential for bugs if context cancellation is not propagated + // correctly on some error paths. + return err + } + // Otherwise, run the fallback function without a timeout. + return afterTimeout(ctx) +} + // watchForNotifications selects on the provided channel and watches for any // updates. If the channel is ever notified, it calls the provided context -// cancelation function and exits. -func (w *lockTableWaiterImpl) watchForNotifications( - ctx context.Context, cancel func(), newStateC chan struct{}, -) { +// cancellation function and exits. +func watchForNotifications(ctx context.Context, cancel func(), newStateC chan struct{}) { select { case <-newStateC: // Re-signal the channel. @@ -787,9 +935,18 @@ func (h *contentionEventHelper) emitAndInit(s waitingState) { } } -func newWriteIntentErr(req Request, ws waitingState) *Error { +const ( + reasonWaitPolicy = roachpb.WriteIntentError_REASON_WAIT_POLICY + reasonLockTimeout = roachpb.WriteIntentError_REASON_LOCK_TIMEOUT + reasonWaitQueueMaxLengthExceeded = roachpb.WriteIntentError_REASON_LOCK_WAIT_QUEUE_MAX_LENGTH_EXCEEDED +) + +func newWriteIntentErr( + req Request, ws waitingState, reason roachpb.WriteIntentError_Reason, +) *Error { err := roachpb.NewError(&roachpb.WriteIntentError{ Intents: []roachpb.Intent{roachpb.MakeIntent(ws.txn, ws.key)}, + Reason: reason, }) // TODO(nvanbenschoten): setting an error index can assist the KV client in // understanding which request hit an error. This is not necessary, but can diff --git a/pkg/kv/kvserver/concurrency/lock_table_waiter_test.go b/pkg/kv/kvserver/concurrency/lock_table_waiter_test.go index e98205168b82..f3b35552eb95 100644 --- a/pkg/kv/kvserver/concurrency/lock_table_waiter_test.go +++ b/pkg/kv/kvserver/concurrency/lock_table_waiter_test.go @@ -12,6 +12,7 @@ package concurrency import ( "context" + "errors" "fmt" "math/rand" "testing" @@ -99,7 +100,12 @@ func (lt *mockLockTable) TransactionIsFinalized(txn *roachpb.Transaction) { var lockTableWaiterTestClock = hlc.Timestamp{WallTime: 12} -func setupLockTableWaiterTest() (*lockTableWaiterImpl, *mockIntentResolver, *mockLockTableGuard) { +func setupLockTableWaiterTest() ( + *lockTableWaiterImpl, + *mockIntentResolver, + *mockLockTableGuard, + *hlc.ManualClock, +) { ir := &mockIntentResolver{} st := cluster.MakeTestingClusterSettings() LockTableLivenessPushDelay.Override(context.Background(), &st.SV, 0) @@ -115,7 +121,7 @@ func setupLockTableWaiterTest() (*lockTableWaiterImpl, *mockIntentResolver, *moc ir: ir, lt: &mockLockTable{}, } - return w, ir, guard + return w, ir, guard, manual } func makeTxnProto(name string) roachpb.Transaction { @@ -176,11 +182,11 @@ func TestLockTableWaiterWithTxn(t *testing.T) { }) t.Run("waitQueueMaxLengthExceeded", func(t *testing.T) { - testErrorWaitPush(t, waitQueueMaxLengthExceeded, makeReq, dontExpectPush) + testErrorWaitPush(t, waitQueueMaxLengthExceeded, makeReq, dontExpectPush, reasonWaitQueueMaxLengthExceeded) }) t.Run("doneWaiting", func(t *testing.T) { - w, _, g := setupLockTableWaiterTest() + w, _, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) g.state = waitingState{kind: doneWaiting} @@ -192,7 +198,7 @@ func TestLockTableWaiterWithTxn(t *testing.T) { }) t.Run("ctx done", func(t *testing.T) { - w, _, g := setupLockTableWaiterTest() + w, _, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) ctxWithCancel, cancel := context.WithCancel(ctx) @@ -204,7 +210,7 @@ func TestLockTableWaiterWithTxn(t *testing.T) { }) t.Run("stopper quiesce", func(t *testing.T) { - w, _, g := setupLockTableWaiterTest() + w, _, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) go func() { @@ -252,11 +258,11 @@ func TestLockTableWaiterWithNonTxn(t *testing.T) { }) t.Run("waitQueueMaxLengthExceeded", func(t *testing.T) { - testErrorWaitPush(t, waitQueueMaxLengthExceeded, makeReq, dontExpectPush) + testErrorWaitPush(t, waitQueueMaxLengthExceeded, makeReq, dontExpectPush, reasonWaitQueueMaxLengthExceeded) }) t.Run("doneWaiting", func(t *testing.T) { - w, _, g := setupLockTableWaiterTest() + w, _, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) g.state = waitingState{kind: doneWaiting} @@ -268,7 +274,7 @@ func TestLockTableWaiterWithNonTxn(t *testing.T) { }) t.Run("ctx done", func(t *testing.T) { - w, _, g := setupLockTableWaiterTest() + w, _, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) ctxWithCancel, cancel := context.WithCancel(ctx) @@ -280,7 +286,7 @@ func TestLockTableWaiterWithNonTxn(t *testing.T) { }) t.Run("stopper quiesce", func(t *testing.T) { - w, _, g := setupLockTableWaiterTest() + w, _, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) go func() { @@ -298,7 +304,7 @@ func testWaitPush(t *testing.T, k waitKind, makeReq func() Request, expPushTS hl keyA := roachpb.Key("keyA") testutils.RunTrueAndFalse(t, "lockHeld", func(t *testing.T, lockHeld bool) { testutils.RunTrueAndFalse(t, "waitAsWrite", func(t *testing.T, waitAsWrite bool) { - w, ir, g := setupLockTableWaiterTest() + w, ir, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) pusheeTxn := makeTxnProto("pushee") @@ -323,8 +329,8 @@ func testWaitPush(t *testing.T, k waitKind, makeReq func() Request, expPushTS hl return } - // Non-transactional requests do not push reservations, only locks. - // They wait for doneWaiting. + // Non-transactional requests without a timeout do not push + // reservations, only locks. They wait for doneWaiting. if req.Txn == nil && !lockHeld { defer notifyUntilDone(t, g)() err := w.WaitOn(ctx, req, g) @@ -380,7 +386,7 @@ func testWaitPush(t *testing.T, k waitKind, makeReq func() Request, expPushTS hl func testWaitNoopUntilDone(t *testing.T, k waitKind, makeReq func() Request) { ctx := context.Background() - w, _, g := setupLockTableWaiterTest() + w, _, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) txn := makeTxnProto("noop-wait-txn") @@ -435,15 +441,15 @@ func TestLockTableWaiterWithErrorWaitPolicy(t *testing.T) { t.Run("state", func(t *testing.T) { t.Run("waitFor", func(t *testing.T) { - testErrorWaitPush(t, waitFor, makeReq, expPushTS) + testErrorWaitPush(t, waitFor, makeReq, expPushTS, reasonWaitPolicy) }) t.Run("waitForDistinguished", func(t *testing.T) { - testErrorWaitPush(t, waitForDistinguished, makeReq, expPushTS) + testErrorWaitPush(t, waitForDistinguished, makeReq, expPushTS, reasonWaitPolicy) }) t.Run("waitElsewhere", func(t *testing.T) { - testErrorWaitPush(t, waitElsewhere, makeReq, expPushTS) + testErrorWaitPush(t, waitElsewhere, makeReq, expPushTS, reasonWaitPolicy) }) t.Run("waitSelf", func(t *testing.T) { @@ -451,11 +457,11 @@ func TestLockTableWaiterWithErrorWaitPolicy(t *testing.T) { }) t.Run("waitQueueMaxLengthExceeded", func(t *testing.T) { - testErrorWaitPush(t, waitQueueMaxLengthExceeded, makeReq, dontExpectPush) + testErrorWaitPush(t, waitQueueMaxLengthExceeded, makeReq, dontExpectPush, reasonWaitQueueMaxLengthExceeded) }) t.Run("doneWaiting", func(t *testing.T) { - w, _, g := setupLockTableWaiterTest() + w, _, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) g.state = waitingState{kind: doneWaiting} @@ -469,7 +475,13 @@ func TestLockTableWaiterWithErrorWaitPolicy(t *testing.T) { var dontExpectPush = hlc.Timestamp{} -func testErrorWaitPush(t *testing.T, k waitKind, makeReq func() Request, expPushTS hlc.Timestamp) { +func testErrorWaitPush( + t *testing.T, + k waitKind, + makeReq func() Request, + expPushTS hlc.Timestamp, + errReason roachpb.WriteIntentError_Reason, +) { ctx := context.Background() keyA := roachpb.Key("keyA") testutils.RunTrueAndFalse(t, "lockHeld", func(t *testing.T, lockHeld bool) { @@ -480,7 +492,7 @@ func testErrorWaitPush(t *testing.T, k waitKind, makeReq func() Request, expPush skip.IgnoreLint(t, "incompatible params") } - w, ir, g := setupLockTableWaiterTest() + w, ir, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) pusheeTxn := makeTxnProto("pushee") @@ -503,7 +515,9 @@ func testErrorWaitPush(t *testing.T, k waitKind, makeReq func() Request, expPush require.Nil(t, err) } else { require.NotNil(t, err) - require.Regexp(t, "conflicting intents", err) + wiErr := new(roachpb.WriteIntentError) + require.True(t, errors.As(err.GoError(), &wiErr)) + require.Equal(t, errReason, wiErr.Reason) } return } @@ -547,7 +561,9 @@ func testErrorWaitPush(t *testing.T, k waitKind, makeReq func() Request, expPush err := w.WaitOn(ctx, req, g) if pusheeActive { require.NotNil(t, err) - require.Regexp(t, "conflicting intents", err) + wiErr := new(roachpb.WriteIntentError) + require.True(t, errors.As(err.GoError(), &wiErr)) + require.Equal(t, errReason, wiErr.Reason) } else { require.Nil(t, err) } @@ -555,6 +571,195 @@ func testErrorWaitPush(t *testing.T, k waitKind, makeReq func() Request, expPush }) } +// TestLockTableWaiterWithLockTimeout tests the lockTableWaiter's behavior under +// different waiting states with a lock timeout. +func TestLockTableWaiterWithLockTimeout(t *testing.T) { + defer leaktest.AfterTest(t)() + defer log.Scope(t).Close(t) + ctx := context.Background() + + testutils.RunTrueAndFalse(t, "txn", func(t *testing.T, txn bool) { + const lockTimeout = 1 * time.Millisecond + makeReq := func() Request { + txn := makeTxnProto("request") + return Request{ + Txn: &txn, + Timestamp: txn.ReadTimestamp, + LockTimeout: lockTimeout, + } + } + if !txn { + makeReq = func() Request { + return Request{ + Timestamp: hlc.Timestamp{WallTime: 10}, + LockTimeout: lockTimeout, + } + } + } + + t.Run("state", func(t *testing.T) { + t.Run("waitFor", func(t *testing.T) { + testWaitPushWithTimeout(t, waitFor, makeReq) + }) + + t.Run("waitForDistinguished", func(t *testing.T) { + testWaitPushWithTimeout(t, waitForDistinguished, makeReq) + }) + + t.Run("waitElsewhere", func(t *testing.T) { + testWaitPushWithTimeout(t, waitElsewhere, makeReq) + }) + + t.Run("waitSelf", func(t *testing.T) { + testWaitNoopUntilDone(t, waitSelf, makeReq) + }) + + t.Run("waitQueueMaxLengthExceeded", func(t *testing.T) { + testErrorWaitPush(t, waitQueueMaxLengthExceeded, makeReq, dontExpectPush, reasonWaitQueueMaxLengthExceeded) + }) + + t.Run("doneWaiting", func(t *testing.T) { + w, _, g, _ := setupLockTableWaiterTest() + defer w.stopper.Stop(ctx) + + g.state = waitingState{kind: doneWaiting} + g.notify() + + err := w.WaitOn(ctx, makeReq(), g) + require.Nil(t, err) + }) + }) + }) +} + +func testWaitPushWithTimeout(t *testing.T, k waitKind, makeReq func() Request) { + ctx := context.Background() + keyA := roachpb.Key("keyA") + testutils.RunTrueAndFalse(t, "lockHeld", func(t *testing.T, lockHeld bool) { + testutils.RunTrueAndFalse(t, "pusheeActive", func(t *testing.T, pusheeActive bool) { + testutils.RunTrueAndFalse(t, "timeoutBeforePush", func(t *testing.T, timeoutBeforePush bool) { + if k == waitElsewhere && timeoutBeforePush { + // waitElsewhere pushes immediately, so timeoutBeforePush is + // irrelevant. + skip.IgnoreLint(t, "incompatible params") + } + if !lockHeld && !pusheeActive { + // !lockHeld means a lock reservation, so is only possible when + // pusheeActive is true. + skip.IgnoreLint(t, "incompatible params") + } + + w, ir, g, manual := setupLockTableWaiterTest() + defer w.stopper.Stop(ctx) + pusheeTxn := makeTxnProto("pushee") + + req := makeReq() + g.state = waitingState{ + kind: k, + txn: &pusheeTxn.TxnMeta, + key: keyA, + held: lockHeld, + guardAccess: spanset.SpanReadWrite, + } + g.notify() + + // If the timeout should already be expired by the time that the + // push is initiated, install a hook to manipulate the clock. + if timeoutBeforePush { + w.onPushTimer = func() { + manual.Increment(req.LockTimeout.Nanoseconds()) + } + } + + // waitElsewhere does not cause a push if the lock is not held. + // It returns immediately. + if !lockHeld && k == waitElsewhere { + err := w.WaitOn(ctx, req, g) + require.Nil(t, err) + return + } + + // If the lock is not held and the request hits its lock timeout + // before a deadlock push, an error is returned immediately. + if !lockHeld && timeoutBeforePush { + err := w.WaitOn(ctx, req, g) + require.NotNil(t, err) + wiErr := new(roachpb.WriteIntentError) + require.True(t, errors.As(err.GoError(), &wiErr)) + require.Equal(t, reasonLockTimeout, wiErr.Reason) + return + } + + expBlockingPush := !timeoutBeforePush + sawBlockingPush := false + sawNonBlockingPush := false + ir.pushTxn = func( + ctx context.Context, + pusheeArg *enginepb.TxnMeta, + h roachpb.Header, + pushType roachpb.PushTxnType, + ) (*roachpb.Transaction, *Error) { + require.Equal(t, &pusheeTxn.TxnMeta, pusheeArg) + require.Equal(t, req.Txn, h.Txn) + + if expBlockingPush { + require.Equal(t, roachpb.PUSH_ABORT, pushType) + _, hasDeadline := ctx.Deadline() + require.True(t, hasDeadline) + sawBlockingPush = true + expBlockingPush = false + + // Wait for the context to hit its timeout. + <-ctx.Done() + return nil, roachpb.NewError(ctx.Err()) + } + + require.Equal(t, roachpb.PUSH_TOUCH, pushType) + _, hasDeadline := ctx.Deadline() + require.False(t, hasDeadline) + sawNonBlockingPush = true + + resp := &roachpb.Transaction{TxnMeta: *pusheeArg, Status: roachpb.PENDING} + if pusheeActive { + return nil, roachpb.NewError(&roachpb.TransactionPushError{ + PusheeTxn: *resp, + }) + } + + // Next, we'll try to resolve the lock now that we know the + // holder is ABORTED. + w.lt.(*mockLockTable).txnFinalizedFn = func(txn *roachpb.Transaction) { + require.Equal(t, pusheeTxn.ID, txn.ID) + require.Equal(t, roachpb.ABORTED, txn.Status) + } + ir.resolveIntent = func(_ context.Context, intent roachpb.LockUpdate) *Error { + require.Equal(t, keyA, intent.Key) + require.Equal(t, pusheeTxn.ID, intent.Txn.ID) + require.Equal(t, roachpb.ABORTED, intent.Status) + g.state = waitingState{kind: doneWaiting} + g.notify() + return nil + } + resp.Status = roachpb.ABORTED + return resp, nil + } + + err := w.WaitOn(ctx, req, g) + if pusheeActive { + require.NotNil(t, err) + wiErr := new(roachpb.WriteIntentError) + require.True(t, errors.As(err.GoError(), &wiErr)) + require.Equal(t, reasonLockTimeout, wiErr.Reason) + } else { + require.Nil(t, err) + } + require.Equal(t, !timeoutBeforePush, sawBlockingPush) + require.Equal(t, lockHeld, sawNonBlockingPush) + }) + }) + }) +} + // TestLockTableWaiterIntentResolverError tests that the lockTableWaiter // propagates errors from its intent resolver when it pushes transactions // or resolves their intents. @@ -562,7 +767,7 @@ func TestLockTableWaiterIntentResolverError(t *testing.T) { defer leaktest.AfterTest(t)() defer log.Scope(t).Close(t) ctx := context.Background() - w, ir, g := setupLockTableWaiterTest() + w, ir, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) err1 := roachpb.NewErrorf("error1") @@ -621,7 +826,7 @@ func TestLockTableWaiterDeferredIntentResolverError(t *testing.T) { defer leaktest.AfterTest(t)() defer log.Scope(t).Close(t) ctx := context.Background() - w, ir, g := setupLockTableWaiterTest() + w, ir, g, _ := setupLockTableWaiterTest() defer w.stopper.Stop(ctx) txn := makeTxnProto("request") diff --git a/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/lock_timeout b/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/lock_timeout new file mode 100644 index 000000000000..888946ddef1d --- /dev/null +++ b/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/lock_timeout @@ -0,0 +1,276 @@ +new-txn name=txn1 ts=10,1 epoch=0 +---- + +new-txn name=txn2 ts=11,1 epoch=0 +---- + +new-txn name=txn3 ts=11,1 epoch=0 +---- + +new-txn name=txnNoWait ts=12,1 epoch=0 +---- + +# ------------------------------------------------------------- +# Prep: Txn 1 acquire locks at key k and key k2 +# Txn 2 acquire locks at key k3 +# Txn 3 begins waiting in k2's wait-queue +# ------------------------------------------------------------- + +new-request name=req1 txn=txn1 ts=10,0 + put key=k value=v + put key=k2 value=v2 +---- + +sequence req=req1 +---- +[1] sequence req1: sequencing request +[1] sequence req1: acquiring latches +[1] sequence req1: scanning lock table for conflicting locks +[1] sequence req1: sequencing complete, returned guard + +on-lock-acquired req=req1 key=k +---- +[-] acquire lock: txn 00000001 @ k + +on-lock-acquired req=req1 key=k2 +---- +[-] acquire lock: txn 00000001 @ k2 + +finish req=req1 +---- +[-] finish req1: finishing request + +new-request name=req2 txn=txn2 ts=11,0 + put key=k3 value=v +---- + +sequence req=req2 +---- +[2] sequence req2: sequencing request +[2] sequence req2: acquiring latches +[2] sequence req2: scanning lock table for conflicting locks +[2] sequence req2: sequencing complete, returned guard + +on-lock-acquired req=req2 key=k3 +---- +[-] acquire lock: txn 00000002 @ k3 + +finish req=req2 +---- +[-] finish req2: finishing request + +new-request name=req3 txn=txn3 ts=11,0 + put key=k2 value=v + put key=k3 value=v +---- + +sequence req=req3 +---- +[3] sequence req3: sequencing request +[3] sequence req3: acquiring latches +[3] sequence req3: scanning lock table for conflicting locks +[3] sequence req3: waiting in lock wait-queues +[3] sequence req3: lock wait-queue event: wait for (distinguished) txn 00000001 holding lock @ key "k2" (queuedWriters: 1, queuedReaders: 0) +[3] sequence req3: pushing txn 00000001 to abort +[3] sequence req3: blocked on select in concurrency_test.(*cluster).PushTransaction + +debug-lock-table +---- +global: num=3 + lock: "k" + holder: txn: 00000001-0000-0000-0000-000000000000, ts: 10.000000000,0, info: unrepl epoch: 0, seqs: [0] + lock: "k2" + holder: txn: 00000001-0000-0000-0000-000000000000, ts: 10.000000000,0, info: unrepl epoch: 0, seqs: [0] + queued writers: + active: true req: 3, txn: 00000003-0000-0000-0000-000000000000 + distinguished req: 3 + lock: "k3" + holder: txn: 00000002-0000-0000-0000-000000000000, ts: 11.000000000,0, info: unrepl epoch: 0, seqs: [0] +local: num=0 + +# ------------------------------------------------------------- +# Read-only request with lock timeout hits lock. The request +# raises an error. +# ------------------------------------------------------------- + +new-request name=reqTimeout1 txn=txnNoWait ts=12,0 lock-timeout + get key=k +---- + +sequence req=reqTimeout1 +---- +[4] sequence reqTimeout1: sequencing request +[4] sequence reqTimeout1: acquiring latches +[4] sequence reqTimeout1: scanning lock table for conflicting locks +[4] sequence reqTimeout1: waiting in lock wait-queues +[4] sequence reqTimeout1: lock wait-queue event: wait for (distinguished) txn 00000001 holding lock @ key "k" (queuedWriters: 0, queuedReaders: 1) +[4] sequence reqTimeout1: pushing txn 00000001 to check if abandoned +[4] sequence reqTimeout1: pushee not abandoned +[4] sequence reqTimeout1: conflicted with 00000001-0000-0000-0000-000000000000 on "k" for 1.234s +[4] sequence reqTimeout1: sequencing complete, returned error: conflicting intents on "k" [reason=lock_timeout] + +# ------------------------------------------------------------- +# Read-only request with lock timeout hits abandoned lock. +# The request removes the abandoned unreplicated lock and proceeds. +# ------------------------------------------------------------- + +on-txn-updated txn=txn1 status=committed +---- +[-] update txn: committing txn1 +[3] sequence req3: resolving intent "k2" for txn 00000001 with COMMITTED status +[3] sequence req3: lock wait-queue event: wait for (distinguished) txn 00000002 holding lock @ key "k3" (queuedWriters: 1, queuedReaders: 0) +[3] sequence req3: conflicted with 00000001-0000-0000-0000-000000000000 on "k2" for 1.234s +[3] sequence req3: pushing txn 00000002 to abort +[3] sequence req3: blocked on select in concurrency_test.(*cluster).PushTransaction + +sequence req=reqTimeout1 +---- +[5] sequence reqTimeout1: sequencing request +[5] sequence reqTimeout1: acquiring latches +[5] sequence reqTimeout1: scanning lock table for conflicting locks +[5] sequence reqTimeout1: sequencing complete, returned guard + +finish req=reqTimeout1 +---- +[-] finish reqTimeout1: finishing request + +debug-lock-table +---- +global: num=2 + lock: "k2" + res: req: 3, txn: 00000003-0000-0000-0000-000000000000, ts: 11.000000000,0, seq: 0 + lock: "k3" + holder: txn: 00000002-0000-0000-0000-000000000000, ts: 11.000000000,0, info: unrepl epoch: 0, seqs: [0] + queued writers: + active: true req: 3, txn: 00000003-0000-0000-0000-000000000000 + distinguished req: 3 +local: num=0 + +# ------------------------------------------------------------- +# Read-write request with lock timeout hits reservation +# holder. The request immediately raises an error instead of +# waiting for the reservation holder. +# ------------------------------------------------------------- + +new-request name=reqTimeout2 txn=txnNoWait ts=12,0 lock-timeout + put key=k2 value=v4 +---- + +sequence req=reqTimeout2 +---- +[6] sequence reqTimeout2: sequencing request +[6] sequence reqTimeout2: acquiring latches +[6] sequence reqTimeout2: scanning lock table for conflicting locks +[6] sequence reqTimeout2: waiting in lock wait-queues +[6] sequence reqTimeout2: lock wait-queue event: wait for (distinguished) txn 00000003 running request @ key "k2" (queuedWriters: 1, queuedReaders: 0) +[6] sequence reqTimeout2: conflicted with 00000003-0000-0000-0000-000000000000 on "k2" for 1.234s +[6] sequence reqTimeout2: sequencing complete, returned error: conflicting intents on "k2" [reason=lock_timeout] + +# ------------------------------------------------------------- +# Read-only request with lock timeout discovers lock. The +# request raises an error. +# ------------------------------------------------------------- + +new-request name=reqTimeout3 txn=txnNoWait ts=12,0 lock-timeout + get key=k4 +---- + +sequence req=reqTimeout3 +---- +[7] sequence reqTimeout3: sequencing request +[7] sequence reqTimeout3: acquiring latches +[7] sequence reqTimeout3: scanning lock table for conflicting locks +[7] sequence reqTimeout3: sequencing complete, returned guard + +handle-write-intent-error req=reqTimeout3 lease-seq=1 + intent txn=txn2 key=k4 +---- +[8] handle write intent error reqTimeout3: handled conflicting intents on "k4", released latches + +sequence req=reqTimeout3 +---- +[9] sequence reqTimeout3: re-sequencing request +[9] sequence reqTimeout3: acquiring latches +[9] sequence reqTimeout3: scanning lock table for conflicting locks +[9] sequence reqTimeout3: waiting in lock wait-queues +[9] sequence reqTimeout3: lock wait-queue event: wait for (distinguished) txn 00000002 holding lock @ key "k4" (queuedWriters: 0, queuedReaders: 1) +[9] sequence reqTimeout3: pushing txn 00000002 to check if abandoned +[9] sequence reqTimeout3: pushee not abandoned +[9] sequence reqTimeout3: conflicted with 00000002-0000-0000-0000-000000000000 on "k4" for 1.234s +[9] sequence reqTimeout3: sequencing complete, returned error: conflicting intents on "k4" [reason=lock_timeout] + +debug-lock-table +---- +global: num=3 + lock: "k2" + res: req: 3, txn: 00000003-0000-0000-0000-000000000000, ts: 11.000000000,0, seq: 0 + lock: "k3" + holder: txn: 00000002-0000-0000-0000-000000000000, ts: 11.000000000,0, info: unrepl epoch: 0, seqs: [0] + queued writers: + active: true req: 3, txn: 00000003-0000-0000-0000-000000000000 + distinguished req: 3 + lock: "k4" + holder: txn: 00000002-0000-0000-0000-000000000000, ts: 11.000000000,1, info: repl epoch: 0, seqs: [0] +local: num=0 + +# ------------------------------------------------------------- +# Read-only request with lock timeout discovers abandoned +# lock. The request resolves the abandoned lock and proceeds. +# ------------------------------------------------------------- + +on-txn-updated txn=txn2 status=aborted +---- +[-] update txn: aborting txn2 +[3] sequence req3: resolving intent "k3" for txn 00000002 with ABORTED status +[3] sequence req3: lock wait-queue event: done waiting +[3] sequence req3: conflicted with 00000002-0000-0000-0000-000000000000 on "k3" for 1.234s +[3] sequence req3: acquiring latches +[3] sequence req3: scanning lock table for conflicting locks +[3] sequence req3: sequencing complete, returned guard + +new-request name=reqTimeout4 txn=txnNoWait ts=12,0 lock-timeout + get key=k5 +---- + +sequence req=reqTimeout4 +---- +[10] sequence reqTimeout4: sequencing request +[10] sequence reqTimeout4: acquiring latches +[10] sequence reqTimeout4: scanning lock table for conflicting locks +[10] sequence reqTimeout4: sequencing complete, returned guard + +handle-write-intent-error req=reqTimeout4 lease-seq=1 + intent txn=txn2 key=k5 +---- +[11] handle write intent error reqTimeout4: handled conflicting intents on "k5", released latches + +sequence req=reqTimeout4 +---- +[12] sequence reqTimeout4: re-sequencing request +[12] sequence reqTimeout4: acquiring latches +[12] sequence reqTimeout4: scanning lock table for conflicting locks +[12] sequence reqTimeout4: waiting in lock wait-queues +[12] sequence reqTimeout4: lock wait-queue event: done waiting +[12] sequence reqTimeout4: resolving a batch of 1 intent(s) +[12] sequence reqTimeout4: resolving intent "k5" for txn 00000002 with ABORTED status +[12] sequence reqTimeout4: acquiring latches +[12] sequence reqTimeout4: scanning lock table for conflicting locks +[12] sequence reqTimeout4: sequencing complete, returned guard + +finish req=reqTimeout4 +---- +[-] finish reqTimeout4: finishing request + +finish req=req3 +---- +[-] finish req3: finishing request + +debug-lock-table +---- +global: num=1 + lock: "k4" + holder: txn: 00000002-0000-0000-0000-000000000000, ts: 11.000000000,1, info: repl [holder finalized: aborted] epoch: 0, seqs: [0] +local: num=0 + +reset +---- diff --git a/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/queue_length_exceeded b/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/queue_length_exceeded index b96e91fa76aa..bcbaeec7a717 100644 --- a/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/queue_length_exceeded +++ b/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/queue_length_exceeded @@ -185,7 +185,7 @@ sequence req=req5w [6] sequence req5w: scanning lock table for conflicting locks [6] sequence req5w: waiting in lock wait-queues [6] sequence req5w: lock wait-queue event: wait-queue maximum length exceeded @ key "k" with length 2 -[6] sequence req5w: sequencing complete, returned error: conflicting intents on "k" +[6] sequence req5w: sequencing complete, returned error: conflicting intents on "k" [reason=lock_wait_queue_max_length_exceeded] # ------------------------------------------------------------- # Cleanup. diff --git a/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/wait_policy_error b/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/wait_policy_error index 8d0d6d5da985..c065bae84137 100644 --- a/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/wait_policy_error +++ b/pkg/kv/kvserver/concurrency/testdata/concurrency_manager/wait_policy_error @@ -107,7 +107,7 @@ sequence req=reqNoWait1 [4] sequence reqNoWait1: pushing txn 00000001 to check if abandoned [4] sequence reqNoWait1: pushee not abandoned [4] sequence reqNoWait1: conflicted with 00000001-0000-0000-0000-000000000000 on "k" for 1.234s -[4] sequence reqNoWait1: sequencing complete, returned error: conflicting intents on "k" +[4] sequence reqNoWait1: sequencing complete, returned error: conflicting intents on "k" [reason=wait_policy] # ------------------------------------------------------------- # Read-only request with WaitPolicy_Error hits abandoned lock. @@ -164,7 +164,7 @@ sequence req=reqNoWait2 [6] sequence reqNoWait2: waiting in lock wait-queues [6] sequence reqNoWait2: lock wait-queue event: wait for (distinguished) txn 00000003 running request @ key "k2" (queuedWriters: 1, queuedReaders: 0) [6] sequence reqNoWait2: conflicted with 00000003-0000-0000-0000-000000000000 on "k2" for 1.234s -[6] sequence reqNoWait2: sequencing complete, returned error: conflicting intents on "k2" +[6] sequence reqNoWait2: sequencing complete, returned error: conflicting intents on "k2" [reason=wait_policy] # ------------------------------------------------------------- # Read-only request with WaitPolicy_Error discovers lock. The @@ -197,7 +197,7 @@ sequence req=reqNoWait3 [9] sequence reqNoWait3: pushing txn 00000002 to check if abandoned [9] sequence reqNoWait3: pushee not abandoned [9] sequence reqNoWait3: conflicted with 00000002-0000-0000-0000-000000000000 on "k4" for 1.234s -[9] sequence reqNoWait3: sequencing complete, returned error: conflicting intents on "k4" +[9] sequence reqNoWait3: sequencing complete, returned error: conflicting intents on "k4" [reason=wait_policy] debug-lock-table ---- diff --git a/pkg/kv/kvserver/replica_send.go b/pkg/kv/kvserver/replica_send.go index 6313e8cabb73..2401ac3bb6b9 100644 --- a/pkg/kv/kvserver/replica_send.go +++ b/pkg/kv/kvserver/replica_send.go @@ -360,6 +360,7 @@ func (r *Replica) executeBatchWithConcurrencyRetries( Priority: ba.UserPriority, ReadConsistency: ba.ReadConsistency, WaitPolicy: ba.WaitPolicy, + LockTimeout: ba.LockTimeout, Requests: ba.Requests, LatchSpans: latchSpans, // nil if g != nil LockSpans: lockSpans, // nil if g != nil diff --git a/pkg/kv/kvserver/testing_knobs.go b/pkg/kv/kvserver/testing_knobs.go index 6171410dae64..cc5674ab477d 100644 --- a/pkg/kv/kvserver/testing_knobs.go +++ b/pkg/kv/kvserver/testing_knobs.go @@ -227,6 +227,8 @@ type StoreTestingKnobs struct { // DontPushOnWriteIntentError will propagate a write intent error immediately // instead of utilizing the intent resolver to try to push the corresponding // transaction. + // TODO(nvanbenschoten): can we replace this knob with usage of the Error + // WaitPolicy on BatchRequests? DontPushOnWriteIntentError bool // DontRetryPushTxnFailures will propagate a push txn failure immediately // instead of utilizing the txn wait queue to wait for the transaction to diff --git a/pkg/roachpb/api.pb.go b/pkg/roachpb/api.pb.go index 694eb69ef45e..2de23858c21a 100644 --- a/pkg/roachpb/api.pb.go +++ b/pkg/roachpb/api.pb.go @@ -6333,6 +6333,26 @@ type Header struct { // If the desired behavior is to block on the conflicting lock up to some // maximum duration, use the Block wait policy and set a context timeout. WaitPolicy lock.WaitPolicy `protobuf:"varint,18,opt,name=wait_policy,json=waitPolicy,proto3,enum=cockroach.kv.kvserver.concurrency.lock.WaitPolicy" json:"wait_policy,omitempty"` + // lock_timeout specifies the maximum amount of time that the batch request + // will wait while attempting to acquire a lock on a key or while blocking on + // an existing lock in order to perform a non-locking read on a key. The time + // limit applies separately to each lock acquisition attempt. If the timeout + // elapses when waiting for a lock, a WriteIntentError will be returned. + // + // Unlike in some other systems like PostgreSQL, where non-locking reads do + // not wait on conflicting locks, in CockroachDB, non-locking reads do wait + // for conflicting locks to be released. Because of this, the lock_timeout + // configuration applies to non-locking reads in read-write and read-only + // transactions as well. + // + // Only the (default) Block wait policy will allow a request to wait on + // conflicting locks, so the timeout only makes sense in conjunction with the + // Block wait policy. The Error wait policy will throw an error immediately if + // a conflicting lock held by an active transaction is encountered, so this + // timeout can never be hit with an Error wait policy. + // + // A value of zero disables the timeout. + LockTimeout time.Duration `protobuf:"bytes,21,opt,name=lock_timeout,json=lockTimeout,proto3,stdduration" json:"lock_timeout"` // If set to a non-zero value, the total number of keys touched by requests in // the batch is limited. A resume span will be provided on the response of the // requests that were not able to run to completion before the limit was @@ -7494,551 +7514,553 @@ func init() { func init() { proto.RegisterFile("roachpb/api.proto", fileDescriptor_e08772acc330f58b) } var fileDescriptor_e08772acc330f58b = []byte{ - // 8701 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7d, 0x5d, 0x6c, 0x24, 0x59, - 0x96, 0x96, 0x23, 0x33, 0x6d, 0x67, 0x9e, 0x74, 0x66, 0x86, 0xaf, 0xeb, 0xc7, 0xed, 0xea, 0xb6, - 0xab, 0xa2, 0xba, 0x7e, 0x77, 0x3a, 0xdd, 0x55, 0x35, 0xc3, 0xf4, 0x76, 0xf7, 0xf4, 0xac, 0x33, - 0x9d, 0x55, 0x99, 0xfe, 0x2b, 0x57, 0x64, 0xba, 0x4a, 0xdd, 0x3b, 0x4b, 0x6c, 0x38, 0xe2, 0xda, - 0x8e, 0x71, 0x66, 0x44, 0x56, 0x44, 0xa4, 0xcb, 0x6e, 0x89, 0x07, 0x60, 0x35, 0xf4, 0x13, 0x1a, - 0x24, 0xa4, 0xed, 0xd1, 0x22, 0x34, 0xfb, 0x23, 0x78, 0xe0, 0x01, 0x04, 0x08, 0xb4, 0x08, 0x58, - 0x89, 0x17, 0x46, 0x68, 0xc4, 0xcc, 0xbe, 0xad, 0x90, 0x30, 0x8b, 0x87, 0x07, 0x56, 0x08, 0x81, - 0x00, 0x69, 0x51, 0x4b, 0x20, 0x74, 0x7f, 0xe2, 0x2f, 0x33, 0x32, 0x9d, 0xae, 0x8e, 0x66, 0x5b, - 0xda, 0x17, 0x3b, 0xe3, 0xdc, 0x7b, 0x4e, 0xdc, 0x7b, 0xee, 0xdf, 0xf9, 0xee, 0x3d, 0xe7, 0x06, - 0xcc, 0xda, 0x96, 0xaa, 0x1d, 0x74, 0x77, 0x97, 0xd5, 0xae, 0x51, 0xee, 0xda, 0x96, 0x6b, 0xa1, - 0x59, 0xcd, 0xd2, 0x0e, 0x29, 0xb9, 0xcc, 0x13, 0x17, 0x2e, 0x63, 0xdb, 0xb6, 0x6c, 0xa7, 0xbb, - 0xbb, 0xcc, 0x7e, 0xb0, 0x9c, 0x0b, 0xf7, 0x0f, 0x8f, 0x96, 0x0f, 0x8f, 0x1c, 0x6c, 0x1f, 0x61, - 0x7b, 0x59, 0xb3, 0x4c, 0xad, 0x67, 0xdb, 0xd8, 0xd4, 0x4e, 0x96, 0xdb, 0x96, 0x76, 0x48, 0xff, - 0x18, 0xe6, 0x7e, 0x5c, 0x5e, 0x1b, 0xab, 0xba, 0xd3, 0xeb, 0x74, 0x54, 0xfb, 0x64, 0x99, 0x8a, - 0xe5, 0x0f, 0x3c, 0x2f, 0xf2, 0x0a, 0xa5, 0xab, 0xae, 0xca, 0x69, 0x97, 0x3c, 0x5a, 0xa4, 0x04, - 0x57, 0x3c, 0x6a, 0x07, 0xbb, 0x6a, 0x28, 0xf7, 0x35, 0xc7, 0xb5, 0x6c, 0x75, 0x1f, 0x2f, 0x63, - 0x73, 0xdf, 0x30, 0x31, 0xc9, 0x70, 0xa4, 0x69, 0x3c, 0xf1, 0xcd, 0xd8, 0xc4, 0x47, 0x3c, 0x75, - 0xbe, 0xe7, 0x1a, 0xed, 0xe5, 0x83, 0xb6, 0xb6, 0xec, 0x1a, 0x1d, 0xec, 0xb8, 0x6a, 0xa7, 0xeb, - 0x55, 0x81, 0xa6, 0xb8, 0xb6, 0xaa, 0x19, 0xe6, 0xbe, 0xf7, 0xbf, 0xbb, 0xbb, 0x6c, 0x63, 0xcd, - 0xb2, 0x75, 0xac, 0x2b, 0x4e, 0x57, 0x35, 0xbd, 0xe2, 0xee, 0x5b, 0xfb, 0x16, 0xfd, 0xb9, 0x4c, - 0x7e, 0x71, 0xea, 0xe2, 0xbe, 0x65, 0xed, 0xb7, 0xf1, 0x32, 0x7d, 0xda, 0xed, 0xed, 0x2d, 0xeb, - 0x3d, 0x5b, 0x75, 0x0d, 0x8b, 0x73, 0x49, 0xff, 0x44, 0x80, 0x82, 0x8c, 0x5f, 0xf6, 0xb0, 0xe3, - 0xd6, 0xb1, 0xaa, 0x63, 0x1b, 0xbd, 0x01, 0xe9, 0x43, 0x7c, 0x32, 0x9f, 0xbe, 0x2e, 0xdc, 0x9d, - 0xa9, 0x4c, 0x7f, 0x71, 0xba, 0x94, 0x5e, 0xc7, 0x27, 0x32, 0xa1, 0xa1, 0xeb, 0x30, 0x8d, 0x4d, - 0x5d, 0x21, 0xc9, 0x99, 0x68, 0xf2, 0x14, 0x36, 0xf5, 0x75, 0x7c, 0x82, 0xbe, 0x07, 0x59, 0x87, - 0x48, 0x33, 0x35, 0x3c, 0x3f, 0x79, 0x5d, 0xb8, 0x3b, 0x59, 0xf9, 0x95, 0x2f, 0x4e, 0x97, 0x3e, - 0xdc, 0x37, 0xdc, 0x83, 0xde, 0x6e, 0x59, 0xb3, 0x3a, 0xcb, 0x7e, 0x53, 0xeb, 0xbb, 0xc1, 0xef, - 0xe5, 0xee, 0xe1, 0xfe, 0x72, 0xbf, 0x8e, 0xca, 0xad, 0x63, 0xb3, 0x89, 0x5f, 0xca, 0xbe, 0xc4, - 0xb5, 0x4c, 0x56, 0x10, 0x53, 0x6b, 0x99, 0x6c, 0x4a, 0x4c, 0x4b, 0x3f, 0x4b, 0x41, 0x51, 0xc6, - 0x4e, 0xd7, 0x32, 0x1d, 0xcc, 0x4b, 0xfe, 0x2e, 0xa4, 0xdd, 0x63, 0x93, 0x96, 0x3c, 0xff, 0x70, - 0xb1, 0x3c, 0xd0, 0xa9, 0xca, 0x2d, 0x5b, 0x35, 0x1d, 0x55, 0x23, 0xd5, 0x97, 0x49, 0x56, 0xf4, - 0x1e, 0xe4, 0x6d, 0xec, 0xf4, 0x3a, 0x98, 0x2a, 0x92, 0x56, 0x2a, 0xff, 0xf0, 0x6a, 0x0c, 0x67, - 0xb3, 0xab, 0x9a, 0x32, 0xb0, 0xbc, 0xe4, 0x37, 0x6a, 0x42, 0x81, 0x73, 0xda, 0x58, 0x75, 0x2c, - 0x73, 0x7e, 0xfa, 0xba, 0x70, 0xb7, 0xf8, 0xb0, 0x1c, 0xc3, 0x1b, 0x2d, 0x25, 0x79, 0xec, 0x75, - 0xb0, 0x4c, 0xb9, 0xe4, 0x19, 0x3b, 0xf4, 0x84, 0xde, 0x80, 0xac, 0xd9, 0xeb, 0x10, 0xfd, 0x3a, - 0x54, 0x7b, 0x69, 0x79, 0xda, 0xec, 0x75, 0xd6, 0xf1, 0x89, 0x83, 0xae, 0x41, 0x8e, 0x24, 0xed, - 0x9e, 0xb8, 0xd8, 0x99, 0xcf, 0xd2, 0x34, 0x92, 0xb7, 0x42, 0x9e, 0xa5, 0x8f, 0x60, 0x26, 0x2c, - 0x15, 0x21, 0x28, 0xca, 0xb5, 0xe6, 0xce, 0x66, 0x4d, 0xd9, 0xd9, 0x5a, 0xdf, 0x7a, 0xfa, 0x62, - 0x4b, 0x9c, 0x40, 0x97, 0x40, 0xe4, 0xb4, 0xf5, 0xda, 0xc7, 0xca, 0x46, 0x63, 0xb3, 0xd1, 0x12, - 0x85, 0x85, 0xcc, 0x67, 0xbf, 0xbb, 0x38, 0xb1, 0x96, 0xc9, 0x4e, 0x89, 0xd3, 0xd2, 0xef, 0x0a, - 0x00, 0x4f, 0xb0, 0xcb, 0x7b, 0x03, 0xaa, 0xc0, 0xd4, 0x01, 0x2d, 0xf1, 0xbc, 0x40, 0xd5, 0x72, - 0x3d, 0xb6, 0x6a, 0xa1, 0x9e, 0x53, 0xc9, 0xfe, 0xe4, 0x74, 0x69, 0xe2, 0xe7, 0xa7, 0x4b, 0x82, - 0xcc, 0x39, 0xd1, 0x33, 0xc8, 0x1f, 0xe2, 0x13, 0x85, 0x8f, 0xcb, 0xf9, 0x14, 0xd5, 0xd1, 0xbb, - 0x21, 0x41, 0x87, 0x47, 0x65, 0x6f, 0x88, 0x96, 0x43, 0xc3, 0xb9, 0x4c, 0x38, 0xca, 0x4d, 0xd7, - 0xc6, 0xe6, 0xbe, 0x7b, 0x20, 0xc3, 0x21, 0x3e, 0xd9, 0x60, 0x32, 0xa4, 0x3f, 0x10, 0x20, 0x4f, - 0x4b, 0xc9, 0x94, 0x8a, 0xaa, 0x7d, 0xc5, 0xbc, 0x71, 0x6e, 0x0b, 0xc4, 0x94, 0xb3, 0x0c, 0x93, - 0x47, 0x6a, 0xbb, 0x87, 0x69, 0x09, 0xf3, 0x0f, 0xe7, 0x63, 0x64, 0x3c, 0x27, 0xe9, 0x32, 0xcb, - 0x86, 0x3e, 0x80, 0x19, 0xc3, 0x74, 0xb1, 0xe9, 0x2a, 0x8c, 0x2d, 0x7d, 0x0e, 0x5b, 0x9e, 0xe5, - 0xa6, 0x0f, 0xd2, 0x3f, 0x16, 0x00, 0xb6, 0x7b, 0x89, 0xea, 0xf9, 0x9b, 0x63, 0x96, 0xbf, 0x92, - 0x21, 0xac, 0x5e, 0x2d, 0xae, 0xc0, 0x94, 0x61, 0xb6, 0x0d, 0x93, 0x95, 0x3f, 0x2b, 0xf3, 0x27, - 0x74, 0x09, 0x26, 0x77, 0xdb, 0x86, 0xa9, 0xd3, 0xf1, 0x90, 0x95, 0xd9, 0x83, 0x24, 0x43, 0x9e, - 0x96, 0x3a, 0x41, 0xbd, 0x4b, 0xa7, 0x29, 0xb8, 0x5c, 0xb5, 0x4c, 0xdd, 0x20, 0x43, 0x52, 0x6d, - 0x7f, 0x2d, 0xb4, 0xb2, 0x06, 0x97, 0x74, 0xdc, 0xb5, 0xb1, 0xa6, 0xba, 0x58, 0x57, 0xf0, 0x71, - 0x77, 0xcc, 0x36, 0x46, 0x01, 0x57, 0xed, 0xb8, 0x4b, 0x69, 0x64, 0xd4, 0x12, 0x01, 0x6c, 0xd4, - 0x4e, 0x91, 0x29, 0x53, 0xce, 0xe2, 0xe3, 0x2e, 0x1d, 0xb5, 0xf1, 0x6a, 0x46, 0xdf, 0x84, 0xab, - 0x6a, 0xbb, 0x6d, 0xbd, 0x52, 0x8c, 0x3d, 0x45, 0xb7, 0xb0, 0xa3, 0x98, 0x96, 0xab, 0xe0, 0x63, - 0xc3, 0x71, 0xe9, 0x94, 0x90, 0x95, 0xe7, 0x68, 0x72, 0x63, 0x6f, 0xd5, 0xc2, 0xce, 0x96, 0xe5, - 0xd6, 0x48, 0x52, 0xa8, 0x29, 0xa7, 0xc3, 0x4d, 0x29, 0xfd, 0x1a, 0x5c, 0xe9, 0xd7, 0x6f, 0x92, - 0xed, 0xf7, 0x53, 0x01, 0x8a, 0x0d, 0xd3, 0x70, 0xbf, 0x16, 0x0d, 0xe7, 0xeb, 0x33, 0x1d, 0xd6, - 0xe7, 0x7d, 0x10, 0xf7, 0x54, 0xa3, 0xfd, 0xd4, 0x6c, 0x59, 0x9d, 0x5d, 0xc7, 0xb5, 0x4c, 0xec, - 0x70, 0x85, 0x0f, 0xd0, 0xa5, 0xe7, 0x50, 0xf2, 0x6b, 0x93, 0xa4, 0x9a, 0x5c, 0x10, 0x1b, 0xa6, - 0x66, 0xe3, 0x0e, 0x36, 0x13, 0xd5, 0xd3, 0x9b, 0x90, 0x33, 0x3c, 0xb9, 0x54, 0x57, 0x69, 0x39, - 0x20, 0x48, 0x3d, 0x98, 0x0d, 0xbd, 0x35, 0xc9, 0xe9, 0x92, 0x2c, 0x46, 0xf8, 0x95, 0x12, 0xb4, - 0x11, 0x59, 0x8c, 0xf0, 0x2b, 0x36, 0xbd, 0x35, 0xa1, 0xb0, 0x8a, 0xdb, 0xd8, 0xc5, 0x09, 0xd6, - 0x54, 0xda, 0x81, 0xa2, 0x27, 0x34, 0xc9, 0x86, 0xf9, 0x4d, 0x01, 0x10, 0x97, 0xab, 0x9a, 0xfb, - 0x49, 0x96, 0x18, 0x2d, 0x11, 0xd3, 0xc2, 0xed, 0xd9, 0x26, 0x5b, 0xce, 0x59, 0x9f, 0x04, 0x46, - 0xa2, 0x2b, 0x7a, 0x30, 0x64, 0x33, 0xe1, 0x21, 0xcb, 0xcd, 0x9b, 0x57, 0x30, 0x17, 0x29, 0x58, - 0xb2, 0xcd, 0x97, 0xa1, 0x65, 0x4a, 0x5d, 0x4f, 0x87, 0x6d, 0x38, 0x4a, 0x94, 0x3e, 0x17, 0x60, - 0xb6, 0xda, 0xc6, 0xaa, 0x9d, 0xb8, 0x46, 0xbe, 0x0b, 0x59, 0x1d, 0xab, 0x3a, 0xad, 0x32, 0x1b, - 0xd8, 0x6f, 0x85, 0xa4, 0x10, 0x4b, 0xb7, 0x7c, 0xd0, 0xd6, 0xca, 0x2d, 0xcf, 0x06, 0xe6, 0xa3, - 0xdb, 0x67, 0x92, 0x3e, 0x06, 0x14, 0x2e, 0x59, 0x92, 0x1d, 0xe1, 0xf7, 0x52, 0x80, 0x64, 0x7c, - 0x84, 0x6d, 0x37, 0xf1, 0x6a, 0xaf, 0x42, 0xde, 0x55, 0xed, 0x7d, 0xec, 0x2a, 0xc4, 0xba, 0xbf, - 0x48, 0xcd, 0x81, 0xf1, 0x11, 0x32, 0x6a, 0xc1, 0x1d, 0x6c, 0xaa, 0xbb, 0x6d, 0x4c, 0xa5, 0x28, - 0xbb, 0x56, 0xcf, 0xd4, 0x15, 0xc3, 0xc5, 0xb6, 0xea, 0x5a, 0xb6, 0x62, 0x75, 0x5d, 0xa3, 0x63, - 0x7c, 0x4a, 0x0d, 0x7b, 0xde, 0xd5, 0x6e, 0xb2, 0xec, 0x84, 0xb9, 0x42, 0x32, 0x37, 0x78, 0xde, - 0xa7, 0xa1, 0xac, 0xa8, 0x0c, 0x73, 0xc6, 0xbe, 0x69, 0xd9, 0x58, 0xd9, 0xd7, 0x14, 0xf7, 0xc0, - 0xc6, 0xce, 0x81, 0xd5, 0xf6, 0x16, 0xa4, 0x59, 0x96, 0xf4, 0x44, 0x6b, 0x79, 0x09, 0xd2, 0x27, - 0x30, 0x17, 0xd1, 0x52, 0x92, 0x4d, 0xf0, 0xdf, 0x05, 0xc8, 0x37, 0x35, 0xd5, 0x4c, 0x52, 0xf7, - 0x1f, 0x41, 0xde, 0xd1, 0x54, 0x53, 0xd9, 0xb3, 0xec, 0x8e, 0xea, 0xd2, 0x7a, 0x15, 0x23, 0xba, - 0xf7, 0xed, 0x7b, 0x4d, 0x35, 0x1f, 0xd3, 0x4c, 0x32, 0x38, 0xfe, 0xef, 0x7e, 0xfb, 0x75, 0xf2, - 0xcb, 0xdb, 0xaf, 0x6c, 0x78, 0xaf, 0x65, 0xb2, 0x69, 0x31, 0x23, 0xfd, 0xa9, 0x00, 0x33, 0xac, - 0xca, 0x49, 0x0e, 0xef, 0x6f, 0x41, 0xc6, 0xb6, 0x5e, 0xb1, 0xe1, 0x9d, 0x7f, 0x78, 0x2d, 0x46, - 0xc4, 0x3a, 0x3e, 0x09, 0xaf, 0x9f, 0x34, 0x3b, 0xaa, 0x00, 0xb7, 0x52, 0x15, 0xca, 0x9d, 0x1e, - 0x97, 0x1b, 0x18, 0x97, 0x4c, 0x64, 0xdc, 0x81, 0xd2, 0xae, 0xea, 0x6a, 0x07, 0x8a, 0xcd, 0x0b, - 0x49, 0xd6, 0xda, 0xf4, 0xdd, 0x19, 0xb9, 0x48, 0xc9, 0x5e, 0xd1, 0x1d, 0x52, 0x73, 0x36, 0xde, - 0x1c, 0xfc, 0xe7, 0xac, 0xcd, 0xff, 0xaf, 0xc0, 0xc7, 0x90, 0x57, 0xf3, 0x3f, 0x6f, 0x4d, 0xff, - 0xa3, 0x14, 0x5c, 0xad, 0x1e, 0x60, 0xed, 0xb0, 0x6a, 0x99, 0x8e, 0xe1, 0xb8, 0x44, 0x77, 0x49, - 0xb6, 0xff, 0x35, 0xc8, 0xbd, 0x32, 0xdc, 0x03, 0x45, 0x37, 0xf6, 0xf6, 0xe8, 0x6c, 0x9b, 0x95, - 0xb3, 0x84, 0xb0, 0x6a, 0xec, 0xed, 0xa1, 0x47, 0x90, 0xe9, 0x58, 0x3a, 0x33, 0xe6, 0x8b, 0x0f, - 0x97, 0x62, 0xc4, 0xd3, 0xa2, 0x39, 0xbd, 0xce, 0xa6, 0xa5, 0x63, 0x99, 0x66, 0x46, 0x8b, 0x00, - 0x1a, 0xa1, 0x76, 0x2d, 0xc3, 0x74, 0xf9, 0xe4, 0x18, 0xa2, 0xa0, 0x3a, 0xe4, 0x5c, 0x6c, 0x77, - 0x0c, 0x53, 0x75, 0xf1, 0xfc, 0x24, 0x55, 0xde, 0xdb, 0xb1, 0x05, 0xef, 0xb6, 0x0d, 0x4d, 0x5d, - 0xc5, 0x8e, 0x66, 0x1b, 0x5d, 0xd7, 0xb2, 0xb9, 0x16, 0x03, 0x66, 0xe9, 0xaf, 0x67, 0x60, 0x7e, - 0x50, 0x37, 0x49, 0xf6, 0x90, 0x6d, 0x98, 0xb2, 0xb1, 0xd3, 0x6b, 0xbb, 0xbc, 0x8f, 0x3c, 0x1c, - 0xa6, 0x82, 0x98, 0x12, 0xd0, 0xad, 0x8b, 0xb6, 0xcb, 0x8b, 0xcd, 0xe5, 0x2c, 0xfc, 0x73, 0x01, - 0xa6, 0x58, 0x02, 0x7a, 0x00, 0x59, 0x9b, 0x2c, 0x0c, 0x8a, 0xa1, 0xd3, 0x32, 0xa6, 0x2b, 0x57, - 0xce, 0x4e, 0x97, 0xa6, 0xe9, 0x62, 0xd1, 0x58, 0xfd, 0x22, 0xf8, 0x29, 0x4f, 0xd3, 0x7c, 0x0d, - 0x9d, 0xb4, 0x96, 0xe3, 0xaa, 0xb6, 0x4b, 0x37, 0x95, 0x52, 0x0c, 0x21, 0x51, 0xc2, 0x3a, 0x3e, - 0x41, 0x6b, 0x30, 0xe5, 0xb8, 0xaa, 0xdb, 0x73, 0x78, 0x7b, 0x5d, 0xa8, 0xb0, 0x4d, 0xca, 0x29, - 0x73, 0x09, 0xc4, 0xdc, 0xd2, 0xb1, 0xab, 0x1a, 0x6d, 0xda, 0x80, 0x39, 0x99, 0x3f, 0x49, 0xbf, - 0x25, 0xc0, 0x14, 0xcb, 0x8a, 0xae, 0xc2, 0x9c, 0xbc, 0xb2, 0xf5, 0xa4, 0xa6, 0x34, 0xb6, 0x56, - 0x6b, 0xad, 0x9a, 0xbc, 0xd9, 0xd8, 0x5a, 0x69, 0xd5, 0xc4, 0x09, 0x74, 0x05, 0x90, 0x97, 0x50, - 0x7d, 0xba, 0xd5, 0x6c, 0x34, 0x5b, 0xb5, 0xad, 0x96, 0x28, 0xd0, 0x3d, 0x15, 0x4a, 0x0f, 0x51, - 0x53, 0xe8, 0x6d, 0xb8, 0xde, 0x4f, 0x55, 0x9a, 0xad, 0x95, 0x56, 0x53, 0xa9, 0x35, 0x5b, 0x8d, - 0xcd, 0x95, 0x56, 0x6d, 0x55, 0x4c, 0x8f, 0xc8, 0x45, 0x5e, 0x22, 0xcb, 0xb5, 0x6a, 0x4b, 0xcc, - 0x48, 0x2e, 0x5c, 0x96, 0xb1, 0x66, 0x75, 0xba, 0x3d, 0x17, 0x93, 0x52, 0x3a, 0x49, 0x8e, 0x94, - 0xab, 0x30, 0xad, 0xdb, 0x27, 0x8a, 0xdd, 0x33, 0xf9, 0x38, 0x99, 0xd2, 0xed, 0x13, 0xb9, 0x67, - 0x4a, 0xff, 0x40, 0x80, 0x2b, 0xfd, 0xaf, 0x4d, 0xb2, 0x13, 0x3e, 0x83, 0xbc, 0xaa, 0xeb, 0x58, - 0x57, 0x74, 0xdc, 0x76, 0x55, 0x6e, 0x12, 0xdd, 0x0f, 0x49, 0xe2, 0x5b, 0x81, 0x65, 0x7f, 0x2b, - 0x70, 0xf3, 0x79, 0xb5, 0x4a, 0x0b, 0xb2, 0x4a, 0x38, 0xbc, 0xe9, 0x87, 0x0a, 0xa1, 0x14, 0xe9, - 0x47, 0x19, 0x28, 0xd4, 0x4c, 0xbd, 0x75, 0x9c, 0xe8, 0x5a, 0x72, 0x05, 0xa6, 0x34, 0xab, 0xd3, - 0x31, 0x5c, 0x4f, 0x41, 0xec, 0x09, 0xfd, 0x72, 0xc8, 0x94, 0x4d, 0x8f, 0x61, 0xd0, 0x05, 0x46, - 0x2c, 0xfa, 0x75, 0xb8, 0x4a, 0x66, 0x4d, 0xdb, 0x54, 0xdb, 0x0a, 0x93, 0xa6, 0xb8, 0xb6, 0xb1, - 0xbf, 0x8f, 0x6d, 0xbe, 0xfd, 0x78, 0x37, 0xa6, 0x9c, 0x0d, 0xce, 0x51, 0xa5, 0x0c, 0x2d, 0x96, - 0x5f, 0xbe, 0x6c, 0xc4, 0x91, 0xd1, 0x87, 0x00, 0x64, 0x29, 0xa2, 0x5b, 0x9a, 0x0e, 0x9f, 0x8f, - 0x86, 0xed, 0x69, 0x7a, 0x53, 0x10, 0x61, 0x20, 0xcf, 0x0e, 0x7a, 0x06, 0xa2, 0x61, 0x2a, 0x7b, - 0x6d, 0x63, 0xff, 0xc0, 0x55, 0x5e, 0xd9, 0x86, 0x8b, 0x9d, 0xf9, 0x59, 0x2a, 0x23, 0xae, 0xa9, - 0x9b, 0x7c, 0x6b, 0x56, 0x7f, 0x41, 0x72, 0x72, 0x69, 0x45, 0xc3, 0x7c, 0x4c, 0xf9, 0x29, 0xd1, - 0x41, 0xcb, 0x04, 0x0a, 0xbd, 0xec, 0x19, 0x36, 0x56, 0x1e, 0x74, 0x35, 0xba, 0x0f, 0x92, 0xad, - 0x14, 0xcf, 0x4e, 0x97, 0x40, 0x66, 0xe4, 0x07, 0xdb, 0x55, 0x02, 0x8d, 0xd8, 0xef, 0xae, 0x46, - 0xd4, 0xde, 0xb5, 0x0c, 0xc7, 0x32, 0xe7, 0x73, 0x4c, 0xed, 0xec, 0x09, 0xdd, 0x03, 0xd1, 0x3d, - 0x36, 0x95, 0x03, 0xac, 0xda, 0xee, 0x2e, 0x56, 0x5d, 0xb2, 0x3e, 0x03, 0xcd, 0x51, 0x72, 0x8f, - 0xcd, 0x7a, 0x88, 0xbc, 0x96, 0xc9, 0x4e, 0x8b, 0xd9, 0xb5, 0x4c, 0x36, 0x2b, 0xe6, 0xa4, 0x7f, - 0x2f, 0x40, 0xd1, 0xeb, 0x1b, 0x49, 0x76, 0xe3, 0xbb, 0x20, 0x5a, 0x26, 0x56, 0xba, 0x07, 0xaa, - 0x83, 0x79, 0x5b, 0xf2, 0xd5, 0xa1, 0x68, 0x99, 0x78, 0x9b, 0x90, 0x59, 0xcb, 0xa0, 0x6d, 0x98, - 0x75, 0x5c, 0x75, 0xdf, 0x30, 0xf7, 0x15, 0x7f, 0x8b, 0x9f, 0x5a, 0x16, 0x63, 0x22, 0x01, 0x91, - 0x73, 0xfb, 0xf4, 0x88, 0x49, 0xf1, 0x87, 0x02, 0xcc, 0xae, 0xe8, 0x1d, 0xc3, 0x6c, 0x76, 0xdb, - 0x46, 0xa2, 0x1b, 0x0c, 0x6f, 0x43, 0xce, 0x21, 0x32, 0x83, 0xd9, 0x39, 0x80, 0x8b, 0x59, 0x9a, - 0x42, 0xa6, 0xe9, 0x0d, 0x28, 0xe1, 0xe3, 0xae, 0xc1, 0xce, 0x15, 0x18, 0xca, 0xc9, 0x8c, 0x5f, - 0xb7, 0x62, 0xc0, 0x4b, 0x92, 0x78, 0x9d, 0x3e, 0x06, 0x14, 0xae, 0x52, 0x92, 0x40, 0xe3, 0x63, - 0x98, 0xa3, 0xa2, 0x77, 0x4c, 0x27, 0x61, 0x7d, 0x49, 0xbf, 0x0a, 0x97, 0xa2, 0xa2, 0x93, 0x2c, - 0xf7, 0x0b, 0xde, 0xca, 0x9b, 0xd8, 0x4e, 0x14, 0xa1, 0xfa, 0xba, 0xe6, 0x82, 0x93, 0x2c, 0xf3, - 0x6f, 0x08, 0xf0, 0x06, 0x95, 0x4d, 0x8f, 0x5e, 0xf6, 0xb0, 0xbd, 0x81, 0x55, 0x27, 0x51, 0x78, - 0x7d, 0x13, 0xa6, 0x18, 0x4c, 0xa6, 0xfd, 0x73, 0xb2, 0x92, 0x27, 0x66, 0x46, 0xd3, 0xb5, 0x6c, - 0x62, 0x66, 0xf0, 0x24, 0x49, 0x85, 0x85, 0xb8, 0x52, 0x24, 0x59, 0xd3, 0xbf, 0x2d, 0xc0, 0x2c, - 0xb7, 0xf0, 0x48, 0x57, 0xae, 0x1e, 0x10, 0x03, 0x07, 0xd5, 0x20, 0xaf, 0xd1, 0x5f, 0x8a, 0x7b, - 0xd2, 0xc5, 0x54, 0x7e, 0x71, 0x94, 0x71, 0xc8, 0xd8, 0x5a, 0x27, 0x5d, 0x4c, 0x2c, 0x4c, 0xef, - 0x37, 0x51, 0x54, 0xa8, 0x92, 0x23, 0xcd, 0x4b, 0x3a, 0x8e, 0x68, 0x5e, 0xcf, 0x4e, 0xe3, 0x3a, - 0xf8, 0x47, 0x69, 0xae, 0x04, 0xf6, 0x0e, 0x9e, 0x3d, 0x51, 0x83, 0xe2, 0x13, 0xb8, 0x12, 0xda, - 0x3a, 0x0f, 0x57, 0x3c, 0x75, 0x81, 0x8a, 0x87, 0xb6, 0xdf, 0x03, 0x2a, 0xfa, 0x18, 0x42, 0x1b, - 0xec, 0x0a, 0xab, 0x93, 0x07, 0x55, 0x2e, 0xa2, 0x8e, 0xd9, 0x40, 0x0a, 0xa3, 0x3b, 0xa8, 0x0a, - 0x59, 0x7c, 0xdc, 0x55, 0x74, 0xec, 0x68, 0x7c, 0xe2, 0x92, 0xe2, 0x04, 0x92, 0xa2, 0x0c, 0x18, - 0xef, 0xd3, 0xf8, 0xb8, 0x4b, 0x88, 0x68, 0x87, 0xac, 0x9b, 0xde, 0xba, 0x4e, 0x8b, 0xed, 0x9c, - 0x8f, 0x05, 0x82, 0x9e, 0xc2, 0xc5, 0x95, 0xfc, 0x25, 0x9d, 0x89, 0x90, 0x7e, 0x2c, 0xc0, 0xb5, - 0xd8, 0x56, 0x4b, 0x72, 0x21, 0xfb, 0x10, 0x32, 0xb4, 0xf2, 0xa9, 0x0b, 0x56, 0x9e, 0x72, 0x49, - 0x9f, 0xa5, 0xf8, 0x18, 0x97, 0x71, 0xdb, 0x22, 0x8a, 0x4d, 0x7c, 0x0b, 0xed, 0x29, 0x14, 0x8e, - 0x2c, 0x17, 0xdb, 0x7e, 0xb3, 0xa7, 0x2e, 0xdc, 0xec, 0x33, 0x54, 0x80, 0xd7, 0xe2, 0xcf, 0x61, - 0xd6, 0xb4, 0x4c, 0x25, 0x2a, 0xf4, 0xe2, 0x7d, 0xa9, 0x64, 0x5a, 0xe6, 0xf3, 0x90, 0x5c, 0x7f, - 0x9e, 0xe9, 0xd3, 0x44, 0x92, 0xf3, 0xcc, 0x0f, 0x05, 0x98, 0xf3, 0x2d, 0x9d, 0x84, 0xcd, 0xdd, - 0x6f, 0x41, 0xda, 0xb4, 0x5e, 0x5d, 0x64, 0x8b, 0x92, 0xe4, 0x27, 0xab, 0x5e, 0xb4, 0x44, 0x49, - 0xd6, 0xf7, 0x5f, 0xa4, 0x20, 0xf7, 0xa4, 0x9a, 0x64, 0x2d, 0x3f, 0xe4, 0xdb, 0xdf, 0xac, 0xbd, - 0xe3, 0x7a, 0xbb, 0xff, 0xbe, 0xf2, 0x93, 0xea, 0x3a, 0x3e, 0xf1, 0x7a, 0x3b, 0xe1, 0x42, 0x2b, - 0x90, 0x8b, 0x6e, 0x94, 0x8e, 0xa9, 0xa9, 0x80, 0x6b, 0x01, 0xc3, 0x24, 0x95, 0xeb, 0xb9, 0x5a, - 0x08, 0x31, 0xae, 0x16, 0xe4, 0x35, 0xbe, 0xa5, 0x98, 0xba, 0xc8, 0x6b, 0x42, 0x26, 0xe2, 0xa4, - 0x38, 0x25, 0x3d, 0x03, 0x20, 0xd5, 0x49, 0xb2, 0x49, 0x7e, 0x90, 0x86, 0xe2, 0x76, 0xcf, 0x39, - 0x48, 0xb8, 0xf7, 0x55, 0x01, 0xba, 0x3d, 0xe7, 0x80, 0x8c, 0xc8, 0x63, 0x93, 0xd7, 0xf9, 0x1c, - 0x2f, 0x0e, 0xaf, 0xd2, 0x8c, 0xaf, 0x75, 0x6c, 0xa2, 0x3a, 0x17, 0x82, 0x95, 0xc0, 0x15, 0xe4, - 0xe6, 0x28, 0x64, 0xd9, 0x3a, 0x36, 0x37, 0xb1, 0x0f, 0x29, 0x99, 0x24, 0x4c, 0x24, 0x7d, 0x08, - 0xd3, 0xe4, 0x41, 0x71, 0xad, 0x8b, 0x34, 0xf3, 0x14, 0xe1, 0x69, 0x59, 0xe8, 0x03, 0xc8, 0x31, - 0x6e, 0xb2, 0xfa, 0x4d, 0xd1, 0xd5, 0x2f, 0xae, 0x2e, 0x5c, 0x8d, 0x74, 0xdd, 0xcb, 0x52, 0x56, - 0xb2, 0xd6, 0x5d, 0x82, 0xc9, 0x3d, 0xcb, 0xd6, 0xbc, 0xc3, 0x5c, 0xf6, 0xc0, 0xda, 0x93, 0x41, - 0x9a, 0xb5, 0x4c, 0x36, 0x27, 0x82, 0xf4, 0x5b, 0x02, 0x94, 0xfc, 0x86, 0x48, 0x72, 0x41, 0xa8, - 0x46, 0xb4, 0x78, 0xf1, 0xa6, 0x20, 0x0a, 0x94, 0xfe, 0x35, 0xb5, 0x88, 0x34, 0xeb, 0x88, 0xb6, - 0x4c, 0x92, 0x3d, 0xe5, 0x03, 0xe6, 0xe8, 0x93, 0xba, 0x68, 0xeb, 0x52, 0x9f, 0x9f, 0x07, 0x70, - 0xc9, 0xe8, 0x90, 0xf9, 0xdc, 0x70, 0xdb, 0x27, 0x1c, 0xb6, 0xb9, 0xd8, 0x3b, 0x35, 0x9e, 0x0b, - 0xd2, 0xaa, 0x5e, 0x92, 0xf4, 0x7b, 0x74, 0xb7, 0x3a, 0xa8, 0x49, 0x92, 0xaa, 0x6e, 0x40, 0xc1, - 0x66, 0xa2, 0x89, 0x59, 0x73, 0x41, 0x6d, 0xcf, 0xf8, 0xac, 0x44, 0xe1, 0xbf, 0x9d, 0x82, 0xd2, - 0xb3, 0x1e, 0xb6, 0x4f, 0xbe, 0x4e, 0xea, 0xbe, 0x0d, 0xa5, 0x57, 0xaa, 0xe1, 0x2a, 0x7b, 0x96, - 0xad, 0xf4, 0xba, 0xba, 0xea, 0x7a, 0xde, 0x26, 0x05, 0x42, 0x7e, 0x6c, 0xd9, 0x3b, 0x94, 0x88, - 0x30, 0xa0, 0x43, 0xd3, 0x7a, 0x65, 0x2a, 0x84, 0x4c, 0x81, 0xf2, 0xb1, 0xc9, 0xb7, 0x90, 0x2b, - 0xdf, 0xfe, 0x77, 0xa7, 0x4b, 0x8f, 0xc6, 0xf2, 0x21, 0xa3, 0xfe, 0x72, 0xbd, 0x9e, 0xa1, 0x97, - 0x77, 0x76, 0x1a, 0xab, 0xb2, 0x48, 0x45, 0xbe, 0x60, 0x12, 0x5b, 0xc7, 0xa6, 0x23, 0xfd, 0x9d, - 0x14, 0x88, 0x81, 0x8e, 0x92, 0x6c, 0xc8, 0x1a, 0xe4, 0x5f, 0xf6, 0xb0, 0x6d, 0xbc, 0x46, 0x33, - 0x02, 0x67, 0x24, 0xd3, 0xce, 0x7d, 0x98, 0x75, 0x8f, 0x4d, 0x85, 0x79, 0xf8, 0x31, 0xc7, 0x0f, - 0xcf, 0x61, 0xa1, 0xe4, 0x92, 0x32, 0x13, 0x3a, 0x75, 0xfa, 0x70, 0xd0, 0x27, 0x30, 0x13, 0xd1, - 0x56, 0xfa, 0xcb, 0x69, 0x2b, 0xff, 0x2a, 0xa4, 0xa8, 0x3f, 0x10, 0x00, 0x51, 0x45, 0x35, 0xd8, - 0x1e, 0xff, 0xd7, 0xa5, 0x3f, 0xdd, 0x05, 0x91, 0xfa, 0x63, 0x2a, 0xc6, 0x9e, 0xd2, 0x31, 0x1c, - 0xc7, 0x30, 0xf7, 0x79, 0x87, 0x2a, 0x52, 0x7a, 0x63, 0x6f, 0x93, 0x51, 0xa5, 0xbf, 0x04, 0x73, - 0x91, 0x0a, 0x24, 0xd9, 0xd8, 0x37, 0x60, 0x66, 0x8f, 0x1d, 0xc1, 0x52, 0xe1, 0x7c, 0x7b, 0x30, - 0x4f, 0x69, 0xec, 0x7d, 0xd2, 0x7f, 0x49, 0xc1, 0x25, 0x19, 0x3b, 0x56, 0xfb, 0x08, 0x27, 0xaf, - 0xc2, 0x3a, 0xf0, 0xb3, 0x17, 0xe5, 0xb5, 0x34, 0x99, 0x63, 0xcc, 0x6c, 0x99, 0x8b, 0xee, 0xb1, - 0xbf, 0x3d, 0xba, 0xc7, 0x0e, 0xee, 0xaa, 0xf3, 0x9d, 0xba, 0x4c, 0x64, 0xa7, 0xce, 0x82, 0x12, - 0x3b, 0x3d, 0xd6, 0x15, 0x07, 0xbf, 0x34, 0x7b, 0x1d, 0x0f, 0x0c, 0x95, 0x47, 0x15, 0xb2, 0xc1, - 0x58, 0x9a, 0xf8, 0xe5, 0x56, 0xaf, 0x43, 0x6d, 0xe7, 0xca, 0x15, 0x52, 0xde, 0xb3, 0xd3, 0xa5, - 0x62, 0x24, 0xcd, 0x91, 0x8b, 0x86, 0xff, 0x4c, 0xa4, 0x4b, 0xdf, 0x83, 0xcb, 0x7d, 0xca, 0x4e, - 0xd2, 0xe2, 0xf9, 0x67, 0x69, 0x78, 0x23, 0x2a, 0x3e, 0x69, 0x88, 0xf3, 0x75, 0x6f, 0xd0, 0x3a, - 0x14, 0x3a, 0x86, 0xf9, 0x7a, 0xbb, 0x97, 0x33, 0x1d, 0xc3, 0xf4, 0x69, 0x71, 0x5d, 0x63, 0xea, - 0x2b, 0xed, 0x1a, 0x2a, 0x2c, 0xc4, 0xb5, 0x5d, 0x92, 0xfd, 0xe3, 0x33, 0x01, 0x66, 0x92, 0xde, - 0x96, 0x7b, 0x3d, 0x2f, 0x38, 0xa9, 0x05, 0x85, 0xaf, 0x60, 0x1f, 0xef, 0xb7, 0x05, 0x40, 0x2d, - 0xbb, 0x67, 0x12, 0x50, 0xbb, 0x61, 0xed, 0x27, 0x59, 0xcd, 0x4b, 0x30, 0x69, 0x98, 0x3a, 0x3e, - 0xa6, 0xd5, 0xcc, 0xc8, 0xec, 0x21, 0x72, 0x94, 0x98, 0x1e, 0xeb, 0x28, 0x51, 0xfa, 0x04, 0xe6, - 0x22, 0x45, 0x4c, 0xb2, 0xfe, 0x7f, 0x92, 0x82, 0x39, 0x5e, 0x91, 0xc4, 0x77, 0x30, 0xbf, 0x09, - 0x93, 0x6d, 0x22, 0x73, 0x44, 0x3b, 0xd3, 0x77, 0x7a, 0xed, 0x4c, 0x33, 0xa3, 0xef, 0x00, 0x74, - 0x6d, 0x7c, 0xa4, 0x30, 0xd6, 0xf4, 0x58, 0xac, 0x39, 0xc2, 0x41, 0x09, 0xe8, 0x73, 0x01, 0x4a, - 0x64, 0x40, 0x77, 0x6d, 0xab, 0x6b, 0x39, 0xc4, 0x66, 0x71, 0xc6, 0x83, 0x39, 0xcf, 0xce, 0x4e, - 0x97, 0x0a, 0x9b, 0x86, 0xb9, 0xcd, 0x19, 0x5b, 0xcd, 0xb1, 0x1d, 0xfc, 0xbd, 0x30, 0x87, 0x72, - 0xb5, 0x6d, 0x69, 0x87, 0xc1, 0xe1, 0x18, 0x99, 0x59, 0x7c, 0x71, 0x8e, 0xf4, 0x33, 0x01, 0x2e, - 0x7d, 0x65, 0xdb, 0xc5, 0x7f, 0x16, 0xca, 0x96, 0x9e, 0x83, 0x48, 0x7f, 0x34, 0xcc, 0x3d, 0x2b, - 0xc9, 0x8d, 0xfb, 0xff, 0x23, 0xc0, 0x6c, 0x48, 0x70, 0x92, 0x06, 0xce, 0xeb, 0xea, 0xa9, 0xc0, - 0xdc, 0x61, 0xdc, 0xf1, 0x54, 0x25, 0xcf, 0xf0, 0xec, 0xac, 0x53, 0x96, 0x61, 0x06, 0x93, 0x59, - 0x8c, 0x6e, 0xf1, 0xee, 0xb2, 0x20, 0x93, 0xbe, 0x1d, 0xfd, 0xbc, 0x9f, 0xa1, 0x72, 0x22, 0xfd, - 0x2a, 0xb1, 0xb0, 0xc2, 0x83, 0x32, 0xc9, 0x21, 0xff, 0x4f, 0x53, 0x70, 0xa5, 0xca, 0x8e, 0xc0, - 0x3d, 0x9f, 0x90, 0x24, 0x3b, 0xe2, 0x3c, 0x4c, 0x1f, 0x61, 0xdb, 0x31, 0x2c, 0xb6, 0xda, 0x17, - 0x64, 0xef, 0x11, 0x2d, 0x40, 0xd6, 0x31, 0xd5, 0xae, 0x73, 0x60, 0x79, 0xc7, 0x89, 0xfe, 0xb3, - 0xef, 0xbf, 0x32, 0xf9, 0xfa, 0xfe, 0x2b, 0x53, 0xa3, 0xfd, 0x57, 0xa6, 0xbf, 0x84, 0xff, 0x0a, - 0x3f, 0xbb, 0xfb, 0x37, 0x02, 0x5c, 0x1d, 0xd0, 0x5c, 0x92, 0x9d, 0xf3, 0xfb, 0x90, 0xd7, 0xb8, - 0x60, 0xb2, 0x3e, 0xb0, 0x83, 0xc9, 0x06, 0xc9, 0xf6, 0x9a, 0xd0, 0xe7, 0xec, 0x74, 0x09, 0xbc, - 0xa2, 0x36, 0x56, 0xb9, 0x72, 0xc8, 0x6f, 0x5d, 0xfa, 0xaf, 0x00, 0xa5, 0xda, 0x31, 0xdb, 0x94, - 0x6f, 0x32, 0xab, 0x04, 0x3d, 0x86, 0x6c, 0xd7, 0xb6, 0x8e, 0x0c, 0xaf, 0x1a, 0xc5, 0x88, 0xf3, - 0x82, 0x57, 0x8d, 0x3e, 0xae, 0x6d, 0xce, 0x21, 0xfb, 0xbc, 0xa8, 0x05, 0xb9, 0x0d, 0x4b, 0x53, - 0xdb, 0x8f, 0x8d, 0xb6, 0x37, 0xd0, 0xde, 0x3d, 0x5f, 0x50, 0xd9, 0xe7, 0xd9, 0x56, 0xdd, 0x03, - 0xaf, 0x11, 0x7c, 0x22, 0x6a, 0x40, 0xb6, 0xee, 0xba, 0x5d, 0x92, 0xc8, 0xc7, 0xdf, 0x9d, 0x31, - 0x84, 0x12, 0x16, 0xcf, 0xe3, 0xd6, 0x63, 0x47, 0x2d, 0x98, 0x7d, 0x42, 0xe3, 0xc7, 0xaa, 0x6d, - 0xab, 0xa7, 0x57, 0x2d, 0x73, 0xcf, 0xd8, 0xe7, 0xcb, 0xc4, 0xed, 0x31, 0x64, 0x3e, 0xa9, 0x36, - 0xe5, 0x41, 0x01, 0x68, 0x05, 0xb2, 0xcd, 0x47, 0x5c, 0x18, 0x33, 0x23, 0x6f, 0x8d, 0x21, 0xac, - 0xf9, 0x48, 0xf6, 0xd9, 0xd0, 0x1a, 0xe4, 0x57, 0x3e, 0xed, 0xd9, 0x98, 0x4b, 0x99, 0x1a, 0xea, - 0x39, 0xd1, 0x2f, 0x85, 0x72, 0xc9, 0x61, 0x66, 0xf4, 0x3d, 0x28, 0x11, 0xbd, 0xb5, 0xd4, 0xdd, - 0xb6, 0x27, 0x2f, 0x4b, 0xe5, 0x7d, 0x63, 0x0c, 0x79, 0x3e, 0xa7, 0x77, 0x24, 0xd0, 0x27, 0x6a, - 0x41, 0x86, 0x42, 0xa4, 0xbd, 0x10, 0x82, 0x4c, 0x97, 0x34, 0x8d, 0x40, 0xdd, 0x90, 0xe8, 0x6f, - 0xf4, 0x0e, 0x4c, 0x9b, 0x96, 0x8e, 0xbd, 0xce, 0x5c, 0xa8, 0x5c, 0x3a, 0x3b, 0x5d, 0x9a, 0xda, - 0xb2, 0x74, 0x66, 0xeb, 0xf0, 0x5f, 0xf2, 0x14, 0xc9, 0xd4, 0xd0, 0x17, 0xae, 0x43, 0x86, 0x34, - 0x11, 0x99, 0x43, 0x76, 0x55, 0x07, 0xef, 0xd8, 0x06, 0x97, 0xe6, 0x3d, 0x2e, 0xfc, 0xfd, 0x14, - 0xa4, 0x9a, 0x8f, 0x88, 0x35, 0xbf, 0xdb, 0xd3, 0x0e, 0xb1, 0xcb, 0xd3, 0xf9, 0x13, 0xb5, 0xf2, - 0x6d, 0xbc, 0x67, 0x30, 0xa3, 0x2b, 0x27, 0xf3, 0x27, 0xf4, 0x16, 0x80, 0xaa, 0x69, 0xd8, 0x71, - 0x14, 0x2f, 0x04, 0x30, 0x27, 0xe7, 0x18, 0x65, 0x1d, 0x9f, 0x10, 0x36, 0x07, 0x6b, 0x36, 0x76, - 0x3d, 0x1f, 0x2a, 0xf6, 0x44, 0xd8, 0x5c, 0xdc, 0xe9, 0x2a, 0xae, 0x75, 0x88, 0x4d, 0xda, 0xa4, - 0x39, 0x32, 0x2b, 0x74, 0xba, 0x2d, 0x42, 0x20, 0x13, 0x1a, 0x36, 0xf5, 0x60, 0xf6, 0xc9, 0xc9, - 0xfe, 0x33, 0x11, 0x69, 0xe3, 0x7d, 0x83, 0x07, 0xd0, 0xe5, 0x64, 0xfe, 0x44, 0xb4, 0xa4, 0xf6, - 0xdc, 0x03, 0xda, 0x12, 0x39, 0x99, 0xfe, 0x46, 0xb7, 0xa1, 0xc4, 0xdc, 0x2e, 0x15, 0x6c, 0x6a, - 0x0a, 0x9d, 0x07, 0x73, 0x34, 0xb9, 0xc0, 0xc8, 0x35, 0x53, 0x23, 0xb3, 0x1e, 0x7a, 0x04, 0x9c, - 0xa0, 0x1c, 0x76, 0x1c, 0xa2, 0x53, 0x20, 0xb9, 0x2a, 0xa5, 0xb3, 0xd3, 0xa5, 0x7c, 0x93, 0x26, - 0xac, 0x6f, 0x36, 0xc9, 0x5a, 0xc2, 0x72, 0xad, 0x77, 0x9c, 0x86, 0xbe, 0xf0, 0x37, 0x05, 0x48, - 0x3f, 0xa9, 0x36, 0x2f, 0xac, 0x32, 0xaf, 0xa0, 0xe9, 0x50, 0x41, 0xef, 0x40, 0x69, 0xd7, 0x68, - 0xb7, 0x0d, 0x73, 0x9f, 0xd8, 0x57, 0xdf, 0xc7, 0x9a, 0xa7, 0xb0, 0x22, 0x27, 0x6f, 0x33, 0x2a, - 0xba, 0x0e, 0x79, 0xcd, 0xc6, 0x3a, 0x36, 0x5d, 0x43, 0x6d, 0x3b, 0x5c, 0x73, 0x61, 0xd2, 0xc2, - 0x5f, 0x16, 0x60, 0x92, 0x76, 0x56, 0xf4, 0x26, 0xe4, 0x34, 0xcb, 0x74, 0x55, 0xc3, 0xe4, 0xb3, - 0x4e, 0x4e, 0x0e, 0x08, 0x43, 0x8b, 0x77, 0x03, 0x66, 0x54, 0x4d, 0xb3, 0x7a, 0xa6, 0xab, 0x98, - 0x6a, 0x07, 0xf3, 0x62, 0xe6, 0x39, 0x6d, 0x4b, 0xed, 0x60, 0xb4, 0x04, 0xde, 0xa3, 0x1f, 0xd9, - 0x99, 0x93, 0x81, 0x93, 0xd6, 0xf1, 0xc9, 0x02, 0x86, 0x9c, 0xdf, 0xab, 0x49, 0x7d, 0x7b, 0x8e, - 0x5f, 0x02, 0xfa, 0x1b, 0xbd, 0x0b, 0x97, 0x5e, 0xf6, 0xd4, 0xb6, 0xb1, 0x47, 0x37, 0xbf, 0xa8, - 0x97, 0x3a, 0x7d, 0x19, 0x2b, 0x0a, 0xf2, 0xd3, 0xa8, 0x04, 0xfa, 0x4e, 0x6f, 0x10, 0xa4, 0x83, - 0x41, 0xc0, 0x5c, 0x76, 0xa4, 0x13, 0x98, 0x95, 0xb1, 0x6b, 0x9f, 0xb4, 0x58, 0xb0, 0x6b, 0xed, - 0x08, 0x9b, 0x2e, 0xa9, 0xbb, 0xd5, 0xc5, 0xcc, 0x49, 0xc4, 0xab, 0xbb, 0x4f, 0x40, 0xb7, 0xa0, - 0xa8, 0xba, 0xa4, 0xbb, 0xb9, 0x8a, 0xd9, 0xeb, 0xec, 0x62, 0x9b, 0xb9, 0x02, 0xc8, 0x05, 0x4e, - 0xdd, 0xa2, 0x44, 0x1e, 0x91, 0x61, 0x9f, 0x28, 0x74, 0x9f, 0x88, 0xbf, 0x1a, 0x28, 0xa9, 0x46, - 0x28, 0xd2, 0x3d, 0xb8, 0x4c, 0xea, 0x59, 0x33, 0x35, 0xfb, 0xa4, 0x4b, 0x24, 0x3f, 0xa5, 0x7f, - 0x1d, 0x24, 0x86, 0xce, 0x69, 0xe8, 0xf1, 0x8c, 0xf4, 0xd3, 0x29, 0x28, 0xd4, 0x8e, 0xbb, 0x96, - 0x9d, 0xe8, 0xae, 0x4e, 0x05, 0xa6, 0x39, 0xf0, 0x1d, 0x71, 0x14, 0xdb, 0x37, 0x03, 0x79, 0xe7, - 0xd0, 0x9c, 0x11, 0x55, 0x00, 0x98, 0x43, 0x25, 0xf5, 0xc3, 0x49, 0x5f, 0xe0, 0xe4, 0x88, 0xb2, - 0xd1, 0x60, 0x83, 0x2d, 0xc8, 0x77, 0x8e, 0x34, 0x4d, 0xd9, 0x33, 0xda, 0x2e, 0xf7, 0x4b, 0x8b, - 0x77, 0xa1, 0xde, 0x7c, 0x5e, 0xad, 0x3e, 0xa6, 0x99, 0x98, 0x3f, 0x57, 0xf0, 0x2c, 0x03, 0x91, - 0xc0, 0x7e, 0xa3, 0x6f, 0x00, 0x0f, 0x7c, 0x51, 0x1c, 0x2f, 0x8c, 0xad, 0x52, 0x38, 0x3b, 0x5d, - 0xca, 0xc9, 0x94, 0xda, 0x6c, 0xb6, 0xe4, 0x1c, 0xcb, 0xd0, 0x74, 0xdc, 0x8b, 0x84, 0x3a, 0x4c, - 0x8f, 0x1f, 0xea, 0xf0, 0xd7, 0x04, 0xb8, 0xc2, 0x75, 0xa4, 0xec, 0x52, 0xf7, 0x6e, 0xb5, 0x6d, - 0xb8, 0x27, 0xca, 0xe1, 0xd1, 0x7c, 0x96, 0x9a, 0x3c, 0xbf, 0x1c, 0xab, 0xeb, 0x50, 0x13, 0x97, - 0x3d, 0x8d, 0x9f, 0x6c, 0x70, 0xe6, 0xf5, 0xa3, 0x9a, 0xe9, 0xda, 0x27, 0x95, 0xab, 0x67, 0xa7, - 0x4b, 0x73, 0x83, 0xa9, 0xcf, 0xe5, 0x39, 0x67, 0x90, 0x05, 0xd5, 0x01, 0xb0, 0xdf, 0xc5, 0xe8, - 0x0c, 0x16, 0xbf, 0x74, 0xc5, 0xf6, 0x45, 0x39, 0xc4, 0x8b, 0xee, 0x82, 0xc8, 0x43, 0x4b, 0xf6, - 0x8c, 0x36, 0x56, 0x1c, 0xe3, 0x53, 0x4c, 0xe7, 0xba, 0xb4, 0x5c, 0x64, 0x74, 0x22, 0xa2, 0x69, - 0x7c, 0x8a, 0xd1, 0x03, 0xb8, 0x1c, 0xb4, 0x80, 0xb2, 0x8b, 0xdb, 0xd6, 0x2b, 0x96, 0x3d, 0x4f, - 0xb3, 0x23, 0x5f, 0xfb, 0x15, 0x92, 0x44, 0x58, 0x16, 0xbe, 0x0f, 0xf3, 0xc3, 0x2a, 0x1c, 0x1e, - 0x10, 0x39, 0x76, 0x5e, 0xf9, 0x5e, 0x74, 0xb3, 0x62, 0x8c, 0x8e, 0xcb, 0x37, 0x2c, 0xde, 0x4f, - 0xbd, 0x27, 0x48, 0x7f, 0x2f, 0x05, 0x85, 0x4a, 0xaf, 0x7d, 0xf8, 0xb4, 0xdb, 0x64, 0x61, 0xf9, - 0xe8, 0x1a, 0xe4, 0x74, 0xd5, 0x55, 0x59, 0x21, 0x05, 0x16, 0x62, 0x46, 0x08, 0xb4, 0x36, 0x77, - 0xa0, 0x14, 0xf2, 0x05, 0xe1, 0x1e, 0xef, 0xb4, 0xda, 0x01, 0x99, 0x3a, 0xa5, 0xbf, 0x07, 0xf3, - 0xa1, 0x8c, 0x74, 0x67, 0x41, 0xc1, 0xa6, 0x6b, 0x1b, 0x98, 0xed, 0x8e, 0xa5, 0xe5, 0x90, 0xc3, - 0x4a, 0x83, 0x24, 0xd7, 0x58, 0x2a, 0x6a, 0xc1, 0x0c, 0xc9, 0x78, 0xa2, 0xd0, 0x59, 0xd0, 0xdb, - 0xbd, 0x7c, 0x10, 0x53, 0xad, 0x48, 0xb9, 0xcb, 0x54, 0x3f, 0x55, 0xca, 0x43, 0x7f, 0xca, 0x79, - 0x1c, 0x50, 0x16, 0x3e, 0x02, 0xb1, 0x3f, 0x43, 0x58, 0x97, 0x19, 0xa6, 0xcb, 0x4b, 0x61, 0x5d, - 0xa6, 0x43, 0x7a, 0x5a, 0xcb, 0x64, 0x33, 0xe2, 0xa4, 0xf4, 0xb3, 0x34, 0x14, 0xbd, 0x9e, 0x99, - 0xa4, 0x59, 0x5d, 0x81, 0x49, 0xd2, 0x8f, 0x3c, 0xf7, 0x8a, 0xdb, 0x23, 0x06, 0x04, 0xf7, 0xb1, - 0x26, 0xfd, 0xcb, 0x43, 0x80, 0x94, 0x35, 0x89, 0xe9, 0x67, 0xe1, 0xbf, 0x09, 0x90, 0xa1, 0x96, - 0xec, 0x03, 0xc8, 0xd0, 0xb8, 0x7c, 0x61, 0x64, 0x5c, 0xbe, 0x77, 0x3c, 0x4f, 0xb2, 0xfa, 0x0b, - 0x4b, 0x2a, 0x64, 0x5d, 0x55, 0xa8, 0x7f, 0x8f, 0x65, 0xbb, 0x58, 0xe7, 0x96, 0xe2, 0xf5, 0xf3, - 0xda, 0xd1, 0xb3, 0x84, 0x3d, 0x3e, 0xf4, 0x06, 0xa4, 0xc9, 0xdc, 0x35, 0xcd, 0x8e, 0xea, 0xcf, - 0x4e, 0x97, 0xd2, 0x64, 0xd6, 0x22, 0x34, 0xb4, 0x0c, 0xf9, 0xe8, 0x6c, 0x42, 0x8c, 0x0d, 0x3a, - 0x1d, 0x86, 0x66, 0x02, 0x68, 0xfb, 0x43, 0x88, 0xa1, 0x24, 0xd6, 0x96, 0xfc, 0x90, 0xfe, 0x37, - 0x04, 0xee, 0x93, 0xd8, 0xd4, 0xc8, 0x9a, 0x65, 0x27, 0xb9, 0xa8, 0xdc, 0x03, 0xd1, 0x56, 0x4d, - 0xdd, 0xea, 0x18, 0x9f, 0x62, 0x86, 0xca, 0x1d, 0x7e, 0x5c, 0x51, 0xf2, 0xe9, 0x14, 0x3e, 0x3b, - 0xd2, 0x7f, 0x16, 0xb8, 0xff, 0xa2, 0x5f, 0x8c, 0x64, 0x0f, 0x95, 0xf3, 0x7c, 0x4b, 0xcf, 0xdc, - 0xb3, 0x3c, 0xf7, 0x8b, 0x37, 0x87, 0x39, 0x1b, 0x35, 0xcc, 0x3d, 0xcb, 0x3b, 0x1e, 0xb3, 0x3d, - 0x82, 0xb3, 0xf0, 0x2b, 0x30, 0x49, 0x93, 0x5f, 0xa3, 0x6f, 0xf8, 0x3e, 0xb3, 0x29, 0x31, 0x2d, - 0xfd, 0x71, 0x0a, 0xde, 0xa6, 0x55, 0x7d, 0x8e, 0x6d, 0x63, 0xef, 0x64, 0xdb, 0xb6, 0x5c, 0xac, - 0xb9, 0x58, 0x0f, 0x76, 0xa5, 0x12, 0x6c, 0x02, 0x1d, 0x72, 0xfc, 0x3c, 0xcf, 0xd0, 0xf9, 0xcd, - 0x19, 0x4f, 0xbe, 0x1c, 0x5a, 0xcd, 0xb2, 0x73, 0xc0, 0xc6, 0xaa, 0x9c, 0x65, 0x92, 0x1b, 0x3a, - 0x5a, 0x81, 0x5c, 0xd7, 0xab, 0xc6, 0x85, 0x5c, 0x46, 0x7c, 0x2e, 0xb4, 0x0e, 0x25, 0x5e, 0x50, - 0xb5, 0x6d, 0x1c, 0x61, 0x45, 0x75, 0x2f, 0x32, 0x84, 0x0b, 0x8c, 0x77, 0x85, 0xb0, 0xae, 0xb8, - 0xd2, 0xdf, 0xc8, 0xc0, 0xad, 0x73, 0x54, 0x9c, 0x64, 0xf7, 0x5a, 0x80, 0xec, 0x11, 0x79, 0x91, - 0xc1, 0x6b, 0x9f, 0x95, 0xfd, 0x67, 0xb4, 0x1b, 0x59, 0x07, 0xf6, 0x54, 0xa3, 0x4d, 0xd6, 0x0d, - 0xe6, 0xa4, 0x37, 0xdc, 0x0d, 0x28, 0xde, 0xe9, 0x2d, 0xb4, 0x62, 0x3c, 0xa6, 0x82, 0x68, 0x36, - 0x07, 0x7d, 0x26, 0xc0, 0x02, 0x7b, 0x21, 0xf3, 0x14, 0xeb, 0x7b, 0x4d, 0x86, 0xbe, 0x66, 0x35, - 0xe6, 0x35, 0x63, 0xe9, 0xa8, 0x1c, 0x7a, 0x17, 0x2f, 0xc8, 0x7c, 0xf8, 0x6d, 0xe1, 0xa2, 0x2c, - 0xfc, 0xa6, 0x00, 0xf9, 0x10, 0x01, 0xdd, 0x1e, 0x88, 0xcb, 0xc9, 0x9f, 0xc5, 0x05, 0xe3, 0xdc, - 0x1a, 0x08, 0xc6, 0xa9, 0x64, 0xbf, 0x38, 0x5d, 0xca, 0xc8, 0xcc, 0xdf, 0xdb, 0x0b, 0xcb, 0xb9, - 0x11, 0x5c, 0x03, 0x93, 0xee, 0xcb, 0xe4, 0xdd, 0x03, 0x43, 0x61, 0x9d, 0xea, 0x1d, 0x23, 0x51, - 0x58, 0x47, 0x9e, 0xa4, 0x1f, 0xa5, 0x60, 0x76, 0x45, 0xd7, 0x9b, 0x4d, 0x0a, 0x05, 0x92, 0x1c, - 0x63, 0x08, 0x32, 0xc4, 0x3e, 0xe0, 0x31, 0x44, 0xf4, 0x37, 0x7a, 0x07, 0x90, 0x6e, 0x38, 0xec, - 0x3a, 0x05, 0xe7, 0x40, 0xd5, 0xad, 0x57, 0xc1, 0x69, 0xf1, 0xac, 0x97, 0xd2, 0xf4, 0x12, 0x50, - 0x13, 0xa8, 0xd1, 0xaa, 0x38, 0xae, 0xea, 0xef, 0x86, 0xdf, 0x1a, 0x2b, 0x2a, 0x85, 0x59, 0xb3, - 0xfe, 0xa3, 0x9c, 0x23, 0x72, 0xe8, 0x4f, 0x62, 0xa3, 0x19, 0xa4, 0x51, 0x5c, 0x45, 0x75, 0xbc, - 0x78, 0x0a, 0x76, 0x91, 0x43, 0x91, 0xd1, 0x57, 0x1c, 0x16, 0x26, 0xc1, 0xdc, 0xb0, 0x03, 0xd5, - 0x24, 0xb9, 0x97, 0xf9, 0x3b, 0x02, 0x14, 0x65, 0xbc, 0x67, 0x63, 0xe7, 0x20, 0x49, 0x9d, 0x3f, - 0x86, 0x19, 0x9b, 0x49, 0x55, 0xf6, 0x6c, 0xab, 0x73, 0x91, 0xb9, 0x22, 0xcf, 0x19, 0x1f, 0xdb, - 0x56, 0x87, 0x4f, 0xc9, 0xcf, 0xa1, 0xe4, 0x97, 0x31, 0xc9, 0xca, 0xff, 0x5d, 0x1a, 0x71, 0xc9, - 0x04, 0x27, 0x7d, 0x6c, 0x9b, 0xac, 0x06, 0xe8, 0x7e, 0x76, 0xb8, 0xa0, 0x49, 0xaa, 0xe1, 0x3f, - 0x09, 0x50, 0x6c, 0xf6, 0x76, 0xd9, 0x35, 0x41, 0xc9, 0x69, 0xa0, 0x06, 0xb9, 0x36, 0xde, 0x73, - 0x95, 0xd7, 0x72, 0x20, 0xce, 0x12, 0x56, 0xea, 0x3e, 0xfd, 0x04, 0xc0, 0xa6, 0x21, 0x47, 0x54, - 0x4e, 0xfa, 0x82, 0x72, 0x72, 0x94, 0x97, 0x90, 0xc9, 0xaa, 0x53, 0xf2, 0xab, 0x99, 0xe4, 0xfa, - 0xf2, 0x22, 0x32, 0x3b, 0xa4, 0x2f, 0x32, 0x3b, 0xcc, 0xf2, 0x93, 0xea, 0xf8, 0x19, 0xa2, 0x0c, - 0x73, 0xd4, 0x2c, 0x53, 0xd4, 0x6e, 0xb7, 0x6d, 0x78, 0x38, 0x85, 0xce, 0x3f, 0x19, 0x79, 0x96, - 0x26, 0xad, 0xb0, 0x14, 0x8a, 0x50, 0xd0, 0x0f, 0x04, 0x98, 0xd9, 0xb3, 0x31, 0xfe, 0x14, 0x2b, - 0x74, 0x4a, 0x1e, 0xef, 0x28, 0x7e, 0x95, 0x94, 0xe1, 0x4b, 0x1f, 0xd5, 0xe5, 0xd9, 0x8b, 0x9b, - 0xe4, 0xbd, 0x68, 0x0b, 0x44, 0xad, 0xcd, 0x0e, 0x0f, 0x7d, 0xb7, 0x80, 0xa9, 0xf1, 0x07, 0x40, - 0x89, 0x31, 0x07, 0x9e, 0x01, 0xcf, 0xc8, 0x60, 0x52, 0x75, 0x85, 0x5f, 0xcd, 0x46, 0x8d, 0xed, - 0xa8, 0x5b, 0x40, 0x38, 0xf4, 0x3a, 0x74, 0xa3, 0x5b, 0x59, 0xc6, 0xaa, 0xce, 0x2d, 0x77, 0x32, - 0xae, 0xfc, 0x07, 0x3e, 0xae, 0x5e, 0xc0, 0x2c, 0xed, 0x37, 0x49, 0x47, 0x50, 0x4a, 0xff, 0x30, - 0x0d, 0x28, 0x2c, 0xf9, 0xab, 0xeb, 0x6f, 0xa9, 0xe4, 0xfa, 0xdb, 0x1a, 0x48, 0x21, 0x63, 0xa8, - 0xad, 0x3a, 0xae, 0xc2, 0xfc, 0xcf, 0x1c, 0xa5, 0x8b, 0x6d, 0xc5, 0xc1, 0x9a, 0xc5, 0x2f, 0xd1, - 0x11, 0xe4, 0xc5, 0x20, 0xe7, 0x86, 0xea, 0xb8, 0xcf, 0x58, 0xbe, 0x6d, 0x6c, 0x37, 0x69, 0x2e, - 0xf4, 0x08, 0xae, 0x74, 0xd4, 0xe3, 0x38, 0xfe, 0x49, 0xca, 0x3f, 0xd7, 0x51, 0x8f, 0x07, 0x98, - 0xde, 0x87, 0x85, 0x78, 0x26, 0xc5, 0xc1, 0xde, 0xf9, 0xd4, 0x95, 0x18, 0xc6, 0x26, 0x76, 0xd1, - 0x0a, 0x40, 0x00, 0x22, 0xf8, 0x1a, 0x3d, 0x0e, 0x86, 0xc8, 0xf9, 0x18, 0x42, 0xfa, 0xa1, 0x00, - 0xc5, 0x4d, 0x63, 0xdf, 0x56, 0x13, 0xbd, 0xa2, 0x06, 0xbd, 0x1f, 0x3d, 0xd0, 0xcb, 0x3f, 0x5c, - 0x88, 0x73, 0xd8, 0x60, 0x39, 0xbc, 0x4d, 0x3b, 0xce, 0x40, 0x96, 0x3e, 0xbf, 0x44, 0x49, 0xce, - 0xf9, 0x1a, 0xbc, 0x45, 0x5d, 0xe0, 0xb8, 0xff, 0xcb, 0x57, 0x82, 0x6e, 0xa4, 0xdf, 0x17, 0x60, - 0x71, 0xd8, 0x5b, 0x92, 0x1c, 0x10, 0x32, 0xbd, 0xac, 0x8f, 0xbe, 0x41, 0xf1, 0x47, 0xc4, 0x39, - 0x33, 0x0d, 0xe2, 0x23, 0x01, 0xfc, 0xb2, 0x35, 0xe9, 0x35, 0x7e, 0xec, 0xb7, 0x23, 0xfd, 0xab, - 0x05, 0x98, 0xe1, 0xf5, 0xdb, 0x31, 0x0d, 0xcb, 0x44, 0x0f, 0x20, 0xbd, 0xcf, 0xf7, 0xfe, 0xf3, - 0xb1, 0x5b, 0x9e, 0xc1, 0x0d, 0x79, 0xf5, 0x09, 0x99, 0xe4, 0x25, 0x2c, 0xdd, 0x9e, 0x1b, 0x53, - 0x9e, 0xc0, 0xc9, 0x3b, 0xcc, 0xd2, 0xed, 0xb9, 0xa8, 0x09, 0x25, 0x2d, 0xb8, 0x96, 0x4b, 0x21, - 0xec, 0xe9, 0xa1, 0xfb, 0x80, 0xb1, 0x17, 0xa4, 0xd5, 0x27, 0xe4, 0xa2, 0x16, 0x49, 0x40, 0xd5, - 0xf0, 0x6d, 0x50, 0x99, 0x01, 0x0f, 0xb2, 0x20, 0x96, 0x38, 0x7a, 0x13, 0x55, 0x7d, 0x22, 0x74, - 0x69, 0x14, 0x7a, 0x1f, 0xa6, 0x74, 0x7a, 0xef, 0x10, 0x5f, 0x55, 0xe2, 0x3a, 0x44, 0xe4, 0x7a, - 0xa7, 0xfa, 0x84, 0xcc, 0x39, 0xd0, 0x1a, 0xcc, 0xb0, 0x5f, 0x0c, 0xf3, 0xf0, 0xb5, 0xe0, 0xd6, - 0x70, 0x09, 0x21, 0x6b, 0xac, 0x3e, 0x21, 0xe7, 0xf5, 0x80, 0x8a, 0x9e, 0x40, 0x5e, 0x6b, 0x63, - 0xd5, 0xe6, 0xa2, 0x6e, 0x0f, 0x0d, 0x7b, 0x1b, 0xb8, 0xab, 0xa8, 0x3e, 0x21, 0x83, 0xe6, 0x13, - 0x49, 0xa1, 0x6c, 0x7a, 0x65, 0x0d, 0x97, 0xf4, 0xee, 0xd0, 0x42, 0x0d, 0xde, 0xff, 0x53, 0xa7, - 0x56, 0x9a, 0x4f, 0x45, 0xdf, 0x84, 0x8c, 0xa3, 0xa9, 0x26, 0x5f, 0x98, 0x16, 0x87, 0xdc, 0x29, - 0x12, 0x30, 0xd3, 0xdc, 0xe8, 0x03, 0x06, 0x97, 0xdc, 0x63, 0x6f, 0xb3, 0x37, 0x4e, 0xa7, 0x91, - 0xd8, 0x75, 0xa2, 0x53, 0x4c, 0x09, 0x44, 0x0f, 0x2a, 0xc1, 0x87, 0x0a, 0x0d, 0x28, 0xa5, 0xbb, - 0xbb, 0xf1, 0x7a, 0x18, 0x08, 0x00, 0xae, 0xd3, 0x00, 0x79, 0x8f, 0x88, 0x36, 0xa1, 0xc0, 0x04, - 0xf5, 0x58, 0x6c, 0xea, 0xfc, 0xf2, 0xd0, 0x63, 0xdc, 0x98, 0xe8, 0xd8, 0xfa, 0x84, 0x3c, 0xa3, - 0x86, 0xc8, 0x41, 0xb9, 0x3a, 0xd8, 0xde, 0x67, 0xdb, 0xc8, 0x23, 0xca, 0x15, 0xf6, 0x8d, 0xf3, - 0xcb, 0x45, 0x89, 0xe8, 0xd7, 0xe1, 0x12, 0x13, 0xe4, 0x72, 0x97, 0x1f, 0xee, 0x39, 0xf2, 0xd6, - 0xd0, 0x23, 0xd8, 0xa1, 0xf1, 0xa4, 0xf5, 0x09, 0x19, 0xa9, 0x03, 0x89, 0x48, 0x83, 0xcb, 0xec, - 0x0d, 0x3c, 0x20, 0xd1, 0xe6, 0x31, 0x74, 0xf3, 0x37, 0xe9, 0x2b, 0xde, 0x19, 0xf6, 0x8a, 0xd8, - 0x38, 0xc9, 0xfa, 0x84, 0x3c, 0xa7, 0x0e, 0xa6, 0x06, 0xd5, 0xb0, 0x79, 0xe8, 0x17, 0xef, 0x6e, - 0xef, 0x8c, 0xae, 0x46, 0x5c, 0xc8, 0x9c, 0x5f, 0x8d, 0x48, 0x22, 0x69, 0x40, 0x3f, 0xf0, 0x9d, - 0x76, 0xa6, 0x99, 0xa1, 0x0d, 0x18, 0x13, 0x1f, 0x46, 0x1a, 0xf0, 0x20, 0x44, 0x46, 0x65, 0x48, - 0xed, 0x6b, 0xf3, 0x85, 0xa1, 0x0b, 0xa8, 0x1f, 0x03, 0x55, 0x9f, 0x90, 0x53, 0xfb, 0x1a, 0xfa, - 0x08, 0xb2, 0x2c, 0xa0, 0xe5, 0xd8, 0x9c, 0x2f, 0x0e, 0x9d, 0xc4, 0xa3, 0x61, 0x41, 0xf5, 0x09, - 0x99, 0xc6, 0xd0, 0xf0, 0x8e, 0xcc, 0x83, 0x15, 0xa8, 0x88, 0xf2, 0x88, 0x38, 0xd6, 0xbe, 0x90, - 0x11, 0xd2, 0x61, 0x6c, 0x9f, 0x88, 0xb6, 0xa1, 0xc8, 0x27, 0x70, 0xcf, 0xf9, 0x5a, 0x1c, 0xea, - 0xe4, 0x10, 0xe7, 0x7f, 0x5d, 0xa7, 0x1b, 0x55, 0x21, 0x3a, 0x69, 0xbb, 0xa8, 0x44, 0xde, 0x76, - 0xb3, 0x43, 0xdb, 0x6e, 0xa8, 0x2f, 0x30, 0x69, 0x3b, 0x7b, 0x20, 0x11, 0x7d, 0x1b, 0x26, 0xd9, - 0x38, 0x41, 0x54, 0x64, 0x9c, 0xdf, 0x4e, 0xdf, 0x10, 0x61, 0xf9, 0xc9, 0xec, 0xe5, 0x72, 0x9f, - 0x46, 0xa5, 0x6d, 0xed, 0xcf, 0xcf, 0x0d, 0x9d, 0xbd, 0x06, 0xbd, 0x33, 0xc9, 0xec, 0xe5, 0x06, - 0x54, 0xd2, 0x81, 0x6c, 0x96, 0xc2, 0x87, 0xd8, 0xa5, 0xa1, 0x1d, 0x28, 0xc6, 0xd5, 0xb1, 0x4e, - 0xa3, 0x4d, 0x02, 0xb2, 0x3f, 0xb1, 0x3a, 0x58, 0xa1, 0x93, 0xe2, 0xe5, 0xd1, 0x13, 0x6b, 0xe4, - 0xa2, 0x27, 0x7f, 0x62, 0x65, 0x54, 0xf4, 0x1c, 0x44, 0x7e, 0xdb, 0x88, 0xe2, 0xb9, 0xde, 0xcc, - 0x5f, 0xa1, 0xf2, 0xee, 0xc5, 0x2e, 0x88, 0x71, 0x5e, 0x59, 0x75, 0x82, 0x28, 0xa2, 0x29, 0xe8, - 0x63, 0x98, 0xa5, 0xf2, 0x14, 0x2d, 0xb8, 0x20, 0x66, 0x7e, 0x7e, 0xe0, 0xba, 0x91, 0xe1, 0x77, - 0xc9, 0x78, 0x92, 0x45, 0xad, 0x2f, 0x89, 0x8c, 0x07, 0xc3, 0x34, 0x5c, 0xba, 0x76, 0x2f, 0x0c, - 0x1d, 0x0f, 0xd1, 0xcb, 0x31, 0xc9, 0x78, 0x30, 0x18, 0x85, 0x74, 0xe3, 0xbe, 0x19, 0xef, 0xcd, - 0xa1, 0xdd, 0x78, 0xc8, 0x64, 0x57, 0x70, 0x23, 0xf3, 0xdc, 0x2a, 0x00, 0xc3, 0x91, 0xd4, 0x34, - 0x5e, 0x1c, 0x6a, 0x00, 0xf4, 0xbb, 0x22, 0x12, 0x03, 0xa0, 0xed, 0xd1, 0x88, 0x01, 0xc0, 0x0e, - 0x3d, 0xe6, 0xaf, 0x0f, 0x5f, 0xac, 0xc2, 0xc7, 0xa2, 0x74, 0xb1, 0xa2, 0x04, 0xb4, 0x02, 0x39, - 0x62, 0xd4, 0x9f, 0xd0, 0x11, 0x7e, 0x63, 0x28, 0x86, 0xef, 0x8b, 0x51, 0xaa, 0x4f, 0xc8, 0xd9, - 0x97, 0x9c, 0x44, 0x7a, 0x15, 0x13, 0xc1, 0xc7, 0xf6, 0xfd, 0xa1, 0xbd, 0x6a, 0x30, 0x38, 0x85, - 0xf4, 0xaa, 0x97, 0x01, 0x35, 0x58, 0xf2, 0x1c, 0x76, 0x9c, 0x31, 0xff, 0xf6, 0xe8, 0x25, 0x2f, - 0x7a, 0xf8, 0xe2, 0x2f, 0x79, 0x9c, 0xcc, 0x96, 0x3c, 0x5d, 0x71, 0x1c, 0xea, 0xe1, 0x30, 0x7f, - 0x6b, 0xc4, 0x92, 0xd7, 0xb7, 0xc1, 0xc9, 0x96, 0x3c, 0xbd, 0xc9, 0x38, 0x89, 0xf5, 0x67, 0x7b, - 0xb7, 0xeb, 0x70, 0x78, 0x77, 0x67, 0xa8, 0xf5, 0x17, 0x7b, 0xfd, 0x0f, 0xb1, 0xfe, 0xec, 0x48, - 0x02, 0xfa, 0x0e, 0x4c, 0xf3, 0x0d, 0xa5, 0xf9, 0xbb, 0x23, 0x6c, 0xec, 0xf0, 0x1e, 0x20, 0xe9, - 0x8e, 0x9c, 0x87, 0x4d, 0x0e, 0x6c, 0x23, 0x8b, 0x4d, 0x7e, 0xf7, 0x46, 0x4c, 0x0e, 0x03, 0x7b, - 0x69, 0x6c, 0x72, 0x08, 0xc8, 0xa4, 0x34, 0x0e, 0xdb, 0x84, 0x99, 0xff, 0xa5, 0xa1, 0xa5, 0x89, - 0xee, 0x46, 0x91, 0xd2, 0x70, 0x1e, 0xba, 0x58, 0xd0, 0xb5, 0x9a, 0x69, 0xe7, 0x1b, 0xc3, 0x17, - 0x8b, 0x7e, 0x58, 0x5f, 0xf7, 0x8e, 0x8b, 0x98, 0x56, 0xfe, 0x8a, 0x00, 0xd7, 0x59, 0x1f, 0xa0, - 0x9b, 0xe5, 0x27, 0x8a, 0x7f, 0xd6, 0x11, 0xda, 0xb3, 0x78, 0x40, 0xc5, 0x7f, 0xfb, 0xe2, 0x5b, - 0xf3, 0xde, 0x1b, 0xdf, 0x52, 0x47, 0xe5, 0x23, 0xca, 0xe8, 0x30, 0x74, 0x37, 0xff, 0x70, 0xa8, - 0x32, 0xa2, 0x88, 0x94, 0x28, 0x83, 0xf3, 0xa0, 0x36, 0xcc, 0xb3, 0x21, 0x11, 0xa0, 0x1f, 0xbf, - 0xe8, 0x8f, 0x86, 0x3a, 0x0d, 0x8e, 0xc4, 0x7d, 0xf5, 0x09, 0xf9, 0xca, 0xcb, 0xd8, 0x0c, 0x95, - 0x69, 0x7e, 0xf8, 0xec, 0x07, 0x9a, 0x96, 0x44, 0x71, 0x2d, 0x93, 0xbd, 0x2a, 0xce, 0xaf, 0x65, - 0xb2, 0x6f, 0x88, 0x0b, 0x6b, 0x99, 0xec, 0x35, 0xf1, 0xcd, 0xb5, 0x4c, 0x76, 0x49, 0xbc, 0xbe, - 0x96, 0xc9, 0x4a, 0xe2, 0x4d, 0xe9, 0x77, 0x16, 0xa0, 0xe0, 0xa1, 0x37, 0x86, 0xa2, 0x1e, 0x86, - 0x51, 0xd4, 0xe2, 0x30, 0x14, 0xc5, 0xf1, 0x1e, 0x87, 0x51, 0x0f, 0xc3, 0x30, 0x6a, 0x71, 0x18, - 0x8c, 0x0a, 0x78, 0x08, 0x8e, 0x6a, 0x0d, 0xc3, 0x51, 0xf7, 0xc6, 0xc0, 0x51, 0xbe, 0xa8, 0x7e, - 0x20, 0xb5, 0x3a, 0x08, 0xa4, 0xde, 0x1e, 0x0d, 0xa4, 0x7c, 0x51, 0x21, 0x24, 0xf5, 0x41, 0x1f, - 0x92, 0xba, 0x31, 0x02, 0x49, 0xf9, 0xfc, 0x1e, 0x94, 0x5a, 0x8f, 0x85, 0x52, 0xb7, 0xcf, 0x83, - 0x52, 0xbe, 0x9c, 0x08, 0x96, 0xaa, 0xc7, 0x61, 0xa9, 0x5b, 0xe7, 0x60, 0x29, 0x5f, 0x54, 0x18, - 0x4c, 0xad, 0xc7, 0x82, 0xa9, 0xdb, 0xe7, 0x81, 0xa9, 0xa0, 0x58, 0x61, 0x34, 0xf5, 0xad, 0x08, - 0x9a, 0x5a, 0x1a, 0x8a, 0xa6, 0x7c, 0x6e, 0x06, 0xa7, 0x3e, 0xec, 0x87, 0x53, 0x37, 0x46, 0xc0, - 0xa9, 0x40, 0xb1, 0x1c, 0x4f, 0xd5, 0xe3, 0xf0, 0xd4, 0xad, 0x73, 0xf0, 0x54, 0xa0, 0x8b, 0x10, - 0xa0, 0xda, 0x8a, 0x07, 0x54, 0x77, 0xce, 0x05, 0x54, 0xbe, 0xb4, 0x28, 0xa2, 0xaa, 0xc7, 0x21, - 0xaa, 0x5b, 0xe7, 0x20, 0xaa, 0xbe, 0x92, 0x31, 0x48, 0xa5, 0x8e, 0x84, 0x54, 0xef, 0x8c, 0x09, - 0xa9, 0x7c, 0xd1, 0x71, 0x98, 0x4a, 0x1f, 0x8d, 0xa9, 0xca, 0xe3, 0x62, 0x2a, 0xff, 0x25, 0xb1, - 0xa0, 0x4a, 0x1d, 0x09, 0xaa, 0xde, 0x19, 0x13, 0x54, 0xf5, 0x55, 0x24, 0x8a, 0xaa, 0xb6, 0xe2, - 0x51, 0xd5, 0x9d, 0x73, 0x51, 0x55, 0xd0, 0x8a, 0x11, 0x58, 0xb5, 0x1c, 0x82, 0x55, 0x6f, 0x0d, - 0x81, 0x55, 0x3e, 0x2b, 0xc1, 0x55, 0xdf, 0x1d, 0xc0, 0x55, 0xd2, 0x28, 0x5c, 0xe5, 0xf3, 0xfa, - 0xc0, 0xaa, 0x1e, 0x07, 0xac, 0x6e, 0x9d, 0x03, 0xac, 0x82, 0x7e, 0x13, 0x42, 0x56, 0xcf, 0x86, - 0x20, 0xab, 0xbb, 0xe7, 0x23, 0x2b, 0x5f, 0x5e, 0x1f, 0xb4, 0x52, 0x47, 0x42, 0xab, 0x77, 0xc6, - 0x84, 0x56, 0x41, 0x0b, 0xc6, 0x60, 0xab, 0xf7, 0xa2, 0xd8, 0xea, 0xfa, 0x70, 0x6c, 0xe5, 0x8b, - 0xe1, 0xe0, 0x6a, 0x3d, 0x16, 0x5c, 0xdd, 0x3e, 0x0f, 0x5c, 0x05, 0xb3, 0x59, 0x18, 0x5d, 0x6d, - 0xc5, 0xa3, 0xab, 0x3b, 0xe7, 0xa2, 0xab, 0xa0, 0x23, 0x45, 0xe0, 0xd5, 0x7a, 0x2c, 0xbc, 0xba, - 0x7d, 0x1e, 0xbc, 0xea, 0x9b, 0x6a, 0x39, 0xbe, 0x7a, 0x31, 0x14, 0x5f, 0xdd, 0x1f, 0x07, 0x5f, - 0xf9, 0x42, 0x07, 0x00, 0xd6, 0x27, 0xc3, 0x01, 0xd6, 0x2f, 0x5d, 0xe0, 0xb2, 0xce, 0x58, 0x84, - 0xf5, 0xdd, 0x01, 0x84, 0x25, 0x8d, 0x42, 0x58, 0xc1, 0xc8, 0xf0, 0x20, 0x56, 0x2d, 0x06, 0x10, - 0xbd, 0x3d, 0x1a, 0x10, 0x05, 0x0b, 0x79, 0x80, 0x88, 0x3e, 0xe8, 0x43, 0x44, 0x37, 0xce, 0xf5, - 0x8b, 0x0b, 0x41, 0xa2, 0xca, 0x20, 0x24, 0xba, 0x39, 0x12, 0x12, 0xf9, 0x12, 0x02, 0x4c, 0xb4, - 0x1e, 0x8b, 0x89, 0x6e, 0x9f, 0x87, 0x89, 0x82, 0xae, 0x10, 0x06, 0x45, 0x5b, 0xf1, 0xa0, 0xe8, - 0xce, 0xb9, 0xa0, 0xa8, 0x6f, 0xd9, 0xf2, 0x50, 0x51, 0x3d, 0x0e, 0x15, 0xdd, 0x3a, 0x07, 0x15, - 0x85, 0x97, 0x2d, 0x1f, 0x16, 0xb5, 0x86, 0xc1, 0xa2, 0x7b, 0x63, 0xc0, 0xa2, 0xc0, 0x98, 0xeb, - 0xc3, 0x45, 0x1f, 0xf5, 0xe3, 0x22, 0x69, 0x14, 0x2e, 0x0a, 0x3a, 0x91, 0x07, 0x8c, 0xb6, 0xe2, - 0x81, 0xd1, 0x9d, 0x73, 0x81, 0x51, 0x78, 0x5c, 0x87, 0x90, 0xd1, 0x47, 0xfd, 0xc8, 0x48, 0x1a, - 0x85, 0x8c, 0x82, 0xf2, 0x78, 0xd0, 0xa8, 0x1e, 0x07, 0x8d, 0x6e, 0x9d, 0x03, 0x8d, 0x42, 0xd3, - 0x7d, 0x80, 0x8d, 0xfe, 0xea, 0xf8, 0xd8, 0xe8, 0xbd, 0xd7, 0x75, 0x5b, 0x3a, 0x1f, 0x1c, 0x7d, - 0xd4, 0x0f, 0x8e, 0xa4, 0x51, 0xe0, 0x28, 0xd0, 0x87, 0x87, 0x8e, 0x3a, 0xe7, 0xa2, 0xa3, 0x07, - 0x17, 0x40, 0x47, 0xbe, 0xfc, 0x2f, 0x0d, 0x8f, 0xde, 0x14, 0xdf, 0x8a, 0x80, 0xa4, 0xff, 0x39, - 0x0d, 0x53, 0xfc, 0x3b, 0x55, 0x91, 0xbb, 0x9d, 0x84, 0xd7, 0xb9, 0xdb, 0x09, 0x7d, 0x07, 0xae, - 0xf9, 0x0f, 0xd4, 0xf3, 0x44, 0xe1, 0x11, 0x2f, 0x5a, 0xdb, 0xd2, 0x0e, 0xe9, 0xda, 0x93, 0x95, - 0xe7, 0xfd, 0x2c, 0x8f, 0x6d, 0xab, 0xc3, 0x22, 0x5f, 0xe8, 0x79, 0x3e, 0x5a, 0x25, 0x83, 0x82, - 0x1a, 0x59, 0xe7, 0x5f, 0x28, 0x38, 0x78, 0xe5, 0x1d, 0x67, 0x7d, 0x8d, 0x18, 0x6d, 0xf4, 0x2d, - 0x28, 0xf4, 0x1c, 0x6c, 0x2b, 0x5d, 0xdb, 0xb0, 0x6c, 0xc3, 0x65, 0xd1, 0x26, 0x42, 0x45, 0xfc, - 0xe2, 0x74, 0x69, 0x66, 0xc7, 0xc1, 0xf6, 0x36, 0xa7, 0xcb, 0x33, 0xbd, 0xd0, 0x93, 0xf7, 0x65, - 0xaf, 0xc9, 0xf1, 0xbf, 0xec, 0xf5, 0x0c, 0x44, 0xea, 0x4b, 0x10, 0x5e, 0x97, 0xd8, 0x35, 0x4c, - 0xf1, 0x4b, 0xa8, 0xaa, 0x87, 0x96, 0x1e, 0x7a, 0x1d, 0x53, 0xc9, 0x8e, 0x12, 0xd1, 0x13, 0x28, - 0xda, 0x56, 0x8f, 0xde, 0xb6, 0xd2, 0xb5, 0xda, 0x86, 0x76, 0x42, 0x0d, 0x86, 0x62, 0xfc, 0x99, - 0x29, 0xcb, 0xb8, 0x4d, 0xf3, 0xc9, 0x05, 0x3b, 0xfc, 0x88, 0x9a, 0x40, 0x6f, 0x5a, 0xf1, 0xa4, - 0xa0, 0x81, 0xbb, 0xad, 0x47, 0xde, 0x30, 0xff, 0x42, 0x35, 0x5c, 0x2e, 0x17, 0x5e, 0xf9, 0xbf, - 0xd1, 0x03, 0xb8, 0xdc, 0x51, 0x8f, 0xe9, 0xa5, 0xbf, 0x8a, 0x67, 0x88, 0xd0, 0x6b, 0xce, 0xd8, - 0xc7, 0xc2, 0x50, 0x47, 0x3d, 0xa6, 0x1f, 0x31, 0x63, 0x49, 0xf4, 0x0b, 0x24, 0x37, 0x60, 0x86, - 0x87, 0x0f, 0xb0, 0x0f, 0x14, 0x95, 0x68, 0x4e, 0xfe, 0xb5, 0x0a, 0xf6, 0x8d, 0xa2, 0x5b, 0x50, - 0xd4, 0x0d, 0xc7, 0x35, 0x4c, 0xcd, 0xe5, 0xf7, 0x09, 0xb3, 0x1b, 0x79, 0x0b, 0x1e, 0x95, 0x5d, - 0x1a, 0xdc, 0x82, 0x59, 0xad, 0x6d, 0xf8, 0xe6, 0x1d, 0x5b, 0x70, 0x67, 0x87, 0x0e, 0xe7, 0x2a, - 0xcd, 0xdb, 0x7f, 0x44, 0x5f, 0xd2, 0xa2, 0x64, 0x54, 0x85, 0xd2, 0xbe, 0xea, 0xe2, 0x57, 0xea, - 0x89, 0xe2, 0x45, 0xc7, 0xe5, 0x69, 0x44, 0xf0, 0xb5, 0xb3, 0xd3, 0xa5, 0xc2, 0x13, 0x96, 0x34, - 0x10, 0x24, 0x57, 0xd8, 0x0f, 0x25, 0xe8, 0xe8, 0x0e, 0x94, 0x54, 0xe7, 0xc4, 0xd4, 0x68, 0x4f, - 0xc0, 0xa6, 0xd3, 0x73, 0xa8, 0x75, 0x9e, 0x95, 0x8b, 0x94, 0x5c, 0xf5, 0xa8, 0xe8, 0x03, 0x58, - 0xe0, 0x9f, 0x0d, 0x78, 0xa5, 0xda, 0xba, 0x42, 0x7b, 0x4f, 0x30, 0x4c, 0x45, 0xca, 0x73, 0x95, - 0x7d, 0x26, 0x80, 0x64, 0x20, 0x5d, 0x26, 0x7c, 0x1d, 0x2f, 0xbb, 0x6e, 0x18, 0xc4, 0xfc, 0x5a, - 0x26, 0x3b, 0x23, 0x16, 0xd6, 0x32, 0xd9, 0xa2, 0x58, 0x92, 0x7e, 0x90, 0x86, 0x12, 0x99, 0x28, - 0x1d, 0xc7, 0xb0, 0xcc, 0xba, 0xef, 0xa8, 0xea, 0x77, 0x7f, 0x81, 0x06, 0x2a, 0xf9, 0xcf, 0x68, - 0x89, 0x06, 0x84, 0x11, 0x83, 0xd4, 0xff, 0x58, 0x48, 0x5a, 0x06, 0x46, 0xa2, 0xa1, 0x39, 0x2b, - 0x30, 0xe5, 0x58, 0x3d, 0x5b, 0xf3, 0xae, 0xb0, 0xbf, 0x37, 0x64, 0x66, 0x0e, 0xbd, 0xb0, 0xdc, - 0xa4, 0x0c, 0x32, 0x67, 0x44, 0x9f, 0x40, 0x89, 0xfd, 0xa2, 0x41, 0x30, 0x34, 0x08, 0x85, 0x45, - 0xf8, 0x3c, 0x18, 0x5b, 0xd6, 0x06, 0x67, 0x94, 0x8b, 0x4e, 0xe4, 0x19, 0x7d, 0x04, 0x6f, 0x9a, - 0x96, 0xd2, 0xc1, 0x1d, 0x8b, 0xcd, 0xc8, 0xa4, 0x0f, 0xeb, 0x8a, 0xea, 0x2a, 0xbc, 0xd0, 0xcc, - 0xf3, 0x71, 0xde, 0xb4, 0x36, 0x69, 0x16, 0x99, 0xe7, 0x58, 0x71, 0x99, 0x5c, 0xa9, 0x0c, 0x53, - 0xec, 0x17, 0xca, 0xc1, 0xe4, 0xd3, 0x56, 0xbd, 0x26, 0x8b, 0x13, 0x68, 0x06, 0xb2, 0x8f, 0xe5, - 0xa7, 0x9b, 0x4a, 0xf3, 0xd9, 0x86, 0x28, 0xa0, 0x3c, 0x4c, 0xcb, 0x4f, 0x9f, 0xb6, 0x94, 0xf5, - 0xe7, 0x62, 0x4a, 0xba, 0x03, 0xc5, 0x68, 0x89, 0x10, 0xc0, 0x94, 0x5c, 0xdb, 0x7c, 0x4a, 0xef, - 0x6d, 0xcf, 0xc1, 0xe4, 0xc6, 0xd3, 0xea, 0xca, 0x86, 0x28, 0x48, 0x7f, 0x22, 0xc0, 0x4c, 0x85, - 0x7d, 0x88, 0x80, 0x79, 0x3e, 0x7c, 0xd0, 0xe7, 0x92, 0xf0, 0x46, 0x3c, 0xe2, 0x8b, 0x77, 0x45, - 0x58, 0x81, 0x2c, 0x1f, 0x63, 0x5e, 0xb0, 0xc4, 0xd2, 0x70, 0x3b, 0x9f, 0x6e, 0x89, 0x79, 0x0e, - 0x6f, 0x1e, 0x1b, 0x6a, 0x82, 0xa8, 0x7a, 0xba, 0x55, 0x78, 0x49, 0x86, 0xbb, 0xbd, 0xf5, 0x35, - 0x83, 0x37, 0x62, 0xd4, 0x28, 0xf9, 0xfd, 0xcc, 0xe7, 0x3f, 0x5e, 0x9a, 0x90, 0xfe, 0x34, 0x03, - 0x85, 0x4a, 0xf8, 0xa3, 0x0b, 0xa8, 0xd1, 0x57, 0xd9, 0x38, 0xeb, 0x25, 0xc2, 0x51, 0x1e, 0xf1, - 0x39, 0x9b, 0x5c, 0xf0, 0x85, 0x07, 0x56, 0xf7, 0xeb, 0x23, 0xbc, 0x39, 0xc2, 0x95, 0x0f, 0x18, - 0x17, 0xfe, 0x6d, 0xda, 0x5f, 0x0d, 0xcb, 0x30, 0xc9, 0x02, 0xf2, 0x84, 0x81, 0xbb, 0x02, 0xe8, - 0x3c, 0x48, 0xac, 0x6b, 0x92, 0x2e, 0xb3, 0x6c, 0x64, 0xf5, 0x6c, 0xbd, 0xd6, 0xcd, 0x88, 0x81, - 0xcd, 0x71, 0xf1, 0x0f, 0x45, 0xf6, 0xd8, 0xcd, 0x98, 0xff, 0x1f, 0x3d, 0xed, 0xc8, 0xfb, 0xd0, - 0xaf, 0x41, 0x49, 0xb3, 0xda, 0x6d, 0x66, 0x94, 0xb1, 0xf9, 0x77, 0xf0, 0xae, 0x1c, 0x5a, 0x04, - 0xfe, 0x6d, 0xd0, 0xb2, 0xff, 0x8d, 0xd0, 0xb2, 0xcc, 0xbf, 0x11, 0x1a, 0x0a, 0x83, 0x28, 0xfa, - 0xc2, 0xd8, 0xb4, 0xdd, 0x17, 0x91, 0x31, 0xfd, 0x3a, 0x11, 0x19, 0x2c, 0x8e, 0x85, 0xf7, 0xbc, - 0x3f, 0x14, 0xb8, 0x3f, 0xdc, 0x86, 0x65, 0x1d, 0xf6, 0x7c, 0x2f, 0xa3, 0x85, 0xf0, 0x3d, 0x97, - 0x81, 0xb3, 0x38, 0x0d, 0x76, 0x8a, 0x5b, 0xa8, 0x53, 0x5f, 0x6e, 0xa1, 0xbe, 0x01, 0x33, 0x5d, - 0x1b, 0xef, 0x61, 0x57, 0x3b, 0x50, 0xcc, 0x5e, 0x87, 0x47, 0x7a, 0xe5, 0x3d, 0xda, 0x56, 0xaf, - 0x83, 0xee, 0x81, 0xe8, 0x67, 0xe1, 0x40, 0xd9, 0xbb, 0x64, 0xcd, 0xa3, 0x73, 0x58, 0x2d, 0xfd, - 0x0f, 0x01, 0xe6, 0x22, 0x75, 0xe2, 0x63, 0x6a, 0x0d, 0xf2, 0xba, 0x6f, 0x1a, 0x39, 0xf3, 0xc2, - 0x05, 0xc3, 0x08, 0xc2, 0xcc, 0x48, 0x81, 0x2b, 0xde, 0x6b, 0xe9, 0x57, 0x11, 0x02, 0xb1, 0xa9, - 0x0b, 0x8a, 0xbd, 0x1c, 0xc8, 0x59, 0x0d, 0xbd, 0xc0, 0x1f, 0x64, 0xe9, 0xb1, 0x06, 0x99, 0xf4, - 0xbf, 0x04, 0x10, 0xe9, 0x0b, 0x1e, 0x63, 0xac, 0x27, 0x32, 0x65, 0x7a, 0xf1, 0x3a, 0xa9, 0xf1, - 0x63, 0xb9, 0x22, 0x5f, 0x72, 0x49, 0xf7, 0x7d, 0xc9, 0x25, 0x6e, 0xfe, 0xcc, 0x7c, 0xc9, 0xf9, - 0x53, 0xfa, 0xb1, 0x00, 0x45, 0xbf, 0xda, 0xec, 0x13, 0x8e, 0x23, 0xee, 0x68, 0x7d, 0xbd, 0xcf, - 0x14, 0x7a, 0x77, 0xc9, 0x8c, 0xf5, 0x55, 0xc9, 0xf0, 0x5d, 0x32, 0xec, 0xf3, 0x7a, 0x7f, 0xcb, - 0xeb, 0x8e, 0xa4, 0x88, 0xd5, 0xe0, 0x12, 0x8f, 0xd7, 0x88, 0x95, 0xfb, 0x2a, 0x1c, 0xea, 0x1e, - 0x87, 0x14, 0x48, 0x7b, 0x14, 0xd1, 0xd2, 0x58, 0xf3, 0xbb, 0xa7, 0x25, 0xd6, 0x01, 0x7f, 0x1a, - 0x6e, 0x09, 0x16, 0x04, 0xfe, 0x08, 0xd2, 0x47, 0x6a, 0x7b, 0x94, 0x07, 0x61, 0xa4, 0xe5, 0x64, - 0x92, 0x1b, 0x3d, 0x8e, 0xdc, 0x7d, 0x92, 0x1a, 0xbe, 0x89, 0x36, 0xa8, 0xd2, 0xc8, 0x1d, 0x29, - 0xdf, 0x8e, 0x0e, 0xa0, 0x91, 0xaf, 0x0f, 0x8f, 0xa4, 0xf7, 0x33, 0x3f, 0xf9, 0xf1, 0x92, 0x20, - 0x7d, 0x08, 0x88, 0xd8, 0x3a, 0xee, 0xb3, 0x9e, 0x65, 0x07, 0xf7, 0xc8, 0xf4, 0xc7, 0xe5, 0x4c, - 0xc6, 0xc7, 0xe5, 0x48, 0x97, 0x61, 0x2e, 0xc2, 0xcd, 0x66, 0x20, 0xe9, 0xdb, 0xf0, 0xc6, 0x13, - 0xcb, 0x71, 0x8c, 0x6e, 0xb3, 0xb7, 0xcb, 0x86, 0x3a, 0x59, 0xaf, 0xfc, 0x39, 0x37, 0xdb, 0xa5, - 0x3b, 0x34, 0x26, 0x9b, 0x9b, 0x72, 0xb2, 0xff, 0x2c, 0xfd, 0x4b, 0x01, 0xae, 0x0e, 0x72, 0x32, - 0x2d, 0xc7, 0x85, 0xf6, 0x4e, 0x6b, 0x56, 0x70, 0xcd, 0xe1, 0xf9, 0xbd, 0xd5, 0xcb, 0x4e, 0x6c, - 0x6f, 0xfe, 0x4e, 0xa5, 0xa3, 0xd2, 0x39, 0x89, 0x47, 0xdd, 0x17, 0x39, 0x79, 0x93, 0x51, 0x83, - 0xe9, 0x29, 0x33, 0xde, 0xf4, 0xf4, 0xbf, 0x05, 0x98, 0x6d, 0x61, 0x53, 0x35, 0x5d, 0x32, 0xef, - 0xf7, 0x3a, 0x2c, 0x1c, 0xba, 0x04, 0x69, 0x5b, 0xe9, 0xd1, 0xa2, 0x0b, 0x72, 0xca, 0xde, 0x41, - 0x37, 0xa1, 0x40, 0xd7, 0x96, 0x90, 0xad, 0x26, 0xdc, 0xcd, 0xc8, 0xd4, 0xcb, 0x5c, 0xf6, 0x0c, - 0xb1, 0xb7, 0x00, 0x68, 0x26, 0x86, 0x81, 0xd2, 0x34, 0x47, 0x8e, 0x50, 0x7c, 0x04, 0x44, 0xa3, - 0x76, 0x02, 0x21, 0xcc, 0x31, 0xbf, 0x40, 0xa9, 0xbe, 0x94, 0x25, 0xc8, 0xb3, 0x6c, 0x4c, 0xcc, - 0x24, 0xcd, 0x03, 0x94, 0xc4, 0xe4, 0x3c, 0x86, 0x4b, 0xce, 0xcb, 0xb6, 0xd2, 0xb5, 0x74, 0x47, - 0xd1, 0xba, 0x3d, 0xee, 0xf1, 0xcc, 0xbe, 0x0a, 0x2b, 0x54, 0x2e, 0x9f, 0x9d, 0x2e, 0xcd, 0x36, - 0x9f, 0x6d, 0x6c, 0x5b, 0xba, 0x53, 0xdd, 0xde, 0x61, 0xfe, 0xce, 0x8e, 0x3c, 0xeb, 0xbc, 0x6c, - 0x53, 0x52, 0xb7, 0xc7, 0x49, 0xd2, 0x67, 0x29, 0x40, 0xf4, 0x5a, 0x8d, 0x0a, 0xbd, 0x97, 0xc2, - 0x6b, 0x6e, 0x0b, 0x16, 0xb5, 0x40, 0x15, 0x8a, 0x63, 0x98, 0xc4, 0xbe, 0x57, 0x1d, 0xd7, 0x2b, - 0x37, 0x1f, 0x37, 0xb1, 0xb7, 0x01, 0xf6, 0x6b, 0x92, 0xb7, 0xe3, 0xb5, 0x90, 0xc4, 0x26, 0x11, - 0xb8, 0xa1, 0x3a, 0xfe, 0x0b, 0xef, 0x41, 0xce, 0xa5, 0x7c, 0xde, 0xa5, 0x25, 0x99, 0xca, 0xcc, - 0xd9, 0xe9, 0x52, 0x96, 0x09, 0x6b, 0xac, 0xca, 0x59, 0x96, 0xdc, 0xd0, 0xd1, 0x32, 0xe4, 0x0d, - 0xd3, 0x71, 0x55, 0x52, 0x24, 0xbe, 0x55, 0x50, 0x60, 0x01, 0xb2, 0x0d, 0x4e, 0x6e, 0xac, 0xca, - 0xe0, 0x65, 0xa1, 0x71, 0x68, 0x45, 0x9f, 0x81, 0x6d, 0xa6, 0xd3, 0xa0, 0x49, 0xb9, 0xe0, 0x51, - 0xd9, 0xb5, 0x5a, 0x4d, 0x98, 0x8b, 0x68, 0x82, 0x2f, 0xcc, 0x1f, 0x46, 0x27, 0x9c, 0xb0, 0x75, - 0xea, 0x7d, 0x54, 0xbe, 0x5c, 0x33, 0x35, 0x4b, 0xe7, 0x23, 0x35, 0x3a, 0xf1, 0xb4, 0xa0, 0xb4, - 0x66, 0x19, 0x26, 0x41, 0x8f, 0x5e, 0x55, 0x57, 0xa0, 0xb8, 0x6b, 0x98, 0xaa, 0x7d, 0xa2, 0x78, - 0x0e, 0xde, 0xc2, 0x79, 0x0e, 0xde, 0x72, 0x81, 0x71, 0xf0, 0x47, 0xe9, 0xe7, 0x02, 0x88, 0x81, - 0x58, 0x5e, 0xd0, 0x6f, 0x00, 0x68, 0xed, 0x9e, 0xe3, 0x62, 0xdb, 0x9b, 0x00, 0x66, 0x58, 0x20, - 0x59, 0x95, 0x51, 0x1b, 0xab, 0x72, 0x8e, 0x67, 0x68, 0xe8, 0xe8, 0x66, 0xf4, 0x8e, 0x98, 0xc9, - 0x0a, 0x9c, 0x0d, 0xdc, 0x0c, 0x43, 0x66, 0x14, 0xc7, 0xb5, 0x6c, 0x5f, 0xcf, 0x7c, 0x46, 0xf1, - 0x6e, 0xcf, 0xa2, 0xb7, 0x44, 0x60, 0x1a, 0x2b, 0x5a, 0x24, 0xe6, 0xed, 0x11, 0xf6, 0xab, 0x94, - 0x39, 0xbf, 0x4a, 0x8c, 0xc3, 0xab, 0xd2, 0xef, 0x0b, 0x50, 0xaa, 0xb2, 0x81, 0xee, 0x4f, 0x1e, - 0x23, 0x16, 0xcb, 0x55, 0xc8, 0xba, 0xc7, 0xa6, 0xd2, 0xc1, 0xfe, 0x07, 0x9f, 0x2e, 0x70, 0xbd, - 0xe5, 0xb4, 0xcb, 0x1e, 0xe9, 0x37, 0x44, 0xf9, 0x07, 0xec, 0xf9, 0x4c, 0xfc, 0x46, 0x99, 0x7d, - 0xe1, 0xbe, 0xec, 0x7d, 0xe1, 0xbe, 0xbc, 0xca, 0x33, 0x30, 0x23, 0xe4, 0xf3, 0xff, 0xb0, 0x24, - 0xc8, 0x3e, 0x13, 0xb3, 0x53, 0xef, 0x37, 0xc9, 0x84, 0x3a, 0x60, 0x49, 0xa2, 0x22, 0x40, 0xe8, - 0x4b, 0x5e, 0xfc, 0x9b, 0xe9, 0x2b, 0xab, 0xca, 0xce, 0x56, 0xf5, 0xe9, 0xe6, 0x66, 0xa3, 0xd5, - 0xaa, 0xad, 0x8a, 0x02, 0x12, 0x61, 0x26, 0xf2, 0x1d, 0xb0, 0x14, 0xfb, 0x8a, 0xfa, 0xfd, 0x77, - 0xa0, 0x10, 0xd9, 0xf6, 0x41, 0x25, 0xc8, 0x6f, 0xd4, 0x56, 0x9a, 0xb5, 0xfa, 0xd3, 0x8d, 0x55, - 0x0a, 0x64, 0xf3, 0x30, 0xbd, 0x55, 0x5b, 0x91, 0x6b, 0xcd, 0x96, 0x28, 0xdc, 0xff, 0x0b, 0x00, - 0xc1, 0x17, 0x08, 0xc9, 0xab, 0xd7, 0x6b, 0x1f, 0x2b, 0xcf, 0x57, 0x36, 0x76, 0x6a, 0x4d, 0x71, - 0x02, 0x21, 0x28, 0x56, 0x56, 0x5a, 0xd5, 0xba, 0x22, 0xd7, 0x9a, 0xdb, 0x4f, 0xb7, 0x9a, 0x35, - 0xef, 0x63, 0xed, 0xf7, 0x57, 0x61, 0x26, 0x7c, 0xc7, 0x17, 0x9a, 0x83, 0x52, 0xb5, 0x5e, 0xab, - 0xae, 0x2b, 0xcf, 0x1b, 0x2b, 0xca, 0xb3, 0x9d, 0xda, 0x0e, 0x41, 0xbe, 0xa4, 0x26, 0x94, 0xf8, - 0x78, 0x67, 0x83, 0x80, 0xe6, 0x12, 0xe4, 0xd9, 0x33, 0xfd, 0xc4, 0x98, 0x98, 0xba, 0xbf, 0x09, - 0xf9, 0xd0, 0xdd, 0xe3, 0xe4, 0x75, 0xdb, 0x3b, 0xcd, 0xba, 0xd2, 0x6a, 0x6c, 0xd6, 0x9a, 0xad, - 0x95, 0xcd, 0x6d, 0x26, 0x83, 0xd2, 0x56, 0x2a, 0x4f, 0xe5, 0x96, 0x28, 0xf8, 0xcf, 0xad, 0xa7, - 0x3b, 0xd5, 0xba, 0x57, 0x6b, 0x29, 0x93, 0x4d, 0x8b, 0xe9, 0xfb, 0xc7, 0x70, 0x75, 0xc8, 0x75, - 0x57, 0xa4, 0xd2, 0x3b, 0x26, 0xbd, 0x87, 0x59, 0x9c, 0x40, 0x05, 0xc8, 0x91, 0x9e, 0x4a, 0x83, - 0xe1, 0x45, 0x01, 0x65, 0x21, 0x73, 0xe0, 0xba, 0x5d, 0x31, 0x85, 0xa6, 0x20, 0xe5, 0x3c, 0x12, - 0xd3, 0xe4, 0xff, 0xbe, 0x23, 0x66, 0x08, 0x74, 0x57, 0x3f, 0xed, 0xd9, 0x58, 0x9c, 0x24, 0xf0, - 0xbf, 0xe7, 0x60, 0x7b, 0xcf, 0x68, 0x63, 0x71, 0x9a, 0xb0, 0x98, 0xbd, 0x76, 0x5b, 0xcc, 0x4a, - 0x99, 0xec, 0x94, 0x38, 0x75, 0xff, 0x06, 0x84, 0x6e, 0x1d, 0x21, 0xe8, 0x7f, 0x43, 0x75, 0xb1, - 0xe3, 0x8a, 0x13, 0x68, 0x1a, 0xd2, 0x2b, 0xed, 0xb6, 0x28, 0x3c, 0xfc, 0x7c, 0x12, 0xb2, 0xde, - 0x17, 0xb4, 0xd0, 0x06, 0x4c, 0x52, 0xa4, 0x8b, 0x96, 0x86, 0x63, 0x60, 0x3a, 0xec, 0x17, 0xae, - 0x9f, 0x07, 0x92, 0xa5, 0x09, 0xf4, 0x17, 0x21, 0x1f, 0xc2, 0x06, 0x68, 0xe8, 0x3e, 0x7c, 0x04, - 0x0f, 0x2d, 0xdc, 0x3e, 0x2f, 0x9b, 0x2f, 0xff, 0x05, 0xe4, 0x7c, 0xb3, 0x02, 0xdd, 0x1c, 0x65, - 0x74, 0x78, 0xb2, 0x47, 0x5b, 0x26, 0x64, 0x94, 0x4a, 0x13, 0xef, 0x0a, 0xc8, 0x06, 0x34, 0x68, - 0x01, 0xa0, 0x38, 0x5f, 0xd7, 0xa1, 0x26, 0xc6, 0xc2, 0xfd, 0xb1, 0x72, 0x07, 0xef, 0x24, 0xca, - 0x0a, 0xcc, 0x98, 0x78, 0x65, 0x0d, 0x18, 0x49, 0xf1, 0xca, 0x8a, 0xb1, 0x86, 0x68, 0x63, 0x84, - 0xd6, 0x83, 0x58, 0xf9, 0x83, 0x2b, 0x67, 0xac, 0xfc, 0x98, 0x65, 0x45, 0x9a, 0x40, 0xcf, 0x20, - 0x43, 0xe6, 0x70, 0x14, 0x07, 0x30, 0xfa, 0xd6, 0x8c, 0x85, 0x9b, 0x23, 0xf3, 0x78, 0x22, 0x2b, - 0xf7, 0x7e, 0xf2, 0x1f, 0x17, 0x27, 0x7e, 0x72, 0xb6, 0x28, 0xfc, 0xfc, 0x6c, 0x51, 0xf8, 0xa3, - 0xb3, 0x45, 0xe1, 0x8f, 0xcf, 0x16, 0x85, 0x1f, 0xfe, 0x62, 0x71, 0xe2, 0xe7, 0xbf, 0x58, 0x9c, - 0xf8, 0xa3, 0x5f, 0x2c, 0x4e, 0x7c, 0x32, 0xcd, 0xb9, 0x77, 0xa7, 0xe8, 0x04, 0xf7, 0xe8, 0xff, - 0x05, 0x00, 0x00, 0xff, 0xff, 0xe5, 0x42, 0x49, 0xd7, 0x40, 0x85, 0x00, 0x00, + // 8724 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7d, 0x5b, 0x6c, 0x23, 0x57, + 0x9a, 0x9e, 0x8a, 0xa4, 0x24, 0xf2, 0xa7, 0x48, 0x96, 0x8e, 0xfa, 0x22, 0xab, 0x6d, 0xa9, 0xbb, + 0xda, 0x7d, 0xdd, 0x31, 0xe5, 0xee, 0x9e, 0xc9, 0x78, 0x6d, 0x8f, 0x67, 0x45, 0x8a, 0xdd, 0xa4, + 0x6e, 0xad, 0x2e, 0x52, 0xdd, 0xb0, 0x77, 0x36, 0xb5, 0xa5, 0xaa, 0x23, 0xa9, 0x46, 0x64, 0x15, + 0xbb, 0xaa, 0xa8, 0x96, 0x0c, 0xe4, 0x21, 0xc9, 0x62, 0xe2, 0xa7, 0x60, 0x02, 0x04, 0x58, 0x0f, + 0x36, 0x08, 0x66, 0x2f, 0x48, 0x1e, 0xf2, 0x90, 0x20, 0x09, 0x12, 0x6c, 0x6e, 0x0b, 0xe4, 0x25, + 0x83, 0x60, 0x90, 0x99, 0x7d, 0x5b, 0x04, 0x88, 0xb2, 0xd1, 0xe4, 0x21, 0x8b, 0x20, 0x48, 0x10, + 0x04, 0xd8, 0xc0, 0x40, 0x82, 0xe0, 0x5c, 0xea, 0x46, 0x16, 0x29, 0xaa, 0x5d, 0xce, 0x1a, 0xd8, + 0x17, 0x89, 0xf5, 0x9f, 0xf3, 0xff, 0x75, 0xce, 0x7f, 0x6e, 0xff, 0x77, 0xce, 0xff, 0x9f, 0x82, + 0x59, 0xdb, 0x52, 0xb5, 0x83, 0xee, 0xee, 0xb2, 0xda, 0x35, 0xca, 0x5d, 0xdb, 0x72, 0x2d, 0x34, + 0xab, 0x59, 0xda, 0x21, 0x25, 0x97, 0x79, 0xe2, 0xc2, 0x65, 0x6c, 0xdb, 0x96, 0xed, 0x74, 0x77, + 0x97, 0xd9, 0x0f, 0x96, 0x73, 0xe1, 0xfe, 0xe1, 0xd1, 0xf2, 0xe1, 0x91, 0x83, 0xed, 0x23, 0x6c, + 0x2f, 0x6b, 0x96, 0xa9, 0xf5, 0x6c, 0x1b, 0x9b, 0xda, 0xc9, 0x72, 0xdb, 0xd2, 0x0e, 0xe9, 0x1f, + 0xc3, 0xdc, 0x8f, 0xcb, 0x6b, 0x63, 0x55, 0x77, 0x7a, 0x9d, 0x8e, 0x6a, 0x9f, 0x2c, 0x53, 0xb1, + 0xfc, 0x81, 0xe7, 0x45, 0x5e, 0xa1, 0x74, 0xd5, 0x55, 0x39, 0xed, 0x92, 0x47, 0x8b, 0x94, 0xe0, + 0x8a, 0x47, 0xed, 0x60, 0x57, 0x0d, 0xe5, 0xbe, 0xe6, 0xb8, 0x96, 0xad, 0xee, 0xe3, 0x65, 0x6c, + 0xee, 0x1b, 0x26, 0x26, 0x19, 0x8e, 0x34, 0x8d, 0x27, 0xbe, 0x19, 0x9b, 0xf8, 0x88, 0xa7, 0xce, + 0xf7, 0x5c, 0xa3, 0xbd, 0x7c, 0xd0, 0xd6, 0x96, 0x5d, 0xa3, 0x83, 0x1d, 0x57, 0xed, 0x74, 0xbd, + 0x2a, 0xd0, 0x14, 0xd7, 0x56, 0x35, 0xc3, 0xdc, 0xf7, 0xfe, 0x77, 0x77, 0x97, 0x6d, 0xac, 0x59, + 0xb6, 0x8e, 0x75, 0xc5, 0xe9, 0xaa, 0xa6, 0x57, 0xdc, 0x7d, 0x6b, 0xdf, 0xa2, 0x3f, 0x97, 0xc9, + 0x2f, 0x4e, 0x5d, 0xdc, 0xb7, 0xac, 0xfd, 0x36, 0x5e, 0xa6, 0x4f, 0xbb, 0xbd, 0xbd, 0x65, 0xbd, + 0x67, 0xab, 0xae, 0x61, 0x71, 0x2e, 0xe9, 0x9f, 0x08, 0x50, 0x90, 0xf1, 0xcb, 0x1e, 0x76, 0xdc, + 0x3a, 0x56, 0x75, 0x6c, 0xa3, 0x37, 0x20, 0x7d, 0x88, 0x4f, 0xe6, 0xd3, 0xd7, 0x85, 0xbb, 0x33, + 0x95, 0xe9, 0x2f, 0x4e, 0x97, 0xd2, 0xeb, 0xf8, 0x44, 0x26, 0x34, 0x74, 0x1d, 0xa6, 0xb1, 0xa9, + 0x2b, 0x24, 0x39, 0x13, 0x4d, 0x9e, 0xc2, 0xa6, 0xbe, 0x8e, 0x4f, 0xd0, 0xf7, 0x20, 0xeb, 0x10, + 0x69, 0xa6, 0x86, 0xe7, 0x27, 0xaf, 0x0b, 0x77, 0x27, 0x2b, 0xbf, 0xf2, 0xc5, 0xe9, 0xd2, 0x87, + 0xfb, 0x86, 0x7b, 0xd0, 0xdb, 0x2d, 0x6b, 0x56, 0x67, 0xd9, 0x6f, 0x6a, 0x7d, 0x37, 0xf8, 0xbd, + 0xdc, 0x3d, 0xdc, 0x5f, 0xee, 0xd7, 0x51, 0xb9, 0x75, 0x6c, 0x36, 0xf1, 0x4b, 0xd9, 0x97, 0xb8, + 0x96, 0xc9, 0x0a, 0x62, 0x6a, 0x2d, 0x93, 0x4d, 0x89, 0x69, 0xe9, 0x67, 0x29, 0x28, 0xca, 0xd8, + 0xe9, 0x5a, 0xa6, 0x83, 0x79, 0xc9, 0xdf, 0x85, 0xb4, 0x7b, 0x6c, 0xd2, 0x92, 0xe7, 0x1f, 0x2e, + 0x96, 0x07, 0x3a, 0x55, 0xb9, 0x65, 0xab, 0xa6, 0xa3, 0x6a, 0xa4, 0xfa, 0x32, 0xc9, 0x8a, 0xde, + 0x83, 0xbc, 0x8d, 0x9d, 0x5e, 0x07, 0x53, 0x45, 0xd2, 0x4a, 0xe5, 0x1f, 0x5e, 0x8d, 0xe1, 0x6c, + 0x76, 0x55, 0x53, 0x06, 0x96, 0x97, 0xfc, 0x46, 0x4d, 0x28, 0x70, 0x4e, 0x1b, 0xab, 0x8e, 0x65, + 0xce, 0x4f, 0x5f, 0x17, 0xee, 0x16, 0x1f, 0x96, 0x63, 0x78, 0xa3, 0xa5, 0x24, 0x8f, 0xbd, 0x0e, + 0x96, 0x29, 0x97, 0x3c, 0x63, 0x87, 0x9e, 0xd0, 0x1b, 0x90, 0x35, 0x7b, 0x1d, 0xa2, 0x5f, 0x87, + 0x6a, 0x2f, 0x2d, 0x4f, 0x9b, 0xbd, 0xce, 0x3a, 0x3e, 0x71, 0xd0, 0x35, 0xc8, 0x91, 0xa4, 0xdd, + 0x13, 0x17, 0x3b, 0xf3, 0x59, 0x9a, 0x46, 0xf2, 0x56, 0xc8, 0xb3, 0xf4, 0x11, 0xcc, 0x84, 0xa5, + 0x22, 0x04, 0x45, 0xb9, 0xd6, 0xdc, 0xd9, 0xac, 0x29, 0x3b, 0x5b, 0xeb, 0x5b, 0x4f, 0x5f, 0x6c, + 0x89, 0x13, 0xe8, 0x12, 0x88, 0x9c, 0xb6, 0x5e, 0xfb, 0x58, 0xd9, 0x68, 0x6c, 0x36, 0x5a, 0xa2, + 0xb0, 0x90, 0xf9, 0xec, 0x77, 0x17, 0x27, 0xd6, 0x32, 0xd9, 0x29, 0x71, 0x5a, 0xfa, 0x5d, 0x01, + 0xe0, 0x09, 0x76, 0x79, 0x6f, 0x40, 0x15, 0x98, 0x3a, 0xa0, 0x25, 0x9e, 0x17, 0xa8, 0x5a, 0xae, + 0xc7, 0x56, 0x2d, 0xd4, 0x73, 0x2a, 0xd9, 0x9f, 0x9c, 0x2e, 0x4d, 0xfc, 0xfc, 0x74, 0x49, 0x90, + 0x39, 0x27, 0x7a, 0x06, 0xf9, 0x43, 0x7c, 0xa2, 0xf0, 0x71, 0x39, 0x9f, 0xa2, 0x3a, 0x7a, 0x37, + 0x24, 0xe8, 0xf0, 0xa8, 0xec, 0x0d, 0xd1, 0x72, 0x68, 0x38, 0x97, 0x09, 0x47, 0xb9, 0xe9, 0xda, + 0xd8, 0xdc, 0x77, 0x0f, 0x64, 0x38, 0xc4, 0x27, 0x1b, 0x4c, 0x86, 0xf4, 0x07, 0x02, 0xe4, 0x69, + 0x29, 0x99, 0x52, 0x51, 0xb5, 0xaf, 0x98, 0x37, 0xce, 0x6d, 0x81, 0x98, 0x72, 0x96, 0x61, 0xf2, + 0x48, 0x6d, 0xf7, 0x30, 0x2d, 0x61, 0xfe, 0xe1, 0x7c, 0x8c, 0x8c, 0xe7, 0x24, 0x5d, 0x66, 0xd9, + 0xd0, 0x07, 0x30, 0x63, 0x98, 0x2e, 0x36, 0x5d, 0x85, 0xb1, 0xa5, 0xcf, 0x61, 0xcb, 0xb3, 0xdc, + 0xf4, 0x41, 0xfa, 0xc7, 0x02, 0xc0, 0x76, 0x2f, 0x51, 0x3d, 0x7f, 0x73, 0xcc, 0xf2, 0x57, 0x32, + 0x84, 0xd5, 0xab, 0xc5, 0x15, 0x98, 0x32, 0xcc, 0xb6, 0x61, 0xb2, 0xf2, 0x67, 0x65, 0xfe, 0x84, + 0x2e, 0xc1, 0xe4, 0x6e, 0xdb, 0x30, 0x75, 0x3a, 0x1e, 0xb2, 0x32, 0x7b, 0x90, 0x64, 0xc8, 0xd3, + 0x52, 0x27, 0xa8, 0x77, 0xe9, 0x34, 0x05, 0x97, 0xab, 0x96, 0xa9, 0x1b, 0x64, 0x48, 0xaa, 0xed, + 0xaf, 0x85, 0x56, 0xd6, 0xe0, 0x92, 0x8e, 0xbb, 0x36, 0xd6, 0x54, 0x17, 0xeb, 0x0a, 0x3e, 0xee, + 0x8e, 0xd9, 0xc6, 0x28, 0xe0, 0xaa, 0x1d, 0x77, 0x29, 0x8d, 0x8c, 0x5a, 0x22, 0x80, 0x8d, 0xda, + 0x29, 0x32, 0x65, 0xca, 0x59, 0x7c, 0xdc, 0xa5, 0xa3, 0x36, 0x5e, 0xcd, 0xe8, 0x9b, 0x70, 0x55, + 0x6d, 0xb7, 0xad, 0x57, 0x8a, 0xb1, 0xa7, 0xe8, 0x16, 0x76, 0x14, 0xd3, 0x72, 0x15, 0x7c, 0x6c, + 0x38, 0x2e, 0x9d, 0x12, 0xb2, 0xf2, 0x1c, 0x4d, 0x6e, 0xec, 0xad, 0x5a, 0xd8, 0xd9, 0xb2, 0xdc, + 0x1a, 0x49, 0x0a, 0x35, 0xe5, 0x74, 0xb8, 0x29, 0xa5, 0x5f, 0x83, 0x2b, 0xfd, 0xfa, 0x4d, 0xb2, + 0xfd, 0x7e, 0x2a, 0x40, 0xb1, 0x61, 0x1a, 0xee, 0xd7, 0xa2, 0xe1, 0x7c, 0x7d, 0xa6, 0xc3, 0xfa, + 0xbc, 0x0f, 0xe2, 0x9e, 0x6a, 0xb4, 0x9f, 0x9a, 0x2d, 0xab, 0xb3, 0xeb, 0xb8, 0x96, 0x89, 0x1d, + 0xae, 0xf0, 0x01, 0xba, 0xf4, 0x1c, 0x4a, 0x7e, 0x6d, 0x92, 0x54, 0x93, 0x0b, 0x62, 0xc3, 0xd4, + 0x6c, 0xdc, 0xc1, 0x66, 0xa2, 0x7a, 0x7a, 0x13, 0x72, 0x86, 0x27, 0x97, 0xea, 0x2a, 0x2d, 0x07, + 0x04, 0xa9, 0x07, 0xb3, 0xa1, 0xb7, 0x26, 0x39, 0x5d, 0x92, 0xc5, 0x08, 0xbf, 0x52, 0x82, 0x36, + 0x22, 0x8b, 0x11, 0x7e, 0xc5, 0xa6, 0xb7, 0x26, 0x14, 0x56, 0x71, 0x1b, 0xbb, 0x38, 0xc1, 0x9a, + 0x4a, 0x3b, 0x50, 0xf4, 0x84, 0x26, 0xd9, 0x30, 0xbf, 0x29, 0x00, 0xe2, 0x72, 0x55, 0x73, 0x3f, + 0xc9, 0x12, 0xa3, 0x25, 0x62, 0x5a, 0xb8, 0x3d, 0xdb, 0x64, 0xcb, 0x39, 0xeb, 0x93, 0xc0, 0x48, + 0x74, 0x45, 0x0f, 0x86, 0x6c, 0x26, 0x3c, 0x64, 0xb9, 0x79, 0xf3, 0x0a, 0xe6, 0x22, 0x05, 0x4b, + 0xb6, 0xf9, 0x32, 0xb4, 0x4c, 0xa9, 0xeb, 0xe9, 0xb0, 0x0d, 0x47, 0x89, 0xd2, 0xe7, 0x02, 0xcc, + 0x56, 0xdb, 0x58, 0xb5, 0x13, 0xd7, 0xc8, 0x77, 0x21, 0xab, 0x63, 0x55, 0xa7, 0x55, 0x66, 0x03, + 0xfb, 0xad, 0x90, 0x14, 0x62, 0xe9, 0x96, 0x0f, 0xda, 0x5a, 0xb9, 0xe5, 0xd9, 0xc0, 0x7c, 0x74, + 0xfb, 0x4c, 0xd2, 0xc7, 0x80, 0xc2, 0x25, 0x4b, 0xb2, 0x23, 0xfc, 0x5e, 0x0a, 0x90, 0x8c, 0x8f, + 0xb0, 0xed, 0x26, 0x5e, 0xed, 0x55, 0xc8, 0xbb, 0xaa, 0xbd, 0x8f, 0x5d, 0x85, 0x58, 0xf7, 0x17, + 0xa9, 0x39, 0x30, 0x3e, 0x42, 0x46, 0x2d, 0xb8, 0x83, 0x4d, 0x75, 0xb7, 0x8d, 0xa9, 0x14, 0x65, + 0xd7, 0xea, 0x99, 0xba, 0x62, 0xb8, 0xd8, 0x56, 0x5d, 0xcb, 0x56, 0xac, 0xae, 0x6b, 0x74, 0x8c, + 0x4f, 0xa9, 0x61, 0xcf, 0xbb, 0xda, 0x4d, 0x96, 0x9d, 0x30, 0x57, 0x48, 0xe6, 0x06, 0xcf, 0xfb, + 0x34, 0x94, 0x15, 0x95, 0x61, 0xce, 0xd8, 0x37, 0x2d, 0x1b, 0x2b, 0xfb, 0x9a, 0xe2, 0x1e, 0xd8, + 0xd8, 0x39, 0xb0, 0xda, 0xde, 0x82, 0x34, 0xcb, 0x92, 0x9e, 0x68, 0x2d, 0x2f, 0x41, 0xfa, 0x04, + 0xe6, 0x22, 0x5a, 0x4a, 0xb2, 0x09, 0xfe, 0x87, 0x00, 0xf9, 0xa6, 0xa6, 0x9a, 0x49, 0xea, 0xfe, + 0x23, 0xc8, 0x3b, 0x9a, 0x6a, 0x2a, 0x7b, 0x96, 0xdd, 0x51, 0x5d, 0x5a, 0xaf, 0x62, 0x44, 0xf7, + 0xbe, 0x7d, 0xaf, 0xa9, 0xe6, 0x63, 0x9a, 0x49, 0x06, 0xc7, 0xff, 0xdd, 0x6f, 0xbf, 0x4e, 0x7e, + 0x79, 0xfb, 0x95, 0x0d, 0xef, 0xb5, 0x4c, 0x36, 0x2d, 0x66, 0xa4, 0x3f, 0x15, 0x60, 0x86, 0x55, + 0x39, 0xc9, 0xe1, 0xfd, 0x2d, 0xc8, 0xd8, 0xd6, 0x2b, 0x36, 0xbc, 0xf3, 0x0f, 0xaf, 0xc5, 0x88, + 0x58, 0xc7, 0x27, 0xe1, 0xf5, 0x93, 0x66, 0x47, 0x15, 0xe0, 0x56, 0xaa, 0x42, 0xb9, 0xd3, 0xe3, + 0x72, 0x03, 0xe3, 0x92, 0x89, 0x8c, 0x3b, 0x50, 0xda, 0x55, 0x5d, 0xed, 0x40, 0xb1, 0x79, 0x21, + 0xc9, 0x5a, 0x9b, 0xbe, 0x3b, 0x23, 0x17, 0x29, 0xd9, 0x2b, 0xba, 0x43, 0x6a, 0xce, 0xc6, 0x9b, + 0x83, 0xff, 0x9c, 0xb5, 0xf9, 0xff, 0x15, 0xf8, 0x18, 0xf2, 0x6a, 0xfe, 0xe7, 0xad, 0xe9, 0x7f, + 0x94, 0x82, 0xab, 0xd5, 0x03, 0xac, 0x1d, 0x56, 0x2d, 0xd3, 0x31, 0x1c, 0x97, 0xe8, 0x2e, 0xc9, + 0xf6, 0xbf, 0x06, 0xb9, 0x57, 0x86, 0x7b, 0xa0, 0xe8, 0xc6, 0xde, 0x1e, 0x9d, 0x6d, 0xb3, 0x72, + 0x96, 0x10, 0x56, 0x8d, 0xbd, 0x3d, 0xf4, 0x08, 0x32, 0x1d, 0x4b, 0x67, 0xc6, 0x7c, 0xf1, 0xe1, + 0x52, 0x8c, 0x78, 0x5a, 0x34, 0xa7, 0xd7, 0xd9, 0xb4, 0x74, 0x2c, 0xd3, 0xcc, 0x68, 0x11, 0x40, + 0x23, 0xd4, 0xae, 0x65, 0x98, 0x2e, 0x9f, 0x1c, 0x43, 0x14, 0x54, 0x87, 0x9c, 0x8b, 0xed, 0x8e, + 0x61, 0xaa, 0x2e, 0x9e, 0x9f, 0xa4, 0xca, 0x7b, 0x3b, 0xb6, 0xe0, 0xdd, 0xb6, 0xa1, 0xa9, 0xab, + 0xd8, 0xd1, 0x6c, 0xa3, 0xeb, 0x5a, 0x36, 0xd7, 0x62, 0xc0, 0x2c, 0xfd, 0xf5, 0x0c, 0xcc, 0x0f, + 0xea, 0x26, 0xc9, 0x1e, 0xb2, 0x0d, 0x53, 0x36, 0x76, 0x7a, 0x6d, 0x97, 0xf7, 0x91, 0x87, 0xc3, + 0x54, 0x10, 0x53, 0x02, 0xba, 0x75, 0xd1, 0x76, 0x79, 0xb1, 0xb9, 0x9c, 0x85, 0x7f, 0x21, 0xc0, + 0x14, 0x4b, 0x40, 0x0f, 0x20, 0x6b, 0x93, 0x85, 0x41, 0x31, 0x74, 0x5a, 0xc6, 0x74, 0xe5, 0xca, + 0xd9, 0xe9, 0xd2, 0x34, 0x5d, 0x2c, 0x1a, 0xab, 0x5f, 0x04, 0x3f, 0xe5, 0x69, 0x9a, 0xaf, 0xa1, + 0x93, 0xd6, 0x72, 0x5c, 0xd5, 0x76, 0xe9, 0xa6, 0x52, 0x8a, 0x21, 0x24, 0x4a, 0x58, 0xc7, 0x27, + 0x68, 0x0d, 0xa6, 0x1c, 0x57, 0x75, 0x7b, 0x0e, 0x6f, 0xaf, 0x0b, 0x15, 0xb6, 0x49, 0x39, 0x65, + 0x2e, 0x81, 0x98, 0x5b, 0x3a, 0x76, 0x55, 0xa3, 0x4d, 0x1b, 0x30, 0x27, 0xf3, 0x27, 0xe9, 0xb7, + 0x04, 0x98, 0x62, 0x59, 0xd1, 0x55, 0x98, 0x93, 0x57, 0xb6, 0x9e, 0xd4, 0x94, 0xc6, 0xd6, 0x6a, + 0xad, 0x55, 0x93, 0x37, 0x1b, 0x5b, 0x2b, 0xad, 0x9a, 0x38, 0x81, 0xae, 0x00, 0xf2, 0x12, 0xaa, + 0x4f, 0xb7, 0x9a, 0x8d, 0x66, 0xab, 0xb6, 0xd5, 0x12, 0x05, 0xba, 0xa7, 0x42, 0xe9, 0x21, 0x6a, + 0x0a, 0xbd, 0x0d, 0xd7, 0xfb, 0xa9, 0x4a, 0xb3, 0xb5, 0xd2, 0x6a, 0x2a, 0xb5, 0x66, 0xab, 0xb1, + 0xb9, 0xd2, 0xaa, 0xad, 0x8a, 0xe9, 0x11, 0xb9, 0xc8, 0x4b, 0x64, 0xb9, 0x56, 0x6d, 0x89, 0x19, + 0xc9, 0x85, 0xcb, 0x32, 0xd6, 0xac, 0x4e, 0xb7, 0xe7, 0x62, 0x52, 0x4a, 0x27, 0xc9, 0x91, 0x72, + 0x15, 0xa6, 0x75, 0xfb, 0x44, 0xb1, 0x7b, 0x26, 0x1f, 0x27, 0x53, 0xba, 0x7d, 0x22, 0xf7, 0x4c, + 0xe9, 0x1f, 0x08, 0x70, 0xa5, 0xff, 0xb5, 0x49, 0x76, 0xc2, 0x67, 0x90, 0x57, 0x75, 0x1d, 0xeb, + 0x8a, 0x8e, 0xdb, 0xae, 0xca, 0x4d, 0xa2, 0xfb, 0x21, 0x49, 0x7c, 0x2b, 0xb0, 0xec, 0x6f, 0x05, + 0x6e, 0x3e, 0xaf, 0x56, 0x69, 0x41, 0x56, 0x09, 0x87, 0x37, 0xfd, 0x50, 0x21, 0x94, 0x22, 0xfd, + 0x28, 0x03, 0x85, 0x9a, 0xa9, 0xb7, 0x8e, 0x13, 0x5d, 0x4b, 0xae, 0xc0, 0x94, 0x66, 0x75, 0x3a, + 0x86, 0xeb, 0x29, 0x88, 0x3d, 0xa1, 0x5f, 0x0e, 0x99, 0xb2, 0xe9, 0x31, 0x0c, 0xba, 0xc0, 0x88, + 0x45, 0xbf, 0x0e, 0x57, 0xc9, 0xac, 0x69, 0x9b, 0x6a, 0x5b, 0x61, 0xd2, 0x14, 0xd7, 0x36, 0xf6, + 0xf7, 0xb1, 0xcd, 0xb7, 0x1f, 0xef, 0xc6, 0x94, 0xb3, 0xc1, 0x39, 0xaa, 0x94, 0xa1, 0xc5, 0xf2, + 0xcb, 0x97, 0x8d, 0x38, 0x32, 0xfa, 0x10, 0x80, 0x2c, 0x45, 0x74, 0x4b, 0xd3, 0xe1, 0xf3, 0xd1, + 0xb0, 0x3d, 0x4d, 0x6f, 0x0a, 0x22, 0x0c, 0xe4, 0xd9, 0x41, 0xcf, 0x40, 0x34, 0x4c, 0x65, 0xaf, + 0x6d, 0xec, 0x1f, 0xb8, 0xca, 0x2b, 0xdb, 0x70, 0xb1, 0x33, 0x3f, 0x4b, 0x65, 0xc4, 0x35, 0x75, + 0x93, 0x6f, 0xcd, 0xea, 0x2f, 0x48, 0x4e, 0x2e, 0xad, 0x68, 0x98, 0x8f, 0x29, 0x3f, 0x25, 0x3a, + 0x68, 0x99, 0x40, 0xa1, 0x97, 0x3d, 0xc3, 0xc6, 0xca, 0x83, 0xae, 0x46, 0xf7, 0x41, 0xb2, 0x95, + 0xe2, 0xd9, 0xe9, 0x12, 0xc8, 0x8c, 0xfc, 0x60, 0xbb, 0x4a, 0xa0, 0x11, 0xfb, 0xdd, 0xd5, 0x88, + 0xda, 0xbb, 0x96, 0xe1, 0x58, 0xe6, 0x7c, 0x8e, 0xa9, 0x9d, 0x3d, 0xa1, 0x7b, 0x20, 0xba, 0xc7, + 0xa6, 0x72, 0x80, 0x55, 0xdb, 0xdd, 0xc5, 0xaa, 0x4b, 0xd6, 0x67, 0xa0, 0x39, 0x4a, 0xee, 0xb1, + 0x59, 0x0f, 0x91, 0xd7, 0x32, 0xd9, 0x69, 0x31, 0xbb, 0x96, 0xc9, 0x66, 0xc5, 0x9c, 0xf4, 0x1f, + 0x04, 0x28, 0x7a, 0x7d, 0x23, 0xc9, 0x6e, 0x7c, 0x17, 0x44, 0xcb, 0xc4, 0x4a, 0xf7, 0x40, 0x75, + 0x30, 0x6f, 0x4b, 0xbe, 0x3a, 0x14, 0x2d, 0x13, 0x6f, 0x13, 0x32, 0x6b, 0x19, 0xb4, 0x0d, 0xb3, + 0x8e, 0xab, 0xee, 0x1b, 0xe6, 0xbe, 0xe2, 0x6f, 0xf1, 0x53, 0xcb, 0x62, 0x4c, 0x24, 0x20, 0x72, + 0x6e, 0x9f, 0x1e, 0x31, 0x29, 0xfe, 0x50, 0x80, 0xd9, 0x15, 0xbd, 0x63, 0x98, 0xcd, 0x6e, 0xdb, + 0x48, 0x74, 0x83, 0xe1, 0x6d, 0xc8, 0x39, 0x44, 0x66, 0x30, 0x3b, 0x07, 0x70, 0x31, 0x4b, 0x53, + 0xc8, 0x34, 0xbd, 0x01, 0x25, 0x7c, 0xdc, 0x35, 0xd8, 0xb9, 0x02, 0x43, 0x39, 0x99, 0xf1, 0xeb, + 0x56, 0x0c, 0x78, 0x49, 0x12, 0xaf, 0xd3, 0xc7, 0x80, 0xc2, 0x55, 0x4a, 0x12, 0x68, 0x7c, 0x0c, + 0x73, 0x54, 0xf4, 0x8e, 0xe9, 0x24, 0xac, 0x2f, 0xe9, 0x57, 0xe1, 0x52, 0x54, 0x74, 0x92, 0xe5, + 0x7e, 0xc1, 0x5b, 0x79, 0x13, 0xdb, 0x89, 0x22, 0x54, 0x5f, 0xd7, 0x5c, 0x70, 0x92, 0x65, 0xfe, + 0x0d, 0x01, 0xde, 0xa0, 0xb2, 0xe9, 0xd1, 0xcb, 0x1e, 0xb6, 0x37, 0xb0, 0xea, 0x24, 0x0a, 0xaf, + 0x6f, 0xc2, 0x14, 0x83, 0xc9, 0xb4, 0x7f, 0x4e, 0x56, 0xf2, 0xc4, 0xcc, 0x68, 0xba, 0x96, 0x4d, + 0xcc, 0x0c, 0x9e, 0x24, 0xa9, 0xb0, 0x10, 0x57, 0x8a, 0x24, 0x6b, 0xfa, 0xb7, 0x05, 0x98, 0xe5, + 0x16, 0x1e, 0xe9, 0xca, 0xd5, 0x03, 0x62, 0xe0, 0xa0, 0x1a, 0xe4, 0x35, 0xfa, 0x4b, 0x71, 0x4f, + 0xba, 0x98, 0xca, 0x2f, 0x8e, 0x32, 0x0e, 0x19, 0x5b, 0xeb, 0xa4, 0x8b, 0x89, 0x85, 0xe9, 0xfd, + 0x26, 0x8a, 0x0a, 0x55, 0x72, 0xa4, 0x79, 0x49, 0xc7, 0x11, 0xcd, 0xeb, 0xd9, 0x69, 0x5c, 0x07, + 0xff, 0x28, 0xcd, 0x95, 0xc0, 0xde, 0xc1, 0xb3, 0x27, 0x6a, 0x50, 0x7c, 0x02, 0x57, 0x42, 0x5b, + 0xe7, 0xe1, 0x8a, 0xa7, 0x2e, 0x50, 0xf1, 0xd0, 0xf6, 0x7b, 0x40, 0x45, 0x1f, 0x43, 0x68, 0x83, + 0x5d, 0x61, 0x75, 0xf2, 0xa0, 0xca, 0x45, 0xd4, 0x31, 0x1b, 0x48, 0x61, 0x74, 0x07, 0x55, 0x21, + 0x8b, 0x8f, 0xbb, 0x8a, 0x8e, 0x1d, 0x8d, 0x4f, 0x5c, 0x52, 0x9c, 0x40, 0x52, 0x94, 0x01, 0xe3, + 0x7d, 0x1a, 0x1f, 0x77, 0x09, 0x11, 0xed, 0x90, 0x75, 0xd3, 0x5b, 0xd7, 0x69, 0xb1, 0x9d, 0xf3, + 0xb1, 0x40, 0xd0, 0x53, 0xb8, 0xb8, 0x92, 0xbf, 0xa4, 0x33, 0x11, 0xd2, 0x8f, 0x05, 0xb8, 0x16, + 0xdb, 0x6a, 0x49, 0x2e, 0x64, 0x1f, 0x42, 0x86, 0x56, 0x3e, 0x75, 0xc1, 0xca, 0x53, 0x2e, 0xe9, + 0xb3, 0x14, 0x1f, 0xe3, 0x32, 0x6e, 0x5b, 0x44, 0xb1, 0x89, 0x6f, 0xa1, 0x3d, 0x85, 0xc2, 0x91, + 0xe5, 0x62, 0xdb, 0x6f, 0xf6, 0xd4, 0x85, 0x9b, 0x7d, 0x86, 0x0a, 0xf0, 0x5a, 0xfc, 0x39, 0xcc, + 0x9a, 0x96, 0xa9, 0x44, 0x85, 0x5e, 0xbc, 0x2f, 0x95, 0x4c, 0xcb, 0x7c, 0x1e, 0x92, 0xeb, 0xcf, + 0x33, 0x7d, 0x9a, 0x48, 0x72, 0x9e, 0xf9, 0xa1, 0x00, 0x73, 0xbe, 0xa5, 0x93, 0xb0, 0xb9, 0xfb, + 0x2d, 0x48, 0x9b, 0xd6, 0xab, 0x8b, 0x6c, 0x51, 0x92, 0xfc, 0x64, 0xd5, 0x8b, 0x96, 0x28, 0xc9, + 0xfa, 0xfe, 0xcb, 0x14, 0xe4, 0x9e, 0x54, 0x93, 0xac, 0xe5, 0x87, 0x7c, 0xfb, 0x9b, 0xb5, 0x77, + 0x5c, 0x6f, 0xf7, 0xdf, 0x57, 0x7e, 0x52, 0x5d, 0xc7, 0x27, 0x5e, 0x6f, 0x27, 0x5c, 0x68, 0x05, + 0x72, 0xd1, 0x8d, 0xd2, 0x31, 0x35, 0x15, 0x70, 0x2d, 0x60, 0x98, 0xa4, 0x72, 0x3d, 0x57, 0x0b, + 0x21, 0xc6, 0xd5, 0x82, 0xbc, 0xc6, 0xb7, 0x14, 0x53, 0x17, 0x79, 0x4d, 0xc8, 0x44, 0x9c, 0x14, + 0xa7, 0xa4, 0x67, 0x00, 0xa4, 0x3a, 0x49, 0x36, 0xc9, 0x0f, 0xd2, 0x50, 0xdc, 0xee, 0x39, 0x07, + 0x09, 0xf7, 0xbe, 0x2a, 0x40, 0xb7, 0xe7, 0x1c, 0x90, 0x11, 0x79, 0x6c, 0xf2, 0x3a, 0x9f, 0xe3, + 0xc5, 0xe1, 0x55, 0x9a, 0xf1, 0xb5, 0x8e, 0x4d, 0x54, 0xe7, 0x42, 0xb0, 0x12, 0xb8, 0x82, 0xdc, + 0x1c, 0x85, 0x2c, 0x5b, 0xc7, 0xe6, 0x26, 0xf6, 0x21, 0x25, 0x93, 0x84, 0x89, 0xa4, 0x0f, 0x61, + 0x9a, 0x3c, 0x28, 0xae, 0x75, 0x91, 0x66, 0x9e, 0x22, 0x3c, 0x2d, 0x0b, 0x7d, 0x00, 0x39, 0xc6, + 0x4d, 0x56, 0xbf, 0x29, 0xba, 0xfa, 0xc5, 0xd5, 0x85, 0xab, 0x91, 0xae, 0x7b, 0x59, 0xca, 0x4a, + 0xd6, 0xba, 0x4b, 0x30, 0xb9, 0x67, 0xd9, 0x9a, 0x77, 0x98, 0xcb, 0x1e, 0x58, 0x7b, 0x32, 0x48, + 0xb3, 0x96, 0xc9, 0xe6, 0x44, 0x90, 0x7e, 0x4b, 0x80, 0x92, 0xdf, 0x10, 0x49, 0x2e, 0x08, 0xd5, + 0x88, 0x16, 0x2f, 0xde, 0x14, 0x44, 0x81, 0xd2, 0xbf, 0xa1, 0x16, 0x91, 0x66, 0x1d, 0xd1, 0x96, + 0x49, 0xb2, 0xa7, 0x7c, 0xc0, 0x1c, 0x7d, 0x52, 0x17, 0x6d, 0x5d, 0xea, 0xf3, 0xf3, 0x00, 0x2e, + 0x19, 0x1d, 0x32, 0x9f, 0x1b, 0x6e, 0xfb, 0x84, 0xc3, 0x36, 0x17, 0x7b, 0xa7, 0xc6, 0x73, 0x41, + 0x5a, 0xd5, 0x4b, 0x92, 0x7e, 0x8f, 0xee, 0x56, 0x07, 0x35, 0x49, 0x52, 0xd5, 0x0d, 0x28, 0xd8, + 0x4c, 0x34, 0x31, 0x6b, 0x2e, 0xa8, 0xed, 0x19, 0x9f, 0x95, 0x28, 0xfc, 0xb7, 0x53, 0x50, 0x7a, + 0xd6, 0xc3, 0xf6, 0xc9, 0xd7, 0x49, 0xdd, 0xb7, 0xa1, 0xf4, 0x4a, 0x35, 0x5c, 0x65, 0xcf, 0xb2, + 0x95, 0x5e, 0x57, 0x57, 0x5d, 0xcf, 0xdb, 0xa4, 0x40, 0xc8, 0x8f, 0x2d, 0x7b, 0x87, 0x12, 0x11, + 0x06, 0x74, 0x68, 0x5a, 0xaf, 0x4c, 0x85, 0x90, 0x29, 0x50, 0x3e, 0x36, 0xf9, 0x16, 0x72, 0xe5, + 0xdb, 0xff, 0xfe, 0x74, 0xe9, 0xd1, 0x58, 0x3e, 0x64, 0xd4, 0x5f, 0xae, 0xd7, 0x33, 0xf4, 0xf2, + 0xce, 0x4e, 0x63, 0x55, 0x16, 0xa9, 0xc8, 0x17, 0x4c, 0x62, 0xeb, 0xd8, 0x74, 0xa4, 0xbf, 0x93, + 0x02, 0x31, 0xd0, 0x51, 0x92, 0x0d, 0x59, 0x83, 0xfc, 0xcb, 0x1e, 0xb6, 0x8d, 0xd7, 0x68, 0x46, + 0xe0, 0x8c, 0x64, 0xda, 0xb9, 0x0f, 0xb3, 0xee, 0xb1, 0xa9, 0x30, 0x0f, 0x3f, 0xe6, 0xf8, 0xe1, + 0x39, 0x2c, 0x94, 0x5c, 0x52, 0x66, 0x42, 0xa7, 0x4e, 0x1f, 0x0e, 0xfa, 0x04, 0x66, 0x22, 0xda, + 0x4a, 0x7f, 0x39, 0x6d, 0xe5, 0x5f, 0x85, 0x14, 0xf5, 0x07, 0x02, 0x20, 0xaa, 0xa8, 0x06, 0xdb, + 0xe3, 0xff, 0xba, 0xf4, 0xa7, 0xbb, 0x20, 0x52, 0x7f, 0x4c, 0xc5, 0xd8, 0x53, 0x3a, 0x86, 0xe3, + 0x18, 0xe6, 0x3e, 0xef, 0x50, 0x45, 0x4a, 0x6f, 0xec, 0x6d, 0x32, 0xaa, 0xf4, 0x97, 0x60, 0x2e, + 0x52, 0x81, 0x24, 0x1b, 0xfb, 0x06, 0xcc, 0xec, 0xb1, 0x23, 0x58, 0x2a, 0x9c, 0x6f, 0x0f, 0xe6, + 0x29, 0x8d, 0xbd, 0x4f, 0xfa, 0xaf, 0x29, 0xb8, 0x24, 0x63, 0xc7, 0x6a, 0x1f, 0xe1, 0xe4, 0x55, + 0x58, 0x07, 0x7e, 0xf6, 0xa2, 0xbc, 0x96, 0x26, 0x73, 0x8c, 0x99, 0x2d, 0x73, 0xd1, 0x3d, 0xf6, + 0xb7, 0x47, 0xf7, 0xd8, 0xc1, 0x5d, 0x75, 0xbe, 0x53, 0x97, 0x89, 0xec, 0xd4, 0x59, 0x50, 0x62, + 0xa7, 0xc7, 0xba, 0xe2, 0xe0, 0x97, 0x66, 0xaf, 0xe3, 0x81, 0xa1, 0xf2, 0xa8, 0x42, 0x36, 0x18, + 0x4b, 0x13, 0xbf, 0xdc, 0xea, 0x75, 0xa8, 0xed, 0x5c, 0xb9, 0x42, 0xca, 0x7b, 0x76, 0xba, 0x54, + 0x8c, 0xa4, 0x39, 0x72, 0xd1, 0xf0, 0x9f, 0x89, 0x74, 0xe9, 0x7b, 0x70, 0xb9, 0x4f, 0xd9, 0x49, + 0x5a, 0x3c, 0xff, 0x2c, 0x0d, 0x6f, 0x44, 0xc5, 0x27, 0x0d, 0x71, 0xbe, 0xee, 0x0d, 0x5a, 0x87, + 0x42, 0xc7, 0x30, 0x5f, 0x6f, 0xf7, 0x72, 0xa6, 0x63, 0x98, 0x3e, 0x2d, 0xae, 0x6b, 0x4c, 0x7d, + 0xa5, 0x5d, 0x43, 0x85, 0x85, 0xb8, 0xb6, 0x4b, 0xb2, 0x7f, 0x7c, 0x26, 0xc0, 0x4c, 0xd2, 0xdb, + 0x72, 0xaf, 0xe7, 0x05, 0x27, 0xb5, 0xa0, 0xf0, 0x15, 0xec, 0xe3, 0xfd, 0xb6, 0x00, 0xa8, 0x65, + 0xf7, 0x4c, 0x02, 0x6a, 0x37, 0xac, 0xfd, 0x24, 0xab, 0x79, 0x09, 0x26, 0x0d, 0x53, 0xc7, 0xc7, + 0xb4, 0x9a, 0x19, 0x99, 0x3d, 0x44, 0x8e, 0x12, 0xd3, 0x63, 0x1d, 0x25, 0x4a, 0x9f, 0xc0, 0x5c, + 0xa4, 0x88, 0x49, 0xd6, 0xff, 0x4f, 0x52, 0x30, 0xc7, 0x2b, 0x92, 0xf8, 0x0e, 0xe6, 0x37, 0x61, + 0xb2, 0x4d, 0x64, 0x8e, 0x68, 0x67, 0xfa, 0x4e, 0xaf, 0x9d, 0x69, 0x66, 0xf4, 0x1d, 0x80, 0xae, + 0x8d, 0x8f, 0x14, 0xc6, 0x9a, 0x1e, 0x8b, 0x35, 0x47, 0x38, 0x28, 0x01, 0x7d, 0x2e, 0x40, 0x89, + 0x0c, 0xe8, 0xae, 0x6d, 0x75, 0x2d, 0x87, 0xd8, 0x2c, 0xce, 0x78, 0x30, 0xe7, 0xd9, 0xd9, 0xe9, + 0x52, 0x61, 0xd3, 0x30, 0xb7, 0x39, 0x63, 0xab, 0x39, 0xb6, 0x83, 0xbf, 0x17, 0xe6, 0x50, 0xae, + 0xb6, 0x2d, 0xed, 0x30, 0x38, 0x1c, 0x23, 0x33, 0x8b, 0x2f, 0xce, 0x91, 0x7e, 0x26, 0xc0, 0xa5, + 0xaf, 0x6c, 0xbb, 0xf8, 0xcf, 0x42, 0xd9, 0xd2, 0x73, 0x10, 0xe9, 0x8f, 0x86, 0xb9, 0x67, 0x25, + 0xb9, 0x71, 0xff, 0x7f, 0x04, 0x98, 0x0d, 0x09, 0x4e, 0xd2, 0xc0, 0x79, 0x5d, 0x3d, 0x15, 0x98, + 0x3b, 0x8c, 0x3b, 0x9e, 0xaa, 0xe4, 0x19, 0x9e, 0x9d, 0x75, 0xca, 0x32, 0xcc, 0x60, 0x32, 0x8b, + 0xd1, 0x2d, 0xde, 0x5d, 0x16, 0x64, 0xd2, 0xb7, 0xa3, 0x9f, 0xf7, 0x33, 0x54, 0x4e, 0xa4, 0x5f, + 0x25, 0x16, 0x56, 0x78, 0x50, 0x26, 0x39, 0xe4, 0xff, 0x69, 0x0a, 0xae, 0x54, 0xd9, 0x11, 0xb8, + 0xe7, 0x13, 0x92, 0x64, 0x47, 0x9c, 0x87, 0xe9, 0x23, 0x6c, 0x3b, 0x86, 0xc5, 0x56, 0xfb, 0x82, + 0xec, 0x3d, 0xa2, 0x05, 0xc8, 0x3a, 0xa6, 0xda, 0x75, 0x0e, 0x2c, 0xef, 0x38, 0xd1, 0x7f, 0xf6, + 0xfd, 0x57, 0x26, 0x5f, 0xdf, 0x7f, 0x65, 0x6a, 0xb4, 0xff, 0xca, 0xf4, 0x97, 0xf0, 0x5f, 0xe1, + 0x67, 0x77, 0xff, 0x56, 0x80, 0xab, 0x03, 0x9a, 0x4b, 0xb2, 0x73, 0x7e, 0x1f, 0xf2, 0x1a, 0x17, + 0x4c, 0xd6, 0x07, 0x76, 0x30, 0xd9, 0x20, 0xd9, 0x5e, 0x13, 0xfa, 0x9c, 0x9d, 0x2e, 0x81, 0x57, + 0xd4, 0xc6, 0x2a, 0x57, 0x0e, 0xf9, 0xad, 0x4b, 0xff, 0x0d, 0xa0, 0x54, 0x3b, 0x66, 0x9b, 0xf2, + 0x4d, 0x66, 0x95, 0xa0, 0xc7, 0x90, 0xed, 0xda, 0xd6, 0x91, 0xe1, 0x55, 0xa3, 0x18, 0x71, 0x5e, + 0xf0, 0xaa, 0xd1, 0xc7, 0xb5, 0xcd, 0x39, 0x64, 0x9f, 0x17, 0xb5, 0x20, 0xb7, 0x61, 0x69, 0x6a, + 0xfb, 0xb1, 0xd1, 0xf6, 0x06, 0xda, 0xbb, 0xe7, 0x0b, 0x2a, 0xfb, 0x3c, 0xdb, 0xaa, 0x7b, 0xe0, + 0x35, 0x82, 0x4f, 0x44, 0x0d, 0xc8, 0xd6, 0x5d, 0xb7, 0x4b, 0x12, 0xf9, 0xf8, 0xbb, 0x33, 0x86, + 0x50, 0xc2, 0xe2, 0x79, 0xdc, 0x7a, 0xec, 0xa8, 0x05, 0xb3, 0x4f, 0x68, 0xfc, 0x58, 0xb5, 0x6d, + 0xf5, 0xf4, 0xaa, 0x65, 0xee, 0x19, 0xfb, 0x7c, 0x99, 0xb8, 0x3d, 0x86, 0xcc, 0x27, 0xd5, 0xa6, + 0x3c, 0x28, 0x00, 0xad, 0x40, 0xb6, 0xf9, 0x88, 0x0b, 0x63, 0x66, 0xe4, 0xad, 0x31, 0x84, 0x35, + 0x1f, 0xc9, 0x3e, 0x1b, 0x5a, 0x83, 0xfc, 0xca, 0xa7, 0x3d, 0x1b, 0x73, 0x29, 0x53, 0x43, 0x3d, + 0x27, 0xfa, 0xa5, 0x50, 0x2e, 0x39, 0xcc, 0x8c, 0xbe, 0x07, 0x25, 0xa2, 0xb7, 0x96, 0xba, 0xdb, + 0xf6, 0xe4, 0x65, 0xa9, 0xbc, 0x6f, 0x8c, 0x21, 0xcf, 0xe7, 0xf4, 0x8e, 0x04, 0xfa, 0x44, 0x2d, + 0xc8, 0x50, 0x88, 0xb4, 0x17, 0x42, 0x90, 0xe9, 0x92, 0xa6, 0x11, 0xa8, 0x1b, 0x12, 0xfd, 0x8d, + 0xde, 0x81, 0x69, 0xd3, 0xd2, 0xb1, 0xd7, 0x99, 0x0b, 0x95, 0x4b, 0x67, 0xa7, 0x4b, 0x53, 0x5b, + 0x96, 0xce, 0x6c, 0x1d, 0xfe, 0x4b, 0x9e, 0x22, 0x99, 0x1a, 0xfa, 0xc2, 0x75, 0xc8, 0x90, 0x26, + 0x22, 0x73, 0xc8, 0xae, 0xea, 0xe0, 0x1d, 0xdb, 0xe0, 0xd2, 0xbc, 0xc7, 0x85, 0xbf, 0x9f, 0x82, + 0x54, 0xf3, 0x11, 0xb1, 0xe6, 0x77, 0x7b, 0xda, 0x21, 0x76, 0x79, 0x3a, 0x7f, 0xa2, 0x56, 0xbe, + 0x8d, 0xf7, 0x0c, 0x66, 0x74, 0xe5, 0x64, 0xfe, 0x84, 0xde, 0x02, 0x50, 0x35, 0x0d, 0x3b, 0x8e, + 0xe2, 0x85, 0x00, 0xe6, 0xe4, 0x1c, 0xa3, 0xac, 0xe3, 0x13, 0xc2, 0xe6, 0x60, 0xcd, 0xc6, 0xae, + 0xe7, 0x43, 0xc5, 0x9e, 0x08, 0x9b, 0x8b, 0x3b, 0x5d, 0xc5, 0xb5, 0x0e, 0xb1, 0x49, 0x9b, 0x34, + 0x47, 0x66, 0x85, 0x4e, 0xb7, 0x45, 0x08, 0x64, 0x42, 0xc3, 0xa6, 0x1e, 0xcc, 0x3e, 0x39, 0xd9, + 0x7f, 0x26, 0x22, 0x6d, 0xbc, 0x6f, 0xf0, 0x00, 0xba, 0x9c, 0xcc, 0x9f, 0x88, 0x96, 0xd4, 0x9e, + 0x7b, 0x40, 0x5b, 0x22, 0x27, 0xd3, 0xdf, 0xe8, 0x36, 0x94, 0x98, 0xdb, 0xa5, 0x82, 0x4d, 0x4d, + 0xa1, 0xf3, 0x60, 0x8e, 0x26, 0x17, 0x18, 0xb9, 0x66, 0x6a, 0x64, 0xd6, 0x43, 0x8f, 0x80, 0x13, + 0x94, 0xc3, 0x8e, 0x43, 0x74, 0x0a, 0x24, 0x57, 0xa5, 0x74, 0x76, 0xba, 0x94, 0x6f, 0xd2, 0x84, + 0xf5, 0xcd, 0x26, 0x59, 0x4b, 0x58, 0xae, 0xf5, 0x8e, 0xd3, 0xd0, 0x17, 0xfe, 0xa6, 0x00, 0xe9, + 0x27, 0xd5, 0xe6, 0x85, 0x55, 0xe6, 0x15, 0x34, 0x1d, 0x2a, 0xe8, 0x1d, 0x28, 0xed, 0x1a, 0xed, + 0xb6, 0x61, 0xee, 0x13, 0xfb, 0xea, 0xfb, 0x58, 0xf3, 0x14, 0x56, 0xe4, 0xe4, 0x6d, 0x46, 0x45, + 0xd7, 0x21, 0xaf, 0xd9, 0x58, 0xc7, 0xa6, 0x6b, 0xa8, 0x6d, 0x87, 0x6b, 0x2e, 0x4c, 0x5a, 0xf8, + 0xcb, 0x02, 0x4c, 0xd2, 0xce, 0x8a, 0xde, 0x84, 0x9c, 0x66, 0x99, 0xae, 0x6a, 0x98, 0x7c, 0xd6, + 0xc9, 0xc9, 0x01, 0x61, 0x68, 0xf1, 0x6e, 0xc0, 0x8c, 0xaa, 0x69, 0x56, 0xcf, 0x74, 0x15, 0x53, + 0xed, 0x60, 0x5e, 0xcc, 0x3c, 0xa7, 0x6d, 0xa9, 0x1d, 0x8c, 0x96, 0xc0, 0x7b, 0xf4, 0x23, 0x3b, + 0x73, 0x32, 0x70, 0xd2, 0x3a, 0x3e, 0x59, 0xc0, 0x90, 0xf3, 0x7b, 0x35, 0xa9, 0x6f, 0xcf, 0xf1, + 0x4b, 0x40, 0x7f, 0xa3, 0x77, 0xe1, 0xd2, 0xcb, 0x9e, 0xda, 0x36, 0xf6, 0xe8, 0xe6, 0x17, 0xf5, + 0x52, 0xa7, 0x2f, 0x63, 0x45, 0x41, 0x7e, 0x1a, 0x95, 0x40, 0xdf, 0xe9, 0x0d, 0x82, 0x74, 0x30, + 0x08, 0x98, 0xcb, 0x8e, 0x74, 0x02, 0xb3, 0x32, 0x76, 0xed, 0x93, 0x16, 0x0b, 0x76, 0xad, 0x1d, + 0x61, 0xd3, 0x25, 0x75, 0xb7, 0xba, 0x98, 0x39, 0x89, 0x78, 0x75, 0xf7, 0x09, 0xe8, 0x16, 0x14, + 0x55, 0x97, 0x74, 0x37, 0x57, 0x31, 0x7b, 0x9d, 0x5d, 0x6c, 0x33, 0x57, 0x00, 0xb9, 0xc0, 0xa9, + 0x5b, 0x94, 0xc8, 0x23, 0x32, 0xec, 0x13, 0x85, 0xee, 0x13, 0xf1, 0x57, 0x03, 0x25, 0xd5, 0x08, + 0x45, 0xba, 0x07, 0x97, 0x49, 0x3d, 0x6b, 0xa6, 0x66, 0x9f, 0x74, 0x89, 0xe4, 0xa7, 0xf4, 0xaf, + 0x83, 0xc4, 0xd0, 0x39, 0x0d, 0x3d, 0x9e, 0x91, 0x7e, 0x3a, 0x05, 0x85, 0xda, 0x71, 0xd7, 0xb2, + 0x13, 0xdd, 0xd5, 0xa9, 0xc0, 0x34, 0x07, 0xbe, 0x23, 0x8e, 0x62, 0xfb, 0x66, 0x20, 0xef, 0x1c, + 0x9a, 0x33, 0xa2, 0x0a, 0x00, 0x73, 0xa8, 0xa4, 0x7e, 0x38, 0xe9, 0x0b, 0x9c, 0x1c, 0x51, 0x36, + 0x1a, 0x6c, 0xb0, 0x05, 0xf9, 0xce, 0x91, 0xa6, 0x29, 0x7b, 0x46, 0xdb, 0xe5, 0x7e, 0x69, 0xf1, + 0x2e, 0xd4, 0x9b, 0xcf, 0xab, 0xd5, 0xc7, 0x34, 0x13, 0xf3, 0xe7, 0x0a, 0x9e, 0x65, 0x20, 0x12, + 0xd8, 0x6f, 0xf4, 0x0d, 0xe0, 0x81, 0x2f, 0x8a, 0xe3, 0x85, 0xb1, 0x55, 0x0a, 0x67, 0xa7, 0x4b, + 0x39, 0x99, 0x52, 0x9b, 0xcd, 0x96, 0x9c, 0x63, 0x19, 0x9a, 0x8e, 0x7b, 0x91, 0x50, 0x87, 0xe9, + 0xf1, 0x43, 0x1d, 0xfe, 0x9a, 0x00, 0x57, 0xb8, 0x8e, 0x94, 0x5d, 0xea, 0xde, 0xad, 0xb6, 0x0d, + 0xf7, 0x44, 0x39, 0x3c, 0x9a, 0xcf, 0x52, 0x93, 0xe7, 0x97, 0x63, 0x75, 0x1d, 0x6a, 0xe2, 0xb2, + 0xa7, 0xf1, 0x93, 0x0d, 0xce, 0xbc, 0x7e, 0x54, 0x33, 0x5d, 0xfb, 0xa4, 0x72, 0xf5, 0xec, 0x74, + 0x69, 0x6e, 0x30, 0xf5, 0xb9, 0x3c, 0xe7, 0x0c, 0xb2, 0xa0, 0x3a, 0x00, 0xf6, 0xbb, 0x18, 0x9d, + 0xc1, 0xe2, 0x97, 0xae, 0xd8, 0xbe, 0x28, 0x87, 0x78, 0xd1, 0x5d, 0x10, 0x79, 0x68, 0xc9, 0x9e, + 0xd1, 0xc6, 0x8a, 0x63, 0x7c, 0x8a, 0xe9, 0x5c, 0x97, 0x96, 0x8b, 0x8c, 0x4e, 0x44, 0x34, 0x8d, + 0x4f, 0x31, 0x7a, 0x00, 0x97, 0x83, 0x16, 0x50, 0x76, 0x71, 0xdb, 0x7a, 0xc5, 0xb2, 0xe7, 0x69, + 0x76, 0xe4, 0x6b, 0xbf, 0x42, 0x92, 0x08, 0xcb, 0xc2, 0xf7, 0x61, 0x7e, 0x58, 0x85, 0xc3, 0x03, + 0x22, 0xc7, 0xce, 0x2b, 0xdf, 0x8b, 0x6e, 0x56, 0x8c, 0xd1, 0x71, 0xf9, 0x86, 0xc5, 0xfb, 0xa9, + 0xf7, 0x04, 0xe9, 0xef, 0xa5, 0xa0, 0x50, 0xe9, 0xb5, 0x0f, 0x9f, 0x76, 0x9b, 0x2c, 0x2c, 0x1f, + 0x5d, 0x83, 0x9c, 0xae, 0xba, 0x2a, 0x2b, 0xa4, 0xc0, 0x42, 0xcc, 0x08, 0x81, 0xd6, 0xe6, 0x0e, + 0x94, 0x42, 0xbe, 0x20, 0xdc, 0xe3, 0x9d, 0x56, 0x3b, 0x20, 0x53, 0xa7, 0xf4, 0xf7, 0x60, 0x3e, + 0x94, 0x91, 0xee, 0x2c, 0x28, 0xd8, 0x74, 0x6d, 0x03, 0xb3, 0xdd, 0xb1, 0xb4, 0x1c, 0x72, 0x58, + 0x69, 0x90, 0xe4, 0x1a, 0x4b, 0x45, 0x2d, 0x98, 0x21, 0x19, 0x4f, 0x14, 0x3a, 0x0b, 0x7a, 0xbb, + 0x97, 0x0f, 0x62, 0xaa, 0x15, 0x29, 0x77, 0x99, 0xea, 0xa7, 0x4a, 0x79, 0xe8, 0x4f, 0x39, 0x8f, + 0x03, 0xca, 0xc2, 0x47, 0x20, 0xf6, 0x67, 0x08, 0xeb, 0x32, 0xc3, 0x74, 0x79, 0x29, 0xac, 0xcb, + 0x74, 0x48, 0x4f, 0x6b, 0x99, 0x6c, 0x46, 0x9c, 0x94, 0x7e, 0x96, 0x86, 0xa2, 0xd7, 0x33, 0x93, + 0x34, 0xab, 0x2b, 0x30, 0x49, 0xfa, 0x91, 0xe7, 0x5e, 0x71, 0x7b, 0xc4, 0x80, 0xe0, 0x3e, 0xd6, + 0xa4, 0x7f, 0x79, 0x08, 0x90, 0xb2, 0x26, 0x31, 0xfd, 0x2c, 0xfc, 0x77, 0x01, 0x32, 0xd4, 0x92, + 0x7d, 0x00, 0x19, 0x1a, 0x97, 0x2f, 0x8c, 0x8c, 0xcb, 0xf7, 0x8e, 0xe7, 0x49, 0x56, 0x7f, 0x61, + 0x49, 0x85, 0xac, 0xab, 0x0a, 0xf5, 0xef, 0xb1, 0x6c, 0x17, 0xeb, 0xdc, 0x52, 0xbc, 0x7e, 0x5e, + 0x3b, 0x7a, 0x96, 0xb0, 0xc7, 0x87, 0xde, 0x80, 0x34, 0x99, 0xbb, 0xa6, 0xd9, 0x51, 0xfd, 0xd9, + 0xe9, 0x52, 0x9a, 0xcc, 0x5a, 0x84, 0x86, 0x96, 0x21, 0x1f, 0x9d, 0x4d, 0x88, 0xb1, 0x41, 0xa7, + 0xc3, 0xd0, 0x4c, 0x00, 0x6d, 0x7f, 0x08, 0x31, 0x94, 0xc4, 0xda, 0x92, 0x1f, 0xd2, 0xff, 0x86, + 0xc0, 0x7d, 0x12, 0x9b, 0x1a, 0x59, 0xb3, 0xec, 0x24, 0x17, 0x95, 0x7b, 0x20, 0xda, 0xaa, 0xa9, + 0x5b, 0x1d, 0xe3, 0x53, 0xcc, 0x50, 0xb9, 0xc3, 0x8f, 0x2b, 0x4a, 0x3e, 0x9d, 0xc2, 0x67, 0x47, + 0xfa, 0x2f, 0x02, 0xf7, 0x5f, 0xf4, 0x8b, 0x91, 0xec, 0xa1, 0x72, 0x9e, 0x6f, 0xe9, 0x99, 0x7b, + 0x96, 0xe7, 0x7e, 0xf1, 0xe6, 0x30, 0x67, 0xa3, 0x86, 0xb9, 0x67, 0x79, 0xc7, 0x63, 0xb6, 0x47, + 0x70, 0x16, 0x7e, 0x05, 0x26, 0x69, 0xf2, 0x6b, 0xf4, 0x0d, 0xdf, 0x67, 0x36, 0x25, 0xa6, 0xa5, + 0x3f, 0x4e, 0xc1, 0xdb, 0xb4, 0xaa, 0xcf, 0xb1, 0x6d, 0xec, 0x9d, 0x6c, 0xdb, 0x96, 0x8b, 0x35, + 0x17, 0xeb, 0xc1, 0xae, 0x54, 0x82, 0x4d, 0xa0, 0x43, 0x8e, 0x9f, 0xe7, 0x19, 0x3a, 0xbf, 0x39, + 0xe3, 0xc9, 0x97, 0x43, 0xab, 0x59, 0x76, 0x0e, 0xd8, 0x58, 0x95, 0xb3, 0x4c, 0x72, 0x43, 0x47, + 0x2b, 0x90, 0xeb, 0x7a, 0xd5, 0xb8, 0x90, 0xcb, 0x88, 0xcf, 0x85, 0xd6, 0xa1, 0xc4, 0x0b, 0xaa, + 0xb6, 0x8d, 0x23, 0xac, 0xa8, 0xee, 0x45, 0x86, 0x70, 0x81, 0xf1, 0xae, 0x10, 0xd6, 0x15, 0x57, + 0xfa, 0x1b, 0x19, 0xb8, 0x75, 0x8e, 0x8a, 0x93, 0xec, 0x5e, 0x0b, 0x90, 0x3d, 0x22, 0x2f, 0x32, + 0x78, 0xed, 0xb3, 0xb2, 0xff, 0x8c, 0x76, 0x23, 0xeb, 0xc0, 0x9e, 0x6a, 0xb4, 0xc9, 0xba, 0xc1, + 0x9c, 0xf4, 0x86, 0xbb, 0x01, 0xc5, 0x3b, 0xbd, 0x85, 0x56, 0x8c, 0xc7, 0x54, 0x10, 0xcd, 0xe6, + 0xa0, 0xcf, 0x04, 0x58, 0x60, 0x2f, 0x64, 0x9e, 0x62, 0x7d, 0xaf, 0xc9, 0xd0, 0xd7, 0xac, 0xc6, + 0xbc, 0x66, 0x2c, 0x1d, 0x95, 0x43, 0xef, 0xe2, 0x05, 0x99, 0x0f, 0xbf, 0x2d, 0x5c, 0x94, 0x85, + 0xdf, 0x14, 0x20, 0x1f, 0x22, 0xa0, 0xdb, 0x03, 0x71, 0x39, 0xf9, 0xb3, 0xb8, 0x60, 0x9c, 0x5b, + 0x03, 0xc1, 0x38, 0x95, 0xec, 0x17, 0xa7, 0x4b, 0x19, 0x99, 0xf9, 0x7b, 0x7b, 0x61, 0x39, 0x37, + 0x82, 0x6b, 0x60, 0xd2, 0x7d, 0x99, 0xbc, 0x7b, 0x60, 0x28, 0xac, 0x53, 0xbd, 0x63, 0x24, 0x0a, + 0xeb, 0xc8, 0x93, 0xf4, 0xa3, 0x14, 0xcc, 0xae, 0xe8, 0x7a, 0xb3, 0x49, 0xa1, 0x40, 0x92, 0x63, + 0x0c, 0x41, 0x86, 0xd8, 0x07, 0x3c, 0x86, 0x88, 0xfe, 0x46, 0xef, 0x00, 0xd2, 0x0d, 0x87, 0x5d, + 0xa7, 0xe0, 0x1c, 0xa8, 0xba, 0xf5, 0x2a, 0x38, 0x2d, 0x9e, 0xf5, 0x52, 0x9a, 0x5e, 0x02, 0x6a, + 0x02, 0x35, 0x5a, 0x15, 0xc7, 0x55, 0xfd, 0xdd, 0xf0, 0x5b, 0x63, 0x45, 0xa5, 0x30, 0x6b, 0xd6, + 0x7f, 0x94, 0x73, 0x44, 0x0e, 0xfd, 0x49, 0x6c, 0x34, 0x83, 0x34, 0x8a, 0xab, 0xa8, 0x8e, 0x17, + 0x4f, 0xc1, 0x2e, 0x72, 0x28, 0x32, 0xfa, 0x8a, 0xc3, 0xc2, 0x24, 0x98, 0x1b, 0x76, 0xa0, 0x9a, + 0x24, 0xf7, 0x32, 0x7f, 0x47, 0x80, 0xa2, 0x8c, 0xf7, 0x6c, 0xec, 0x1c, 0x24, 0xa9, 0xf3, 0xc7, + 0x30, 0x63, 0x33, 0xa9, 0xca, 0x9e, 0x6d, 0x75, 0x2e, 0x32, 0x57, 0xe4, 0x39, 0xe3, 0x63, 0xdb, + 0xea, 0xf0, 0x29, 0xf9, 0x39, 0x94, 0xfc, 0x32, 0x26, 0x59, 0xf9, 0xbf, 0x4b, 0x23, 0x2e, 0x99, + 0xe0, 0xa4, 0x8f, 0x6d, 0x93, 0xd5, 0x00, 0xdd, 0xcf, 0x0e, 0x17, 0x34, 0x49, 0x35, 0xfc, 0x67, + 0x01, 0x8a, 0xcd, 0xde, 0x2e, 0xbb, 0x26, 0x28, 0x39, 0x0d, 0xd4, 0x20, 0xd7, 0xc6, 0x7b, 0xae, + 0xf2, 0x5a, 0x0e, 0xc4, 0x59, 0xc2, 0x4a, 0xdd, 0xa7, 0x9f, 0x00, 0xd8, 0x34, 0xe4, 0x88, 0xca, + 0x49, 0x5f, 0x50, 0x4e, 0x8e, 0xf2, 0x12, 0x32, 0x59, 0x75, 0x4a, 0x7e, 0x35, 0x93, 0x5c, 0x5f, + 0x5e, 0x44, 0x66, 0x87, 0xf4, 0x45, 0x66, 0x87, 0x59, 0x7e, 0x52, 0x1d, 0x3f, 0x43, 0x94, 0x61, + 0x8e, 0x9a, 0x65, 0x8a, 0xda, 0xed, 0xb6, 0x0d, 0x0f, 0xa7, 0xd0, 0xf9, 0x27, 0x23, 0xcf, 0xd2, + 0xa4, 0x15, 0x96, 0x42, 0x11, 0x0a, 0xfa, 0x81, 0x00, 0x33, 0x7b, 0x36, 0xc6, 0x9f, 0x62, 0x85, + 0x4e, 0xc9, 0xe3, 0x1d, 0xc5, 0xaf, 0x92, 0x32, 0x7c, 0xe9, 0xa3, 0xba, 0x3c, 0x7b, 0x71, 0x93, + 0xbc, 0x17, 0x6d, 0x81, 0xa8, 0xb5, 0xd9, 0xe1, 0xa1, 0xef, 0x16, 0x30, 0x35, 0xfe, 0x00, 0x28, + 0x31, 0xe6, 0xc0, 0x33, 0xe0, 0x19, 0x19, 0x4c, 0xaa, 0xae, 0xf0, 0xab, 0xd9, 0xa8, 0xb1, 0x1d, + 0x75, 0x0b, 0x08, 0x87, 0x5e, 0x87, 0x6e, 0x74, 0x2b, 0xcb, 0x58, 0xd5, 0xb9, 0xe5, 0x4e, 0xc6, + 0x95, 0xff, 0xc0, 0xc7, 0xd5, 0x0b, 0x98, 0xa5, 0xfd, 0x26, 0xe9, 0x08, 0x4a, 0xe9, 0x1f, 0xa6, + 0x01, 0x85, 0x25, 0x7f, 0x75, 0xfd, 0x2d, 0x95, 0x5c, 0x7f, 0x5b, 0x03, 0x29, 0x64, 0x0c, 0xb5, + 0x55, 0xc7, 0x55, 0x98, 0xff, 0x99, 0xa3, 0x74, 0xb1, 0xad, 0x38, 0x58, 0xb3, 0xf8, 0x25, 0x3a, + 0x82, 0xbc, 0x18, 0xe4, 0xdc, 0x50, 0x1d, 0xf7, 0x19, 0xcb, 0xb7, 0x8d, 0xed, 0x26, 0xcd, 0x85, + 0x1e, 0xc1, 0x95, 0x8e, 0x7a, 0x1c, 0xc7, 0x3f, 0x49, 0xf9, 0xe7, 0x3a, 0xea, 0xf1, 0x00, 0xd3, + 0xfb, 0xb0, 0x10, 0xcf, 0xa4, 0x38, 0xd8, 0x3b, 0x9f, 0xba, 0x12, 0xc3, 0xd8, 0xc4, 0x2e, 0x5a, + 0x01, 0x08, 0x40, 0x04, 0x5f, 0xa3, 0xc7, 0xc1, 0x10, 0x39, 0x1f, 0x43, 0x48, 0x3f, 0x14, 0xa0, + 0xb8, 0x69, 0xec, 0xdb, 0x6a, 0xa2, 0x57, 0xd4, 0xa0, 0xf7, 0xa3, 0x07, 0x7a, 0xf9, 0x87, 0x0b, + 0x71, 0x0e, 0x1b, 0x2c, 0x87, 0xb7, 0x69, 0xc7, 0x19, 0xc8, 0xd2, 0xe7, 0x97, 0x28, 0xc9, 0x39, + 0x5f, 0x83, 0xb7, 0xa8, 0x0b, 0x1c, 0xf7, 0x7f, 0xf9, 0x4a, 0xd0, 0x8d, 0xf4, 0xfb, 0x02, 0x2c, + 0x0e, 0x7b, 0x4b, 0x92, 0x03, 0x42, 0xa6, 0x97, 0xf5, 0xd1, 0x37, 0x28, 0xfe, 0x88, 0x38, 0x67, + 0xa6, 0x41, 0x7c, 0x24, 0x80, 0x5f, 0xb6, 0x26, 0xbd, 0xc6, 0x8f, 0xfd, 0x76, 0xa4, 0x7f, 0xbd, + 0x00, 0x33, 0xbc, 0x7e, 0x3b, 0xa6, 0x61, 0x99, 0xe8, 0x01, 0xa4, 0xf7, 0xf9, 0xde, 0x7f, 0x3e, + 0x76, 0xcb, 0x33, 0xb8, 0x21, 0xaf, 0x3e, 0x21, 0x93, 0xbc, 0x84, 0xa5, 0xdb, 0x73, 0x63, 0xca, + 0x13, 0x38, 0x79, 0x87, 0x59, 0xba, 0x3d, 0x17, 0x35, 0xa1, 0xa4, 0x05, 0xd7, 0x72, 0x29, 0x84, + 0x3d, 0x3d, 0x74, 0x1f, 0x30, 0xf6, 0x82, 0xb4, 0xfa, 0x84, 0x5c, 0xd4, 0x22, 0x09, 0xa8, 0x1a, + 0xbe, 0x0d, 0x2a, 0x33, 0xe0, 0x41, 0x16, 0xc4, 0x12, 0x47, 0x6f, 0xa2, 0xaa, 0x4f, 0x84, 0x2e, + 0x8d, 0x42, 0xef, 0xc3, 0x94, 0x4e, 0xef, 0x1d, 0xe2, 0xab, 0x4a, 0x5c, 0x87, 0x88, 0x5c, 0xef, + 0x54, 0x9f, 0x90, 0x39, 0x07, 0x5a, 0x83, 0x19, 0xf6, 0x8b, 0x61, 0x1e, 0xbe, 0x16, 0xdc, 0x1a, + 0x2e, 0x21, 0x64, 0x8d, 0xd5, 0x27, 0xe4, 0xbc, 0x1e, 0x50, 0xd1, 0x13, 0xc8, 0x6b, 0x6d, 0xac, + 0xda, 0x5c, 0xd4, 0xed, 0xa1, 0x61, 0x6f, 0x03, 0x77, 0x15, 0xd5, 0x27, 0x64, 0xd0, 0x7c, 0x22, + 0x29, 0x94, 0x4d, 0xaf, 0xac, 0xe1, 0x92, 0xde, 0x1d, 0x5a, 0xa8, 0xc1, 0xfb, 0x7f, 0xea, 0xd4, + 0x4a, 0xf3, 0xa9, 0xe8, 0x9b, 0x90, 0x71, 0x34, 0xd5, 0xe4, 0x0b, 0xd3, 0xe2, 0x90, 0x3b, 0x45, + 0x02, 0x66, 0x9a, 0x1b, 0x7d, 0xc0, 0xe0, 0x92, 0x7b, 0xec, 0x6d, 0xf6, 0xc6, 0xe9, 0x34, 0x12, + 0xbb, 0x4e, 0x74, 0x8a, 0x29, 0x81, 0xe8, 0x41, 0x25, 0xf8, 0x50, 0xa1, 0x01, 0xa5, 0x74, 0x77, + 0x37, 0x5e, 0x0f, 0x03, 0x01, 0xc0, 0x75, 0x1a, 0x20, 0xef, 0x11, 0xd1, 0x26, 0x14, 0x98, 0xa0, + 0x1e, 0x8b, 0x4d, 0x9d, 0x5f, 0x1e, 0x7a, 0x8c, 0x1b, 0x13, 0x1d, 0x5b, 0x9f, 0x90, 0x67, 0xd4, + 0x10, 0x39, 0x28, 0x57, 0x07, 0xdb, 0xfb, 0x6c, 0x1b, 0x79, 0x44, 0xb9, 0xc2, 0xbe, 0x71, 0x7e, + 0xb9, 0x28, 0x11, 0xfd, 0x3a, 0x5c, 0x62, 0x82, 0x5c, 0xee, 0xf2, 0xc3, 0x3d, 0x47, 0xde, 0x1a, + 0x7a, 0x04, 0x3b, 0x34, 0x9e, 0xb4, 0x3e, 0x21, 0x23, 0x75, 0x20, 0x11, 0x69, 0x70, 0x99, 0xbd, + 0x81, 0x07, 0x24, 0xda, 0x3c, 0x86, 0x6e, 0xfe, 0x26, 0x7d, 0xc5, 0x3b, 0xc3, 0x5e, 0x11, 0x1b, + 0x27, 0x59, 0x9f, 0x90, 0xe7, 0xd4, 0xc1, 0xd4, 0xa0, 0x1a, 0x36, 0x0f, 0xfd, 0xe2, 0xdd, 0xed, + 0x9d, 0xd1, 0xd5, 0x88, 0x0b, 0x99, 0xf3, 0xab, 0x11, 0x49, 0x24, 0x0d, 0xe8, 0x07, 0xbe, 0xd3, + 0xce, 0x34, 0x33, 0xb4, 0x01, 0x63, 0xe2, 0xc3, 0x48, 0x03, 0x1e, 0x84, 0xc8, 0xa8, 0x0c, 0xa9, + 0x7d, 0x6d, 0xbe, 0x30, 0x74, 0x01, 0xf5, 0x63, 0xa0, 0xea, 0x13, 0x72, 0x6a, 0x5f, 0x43, 0x1f, + 0x41, 0x96, 0x05, 0xb4, 0x1c, 0x9b, 0xf3, 0xc5, 0xa1, 0x93, 0x78, 0x34, 0x2c, 0xa8, 0x3e, 0x21, + 0xd3, 0x18, 0x1a, 0xde, 0x91, 0x79, 0xb0, 0x02, 0x15, 0x51, 0x1e, 0x11, 0xc7, 0xda, 0x17, 0x32, + 0x42, 0x3a, 0x8c, 0xed, 0x13, 0xd1, 0x36, 0x14, 0xf9, 0x04, 0xee, 0x39, 0x5f, 0x8b, 0x43, 0x9d, + 0x1c, 0xe2, 0xfc, 0xaf, 0xeb, 0x74, 0xa3, 0x2a, 0x44, 0x27, 0x6d, 0x17, 0x95, 0xc8, 0xdb, 0x6e, + 0x76, 0x68, 0xdb, 0x0d, 0xf5, 0x05, 0x26, 0x6d, 0x67, 0x0f, 0x24, 0xa2, 0x6f, 0xc3, 0x24, 0x1b, + 0x27, 0x88, 0x8a, 0x8c, 0xf3, 0xdb, 0xe9, 0x1b, 0x22, 0x2c, 0x3f, 0x99, 0xbd, 0x5c, 0xee, 0xd3, + 0xa8, 0xb4, 0xad, 0xfd, 0xf9, 0xb9, 0xa1, 0xb3, 0xd7, 0xa0, 0x77, 0x26, 0x99, 0xbd, 0xdc, 0x80, + 0x4a, 0x3a, 0x90, 0xcd, 0x52, 0xf8, 0x10, 0xbb, 0x34, 0xb4, 0x03, 0xc5, 0xb8, 0x3a, 0xd6, 0x69, + 0xb4, 0x49, 0x40, 0xf6, 0x27, 0x56, 0x07, 0x2b, 0x74, 0x52, 0xbc, 0x3c, 0x7a, 0x62, 0x8d, 0x5c, + 0xf4, 0xe4, 0x4f, 0xac, 0x8c, 0x8a, 0x9e, 0x83, 0xc8, 0x6f, 0x1b, 0x51, 0x3c, 0xd7, 0x9b, 0xf9, + 0x2b, 0x54, 0xde, 0xbd, 0xd8, 0x05, 0x31, 0xce, 0x2b, 0xab, 0x4e, 0x10, 0x45, 0x34, 0x05, 0x7d, + 0x0c, 0xb3, 0x54, 0x9e, 0xa2, 0x05, 0x17, 0xc4, 0xcc, 0xcf, 0x0f, 0x5c, 0x37, 0x32, 0xfc, 0x2e, + 0x19, 0x4f, 0xb2, 0xa8, 0xf5, 0x25, 0x91, 0xf1, 0x60, 0x98, 0x86, 0x4b, 0xd7, 0xee, 0x85, 0xa1, + 0xe3, 0x21, 0x7a, 0x39, 0x26, 0x19, 0x0f, 0x06, 0xa3, 0x90, 0x6e, 0xdc, 0x37, 0xe3, 0xbd, 0x39, + 0xb4, 0x1b, 0x0f, 0x99, 0xec, 0x0a, 0x6e, 0x64, 0x9e, 0x5b, 0x05, 0x60, 0x38, 0x92, 0x9a, 0xc6, + 0x8b, 0x43, 0x0d, 0x80, 0x7e, 0x57, 0x44, 0x62, 0x00, 0xb4, 0x3d, 0x1a, 0x31, 0x00, 0xd8, 0xa1, + 0xc7, 0xfc, 0xf5, 0xe1, 0x8b, 0x55, 0xf8, 0x58, 0x94, 0x2e, 0x56, 0x94, 0x80, 0x56, 0x20, 0x47, + 0x8c, 0xfa, 0x13, 0x3a, 0xc2, 0x6f, 0x0c, 0xc5, 0xf0, 0x7d, 0x31, 0x4a, 0xf5, 0x09, 0x39, 0xfb, + 0x92, 0x93, 0x48, 0xaf, 0x62, 0x22, 0xf8, 0xd8, 0xbe, 0x3f, 0xb4, 0x57, 0x0d, 0x06, 0xa7, 0x90, + 0x5e, 0xf5, 0x32, 0xa0, 0x06, 0x4b, 0x9e, 0xc3, 0x8e, 0x33, 0xe6, 0xdf, 0x1e, 0xbd, 0xe4, 0x45, + 0x0f, 0x5f, 0xfc, 0x25, 0x8f, 0x93, 0xd9, 0x92, 0xa7, 0x2b, 0x8e, 0x43, 0x3d, 0x1c, 0xe6, 0x6f, + 0x8d, 0x58, 0xf2, 0xfa, 0x36, 0x38, 0xd9, 0x92, 0xa7, 0x37, 0x19, 0x27, 0xb1, 0xfe, 0x6c, 0xef, + 0x76, 0x1d, 0x0e, 0xef, 0xee, 0x0c, 0xb5, 0xfe, 0x62, 0xaf, 0xff, 0x21, 0xd6, 0x9f, 0x1d, 0x49, + 0x40, 0xdf, 0x81, 0x69, 0xbe, 0xa1, 0x34, 0x7f, 0x77, 0x84, 0x8d, 0x1d, 0xde, 0x03, 0x24, 0xdd, + 0x91, 0xf3, 0xb0, 0xc9, 0x81, 0x6d, 0x64, 0xb1, 0xc9, 0xef, 0xde, 0x88, 0xc9, 0x61, 0x60, 0x2f, + 0x8d, 0x4d, 0x0e, 0x01, 0x99, 0x94, 0xc6, 0x61, 0x9b, 0x30, 0xf3, 0xbf, 0x34, 0xb4, 0x34, 0xd1, + 0xdd, 0x28, 0x52, 0x1a, 0xce, 0x43, 0x17, 0x0b, 0xba, 0x56, 0x33, 0xed, 0x7c, 0x63, 0xf8, 0x62, + 0xd1, 0x0f, 0xeb, 0xeb, 0xde, 0x71, 0x11, 0xd3, 0xca, 0x5f, 0x11, 0xe0, 0x3a, 0xeb, 0x03, 0x74, + 0xb3, 0xfc, 0x44, 0xf1, 0xcf, 0x3a, 0x42, 0x7b, 0x16, 0x0f, 0xa8, 0xf8, 0x6f, 0x5f, 0x7c, 0x6b, + 0xde, 0x7b, 0xe3, 0x5b, 0xea, 0xa8, 0x7c, 0x44, 0x19, 0x1d, 0x86, 0xee, 0xe6, 0x1f, 0x0e, 0x55, + 0x46, 0x14, 0x91, 0x12, 0x65, 0x70, 0x1e, 0xd4, 0x86, 0x79, 0x36, 0x24, 0x02, 0xf4, 0xe3, 0x17, + 0xfd, 0xd1, 0x50, 0xa7, 0xc1, 0x91, 0xb8, 0xaf, 0x3e, 0x21, 0x5f, 0x79, 0x19, 0x9b, 0xa1, 0x32, + 0xcd, 0x0f, 0x9f, 0xfd, 0x40, 0xd3, 0x92, 0x28, 0xae, 0x65, 0xb2, 0x57, 0xc5, 0xf9, 0xb5, 0x4c, + 0xf6, 0x0d, 0x71, 0x61, 0x2d, 0x93, 0xbd, 0x26, 0xbe, 0xb9, 0x96, 0xc9, 0x2e, 0x89, 0xd7, 0xd7, + 0x32, 0x59, 0x49, 0xbc, 0x29, 0xfd, 0xce, 0x02, 0x14, 0x3c, 0xf4, 0xc6, 0x50, 0xd4, 0xc3, 0x30, + 0x8a, 0x5a, 0x1c, 0x86, 0xa2, 0x38, 0xde, 0xe3, 0x30, 0xea, 0x61, 0x18, 0x46, 0x2d, 0x0e, 0x83, + 0x51, 0x01, 0x0f, 0xc1, 0x51, 0xad, 0x61, 0x38, 0xea, 0xde, 0x18, 0x38, 0xca, 0x17, 0xd5, 0x0f, + 0xa4, 0x56, 0x07, 0x81, 0xd4, 0xdb, 0xa3, 0x81, 0x94, 0x2f, 0x2a, 0x84, 0xa4, 0x3e, 0xe8, 0x43, + 0x52, 0x37, 0x46, 0x20, 0x29, 0x9f, 0xdf, 0x83, 0x52, 0xeb, 0xb1, 0x50, 0xea, 0xf6, 0x79, 0x50, + 0xca, 0x97, 0x13, 0xc1, 0x52, 0xf5, 0x38, 0x2c, 0x75, 0xeb, 0x1c, 0x2c, 0xe5, 0x8b, 0x0a, 0x83, + 0xa9, 0xf5, 0x58, 0x30, 0x75, 0xfb, 0x3c, 0x30, 0x15, 0x14, 0x2b, 0x8c, 0xa6, 0xbe, 0x15, 0x41, + 0x53, 0x4b, 0x43, 0xd1, 0x94, 0xcf, 0xcd, 0xe0, 0xd4, 0x87, 0xfd, 0x70, 0xea, 0xc6, 0x08, 0x38, + 0x15, 0x28, 0x96, 0xe3, 0xa9, 0x7a, 0x1c, 0x9e, 0xba, 0x75, 0x0e, 0x9e, 0x0a, 0x74, 0x11, 0x02, + 0x54, 0x5b, 0xf1, 0x80, 0xea, 0xce, 0xb9, 0x80, 0xca, 0x97, 0x16, 0x45, 0x54, 0xf5, 0x38, 0x44, + 0x75, 0xeb, 0x1c, 0x44, 0xd5, 0x57, 0x32, 0x06, 0xa9, 0xd4, 0x91, 0x90, 0xea, 0x9d, 0x31, 0x21, + 0x95, 0x2f, 0x3a, 0x0e, 0x53, 0xe9, 0xa3, 0x31, 0x55, 0x79, 0x5c, 0x4c, 0xe5, 0xbf, 0x24, 0x16, + 0x54, 0xa9, 0x23, 0x41, 0xd5, 0x3b, 0x63, 0x82, 0xaa, 0xbe, 0x8a, 0x44, 0x51, 0xd5, 0x56, 0x3c, + 0xaa, 0xba, 0x73, 0x2e, 0xaa, 0x0a, 0x5a, 0x31, 0x02, 0xab, 0x96, 0x43, 0xb0, 0xea, 0xad, 0x21, + 0xb0, 0xca, 0x67, 0x25, 0xb8, 0xea, 0xbb, 0x03, 0xb8, 0x4a, 0x1a, 0x85, 0xab, 0x7c, 0x5e, 0x1f, + 0x58, 0xd5, 0xe3, 0x80, 0xd5, 0xad, 0x73, 0x80, 0x55, 0xd0, 0x6f, 0x42, 0xc8, 0xea, 0xd9, 0x10, + 0x64, 0x75, 0xf7, 0x7c, 0x64, 0xe5, 0xcb, 0xeb, 0x83, 0x56, 0xea, 0x48, 0x68, 0xf5, 0xce, 0x98, + 0xd0, 0x2a, 0x68, 0xc1, 0x18, 0x6c, 0xf5, 0x5e, 0x14, 0x5b, 0x5d, 0x1f, 0x8e, 0xad, 0x7c, 0x31, + 0x1c, 0x5c, 0xad, 0xc7, 0x82, 0xab, 0xdb, 0xe7, 0x81, 0xab, 0x60, 0x36, 0x0b, 0xa3, 0xab, 0xad, + 0x78, 0x74, 0x75, 0xe7, 0x5c, 0x74, 0x15, 0x74, 0xa4, 0x08, 0xbc, 0x5a, 0x8f, 0x85, 0x57, 0xb7, + 0xcf, 0x83, 0x57, 0x7d, 0x53, 0x2d, 0xc7, 0x57, 0x2f, 0x86, 0xe2, 0xab, 0xfb, 0xe3, 0xe0, 0x2b, + 0x5f, 0xe8, 0x00, 0xc0, 0xfa, 0x64, 0x38, 0xc0, 0xfa, 0xa5, 0x0b, 0x5c, 0xd6, 0x19, 0x8b, 0xb0, + 0xbe, 0x3b, 0x80, 0xb0, 0xa4, 0x51, 0x08, 0x2b, 0x18, 0x19, 0x1e, 0xc4, 0xaa, 0xc5, 0x00, 0xa2, + 0xb7, 0x47, 0x03, 0xa2, 0x60, 0x21, 0x0f, 0x10, 0xd1, 0x07, 0x7d, 0x88, 0xe8, 0xc6, 0xb9, 0x7e, + 0x71, 0x21, 0x48, 0x54, 0x19, 0x84, 0x44, 0x37, 0x47, 0x42, 0x22, 0x5f, 0x42, 0x80, 0x89, 0xd6, + 0x63, 0x31, 0xd1, 0xed, 0xf3, 0x30, 0x51, 0xd0, 0x15, 0xc2, 0xa0, 0x68, 0x2b, 0x1e, 0x14, 0xdd, + 0x39, 0x17, 0x14, 0xf5, 0x2d, 0x5b, 0x1e, 0x2a, 0xaa, 0xc7, 0xa1, 0xa2, 0x5b, 0xe7, 0xa0, 0xa2, + 0xf0, 0xb2, 0xe5, 0xc3, 0xa2, 0xd6, 0x30, 0x58, 0x74, 0x6f, 0x0c, 0x58, 0x14, 0x18, 0x73, 0x7d, + 0xb8, 0xe8, 0xa3, 0x7e, 0x5c, 0x24, 0x8d, 0xc2, 0x45, 0x41, 0x27, 0xf2, 0x80, 0xd1, 0x56, 0x3c, + 0x30, 0xba, 0x73, 0x2e, 0x30, 0x0a, 0x8f, 0xeb, 0x10, 0x32, 0xfa, 0xa8, 0x1f, 0x19, 0x49, 0xa3, + 0x90, 0x51, 0x50, 0x1e, 0x0f, 0x1a, 0xd5, 0xe3, 0xa0, 0xd1, 0xad, 0x73, 0xa0, 0x51, 0x68, 0xba, + 0x0f, 0xb0, 0xd1, 0x5f, 0x1d, 0x1f, 0x1b, 0xbd, 0xf7, 0xba, 0x6e, 0x4b, 0xe7, 0x83, 0xa3, 0x8f, + 0xfa, 0xc1, 0x91, 0x34, 0x0a, 0x1c, 0x05, 0xfa, 0xf0, 0xd0, 0x51, 0xe7, 0x5c, 0x74, 0xf4, 0xe0, + 0x02, 0xe8, 0xc8, 0x97, 0xff, 0xa5, 0xe1, 0xd1, 0x9b, 0xe2, 0x5b, 0x11, 0x90, 0xf4, 0xcf, 0xb3, + 0x30, 0xc5, 0xbf, 0x53, 0x15, 0xb9, 0xdb, 0x49, 0x78, 0x9d, 0xbb, 0x9d, 0xd0, 0x77, 0xe0, 0x9a, + 0xff, 0x40, 0x3d, 0x4f, 0x14, 0x1e, 0xf1, 0xa2, 0xb5, 0x2d, 0xed, 0x90, 0xae, 0x3d, 0x59, 0x79, + 0xde, 0xcf, 0xf2, 0xd8, 0xb6, 0x3a, 0x2c, 0xf2, 0x85, 0x9e, 0xe7, 0xa3, 0x55, 0x32, 0x28, 0xa8, + 0x91, 0x75, 0xfe, 0x85, 0x82, 0x83, 0x57, 0xde, 0x71, 0xd6, 0xd7, 0x88, 0xd1, 0x46, 0xdf, 0x82, + 0x42, 0xcf, 0xc1, 0xb6, 0xd2, 0xb5, 0x0d, 0xcb, 0x36, 0x5c, 0x16, 0x6d, 0x22, 0x54, 0xc4, 0x2f, + 0x4e, 0x97, 0x66, 0x76, 0x1c, 0x6c, 0x6f, 0x73, 0xba, 0x3c, 0xd3, 0x0b, 0x3d, 0x79, 0x5f, 0xf6, + 0x9a, 0x1c, 0xff, 0xcb, 0x5e, 0xcf, 0x40, 0xa4, 0xbe, 0x04, 0xe1, 0x75, 0x89, 0x5d, 0xc3, 0x14, + 0xbf, 0x84, 0xaa, 0x7a, 0x68, 0xe9, 0xa1, 0xd7, 0x31, 0x95, 0xec, 0x28, 0x11, 0x3d, 0x81, 0xa2, + 0x6d, 0xf5, 0xe8, 0x6d, 0x2b, 0x5d, 0xab, 0x6d, 0x68, 0x27, 0xd4, 0x60, 0x28, 0xc6, 0x9f, 0x99, + 0xb2, 0x8c, 0xdb, 0x34, 0x9f, 0x5c, 0xb0, 0xc3, 0x8f, 0xa8, 0x09, 0xf4, 0xa6, 0x15, 0x4f, 0x0a, + 0x1a, 0xb8, 0xdb, 0x7a, 0xe4, 0x0d, 0xf3, 0x2f, 0x54, 0xc3, 0xe5, 0x72, 0xe1, 0x95, 0xff, 0x1b, + 0x3d, 0x86, 0x19, 0x7a, 0xeb, 0x2f, 0x69, 0x73, 0xab, 0xe7, 0x72, 0x7b, 0xe1, 0x8d, 0x32, 0xfb, + 0xfe, 0x5b, 0xd9, 0xfb, 0xfe, 0x5b, 0x79, 0x95, 0x7f, 0xff, 0x8d, 0x1d, 0xb0, 0x7e, 0xfe, 0x1f, + 0x97, 0x04, 0x39, 0xef, 0xf9, 0x78, 0x58, 0x3d, 0x17, 0x3d, 0x80, 0xcb, 0x1d, 0xf5, 0x98, 0x5e, + 0x1e, 0xac, 0x78, 0x06, 0x0d, 0xbd, 0x2e, 0x8d, 0x7d, 0x74, 0x0c, 0x75, 0xd4, 0x63, 0xfa, 0x31, + 0x34, 0x96, 0x44, 0xbf, 0x64, 0x72, 0x03, 0x66, 0x78, 0x18, 0x02, 0xfb, 0xd0, 0x51, 0x89, 0xe6, + 0xe4, 0x5f, 0xbd, 0x60, 0xdf, 0x3a, 0xba, 0x05, 0x45, 0xdd, 0x70, 0x5c, 0xc3, 0xd4, 0x5c, 0x7e, + 0x2f, 0x31, 0xbb, 0xd9, 0xb7, 0xe0, 0x51, 0xd9, 0xe5, 0xc3, 0x2d, 0x98, 0xd5, 0xda, 0x86, 0x6f, + 0x26, 0xb2, 0x85, 0x7b, 0x76, 0xe8, 0xb4, 0x50, 0xa5, 0x79, 0xfb, 0x8f, 0xfa, 0x4b, 0x5a, 0x94, + 0x8c, 0xaa, 0x50, 0xda, 0x57, 0x5d, 0xfc, 0x4a, 0x3d, 0x51, 0xbc, 0x28, 0xbb, 0x3c, 0x8d, 0x2c, + 0xbe, 0x76, 0x76, 0xba, 0x54, 0x78, 0xc2, 0x92, 0x06, 0x82, 0xed, 0x0a, 0xfb, 0xa1, 0x04, 0x1d, + 0xdd, 0x81, 0x92, 0xea, 0x9c, 0x98, 0x1a, 0xed, 0x51, 0xd8, 0x74, 0x7a, 0x0e, 0xb5, 0xf2, 0xb3, + 0x72, 0x91, 0x92, 0xab, 0x1e, 0x15, 0x7d, 0x00, 0x0b, 0xfc, 0xf3, 0x03, 0xaf, 0x54, 0x5b, 0x57, + 0x68, 0x2f, 0x0c, 0x86, 0xbb, 0x48, 0x79, 0xae, 0xb2, 0xcf, 0x0d, 0x90, 0x0c, 0xa4, 0xeb, 0x85, + 0xaf, 0xf5, 0x65, 0xd7, 0x16, 0x83, 0x98, 0x5f, 0xcb, 0x64, 0x67, 0xc4, 0xc2, 0x5a, 0x26, 0x5b, + 0x14, 0x4b, 0xd2, 0x0f, 0xd2, 0x50, 0x22, 0x13, 0xae, 0xe3, 0x18, 0x96, 0x59, 0xf7, 0x1d, 0x5e, + 0xfd, 0x61, 0x24, 0xd0, 0x80, 0x27, 0xff, 0x19, 0x2d, 0xd1, 0xc0, 0x32, 0x62, 0xd8, 0xfa, 0x1f, + 0x1d, 0x49, 0xcb, 0xc0, 0x48, 0x34, 0xc4, 0x67, 0x05, 0xa6, 0x1c, 0xab, 0x67, 0x6b, 0xde, 0x55, + 0xf8, 0xf7, 0x86, 0xcc, 0xf0, 0xa1, 0x17, 0x96, 0x9b, 0x94, 0x41, 0xe6, 0x8c, 0xe8, 0x13, 0x28, + 0xb1, 0x5f, 0x34, 0x98, 0x86, 0x06, 0xb3, 0xb0, 0x48, 0xa1, 0x07, 0x63, 0xcb, 0xda, 0xe0, 0x8c, + 0x72, 0xd1, 0x89, 0x3c, 0xa3, 0x8f, 0xe0, 0x4d, 0xd3, 0x52, 0x3a, 0xb8, 0x63, 0xb1, 0x99, 0x9d, + 0x8c, 0x05, 0x5d, 0x51, 0x5d, 0x85, 0x17, 0x9a, 0x79, 0x50, 0xce, 0x9b, 0xd6, 0x26, 0xcd, 0x22, + 0xf3, 0x1c, 0x2b, 0x2e, 0x93, 0x2b, 0x95, 0x61, 0x8a, 0xfd, 0x42, 0x39, 0x98, 0x7c, 0xda, 0xaa, + 0xd7, 0x64, 0x71, 0x02, 0xcd, 0x40, 0xf6, 0xb1, 0xfc, 0x74, 0x53, 0x69, 0x3e, 0xdb, 0x10, 0x05, + 0x94, 0x87, 0x69, 0xf9, 0xe9, 0xd3, 0x96, 0xb2, 0xfe, 0x5c, 0x4c, 0x49, 0x77, 0xa0, 0x18, 0x2d, + 0x11, 0x02, 0x98, 0x92, 0x6b, 0x9b, 0x4f, 0xe9, 0xfd, 0xef, 0x39, 0x98, 0xdc, 0x78, 0x5a, 0x5d, + 0xd9, 0x10, 0x05, 0xe9, 0x4f, 0x04, 0x98, 0xa9, 0xb0, 0x0f, 0x1a, 0x30, 0x0f, 0x8a, 0x0f, 0xfa, + 0x5c, 0x1b, 0xde, 0x88, 0x47, 0x8e, 0xf1, 0x2e, 0x0d, 0x2b, 0x90, 0xe5, 0x63, 0xcc, 0x0b, 0xba, + 0x58, 0x1a, 0x8e, 0x17, 0xe8, 0xd6, 0x9a, 0xe7, 0x38, 0xe7, 0xb1, 0xa1, 0x26, 0x88, 0xaa, 0xa7, + 0x5b, 0x85, 0x97, 0x64, 0xb8, 0xfb, 0x5c, 0x5f, 0x33, 0x78, 0x23, 0x46, 0x8d, 0x92, 0xdf, 0xcf, + 0x7c, 0xfe, 0xe3, 0xa5, 0x09, 0xe9, 0x4f, 0x33, 0x50, 0xa8, 0x84, 0x3f, 0xde, 0x80, 0x1a, 0x7d, + 0x95, 0x8d, 0xb3, 0x82, 0x22, 0x1c, 0xe5, 0x11, 0x9f, 0xc5, 0xc9, 0x05, 0x5f, 0x8a, 0x60, 0x75, + 0xbf, 0x3e, 0xc2, 0x2b, 0x24, 0x5c, 0xf9, 0x80, 0x71, 0xe1, 0xdf, 0xa5, 0xfd, 0x55, 0xb5, 0x0c, + 0x93, 0x2c, 0xb0, 0x4f, 0x18, 0xb8, 0x73, 0x80, 0xce, 0xa7, 0xc4, 0x4a, 0x27, 0xe9, 0x32, 0xcb, + 0x46, 0x56, 0xe1, 0xd6, 0x6b, 0xdd, 0xb0, 0x18, 0xd8, 0x2e, 0x17, 0xff, 0xe0, 0x64, 0x8f, 0xdd, + 0xb0, 0xf9, 0xff, 0xd1, 0x63, 0x8f, 0xbc, 0x0f, 0xfd, 0x1a, 0x94, 0x34, 0xab, 0xdd, 0x66, 0xc6, + 0x1d, 0x9b, 0x7f, 0x07, 0xef, 0xdc, 0xa1, 0x45, 0xe0, 0xdf, 0x18, 0x2d, 0xfb, 0xdf, 0x1a, 0x2d, + 0xcb, 0xfc, 0x5b, 0xa3, 0xa1, 0x70, 0x8a, 0xa2, 0x2f, 0x8c, 0x4d, 0xdb, 0x7d, 0x91, 0x1d, 0xd3, + 0xaf, 0x13, 0xd9, 0xc1, 0xe2, 0x61, 0x78, 0xcf, 0xfb, 0x43, 0x81, 0xfb, 0xd5, 0x6d, 0x58, 0xd6, + 0x61, 0xcf, 0xf7, 0x56, 0x5a, 0x08, 0xdf, 0x97, 0x19, 0x38, 0x9d, 0xd3, 0xa0, 0xa9, 0xb8, 0x05, + 0x3f, 0xf5, 0xe5, 0x16, 0xfc, 0x1b, 0x30, 0xd3, 0xb5, 0xf1, 0x1e, 0x76, 0xb5, 0x03, 0xc5, 0xec, + 0x75, 0x78, 0xc4, 0x58, 0xde, 0xa3, 0x6d, 0xf5, 0x3a, 0xe8, 0x1e, 0x88, 0x7e, 0x16, 0x0e, 0xb8, + 0xbd, 0xcb, 0xda, 0x3c, 0x3a, 0x87, 0xe7, 0xd2, 0xff, 0x14, 0x60, 0x2e, 0x52, 0x27, 0x3e, 0xa6, + 0xd6, 0x20, 0xaf, 0xfb, 0x26, 0x96, 0x33, 0x2f, 0x5c, 0x30, 0x1c, 0x21, 0xcc, 0x8c, 0x14, 0xb8, + 0xe2, 0xbd, 0x96, 0x7e, 0x5d, 0x21, 0x10, 0x9b, 0xba, 0xa0, 0xd8, 0xcb, 0x81, 0x9c, 0xd5, 0xd0, + 0x0b, 0xfc, 0x41, 0x96, 0x1e, 0x6b, 0x90, 0x49, 0xff, 0x4b, 0x00, 0x91, 0xbe, 0xe0, 0x31, 0xc6, + 0x7a, 0x22, 0x53, 0xa6, 0x17, 0xf7, 0x93, 0x1a, 0x3f, 0x26, 0x2c, 0xf2, 0x45, 0x98, 0x74, 0xdf, + 0x17, 0x61, 0xe2, 0xe6, 0xcf, 0xcc, 0x97, 0x9c, 0x3f, 0xa5, 0x1f, 0x0b, 0x50, 0xf4, 0xab, 0xcd, + 0x3e, 0x05, 0x39, 0xe2, 0xae, 0xd7, 0xd7, 0xfb, 0xdc, 0xa1, 0x77, 0x27, 0xcd, 0x58, 0x5f, 0xa7, + 0x0c, 0xdf, 0x49, 0xc3, 0x3e, 0xd3, 0xf7, 0xb7, 0xbc, 0xee, 0x48, 0x8a, 0x58, 0x0d, 0x2e, 0x03, + 0x79, 0x8d, 0x98, 0xbb, 0xaf, 0xc2, 0x31, 0xef, 0x71, 0x48, 0x81, 0xb4, 0x47, 0x11, 0x2d, 0x8d, + 0x35, 0xbf, 0x7b, 0x5a, 0x62, 0x1d, 0xf0, 0xa7, 0xe1, 0x96, 0x60, 0xc1, 0xe4, 0x8f, 0x20, 0x7d, + 0xa4, 0xb6, 0x47, 0x79, 0x22, 0x46, 0x5a, 0x4e, 0x26, 0xb9, 0xd1, 0xe3, 0xc8, 0x1d, 0x2a, 0xa9, + 0xe1, 0x9b, 0x71, 0x83, 0x2a, 0x8d, 0xdc, 0xb5, 0xf2, 0xed, 0xe8, 0x00, 0x1a, 0xf9, 0xfa, 0xf0, + 0x48, 0x7a, 0x3f, 0xf3, 0x93, 0x1f, 0x2f, 0x09, 0xd2, 0x87, 0x80, 0x88, 0xad, 0xe3, 0x3e, 0xeb, + 0x59, 0x76, 0x70, 0x1f, 0x4d, 0x7f, 0x7c, 0xcf, 0x64, 0x7c, 0x7c, 0x8f, 0x74, 0x19, 0xe6, 0x22, + 0xdc, 0x6c, 0x06, 0x92, 0xbe, 0x0d, 0x6f, 0x3c, 0xb1, 0x1c, 0xc7, 0xe8, 0x36, 0x7b, 0xbb, 0x6c, + 0xa8, 0x93, 0xf5, 0xca, 0x9f, 0x73, 0xb3, 0x5d, 0xba, 0xd3, 0x63, 0xb2, 0xb9, 0x29, 0x27, 0xfb, + 0xcf, 0xd2, 0xbf, 0x12, 0xe0, 0xea, 0x20, 0x27, 0xd3, 0x72, 0x5c, 0x88, 0xf0, 0xb4, 0x66, 0x05, + 0xd7, 0x25, 0x9e, 0xdf, 0x5b, 0xbd, 0xec, 0xc4, 0xf6, 0xe6, 0xef, 0x54, 0x3a, 0x2a, 0x9d, 0x93, + 0x78, 0xf4, 0x7e, 0x91, 0x93, 0x37, 0x19, 0x35, 0x98, 0x9e, 0x32, 0xe3, 0x4d, 0x4f, 0xff, 0x5b, + 0x80, 0xd9, 0x16, 0x36, 0x55, 0xd3, 0x25, 0xf3, 0x7e, 0xaf, 0xc3, 0xc2, 0xaa, 0x4b, 0x90, 0xb6, + 0x95, 0x1e, 0x2d, 0xba, 0x20, 0xa7, 0xec, 0x1d, 0x74, 0x13, 0x0a, 0x74, 0x6d, 0x09, 0xd9, 0x6a, + 0xc2, 0xdd, 0x8c, 0x4c, 0xbd, 0xd5, 0x65, 0xcf, 0x10, 0x7b, 0x0b, 0x80, 0x66, 0x62, 0x18, 0x28, + 0x4d, 0x73, 0xe4, 0x08, 0xc5, 0x47, 0x40, 0x34, 0xfa, 0x27, 0x10, 0xc2, 0x1c, 0xfc, 0x0b, 0x94, + 0xea, 0x4b, 0x59, 0x82, 0x3c, 0xcb, 0xc6, 0xc4, 0x4c, 0xd2, 0x3c, 0x40, 0x49, 0x4c, 0xce, 0x63, + 0xb8, 0xe4, 0xbc, 0x6c, 0x2b, 0x5d, 0x4b, 0x77, 0x14, 0xad, 0xdb, 0xe3, 0x9e, 0xd3, 0xec, 0xeb, + 0xb2, 0x42, 0xe5, 0xf2, 0xd9, 0xe9, 0xd2, 0x6c, 0xf3, 0xd9, 0xc6, 0xb6, 0xa5, 0x3b, 0xd5, 0xed, + 0x1d, 0xe6, 0x37, 0xed, 0xc8, 0xb3, 0xce, 0xcb, 0x36, 0x25, 0x75, 0x7b, 0x9c, 0x24, 0x7d, 0x96, + 0x02, 0x44, 0xaf, 0xe7, 0xa8, 0xd0, 0xfb, 0x2d, 0xbc, 0xe6, 0xb6, 0x60, 0x51, 0x0b, 0x54, 0xa1, + 0x38, 0x86, 0x49, 0xec, 0x7b, 0xd5, 0x71, 0xbd, 0x72, 0xf3, 0x71, 0x13, 0x7b, 0xab, 0x60, 0xbf, + 0x26, 0x79, 0x3b, 0x5e, 0x0b, 0x49, 0x6c, 0x12, 0x81, 0x1b, 0xaa, 0xe3, 0xbf, 0xf0, 0x1e, 0xe4, + 0x5c, 0xca, 0xe7, 0x5d, 0x7e, 0x92, 0xa9, 0xcc, 0x9c, 0x9d, 0x2e, 0x65, 0x99, 0xb0, 0xc6, 0xaa, + 0x9c, 0x65, 0xc9, 0x0d, 0x1d, 0x2d, 0x43, 0xde, 0x30, 0x1d, 0x57, 0x25, 0x45, 0xe2, 0x5b, 0x0e, + 0x05, 0x16, 0x68, 0xdb, 0xe0, 0xe4, 0xc6, 0xaa, 0x0c, 0x5e, 0x16, 0x1a, 0xcf, 0x56, 0xf4, 0x19, + 0xd8, 0xa6, 0x3c, 0x0d, 0xbe, 0x94, 0x0b, 0x1e, 0x95, 0x5d, 0xcf, 0xd5, 0x84, 0xb9, 0x88, 0x26, + 0xf8, 0xc2, 0xfc, 0x61, 0x74, 0xc2, 0x09, 0x5b, 0xa7, 0xde, 0xc7, 0xe9, 0xcb, 0x35, 0x53, 0xb3, + 0x74, 0x3e, 0x52, 0xa3, 0x13, 0x4f, 0x0b, 0x4a, 0x6b, 0x96, 0x61, 0x12, 0xf4, 0xe8, 0x55, 0x75, + 0x05, 0x8a, 0xbb, 0x86, 0xa9, 0xda, 0x27, 0x8a, 0xe7, 0x28, 0x2e, 0x9c, 0xe7, 0x28, 0x2e, 0x17, + 0x18, 0x07, 0x7f, 0x94, 0x7e, 0x2e, 0x80, 0x18, 0x88, 0xe5, 0x05, 0xfd, 0x06, 0x80, 0xd6, 0xee, + 0x39, 0x2e, 0xb6, 0xbd, 0x09, 0x60, 0x86, 0x05, 0xa4, 0x55, 0x19, 0xb5, 0xb1, 0x2a, 0xe7, 0x78, + 0x86, 0x86, 0x8e, 0x6e, 0x46, 0xef, 0x9a, 0x99, 0xac, 0xc0, 0xd9, 0xc0, 0x0d, 0x33, 0x64, 0x46, + 0x71, 0x5c, 0xcb, 0xf6, 0xf5, 0xcc, 0x67, 0x14, 0xef, 0x16, 0x2e, 0x7a, 0xdb, 0x04, 0xa6, 0x31, + 0xa7, 0x45, 0x62, 0xde, 0x1e, 0x61, 0xbf, 0x4a, 0x99, 0xf3, 0xab, 0xc4, 0x38, 0xbc, 0x2a, 0xfd, + 0xbe, 0x00, 0xa5, 0x2a, 0x1b, 0xe8, 0xfe, 0xe4, 0x31, 0x62, 0xb1, 0x5c, 0x85, 0xac, 0x7b, 0x6c, + 0x2a, 0x1d, 0xec, 0x7f, 0x38, 0xea, 0x02, 0xd7, 0x64, 0x4e, 0xbb, 0xec, 0x91, 0x7e, 0x8b, 0x94, + 0x6f, 0x84, 0xf0, 0x99, 0x78, 0xac, 0x9d, 0x12, 0x9f, 0x89, 0xd9, 0xa9, 0xf7, 0x9b, 0x64, 0x42, + 0x1d, 0xb0, 0x24, 0x51, 0x11, 0x20, 0xf4, 0x45, 0x30, 0xfe, 0xed, 0xf5, 0x95, 0x55, 0x65, 0x67, + 0xab, 0xfa, 0x74, 0x73, 0xb3, 0xd1, 0x6a, 0xd5, 0x56, 0x45, 0x01, 0x89, 0x30, 0x13, 0xf9, 0x9e, + 0x58, 0x8a, 0x7d, 0x8d, 0xfd, 0xfe, 0x3b, 0x50, 0x88, 0x6c, 0x1f, 0xa1, 0x12, 0xe4, 0x37, 0x6a, + 0x2b, 0xcd, 0x5a, 0xfd, 0xe9, 0xc6, 0x2a, 0x05, 0xb2, 0x79, 0x98, 0xde, 0xaa, 0xad, 0xc8, 0xb5, + 0x66, 0x4b, 0x14, 0xee, 0xff, 0x05, 0x80, 0xe0, 0x4b, 0x86, 0xe4, 0xd5, 0xeb, 0xb5, 0x8f, 0x95, + 0xe7, 0x2b, 0x1b, 0x3b, 0xb5, 0xa6, 0x38, 0x81, 0x10, 0x14, 0x2b, 0x2b, 0xad, 0x6a, 0x5d, 0x91, + 0x6b, 0xcd, 0xed, 0xa7, 0x5b, 0xcd, 0x9a, 0xf7, 0xd1, 0xf7, 0xfb, 0xab, 0x30, 0x13, 0xbe, 0x2b, + 0x0c, 0xcd, 0x41, 0xa9, 0x5a, 0xaf, 0x55, 0xd7, 0x95, 0xe7, 0x8d, 0x15, 0xe5, 0xd9, 0x4e, 0x6d, + 0x87, 0x20, 0x5f, 0x52, 0x13, 0x4a, 0x7c, 0xbc, 0xb3, 0x41, 0x40, 0x73, 0x09, 0xf2, 0xec, 0x99, + 0x7e, 0xaa, 0x4c, 0x4c, 0xdd, 0xdf, 0x84, 0x7c, 0xe8, 0x0e, 0x73, 0xf2, 0xba, 0xed, 0x9d, 0x66, + 0x5d, 0x69, 0x35, 0x36, 0x6b, 0xcd, 0xd6, 0xca, 0xe6, 0x36, 0x93, 0x41, 0x69, 0x2b, 0x95, 0xa7, + 0x72, 0x4b, 0x14, 0xfc, 0xe7, 0xd6, 0xd3, 0x9d, 0x6a, 0xdd, 0xab, 0xb5, 0x94, 0xc9, 0xa6, 0xc5, + 0xf4, 0xfd, 0x63, 0xb8, 0x3a, 0xe4, 0xda, 0x2c, 0x52, 0xe9, 0x1d, 0x93, 0xde, 0xe7, 0x2c, 0x4e, + 0xa0, 0x02, 0xe4, 0x48, 0x4f, 0xa5, 0x41, 0xf5, 0xa2, 0x80, 0xb2, 0x90, 0x39, 0x70, 0xdd, 0xae, + 0x98, 0x42, 0x53, 0x90, 0x72, 0x1e, 0x89, 0x69, 0xf2, 0x7f, 0xdf, 0x11, 0x33, 0x04, 0xba, 0xab, + 0x9f, 0xf6, 0x6c, 0x2c, 0x4e, 0x12, 0xf8, 0xdf, 0x73, 0xb0, 0xbd, 0x67, 0xb4, 0xb1, 0x38, 0x4d, + 0x58, 0xcc, 0x5e, 0xbb, 0x2d, 0x66, 0xa5, 0x4c, 0x76, 0x4a, 0x9c, 0xba, 0x7f, 0x03, 0x42, 0xb7, + 0x97, 0x10, 0xf4, 0xbf, 0xa1, 0xba, 0xd8, 0x71, 0xc5, 0x09, 0x34, 0x0d, 0xe9, 0x95, 0x76, 0x5b, + 0x14, 0x1e, 0x7e, 0x3e, 0x09, 0x59, 0xef, 0x4b, 0x5c, 0x68, 0x03, 0x26, 0x29, 0xd2, 0x45, 0x4b, + 0xc3, 0x31, 0x30, 0x1d, 0xf6, 0x0b, 0xd7, 0xcf, 0x03, 0xc9, 0xd2, 0x04, 0xfa, 0x8b, 0x90, 0x0f, + 0x61, 0x03, 0x34, 0x74, 0x3f, 0x3f, 0x82, 0x87, 0x16, 0x6e, 0x9f, 0x97, 0xcd, 0x97, 0xff, 0x02, + 0x72, 0xbe, 0x59, 0x81, 0x6e, 0x8e, 0x32, 0x3a, 0x3c, 0xd9, 0xa3, 0x2d, 0x13, 0x32, 0x4a, 0xa5, + 0x89, 0x77, 0x05, 0x64, 0x03, 0x1a, 0xb4, 0x00, 0x50, 0x9c, 0xcf, 0xec, 0x50, 0x13, 0x63, 0xe1, + 0xfe, 0x58, 0xb9, 0x83, 0x77, 0x12, 0x65, 0x05, 0x66, 0x4c, 0xbc, 0xb2, 0x06, 0x8c, 0xa4, 0x78, + 0x65, 0xc5, 0x58, 0x43, 0xb4, 0x31, 0x42, 0xeb, 0x41, 0xac, 0xfc, 0xc1, 0x95, 0x33, 0x56, 0x7e, + 0xcc, 0xb2, 0x22, 0x4d, 0xa0, 0x67, 0x90, 0x21, 0x73, 0x38, 0x8a, 0x03, 0x18, 0x7d, 0x6b, 0xc6, + 0xc2, 0xcd, 0x91, 0x79, 0x3c, 0x91, 0x95, 0x7b, 0x3f, 0xf9, 0x4f, 0x8b, 0x13, 0x3f, 0x39, 0x5b, + 0x14, 0x7e, 0x7e, 0xb6, 0x28, 0xfc, 0xd1, 0xd9, 0xa2, 0xf0, 0xc7, 0x67, 0x8b, 0xc2, 0x0f, 0x7f, + 0xb1, 0x38, 0xf1, 0xf3, 0x5f, 0x2c, 0x4e, 0xfc, 0xd1, 0x2f, 0x16, 0x27, 0x3e, 0x99, 0xe6, 0xdc, + 0xbb, 0x53, 0x74, 0x82, 0x7b, 0xf4, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x8a, 0x1d, 0x6f, 0x74, + 0x88, 0x85, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -15685,6 +15707,16 @@ func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + n245, err245 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.LockTimeout, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.LockTimeout):]) + if err245 != nil { + return 0, err245 + } + i -= n245 + i = encodeVarintApi(dAtA, i, uint64(n245)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xaa if m.TimestampFromServerClock { i-- if m.TimestampFromServerClock { @@ -16821,12 +16853,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 + n275, err275 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) + if err275 != nil { + return 0, err275 } - i -= n274 - i = encodeVarintApi(dAtA, i, uint64(n274)) + i -= n275 + i = encodeVarintApi(dAtA, i, uint64(n275)) i-- dAtA[i] = 0x1a { @@ -19828,6 +19860,8 @@ func (m *Header) Size() (n int) { if m.TimestampFromServerClock { n += 3 } + l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.LockTimeout) + n += 2 + l + sovApi(uint64(l)) return n } @@ -38130,6 +38164,39 @@ func (m *Header) Unmarshal(dAtA []byte) error { } } m.TimestampFromServerClock = bool(v != 0) + case 21: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field LockTimeout", 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 := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.LockTimeout, dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) diff --git a/pkg/roachpb/api.proto b/pkg/roachpb/api.proto index 041c0b32dfc6..3708c0d6ee74 100644 --- a/pkg/roachpb/api.proto +++ b/pkg/roachpb/api.proto @@ -1969,6 +1969,27 @@ message Header { // If the desired behavior is to block on the conflicting lock up to some // maximum duration, use the Block wait policy and set a context timeout. kv.kvserver.concurrency.lock.WaitPolicy wait_policy = 18; + // lock_timeout specifies the maximum amount of time that the batch request + // will wait while attempting to acquire a lock on a key or while blocking on + // an existing lock in order to perform a non-locking read on a key. The time + // limit applies separately to each lock acquisition attempt. If the timeout + // elapses when waiting for a lock, a WriteIntentError will be returned. + // + // Unlike in some other systems like PostgreSQL, where non-locking reads do + // not wait on conflicting locks, in CockroachDB, non-locking reads do wait + // for conflicting locks to be released. Because of this, the lock_timeout + // configuration applies to non-locking reads in read-write and read-only + // transactions as well. + // + // Only the (default) Block wait policy will allow a request to wait on + // conflicting locks, so the timeout only makes sense in conjunction with the + // Block wait policy. The Error wait policy will throw an error immediately if + // a conflicting lock held by an active transaction is encountered, so this + // timeout can never be hit with an Error wait policy. + // + // A value of zero disables the timeout. + google.protobuf.Duration lock_timeout = 21 [(gogoproto.nullable) = false, + (gogoproto.stdduration) = true]; // If set to a non-zero value, the total number of keys touched by requests in // the batch is limited. A resume span will be provided on the response of the // requests that were not able to run to completion before the limit was diff --git a/pkg/roachpb/errors.go b/pkg/roachpb/errors.go index 88dc8f604728..724d2a95d6df 100644 --- a/pkg/roachpb/errors.go +++ b/pkg/roachpb/errors.go @@ -871,6 +871,19 @@ func (e *WriteIntentError) message(_ *Error) string { buf.WriteString(end[i].Key.String()) } } + + switch e.Reason { + case WriteIntentError_REASON_UNSPECIFIED: + // Nothing to say. + case WriteIntentError_REASON_WAIT_POLICY: + buf.WriteString(" [reason=wait_policy]") + case WriteIntentError_REASON_LOCK_TIMEOUT: + buf.WriteString(" [reason=lock_timeout]") + case WriteIntentError_REASON_LOCK_WAIT_QUEUE_MAX_LENGTH_EXCEEDED: + buf.WriteString(" [reason=lock_wait_queue_max_length_exceeded]") + default: + // Could panic, better to silently ignore in case new reasons are added. + } return buf.String() } diff --git a/pkg/roachpb/errors.pb.go b/pkg/roachpb/errors.pb.go index 69c353276163..0cf3da83d15c 100644 --- a/pkg/roachpb/errors.pb.go +++ b/pkg/roachpb/errors.pb.go @@ -301,6 +301,60 @@ func (TransactionStatusError_Reason) EnumDescriptor() ([]byte, []int) { return fileDescriptor_123941c6716fd549, []int{9, 0} } +type WriteIntentError_Reason int32 + +const ( + // The reason for the WriteIntentError is unspecified. This will + // always be the case for errors returned from MVCC. + WriteIntentError_REASON_UNSPECIFIED WriteIntentError_Reason = 0 + // The request used an Error wait policy because it did not want to + // wait on locks and it encountered a conflicting lock. + WriteIntentError_REASON_WAIT_POLICY WriteIntentError_Reason = 1 + // The request used a Block wait policy and specified a lock timeout + // which expired while waiting for a conflicting lock. + WriteIntentError_REASON_LOCK_TIMEOUT WriteIntentError_Reason = 2 + // The request attempted to wait in a lock wait-queue whose length was + // already equal to or exceeding the configured maximum. + WriteIntentError_REASON_LOCK_WAIT_QUEUE_MAX_LENGTH_EXCEEDED WriteIntentError_Reason = 3 +) + +var WriteIntentError_Reason_name = map[int32]string{ + 0: "REASON_UNSPECIFIED", + 1: "REASON_WAIT_POLICY", + 2: "REASON_LOCK_TIMEOUT", + 3: "REASON_LOCK_WAIT_QUEUE_MAX_LENGTH_EXCEEDED", +} + +var WriteIntentError_Reason_value = map[string]int32{ + "REASON_UNSPECIFIED": 0, + "REASON_WAIT_POLICY": 1, + "REASON_LOCK_TIMEOUT": 2, + "REASON_LOCK_WAIT_QUEUE_MAX_LENGTH_EXCEEDED": 3, +} + +func (x WriteIntentError_Reason) Enum() *WriteIntentError_Reason { + p := new(WriteIntentError_Reason) + *p = x + return p +} + +func (x WriteIntentError_Reason) String() string { + return proto.EnumName(WriteIntentError_Reason_name, int32(x)) +} + +func (x *WriteIntentError_Reason) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(WriteIntentError_Reason_value, data, "WriteIntentError_Reason") + if err != nil { + return err + } + *x = WriteIntentError_Reason(value) + return nil +} + +func (WriteIntentError_Reason) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_123941c6716fd549, []int{10, 0} +} + // Reason specifies what caused the error. type RangeFeedRetryError_Reason int32 @@ -813,6 +867,10 @@ type WriteIntentError struct { // operating under. Used on the server to avoid adding discovered locks // which were discovered under old leases to the lock table. LeaseSequence LeaseSequence `protobuf:"varint,3,opt,name=lease_sequence,json=leaseSequence,casttype=LeaseSequence" json:"lease_sequence"` + // The reason for the error. Applies to WriteIntentErrors that are + // returned from the concurrency manager (the second use described + // above). + Reason WriteIntentError_Reason `protobuf:"varint,4,opt,name=reason,enum=cockroach.kv.kvpb.WriteIntentError_Reason" json:"reason"` } func (m *WriteIntentError) Reset() { *m = WriteIntentError{} } @@ -2163,6 +2221,7 @@ func init() { proto.RegisterEnum("cockroach.kv.kvpb.TransactionRetryReason", TransactionRetryReason_name, TransactionRetryReason_value) proto.RegisterEnum("cockroach.kv.kvpb.TransactionRestart", TransactionRestart_name, TransactionRestart_value) proto.RegisterEnum("cockroach.kv.kvpb.TransactionStatusError_Reason", TransactionStatusError_Reason_name, TransactionStatusError_Reason_value) + proto.RegisterEnum("cockroach.kv.kvpb.WriteIntentError_Reason", WriteIntentError_Reason_name, WriteIntentError_Reason_value) proto.RegisterEnum("cockroach.kv.kvpb.RangeFeedRetryError_Reason", RangeFeedRetryError_Reason_name, RangeFeedRetryError_Reason_value) proto.RegisterType((*NotLeaseHolderError)(nil), "cockroach.kv.kvpb.NotLeaseHolderError") proto.RegisterType((*NodeUnavailableError)(nil), "cockroach.kv.kvpb.NodeUnavailableError") @@ -2203,204 +2262,209 @@ func init() { func init() { proto.RegisterFile("roachpb/errors.proto", fileDescriptor_123941c6716fd549) } var fileDescriptor_123941c6716fd549 = []byte{ - // 3140 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x59, 0x4b, 0x6f, 0x1b, 0x57, - 0x96, 0x26, 0x25, 0x4a, 0xa2, 0x8e, 0x1e, 0x2e, 0x5d, 0xbd, 0x4a, 0xb2, 0x4d, 0x29, 0x65, 0x3b, - 0xb1, 0x1d, 0x44, 0x1a, 0x38, 0x13, 0xcc, 0x24, 0xe3, 0x59, 0xf0, 0x51, 0x12, 0x29, 0xf1, 0xa1, - 0x29, 0x52, 0x7e, 0xc4, 0x08, 0x6e, 0x4a, 0xac, 0x2b, 0xaa, 0xc6, 0xc5, 0x2a, 0xe6, 0x56, 0x51, - 0x96, 0x80, 0x59, 0x0c, 0x66, 0x36, 0xc1, 0xcc, 0xa2, 0xbb, 0x57, 0xdd, 0xcb, 0x06, 0x82, 0x5e, - 0x34, 0xd0, 0x68, 0xf4, 0x2f, 0xe8, 0x55, 0x2f, 0xb2, 0x0c, 0x7a, 0x15, 0xf4, 0xc2, 0xe8, 0xb6, - 0xfb, 0x57, 0x64, 0xd5, 0xb8, 0x8f, 0x22, 0x8b, 0x64, 0x51, 0x56, 0xb2, 0x23, 0xcf, 0xeb, 0x9e, - 0xfb, 0xfa, 0xce, 0x77, 0x6e, 0xc1, 0x0a, 0xf5, 0xcc, 0xe6, 0x59, 0xe7, 0x64, 0x97, 0x50, 0xea, - 0x51, 0x7f, 0xa7, 0x43, 0xbd, 0xc0, 0x43, 0x4b, 0x4d, 0xaf, 0xf9, 0x92, 0x6b, 0x76, 0x5e, 0x9e, - 0xef, 0xbc, 0x3c, 0xef, 0x9c, 0x6c, 0xae, 0x0a, 0x83, 0x21, 0xcb, 0x4d, 0x14, 0xfa, 0x5b, 0x66, - 0x60, 0x4a, 0xd9, 0x5a, 0x28, 0x6b, 0x93, 0xc0, 0x8c, 0xc8, 0xd5, 0x6e, 0x60, 0x3b, 0xbb, 0x67, - 0x4e, 0x73, 0x37, 0xb0, 0xdb, 0xc4, 0x0f, 0xcc, 0x76, 0x47, 0x6a, 0x56, 0x5a, 0x5e, 0xcb, 0xe3, - 0x3f, 0x77, 0xd9, 0x2f, 0x21, 0xd5, 0xfe, 0x30, 0x01, 0xcb, 0x55, 0x2f, 0x28, 0x13, 0xd3, 0x27, - 0x45, 0xcf, 0xb1, 0x08, 0xd5, 0xd9, 0xd0, 0xa8, 0x00, 0x33, 0x94, 0x74, 0x1c, 0xbb, 0x69, 0xaa, - 0xc9, 0xed, 0xe4, 0xfd, 0xb9, 0x47, 0x77, 0x77, 0xfa, 0xf9, 0xca, 0xb1, 0x77, 0x0c, 0x61, 0x51, - 0x20, 0x7e, 0x93, 0xda, 0x9d, 0xc0, 0xa3, 0xb9, 0xd4, 0xb7, 0xaf, 0xb7, 0x12, 0x46, 0xe8, 0x8a, - 0xf6, 0x61, 0xde, 0x61, 0x91, 0xf1, 0x19, 0x0f, 0xad, 0x4e, 0x5c, 0x3f, 0x94, 0x31, 0xe7, 0xf4, - 0x73, 0x42, 0x3b, 0x30, 0xc5, 0xff, 0xaa, 0x29, 0x1e, 0x41, 0x8d, 0x89, 0xc0, 0xa7, 0x60, 0x08, - 0x33, 0xf4, 0x09, 0xa4, 0xa9, 0xe9, 0xb6, 0x08, 0xb6, 0x2d, 0x75, 0x72, 0x3b, 0x79, 0x7f, 0x32, - 0xb7, 0xc9, 0x32, 0x7b, 0xf3, 0x7a, 0x6b, 0xc6, 0x60, 0xf2, 0x52, 0xe1, 0x87, 0xfe, 0x4f, 0x63, - 0x86, 0xdb, 0x96, 0x2c, 0x74, 0x07, 0xa0, 0xd9, 0xf5, 0x03, 0xaf, 0x8d, 0xdb, 0x7e, 0x4b, 0x9d, - 0xda, 0x4e, 0xde, 0x9f, 0x95, 0x53, 0x9a, 0x15, 0xf2, 0x8a, 0xdf, 0xd2, 0xd6, 0x60, 0xa5, 0xea, - 0x59, 0xe4, 0xd8, 0x35, 0xcf, 0x4d, 0xdb, 0x31, 0x4f, 0x1c, 0xc2, 0x97, 0x4c, 0xdb, 0x80, 0xf5, - 0x63, 0xd7, 0xef, 0x76, 0x3a, 0x1e, 0x0d, 0x88, 0x65, 0x90, 0xaf, 0xba, 0xc4, 0x0f, 0x84, 0xea, - 0x7f, 0x92, 0x80, 0xf8, 0x60, 0x55, 0x2f, 0xd8, 0xf3, 0xba, 0xae, 0x25, 0x16, 0x39, 0x9a, 0x65, - 0xf2, 0xfa, 0x59, 0x7e, 0x02, 0x69, 0x3f, 0xf0, 0x28, 0x77, 0x9b, 0x18, 0x74, 0xab, 0x33, 0xb9, - 0x70, 0x93, 0x3f, 0x8d, 0x19, 0x6e, 0x5b, 0xb2, 0xb4, 0x5f, 0x4e, 0xc2, 0x2a, 0x8f, 0x75, 0x48, - 0x2e, 0x2b, 0xb6, 0xdf, 0x36, 0x83, 0xe6, 0x99, 0xc8, 0xe3, 0x63, 0x58, 0xa2, 0x22, 0x5d, 0xec, - 0x07, 0x26, 0x0d, 0xf0, 0x4b, 0x72, 0xc9, 0x13, 0x9a, 0xcf, 0xcd, 0xfc, 0xf0, 0x7a, 0x6b, 0xf2, - 0x90, 0x5c, 0x1a, 0x37, 0xa4, 0x45, 0x9d, 0x19, 0x1c, 0x92, 0x4b, 0xb4, 0x0b, 0xa1, 0x08, 0x13, - 0xd7, 0xe2, 0x2e, 0x13, 0x83, 0x2e, 0x0b, 0x52, 0xaf, 0xbb, 0x16, 0x73, 0x38, 0x83, 0x9b, 0x16, - 0xe9, 0x50, 0xd2, 0x34, 0x03, 0x62, 0xe1, 0xb6, 0xcc, 0x80, 0x58, 0x98, 0xcf, 0x8b, 0x6f, 0xd3, - 0xdc, 0x23, 0x2d, 0xee, 0x6c, 0x30, 0xfd, 0xc8, 0x21, 0xdb, 0xe8, 0x07, 0xab, 0xf4, 0x62, 0x71, - 0x53, 0xf4, 0x25, 0x6c, 0x46, 0x46, 0xf2, 0xbb, 0xad, 0x16, 0xf1, 0x83, 0xde, 0x40, 0xa9, 0xeb, - 0x0e, 0x64, 0xa8, 0xfd, 0x28, 0xf5, 0x30, 0x88, 0x18, 0xa1, 0x0c, 0xd3, 0x3c, 0x98, 0xaf, 0x4e, - 0x6d, 0x4f, 0xde, 0x9f, 0x7b, 0x74, 0x6b, 0x5c, 0xb4, 0x92, 0x7b, 0xea, 0xe5, 0xd6, 0xe4, 0xf6, - 0x2c, 0x0a, 0x9f, 0x92, 0x1b, 0x10, 0xea, 0x9a, 0x8e, 0x21, 0x63, 0x68, 0x6f, 0x27, 0x41, 0x33, - 0x88, 0x69, 0x3d, 0xb5, 0x83, 0x33, 0xdb, 0x3d, 0x76, 0x9b, 0x84, 0x06, 0xa6, 0xed, 0x06, 0x97, - 0xdc, 0xf2, 0xdc, 0x74, 0xc4, 0x36, 0x1d, 0xc0, 0x22, 0x25, 0xa6, 0x85, 0x7b, 0x37, 0x5b, 0x5e, - 0xcd, 0xdb, 0x91, 0xc1, 0xd9, 0xf5, 0xdf, 0x39, 0x73, 0x9a, 0x3b, 0x8d, 0xd0, 0x48, 0x2e, 0xd7, - 0x02, 0x73, 0xed, 0x09, 0x91, 0x01, 0x88, 0x5c, 0xd8, 0x7e, 0x60, 0xbb, 0xad, 0x48, 0xbc, 0x89, - 0xeb, 0xc7, 0x5b, 0x0a, 0xdd, 0xfb, 0x31, 0x5f, 0xc0, 0xba, 0xe3, 0x35, 0x4d, 0x07, 0x77, 0xfb, - 0x33, 0xc0, 0x8e, 0xdd, 0xb6, 0x03, 0x7e, 0x95, 0xae, 0x19, 0x78, 0x95, 0xc7, 0x88, 0x2c, 0x42, - 0x99, 0x45, 0x40, 0x5f, 0x80, 0xda, 0x72, 0xbc, 0x93, 0xd8, 0xe8, 0x93, 0xd7, 0x8f, 0xbe, 0x26, - 0x82, 0x8c, 0x84, 0x7f, 0x01, 0xcb, 0xde, 0x89, 0x4f, 0xe8, 0x39, 0x89, 0xac, 0xaf, 0xaf, 0xa6, - 0xf8, 0xee, 0xc6, 0x01, 0x56, 0x4d, 0x5a, 0x0f, 0x0f, 0x80, 0xbc, 0x61, 0x85, 0xff, 0x59, 0xea, - 0x57, 0xbf, 0xde, 0x4a, 0x68, 0x16, 0xac, 0x37, 0xa8, 0xe9, 0xfa, 0x66, 0x33, 0xb0, 0x3d, 0x37, - 0x7b, 0xc2, 0x61, 0x42, 0xec, 0x6c, 0x09, 0xa6, 0x29, 0x31, 0x7d, 0xcf, 0xe5, 0x3b, 0xba, 0xf8, - 0xe8, 0xc3, 0x9d, 0x91, 0xe2, 0xb0, 0x33, 0xea, 0x6b, 0x70, 0x17, 0x39, 0xae, 0x0c, 0xa0, 0xbd, - 0x80, 0x95, 0x88, 0xe5, 0x51, 0xd7, 0x97, 0x77, 0x3c, 0x0f, 0xd0, 0xe9, 0xfa, 0x67, 0x84, 0xe0, - 0xe0, 0xc2, 0x95, 0x07, 0x27, 0x13, 0x33, 0xaf, 0x88, 0x73, 0x08, 0x7d, 0xc2, 0xaf, 0x71, 0xe1, - 0x6a, 0xff, 0x9b, 0x84, 0xd5, 0x88, 0x81, 0x41, 0x02, 0x7a, 0x29, 0xc2, 0xef, 0x0f, 0xcd, 0xe0, - 0xc1, 0xd5, 0x33, 0xe0, 0x9e, 0x71, 0xf9, 0xa3, 0xf7, 0x60, 0x96, 0x5c, 0x04, 0xd4, 0xe4, 0x08, - 0x3c, 0x11, 0x41, 0xe0, 0x34, 0x17, 0x33, 0x00, 0xfe, 0x63, 0x12, 0xd6, 0x22, 0xb1, 0xea, 0x81, - 0x19, 0x74, 0x7d, 0x91, 0xc6, 0x1a, 0x4c, 0x32, 0xbf, 0x64, 0xc4, 0x8f, 0x09, 0x50, 0xb5, 0x97, - 0xde, 0x04, 0x4f, 0xef, 0x9f, 0xae, 0x4e, 0x2f, 0x12, 0x72, 0x27, 0x76, 0x95, 0x1f, 0xc3, 0xb4, - 0x90, 0x23, 0x04, 0x8b, 0x86, 0x9e, 0xad, 0xd7, 0xaa, 0xf8, 0xb8, 0x7a, 0x58, 0xad, 0x3d, 0xad, - 0x2a, 0x09, 0xa4, 0xc2, 0x8a, 0x94, 0x35, 0x9e, 0x55, 0x71, 0xbe, 0x56, 0xa9, 0x94, 0x1a, 0x0d, - 0xbd, 0xa0, 0x4c, 0x68, 0xa9, 0x74, 0x52, 0x49, 0x6a, 0xbf, 0x48, 0x82, 0xf2, 0x94, 0xda, 0x01, - 0x61, 0xf7, 0xdb, 0x15, 0x35, 0x02, 0x7d, 0x0a, 0x33, 0x36, 0xff, 0xeb, 0xab, 0x49, 0x7e, 0xea, - 0x36, 0x62, 0x76, 0x47, 0x38, 0x84, 0x65, 0x56, 0xda, 0xa3, 0xc7, 0xb0, 0x28, 0xca, 0xac, 0xcf, - 0x00, 0xd7, 0x6d, 0x12, 0x59, 0xf3, 0x56, 0x99, 0xd9, 0x0f, 0xaf, 0xb7, 0x16, 0x78, 0x6d, 0xac, - 0x4b, 0xa5, 0xb1, 0xe0, 0x44, 0xff, 0x1e, 0xa4, 0xd2, 0x13, 0xca, 0xa4, 0xf6, 0x9b, 0x30, 0xa7, - 0x86, 0xe7, 0xd5, 0x1c, 0x79, 0x2e, 0xb3, 0x30, 0xfb, 0x93, 0xc0, 0xa6, 0xef, 0x85, 0xaa, 0xa0, - 0x98, 0xcd, 0xa0, 0x6b, 0x3a, 0x3f, 0x0d, 0x66, 0x6e, 0x08, 0xe7, 0x9e, 0x58, 0x5b, 0x01, 0x54, - 0xeb, 0xb0, 0xe2, 0x6a, 0x53, 0xe2, 0x37, 0x2e, 0x5c, 0x51, 0x60, 0xeb, 0xb0, 0x92, 0xf7, 0x5c, - 0xcb, 0x66, 0x9b, 0xb7, 0x67, 0xda, 0x4e, 0x78, 0xb1, 0xfe, 0x0d, 0xe6, 0xe5, 0xe8, 0xe7, 0xa6, - 0xd3, 0x25, 0x72, 0x0e, 0x71, 0xf4, 0xe1, 0x09, 0xd3, 0x1b, 0x73, 0xc2, 0x9a, 0xff, 0xd1, 0x7e, - 0x9f, 0x04, 0x24, 0x58, 0x05, 0xf9, 0x4f, 0xd2, 0xec, 0x5d, 0xd6, 0x0c, 0xcc, 0xb4, 0x89, 0xef, - 0x9b, 0x2d, 0x32, 0x70, 0xce, 0x42, 0x21, 0x7a, 0x0c, 0xb3, 0xb2, 0xf0, 0x11, 0x4b, 0x4e, 0x75, - 0x2c, 0x5f, 0x09, 0xd7, 0xab, 0xe7, 0x80, 0x3e, 0x83, 0x74, 0x88, 0xac, 0x12, 0xd7, 0xde, 0xe5, - 0xdc, 0xb3, 0xd7, 0xbe, 0x82, 0x95, 0x6c, 0xfb, 0xc4, 0x6e, 0x75, 0xbd, 0xae, 0x6f, 0x10, 0xbf, - 0xeb, 0x04, 0xd7, 0xcb, 0xf8, 0x53, 0x98, 0x7b, 0x45, 0xcd, 0x4e, 0x87, 0x58, 0x98, 0x50, 0x1a, - 0x93, 0x73, 0x78, 0x45, 0x78, 0x38, 0x03, 0xa4, 0xb1, 0x4e, 0xa9, 0xb6, 0xce, 0x38, 0xc5, 0x69, - 0xb0, 0x4f, 0xbd, 0x6e, 0xa7, 0x40, 0x1c, 0x12, 0xae, 0x92, 0x86, 0x61, 0x4d, 0x72, 0xba, 0xbc, - 0x47, 0x69, 0xb7, 0xc3, 0x76, 0x46, 0x64, 0xc3, 0x6e, 0x38, 0xfb, 0x81, 0x87, 0x6f, 0x6a, 0x9a, - 0x8b, 0x2b, 0x7e, 0x0b, 0x69, 0x30, 0xdb, 0xa1, 0x5e, 0x93, 0xf8, 0xbe, 0x5c, 0xc2, 0x74, 0x0f, - 0x8b, 0x42, 0xb1, 0x56, 0x07, 0x24, 0x07, 0x88, 0x9e, 0xd8, 0x7f, 0x07, 0x90, 0xe4, 0x33, 0x24, - 0x55, 0x53, 0xb9, 0x8c, 0x2c, 0xbf, 0xb3, 0xd2, 0x9e, 0xf3, 0xa3, 0xfe, 0x1f, 0xb6, 0xfa, 0xe2, - 0xa7, 0xa5, 0x1d, 0x02, 0xe2, 0xbc, 0x69, 0x84, 0xa7, 0xf5, 0x08, 0x57, 0xf2, 0xfa, 0x84, 0xab, - 0xce, 0x08, 0xe1, 0x99, 0xe9, 0x5a, 0x0e, 0xc3, 0xea, 0x80, 0x5e, 0xf6, 0xb8, 0x22, 0x7a, 0x04, - 0xa9, 0x8e, 0x4e, 0x69, 0xcc, 0x79, 0x1c, 0x58, 0x6a, 0x39, 0x6b, 0x6e, 0x2b, 0xab, 0xc8, 0xdf, - 0x93, 0x70, 0x6f, 0x18, 0x48, 0x19, 0x6f, 0x38, 0x62, 0x74, 0xde, 0x20, 0xa7, 0x94, 0x84, 0x88, - 0x3f, 0x0e, 0x0b, 0x5f, 0xc0, 0x74, 0x70, 0xe1, 0x86, 0xe4, 0x71, 0x3e, 0x57, 0x60, 0xaa, 0xbf, - 0xbc, 0xde, 0xfa, 0xb8, 0x65, 0x07, 0x67, 0xdd, 0x93, 0x9d, 0xa6, 0xd7, 0xde, 0xed, 0xe5, 0x63, - 0x9d, 0xf4, 0x7f, 0xef, 0x76, 0x5e, 0xb6, 0x76, 0x79, 0x7f, 0xd1, 0xed, 0xda, 0xd6, 0xce, 0xf1, - 0x71, 0xa9, 0xf0, 0xe6, 0xf5, 0xd6, 0x54, 0xe3, 0xc2, 0x2d, 0x15, 0x8c, 0xa9, 0xe0, 0xc2, 0x2d, - 0x59, 0x68, 0x0f, 0xe6, 0x82, 0x7e, 0x76, 0xf2, 0x04, 0x5f, 0xaf, 0xce, 0x44, 0x1d, 0xb5, 0x3d, - 0xd8, 0x6a, 0x5c, 0xb8, 0x59, 0x87, 0xb1, 0x96, 0x4b, 0xdd, 0x6d, 0x7a, 0x5d, 0x46, 0x85, 0xe4, - 0xe1, 0x12, 0xf3, 0xbb, 0x03, 0xd0, 0xa1, 0xe4, 0x1c, 0xf3, 0x53, 0x33, 0x30, 0xcd, 0x59, 0x26, - 0x17, 0xc7, 0xf0, 0xff, 0x93, 0xb0, 0xc2, 0x40, 0xb3, 0x45, 0x68, 0xed, 0x9c, 0xd0, 0x53, 0xc7, - 0x7b, 0x25, 0xbc, 0x37, 0x60, 0x32, 0x86, 0xe5, 0x32, 0x19, 0x7a, 0x00, 0x0b, 0xcd, 0x2e, 0xa5, - 0xc4, 0x0d, 0x24, 0x6a, 0x08, 0x92, 0x2d, 0x62, 0xcf, 0x4b, 0x15, 0x87, 0x08, 0xf4, 0x11, 0xdc, - 0xb0, 0xdd, 0x26, 0x25, 0xed, 0xbe, 0xf1, 0x64, 0xc4, 0x78, 0xb1, 0xa7, 0x14, 0x88, 0xf2, 0x4d, - 0x12, 0x6e, 0xe6, 0x18, 0x53, 0xed, 0xc3, 0x1c, 0x39, 0xf5, 0x28, 0xd9, 0xcf, 0xf7, 0xf0, 0xb6, - 0xf1, 0x93, 0xf0, 0xb6, 0x4f, 0xc2, 0x58, 0x88, 0x33, 0x76, 0x08, 0x3c, 0xc7, 0xfa, 0x31, 0x40, - 0xdb, 0xf7, 0xd2, 0xda, 0x80, 0x44, 0x9d, 0xa9, 0xd8, 0xbe, 0x6f, 0xbb, 0x2d, 0x91, 0xdb, 0x63, - 0x98, 0x7f, 0x45, 0x3d, 0xb7, 0x85, 0x45, 0xd5, 0x91, 0xe9, 0x8d, 0x2f, 0x52, 0xc6, 0x1c, 0x37, - 0x17, 0x7f, 0xc2, 0xe5, 0x9e, 0x18, 0x5d, 0x6e, 0xd6, 0x4f, 0x55, 0x08, 0x65, 0x54, 0xf9, 0x88, - 0x7a, 0x2d, 0x4a, 0x7c, 0x51, 0x78, 0xb5, 0xdf, 0x4e, 0xc0, 0x32, 0xe7, 0xd0, 0x7b, 0x44, 0xde, - 0x1f, 0x91, 0xc8, 0xe1, 0x10, 0xd5, 0xf8, 0x28, 0xe6, 0xf6, 0xc4, 0xf8, 0xc5, 0x17, 0xf2, 0x3f, - 0x25, 0x7b, 0x95, 0x7c, 0x13, 0xd6, 0x64, 0xd5, 0x36, 0xf4, 0xa3, 0x72, 0x29, 0x9f, 0xc5, 0x86, - 0x5e, 0xa9, 0x3d, 0xd1, 0x0b, 0x4a, 0x02, 0xad, 0x01, 0x0a, 0x75, 0xd9, 0xea, 0xbe, 0x8e, 0xeb, - 0x47, 0xe5, 0x52, 0x43, 0x49, 0xa2, 0x75, 0x58, 0x1e, 0x90, 0x57, 0x74, 0x63, 0x9f, 0x15, 0xfa, - 0x08, 0x05, 0x30, 0xb2, 0x7b, 0x0d, 0x5c, 0xaf, 0x66, 0x8f, 0xea, 0xc5, 0x5a, 0x43, 0x99, 0x44, - 0x19, 0xd8, 0x94, 0x9a, 0x72, 0x6d, 0xbf, 0x94, 0xcf, 0x96, 0x71, 0xed, 0xa8, 0x8e, 0x2b, 0xa5, - 0x7a, 0xbd, 0x54, 0xdd, 0x57, 0x52, 0x11, 0xcf, 0x7a, 0xb9, 0xf6, 0x14, 0xe7, 0x6b, 0xd5, 0xfa, - 0x71, 0x45, 0x37, 0x94, 0x29, 0xb4, 0x01, 0xab, 0x52, 0x53, 0xad, 0xe1, 0xb2, 0x9e, 0xad, 0xeb, - 0xc5, 0x5a, 0xb9, 0xa0, 0x1b, 0xca, 0xb4, 0x66, 0x82, 0x5a, 0x72, 0x2d, 0x12, 0x10, 0xda, 0xb6, - 0x5d, 0x33, 0x20, 0x79, 0xaf, 0xdd, 0xb6, 0x25, 0xfa, 0xeb, 0x30, 0xe7, 0x07, 0x66, 0x8b, 0x33, - 0xfd, 0x1f, 0x49, 0xfd, 0x40, 0x3a, 0x32, 0xee, 0xb7, 0x0c, 0x4b, 0x25, 0xf7, 0xdc, 0x74, 0x6c, - 0x8b, 0x17, 0x1f, 0xb1, 0x47, 0x19, 0xb8, 0x55, 0xeb, 0x04, 0x76, 0x9b, 0x15, 0xa0, 0xa6, 0x7e, - 0x6e, 0x3a, 0x79, 0xcf, 0x3d, 0x75, 0xec, 0x66, 0x20, 0xf7, 0xf0, 0x67, 0x6b, 0x30, 0xc7, 0x7f, - 0x15, 0x48, 0x60, 0xda, 0x0e, 0x32, 0x40, 0x71, 0xbd, 0x00, 0x0f, 0x3c, 0x0a, 0x88, 0x84, 0xde, - 0x8f, 0xd9, 0xc5, 0x98, 0x87, 0x89, 0x62, 0xc2, 0x58, 0x74, 0x07, 0xc4, 0xa8, 0x06, 0x37, 0x44, - 0x17, 0xcd, 0x22, 0x9f, 0x32, 0xd4, 0x96, 0xe7, 0xfe, 0xde, 0xb8, 0x83, 0x31, 0x80, 0xee, 0x45, - 0xd6, 0x1b, 0x45, 0xa5, 0xe8, 0x19, 0x20, 0x11, 0xf0, 0x25, 0xb9, 0xec, 0xf5, 0xa9, 0x12, 0xca, - 0xee, 0x8f, 0x8b, 0x39, 0xdc, 0x54, 0x17, 0x13, 0x86, 0x42, 0x87, 0x14, 0xe8, 0xbf, 0x93, 0xb0, - 0xcd, 0x5b, 0xb8, 0x57, 0xbc, 0xd3, 0x1b, 0x68, 0x65, 0x6c, 0xd9, 0xeb, 0xc9, 0xfe, 0xf4, 0x93, - 0xb8, 0x81, 0xde, 0xd9, 0x23, 0x16, 0x13, 0xc6, 0x6d, 0x7a, 0x95, 0x15, 0xfa, 0x02, 0x96, 0x23, - 0x38, 0x8b, 0x4d, 0xd1, 0x4a, 0xc8, 0x06, 0xed, 0xe1, 0xb5, 0xfa, 0x8e, 0x70, 0x24, 0x14, 0x8c, - 0xa8, 0x50, 0x03, 0x94, 0x68, 0x78, 0xd6, 0x3a, 0xa8, 0xd3, 0x3c, 0xf6, 0x07, 0x57, 0xc7, 0xee, - 0x75, 0x2a, 0xc5, 0x84, 0x71, 0x23, 0x18, 0x94, 0xa3, 0xa7, 0xb0, 0x14, 0x8d, 0x4a, 0xd9, 0xa5, - 0x56, 0x67, 0xc6, 0x6e, 0x48, 0x6c, 0x8b, 0xc2, 0x36, 0x24, 0x18, 0x52, 0xa0, 0xcf, 0x21, 0x3a, - 0x09, 0xec, 0x73, 0xde, 0xaf, 0xa6, 0x79, 0xe4, 0x07, 0xd7, 0xee, 0x11, 0x8a, 0x09, 0x23, 0x9a, - 0x9f, 0xd0, 0xa0, 0x22, 0x03, 0x4c, 0x3b, 0x20, 0x21, 0x60, 0xce, 0xf2, 0xa8, 0x77, 0x62, 0xa2, - 0x0e, 0xf7, 0x02, 0xc5, 0x04, 0x03, 0xcf, 0x9e, 0x0c, 0x95, 0x60, 0x41, 0x44, 0x0a, 0x3c, 0x0f, - 0x33, 0x5c, 0x87, 0xab, 0x43, 0x45, 0x08, 0x51, 0x2f, 0x94, 0x90, 0xb1, 0xcb, 0xe2, 0x75, 0x30, - 0x95, 0xfc, 0x99, 0x03, 0xc2, 0xdc, 0xd8, 0xcb, 0x32, 0x4a, 0xb4, 0xd9, 0x65, 0xf1, 0xa2, 0x52, - 0xb6, 0xe1, 0xcd, 0x90, 0x79, 0xe3, 0x53, 0x4e, 0xbd, 0xd5, 0xf9, 0xb1, 0x1b, 0x1e, 0x47, 0xd2, - 0xd9, 0x86, 0x37, 0x07, 0xe5, 0xa8, 0x1a, 0x76, 0x34, 0x54, 0x52, 0x6f, 0x75, 0x61, 0x6c, 0x96, - 0xa3, 0x14, 0x9d, 0x65, 0xe9, 0x44, 0xa5, 0x2c, 0x4b, 0xd7, 0xb3, 0x08, 0xee, 0xf6, 0x1f, 0xed, - 0xd4, 0xc5, 0xb1, 0x59, 0xc6, 0x3d, 0xef, 0xb1, 0x2c, 0xdd, 0x41, 0xb9, 0x00, 0x8a, 0xd3, 0x00, - 0xb7, 0x18, 0xfb, 0xc5, 0x96, 0xa0, 0xbf, 0xaa, 0x72, 0x05, 0x50, 0xc4, 0x30, 0x65, 0x01, 0x14, - 0x83, 0x0a, 0x76, 0x2e, 0x43, 0x1a, 0xdb, 0xec, 0xd1, 0x67, 0x75, 0x69, 0xec, 0xb9, 0x8c, 0xa7, - 0xda, 0xec, 0x5c, 0xd2, 0x61, 0x0d, 0xc7, 0x4b, 0x19, 0x3b, 0x3c, 0x4f, 0x68, 0x3c, 0x5e, 0x8e, - 0x50, 0x6c, 0x8e, 0x97, 0x51, 0x29, 0x5b, 0x5c, 0x33, 0x6c, 0x3b, 0x30, 0xe5, 0x7d, 0x87, 0xba, - 0x39, 0x76, 0x71, 0xe3, 0x3a, 0x14, 0xb6, 0xb8, 0xe6, 0xa0, 0x9c, 0xa5, 0x29, 0x48, 0x77, 0x1f, - 0xd6, 0x6f, 0x8e, 0x4d, 0x73, 0x94, 0xb4, 0xb3, 0x34, 0xfd, 0xa8, 0x14, 0xfd, 0x5f, 0x12, 0xee, - 0x8e, 0xa0, 0x08, 0x47, 0x62, 0xcc, 0xdf, 0xc2, 0x31, 0x15, 0xec, 0x59, 0xbd, 0xc5, 0x87, 0xf9, - 0xd7, 0x6b, 0x00, 0x4b, 0x2c, 0xf1, 0x2e, 0x26, 0x8c, 0xed, 0xe0, 0x1d, 0x86, 0x6c, 0xcd, 0x6c, - 0x41, 0x4b, 0xb1, 0x27, 0x79, 0xa9, 0xba, 0x35, 0x76, 0xcd, 0xe2, 0x18, 0x2c, 0x5b, 0x33, 0x7b, - 0x50, 0xce, 0xc0, 0xbd, 0xdb, 0x7f, 0x82, 0xc6, 0xb2, 0xab, 0x54, 0xb7, 0xc7, 0x82, 0xfb, 0x98, - 0x07, 0x6b, 0x06, 0xee, 0xdd, 0x11, 0x15, 0x7a, 0x01, 0x4a, 0xaf, 0x89, 0xc7, 0x27, 0x9c, 0xb9, - 0xaa, 0x1a, 0x8f, 0xbd, 0x13, 0x13, 0xfb, 0x0a, 0xa2, 0xcb, 0x31, 0x7e, 0x50, 0x83, 0x5e, 0xc1, - 0x6d, 0xd6, 0x96, 0x98, 0x82, 0xf2, 0x63, 0xd2, 0xe7, 0xfc, 0x92, 0xe1, 0xdf, 0xe1, 0x23, 0x3d, - 0x8a, 0xdb, 0x96, 0xab, 0x3b, 0x85, 0x62, 0xc2, 0xd8, 0x0c, 0xc6, 0x9a, 0x30, 0xac, 0x11, 0x08, - 0xcd, 0x6a, 0x3d, 0xe3, 0xbb, 0xea, 0xdd, 0xb1, 0xe7, 0x6c, 0x94, 0x17, 0xb3, 0x73, 0x66, 0x47, - 0xa5, 0xe8, 0x18, 0x96, 0xda, 0x8c, 0xcf, 0x62, 0xdb, 0x65, 0x07, 0x8b, 0x33, 0x5a, 0xf5, 0xde, - 0xd8, 0xbd, 0x8d, 0xe3, 0xbe, 0x6c, 0x7d, 0xda, 0x83, 0x72, 0xf4, 0x1f, 0x92, 0xe6, 0x9c, 0x12, - 0xbe, 0xb3, 0xac, 0x02, 0xbe, 0x3f, 0x96, 0x39, 0xc5, 0xf0, 0x5f, 0xc6, 0x9c, 0x7a, 0x01, 0x44, - 0xf5, 0xfb, 0x12, 0x56, 0xec, 0x28, 0x6b, 0xc4, 0x4d, 0x4e, 0x1b, 0xd5, 0x0f, 0x78, 0xdc, 0x0f, - 0x63, 0xe7, 0x1f, 0x4f, 0x32, 0x8b, 0x09, 0x63, 0xd9, 0x1e, 0xd5, 0xa1, 0x27, 0xb0, 0x6c, 0x0b, - 0xd2, 0x28, 0x39, 0x9f, 0xd8, 0xca, 0xfb, 0x23, 0xdf, 0x81, 0xfa, 0x03, 0x0c, 0x51, 0x4c, 0x86, - 0x61, 0xf6, 0xb0, 0x10, 0xb5, 0x61, 0xc3, 0xeb, 0xf1, 0x4e, 0x4c, 0xce, 0x4d, 0x07, 0x37, 0x43, - 0xe6, 0xa9, 0x3e, 0xe0, 0xd1, 0x77, 0x63, 0x0b, 0xda, 0x78, 0xae, 0x5a, 0x4c, 0x18, 0xeb, 0x5e, - 0xbc, 0x3e, 0x37, 0x03, 0x53, 0xbc, 0xb9, 0x3b, 0x48, 0xa5, 0x6f, 0x28, 0xca, 0x41, 0x2a, 0xbd, - 0xac, 0xac, 0x1c, 0xa4, 0xd2, 0x2b, 0xca, 0xea, 0x41, 0x2a, 0xbd, 0xaa, 0xac, 0x1d, 0xa4, 0xd2, - 0x6b, 0xca, 0xfa, 0x41, 0x2a, 0xbd, 0xae, 0xa8, 0x07, 0xa9, 0xb4, 0xaa, 0x6c, 0x1c, 0xa4, 0xd2, - 0x1b, 0xca, 0xe6, 0x41, 0x2a, 0x7d, 0x5b, 0xc9, 0x1c, 0xa4, 0xd2, 0x19, 0x65, 0xeb, 0x20, 0x95, - 0x7e, 0x4f, 0xd1, 0xb4, 0x07, 0x9c, 0x10, 0x1f, 0x79, 0x3e, 0x2f, 0x77, 0x68, 0x13, 0xa6, 0xd8, - 0xba, 0x5d, 0xc8, 0xa7, 0x0a, 0x41, 0xbb, 0x85, 0x48, 0xfb, 0x7a, 0x0a, 0xa6, 0xc2, 0x0f, 0x34, - 0x43, 0x0f, 0x38, 0x1b, 0xf2, 0xfd, 0x61, 0x29, 0xf2, 0x11, 0x44, 0x18, 0xf4, 0x5f, 0x75, 0xfe, - 0x6b, 0x90, 0xe9, 0x51, 0xc2, 0xbf, 0xed, 0x70, 0x1e, 0xbb, 0x18, 0x7b, 0xb8, 0x07, 0xd0, 0x8d, - 0x1b, 0xe7, 0xee, 0xca, 0x71, 0x6e, 0xf5, 0xc7, 0x19, 0xb5, 0x1a, 0x20, 0x82, 0x52, 0x86, 0xf2, - 0xb0, 0xd0, 0x75, 0xc9, 0x45, 0xc7, 0xf3, 0x89, 0xc5, 0x69, 0x46, 0xea, 0x3a, 0x7d, 0x87, 0x31, - 0xdf, 0x73, 0x62, 0xe4, 0x62, 0x17, 0xe6, 0x3c, 0x6a, 0xb7, 0x6c, 0x17, 0xb3, 0xd2, 0xcb, 0x49, - 0xea, 0x54, 0x6e, 0x51, 0xbe, 0x6a, 0x4e, 0xb3, 0x32, 0x5d, 0x2a, 0x18, 0x20, 0x4c, 0xd8, 0x3f, - 0x74, 0x04, 0xd3, 0x16, 0xef, 0x34, 0x24, 0xe9, 0xcc, 0x8c, 0x7b, 0x59, 0x11, 0xfd, 0x48, 0x4e, - 0x95, 0xf3, 0x53, 0xfa, 0xf3, 0x13, 0x1a, 0x43, 0xc6, 0x41, 0x87, 0xb0, 0xc0, 0xa0, 0xc8, 0xea, - 0xc1, 0x90, 0xa0, 0x71, 0xdb, 0x91, 0xc0, 0xe1, 0x57, 0xdb, 0x1d, 0x5d, 0x18, 0x46, 0x9f, 0x6e, - 0xe6, 0x49, 0x44, 0x86, 0xfe, 0x39, 0xdc, 0xed, 0x99, 0xab, 0xb2, 0x0b, 0x0f, 0x87, 0x3c, 0x07, - 0xa8, 0x0b, 0x93, 0xae, 0xf7, 0x4a, 0xb2, 0xd2, 0x77, 0x34, 0xf3, 0x05, 0xb9, 0x38, 0x8f, 0xaf, - 0xff, 0x98, 0xc3, 0x02, 0xe4, 0x1d, 0xaf, 0xf9, 0xb2, 0x17, 0xc5, 0x60, 0xe3, 0x89, 0xf7, 0x26, - 0xf1, 0x3a, 0xfc, 0xf0, 0xcf, 0x13, 0xa0, 0x8e, 0xfb, 0x00, 0xc1, 0x3a, 0xd6, 0x6c, 0xae, 0x66, - 0x34, 0xf0, 0xc8, 0x43, 0xf8, 0x3d, 0x78, 0x6f, 0x40, 0xc3, 0xff, 0xe8, 0x05, 0x6c, 0xe8, 0xf9, - 0x9a, 0x51, 0xc0, 0x7b, 0xb5, 0xe3, 0x6a, 0x41, 0x49, 0xb2, 0x96, 0x78, 0xc0, 0x2c, 0x5f, 0x2e, - 0xe9, 0x55, 0xf6, 0xef, 0x40, 0xcf, 0xb3, 0x96, 0x79, 0x0b, 0x6e, 0x0e, 0xe8, 0x8f, 0x8e, 0xeb, - 0x45, 0xdd, 0x08, 0xa3, 0x29, 0x29, 0x74, 0x13, 0xd6, 0x47, 0xc7, 0xc1, 0xf5, 0xa3, 0x6c, 0x55, - 0x99, 0x42, 0xff, 0x02, 0x1f, 0x0f, 0x28, 0xe5, 0xe0, 0xd9, 0xb2, 0xa1, 0x67, 0x0b, 0xcf, 0xf1, - 0x53, 0xa3, 0xd4, 0x68, 0xe8, 0x55, 0x7c, 0x54, 0xab, 0xd7, 0x4b, 0xb9, 0xb2, 0xce, 0xbb, 0xff, - 0xec, 0x73, 0x65, 0x1a, 0x7d, 0x00, 0x77, 0x06, 0x1c, 0xab, 0xfa, 0x53, 0xd1, 0x76, 0xe3, 0x23, - 0x43, 0x7f, 0xa2, 0x57, 0x1b, 0x75, 0xdc, 0x78, 0x56, 0x55, 0xd2, 0xe8, 0x01, 0xdc, 0x1b, 0x30, - 0x6c, 0x94, 0x2a, 0x7a, 0xbd, 0x91, 0xad, 0x1c, 0xe1, 0x7c, 0x36, 0x5f, 0xd4, 0xe5, 0x44, 0xf4, - 0x82, 0x32, 0xb3, 0x99, 0xfa, 0xfa, 0x9b, 0x4c, 0x42, 0x63, 0x8b, 0x3a, 0xf1, 0xf0, 0x77, 0x83, - 0xdf, 0x31, 0x22, 0xdf, 0x44, 0xc4, 0x23, 0x40, 0xc3, 0x78, 0x3e, 0xba, 0xa4, 0xfc, 0xc5, 0x81, - 0x69, 0x58, 0xde, 0x3a, 0x6e, 0xd4, 0x6a, 0xb8, 0x56, 0x66, 0x8b, 0xc8, 0x9f, 0x28, 0x98, 0xa2, - 0xae, 0x1b, 0xa5, 0x6c, 0xb9, 0xf4, 0x79, 0x36, 0x57, 0xd6, 0x95, 0x49, 0x74, 0x1b, 0x36, 0x84, - 0x3c, 0x5b, 0x7f, 0x5e, 0xcd, 0x4b, 0xb7, 0xbd, 0x6c, 0xa9, 0x7c, 0x6c, 0xe8, 0xca, 0x14, 0xd2, - 0x20, 0x23, 0xd4, 0xe2, 0x33, 0x05, 0x2e, 0xe8, 0xd9, 0x42, 0xb9, 0x54, 0xd5, 0xb1, 0xfe, 0x2c, - 0xaf, 0xeb, 0x05, 0xbd, 0xa0, 0x4c, 0x8b, 0xa4, 0x1f, 0x7e, 0x06, 0x68, 0xf4, 0xee, 0xa3, 0x34, - 0xa4, 0xaa, 0xb5, 0xaa, 0xae, 0x24, 0xd0, 0x1c, 0xcc, 0xe4, 0xb2, 0xf9, 0xc3, 0xda, 0xde, 0x9e, - 0x92, 0x44, 0x0b, 0x30, 0x5b, 0xaa, 0x54, 0xf4, 0x42, 0x29, 0xdb, 0xd0, 0x95, 0x89, 0xdc, 0x83, - 0x6f, 0xff, 0x96, 0x49, 0x7c, 0xfb, 0x26, 0x93, 0xfc, 0xee, 0x4d, 0x26, 0xf9, 0xfd, 0x9b, 0x4c, - 0xf2, 0xaf, 0x6f, 0x32, 0xc9, 0x9f, 0xbf, 0xcd, 0x24, 0xbe, 0x7b, 0x9b, 0x49, 0x7c, 0xff, 0x36, - 0x93, 0xf8, 0x7c, 0x46, 0xa2, 0xc1, 0x3f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x52, 0x4f, 0x43, 0x0b, - 0x2e, 0x21, 0x00, 0x00, + // 3222 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x59, 0xcd, 0x73, 0xdb, 0xd6, + 0xb5, 0x27, 0x29, 0x4a, 0xa2, 0x8e, 0x3e, 0x0c, 0x5d, 0x7d, 0x41, 0xb2, 0x4d, 0x29, 0xb4, 0x9d, + 0xd8, 0xce, 0x84, 0x7a, 0xe3, 0xbc, 0xcc, 0x7b, 0xc9, 0xf3, 0x5b, 0xf0, 0x03, 0x12, 0x21, 0xf1, + 0x2b, 0x20, 0x65, 0xd9, 0xf1, 0x64, 0x6e, 0x20, 0xe2, 0x8a, 0xc2, 0x33, 0x08, 0x30, 0x00, 0x28, + 0x4b, 0x33, 0x6f, 0xf1, 0x5e, 0xbb, 0xc9, 0xb4, 0x8b, 0x76, 0xd7, 0x2e, 0x3b, 0x93, 0xe9, 0xa2, + 0x33, 0x9d, 0x4e, 0xff, 0x82, 0xae, 0xba, 0xc8, 0x32, 0xd3, 0x55, 0xa6, 0x0b, 0xb7, 0xb5, 0xfb, + 0x57, 0x64, 0xd5, 0xb9, 0x1f, 0x20, 0x41, 0x12, 0x94, 0x95, 0xec, 0x80, 0x73, 0xcf, 0x39, 0xf7, + 0xdc, 0x73, 0x2f, 0x7e, 0xe7, 0x77, 0x2e, 0x60, 0xd5, 0x75, 0xf4, 0xd6, 0x59, 0xf7, 0x64, 0x97, + 0xb8, 0xae, 0xe3, 0x7a, 0xd9, 0xae, 0xeb, 0xf8, 0x0e, 0x5a, 0x6e, 0x39, 0xad, 0x17, 0x6c, 0x24, + 0xfb, 0xe2, 0x3c, 0xfb, 0xe2, 0xbc, 0x7b, 0xb2, 0xb5, 0xc6, 0x15, 0x46, 0x34, 0xb7, 0x50, 0x60, + 0x6f, 0xe8, 0xbe, 0x2e, 0x64, 0xeb, 0x81, 0xac, 0x43, 0x7c, 0x3d, 0x24, 0x97, 0x7b, 0xbe, 0x69, + 0xed, 0x9e, 0x59, 0xad, 0x5d, 0xdf, 0xec, 0x10, 0xcf, 0xd7, 0x3b, 0x5d, 0x31, 0xb2, 0xda, 0x76, + 0xda, 0x0e, 0x7b, 0xdc, 0xa5, 0x4f, 0x5c, 0x9a, 0xf9, 0x63, 0x02, 0x56, 0xaa, 0x8e, 0x5f, 0x26, + 0xba, 0x47, 0x4a, 0x8e, 0x65, 0x10, 0x57, 0xa1, 0x53, 0xa3, 0x22, 0xcc, 0xba, 0xa4, 0x6b, 0x99, + 0x2d, 0x5d, 0x8e, 0xef, 0xc4, 0xef, 0xcf, 0x3f, 0xba, 0x9b, 0x1d, 0xc4, 0x2b, 0xe6, 0xce, 0x6a, + 0x5c, 0xa3, 0x48, 0xbc, 0x96, 0x6b, 0x76, 0x7d, 0xc7, 0xcd, 0x27, 0xbf, 0x79, 0xb5, 0x1d, 0xd3, + 0x02, 0x53, 0xb4, 0x0f, 0x0b, 0x16, 0xf5, 0x8c, 0xcf, 0x98, 0x6b, 0x39, 0x71, 0x7d, 0x57, 0xda, + 0xbc, 0x35, 0x88, 0x09, 0x65, 0x61, 0x9a, 0xbd, 0xca, 0x49, 0xe6, 0x41, 0x8e, 0xf0, 0xc0, 0x96, + 0xa0, 0x71, 0x35, 0xf4, 0x11, 0xa4, 0x5c, 0xdd, 0x6e, 0x13, 0x6c, 0x1a, 0xf2, 0xd4, 0x4e, 0xfc, + 0xfe, 0x54, 0x7e, 0x8b, 0x46, 0xf6, 0xfa, 0xd5, 0xf6, 0xac, 0x46, 0xe5, 0x6a, 0xf1, 0xfb, 0xc1, + 0xa3, 0x36, 0xcb, 0x74, 0x55, 0x03, 0xdd, 0x01, 0x68, 0xf5, 0x3c, 0xdf, 0xe9, 0xe0, 0x8e, 0xd7, + 0x96, 0xa7, 0x77, 0xe2, 0xf7, 0xe7, 0xc4, 0x92, 0xe6, 0xb8, 0xbc, 0xe2, 0xb5, 0x33, 0xeb, 0xb0, + 0x5a, 0x75, 0x0c, 0x72, 0x64, 0xeb, 0xe7, 0xba, 0x69, 0xe9, 0x27, 0x16, 0x61, 0x29, 0xcb, 0x6c, + 0xc2, 0xc6, 0x91, 0xed, 0xf5, 0xba, 0x5d, 0xc7, 0xf5, 0x89, 0xa1, 0x91, 0x2f, 0x7b, 0xc4, 0xf3, + 0xf9, 0xd0, 0x4f, 0xe2, 0x80, 0xd8, 0x64, 0x55, 0xc7, 0xdf, 0x73, 0x7a, 0xb6, 0xc1, 0x93, 0x1c, + 0x8e, 0x32, 0x7e, 0xfd, 0x28, 0x3f, 0x82, 0x94, 0xe7, 0x3b, 0x2e, 0x33, 0x4b, 0x0c, 0x9b, 0x35, + 0xa8, 0x9c, 0x9b, 0x89, 0x47, 0x6d, 0x96, 0xe9, 0xaa, 0x46, 0xe6, 0x57, 0x53, 0xb0, 0xc6, 0x7c, + 0x1d, 0x92, 0xcb, 0x8a, 0xe9, 0x75, 0x74, 0xbf, 0x75, 0xc6, 0xe3, 0xf8, 0x10, 0x96, 0x5d, 0x1e, + 0x2e, 0xf6, 0x7c, 0xdd, 0xf5, 0xf1, 0x0b, 0x72, 0xc9, 0x02, 0x5a, 0xc8, 0xcf, 0x7e, 0xff, 0x6a, + 0x7b, 0xea, 0x90, 0x5c, 0x6a, 0x37, 0x84, 0x46, 0x83, 0x2a, 0x1c, 0x92, 0x4b, 0xb4, 0x0b, 0x81, + 0x08, 0x13, 0xdb, 0x60, 0x26, 0x89, 0x61, 0x93, 0x45, 0x31, 0xae, 0xd8, 0x06, 0x35, 0x38, 0x83, + 0x9b, 0x06, 0xe9, 0xba, 0xa4, 0xa5, 0xfb, 0xc4, 0xc0, 0x1d, 0x11, 0x01, 0x31, 0x30, 0x5b, 0x17, + 0xdb, 0xa6, 0xf9, 0x47, 0x99, 0xa8, 0xb3, 0x41, 0xc7, 0xc7, 0x0e, 0xd9, 0xe6, 0xc0, 0x59, 0xa5, + 0xef, 0x8b, 0xa9, 0xa2, 0x2f, 0x60, 0x2b, 0x34, 0x93, 0xd7, 0x6b, 0xb7, 0x89, 0xe7, 0xf7, 0x27, + 0x4a, 0x5e, 0x77, 0x22, 0x4d, 0x1e, 0x78, 0x69, 0x04, 0x4e, 0xf8, 0x0c, 0x65, 0x98, 0x61, 0xce, + 0x3c, 0x79, 0x7a, 0x67, 0xea, 0xfe, 0xfc, 0xa3, 0x5b, 0x93, 0xbc, 0xa9, 0xf6, 0xa9, 0x93, 0x5f, + 0x17, 0xdb, 0xb3, 0xc4, 0x6d, 0x54, 0xdb, 0x27, 0xae, 0xad, 0x5b, 0x9a, 0xf0, 0x91, 0x79, 0x33, + 0x05, 0x19, 0x8d, 0xe8, 0xc6, 0xb1, 0xe9, 0x9f, 0x99, 0xf6, 0x91, 0xdd, 0x22, 0xae, 0xaf, 0x9b, + 0xb6, 0x7f, 0xc9, 0x34, 0xcf, 0x75, 0x8b, 0x6f, 0xd3, 0x01, 0x2c, 0xb9, 0x44, 0x37, 0x70, 0xff, + 0xcb, 0x16, 0x9f, 0xe6, 0xed, 0xd0, 0xe4, 0xf4, 0xf3, 0xcf, 0x9e, 0x59, 0xad, 0x6c, 0x33, 0x50, + 0x12, 0xe9, 0x5a, 0xa4, 0xa6, 0x7d, 0x21, 0xd2, 0x00, 0x91, 0x0b, 0xd3, 0xf3, 0x4d, 0xbb, 0x1d, + 0xf2, 0x97, 0xb8, 0xbe, 0xbf, 0xe5, 0xc0, 0x7c, 0xe0, 0xf3, 0x39, 0x6c, 0x58, 0x4e, 0x4b, 0xb7, + 0x70, 0x6f, 0xb0, 0x02, 0x6c, 0x99, 0x1d, 0xd3, 0x67, 0x9f, 0xd2, 0x35, 0x1d, 0xaf, 0x31, 0x1f, + 0xa1, 0x24, 0x94, 0xa9, 0x07, 0xf4, 0x39, 0xc8, 0x6d, 0xcb, 0x39, 0x89, 0xf4, 0x3e, 0x75, 0x7d, + 0xef, 0xeb, 0xdc, 0xc9, 0x98, 0xfb, 0xe7, 0xb0, 0xe2, 0x9c, 0x78, 0xc4, 0x3d, 0x27, 0xa1, 0xfc, + 0x7a, 0x72, 0x92, 0xed, 0x6e, 0x14, 0x60, 0xd5, 0x84, 0xf6, 0xe8, 0x04, 0xc8, 0x19, 0x1d, 0xf0, + 0x3e, 0x49, 0xfe, 0xfa, 0x37, 0xdb, 0xb1, 0x8c, 0x01, 0x1b, 0x4d, 0x57, 0xb7, 0x3d, 0xbd, 0xe5, + 0x9b, 0x8e, 0x9d, 0x3b, 0x61, 0x30, 0xc1, 0x77, 0x56, 0x85, 0x19, 0x97, 0xe8, 0x9e, 0x63, 0xb3, + 0x1d, 0x5d, 0x7a, 0xf4, 0x7e, 0x76, 0xac, 0x38, 0x64, 0xc7, 0x6d, 0x35, 0x66, 0x22, 0xe6, 0x15, + 0x0e, 0x32, 0xcf, 0x61, 0x35, 0xa4, 0x59, 0xef, 0x79, 0xe2, 0x1b, 0x2f, 0x00, 0x74, 0x7b, 0xde, + 0x19, 0x21, 0xd8, 0xbf, 0xb0, 0xc5, 0xc1, 0x49, 0x47, 0xac, 0x2b, 0x64, 0x1c, 0x40, 0x1f, 0xb7, + 0x6b, 0x5e, 0xd8, 0x99, 0x9f, 0xc6, 0x61, 0x2d, 0xa4, 0xa0, 0x11, 0xdf, 0xbd, 0xe4, 0xee, 0xf7, + 0x47, 0x56, 0xf0, 0xe0, 0xea, 0x15, 0x30, 0xcb, 0xa8, 0xf8, 0xd1, 0x3b, 0x30, 0x47, 0x2e, 0x7c, + 0x57, 0x67, 0x08, 0x9c, 0x08, 0x21, 0x70, 0x8a, 0x89, 0x29, 0x00, 0xff, 0x29, 0x0e, 0xeb, 0x21, + 0x5f, 0x0d, 0x5f, 0xf7, 0x7b, 0x1e, 0x0f, 0x63, 0x1d, 0xa6, 0xa8, 0x5d, 0x3c, 0x64, 0x47, 0x05, + 0xa8, 0xda, 0x0f, 0x2f, 0xc1, 0xc2, 0xfb, 0xb7, 0xab, 0xc3, 0x0b, 0xb9, 0xcc, 0x46, 0x66, 0xf9, + 0x31, 0xcc, 0x70, 0x39, 0x42, 0xb0, 0xa4, 0x29, 0xb9, 0x46, 0xad, 0x8a, 0x8f, 0xaa, 0x87, 0xd5, + 0xda, 0x71, 0x55, 0x8a, 0x21, 0x19, 0x56, 0x85, 0xac, 0xf9, 0xb4, 0x8a, 0x0b, 0xb5, 0x4a, 0x45, + 0x6d, 0x36, 0x95, 0xa2, 0x94, 0xc8, 0x24, 0x53, 0x71, 0x29, 0x9e, 0xf9, 0x5b, 0x02, 0xa4, 0x63, + 0xd7, 0xf4, 0x09, 0xfd, 0xbe, 0x6d, 0x5e, 0x23, 0xd0, 0xc7, 0x30, 0x6b, 0xb2, 0x57, 0x4f, 0x8e, + 0xb3, 0x53, 0xb7, 0x19, 0xb1, 0x3b, 0xdc, 0x20, 0x28, 0xb3, 0x42, 0x1f, 0x3d, 0x86, 0x25, 0x5e, + 0x66, 0x3d, 0x0a, 0xb8, 0x76, 0x8b, 0x88, 0x9a, 0xb7, 0x46, 0xd5, 0xbe, 0x7f, 0xb5, 0xbd, 0xc8, + 0x6a, 0x63, 0x43, 0x0c, 0x6a, 0x8b, 0x56, 0xf8, 0x15, 0x95, 0xfa, 0xb9, 0x49, 0xb2, 0xdc, 0x3c, + 0x8c, 0xc8, 0xcd, 0x68, 0xb4, 0xd1, 0x59, 0xf9, 0xff, 0x78, 0x3f, 0x2d, 0xeb, 0x80, 0xfa, 0x69, + 0x69, 0xd4, 0x95, 0x82, 0xba, 0xa7, 0x2a, 0x45, 0x29, 0x16, 0x92, 0x1f, 0xe7, 0xd4, 0x26, 0xae, + 0xd7, 0xca, 0x6a, 0xe1, 0x99, 0x14, 0x47, 0x1b, 0xb0, 0x22, 0xe4, 0xe5, 0x5a, 0xe1, 0x10, 0x37, + 0xd5, 0x8a, 0x52, 0x3b, 0x6a, 0x4a, 0x09, 0x94, 0x85, 0x87, 0xe1, 0x01, 0x66, 0xf5, 0xe9, 0x91, + 0x72, 0xa4, 0xe0, 0x4a, 0xee, 0x29, 0x2e, 0x2b, 0xd5, 0xfd, 0x66, 0x09, 0x2b, 0x4f, 0x0b, 0x8a, + 0x52, 0x54, 0x8a, 0xd2, 0xd4, 0x41, 0x32, 0x95, 0x90, 0xa6, 0x32, 0xbf, 0x8d, 0x8b, 0x0c, 0x37, + 0x1d, 0xa7, 0x66, 0x89, 0xaf, 0x2c, 0x07, 0x73, 0x3f, 0x0a, 0x3a, 0x07, 0x56, 0xa8, 0x0a, 0x92, + 0xde, 0xf2, 0x7b, 0xba, 0xf5, 0xe3, 0x40, 0xf3, 0x06, 0x37, 0xee, 0x8b, 0x33, 0xab, 0x80, 0x6a, + 0x5d, 0x4a, 0x15, 0x4c, 0x97, 0x78, 0xcd, 0x0b, 0x9b, 0xd3, 0x85, 0x06, 0xac, 0x16, 0x1c, 0xdb, + 0x30, 0xe9, 0x51, 0xdc, 0xd3, 0x4d, 0x2b, 0x80, 0x89, 0xff, 0x82, 0x05, 0x31, 0xfb, 0xb9, 0x6e, + 0xf5, 0x88, 0x58, 0x43, 0x14, 0x19, 0x7a, 0x42, 0xc7, 0xb5, 0x79, 0xae, 0xcd, 0x5e, 0x32, 0x7f, + 0x88, 0x03, 0xe2, 0x1c, 0x89, 0xfc, 0x0f, 0x69, 0xf5, 0xa1, 0x27, 0x0d, 0xb3, 0x1d, 0xe2, 0x79, + 0x7a, 0x9b, 0x0c, 0x7d, 0x35, 0x81, 0x10, 0x3d, 0x86, 0x39, 0x51, 0xc6, 0x89, 0x21, 0x96, 0x3a, + 0x91, 0x7d, 0x05, 0xf9, 0xea, 0x1b, 0xa0, 0x4f, 0x20, 0x15, 0xd4, 0x09, 0x81, 0xd2, 0x6f, 0x33, + 0xee, 0xeb, 0x67, 0xbe, 0x84, 0xd5, 0x5c, 0xe7, 0xc4, 0x6c, 0xf7, 0x9c, 0x9e, 0xa7, 0x11, 0xaf, + 0x67, 0xf9, 0xd7, 0x8b, 0xf8, 0x63, 0x98, 0x7f, 0xe9, 0xea, 0xdd, 0x2e, 0x31, 0x30, 0x71, 0xdd, + 0x88, 0x98, 0x83, 0x43, 0xcd, 0xdc, 0x69, 0x20, 0x94, 0x15, 0xd7, 0xcd, 0x6c, 0x50, 0x86, 0x74, + 0xea, 0xef, 0xbb, 0x4e, 0xaf, 0x5b, 0x24, 0x16, 0x09, 0xb2, 0x94, 0xc1, 0xb0, 0x2e, 0x18, 0x6a, + 0xc1, 0x71, 0xdd, 0x5e, 0x97, 0xee, 0x0c, 0x8f, 0x86, 0xe2, 0x15, 0x7d, 0xc0, 0xa3, 0xb8, 0x93, + 0x62, 0xe2, 0x8a, 0xd7, 0x46, 0x19, 0x98, 0xeb, 0xba, 0x4e, 0x8b, 0x78, 0x9e, 0x48, 0x61, 0xaa, + 0x8f, 0xac, 0x81, 0x38, 0xd3, 0x00, 0x24, 0x26, 0x08, 0x9f, 0xd8, 0xff, 0x06, 0x10, 0x54, 0x3a, + 0xa0, 0x88, 0xd3, 0xf9, 0xb4, 0x20, 0x13, 0x73, 0x42, 0x9f, 0xb1, 0xbd, 0xc1, 0x0b, 0xcd, 0x3e, + 0x7f, 0x34, 0x32, 0x87, 0x80, 0x18, 0x0b, 0x1c, 0x63, 0x9d, 0x7d, 0xfa, 0x18, 0xbf, 0x3e, 0x7d, + 0x6c, 0x50, 0x7a, 0x7b, 0xa6, 0xdb, 0x86, 0x45, 0x2b, 0x8f, 0xef, 0x5e, 0xf6, 0x99, 0x2f, 0x7a, + 0x04, 0xc9, 0xae, 0xe2, 0xba, 0x11, 0xe7, 0x71, 0x28, 0xd5, 0x62, 0xd5, 0x4c, 0x57, 0xd4, 0xc4, + 0x7f, 0xc6, 0xe1, 0xde, 0x68, 0x59, 0xa0, 0x2c, 0xa8, 0x4e, 0x9b, 0x13, 0x8d, 0x9c, 0xba, 0x24, + 0xa8, 0x5f, 0x93, 0x90, 0xfd, 0x39, 0xcc, 0xf8, 0x17, 0x76, 0x40, 0x85, 0x17, 0xf2, 0x45, 0x3a, + 0xf4, 0xd7, 0x57, 0xdb, 0x1f, 0xb6, 0x4d, 0xff, 0xac, 0x77, 0x92, 0x6d, 0x39, 0x9d, 0xdd, 0x7e, + 0x3c, 0xc6, 0xc9, 0xe0, 0x79, 0xb7, 0xfb, 0xa2, 0xbd, 0xcb, 0xba, 0xa5, 0x5e, 0xcf, 0x34, 0xb2, + 0x47, 0x47, 0x6a, 0xf1, 0xf5, 0xab, 0xed, 0xe9, 0xe6, 0x85, 0xad, 0x16, 0xb5, 0x69, 0xff, 0xc2, + 0x56, 0x0d, 0xb4, 0x07, 0xf3, 0xfe, 0x20, 0x3a, 0x71, 0x82, 0xaf, 0x57, 0x35, 0xc3, 0x86, 0x99, + 0x3d, 0xd8, 0x6e, 0x5e, 0xd8, 0x39, 0x8b, 0x72, 0xb0, 0x4b, 0xc5, 0x6e, 0x39, 0x3d, 0x4a, 0xec, + 0xc4, 0xe1, 0xe2, 0xeb, 0xbb, 0x03, 0xd0, 0x75, 0xc9, 0x39, 0x66, 0xa7, 0x66, 0x68, 0x99, 0x73, + 0x54, 0xce, 0x8f, 0xe1, 0xcf, 0xe3, 0xb0, 0x4a, 0x51, 0xb8, 0x4d, 0xdc, 0xda, 0x39, 0x71, 0x4f, + 0x2d, 0xe7, 0x25, 0xb7, 0xde, 0x84, 0xa9, 0x08, 0xce, 0x4e, 0x65, 0xe8, 0x01, 0x2c, 0xb6, 0x7a, + 0xae, 0x4b, 0x6c, 0x5f, 0xa0, 0x06, 0x6f, 0x19, 0xb8, 0xef, 0x05, 0x31, 0xc4, 0x20, 0x02, 0x7d, + 0x00, 0x37, 0x4c, 0xbb, 0xe5, 0x92, 0xce, 0x40, 0x79, 0x2a, 0xa4, 0xbc, 0xd4, 0x1f, 0xe4, 0x88, + 0xf2, 0x75, 0x1c, 0x6e, 0xe6, 0x29, 0xef, 0x1e, 0xc0, 0x1c, 0x39, 0x75, 0x5c, 0xb2, 0x5f, 0xe8, + 0xe3, 0x6d, 0xf3, 0x47, 0xe1, 0xed, 0x80, 0x52, 0x52, 0x17, 0x67, 0xf4, 0x10, 0x38, 0x96, 0xf1, + 0x43, 0x80, 0x76, 0x60, 0x95, 0xe9, 0x00, 0xe2, 0x85, 0xab, 0x62, 0x7a, 0x9e, 0x69, 0xb7, 0x79, + 0x6c, 0x8f, 0x61, 0xe1, 0xa5, 0xeb, 0xd8, 0x6d, 0xcc, 0x6b, 0xa8, 0x08, 0x6f, 0x72, 0xc9, 0xd5, + 0xe6, 0x99, 0x3a, 0x7f, 0x09, 0xd2, 0x9d, 0x18, 0x4f, 0x37, 0xed, 0x0e, 0x2b, 0xc4, 0xa5, 0xc4, + 0xbf, 0xee, 0x3a, 0x6d, 0x97, 0x78, 0x9c, 0x46, 0x64, 0x7e, 0x97, 0x80, 0x15, 0xd6, 0x11, 0xec, + 0x11, 0xf1, 0xfd, 0xf0, 0x40, 0x0e, 0x47, 0x88, 0xd3, 0x07, 0x11, 0x5f, 0x4f, 0x84, 0x5d, 0x74, + 0x01, 0xfe, 0xf3, 0xa0, 0x00, 0x6f, 0xc1, 0xba, 0xa8, 0x9b, 0x9a, 0x52, 0x2f, 0xab, 0x85, 0x1c, + 0xd6, 0x94, 0x4a, 0xed, 0xc9, 0x48, 0x11, 0xd6, 0x72, 0xd5, 0x7d, 0x05, 0x37, 0xea, 0x65, 0xb5, + 0x39, 0x54, 0x84, 0xb9, 0xbc, 0xa2, 0x68, 0xfb, 0x94, 0xb6, 0x84, 0x08, 0x8d, 0x96, 0xdb, 0x6b, + 0xe2, 0x46, 0x35, 0x57, 0x6f, 0x94, 0x6a, 0x4d, 0x69, 0x0a, 0xa5, 0x61, 0xab, 0x5f, 0x9e, 0xf7, + 0xd5, 0x42, 0xae, 0x8c, 0x6b, 0xf5, 0x06, 0xae, 0xa8, 0x8d, 0x86, 0x5a, 0xdd, 0x97, 0x92, 0x21, + 0xcb, 0x46, 0xb9, 0x76, 0x8c, 0x0b, 0xb5, 0x6a, 0xe3, 0xa8, 0xa2, 0x68, 0xd2, 0x34, 0xda, 0x84, + 0x35, 0x31, 0x52, 0xad, 0xe1, 0xb2, 0x92, 0x6b, 0x28, 0xa5, 0x5a, 0xb9, 0xa8, 0x68, 0xd2, 0x4c, + 0x46, 0x07, 0x59, 0xb5, 0x0d, 0xe2, 0x13, 0xb7, 0x63, 0xda, 0xba, 0x4f, 0x0a, 0x4e, 0xa7, 0x63, + 0x0a, 0xf4, 0x57, 0x60, 0xde, 0xf3, 0xf5, 0x36, 0xeb, 0x5b, 0x7e, 0x20, 0x91, 0x05, 0x61, 0x48, + 0x99, 0xec, 0x0a, 0x2c, 0xab, 0xf6, 0xb9, 0x6e, 0x99, 0x06, 0x2b, 0x3e, 0x7c, 0x8f, 0xd2, 0x70, + 0xab, 0xd6, 0xf5, 0xcd, 0x0e, 0x2d, 0x40, 0x2d, 0xe5, 0x5c, 0xb7, 0x0a, 0x8e, 0x7d, 0x6a, 0x99, + 0x2d, 0x5f, 0xec, 0xe1, 0x2f, 0xd6, 0x61, 0x9e, 0x3d, 0x15, 0x89, 0xaf, 0x9b, 0x16, 0xd2, 0x40, + 0xb2, 0x1d, 0x1f, 0x0f, 0x5d, 0x71, 0xf0, 0x80, 0xde, 0x8d, 0xd8, 0xc5, 0x88, 0x6b, 0x96, 0x52, + 0x4c, 0x5b, 0xb2, 0x87, 0xc4, 0xa8, 0x06, 0x37, 0xf8, 0x9d, 0x00, 0xf5, 0x7c, 0x4a, 0x51, 0x5b, + 0x9c, 0xfb, 0x7b, 0x93, 0x0e, 0xc6, 0x10, 0xba, 0x97, 0x68, 0xa7, 0x17, 0x96, 0xa2, 0xa7, 0x80, + 0xb8, 0xc3, 0x17, 0xe4, 0xb2, 0xdf, 0x75, 0x0b, 0x28, 0xbb, 0x3f, 0xc9, 0xe7, 0xe8, 0x15, 0x41, + 0x29, 0xa6, 0x49, 0xee, 0xc8, 0x00, 0xfa, 0xbf, 0x38, 0xec, 0xb0, 0x86, 0xf4, 0x25, 0xeb, 0x5b, + 0x87, 0x1a, 0x33, 0x53, 0x74, 0xae, 0xa2, 0xdb, 0xfe, 0x28, 0x6a, 0xa2, 0xb7, 0x76, 0xbc, 0xa5, + 0x98, 0x76, 0xdb, 0xbd, 0x4a, 0x0b, 0x7d, 0x0e, 0x2b, 0x21, 0x9c, 0xc5, 0x3a, 0x6f, 0x8c, 0x44, + 0xbb, 0xf9, 0xf0, 0x5a, 0x5d, 0x54, 0x30, 0x13, 0xf2, 0xc7, 0x86, 0x50, 0x13, 0xa4, 0xb0, 0x7b, + 0xda, 0x08, 0xc9, 0x33, 0xcc, 0xf7, 0x7b, 0x57, 0xfb, 0xee, 0xf7, 0x5d, 0xa5, 0x98, 0x76, 0xc3, + 0x1f, 0x96, 0xa3, 0x63, 0x58, 0x0e, 0x7b, 0x75, 0xe9, 0x47, 0x2d, 0xcf, 0x4e, 0xdc, 0x90, 0xc8, + 0x86, 0x8b, 0x6e, 0x88, 0x3f, 0x32, 0x80, 0x3e, 0x83, 0xf0, 0x22, 0xb0, 0xc7, 0xba, 0x18, 0x39, + 0xc5, 0x3c, 0x3f, 0xb8, 0x76, 0xc7, 0x53, 0x8a, 0x69, 0xe1, 0xf8, 0xf8, 0x08, 0x2a, 0x51, 0xc0, + 0x34, 0x7d, 0x12, 0x00, 0xe6, 0x1c, 0xf3, 0x7a, 0xe7, 0x1a, 0xbd, 0x42, 0x29, 0x46, 0xc1, 0xb3, + 0x2f, 0x43, 0x2a, 0x2c, 0x72, 0x4f, 0xbe, 0xe3, 0x60, 0x8a, 0xeb, 0x70, 0xb5, 0xab, 0x10, 0x21, + 0xea, 0xbb, 0xe2, 0x32, 0xfa, 0xb1, 0x38, 0x5d, 0xec, 0x0a, 0xfe, 0xcc, 0x00, 0x61, 0x7e, 0xe2, + 0xc7, 0x32, 0x4e, 0xb4, 0xe9, 0xc7, 0xe2, 0x84, 0xa5, 0x74, 0xc3, 0x5b, 0x01, 0xf3, 0xc6, 0xa7, + 0x8c, 0x7a, 0xcb, 0x0b, 0x13, 0x37, 0x3c, 0x8a, 0xa4, 0xd3, 0x0d, 0x6f, 0x0d, 0xcb, 0x51, 0x35, + 0xe8, 0xcf, 0x5c, 0x41, 0xbd, 0xe5, 0xc5, 0x89, 0x51, 0x8e, 0x53, 0x74, 0x1a, 0xa5, 0x15, 0x96, + 0xd2, 0x28, 0x6d, 0xc7, 0x20, 0xb8, 0x37, 0xb8, 0x82, 0x94, 0x97, 0x26, 0x46, 0x19, 0x75, 0x59, + 0x49, 0xa3, 0xb4, 0x87, 0xe5, 0x1c, 0x28, 0x4e, 0x7d, 0xdc, 0xa6, 0xec, 0x17, 0x1b, 0x9c, 0xfe, + 0xca, 0xd2, 0x15, 0x40, 0x11, 0xc1, 0x94, 0x39, 0x50, 0x0c, 0x0f, 0xd0, 0x73, 0x19, 0xd0, 0xd8, + 0x56, 0x9f, 0x3e, 0xcb, 0xcb, 0x13, 0xcf, 0x65, 0x34, 0xd5, 0xa6, 0xe7, 0xd2, 0x1d, 0x1d, 0x61, + 0x78, 0x29, 0x7c, 0x07, 0xe7, 0x09, 0x4d, 0xc6, 0xcb, 0x31, 0x8a, 0xcd, 0xf0, 0x32, 0x2c, 0xa5, + 0xc9, 0xd5, 0x83, 0xb6, 0x03, 0xbb, 0xac, 0xef, 0x90, 0xb7, 0x26, 0x26, 0x37, 0xaa, 0x43, 0xa1, + 0xc9, 0xd5, 0x87, 0xe5, 0x34, 0x4c, 0x4e, 0xba, 0x07, 0xb0, 0x7e, 0x73, 0x62, 0x98, 0xe3, 0xa4, + 0x9d, 0x86, 0xe9, 0x85, 0xa5, 0xe8, 0x67, 0x71, 0xb8, 0x3b, 0x86, 0x22, 0x0c, 0x89, 0x31, 0xbb, + 0xd9, 0xc7, 0x2e, 0x67, 0xcf, 0xf2, 0x2d, 0x36, 0xcd, 0x7f, 0x5e, 0x03, 0x58, 0x22, 0x89, 0x77, + 0x29, 0xa6, 0xed, 0xf8, 0x6f, 0x51, 0xa4, 0x39, 0x33, 0x39, 0x2d, 0xc5, 0x8e, 0xe0, 0xa5, 0xf2, + 0xf6, 0xc4, 0x9c, 0x45, 0x31, 0x58, 0x9a, 0x33, 0x73, 0x58, 0x4e, 0xc1, 0xbd, 0x37, 0xb8, 0x50, + 0xc7, 0xa2, 0xab, 0x94, 0x77, 0x26, 0x82, 0xfb, 0x84, 0xeb, 0x77, 0x0a, 0xee, 0xbd, 0xb1, 0x21, + 0xf4, 0x1c, 0xa4, 0x7e, 0x13, 0x8f, 0x4f, 0x18, 0x73, 0x95, 0x33, 0xcc, 0x77, 0x36, 0xc2, 0xf7, + 0x15, 0x44, 0x97, 0x61, 0xfc, 0xf0, 0x08, 0x7a, 0x09, 0xb7, 0x69, 0x5b, 0xa2, 0x73, 0xca, 0x8f, + 0xc9, 0x80, 0xf3, 0x0b, 0x86, 0x7f, 0x87, 0xcd, 0xf4, 0x28, 0x6a, 0x5b, 0xae, 0xee, 0x14, 0x4a, + 0x31, 0x6d, 0xcb, 0x9f, 0xa8, 0x42, 0xb1, 0x86, 0x23, 0x34, 0xad, 0xf5, 0x94, 0xef, 0xca, 0x77, + 0x27, 0x9e, 0xb3, 0x71, 0x5e, 0x4c, 0xcf, 0x99, 0x19, 0x96, 0xa2, 0x23, 0x58, 0xee, 0x50, 0x3e, + 0x8b, 0x4d, 0x9b, 0x1e, 0x2c, 0xc6, 0x68, 0xe5, 0x7b, 0x13, 0xf7, 0x36, 0x8a, 0xfb, 0xd2, 0xfc, + 0x74, 0x86, 0xe5, 0xe8, 0x53, 0x41, 0x73, 0x4e, 0x09, 0xdb, 0x59, 0x5a, 0x01, 0xdf, 0x9d, 0xc8, + 0x9c, 0x22, 0xf8, 0x2f, 0x65, 0x4e, 0x7d, 0x07, 0xbc, 0xfa, 0x7d, 0x01, 0xab, 0x66, 0x98, 0x35, + 0xe2, 0x16, 0xa3, 0x8d, 0xf2, 0x7b, 0xcc, 0xef, 0xfb, 0x91, 0xeb, 0x8f, 0x26, 0x99, 0xa5, 0x98, + 0xb6, 0x62, 0x8e, 0x8f, 0xa1, 0x27, 0xb0, 0x62, 0x72, 0xd2, 0x28, 0x38, 0x1f, 0xdf, 0xca, 0xfb, + 0x63, 0x7f, 0xb5, 0x06, 0x13, 0x8c, 0x50, 0x4c, 0x8a, 0x61, 0xe6, 0xa8, 0x10, 0x75, 0x60, 0xd3, + 0xe9, 0xf3, 0x4e, 0x4c, 0xce, 0x75, 0x0b, 0xb7, 0x02, 0xe6, 0x29, 0x3f, 0x60, 0xde, 0x77, 0x23, + 0x0b, 0xda, 0x64, 0xae, 0x5a, 0x8a, 0x69, 0x1b, 0x4e, 0xf4, 0x78, 0x7e, 0x16, 0xa6, 0x59, 0x73, + 0x77, 0x90, 0x4c, 0xdd, 0x90, 0xa4, 0x83, 0x64, 0x6a, 0x45, 0x5a, 0x3d, 0x48, 0xa6, 0x56, 0xa5, + 0xb5, 0x83, 0x64, 0x6a, 0x4d, 0x5a, 0x3f, 0x48, 0xa6, 0xd6, 0xa5, 0x8d, 0x83, 0x64, 0x6a, 0x43, + 0x92, 0x0f, 0x92, 0x29, 0x59, 0xda, 0x3c, 0x48, 0xa6, 0x36, 0xa5, 0xad, 0x83, 0x64, 0xea, 0xb6, + 0x94, 0x3e, 0x48, 0xa6, 0xd2, 0xd2, 0xf6, 0x41, 0x32, 0xf5, 0x8e, 0x94, 0xc9, 0x3c, 0x60, 0x84, + 0xb8, 0xee, 0x78, 0xac, 0xdc, 0xa1, 0x2d, 0x98, 0xa6, 0x79, 0xbb, 0x10, 0x57, 0x15, 0x9c, 0x76, + 0x73, 0x51, 0xe6, 0xab, 0x69, 0x98, 0x0e, 0x7e, 0x37, 0x8d, 0x5c, 0xe0, 0x6c, 0x8a, 0xfb, 0x87, + 0xe5, 0xd0, 0x2f, 0x1d, 0xae, 0x30, 0xb8, 0xd5, 0xf9, 0xdf, 0x61, 0xa6, 0xe7, 0x12, 0xf6, 0xa7, + 0x8a, 0xf1, 0xd8, 0xa5, 0xc8, 0xc3, 0x3d, 0x84, 0x6e, 0x4c, 0x39, 0x7f, 0x57, 0xcc, 0x73, 0x6b, + 0x30, 0xcf, 0xb8, 0xd6, 0x10, 0x11, 0x14, 0x32, 0x54, 0x80, 0xc5, 0x9e, 0x4d, 0x2e, 0xba, 0x8e, + 0x47, 0x0c, 0x46, 0x33, 0x92, 0xd7, 0xe9, 0x3b, 0xb4, 0x85, 0xbe, 0x11, 0x25, 0x17, 0xbb, 0x30, + 0xef, 0xb8, 0x66, 0xdb, 0xb4, 0x31, 0x2d, 0xbd, 0x8c, 0xa4, 0x4e, 0xe7, 0x97, 0xc4, 0x1d, 0xed, + 0x0c, 0x2d, 0xd3, 0x6a, 0x51, 0x03, 0xae, 0x42, 0xdf, 0x50, 0x1d, 0x66, 0x0c, 0xd6, 0x69, 0x08, + 0xd2, 0x99, 0x9e, 0x74, 0xb3, 0xc2, 0xfb, 0x91, 0xbc, 0x2c, 0xd6, 0x27, 0x0d, 0xd6, 0xc7, 0x47, + 0x34, 0xe1, 0x07, 0x1d, 0xc2, 0x22, 0x85, 0x22, 0xa3, 0x0f, 0x43, 0x9c, 0xc6, 0xed, 0x84, 0x1c, + 0x07, 0xff, 0xa0, 0xb3, 0x0a, 0x57, 0x0c, 0x5f, 0xdd, 0x2c, 0x90, 0x90, 0x0c, 0xfd, 0x7b, 0xb0, + 0xdb, 0xb3, 0x57, 0x45, 0x17, 0x1c, 0x0e, 0x71, 0x0e, 0x50, 0x0f, 0xa6, 0x6c, 0xe7, 0xa5, 0x60, + 0xa5, 0x6f, 0x69, 0xe6, 0x8b, 0x22, 0x39, 0x8f, 0xaf, 0x7f, 0x99, 0x43, 0x1d, 0x14, 0x2c, 0xa7, + 0xf5, 0xa2, 0xef, 0x45, 0xa3, 0xf3, 0xf1, 0xfb, 0x26, 0x7e, 0x3b, 0xfc, 0xf0, 0x2f, 0x09, 0x90, + 0x27, 0xfd, 0x4e, 0xa1, 0x1d, 0x6b, 0x2e, 0x5f, 0xd3, 0x9a, 0x78, 0xec, 0x5a, 0xff, 0x1e, 0xbc, + 0x33, 0x34, 0xc2, 0x5e, 0x94, 0x22, 0xd6, 0x94, 0x42, 0x4d, 0x2b, 0xe2, 0xbd, 0xda, 0x51, 0xb5, + 0x28, 0xc5, 0x69, 0x4b, 0x3c, 0xa4, 0x56, 0x28, 0xab, 0x4a, 0x95, 0xbe, 0x1d, 0x28, 0x05, 0xda, + 0x32, 0x6f, 0xc3, 0xcd, 0xa1, 0xf1, 0xfa, 0x51, 0xa3, 0xa4, 0x68, 0x81, 0x37, 0x29, 0x89, 0x6e, + 0xc2, 0xc6, 0xf8, 0x3c, 0xb8, 0x51, 0xcf, 0x55, 0xa5, 0x69, 0xf4, 0x1f, 0xf0, 0xe1, 0xd0, 0xa0, + 0x98, 0x3c, 0x57, 0xd6, 0x94, 0x5c, 0xf1, 0x19, 0x3e, 0xd6, 0xd4, 0x66, 0x53, 0xa9, 0xe2, 0x7a, + 0xad, 0xd1, 0x50, 0xf3, 0x65, 0x85, 0x75, 0xff, 0xb9, 0x67, 0xd2, 0x0c, 0x7a, 0x0f, 0xee, 0x0c, + 0x19, 0x56, 0x95, 0x63, 0xde, 0x76, 0xe3, 0xba, 0xa6, 0x3c, 0x51, 0xaa, 0xcd, 0x06, 0x6e, 0x3e, + 0xad, 0x4a, 0x29, 0xf4, 0x00, 0xee, 0x0d, 0x29, 0x36, 0xd5, 0x8a, 0xd2, 0x68, 0xe6, 0x2a, 0x75, + 0x5c, 0xc8, 0x15, 0x4a, 0x8a, 0x58, 0x88, 0x52, 0x94, 0x66, 0xb7, 0x92, 0x5f, 0x7d, 0x9d, 0x8e, + 0x65, 0x68, 0x52, 0x13, 0x0f, 0x7f, 0x3f, 0xfc, 0x57, 0x26, 0xf4, 0x87, 0x87, 0x5f, 0x02, 0x34, + 0xb5, 0x67, 0xe3, 0x29, 0x65, 0x37, 0x0e, 0x74, 0x84, 0xc6, 0xad, 0xe0, 0x66, 0xad, 0x86, 0x6b, + 0x65, 0x9a, 0x44, 0x76, 0x45, 0x41, 0x07, 0x1a, 0x8a, 0xa6, 0xe6, 0xca, 0xea, 0x67, 0xb9, 0x7c, + 0x59, 0x91, 0xa6, 0xd0, 0x6d, 0xd8, 0xe4, 0xf2, 0x5c, 0xe3, 0x59, 0xb5, 0x20, 0xcc, 0xf6, 0x72, + 0x6a, 0xf9, 0x48, 0x53, 0xa4, 0x69, 0x94, 0x81, 0x34, 0x1f, 0xe6, 0x3f, 0x5d, 0x70, 0x51, 0xc9, + 0x15, 0xcb, 0x6a, 0x55, 0x19, 0xfc, 0x21, 0x98, 0xe1, 0x41, 0x3f, 0xfc, 0x04, 0xd0, 0xf8, 0xb7, + 0x8f, 0x52, 0x90, 0xac, 0xd6, 0xaa, 0x8a, 0x14, 0x43, 0xf3, 0x30, 0x9b, 0xcf, 0x15, 0x0e, 0x6b, + 0x7b, 0x7b, 0x52, 0x1c, 0x2d, 0xc2, 0x9c, 0x5a, 0xa9, 0x28, 0x45, 0x35, 0xd7, 0x54, 0xa4, 0x44, + 0xfe, 0xc1, 0x37, 0xff, 0x48, 0xc7, 0xbe, 0x79, 0x9d, 0x8e, 0x7f, 0xfb, 0x3a, 0x1d, 0xff, 0xee, + 0x75, 0x3a, 0xfe, 0xf7, 0xd7, 0xe9, 0xf8, 0x2f, 0xdf, 0xa4, 0x63, 0xdf, 0xbe, 0x49, 0xc7, 0xbe, + 0x7b, 0x93, 0x8e, 0x7d, 0x36, 0x2b, 0xd0, 0xe0, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x50, 0x05, + 0xa8, 0x92, 0xfc, 0x21, 0x00, 0x00, } func (m *NotLeaseHolderError) Marshal() (dAtA []byte, err error) { @@ -2834,6 +2898,9 @@ func (m *WriteIntentError) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + i = encodeVarintErrors(dAtA, i, uint64(m.Reason)) + i-- + dAtA[i] = 0x20 i = encodeVarintErrors(dAtA, i, uint64(m.LeaseSequence)) i-- dAtA[i] = 0x18 @@ -4492,6 +4559,7 @@ func (m *WriteIntentError) Size() (n int) { } } n += 1 + sovErrors(uint64(m.LeaseSequence)) + n += 1 + sovErrors(uint64(m.Reason)) return n } @@ -6413,6 +6481,25 @@ func (m *WriteIntentError) Unmarshal(dAtA []byte) error { break } } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) + } + m.Reason = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowErrors + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Reason |= WriteIntentError_Reason(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipErrors(dAtA[iNdEx:]) diff --git a/pkg/roachpb/errors.proto b/pkg/roachpb/errors.proto index 196e7f3d2b4d..06ab091350d9 100644 --- a/pkg/roachpb/errors.proto +++ b/pkg/roachpb/errors.proto @@ -304,6 +304,24 @@ message WriteIntentError { // which were discovered under old leases to the lock table. optional int64 lease_sequence = 3 [(gogoproto.nullable) = false, (gogoproto.casttype) = "LeaseSequence"]; + enum Reason { + // The reason for the WriteIntentError is unspecified. This will + // always be the case for errors returned from MVCC. + REASON_UNSPECIFIED = 0; + // The request used an Error wait policy because it did not want to + // wait on locks and it encountered a conflicting lock. + REASON_WAIT_POLICY = 1; + // The request used a Block wait policy and specified a lock timeout + // which expired while waiting for a conflicting lock. + REASON_LOCK_TIMEOUT = 2; + // The request attempted to wait in a lock wait-queue whose length was + // already equal to or exceeding the configured maximum. + REASON_LOCK_WAIT_QUEUE_MAX_LENGTH_EXCEEDED = 3; + } + // The reason for the error. Applies to WriteIntentErrors that are + // returned from the concurrency manager (the second use described + // above). + optional Reason reason = 4 [(gogoproto.nullable) = false]; } // A WriteTooOldError indicates that a write encountered a versioned diff --git a/pkg/testutils/lint/lint_test.go b/pkg/testutils/lint/lint_test.go index 3994c3bd6914..e201a5b9fafb 100644 --- a/pkg/testutils/lint/lint_test.go +++ b/pkg/testutils/lint/lint_test.go @@ -810,7 +810,10 @@ func TestLint(t *testing.T) { t.Fatal(err) } - if err := stream.ForEach(filter, func(s string) { + if err := stream.ForEach(stream.Sequence( + filter, + stream.GrepNot(`nolint:context`), + ), func(s string) { t.Errorf("\n%s <- forbidden; use 'contextutil.RunWithTimeout' instead", s) }); err != nil { t.Error(err)