diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 26b7b98c4..ac1be80e7 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -12,7 +12,7 @@ on: run-on-runner: description: 'Specify the runner to use' required: true - default: 'arm64' + default: 'mac-mini-org-heart' permissions: @@ -23,17 +23,17 @@ permissions: jobs: build: - runs-on: ${{ github.event_name == 'push' && 'arm64' || (github.event.inputs.run-on-runner || 'arm64') }} + runs-on: ${{ github.event_name == 'push' && 'mac-mini-org-heart' || (github.event.inputs.run-on-runner || 'mac-mini-org-heart') }} steps: - name: validate agent run: | - if [[ "${{ github.event_name }}" == "workflow_dispatch" && "${{ github.event.inputs.run-on-runner }}" != "arm64" ]]; then + if [[ "${{ github.event_name }}" == "workflow_dispatch" && "${{ github.event.inputs.run-on-runner }}" != "mac-mini-org-heart" ]]; then echo "Invalid runner" exit 1 fi - name: Install Go - if: runner.name != 'mac-mini-org-heart' + if: ${{ !startsWith(runner.name, 'mac-mini-runner-') }} uses: actions/setup-go@v4 with: go-version: 1.23.2 @@ -50,9 +50,14 @@ jobs: uses: actions/checkout@v3 - name: Install brew and node deps - if: runner.name != 'mac-mini-org-heart' + if: ${{ !startsWith(runner.name, 'mac-mini-runner-') }} run: make install-brew-and-node-deps + - name: Setup Xcode + uses: maxim-lobanov/setup-xcode@v1.6.0 + with: + xcode-version: '16.2' + - name: Set env vars env: UNSPLASH_KEY: ${{ secrets.UNSPLASH_KEY }} diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index def51c133..50d652988 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -14,12 +14,14 @@ on: options: - alpha - beta -# schedule: -# - cron: '0 0 * * *' # every day at midnight -# filters: -# branches: -# include: -# - 'nightly-ci-test' + run-on-runner: + description: 'Specify the runner to use' + required: true + default: 'mac-mini-org-heart' + type: choice + options: + - mac-mini-org-heart + - macos-14 permissions: actions: 'write' @@ -28,9 +30,10 @@ permissions: jobs: build: - runs-on: 'macos-14' + runs-on: ${{ github.event.inputs.run-on-runner }} steps: - name: Install Go + if: ${{ !startsWith(runner.name, 'mac-mini-runner-') }} uses: actions/setup-go@v4 with: go-version: 1.23.2 @@ -47,8 +50,14 @@ jobs: uses: actions/checkout@v3 - name: Install brew and node deps + if: ${{ !startsWith(runner.name, 'mac-mini-runner-') }} run: make install-brew-and-node-deps + - name: Setup Xcode + uses: maxim-lobanov/setup-xcode@v1.6.0 + with: + xcode-version: '16.2' + - name: Nightly mode env settings shell: bash run: | diff --git a/.github/workflows/perftests-grafana.yml b/.github/workflows/perftests-grafana.yml index fdedcff6b..6a18b644b 100644 --- a/.github/workflows/perftests-grafana.yml +++ b/.github/workflows/perftests-grafana.yml @@ -6,7 +6,11 @@ on: run-on-runner: description: 'Specify the runner to use' required: true - default: 'arm64' + default: 'mac-mini-org-heart' + perf-test: + description: 'Run perf test times' + required: true + default: '1' schedule: - cron: '0 0 * * *' # every day at midnight filters: @@ -23,10 +27,10 @@ permissions: jobs: perftests-grafana: - runs-on: ${{ github.event.inputs.run-on-runner || 'arm64' }} + runs-on: ${{ github.event.inputs.run-on-runner || 'mac-mini-org-heart' }} steps: - name: Install Go - if: runner.name != 'mac-mini-org-heart' + if: ${{ !startsWith(runner.name, 'mac-mini-runner-') }} uses: actions/setup-go@v4 with: go-version: 1.23.2 @@ -43,7 +47,7 @@ jobs: uses: actions/checkout@v3 - name: Install brew and node deps - if: runner.name != 'mac-mini-org-heart' + if: ${{ !startsWith(runner.name, 'mac-mini-runner-') }} run: make install-brew-and-node-deps - name: Set env vars @@ -92,8 +96,12 @@ jobs: PROM_PASSWORD: ${{ secrets.PROMETHEUS_PASSWORD }} run: | echo "Running perf tests" + RUN_COUNT=${{ github.event.inputs.perf-test }} + if [[ "${{ github.event_name }}" == "schedule" ]]; then + RUN_COUNT=10 + fi cd cmd/perftester/ - CGO_ENABLED="1" go run main.go 10 + CGO_ENABLED="1" go run main.go $RUN_COUNT - name: Archive perf tests results uses: actions/upload-artifact@v4 diff --git a/.github/workflows/perftests.yml b/.github/workflows/perftests.yml index 02b74c084..c1427d946 100644 --- a/.github/workflows/perftests.yml +++ b/.github/workflows/perftests.yml @@ -8,7 +8,7 @@ on: run-on-runner-mac: description: 'Specify the runner to use on MacOS' required: true - default: 'ARM64' + default: 'mac-mini-org-heart' run-on-runner-win: description: 'Specify the runner to use on Windows' required: true @@ -33,7 +33,7 @@ permissions: jobs: perftests-macos: timeout-minutes: 60 - runs-on: 'ARM64' + runs-on: 'mac-mini-org-heart' steps: - name: Setup GO run: | diff --git a/.gitignore b/.gitignore index 433d7b311..d61722cc1 100644 --- a/.gitignore +++ b/.gitignore @@ -20,3 +20,4 @@ build /core/anytype/config/nodes/custom.yml /.direnv/ /.envrc +*.swp diff --git a/cmd/grpcserver/performance.go b/cmd/grpcserver/performance.go index 1fc730c3d..d6f5cd013 100644 --- a/cmd/grpcserver/performance.go +++ b/cmd/grpcserver/performance.go @@ -306,7 +306,7 @@ func getTableSizes(mw *core.Middleware) (tables map[string]uint64) { tables = make(map[string]uint64) cfg := mw.GetApp().MustComponent(config.CName).(*config.Config) - db, err := sql.Open("sqlite3", cfg.GetSqliteStorePath()) + db, err := sql.Open("sqlite3", cfg.GetNewSpaceStorePath()) if err != nil { fmt.Println("Error opening database:", err) return diff --git a/core/anytype/bootstrap.go b/core/anytype/bootstrap.go index f4b43916e..f9a2d5042 100644 --- a/core/anytype/bootstrap.go +++ b/core/anytype/bootstrap.go @@ -136,8 +136,8 @@ func BootstrapConfig(newAccount bool, isStaging bool) *config.Config { ) } -func BootstrapWallet(rootPath string, derivationResult crypto.DerivationResult) wallet.Wallet { - return wallet.NewWithAccountRepo(rootPath, derivationResult) +func BootstrapWallet(rootPath string, derivationResult crypto.DerivationResult, lang string) wallet.Wallet { + return wallet.NewWithAccountRepo(rootPath, derivationResult, lang) } func StartNewApp(ctx context.Context, clientWithVersion string, components ...app.Component) (a *app.App, err error) { diff --git a/core/application/account_create.go b/core/application/account_create.go index 0c2fa5189..138ef59e3 100644 --- a/core/application/account_create.go +++ b/core/application/account_create.go @@ -62,7 +62,7 @@ func (s *Service) AccountCreate(ctx context.Context, req *pb.RpcAccountCreateReq } comps := []app.Component{ cfg, - anytype.BootstrapWallet(s.rootPath, derivationResult), + anytype.BootstrapWallet(s.rootPath, derivationResult, s.fulltextPrimaryLanguage), s.eventSender, } diff --git a/core/application/account_create_from_export.go b/core/application/account_create_from_export.go index 4c6fca524..1c8da66dd 100644 --- a/core/application/account_create_from_export.go +++ b/core/application/account_create_from_export.go @@ -87,6 +87,7 @@ func (s *Service) RecoverFromLegacy(req *pb.RpcAccountRecoverFromLegacyExportReq return RecoverFromLegacyResponse{}, ErrAccountMismatch } s.rootPath = req.RootPath + s.fulltextPrimaryLanguage = req.FulltextPrimaryLanguage err = os.MkdirAll(s.rootPath, 0700) if err != nil { return RecoverFromLegacyResponse{}, anyerror.CleanupError(err) @@ -134,7 +135,7 @@ func (s *Service) RecoverFromLegacy(req *pb.RpcAccountRecoverFromLegacyExportReq func (s *Service) startApp(cfg *config.Config, derivationResult crypto.DerivationResult) error { comps := []app.Component{ cfg, - anytype.BootstrapWallet(s.rootPath, derivationResult), + anytype.BootstrapWallet(s.rootPath, derivationResult, s.fulltextPrimaryLanguage), s.eventSender, } diff --git a/core/application/account_select.go b/core/application/account_select.go index 303a3b915..5eeaf7900 100644 --- a/core/application/account_select.go +++ b/core/application/account_select.go @@ -41,7 +41,7 @@ func (s *Service) AccountSelect(ctx context.Context, req *pb.RpcAccountSelectReq if req.Id == "" { return nil, ErrEmptyAccountID } - curMigration := s.migrationManager.getOrCreateMigration(req.RootPath, req.Id) + curMigration := s.migrationManager.getOrCreateMigration(req.RootPath, req.Id, req.FulltextPrimaryLanguage) if !curMigration.successful() { return nil, ErrAccountStoreIsNotMigrated } @@ -82,16 +82,30 @@ func (s *Service) AccountSelect(ctx context.Context, req *pb.RpcAccountSelectReq } metrics.Service.SetWorkingDir(req.RootPath, req.Id) - return s.start(ctx, req.Id, req.RootPath, req.DisableLocalNetworkSync, req.JsonApiListenAddr, req.PreferYamuxTransport, req.NetworkMode, req.NetworkCustomConfigFilePath) + return s.start(ctx, req.Id, req.RootPath, req.DisableLocalNetworkSync, req.JsonApiListenAddr, + req.PreferYamuxTransport, req.NetworkMode, req.NetworkCustomConfigFilePath, req.FulltextPrimaryLanguage) } -func (s *Service) start(ctx context.Context, id string, rootPath string, disableLocalNetworkSync bool, jsonApiListenAddr string, preferYamux bool, networkMode pb.RpcAccountNetworkMode, networkConfigFilePath string) (*model.Account, error) { +func (s *Service) start( + ctx context.Context, + id string, + rootPath string, + disableLocalNetworkSync bool, + jsonApiListenAddr string, + preferYamux bool, + networkMode pb.RpcAccountNetworkMode, + networkConfigFilePath string, + lang string, +) (*model.Account, error) { ctx, task := trace2.NewTask(ctx, "application.start") defer task.End() if rootPath != "" { s.rootPath = rootPath } + if lang != "" { + s.fulltextPrimaryLanguage = lang + } if s.mnemonic == "" { return nil, ErrNoMnemonicProvided } @@ -129,7 +143,7 @@ func (s *Service) start(ctx context.Context, id string, rootPath string, disable } comps := []app.Component{ cfg, - anytype.BootstrapWallet(s.rootPath, res), + anytype.BootstrapWallet(s.rootPath, res, s.fulltextPrimaryLanguage), s.eventSender, } diff --git a/core/application/account_stop.go b/core/application/account_stop.go index b5f1f353e..ad1a75ca2 100644 --- a/core/application/account_stop.go +++ b/core/application/account_stop.go @@ -61,6 +61,7 @@ func (s *Service) AccountChangeNetworkConfigAndRestart(ctx context.Context, req } rootPath := s.app.MustComponent(walletComp.CName).(walletComp.Wallet).RootPath() + lang := s.app.MustComponent(walletComp.CName).(walletComp.Wallet).FtsPrimaryLang() accountId := s.app.MustComponent(walletComp.CName).(walletComp.Wallet).GetAccountPrivkey().GetPublic().Account() conf := s.app.MustComponent(config.CName).(*config.Config) @@ -89,7 +90,8 @@ func (s *Service) AccountChangeNetworkConfigAndRestart(ctx context.Context, req return ErrFailedToStopApplication } - _, err = s.start(ctx, accountId, rootPath, conf.DontStartLocalNetworkSyncAutomatically, conf.JsonApiListenAddr, conf.PeferYamuxTransport, req.NetworkMode, req.NetworkCustomConfigFilePath) + _, err = s.start(ctx, accountId, rootPath, conf.DontStartLocalNetworkSyncAutomatically, conf.JsonApiListenAddr, + conf.PeferYamuxTransport, req.NetworkMode, req.NetworkCustomConfigFilePath, lang) return err } diff --git a/core/application/account_store_migrate.go b/core/application/account_store_migrate.go index 838c98987..7fb5269db 100644 --- a/core/application/account_store_migrate.go +++ b/core/application/account_store_migrate.go @@ -25,7 +25,7 @@ func (s *Service) AccountMigrate(ctx context.Context, req *pb.RpcAccountMigrateR if s.rootPath == "" { s.rootPath = req.RootPath } - return s.migrationManager.getOrCreateMigration(req.RootPath, req.Id).wait() + return s.migrationManager.getOrCreateMigration(req.RootPath, req.Id, req.FulltextPrimaryLanguage).wait() } func (s *Service) AccountMigrateCancel(ctx context.Context, req *pb.RpcAccountMigrateCancelRequest) error { @@ -37,7 +37,7 @@ func (s *Service) AccountMigrateCancel(ctx context.Context, req *pb.RpcAccountMi return nil } -func (s *Service) migrate(ctx context.Context, id string) error { +func (s *Service) migrate(ctx context.Context, id, lang string) error { res, err := core.WalletAccountAt(s.mnemonic, 0) if err != nil { return err @@ -53,7 +53,7 @@ func (s *Service) migrate(ctx context.Context, id string) error { cfg.DisableNetworkIdCheck = true comps := []app.Component{ cfg, - anytype.BootstrapWallet(s.rootPath, res), + anytype.BootstrapWallet(s.rootPath, res, lang), s.eventSender, } a := &app.App{} @@ -75,21 +75,23 @@ type migration struct { err error id string done chan struct{} + lang string } -func newMigration(m *migrationManager, id string) *migration { +func newMigration(m *migrationManager, id, lang string) *migration { ctx, cancel := context.WithCancel(context.Background()) return &migration{ ctx: ctx, cancel: cancel, done: make(chan struct{}), id: id, + lang: lang, manager: m, } } -func newSuccessfulMigration(manager *migrationManager, id string) *migration { - m := newMigration(manager, id) +func newSuccessfulMigration(manager *migrationManager, id, lang string) *migration { + m := newMigration(manager, id, lang) m.setFinished(nil, false) return m } @@ -127,7 +129,7 @@ func (m *migration) wait() error { return m.err } m.mx.Unlock() - err := m.manager.service.migrate(m.ctx, m.id) + err := m.manager.service.migrate(m.ctx, m.id, m.lang) if err != nil { m.setFinished(err, true) return err @@ -184,7 +186,7 @@ func (m *migrationManager) isRunning() bool { return m.runningMigration != "" } -func (m *migrationManager) getOrCreateMigration(rootPath, id string) *migration { +func (m *migrationManager) getOrCreateMigration(rootPath, id, lang string) *migration { m.Lock() defer m.Unlock() if m.migrations == nil { @@ -194,14 +196,14 @@ func (m *migrationManager) getOrCreateMigration(rootPath, id string) *migration sqlitePath := filepath.Join(rootPath, id, config.SpaceStoreSqlitePath) baderPath := filepath.Join(rootPath, id, config.SpaceStoreBadgerPath) if anyPathExists([]string{sqlitePath, baderPath}) { - m.migrations[id] = newMigration(m, id) + m.migrations[id] = newMigration(m, id, lang) } else { - m.migrations[id] = newSuccessfulMigration(m, id) + m.migrations[id] = newSuccessfulMigration(m, id, lang) } } if m.migrations[id].finished() && !m.migrations[id].successful() { // resetting migration - m.migrations[id] = newMigration(m, id) + m.migrations[id] = newMigration(m, id, lang) } return m.migrations[id] } diff --git a/core/application/application.go b/core/application/application.go index ceabeb78d..293ceef8b 100644 --- a/core/application/application.go +++ b/core/application/application.go @@ -25,12 +25,13 @@ type Service struct { // memoized private key derived from mnemonic, used for signing session tokens sessionSigningKey []byte - rootPath string - clientWithVersion string - eventSender event.Sender - sessions session.Service - traceRecorder *traceRecorder - migrationManager *migrationManager + rootPath string + fulltextPrimaryLanguage string + clientWithVersion string + eventSender event.Sender + sessions session.Service + traceRecorder *traceRecorder + migrationManager *migrationManager appAccountStartInProcessCancel context.CancelFunc appAccountStartInProcessCancelMutex sync.Mutex diff --git a/core/application/wallet_create.go b/core/application/wallet_create.go index d43f6c1ff..c634343b9 100644 --- a/core/application/wallet_create.go +++ b/core/application/wallet_create.go @@ -17,6 +17,7 @@ func (s *Service) WalletCreate(req *pb.RpcWalletCreateRequest) (string, error) { defer s.lock.Unlock() s.rootPath = req.RootPath + s.fulltextPrimaryLanguage = req.FulltextPrimaryLanguage err := os.MkdirAll(s.rootPath, 0700) if err != nil { diff --git a/core/application/wallet_recover.go b/core/application/wallet_recover.go index 800ea4dcc..fca3475ff 100644 --- a/core/application/wallet_recover.go +++ b/core/application/wallet_recover.go @@ -32,5 +32,6 @@ func (s *Service) WalletRecover(req *pb.RpcWalletRecoverRequest) error { return err } s.rootPath = req.RootPath + s.fulltextPrimaryLanguage = req.FulltextPrimaryLanguage return nil } diff --git a/core/block/editor/factory.go b/core/block/editor/factory.go index 8c282d09b..d6860c54e 100644 --- a/core/block/editor/factory.go +++ b/core/block/editor/factory.go @@ -176,11 +176,12 @@ func (f *ObjectFactory) New(space smartblock.Space, sbType coresb.SmartBlockType coresb.SmartBlockTypeDate, coresb.SmartBlockTypeBundledRelation, coresb.SmartBlockTypeBundledObjectType, - coresb.SmartBlockTypeObjectType, coresb.SmartBlockTypeRelation, coresb.SmartBlockTypeRelationOption, coresb.SmartBlockTypeChatObject: return f.newPage(space.Id(), sb), nil + case coresb.SmartBlockTypeObjectType: + return f.newObjectType(space.Id(), sb), nil case coresb.SmartBlockTypeArchive: return NewArchive(sb, store), nil case coresb.SmartBlockTypeHome: diff --git a/core/block/editor/objecttype.go b/core/block/editor/objecttype.go new file mode 100644 index 000000000..890762e50 --- /dev/null +++ b/core/block/editor/objecttype.go @@ -0,0 +1,442 @@ +package editor + +import ( + "context" + "errors" + "fmt" + "slices" + + "github.com/anyproto/any-sync/app/ocache" + + "github.com/anyproto/anytype-heart/core/block/editor/basic" + "github.com/anyproto/anytype-heart/core/block/editor/clipboard" + "github.com/anyproto/anytype-heart/core/block/editor/dataview" + "github.com/anyproto/anytype-heart/core/block/editor/file" + "github.com/anyproto/anytype-heart/core/block/editor/smartblock" + "github.com/anyproto/anytype-heart/core/block/editor/state" + "github.com/anyproto/anytype-heart/core/block/editor/stext" + "github.com/anyproto/anytype-heart/core/block/editor/template" + "github.com/anyproto/anytype-heart/core/block/migration" + "github.com/anyproto/anytype-heart/core/block/simple" + "github.com/anyproto/anytype-heart/core/block/source" + "github.com/anyproto/anytype-heart/core/domain" + "github.com/anyproto/anytype-heart/core/relationutils" + "github.com/anyproto/anytype-heart/pb" + "github.com/anyproto/anytype-heart/pkg/lib/bundle" + coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock" + "github.com/anyproto/anytype-heart/pkg/lib/database" + "github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore/spaceindex" + "github.com/anyproto/anytype-heart/pkg/lib/pb/model" + "github.com/anyproto/anytype-heart/util/pbtypes" +) + +var typeRequiredRelations = append(typeAndRelationRequiredRelations, + bundle.RelationKeyRecommendedRelations, + bundle.RelationKeyRecommendedFeaturedRelations, + bundle.RelationKeyRecommendedHiddenRelations, + bundle.RelationKeyRecommendedFileRelations, + bundle.RelationKeyRecommendedLayout, + bundle.RelationKeySmartblockTypes, + bundle.RelationKeyIconOption, + bundle.RelationKeyIconName, +) + +type ObjectType struct { + smartblock.SmartBlock + basic.AllOperations + basic.IHistory + stext.Text + clipboard.Clipboard + source.ChangeReceiver + dataview.Dataview + + spaceIndex spaceindex.Store +} + +func (f *ObjectFactory) newObjectType(spaceId string, sb smartblock.SmartBlock) *ObjectType { + store := f.objectStore.SpaceIndex(spaceId) + fileComponent := file.NewFile(sb, f.fileBlockService, f.picker, f.processService, f.fileUploaderService) + return &ObjectType{ + SmartBlock: sb, + ChangeReceiver: sb.(source.ChangeReceiver), + AllOperations: basic.NewBasic(sb, store, f.layoutConverter, f.fileObjectService), + IHistory: basic.NewHistory(sb), + Text: stext.NewText( + sb, + store, + f.eventSender, + ), + Clipboard: clipboard.NewClipboard( + sb, + fileComponent, + f.tempDirProvider, + store, + f.fileService, + f.fileObjectService, + ), + Dataview: dataview.NewDataview(sb, store), + + spaceIndex: store, + } +} + +func (ot *ObjectType) Init(ctx *smartblock.InitContext) (err error) { + ctx.RequiredInternalRelationKeys = append(ctx.RequiredInternalRelationKeys, typeRequiredRelations...) + + if err = ot.SmartBlock.Init(ctx); err != nil { + return + } + + ot.AddHook(ot.syncLayoutForObjectsAndTemplates, smartblock.HookAfterApply) + return nil +} + +func (ot *ObjectType) CreationStateMigration(ctx *smartblock.InitContext) migration.Migration { + return migration.Migration{ + Version: 2, + Proc: func(s *state.State) { + if len(ctx.ObjectTypeKeys) > 0 && len(ctx.State.ObjectTypeKeys()) == 0 { + ctx.State.SetObjectTypeKeys(ctx.ObjectTypeKeys) + } + + templates := []template.StateTransformer{ + template.WithEmpty, + template.WithObjectTypes(ctx.State.ObjectTypeKeys()), + template.WithTitle, + template.WithLayout(model.ObjectType_objectType), + } + + template.InitTemplate(s, templates...) + }, + } +} + +func (ot *ObjectType) StateMigrations() migration.Migrations { + return migration.MakeMigrations([]migration.Migration{ + { + Version: 2, + Proc: func(s *state.State) {}, + }, + { + Version: 3, + Proc: ot.featuredRelationsMigration, + }, + }) +} + +func (ot *ObjectType) featuredRelationsMigration(s *state.State) { + if ot.Type() != coresb.SmartBlockTypeObjectType { + return + } + + if s.HasRelation(bundle.RelationKeyRecommendedFeaturedRelations.String()) { + return + } + + featuredRelationKeys := relationutils.DefaultFeaturedRelationKeys() + featuredRelationIds := make([]string, 0, len(featuredRelationKeys)) + for _, key := range featuredRelationKeys { + id, err := ot.Space().DeriveObjectID(context.Background(), domain.MustUniqueKey(coresb.SmartBlockTypeRelation, key.String())) + if err != nil { + log.Errorf("failed to derive object id: %v", err) + continue + } + featuredRelationIds = append(featuredRelationIds, id) + } + + if len(featuredRelationIds) == 0 { + return + } + + s.SetDetail(bundle.RelationKeyRecommendedFeaturedRelations, domain.StringList(featuredRelationIds)) + + recommendedRelations := s.Details().GetStringList(bundle.RelationKeyRecommendedRelations) + oldLen := len(recommendedRelations) + recommendedRelations = slices.DeleteFunc(recommendedRelations, func(s string) bool { + return slices.Contains(featuredRelationIds, s) + }) + + if oldLen == len(recommendedRelations) { + return + } + + s.SetDetail(bundle.RelationKeyRecommendedRelations, domain.StringList(recommendedRelations)) +} + +type layoutState struct { + layout int64 + layoutAlign int64 + featuredRelations []string + + isLayoutSet bool + isLayoutAlignSet bool + isFeaturedRelationsSet bool +} + +func (ls layoutState) isAllSet() bool { + return ls.isLayoutSet && ls.isLayoutAlignSet && ls.isFeaturedRelationsSet +} + +func (ls layoutState) isAnySet() bool { + return ls.isLayoutSet || ls.isLayoutAlignSet || ls.isFeaturedRelationsSet +} + +type relationIdDeriver struct { + space smartblock.Space + cache map[domain.RelationKey]string +} + +func (d *relationIdDeriver) deriveId(key domain.RelationKey) (string, error) { + if d.cache != nil { + if id, found := d.cache[key]; found { + return id, nil + } + } + + id, err := d.space.DeriveObjectID(context.Background(), domain.MustUniqueKey(coresb.SmartBlockTypeRelation, key.String())) + if err != nil { + return "", fmt.Errorf("failed to derive relation id: %w", err) + } + + if d.cache == nil { + d.cache = map[domain.RelationKey]string{} + } + d.cache[key] = id + return id, nil +} + +func (ot *ObjectType) syncLayoutForObjectsAndTemplates(info smartblock.ApplyInfo) error { + newLayout := getLayoutStateFromMessages(info.Events) + if newLayout.isLayoutSet && !isLayoutChangeApplicable(newLayout.layout) { + // if layout change is not applicable, then it is init of some system type. Objects' layout should not be modified + newLayout.isLayoutSet = false + } + + if !newLayout.isAnySet() { + // layout details were not changed + return nil + } + + oldLayout := getLayoutStateFromParent(info.ParentState) + + records, err := ot.queryObjectsAndTemplates() + if err != nil { + return err + } + + var ( + resultErr error + deriver = relationIdDeriver{space: ot.Space()} + ) + + for _, record := range records { + id := record.Details.GetString(bundle.RelationKeyId) + if id == "" { + continue + } + + changes := collectRelationsChanges(record.Details, newLayout, oldLayout, deriver) + if len(changes.relationsToRemove) > 0 || changes.isFeaturedRelationsChanged { + // we should modify not local relations from object, that's why we apply changes even if object is not in cache + err = ot.Space().Do(id, func(b smartblock.SmartBlock) error { + st := b.NewState() + st.RemoveDetail(changes.relationsToRemove...) + if changes.isFeaturedRelationsChanged { + st.SetDetail(bundle.RelationKeyFeaturedRelations, domain.StringList(changes.newFeaturedRelations)) + } + return b.Apply(st) + }) + if err != nil { + resultErr = errors.Join(resultErr, err) + } + continue + } + + if changes.isLayoutFound || !newLayout.isLayoutSet || record.Details.GetInt64(bundle.RelationKeyResolvedLayout) == newLayout.layout { + // layout detail remains in object or recommendedLayout was not changed or relevant layout is already set, skipping + continue + } + + err = ot.Space().DoLockedIfNotExists(id, func() error { + return ot.spaceIndex.ModifyObjectDetails(id, func(details *domain.Details) (*domain.Details, bool, error) { + if details == nil { + return nil, false, nil + } + if details.GetInt64(bundle.RelationKeyResolvedLayout) == newLayout.layout { + return nil, false, nil + } + details.Set(bundle.RelationKeyResolvedLayout, domain.Int64(newLayout.layout)) + return details, true, nil + }) + }) + + if err == nil { + continue + } + + if !errors.Is(err, ocache.ErrExists) { + resultErr = errors.Join(resultErr, err) + continue + } + + if err = ot.Space().Do(id, func(b smartblock.SmartBlock) error { + if cr, ok := b.(source.ChangeReceiver); ok { + // we can do StateAppend here, so resolvedLayout will be injected automatically + return cr.StateAppend(func(d state.Doc) (s *state.State, changes []*pb.ChangeContent, err error) { + return d.NewState(), nil, nil + }) + } + return nil + }); err != nil { + resultErr = errors.Join(resultErr, err) + } + } + + if resultErr != nil { + return fmt.Errorf("failed to change layout details for objects: %w", resultErr) + } + return nil +} + +func isLayoutChangeApplicable(layout int64) bool { + return slices.Contains([]model.ObjectTypeLayout{ + model.ObjectType_basic, + model.ObjectType_todo, + model.ObjectType_profile, + model.ObjectType_note, + model.ObjectType_collection, + }, model.ObjectTypeLayout(layout)) // nolint:gosec +} + +func getLayoutStateFromMessages(msgs []simple.EventMessage) layoutState { + ls := layoutState{} + for _, ev := range msgs { + if amend := ev.Msg.GetObjectDetailsAmend(); amend != nil { + for _, detail := range amend.Details { + switch detail.Key { + case bundle.RelationKeyRecommendedLayout.String(): + ls.layout = int64(detail.Value.GetNumberValue()) + ls.isLayoutSet = true + case bundle.RelationKeyRecommendedFeaturedRelations.String(): + ls.featuredRelations = pbtypes.GetStringListValue(detail.Value) + ls.isFeaturedRelationsSet = true + case bundle.RelationKeyLayoutAlign.String(): + ls.layoutAlign = int64(detail.Value.GetNumberValue()) + ls.isLayoutAlignSet = true + } + } + if ls.isAllSet() { + return ls + } + } + } + return ls +} + +func getLayoutStateFromParent(ps *state.State) layoutState { + ls := layoutState{} + if ps == nil { + return ls + } + + if layout, ok := ps.Details().TryInt64(bundle.RelationKeyRecommendedLayout); ok { + ls.layout = layout + ls.isLayoutSet = true + } + + if layoutAlign, ok := ps.Details().TryInt64(bundle.RelationKeyLayoutAlign); ok { + ls.layoutAlign = layoutAlign + ls.isLayoutAlignSet = true + } + + featuredRelations, ok := ps.Details().TryStringList(bundle.RelationKeyRecommendedFeaturedRelations) + // featuredRelations can present in objects as empty slice or containing only description + if ok && len(featuredRelations) != 0 && !slices.Equal(featuredRelations, []string{bundle.RelationKeyDescription.String()}) { + ls.featuredRelations = featuredRelations + ls.isFeaturedRelationsSet = true + } + return ls +} + +func (ot *ObjectType) queryObjectsAndTemplates() ([]database.Record, error) { + records, err := ot.spaceIndex.Query(database.Query{Filters: []database.FilterRequest{ + { + RelationKey: bundle.RelationKeyType, + Condition: model.BlockContentDataviewFilter_Equal, + Value: domain.String(ot.Id()), + }, + }}) + if err != nil { + return nil, fmt.Errorf("failed to get objects of single type: %w", err) + } + + templates, err := ot.spaceIndex.Query(database.Query{Filters: []database.FilterRequest{ + { + RelationKey: bundle.RelationKeyTargetObjectType, + Condition: model.BlockContentDataviewFilter_Equal, + Value: domain.String(ot.Id()), + }, + }}) + if err != nil { + return nil, fmt.Errorf("failed to get templates with this target type: %w", err) + } + + return append(records, templates...), nil +} + +type layoutRelationsChanges struct { + relationsToRemove []domain.RelationKey + isLayoutFound bool + isFeaturedRelationsChanged bool + newFeaturedRelations []string +} + +func collectRelationsChanges(details *domain.Details, newLayout, oldLayout layoutState, deriver relationIdDeriver) (changes layoutRelationsChanges) { + changes.relationsToRemove = make([]domain.RelationKey, 0, 2) + if newLayout.isLayoutSet { + layout, found := details.TryInt64(bundle.RelationKeyLayout) + if found { + changes.isLayoutFound = true + if layout == newLayout.layout || oldLayout.isLayoutSet && layout == oldLayout.layout { + changes.relationsToRemove = append(changes.relationsToRemove, bundle.RelationKeyLayout) + } + } + } + + if newLayout.isLayoutAlignSet { + layoutAlign, found := details.TryInt64(bundle.RelationKeyLayoutAlign) + if found && (layoutAlign == newLayout.layoutAlign || oldLayout.isLayoutAlignSet && layoutAlign == oldLayout.layoutAlign) { + changes.relationsToRemove = append(changes.relationsToRemove, bundle.RelationKeyLayoutAlign) + } + } + + if newLayout.isFeaturedRelationsSet { + featuredRelations, found := details.TryStringList(bundle.RelationKeyFeaturedRelations) + if found && isFeaturedRelationsCorrespondToType(featuredRelations, newLayout, oldLayout, deriver) { + changes.isFeaturedRelationsChanged = true + changes.newFeaturedRelations = []string{} + if slices.Contains(featuredRelations, bundle.RelationKeyDescription.String()) { + changes.newFeaturedRelations = append(changes.newFeaturedRelations, bundle.RelationKeyDescription.String()) + } + } + } + return changes +} + +func isFeaturedRelationsCorrespondToType(fr []string, newLayout, oldLayout layoutState, deriver relationIdDeriver) bool { + featuredRelationIds := make([]string, 0, len(fr)) + for _, key := range fr { + id, err := deriver.deriveId(domain.RelationKey(key)) + if err != nil { + log.Errorf("failed to derive relation key %s", key) + return false // let's fallback to true, so featuredRelations won't be changed + } + featuredRelationIds = append(featuredRelationIds, id) + } + + if newLayout.isFeaturedRelationsSet && slices.Equal(featuredRelationIds, newLayout.featuredRelations) { + return true + } + + return oldLayout.isFeaturedRelationsSet && slices.Equal(featuredRelationIds, oldLayout.featuredRelations) +} diff --git a/core/block/editor/objecttype_test.go b/core/block/editor/objecttype_test.go new file mode 100644 index 000000000..defb91a92 --- /dev/null +++ b/core/block/editor/objecttype_test.go @@ -0,0 +1,401 @@ +package editor + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + + "github.com/anyproto/any-sync/app/ocache" + + "github.com/anyproto/anytype-heart/core/block/editor/smartblock" + "github.com/anyproto/anytype-heart/core/block/editor/smartblock/smarttest" + "github.com/anyproto/anytype-heart/core/block/editor/state" + "github.com/anyproto/anytype-heart/core/block/simple" + "github.com/anyproto/anytype-heart/core/domain" + "github.com/anyproto/anytype-heart/pb" + "github.com/anyproto/anytype-heart/pkg/lib/bundle" + coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock" + "github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore" + "github.com/anyproto/anytype-heart/pkg/lib/pb/model" +) + +const ( + spaceId = "spc" +) + +type fixture struct { + sb *smarttest.SmartTest + store *objectstore.StoreFixture + space *smartblock.MockSpace + *ObjectType +} + +func newFixture(t *testing.T, id string) *fixture { + sb := smarttest.New(id) + store := objectstore.NewStoreFixture(t) + spc := smartblock.NewMockSpace(t) + sb.SetSpace(spc) + page := &ObjectType{ + SmartBlock: sb, + spaceIndex: store.SpaceIndex(spaceId), + } + + return &fixture{ + sb: sb, + store: store, + space: spc, + ObjectType: page, + } +} + +func TestObjectType_syncLayoutForObjectsAndTemplates(t *testing.T) { + typeId := bundle.TypeKeyTask.URL() + t.Run("recommendedLayout is updated", func(t *testing.T) { + // given + fx := newFixture(t, typeId) + fx.sb.SetType(coresb.SmartBlockTypeObjectType) + + fx.store.AddObjects(t, spaceId, []objectstore.TestObject{ + { + bundle.RelationKeyId: domain.String("obj1"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_basic)), + bundle.RelationKeyLayout: domain.Int64(int64(model.ObjectType_basic)), + // layout detail should be deleted from obj1, because its value equals old recommendedLayout value + }, + { + bundle.RelationKeyId: domain.String("obj2"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_todo)), + bundle.RelationKeyLayout: domain.Int64(int64(model.ObjectType_todo)), + // layout detail should be deleted from obj2, because its value equals new recommendedLayout value + }, + { + bundle.RelationKeyId: domain.String("obj3"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_profile)), + bundle.RelationKeyLayout: domain.Int64(int64(model.ObjectType_profile)), + // obj3 should not be modified, because old layout does not correspond to old and new recommendedLayout values + }, + { + bundle.RelationKeyId: domain.String("obj4"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_basic)), + // obj4 does not have layout detail set, so it has nothing to delete + // StateAppend must be called for this object because resolvedLayout must be reinjected + }, + { + bundle.RelationKeyId: domain.String("obj5"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_note)), + // obj5 does not have layout detail set, so it has nothing to delete + // StateAppend must be called for this object because resolvedLayout must be reinjected + }, + { + bundle.RelationKeyId: domain.String("obj6"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_todo)), + // obj6 does not have layout detail set, so it has nothing to delete + // obj6 will not be modified, because it already has correct resolvedLauout value + }, + { + bundle.RelationKeyId: domain.String("tmpl"), + bundle.RelationKeyType: domain.String(bundle.TypeKeyTemplate.URL()), + bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_basic)), + bundle.RelationKeyLayout: domain.Int64(int64(model.ObjectType_basic)), + bundle.RelationKeyTargetObjectType: domain.String(typeId), + // layout detail should be deleted from template, because its value equals old recommendedLayout value + }, + }) + + obj1 := smarttest.New("obj1") + require.NoError(t, obj1.SetDetails(nil, []domain.Detail{{ + Key: bundle.RelationKeyLayout, Value: domain.Int64(int64(model.ObjectType_basic)), + }}, false)) + obj2 := smarttest.New("obj2") + require.NoError(t, obj2.SetDetails(nil, []domain.Detail{{ + Key: bundle.RelationKeyLayout, Value: domain.Int64(int64(model.ObjectType_todo)), + }}, false)) + obj4 := smarttest.New("obj4") + tmpl := smarttest.New("tmpl") + require.NoError(t, tmpl.SetDetails(nil, []domain.Detail{{ + Key: bundle.RelationKeyLayout, Value: domain.Int64(int64(model.ObjectType_basic)), + }}, false)) + + fx.space.EXPECT().DoLockedIfNotExists(mock.Anything, mock.Anything).RunAndReturn(func(id string, f func() error) error { + switch id { + case "obj4": + return ocache.ErrExists + case "obj5": + return f() + default: + panic("DoLockedIfNotExists: invalid object id") + } + }) + + fx.space.EXPECT().Do(mock.Anything, mock.Anything).RunAndReturn(func(id string, f func(smartblock.SmartBlock) error) error { + switch id { + case "obj1": + assert.NoError(t, f(obj1)) + case "obj2": + assert.NoError(t, f(obj2)) + case "obj4": + assert.NoError(t, f(obj4)) + case "tmpl": + assert.NoError(t, f(tmpl)) + default: + panic("Do: invalid object id") + } + return nil + }) + + // when + err := fx.syncLayoutForObjectsAndTemplates(makeApplyInfo(typeId, + // recommendedLayout is changed: basic -> todo + layoutState{isLayoutSet: true, layout: int64(model.ObjectType_basic)}, + layoutState{isLayoutSet: true, layout: int64(model.ObjectType_todo)}, + )) + + // then + assert.NoError(t, err) + + assert.False(t, obj1.Details().Has(bundle.RelationKeyLayout)) + assert.False(t, obj2.Details().Has(bundle.RelationKeyLayout)) + assert.False(t, tmpl.Details().Has(bundle.RelationKeyLayout)) + + assert.True(t, obj4.Results.IsStateAppendCalled) + details, err := fx.spaceIndex.GetDetails("obj5") + require.NoError(t, err) + assert.Equal(t, int64(model.ObjectType_todo), details.GetInt64(bundle.RelationKeyResolvedLayout)) + }) + + t.Run("layoutAlign is updated", func(t *testing.T) { + // given + fx := newFixture(t, typeId) + fx.sb.SetType(coresb.SmartBlockTypeObjectType) + + fx.store.AddObjects(t, spaceId, []objectstore.TestObject{ + { + bundle.RelationKeyId: domain.String("obj1"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyLayoutAlign: domain.Int64(int64(model.Block_AlignLeft)), + // layoutAlign detail should be deleted from obj1, because its value equals old type layoutAlign value + }, + { + bundle.RelationKeyId: domain.String("obj2"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyLayoutAlign: domain.Int64(int64(model.Block_AlignRight)), + // layoutAlign detail should be deleted from obj2, because its value equals new type layoutAlign value + }, + { + bundle.RelationKeyId: domain.String("obj3"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyLayoutAlign: domain.Int64(int64(model.Block_AlignCenter)), + // obj3 should not be modified, because layoutAlign does not correspond to old and new type layoutAlign values + }, + { + bundle.RelationKeyId: domain.String("obj4"), + bundle.RelationKeyType: domain.String(typeId), + // obj4 does not have layoutAlign detail set, so it has nothing to delete + }, + { + bundle.RelationKeyId: domain.String("tmpl"), + bundle.RelationKeyType: domain.String(bundle.TypeKeyTemplate.URL()), + bundle.RelationKeyLayoutAlign: domain.Int64(int64(model.Block_AlignRight)), + bundle.RelationKeyTargetObjectType: domain.String(typeId), + // layoutAlign detail should be deleted from template, because its value equals new type layoutAlign value + }, + }) + + obj1 := smarttest.New("obj1") + require.NoError(t, obj1.SetDetails(nil, []domain.Detail{{ + Key: bundle.RelationKeyLayoutAlign, Value: domain.Int64(int64(model.ObjectType_basic)), + }}, false)) + obj2 := smarttest.New("obj2") + require.NoError(t, obj2.SetDetails(nil, []domain.Detail{{ + Key: bundle.RelationKeyLayoutAlign, Value: domain.Int64(int64(model.ObjectType_todo)), + }}, false)) + tmpl := smarttest.New("tmpl") + require.NoError(t, tmpl.SetDetails(nil, []domain.Detail{{ + Key: bundle.RelationKeyLayoutAlign, Value: domain.Int64(int64(model.ObjectType_basic)), + }}, false)) + + fx.space.EXPECT().Do(mock.Anything, mock.Anything).RunAndReturn(func(id string, f func(smartblock.SmartBlock) error) error { + switch id { + case "obj1": + assert.NoError(t, f(obj1)) + case "obj2": + assert.NoError(t, f(obj2)) + case "tmpl": + assert.NoError(t, f(tmpl)) + default: + panic("Do: invalid object id") + } + return nil + }) + + // when + err := fx.syncLayoutForObjectsAndTemplates(makeApplyInfo(typeId, + // recommendedLayout is changed: basic -> todo + layoutState{isLayoutAlignSet: true, layoutAlign: int64(model.Block_AlignLeft)}, + layoutState{isLayoutAlignSet: true, layoutAlign: int64(model.Block_AlignRight)}, + )) + + // then + assert.NoError(t, err) + + assert.False(t, obj1.Details().Has(bundle.RelationKeyLayoutAlign)) + assert.False(t, obj2.Details().Has(bundle.RelationKeyLayoutAlign)) + assert.False(t, tmpl.Details().Has(bundle.RelationKeyLayoutAlign)) + }) + + t.Run("recommendedFeaturedRelations is updated", func(t *testing.T) { + // given + fx := newFixture(t, typeId) + fx.sb.SetType(coresb.SmartBlockTypeObjectType) + + fx.store.AddObjects(t, spaceId, []objectstore.TestObject{ + { + bundle.RelationKeyId: domain.String("obj1"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyFeaturedRelations: domain.StringList([]string{ + bundle.RelationKeyType.String(), bundle.RelationKeyTag.String(), + }), + // featuredRelations detail should be cleared in obj1, because its value corresponds to old recommendedFeaturedRelations value + }, + { + bundle.RelationKeyId: domain.String("obj2"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyFeaturedRelations: domain.StringList([]string{ + bundle.RelationKeyType.String(), bundle.RelationKeyTag.String(), bundle.RelationKeyCreator.String(), + }), + // featuredRelations detail should be cleared in obj1, because its value corresponds to new recommendedFeaturedRelations value + }, + { + bundle.RelationKeyId: domain.String("obj3"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyFeaturedRelations: domain.StringList([]string{ + bundle.RelationKeyType.String(), bundle.RelationKeyTag.String(), bundle.RelationKeyBacklinks.String(), + }), + // obj3 should not be modified, because featuredRelations does not correspond to old and new recommendedFeaturedRelations values + }, + { + bundle.RelationKeyId: domain.String("obj4"), + bundle.RelationKeyType: domain.String(typeId), + bundle.RelationKeyFeaturedRelations: domain.StringList([]string{ + bundle.RelationKeyDescription.String(), + }), + // featuredRelations of obj4 contains only description, so obj4 has nothing to delete + }, + { + bundle.RelationKeyId: domain.String("tmpl"), + bundle.RelationKeyType: domain.String(bundle.TypeKeyTemplate.URL()), + bundle.RelationKeyFeaturedRelations: domain.StringList([]string{}), + bundle.RelationKeyTargetObjectType: domain.String(typeId), + // featuredRelations of template is empty, so it has nothing to delete + }, + }) + + obj1 := smarttest.New("obj1") + require.NoError(t, obj1.SetDetails(nil, []domain.Detail{{ + Key: bundle.RelationKeyFeaturedRelations, Value: domain.StringList([]string{ + bundle.RelationKeyType.String(), bundle.RelationKeyTag.String(), + }), + }}, false)) + obj2 := smarttest.New("obj2") + require.NoError(t, obj2.SetDetails(nil, []domain.Detail{{ + Key: bundle.RelationKeyFeaturedRelations, Value: domain.StringList([]string{ + bundle.RelationKeyType.String(), bundle.RelationKeyTag.String(), bundle.RelationKeyCreator.String(), + }), + }}, false)) + + fx.space.EXPECT().Do(mock.Anything, mock.Anything).RunAndReturn(func(id string, f func(smartblock.SmartBlock) error) error { + switch id { + case "obj1": + assert.NoError(t, f(obj1)) + case "obj2": + assert.NoError(t, f(obj2)) + default: + panic("Do: invalid object id") + } + return nil + }) + + fx.space.EXPECT().DeriveObjectID(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, key domain.UniqueKey) (string, error) { + return key.Marshal(), nil + }) + + // when + err := fx.syncLayoutForObjectsAndTemplates(makeApplyInfo(typeId, + // recommendedLayout is changed: basic -> todo + layoutState{isFeaturedRelationsSet: true, featuredRelations: []string{ + bundle.RelationKeyType.URL(), bundle.RelationKeyTag.URL(), + }}, + layoutState{isFeaturedRelationsSet: true, featuredRelations: []string{ + bundle.RelationKeyType.URL(), bundle.RelationKeyTag.URL(), bundle.RelationKeyCreator.URL(), + }}, + )) + + // then + assert.NoError(t, err) + + require.True(t, obj1.Details().Has(bundle.RelationKeyFeaturedRelations)) + assert.Empty(t, obj1.Details().GetStringList(bundle.RelationKeyFeaturedRelations)) + require.True(t, obj2.Details().Has(bundle.RelationKeyFeaturedRelations)) + assert.Empty(t, obj2.Details().GetStringList(bundle.RelationKeyFeaturedRelations)) + }) +} + +func makeApplyInfo(typeId string, oldLS, newLS layoutState) smartblock.ApplyInfo { + events := make([]simple.EventMessage, 0, 3) + if newLS.isLayoutSet { + events = append(events, makeObjectDetailsAmendMsg(domain.Detail{ + Key: bundle.RelationKeyRecommendedLayout, + Value: domain.Int64(newLS.layout), + })) + } + + if newLS.isLayoutAlignSet { + events = append(events, makeObjectDetailsAmendMsg(domain.Detail{ + Key: bundle.RelationKeyLayoutAlign, + Value: domain.Int64(newLS.layoutAlign), + })) + } + + if newLS.isFeaturedRelationsSet { + events = append(events, makeObjectDetailsAmendMsg(domain.Detail{ + Key: bundle.RelationKeyRecommendedFeaturedRelations, + Value: domain.StringList(newLS.featuredRelations), + })) + } + + ps := state.NewDoc(typeId, nil).NewState().SetDetails(domain.NewDetails()) + if oldLS.isLayoutSet { + ps.SetDetail(bundle.RelationKeyRecommendedLayout, domain.Int64(oldLS.layout)) + } + if oldLS.isLayoutAlignSet { + ps.SetDetail(bundle.RelationKeyLayoutAlign, domain.Int64(oldLS.layoutAlign)) + } + if oldLS.isFeaturedRelationsSet { + ps.SetDetail(bundle.RelationKeyRecommendedFeaturedRelations, domain.StringList(oldLS.featuredRelations)) + } + + return smartblock.ApplyInfo{ + Events: events, + ParentState: ps, + } +} + +func makeObjectDetailsAmendMsg(detail domain.Detail) simple.EventMessage { + return simple.EventMessage{ + Msg: &pb.EventMessage{Value: &pb.EventMessageValueOfObjectDetailsAmend{ObjectDetailsAmend: &pb.EventObjectDetailsAmend{ + Details: []*pb.EventObjectDetailsAmendKeyValue{{ + Key: detail.Key.String(), + Value: detail.Value.ToProto(), + }}, + }}}, + } +} diff --git a/core/block/editor/page.go b/core/block/editor/page.go index a68bae794..b6951fa6e 100644 --- a/core/block/editor/page.go +++ b/core/block/editor/page.go @@ -1,8 +1,6 @@ package editor import ( - "slices" - "github.com/anyproto/anytype-heart/core/block/editor/basic" "github.com/anyproto/anytype-heart/core/block/editor/bookmark" "github.com/anyproto/anytype-heart/core/block/editor/clipboard" @@ -17,7 +15,6 @@ import ( "github.com/anyproto/anytype-heart/core/block/source" "github.com/anyproto/anytype-heart/core/domain" "github.com/anyproto/anytype-heart/core/files/fileobject" - "github.com/anyproto/anytype-heart/core/relationutils" "github.com/anyproto/anytype-heart/pkg/lib/bundle" coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock" "github.com/anyproto/anytype-heart/pkg/lib/database" @@ -36,7 +33,6 @@ var pageRequiredRelations = []domain.RelationKey{ bundle.RelationKeyLinks, bundle.RelationKeyBacklinks, bundle.RelationKeyMentions, - bundle.RelationKeyLayoutAlign, } var typeAndRelationRequiredRelations = []domain.RelationKey{ @@ -48,17 +44,6 @@ var typeAndRelationRequiredRelations = []domain.RelationKey{ bundle.RelationKeyIsHidden, } -var typeRequiredRelations = append(typeAndRelationRequiredRelations, - bundle.RelationKeyRecommendedRelations, - bundle.RelationKeyRecommendedFeaturedRelations, - bundle.RelationKeyRecommendedHiddenRelations, - bundle.RelationKeyRecommendedFileRelations, - bundle.RelationKeyRecommendedLayout, - bundle.RelationKeySmartblockTypes, - bundle.RelationKeyIconOption, - bundle.RelationKeyIconName, -) - var relationRequiredRelations = append(typeAndRelationRequiredRelations, bundle.RelationKeyRelationFormat, bundle.RelationKeyRelationFormatObjectTypes, @@ -244,11 +229,6 @@ func (p *Page) CreationStateMigration(ctx *smartblock.InitContext) migration.Mig template.WithTitle, template.WithLayout(layout), ) - case model.ObjectType_objectType: - templates = append(templates, - template.WithTitle, - template.WithLayout(layout), - ) case model.ObjectType_chat: templates = append(templates, template.WithTitle, @@ -285,48 +265,5 @@ func (p *Page) StateMigrations() migration.Migrations { Version: 2, Proc: func(s *state.State) {}, }, - { - Version: 3, - Proc: p.featuredRelationsMigration, - }, }) } - -func (p *Page) featuredRelationsMigration(s *state.State) { - if p.Type() != coresb.SmartBlockTypeObjectType { - return - } - - if s.HasRelation(bundle.RelationKeyRecommendedFeaturedRelations.String()) { - return - } - - featuredRelationKeys := relationutils.DefaultFeaturedRelationKeys() - featuredRelationIds := make([]string, 0, len(featuredRelationKeys)) - for _, key := range featuredRelationKeys { - id, err := p.Space().DeriveObjectID(nil, domain.MustUniqueKey(coresb.SmartBlockTypeRelation, key.String())) - if err != nil { - log.Errorf("failed to derive object id: %v", err) - continue - } - featuredRelationIds = append(featuredRelationIds, id) - } - - if len(featuredRelationIds) == 0 { - return - } - - s.SetDetail(bundle.RelationKeyRecommendedFeaturedRelations, domain.StringList(featuredRelationIds)) - - recommendedRelations := s.Details().GetStringList(bundle.RelationKeyRecommendedRelations) - oldLen := len(recommendedRelations) - recommendedRelations = slices.DeleteFunc(recommendedRelations, func(s string) bool { - return slices.Contains(featuredRelationIds, s) - }) - - if oldLen == len(recommendedRelations) { - return - } - - s.SetDetail(bundle.RelationKeyRecommendedRelations, domain.StringList(recommendedRelations)) -} diff --git a/core/block/editor/smartblock/detailsinject_test.go b/core/block/editor/smartblock/detailsinject_test.go index f796027f5..23f21e36e 100644 --- a/core/block/editor/smartblock/detailsinject_test.go +++ b/core/block/editor/smartblock/detailsinject_test.go @@ -6,15 +6,12 @@ import ( "testing" "time" - "github.com/anyproto/any-sync/app/ocache" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" "github.com/anyproto/anytype-heart/core/block/editor/state" "github.com/anyproto/anytype-heart/core/block/simple" "github.com/anyproto/anytype-heart/core/domain" - "github.com/anyproto/anytype-heart/pb" "github.com/anyproto/anytype-heart/pkg/lib/bundle" "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock" "github.com/anyproto/anytype-heart/pkg/lib/localstore/objectstore" @@ -405,113 +402,3 @@ func TestInjectResolvedLayout(t *testing.T) { assert.Equal(t, int64(model.ObjectType_todo), st.LocalDetails().GetInt64(bundle.RelationKeyResolvedLayout)) }) } - -func TestChangeResolvedLayoutForObjects(t *testing.T) { - typeId := "typeId" - t.Run("change resolvedLayout, do not delete layout", func(t *testing.T) { - // given - fx := newFixture(typeId, t) - fx.source.sbType = smartblock.SmartBlockTypeObjectType - - fx.objectStore.AddObjects(t, testSpaceId, []objectstore.TestObject{ - { - bundle.RelationKeyId: domain.String("obj1"), - bundle.RelationKeyType: domain.String(typeId), - bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_basic)), - }, - { - bundle.RelationKeyId: domain.String("obj2"), - bundle.RelationKeyType: domain.String(typeId), - bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_todo)), - }, - { - bundle.RelationKeyId: domain.String("obj3"), - bundle.RelationKeyType: domain.String(typeId), - bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_profile)), - }, - { - bundle.RelationKeyId: domain.String("tmpl"), - bundle.RelationKeyType: domain.String(bundle.TypeKeyTemplate.URL()), - bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_basic)), - bundle.RelationKeyTargetObjectType: domain.String(typeId), - }, - }) - - fx.space.EXPECT().DoLockedIfNotExists(mock.Anything, mock.Anything).RunAndReturn(func(id string, f func() error) error { - if id == "obj1" || id == "tmpl" { - return f() - } - return ocache.ErrExists - }) - - fx.space.EXPECT().Do(mock.Anything, mock.Anything).RunAndReturn(func(id string, f func(SmartBlock) error) error { - assert.Equal(t, "obj3", id) - return nil - }) - - // when - err := fx.changeResolvedLayoutForObjects(makeLayoutChanges(int64(model.ObjectType_todo)), false) - - // then - assert.NoError(t, err) - }) - - t.Run("change resolvedLayout, do not delete layout", func(t *testing.T) { - // given - fx := newFixture(typeId, t) - fx.source.sbType = smartblock.SmartBlockTypeObjectType - - fx.objectStore.AddObjects(t, testSpaceId, []objectstore.TestObject{ - { - bundle.RelationKeyId: domain.String("obj1"), - bundle.RelationKeyType: domain.String(typeId), - bundle.RelationKeyLayout: domain.Int64(int64(model.ObjectType_basic)), - }, - { - bundle.RelationKeyId: domain.String("obj2"), - bundle.RelationKeyType: domain.String(typeId), - bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_todo)), - bundle.RelationKeyLayout: domain.Int64(int64(model.ObjectType_todo)), - }, - { - bundle.RelationKeyId: domain.String("obj3"), - bundle.RelationKeyType: domain.String(typeId), - bundle.RelationKeyLayout: domain.Int64(int64(model.ObjectType_profile)), - }, - { - bundle.RelationKeyId: domain.String("obj4"), - bundle.RelationKeyType: domain.String(typeId), - bundle.RelationKeyResolvedLayout: domain.Int64(int64(model.ObjectType_note)), - }, - }) - - fx.space.EXPECT().DoLockedIfNotExists(mock.Anything, mock.Anything).RunAndReturn(func(id string, f func() error) error { - assert.Equal(t, "obj4", id) - return f() - }) - - counter := 0 - fx.space.EXPECT().Do(mock.Anything, mock.Anything).RunAndReturn(func(id string, f func(SmartBlock) error) error { - counter++ - return nil - }) - - // when - err := fx.changeResolvedLayoutForObjects(makeLayoutChanges(int64(model.ObjectType_todo)), true) - - // then - assert.NoError(t, err) - assert.Equal(t, 3, counter) - }) -} - -func makeLayoutChanges(layout int64) []simple.EventMessage { - return []simple.EventMessage{{ - Msg: &pb.EventMessage{Value: &pb.EventMessageValueOfObjectDetailsAmend{ObjectDetailsAmend: &pb.EventObjectDetailsAmend{ - Details: []*pb.EventObjectDetailsAmendKeyValue{{ - Key: bundle.RelationKeyRecommendedLayout.String(), - Value: domain.Int64(layout).ToProto(), - }, - }}}}, - }} -} diff --git a/core/block/editor/smartblock/smartblock.go b/core/block/editor/smartblock/smartblock.go index f23821249..fcc8e203e 100644 --- a/core/block/editor/smartblock/smartblock.go +++ b/core/block/editor/smartblock/smartblock.go @@ -69,9 +69,10 @@ const ( type Hook int type ApplyInfo struct { - State *state.State - Events []simple.EventMessage - Changes []*pb.ChangeContent + State *state.State + ParentState *state.State + Events []simple.EventMessage + Changes []*pb.ChangeContent } type HookCallback func(info ApplyInfo) (err error) @@ -699,7 +700,8 @@ func (sb *smartBlock) Apply(s *state.State, flags ...ApplyFlag) (err error) { } migrationVersionUpdated := true - if parent := s.ParentState(); parent != nil { + parent := s.ParentState() + if parent != nil { migrationVersionUpdated = s.MigrationVersion() != parent.MigrationVersion() } @@ -708,10 +710,6 @@ func (sb *smartBlock) Apply(s *state.State, flags ...ApplyFlag) (err error) { return } - if err = sb.changeResolvedLayoutForObjects(msgs, true); err != nil { - return - } - // we may have layout changed, so we need to update restrictions sb.updateRestrictions() sb.setRestrictionsDetail(s) @@ -816,7 +814,12 @@ func (sb *smartBlock) Apply(s *state.State, flags ...ApplyFlag) (err error) { sb.CheckSubscriptions() } if hooks { - if e := sb.execHooks(HookAfterApply, ApplyInfo{State: sb.Doc.(*state.State), Events: msgs, Changes: changes}); e != nil { + if e := sb.execHooks(HookAfterApply, ApplyInfo{ + State: sb.Doc.(*state.State), + ParentState: parent, + Events: msgs, + Changes: changes, + }); e != nil { log.With("objectID", sb.Id()).Warnf("after apply execHooks error: %v", e) } } @@ -945,10 +948,6 @@ func (sb *smartBlock) StateAppend(f func(d state.Doc) (s *state.State, changes [ } log.Infof("changes: stateAppend: %d events", len(msgs)) - if err = sb.changeResolvedLayoutForObjects(msgs, true); err != nil { - return err - } - if len(msgs) > 0 { sb.sendEvent(&pb.Event{ Messages: msgsToEvents(msgs), @@ -960,7 +959,14 @@ func (sb *smartBlock) StateAppend(f func(d state.Doc) (s *state.State, changes [ sb.CheckSubscriptions() } sb.runIndexer(s) - sb.execHooks(HookAfterApply, ApplyInfo{State: s, Events: msgs, Changes: changes}) + if err = sb.execHooks(HookAfterApply, ApplyInfo{ + State: s, + ParentState: s.ParentState(), + Events: msgs, + Changes: changes, + }); err != nil { + log.Errorf("failed to execute smartblock hooks after apply on StateAppend: %v", err) + } return nil } diff --git a/core/block/editor/smartblock/smarttest/smarttest.go b/core/block/editor/smartblock/smarttest/smarttest.go index 45daaf46c..2b2e80da8 100644 --- a/core/block/editor/smartblock/smarttest/smarttest.go +++ b/core/block/editor/smartblock/smarttest/smarttest.go @@ -367,7 +367,8 @@ func (st *SmartTest) StateRebuild(d state.Doc) (err error) { } func (st *SmartTest) StateAppend(func(d state.Doc) (s *state.State, changes []*pb.ChangeContent, err error)) error { - panic("not implemented") + st.Results.IsStateAppendCalled = true + return nil } func (st *SmartTest) AddBlock(b simple.Block) *SmartTest { @@ -423,6 +424,7 @@ func (st *SmartTest) Update(ctx session.Context, apply func(b simple.Block) erro } type Results struct { - Events [][]simple.EventMessage - Applies [][]*model.Block + Events [][]simple.EventMessage + Applies [][]*model.Block + IsStateAppendCalled bool } diff --git a/core/block/export/export.go b/core/block/export/export.go index 66eec2b14..78983bdda 100644 --- a/core/block/export/export.go +++ b/core/block/export/export.go @@ -164,6 +164,9 @@ type exportContext struct { linkStateFilters *state.Filters isLinkProcess bool includeBackLinks bool + relations map[string]struct{} + setOfList map[string]struct{} + objectTypes map[string]struct{} *export } @@ -182,7 +185,11 @@ func newExportContext(e *export, req pb.RpcObjectListExportRequest) *exportConte zip: req.Zip, linkStateFilters: pbFiltersToState(req.LinksStateFilters), includeBackLinks: req.IncludeBacklinks, - export: e, + setOfList: make(map[string]struct{}), + objectTypes: make(map[string]struct{}), + relations: make(map[string]struct{}), + + export: e, } return ec } @@ -201,6 +208,9 @@ func (e *exportContext) copy() *exportContext { isLinkProcess: e.isLinkProcess, linkStateFilters: e.linkStateFilters, includeBackLinks: e.includeBackLinks, + relations: e.relations, + setOfList: e.setOfList, + objectTypes: e.objectTypes, } } @@ -524,70 +534,75 @@ func (e *exportContext) processFiles(ids []string) ([]string, error) { func (e *exportContext) addDerivedObjects() error { processedObjects := make(map[string]struct{}, 0) - allRelations, allTypes, allSetOfList, err := e.getRelationsAndTypes(e.docs, processedObjects) + err := e.getRelationsAndTypes(e.docs, processedObjects) if err != nil { return err } - templateRelations, templateTypes, templateSetOfList, err := e.getTemplatesRelationsAndTypes(lo.Union(allTypes, allSetOfList), processedObjects) + + err = e.getTemplatesRelationsAndTypes(processedObjects) if err != nil { return err } - allRelations = lo.Union(allRelations, templateRelations) - allTypes = lo.Union(allTypes, templateTypes) - allSetOfList = lo.Union(allSetOfList, templateSetOfList) - err = e.addRelationsAndTypes(allTypes, allRelations, allSetOfList) + err = e.addRelationsAndTypes() if err != nil { return err } return nil } -func (e *exportContext) getRelationsAndTypes(notProcessedObjects map[string]*Doc, processedObjects map[string]struct{}) ([]string, []string, []string, error) { - allRelations, allTypes, allSetOfList, err := e.collectDerivedObjects(notProcessedObjects) +func (e *exportContext) getRelationsAndTypes(notProcessedObjects map[string]*Doc, processedObjects map[string]struct{}) error { + err := e.collectDerivedObjects(notProcessedObjects) if err != nil { - return nil, nil, nil, err + return err } // get derived objects only from types, // because relations currently have only system relations and object type - if len(allTypes) > 0 || len(allSetOfList) > 0 { - relations, objectTypes, setOfList, err := e.getDerivedObjectsForTypes(lo.Union(allTypes, allSetOfList), processedObjects) + if len(e.objectTypes) > 0 || len(e.setOfList) > 0 { + err = e.getDerivedObjectsForTypes(processedObjects) if err != nil { - return nil, nil, nil, err + return err } - allRelations = lo.Union(allRelations, relations) - allTypes = lo.Union(allTypes, objectTypes) - allSetOfList = lo.Union(allSetOfList, setOfList) } - return allRelations, allTypes, allSetOfList, nil + return nil } -func (e *exportContext) collectDerivedObjects(objects map[string]*Doc) ([]string, []string, []string, error) { - var relations, objectsTypes, setOf []string +func (e *exportContext) collectDerivedObjects(objects map[string]*Doc) error { for id := range objects { err := cache.Do(e.picker, id, func(b sb.SmartBlock) error { state := b.NewState().Copy().Filter(e.getStateFilters(id)) - relations = lo.Union(relations, getObjectRelations(state)) + objectRelations := getObjectRelations(state) + fillObjectsMap(e.relations, objectRelations) details := state.CombinedDetails() if isObjectWithDataview(details) { dataviewRelations, err := getDataviewRelations(state) if err != nil { return err } - relations = lo.Union(relations, dataviewRelations) + fillObjectsMap(e.relations, dataviewRelations) } + var objectTypes []string if details.Has(bundle.RelationKeyType) { - objectTypeId := details.GetString(bundle.RelationKeyType) - objectsTypes = lo.Union(objectsTypes, []string{objectTypeId}) + objectTypes = append(objectTypes, details.GetString(bundle.RelationKeyType)) } + if details.Has(bundle.RelationKeyTargetObjectType) { + objectTypes = append(objectTypes, details.GetString(bundle.RelationKeyTargetObjectType)) + } + fillObjectsMap(e.objectTypes, objectTypes) setOfList := details.GetStringList(bundle.RelationKeySetOf) - setOf = lo.Union(setOf, setOfList) + fillObjectsMap(e.setOfList, setOfList) return nil }) if err != nil { - return nil, nil, nil, err + return err } } - return relations, objectsTypes, setOf, nil + return nil +} + +func fillObjectsMap(dst map[string]struct{}, objectsToAdd []string) { + for _, objectId := range objectsToAdd { + dst[objectId] = struct{}{} + } } func getObjectRelations(state *state.State) []string { @@ -619,33 +634,40 @@ func getDataviewRelations(state *state.State) ([]string, error) { return relations, err } -func (e *exportContext) getDerivedObjectsForTypes(allTypes []string, processedObjects map[string]struct{}) ([]string, []string, []string, error) { +func (e *exportContext) getDerivedObjectsForTypes(processedObjects map[string]struct{}) error { notProceedTypes := make(map[string]*Doc) - var relations, objectTypes []string - for _, object := range allTypes { - if _, ok := processedObjects[object]; ok { - continue - } - notProceedTypes[object] = nil - processedObjects[object] = struct{}{} + for object := range e.objectTypes { + e.fillNotProcessedTypes(processedObjects, object, notProceedTypes) + } + for object := range e.setOfList { + e.fillNotProcessedTypes(processedObjects, object, notProceedTypes) } if len(notProceedTypes) == 0 { - return relations, objectTypes, nil, nil + return nil } - relations, objectTypes, setOfList, err := e.getRelationsAndTypes(notProceedTypes, processedObjects) + err := e.getRelationsAndTypes(notProceedTypes, processedObjects) if err != nil { - return nil, nil, nil, err + return err } - return relations, objectTypes, setOfList, nil + return nil } -func (e *exportContext) getTemplatesRelationsAndTypes(allTypes []string, processedObjects map[string]struct{}) ([]string, []string, []string, error) { +func (e *exportContext) fillNotProcessedTypes(processedObjects map[string]struct{}, object string, notProceedTypes map[string]*Doc) { + if _, ok := processedObjects[object]; ok { + return + } + notProceedTypes[object] = nil + processedObjects[object] = struct{}{} +} + +func (e *exportContext) getTemplatesRelationsAndTypes(processedObjects map[string]struct{}) error { + allTypes := lo.MapToSlice(e.objectTypes, func(key string, value struct{}) string { return key }) templates, err := e.queryAndFilterObjectsByRelation(e.spaceId, allTypes, bundle.RelationKeyTargetObjectType) if err != nil { - return nil, nil, nil, err + return nil } if len(templates) == 0 { - return nil, nil, nil, nil + return nil } templatesToProcess := make(map[string]*Doc, len(templates)) for _, template := range templates { @@ -656,14 +678,18 @@ func (e *exportContext) getTemplatesRelationsAndTypes(allTypes []string, process templatesToProcess[id] = templateDoc } } - templateRelations, templateType, templateSetOfList, err := e.getRelationsAndTypes(templatesToProcess, processedObjects) + err = e.getRelationsAndTypes(templatesToProcess, processedObjects) if err != nil { - return nil, nil, nil, err + return err } - return templateRelations, templateType, templateSetOfList, nil + return nil } -func (e *exportContext) addRelationsAndTypes(types, relations, setOfList []string) error { +func (e *exportContext) addRelationsAndTypes() error { + types := lo.MapToSlice(e.objectTypes, func(key string, value struct{}) string { return key }) + setOfList := lo.MapToSlice(e.setOfList, func(key string, value struct{}) string { return key }) + relations := lo.MapToSlice(e.relations, func(key string, value struct{}) string { return key }) + err := e.addRelations(relations) if err != nil { return err diff --git a/core/block/export/export_test.go b/core/block/export/export_test.go index badd57e65..a9d70d2cd 100644 --- a/core/block/export/export_test.go +++ b/core/block/export/export_test.go @@ -947,10 +947,10 @@ func Test_docsForExport(t *testing.T) { relationKey := domain.RelationKey("key") storeFixture.AddObjects(t, spaceId, []objectstore.TestObject{ { - bundle.RelationKeyId: domain.String("id"), - domain.RelationKey(relationKey): domain.String("value"), - bundle.RelationKeyType: domain.String("objectType"), - bundle.RelationKeySpaceId: domain.String(spaceId), + bundle.RelationKeyId: domain.String("id"), + relationKey: domain.String("value"), + bundle.RelationKeyType: domain.String("objectType"), + bundle.RelationKeySpaceId: domain.String(spaceId), }, }) err := storeFixture.SpaceIndex(spaceId).UpdateObjectLinks(context.Background(), "id", []string{"id1"}) @@ -1016,10 +1016,10 @@ func Test_docsForExport(t *testing.T) { storeFixture.AddObjects(t, spaceId, []objectstore.TestObject{ { - bundle.RelationKeyId: domain.String("id"), - domain.RelationKey(relationKey): domain.String("value"), - bundle.RelationKeyType: domain.String("objectType"), - bundle.RelationKeySpaceId: domain.String(spaceId), + bundle.RelationKeyId: domain.String("id"), + relationKey: domain.String("value"), + bundle.RelationKeyType: domain.String("objectType"), + bundle.RelationKeySpaceId: domain.String(spaceId), }, { bundle.RelationKeyId: domain.String(relationKey), @@ -1093,10 +1093,10 @@ func Test_docsForExport(t *testing.T) { storeFixture.AddObjects(t, spaceId, []objectstore.TestObject{ { - bundle.RelationKeyId: domain.String("id"), - domain.RelationKey(relationKey): domain.String("value"), - bundle.RelationKeyType: domain.String("objectType"), - bundle.RelationKeySpaceId: domain.String(spaceId), + bundle.RelationKeyId: domain.String("id"), + relationKey: domain.String("value"), + bundle.RelationKeyType: domain.String("objectType"), + bundle.RelationKeySpaceId: domain.String(spaceId), }, { bundle.RelationKeyId: domain.String(relationKey), @@ -1172,10 +1172,10 @@ func Test_docsForExport(t *testing.T) { storeFixture.AddObjects(t, spaceId, []objectstore.TestObject{ { - bundle.RelationKeyId: domain.String("id"), - domain.RelationKey(relationKey): domain.String(optionId), - bundle.RelationKeyType: domain.String("objectType"), - bundle.RelationKeySpaceId: domain.String(spaceId), + bundle.RelationKeyId: domain.String("id"), + relationKey: domain.String(optionId), + bundle.RelationKeyType: domain.String("objectType"), + bundle.RelationKeySpaceId: domain.String(spaceId), }, { bundle.RelationKeyId: domain.String(relationKey), @@ -1967,6 +1967,106 @@ func Test_docsForExport(t *testing.T) { assert.Nil(t, err) assert.Equal(t, 5, len(expCtx.docs)) }) + t.Run("export template", func(t *testing.T) { + // given + storeFixture := objectstore.NewStoreFixture(t) + objectTypeKey := "customObjectType" + objectTypeUniqueKey, err := domain.NewUniqueKey(smartblock.SmartBlockTypeObjectType, objectTypeKey) + assert.Nil(t, err) + + templateType := "templateType" + templateObjectTypeUniqueKey, err := domain.NewUniqueKey(smartblock.SmartBlockTypeObjectType, templateType) + assert.Nil(t, err) + + objectId := "objectId" + storeFixture.AddObjects(t, spaceId, []objectstore.TestObject{ + { + bundle.RelationKeyId: domain.String(objectId), + bundle.RelationKeyName: domain.String("template"), + bundle.RelationKeySpaceId: domain.String(spaceId), + bundle.RelationKeyTargetObjectType: domain.String(objectTypeKey), + bundle.RelationKeyType: domain.String(templateType), + }, + { + bundle.RelationKeyId: domain.String(objectTypeKey), + bundle.RelationKeyUniqueKey: domain.String(objectTypeUniqueKey.Marshal()), + bundle.RelationKeyLayout: domain.Int64(int64(model.ObjectType_objectType)), + bundle.RelationKeySpaceId: domain.String(spaceId), + bundle.RelationKeyType: domain.String(objectTypeKey), + }, + { + bundle.RelationKeyId: domain.String(templateType), + bundle.RelationKeyUniqueKey: domain.String(templateObjectTypeUniqueKey.Marshal()), + bundle.RelationKeyLayout: domain.Int64(int64(model.ObjectType_objectType)), + bundle.RelationKeySpaceId: domain.String(spaceId), + bundle.RelationKeyType: domain.String(objectTypeKey), + }, + }) + + smartBlockTest := smarttest.New(objectId) + doc := smartBlockTest.NewState().SetDetails(domain.NewDetailsFromMap(map[domain.RelationKey]domain.Value{ + bundle.RelationKeyId: domain.String(objectId), + bundle.RelationKeyType: domain.String(templateType), + bundle.RelationKeyTargetObjectType: domain.String(objectTypeKey), + })) + doc.AddRelationLinks(&model.RelationLink{ + Key: bundle.RelationKeyId.String(), + Format: model.RelationFormat_longtext, + }) + smartBlockTest.Doc = doc + + objectType := smarttest.New(objectTypeKey) + objectTypeDoc := objectType.NewState().SetDetails(domain.NewDetailsFromMap(map[domain.RelationKey]domain.Value{ + bundle.RelationKeyId: domain.String(objectTypeKey), + bundle.RelationKeyType: domain.String(objectTypeKey), + })) + objectTypeDoc.AddRelationLinks(&model.RelationLink{ + Key: bundle.RelationKeyId.String(), + Format: model.RelationFormat_longtext, + }, &model.RelationLink{ + Key: bundle.RelationKeyType.String(), + Format: model.RelationFormat_longtext, + }) + objectType.Doc = objectTypeDoc + + templateTypeObject := smarttest.New(templateType) + templateTypeObjectDoc := objectType.NewState().SetDetails(domain.NewDetailsFromMap(map[domain.RelationKey]domain.Value{ + bundle.RelationKeyId: domain.String(templateType), + bundle.RelationKeyType: domain.String(templateType), + })) + templateTypeObjectDoc.AddRelationLinks(&model.RelationLink{ + Key: bundle.RelationKeyId.String(), + Format: model.RelationFormat_longtext, + }, &model.RelationLink{ + Key: bundle.RelationKeyType.String(), + Format: model.RelationFormat_longtext, + }) + templateTypeObject.Doc = templateTypeObjectDoc + + objectGetter := mock_cache.NewMockObjectGetter(t) + objectGetter.EXPECT().GetObject(context.Background(), objectId).Return(smartBlockTest, nil) + objectGetter.EXPECT().GetObject(context.Background(), objectTypeKey).Return(objectType, nil) + objectGetter.EXPECT().GetObject(context.Background(), templateType).Return(templateTypeObject, nil) + + e := &export{ + objectStore: storeFixture, + picker: objectGetter, + } + + expCtx := newExportContext(e, pb.RpcObjectListExportRequest{ + SpaceId: spaceId, + ObjectIds: []string{objectId}, + IncludeNested: false, + Format: model.Export_Protobuf, + }) + + // when + err = expCtx.docsForExport() + + // then + assert.Nil(t, err) + assert.Equal(t, 3, len(expCtx.docs)) + }) t.Run("add default object type and template from dataview", func(t *testing.T) { // given id := "id" diff --git a/core/block/import/pb/space.go b/core/block/import/pb/space.go index 44bf37bd2..73e69e29a 100644 --- a/core/block/import/pb/space.go +++ b/core/block/import/pb/space.go @@ -65,7 +65,7 @@ func (s *SpaceImport) ProvideCollection(snapshots []*common.Snapshot, } func (s *SpaceImport) objectShouldBeSkipped(item *common.Snapshot) bool { - return item.Snapshot.SbType == smartblock.SmartBlockTypeSubObject || item.Snapshot.SbType == smartblock.SmartBlockTypeTemplate || + return item.Snapshot.SbType == smartblock.SmartBlockTypeSubObject || item.Snapshot.SbType == smartblock.SmartBlockTypeRelation || item.Snapshot.SbType == smartblock.SmartBlockTypeObjectType || item.Snapshot.SbType == smartblock.SmartBlockTypeRelationOption } diff --git a/core/block/import/pb/space_test.go b/core/block/import/pb/space_test.go index df0b01877..119fa6cbe 100644 --- a/core/block/import/pb/space_test.go +++ b/core/block/import/pb/space_test.go @@ -44,7 +44,7 @@ func TestSpaceImport_ProvideCollection(t *testing.T) { assert.Nil(t, err) assert.Nil(t, collection) }) - t.Run("no widget object - add all objects (except template and subobjects) in Protobuf Import collection", func(t *testing.T) { + t.Run("no widget object - add all objects (except subobjects) in Protobuf Import collection", func(t *testing.T) { // given p := SpaceImport{} params := &pb.RpcObjectImportRequestPbParams{NoCollection: false} @@ -85,9 +85,10 @@ func TestSpaceImport_ProvideCollection(t *testing.T) { assert.Len(t, collection, 1) rootCollectionState := state.NewDocFromSnapshot("", collection[0].Snapshot.ToProto()).(*state.State) objectsInCollection := rootCollectionState.GetStoreSlice(template.CollectionStoreKey) - assert.Len(t, objectsInCollection, 2) + assert.Len(t, objectsInCollection, 3) assert.Equal(t, objectsInCollection[0], "id1") - assert.Equal(t, objectsInCollection[1], "id4") + assert.Equal(t, objectsInCollection[1], "id3") + assert.Equal(t, objectsInCollection[2], "id4") }) t.Run("widget with sets - add only sets in Protobuf Import collection", func(t *testing.T) { // given @@ -106,6 +107,9 @@ func TestSpaceImport_ProvideCollection(t *testing.T) { Id: "id3", Snapshot: &common.SnapshotModel{ SbType: smartblock2.SmartBlockTypeTemplate, + Data: &common.StateSnapshot{ + ObjectTypes: []string{bundle.TypeKeyTemplate.URL()}, + }, }, }, // page @@ -191,6 +195,9 @@ func TestSpaceImport_ProvideCollection(t *testing.T) { Id: "id3", Snapshot: &common.SnapshotModel{ SbType: smartblock2.SmartBlockTypeTemplate, + Data: &common.StateSnapshot{ + ObjectTypes: []string{bundle.TypeKeyTemplate.URL()}, + }, }, }, // page @@ -277,6 +284,9 @@ func TestSpaceImport_ProvideCollection(t *testing.T) { Id: "id3", Snapshot: &common.SnapshotModel{ SbType: smartblock2.SmartBlockTypeTemplate, + Data: &common.StateSnapshot{ + ObjectTypes: []string{bundle.TypeKeyTemplate.URL()}, + }, }, }, // favorite page diff --git a/core/gallery/gallery.go b/core/gallery/gallery.go index 3d0f41f69..13005b72f 100644 --- a/core/gallery/gallery.go +++ b/core/gallery/gallery.go @@ -56,7 +56,6 @@ func DownloadManifest(url string, checkWhitelist bool) (info *model.ManifestInfo if err != nil { return nil, err } - schemaResp := schemaResponse{} err = json.Unmarshal(raw, &schemaResp) if err != nil { @@ -119,7 +118,7 @@ func getRawJson(url string) ([]byte, error) { if err != nil { return nil, err } - + req.Close = true res, err := client.Do(req) if err != nil { return nil, err diff --git a/core/gallery/gallery_test.go b/core/gallery/gallery_test.go index bfe52d64a..90bcecfa7 100644 --- a/core/gallery/gallery_test.go +++ b/core/gallery/gallery_test.go @@ -4,6 +4,7 @@ import ( _ "embed" "encoding/json" "net/http" + "net/http/httptest" "testing" "github.com/stretchr/testify/assert" @@ -11,8 +12,6 @@ import ( "github.com/anyproto/anytype-heart/pkg/lib/pb/model" ) -const port = ":7070" - //go:embed testdata/schema.json var schemaJSON []byte @@ -37,13 +36,13 @@ func TestIsInWhitelist(t *testing.T) { } func TestDownloadManifestAndValidateSchema(t *testing.T) { - schema := schemaResponse{Schema: "http://localhost" + port + "/schema.json"} server := startHttpServer() - defer server.Shutdown(nil) + defer server.Close() + schema := schemaResponse{Schema: server.URL + "/schema.json"} t.Run("download knowledge base manifest", func(t *testing.T) { // given - url := "http://localhost" + port + "/manifest.json" + url := server.URL + "/manifest.json" // when info, err := DownloadManifest(url, false) @@ -116,7 +115,7 @@ func TestDownloadManifestAndValidateSchema(t *testing.T) { }) } -func startHttpServer() *http.Server { +func startHttpServer() *httptest.Server { handler := http.NewServeMux() handler.HandleFunc("/manifest.json", func(w http.ResponseWriter, _ *http.Request) { w.Header().Set("Content-Type", "application/json") @@ -128,9 +127,7 @@ func startHttpServer() *http.Server { w.Header().Set("Content-Type", "application/json") _, _ = w.Write(schemaJSON) }) - server := &http.Server{Addr: port, Handler: handler} - go server.ListenAndServe() - return server + return httptest.NewServer(handler) } func buildInfo() *model.ManifestInfo { diff --git a/core/subscription/service.go b/core/subscription/service.go index ae7b8ea85..c59e203b9 100644 --- a/core/subscription/service.go +++ b/core/subscription/service.go @@ -33,7 +33,7 @@ const CName = "subscription" var log = logging.Logger("anytype-mw-subscription") -var batchTime = 50 * time.Millisecond +var batchTime = 250 * time.Millisecond func New() Service { return &service{} diff --git a/core/syncstatus/syncsubscriptions/syncsubscriptions_test.go b/core/syncstatus/syncsubscriptions/syncsubscriptions_test.go index 452ab78f5..cbefc9e54 100644 --- a/core/syncstatus/syncsubscriptions/syncsubscriptions_test.go +++ b/core/syncstatus/syncsubscriptions/syncsubscriptions_test.go @@ -44,7 +44,7 @@ func TestSyncSubscriptions(t *testing.T) { subs.(*syncSubscriptions).service = testSubs err := subs.Run(context.Background()) require.NoError(t, err) - time.Sleep(100 * time.Millisecond) + time.Sleep(500 * time.Millisecond) spaceSub, err := subs.GetSubscription("spaceId") require.NoError(t, err) syncCnt := spaceSub.SyncingObjectsCount([]string{"1", "2"}) @@ -59,7 +59,7 @@ func TestSyncSubscriptions(t *testing.T) { objects[i][bundle.RelationKeySyncStatus] = domain.Int64(int64(domain.ObjectSyncStatusSynced)) testSubs.AddObjects(t, "spaceId", []objectstore.TestObject{objects[i]}) } - time.Sleep(100 * time.Millisecond) + time.Sleep(500 * time.Millisecond) syncCnt = spaceSub.SyncingObjectsCount([]string{"1", "2"}) require.Equal(t, 2, syncCnt) err = subs.Close(context.Background()) diff --git a/core/wallet/mock_wallet/mock_Wallet.go b/core/wallet/mock_wallet/mock_Wallet.go index d38538747..82610f1c8 100644 --- a/core/wallet/mock_wallet/mock_Wallet.go +++ b/core/wallet/mock_wallet/mock_Wallet.go @@ -73,6 +73,51 @@ func (_c *MockWallet_Account_Call) RunAndReturn(run func() *accountdata.AccountK return _c } +// FtsPrimaryLang provides a mock function with given fields: +func (_m *MockWallet) FtsPrimaryLang() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for FtsPrimaryLang") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockWallet_FtsPrimaryLang_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FtsPrimaryLang' +type MockWallet_FtsPrimaryLang_Call struct { + *mock.Call +} + +// FtsPrimaryLang is a helper method to define mock.On call +func (_e *MockWallet_Expecter) FtsPrimaryLang() *MockWallet_FtsPrimaryLang_Call { + return &MockWallet_FtsPrimaryLang_Call{Call: _e.mock.On("FtsPrimaryLang")} +} + +func (_c *MockWallet_FtsPrimaryLang_Call) Run(run func()) *MockWallet_FtsPrimaryLang_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockWallet_FtsPrimaryLang_Call) Return(_a0 string) *MockWallet_FtsPrimaryLang_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockWallet_FtsPrimaryLang_Call) RunAndReturn(run func() string) *MockWallet_FtsPrimaryLang_Call { + _c.Call.Return(run) + return _c +} + // GetAccountEthAddress provides a mock function with given fields: func (_m *MockWallet) GetAccountEthAddress() wallet.EthAddress { ret := _m.Called() diff --git a/core/wallet/wallet.go b/core/wallet/wallet.go index 196687fe8..fa0be7e6c 100644 --- a/core/wallet/wallet.go +++ b/core/wallet/wallet.go @@ -29,6 +29,7 @@ type EthAddress = common.Address type wallet struct { rootPath string repoPath string // other components will init their files/dirs inside + lang string deviceKeyPath string accountKey crypto.PrivKey @@ -117,6 +118,10 @@ func (r *wallet) RepoPath() string { return r.repoPath } +func (r *wallet) FtsPrimaryLang() string { + return r.lang +} + func (r *wallet) RootPath() string { return r.rootPath } @@ -129,12 +134,13 @@ func (r *wallet) Account() *accountdata.AccountKeys { return r.accountData } -func NewWithAccountRepo(rootPath string, derivationResult crypto.DerivationResult) Wallet { +func NewWithAccountRepo(rootPath string, derivationResult crypto.DerivationResult, lang string) Wallet { accountId := derivationResult.Identity.GetPublic().Account() repoPath := filepath.Join(rootPath, accountId) return &wallet{ rootPath: rootPath, repoPath: repoPath, + lang: lang, masterKey: derivationResult.MasterKey, oldAccountKey: derivationResult.OldAccountKey, accountKey: derivationResult.Identity, @@ -160,6 +166,7 @@ func NewWithRepoPathAndKeys(repoPath string, accountKeypair, deviceKeypair crypt type Wallet interface { RootPath() string RepoPath() string + FtsPrimaryLang() string GetAccountPrivkey() crypto.PrivKey GetDevicePrivkey() crypto.PrivKey GetOldAccountKey() crypto.PrivKey diff --git a/docs/Build.md b/docs/Build.md index b8686c5a3..85d43c01f 100644 --- a/docs/Build.md +++ b/docs/Build.md @@ -13,8 +13,11 @@ make download-tantivy-all-force #### Mac As of 16.01.23 last protobuf version (21.12) broke the JS plugin support, so you can use the v3 branch: +Make sure you've removed protobuf ``` +brew remove protobuf --ignore-dependencies brew install protobuf@3 +brew link --force --overwrite protobuf@3 ``` To generate Swift protobuf: diff --git a/docs/proto.md b/docs/proto.md index c556d8092..ad9a28d64 100644 --- a/docs/proto.md +++ b/docs/proto.md @@ -3510,6 +3510,7 @@ TODO: Remove this request if we do not need it, GO-1926 | ----- | ---- | ----- | ----------- | | id | [string](#string) | | Id of a selected account | | rootPath | [string](#string) | | | +| fulltextPrimaryLanguage | [string](#string) | | optional, default fts language | @@ -3732,6 +3733,7 @@ Middleware-to-front-end response to an account recover request, that can contain | path | [string](#string) | | | | rootPath | [string](#string) | | | | icon | [int64](#int64) | | | +| fulltextPrimaryLanguage | [string](#string) | | optional, default fts language | @@ -3849,6 +3851,7 @@ User can select an account from those, that came with an AccountAdd events | networkCustomConfigFilePath | [string](#string) | | config path for the custom network mode | | preferYamuxTransport | [bool](#bool) | | optional, default is false, recommended in case of problems with QUIC transport | | jsonApiListenAddr | [string](#string) | | optional, if empty json api will not be started; 127.0.0.1:31009 should be the default one | +| fulltextPrimaryLanguage | [string](#string) | | optional, default fts language | @@ -20297,6 +20300,7 @@ Front-end-to-middleware request to create a new wallet | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | | rootPath | [string](#string) | | Path to a wallet directory | +| fulltextPrimaryLanguage | [string](#string) | | optional, default fts language | @@ -20415,6 +20419,7 @@ Front end to middleware request-to-recover-a wallet with this mnemonic and a roo | ----- | ---- | ----- | ----------- | | rootPath | [string](#string) | | Path to a wallet directory | | mnemonic | [string](#string) | | Mnemonic of a wallet to recover | +| fulltextPrimaryLanguage | [string](#string) | | optional, default fts language | diff --git a/go.mod b/go.mod index e2df99468..1ca7626e6 100644 --- a/go.mod +++ b/go.mod @@ -7,7 +7,7 @@ require ( github.com/PuerkitoBio/goquery v1.10.2 github.com/VividCortex/ewma v1.2.0 github.com/adrium/goheif v0.0.0-20230113233934-ca402e77a786 - github.com/anyproto/any-store v0.1.7 + github.com/anyproto/any-store v0.1.8 github.com/anyproto/any-sync v0.6.1 github.com/anyproto/anytype-publish-server/publishclient v0.0.0-20250131145601-de288583ff2a github.com/anyproto/go-chash v0.1.0 @@ -15,9 +15,9 @@ require ( github.com/anyproto/go-slip10 v1.0.0 github.com/anyproto/lexid v0.0.4 github.com/anyproto/protobuf v1.3.3-0.20240814124528-72b8c7e0e0f5 - github.com/anyproto/tantivy-go v0.3.1 + github.com/anyproto/tantivy-go v1.0.1 github.com/araddon/dateparse v0.0.0-20210429162001-6b43995a97de - github.com/avast/retry-go/v4 v4.6.0 + github.com/avast/retry-go/v4 v4.6.1 github.com/chai2010/webp v1.1.2-0.20240612091223-aa1b379218b7 github.com/cheggaaa/mb/v3 v3.0.2 github.com/dave/jennifer v1.7.1 @@ -54,8 +54,8 @@ require ( github.com/ipfs/boxo v0.28.0 github.com/ipfs/go-block-format v0.2.0 github.com/ipfs/go-cid v0.5.0 - github.com/ipfs/go-datastore v0.8.0 - github.com/ipfs/go-ds-flatfs v0.5.2-0.20250227125509-a1310bca4792 + github.com/ipfs/go-datastore v0.8.1 + github.com/ipfs/go-ds-flatfs v0.5.4 github.com/ipfs/go-ipld-format v0.6.0 github.com/ipfs/go-log v1.0.5 github.com/joho/godotenv v1.5.1 @@ -103,11 +103,11 @@ require ( go.uber.org/mock v0.5.0 go.uber.org/multierr v1.11.0 go.uber.org/zap v1.27.0 - golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac + golang.org/x/exp v0.0.0-20250218142911-aa4b98e5adaa golang.org/x/image v0.24.0 - golang.org/x/mobile v0.0.0-20241108191957-fa514ef75a0f + golang.org/x/mobile v0.0.0-20250218173827-cd096645fcd3 golang.org/x/net v0.35.0 - golang.org/x/oauth2 v0.26.0 + golang.org/x/oauth2 v0.27.0 golang.org/x/sys v0.30.0 golang.org/x/text v0.22.0 google.golang.org/grpc v1.70.0 @@ -294,7 +294,7 @@ require ( modernc.org/libc v1.61.13 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.8.2 // indirect - modernc.org/sqlite v1.34.5 // indirect + modernc.org/sqlite v1.36.0 // indirect nhooyr.io/websocket v1.8.7 // indirect ) diff --git a/go.sum b/go.sum index 686d1d156..89e360144 100644 --- a/go.sum +++ b/go.sum @@ -82,8 +82,8 @@ github.com/alexbrainman/goissue34681 v0.0.0-20191006012335-3fc7a47baff5/go.mod h github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA= github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kktS1LM= github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA= -github.com/anyproto/any-store v0.1.7 h1:E3DntI+JXo3h7v0WTUJWH+nm7G4MV0PNOXZ6SFzQ2OU= -github.com/anyproto/any-store v0.1.7/go.mod h1:nbyRoJYOlvSWU1xDOrmgPP96UeoTf4eYZ9k+qqLK9k8= +github.com/anyproto/any-store v0.1.8 h1:/bxUVq6sBTwYkmPL2g1xUAWNb3axF+zPhP2dvdEBH68= +github.com/anyproto/any-store v0.1.8/go.mod h1:GpnVhcGm5aUQtOwCnKeTt4jsWgVXZ773WbQVLFdeCFo= github.com/anyproto/any-sync v0.6.1 h1:Dasbp7qGQme8diGGpzaDQfSDs5o7PAK3E5rxHHrB/+4= github.com/anyproto/any-sync v0.6.1/go.mod h1:5js8TNBdqe75zwlr9XEQSVDtwhsvEU2qLeC2wTnT/Fo= github.com/anyproto/anytype-publish-server/publishclient v0.0.0-20250131145601-de288583ff2a h1:ZZM+0OUCQMWSLSflpkf0ZMVo3V76qEDDIXPpQOClNs0= @@ -116,8 +116,8 @@ github.com/anyproto/protobuf v1.3.3-0.20240814124528-72b8c7e0e0f5 h1:aY7tBzQ+z8H github.com/anyproto/protobuf v1.3.3-0.20240814124528-72b8c7e0e0f5/go.mod h1:5+PHE01DgsDPkralb8MYmGg2sPQahsqEJ9ue7ciDHKg= github.com/anyproto/ristretto v0.1.2-0.20240221153107-2b23839cc50c h1:GicoaTUyB2mtCIl3YMrO0OzysqRT5GA4vuvDsqEkhSM= github.com/anyproto/ristretto v0.1.2-0.20240221153107-2b23839cc50c/go.mod h1:S1GPSBCYCIhmVNfcth17y2zZtQT6wzkzgwUve0VDWWA= -github.com/anyproto/tantivy-go v0.3.1 h1:59XePWnHlaTOgw1jVqpKD7oyZa8nwY5+U9UKnt0HHZU= -github.com/anyproto/tantivy-go v0.3.1/go.mod h1:7hhkPpyTq7+W1dx9Dcva4bsg4TLHq9xqmmYLCwqDq/k= +github.com/anyproto/tantivy-go v1.0.1 h1:Uc9WqwGEDsVUEwRgSg4nmhoW20GjMUBKRz5FYw4r+ns= +github.com/anyproto/tantivy-go v1.0.1/go.mod h1:LtipOpRjGtcYMGcop6gQN7rVl1Pc6BlIs9BTMqeWMsk= github.com/anyproto/zeroconf/v2 v2.2.1-0.20240228113933-f90a5cc4439d h1:5bj7nX/AS8sxGpTIrapE7PC4oPlhkHMwMqXlJbUHBlg= github.com/anyproto/zeroconf/v2 v2.2.1-0.20240228113933-f90a5cc4439d/go.mod h1:fuJqLnUwZTshS3U/bMRJ3+ow/v9oid1n0DmyYyNO1Xs= github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= @@ -126,8 +126,8 @@ github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hC github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A= -github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA= -github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE= +github.com/avast/retry-go/v4 v4.6.1 h1:VkOLRubHdisGrHnTu89g08aQEWEgRU7LVEop3GbIcMk= +github.com/avast/retry-go/v4 v4.6.1/go.mod h1:V6oF8njAwxJ5gRo1Q7Cxab24xs5NCWZBeaHHBklR8mA= github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU= github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g= @@ -589,10 +589,12 @@ github.com/ipfs/go-block-format v0.2.0 h1:ZqrkxBA2ICbDRbK8KJs/u0O3dlp6gmAuuXUJNi github.com/ipfs/go-block-format v0.2.0/go.mod h1:+jpL11nFx5A/SPpsoBn6Bzkra/zaArfSmsknbPMYgzM= github.com/ipfs/go-cid v0.5.0 h1:goEKKhaGm0ul11IHA7I6p1GmKz8kEYniqFopaB5Otwg= github.com/ipfs/go-cid v0.5.0/go.mod h1:0L7vmeNXpQpUS9vt+yEARkJ8rOg43DF3iPgn4GIN0mk= -github.com/ipfs/go-datastore v0.8.0 h1:n8xKnoSTo/28L5KM+Jfz4kfohD889/afdWcDHve9VuY= -github.com/ipfs/go-datastore v0.8.0/go.mod h1:BGN3N+sLTEWQUHMtOjmm2GKccMJnVFPgSLp6kshNqRk= -github.com/ipfs/go-ds-flatfs v0.5.2-0.20250227125509-a1310bca4792 h1:uEelQJ1AfEM+7WtrOxVJEzdQYfNAe3wyRcMz5ZHchYw= -github.com/ipfs/go-ds-flatfs v0.5.2-0.20250227125509-a1310bca4792/go.mod h1:hCh3OKNvlqPQ+retNJy8402Oej6QpX4U18OYzLrfLR8= +github.com/ipfs/go-datastore v0.8.1 h1:p4+tWJuopShJgB3kIK0MMvnH6CFPvi7g/S44f2/EHQA= +github.com/ipfs/go-datastore v0.8.1/go.mod h1:W+pI1NsUsz3tcsAACMtfC+IZdnQTnC/7VfPoJBQuts0= +github.com/ipfs/go-detect-race v0.0.1 h1:qX/xay2W3E4Q1U7d9lNs1sU9nvguX0a7319XbyQ6cOk= +github.com/ipfs/go-detect-race v0.0.1/go.mod h1:8BNT7shDZPo99Q74BpGMK+4D8Mn4j46UU0LZ723meps= +github.com/ipfs/go-ds-flatfs v0.5.4 h1:rQjd6tiQZgMU8yNmS2iai4FI+JP7EoYLhsjxxAkA/sE= +github.com/ipfs/go-ds-flatfs v0.5.4/go.mod h1:sskCDxKNQT3GMVz7QpBc2DK4qalYHZ12y2iCGp4ZZbU= github.com/ipfs/go-ipfs-delay v0.0.1 h1:r/UXYyRcddO6thwOnhiznIAiSvxMECGgtv35Xs1IeRQ= github.com/ipfs/go-ipfs-delay v0.0.1/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw= github.com/ipfs/go-ipfs-pq v0.0.3 h1:YpoHVJB+jzK15mr/xsWC574tyDLkezVrDNeaalQBsTE= @@ -1204,8 +1206,8 @@ golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw= -golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac h1:l5+whBCLH3iH2ZNHYLbAe58bo7yrN4mVcnkHDYz5vvs= -golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac/go.mod h1:hH+7mtFmImwwcMvScyxUhjuVHR3HGaDPMn9rMSUUbxo= +golang.org/x/exp v0.0.0-20250218142911-aa4b98e5adaa h1:t2QcU6V556bFjYgu4L6C+6VrCPyJZ+eyRsABUPs1mz4= +golang.org/x/exp v0.0.0-20250218142911-aa4b98e5adaa/go.mod h1:BHOTPb3L19zxehTsLoJXVaTktb06DFgmdW6Wb9s8jqk= golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81/go.mod h1:ux5Hcp/YLpHSI86hEcLt0YII63i6oz57MZXIpbrjZUs= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= @@ -1225,8 +1227,8 @@ golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPI golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= -golang.org/x/mobile v0.0.0-20241108191957-fa514ef75a0f h1:23H/YlmTHfmmvpZ+ajKZL0qLz0+IwFOIqQA0mQbmLeM= -golang.org/x/mobile v0.0.0-20241108191957-fa514ef75a0f/go.mod h1:UbSUP4uu/C9hw9R2CkojhXlAxvayHjBdU9aRvE+c1To= +golang.org/x/mobile v0.0.0-20250218173827-cd096645fcd3 h1:0V/7Y1FEaFdAzb9DkVDh4QFp4vL4yYCiJ5cjk80lZyA= +golang.org/x/mobile v0.0.0-20250218173827-cd096645fcd3/go.mod h1:j5VYNgQ6lZYZlzHFjdgS2UeqRSZunDk+/zXVTAIA3z4= golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= @@ -1316,8 +1318,8 @@ golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.26.0 h1:afQXWNNaeC4nvZ0Ed9XvCCzXM6UHJG7iCg0W4fPqSBE= -golang.org/x/oauth2 v0.26.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= +golang.org/x/oauth2 v0.27.0 h1:da9Vo7/tDv5RH/7nZDz1eMGS/q1Vv1N/7FCrBhI9I3M= +golang.org/x/oauth2 v0.27.0/go.mod h1:onh5ek6nERTohokkhCD/y2cV4Do3fxFHFuAejCkRWT8= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -1701,8 +1703,8 @@ modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8= modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= -modernc.org/sqlite v1.34.5 h1:Bb6SR13/fjp15jt70CL4f18JIN7p7dnMExd+UFnF15g= -modernc.org/sqlite v1.34.5/go.mod h1:YLuNmX9NKs8wRNK2ko1LW1NGYcc9FkBO69JOt1AR9JE= +modernc.org/sqlite v1.36.0 h1:EQXNRn4nIS+gfsKeUTymHIz1waxuv5BzU7558dHSfH8= +modernc.org/sqlite v1.36.0/go.mod h1:7MPwH7Z6bREicF9ZVUR78P1IKuxfZ8mRIDHD0iD+8TU= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= diff --git a/makefiles/setup.mk b/makefiles/setup.mk index 14edebe96..6568b5ebf 100644 --- a/makefiles/setup.mk +++ b/makefiles/setup.mk @@ -41,4 +41,4 @@ setup-protoc-jsweb: mv deps/grpc-web/javascript/net/grpc/web/generator/protoc-gen-grpc-web deps/protoc-gen-grpc-web @rm -rf deps/grpc-web -setup-protoc: setup-protoc-go setup-protoc-jsweb +setup-protoc: setup-protoc-go setup-protoc-jsweb \ No newline at end of file diff --git a/metrics/client_test.go b/metrics/client_test.go index cef2f4f49..d9ff1d9f5 100644 --- a/metrics/client_test.go +++ b/metrics/client_test.go @@ -7,8 +7,8 @@ import ( "time" "github.com/cheggaaa/mb/v3" - "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" "github.com/valyala/fastjson" "github.com/anyproto/anytype-heart/metrics/anymetry" @@ -79,19 +79,19 @@ func TestClient_SendEvents(t *testing.T) { go c.startSendingBatchMessages(&testAppInfoProvider{}) c.send(&testEvent{}) - time.Sleep(1 * time.Millisecond) + time.Sleep(100 * time.Millisecond) - assert.Equal(t, 1, c.batcher.Len()) + require.Equal(t, 1, c.batcher.Len()) telemetry.AssertNotCalled(t, "SendEvents", mock.Anything, mock.Anything) c.send(&testEvent{}) - time.Sleep(1 * time.Millisecond) + time.Sleep(100 * time.Millisecond) mutex.Lock() - assert.Equal(t, 0, c.batcher.Len()) - assert.Equal(t, 2, len(events)) + require.Equal(t, 0, c.batcher.Len()) + require.Equal(t, 2, len(events)) mutex.Unlock() - assert.True(t, events[0].GetTimestamp() > 0) + require.True(t, events[0].GetTimestamp() > 0) telemetry.AssertCalled(t, "SendEvents", mock.Anything, mock.Anything) } diff --git a/pb/commands.pb.go b/pb/commands.pb.go index eab79f6c2..1c8282602 100644 --- a/pb/commands.pb.go +++ b/pb/commands.pb.go @@ -13097,7 +13097,8 @@ var xxx_messageInfo_RpcWalletCreate proto.InternalMessageInfo // * // Front-end-to-middleware request to create a new wallet type RpcWalletCreateRequest struct { - RootPath string `protobuf:"bytes,1,opt,name=rootPath,proto3" json:"rootPath,omitempty"` + RootPath string `protobuf:"bytes,1,opt,name=rootPath,proto3" json:"rootPath,omitempty"` + FulltextPrimaryLanguage string `protobuf:"bytes,2,opt,name=fulltextPrimaryLanguage,proto3" json:"fulltextPrimaryLanguage,omitempty"` } func (m *RpcWalletCreateRequest) Reset() { *m = RpcWalletCreateRequest{} } @@ -13140,6 +13141,13 @@ func (m *RpcWalletCreateRequest) GetRootPath() string { return "" } +func (m *RpcWalletCreateRequest) GetFulltextPrimaryLanguage() string { + if m != nil { + return m.FulltextPrimaryLanguage + } + return "" +} + // * // Middleware-to-front-end response, that can contain mnemonic of a created account and a NULL error or an empty mnemonic and a non-NULL error type RpcWalletCreateResponse struct { @@ -13285,8 +13293,9 @@ var xxx_messageInfo_RpcWalletRecover proto.InternalMessageInfo // * // Front end to middleware request-to-recover-a wallet with this mnemonic and a rootPath type RpcWalletRecoverRequest struct { - RootPath string `protobuf:"bytes,1,opt,name=rootPath,proto3" json:"rootPath,omitempty"` - Mnemonic string `protobuf:"bytes,2,opt,name=mnemonic,proto3" json:"mnemonic,omitempty"` + RootPath string `protobuf:"bytes,1,opt,name=rootPath,proto3" json:"rootPath,omitempty"` + Mnemonic string `protobuf:"bytes,2,opt,name=mnemonic,proto3" json:"mnemonic,omitempty"` + FulltextPrimaryLanguage string `protobuf:"bytes,3,opt,name=fulltextPrimaryLanguage,proto3" json:"fulltextPrimaryLanguage,omitempty"` } func (m *RpcWalletRecoverRequest) Reset() { *m = RpcWalletRecoverRequest{} } @@ -13336,6 +13345,13 @@ func (m *RpcWalletRecoverRequest) GetMnemonic() string { return "" } +func (m *RpcWalletRecoverRequest) GetFulltextPrimaryLanguage() string { + if m != nil { + return m.FulltextPrimaryLanguage + } + return "" +} + // * // Middleware-to-front-end response, that can contain a NULL error or a non-NULL error type RpcWalletRecoverResponse struct { @@ -15015,8 +15031,9 @@ func (m *RpcAccountMigrate) XXX_DiscardUnknown() { var xxx_messageInfo_RpcAccountMigrate proto.InternalMessageInfo type RpcAccountMigrateRequest struct { - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` - RootPath string `protobuf:"bytes,2,opt,name=rootPath,proto3" json:"rootPath,omitempty"` + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + RootPath string `protobuf:"bytes,2,opt,name=rootPath,proto3" json:"rootPath,omitempty"` + FulltextPrimaryLanguage string `protobuf:"bytes,3,opt,name=fulltextPrimaryLanguage,proto3" json:"fulltextPrimaryLanguage,omitempty"` } func (m *RpcAccountMigrateRequest) Reset() { *m = RpcAccountMigrateRequest{} } @@ -15066,6 +15083,13 @@ func (m *RpcAccountMigrateRequest) GetRootPath() string { return "" } +func (m *RpcAccountMigrateRequest) GetFulltextPrimaryLanguage() string { + if m != nil { + return m.FulltextPrimaryLanguage + } + return "" +} + type RpcAccountMigrateResponse struct { Error *RpcAccountMigrateResponseError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` } @@ -15385,6 +15409,7 @@ type RpcAccountSelectRequest struct { NetworkCustomConfigFilePath string `protobuf:"bytes,5,opt,name=networkCustomConfigFilePath,proto3" json:"networkCustomConfigFilePath,omitempty"` PreferYamuxTransport bool `protobuf:"varint,6,opt,name=preferYamuxTransport,proto3" json:"preferYamuxTransport,omitempty"` JsonApiListenAddr string `protobuf:"bytes,7,opt,name=jsonApiListenAddr,proto3" json:"jsonApiListenAddr,omitempty"` + FulltextPrimaryLanguage string `protobuf:"bytes,8,opt,name=fulltextPrimaryLanguage,proto3" json:"fulltextPrimaryLanguage,omitempty"` } func (m *RpcAccountSelectRequest) Reset() { *m = RpcAccountSelectRequest{} } @@ -15469,6 +15494,13 @@ func (m *RpcAccountSelectRequest) GetJsonApiListenAddr() string { return "" } +func (m *RpcAccountSelectRequest) GetFulltextPrimaryLanguage() string { + if m != nil { + return m.FulltextPrimaryLanguage + } + return "" +} + // * // Middleware-to-front-end response for an account select request, that can contain a NULL error and selected account or a non-NULL error and an empty account type RpcAccountSelectResponse struct { @@ -16262,9 +16294,10 @@ func (m *RpcAccountRecoverFromLegacyExport) XXX_DiscardUnknown() { var xxx_messageInfo_RpcAccountRecoverFromLegacyExport proto.InternalMessageInfo type RpcAccountRecoverFromLegacyExportRequest struct { - Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` - RootPath string `protobuf:"bytes,2,opt,name=rootPath,proto3" json:"rootPath,omitempty"` - Icon int64 `protobuf:"varint,3,opt,name=icon,proto3" json:"icon,omitempty"` + Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"` + RootPath string `protobuf:"bytes,2,opt,name=rootPath,proto3" json:"rootPath,omitempty"` + Icon int64 `protobuf:"varint,3,opt,name=icon,proto3" json:"icon,omitempty"` + FulltextPrimaryLanguage string `protobuf:"bytes,4,opt,name=fulltextPrimaryLanguage,proto3" json:"fulltextPrimaryLanguage,omitempty"` } func (m *RpcAccountRecoverFromLegacyExportRequest) Reset() { @@ -16323,6 +16356,13 @@ func (m *RpcAccountRecoverFromLegacyExportRequest) GetIcon() int64 { return 0 } +func (m *RpcAccountRecoverFromLegacyExportRequest) GetFulltextPrimaryLanguage() string { + if m != nil { + return m.FulltextPrimaryLanguage + } + return "" +} + type RpcAccountRecoverFromLegacyExportResponse struct { AccountId string `protobuf:"bytes,1,opt,name=accountId,proto3" json:"accountId,omitempty"` PersonalSpaceId string `protobuf:"bytes,3,opt,name=personalSpaceId,proto3" json:"personalSpaceId,omitempty"` @@ -73429,1265 +73469,1268 @@ func init() { func init() { proto.RegisterFile("pb/protos/commands.proto", fileDescriptor_8261c968b2e6f45c) } var fileDescriptor_8261c968b2e6f45c = []byte{ - // 20115 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x7b, 0x98, 0x2b, 0x47, - 0x75, 0x2f, 0xba, 0xd5, 0x2d, 0x69, 0x34, 0x35, 0x8f, 0xad, 0xdd, 0xde, 0x7b, 0x7b, 0xbb, 0x6c, - 0xb6, 0x9d, 0x6d, 0x63, 0x1c, 0x63, 0xc6, 0xd8, 0x10, 0x82, 0x8d, 0x8d, 0xad, 0xd1, 0xf4, 0xcc, - 0xc8, 0x9e, 0x91, 0x26, 0x2d, 0xcd, 0xde, 0x38, 0xb9, 0xb9, 0x4a, 0x6f, 0xa9, 0x66, 0xa6, 0xbd, - 0x35, 0xdd, 0xa2, 0xbb, 0x67, 0xb6, 0x87, 0xfb, 0x9d, 0x7b, 0x42, 0x88, 0x79, 0x84, 0x10, 0x42, - 0x08, 0x49, 0x80, 0x00, 0xc1, 0xc4, 0x10, 0x20, 0xbc, 0x5f, 0x07, 0x08, 0x8f, 0xf0, 0x08, 0x8f, - 0x10, 0x42, 0x20, 0x84, 0x47, 0xe2, 0x2f, 0x10, 0x08, 0x21, 0xe7, 0x0b, 0x97, 0x4b, 0xee, 0x09, - 0x84, 0x1c, 0x38, 0xdc, 0xaf, 0xab, 0xaa, 0xbb, 0xab, 0x34, 0xea, 0x56, 0xb5, 0x46, 0xad, 0x31, + // 20162 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x7b, 0x78, 0x2c, 0x47, + 0x75, 0x2f, 0xba, 0xa7, 0x7b, 0x66, 0x34, 0x2a, 0x3d, 0xf6, 0xec, 0xf6, 0xde, 0xdb, 0xdb, 0x65, + 0xb3, 0xed, 0x6c, 0x1b, 0xe3, 0x18, 0x23, 0x63, 0x43, 0x08, 0x36, 0x36, 0xf6, 0x68, 0xd4, 0x92, + 0xc6, 0x96, 0x66, 0x94, 0x9e, 0xd1, 0xde, 0x38, 0xb9, 0xb9, 0x93, 0xd6, 0x4c, 0x49, 0x6a, 0xef, + 0x51, 0xf7, 0xd0, 0xdd, 0xd2, 0xb6, 0xb8, 0xdf, 0xb9, 0x27, 0x84, 0x38, 0x90, 0x10, 0x42, 0x48, + 0x42, 0x08, 0x10, 0x20, 0x40, 0x0c, 0x81, 0x84, 0xf7, 0xeb, 0x00, 0xe1, 0x11, 0x1e, 0xe1, 0x11, + 0x42, 0x08, 0x84, 0xf0, 0x48, 0xf8, 0x02, 0x81, 0x10, 0x72, 0xbe, 0x70, 0xb9, 0xe4, 0x9e, 0x40, + 0xc8, 0x81, 0x93, 0xfb, 0x75, 0x55, 0x75, 0x77, 0xd5, 0x68, 0xba, 0xa7, 0x7a, 0x34, 0x3d, 0x32, 0xe1, 0xfc, 0xd7, 0x5d, 0x5d, 0xbd, 0x6a, 0xd5, 0xfa, 0xad, 0xaa, 0x5a, 0x55, 0xb5, 0x6a, 0x15, - 0x38, 0xd5, 0x3d, 0x7f, 0x63, 0xd7, 0xb6, 0x5c, 0xcb, 0xb9, 0xb1, 0x65, 0x6d, 0x6f, 0xeb, 0x66, - 0xdb, 0x99, 0xc3, 0xef, 0xca, 0x84, 0x6e, 0xee, 0xb9, 0x7b, 0x5d, 0x04, 0xaf, 0xe9, 0x5e, 0xd8, - 0xbc, 0xb1, 0x63, 0x9c, 0xbf, 0xb1, 0x7b, 0xfe, 0xc6, 0x6d, 0xab, 0x8d, 0x3a, 0xfe, 0x0f, 0xf8, - 0x85, 0x66, 0x87, 0xd7, 0x45, 0xe5, 0xea, 0x58, 0x2d, 0xbd, 0xe3, 0xb8, 0x96, 0x8d, 0x68, 0xce, - 0x93, 0x61, 0x91, 0x68, 0x17, 0x99, 0xae, 0x4f, 0xe1, 0x8a, 0x4d, 0xcb, 0xda, 0xec, 0x20, 0xf2, - 0xed, 0xfc, 0xce, 0xc6, 0x8d, 0x8e, 0x6b, 0xef, 0xb4, 0x5c, 0xfa, 0xf5, 0xaa, 0xde, 0xaf, 0x6d, - 0xe4, 0xb4, 0x6c, 0xa3, 0xeb, 0x5a, 0x36, 0xc9, 0x71, 0xe6, 0x47, 0x0f, 0x14, 0x80, 0xac, 0x75, - 0x5b, 0xf0, 0xbb, 0x13, 0x40, 0x2e, 0x75, 0xbb, 0xf0, 0xa3, 0x12, 0x00, 0x4b, 0xc8, 0x3d, 0x8b, - 0x6c, 0xc7, 0xb0, 0x4c, 0x78, 0x14, 0x4c, 0x68, 0xe8, 0xa9, 0x3b, 0xc8, 0x71, 0x6f, 0xcd, 0x3e, - 0xfb, 0x1b, 0x72, 0x06, 0x3e, 0x28, 0x81, 0x82, 0x86, 0x9c, 0xae, 0x65, 0x3a, 0x48, 0xb9, 0x13, - 0xe4, 0x90, 0x6d, 0x5b, 0xf6, 0xa9, 0xcc, 0x55, 0x99, 0xeb, 0xa6, 0x6e, 0xbe, 0x7e, 0x8e, 0x56, - 0x7f, 0x4e, 0xeb, 0xb6, 0xe6, 0x4a, 0xdd, 0xee, 0x5c, 0x48, 0x69, 0xce, 0xff, 0x69, 0x4e, 0xf5, - 0xfe, 0xd0, 0xc8, 0x8f, 0xca, 0x29, 0x30, 0xb1, 0x4b, 0x32, 0x9c, 0x92, 0xae, 0xca, 0x5c, 0x37, - 0xa9, 0xf9, 0xaf, 0xde, 0x97, 0x36, 0x72, 0x75, 0xa3, 0xe3, 0x9c, 0x92, 0xc9, 0x17, 0xfa, 0x0a, - 0x1f, 0xc8, 0x80, 0x1c, 0x26, 0xa2, 0x94, 0x41, 0xb6, 0x65, 0xb5, 0x11, 0x2e, 0x7e, 0xf6, 0xe6, - 0x1b, 0xc5, 0x8b, 0x9f, 0x2b, 0x5b, 0x6d, 0xa4, 0xe1, 0x9f, 0x95, 0xab, 0xc0, 0x94, 0x2f, 0x96, - 0x90, 0x0d, 0x36, 0xe9, 0xcc, 0xcd, 0x20, 0xeb, 0xe5, 0x57, 0x0a, 0x20, 0x5b, 0x5d, 0x5f, 0x59, - 0x29, 0x1e, 0x51, 0x8e, 0x81, 0x99, 0xf5, 0xea, 0xdd, 0xd5, 0xda, 0xb9, 0x6a, 0x53, 0xd5, 0xb4, - 0x9a, 0x56, 0xcc, 0x28, 0x33, 0x60, 0x72, 0xbe, 0xb4, 0xd0, 0xac, 0x54, 0xd7, 0xd6, 0x1b, 0x45, - 0x09, 0xbe, 0x5c, 0x06, 0xb3, 0x75, 0xe4, 0x2e, 0xa0, 0x5d, 0xa3, 0x85, 0xea, 0xae, 0xee, 0x22, - 0xf8, 0xfc, 0x4c, 0x20, 0x4c, 0x65, 0xdd, 0x2b, 0x34, 0xf8, 0x44, 0x2b, 0xf0, 0xb8, 0x7d, 0x15, - 0xe0, 0x29, 0xcc, 0xd1, 0xbf, 0xe7, 0x98, 0x34, 0x8d, 0xa5, 0x73, 0xe6, 0x31, 0x60, 0x8a, 0xf9, - 0xa6, 0xcc, 0x02, 0x30, 0x5f, 0x2a, 0xdf, 0xbd, 0xa4, 0xd5, 0xd6, 0xab, 0x0b, 0xc5, 0x23, 0xde, - 0xfb, 0x62, 0x4d, 0x53, 0xe9, 0x7b, 0x06, 0x7e, 0x3f, 0xc3, 0x80, 0xb9, 0xc0, 0x83, 0x39, 0x37, - 0x98, 0x99, 0x3e, 0x80, 0xc2, 0x57, 0x07, 0xe0, 0x2c, 0x71, 0xe0, 0x3c, 0x2e, 0x19, 0xb9, 0xf4, - 0x01, 0xba, 0x5f, 0x02, 0x85, 0xfa, 0xd6, 0x8e, 0xdb, 0xb6, 0x2e, 0x9a, 0x70, 0x32, 0x40, 0x06, - 0x7e, 0x8b, 0x95, 0xc9, 0x93, 0x79, 0x99, 0x5c, 0xb7, 0xbf, 0x12, 0x94, 0x42, 0x84, 0x34, 0xfe, - 0x20, 0x90, 0x46, 0x89, 0x93, 0xc6, 0x63, 0x44, 0x09, 0xa5, 0x2f, 0x87, 0x97, 0x3c, 0x11, 0xe4, - 0xea, 0x5d, 0xbd, 0x85, 0xe0, 0xa7, 0x64, 0x30, 0xbd, 0x82, 0xf4, 0x5d, 0x54, 0xea, 0x76, 0x6d, - 0x6b, 0x17, 0xc1, 0x72, 0xa8, 0xaf, 0xa7, 0xc0, 0x84, 0xe3, 0x65, 0xaa, 0xb4, 0x71, 0x0d, 0x26, - 0x35, 0xff, 0x55, 0x39, 0x0d, 0x80, 0xd1, 0x46, 0xa6, 0x6b, 0xb8, 0x06, 0x72, 0x4e, 0x49, 0x57, - 0xc9, 0xd7, 0x4d, 0x6a, 0x4c, 0x0a, 0xfc, 0xae, 0x24, 0xaa, 0x63, 0x98, 0x8b, 0x39, 0x96, 0x83, - 0x08, 0xa9, 0xbe, 0x4a, 0x12, 0xd1, 0xb1, 0x81, 0xe4, 0x92, 0xc9, 0xf6, 0x8d, 0x99, 0xe4, 0xc2, - 0xf5, 0x72, 0x54, 0x6b, 0xcd, 0xfa, 0x7a, 0x79, 0xb9, 0x59, 0x5f, 0x2b, 0x95, 0xd5, 0x22, 0x52, - 0x8e, 0x83, 0x22, 0x7e, 0x6c, 0x56, 0xea, 0xcd, 0x05, 0x75, 0x45, 0x6d, 0xa8, 0x0b, 0xc5, 0x0d, - 0x45, 0x01, 0xb3, 0x9a, 0xfa, 0x73, 0xeb, 0x6a, 0xbd, 0xd1, 0x5c, 0x2c, 0x55, 0x56, 0xd4, 0x85, - 0xe2, 0xa6, 0xf7, 0xf3, 0x4a, 0x65, 0xb5, 0xd2, 0x68, 0x6a, 0x6a, 0xa9, 0xbc, 0xac, 0x2e, 0x14, - 0xb7, 0x94, 0x4b, 0xc1, 0x25, 0xd5, 0x5a, 0xb3, 0xb4, 0xb6, 0xa6, 0xd5, 0xce, 0xaa, 0x4d, 0xfa, - 0x47, 0xbd, 0x68, 0x90, 0x82, 0x1a, 0xcd, 0xfa, 0x72, 0x49, 0x53, 0x4b, 0xf3, 0x2b, 0x6a, 0xf1, - 0x5e, 0xf8, 0x0c, 0x19, 0xcc, 0xac, 0xea, 0x17, 0x50, 0x7d, 0x4b, 0xb7, 0x91, 0x7e, 0xbe, 0x83, - 0xe0, 0xd5, 0x02, 0x78, 0xc2, 0x4f, 0xb1, 0x78, 0xa9, 0x3c, 0x5e, 0x37, 0xf6, 0x11, 0x30, 0x57, - 0x44, 0x04, 0x60, 0xff, 0x1e, 0x34, 0x83, 0x65, 0x0e, 0xb0, 0xc7, 0x27, 0xa4, 0x97, 0x0c, 0xb1, - 0x5f, 0x79, 0x18, 0x20, 0x06, 0x1f, 0x92, 0xc1, 0x6c, 0xc5, 0xdc, 0x35, 0x5c, 0xb4, 0x84, 0x4c, - 0x64, 0x7b, 0xe3, 0x80, 0x10, 0x0c, 0x0f, 0xca, 0x0c, 0x0c, 0x8b, 0x3c, 0x0c, 0x8f, 0xed, 0x23, - 0x36, 0xbe, 0x8c, 0x88, 0xd1, 0xf6, 0x0a, 0x30, 0x69, 0xe0, 0x7c, 0x65, 0xa3, 0x4d, 0x25, 0x16, - 0x26, 0x28, 0xd7, 0x80, 0x19, 0xf2, 0xb2, 0x68, 0x74, 0xd0, 0xdd, 0x68, 0x8f, 0x8e, 0xbb, 0x7c, - 0x22, 0xfc, 0xf5, 0xa0, 0xf1, 0x55, 0x38, 0x2c, 0x7f, 0x26, 0x29, 0x53, 0xc9, 0xc0, 0x7c, 0xd1, - 0xc3, 0xa1, 0xf9, 0xed, 0x6b, 0x65, 0x06, 0xfc, 0xa1, 0x04, 0xa6, 0xea, 0xae, 0xd5, 0xf5, 0x54, - 0xd6, 0x30, 0x37, 0xc5, 0xc0, 0xfd, 0x38, 0xdb, 0xc6, 0xca, 0x3c, 0xb8, 0x8f, 0xe9, 0x23, 0x47, - 0xa6, 0x80, 0x88, 0x16, 0xf6, 0xdd, 0xa0, 0x85, 0x2d, 0x72, 0xa8, 0xdc, 0x9c, 0x88, 0xda, 0x8f, - 0x61, 0xfb, 0x7a, 0x91, 0x0c, 0x8a, 0xbe, 0x9a, 0xb9, 0xe5, 0x1d, 0xdb, 0x46, 0xa6, 0x2b, 0x06, - 0xc2, 0xdf, 0xb2, 0x20, 0x2c, 0xf3, 0x20, 0xdc, 0x1c, 0xa3, 0xcc, 0x7e, 0x29, 0x29, 0xb6, 0xb1, - 0x0f, 0x06, 0x68, 0xde, 0xcd, 0xa1, 0xf9, 0xb3, 0xc9, 0xd9, 0x4a, 0x06, 0xe9, 0xf2, 0x10, 0x88, - 0x1e, 0x07, 0x45, 0x6f, 0x4c, 0x2a, 0x37, 0x2a, 0x67, 0xd5, 0x66, 0xa5, 0x7a, 0xb6, 0xd2, 0x50, - 0x8b, 0x08, 0xbe, 0x50, 0x06, 0xd3, 0x84, 0x35, 0x0d, 0xed, 0x5a, 0x17, 0x04, 0x7b, 0xbd, 0x87, - 0x12, 0x1a, 0x0b, 0x6c, 0x09, 0x11, 0x2d, 0xe3, 0xd7, 0x12, 0x18, 0x0b, 0x31, 0xe4, 0x1e, 0x4e, - 0xbd, 0xd5, 0xbe, 0x66, 0xb0, 0xd9, 0xa7, 0xb5, 0xf4, 0xed, 0xad, 0x5e, 0x94, 0x05, 0x80, 0x54, - 0xf2, 0xac, 0x81, 0x2e, 0xc2, 0xd5, 0x10, 0x13, 0x4e, 0x6d, 0x33, 0x03, 0xd5, 0x56, 0xea, 0xa7, - 0xb6, 0xef, 0x62, 0xc7, 0xac, 0x79, 0x1e, 0xbd, 0x1b, 0x22, 0xc5, 0xed, 0x71, 0x12, 0x3d, 0x3b, - 0xf4, 0x15, 0x45, 0xe2, 0xad, 0xce, 0x2b, 0xc0, 0x24, 0x7e, 0xac, 0xea, 0xdb, 0x88, 0xb6, 0xa1, - 0x30, 0x41, 0x39, 0x03, 0xa6, 0x49, 0xc6, 0x96, 0x65, 0x7a, 0xf5, 0xc9, 0xe2, 0x0c, 0x5c, 0x9a, - 0x07, 0x62, 0xcb, 0x46, 0xba, 0x6b, 0xd9, 0x98, 0x46, 0x8e, 0x80, 0xc8, 0x24, 0xc1, 0x6f, 0x06, - 0xad, 0x50, 0xe5, 0x34, 0xe7, 0xa6, 0x24, 0x55, 0x49, 0xa6, 0x37, 0xbb, 0xc3, 0xb5, 0x3f, 0xd2, - 0xea, 0x9a, 0x1e, 0xda, 0x8b, 0x78, 0x6a, 0x87, 0x94, 0x93, 0x40, 0xa1, 0xa9, 0x5e, 0xde, 0x72, - 0xad, 0xda, 0x50, 0xab, 0x8d, 0xe2, 0x46, 0x5f, 0x8d, 0xda, 0x84, 0xaf, 0xca, 0x82, 0xec, 0x5d, - 0x96, 0x61, 0xc2, 0xfb, 0x33, 0x9c, 0x4a, 0x98, 0xc8, 0xbd, 0x68, 0xd9, 0x17, 0x82, 0x86, 0x1a, - 0x26, 0xc4, 0x63, 0x13, 0xaa, 0x92, 0x3c, 0x50, 0x95, 0xb2, 0xfd, 0x54, 0xe9, 0xb7, 0x58, 0x55, - 0xba, 0x8d, 0x57, 0xa5, 0x6b, 0xfb, 0xc8, 0xdf, 0x63, 0x3e, 0xa2, 0x03, 0xf8, 0x58, 0xd0, 0x01, - 0xdc, 0xc1, 0xc1, 0xf8, 0x68, 0x31, 0x32, 0xc9, 0x00, 0xfc, 0x72, 0xaa, 0x0d, 0xbf, 0x1f, 0xd4, - 0x9b, 0x11, 0x50, 0x6f, 0xf5, 0xe9, 0x13, 0x8c, 0xfd, 0x5d, 0xc7, 0xbd, 0xfb, 0xbb, 0x89, 0x0b, - 0xca, 0x09, 0x70, 0x6c, 0xa1, 0xb2, 0xb8, 0xa8, 0x6a, 0x6a, 0xb5, 0xd1, 0xac, 0xaa, 0x8d, 0x73, - 0x35, 0xed, 0xee, 0x62, 0x07, 0x3e, 0x20, 0x03, 0xe0, 0x49, 0xa8, 0xac, 0x9b, 0x2d, 0xd4, 0x11, - 0xeb, 0xd1, 0xff, 0x1f, 0x29, 0x59, 0x9f, 0x10, 0xd2, 0x8f, 0x80, 0xf3, 0x65, 0x92, 0x78, 0xab, - 0x8c, 0x24, 0x96, 0x0c, 0xd4, 0xd7, 0x3d, 0x1c, 0x6c, 0xcf, 0x4b, 0xc0, 0x51, 0x9f, 0x1e, 0xcd, - 0xde, 0x7f, 0xda, 0xf7, 0xa6, 0x2c, 0x98, 0xa5, 0xb0, 0xf8, 0xf3, 0xf8, 0x67, 0x67, 0x44, 0x26, + 0x38, 0xd3, 0xdd, 0xb8, 0xb9, 0x6b, 0x5b, 0xae, 0xe5, 0xdc, 0xdc, 0xb2, 0x76, 0x76, 0x74, 0xb3, + 0xed, 0xcc, 0xe1, 0x77, 0x65, 0x42, 0x37, 0xf7, 0xdd, 0xfd, 0x2e, 0x82, 0xd7, 0x75, 0x2f, 0x6e, + 0xdd, 0xdc, 0x31, 0x36, 0x6e, 0xee, 0x6e, 0xdc, 0xbc, 0x63, 0xb5, 0x51, 0xc7, 0xff, 0x01, 0xbf, + 0xd0, 0xec, 0xf0, 0x86, 0xa8, 0x5c, 0x1d, 0xab, 0xa5, 0x77, 0x1c, 0xd7, 0xb2, 0x11, 0xcd, 0x79, + 0x3a, 0x2c, 0x12, 0xed, 0x21, 0xd3, 0xf5, 0x29, 0x5c, 0xb5, 0x65, 0x59, 0x5b, 0x1d, 0x44, 0xbe, + 0x6d, 0xec, 0x6e, 0xde, 0xec, 0xb8, 0xf6, 0x6e, 0xcb, 0xa5, 0x5f, 0xaf, 0xe9, 0xfd, 0xda, 0x46, + 0x4e, 0xcb, 0x36, 0xba, 0xae, 0x65, 0x93, 0x1c, 0xe7, 0x5e, 0xf9, 0x50, 0x01, 0xc8, 0x5a, 0xb7, + 0x05, 0xbf, 0x33, 0x01, 0xe4, 0x52, 0xb7, 0x0b, 0x3f, 0x2c, 0x01, 0xb0, 0x84, 0xdc, 0xf3, 0xc8, + 0x76, 0x0c, 0xcb, 0x84, 0xc7, 0xc1, 0x84, 0x86, 0x9e, 0xba, 0x8b, 0x1c, 0xf7, 0xf6, 0xec, 0xb3, + 0xbe, 0x2e, 0x67, 0xe0, 0x43, 0x12, 0x28, 0x68, 0xc8, 0xe9, 0x5a, 0xa6, 0x83, 0x94, 0xbb, 0x41, + 0x0e, 0xd9, 0xb6, 0x65, 0x9f, 0xc9, 0x5c, 0x93, 0xb9, 0x61, 0xea, 0xd6, 0x1b, 0xe7, 0x68, 0xf5, + 0xe7, 0xb4, 0x6e, 0x6b, 0xae, 0xd4, 0xed, 0xce, 0x85, 0x94, 0xe6, 0xfc, 0x9f, 0xe6, 0x54, 0xef, + 0x0f, 0x8d, 0xfc, 0xa8, 0x9c, 0x01, 0x13, 0x7b, 0x24, 0xc3, 0x19, 0xe9, 0x9a, 0xcc, 0x0d, 0x93, + 0x9a, 0xff, 0xea, 0x7d, 0x69, 0x23, 0x57, 0x37, 0x3a, 0xce, 0x19, 0x99, 0x7c, 0xa1, 0xaf, 0xf0, + 0x15, 0x19, 0x90, 0xc3, 0x44, 0x94, 0x32, 0xc8, 0xb6, 0xac, 0x36, 0xc2, 0xc5, 0xcf, 0xde, 0x7a, + 0xb3, 0x78, 0xf1, 0x73, 0x65, 0xab, 0x8d, 0x34, 0xfc, 0xb3, 0x72, 0x0d, 0x98, 0xf2, 0xc5, 0x12, + 0xb2, 0xc1, 0x26, 0x9d, 0xbb, 0x15, 0x64, 0xbd, 0xfc, 0x4a, 0x01, 0x64, 0xab, 0xeb, 0x2b, 0x2b, + 0xc5, 0x63, 0xca, 0x09, 0x30, 0xb3, 0x5e, 0xbd, 0xb7, 0x5a, 0xbb, 0x50, 0x6d, 0xaa, 0x9a, 0x56, + 0xd3, 0x8a, 0x19, 0x65, 0x06, 0x4c, 0xce, 0x97, 0x16, 0x9a, 0x95, 0xea, 0xda, 0x7a, 0xa3, 0x28, + 0xc1, 0x97, 0xca, 0x60, 0xb6, 0x8e, 0xdc, 0x05, 0xb4, 0x67, 0xb4, 0x50, 0xdd, 0xd5, 0x5d, 0x04, + 0x9f, 0x9b, 0x09, 0x84, 0xa9, 0xac, 0x7b, 0x85, 0x06, 0x9f, 0x68, 0x05, 0x1e, 0x77, 0xa0, 0x02, + 0x3c, 0x85, 0x39, 0xfa, 0xf7, 0x1c, 0x93, 0xa6, 0xb1, 0x74, 0xce, 0x3d, 0x06, 0x4c, 0x31, 0xdf, + 0x94, 0x59, 0x00, 0xe6, 0x4b, 0xe5, 0x7b, 0x97, 0xb4, 0xda, 0x7a, 0x75, 0xa1, 0x78, 0xcc, 0x7b, + 0x5f, 0xac, 0x69, 0x2a, 0x7d, 0xcf, 0xc0, 0xef, 0x65, 0x18, 0x30, 0x17, 0x78, 0x30, 0xe7, 0x06, + 0x33, 0xd3, 0x07, 0x50, 0xf8, 0xaa, 0x00, 0x9c, 0x25, 0x0e, 0x9c, 0xc7, 0x25, 0x23, 0x97, 0x3e, + 0x40, 0x0f, 0x4a, 0xa0, 0x50, 0xdf, 0xde, 0x75, 0xdb, 0xd6, 0x25, 0x13, 0x4e, 0x06, 0xc8, 0xc0, + 0x6f, 0xb2, 0x32, 0x79, 0x32, 0x2f, 0x93, 0x1b, 0x0e, 0x56, 0x82, 0x52, 0x88, 0x90, 0xc6, 0xef, + 0x05, 0xd2, 0x28, 0x71, 0xd2, 0x78, 0x8c, 0x28, 0xa1, 0xf4, 0xe5, 0xf0, 0xa2, 0x27, 0x82, 0x5c, + 0xbd, 0xab, 0xb7, 0x10, 0xfc, 0x84, 0x0c, 0xa6, 0x57, 0x90, 0xbe, 0x87, 0x4a, 0xdd, 0xae, 0x6d, + 0xed, 0x21, 0x58, 0x0e, 0xf5, 0xf5, 0x0c, 0x98, 0x70, 0xbc, 0x4c, 0x95, 0x36, 0xae, 0xc1, 0xa4, + 0xe6, 0xbf, 0x2a, 0x67, 0x01, 0x30, 0xda, 0xc8, 0x74, 0x0d, 0xd7, 0x40, 0xce, 0x19, 0xe9, 0x1a, + 0xf9, 0x86, 0x49, 0x8d, 0x49, 0x81, 0xdf, 0x91, 0x44, 0x75, 0x0c, 0x73, 0x31, 0xc7, 0x72, 0x10, + 0x21, 0xd5, 0x57, 0x4a, 0x22, 0x3a, 0x36, 0x90, 0x5c, 0x32, 0xd9, 0xbe, 0x3e, 0x93, 0x5c, 0xb8, + 0x5e, 0x8e, 0x6a, 0xad, 0x59, 0x5f, 0x2f, 0x2f, 0x37, 0xeb, 0x6b, 0xa5, 0xb2, 0x5a, 0x44, 0xca, + 0x49, 0x50, 0xc4, 0x8f, 0xcd, 0x4a, 0xbd, 0xb9, 0xa0, 0xae, 0xa8, 0x0d, 0x75, 0xa1, 0xb8, 0xa9, + 0x28, 0x60, 0x56, 0x53, 0x7f, 0x6a, 0x5d, 0xad, 0x37, 0x9a, 0x8b, 0xa5, 0xca, 0x8a, 0xba, 0x50, + 0xdc, 0xf2, 0x7e, 0x5e, 0xa9, 0xac, 0x56, 0x1a, 0x4d, 0x4d, 0x2d, 0x95, 0x97, 0xd5, 0x85, 0xe2, + 0xb6, 0x72, 0x39, 0xb8, 0xac, 0x5a, 0x6b, 0x96, 0xd6, 0xd6, 0xb4, 0xda, 0x79, 0xb5, 0x49, 0xff, + 0xa8, 0x17, 0x0d, 0x52, 0x50, 0xa3, 0x59, 0x5f, 0x2e, 0x69, 0x6a, 0x69, 0x7e, 0x45, 0x2d, 0xde, + 0x0f, 0x9f, 0x21, 0x83, 0x99, 0x55, 0xfd, 0x22, 0xaa, 0x6f, 0xeb, 0x36, 0xd2, 0x37, 0x3a, 0x08, + 0x5e, 0x2b, 0x80, 0x27, 0xfc, 0x04, 0x8b, 0x97, 0xca, 0xe3, 0x75, 0x73, 0x1f, 0x01, 0x73, 0x45, + 0x44, 0x00, 0xf6, 0x6f, 0x41, 0x33, 0x58, 0xe6, 0x00, 0x7b, 0x7c, 0x42, 0x7a, 0xc9, 0x10, 0xfb, + 0x85, 0x87, 0x01, 0x62, 0xf0, 0x4b, 0x32, 0x98, 0xad, 0x98, 0x7b, 0x86, 0x8b, 0x96, 0x90, 0x89, + 0x6c, 0x6f, 0x1c, 0x10, 0x82, 0xe1, 0x21, 0x99, 0x81, 0x61, 0x91, 0x87, 0xe1, 0xb1, 0x7d, 0xc4, + 0xc6, 0x97, 0x11, 0x31, 0xda, 0x5e, 0x05, 0x26, 0x0d, 0x9c, 0xaf, 0x6c, 0xb4, 0xa9, 0xc4, 0xc2, + 0x04, 0xe5, 0x3a, 0x30, 0x43, 0x5e, 0x16, 0x8d, 0x0e, 0xba, 0x17, 0xed, 0xd3, 0x71, 0x97, 0x4f, + 0x84, 0xbf, 0x1a, 0x34, 0xbe, 0x0a, 0x87, 0xe5, 0x4f, 0x24, 0x65, 0x2a, 0x19, 0x98, 0xcf, 0x7f, + 0x38, 0x34, 0xbf, 0x03, 0xad, 0xcc, 0x80, 0x3f, 0x90, 0xc0, 0x54, 0xdd, 0xb5, 0xba, 0x9e, 0xca, + 0x1a, 0xe6, 0x96, 0x18, 0xb8, 0x1f, 0x65, 0xdb, 0x58, 0x99, 0x07, 0xf7, 0x31, 0x7d, 0xe4, 0xc8, + 0x14, 0x10, 0xd1, 0xc2, 0xbe, 0x13, 0xb4, 0xb0, 0x45, 0x0e, 0x95, 0x5b, 0x13, 0x51, 0xfb, 0x21, + 0x6c, 0x5f, 0xcf, 0x97, 0x41, 0xd1, 0x57, 0x33, 0xb7, 0xbc, 0x6b, 0xdb, 0xc8, 0x74, 0xc5, 0x40, + 0xf8, 0x1b, 0x16, 0x84, 0x65, 0x1e, 0x84, 0x5b, 0x63, 0x94, 0xd9, 0x2f, 0x25, 0xc5, 0x36, 0xf6, + 0xfe, 0x00, 0xcd, 0x7b, 0x39, 0x34, 0x7f, 0x32, 0x39, 0x5b, 0xc9, 0x20, 0x5d, 0x1e, 0x02, 0xd1, + 0x93, 0xa0, 0xe8, 0x8d, 0x49, 0xe5, 0x46, 0xe5, 0xbc, 0xda, 0xac, 0x54, 0xcf, 0x57, 0x1a, 0x6a, + 0x11, 0xc1, 0xdf, 0x94, 0xc1, 0x34, 0x61, 0x4d, 0x43, 0x7b, 0xd6, 0x45, 0xc1, 0x5e, 0xef, 0x4b, + 0x09, 0x8d, 0x05, 0xb6, 0x84, 0x88, 0x96, 0xf1, 0x2b, 0x09, 0x8c, 0x85, 0x18, 0x72, 0x0f, 0xa7, + 0xde, 0xea, 0x40, 0x33, 0xd8, 0xea, 0xd3, 0x5a, 0xfa, 0xf6, 0x56, 0xcf, 0xcf, 0x02, 0x40, 0x2a, + 0x79, 0xde, 0x40, 0x97, 0xe0, 0x6a, 0x88, 0x09, 0xa7, 0xb6, 0x99, 0x81, 0x6a, 0x2b, 0xf5, 0x53, + 0xdb, 0x77, 0xb0, 0x63, 0xd6, 0x3c, 0x8f, 0xde, 0x4d, 0x91, 0xe2, 0xf6, 0x38, 0x89, 0x9e, 0x1d, + 0xfa, 0x8a, 0x22, 0xf1, 0x56, 0xe7, 0x55, 0x60, 0x12, 0x3f, 0x56, 0xf5, 0x1d, 0x44, 0xdb, 0x50, + 0x98, 0xa0, 0x9c, 0x03, 0xd3, 0x24, 0x63, 0xcb, 0x32, 0xbd, 0xfa, 0x64, 0x71, 0x06, 0x2e, 0xcd, + 0x03, 0xb1, 0x65, 0x23, 0xdd, 0xb5, 0x6c, 0x4c, 0x23, 0x47, 0x40, 0x64, 0x92, 0xe0, 0x37, 0x82, + 0x56, 0xa8, 0x72, 0x9a, 0x73, 0x4b, 0x92, 0xaa, 0x24, 0xd3, 0x9b, 0xbd, 0xe1, 0xda, 0x1f, 0x69, + 0x75, 0x4d, 0x0f, 0xed, 0x45, 0x3c, 0xb5, 0x43, 0xca, 0x69, 0xa0, 0xd0, 0x54, 0x2f, 0x6f, 0xb9, + 0x56, 0x6d, 0xa8, 0xd5, 0x46, 0x71, 0xb3, 0xaf, 0x46, 0x6d, 0xc1, 0x57, 0x66, 0x41, 0xf6, 0x1e, + 0xcb, 0x30, 0xe1, 0x83, 0x19, 0x4e, 0x25, 0x4c, 0xe4, 0x5e, 0xb2, 0xec, 0x8b, 0x41, 0x43, 0x0d, + 0x13, 0xe2, 0xb1, 0x09, 0x55, 0x49, 0x1e, 0xa8, 0x4a, 0xd9, 0x7e, 0xaa, 0xf4, 0x1b, 0xac, 0x2a, + 0xdd, 0xc1, 0xab, 0xd2, 0xf5, 0x7d, 0xe4, 0xef, 0x31, 0x1f, 0xd1, 0x01, 0x7c, 0x24, 0xe8, 0x00, + 0xee, 0xe2, 0x60, 0x7c, 0xb4, 0x18, 0x99, 0x64, 0x00, 0x7e, 0x31, 0xd5, 0x86, 0xdf, 0x0f, 0xea, + 0xad, 0x08, 0xa8, 0xb7, 0xfb, 0xf4, 0x09, 0xc6, 0xc1, 0xae, 0xe3, 0xfe, 0x83, 0xdd, 0xc4, 0x45, + 0xe5, 0x14, 0x38, 0xb1, 0x50, 0x59, 0x5c, 0x54, 0x35, 0xb5, 0xda, 0x68, 0x56, 0xd5, 0xc6, 0x85, + 0x9a, 0x76, 0x6f, 0xb1, 0x03, 0x5f, 0x21, 0x03, 0xe0, 0x49, 0xa8, 0xac, 0x9b, 0x2d, 0xd4, 0x11, + 0xeb, 0xd1, 0xff, 0x1f, 0x29, 0x59, 0x9f, 0x10, 0xd2, 0x8f, 0x80, 0xf3, 0x25, 0x92, 0x78, 0xab, + 0x8c, 0x24, 0x96, 0x0c, 0xd4, 0xd7, 0x3e, 0x1c, 0x6c, 0xcf, 0xcb, 0xc0, 0x71, 0x9f, 0x1e, 0xcd, + 0xde, 0x7f, 0xda, 0xf7, 0x86, 0x2c, 0x98, 0xa5, 0xb0, 0xf8, 0xf3, 0xf8, 0x67, 0x65, 0x44, 0x26, 0xf2, 0x10, 0x14, 0xe8, 0xb4, 0xdd, 0xef, 0xde, 0x83, 0x77, 0x65, 0x09, 0x4c, 0x75, 0x91, 0xbd, - 0x6d, 0x38, 0x8e, 0x61, 0x99, 0x64, 0x41, 0x6e, 0xf6, 0xe6, 0x47, 0x06, 0x12, 0xc7, 0x6b, 0x97, + 0x63, 0x38, 0x8e, 0x61, 0x99, 0x64, 0x41, 0x6e, 0xf6, 0xd6, 0x47, 0x06, 0x12, 0xc7, 0x6b, 0x97, 0x73, 0x6b, 0xba, 0xed, 0x1a, 0x2d, 0xa3, 0xab, 0x9b, 0xee, 0x5a, 0x98, 0x59, 0x63, 0xff, 0x84, - 0x2f, 0x48, 0x38, 0xad, 0xe1, 0x6b, 0x12, 0xa1, 0x12, 0x7f, 0x92, 0x60, 0x4a, 0x12, 0x4b, 0x30, - 0x99, 0x5a, 0x7c, 0x34, 0x55, 0xb5, 0xe8, 0x83, 0xf7, 0xa6, 0x72, 0x19, 0x38, 0x51, 0xa9, 0x96, + 0xcf, 0x4b, 0x38, 0xad, 0xe1, 0x6b, 0x12, 0xa1, 0x12, 0x7f, 0x9c, 0x60, 0x4a, 0x12, 0x4b, 0x30, + 0x99, 0x5a, 0x7c, 0x38, 0x55, 0xb5, 0xe8, 0x83, 0xf7, 0x96, 0x72, 0x05, 0x38, 0x55, 0xa9, 0x96, 0x6b, 0x9a, 0xa6, 0x96, 0x1b, 0xcd, 0x35, 0x55, 0x5b, 0xad, 0xd4, 0xeb, 0x95, 0x5a, 0xb5, 0x7e, - 0x90, 0xd6, 0x0e, 0x3f, 0x29, 0x07, 0x1a, 0xb3, 0x80, 0x5a, 0x1d, 0xc3, 0x44, 0xf0, 0x8e, 0x03, - 0x2a, 0x0c, 0xbf, 0xea, 0x23, 0x8e, 0x33, 0x2d, 0x3f, 0x02, 0xe7, 0x57, 0x26, 0xc7, 0xb9, 0x3f, - 0xc1, 0xff, 0xc4, 0xcd, 0xff, 0x21, 0x19, 0x1c, 0x63, 0x1a, 0xa2, 0x86, 0xb6, 0x47, 0xb6, 0x92, - 0xf7, 0x2b, 0x6c, 0xdb, 0xad, 0xf0, 0x98, 0xf6, 0xb3, 0xa6, 0xf7, 0xb1, 0x11, 0x01, 0xeb, 0xeb, - 0x02, 0x58, 0x57, 0x38, 0x58, 0x9f, 0x38, 0x04, 0xcd, 0x64, 0xc8, 0xbe, 0x39, 0x55, 0x64, 0x2f, - 0x03, 0x27, 0xd6, 0x4a, 0x5a, 0xa3, 0x52, 0xae, 0xac, 0x95, 0xbc, 0x71, 0x94, 0x19, 0xb2, 0x23, - 0xcc, 0x75, 0x1e, 0xf4, 0xbe, 0xf8, 0x7e, 0x20, 0x0b, 0xae, 0xe8, 0xdf, 0xd1, 0x96, 0xb7, 0x74, - 0x73, 0x13, 0x41, 0x43, 0x04, 0xea, 0x05, 0x30, 0xd1, 0xc2, 0xd9, 0x09, 0xce, 0xec, 0xd6, 0x4d, - 0x4c, 0x5f, 0x4e, 0x4a, 0xd0, 0xfc, 0x5f, 0xe1, 0xdb, 0x58, 0x85, 0x68, 0xf0, 0x0a, 0xf1, 0xe4, - 0x78, 0xf0, 0xf6, 0xf1, 0x1d, 0xa1, 0x1b, 0x9f, 0x09, 0x74, 0xe3, 0x1c, 0xa7, 0x1b, 0xe5, 0x83, - 0x91, 0x4f, 0xa6, 0x26, 0x7f, 0xfe, 0x70, 0xe8, 0x00, 0x22, 0xb5, 0xc9, 0x88, 0x1e, 0x15, 0xfa, - 0x76, 0xf7, 0xaf, 0x90, 0x41, 0x7e, 0x01, 0x75, 0x90, 0xe8, 0x4a, 0xe4, 0xb7, 0x25, 0xd1, 0x0d, - 0x11, 0x02, 0x03, 0xa1, 0x1d, 0xbd, 0x3a, 0xe2, 0x1a, 0xdb, 0xc8, 0x71, 0xf5, 0xed, 0x2e, 0x16, - 0xb5, 0xac, 0x85, 0x09, 0xf0, 0x57, 0x25, 0x91, 0xed, 0x92, 0x98, 0x62, 0xfe, 0x73, 0xac, 0x29, - 0x7e, 0x4e, 0x02, 0x85, 0x3a, 0x72, 0x6b, 0x76, 0x1b, 0xd9, 0xb0, 0x1e, 0x62, 0x74, 0x15, 0x98, - 0xc2, 0xa0, 0x78, 0xd3, 0xcc, 0x00, 0x27, 0x36, 0x49, 0xb9, 0x16, 0xcc, 0x06, 0xaf, 0xf8, 0x77, - 0xda, 0x8d, 0xf7, 0xa4, 0xc2, 0xef, 0x64, 0x44, 0x77, 0x71, 0xe9, 0x92, 0x21, 0xe5, 0x26, 0xa2, - 0x95, 0x8a, 0xed, 0xc8, 0xc6, 0x92, 0x4a, 0x7f, 0xa3, 0xeb, 0x2d, 0x12, 0x00, 0xeb, 0xa6, 0xe3, - 0xcb, 0xf5, 0xd1, 0x09, 0xe4, 0x0a, 0xff, 0x2d, 0x93, 0x6c, 0x16, 0x13, 0x96, 0x13, 0x21, 0xb1, - 0x3f, 0x4c, 0xb0, 0xb6, 0x10, 0x49, 0x2c, 0x7d, 0x99, 0x7d, 0x6d, 0x16, 0xe4, 0xcf, 0xe9, 0x9d, - 0x0e, 0x72, 0xe1, 0xd7, 0x25, 0x90, 0x2f, 0xdb, 0x48, 0x77, 0x11, 0x2b, 0x3a, 0x08, 0x0a, 0xb6, - 0x65, 0xb9, 0x6b, 0xba, 0xbb, 0x45, 0xe5, 0x16, 0xbc, 0x53, 0x87, 0x81, 0x3f, 0x66, 0xbb, 0x8f, - 0x3b, 0x78, 0xd1, 0xfd, 0x34, 0x57, 0x5b, 0x52, 0xd0, 0x1c, 0x29, 0x24, 0xa2, 0xff, 0x80, 0xa0, - 0xb0, 0x6d, 0xa2, 0x6d, 0xcb, 0x34, 0x5a, 0xbe, 0xcd, 0xe9, 0xbf, 0xc3, 0x0f, 0x05, 0x32, 0x9d, - 0xe7, 0x64, 0x3a, 0x27, 0x5c, 0x4a, 0x32, 0x81, 0xd6, 0x87, 0xe8, 0x3d, 0xae, 0x04, 0x97, 0x93, - 0xce, 0xa0, 0xd9, 0xa8, 0x35, 0xcb, 0x9a, 0x5a, 0x6a, 0xa8, 0xcd, 0x95, 0x5a, 0xb9, 0xb4, 0xd2, - 0xd4, 0xd4, 0xb5, 0x5a, 0x11, 0xc1, 0x7f, 0x92, 0x3c, 0xe1, 0xb6, 0xac, 0x5d, 0x64, 0xc3, 0x25, - 0x21, 0x39, 0xc7, 0xc9, 0x84, 0x62, 0xf0, 0x5b, 0xc2, 0x4e, 0x1b, 0x54, 0x3a, 0x94, 0x83, 0x08, - 0xe5, 0xfd, 0xb0, 0x50, 0x73, 0x8f, 0x25, 0xf5, 0x30, 0x90, 0xf4, 0xff, 0x90, 0xc0, 0x44, 0xd9, - 0x32, 0x77, 0x91, 0xed, 0xb2, 0xf3, 0x1d, 0x56, 0x9a, 0x19, 0x5e, 0x9a, 0xde, 0x20, 0x89, 0x4c, - 0xd7, 0xb6, 0xba, 0xfe, 0x84, 0xc7, 0x7f, 0x85, 0xaf, 0x49, 0x2a, 0x61, 0x5a, 0x72, 0xf4, 0xc2, - 0x67, 0xff, 0x82, 0x38, 0xf6, 0xe4, 0x9e, 0x06, 0xf0, 0x40, 0x12, 0x5c, 0xfa, 0x33, 0x90, 0x7e, - 0x97, 0xf2, 0x15, 0x19, 0xcc, 0x90, 0xc6, 0x57, 0x47, 0xd8, 0x42, 0x83, 0x35, 0x76, 0xc9, 0xb1, - 0x47, 0xf8, 0xcb, 0x47, 0x38, 0xf1, 0xe7, 0xf5, 0x6e, 0x37, 0x58, 0x7e, 0x5e, 0x3e, 0xa2, 0xd1, - 0x77, 0xa2, 0xe6, 0xf3, 0x79, 0x90, 0xd5, 0x77, 0xdc, 0x2d, 0xf8, 0x43, 0xe1, 0xc9, 0x27, 0xd7, - 0x19, 0x50, 0x7e, 0x22, 0x20, 0x39, 0x0e, 0x72, 0xae, 0x75, 0x01, 0xf9, 0x72, 0x20, 0x2f, 0x1e, - 0x1c, 0x7a, 0xb7, 0xdb, 0xc0, 0x1f, 0x28, 0x1c, 0xfe, 0xbb, 0x67, 0xeb, 0xe8, 0xad, 0x96, 0xb5, - 0x63, 0xba, 0x15, 0x7f, 0x09, 0x3a, 0x4c, 0x80, 0x5f, 0xcc, 0x88, 0x4c, 0x66, 0x05, 0x18, 0x4c, - 0x06, 0xd9, 0xf9, 0x21, 0x9a, 0xd2, 0x1c, 0xb8, 0xbe, 0xb4, 0xb6, 0xd6, 0x6c, 0xd4, 0xee, 0x56, - 0xab, 0xa1, 0xe1, 0xd9, 0xac, 0x54, 0x9b, 0x8d, 0x65, 0xb5, 0x59, 0x5e, 0xd7, 0xf0, 0x3a, 0x61, - 0xa9, 0x5c, 0xae, 0xad, 0x57, 0x1b, 0x45, 0x04, 0xdf, 0x20, 0x81, 0xe9, 0x72, 0xc7, 0x72, 0x02, - 0x84, 0xaf, 0x0c, 0x11, 0x0e, 0xc4, 0x98, 0x61, 0xc4, 0x08, 0xff, 0x67, 0x46, 0xd4, 0xe9, 0xc0, - 0x17, 0x08, 0x43, 0x3e, 0xa2, 0x97, 0x7a, 0x8d, 0x90, 0xd3, 0xc1, 0x60, 0x7a, 0xe9, 0x37, 0x89, - 0xd7, 0x2f, 0x80, 0x89, 0x12, 0x51, 0x0c, 0xf8, 0xf7, 0x19, 0x90, 0x2f, 0x5b, 0xe6, 0x86, 0xb1, - 0xe9, 0x19, 0x73, 0xc8, 0xd4, 0xcf, 0x77, 0xd0, 0x82, 0xee, 0xea, 0xbb, 0x06, 0xba, 0x88, 0x2b, - 0x50, 0xd0, 0x7a, 0x52, 0x3d, 0xa6, 0x68, 0x0a, 0x3a, 0xbf, 0xb3, 0x89, 0x99, 0x2a, 0x68, 0x6c, - 0x92, 0xf2, 0x44, 0x70, 0x29, 0x79, 0x5d, 0xb3, 0x91, 0x8d, 0x3a, 0x48, 0x77, 0x90, 0x37, 0x2d, - 0x32, 0x51, 0x07, 0x2b, 0x6d, 0x41, 0x8b, 0xfa, 0xac, 0x9c, 0x01, 0xd3, 0xe4, 0x13, 0x36, 0x45, - 0x1c, 0xac, 0xc6, 0x05, 0x8d, 0x4b, 0x53, 0x1e, 0x03, 0x72, 0xe8, 0x3e, 0xd7, 0xd6, 0x4f, 0xb5, - 0x31, 0x5e, 0x97, 0xce, 0x11, 0xaf, 0xc3, 0x39, 0xdf, 0xeb, 0x70, 0xae, 0x8e, 0x7d, 0x12, 0x35, - 0x92, 0x0b, 0x7e, 0xb2, 0x10, 0x18, 0x12, 0x6f, 0x90, 0x43, 0xc5, 0x50, 0x40, 0xd6, 0xd4, 0xb7, - 0x11, 0xd5, 0x0b, 0xfc, 0xac, 0x5c, 0x0f, 0x8e, 0xea, 0xbb, 0xba, 0xab, 0xdb, 0x2b, 0x56, 0x4b, - 0xef, 0xe0, 0xc1, 0xcf, 0x6f, 0xf9, 0xbd, 0x1f, 0xf0, 0x8e, 0x90, 0x6b, 0xd9, 0x08, 0xe7, 0xf2, - 0x77, 0x84, 0xfc, 0x04, 0x8f, 0xba, 0xd1, 0xb2, 0x4c, 0xcc, 0xbf, 0xac, 0xe1, 0x67, 0x4f, 0x2a, - 0x6d, 0xc3, 0xf1, 0x2a, 0x82, 0xa9, 0x54, 0xc9, 0xd6, 0x46, 0x7d, 0xcf, 0x6c, 0xe1, 0xdd, 0xa0, - 0x82, 0x16, 0xf5, 0x59, 0x99, 0x07, 0x53, 0x74, 0x23, 0x64, 0xd5, 0xd3, 0xab, 0x3c, 0xd6, 0xab, - 0xab, 0x78, 0x9f, 0x2e, 0x82, 0xe7, 0x5c, 0x35, 0xcc, 0xa7, 0xb1, 0x3f, 0x29, 0x77, 0x82, 0xcb, - 0xe9, 0x6b, 0x79, 0xc7, 0x71, 0xad, 0x6d, 0x02, 0xfa, 0xa2, 0xd1, 0x21, 0x35, 0x98, 0xc0, 0x35, - 0x88, 0xcb, 0xa2, 0xdc, 0x0c, 0x8e, 0x77, 0x6d, 0xb4, 0x81, 0xec, 0x7b, 0xf4, 0xed, 0x9d, 0xfb, - 0x1a, 0xb6, 0x6e, 0x3a, 0x5d, 0xcb, 0x76, 0x4f, 0x15, 0x30, 0xf3, 0x7d, 0xbf, 0x29, 0x37, 0x80, - 0x63, 0xf7, 0x3a, 0x96, 0x59, 0xea, 0x1a, 0x2b, 0x86, 0xe3, 0x22, 0xb3, 0xd4, 0x6e, 0xdb, 0xa7, - 0x26, 0x71, 0x59, 0xfb, 0x3f, 0xd0, 0x6e, 0xb5, 0x00, 0xf2, 0x44, 0xd8, 0xf0, 0xf9, 0x39, 0x61, - 0xe7, 0x4f, 0x5a, 0xfd, 0x58, 0x63, 0xee, 0xb1, 0x60, 0x82, 0xf6, 0x87, 0x18, 0xd6, 0xa9, 0x9b, - 0x4f, 0xf6, 0xac, 0x42, 0x50, 0x2a, 0x9a, 0x9f, 0x4d, 0x79, 0x1c, 0xc8, 0xb7, 0xb0, 0x10, 0x30, - 0xc2, 0x53, 0x37, 0x5f, 0xde, 0xbf, 0x50, 0x9c, 0x45, 0xa3, 0x59, 0xe1, 0x97, 0x64, 0x21, 0x7f, - 0xd1, 0x38, 0x8e, 0x93, 0xf5, 0x01, 0xdf, 0x94, 0x86, 0xe8, 0x64, 0x6f, 0x00, 0xd7, 0xd1, 0x1e, - 0x94, 0x5a, 0x2b, 0x0b, 0xcd, 0xf9, 0x75, 0x7f, 0xea, 0xe8, 0xd9, 0x30, 0xf5, 0x46, 0x49, 0xf3, - 0xe6, 0xfd, 0x0b, 0xde, 0x94, 0xf3, 0x7a, 0x70, 0xed, 0x80, 0xdc, 0x6a, 0xa3, 0x59, 0x2d, 0xad, - 0xaa, 0xc5, 0x0d, 0xde, 0x12, 0xaa, 0x37, 0x6a, 0x6b, 0x4d, 0x6d, 0xbd, 0x5a, 0xad, 0x54, 0x97, - 0x08, 0x31, 0xcf, 0x80, 0x3c, 0x19, 0x66, 0x38, 0xa7, 0x55, 0x1a, 0x6a, 0xb3, 0x5c, 0xab, 0x2e, - 0x56, 0x96, 0x8a, 0xc6, 0x20, 0x33, 0xea, 0x5e, 0xe5, 0x2a, 0x70, 0x05, 0xc7, 0x49, 0xa5, 0x56, - 0xf5, 0xe6, 0xc1, 0xe5, 0x52, 0xb5, 0xac, 0x7a, 0x93, 0xde, 0x0b, 0x0a, 0x04, 0x27, 0x08, 0xb9, - 0xe6, 0x62, 0x65, 0x85, 0xdd, 0xba, 0xfa, 0x78, 0x46, 0x39, 0x05, 0x2e, 0x61, 0xbf, 0x55, 0xaa, - 0x67, 0x4b, 0x2b, 0x95, 0x85, 0xe2, 0x27, 0x32, 0xca, 0x35, 0xe0, 0x4a, 0xee, 0x2f, 0xb2, 0x0b, - 0xd5, 0xac, 0x2c, 0x34, 0x57, 0x2b, 0xf5, 0xd5, 0x52, 0xa3, 0xbc, 0x5c, 0xfc, 0x24, 0x9e, 0x5d, - 0x04, 0xe6, 0x32, 0xe3, 0xc4, 0xf9, 0x22, 0xd6, 0x02, 0x28, 0xf1, 0x8a, 0xfa, 0xe8, 0xbe, 0xb0, - 0xc7, 0x5b, 0xbc, 0x1f, 0x0d, 0xc6, 0x92, 0x05, 0x4e, 0x85, 0x1e, 0x9b, 0x80, 0x56, 0x32, 0x1d, - 0x6a, 0x0c, 0xa1, 0x42, 0x57, 0x81, 0x2b, 0xaa, 0x2a, 0x41, 0x4a, 0x53, 0xcb, 0xb5, 0xb3, 0xaa, - 0xd6, 0x3c, 0x57, 0x5a, 0x59, 0x51, 0x1b, 0xcd, 0xc5, 0x8a, 0x56, 0x6f, 0x14, 0x37, 0xe0, 0xbf, - 0x49, 0xc1, 0xda, 0x0f, 0x23, 0xad, 0xbf, 0x97, 0x92, 0x36, 0xeb, 0xd8, 0x35, 0x9e, 0x9f, 0x01, - 0x79, 0xc7, 0xd5, 0xdd, 0x1d, 0x87, 0xb6, 0xea, 0x47, 0xf4, 0x6f, 0xd5, 0x73, 0x75, 0x9c, 0x49, - 0xa3, 0x99, 0xe1, 0x97, 0x32, 0x49, 0x9a, 0xe9, 0x08, 0x96, 0x7f, 0x8c, 0x21, 0x44, 0x7c, 0x1a, - 0x40, 0x5f, 0xdb, 0x2b, 0xf5, 0x66, 0x69, 0x45, 0x53, 0x4b, 0x0b, 0xf7, 0x04, 0x8b, 0x3e, 0x48, - 0x39, 0x01, 0x8e, 0xad, 0x57, 0x4b, 0xf3, 0x2b, 0x2a, 0x6e, 0x2e, 0xb5, 0x6a, 0x55, 0x2d, 0x7b, - 0x72, 0xff, 0x55, 0xbc, 0xc5, 0xe2, 0xd9, 0xdb, 0x98, 0x6f, 0xcf, 0x26, 0x62, 0xe4, 0xff, 0x0d, - 0x61, 0x4f, 0xa4, 0x50, 0xc3, 0x58, 0x5a, 0xa3, 0xc5, 0xe1, 0x8b, 0x42, 0xce, 0x47, 0x42, 0x9c, - 0x24, 0xc3, 0xe3, 0x97, 0x86, 0xc0, 0xe3, 0x04, 0x38, 0xc6, 0xe2, 0x81, 0x9d, 0x90, 0xa2, 0x61, - 0xf8, 0x81, 0x04, 0x26, 0x56, 0x8d, 0x4d, 0xec, 0x85, 0xf9, 0xa4, 0xd0, 0xf4, 0x98, 0x05, 0x52, - 0xe0, 0xf4, 0x22, 0x19, 0x6d, 0x6e, 0xb2, 0x2d, 0xf5, 0x5d, 0xd4, 0x78, 0x5b, 0xe2, 0xfe, 0x85, - 0x16, 0x1b, 0xd1, 0xbf, 0x7c, 0x2d, 0x51, 0xff, 0xd2, 0x9f, 0x56, 0x32, 0x61, 0xdb, 0x07, 0x13, - 0x36, 0xeb, 0x6a, 0x32, 0x0d, 0x0a, 0x41, 0x6f, 0x8f, 0x77, 0x3d, 0xbc, 0x8f, 0x6a, 0xb5, 0xb6, - 0xbe, 0xb4, 0xdc, 0x5c, 0xd4, 0x54, 0x95, 0xae, 0x93, 0x6e, 0xc2, 0xb7, 0x4a, 0x60, 0x86, 0xf2, - 0x4e, 0x5d, 0x08, 0xae, 0x8c, 0x04, 0x81, 0x0a, 0xfa, 0x47, 0xec, 0xc4, 0x60, 0x89, 0x17, 0xf4, - 0x4d, 0x71, 0xc2, 0x89, 0xf5, 0x21, 0x78, 0x6d, 0x20, 0xee, 0xbb, 0x38, 0x71, 0x3f, 0x21, 0x31, - 0xc5, 0xf4, 0x27, 0x07, 0x6f, 0x9a, 0x04, 0xf9, 0x3a, 0xea, 0xa0, 0x96, 0x0b, 0x1f, 0x92, 0x86, - 0xd2, 0xd9, 0x38, 0x43, 0x57, 0x4e, 0x64, 0xe8, 0x66, 0x53, 0x30, 0x74, 0x73, 0xc3, 0x1b, 0xba, - 0xf9, 0xa4, 0x86, 0xee, 0x44, 0xac, 0xa1, 0x0b, 0x3f, 0x92, 0x4f, 0x3a, 0x0e, 0x12, 0x60, 0x0e, - 0xd7, 0xbc, 0xfd, 0x8d, 0x5c, 0x92, 0x71, 0xb3, 0x2f, 0xc7, 0xc9, 0xb4, 0xf8, 0x65, 0xd9, 0x14, - 0x96, 0xe3, 0x94, 0xab, 0xc1, 0x95, 0xe1, 0x7b, 0x53, 0x7d, 0x4a, 0xa5, 0xde, 0xa8, 0x63, 0x9b, - 0xb6, 0x5c, 0xd3, 0xb4, 0xf5, 0x35, 0xb2, 0xa7, 0x72, 0x12, 0x28, 0x21, 0x15, 0x6d, 0xbd, 0x4a, - 0x2c, 0xd8, 0x4d, 0x9e, 0xfa, 0x62, 0xa5, 0xba, 0xd0, 0x0c, 0x46, 0x85, 0xea, 0x62, 0xad, 0xb8, - 0xa5, 0xcc, 0x81, 0xeb, 0x19, 0xea, 0xb8, 0x83, 0x22, 0x25, 0x94, 0xaa, 0x0b, 0xcd, 0xd5, 0xaa, - 0xba, 0x5a, 0xab, 0x56, 0xca, 0x38, 0xbd, 0xae, 0x36, 0x8a, 0x86, 0x67, 0x4a, 0xf5, 0xd8, 0xcc, - 0x75, 0xb5, 0xa4, 0x95, 0x97, 0x55, 0x8d, 0x14, 0x79, 0xaf, 0x72, 0x2d, 0x38, 0x53, 0xaa, 0xd6, - 0x1a, 0x5e, 0x4a, 0xa9, 0x7a, 0x4f, 0xe3, 0x9e, 0x35, 0xb5, 0xb9, 0xa6, 0xd5, 0xca, 0x6a, 0xbd, - 0xee, 0x8d, 0x44, 0xd4, 0xc2, 0x2e, 0x76, 0x94, 0x27, 0x83, 0x5b, 0x19, 0xd6, 0xd4, 0x06, 0xde, - 0xc0, 0x5f, 0xad, 0x61, 0x1f, 0xae, 0x05, 0xb5, 0xb9, 0x5c, 0xaa, 0x37, 0x2b, 0xd5, 0x72, 0x6d, - 0x75, 0xad, 0xd4, 0xa8, 0x78, 0x03, 0xd6, 0x9a, 0x56, 0x6b, 0xd4, 0x9a, 0x67, 0x55, 0xad, 0x5e, - 0xa9, 0x55, 0x8b, 0xa6, 0x57, 0x65, 0x66, 0x84, 0xf3, 0x2d, 0x0d, 0x4b, 0xb9, 0x02, 0x9c, 0xf2, - 0xd3, 0x57, 0x6a, 0x9e, 0xa0, 0x19, 0x9b, 0xbb, 0xcb, 0xda, 0x29, 0xf5, 0x46, 0x4d, 0x23, 0x56, - 0xf7, 0x6a, 0x65, 0x49, 0xf3, 0xa6, 0x0a, 0xc5, 0xa7, 0xa6, 0x6a, 0x93, 0xff, 0x87, 0x04, 0xb2, - 0x75, 0xd7, 0xea, 0xc2, 0x9f, 0x0e, 0xbb, 0xab, 0xd3, 0x00, 0xd8, 0x78, 0xbf, 0x7e, 0x41, 0x77, - 0x75, 0xba, 0x8e, 0xc1, 0xa4, 0xc0, 0x3f, 0x13, 0xde, 0x64, 0x0c, 0xad, 0x16, 0xab, 0x1b, 0xd1, - 0xbd, 0x7f, 0x5f, 0xec, 0xd4, 0x55, 0x34, 0xa1, 0x64, 0xed, 0xe1, 0xd7, 0x86, 0xd9, 0x46, 0x84, - 0xe0, 0x24, 0x03, 0xab, 0x27, 0x7f, 0x5f, 0x65, 0x90, 0x72, 0x29, 0xb8, 0xa4, 0x47, 0xf9, 0xb0, - 0xce, 0x6d, 0x28, 0x3f, 0x05, 0x1e, 0xc1, 0xa8, 0xbf, 0xba, 0x5a, 0x3b, 0xab, 0x06, 0x8a, 0xbe, - 0x50, 0x6a, 0x94, 0x8a, 0x9b, 0xf0, 0x73, 0x32, 0xc8, 0xae, 0x5a, 0xbb, 0xbd, 0x7b, 0xbb, 0x26, - 0xba, 0xc8, 0xec, 0x1d, 0xf8, 0xaf, 0xfc, 0x29, 0x13, 0x21, 0xb1, 0xaf, 0x46, 0xfb, 0x71, 0x7c, - 0x51, 0x4a, 0x22, 0xf6, 0xd5, 0x83, 0x3a, 0x6f, 0xfc, 0xf3, 0x30, 0x62, 0x8f, 0x10, 0x2d, 0x52, - 0xce, 0x80, 0xd3, 0xe1, 0x87, 0xca, 0x82, 0x5a, 0x6d, 0x54, 0x16, 0xef, 0x09, 0x85, 0x5b, 0xd1, - 0x84, 0xc4, 0x3f, 0xa8, 0x9b, 0x8b, 0x9f, 0x6b, 0x9f, 0x02, 0xc7, 0xc3, 0x6f, 0x4b, 0x6a, 0xc3, - 0xff, 0x72, 0x2f, 0xbc, 0x3f, 0x07, 0xa6, 0x49, 0xb7, 0xbf, 0xde, 0x6d, 0x7b, 0xd6, 0xeb, 0xe3, - 0x42, 0x74, 0xaf, 0x03, 0x47, 0x2b, 0x6b, 0x8b, 0xf5, 0xba, 0x6b, 0xd9, 0xfa, 0x26, 0xc2, 0xe3, - 0x1c, 0x91, 0x56, 0x6f, 0x32, 0x7c, 0x87, 0xf0, 0xba, 0x38, 0x3f, 0xd4, 0x90, 0x32, 0x23, 0x50, - 0xff, 0x8a, 0xd0, 0x3a, 0xb6, 0x00, 0xc1, 0x64, 0xe8, 0xdf, 0x3b, 0xe2, 0x36, 0x17, 0x8d, 0xcb, - 0xc6, 0x99, 0x67, 0x49, 0x60, 0xb2, 0x61, 0x6c, 0xa3, 0xa7, 0x59, 0x26, 0x72, 0x94, 0x09, 0x20, - 0x2f, 0xad, 0x36, 0x8a, 0x47, 0xbc, 0x07, 0x6f, 0x5a, 0x91, 0xc1, 0x0f, 0xaa, 0x57, 0x80, 0xf7, - 0x50, 0x6a, 0x14, 0x65, 0xef, 0x61, 0x55, 0x6d, 0x14, 0xb3, 0xde, 0x43, 0x55, 0x6d, 0x14, 0x73, - 0xde, 0xc3, 0xda, 0x4a, 0xa3, 0x98, 0xf7, 0x1e, 0x2a, 0xf5, 0x46, 0x71, 0xc2, 0x7b, 0x98, 0xaf, - 0x37, 0x8a, 0x05, 0xef, 0xe1, 0x6c, 0xbd, 0x51, 0x9c, 0xf4, 0x1e, 0xca, 0x8d, 0x46, 0x11, 0x78, - 0x0f, 0x77, 0xd5, 0x1b, 0xc5, 0x29, 0xef, 0xa1, 0x54, 0x6e, 0x14, 0xa7, 0xf1, 0x83, 0xda, 0x28, - 0xce, 0x78, 0x0f, 0xf5, 0x7a, 0xa3, 0x38, 0x8b, 0x29, 0xd7, 0x1b, 0xc5, 0xa3, 0xb8, 0xac, 0x4a, - 0xa3, 0x58, 0xf4, 0x1e, 0x96, 0xeb, 0x8d, 0xe2, 0x31, 0x9c, 0xb9, 0xde, 0x28, 0x2a, 0xb8, 0xd0, - 0x7a, 0xa3, 0x78, 0x09, 0xce, 0x53, 0x6f, 0x14, 0x8f, 0xe3, 0x22, 0xea, 0x8d, 0xe2, 0x09, 0xcc, - 0x86, 0xda, 0x28, 0x9e, 0xc4, 0x79, 0xb4, 0x46, 0xf1, 0x52, 0xfc, 0xa9, 0xda, 0x28, 0x9e, 0xc2, - 0x8c, 0xa9, 0x8d, 0xe2, 0x65, 0xf8, 0x41, 0x6b, 0x14, 0x21, 0xfe, 0x54, 0x6a, 0x14, 0x2f, 0x87, - 0x8f, 0x00, 0x93, 0x4b, 0xc8, 0x25, 0x20, 0xc2, 0x22, 0x90, 0x97, 0x90, 0xcb, 0x4e, 0x64, 0xbf, - 0x26, 0x83, 0x4b, 0xe9, 0xe2, 0xc7, 0xa2, 0x6d, 0x6d, 0xaf, 0xa0, 0x4d, 0xbd, 0xb5, 0xa7, 0xde, - 0xe7, 0x19, 0x64, 0xac, 0x1f, 0x83, 0x02, 0xb2, 0xdd, 0xb0, 0x33, 0xc2, 0xcf, 0xb1, 0xf6, 0xab, - 0xbf, 0x78, 0x2b, 0x87, 0x8b, 0xb7, 0xd4, 0x62, 0xfb, 0x57, 0x56, 0xa3, 0xb9, 0xfd, 0x96, 0x4c, - 0xcf, 0x7e, 0x8b, 0xd7, 0x4c, 0xba, 0xc8, 0x76, 0x2c, 0x53, 0xef, 0xd4, 0xa9, 0xa3, 0x0b, 0x59, - 0x25, 0xee, 0x4d, 0x56, 0x7e, 0xce, 0x6f, 0x19, 0xc4, 0x6a, 0x7b, 0x52, 0xdc, 0x1a, 0x4f, 0x6f, - 0x35, 0x23, 0x1a, 0xc9, 0x27, 0x83, 0x46, 0xd2, 0xe0, 0x1a, 0xc9, 0x9d, 0x07, 0xa0, 0x9d, 0xac, - 0xbd, 0x54, 0x86, 0x9b, 0xef, 0x85, 0x6e, 0xe0, 0xfe, 0xf6, 0x8e, 0x0c, 0x3f, 0x27, 0x81, 0x93, - 0xaa, 0xd9, 0x6f, 0xbe, 0xc0, 0xea, 0xc2, 0x1b, 0x58, 0x68, 0xd6, 0x78, 0x91, 0xde, 0xda, 0xb7, - 0xda, 0xfd, 0x69, 0x46, 0x48, 0xf4, 0xd3, 0x81, 0x44, 0xeb, 0x9c, 0x44, 0xef, 0x18, 0x9e, 0x74, - 0x32, 0x81, 0x56, 0x47, 0xda, 0x01, 0x65, 0xe1, 0xd7, 0x25, 0x70, 0x8c, 0xf8, 0xaa, 0xdd, 0x45, - 0xa6, 0x27, 0xb8, 0xcb, 0xe6, 0x4d, 0xa8, 0x4e, 0x38, 0x95, 0x21, 0xfa, 0xcd, 0xa4, 0xc0, 0x57, - 0xb1, 0x02, 0xbf, 0x9b, 0x17, 0x78, 0x44, 0x67, 0xdc, 0x5b, 0x5c, 0x84, 0xac, 0x3f, 0x11, 0xc8, - 0xba, 0xca, 0xc9, 0xfa, 0xd6, 0xa1, 0xa8, 0x1e, 0xae, 0x98, 0xbf, 0x99, 0x05, 0x8f, 0x20, 0x1c, - 0x52, 0x45, 0x20, 0x9d, 0x59, 0xc9, 0x6c, 0x6b, 0xc8, 0x71, 0x75, 0xdb, 0xe5, 0xc2, 0x34, 0xf4, - 0xcc, 0x7f, 0x33, 0x29, 0xcc, 0x7f, 0xa5, 0x81, 0xf3, 0x5f, 0xf8, 0x76, 0xd6, 0x4a, 0x3b, 0xc7, - 0x23, 0x5b, 0x8a, 0xc1, 0x20, 0xa2, 0x86, 0x51, 0x2d, 0x2a, 0x30, 0xdf, 0x7e, 0x9e, 0x43, 0x79, - 0xf1, 0xc0, 0x25, 0x24, 0x43, 0xfc, 0xcf, 0x46, 0x6b, 0x4e, 0x67, 0xd9, 0x6f, 0xbc, 0xed, 0x57, - 0x6c, 0xa7, 0x3a, 0x0f, 0x7a, 0x41, 0x01, 0x4c, 0xe2, 0x2e, 0x67, 0xc5, 0x30, 0x2f, 0x78, 0x63, - 0xe3, 0x74, 0x15, 0x5d, 0x2c, 0x6f, 0xe9, 0x9d, 0x0e, 0x32, 0x37, 0x11, 0xbc, 0x97, 0x33, 0xd0, - 0xf5, 0x6e, 0xb7, 0x1a, 0x6e, 0x7f, 0xfa, 0xaf, 0xca, 0x1d, 0x20, 0xe7, 0xb4, 0xac, 0x2e, 0xc2, - 0x82, 0x9a, 0x65, 0x1c, 0xa6, 0xf8, 0x25, 0xdc, 0xd2, 0x8e, 0xbb, 0x35, 0x87, 0xcb, 0x2a, 0x75, - 0x8d, 0xba, 0xf7, 0x83, 0x46, 0xfe, 0xa3, 0xe3, 0xe4, 0x37, 0xfa, 0x76, 0xc6, 0x99, 0x98, 0xce, - 0x38, 0x60, 0x7c, 0x8e, 0x65, 0x3a, 0x62, 0xa5, 0xe3, 0x2a, 0x30, 0xd5, 0xf2, 0xb3, 0x04, 0xe7, - 0xc1, 0xd8, 0x24, 0xf8, 0x8f, 0x89, 0xba, 0x6b, 0xa1, 0xc2, 0x93, 0x69, 0x15, 0x1a, 0xb1, 0xbd, - 0x78, 0x02, 0x1c, 0x6b, 0xd4, 0x6a, 0xcd, 0xd5, 0x52, 0xf5, 0x9e, 0x30, 0x0e, 0xc3, 0x06, 0x7c, - 0x59, 0x16, 0xcc, 0xd6, 0xad, 0xce, 0x2e, 0x0a, 0x71, 0xae, 0x70, 0x8e, 0x86, 0xac, 0x9c, 0x32, - 0xfb, 0xe4, 0xa4, 0x9c, 0x04, 0x79, 0xdd, 0x74, 0x2e, 0x22, 0xdf, 0x86, 0xa7, 0x6f, 0x14, 0xc6, - 0x0f, 0xb0, 0x1d, 0x81, 0xc6, 0xc3, 0x78, 0xdb, 0x00, 0x49, 0xf2, 0x5c, 0x45, 0x00, 0x79, 0x06, - 0x4c, 0x3b, 0xc4, 0x09, 0xa2, 0xc1, 0xf8, 0xba, 0x70, 0x69, 0x98, 0x45, 0xe2, 0x85, 0x23, 0x53, - 0x16, 0xf1, 0x1b, 0x7c, 0x20, 0xe8, 0x3f, 0xd6, 0x39, 0x88, 0x4b, 0x07, 0x61, 0x2c, 0x19, 0xc8, - 0xaf, 0x18, 0xf5, 0x4c, 0xfc, 0x14, 0x38, 0x4e, 0x9b, 0x7d, 0xb3, 0xbc, 0x5c, 0x5a, 0x59, 0x51, - 0xab, 0x4b, 0x6a, 0xb3, 0xb2, 0x40, 0x36, 0x55, 0xc3, 0x94, 0x52, 0xa3, 0xa1, 0xae, 0xae, 0x35, - 0xea, 0x4d, 0xf5, 0x29, 0x65, 0x55, 0x5d, 0xc0, 0xae, 0xbe, 0xf8, 0xac, 0x9e, 0xef, 0x94, 0x5d, - 0xaa, 0xd6, 0xcf, 0xa9, 0x5a, 0x71, 0xeb, 0x4c, 0x09, 0x4c, 0x31, 0x03, 0x85, 0xc7, 0xdd, 0x02, - 0xda, 0xd0, 0x77, 0x3a, 0xd4, 0xa6, 0x2e, 0x1e, 0xf1, 0xb8, 0xc3, 0xb2, 0xa9, 0x99, 0x9d, 0xbd, - 0x62, 0x46, 0x29, 0x82, 0x69, 0x76, 0x4c, 0x28, 0x4a, 0xf0, 0x2d, 0x57, 0x80, 0xc9, 0x73, 0x96, - 0x7d, 0x01, 0xfb, 0xa7, 0xc2, 0x77, 0x93, 0x78, 0x4d, 0xfe, 0xc9, 0x77, 0xc6, 0x00, 0x7b, 0x85, - 0xb8, 0x17, 0x94, 0x4f, 0x6d, 0x6e, 0xe0, 0xe9, 0xf6, 0xab, 0xc0, 0xd4, 0x45, 0x3f, 0x77, 0xd8, - 0xd2, 0x99, 0x24, 0xf8, 0x47, 0x62, 0x7e, 0x4d, 0x83, 0x8b, 0x1c, 0xc3, 0xd2, 0xba, 0x04, 0xf2, - 0x4b, 0xc8, 0x2d, 0x75, 0x3a, 0xac, 0xdc, 0x5e, 0x2c, 0x7c, 0x62, 0x91, 0xab, 0x44, 0xa9, 0xd3, - 0x89, 0x6e, 0x54, 0x8c, 0x80, 0xfc, 0x93, 0x35, 0x5c, 0x9a, 0xa0, 0x3f, 0xf0, 0x80, 0x02, 0xd3, - 0x97, 0xd8, 0x87, 0xe4, 0xc0, 0x77, 0xe7, 0x41, 0xc6, 0x4c, 0xba, 0x29, 0x8c, 0xd5, 0x95, 0x89, - 0xf7, 0x01, 0xf2, 0xf3, 0x29, 0x77, 0x83, 0x89, 0x1d, 0x07, 0x95, 0x75, 0xc7, 0x1f, 0xda, 0xf8, - 0x9a, 0xd6, 0xce, 0xdf, 0x8b, 0x5a, 0xee, 0x5c, 0x65, 0xdb, 0x9b, 0xf8, 0xac, 0x93, 0x8c, 0x41, - 0xf8, 0x2b, 0xfa, 0xae, 0xf9, 0x14, 0xbc, 0xc9, 0xe3, 0x45, 0xc3, 0xdd, 0x2a, 0x6f, 0xe9, 0x2e, - 0xdd, 0xd1, 0x08, 0xde, 0xe1, 0xf3, 0x87, 0x80, 0x33, 0xd6, 0x6b, 0x25, 0xf2, 0xe0, 0x73, 0x62, - 0x10, 0x47, 0xe0, 0x6a, 0x32, 0x0c, 0x88, 0xff, 0x22, 0x81, 0x6c, 0xad, 0x8b, 0x4c, 0xe1, 0x53, - 0x7e, 0x81, 0x6c, 0xa5, 0x1e, 0xd9, 0x3e, 0x20, 0xee, 0xf5, 0x1a, 0x54, 0xda, 0x2b, 0x39, 0x42, - 0xb2, 0x37, 0x82, 0xac, 0x61, 0x6e, 0x58, 0xd4, 0xb2, 0xbd, 0x3c, 0xc2, 0xd6, 0xa9, 0x98, 0x1b, - 0x96, 0x86, 0x33, 0x8a, 0x3a, 0xbc, 0xc6, 0x95, 0x9d, 0xbe, 0xb8, 0xbf, 0x55, 0x00, 0x79, 0xa2, - 0xce, 0xf0, 0x45, 0x32, 0x90, 0x4b, 0xed, 0x76, 0x84, 0xe0, 0xa5, 0x7d, 0x82, 0xb7, 0xf0, 0x6f, - 0x01, 0x26, 0xc1, 0x3b, 0x1f, 0xa4, 0x49, 0xb0, 0x6f, 0xa7, 0x4d, 0xaa, 0xd4, 0x6e, 0x47, 0xfb, - 0xd6, 0x07, 0x05, 0x4a, 0x7c, 0x81, 0x6c, 0x0b, 0x97, 0xc5, 0x5a, 0x78, 0xe2, 0x81, 0x20, 0x92, - 0xbf, 0xf4, 0x21, 0xfa, 0x57, 0x09, 0x4c, 0xac, 0x18, 0x8e, 0xeb, 0x61, 0x53, 0x12, 0xc1, 0xe6, - 0x0a, 0x30, 0xe9, 0x8b, 0xc6, 0xeb, 0xf2, 0xbc, 0xfe, 0x3c, 0x4c, 0xe0, 0x67, 0xe2, 0x77, 0xf1, - 0xe8, 0x3c, 0x3e, 0xbe, 0xf6, 0x94, 0x8b, 0xe8, 0xd3, 0x53, 0x61, 0xb1, 0x52, 0x6f, 0xb1, 0x7f, - 0x1c, 0x08, 0x7c, 0x95, 0x13, 0xf8, 0x2d, 0xc3, 0x14, 0x99, 0xbe, 0xd0, 0x3f, 0x2f, 0x01, 0xe0, - 0x95, 0x4d, 0x8f, 0xa8, 0x3e, 0x8a, 0x0b, 0x3c, 0x11, 0x23, 0xdd, 0x97, 0xb1, 0xd2, 0x5d, 0xe5, - 0xa5, 0xfb, 0xb3, 0x83, 0xab, 0x1a, 0x77, 0x14, 0x55, 0x29, 0x02, 0xd9, 0x08, 0x44, 0xeb, 0x3d, - 0xc2, 0x37, 0x05, 0x42, 0x5d, 0xe3, 0x84, 0x7a, 0xdb, 0x90, 0x25, 0xa5, 0x2f, 0xd7, 0xbf, 0x95, - 0xc0, 0x44, 0x1d, 0xb9, 0x5e, 0x37, 0x09, 0xcf, 0x8a, 0xf4, 0xf0, 0x4c, 0xdb, 0x96, 0x04, 0xdb, - 0xf6, 0xf7, 0x32, 0xa2, 0x01, 0xac, 0x42, 0xc9, 0x50, 0x9e, 0x22, 0x56, 0x1f, 0x1e, 0x14, 0x0a, - 0x60, 0x35, 0x88, 0x5a, 0xfa, 0xd2, 0x7d, 0x83, 0x14, 0xb8, 0x63, 0xf0, 0x27, 0xc8, 0x58, 0xb3, - 0x38, 0xb3, 0xdf, 0x2c, 0x16, 0x3f, 0x41, 0xc6, 0xd6, 0x31, 0xda, 0xbb, 0x20, 0xb1, 0xb1, 0x31, - 0x82, 0x8d, 0xff, 0x61, 0xe4, 0xf5, 0x0c, 0x19, 0xe4, 0xe9, 0x0e, 0xc0, 0x1d, 0xf1, 0x3b, 0x00, - 0x83, 0xa7, 0x16, 0xef, 0x1a, 0xc2, 0x94, 0x8b, 0x5b, 0x96, 0x0f, 0xd8, 0x90, 0x18, 0x36, 0x6e, - 0x00, 0x39, 0x1c, 0x61, 0x97, 0x8e, 0x73, 0xa1, 0xcf, 0x86, 0x4f, 0x42, 0xf5, 0xbe, 0x6a, 0x24, - 0x53, 0x62, 0x14, 0x46, 0xb0, 0x92, 0x3f, 0x0c, 0x0a, 0xdf, 0x54, 0x00, 0x58, 0xdb, 0x39, 0xdf, - 0x31, 0x9c, 0x2d, 0xc3, 0xc4, 0x8e, 0x58, 0xd3, 0xf4, 0x95, 0x04, 0x8a, 0x8d, 0x35, 0xff, 0x22, - 0x8d, 0x82, 0x22, 0x90, 0x77, 0x6c, 0x83, 0x2e, 0x03, 0x78, 0x8f, 0xca, 0xed, 0x81, 0xcb, 0x61, - 0xb6, 0x27, 0x44, 0x88, 0x27, 0x86, 0x90, 0x83, 0x39, 0xa6, 0xf4, 0xd0, 0xf5, 0x90, 0x8d, 0x06, - 0x9c, 0xe3, 0xa3, 0x01, 0x73, 0xe7, 0x86, 0xf3, 0x3d, 0xe7, 0x86, 0x3d, 0x1c, 0x1d, 0xe3, 0x69, - 0x08, 0xfb, 0xf7, 0xc8, 0x1a, 0x7e, 0xf6, 0xfe, 0xb8, 0xd7, 0x32, 0x4c, 0xbc, 0xa9, 0x43, 0x5d, - 0xe2, 0xc3, 0x04, 0xb6, 0xcf, 0x9b, 0x14, 0xec, 0xf3, 0x3e, 0x18, 0xce, 0x7d, 0x2c, 0x41, 0xc3, - 0x39, 0x81, 0xe4, 0x38, 0x76, 0xb3, 0x3d, 0xec, 0xc2, 0x8f, 0x08, 0x07, 0x0c, 0x64, 0x64, 0x1c, - 0x3b, 0x8b, 0xa1, 0x1c, 0x48, 0x01, 0x07, 0xcc, 0x46, 0x6e, 0x5c, 0x0f, 0x3c, 0x88, 0x7e, 0x32, - 0x5d, 0xde, 0x1e, 0x62, 0xbd, 0x46, 0x01, 0xb3, 0xfe, 0x01, 0xec, 0xda, 0xfc, 0x5d, 0x6a, 0xb9, - 0x51, 0x44, 0xfb, 0x0f, 0x65, 0xe3, 0xe3, 0xd7, 0xe4, 0xa8, 0x75, 0xb8, 0x26, 0x03, 0xff, 0xbb, - 0x04, 0xf2, 0xd4, 0xdc, 0xb8, 0xe3, 0x80, 0x10, 0xc2, 0x97, 0x0f, 0x03, 0x49, 0x6c, 0x1c, 0x8c, - 0x4f, 0x25, 0x05, 0x60, 0x04, 0x06, 0xc6, 0x3d, 0xa9, 0x01, 0x00, 0xff, 0x5d, 0x02, 0x59, 0xcf, - 0x0c, 0x12, 0x8b, 0x32, 0xf0, 0x49, 0x61, 0x8f, 0x5a, 0x46, 0x00, 0x1e, 0xf9, 0x08, 0xfd, 0x9e, - 0x07, 0x93, 0x5d, 0x92, 0x31, 0x88, 0x71, 0x71, 0x8d, 0x40, 0x67, 0x84, 0xb4, 0xf0, 0x37, 0xf8, - 0x4e, 0x21, 0xaf, 0xdc, 0x78, 0x7e, 0x92, 0xc1, 0xa1, 0x8e, 0x22, 0x20, 0x01, 0xf6, 0x73, 0x06, - 0x1a, 0x72, 0xac, 0xce, 0x2e, 0x5a, 0xb7, 0x0d, 0x78, 0x79, 0x08, 0x00, 0x6d, 0xf6, 0x99, 0xb0, - 0xd9, 0x7f, 0x46, 0x12, 0xf5, 0xb0, 0xe5, 0x34, 0xcf, 0x27, 0x1e, 0x21, 0xfe, 0x27, 0x83, 0x09, - 0x2a, 0x47, 0x6a, 0x53, 0x8a, 0x09, 0xdf, 0xff, 0x09, 0xbe, 0x47, 0xc8, 0x43, 0x57, 0x84, 0xa3, - 0x64, 0x00, 0x94, 0x87, 0x00, 0xe0, 0x28, 0x98, 0xf2, 0x01, 0x58, 0xd7, 0x2a, 0x45, 0x04, 0xdf, - 0x26, 0x63, 0x37, 0x09, 0x32, 0xb8, 0x1d, 0xbc, 0xa7, 0xf9, 0xba, 0xf0, 0x64, 0x9f, 0x91, 0x47, - 0x50, 0x7e, 0x4a, 0x00, 0xfd, 0xa5, 0xd0, 0xec, 0x5e, 0x80, 0xa1, 0x87, 0x4b, 0x7f, 0x75, 0x46, - 0x05, 0x33, 0x9c, 0x55, 0xa2, 0x9c, 0x02, 0xc7, 0xb9, 0x04, 0x32, 0xde, 0xb5, 0x8b, 0x47, 0x14, - 0x08, 0x4e, 0x72, 0x5f, 0xe8, 0x0b, 0x6a, 0x17, 0x33, 0xf0, 0xcd, 0x5f, 0xc8, 0x04, 0xeb, 0x3d, - 0xef, 0xca, 0xd2, 0x95, 0xb6, 0x8f, 0xf1, 0x61, 0x15, 0x5b, 0x96, 0xe9, 0xa2, 0xfb, 0x18, 0x37, - 0x95, 0x20, 0x21, 0xd6, 0x6a, 0x38, 0x05, 0x26, 0x5c, 0x9b, 0x75, 0x5d, 0xf1, 0x5f, 0x59, 0xc5, - 0xca, 0xf1, 0x8a, 0x55, 0x05, 0x67, 0x0c, 0xb3, 0xd5, 0xd9, 0x69, 0x23, 0x0d, 0x75, 0x74, 0x4f, - 0x86, 0x4e, 0xc9, 0x59, 0x40, 0x5d, 0x64, 0xb6, 0x91, 0xe9, 0x12, 0x3e, 0xfd, 0x63, 0x9d, 0x02, - 0x39, 0x79, 0x65, 0xbc, 0x9d, 0x57, 0xc6, 0x47, 0xf5, 0x5b, 0xc2, 0x8d, 0x59, 0xef, 0xbb, 0x05, - 0x00, 0x52, 0xb7, 0xb3, 0x06, 0xba, 0x48, 0xd5, 0xf0, 0xb2, 0x9e, 0x55, 0xbf, 0x5a, 0x90, 0x41, - 0x63, 0x32, 0xc3, 0x87, 0x02, 0xf5, 0xbb, 0x93, 0x53, 0xbf, 0x1b, 0x04, 0x59, 0x48, 0xa6, 0x75, - 0xdd, 0x21, 0xb4, 0x6e, 0x06, 0x4c, 0x86, 0xbb, 0xc9, 0xb2, 0x72, 0x19, 0x38, 0xe1, 0xbb, 0x09, - 0x57, 0x55, 0x75, 0xa1, 0xde, 0x5c, 0x5f, 0x5b, 0xd2, 0x4a, 0x0b, 0x6a, 0x11, 0x78, 0xfa, 0x49, - 0xf4, 0x32, 0xf0, 0xee, 0xcd, 0xc2, 0xbf, 0x91, 0x40, 0x0e, 0x9f, 0x49, 0x86, 0xbf, 0x38, 0x22, - 0xcd, 0x71, 0x38, 0xa7, 0xa7, 0x60, 0xdc, 0x15, 0xbf, 0xee, 0x80, 0x0a, 0x13, 0x73, 0x75, 0xa0, - 0xeb, 0x0e, 0x62, 0x08, 0xa5, 0x3f, 0x13, 0xf2, 0x9a, 0x64, 0x7d, 0xcb, 0xba, 0xf8, 0x93, 0xdc, - 0x24, 0xbd, 0xfa, 0x1f, 0x72, 0x93, 0xec, 0xc3, 0xc2, 0xd8, 0x9b, 0x64, 0x9f, 0x76, 0x17, 0xd3, - 0x4c, 0xe1, 0xd3, 0x73, 0xc1, 0xfc, 0xef, 0x59, 0xd2, 0x81, 0xf6, 0xbe, 0x4a, 0x60, 0xc6, 0x30, - 0x5d, 0x64, 0x9b, 0x7a, 0x67, 0xb1, 0xa3, 0x6f, 0xfa, 0xf6, 0x69, 0xef, 0x86, 0x47, 0x85, 0xc9, - 0xa3, 0xf1, 0x7f, 0x28, 0xa7, 0x01, 0x70, 0xd1, 0x76, 0xb7, 0xa3, 0xbb, 0xa1, 0xea, 0x31, 0x29, - 0xac, 0xf6, 0x65, 0x79, 0xed, 0x7b, 0x2c, 0xb8, 0x84, 0x80, 0xd6, 0xd8, 0xeb, 0xa2, 0x75, 0xd3, - 0x78, 0xea, 0x0e, 0x8e, 0xc2, 0x4b, 0x74, 0xb4, 0xdf, 0x27, 0x6e, 0x07, 0x28, 0xdf, 0xb3, 0x03, - 0xf4, 0x2f, 0xc2, 0xd1, 0x7d, 0xfc, 0x56, 0x3f, 0x20, 0xba, 0x4f, 0xd0, 0xd2, 0xe4, 0x9e, 0x96, - 0x16, 0xac, 0xcb, 0x64, 0x05, 0xd6, 0x65, 0x58, 0x54, 0x72, 0x82, 0xf3, 0xfb, 0x57, 0x0a, 0x85, - 0x0f, 0x8a, 0xab, 0x46, 0xfa, 0xbd, 0xd7, 0x77, 0x65, 0x30, 0x4b, 0x8a, 0x9e, 0xb7, 0xac, 0x0b, - 0xdb, 0xba, 0x7d, 0x01, 0xfe, 0xd6, 0xc1, 0xf6, 0x61, 0x63, 0xf7, 0x9f, 0xa2, 0x36, 0x55, 0x7b, - 0xd4, 0x2f, 0xdb, 0xab, 0x7e, 0xf0, 0xd3, 0xc2, 0x93, 0x0a, 0x4e, 0x9e, 0x7e, 0xa5, 0xc6, 0xb3, - 0x41, 0x25, 0x76, 0x0a, 0x50, 0x84, 0xc1, 0xf4, 0x81, 0xff, 0xf3, 0x00, 0x78, 0x7f, 0x24, 0x60, - 0xd7, 0xf6, 0x47, 0x89, 0x3b, 0xfc, 0xca, 0x70, 0xd8, 0xf9, 0x7c, 0x0d, 0x81, 0x5d, 0x11, 0xc8, - 0x17, 0x02, 0x77, 0x22, 0xef, 0x91, 0xad, 0x50, 0x36, 0x3d, 0x34, 0x23, 0x58, 0x1e, 0x0b, 0x9a, - 0xc7, 0x79, 0x16, 0x6a, 0xdd, 0x54, 0x31, 0xfd, 0xb2, 0xf0, 0x9e, 0x59, 0x5f, 0x01, 0x11, 0xee, - 0xc6, 0xd3, 0x2a, 0xc5, 0x36, 0xdc, 0xc4, 0xd9, 0x4c, 0x1f, 0xcd, 0xe7, 0xe5, 0xc0, 0xa4, 0x1f, - 0xa0, 0x09, 0xdf, 0x1f, 0x16, 0x60, 0x78, 0x12, 0xe4, 0x1d, 0x6b, 0xc7, 0x6e, 0x21, 0xba, 0x8b, - 0x49, 0xdf, 0x86, 0xd8, 0x71, 0x1b, 0x38, 0xe0, 0xef, 0xb3, 0x29, 0xb2, 0x89, 0x6d, 0x8a, 0x68, - 0x8b, 0x35, 0xce, 0x02, 0x78, 0xbe, 0xf0, 0xa5, 0x0f, 0x1c, 0x66, 0x75, 0xe4, 0x3e, 0x1c, 0x8d, - 0x80, 0x3f, 0x15, 0xda, 0xcf, 0x19, 0x50, 0x93, 0x64, 0x2a, 0x57, 0x1b, 0xc2, 0x92, 0xbd, 0x1c, - 0x5c, 0xea, 0xe7, 0xa0, 0x26, 0x2c, 0x36, 0x59, 0xd7, 0xb5, 0x95, 0xa2, 0x0c, 0x9f, 0x91, 0x05, - 0x45, 0xc2, 0x5a, 0x2d, 0xb0, 0xe6, 0xe0, 0x8b, 0x33, 0x87, 0x6d, 0xb2, 0x46, 0xcf, 0x41, 0x3f, - 0x2b, 0x89, 0x06, 0x96, 0xe6, 0x04, 0x1f, 0xd6, 0x2e, 0x42, 0x93, 0x86, 0x68, 0x66, 0x31, 0xca, - 0x07, 0x5f, 0x9f, 0x11, 0x89, 0x53, 0x2d, 0xc6, 0x62, 0xfa, 0xbd, 0xd2, 0xf7, 0xb2, 0x7e, 0x9c, - 0xbd, 0x45, 0xdb, 0xda, 0x5e, 0xb7, 0x3b, 0xf0, 0x7f, 0x09, 0x5d, 0x03, 0x10, 0x31, 0x3f, 0x90, - 0xa2, 0xe7, 0x07, 0x78, 0x4d, 0xb9, 0x13, 0x6e, 0x66, 0x75, 0x86, 0x18, 0xbe, 0x95, 0x6b, 0xc1, - 0xac, 0xde, 0x6e, 0xaf, 0xe9, 0x9b, 0xa8, 0xec, 0x4d, 0xbc, 0x4d, 0x97, 0xc6, 0xe0, 0xea, 0x49, - 0x8d, 0xeb, 0x8a, 0x7a, 0xfa, 0xc8, 0x89, 0x7d, 0x56, 0xa9, 0xf8, 0x42, 0x2a, 0x07, 0x22, 0x95, - 0xdf, 0x58, 0x86, 0x3f, 0x6f, 0xc8, 0x68, 0x6d, 0xe9, 0x61, 0xc4, 0x40, 0xfa, 0x26, 0xe8, 0x4d, - 0x25, 0xc0, 0x77, 0xfa, 0x9a, 0xf7, 0x27, 0x12, 0x98, 0xf0, 0xf0, 0x28, 0xb5, 0xdb, 0xf0, 0x91, - 0x5c, 0x60, 0xcd, 0x48, 0x7f, 0xb6, 0xe7, 0x08, 0x3b, 0x12, 0xfa, 0x35, 0x24, 0xf4, 0x23, 0x30, - 0x09, 0x85, 0x28, 0x71, 0x42, 0x14, 0xf3, 0x17, 0x8c, 0x2d, 0x22, 0x7d, 0xf1, 0x7d, 0x52, 0x02, - 0x33, 0xfe, 0x3c, 0x63, 0x11, 0xb9, 0xad, 0x2d, 0x78, 0x8b, 0xe8, 0x4a, 0x15, 0x6d, 0x89, 0xc1, - 0xa6, 0x6e, 0x07, 0xfe, 0x30, 0x93, 0x50, 0xe5, 0xb9, 0x92, 0x23, 0x96, 0xf9, 0x12, 0xe9, 0x62, - 0x1c, 0xc1, 0xf4, 0x85, 0xf9, 0x90, 0x04, 0x40, 0xc3, 0x0a, 0x26, 0xcb, 0x07, 0x90, 0xe4, 0x0b, - 0x85, 0xf7, 0x7b, 0x69, 0xc5, 0xc3, 0x62, 0x93, 0xf7, 0x1c, 0x82, 0xee, 0x50, 0x83, 0x4a, 0x1a, - 0x4b, 0x5b, 0x9f, 0x5c, 0xd8, 0xe9, 0x76, 0x8c, 0x96, 0xee, 0xf6, 0xfa, 0xf0, 0x45, 0x8b, 0x17, - 0x5f, 0xbe, 0x9b, 0xc8, 0x68, 0x0c, 0xca, 0x88, 0x90, 0x25, 0x09, 0x87, 0x23, 0xf9, 0xe1, 0x70, - 0x04, 0xfd, 0x72, 0x06, 0x10, 0x1f, 0x83, 0x7a, 0xca, 0xe0, 0x68, 0xad, 0x8b, 0xcc, 0x79, 0x1b, - 0xe9, 0xed, 0x96, 0xbd, 0xb3, 0x7d, 0xde, 0x61, 0x1d, 0x50, 0xe3, 0x75, 0x94, 0x59, 0x7b, 0x96, - 0xb8, 0xb5, 0x67, 0xf8, 0x4c, 0x59, 0x34, 0xa0, 0x18, 0xb3, 0x43, 0xc2, 0xf0, 0x30, 0xc4, 0x50, - 0x97, 0xc8, 0x6d, 0xaa, 0x67, 0x99, 0x39, 0x9b, 0x64, 0x99, 0xf9, 0x75, 0x42, 0xe1, 0xc9, 0x84, - 0xea, 0x35, 0x16, 0xef, 0xb7, 0xd9, 0x3a, 0x72, 0x23, 0xe0, 0xbd, 0x06, 0xcc, 0x9c, 0x0f, 0xbf, - 0x04, 0x10, 0xf3, 0x89, 0x7d, 0x7c, 0x52, 0xdf, 0x90, 0x74, 0x85, 0x86, 0x67, 0x21, 0x02, 0xdd, - 0x00, 0x41, 0x49, 0xc4, 0xf1, 0x2d, 0xd1, 0x72, 0x4b, 0x6c, 0xf9, 0xe9, 0xa3, 0xf0, 0x11, 0x09, - 0x4c, 0xe1, 0x2b, 0x85, 0xe7, 0xf7, 0xf0, 0x51, 0x4c, 0x41, 0xa3, 0xe4, 0x79, 0xac, 0x98, 0x15, - 0x90, 0xed, 0x18, 0xe6, 0x05, 0xdf, 0x63, 0xd1, 0x7b, 0x0e, 0x2f, 0xa8, 0x94, 0xfa, 0x5c, 0x50, - 0x19, 0x6c, 0x74, 0x04, 0xe5, 0x1e, 0xe8, 0xc6, 0xf4, 0x81, 0xe4, 0xd2, 0x17, 0xe3, 0x3f, 0x65, - 0x41, 0xbe, 0x8e, 0x74, 0xbb, 0xb5, 0x05, 0xdf, 0x25, 0xf5, 0x9d, 0x4a, 0x14, 0xf8, 0xa9, 0xc4, - 0x22, 0x98, 0xd8, 0x30, 0x3a, 0x2e, 0xb2, 0x89, 0x17, 0x37, 0xdb, 0xb5, 0x93, 0x26, 0x3e, 0xdf, - 0xb1, 0x5a, 0x17, 0xe6, 0xa8, 0x69, 0x3f, 0xe7, 0x07, 0x34, 0x9e, 0x5b, 0xc4, 0x3f, 0x69, 0xfe, - 0xcf, 0x9e, 0x41, 0xe8, 0x58, 0xb6, 0x1b, 0x75, 0x57, 0x4d, 0x04, 0x95, 0xba, 0x65, 0xbb, 0x1a, - 0xf9, 0xd1, 0x83, 0x79, 0x63, 0xa7, 0xd3, 0x69, 0xa0, 0xfb, 0x5c, 0x7f, 0x5a, 0xe7, 0xbf, 0x7b, - 0xc6, 0xa2, 0xb5, 0xb1, 0xe1, 0x20, 0xb2, 0xa8, 0x90, 0xd3, 0xe8, 0x9b, 0x72, 0x1c, 0xe4, 0x3a, - 0xc6, 0xb6, 0x41, 0x26, 0x22, 0x39, 0x8d, 0xbc, 0x28, 0xd7, 0x83, 0x62, 0x38, 0x07, 0x22, 0x8c, - 0x9e, 0xca, 0xe3, 0xa6, 0xb9, 0x2f, 0xdd, 0xd3, 0x99, 0x0b, 0x68, 0xcf, 0x39, 0x35, 0x81, 0xbf, - 0xe3, 0x67, 0xfe, 0xc8, 0x8c, 0xc8, 0x86, 0x09, 0x91, 0x78, 0xf4, 0x0c, 0xd7, 0x46, 0x2d, 0xcb, - 0x6e, 0xfb, 0xb2, 0x89, 0x9e, 0x60, 0xd0, 0x7c, 0xc9, 0xb6, 0x39, 0xfa, 0x16, 0x9e, 0xbe, 0xa6, - 0xbd, 0x3d, 0xef, 0x75, 0x9b, 0x5e, 0xd1, 0xe7, 0x0c, 0x77, 0x6b, 0x15, 0xb9, 0x3a, 0xfc, 0x27, - 0xb9, 0xaf, 0xc6, 0x4d, 0xfd, 0x6f, 0x8d, 0x1b, 0xa0, 0x71, 0x24, 0xf4, 0x96, 0xbb, 0x63, 0x9b, - 0x9e, 0x1c, 0xa9, 0x27, 0x2c, 0x93, 0xa2, 0xdc, 0x06, 0x2e, 0x0b, 0xdf, 0xfc, 0xa5, 0xd4, 0x05, - 0xc6, 0x39, 0xb6, 0xa0, 0x45, 0x67, 0x50, 0xd6, 0xc0, 0xd5, 0xe4, 0xe3, 0x72, 0x63, 0x75, 0x65, - 0xd9, 0xd8, 0xdc, 0xea, 0x18, 0x9b, 0x5b, 0xae, 0x53, 0x31, 0x1d, 0x17, 0xe9, 0xed, 0xda, 0x86, - 0x46, 0x6e, 0x99, 0x02, 0x98, 0x8e, 0x48, 0x56, 0xde, 0xcb, 0x5b, 0x6c, 0x74, 0x63, 0x35, 0x25, - 0xa2, 0xa5, 0x3c, 0xc1, 0x6b, 0x29, 0xce, 0x4e, 0x27, 0xc0, 0xf4, 0x8a, 0x1e, 0x4c, 0x43, 0x55, - 0xdf, 0xe9, 0xe0, 0xe6, 0x82, 0x33, 0x27, 0x1d, 0xe7, 0x62, 0x38, 0x49, 0xbf, 0xd9, 0xfc, 0xaf, - 0x3c, 0xc8, 0x2d, 0xd9, 0x7a, 0x77, 0x0b, 0x3e, 0x83, 0xe9, 0x9f, 0x47, 0xd5, 0x26, 0x02, 0xed, - 0x94, 0x06, 0x69, 0xa7, 0x3c, 0x40, 0x3b, 0xb3, 0x8c, 0x76, 0x46, 0x2f, 0x3a, 0x9f, 0x01, 0xd3, - 0x2d, 0xab, 0xd3, 0x41, 0x2d, 0x4f, 0x1e, 0x95, 0x36, 0x5e, 0xed, 0x99, 0xd4, 0xb8, 0x34, 0x1c, - 0xf4, 0x1d, 0xb9, 0x75, 0xb2, 0xc6, 0x4e, 0x94, 0x3e, 0x4c, 0x80, 0x2f, 0x96, 0x40, 0x56, 0x6d, - 0x6f, 0x22, 0x6e, 0x1d, 0x3e, 0xc3, 0xac, 0xc3, 0x9f, 0x04, 0x79, 0x57, 0xb7, 0x37, 0x91, 0xeb, - 0xaf, 0x13, 0x90, 0xb7, 0x20, 0x16, 0xbd, 0xcc, 0xc4, 0xa2, 0xff, 0x59, 0x90, 0xf5, 0x64, 0x46, - 0x1d, 0xdb, 0xaf, 0xee, 0x07, 0x3f, 0x96, 0xfd, 0x9c, 0x57, 0xe2, 0x9c, 0x57, 0x6b, 0x0d, 0xff, - 0xd0, 0x8b, 0x75, 0x6e, 0x1f, 0xd6, 0xf8, 0xc2, 0xdc, 0x96, 0x65, 0x56, 0xb6, 0xf5, 0x4d, 0x44, - 0xab, 0x19, 0x26, 0xf8, 0x5f, 0xd5, 0x6d, 0xeb, 0x5e, 0x83, 0x2e, 0x6a, 0x85, 0x09, 0x5e, 0x15, - 0xb6, 0x8c, 0x76, 0x1b, 0x99, 0xb4, 0x65, 0xd3, 0xb7, 0x33, 0xa7, 0x41, 0xd6, 0xe3, 0xc1, 0xd3, - 0x1f, 0xcf, 0x58, 0x28, 0x1e, 0x51, 0xa6, 0xbd, 0x66, 0x45, 0x1a, 0x6f, 0x31, 0xc3, 0xaf, 0xb9, - 0x8a, 0xf8, 0xfd, 0x90, 0xca, 0xf5, 0x6f, 0x5c, 0x8f, 0x01, 0x39, 0xd3, 0x6a, 0xa3, 0x81, 0x83, - 0x10, 0xc9, 0xa5, 0x3c, 0x1e, 0xe4, 0x50, 0xdb, 0xeb, 0x15, 0x64, 0x9c, 0xfd, 0x74, 0xbc, 0x2c, - 0x35, 0x92, 0x39, 0x99, 0x73, 0x51, 0x3f, 0x6e, 0xd3, 0x6f, 0x80, 0xbf, 0x3e, 0x01, 0x8e, 0x92, - 0x3e, 0xa0, 0xbe, 0x73, 0xde, 0x23, 0x75, 0x1e, 0xc1, 0x07, 0xfb, 0x0f, 0x5c, 0x47, 0x79, 0x65, - 0x3f, 0x0e, 0x72, 0xce, 0xce, 0xf9, 0xc0, 0x08, 0x25, 0x2f, 0x6c, 0xd3, 0x95, 0x46, 0x32, 0x9c, - 0xc9, 0xc3, 0x0e, 0x67, 0xdc, 0xd0, 0x24, 0xfb, 0x8d, 0x3f, 0x1c, 0xc8, 0xc8, 0x91, 0x0c, 0x7f, - 0x20, 0xeb, 0x37, 0x0c, 0x9d, 0x02, 0x13, 0xfa, 0x86, 0x8b, 0xec, 0xd0, 0x4c, 0xa4, 0xaf, 0xde, - 0x50, 0x79, 0x1e, 0x6d, 0x58, 0xb6, 0x27, 0x16, 0x72, 0x15, 0x41, 0xf0, 0xce, 0xb4, 0x5c, 0xc0, - 0xed, 0xa0, 0xdd, 0x00, 0x8e, 0x99, 0xd6, 0x02, 0xea, 0x52, 0x39, 0x13, 0x14, 0x67, 0x70, 0x0b, - 0xd8, 0xff, 0x61, 0x5f, 0x57, 0x32, 0xbb, 0xbf, 0x2b, 0x81, 0x9f, 0x49, 0x3a, 0x67, 0xee, 0x01, - 0x7a, 0x64, 0x16, 0x9a, 0xf2, 0x24, 0x30, 0xdd, 0xa6, 0x3e, 0x5e, 0x2d, 0x23, 0x68, 0x25, 0x91, - 0xff, 0x71, 0x99, 0x43, 0x45, 0xca, 0xb2, 0x8a, 0xb4, 0x04, 0x0a, 0xf8, 0xf0, 0xb4, 0xa7, 0x49, - 0xb9, 0x1e, 0x9f, 0x7a, 0x3c, 0xad, 0x0b, 0x2a, 0xc5, 0x88, 0x6d, 0xae, 0x4c, 0x7f, 0xd1, 0x82, - 0x9f, 0x93, 0xcd, 0xbe, 0xe3, 0x25, 0x94, 0x7e, 0x73, 0xfc, 0xe3, 0x3c, 0xb8, 0xac, 0x6c, 0x5b, - 0x8e, 0x83, 0x0f, 0xd1, 0xf4, 0x36, 0xcc, 0xd7, 0x48, 0xdc, 0xad, 0x34, 0x0f, 0xeb, 0xe6, 0xd7, - 0xaf, 0x41, 0x8d, 0xaf, 0x69, 0x7c, 0x5d, 0x38, 0xec, 0x4c, 0xb0, 0xff, 0x10, 0x21, 0xf4, 0x9f, - 0x8c, 0x46, 0xf2, 0xf6, 0x8c, 0x48, 0x24, 0x9c, 0x84, 0xb2, 0x4a, 0xbf, 0xb9, 0x7c, 0x59, 0x02, - 0x97, 0xf7, 0x72, 0xb3, 0x6e, 0x3a, 0x41, 0x83, 0xb9, 0x72, 0x40, 0x7b, 0xe1, 0x23, 0xa7, 0xc4, - 0xde, 0x07, 0x1b, 0x51, 0x77, 0xa6, 0xb4, 0x88, 0xc5, 0x92, 0xf0, 0x48, 0x4e, 0xdc, 0x7d, 0xb0, - 0x89, 0xc9, 0xa7, 0x2f, 0xdc, 0xcf, 0x66, 0xc1, 0xd1, 0x25, 0xdb, 0xda, 0xe9, 0x3a, 0x61, 0x0f, - 0xf4, 0xf7, 0xfd, 0x37, 0x64, 0xf3, 0x22, 0xa6, 0xc1, 0x55, 0x60, 0xca, 0xa6, 0xd6, 0x5c, 0xb8, - 0x3d, 0xcb, 0x26, 0xb1, 0xbd, 0x97, 0x7c, 0x90, 0xde, 0x2b, 0xec, 0x67, 0xb2, 0x5c, 0x3f, 0xd3, - 0xdb, 0x73, 0xe4, 0xfa, 0xf4, 0x1c, 0x7f, 0x27, 0x25, 0x1c, 0x54, 0x7b, 0x44, 0x14, 0xd1, 0x5f, - 0x94, 0x41, 0x7e, 0x13, 0x67, 0xa4, 0xdd, 0xc5, 0xa3, 0xc5, 0x6a, 0x86, 0x89, 0x6b, 0xf4, 0xd7, - 0x50, 0xae, 0x32, 0xab, 0xc3, 0x89, 0x06, 0xb8, 0x78, 0x6e, 0xd3, 0x57, 0xaa, 0x07, 0xb2, 0x60, - 0x3a, 0x28, 0xbd, 0xd2, 0x76, 0xe0, 0xf3, 0xfa, 0x6b, 0xd4, 0x8c, 0x88, 0x46, 0xed, 0x5b, 0x67, - 0x0e, 0x46, 0x1d, 0x99, 0x19, 0x75, 0xfa, 0x8e, 0x2e, 0xd3, 0x11, 0xa3, 0x0b, 0x7c, 0xba, 0x2c, - 0x7a, 0xaf, 0x1b, 0xdf, 0xb5, 0xe2, 0xda, 0x3c, 0x9c, 0x07, 0x0b, 0xc1, 0xdb, 0xe5, 0x06, 0xd7, - 0x2a, 0x7d, 0x25, 0x79, 0xbf, 0x04, 0x8e, 0xed, 0xef, 0xcc, 0x7f, 0x8a, 0xf7, 0x52, 0xf3, 0xea, - 0xe4, 0x04, 0x5e, 0x6a, 0xf8, 0x8d, 0xdf, 0xa4, 0x8b, 0x0d, 0x63, 0xc2, 0xd9, 0x7b, 0x83, 0x3b, - 0x71, 0xb1, 0x40, 0x25, 0x82, 0x44, 0xd3, 0x17, 0xe0, 0x6f, 0xcb, 0x60, 0xb2, 0x8e, 0xdc, 0x15, - 0x7d, 0xcf, 0xda, 0x71, 0xa1, 0x2e, 0xba, 0x3d, 0xf7, 0x44, 0x90, 0xef, 0xe0, 0x5f, 0x70, 0x07, - 0xc3, 0x86, 0x0d, 0x65, 0xf7, 0xb7, 0xb0, 0x6f, 0x10, 0x21, 0xad, 0xd1, 0xfc, 0x7c, 0xfc, 0x18, - 0x91, 0xdd, 0xd1, 0x80, 0xbb, 0x91, 0x6c, 0xed, 0x24, 0xda, 0x3b, 0x8d, 0x2a, 0x3a, 0x7d, 0x58, - 0x9e, 0x29, 0x83, 0x99, 0x3a, 0x72, 0x2b, 0xce, 0xa2, 0xbe, 0x6b, 0xd9, 0x86, 0x8b, 0xd8, 0xfb, - 0x72, 0xe3, 0xa1, 0x39, 0x0d, 0x80, 0x11, 0xfc, 0x46, 0xa3, 0x5a, 0x31, 0x29, 0xf0, 0xf5, 0x49, - 0x1d, 0x85, 0x38, 0x3e, 0x46, 0x02, 0x42, 0x22, 0x1f, 0x8b, 0xb8, 0xe2, 0xd3, 0x07, 0xe2, 0x8b, - 0x12, 0x05, 0xa2, 0x64, 0xb7, 0xb6, 0x8c, 0x5d, 0xd4, 0x4e, 0x08, 0x84, 0xff, 0x5b, 0x08, 0x44, - 0x40, 0x28, 0xb1, 0xfb, 0x0a, 0xc7, 0xc7, 0x28, 0xdc, 0x57, 0xe2, 0x08, 0x8e, 0x25, 0x30, 0x95, - 0xd7, 0xf5, 0xd0, 0xf5, 0xcc, 0x3b, 0x44, 0xc5, 0x1a, 0x9a, 0x6c, 0x12, 0x6b, 0xb2, 0x0d, 0xd5, - 0xb1, 0x90, 0xb2, 0x07, 0xe9, 0x74, 0x36, 0x8d, 0x8e, 0xa5, 0x6f, 0xd1, 0xe9, 0x0b, 0xfd, 0x9d, - 0x32, 0x38, 0x11, 0x44, 0x6c, 0xa9, 0x23, 0x77, 0x41, 0x77, 0xb6, 0xce, 0x5b, 0xba, 0xdd, 0x86, - 0xe5, 0x11, 0x1c, 0x19, 0x84, 0x5f, 0x60, 0x41, 0xa8, 0xf2, 0x20, 0xf4, 0x75, 0x25, 0xed, 0xcb, - 0xcb, 0x28, 0x3a, 0x99, 0x58, 0x6f, 0xd7, 0x37, 0x07, 0x60, 0xfd, 0x1c, 0x07, 0xd6, 0xed, 0xc3, - 0xb2, 0x98, 0x3e, 0x70, 0xbf, 0x47, 0x46, 0x04, 0xc6, 0xeb, 0xf9, 0x1e, 0x51, 0xc0, 0x22, 0xbc, - 0x5e, 0xe5, 0x48, 0xaf, 0xd7, 0xa1, 0xc6, 0x88, 0x81, 0x1e, 0xcb, 0xe9, 0x8e, 0x11, 0x87, 0xe8, - 0x8d, 0xfc, 0x56, 0x19, 0x14, 0x71, 0xc8, 0x2e, 0xc6, 0x23, 0x9c, 0x8d, 0x80, 0x1d, 0x8f, 0xce, - 0x3e, 0xef, 0xf3, 0x89, 0xa4, 0xde, 0xe7, 0xf0, 0x2d, 0x49, 0x7d, 0xcc, 0x7b, 0xb9, 0x1d, 0x09, - 0x62, 0x89, 0x5c, 0xc8, 0x07, 0x70, 0x90, 0x3e, 0x68, 0xbf, 0x21, 0x03, 0xe0, 0x35, 0x68, 0x7a, - 0x36, 0xe2, 0x29, 0xa2, 0x70, 0xdd, 0xc8, 0xfa, 0xdd, 0x7b, 0x40, 0x9d, 0xe8, 0x01, 0x8a, 0x50, - 0x0c, 0x4f, 0x5d, 0x3c, 0x98, 0xd4, 0xb7, 0x32, 0xe4, 0x6a, 0x24, 0xb0, 0x24, 0xf2, 0xb6, 0x8c, - 0x2c, 0x3b, 0x7d, 0x40, 0xfe, 0x9b, 0x04, 0x72, 0x0d, 0xab, 0x8e, 0xdc, 0x83, 0x9b, 0x02, 0x89, - 0xcf, 0xfd, 0xe3, 0x72, 0x47, 0x71, 0xee, 0xbf, 0x1f, 0xa1, 0xf4, 0x45, 0xf7, 0x0e, 0x09, 0x4c, - 0x37, 0xac, 0x72, 0xb0, 0x38, 0x25, 0xee, 0xab, 0x2a, 0x7e, 0x37, 0x7d, 0x50, 0xc1, 0xb0, 0x98, - 0x03, 0xdd, 0x4d, 0x3f, 0x98, 0x5e, 0xfa, 0x72, 0xbb, 0x05, 0x1c, 0x5d, 0x37, 0xdb, 0x96, 0x86, - 0xda, 0x16, 0x5d, 0xe9, 0x56, 0x14, 0x90, 0xdd, 0x31, 0xdb, 0x16, 0x66, 0x39, 0xa7, 0xe1, 0x67, - 0x2f, 0xcd, 0x46, 0x6d, 0x8b, 0xfa, 0x06, 0xe0, 0x67, 0xf8, 0x75, 0x19, 0x64, 0xbd, 0x7f, 0xc5, - 0x45, 0xfd, 0x56, 0x39, 0x61, 0x24, 0x03, 0x8f, 0xfc, 0x48, 0x2c, 0xa1, 0x3b, 0x98, 0xb5, 0x7f, - 0xe2, 0xc1, 0x7a, 0x75, 0x54, 0x79, 0x8c, 0x28, 0xc2, 0x35, 0x7f, 0xe5, 0x14, 0x98, 0x38, 0xdf, - 0xb1, 0x5a, 0x17, 0xc2, 0x03, 0xf7, 0xf4, 0x55, 0xb9, 0x1e, 0xe4, 0x6c, 0xdd, 0xdc, 0x44, 0x74, - 0x4f, 0xe1, 0x78, 0x4f, 0x5f, 0x88, 0xbd, 0x5e, 0x34, 0x92, 0x05, 0xbe, 0x25, 0x49, 0x0c, 0x85, - 0x3e, 0x95, 0x4f, 0xa6, 0x0f, 0x0b, 0x43, 0x9c, 0x3c, 0x2b, 0x82, 0xe9, 0x72, 0xa9, 0x4a, 0xae, - 0x13, 0xac, 0x9d, 0x55, 0x8b, 0x32, 0x86, 0xd9, 0x93, 0x49, 0x8a, 0x30, 0x7b, 0xe4, 0x7f, 0x62, - 0x61, 0xee, 0x53, 0xf9, 0xc3, 0x80, 0xf9, 0x93, 0x12, 0x98, 0x59, 0x31, 0x1c, 0x37, 0xca, 0xdb, - 0x3f, 0x26, 0x62, 0xef, 0xf3, 0x93, 0x9a, 0xca, 0x5c, 0x39, 0xc2, 0xa1, 0x7a, 0x13, 0x99, 0xc3, - 0x71, 0x45, 0x8c, 0xe7, 0x58, 0x0a, 0xe6, 0x80, 0xdc, 0xc5, 0x2e, 0x2c, 0xc9, 0xc4, 0x86, 0x52, - 0x58, 0xc8, 0xf8, 0x0d, 0xa5, 0xc8, 0xb2, 0xd3, 0x97, 0xef, 0xd7, 0x25, 0x70, 0xcc, 0x2b, 0x3e, - 0x6e, 0x59, 0x2a, 0x5a, 0xcc, 0x03, 0x97, 0xa5, 0x12, 0xaf, 0x8c, 0xef, 0xe3, 0x65, 0x14, 0x2b, - 0xe3, 0x83, 0x88, 0x8e, 0x59, 0xcc, 0x11, 0xcb, 0xb0, 0x83, 0xc4, 0x1c, 0xb3, 0x0c, 0x3b, 0xbc, - 0x98, 0xe3, 0x97, 0x62, 0x87, 0x14, 0xf3, 0xa1, 0x2d, 0xb0, 0xfe, 0xa1, 0x1c, 0x88, 0x39, 0x72, - 0x6d, 0x23, 0x46, 0xcc, 0x89, 0x4f, 0xf4, 0xf2, 0xd7, 0xdb, 0x27, 0x10, 0xfc, 0x88, 0xd7, 0x37, - 0x86, 0x81, 0xe9, 0x10, 0xd7, 0x38, 0x5e, 0x22, 0x83, 0x59, 0xca, 0x45, 0xff, 0x29, 0x73, 0x0c, - 0x46, 0x89, 0xa7, 0xcc, 0x89, 0xcf, 0x00, 0xf1, 0x9c, 0x8d, 0xff, 0x0c, 0x50, 0x6c, 0xf9, 0xe9, - 0x83, 0xf3, 0x8d, 0x2c, 0x38, 0xe9, 0xb1, 0xb0, 0x6a, 0xb5, 0x8d, 0x8d, 0x3d, 0xc2, 0xc5, 0x59, - 0xbd, 0xb3, 0x83, 0x1c, 0xf8, 0x6e, 0x49, 0x14, 0xa5, 0xff, 0x03, 0x00, 0xab, 0x8b, 0x6c, 0x12, - 0x89, 0x8d, 0x02, 0x75, 0x5b, 0x54, 0x65, 0xf7, 0x97, 0x14, 0x5c, 0x60, 0x53, 0xf3, 0x89, 0x68, - 0x0c, 0x3d, 0xcf, 0x2a, 0x9c, 0x0c, 0xbe, 0xf4, 0x3a, 0x78, 0x64, 0xf6, 0x3b, 0x78, 0x5c, 0x07, - 0x64, 0xbd, 0xdd, 0x0e, 0xa0, 0xea, 0xdd, 0xcc, 0xc6, 0x65, 0x6a, 0x5e, 0x16, 0x2f, 0xa7, 0x83, - 0xc2, 0xa3, 0x79, 0x11, 0x39, 0x1d, 0xe4, 0x2a, 0x73, 0x20, 0x4f, 0x6e, 0xe5, 0x0e, 0x56, 0xf4, - 0xfb, 0x67, 0xa6, 0xb9, 0x78, 0xd3, 0xae, 0xc6, 0xab, 0xe1, 0x2d, 0x89, 0x24, 0xd3, 0xaf, 0x9f, - 0x0e, 0xed, 0x64, 0x8d, 0x53, 0xb0, 0x27, 0x0f, 0x4d, 0x79, 0x3c, 0xbb, 0x61, 0xa5, 0x6e, 0xb7, - 0xb3, 0xd7, 0xa0, 0x81, 0x07, 0x12, 0xed, 0x86, 0x31, 0xf1, 0x0b, 0xa4, 0x7d, 0xf1, 0x0b, 0x12, - 0xef, 0x86, 0x71, 0x7c, 0x8c, 0x62, 0x37, 0x2c, 0x8e, 0x60, 0xfa, 0xa2, 0xfd, 0x44, 0x81, 0x58, - 0xcd, 0xf4, 0x3e, 0x81, 0xcf, 0xf4, 0xf7, 0xac, 0x06, 0xbc, 0xb3, 0x4b, 0xbf, 0xab, 0x06, 0x62, - 0xef, 0x51, 0x51, 0x1e, 0x0f, 0xf2, 0x1b, 0x96, 0xbd, 0xad, 0xfb, 0x1b, 0xf7, 0xbd, 0x27, 0x45, - 0x68, 0x0c, 0xff, 0x45, 0x9c, 0x47, 0xa3, 0x79, 0xbd, 0xf9, 0xc8, 0xd3, 0x8c, 0x2e, 0x0d, 0xdb, - 0xe8, 0x3d, 0x2a, 0xd7, 0x80, 0x19, 0x1a, 0xbd, 0xb1, 0x8a, 0x1c, 0x17, 0xb5, 0x69, 0x44, 0x0b, - 0x3e, 0x51, 0x39, 0x03, 0xa6, 0x69, 0xc2, 0xa2, 0xd1, 0x41, 0x0e, 0x0d, 0x6a, 0xc1, 0xa5, 0x29, - 0x27, 0x41, 0xde, 0x70, 0xee, 0x72, 0x2c, 0x13, 0xfb, 0xff, 0x17, 0x34, 0xfa, 0xa6, 0x5c, 0x07, - 0x8e, 0xd2, 0x7c, 0x81, 0xb1, 0x4a, 0x0e, 0xec, 0xf4, 0x26, 0x7b, 0xaa, 0x65, 0x5a, 0x6b, 0xb6, - 0xb5, 0x69, 0x23, 0xc7, 0xc1, 0xa7, 0xa6, 0x0a, 0x1a, 0x93, 0xa2, 0xdc, 0x03, 0x8e, 0x75, 0x0c, - 0xf3, 0x82, 0x83, 0xa3, 0xfc, 0x2e, 0x52, 0xb7, 0xb1, 0xe9, 0x3e, 0xd1, 0xb7, 0x99, 0xc6, 0x46, - 0xe5, 0xc0, 0xfe, 0xa2, 0xed, 0xa7, 0xa2, 0x5c, 0x0f, 0x8a, 0x94, 0x9b, 0x79, 0xbd, 0x75, 0x01, - 0x7f, 0xa7, 0xee, 0xa8, 0xfb, 0xd2, 0xe1, 0x8b, 0x32, 0x60, 0x9a, 0xfb, 0x59, 0x07, 0x8a, 0xdf, - 0xe5, 0x39, 0xe7, 0xb6, 0x0c, 0x17, 0x79, 0x05, 0xd3, 0x73, 0x2c, 0x37, 0x0d, 0x60, 0x4c, 0xdb, - 0xf7, 0xa3, 0xd6, 0x87, 0x98, 0x07, 0x00, 0xe9, 0xcc, 0xb0, 0xd7, 0x98, 0x43, 0xed, 0x50, 0x2e, - 0x0d, 0x3e, 0x0d, 0x28, 0xfb, 0xa9, 0x31, 0x1e, 0x1e, 0x99, 0x64, 0x1e, 0x1e, 0x9e, 0x4c, 0xf4, - 0x4e, 0xc7, 0xba, 0x88, 0xda, 0x01, 0x59, 0xaa, 0x87, 0xfb, 0xd2, 0xe1, 0xe7, 0x86, 0x99, 0xf3, - 0x25, 0xbe, 0xf6, 0xc2, 0x6b, 0x40, 0x3b, 0xad, 0x16, 0x42, 0x6d, 0x7a, 0x28, 0xcd, 0x7f, 0x4d, - 0x78, 0x21, 0x46, 0xe2, 0x19, 0xe2, 0x21, 0xdd, 0x88, 0xf1, 0xa1, 0x13, 0x20, 0x4f, 0x6e, 0x97, - 0x83, 0x2f, 0x9a, 0xed, 0xdb, 0x8f, 0xcc, 0xf2, 0xfd, 0xc8, 0x3a, 0x98, 0x36, 0x2d, 0xaf, 0xb8, - 0x35, 0xdd, 0xd6, 0xb7, 0x9d, 0xb8, 0x05, 0x60, 0x42, 0x37, 0x18, 0xed, 0xab, 0xcc, 0x6f, 0xcb, - 0x47, 0x34, 0x8e, 0x8c, 0xf2, 0x7f, 0x82, 0xa3, 0xe7, 0x69, 0xf0, 0x06, 0x87, 0x52, 0x96, 0xa2, - 0xdd, 0x23, 0x7b, 0x28, 0xcf, 0xf3, 0x7f, 0x2e, 0x1f, 0xd1, 0x7a, 0x89, 0x29, 0xbf, 0x00, 0x66, - 0xbd, 0xd7, 0xb6, 0x75, 0xd1, 0x67, 0x5c, 0x8e, 0xb6, 0x11, 0x7b, 0xc8, 0xaf, 0x72, 0x3f, 0x2e, - 0x1f, 0xd1, 0x7a, 0x48, 0x29, 0x35, 0x00, 0xb6, 0xdc, 0xed, 0x0e, 0x25, 0x9c, 0x8d, 0x56, 0xc9, - 0x1e, 0xc2, 0xcb, 0xc1, 0x4f, 0xcb, 0x47, 0x34, 0x86, 0x84, 0xb2, 0x02, 0x26, 0xdd, 0xfb, 0x5c, - 0x4a, 0x2f, 0x17, 0xed, 0x97, 0xd0, 0x43, 0xaf, 0xe1, 0xff, 0xb3, 0x7c, 0x44, 0x0b, 0x09, 0x28, - 0x15, 0x50, 0xe8, 0x9e, 0xa7, 0xc4, 0xf2, 0xd1, 0x7d, 0x59, 0x0f, 0xb1, 0xb5, 0xf3, 0x01, 0xad, - 0xe0, 0x77, 0x8f, 0xb1, 0x96, 0xb3, 0x4b, 0x69, 0x4d, 0x08, 0x33, 0x56, 0xf6, 0xff, 0xf1, 0x18, - 0x0b, 0x08, 0x28, 0x15, 0x30, 0xe9, 0x98, 0x7a, 0xd7, 0xd9, 0xb2, 0x5c, 0xe7, 0x54, 0xa1, 0xc7, - 0x85, 0x35, 0x9a, 0x5a, 0x9d, 0xfe, 0xa3, 0x85, 0x7f, 0x2b, 0x8f, 0x07, 0x27, 0x76, 0xba, 0x6d, - 0xdd, 0x45, 0xea, 0x7d, 0x86, 0xe3, 0x1a, 0xe6, 0xa6, 0x1f, 0x3f, 0x98, 0x0c, 0x04, 0xfd, 0x3f, - 0x2a, 0x73, 0xf4, 0x30, 0x1b, 0xc0, 0x6d, 0x13, 0xf6, 0xee, 0xa3, 0x92, 0x62, 0x99, 0x33, 0x6c, - 0x4f, 0x02, 0x59, 0xef, 0x13, 0x1e, 0x38, 0x66, 0xfb, 0xaf, 0xd1, 0xf6, 0xea, 0x0e, 0x6e, 0xc0, - 0xde, 0x4f, 0x3d, 0x63, 0xcf, 0xf4, 0xbe, 0xb1, 0xe7, 0x2a, 0x30, 0x65, 0x38, 0xab, 0xc6, 0x26, - 0x31, 0x7c, 0xe9, 0xd8, 0xc0, 0x26, 0x91, 0x85, 0x82, 0x2a, 0xba, 0x48, 0x6e, 0x47, 0x39, 0xea, - 0x2f, 0x14, 0xf8, 0x29, 0xf0, 0x5a, 0x30, 0xcd, 0x36, 0x32, 0x72, 0x45, 0xad, 0x11, 0x9a, 0xcd, - 0xf4, 0x0d, 0x5e, 0x03, 0x66, 0x79, 0x9d, 0x66, 0xac, 0x03, 0xd9, 0xef, 0x0a, 0xe1, 0xd5, 0xe0, - 0x68, 0x4f, 0xc3, 0xf2, 0xc3, 0xc1, 0x64, 0xc2, 0x70, 0x30, 0x57, 0x01, 0x10, 0x6a, 0x71, 0x5f, - 0x32, 0x57, 0x82, 0xc9, 0x40, 0x2f, 0xfb, 0x66, 0xf8, 0x6a, 0x06, 0x14, 0x7c, 0x65, 0xeb, 0x97, - 0xc1, 0x1b, 0x99, 0x4c, 0x66, 0xef, 0xc7, 0x1f, 0x99, 0xd8, 0x34, 0xcf, 0x04, 0x08, 0x3d, 0xae, - 0x1b, 0x86, 0xdb, 0xf1, 0x4f, 0x2d, 0xf6, 0x26, 0x2b, 0x6b, 0x00, 0x18, 0x18, 0xa3, 0x46, 0x78, - 0x8c, 0xf1, 0xb1, 0x09, 0xda, 0x03, 0xd1, 0x07, 0x86, 0xc6, 0x99, 0x9f, 0xa2, 0x67, 0x0c, 0x27, - 0x41, 0x8e, 0x04, 0xd1, 0x3f, 0xa2, 0xcc, 0x02, 0xa0, 0x3e, 0x65, 0x4d, 0xd5, 0x2a, 0x6a, 0xb5, - 0xac, 0x16, 0x33, 0xf0, 0xa5, 0x12, 0x98, 0x0c, 0x1a, 0x41, 0xdf, 0x4a, 0xaa, 0x54, 0xb5, 0x06, - 0xde, 0x02, 0xba, 0xbf, 0x51, 0xb1, 0x4a, 0xf6, 0x44, 0x70, 0xe9, 0x8e, 0x83, 0x16, 0x0d, 0xdb, - 0x71, 0x35, 0xeb, 0xe2, 0xa2, 0x65, 0x87, 0x03, 0x2b, 0x09, 0x5e, 0x1b, 0xf5, 0xd9, 0x33, 0x06, - 0xdb, 0x08, 0x9f, 0x67, 0x43, 0x36, 0x5d, 0xd4, 0x0f, 0x13, 0x3c, 0xba, 0xae, 0xad, 0x9b, 0x4e, - 0xd7, 0x72, 0x90, 0x66, 0x5d, 0x74, 0x4a, 0x66, 0xbb, 0x6c, 0x75, 0x76, 0xb6, 0x4d, 0x87, 0x9a, - 0x73, 0x51, 0x9f, 0x3d, 0xe9, 0xe0, 0x3b, 0x7e, 0x67, 0x01, 0x28, 0xd7, 0x56, 0x56, 0xd4, 0x72, - 0xa3, 0x52, 0xab, 0x16, 0x8f, 0x78, 0xd2, 0x6a, 0x94, 0xe6, 0x57, 0x3c, 0xe9, 0xfc, 0x22, 0x28, - 0xf8, 0x6d, 0x9a, 0x46, 0xb0, 0xc9, 0xf8, 0x11, 0x6c, 0x94, 0x12, 0x28, 0xf8, 0xad, 0x9c, 0x8e, - 0x08, 0x8f, 0xec, 0x3d, 0xb1, 0xbc, 0xad, 0xdb, 0x2e, 0x36, 0x50, 0x7c, 0x22, 0xf3, 0xba, 0x83, - 0xb4, 0xe0, 0xb7, 0x33, 0x8f, 0xa1, 0x1c, 0x28, 0x60, 0xb6, 0xb4, 0xb2, 0xd2, 0xac, 0x69, 0xcd, - 0x6a, 0xad, 0xb1, 0x5c, 0xa9, 0x2e, 0x91, 0x11, 0xb2, 0xb2, 0x54, 0xad, 0x69, 0x2a, 0x19, 0x20, - 0xeb, 0xc5, 0x0c, 0xb9, 0x63, 0x7a, 0xbe, 0x00, 0xf2, 0x5d, 0x2c, 0x5d, 0xf8, 0x65, 0x39, 0x61, - 0xa8, 0x82, 0x00, 0xa7, 0x88, 0x5b, 0x70, 0xb9, 0xe3, 0x02, 0x52, 0x9f, 0xe3, 0xbc, 0x67, 0xc0, - 0x34, 0x31, 0xc3, 0x1d, 0xbc, 0xf3, 0x82, 0x91, 0x93, 0x35, 0x2e, 0x0d, 0x7e, 0x44, 0x4a, 0x10, - 0xbf, 0xa0, 0x2f, 0x47, 0xc9, 0x8c, 0x8b, 0xbf, 0xce, 0x0c, 0x77, 0xe5, 0x44, 0xa5, 0xda, 0x50, - 0xb5, 0x6a, 0x69, 0x85, 0x66, 0x91, 0x95, 0x53, 0xe0, 0x78, 0xb5, 0x46, 0xc3, 0x35, 0xd6, 0x9b, - 0x8d, 0x5a, 0xb3, 0xb2, 0xba, 0x56, 0xd3, 0x1a, 0xc5, 0x9c, 0x72, 0x12, 0x28, 0xe4, 0xb9, 0x59, - 0xa9, 0x37, 0xcb, 0xa5, 0x6a, 0x59, 0x5d, 0x51, 0x17, 0x8a, 0x79, 0xe5, 0x51, 0xe0, 0x6a, 0x72, - 0x85, 0x51, 0x6d, 0xb1, 0xa9, 0xd5, 0xce, 0xd5, 0x3d, 0x04, 0x35, 0x75, 0xa5, 0xe4, 0x29, 0x12, - 0x73, 0xd7, 0xf4, 0x84, 0x72, 0x09, 0x38, 0x8a, 0x2f, 0xa2, 0x5f, 0xa9, 0x95, 0x16, 0x68, 0x79, - 0x05, 0xe5, 0x0a, 0x70, 0xaa, 0x52, 0xad, 0xaf, 0x2f, 0x2e, 0x56, 0xca, 0x15, 0xb5, 0xda, 0x68, - 0xae, 0xa9, 0xda, 0x6a, 0xa5, 0x5e, 0xf7, 0xfe, 0x2d, 0x4e, 0xe2, 0x9b, 0x7c, 0x49, 0x9f, 0x09, - 0xdf, 0x25, 0x83, 0x99, 0xb3, 0x7a, 0xc7, 0xf0, 0x06, 0x0a, 0x7c, 0xc5, 0x77, 0xcf, 0x49, 0x1f, - 0x17, 0x5f, 0x05, 0x4e, 0xcf, 0x0a, 0xe0, 0x17, 0xf8, 0xab, 0x72, 0xc2, 0x93, 0x3e, 0x14, 0x08, - 0x52, 0xe2, 0x1c, 0x57, 0x5a, 0xc4, 0xbc, 0xf4, 0x95, 0x52, 0x82, 0x93, 0x3e, 0xe2, 0xe4, 0x93, - 0x81, 0xff, 0xfb, 0xa3, 0x02, 0xbf, 0x08, 0xa6, 0xd7, 0xab, 0xa5, 0xf5, 0xc6, 0x72, 0x4d, 0xab, - 0xfc, 0x3c, 0x8e, 0x34, 0x3f, 0x03, 0x26, 0x17, 0x6b, 0xda, 0x7c, 0x65, 0x61, 0x41, 0xad, 0x16, - 0x73, 0xca, 0xa5, 0xe0, 0x92, 0xba, 0xaa, 0x9d, 0xad, 0x94, 0xd5, 0xe6, 0x7a, 0xb5, 0x74, 0xb6, - 0x54, 0x59, 0xc1, 0x7d, 0x44, 0x3e, 0xe6, 0x7a, 0xf2, 0x09, 0xf8, 0xcb, 0x59, 0x00, 0x48, 0xd5, - 0xf1, 0x45, 0x4b, 0xcc, 0x25, 0xd6, 0x7f, 0x93, 0x74, 0xd2, 0x10, 0x92, 0x89, 0x68, 0xbf, 0x15, - 0x50, 0xb0, 0xe9, 0x07, 0xba, 0xf2, 0x35, 0x88, 0x0e, 0x79, 0xf4, 0xa9, 0x69, 0xc1, 0xef, 0xf0, - 0xdd, 0x49, 0xe6, 0x08, 0x91, 0x8c, 0x25, 0x43, 0x72, 0x71, 0x34, 0x40, 0xc2, 0xe7, 0x65, 0xc0, - 0x2c, 0x5f, 0x31, 0xaf, 0x12, 0xd8, 0x98, 0x12, 0xab, 0x04, 0xff, 0x33, 0x63, 0x64, 0x9d, 0x79, - 0x1c, 0x1d, 0x4e, 0x81, 0xdf, 0x32, 0xc9, 0xa1, 0x7d, 0xdf, 0x62, 0x29, 0x66, 0x3c, 0xe6, 0x3d, - 0xa3, 0xa3, 0x28, 0x29, 0x13, 0x40, 0x6e, 0xdc, 0xe7, 0x16, 0x65, 0xf8, 0x55, 0x19, 0xcc, 0x70, - 0xb7, 0x64, 0xc3, 0x57, 0x66, 0x44, 0x6e, 0xb0, 0x65, 0xee, 0xdf, 0xce, 0x1c, 0xf4, 0xfe, 0xed, - 0x33, 0x37, 0x82, 0x09, 0x9a, 0x86, 0xe5, 0x5b, 0xab, 0x7a, 0xa6, 0xc0, 0x51, 0x30, 0xb5, 0xa4, - 0x36, 0x9a, 0xf5, 0x46, 0x49, 0x6b, 0xa8, 0x0b, 0xc5, 0x8c, 0x37, 0xf0, 0xa9, 0xab, 0x6b, 0x8d, - 0x7b, 0x8a, 0x52, 0x72, 0xe7, 0xc9, 0x5e, 0x46, 0xc6, 0xec, 0x3c, 0x19, 0x57, 0x7c, 0xfa, 0x73, - 0xd5, 0xcf, 0xc8, 0xa0, 0x48, 0x38, 0x50, 0xef, 0xeb, 0x22, 0xdb, 0x40, 0x66, 0x0b, 0xc1, 0x0b, - 0x22, 0xc1, 0x5c, 0xf7, 0x85, 0x31, 0xc4, 0xfd, 0x39, 0x63, 0x25, 0x92, 0x97, 0x1e, 0x03, 0x3b, - 0xbb, 0xcf, 0xc0, 0xfe, 0x74, 0x52, 0xef, 0xc9, 0x5e, 0x76, 0x47, 0x02, 0xd9, 0xc7, 0x93, 0x78, - 0x4f, 0x0e, 0xe0, 0x60, 0x2c, 0x31, 0x9a, 0x23, 0xc6, 0xdf, 0xa2, 0x0c, 0x9f, 0x2b, 0x83, 0xa3, - 0x0b, 0xba, 0x8b, 0xe6, 0xf7, 0x1a, 0xfe, 0x2d, 0x96, 0x11, 0x37, 0x4f, 0x67, 0xf6, 0xdd, 0x3c, - 0x1d, 0x5e, 0x84, 0x29, 0xf5, 0x5c, 0x84, 0x09, 0xdf, 0x9e, 0xf4, 0xbc, 0x65, 0x0f, 0x0f, 0x23, - 0x0b, 0xa4, 0x9c, 0xec, 0x1c, 0x65, 0x3c, 0x17, 0xe9, 0x37, 0xb0, 0x37, 0x4d, 0x82, 0x22, 0x61, - 0x85, 0x71, 0x10, 0xfc, 0x6d, 0x7a, 0x59, 0x7b, 0x33, 0x41, 0x3c, 0x46, 0x3f, 0xc2, 0x85, 0xc4, - 0x47, 0xb8, 0xe0, 0xd6, 0x9b, 0xe5, 0x5e, 0xa7, 0x8e, 0xa4, 0x9d, 0x21, 0xe3, 0x0d, 0x18, 0x1d, - 0x02, 0x37, 0xbd, 0xce, 0x30, 0xb6, 0xf8, 0xf1, 0x5c, 0x28, 0x4c, 0xef, 0xf0, 0x54, 0x45, 0x91, - 0x89, 0xbf, 0x37, 0x3d, 0xa9, 0x6b, 0x38, 0xe7, 0x8d, 0x19, 0x73, 0x99, 0x78, 0x7a, 0xae, 0xe1, - 0x83, 0x38, 0x48, 0x1f, 0x85, 0x1f, 0x4a, 0x20, 0x5b, 0xb7, 0x6c, 0x77, 0x54, 0x18, 0x24, 0xdd, - 0xce, 0x66, 0x24, 0x50, 0x8f, 0x9e, 0x73, 0xa6, 0xb7, 0x9d, 0x1d, 0x5f, 0xfe, 0x18, 0x42, 0x5a, - 0x1e, 0x05, 0xb3, 0x84, 0x93, 0xe0, 0x3e, 0x98, 0x1f, 0x48, 0xa4, 0xbf, 0xba, 0x5b, 0x14, 0x11, - 0xbc, 0xf1, 0x11, 0x6c, 0x27, 0xfb, 0xa0, 0x70, 0x69, 0xf0, 0x35, 0x2c, 0x2e, 0x0b, 0x3c, 0x2e, - 0xfd, 0x66, 0xdc, 0xc1, 0x95, 0x2a, 0xa3, 0xea, 0x99, 0x92, 0x44, 0xc7, 0x8c, 0x29, 0x3c, 0x7d, - 0x44, 0xee, 0x97, 0x41, 0x9e, 0xba, 0xf3, 0x8d, 0x14, 0x81, 0xa4, 0x2d, 0x23, 0x10, 0x82, 0x98, - 0xdb, 0x9f, 0x3c, 0xea, 0x96, 0x11, 0x5f, 0x7e, 0xfa, 0x38, 0xfc, 0x88, 0xfa, 0xa9, 0x96, 0x76, - 0x75, 0xa3, 0xa3, 0x9f, 0xef, 0x24, 0x88, 0x4a, 0xfd, 0x91, 0x84, 0x27, 0xf3, 0x82, 0xaa, 0x72, - 0xe5, 0x45, 0x48, 0xfc, 0x67, 0xc0, 0xa4, 0xcd, 0xed, 0xf5, 0x79, 0x56, 0x54, 0x8f, 0x8f, 0x30, - 0xfd, 0xae, 0x85, 0x39, 0x13, 0x1d, 0xc3, 0x13, 0xe2, 0x67, 0x2c, 0xc7, 0x86, 0xa6, 0x4a, 0xed, - 0xf6, 0x22, 0xd2, 0xdd, 0x1d, 0x1b, 0xb5, 0x13, 0x0d, 0x11, 0x76, 0xcf, 0x76, 0x28, 0x23, 0x09, - 0x2e, 0x2e, 0xe4, 0x0a, 0x8f, 0xce, 0x13, 0x06, 0xf4, 0x06, 0x3e, 0x2f, 0x23, 0xe9, 0x92, 0xde, - 0x18, 0x40, 0x52, 0xe3, 0x20, 0x79, 0xd2, 0x70, 0x4c, 0xa4, 0x0f, 0xc8, 0xef, 0xca, 0x60, 0x96, - 0xd8, 0x09, 0xa3, 0xc6, 0xe4, 0x7d, 0x09, 0xdd, 0x7f, 0x98, 0x1b, 0xb7, 0x58, 0x76, 0x46, 0x02, - 0x4b, 0x12, 0x67, 0x21, 0x31, 0x3e, 0xd2, 0x47, 0xe6, 0x59, 0xc7, 0x00, 0x60, 0x5c, 0x3a, 0x3f, - 0x92, 0x0f, 0x63, 0x34, 0xc2, 0xb7, 0xd0, 0xf9, 0x47, 0x9d, 0x0b, 0x18, 0xce, 0xb8, 0x6b, 0x06, - 0x1b, 0x52, 0x7c, 0xa2, 0xd0, 0xa8, 0xf2, 0xd7, 0x09, 0x6d, 0x5e, 0xea, 0x50, 0x39, 0x70, 0x70, - 0x1f, 0xb2, 0x97, 0xfb, 0x68, 0x02, 0xe3, 0x77, 0x10, 0x2b, 0xc9, 0x50, 0x5b, 0x19, 0x62, 0x66, - 0x7f, 0x0a, 0x1c, 0xd7, 0xd4, 0xd2, 0x42, 0xad, 0xba, 0x72, 0x0f, 0x7b, 0xfd, 0x52, 0x51, 0x66, - 0x27, 0x27, 0xa9, 0xc0, 0xf6, 0xaa, 0x84, 0x7d, 0x20, 0x2f, 0xab, 0xb8, 0xd9, 0x0a, 0xb3, 0xb8, - 0x32, 0xb8, 0x57, 0x13, 0x20, 0x7b, 0x98, 0x28, 0x7c, 0x27, 0x0f, 0xa6, 0x34, 0xd4, 0xb2, 0xb6, - 0xb7, 0x91, 0xd9, 0x46, 0x6d, 0xf8, 0x2a, 0x19, 0x4c, 0x07, 0xfb, 0x7d, 0x75, 0xe4, 0xc2, 0x5f, - 0x08, 0xb1, 0x39, 0x03, 0xa6, 0xbd, 0xca, 0xd5, 0xf8, 0x20, 0xf0, 0x5c, 0x9a, 0x72, 0x03, 0x38, - 0xe6, 0xa3, 0x50, 0xeb, 0x99, 0xc2, 0xec, 0xff, 0x00, 0xdf, 0xc1, 0x62, 0xb4, 0xce, 0x63, 0x74, - 0x47, 0xb4, 0x30, 0x03, 0x76, 0xe7, 0x58, 0x56, 0x23, 0xc0, 0xfa, 0xab, 0x00, 0xac, 0xa7, 0x70, - 0x60, 0x2d, 0x1c, 0x90, 0xfe, 0x61, 0xa2, 0xf6, 0x5e, 0x19, 0x1c, 0xf7, 0x3b, 0xe2, 0xf1, 0xa1, - 0xf5, 0x51, 0x16, 0xad, 0x5f, 0xe4, 0xd1, 0x5a, 0x12, 0x91, 0x66, 0x3f, 0x96, 0x23, 0x50, 0xfb, - 0x52, 0x80, 0xda, 0x2f, 0x71, 0xa8, 0xad, 0x8c, 0xa8, 0x9c, 0xc3, 0x44, 0xef, 0x7d, 0x32, 0x38, - 0xe5, 0x99, 0x9d, 0x65, 0xcb, 0xdc, 0xe8, 0x18, 0x2d, 0xd7, 0x30, 0x37, 0x43, 0x17, 0xb6, 0x25, - 0x91, 0x95, 0xcd, 0x5e, 0x6c, 0xa5, 0xfd, 0xd8, 0xf2, 0xb1, 0x33, 0x44, 0xdb, 0x56, 0x14, 0x5b, - 0x11, 0x43, 0x18, 0xe3, 0x78, 0x1d, 0x6a, 0x0e, 0x9b, 0x94, 0xbc, 0xf5, 0x09, 0x72, 0x70, 0x98, - 0xf8, 0xdd, 0x0f, 0x18, 0xd3, 0xe3, 0x39, 0x32, 0x28, 0x62, 0x7f, 0x49, 0xdc, 0xb3, 0xd3, 0xbb, - 0x49, 0x6b, 0xbc, 0x97, 0x7c, 0xd7, 0x17, 0x90, 0xef, 0x25, 0xef, 0x27, 0x28, 0xd7, 0x82, 0xd9, - 0xd6, 0x16, 0x6a, 0x5d, 0xa8, 0x98, 0xbe, 0x2f, 0x12, 0x71, 0x5c, 0xe9, 0x49, 0xe5, 0x07, 0xb3, - 0xbb, 0x79, 0x30, 0xf9, 0x85, 0x47, 0x6e, 0x62, 0xc3, 0x32, 0x15, 0xd1, 0xd0, 0x3e, 0x11, 0x00, - 0x54, 0xe5, 0x00, 0xba, 0x75, 0x28, 0xaa, 0xc9, 0x60, 0xa9, 0x0e, 0x01, 0x0b, 0x04, 0x27, 0x6b, - 0x6b, 0x8d, 0x4a, 0xad, 0xda, 0x5c, 0xaf, 0xab, 0x0b, 0xcd, 0x79, 0x1f, 0x9c, 0x7a, 0x51, 0x86, - 0xdf, 0x94, 0xc0, 0x04, 0x61, 0xcb, 0x81, 0x8f, 0x0e, 0x21, 0x18, 0x78, 0x3c, 0x00, 0xbe, 0x49, - 0x38, 0xd8, 0x4f, 0x20, 0x08, 0x5a, 0x4e, 0x44, 0xc3, 0x78, 0x22, 0x98, 0x20, 0x20, 0xfb, 0xbb, - 0x00, 0xa7, 0x23, 0x2c, 0x3b, 0x4a, 0x46, 0xf3, 0xb3, 0x0b, 0x06, 0xfe, 0x19, 0xc0, 0x46, 0xfa, - 0xd6, 0xf8, 0xd3, 0xb3, 0x64, 0xe9, 0xe0, 0x9c, 0xe1, 0x6e, 0xe1, 0xd3, 0x03, 0xf0, 0xe7, 0x44, - 0x3a, 0xae, 0x1b, 0x40, 0x6e, 0xd7, 0xcb, 0x3d, 0xe0, 0x24, 0x06, 0xc9, 0x04, 0x7f, 0x5f, 0x38, - 0xce, 0x34, 0xa7, 0x9f, 0x01, 0x4f, 0x11, 0xe0, 0xac, 0x82, 0x6c, 0xc7, 0x70, 0x5c, 0x6a, 0x73, - 0xdf, 0x92, 0x88, 0x90, 0xff, 0x50, 0x71, 0xd1, 0xb6, 0x86, 0xc9, 0xc0, 0xbb, 0x3c, 0x8b, 0x29, - 0x4c, 0x15, 0x38, 0x8d, 0x72, 0x0a, 0x4c, 0xd0, 0x53, 0xd2, 0x74, 0x5b, 0xca, 0x7f, 0x15, 0xdc, - 0x0a, 0x12, 0xaa, 0x6d, 0xfa, 0x3a, 0xf0, 0xff, 0x1d, 0x05, 0x13, 0xcb, 0x86, 0xe3, 0x5a, 0xf6, - 0x1e, 0x7c, 0x30, 0x03, 0x26, 0xce, 0x22, 0xdb, 0x31, 0x2c, 0x73, 0x9f, 0x7b, 0xd6, 0x55, 0x60, - 0xaa, 0x6b, 0xa3, 0x5d, 0xc3, 0xda, 0x71, 0x98, 0x51, 0x82, 0x49, 0x52, 0x20, 0x28, 0xe8, 0x3b, - 0xee, 0x96, 0x65, 0x87, 0xc1, 0x95, 0xfc, 0x77, 0xe5, 0x34, 0x00, 0xe4, 0xb9, 0xaa, 0x6f, 0x23, - 0xff, 0xfe, 0xf4, 0x30, 0x45, 0x51, 0x40, 0xd6, 0x35, 0xb6, 0x11, 0x8d, 0xb6, 0x8e, 0x9f, 0x3d, - 0x01, 0xe3, 0xc8, 0xa5, 0x34, 0x42, 0xac, 0xac, 0xf9, 0xaf, 0xf0, 0x0b, 0x32, 0x98, 0x5a, 0x42, - 0x2e, 0x65, 0xd5, 0x81, 0xcf, 0xcf, 0x08, 0x5d, 0x70, 0xe4, 0xcd, 0x4b, 0x3a, 0xba, 0xe3, 0xff, - 0x17, 0x0c, 0xb9, 0x7c, 0x62, 0x18, 0xfa, 0x5d, 0x66, 0xef, 0x7d, 0xc0, 0x71, 0x40, 0xdd, 0x0a, - 0x71, 0xe0, 0xa7, 0x99, 0xe9, 0xc6, 0xf1, 0xfe, 0x0f, 0xbc, 0x4d, 0x1c, 0x1b, 0x43, 0x83, 0xca, - 0x7e, 0x8e, 0xa9, 0x4f, 0x64, 0x77, 0x54, 0xd8, 0xa5, 0x39, 0xf6, 0x5d, 0xe9, 0xc1, 0x52, 0xa2, - 0x64, 0xb4, 0x20, 0xb7, 0x60, 0xf4, 0x8d, 0xc1, 0x9c, 0x8c, 0xe1, 0x12, 0x57, 0x19, 0x4c, 0xd5, - 0xb7, 0xac, 0x8b, 0xbe, 0x1c, 0x7f, 0x51, 0x0c, 0xd8, 0x2b, 0xc0, 0xe4, 0x6e, 0x0f, 0xa8, 0x61, - 0x02, 0x7b, 0x6f, 0x9c, 0xcc, 0xdf, 0x1b, 0xf7, 0x6c, 0x39, 0x29, 0x4c, 0x0c, 0x73, 0x11, 0x30, - 0xf1, 0x57, 0xbd, 0x49, 0x09, 0xae, 0x7a, 0x53, 0x9e, 0x00, 0x26, 0x28, 0xd7, 0x74, 0x99, 0x3a, - 0x1e, 0x60, 0x3f, 0x33, 0x5b, 0xc1, 0x2c, 0x5f, 0xc1, 0x64, 0xc8, 0x47, 0x57, 0x2e, 0x7d, 0xe4, - 0xff, 0x42, 0xc2, 0xb1, 0x97, 0x7c, 0xe0, 0xcb, 0x23, 0x00, 0x1e, 0x7e, 0x3f, 0x23, 0xba, 0x99, - 0x13, 0x48, 0x20, 0xe0, 0xe0, 0x40, 0x97, 0x97, 0x0d, 0x24, 0x97, 0xbe, 0x3c, 0x5f, 0x9a, 0x05, - 0xd3, 0x0b, 0xc6, 0xc6, 0x46, 0xd0, 0x49, 0xbe, 0x40, 0xb0, 0x93, 0x8c, 0x76, 0xa1, 0xf2, 0xec, - 0xdc, 0x1d, 0xdb, 0x46, 0xa6, 0x5f, 0x29, 0xda, 0x9c, 0x7a, 0x52, 0x95, 0xeb, 0xc0, 0x51, 0x7f, - 0x5c, 0x60, 0x3b, 0xca, 0x49, 0xad, 0x37, 0x19, 0x7e, 0x57, 0xd8, 0x13, 0xc0, 0x97, 0x28, 0x5b, - 0xa5, 0x88, 0x06, 0x78, 0x1b, 0x98, 0xd9, 0x22, 0xb9, 0xf1, 0x72, 0xa9, 0xdf, 0x59, 0x9e, 0xec, - 0x89, 0x6d, 0xbf, 0x8a, 0x1c, 0x47, 0xdf, 0x44, 0x1a, 0x9f, 0xb9, 0xa7, 0xf9, 0xca, 0x49, 0x6e, - 0x6a, 0x14, 0x73, 0x2a, 0x10, 0xa8, 0xc9, 0x18, 0xb4, 0xe3, 0x0c, 0xc8, 0x2e, 0x1a, 0x1d, 0x04, - 0x7f, 0x4d, 0x02, 0x93, 0xde, 0xac, 0xdb, 0x6c, 0x79, 0x6f, 0x8c, 0x43, 0xe5, 0x77, 0x32, 0xa2, - 0x37, 0x14, 0x7b, 0x74, 0xe6, 0x02, 0x1a, 0x11, 0xed, 0x46, 0xec, 0x26, 0xe2, 0x58, 0x52, 0x63, - 0xb8, 0x4f, 0xca, 0x9b, 0x7a, 0x6c, 0x6c, 0x74, 0x2c, 0x9d, 0xdb, 0x30, 0xe8, 0x35, 0x85, 0xc2, - 0x03, 0x7e, 0x55, 0xcb, 0x5d, 0x33, 0x4c, 0x33, 0x88, 0x99, 0xb1, 0x2f, 0x9d, 0xf7, 0x75, 0x89, - 0x0d, 0x3b, 0x86, 0xeb, 0x4e, 0x4b, 0x8f, 0xd0, 0xec, 0x6b, 0xc1, 0xec, 0xf9, 0x3d, 0x17, 0x39, - 0x34, 0x17, 0x2d, 0x36, 0xab, 0xf5, 0xa4, 0x32, 0x97, 0x06, 0xc4, 0x85, 0x27, 0x8b, 0x29, 0x30, - 0x99, 0xa8, 0x97, 0x87, 0x98, 0x01, 0x1e, 0x07, 0xc5, 0x6a, 0x6d, 0x41, 0xc5, 0xfe, 0xbd, 0xbe, - 0xc7, 0xe4, 0x26, 0x7c, 0xa1, 0x0c, 0xa6, 0xb1, 0x03, 0x9e, 0x8f, 0xc2, 0xd5, 0x02, 0xf3, 0x11, - 0xf8, 0x90, 0xb0, 0xef, 0x2f, 0xae, 0x32, 0x5b, 0x40, 0xb4, 0xa0, 0x37, 0x8c, 0x4e, 0xaf, 0xa0, - 0x73, 0x5a, 0x4f, 0x6a, 0x1f, 0x40, 0xe4, 0xbe, 0x80, 0xbc, 0x57, 0xc8, 0x01, 0x78, 0x10, 0x77, - 0x87, 0x85, 0xca, 0x9f, 0xc8, 0x60, 0xca, 0x9b, 0xa4, 0xf8, 0xa0, 0xd4, 0x38, 0x50, 0x2c, 0xb3, - 0xb3, 0x17, 0x2e, 0x8b, 0xf8, 0xaf, 0x89, 0x1a, 0xc9, 0xdf, 0x0a, 0xcf, 0xdc, 0xb1, 0x88, 0x18, - 0x5e, 0xc6, 0x84, 0xdf, 0x7b, 0x84, 0xe6, 0xf3, 0x03, 0x98, 0x3b, 0x2c, 0xf8, 0xbe, 0x9e, 0x03, - 0xf9, 0xf5, 0x2e, 0x46, 0xee, 0xf7, 0x65, 0x91, 0x0b, 0x38, 0xf6, 0x1d, 0xfe, 0xf2, 0xcc, 0xac, - 0x8e, 0xd5, 0xd2, 0x3b, 0x6b, 0xe1, 0x29, 0xda, 0x30, 0x41, 0xb9, 0x95, 0xfa, 0x83, 0x93, 0xd3, - 0xe3, 0xd7, 0xc6, 0xde, 0x4d, 0x81, 0x65, 0xc4, 0x1c, 0xb4, 0xbb, 0x01, 0x1c, 0x6b, 0x1b, 0x8e, - 0x7e, 0xbe, 0x83, 0x54, 0xb3, 0x65, 0xef, 0x11, 0x71, 0xd0, 0x69, 0xd5, 0xbe, 0x0f, 0xca, 0xed, - 0x20, 0xe7, 0xb8, 0x7b, 0x1d, 0x32, 0x4f, 0x64, 0xcf, 0xe5, 0x45, 0x16, 0x55, 0xf7, 0xb2, 0x6b, - 0xe4, 0x2f, 0xd6, 0xad, 0x73, 0x42, 0xcc, 0xad, 0x53, 0x79, 0x1c, 0xc8, 0x5b, 0xb6, 0xb1, 0x69, - 0x90, 0xeb, 0xe6, 0x66, 0xf7, 0x85, 0x60, 0x25, 0xa6, 0x40, 0x0d, 0x67, 0xd1, 0x68, 0x56, 0xe5, - 0x09, 0x60, 0xd2, 0xd8, 0xd6, 0x37, 0xd1, 0xdd, 0x86, 0x49, 0x0e, 0xa8, 0xcf, 0xde, 0x7c, 0x6a, - 0xdf, 0x91, 0x43, 0xfa, 0x5d, 0x0b, 0xb3, 0xc2, 0xf7, 0x48, 0xa2, 0x71, 0xe2, 0x70, 0xdd, 0x08, - 0xa8, 0x43, 0xdc, 0x5d, 0xcd, 0xc8, 0x41, 0x16, 0x74, 0x6f, 0x7d, 0x85, 0x50, 0x04, 0xb7, 0x68, - 0xb6, 0xd2, 0x1f, 0xbc, 0x3f, 0x2f, 0x81, 0xc2, 0x82, 0x75, 0xd1, 0xc4, 0x8a, 0x7e, 0x8b, 0x98, - 0xad, 0xdb, 0xe7, 0x60, 0x38, 0x7f, 0x0b, 0x72, 0xec, 0x29, 0x30, 0x5c, 0x5b, 0xbf, 0xc8, 0x08, - 0x18, 0x62, 0x5b, 0x8e, 0xe0, 0xdd, 0xb4, 0x71, 0xe5, 0xa4, 0x2f, 0xd7, 0xbf, 0x94, 0x41, 0x76, - 0xc1, 0xb6, 0xba, 0xf0, 0x8d, 0x99, 0x04, 0x6e, 0x5e, 0x6d, 0xdb, 0xea, 0x36, 0xf0, 0xe5, 0x92, - 0xe1, 0xce, 0x06, 0x9b, 0xa6, 0xdc, 0x02, 0x0a, 0x5d, 0xcb, 0x31, 0x5c, 0x7f, 0x1a, 0x31, 0x7b, - 0xf3, 0x23, 0xfa, 0xb6, 0xe6, 0x35, 0x9a, 0x49, 0x0b, 0xb2, 0x7b, 0xbd, 0x36, 0x16, 0xa1, 0x27, - 0x17, 0x4f, 0x8c, 0xfe, 0x05, 0x9b, 0x3d, 0xa9, 0xf0, 0x45, 0x2c, 0x92, 0x4f, 0xe2, 0x91, 0x7c, - 0x64, 0x1f, 0x09, 0xdb, 0x56, 0x77, 0x24, 0x8e, 0x19, 0x2f, 0x0b, 0x50, 0x7d, 0x32, 0x87, 0xea, - 0xf5, 0x42, 0x65, 0xa6, 0x8f, 0xe8, 0x7b, 0xb2, 0x00, 0x60, 0x33, 0x63, 0xdd, 0x9b, 0x00, 0x89, - 0xd9, 0x58, 0xcf, 0xcc, 0x32, 0xb2, 0x2c, 0xf1, 0xb2, 0x7c, 0x74, 0x84, 0x15, 0x83, 0xc9, 0x47, - 0x48, 0xb4, 0x04, 0x72, 0x3b, 0xde, 0x67, 0x2a, 0x51, 0x41, 0x12, 0xf8, 0x55, 0x23, 0x7f, 0xc2, - 0xbf, 0xc8, 0x80, 0x1c, 0x4e, 0x50, 0x4e, 0x03, 0x80, 0x07, 0x76, 0x72, 0x88, 0x32, 0x83, 0x87, - 0x70, 0x26, 0x05, 0x6b, 0xab, 0xd1, 0xa6, 0x9f, 0x89, 0xc9, 0x1c, 0x26, 0x78, 0x7f, 0xe3, 0xe1, - 0x1e, 0xd3, 0xa2, 0x06, 0x00, 0x93, 0xe2, 0xfd, 0x8d, 0xdf, 0x56, 0xd0, 0x06, 0x89, 0xfb, 0x9f, - 0xd5, 0xc2, 0x84, 0xe0, 0xef, 0x95, 0xe0, 0xb6, 0x48, 0xff, 0x6f, 0x9c, 0xe2, 0x4d, 0x86, 0xb1, - 0x5a, 0xce, 0x87, 0x45, 0xe4, 0x71, 0xa6, 0xde, 0x64, 0xf8, 0xaa, 0x40, 0x6d, 0x16, 0x38, 0xb5, - 0x79, 0x6c, 0x02, 0xf1, 0xa6, 0xaf, 0x3c, 0x5f, 0xcd, 0x81, 0xc9, 0xaa, 0xd5, 0xa6, 0xba, 0xc3, - 0x4c, 0x18, 0x3f, 0x9e, 0x4b, 0x34, 0x61, 0x0c, 0x68, 0x44, 0x28, 0xc8, 0x9d, 0xbc, 0x82, 0x88, - 0x51, 0x60, 0xf5, 0x43, 0x99, 0x07, 0x79, 0xac, 0xbd, 0xfb, 0xaf, 0x21, 0x8c, 0x23, 0x81, 0x45, - 0xab, 0xd1, 0x3f, 0xff, 0xd3, 0xe9, 0xd8, 0x7f, 0x05, 0x39, 0x5c, 0xc1, 0x98, 0xdd, 0x1d, 0xbe, - 0xa2, 0x52, 0x7c, 0x45, 0xe5, 0xf8, 0x8a, 0x66, 0x7b, 0x2b, 0x9a, 0x64, 0x1d, 0x20, 0x4a, 0x43, - 0xd2, 0xd7, 0xf1, 0x7f, 0x99, 0x00, 0xa0, 0xaa, 0xef, 0x1a, 0x9b, 0x64, 0x77, 0xf8, 0x0b, 0xfe, - 0xfc, 0x87, 0xee, 0xe3, 0xfe, 0x06, 0x33, 0x10, 0xde, 0x02, 0x26, 0xe8, 0xb8, 0x47, 0x2b, 0x72, - 0x25, 0x57, 0x91, 0x90, 0x0a, 0x31, 0x4b, 0xef, 0x73, 0x35, 0x3f, 0x3f, 0x77, 0x63, 0xba, 0xd4, - 0x73, 0x63, 0x7a, 0xff, 0x3d, 0x88, 0x88, 0x7b, 0xd4, 0xe1, 0x3b, 0x85, 0x4f, 0x41, 0x31, 0xfc, - 0x30, 0x35, 0x8a, 0x68, 0x82, 0x8f, 0x03, 0x13, 0x56, 0xb0, 0xa1, 0x2d, 0x47, 0xae, 0x83, 0x55, - 0xcc, 0x0d, 0x4b, 0xf3, 0x73, 0x0a, 0x6e, 0x7e, 0x09, 0xf1, 0x31, 0x96, 0x83, 0x86, 0x27, 0x97, - 0xfc, 0x18, 0x8a, 0x5e, 0x3d, 0xce, 0x19, 0xee, 0xd6, 0x0a, 0x8e, 0xcc, 0xf4, 0x4b, 0x62, 0x16, - 0x24, 0x83, 0xbf, 0x94, 0x0c, 0x7f, 0x3e, 0xce, 0x51, 0x9d, 0x47, 0xed, 0xf6, 0x28, 0x2a, 0xfd, - 0xb9, 0x8d, 0x00, 0xf0, 0x56, 0x90, 0x27, 0x8c, 0xd2, 0x4e, 0xf4, 0x4c, 0x24, 0x7e, 0x01, 0x25, - 0x8d, 0xfe, 0x01, 0xdf, 0x11, 0xe0, 0x78, 0x96, 0xc3, 0x71, 0xfe, 0x40, 0x9c, 0xa5, 0x0e, 0xe9, - 0x99, 0x9b, 0xc0, 0x04, 0x95, 0xb4, 0x32, 0xcb, 0xb6, 0xe2, 0xe2, 0x11, 0x05, 0x80, 0xfc, 0xaa, - 0xb5, 0x8b, 0x1a, 0x56, 0x31, 0xe3, 0x3d, 0x7b, 0xfc, 0x35, 0xac, 0xa2, 0x04, 0x5f, 0x5e, 0x00, - 0x85, 0x20, 0x78, 0xdd, 0xe7, 0x25, 0x50, 0x2c, 0xdb, 0x48, 0x77, 0xd1, 0xa2, 0x6d, 0x6d, 0x93, - 0x1a, 0x89, 0x7b, 0xd4, 0xff, 0xae, 0xb0, 0x8b, 0x47, 0x10, 0x54, 0xae, 0xb7, 0xb0, 0x08, 0x2c, - 0xc9, 0x22, 0xa4, 0xe4, 0x2f, 0x42, 0xc2, 0x37, 0x08, 0xb9, 0x7c, 0x88, 0x96, 0x92, 0x7e, 0x53, - 0xfb, 0xb4, 0x04, 0x72, 0xe5, 0x8e, 0x65, 0x22, 0xf6, 0xd8, 0xe7, 0xc0, 0xf3, 0x85, 0xfd, 0x77, - 0x22, 0xe0, 0xd3, 0x25, 0x51, 0x5b, 0x23, 0x14, 0x80, 0x57, 0xb6, 0xa0, 0x6c, 0xc5, 0x06, 0xa9, - 0x58, 0xd2, 0xe9, 0x0b, 0xf4, 0x9b, 0x12, 0x98, 0x24, 0xb1, 0xc4, 0x4a, 0x9d, 0x0e, 0x7c, 0x44, - 0x28, 0xd4, 0x3e, 0x01, 0x00, 0xe1, 0x7b, 0x85, 0x8f, 0x35, 0x05, 0xb5, 0x0a, 0x68, 0x27, 0x08, - 0xaa, 0x96, 0xec, 0x94, 0x8d, 0xd8, 0x5e, 0xda, 0x40, 0x86, 0xd2, 0x17, 0xf5, 0xdf, 0x48, 0x9e, - 0x01, 0x60, 0x5e, 0x58, 0xb3, 0xd1, 0xae, 0x81, 0x2e, 0xc2, 0xcb, 0x43, 0x61, 0xef, 0x0f, 0x94, - 0xf4, 0x5a, 0xe1, 0x45, 0x1c, 0x86, 0x64, 0xe4, 0x56, 0xd6, 0x54, 0x27, 0xcc, 0x44, 0x7b, 0xf1, - 0xde, 0xe8, 0x55, 0x0c, 0x19, 0x8d, 0xcd, 0x2e, 0xb8, 0x66, 0x13, 0xcd, 0x45, 0xfa, 0x82, 0xfd, - 0xe0, 0x04, 0x28, 0xac, 0x9b, 0x4e, 0xb7, 0xa3, 0x3b, 0x5b, 0xf0, 0x07, 0x32, 0xc8, 0x93, 0xcb, - 0x2f, 0xe1, 0xcf, 0x70, 0xf1, 0x58, 0x9e, 0xba, 0x83, 0x6c, 0xdf, 0x05, 0x87, 0xbc, 0x84, 0xf6, - 0x91, 0xc4, 0xd8, 0x47, 0xf0, 0x3d, 0xb2, 0xe8, 0x24, 0xd5, 0x2f, 0x94, 0xde, 0xb6, 0x19, 0x1d, - 0x02, 0xa4, 0x6b, 0xb4, 0xdc, 0x1d, 0x1b, 0x39, 0x7d, 0x43, 0x80, 0x44, 0x52, 0x59, 0x23, 0x7f, - 0x69, 0xc1, 0xef, 0x50, 0x07, 0x13, 0x34, 0x71, 0xdf, 0x76, 0xd2, 0xfe, 0x98, 0x05, 0x27, 0x41, - 0x5e, 0xb7, 0x5d, 0xc3, 0x71, 0xe9, 0x06, 0x2b, 0x7d, 0xf3, 0xba, 0x4b, 0xf2, 0xb4, 0x6e, 0x77, - 0xfc, 0xc8, 0x4d, 0x41, 0x02, 0xfc, 0x13, 0xa1, 0xf9, 0x63, 0x7c, 0xcd, 0x93, 0x41, 0x7e, 0xf7, - 0x10, 0x6b, 0xd4, 0x97, 0x82, 0x4b, 0xb4, 0x52, 0x43, 0x6d, 0x92, 0x40, 0x3f, 0x41, 0x4c, 0x9f, - 0x36, 0x7c, 0xbb, 0xcc, 0xac, 0xdf, 0xed, 0x71, 0x63, 0x04, 0x95, 0x62, 0x38, 0x46, 0x04, 0x09, - 0x31, 0xbb, 0xd5, 0xdc, 0x22, 0xac, 0x2c, 0xbe, 0x08, 0xfb, 0xc7, 0xc2, 0xbb, 0x49, 0x81, 0x28, - 0x07, 0xac, 0x01, 0xc6, 0x5d, 0x8e, 0xf7, 0x7e, 0xa1, 0x9d, 0xa1, 0x41, 0x25, 0x1d, 0x22, 0x6c, - 0xaf, 0x99, 0x00, 0x13, 0x4b, 0x7a, 0xa7, 0x83, 0xec, 0x3d, 0x6f, 0x48, 0x2a, 0xfa, 0x1c, 0xae, - 0xea, 0xa6, 0xb1, 0x81, 0x1c, 0x37, 0xbe, 0xb3, 0x7c, 0xa7, 0x70, 0xe0, 0x75, 0x5a, 0xc6, 0x5c, - 0x2f, 0xfd, 0x08, 0x99, 0xdf, 0x08, 0xb2, 0x86, 0xb9, 0x61, 0xd1, 0x2e, 0xb3, 0x77, 0xd5, 0xde, - 0xff, 0x19, 0x4f, 0x5d, 0x70, 0x46, 0xc1, 0xd8, 0xeb, 0x82, 0x5c, 0xa4, 0xdf, 0x73, 0xbe, 0x39, - 0x0b, 0x66, 0x7c, 0x26, 0x2a, 0x66, 0x1b, 0xdd, 0xc7, 0x2e, 0xc5, 0xbc, 0x30, 0x2b, 0x7a, 0x84, - 0xb6, 0xb7, 0x3e, 0x98, 0x54, 0x84, 0x48, 0x1b, 0x00, 0xb4, 0x74, 0x17, 0x6d, 0x5a, 0xb6, 0x11, - 0xf4, 0x87, 0x8f, 0x4f, 0x42, 0xad, 0x4c, 0xfe, 0xde, 0xd3, 0x18, 0x3a, 0xca, 0xed, 0x60, 0x0a, - 0x05, 0x31, 0x4b, 0xfc, 0xa5, 0x9a, 0x58, 0xbc, 0xd8, 0xfc, 0xf0, 0x6f, 0x84, 0x4e, 0xea, 0x8a, - 0x54, 0x33, 0x19, 0x66, 0xcd, 0xe1, 0xda, 0xd0, 0x7a, 0x75, 0xb5, 0xa4, 0xd5, 0x97, 0x4b, 0x2b, - 0x2b, 0x95, 0xea, 0x52, 0x10, 0x2c, 0x4b, 0x01, 0xb3, 0x0b, 0xb5, 0x73, 0x55, 0x26, 0x9a, 0x59, - 0x16, 0xae, 0x81, 0x82, 0x2f, 0xaf, 0x7e, 0xbe, 0x98, 0xac, 0xcc, 0xa8, 0x2f, 0x26, 0x93, 0xe4, - 0x19, 0x67, 0x46, 0x2b, 0x70, 0xd0, 0xc1, 0xcf, 0xf0, 0xcf, 0x75, 0x90, 0xc3, 0x6b, 0xea, 0xf0, - 0xad, 0x78, 0x1b, 0xb0, 0xdb, 0xd1, 0x5b, 0x08, 0x6e, 0x27, 0xb0, 0xc6, 0xfd, 0x9b, 0x80, 0xa4, - 0x7d, 0x37, 0x01, 0xe1, 0x47, 0x6a, 0xf5, 0x1d, 0xef, 0xb7, 0x8e, 0xaf, 0x91, 0x2c, 0xfc, 0xa1, - 0xd6, 0xd8, 0xdd, 0x15, 0xb2, 0xfc, 0x4f, 0xd9, 0x8c, 0x50, 0xc9, 0x68, 0x9e, 0x92, 0x59, 0xa2, - 0x62, 0xfb, 0x30, 0x71, 0x1c, 0xa5, 0xdf, 0xe2, 0xbf, 0x9c, 0x05, 0xb9, 0x7a, 0xb7, 0x63, 0xb8, - 0xf0, 0x25, 0xd2, 0x48, 0x30, 0x23, 0xb7, 0x37, 0xc9, 0x03, 0x6f, 0x6f, 0x0a, 0x77, 0x5d, 0xb3, - 0x02, 0xbb, 0xae, 0x0d, 0x74, 0x9f, 0xcb, 0xef, 0xba, 0xde, 0x42, 0x03, 0x5e, 0x92, 0x3d, 0xdb, - 0x47, 0xf6, 0x11, 0x29, 0xae, 0x56, 0x9f, 0x48, 0xaa, 0x67, 0x6e, 0xa2, 0x01, 0x1d, 0x01, 0xc8, - 0xcf, 0xd7, 0x1a, 0x8d, 0xda, 0x6a, 0xf1, 0x08, 0x8e, 0x04, 0x56, 0x5b, 0x23, 0xe1, 0xb5, 0x2a, - 0xd5, 0xaa, 0xaa, 0x15, 0x25, 0x1c, 0x62, 0xb2, 0xd2, 0x58, 0x51, 0x8b, 0x32, 0x7f, 0x95, 0x47, - 0xac, 0xf9, 0xcd, 0x97, 0x9d, 0xa6, 0x7a, 0x89, 0x19, 0xe2, 0xd1, 0xfc, 0xa4, 0xaf, 0x5c, 0xbf, - 0x23, 0x83, 0xdc, 0x2a, 0xb2, 0x37, 0x11, 0x7c, 0x6a, 0x82, 0x4d, 0xbe, 0x0d, 0xc3, 0x76, 0x48, - 0x40, 0xce, 0x70, 0x93, 0x8f, 0x4d, 0x53, 0xae, 0x01, 0x33, 0x0e, 0x6a, 0x59, 0x66, 0xdb, 0xcf, - 0x44, 0xfa, 0x23, 0x3e, 0x11, 0xbe, 0x38, 0x21, 0x64, 0x98, 0xd1, 0x91, 0xec, 0xd4, 0x25, 0x01, - 0xa6, 0x5f, 0xa9, 0xe9, 0x03, 0xf3, 0x5d, 0xd9, 0xfb, 0xa9, 0xbb, 0x07, 0x5f, 0x2c, 0xbc, 0xfb, - 0x7a, 0x03, 0xc8, 0x9f, 0xf7, 0x23, 0xbb, 0xcb, 0x91, 0xfd, 0x31, 0xcd, 0xa3, 0xcc, 0x83, 0x63, - 0x0e, 0xea, 0xa0, 0x96, 0x8b, 0xda, 0x5e, 0xd3, 0xd5, 0x06, 0x76, 0x0a, 0xfb, 0xb3, 0xc3, 0xbf, - 0x62, 0x01, 0xbc, 0x8d, 0x07, 0xf0, 0xda, 0x3e, 0xa2, 0xf4, 0x2a, 0x14, 0x6d, 0x2b, 0x7b, 0xd5, - 0xa8, 0x77, 0xac, 0x60, 0x51, 0xdc, 0x7f, 0xf7, 0xbe, 0x6d, 0xb9, 0xdb, 0x1d, 0xfc, 0x8d, 0x1e, - 0x30, 0xf0, 0xdf, 0x95, 0x39, 0x30, 0xa1, 0x9b, 0x7b, 0xf8, 0x53, 0x36, 0xa6, 0xd6, 0x7e, 0x26, - 0xf8, 0xf2, 0x00, 0xf9, 0x3b, 0x38, 0xe4, 0x1f, 0x2d, 0xc6, 0x6e, 0xfa, 0xc0, 0xff, 0xea, 0x04, - 0xc8, 0xad, 0xe9, 0x8e, 0x8b, 0xe0, 0xff, 0x2b, 0x8b, 0x22, 0x7f, 0x2d, 0x98, 0xdd, 0xb0, 0x5a, - 0x3b, 0x0e, 0x6a, 0xf3, 0x8d, 0xb2, 0x27, 0x75, 0x14, 0x98, 0x2b, 0xd7, 0x83, 0xa2, 0x9f, 0x48, - 0xc9, 0xfa, 0xdb, 0xf0, 0xfb, 0xd2, 0xf1, 0xc5, 0x10, 0xce, 0x9a, 0x6e, 0xbb, 0xb5, 0x0d, 0x9c, - 0x16, 0x5c, 0x0c, 0xc1, 0x26, 0x72, 0xd0, 0xe7, 0x63, 0xa0, 0x9f, 0x88, 0x86, 0xbe, 0x20, 0x00, - 0xbd, 0x52, 0x02, 0x85, 0x0d, 0xa3, 0x83, 0xf0, 0x0f, 0x93, 0xf8, 0x87, 0x7e, 0x63, 0x12, 0x96, - 0x7d, 0x30, 0x26, 0x2d, 0x1a, 0x1d, 0xa4, 0x05, 0xbf, 0xf9, 0x13, 0x19, 0x10, 0x4e, 0x64, 0x56, - 0x88, 0x3f, 0xad, 0x67, 0x78, 0x99, 0xfa, 0x36, 0xf2, 0x17, 0xdf, 0x4c, 0x7a, 0xb8, 0xa5, 0xad, - 0xbb, 0x3a, 0x06, 0x63, 0x5a, 0xc3, 0xcf, 0xbc, 0x5f, 0x88, 0xdc, 0xeb, 0x17, 0xf2, 0x2c, 0x39, - 0x59, 0x8f, 0xe8, 0x33, 0x1b, 0xd1, 0xa2, 0xce, 0xfb, 0x00, 0x11, 0x4b, 0x31, 0x78, 0xf7, 0x80, - 0x69, 0xe9, 0x36, 0x72, 0xd7, 0x58, 0x4f, 0x8c, 0x9c, 0xc6, 0x27, 0x62, 0x57, 0x3e, 0xa7, 0xae, - 0x6f, 0x93, 0xcb, 0x21, 0xca, 0xde, 0x37, 0xea, 0xa2, 0xb5, 0x2f, 0x3d, 0xec, 0x7f, 0x73, 0xa3, - 0xee, 0x7f, 0xfb, 0xd5, 0x31, 0xfd, 0x66, 0xf8, 0xca, 0x2c, 0x90, 0xcb, 0x3b, 0xee, 0xc3, 0xba, - 0xfb, 0xfd, 0xa1, 0xb0, 0x9f, 0x0b, 0xed, 0xcf, 0x76, 0xdc, 0xc3, 0xed, 0x7d, 0x13, 0x6a, 0x89, - 0x98, 0x3f, 0x4d, 0x54, 0xdd, 0xd2, 0xd7, 0x91, 0x37, 0xca, 0x81, 0x83, 0xe5, 0xfd, 0x99, 0x83, - 0x9b, 0xe6, 0x90, 0xf4, 0x4f, 0x4c, 0xcf, 0x10, 0xbc, 0xfb, 0x1d, 0x4f, 0x96, 0x8b, 0x6f, 0x8a, - 0xb7, 0xd7, 0xb1, 0x28, 0xa7, 0x35, 0xf2, 0x02, 0x5f, 0x2a, 0xec, 0x76, 0x4e, 0xc4, 0x16, 0xeb, - 0x4a, 0x98, 0xcc, 0xa6, 0x12, 0xbb, 0x1b, 0x3b, 0xa6, 0xd8, 0xf4, 0x01, 0xfb, 0x36, 0xeb, 0x2a, - 0x58, 0x3a, 0x30, 0x62, 0xf0, 0x15, 0xc2, 0xdb, 0x51, 0xa4, 0xda, 0x03, 0xd6, 0x0b, 0x93, 0xc9, - 0x5b, 0x6c, 0xb3, 0x2a, 0xb6, 0xe0, 0xf4, 0x25, 0xfe, 0x2d, 0x19, 0xe4, 0xc9, 0x16, 0x24, 0x7c, - 0x9d, 0x70, 0x13, 0xf1, 0x7a, 0x23, 0xde, 0x85, 0x30, 0x78, 0x4f, 0xb2, 0xe6, 0xc0, 0xb9, 0x1a, - 0x66, 0x13, 0xb9, 0x1a, 0xf2, 0xe7, 0x38, 0x05, 0xda, 0x11, 0xa9, 0x63, 0xca, 0xd3, 0xc9, 0x24, - 0x2d, 0xac, 0x2f, 0x43, 0xe9, 0xe3, 0xfd, 0x9c, 0x1c, 0x98, 0x26, 0x45, 0x9f, 0x33, 0xda, 0x9b, - 0xc8, 0x85, 0x6f, 0x97, 0x7e, 0x7c, 0x50, 0x57, 0xaa, 0x60, 0xfa, 0x22, 0x66, 0x9b, 0xdc, 0x62, - 0x45, 0x57, 0x2e, 0xae, 0x8f, 0x5d, 0xf7, 0x20, 0xf5, 0xf4, 0xef, 0xbd, 0xe2, 0xfe, 0xf7, 0x64, - 0x4c, 0x16, 0xfc, 0x89, 0x03, 0x57, 0x1e, 0x1b, 0x59, 0x6c, 0x92, 0x72, 0x12, 0xe4, 0x77, 0x0d, - 0x74, 0xb1, 0xd2, 0xa6, 0xd6, 0x2d, 0x7d, 0x83, 0x7f, 0x2a, 0xbc, 0x6f, 0xcb, 0xc2, 0x4d, 0x79, - 0x49, 0x57, 0x0b, 0xc5, 0x76, 0x6f, 0x07, 0xb2, 0x35, 0x86, 0x33, 0xc5, 0xfc, 0xdd, 0xd3, 0xe5, - 0x04, 0x8a, 0x18, 0x65, 0x38, 0xf3, 0xa1, 0x3c, 0x62, 0x4f, 0xac, 0x10, 0x01, 0x8c, 0xf8, 0x5a, - 0x6a, 0xb1, 0xf8, 0x12, 0x03, 0x8a, 0x4e, 0x5f, 0xf2, 0xaf, 0x92, 0xc1, 0x64, 0x1d, 0xb9, 0x8b, - 0x06, 0xea, 0xb4, 0x1d, 0x68, 0x1f, 0xdc, 0x34, 0xba, 0x11, 0xe4, 0x37, 0x30, 0xb1, 0x41, 0xe7, - 0x16, 0x68, 0x36, 0xf8, 0x4a, 0x49, 0x74, 0x47, 0x98, 0xae, 0xbe, 0xf9, 0xdc, 0x8e, 0x04, 0x26, - 0x31, 0x8f, 0xde, 0xf8, 0x92, 0xc7, 0x10, 0x0c, 0x5c, 0x06, 0xd3, 0xf4, 0xb2, 0xda, 0x52, 0xc7, - 0xd8, 0x34, 0xe1, 0xce, 0x08, 0x5a, 0x88, 0xf2, 0x58, 0x90, 0xd3, 0x3d, 0x6a, 0x74, 0xeb, 0x15, - 0xf6, 0xed, 0x3c, 0x71, 0x79, 0x1a, 0xc9, 0x98, 0x20, 0xf4, 0x6e, 0xa8, 0xd8, 0x3e, 0xcf, 0x63, - 0x0c, 0xbd, 0x3b, 0xb0, 0xf0, 0xf4, 0x11, 0xfb, 0x8a, 0x0c, 0x8e, 0x53, 0x06, 0xce, 0x22, 0xdb, - 0x35, 0x5a, 0x7a, 0x87, 0x20, 0xf7, 0xbc, 0xcc, 0x28, 0xa0, 0x5b, 0x06, 0x33, 0xbb, 0x2c, 0x59, - 0x0a, 0xe1, 0x99, 0xbe, 0x10, 0x72, 0x0c, 0x68, 0xfc, 0x8f, 0x09, 0x42, 0x98, 0x72, 0x52, 0xe5, - 0x68, 0x8e, 0x31, 0x84, 0xa9, 0x30, 0x13, 0xe9, 0x43, 0xfc, 0x22, 0x1a, 0x9a, 0x27, 0xec, 0x3e, - 0xbf, 0x20, 0x8c, 0xed, 0x3a, 0x98, 0xc2, 0x58, 0x92, 0x1f, 0xe9, 0x32, 0x44, 0x8c, 0x12, 0x07, - 0xfd, 0x0e, 0xbd, 0x64, 0x31, 0xf8, 0x57, 0x63, 0xe9, 0xc0, 0x73, 0x00, 0x84, 0x9f, 0xd8, 0x4e, - 0x3a, 0x13, 0xd5, 0x49, 0x4b, 0x62, 0x9d, 0xf4, 0x6b, 0x85, 0x83, 0xa5, 0xf4, 0x67, 0xfb, 0xe0, - 0xea, 0x21, 0x16, 0x26, 0x63, 0x70, 0xe9, 0xe9, 0xeb, 0xc5, 0xcb, 0xa9, 0x5e, 0x2c, 0xec, 0x74, - 0x3b, 0x46, 0xcb, 0x9b, 0x4f, 0x7d, 0x64, 0x24, 0xf3, 0x29, 0xb6, 0x3f, 0x90, 0x7b, 0xfa, 0x83, - 0x03, 0x58, 0xd2, 0xd7, 0x81, 0xa3, 0xa4, 0x88, 0x72, 0xc0, 0x56, 0x8e, 0x84, 0x82, 0xe8, 0x49, - 0xe6, 0xe3, 0x12, 0x0a, 0x2a, 0x41, 0x20, 0x84, 0x21, 0x96, 0x3e, 0x93, 0x19, 0xbb, 0x49, 0x15, - 0x24, 0x8a, 0xb3, 0x31, 0xb8, 0x85, 0x66, 0x89, 0xb5, 0xbb, 0x8e, 0xef, 0xc1, 0x84, 0x5f, 0xca, - 0x8e, 0x62, 0x44, 0xb8, 0x13, 0x64, 0xb1, 0x8b, 0xbb, 0x1c, 0xb9, 0xa4, 0x11, 0x16, 0x19, 0x5e, - 0x52, 0x8a, 0xee, 0x73, 0x97, 0x8f, 0x68, 0xf8, 0x4f, 0xe5, 0x7a, 0x70, 0xf4, 0xbc, 0xde, 0xba, - 0xb0, 0x69, 0x5b, 0x3b, 0xf8, 0xc6, 0x40, 0x8b, 0x5e, 0x3d, 0x88, 0xaf, 0x70, 0xe5, 0x3f, 0x28, - 0x37, 0xfb, 0xa6, 0x43, 0x6e, 0x90, 0xe9, 0xb0, 0x7c, 0x84, 0x1a, 0x0f, 0xca, 0x4d, 0x41, 0xa7, - 0x93, 0x8f, 0xed, 0x74, 0x96, 0x8f, 0xf8, 0xdd, 0x8e, 0xb2, 0x00, 0x0a, 0x6d, 0x63, 0x17, 0x6f, - 0x55, 0xe3, 0x59, 0xd7, 0xa0, 0xa3, 0xcb, 0x0b, 0xc6, 0x2e, 0xd9, 0xd8, 0x5e, 0x3e, 0xa2, 0x05, - 0x7f, 0x2a, 0x4b, 0x60, 0x12, 0x6f, 0x0b, 0x60, 0x32, 0x85, 0x44, 0xc7, 0x92, 0x97, 0x8f, 0x68, - 0xe1, 0xbf, 0x9e, 0xf5, 0x91, 0xc5, 0x67, 0x3f, 0xee, 0xf0, 0xb7, 0xdb, 0x33, 0x89, 0xb6, 0xdb, - 0x3d, 0x59, 0x90, 0x0d, 0xf7, 0x93, 0x20, 0xd7, 0xc2, 0x12, 0x96, 0xa8, 0x84, 0xc9, 0xab, 0x72, - 0x1b, 0xc8, 0x6e, 0xeb, 0xb6, 0x3f, 0x79, 0xbe, 0x76, 0x30, 0xdd, 0x55, 0xdd, 0xbe, 0xe0, 0x21, - 0xe8, 0xfd, 0x35, 0x3f, 0x01, 0x72, 0x58, 0x70, 0xc1, 0x03, 0x7c, 0x63, 0x96, 0x98, 0x21, 0x65, - 0xcb, 0xf4, 0x86, 0xfd, 0x86, 0xe5, 0x1f, 0x90, 0xf9, 0xd3, 0xcc, 0x68, 0x2c, 0xc8, 0x4b, 0x98, - 0x80, 0xc1, 0xa6, 0xf1, 0xd4, 0x1d, 0x74, 0x37, 0xda, 0xa3, 0x4b, 0xa2, 0xfd, 0x3e, 0xf5, 0xdc, - 0x27, 0x9f, 0xed, 0xbd, 0x4f, 0x3e, 0x5c, 0x3e, 0xc8, 0x0d, 0x76, 0x54, 0xf9, 0xab, 0x21, 0x4c, - 0x97, 0x5e, 0x41, 0x44, 0xcf, 0xc0, 0x3b, 0x86, 0xc9, 0xd4, 0xd9, 0x7f, 0x4d, 0xd8, 0x29, 0x25, - 0x35, 0x6a, 0x06, 0xb0, 0x97, 0x7e, 0xdf, 0xf4, 0xfa, 0x2c, 0x89, 0x99, 0x4a, 0x4e, 0x61, 0xf0, - 0x77, 0xf4, 0xc2, 0x4f, 0x8d, 0x44, 0x69, 0xfa, 0x0c, 0x38, 0x72, 0xdf, 0x01, 0x67, 0xdf, 0x21, - 0xe5, 0xec, 0x80, 0x43, 0xca, 0xb9, 0x64, 0x2b, 0x87, 0x1f, 0x60, 0xf5, 0x67, 0x8d, 0xd7, 0x9f, - 0x5b, 0x23, 0x00, 0xea, 0x27, 0x97, 0x91, 0xd8, 0x37, 0x6f, 0x0d, 0x34, 0xa5, 0xce, 0x69, 0xca, - 0x1d, 0xc3, 0x33, 0x92, 0xbe, 0xb6, 0xbc, 0x2f, 0x0b, 0x2e, 0x09, 0x99, 0xa9, 0xa2, 0x8b, 0x54, - 0x51, 0x3e, 0x3f, 0x12, 0x45, 0x49, 0x1e, 0x03, 0x21, 0x6d, 0x8d, 0xf9, 0x0b, 0xe1, 0xb3, 0x43, - 0xbd, 0x40, 0x05, 0xb2, 0x89, 0x50, 0x96, 0x93, 0x20, 0x4f, 0x7a, 0x18, 0x0a, 0x0d, 0x7d, 0x4b, - 0xd8, 0xdd, 0x88, 0x9d, 0x38, 0x12, 0xe5, 0x6d, 0x0c, 0xfa, 0x43, 0xd7, 0x35, 0x1a, 0x3b, 0xb6, - 0x59, 0x31, 0x5d, 0x0b, 0xfe, 0xca, 0x48, 0x14, 0x27, 0xf0, 0x86, 0x93, 0x87, 0xf1, 0x86, 0x1b, - 0x6a, 0x95, 0xc3, 0xaf, 0xc1, 0xa1, 0xac, 0x72, 0x44, 0x14, 0x9e, 0x3e, 0x7e, 0x6f, 0x91, 0xc1, - 0x49, 0x3a, 0xd9, 0x9a, 0xe7, 0x2d, 0x44, 0x78, 0xcf, 0x28, 0x80, 0x3c, 0xee, 0x9b, 0x49, 0xf4, - 0x66, 0x48, 0xfc, 0xc2, 0x9f, 0x94, 0x8a, 0xbd, 0x13, 0x87, 0x9b, 0x0e, 0xf6, 0x70, 0x38, 0x12, - 0xa4, 0xc4, 0xae, 0xc2, 0x49, 0xc0, 0x46, 0xfa, 0x98, 0xbd, 0x40, 0x06, 0x79, 0x72, 0x4e, 0x0b, - 0xae, 0xa7, 0xe2, 0x30, 0xc1, 0x47, 0x79, 0x16, 0xd8, 0x91, 0x23, 0xdc, 0xa4, 0x76, 0x86, 0x2d, - 0xc9, 0x5e, 0x5c, 0x5f, 0x56, 0xc6, 0xe0, 0x42, 0x28, 0x81, 0xa9, 0x3a, 0x72, 0xcb, 0xba, 0x6d, - 0x1b, 0xfa, 0xe6, 0xa8, 0x3c, 0xbe, 0x45, 0xbd, 0x87, 0xe1, 0xf7, 0x32, 0xa2, 0xe7, 0x69, 0x82, - 0x85, 0x70, 0x9f, 0xd5, 0x88, 0x58, 0x82, 0x0f, 0x0a, 0x9d, 0x99, 0x19, 0x44, 0x6d, 0x0c, 0x1e, - 0xdb, 0x12, 0x98, 0xf0, 0xcf, 0xe2, 0xdd, 0xc8, 0x9d, 0xcf, 0xdc, 0x72, 0xb7, 0xfd, 0x63, 0x30, - 0xf8, 0x79, 0xff, 0x19, 0x30, 0xf8, 0xb2, 0x84, 0x8e, 0xf2, 0xf1, 0x07, 0x09, 0x93, 0xb5, 0xb1, - 0x24, 0xee, 0xf0, 0x87, 0x75, 0x74, 0xf0, 0xbd, 0x13, 0x74, 0x39, 0x72, 0x45, 0x77, 0xd1, 0x7d, - 0xf0, 0x0b, 0x32, 0x98, 0xa8, 0x23, 0xd7, 0x1b, 0x6f, 0xb9, 0x0b, 0xa1, 0x87, 0xd5, 0x70, 0x85, - 0x59, 0xf1, 0x98, 0xa4, 0x6b, 0x18, 0x77, 0x81, 0xc9, 0xae, 0x6d, 0xb5, 0x90, 0xe3, 0xd0, 0xd5, - 0x0b, 0xd6, 0x51, 0xad, 0xdf, 0xe8, 0x8f, 0x59, 0x9b, 0x5b, 0xf3, 0xff, 0xd1, 0xc2, 0xdf, 0x93, - 0x9a, 0x01, 0x84, 0x12, 0xad, 0xe0, 0xb8, 0xcd, 0x80, 0xb8, 0xc2, 0xd3, 0x07, 0xfa, 0xb3, 0x32, - 0x98, 0xae, 0x23, 0x37, 0x90, 0x62, 0x82, 0x4d, 0x8e, 0x68, 0x78, 0x39, 0x28, 0xe5, 0x83, 0x41, - 0x29, 0x7e, 0x9d, 0x2a, 0x2f, 0xcd, 0x80, 0xd8, 0x18, 0xaf, 0x53, 0x15, 0xe3, 0x60, 0x0c, 0xc7, - 0xd7, 0x1e, 0x09, 0x26, 0x31, 0x2f, 0xb8, 0xc1, 0xfe, 0x7a, 0x36, 0x6c, 0xbc, 0x5f, 0x4c, 0xa9, - 0xf1, 0xde, 0x0e, 0x72, 0xdb, 0xba, 0x7d, 0xc1, 0xc1, 0x0d, 0x77, 0x4a, 0xc4, 0x6c, 0x5f, 0xf5, - 0xb2, 0x6b, 0xe4, 0xaf, 0xfe, 0x7e, 0x9a, 0xb9, 0x64, 0x7e, 0x9a, 0x0f, 0x4a, 0x89, 0x46, 0x42, - 0x32, 0x77, 0x18, 0x61, 0x93, 0x4f, 0x30, 0x6e, 0xc6, 0x94, 0x9d, 0xbe, 0x72, 0x3c, 0x4f, 0x06, - 0x05, 0x6f, 0xdc, 0xc6, 0xf6, 0xf8, 0xb9, 0x83, 0xab, 0x43, 0x7f, 0x43, 0x3f, 0x61, 0x0f, 0xec, - 0x4b, 0x64, 0x74, 0xe6, 0x7d, 0x82, 0x1e, 0x38, 0xae, 0xf0, 0xf4, 0xf1, 0x78, 0x1b, 0xc1, 0x03, - 0xb7, 0x07, 0xf8, 0x6a, 0x19, 0xc8, 0x4b, 0xc8, 0x1d, 0xb7, 0x15, 0xf9, 0x26, 0xe1, 0x10, 0x47, - 0x9c, 0xc0, 0x30, 0xcf, 0x73, 0x4b, 0x68, 0x34, 0x0d, 0x48, 0x2c, 0xb6, 0x91, 0x10, 0x03, 0xe9, - 0xa3, 0xf6, 0x2e, 0x82, 0x1a, 0xd9, 0x5c, 0xf8, 0xe5, 0x11, 0xf4, 0xaa, 0xe3, 0x5d, 0xf8, 0xf0, - 0x05, 0x88, 0x69, 0x1c, 0x56, 0x7b, 0xeb, 0x57, 0xf8, 0x58, 0xae, 0x2f, 0x05, 0x5e, 0x63, 0xdf, - 0x42, 0xad, 0x0b, 0xa8, 0xcd, 0x5e, 0x07, 0x37, 0x2c, 0x74, 0xa7, 0xc0, 0x44, 0x8b, 0x50, 0xc3, - 0xe0, 0x15, 0x34, 0xff, 0x35, 0xc1, 0x5d, 0xfc, 0x7c, 0x47, 0x44, 0x7e, 0x1f, 0xe3, 0x5d, 0xfc, - 0x02, 0xc5, 0x8f, 0xc1, 0x6c, 0x21, 0xb3, 0x8c, 0x4a, 0xcb, 0x32, 0xe1, 0x7f, 0x39, 0x38, 0x2c, - 0x57, 0x80, 0x49, 0xa3, 0x65, 0x99, 0x38, 0x0c, 0x85, 0x7f, 0x08, 0x28, 0x48, 0xf0, 0xbf, 0xaa, - 0xdb, 0xd6, 0xbd, 0x06, 0xdd, 0x35, 0x0f, 0x13, 0x86, 0x35, 0x26, 0x3c, 0xd6, 0x0f, 0xcb, 0x98, - 0xe8, 0x53, 0x76, 0xfa, 0x90, 0x7d, 0x34, 0xf4, 0x6e, 0x23, 0x5d, 0xe1, 0xc3, 0x62, 0x15, 0x78, - 0x98, 0xe1, 0x8c, 0xad, 0xc5, 0xa1, 0x0c, 0x67, 0x31, 0x0c, 0x8c, 0xe1, 0xc6, 0x8a, 0x10, 0xc7, - 0xd4, 0xd7, 0x80, 0x0f, 0x80, 0xce, 0xe8, 0xcc, 0xc3, 0x21, 0xd1, 0x39, 0x1c, 0x13, 0xf1, 0xfd, - 0x34, 0x44, 0x26, 0xb5, 0x78, 0xe0, 0x7f, 0x1d, 0x05, 0x38, 0xb7, 0x0e, 0xe3, 0xaf, 0x40, 0xbc, - 0x15, 0xe0, 0x1b, 0x24, 0xd1, 0x10, 0x28, 0xfb, 0x24, 0xe8, 0x51, 0x19, 0x09, 0x82, 0xaf, 0x15, - 0x8a, 0x4d, 0x22, 0x52, 0x7e, 0xfa, 0x00, 0x3e, 0x57, 0x06, 0xb3, 0xd8, 0x47, 0xa0, 0x83, 0x74, - 0x9b, 0x74, 0x94, 0x23, 0x71, 0x94, 0x7f, 0x9b, 0x70, 0x80, 0x1f, 0x5e, 0x0e, 0x21, 0x1f, 0x23, - 0x81, 0x42, 0x2c, 0xba, 0x8f, 0x20, 0x0b, 0x63, 0xd9, 0x46, 0x29, 0x06, 0x2c, 0x50, 0x15, 0x1f, - 0x0d, 0x1e, 0x09, 0x3d, 0x72, 0x79, 0x61, 0xf8, 0x8d, 0x6d, 0xcc, 0x1e, 0xb9, 0x22, 0x4c, 0xa4, - 0x8f, 0xc9, 0xab, 0x1f, 0x4b, 0x17, 0x9c, 0x1b, 0xfa, 0xf9, 0x0e, 0x82, 0xaf, 0xc8, 0x06, 0x27, - 0xda, 0x3e, 0x3b, 0x12, 0x0f, 0xcc, 0x03, 0x04, 0xc4, 0x57, 0x40, 0xd6, 0xb6, 0x2e, 0x92, 0xa5, - 0xad, 0x19, 0x0d, 0x3f, 0x93, 0xeb, 0x29, 0x3b, 0x3b, 0xdb, 0x26, 0x39, 0x19, 0x3a, 0xa3, 0xf9, - 0xaf, 0xca, 0x35, 0x60, 0xe6, 0xa2, 0xe1, 0x6e, 0x2d, 0x23, 0xbd, 0x8d, 0x6c, 0xcd, 0xba, 0x88, - 0x3d, 0xe6, 0x0a, 0x1a, 0x9f, 0xc8, 0xfb, 0xaf, 0x08, 0xd8, 0x97, 0x9e, 0x50, 0xc6, 0x73, 0xfc, - 0x2d, 0x89, 0xe5, 0x19, 0xcd, 0x55, 0xfa, 0x0a, 0xf3, 0x6e, 0x19, 0x4c, 0x6a, 0xd6, 0x45, 0xaa, - 0x24, 0xff, 0xf7, 0xe1, 0xea, 0x48, 0xe2, 0x89, 0x1e, 0x96, 0x5c, 0xc0, 0xfe, 0xd8, 0x27, 0x7a, - 0xb1, 0xc5, 0x8f, 0xe5, 0xe4, 0xd2, 0xb4, 0x66, 0x5d, 0xac, 0x23, 0x97, 0xb4, 0x08, 0xd8, 0x1c, - 0x91, 0x93, 0xb5, 0xe1, 0x10, 0x82, 0x74, 0x1e, 0x1e, 0xbc, 0x27, 0xdd, 0x45, 0x08, 0x04, 0x14, - 0xb0, 0x38, 0xee, 0x5d, 0x84, 0x81, 0x1c, 0x8c, 0x21, 0x46, 0x8a, 0x0c, 0xa6, 0x34, 0xeb, 0xa2, - 0x37, 0x34, 0x2c, 0x1a, 0x9d, 0xce, 0x68, 0x46, 0xc8, 0xa4, 0xc6, 0xbf, 0x2f, 0x06, 0x9f, 0x8b, - 0xb1, 0x1b, 0xff, 0x03, 0x18, 0x48, 0x1f, 0x86, 0x67, 0x91, 0xc6, 0xe2, 0x8f, 0xd0, 0xe6, 0x68, - 0x70, 0x18, 0xb6, 0x41, 0x04, 0x6c, 0x1c, 0x5a, 0x83, 0x88, 0xe2, 0x60, 0x2c, 0x3b, 0x27, 0xb3, - 0x65, 0x3c, 0xcc, 0x8f, 0xb6, 0x4d, 0xbc, 0x23, 0x99, 0x6b, 0x22, 0x1d, 0x76, 0x39, 0x46, 0x46, - 0x82, 0x46, 0x02, 0x17, 0x44, 0x01, 0x1e, 0xd2, 0xc7, 0xe3, 0x43, 0x32, 0x98, 0x26, 0x2c, 0x3c, - 0x4c, 0xac, 0x80, 0xa1, 0x1a, 0x15, 0x5b, 0x83, 0xc3, 0x69, 0x54, 0x31, 0x1c, 0x8c, 0xe5, 0x56, - 0x50, 0xcf, 0x8e, 0x1b, 0xe2, 0xf8, 0x78, 0x14, 0x82, 0x43, 0x1b, 0x63, 0x23, 0x3c, 0x42, 0x3e, - 0x8c, 0x31, 0x76, 0x48, 0xc7, 0xc8, 0x9f, 0x15, 0xb4, 0xa2, 0x51, 0x62, 0x70, 0x80, 0xa6, 0x30, - 0x42, 0x18, 0x86, 0x6c, 0x0a, 0x87, 0x84, 0xc4, 0x57, 0x65, 0x00, 0x08, 0x03, 0xab, 0xd6, 0x2e, - 0xbe, 0xcc, 0x67, 0x04, 0xdd, 0x59, 0xaf, 0x5b, 0xbd, 0x3c, 0xc0, 0xad, 0x3e, 0x61, 0x08, 0x97, - 0xa4, 0x2b, 0x81, 0x8c, 0x94, 0xbd, 0x4a, 0x8e, 0x7d, 0x25, 0x30, 0xbe, 0xfc, 0xf4, 0x31, 0x7e, - 0x88, 0x58, 0x73, 0xe1, 0x01, 0xd3, 0xdf, 0x1b, 0x09, 0xca, 0xcc, 0xec, 0x5f, 0xe6, 0x67, 0xff, - 0x07, 0xc0, 0x76, 0x58, 0x1b, 0x71, 0xd0, 0xc1, 0xd1, 0xf4, 0x6d, 0xc4, 0xc3, 0x3b, 0x20, 0xfa, - 0xcb, 0x59, 0x70, 0x94, 0x76, 0x22, 0x3f, 0x0e, 0x10, 0x27, 0x3c, 0x87, 0xc7, 0x75, 0x92, 0x03, - 0x50, 0x1e, 0xd5, 0x82, 0x54, 0x92, 0xa5, 0x4c, 0x01, 0xf6, 0xc6, 0xb2, 0xba, 0x91, 0x57, 0xef, - 0xeb, 0xea, 0x66, 0x5b, 0x3c, 0xdc, 0xef, 0x00, 0xe0, 0xfd, 0xb5, 0x46, 0x99, 0x5f, 0x6b, 0xec, - 0xb3, 0x32, 0x99, 0x78, 0xe7, 0x1a, 0x8b, 0x8c, 0xb0, 0x3b, 0xf6, 0x9d, 0xeb, 0xe8, 0xb2, 0xd3, - 0x47, 0xe9, 0x1d, 0x32, 0xc8, 0xd6, 0x2d, 0xdb, 0x85, 0xcf, 0x4e, 0xd2, 0x3a, 0x89, 0xe4, 0x43, - 0x90, 0xfc, 0x77, 0xa5, 0xcc, 0xdd, 0xd2, 0x7c, 0x63, 0xfc, 0x51, 0x67, 0xdd, 0xd5, 0xb1, 0x57, - 0xb7, 0x57, 0x3e, 0x73, 0x5d, 0x73, 0xd2, 0x78, 0x3a, 0x44, 0x7e, 0xf5, 0xe8, 0x03, 0x18, 0xa9, - 0xc5, 0xd3, 0x89, 0x2c, 0x39, 0x7d, 0xdc, 0x1e, 0x38, 0x4a, 0x7d, 0x5b, 0x17, 0x8d, 0x0e, 0x82, - 0xcf, 0x26, 0x2e, 0x23, 0x55, 0x7d, 0x1b, 0x89, 0x1f, 0x89, 0x89, 0x75, 0x6d, 0xc5, 0xf1, 0x65, - 0xe5, 0x30, 0xbe, 0x6c, 0xd2, 0x06, 0x45, 0x0e, 0xa0, 0x13, 0x96, 0xc6, 0xdd, 0xa0, 0x62, 0xca, - 0x1e, 0x4b, 0x9c, 0xce, 0x63, 0x75, 0xe4, 0x12, 0xa3, 0xb2, 0xe6, 0xdf, 0xc0, 0xf2, 0x8b, 0x23, - 0x89, 0xd8, 0x19, 0x5c, 0xf0, 0x22, 0xf7, 0x5c, 0xf0, 0xf2, 0x6e, 0x16, 0x9c, 0x55, 0x1e, 0x9c, - 0x9f, 0x8d, 0x16, 0x10, 0xcf, 0xe4, 0x48, 0x60, 0x7a, 0x53, 0x00, 0xd3, 0x1a, 0x07, 0xd3, 0x6d, - 0x43, 0x72, 0x91, 0x3e, 0x60, 0xbf, 0x99, 0x03, 0x47, 0xc9, 0xa4, 0xbf, 0x64, 0xb6, 0x69, 0x84, - 0xd5, 0xd7, 0x49, 0x87, 0xbc, 0xd9, 0xb6, 0x3f, 0x04, 0x2b, 0x17, 0xcb, 0x39, 0xd7, 0x7b, 0x3b, - 0xfe, 0x3c, 0x09, 0xe7, 0xea, 0x75, 0xa2, 0x78, 0xa7, 0x4d, 0xfc, 0x86, 0xfc, 0xe0, 0x3f, 0xfe, - 0x2e, 0xa3, 0x09, 0xf1, 0xbb, 0x8c, 0xfe, 0x32, 0xd9, 0xba, 0x1d, 0x2e, 0xba, 0x47, 0xe0, 0x29, - 0xdb, 0x4e, 0x09, 0x56, 0xf4, 0x04, 0xb8, 0xfb, 0xc9, 0x70, 0x27, 0x0b, 0x23, 0x88, 0x0c, 0xe9, - 0x4e, 0x86, 0x09, 0x1c, 0xa6, 0x3b, 0xd9, 0x20, 0x06, 0xc6, 0x70, 0xab, 0x7d, 0x8e, 0xee, 0xe6, - 0xe3, 0x76, 0x03, 0xff, 0x4e, 0x4a, 0x7d, 0x94, 0xfe, 0x7e, 0x26, 0x91, 0xff, 0x33, 0xe6, 0x2b, - 0x7e, 0x98, 0x4e, 0xe2, 0xd1, 0x1c, 0x47, 0x6e, 0x0c, 0xeb, 0x46, 0x12, 0xf6, 0x45, 0x3f, 0x67, - 0xb4, 0xdd, 0xad, 0x11, 0x9d, 0xe8, 0xb8, 0xe8, 0xd1, 0xf2, 0xaf, 0x47, 0xc6, 0x2f, 0xf0, 0x7f, - 0x66, 0x12, 0x85, 0x90, 0x0a, 0x44, 0x82, 0xd9, 0x8a, 0x10, 0x71, 0x82, 0xc0, 0x4f, 0xb1, 0xf4, - 0xc6, 0xa8, 0xd1, 0x67, 0x8d, 0x36, 0xb2, 0x1e, 0x86, 0x1a, 0x8d, 0xf9, 0x1a, 0x9d, 0x46, 0xc7, - 0x91, 0xfb, 0x09, 0xd5, 0xe8, 0x40, 0x24, 0x23, 0xd2, 0xe8, 0x58, 0x7a, 0xe9, 0xcb, 0xf8, 0x65, - 0xd3, 0x74, 0x22, 0xb5, 0x62, 0x98, 0x17, 0xe0, 0xbf, 0xe5, 0xfd, 0x8b, 0x99, 0xcf, 0x19, 0xee, - 0x16, 0x8d, 0x05, 0xf3, 0x3e, 0xe1, 0xbb, 0x51, 0x86, 0x88, 0xf7, 0xc2, 0x87, 0x93, 0xca, 0xed, - 0x0b, 0x27, 0x55, 0x02, 0x33, 0x86, 0xe9, 0x22, 0xdb, 0xd4, 0x3b, 0x8b, 0x1d, 0x7d, 0xd3, 0x39, - 0x35, 0xd1, 0xf7, 0xf2, 0xba, 0x0a, 0x93, 0x47, 0xe3, 0xff, 0x60, 0xaf, 0xaf, 0x2c, 0xf0, 0xd7, - 0x57, 0x46, 0x44, 0xbf, 0x9a, 0x8c, 0x8e, 0x7e, 0x15, 0x44, 0xb7, 0x02, 0x83, 0x83, 0x63, 0x8b, - 0xda, 0xc6, 0x09, 0xc3, 0xfd, 0xdd, 0x28, 0x18, 0x85, 0x2d, 0x08, 0xfd, 0xf8, 0x07, 0x72, 0xa2, - 0xd5, 0x3d, 0x4f, 0x11, 0xe6, 0x7a, 0x95, 0x20, 0xb1, 0x85, 0xca, 0x56, 0x5e, 0xee, 0xa9, 0x7c, - 0x60, 0xf2, 0x64, 0x05, 0x4c, 0x1e, 0x56, 0xa9, 0x72, 0x62, 0x4a, 0x95, 0x64, 0xb1, 0x50, 0xa4, - 0xb6, 0x63, 0x38, 0x8d, 0x94, 0x03, 0xc7, 0xfc, 0x68, 0xb7, 0xdd, 0x2e, 0xd2, 0x6d, 0xdd, 0x6c, - 0x21, 0xf8, 0x51, 0x69, 0x14, 0x66, 0xef, 0x22, 0x28, 0x18, 0x2d, 0xcb, 0xac, 0x1b, 0x4f, 0xf3, - 0x2f, 0x97, 0x8b, 0x0f, 0xb2, 0x8e, 0x25, 0x52, 0xa1, 0x7f, 0x68, 0xc1, 0xbf, 0x4a, 0x05, 0x4c, - 0xb6, 0x74, 0xbb, 0x4d, 0x82, 0xf0, 0xe5, 0x7a, 0x2e, 0x72, 0x8a, 0x24, 0x54, 0xf6, 0x7f, 0xd1, - 0xc2, 0xbf, 0x95, 0x1a, 0x2f, 0xc4, 0x7c, 0x4f, 0x34, 0x8f, 0x48, 0x62, 0x0b, 0xe1, 0x4f, 0x9c, - 0xcc, 0x3d, 0xe9, 0xd8, 0xa8, 0x83, 0xef, 0xa0, 0x27, 0x3d, 0xc4, 0xa4, 0x16, 0x26, 0x24, 0x5d, - 0x1e, 0xc0, 0x45, 0xed, 0x43, 0x63, 0xdc, 0xcb, 0x03, 0x42, 0x5c, 0xa4, 0xaf, 0x99, 0x6f, 0xcd, - 0x83, 0x19, 0xd2, 0xab, 0x51, 0x71, 0xc2, 0xe7, 0xe2, 0x2b, 0xa4, 0xdd, 0xbb, 0xd1, 0x1e, 0xac, - 0x1f, 0x7c, 0x4c, 0x2e, 0x02, 0xf9, 0x42, 0x10, 0x70, 0xd0, 0x7b, 0x4c, 0xba, 0x6f, 0xef, 0xf3, - 0x35, 0x47, 0x78, 0x1a, 0xf7, 0xbe, 0x7d, 0x7c, 0xf1, 0xe9, 0xe3, 0xf3, 0x5b, 0x32, 0x90, 0x4b, - 0xed, 0x36, 0x6c, 0x1d, 0x1c, 0x8a, 0xab, 0xc0, 0x94, 0xdf, 0x66, 0xc2, 0x18, 0x90, 0x6c, 0x52, - 0xd2, 0x45, 0xd0, 0x40, 0x36, 0xa5, 0xf6, 0xd8, 0x77, 0x15, 0x62, 0xca, 0x4e, 0x1f, 0x94, 0x2f, - 0x4e, 0xd0, 0x46, 0x33, 0x6f, 0x59, 0x17, 0xf0, 0x51, 0x99, 0x3f, 0x92, 0x41, 0x6e, 0x11, 0xb9, - 0xad, 0x2d, 0xe8, 0x8c, 0xa4, 0xcd, 0xec, 0xd8, 0x1d, 0xbf, 0xcd, 0xec, 0xd8, 0x9d, 0x41, 0x41, - 0x39, 0x93, 0x46, 0x7f, 0xf6, 0xd9, 0x9e, 0xc3, 0x2c, 0x8f, 0x3b, 0xfa, 0x73, 0x6c, 0xe9, 0x63, - 0x38, 0x04, 0x97, 0x05, 0xb3, 0xc1, 0x0a, 0x18, 0xc1, 0xec, 0xcd, 0x99, 0x87, 0xdd, 0x7a, 0xe8, - 0x00, 0xbb, 0x19, 0x7e, 0x3e, 0x59, 0x88, 0xb5, 0x40, 0xe6, 0x7c, 0xcd, 0x53, 0x5e, 0x98, 0x4c, - 0x10, 0x7c, 0x4d, 0x8c, 0xc1, 0x31, 0xac, 0x00, 0xc8, 0xa0, 0x80, 0x19, 0x5a, 0x30, 0x76, 0xb1, - 0xeb, 0x21, 0xb7, 0x50, 0xf9, 0xf4, 0x91, 0x2c, 0x54, 0xde, 0xc6, 0x2f, 0x54, 0x0a, 0x46, 0x4c, - 0xf6, 0xd7, 0x29, 0x13, 0xfa, 0xe2, 0x78, 0xff, 0x8f, 0x7c, 0x99, 0x32, 0x81, 0x2f, 0xce, 0x80, - 0xf2, 0xc7, 0xe0, 0x7a, 0xf8, 0x14, 0xda, 0x59, 0xfb, 0x1b, 0xb2, 0xf0, 0xbf, 0x1f, 0x03, 0xd9, - 0xb3, 0xde, 0xc3, 0xff, 0x08, 0x6f, 0xd4, 0x7a, 0xf1, 0x08, 0x82, 0x3b, 0x3c, 0x19, 0x64, 0x3d, - 0xfa, 0x74, 0xda, 0x73, 0xbd, 0xd8, 0xee, 0xb0, 0xc7, 0x88, 0x86, 0xff, 0x53, 0x4e, 0x82, 0xbc, - 0x63, 0xed, 0xd8, 0x2d, 0xcf, 0xfc, 0xf6, 0x34, 0x86, 0xbe, 0x25, 0x0d, 0x6a, 0xca, 0x91, 0x9e, - 0x1b, 0x9d, 0xcb, 0x29, 0x73, 0xc1, 0x92, 0xcc, 0x5d, 0xb0, 0x94, 0x60, 0xff, 0x41, 0x80, 0xb7, - 0xf4, 0x35, 0xe2, 0xef, 0xf0, 0x5d, 0x83, 0xed, 0x51, 0xc1, 0x1e, 0x21, 0x96, 0x83, 0xaa, 0x43, - 0x52, 0x87, 0x71, 0x5e, 0xb4, 0x41, 0x1c, 0xf9, 0xb1, 0x3a, 0x8c, 0x0b, 0xf0, 0x30, 0x96, 0x53, - 0xee, 0x79, 0xea, 0xe4, 0x7a, 0xcf, 0x28, 0xd1, 0xcd, 0x72, 0x4a, 0x7f, 0x20, 0x74, 0x46, 0xe8, - 0xfc, 0x3a, 0x34, 0x3a, 0x87, 0xe4, 0xfe, 0xfa, 0x67, 0x32, 0x8e, 0xa4, 0xe9, 0x1b, 0x41, 0xe2, - 0x17, 0x25, 0x25, 0x86, 0xc8, 0x1b, 0x83, 0xb9, 0x38, 0xd2, 0x33, 0xc3, 0x87, 0x16, 0xe7, 0x45, - 0xc7, 0xf0, 0x3f, 0xee, 0xd0, 0xe2, 0xa2, 0x8c, 0xa4, 0x0f, 0xe4, 0x1f, 0x92, 0x8b, 0xc9, 0x4a, - 0x2d, 0xd7, 0xd8, 0x1d, 0x71, 0x4b, 0xe3, 0x87, 0x97, 0x84, 0xd1, 0x84, 0xf7, 0x49, 0x88, 0x70, - 0x38, 0xee, 0x68, 0xc2, 0x62, 0x6c, 0xa4, 0x0f, 0xd3, 0x3f, 0xe6, 0x3d, 0xe9, 0xd1, 0xb5, 0x9d, - 0x57, 0xd3, 0xd5, 0x04, 0x74, 0x70, 0xb4, 0xce, 0x80, 0x69, 0x66, 0xe9, 0xc0, 0xbf, 0xf0, 0x86, - 0x4b, 0x4b, 0x7a, 0x50, 0x3e, 0x10, 0xd9, 0xc8, 0x17, 0x16, 0x12, 0x2c, 0x18, 0x8b, 0x30, 0x31, - 0x96, 0xfb, 0xe4, 0xfc, 0x31, 0x6c, 0x4c, 0x58, 0xbd, 0x8f, 0xc5, 0xaa, 0xc6, 0x63, 0x75, 0x8b, - 0x88, 0x98, 0xc4, 0xc6, 0x34, 0xa1, 0x79, 0xe3, 0x5b, 0x02, 0xb8, 0x34, 0x0e, 0xae, 0x27, 0x0f, - 0xcd, 0x47, 0xfa, 0x88, 0xbd, 0x84, 0x74, 0x87, 0x75, 0x62, 0xb2, 0x8f, 0xa6, 0x3b, 0xa4, 0xb3, - 0x01, 0x99, 0x9b, 0x0d, 0x24, 0xf4, 0xd7, 0x0f, 0xdd, 0x50, 0x7d, 0xe6, 0x06, 0x41, 0x94, 0x1d, - 0xb1, 0xbf, 0xfe, 0x40, 0x0e, 0xd2, 0x07, 0xe7, 0x3b, 0x32, 0x00, 0x4b, 0xb6, 0xb5, 0xd3, 0xad, - 0xd9, 0x6d, 0x64, 0xc3, 0x7f, 0x08, 0x27, 0x00, 0x2f, 0x1c, 0xc1, 0x04, 0x60, 0x0d, 0x80, 0xcd, - 0x80, 0x38, 0xd5, 0xf0, 0xc7, 0x8a, 0x99, 0xfb, 0x21, 0x53, 0x1a, 0x43, 0x83, 0xbf, 0xb2, 0xf6, - 0xe7, 0x78, 0x8c, 0xe3, 0xfa, 0xac, 0x90, 0xdc, 0x28, 0x27, 0x00, 0x6f, 0x0b, 0xb0, 0x6e, 0x70, - 0x58, 0xdf, 0x79, 0x00, 0x4e, 0xd2, 0xc7, 0xfc, 0x5f, 0x27, 0xc0, 0x14, 0xd9, 0xee, 0x23, 0x32, - 0xfd, 0xe7, 0x10, 0xf4, 0xdf, 0x1b, 0x01, 0xe8, 0xeb, 0x60, 0xda, 0x0a, 0xa9, 0x93, 0x3e, 0x95, - 0x5d, 0x80, 0x89, 0x85, 0x9d, 0xe1, 0x4b, 0xe3, 0xc8, 0xc0, 0x0f, 0xb3, 0xc8, 0x6b, 0x3c, 0xf2, - 0xb7, 0xc5, 0xc8, 0x9b, 0xa1, 0x38, 0x4a, 0xe8, 0xdf, 0x1e, 0x40, 0xbf, 0xce, 0x41, 0x5f, 0x3a, - 0x08, 0x2b, 0x63, 0x08, 0xd7, 0x2f, 0x83, 0x2c, 0x3e, 0x5d, 0xf7, 0xfa, 0x14, 0xe7, 0xf7, 0xa7, - 0xc0, 0x04, 0x6e, 0xb2, 0xc1, 0xbc, 0xc3, 0x7f, 0xf5, 0xbe, 0xe8, 0x1b, 0x2e, 0xb2, 0x83, 0x95, - 0x5b, 0xff, 0xd5, 0xe3, 0xc1, 0xf7, 0x6a, 0x76, 0x4e, 0xe5, 0xc9, 0x46, 0x66, 0x90, 0x30, 0xf4, - 0xa4, 0x84, 0x95, 0xf8, 0xc8, 0xce, 0xdb, 0x0d, 0x33, 0x29, 0x19, 0xc0, 0x48, 0xfa, 0xc0, 0x7f, - 0x29, 0x0b, 0x4e, 0x91, 0x55, 0xa5, 0x45, 0xdb, 0xda, 0xee, 0xb9, 0x1d, 0xcb, 0x38, 0xb8, 0x2e, - 0x5c, 0x0b, 0x66, 0x5d, 0xce, 0x9f, 0x9b, 0xea, 0x44, 0x4f, 0x2a, 0xfc, 0x2b, 0xd6, 0x27, 0xe3, - 0x29, 0x3c, 0x92, 0xf3, 0x31, 0x02, 0x8c, 0xe2, 0x3d, 0xf1, 0x42, 0xbd, 0x20, 0xa3, 0xcc, 0x22, - 0x95, 0x3c, 0xd4, 0x9a, 0x65, 0xa0, 0x53, 0x39, 0x11, 0x9d, 0x7a, 0x4f, 0xa0, 0x53, 0xbf, 0xc0, - 0xe9, 0xd4, 0xd2, 0xc1, 0x45, 0x32, 0x86, 0x95, 0x8b, 0x59, 0x90, 0x5f, 0x34, 0x3a, 0x2e, 0xb2, - 0xe1, 0x43, 0x74, 0x1e, 0xf5, 0x8a, 0x14, 0xbb, 0x97, 0x05, 0x90, 0xdf, 0xc0, 0xa5, 0x51, 0x83, - 0xec, 0x06, 0x31, 0x6c, 0x08, 0x87, 0x1a, 0xfd, 0x37, 0x69, 0xec, 0xb8, 0x1e, 0x32, 0x23, 0x9b, - 0x80, 0x25, 0x88, 0x1d, 0x37, 0x98, 0x85, 0xb1, 0x5c, 0x9b, 0x94, 0xd7, 0xd0, 0xb6, 0x37, 0x82, - 0x5c, 0x48, 0x0f, 0xe1, 0x22, 0x90, 0x8d, 0xb6, 0x83, 0x9b, 0xde, 0xa4, 0xe6, 0x3d, 0x26, 0xf5, - 0x64, 0xe9, 0x15, 0x15, 0x61, 0x79, 0xdc, 0x9e, 0x2c, 0x42, 0x5c, 0xa4, 0x8f, 0xd9, 0xf7, 0xb1, - 0x1b, 0x63, 0xb7, 0xa3, 0xb7, 0x90, 0xc7, 0x7d, 0x6a, 0xa8, 0xcd, 0x02, 0xc9, 0xf0, 0x47, 0x7c, - 0xc9, 0x60, 0xdb, 0x69, 0xee, 0x00, 0xed, 0x74, 0xd8, 0x45, 0xae, 0x40, 0xe6, 0xb8, 0xe2, 0x87, - 0xb6, 0xc8, 0x15, 0xcb, 0xc6, 0x18, 0x2e, 0xc5, 0xf4, 0x8f, 0x79, 0x8e, 0xb5, 0xb5, 0x0e, 0xbb, - 0x05, 0x40, 0x85, 0x35, 0xb2, 0x23, 0x9d, 0xc3, 0x6c, 0x01, 0x44, 0xf3, 0x30, 0x06, 0xb4, 0x66, - 0x29, 0x5a, 0x9f, 0xa3, 0xc3, 0x68, 0xca, 0xbb, 0x70, 0x8e, 0x65, 0xbb, 0xc9, 0x76, 0xe1, 0x3c, - 0xee, 0x34, 0xfc, 0x5f, 0xd2, 0x63, 0x41, 0xfc, 0xa9, 0xdf, 0x51, 0x0d, 0x9f, 0x09, 0x8e, 0x05, - 0x0d, 0x62, 0x20, 0x7d, 0x78, 0xdf, 0x70, 0x48, 0x83, 0xe7, 0xb0, 0xcd, 0x91, 0xb6, 0x81, 0x91, - 0x0d, 0x9d, 0xc3, 0x34, 0xc7, 0x68, 0x1e, 0xd2, 0xc7, 0xeb, 0xdb, 0xcc, 0xc0, 0xf9, 0xda, 0x31, - 0x0e, 0x9c, 0x7e, 0xcb, 0xcc, 0x0d, 0xd9, 0x32, 0x87, 0xdd, 0x5d, 0xa0, 0xb2, 0x1e, 0xdd, 0x80, - 0x39, 0xcc, 0xee, 0x42, 0x0c, 0x13, 0xe9, 0x23, 0xfe, 0x3a, 0x19, 0xe4, 0xea, 0xe3, 0x1f, 0x2f, - 0x87, 0x9d, 0x8b, 0x60, 0x59, 0xd5, 0x47, 0x36, 0x5c, 0x0e, 0x33, 0x17, 0x89, 0x64, 0x61, 0x0c, - 0x61, 0xe1, 0x8f, 0x82, 0x69, 0x3c, 0xe1, 0xf6, 0x37, 0xf1, 0xbe, 0x4d, 0x47, 0xcd, 0x07, 0x53, - 0x6c, 0xab, 0x77, 0x81, 0x82, 0xbf, 0x3b, 0x44, 0x47, 0xce, 0x39, 0xb1, 0xf6, 0xe9, 0x73, 0xa9, - 0x05, 0xff, 0x1f, 0x68, 0xab, 0x7d, 0xe4, 0x3b, 0x81, 0xc3, 0x6e, 0xb5, 0x1f, 0xea, 0x6e, 0xe0, - 0x5f, 0x86, 0x23, 0xea, 0x7f, 0x49, 0x0f, 0xf3, 0xde, 0x5d, 0xc2, 0x6c, 0x9f, 0x5d, 0xc2, 0x8f, - 0xb2, 0x58, 0xd6, 0x79, 0x2c, 0x6f, 0x17, 0x15, 0xe1, 0x08, 0xc7, 0xda, 0x77, 0x04, 0x70, 0x9e, - 0xe5, 0xe0, 0x9c, 0x3f, 0x10, 0x2f, 0x63, 0x38, 0x96, 0x97, 0x0d, 0xc7, 0xdc, 0x8f, 0xa5, 0xd8, - 0x8e, 0x7b, 0x7c, 0xfe, 0xb3, 0xfb, 0x7c, 0xfe, 0xb9, 0x96, 0x9e, 0x3b, 0x60, 0x4b, 0xff, 0x18, - 0xab, 0x1d, 0x0d, 0x5e, 0x3b, 0x9e, 0x2c, 0x8e, 0xc8, 0xe8, 0x46, 0xe6, 0x77, 0x06, 0xea, 0x71, - 0x8e, 0x53, 0x8f, 0xf2, 0xc1, 0x98, 0x49, 0x5f, 0x3f, 0x3e, 0xe1, 0x4f, 0x68, 0x0f, 0xb9, 0xbd, - 0x0f, 0xbb, 0x11, 0xc9, 0x09, 0x71, 0x64, 0x23, 0xf7, 0x30, 0x1b, 0x91, 0x83, 0x38, 0x19, 0x43, - 0xa4, 0xb0, 0x19, 0x30, 0x85, 0x79, 0x3a, 0x67, 0xb4, 0x37, 0x91, 0x0b, 0xff, 0x80, 0x78, 0xc0, - 0xf9, 0x71, 0x19, 0x47, 0x14, 0x3c, 0x27, 0xea, 0x34, 0x66, 0x52, 0x7f, 0x01, 0xc2, 0xe4, 0x1c, - 0xc3, 0xe0, 0xb8, 0xe3, 0xfb, 0x0d, 0xe4, 0x20, 0x7d, 0xc8, 0x3e, 0x4c, 0x9c, 0x39, 0x56, 0xf4, - 0x3d, 0x6b, 0xc7, 0x85, 0xf7, 0x8f, 0xa0, 0x83, 0x9e, 0x07, 0xf9, 0x0e, 0xa6, 0x46, 0x9d, 0xfe, - 0xe3, 0xa7, 0x3b, 0x54, 0x04, 0xa4, 0x7c, 0x8d, 0xfe, 0x99, 0xd4, 0xf3, 0x3f, 0x94, 0x23, 0xa1, - 0x33, 0x6e, 0xcf, 0xff, 0x01, 0xe5, 0x8f, 0xe5, 0x06, 0x98, 0x82, 0x57, 0xba, 0xb1, 0x6d, 0xb8, - 0x23, 0x8a, 0x2f, 0xd0, 0xf1, 0x68, 0xf9, 0xf1, 0x05, 0xf0, 0x4b, 0xd2, 0xf3, 0x8c, 0x8c, 0x54, - 0xbc, 0xdf, 0xc7, 0x7d, 0x9e, 0x31, 0xbe, 0xf8, 0xf4, 0x31, 0xf9, 0x1d, 0xd2, 0xb2, 0xce, 0x12, - 0xd7, 0xce, 0x14, 0xbd, 0x46, 0x87, 0x6e, 0x2c, 0x84, 0xb5, 0xc3, 0x6b, 0x2c, 0x7d, 0xcb, 0x4f, - 0x1f, 0x98, 0x3f, 0xfa, 0x69, 0x90, 0x5b, 0x40, 0xe7, 0x77, 0x36, 0xe1, 0x6d, 0xa0, 0xd0, 0xb0, - 0x11, 0xaa, 0x98, 0x1b, 0x96, 0x27, 0x5d, 0xd7, 0x7b, 0xf6, 0x21, 0xa1, 0x6f, 0x1e, 0x1e, 0x5b, - 0x48, 0x6f, 0x87, 0xa7, 0x9b, 0xfc, 0x57, 0xf8, 0x62, 0x09, 0x64, 0xeb, 0xae, 0xee, 0xc2, 0xc9, - 0x00, 0x5b, 0x78, 0x3f, 0x8b, 0xc5, 0x6d, 0x3c, 0x16, 0xd7, 0x72, 0xb2, 0xc0, 0x1c, 0xcc, 0x79, - 0xff, 0x47, 0x00, 0x00, 0x41, 0xe1, 0x5e, 0xc7, 0x32, 0xbd, 0x1c, 0xfe, 0x01, 0x3c, 0xff, 0x1d, - 0xbe, 0x3c, 0x10, 0xf7, 0x1d, 0x9c, 0xb8, 0x1f, 0x2d, 0x56, 0xc4, 0x18, 0x56, 0xda, 0x24, 0x30, - 0xe9, 0x89, 0x76, 0x19, 0xe9, 0x6d, 0x07, 0xfe, 0x54, 0xa8, 0xfc, 0x11, 0x62, 0x86, 0xef, 0x17, - 0x0e, 0x15, 0x49, 0x6a, 0x15, 0x10, 0x8f, 0xf6, 0x17, 0xf0, 0x43, 0x65, 0x48, 0x7c, 0xa8, 0x8c, - 0x1b, 0x41, 0xd6, 0x30, 0x37, 0x2c, 0xea, 0xbd, 0x76, 0x79, 0x04, 0x6d, 0x4f, 0x27, 0x34, 0x9c, - 0x51, 0x30, 0x8e, 0x64, 0x3c, 0x5b, 0x63, 0xb9, 0x92, 0x2d, 0xeb, 0x95, 0x0e, 0xff, 0xaf, 0x81, - 0xc2, 0x56, 0x14, 0x90, 0xed, 0xea, 0xee, 0x16, 0x2d, 0x1a, 0x3f, 0x7b, 0x36, 0xf2, 0x8e, 0xa9, - 0x9b, 0x96, 0xb9, 0xb7, 0x6d, 0x3c, 0x2d, 0xb8, 0xf9, 0x95, 0x4b, 0xf3, 0x38, 0xdf, 0x44, 0x26, - 0xb2, 0x75, 0x17, 0xd5, 0x77, 0x37, 0xf1, 0x1c, 0xab, 0xa0, 0xb1, 0x49, 0x89, 0xf5, 0xdf, 0xe3, - 0x38, 0x5a, 0xff, 0x37, 0x8c, 0x0e, 0xc2, 0x71, 0x84, 0xa8, 0xfe, 0xfb, 0xef, 0x89, 0xf4, 0xbf, - 0x4f, 0x11, 0xe9, 0xa3, 0xf1, 0x03, 0x09, 0x4c, 0xd7, 0x3d, 0x85, 0xab, 0xef, 0x6c, 0x6f, 0xeb, - 0xf6, 0x1e, 0xbc, 0x3a, 0x44, 0x85, 0x51, 0xcd, 0x0c, 0xa7, 0x9a, 0xf0, 0xcf, 0x84, 0x2f, 0x3d, - 0xa6, 0x4d, 0x9b, 0x29, 0x21, 0x71, 0x3b, 0xb8, 0x09, 0xe4, 0x3c, 0xf5, 0xf6, 0xfd, 0xf9, 0x62, - 0x1b, 0x02, 0xc9, 0x29, 0x18, 0x6f, 0x69, 0x20, 0x6f, 0x63, 0x88, 0xf5, 0x20, 0x81, 0xa3, 0x75, - 0x57, 0x6f, 0x5d, 0x58, 0xb2, 0x6c, 0x6b, 0xc7, 0x35, 0x4c, 0xe4, 0xc0, 0x47, 0x84, 0x08, 0xf8, - 0xfa, 0x9f, 0x09, 0xf5, 0x1f, 0xfe, 0x28, 0x23, 0x3a, 0x8a, 0x06, 0xdd, 0x2a, 0x4b, 0x3e, 0x22, - 0x7c, 0x92, 0xd8, 0xb8, 0x28, 0x42, 0x31, 0x7d, 0xa1, 0xbd, 0x56, 0x06, 0x45, 0xf5, 0xbe, 0xae, - 0x65, 0xbb, 0x2b, 0x56, 0x4b, 0xef, 0x38, 0xae, 0x65, 0x23, 0x58, 0x8b, 0x95, 0x9a, 0xd7, 0xc3, - 0xb4, 0xad, 0x56, 0x38, 0x38, 0xd2, 0x37, 0x56, 0xed, 0x64, 0x5e, 0xc7, 0x3f, 0x2c, 0xbc, 0xcb, - 0x48, 0xa4, 0xd2, 0xcb, 0x51, 0x84, 0x9e, 0xf7, 0xeb, 0xd2, 0x92, 0xb9, 0xe2, 0x8b, 0xed, 0x3c, - 0x0a, 0x31, 0x35, 0x86, 0xa5, 0x72, 0x09, 0xcc, 0xd4, 0x77, 0xce, 0x07, 0x44, 0x1c, 0xd6, 0x08, - 0x79, 0xa5, 0x70, 0x8c, 0x04, 0xaa, 0x78, 0x2c, 0xa1, 0x08, 0xf9, 0x5e, 0x03, 0x66, 0x1c, 0x36, - 0x1b, 0xc5, 0x9b, 0x4f, 0x14, 0x8c, 0x8d, 0x30, 0xb8, 0xd4, 0xf4, 0x05, 0xf8, 0x4e, 0x09, 0xcc, - 0xd4, 0xba, 0xc8, 0x44, 0x6d, 0xe2, 0x63, 0xc7, 0x09, 0xf0, 0xc5, 0x09, 0x05, 0xc8, 0x11, 0x8a, - 0x10, 0x60, 0xe8, 0x0f, 0xbb, 0xe0, 0x0b, 0x2f, 0x4c, 0x48, 0x24, 0xb8, 0xb8, 0xd2, 0xd2, 0x17, - 0xdc, 0x97, 0x25, 0x30, 0xa5, 0xed, 0x98, 0x6b, 0xb6, 0xe5, 0x8d, 0xc6, 0x36, 0xbc, 0x3d, 0xec, - 0x20, 0x6e, 0x00, 0xc7, 0xda, 0x3b, 0x36, 0x5e, 0x7f, 0xaa, 0x98, 0x75, 0xd4, 0xb2, 0xcc, 0xb6, - 0x83, 0xeb, 0x91, 0xd3, 0xf6, 0x7f, 0xb8, 0x35, 0xfb, 0xec, 0x6f, 0xc8, 0x19, 0xf8, 0x5c, 0xe1, - 0x40, 0x2c, 0xa4, 0xf2, 0x4c, 0xd1, 0xe2, 0x3d, 0x81, 0x60, 0xb8, 0x95, 0x41, 0x25, 0xa4, 0x2f, - 0xdc, 0xcf, 0x49, 0x40, 0x29, 0xb5, 0x5a, 0xd6, 0x8e, 0xe9, 0xd6, 0x51, 0x07, 0xb5, 0xdc, 0x86, - 0xad, 0xb7, 0x10, 0x6b, 0x3f, 0x17, 0x81, 0xdc, 0x36, 0x6c, 0xda, 0x07, 0x7b, 0x8f, 0x54, 0x8e, - 0x2f, 0x16, 0xde, 0x71, 0x24, 0xb5, 0xdc, 0x5f, 0x4a, 0x02, 0x71, 0x8a, 0xed, 0x2b, 0x0a, 0x16, - 0x94, 0xbe, 0x54, 0x3f, 0x26, 0x81, 0x49, 0xbf, 0xc7, 0xde, 0x14, 0x11, 0xe6, 0xef, 0x24, 0x9c, - 0x8c, 0x04, 0xc4, 0x13, 0xc8, 0xf0, 0xad, 0x09, 0x66, 0x15, 0x51, 0xf4, 0x93, 0x89, 0xae, 0x94, - 0x5c, 0x74, 0xde, 0x6b, 0xb5, 0xd6, 0x5c, 0xac, 0xad, 0x2c, 0xa8, 0x5a, 0x51, 0x86, 0x0f, 0x49, - 0x20, 0xbb, 0x66, 0x98, 0x9b, 0x6c, 0xbc, 0xac, 0xe3, 0x9e, 0x1d, 0xd9, 0x46, 0xf7, 0xd1, 0x96, - 0x4e, 0x5e, 0x94, 0x9b, 0xc1, 0x71, 0x73, 0x67, 0xfb, 0x3c, 0xb2, 0x6b, 0x1b, 0x78, 0x94, 0x75, - 0x1a, 0x56, 0x1d, 0x99, 0xc4, 0x08, 0xcd, 0x69, 0x7d, 0xbf, 0xf1, 0x26, 0x98, 0xc0, 0xe4, 0xc1, - 0xe3, 0x24, 0x42, 0xe2, 0x01, 0x53, 0x12, 0xc3, 0x54, 0xa2, 0x69, 0x43, 0x1f, 0xe2, 0xe9, 0x6b, - 0xea, 0x9f, 0xe7, 0xc0, 0x89, 0x92, 0xb9, 0x87, 0x6d, 0x0a, 0xd2, 0xc1, 0x97, 0xb7, 0x74, 0x73, - 0x13, 0xe1, 0x01, 0x22, 0x90, 0x38, 0x1b, 0x40, 0x3e, 0xc3, 0x07, 0x90, 0x57, 0x34, 0x30, 0x61, - 0xd9, 0x6d, 0x64, 0xcf, 0xef, 0x61, 0x9e, 0x7a, 0x97, 0x9d, 0x69, 0x9b, 0xec, 0x57, 0xc4, 0x1c, - 0x25, 0x3f, 0x57, 0x23, 0xff, 0x6b, 0x3e, 0xa1, 0x33, 0x37, 0x80, 0x09, 0x9a, 0xa6, 0x4c, 0x83, - 0x42, 0x4d, 0x5b, 0x50, 0xb5, 0x66, 0x65, 0xa1, 0x78, 0x44, 0xb9, 0x04, 0x1c, 0xad, 0x34, 0x54, - 0xad, 0xd4, 0xa8, 0xd4, 0xaa, 0x4d, 0x9c, 0x5e, 0xcc, 0xc0, 0x67, 0x65, 0x45, 0x3d, 0x7b, 0xe3, - 0x99, 0xe9, 0x07, 0xab, 0x06, 0x26, 0x5a, 0x24, 0x03, 0x1e, 0x42, 0xa7, 0x12, 0xd5, 0x8e, 0x12, - 0x24, 0x09, 0x9a, 0x4f, 0x48, 0x39, 0x0d, 0xc0, 0x45, 0xdb, 0x32, 0x37, 0xc3, 0x33, 0x6d, 0x05, - 0x8d, 0x49, 0x81, 0xf7, 0x67, 0x40, 0x9e, 0xfc, 0x83, 0x2f, 0xcc, 0xc0, 0x4f, 0xa1, 0xe0, 0xfd, - 0x77, 0xcf, 0xe2, 0xc5, 0xf2, 0x0a, 0x27, 0x5a, 0xf4, 0xd5, 0xd3, 0x45, 0x22, 0x03, 0x62, 0x09, - 0xd3, 0xaa, 0xdc, 0x08, 0xf2, 0xe4, 0x5f, 0xea, 0x75, 0x10, 0x1d, 0xfc, 0x92, 0x64, 0x13, 0xf4, - 0x53, 0x16, 0x97, 0x69, 0xfa, 0xda, 0xfc, 0x01, 0x09, 0x14, 0xaa, 0xc8, 0x2d, 0x6f, 0xa1, 0xd6, - 0x05, 0xf8, 0x28, 0x7e, 0x01, 0xb4, 0x63, 0x20, 0xd3, 0xbd, 0x67, 0xbb, 0x13, 0x2c, 0x80, 0xfa, - 0x09, 0xf0, 0x39, 0x6c, 0xe7, 0x7b, 0x27, 0xaf, 0x3f, 0xd7, 0xf7, 0xa9, 0xab, 0x5f, 0x42, 0x84, - 0xca, 0x9c, 0x04, 0x79, 0x1b, 0x39, 0x3b, 0x1d, 0x7f, 0x11, 0x8d, 0xbe, 0xc1, 0x07, 0x02, 0x71, - 0x96, 0x39, 0x71, 0xde, 0x28, 0x5e, 0xc4, 0x18, 0xa2, 0x69, 0x66, 0xc1, 0x44, 0xc5, 0x34, 0x5c, - 0x43, 0xef, 0xc0, 0xe7, 0x66, 0xc1, 0x4c, 0x1d, 0xb9, 0x6b, 0xba, 0xad, 0x6f, 0x23, 0x17, 0xd9, - 0x0e, 0xfc, 0x1e, 0xdf, 0x27, 0x74, 0x3b, 0xba, 0xbb, 0x61, 0xd9, 0xdb, 0xbe, 0x6a, 0xfa, 0xef, - 0x9e, 0x6a, 0xee, 0x22, 0xdb, 0x09, 0xf9, 0xf2, 0x5f, 0xbd, 0x2f, 0x17, 0x2d, 0xfb, 0x82, 0x37, - 0x08, 0xd2, 0x69, 0x1a, 0x7d, 0xf5, 0xe8, 0x75, 0xac, 0xcd, 0x15, 0xb4, 0x8b, 0xfc, 0x60, 0x5d, - 0xc1, 0xbb, 0x37, 0x17, 0x68, 0x5b, 0x55, 0xcb, 0xf5, 0x3a, 0xed, 0x15, 0x6b, 0x93, 0x44, 0x33, - 0x2d, 0x68, 0x7c, 0x62, 0x98, 0x4b, 0xdf, 0x45, 0x38, 0x57, 0x9e, 0xcd, 0x45, 0x13, 0x95, 0x39, - 0xa0, 0x04, 0xbf, 0x35, 0x50, 0x07, 0x6d, 0x23, 0xd7, 0xde, 0xc3, 0x97, 0x16, 0x14, 0xb4, 0x3e, - 0x5f, 0xe8, 0x00, 0x2d, 0x3e, 0x59, 0xa7, 0xd2, 0x9b, 0xe3, 0x24, 0x77, 0xa0, 0xc9, 0xba, 0x08, - 0xc5, 0xb1, 0x5c, 0xca, 0x24, 0x7b, 0xd6, 0xcc, 0x4b, 0x65, 0x90, 0xc5, 0x83, 0xe7, 0xeb, 0x32, - 0xdc, 0x0a, 0xd3, 0x36, 0x72, 0x1c, 0x7d, 0x13, 0xf9, 0x2b, 0x4c, 0xf4, 0x55, 0xb9, 0x05, 0xe4, - 0x3a, 0x18, 0x53, 0x32, 0x38, 0x5c, 0xcd, 0xd5, 0xcc, 0x33, 0x30, 0x3c, 0x5a, 0xc1, 0x48, 0x80, - 0xe1, 0xd6, 0xc8, 0x1f, 0x67, 0xee, 0x02, 0x39, 0x02, 0xff, 0x24, 0xc8, 0x2d, 0xa8, 0xf3, 0xeb, - 0x4b, 0xc5, 0x23, 0xde, 0xa3, 0xcf, 0xdf, 0x24, 0xc8, 0x2d, 0x96, 0x1a, 0xa5, 0x95, 0xa2, 0xe4, - 0xd5, 0xa3, 0x52, 0x5d, 0xac, 0x15, 0x65, 0x2f, 0x71, 0xad, 0x54, 0xad, 0x94, 0x8b, 0x59, 0x65, - 0x0a, 0x4c, 0x9c, 0x2b, 0x69, 0xd5, 0x4a, 0x75, 0xa9, 0x98, 0x83, 0xff, 0xc8, 0xe2, 0x77, 0x2b, - 0x8f, 0xdf, 0x35, 0x51, 0x3c, 0xf5, 0x83, 0xec, 0xf7, 0x03, 0xc8, 0x6e, 0xe7, 0x20, 0xfb, 0x69, - 0x11, 0x22, 0x63, 0x70, 0x67, 0xca, 0x83, 0x89, 0x35, 0xdb, 0x6a, 0x21, 0xc7, 0x81, 0xbf, 0x2b, - 0x81, 0x7c, 0x59, 0x37, 0x5b, 0xa8, 0x03, 0x2f, 0x0b, 0xa1, 0x22, 0xae, 0xa2, 0x19, 0xdf, 0x55, - 0x14, 0x7e, 0x27, 0x23, 0xda, 0xfb, 0x51, 0xba, 0x73, 0x84, 0x66, 0x84, 0x7c, 0xc4, 0x7a, 0xb9, - 0x58, 0x52, 0x63, 0xb8, 0xb8, 0x45, 0x02, 0x93, 0x74, 0x35, 0xe0, 0x3c, 0x62, 0xe7, 0xe1, 0xdf, - 0xcb, 0x88, 0x4e, 0x0e, 0xfd, 0x1a, 0x04, 0x64, 0x22, 0xe4, 0x21, 0x36, 0x11, 0x1c, 0x44, 0x6d, - 0x0c, 0x9b, 0x87, 0x12, 0x98, 0x5a, 0x37, 0x9d, 0x7e, 0x42, 0x11, 0x8f, 0xf2, 0xee, 0x57, 0x83, - 0x21, 0x74, 0xa0, 0x28, 0xef, 0x83, 0xe9, 0xa5, 0x2f, 0x98, 0xef, 0x65, 0xc0, 0xf1, 0x25, 0x64, - 0x22, 0xdb, 0x68, 0x91, 0x1a, 0xf8, 0x92, 0xb8, 0x9d, 0x97, 0xc4, 0xa3, 0x38, 0xce, 0xfb, 0xfd, - 0xc1, 0x4b, 0xe0, 0x15, 0x81, 0x04, 0xee, 0xe4, 0x24, 0x70, 0x83, 0x20, 0x9d, 0x31, 0xdc, 0xd6, - 0x3d, 0x09, 0xa6, 0xab, 0x96, 0x6b, 0x6c, 0x18, 0x2d, 0xe2, 0x83, 0xf6, 0x12, 0x19, 0x64, 0x57, - 0x0c, 0xc7, 0x85, 0xa5, 0xb0, 0x3b, 0xb9, 0x0a, 0x4c, 0x19, 0x66, 0xab, 0xb3, 0xd3, 0x46, 0x1a, - 0xd2, 0x49, 0xbf, 0x52, 0xd0, 0xd8, 0xa4, 0x70, 0x6b, 0xdf, 0x63, 0x4b, 0xf6, 0xb7, 0xf6, 0x3f, - 0x2d, 0xbc, 0x0c, 0xc3, 0xb2, 0x80, 0xc3, 0x1d, 0x46, 0xd8, 0x5d, 0x25, 0x30, 0x63, 0x32, 0x59, - 0x7d, 0x83, 0xbd, 0x37, 0xdc, 0x3d, 0x4b, 0x4e, 0xe3, 0xff, 0x80, 0xef, 0x16, 0x6a, 0xac, 0x83, - 0x18, 0x4a, 0x86, 0xcc, 0xe2, 0x10, 0x93, 0x64, 0x05, 0xcc, 0x56, 0xaa, 0x0d, 0x55, 0xab, 0x96, - 0x56, 0x68, 0x16, 0x19, 0xfe, 0x40, 0x02, 0x39, 0x0d, 0x75, 0x3b, 0x7b, 0x6c, 0x3c, 0x63, 0xea, - 0x28, 0x9e, 0x09, 0x1c, 0xc5, 0x95, 0x45, 0x00, 0xf4, 0x96, 0x57, 0x30, 0xbe, 0xf0, 0x49, 0xea, - 0x1b, 0x25, 0x93, 0xab, 0x60, 0x29, 0xc8, 0xad, 0x31, 0x7f, 0xc2, 0xe7, 0x09, 0xef, 0x1c, 0x71, - 0xd4, 0x30, 0x87, 0x11, 0x7d, 0xc2, 0x7b, 0x84, 0x36, 0x7b, 0x06, 0x92, 0x3b, 0x1c, 0xf1, 0x7f, - 0x45, 0x02, 0xd9, 0x86, 0xd7, 0x5b, 0x32, 0x1d, 0xe7, 0xa7, 0x86, 0xd3, 0x71, 0x8f, 0x4c, 0x84, - 0x8e, 0xdf, 0x01, 0xa6, 0x59, 0x8d, 0xa5, 0xae, 0x12, 0xb1, 0x2a, 0xce, 0xfd, 0x30, 0x8c, 0x86, - 0xf7, 0x61, 0xe7, 0x70, 0x44, 0xfc, 0xf1, 0x47, 0x03, 0xb0, 0x8a, 0xb6, 0xcf, 0x23, 0xdb, 0xd9, - 0x32, 0xba, 0xf0, 0x9f, 0x64, 0x30, 0xb9, 0x84, 0xdc, 0xba, 0xab, 0xbb, 0x3b, 0x4e, 0xcf, 0x76, - 0xa7, 0x69, 0x95, 0xf5, 0xd6, 0x16, 0xa2, 0xdd, 0x91, 0xff, 0x0a, 0xdf, 0x2e, 0x8b, 0xfa, 0x13, - 0x85, 0xe5, 0xcc, 0x05, 0x65, 0x44, 0x60, 0xf2, 0x18, 0x90, 0x6d, 0xeb, 0xae, 0x4e, 0xb1, 0xb8, - 0xac, 0x07, 0x8b, 0x90, 0x90, 0x86, 0xb3, 0xc1, 0x37, 0x4b, 0x22, 0x0e, 0x45, 0x02, 0xe5, 0x27, - 0x03, 0xe1, 0xdd, 0x99, 0x21, 0x50, 0x38, 0x06, 0x66, 0xaa, 0xb5, 0x46, 0x73, 0xa5, 0xb6, 0xb4, - 0xa4, 0x7a, 0xa9, 0x45, 0x59, 0x39, 0x09, 0x94, 0xb5, 0xd2, 0x3d, 0xab, 0x6a, 0xb5, 0xd1, 0xac, - 0xd6, 0x16, 0x54, 0xfa, 0x67, 0x56, 0x39, 0x0a, 0xa6, 0xca, 0xa5, 0xf2, 0xb2, 0x9f, 0x90, 0x53, - 0x4e, 0x81, 0xe3, 0xab, 0xea, 0xea, 0xbc, 0xaa, 0xd5, 0x97, 0x2b, 0x6b, 0x4d, 0x8f, 0xcc, 0x62, - 0x6d, 0xbd, 0xba, 0x50, 0xcc, 0x2b, 0x10, 0x9c, 0x64, 0xbe, 0x9c, 0xd3, 0x6a, 0xd5, 0xa5, 0x66, - 0xbd, 0x51, 0x6a, 0xa8, 0xc5, 0x09, 0xe5, 0x12, 0x70, 0xb4, 0x5c, 0xaa, 0xe2, 0xec, 0xe5, 0x5a, - 0xb5, 0xaa, 0x96, 0x1b, 0xc5, 0x02, 0xfc, 0x51, 0x16, 0x4c, 0x55, 0x9c, 0xaa, 0xbe, 0x8d, 0xce, - 0xea, 0x1d, 0xa3, 0x0d, 0x9f, 0xcb, 0xcc, 0x3c, 0xae, 0x01, 0x33, 0x36, 0x79, 0x44, 0xed, 0x86, - 0x81, 0x08, 0x9a, 0x33, 0x1a, 0x9f, 0xe8, 0xcd, 0xc9, 0x4d, 0x4c, 0xc0, 0x9f, 0x93, 0x93, 0x37, - 0x65, 0x1e, 0x00, 0xf2, 0xd4, 0x08, 0xaf, 0x1e, 0x3d, 0xd3, 0xdb, 0x9a, 0xf4, 0x6d, 0xe4, 0x20, - 0x7b, 0xd7, 0x68, 0x21, 0x3f, 0xa7, 0xc6, 0xfc, 0x05, 0xbf, 0x2a, 0x8b, 0xee, 0x2f, 0x32, 0xa0, - 0x32, 0xd5, 0x89, 0xe8, 0x0d, 0x7f, 0x4d, 0x16, 0xd9, 0x1d, 0x14, 0x22, 0x99, 0x4c, 0x53, 0x5e, - 0x20, 0x0d, 0xb7, 0x6c, 0xdb, 0xa8, 0xd5, 0x9a, 0xf5, 0xe5, 0x9a, 0xd6, 0x28, 0xca, 0xca, 0x34, - 0x28, 0x78, 0xaf, 0x2b, 0xb5, 0xea, 0x52, 0x31, 0xab, 0x9c, 0x00, 0xc7, 0x96, 0x4b, 0xf5, 0x66, - 0xa5, 0x7a, 0xb6, 0xb4, 0x52, 0x59, 0x68, 0x96, 0x97, 0x4b, 0x5a, 0xbd, 0x98, 0x53, 0x2e, 0x03, - 0x27, 0x1a, 0x15, 0x55, 0x6b, 0x2e, 0xaa, 0xa5, 0xc6, 0xba, 0xa6, 0xd6, 0x9b, 0xd5, 0x5a, 0xb3, - 0x5a, 0x5a, 0x55, 0x8b, 0x79, 0xaf, 0xf9, 0xe3, 0x4f, 0xa1, 0xda, 0x4c, 0xec, 0x57, 0xc6, 0x42, - 0x84, 0x32, 0x4e, 0xf6, 0x2a, 0x23, 0x60, 0xd5, 0x4a, 0x53, 0xeb, 0xaa, 0x76, 0x56, 0x2d, 0x4e, - 0xf5, 0xd3, 0xb5, 0x69, 0xe5, 0x38, 0x28, 0x7a, 0x3c, 0x34, 0x2b, 0x75, 0x3f, 0xe7, 0x42, 0x71, - 0x06, 0x7e, 0x2c, 0x0f, 0x4e, 0x6a, 0x68, 0xd3, 0x70, 0x5c, 0x64, 0xaf, 0xe9, 0x7b, 0xdb, 0xc8, - 0x74, 0xfd, 0x4e, 0xfe, 0xdf, 0x13, 0x2b, 0xe3, 0x2a, 0x98, 0xe9, 0x12, 0x1a, 0xab, 0xc8, 0xdd, - 0xb2, 0xda, 0x74, 0x14, 0x7e, 0x54, 0x64, 0xcf, 0x31, 0xb7, 0xc6, 0x66, 0xd7, 0xf8, 0xbf, 0x19, - 0xdd, 0x96, 0x63, 0x74, 0x3b, 0x3b, 0x8c, 0x6e, 0x2b, 0x57, 0x80, 0xc9, 0x1d, 0x07, 0xd9, 0xea, - 0xb6, 0x6e, 0x74, 0xfc, 0xab, 0x23, 0x83, 0x04, 0xf8, 0x96, 0xac, 0xe8, 0x89, 0x15, 0xa6, 0x2e, - 0xfd, 0xc5, 0x18, 0xd1, 0xb7, 0x9e, 0x06, 0x80, 0x56, 0x76, 0xdd, 0xee, 0x50, 0x65, 0x65, 0x52, - 0x3c, 0xfe, 0xce, 0x1b, 0x9d, 0x8e, 0x61, 0x6e, 0x06, 0xfb, 0xfe, 0x61, 0x02, 0x7c, 0x81, 0x2c, - 0x72, 0x82, 0x25, 0x29, 0x6f, 0xc9, 0x5a, 0xd3, 0xf3, 0xa4, 0x31, 0xf7, 0xbb, 0xfb, 0x9b, 0x4e, - 0x5e, 0x29, 0x82, 0x69, 0x9c, 0x46, 0x5b, 0x60, 0x71, 0xc2, 0xeb, 0x83, 0x7d, 0x72, 0xab, 0x6a, - 0x63, 0xb9, 0xb6, 0x10, 0x7c, 0x2b, 0x78, 0x24, 0x3d, 0x66, 0x4a, 0xd5, 0x7b, 0x70, 0x6b, 0x9c, - 0x54, 0x1e, 0x01, 0x2e, 0x63, 0x3a, 0xec, 0xd2, 0x8a, 0xa6, 0x96, 0x16, 0xee, 0x69, 0xaa, 0x4f, - 0xa9, 0xd4, 0x1b, 0x75, 0xbe, 0x71, 0xf9, 0xed, 0x68, 0xca, 0xe3, 0x57, 0x5d, 0x2d, 0x55, 0x56, - 0x68, 0xff, 0xbe, 0x58, 0xd3, 0x56, 0x4b, 0x8d, 0xe2, 0x34, 0x7c, 0xa9, 0x0c, 0x8a, 0x4b, 0xc8, - 0x5d, 0xb3, 0x6c, 0x57, 0xef, 0xac, 0x18, 0xe6, 0x85, 0x75, 0xbb, 0xc3, 0x4d, 0x36, 0x85, 0xc3, - 0x74, 0xf0, 0x43, 0x24, 0x47, 0x30, 0x7a, 0x47, 0xbc, 0x8b, 0xb3, 0x85, 0xca, 0x14, 0x26, 0xc0, - 0xa7, 0x4b, 0x22, 0xcb, 0xdd, 0xe2, 0xa5, 0x26, 0xd3, 0x93, 0x67, 0x8c, 0x7b, 0x7c, 0xee, 0x83, - 0x5a, 0x1e, 0x3e, 0x3b, 0x0b, 0x0a, 0x8b, 0x86, 0xa9, 0x77, 0x8c, 0xa7, 0x71, 0xd1, 0x31, 0xc3, - 0x3e, 0x26, 0x13, 0xd3, 0xc7, 0x48, 0x43, 0x8d, 0x9f, 0xbf, 0x2d, 0x8b, 0x2e, 0x2f, 0x30, 0xb2, - 0xf7, 0x99, 0x8c, 0x18, 0x3c, 0x3f, 0x28, 0x89, 0x2c, 0x2f, 0x0c, 0xa6, 0x97, 0x0c, 0xc3, 0x4f, - 0xfe, 0x78, 0xd8, 0x58, 0x3d, 0xed, 0xbb, 0xd0, 0x4f, 0x15, 0x26, 0xe1, 0x5f, 0xcb, 0x00, 0x2e, - 0x21, 0xf7, 0x2c, 0xb2, 0x83, 0xa9, 0x00, 0xee, 0xf5, 0xa9, 0xbd, 0xcd, 0x34, 0xd9, 0xd7, 0xb1, - 0x00, 0x9e, 0xe3, 0x01, 0x2c, 0xc5, 0x34, 0x9e, 0x08, 0xd2, 0x11, 0x8d, 0xb7, 0x02, 0xf2, 0x0e, - 0xfe, 0x4e, 0xd5, 0xec, 0xa6, 0xe8, 0xe1, 0x12, 0x13, 0x63, 0xa9, 0x13, 0xc2, 0x1a, 0x25, 0x00, - 0xbf, 0x1f, 0x4c, 0x82, 0x7e, 0x9e, 0xd3, 0x8e, 0xc5, 0x03, 0x33, 0x9b, 0x4c, 0x5f, 0xec, 0x74, - 0xd5, 0xa5, 0x9f, 0x7d, 0x03, 0x3f, 0x98, 0x03, 0xc7, 0xfb, 0x55, 0x07, 0xbe, 0x37, 0xc3, 0xed, - 0xb0, 0x23, 0x3c, 0xe4, 0x67, 0xe8, 0x06, 0xa2, 0xf7, 0xa2, 0x3c, 0x1e, 0x9c, 0x08, 0x96, 0xe1, - 0x1a, 0x56, 0x15, 0x5d, 0x74, 0x3a, 0xc8, 0x75, 0x91, 0x8d, 0xab, 0x56, 0xd0, 0xfa, 0x7f, 0x54, - 0x9e, 0x08, 0x2e, 0x35, 0x4c, 0xc7, 0x68, 0x23, 0xbb, 0x61, 0x74, 0x9d, 0x92, 0xd9, 0x6e, 0xec, - 0xb8, 0x96, 0x6d, 0xe8, 0xf4, 0xa2, 0xc3, 0x82, 0x16, 0xf5, 0x59, 0xb9, 0x1e, 0x14, 0x0d, 0xa7, - 0x66, 0x9e, 0xb7, 0x74, 0xbb, 0x6d, 0x98, 0x9b, 0x2b, 0x86, 0xe3, 0x52, 0x0f, 0xe0, 0x7d, 0xe9, - 0xf0, 0x9f, 0x65, 0xd1, 0xc3, 0x74, 0x03, 0x60, 0x8d, 0xe8, 0x50, 0x9e, 0x23, 0x8b, 0x1c, 0x8f, - 0x4b, 0x46, 0x3b, 0x99, 0xb2, 0x3c, 0x6b, 0xdc, 0x86, 0x44, 0xff, 0x11, 0x1c, 0x77, 0x2d, 0x24, - 0xdd, 0x37, 0x04, 0xce, 0xaa, 0x5a, 0x65, 0xb1, 0xa2, 0x7a, 0x66, 0xc5, 0x09, 0x70, 0x2c, 0xfc, - 0xb6, 0x70, 0x4f, 0xb3, 0xae, 0x56, 0x1b, 0xc5, 0x82, 0xd7, 0x4f, 0x91, 0xe4, 0xc5, 0x52, 0x65, - 0x45, 0x5d, 0x68, 0x36, 0x6a, 0xde, 0x97, 0x85, 0xe1, 0x4c, 0x0b, 0x78, 0x7f, 0x16, 0x1c, 0xc5, - 0xb2, 0xdd, 0xc3, 0x52, 0xf5, 0x84, 0xd2, 0xe3, 0x6b, 0x1b, 0x00, 0x34, 0x49, 0xc4, 0x0b, 0x3f, - 0x2b, 0x7c, 0x8f, 0x23, 0x03, 0x61, 0x4f, 0x19, 0x11, 0x9a, 0xf1, 0x3d, 0x49, 0x24, 0x42, 0x85, - 0x30, 0xd9, 0x64, 0x4a, 0xf1, 0x1f, 0xe3, 0x1e, 0x71, 0xa2, 0xc1, 0xc7, 0x56, 0x66, 0x19, 0xff, - 0xfc, 0x94, 0xb5, 0x8a, 0x86, 0xd5, 0x61, 0x16, 0x00, 0x9c, 0x82, 0x35, 0x88, 0xe8, 0x41, 0xdf, - 0xf1, 0x2a, 0x4a, 0x0f, 0x4a, 0xe5, 0x46, 0xe5, 0xac, 0x1a, 0xa5, 0x07, 0x9f, 0x91, 0x41, 0x61, - 0x09, 0xb9, 0xde, 0x9c, 0xca, 0x81, 0x4f, 0x12, 0x58, 0xff, 0xf1, 0xcc, 0x18, 0x7c, 0xf1, 0x7d, - 0xb0, 0x0c, 0x40, 0xde, 0xe0, 0x33, 0x87, 0x31, 0x41, 0xfc, 0xa2, 0x23, 0xc6, 0xab, 0x9f, 0x05, - 0x39, 0xd7, 0xfb, 0x4c, 0x97, 0xa1, 0x7f, 0x2a, 0x72, 0xb8, 0xf2, 0x88, 0x2c, 0xe8, 0xae, 0xae, - 0x91, 0xfc, 0xcc, 0xe8, 0x24, 0x68, 0xbb, 0x44, 0x30, 0xf2, 0xe3, 0x68, 0x7f, 0xfe, 0xa3, 0x0c, - 0x4e, 0x90, 0xf6, 0x51, 0xea, 0x76, 0xeb, 0xae, 0x65, 0x23, 0x0d, 0xb5, 0x90, 0xd1, 0x75, 0x7b, - 0xd6, 0xf7, 0x6c, 0x92, 0xea, 0x6f, 0x36, 0xd3, 0x57, 0xf8, 0x6a, 0x59, 0x34, 0xc2, 0xef, 0xbe, - 0xf6, 0xd8, 0x53, 0x5e, 0x44, 0x63, 0xff, 0xa8, 0x24, 0x12, 0xb3, 0x37, 0x21, 0xf1, 0x64, 0x40, - 0x7d, 0xe8, 0x10, 0x80, 0xf2, 0x57, 0x6e, 0x34, 0xb5, 0xac, 0x56, 0xd6, 0xbc, 0x41, 0xe0, 0x4a, - 0x70, 0xf9, 0xda, 0xba, 0x56, 0x5e, 0x2e, 0xd5, 0xd5, 0xa6, 0xa6, 0x2e, 0x55, 0xea, 0x0d, 0xea, - 0x94, 0x45, 0xfe, 0x9a, 0x50, 0xae, 0x00, 0xa7, 0xea, 0xeb, 0xf3, 0xf5, 0xb2, 0x56, 0x59, 0xc3, - 0xe9, 0x9a, 0x5a, 0x55, 0xcf, 0xd1, 0xaf, 0x05, 0xf8, 0xfe, 0x22, 0x98, 0xf2, 0x26, 0x00, 0x75, - 0x32, 0x2f, 0x80, 0xdf, 0xca, 0x82, 0x29, 0x0d, 0x39, 0x56, 0x67, 0x17, 0xcf, 0x11, 0xc6, 0x35, - 0xf5, 0xf8, 0xae, 0x2c, 0x7a, 0x7e, 0x9b, 0x61, 0x76, 0x8e, 0x61, 0x34, 0x7a, 0xa2, 0xa9, 0xef, - 0xea, 0x46, 0x47, 0x3f, 0x4f, 0xbb, 0x9a, 0x82, 0x16, 0x26, 0x28, 0x73, 0x40, 0xb1, 0x2e, 0x9a, - 0xc8, 0xae, 0xb7, 0x2e, 0xaa, 0xee, 0x56, 0xa9, 0xdd, 0xb6, 0x91, 0xe3, 0xd0, 0xd5, 0x8b, 0x3e, - 0x5f, 0x94, 0xeb, 0xc0, 0x51, 0x9c, 0xca, 0x64, 0x26, 0x0e, 0x32, 0xbd, 0xc9, 0x41, 0xce, 0x92, - 0xb9, 0xe7, 0xe7, 0xcc, 0x31, 0x39, 0xc3, 0x64, 0xf6, 0xb8, 0x44, 0x9e, 0x3f, 0xa5, 0x73, 0x15, - 0x98, 0x32, 0xf5, 0x6d, 0xa4, 0xde, 0xd7, 0x35, 0x6c, 0xe4, 0x60, 0xc7, 0x18, 0x59, 0x63, 0x93, - 0xe0, 0x07, 0x85, 0xce, 0x9b, 0x8b, 0x49, 0x2c, 0x99, 0xee, 0x2f, 0x0d, 0xa1, 0xfa, 0x7d, 0xfa, - 0x19, 0x19, 0xbe, 0x5f, 0x06, 0xd3, 0x94, 0xa9, 0x92, 0xb9, 0x57, 0x69, 0xc3, 0x2b, 0x39, 0xe3, - 0x57, 0xf7, 0xd2, 0x7c, 0xe3, 0x17, 0xbf, 0xc0, 0x5f, 0x97, 0x45, 0xdd, 0x9d, 0xfb, 0x54, 0x1c, - 0x97, 0x11, 0xed, 0x38, 0xba, 0x61, 0xed, 0x50, 0x47, 0xd5, 0x82, 0x46, 0x5e, 0xd2, 0x5c, 0xd4, - 0x83, 0x7f, 0x2a, 0xe4, 0x4c, 0x2d, 0x58, 0x8d, 0x43, 0x02, 0xf0, 0xe3, 0x32, 0x98, 0xa5, 0x5c, - 0xd5, 0xe9, 0x39, 0x1f, 0xa1, 0x03, 0x6f, 0xbf, 0x29, 0x6c, 0x08, 0xf6, 0xa9, 0x3f, 0x2d, 0xe9, - 0x61, 0x03, 0xe4, 0x87, 0x85, 0x82, 0xa3, 0x09, 0x57, 0xe4, 0x90, 0xa0, 0x7c, 0x6b, 0x16, 0x4c, - 0xad, 0x3b, 0xc8, 0xa6, 0x7e, 0xfb, 0xf0, 0x81, 0x2c, 0x90, 0x97, 0x10, 0xb7, 0x91, 0xfa, 0x7c, - 0x61, 0x0f, 0x5f, 0xb6, 0xb2, 0x0c, 0x51, 0xcf, 0x46, 0x8a, 0x80, 0xed, 0x5a, 0x30, 0x4b, 0x44, - 0x5a, 0x72, 0x5d, 0xcf, 0x48, 0xf4, 0xbd, 0x69, 0x7b, 0x52, 0x47, 0xb1, 0x55, 0x84, 0xcb, 0xf2, - 0xb2, 0x94, 0x3d, 0x9e, 0x56, 0xd0, 0x06, 0x99, 0xcf, 0x66, 0xb5, 0x9e, 0x54, 0x7c, 0xb9, 0x7e, - 0x17, 0x91, 0xf3, 0x2b, 0x4c, 0xe6, 0x1c, 0xce, 0xdc, 0xef, 0x13, 0xfc, 0x96, 0x90, 0xaf, 0xae, - 0xb8, 0x74, 0x92, 0xe9, 0x42, 0x77, 0x34, 0x26, 0xc9, 0x71, 0x50, 0xf4, 0x72, 0xe0, 0xfd, 0x17, - 0x4d, 0xad, 0xd7, 0x56, 0xce, 0xaa, 0xfd, 0x97, 0x31, 0x72, 0xf0, 0x59, 0x32, 0x98, 0x9c, 0xb7, - 0x2d, 0xbd, 0xdd, 0xd2, 0x1d, 0x17, 0x7e, 0x5f, 0x02, 0xd3, 0x6b, 0xfa, 0x5e, 0xc7, 0xd2, 0xdb, - 0xd8, 0xbf, 0xbf, 0xa7, 0x2f, 0xe8, 0x92, 0x4f, 0x7e, 0x5f, 0x40, 0x5f, 0xf9, 0x83, 0x81, 0xc1, - 0xd1, 0xbd, 0x8c, 0xc8, 0x75, 0x8d, 0xc1, 0x36, 0x9f, 0xd4, 0x2f, 0x58, 0xa9, 0xcf, 0xd7, 0x1c, - 0xcb, 0x53, 0x84, 0x45, 0xf9, 0x7e, 0xb1, 0xf0, 0xa3, 0x22, 0x24, 0x0f, 0x67, 0x57, 0xfe, 0xd9, - 0x05, 0x90, 0x5f, 0x40, 0xd8, 0x8a, 0xfb, 0x6f, 0x12, 0x98, 0xa8, 0x23, 0x17, 0x5b, 0x70, 0xb7, - 0x70, 0x9e, 0xc2, 0x6d, 0x9c, 0x21, 0x74, 0x62, 0xf7, 0xdf, 0xbd, 0xc9, 0x3a, 0x73, 0xde, 0x1a, - 0x3f, 0x27, 0xf0, 0x48, 0x24, 0xe5, 0xce, 0xd1, 0x32, 0x0f, 0xe4, 0x91, 0x18, 0x4b, 0x2a, 0x7d, - 0x5f, 0xab, 0xb7, 0x4b, 0xd4, 0xb5, 0x8a, 0xe9, 0xf5, 0xfe, 0x80, 0xd5, 0xcf, 0x58, 0x6f, 0x33, - 0xca, 0x7c, 0x8c, 0x73, 0xd4, 0xe3, 0xc0, 0x04, 0x91, 0xb9, 0x3f, 0x1f, 0xed, 0xf5, 0x53, 0x20, - 0x24, 0xf0, 0xd9, 0x6b, 0x3f, 0xa7, 0xa0, 0x8b, 0x5a, 0x74, 0xe1, 0x63, 0x89, 0x41, 0x30, 0x5d, - 0x45, 0xee, 0x45, 0xcb, 0xbe, 0x50, 0x77, 0x75, 0x17, 0xc1, 0xff, 0x90, 0x80, 0x5c, 0x47, 0x2e, - 0x1b, 0xfd, 0xa4, 0x0a, 0x8e, 0x91, 0x0a, 0xd1, 0x8c, 0xb8, 0xff, 0x26, 0x15, 0xb9, 0xaa, 0xaf, - 0x10, 0x98, 0x7c, 0xda, 0xfe, 0x5f, 0xe1, 0xef, 0xf6, 0x0d, 0xfa, 0x24, 0xf5, 0x99, 0x34, 0x50, - 0xc9, 0xb0, 0x0c, 0x7a, 0x0a, 0x16, 0xa1, 0xa7, 0x1f, 0x10, 0x32, 0xab, 0xc5, 0x68, 0x1e, 0x4e, - 0x57, 0xf0, 0xe1, 0xcb, 0x40, 0xb6, 0xbc, 0xa5, 0xbb, 0xf0, 0x6d, 0x32, 0x00, 0xa5, 0x76, 0x7b, - 0x95, 0xf8, 0x80, 0xb3, 0x0e, 0x69, 0x67, 0xc0, 0x74, 0x6b, 0x4b, 0x0f, 0x6f, 0xce, 0x20, 0xfd, - 0x01, 0x97, 0xa6, 0x3c, 0x3e, 0x74, 0x26, 0x27, 0x52, 0x85, 0x3d, 0x30, 0x79, 0x65, 0x50, 0xda, - 0x81, 0xa3, 0x39, 0x1f, 0x0a, 0x33, 0xf6, 0x08, 0x9d, 0xf7, 0xfb, 0x5c, 0xc8, 0x5e, 0xf4, 0x1c, - 0x8e, 0x92, 0x0e, 0x0e, 0xd8, 0x84, 0x09, 0x09, 0x4f, 0x7a, 0x8b, 0x05, 0xf4, 0x88, 0xe7, 0x6b, - 0x2c, 0xa1, 0x6b, 0x15, 0xb5, 0x6d, 0xf8, 0xa2, 0xa5, 0x01, 0xb3, 0xe0, 0xf3, 0x32, 0xc9, 0xe0, - 0x8b, 0x17, 0xdc, 0x9d, 0x60, 0x06, 0xb5, 0x0d, 0x17, 0xf9, 0xb5, 0xa4, 0x02, 0x8c, 0x83, 0x98, - 0xff, 0x01, 0x3e, 0x43, 0x38, 0xe8, 0x1a, 0x16, 0xe8, 0xfe, 0x1a, 0x45, 0xb4, 0x3f, 0xb1, 0x30, - 0x6a, 0x62, 0x34, 0xd3, 0x07, 0xeb, 0x99, 0x32, 0x38, 0xd1, 0xb0, 0x36, 0x37, 0x3b, 0xc8, 0x17, - 0x13, 0x22, 0xde, 0x99, 0x50, 0x1f, 0x25, 0x5c, 0x78, 0x27, 0xc8, 0xba, 0xd7, 0x08, 0x8e, 0x92, - 0x79, 0x2f, 0xfc, 0x89, 0xa9, 0xd8, 0x59, 0x14, 0x16, 0x57, 0x5f, 0x3e, 0x23, 0x50, 0x10, 0x0b, - 0xf8, 0x2c, 0x4c, 0x36, 0x7d, 0x20, 0xbe, 0x28, 0x81, 0x19, 0x72, 0x2f, 0xa2, 0xaf, 0xa0, 0x77, - 0x8f, 0x10, 0x00, 0xf8, 0xfd, 0x8c, 0xa8, 0x9f, 0x2d, 0x96, 0x09, 0xc7, 0x49, 0x84, 0x88, 0xc5, - 0x82, 0xaa, 0x0c, 0x24, 0x97, 0xbe, 0x68, 0xff, 0x42, 0x06, 0x53, 0x4b, 0xc8, 0x6f, 0x69, 0x4e, - 0xe2, 0x9e, 0xe8, 0x0c, 0x98, 0xc6, 0x97, 0x83, 0xd5, 0xe8, 0x31, 0x49, 0xb2, 0x6a, 0xc6, 0xa5, - 0x29, 0xd7, 0x80, 0x99, 0xf3, 0x68, 0xc3, 0xb2, 0x51, 0x8d, 0x3b, 0x4b, 0xc9, 0x27, 0x46, 0x84, - 0xa7, 0xe3, 0xe2, 0xa0, 0xcd, 0xf3, 0xd8, 0xdc, 0xb0, 0x5f, 0x98, 0x4c, 0x55, 0x22, 0xc6, 0x9c, - 0x27, 0x80, 0x02, 0x45, 0xde, 0x37, 0xd3, 0xe2, 0xfa, 0xc5, 0x20, 0x2f, 0xfc, 0xc3, 0x00, 0x51, - 0x95, 0x43, 0xf4, 0xa6, 0x24, 0x4c, 0x8c, 0xe5, 0xf6, 0xf0, 0x22, 0x53, 0xfe, 0xfc, 0x5e, 0xa5, - 0xed, 0xc0, 0xd5, 0x64, 0x98, 0x9e, 0x06, 0x20, 0x68, 0x1c, 0x7e, 0x58, 0x0b, 0x26, 0x85, 0x8f, - 0x5c, 0x1f, 0x7b, 0x50, 0xaf, 0x57, 0x1c, 0x98, 0x9d, 0x11, 0x03, 0x23, 0x76, 0xc0, 0x4f, 0x84, - 0x93, 0xf4, 0xd1, 0xf9, 0xb4, 0x0c, 0x4e, 0x04, 0xe7, 0x8f, 0x56, 0x74, 0x27, 0x6c, 0x77, 0xe5, - 0x64, 0x10, 0x71, 0x07, 0x3e, 0x82, 0xc6, 0xf2, 0xed, 0x64, 0x63, 0x46, 0x5f, 0x4e, 0x46, 0x8b, - 0x8e, 0x72, 0x03, 0x38, 0x66, 0xee, 0x6c, 0x07, 0x52, 0xc7, 0x2d, 0x9e, 0xb6, 0xf0, 0xfd, 0x1f, - 0x92, 0x8c, 0x4c, 0x22, 0xcc, 0x8f, 0x65, 0x4e, 0xc9, 0x1d, 0xe9, 0x7a, 0x4c, 0x22, 0x18, 0xe1, - 0xbf, 0x65, 0x12, 0xf5, 0x6e, 0x83, 0xcf, 0x7c, 0x25, 0xe8, 0xa5, 0x0e, 0xf1, 0xc0, 0xd7, 0x99, - 0x09, 0x90, 0x53, 0xb7, 0xbb, 0xee, 0xde, 0x99, 0x47, 0x82, 0x99, 0xba, 0x6b, 0x23, 0x7d, 0x9b, - 0xd9, 0x19, 0x70, 0xad, 0x0b, 0xc8, 0xf4, 0x77, 0x06, 0xf0, 0xcb, 0xad, 0xb7, 0x80, 0x09, 0xd3, - 0x6a, 0xea, 0x3b, 0xee, 0x96, 0x72, 0xe5, 0xbe, 0x23, 0xf5, 0x14, 0xfc, 0x1a, 0x8d, 0x61, 0xf4, - 0xd5, 0xdb, 0xf0, 0xda, 0x70, 0xde, 0xb4, 0x4a, 0x3b, 0xee, 0xd6, 0xfc, 0x15, 0x1f, 0xff, 0x87, - 0xd3, 0x99, 0xcf, 0xfc, 0xc3, 0xe9, 0xcc, 0x57, 0xfe, 0xe1, 0x74, 0xe6, 0x37, 0xbf, 0x76, 0xfa, - 0xc8, 0x67, 0xbe, 0x76, 0xfa, 0xc8, 0x17, 0xbf, 0x76, 0xfa, 0xc8, 0xcf, 0x4b, 0xdd, 0xf3, 0xe7, - 0xf3, 0x98, 0xca, 0xe3, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x42, 0x59, 0x3f, 0x33, 0xdf, - 0x12, 0x02, 0x00, + 0x98, 0xd6, 0x0e, 0x3f, 0x2e, 0x07, 0x1a, 0xb3, 0x80, 0x5a, 0x1d, 0xc3, 0x44, 0xf0, 0xae, 0x43, + 0x2a, 0x0c, 0xbf, 0xea, 0x23, 0x8e, 0x33, 0x2d, 0x3f, 0x02, 0xe7, 0x97, 0x27, 0xc7, 0xb9, 0x3f, + 0xc1, 0xff, 0xc4, 0xcd, 0xff, 0x4b, 0x32, 0x38, 0xc1, 0x34, 0x44, 0x0d, 0xed, 0x8c, 0x6c, 0x25, + 0xef, 0x17, 0xd8, 0xb6, 0x5b, 0xe1, 0x31, 0xed, 0x67, 0x4d, 0x1f, 0x60, 0x23, 0x02, 0xd6, 0xd7, + 0x06, 0xb0, 0xae, 0x70, 0xb0, 0x3e, 0x71, 0x08, 0x9a, 0xc9, 0x90, 0x7d, 0x63, 0xaa, 0xc8, 0x5e, + 0x01, 0x4e, 0xad, 0x95, 0xb4, 0x46, 0xa5, 0x5c, 0x59, 0x2b, 0x79, 0xe3, 0x28, 0x33, 0x64, 0x47, + 0x98, 0xeb, 0x3c, 0xe8, 0x7d, 0xf1, 0x7d, 0x5f, 0x16, 0x5c, 0xd5, 0xbf, 0xa3, 0x2d, 0x6f, 0xeb, + 0xe6, 0x16, 0x82, 0x86, 0x08, 0xd4, 0x0b, 0x60, 0xa2, 0x85, 0xb3, 0x13, 0x9c, 0xd9, 0xad, 0x9b, + 0x98, 0xbe, 0x9c, 0x94, 0xa0, 0xf9, 0xbf, 0xc2, 0xb7, 0xb0, 0x0a, 0xd1, 0xe0, 0x15, 0xe2, 0xc9, + 0xf1, 0xe0, 0x1d, 0xe0, 0x3b, 0x42, 0x37, 0x3e, 0x15, 0xe8, 0xc6, 0x05, 0x4e, 0x37, 0xca, 0x87, + 0x23, 0x9f, 0x4c, 0x4d, 0xfe, 0xec, 0xe1, 0xd0, 0x01, 0x44, 0x6a, 0x93, 0x11, 0x3d, 0x2a, 0xf4, + 0xed, 0xee, 0x5f, 0x26, 0x83, 0xfc, 0x02, 0xea, 0x20, 0xd1, 0x95, 0xc8, 0x6f, 0x49, 0xa2, 0x1b, + 0x22, 0x04, 0x06, 0x42, 0x3b, 0x7a, 0x75, 0xc4, 0x35, 0x76, 0x90, 0xe3, 0xea, 0x3b, 0x5d, 0x2c, + 0x6a, 0x59, 0x0b, 0x13, 0xe0, 0x2f, 0x4a, 0x22, 0xdb, 0x25, 0x31, 0xc5, 0xfc, 0xe7, 0x58, 0x53, + 0xfc, 0x8c, 0x04, 0x0a, 0x75, 0xe4, 0xd6, 0xec, 0x36, 0xb2, 0x61, 0x3d, 0xc4, 0xe8, 0x1a, 0x30, + 0x85, 0x41, 0xf1, 0xa6, 0x99, 0x01, 0x4e, 0x6c, 0x92, 0x72, 0x3d, 0x98, 0x0d, 0x5e, 0xf1, 0xef, + 0xb4, 0x1b, 0xef, 0x49, 0x85, 0xdf, 0xce, 0x88, 0xee, 0xe2, 0xd2, 0x25, 0x43, 0xca, 0x4d, 0x44, + 0x2b, 0x15, 0xdb, 0x91, 0x8d, 0x25, 0x95, 0xfe, 0x46, 0xd7, 0x9b, 0x24, 0x00, 0xd6, 0x4d, 0xc7, + 0x97, 0xeb, 0xa3, 0x13, 0xc8, 0x15, 0xfe, 0x6b, 0x26, 0xd9, 0x2c, 0x26, 0x2c, 0x27, 0x42, 0x62, + 0xbf, 0x9f, 0x60, 0x6d, 0x21, 0x92, 0x58, 0xfa, 0x32, 0xfb, 0xfc, 0x71, 0x90, 0xbf, 0xa0, 0x77, + 0x3a, 0xc8, 0x85, 0x2f, 0x95, 0x41, 0xbe, 0x6c, 0x23, 0xdd, 0x45, 0x10, 0x85, 0xa2, 0x83, 0xa0, + 0x60, 0x5b, 0x96, 0xbb, 0xa6, 0xbb, 0xdb, 0x54, 0x6e, 0xc1, 0xbb, 0xf2, 0x44, 0x70, 0xf9, 0xe6, + 0x6e, 0xa7, 0xe3, 0xa2, 0x07, 0xdc, 0x35, 0xdb, 0xd8, 0xd1, 0xed, 0xfd, 0x15, 0xdd, 0xdc, 0xda, + 0xd5, 0xb7, 0x10, 0x65, 0x2f, 0xea, 0x33, 0x75, 0x35, 0xf8, 0x23, 0xb6, 0xe3, 0xb9, 0x8b, 0x17, + 0xfa, 0x8f, 0x73, 0x72, 0x22, 0x2c, 0xce, 0x11, 0xf6, 0x22, 0x7a, 0x1e, 0x08, 0x0a, 0x3b, 0x26, + 0xda, 0xb1, 0x4c, 0xa3, 0xe5, 0x5b, 0xab, 0xfe, 0x3b, 0xfc, 0x40, 0x80, 0xc6, 0x3c, 0x87, 0xc6, + 0x9c, 0x70, 0x29, 0xc9, 0xa0, 0xa8, 0x0f, 0xd1, 0xef, 0x5c, 0x0d, 0xae, 0x24, 0xdd, 0x48, 0xb3, + 0x51, 0x6b, 0x96, 0x35, 0xb5, 0xd4, 0x50, 0x9b, 0x2b, 0xb5, 0x72, 0x69, 0xa5, 0xa9, 0xa9, 0x6b, + 0xb5, 0x22, 0xf2, 0x66, 0xe7, 0x13, 0x1a, 0x6a, 0x59, 0x7b, 0xc8, 0x86, 0x4f, 0xcf, 0x88, 0x41, + 0x14, 0x23, 0x94, 0x38, 0xf8, 0x64, 0x11, 0xf8, 0x7e, 0x43, 0xd8, 0x53, 0x84, 0x0a, 0x96, 0x32, + 0x1f, 0xd1, 0x62, 0x3e, 0x28, 0xd4, 0xc7, 0xc4, 0x92, 0x7a, 0x18, 0x80, 0xf4, 0x3f, 0x24, 0x30, + 0x51, 0xb6, 0xcc, 0x3d, 0x64, 0xbb, 0xec, 0x24, 0x8b, 0xc5, 0x21, 0xd3, 0x83, 0xc3, 0x19, 0x30, + 0x81, 0x4c, 0xd7, 0xb6, 0xba, 0xfe, 0x2c, 0xcb, 0x7f, 0x85, 0xaf, 0x4e, 0x2a, 0x61, 0x5a, 0x72, + 0xf4, 0x6a, 0x6b, 0xff, 0x82, 0x38, 0xf6, 0xe4, 0x9e, 0xb6, 0xf3, 0x8a, 0x24, 0xb8, 0xf4, 0x67, + 0x20, 0xfd, 0x7e, 0xec, 0xcb, 0x32, 0x98, 0x21, 0xed, 0xb6, 0x8e, 0xb0, 0x59, 0x08, 0x6b, 0xec, + 0x3a, 0x67, 0x8f, 0xf0, 0x97, 0x8f, 0x71, 0xe2, 0xcf, 0xeb, 0xdd, 0x6e, 0xb0, 0xe6, 0xbd, 0x7c, + 0x4c, 0xa3, 0xef, 0x44, 0xcd, 0xe7, 0xf3, 0x20, 0xab, 0xef, 0xba, 0xdb, 0xf0, 0x07, 0xc2, 0x33, + 0x5e, 0xae, 0x1f, 0xa1, 0xfc, 0x44, 0x40, 0x72, 0x12, 0xe4, 0x5c, 0xeb, 0x22, 0xf2, 0xe5, 0x40, + 0x5e, 0x3c, 0x38, 0xf4, 0x6e, 0xb7, 0x81, 0x3f, 0x50, 0x38, 0xfc, 0x77, 0xcf, 0xc0, 0xd2, 0x5b, + 0x2d, 0x6b, 0xd7, 0x74, 0x2b, 0xfe, 0xba, 0x77, 0x98, 0x00, 0x3f, 0x9f, 0x11, 0x99, 0x41, 0x0b, + 0x30, 0x98, 0x0c, 0xb2, 0x8d, 0x21, 0x9a, 0xd2, 0x1c, 0xb8, 0xb1, 0xb4, 0xb6, 0xd6, 0x6c, 0xd4, + 0xee, 0x55, 0xab, 0xa1, 0xb5, 0xdb, 0xac, 0x54, 0x9b, 0x8d, 0x65, 0xb5, 0x59, 0x5e, 0xd7, 0xf0, + 0xe2, 0x64, 0xa9, 0x5c, 0xae, 0xad, 0x57, 0x1b, 0x45, 0x04, 0x5f, 0x27, 0x81, 0xe9, 0x72, 0xc7, + 0x72, 0x02, 0x84, 0xaf, 0x0e, 0x11, 0x0e, 0xc4, 0x98, 0x61, 0xc4, 0x08, 0xff, 0x67, 0x46, 0xd4, + 0xd3, 0xc1, 0x17, 0x08, 0x43, 0x3e, 0xa2, 0x97, 0x7a, 0xb5, 0x90, 0xa7, 0xc3, 0x60, 0x7a, 0xe9, + 0x37, 0x89, 0x2f, 0xaa, 0x60, 0xa2, 0x44, 0x14, 0x03, 0xfe, 0x5d, 0x06, 0xe4, 0xcb, 0x96, 0xb9, + 0x69, 0x6c, 0x79, 0x16, 0x24, 0x32, 0xf5, 0x8d, 0x0e, 0x5a, 0xd0, 0x5d, 0x7d, 0xcf, 0x40, 0x97, + 0x70, 0x05, 0x0a, 0x5a, 0x4f, 0xaa, 0xc7, 0x14, 0x4d, 0x41, 0x1b, 0xbb, 0x5b, 0x98, 0xa9, 0x82, + 0xc6, 0x26, 0x79, 0xe3, 0x07, 0x79, 0x5d, 0xb3, 0x91, 0x8d, 0x3a, 0x48, 0x77, 0x90, 0x37, 0x17, + 0x33, 0x51, 0x07, 0x2b, 0x6d, 0x41, 0x8b, 0xfa, 0xac, 0x9c, 0x03, 0xd3, 0xe4, 0x13, 0xb6, 0x7f, + 0x1c, 0xac, 0xc6, 0x05, 0x8d, 0x4b, 0x53, 0x1e, 0x03, 0x72, 0xe8, 0x01, 0xd7, 0xd6, 0xcf, 0xb4, + 0x31, 0x5e, 0x97, 0xcf, 0x11, 0x57, 0xc7, 0x39, 0xdf, 0xd5, 0x71, 0xae, 0x8e, 0x1d, 0x21, 0x35, + 0x92, 0x0b, 0x7e, 0xbc, 0x10, 0x58, 0x2f, 0xaf, 0x93, 0x43, 0xc5, 0x50, 0x40, 0xd6, 0xd4, 0x77, + 0x10, 0xd5, 0x0b, 0xfc, 0xac, 0xdc, 0x08, 0x8e, 0xeb, 0x7b, 0xba, 0xab, 0xdb, 0x2b, 0x56, 0x4b, + 0xef, 0xe0, 0x61, 0xd3, 0x6f, 0xf9, 0xbd, 0x1f, 0xf0, 0x36, 0x94, 0x6b, 0xd9, 0x08, 0xe7, 0xf2, + 0xb7, 0xa1, 0xfc, 0x04, 0x8f, 0xba, 0xd1, 0xb2, 0x4c, 0xcc, 0xbf, 0xac, 0xe1, 0x67, 0x4f, 0x2a, + 0x6d, 0xc3, 0xf1, 0x2a, 0x82, 0xa9, 0x54, 0xc9, 0x7e, 0x4a, 0x7d, 0xdf, 0x6c, 0xe1, 0x2d, 0xa8, + 0x82, 0x16, 0xf5, 0x59, 0x99, 0x07, 0x53, 0x74, 0xf7, 0x65, 0xd5, 0xd3, 0xab, 0x3c, 0xd6, 0xab, + 0x6b, 0x78, 0x47, 0x32, 0x82, 0xe7, 0x5c, 0x35, 0xcc, 0xa7, 0xb1, 0x3f, 0x29, 0x77, 0x83, 0x2b, + 0xe9, 0x6b, 0x79, 0xd7, 0x71, 0xad, 0x1d, 0x02, 0xfa, 0xa2, 0xd1, 0x21, 0x35, 0x98, 0xc0, 0x35, + 0x88, 0xcb, 0xa2, 0xdc, 0x0a, 0x4e, 0x76, 0x6d, 0xb4, 0x89, 0xec, 0xfb, 0xf4, 0x9d, 0xdd, 0x07, + 0x1a, 0xb6, 0x6e, 0x3a, 0x5d, 0xcb, 0x76, 0xcf, 0x14, 0x30, 0xf3, 0x7d, 0xbf, 0x29, 0x37, 0x81, + 0x13, 0xf7, 0x3b, 0x96, 0x59, 0xea, 0x1a, 0x2b, 0x86, 0xe3, 0x22, 0xb3, 0xd4, 0x6e, 0xdb, 0x67, + 0x26, 0x71, 0x59, 0x07, 0x3f, 0xd0, 0x6e, 0xb5, 0x00, 0xf2, 0x44, 0xd8, 0xf0, 0xb9, 0x39, 0x61, + 0x8f, 0x53, 0x5a, 0xfd, 0x58, 0x3b, 0xf0, 0xb1, 0x60, 0x82, 0xf6, 0x87, 0x18, 0xd6, 0xa9, 0x5b, + 0x4f, 0xf7, 0x2c, 0x7d, 0x50, 0x2a, 0x9a, 0x9f, 0x4d, 0x79, 0x1c, 0xc8, 0xb7, 0xb0, 0x10, 0x30, + 0xc2, 0x53, 0xb7, 0x5e, 0xd9, 0xbf, 0x50, 0x9c, 0x45, 0xa3, 0x59, 0xe1, 0x17, 0x64, 0x21, 0x27, + 0xd5, 0x38, 0x8e, 0x93, 0xf5, 0x01, 0xdf, 0x90, 0x86, 0xe8, 0x64, 0x6f, 0x02, 0x37, 0xd0, 0x1e, + 0x94, 0x5a, 0x2b, 0x0b, 0xcd, 0xf9, 0x75, 0x7f, 0xbe, 0xea, 0xd9, 0x30, 0xf5, 0x46, 0x49, 0x6b, + 0x34, 0xab, 0xb5, 0x05, 0x6f, 0x9e, 0x7b, 0x23, 0xb8, 0x7e, 0x40, 0x6e, 0xb5, 0xd1, 0xac, 0x96, + 0x56, 0xd5, 0xe2, 0x26, 0x6f, 0x09, 0xd5, 0x1b, 0xb5, 0xb5, 0xa6, 0xb6, 0x5e, 0xad, 0x56, 0xaa, + 0x4b, 0x84, 0x98, 0x67, 0x7a, 0x9e, 0x0e, 0x33, 0x5c, 0xd0, 0x2a, 0x0d, 0xb5, 0x59, 0xae, 0x55, + 0x17, 0x2b, 0x4b, 0x45, 0x63, 0x90, 0x19, 0x75, 0xbf, 0x72, 0x0d, 0xb8, 0x8a, 0xe3, 0xa4, 0x52, + 0xab, 0x7a, 0x93, 0xef, 0x72, 0xa9, 0x5a, 0x56, 0xbd, 0x99, 0xf6, 0x45, 0x05, 0x82, 0x53, 0x84, + 0x5c, 0x73, 0xb1, 0xb2, 0xc2, 0xee, 0x97, 0x7d, 0x34, 0xa3, 0x9c, 0x01, 0x97, 0xb1, 0xdf, 0x2a, + 0xd5, 0xf3, 0xa5, 0x95, 0xca, 0x42, 0xf1, 0x63, 0x19, 0xe5, 0x3a, 0x70, 0x35, 0xf7, 0x17, 0xd9, + 0xfa, 0x6a, 0x56, 0x16, 0x9a, 0xab, 0x95, 0xfa, 0x6a, 0xa9, 0x51, 0x5e, 0x2e, 0x7e, 0x1c, 0x4f, + 0x4c, 0x02, 0x4b, 0x9b, 0xf1, 0x1c, 0x7d, 0x3e, 0x6b, 0x01, 0x94, 0x78, 0x45, 0x7d, 0x74, 0x5f, + 0xd8, 0xe3, 0x2d, 0xde, 0x0f, 0x07, 0x63, 0xc9, 0x02, 0xa7, 0x42, 0x8f, 0x4d, 0x40, 0x2b, 0x99, + 0x0e, 0x35, 0x86, 0x50, 0xa1, 0x6b, 0xc0, 0x55, 0x55, 0x95, 0x20, 0xa5, 0xa9, 0xe5, 0xda, 0x79, + 0x55, 0x6b, 0x5e, 0x28, 0xad, 0xac, 0xa8, 0x8d, 0xe6, 0x62, 0x45, 0xab, 0x37, 0x8a, 0x9b, 0xf0, + 0x5f, 0xa5, 0x60, 0xc1, 0x89, 0x91, 0xd6, 0xdf, 0x49, 0x49, 0x9b, 0x75, 0xec, 0xc2, 0xd2, 0x4f, + 0x80, 0xbc, 0xe3, 0xea, 0xee, 0xae, 0x43, 0x5b, 0xf5, 0x23, 0xfa, 0xb7, 0xea, 0xb9, 0x3a, 0xce, + 0xa4, 0xd1, 0xcc, 0xf0, 0x0b, 0x99, 0x24, 0xcd, 0x74, 0x04, 0x6b, 0x4e, 0xc6, 0x10, 0x22, 0x3e, + 0x0b, 0xa0, 0xaf, 0xed, 0x95, 0x7a, 0xb3, 0xb4, 0xa2, 0xa9, 0xa5, 0x85, 0xfb, 0x82, 0x95, 0x26, + 0xa4, 0x9c, 0x02, 0x27, 0xd6, 0xab, 0xa5, 0xf9, 0x15, 0x15, 0x37, 0x97, 0x5a, 0xb5, 0xaa, 0x96, + 0x3d, 0xb9, 0xff, 0x22, 0xde, 0xd7, 0xf1, 0xec, 0x6d, 0xcc, 0xb7, 0x67, 0x13, 0x31, 0xf2, 0xff, + 0xba, 0xb0, 0xfb, 0x53, 0xa8, 0x61, 0x2c, 0xad, 0xd1, 0xe2, 0xf0, 0x79, 0x21, 0x8f, 0x27, 0x21, + 0x4e, 0x92, 0xe1, 0xf1, 0x73, 0x43, 0xe0, 0x71, 0x0a, 0x9c, 0x60, 0xf1, 0xc0, 0x9e, 0x4f, 0xd1, + 0x30, 0xbc, 0x5d, 0x06, 0x13, 0xab, 0xc6, 0x16, 0x76, 0xfd, 0xdc, 0x0d, 0x4d, 0x8f, 0x59, 0x20, + 0x05, 0x9e, 0x36, 0x92, 0xd1, 0xe6, 0xa6, 0xe9, 0x92, 0xf8, 0x4a, 0x8a, 0xd0, 0x54, 0xfc, 0x2d, + 0x89, 0x7b, 0x26, 0xca, 0x70, 0x44, 0xcf, 0xf4, 0xd5, 0x44, 0x3d, 0x53, 0x7f, 0x5a, 0xc9, 0x60, + 0xb2, 0x0f, 0x07, 0x13, 0xeb, 0x19, 0x33, 0x0d, 0x0a, 0xc1, 0x38, 0x81, 0x37, 0x69, 0xbc, 0x8f, + 0x6a, 0xb5, 0xb6, 0xbe, 0xb4, 0xdc, 0x5c, 0xd4, 0x54, 0x95, 0x2e, 0xeb, 0x6e, 0xc1, 0x37, 0x4b, + 0x60, 0x86, 0xf2, 0x4e, 0x3d, 0x1e, 0xae, 0x8e, 0x84, 0x8f, 0x0a, 0xfa, 0x3f, 0xd8, 0x29, 0xc5, + 0x12, 0x2f, 0xe8, 0x5b, 0xe2, 0x84, 0x13, 0xeb, 0xf2, 0xf0, 0x9a, 0x40, 0xdc, 0xf7, 0x70, 0xe2, + 0x7e, 0x42, 0x62, 0x8a, 0xe9, 0x4f, 0x2b, 0xfe, 0x69, 0x12, 0xe4, 0xeb, 0xa8, 0x83, 0x5a, 0x2e, + 0x7c, 0x81, 0x3c, 0xb4, 0xb6, 0x47, 0x99, 0xc8, 0x72, 0x22, 0x13, 0x39, 0x9b, 0x82, 0x89, 0x9c, + 0x1b, 0xde, 0x44, 0xce, 0x27, 0x35, 0x91, 0x27, 0x22, 0x4c, 0xe4, 0xb8, 0xfe, 0xa0, 0x20, 0xd2, + 0x1f, 0x7c, 0x28, 0x9f, 0x74, 0xec, 0x25, 0x90, 0x1e, 0xad, 0x49, 0xfd, 0x6b, 0xb9, 0x24, 0x63, + 0x75, 0x5f, 0x8e, 0x93, 0xe9, 0xff, 0x4b, 0xb2, 0x29, 0x2c, 0x01, 0x2a, 0xd7, 0x82, 0xab, 0xc3, + 0xf7, 0xa6, 0xfa, 0x94, 0x4a, 0xbd, 0x51, 0xc7, 0x76, 0x74, 0xb9, 0xa6, 0x69, 0xeb, 0x6b, 0x64, + 0xf3, 0xe8, 0x34, 0x50, 0x42, 0x2a, 0xda, 0x7a, 0x95, 0x58, 0xcd, 0x5b, 0x3c, 0xf5, 0xc5, 0x4a, + 0x75, 0xa1, 0x19, 0x8c, 0x44, 0xd5, 0xc5, 0x5a, 0x71, 0x5b, 0x99, 0x03, 0x37, 0x32, 0xd4, 0x71, + 0xd7, 0x46, 0x4a, 0x28, 0x55, 0x17, 0x9a, 0xab, 0x55, 0x75, 0xb5, 0x56, 0xad, 0x94, 0x71, 0x7a, + 0x5d, 0x6d, 0x14, 0x0d, 0xcf, 0x7c, 0xeb, 0xb1, 0xd3, 0xeb, 0x6a, 0x49, 0x2b, 0x2f, 0xab, 0x1a, + 0x29, 0xf2, 0x7e, 0xe5, 0x7a, 0x70, 0xae, 0x54, 0xad, 0x35, 0xbc, 0x94, 0x52, 0xf5, 0xbe, 0xc6, + 0x7d, 0x6b, 0x6a, 0x73, 0x4d, 0xab, 0x95, 0xd5, 0x7a, 0xdd, 0x1b, 0xfd, 0xa8, 0x55, 0x5f, 0xec, + 0x28, 0x4f, 0x06, 0xb7, 0x33, 0xac, 0xa9, 0x0d, 0xec, 0xa9, 0xb0, 0x5a, 0xc3, 0xce, 0x6a, 0x0b, + 0x6a, 0x73, 0xb9, 0x54, 0x6f, 0x56, 0xaa, 0xe5, 0xda, 0xea, 0x5a, 0xa9, 0x51, 0xf1, 0x06, 0xc9, + 0x35, 0xad, 0xd6, 0xa8, 0x35, 0xcf, 0xab, 0x5a, 0xbd, 0x52, 0xab, 0x16, 0x4d, 0xaf, 0xca, 0xcc, + 0xa8, 0xea, 0x5b, 0x37, 0x96, 0x72, 0x15, 0x38, 0xe3, 0xa7, 0xaf, 0xd4, 0x3c, 0x41, 0x33, 0x76, + 0x7e, 0x97, 0xb5, 0x8d, 0xea, 0x8d, 0x9a, 0x46, 0x2c, 0xfd, 0xd5, 0xca, 0x92, 0xe6, 0x4d, 0x4f, + 0x8a, 0x4f, 0x4d, 0x75, 0x1e, 0xf0, 0xef, 0x12, 0xc8, 0xd6, 0x5d, 0xab, 0x0b, 0x7f, 0x3c, 0xec, + 0xe8, 0xce, 0x02, 0x60, 0x63, 0xc7, 0x84, 0x05, 0xdd, 0xd5, 0xe9, 0xda, 0x09, 0x93, 0x02, 0xff, + 0x54, 0x78, 0x37, 0x35, 0xb4, 0x94, 0xac, 0x6e, 0xc4, 0xc0, 0xf0, 0x3d, 0xb1, 0xe3, 0x65, 0xd1, + 0x84, 0x92, 0xb5, 0x87, 0x5f, 0x19, 0x66, 0xbf, 0x14, 0x82, 0xd3, 0x0c, 0xac, 0x9e, 0xfc, 0x7d, + 0x95, 0x41, 0xca, 0xe5, 0xe0, 0xb2, 0x1e, 0xe5, 0xc3, 0x3a, 0xb7, 0xa9, 0xfc, 0x18, 0x78, 0x04, + 0xa3, 0xfe, 0xea, 0x6a, 0xed, 0xbc, 0x1a, 0x28, 0xfa, 0x42, 0xa9, 0x51, 0x2a, 0x6e, 0xc1, 0xcf, + 0xc8, 0x20, 0xbb, 0x6a, 0xed, 0xf5, 0x6e, 0x62, 0x9b, 0xe8, 0x12, 0xb3, 0xd3, 0xe1, 0xbf, 0xf2, + 0xc7, 0x69, 0x84, 0xc4, 0xbe, 0x1a, 0xed, 0xb0, 0xf2, 0x79, 0x29, 0x89, 0xd8, 0x57, 0x0f, 0xeb, + 0xa5, 0xf2, 0x4f, 0xc3, 0x88, 0x3d, 0x42, 0xb4, 0x48, 0x39, 0x07, 0xce, 0x86, 0x1f, 0x2a, 0x0b, + 0x6a, 0xb5, 0x51, 0x59, 0xbc, 0x2f, 0x14, 0x6e, 0x45, 0x13, 0x12, 0xff, 0xa0, 0x6e, 0x2e, 0x7e, + 0x7e, 0x7f, 0x06, 0x9c, 0x0c, 0xbf, 0x2d, 0xa9, 0x0d, 0xff, 0xcb, 0xfd, 0xf0, 0xc1, 0x1c, 0x98, + 0x26, 0xdd, 0xfe, 0x7a, 0xb7, 0xed, 0x59, 0xcc, 0x8f, 0x0b, 0xd1, 0xbd, 0x01, 0x1c, 0xaf, 0xac, + 0x2d, 0xd6, 0xeb, 0xae, 0x65, 0xeb, 0x5b, 0x08, 0x8f, 0x90, 0x44, 0x5a, 0xbd, 0xc9, 0xf0, 0x6d, + 0xc2, 0x6b, 0xf1, 0xfc, 0x50, 0x43, 0xca, 0x8c, 0x40, 0xfd, 0xcb, 0x42, 0x6b, 0xe7, 0x02, 0x04, + 0x93, 0xa1, 0x7f, 0xff, 0x88, 0xdb, 0x5c, 0x34, 0x2e, 0x9b, 0xe7, 0x9e, 0x29, 0x81, 0xc9, 0x86, + 0xb1, 0x83, 0x9e, 0x66, 0x99, 0xc8, 0x51, 0x26, 0x80, 0xbc, 0xb4, 0xda, 0x28, 0x1e, 0xf3, 0x1e, + 0xbc, 0xa9, 0x4c, 0x06, 0x3f, 0xa8, 0x5e, 0x01, 0xde, 0x43, 0xa9, 0x51, 0x94, 0xbd, 0x87, 0x55, + 0xb5, 0x51, 0xcc, 0x7a, 0x0f, 0x55, 0xb5, 0x51, 0xcc, 0x79, 0x0f, 0x6b, 0x2b, 0x8d, 0x62, 0xde, + 0x7b, 0xa8, 0xd4, 0x1b, 0xc5, 0x09, 0xef, 0x61, 0xbe, 0xde, 0x28, 0x16, 0xbc, 0x87, 0xf3, 0xf5, + 0x46, 0x71, 0xd2, 0x7b, 0x28, 0x37, 0x1a, 0x45, 0xe0, 0x3d, 0xdc, 0x53, 0x6f, 0x14, 0xa7, 0xbc, + 0x87, 0x52, 0xb9, 0x51, 0x9c, 0xc6, 0x0f, 0x6a, 0xa3, 0x38, 0xe3, 0x3d, 0xd4, 0xeb, 0x8d, 0xe2, + 0x2c, 0xa6, 0x5c, 0x6f, 0x14, 0x8f, 0xe3, 0xb2, 0x2a, 0x8d, 0x62, 0xd1, 0x7b, 0x58, 0xae, 0x37, + 0x8a, 0x27, 0x70, 0xe6, 0x7a, 0xa3, 0xa8, 0xe0, 0x42, 0xeb, 0x8d, 0xe2, 0x65, 0x38, 0x4f, 0xbd, + 0x51, 0x3c, 0x89, 0x8b, 0xa8, 0x37, 0x8a, 0xa7, 0x30, 0x1b, 0x6a, 0xa3, 0x78, 0x1a, 0xe7, 0xd1, + 0x1a, 0xc5, 0xcb, 0xf1, 0xa7, 0x6a, 0xa3, 0x78, 0x06, 0x33, 0xa6, 0x36, 0x8a, 0x57, 0xe0, 0x07, + 0xad, 0x51, 0x84, 0xf8, 0x53, 0xa9, 0x51, 0xbc, 0x12, 0x3e, 0x02, 0x4c, 0x2e, 0x21, 0x97, 0x80, + 0x08, 0x8b, 0x40, 0x5e, 0x42, 0x2e, 0x3b, 0x79, 0x7e, 0x69, 0x16, 0x5c, 0x4e, 0x17, 0x5c, 0x16, + 0x6d, 0x6b, 0x67, 0x05, 0x6d, 0xe9, 0xad, 0x7d, 0xf5, 0x01, 0xcf, 0x94, 0x83, 0xcf, 0xc9, 0x70, + 0xeb, 0xcb, 0xdd, 0xb0, 0x37, 0xc2, 0xcf, 0xb1, 0xa6, 0xaf, 0xbf, 0x62, 0x2c, 0xf3, 0x2b, 0xc6, + 0x51, 0xc6, 0x5e, 0x56, 0xc4, 0xd8, 0xfb, 0x17, 0xb6, 0x31, 0x70, 0xdb, 0x43, 0x99, 0x9e, 0xed, + 0x21, 0xaf, 0x85, 0x75, 0x91, 0xed, 0x58, 0xa6, 0xde, 0xa9, 0x53, 0x67, 0x20, 0x32, 0xbf, 0xec, + 0x4d, 0x56, 0x7e, 0xca, 0x6f, 0x54, 0xc4, 0xe0, 0x7b, 0x52, 0xdc, 0x92, 0x54, 0xaf, 0x84, 0x22, + 0xda, 0xd7, 0xc7, 0x83, 0xf6, 0xd5, 0xe0, 0xda, 0xd7, 0xdd, 0x87, 0xa0, 0x9d, 0xac, 0xa9, 0x55, + 0x86, 0x9b, 0x64, 0x86, 0xae, 0xf2, 0xfe, 0x6e, 0x94, 0x0c, 0x3f, 0x23, 0x81, 0xd3, 0xaa, 0xd9, + 0x6f, 0x92, 0xc2, 0xaa, 0xd1, 0xeb, 0x58, 0x68, 0xd6, 0x78, 0x91, 0xde, 0xde, 0xb7, 0xda, 0xfd, + 0x69, 0x46, 0x48, 0xf4, 0x93, 0x81, 0x44, 0xeb, 0x9c, 0x44, 0xef, 0x1a, 0x9e, 0x74, 0x32, 0x81, + 0x56, 0x47, 0xda, 0x77, 0x65, 0xe1, 0xd7, 0x24, 0x70, 0x82, 0xf8, 0xf3, 0xdd, 0x43, 0xe6, 0x44, + 0xb8, 0xb7, 0xe7, 0xad, 0xaf, 0x4e, 0x38, 0x7f, 0x22, 0xfa, 0xcd, 0xa4, 0xc0, 0x57, 0xb2, 0x02, + 0xbf, 0x97, 0x17, 0x78, 0x44, 0x3f, 0xde, 0x5b, 0x5c, 0x84, 0xac, 0x3f, 0x16, 0xc8, 0xba, 0xca, + 0xc9, 0xfa, 0xf6, 0xa1, 0xa8, 0x1e, 0xad, 0x98, 0xbf, 0x91, 0x05, 0x8f, 0x20, 0x1c, 0x52, 0x45, + 0x20, 0xfd, 0x60, 0xc9, 0x6c, 0x6b, 0xc8, 0x71, 0x75, 0xdb, 0xe5, 0x42, 0x59, 0xf4, 0x4c, 0xba, + 0x33, 0x29, 0x4c, 0xba, 0xa5, 0x81, 0x93, 0x6e, 0xf8, 0x56, 0xd6, 0xc0, 0xbb, 0xc0, 0x23, 0x5b, + 0x8a, 0xc1, 0x20, 0xa2, 0x86, 0x51, 0x2d, 0x2a, 0xb0, 0xfc, 0x7e, 0x9a, 0x43, 0x79, 0xf1, 0xd0, + 0x25, 0x24, 0x43, 0xfc, 0x4f, 0x47, 0x6b, 0x89, 0x67, 0xd9, 0x6f, 0xbc, 0xd9, 0x58, 0x6c, 0xa7, + 0x3a, 0x85, 0x7a, 0x5e, 0x01, 0x4c, 0xe2, 0x2e, 0x67, 0xc5, 0x30, 0x2f, 0xc2, 0xaf, 0xca, 0x60, + 0xba, 0x8a, 0x2e, 0x95, 0xb7, 0xf5, 0x4e, 0x07, 0x99, 0x5b, 0x08, 0xde, 0xcf, 0xd9, 0xf6, 0x7a, + 0xb7, 0x5b, 0x0d, 0x77, 0x6b, 0xfd, 0x57, 0xe5, 0x2e, 0x90, 0x73, 0x5a, 0x56, 0x97, 0x78, 0x95, + 0xcd, 0x32, 0xae, 0x61, 0xfc, 0x8a, 0x73, 0x69, 0xd7, 0xdd, 0x9e, 0xc3, 0x65, 0x95, 0xba, 0x46, + 0xdd, 0xfb, 0x41, 0x23, 0xff, 0xd1, 0x71, 0xf2, 0xeb, 0x7d, 0x3b, 0xe3, 0x4c, 0x4c, 0x67, 0x1c, + 0x30, 0x3e, 0xc7, 0x32, 0x1d, 0xb1, 0x48, 0x72, 0x0d, 0x98, 0x6a, 0xf9, 0x59, 0x82, 0x33, 0x73, + 0x6c, 0x12, 0xfc, 0x87, 0x44, 0xdd, 0xb5, 0x50, 0xe1, 0xc9, 0xb4, 0x0a, 0x8d, 0xd8, 0xd4, 0x3c, + 0x05, 0x4e, 0x34, 0x6a, 0xb5, 0xe6, 0x6a, 0xa9, 0x7a, 0x5f, 0x18, 0xab, 0x62, 0x13, 0xbe, 0x24, + 0x0b, 0x66, 0xeb, 0x56, 0x67, 0x0f, 0x85, 0x38, 0x57, 0x38, 0x67, 0x4c, 0x56, 0x4e, 0x99, 0x03, + 0x72, 0x52, 0x4e, 0x83, 0xbc, 0x6e, 0x3a, 0x97, 0x90, 0x6f, 0xfe, 0xd3, 0x37, 0x0a, 0xe3, 0xfb, + 0xd8, 0x8e, 0x40, 0xe3, 0x61, 0xbc, 0x63, 0x80, 0x24, 0x79, 0xae, 0x22, 0x80, 0x3c, 0x07, 0xa6, + 0x1d, 0xe2, 0xb3, 0xd1, 0x60, 0x5c, 0x73, 0xb8, 0x34, 0xcc, 0x22, 0x71, 0x1a, 0x92, 0x29, 0x8b, + 0xf8, 0x0d, 0xbe, 0x22, 0xe8, 0x3f, 0xd6, 0x39, 0x88, 0x4b, 0x87, 0x61, 0x2c, 0x19, 0xc8, 0x2f, + 0x1b, 0xf5, 0x24, 0xfe, 0x0c, 0x38, 0x49, 0x9b, 0x7d, 0xb3, 0xbc, 0x5c, 0x5a, 0x59, 0x51, 0xab, + 0x4b, 0x6a, 0xb3, 0xb2, 0x40, 0xf6, 0x80, 0xc3, 0x94, 0x52, 0xa3, 0xa1, 0xae, 0xae, 0x35, 0xea, + 0x4d, 0xf5, 0x29, 0x65, 0x55, 0x5d, 0xc0, 0xee, 0xd0, 0xf8, 0x3c, 0xa3, 0xef, 0xb8, 0x5e, 0xaa, + 0xd6, 0x2f, 0xa8, 0x5a, 0x71, 0xfb, 0x5c, 0x09, 0x4c, 0x31, 0x03, 0x85, 0xc7, 0xdd, 0x02, 0xda, + 0xd4, 0x77, 0x3b, 0xd4, 0x1c, 0x2f, 0x1e, 0xf3, 0xb8, 0xc3, 0xb2, 0xa9, 0x99, 0x9d, 0xfd, 0x62, + 0x46, 0x29, 0x82, 0x69, 0x76, 0x4c, 0x28, 0x4a, 0xf0, 0x4d, 0x57, 0x81, 0xc9, 0x0b, 0x96, 0x7d, + 0x11, 0xfb, 0xf0, 0xc2, 0x77, 0x92, 0x98, 0x56, 0x7e, 0x74, 0x00, 0xc6, 0x00, 0x7b, 0x99, 0xb8, + 0xd3, 0x96, 0x4f, 0x6d, 0x6e, 0x60, 0x04, 0x80, 0x6b, 0xc0, 0xd4, 0x25, 0x3f, 0x77, 0xd8, 0xd2, + 0x99, 0x24, 0xf8, 0x07, 0x62, 0x6e, 0x58, 0x83, 0x8b, 0x4c, 0x7f, 0x3d, 0xff, 0x0d, 0x12, 0xc8, + 0x2f, 0x21, 0xb7, 0xd4, 0xe9, 0xb0, 0x72, 0x7b, 0xa1, 0xf0, 0xa9, 0x4e, 0xae, 0x12, 0xa5, 0x4e, + 0x27, 0xba, 0x51, 0x31, 0x02, 0xf2, 0x4f, 0x1f, 0x71, 0x69, 0x82, 0x3e, 0xd3, 0x03, 0x0a, 0x4c, + 0x5f, 0x62, 0x1f, 0x08, 0x1d, 0xa5, 0x1f, 0x62, 0xcc, 0xa4, 0x5b, 0xc2, 0x78, 0x66, 0x99, 0x78, + 0x97, 0x25, 0x3f, 0x9f, 0x72, 0x2f, 0x98, 0xd8, 0x75, 0x50, 0x59, 0x77, 0xfc, 0xa1, 0x8d, 0xaf, + 0x69, 0x6d, 0xe3, 0x7e, 0xd4, 0x72, 0xe7, 0x2a, 0x3b, 0xde, 0xc4, 0x67, 0x9d, 0x64, 0x0c, 0x42, + 0x84, 0xd1, 0x77, 0xcd, 0xa7, 0xe0, 0x4d, 0x3b, 0x2f, 0x19, 0xee, 0x76, 0x79, 0x5b, 0x77, 0xe9, + 0x36, 0x4a, 0xf0, 0x0e, 0x9f, 0x3b, 0x04, 0x9c, 0xb1, 0x4e, 0x36, 0x91, 0x87, 0xc3, 0x13, 0x83, + 0x38, 0x02, 0xcf, 0x98, 0x61, 0x40, 0xfc, 0x67, 0x09, 0x64, 0x6b, 0x5d, 0x64, 0x0a, 0x9f, 0x84, + 0x0c, 0x64, 0x2b, 0xf5, 0xc8, 0xf6, 0x15, 0xe2, 0x4e, 0xba, 0x41, 0xa5, 0xbd, 0x92, 0x23, 0x24, + 0x7b, 0x33, 0xc8, 0x1a, 0xe6, 0xa6, 0x45, 0x2d, 0xdb, 0x2b, 0x23, 0x6c, 0x9d, 0x8a, 0xb9, 0x69, + 0x69, 0x38, 0xa3, 0xa8, 0x7f, 0x6e, 0x5c, 0xd9, 0xe9, 0x8b, 0xfb, 0x9b, 0x05, 0x90, 0x27, 0xea, + 0x0c, 0x9f, 0x2f, 0x03, 0xb9, 0xd4, 0x6e, 0x47, 0x08, 0x5e, 0x3a, 0x20, 0x78, 0x0b, 0xff, 0x16, + 0x60, 0x12, 0xbc, 0xf3, 0x81, 0xac, 0x04, 0xfb, 0x76, 0xda, 0xa4, 0x4a, 0xed, 0x76, 0xf4, 0x29, + 0x82, 0xa0, 0x40, 0x89, 0x2f, 0x90, 0x6d, 0xe1, 0xb2, 0x58, 0x0b, 0x4f, 0x3c, 0x10, 0x44, 0xf2, + 0x97, 0x3e, 0x44, 0xff, 0x22, 0x81, 0x89, 0x15, 0xc3, 0x71, 0x3d, 0x6c, 0x4a, 0x22, 0xd8, 0x5c, + 0x05, 0x26, 0x7d, 0xd1, 0x78, 0x5d, 0x9e, 0xd7, 0x9f, 0x87, 0x09, 0xfc, 0x4c, 0xfc, 0x1e, 0x1e, + 0x9d, 0xc7, 0xc7, 0xd7, 0x9e, 0x72, 0x11, 0x7d, 0xc2, 0x2c, 0x2c, 0x56, 0xea, 0x2d, 0xf6, 0x8f, + 0x02, 0x81, 0xaf, 0x72, 0x02, 0xbf, 0x6d, 0x98, 0x22, 0xd3, 0x17, 0xfa, 0x67, 0x25, 0x00, 0xbc, + 0xb2, 0xe9, 0x31, 0xde, 0x47, 0x71, 0xc1, 0x39, 0x62, 0xa4, 0xfb, 0x12, 0x56, 0xba, 0xab, 0xbc, + 0x74, 0x7f, 0x72, 0x70, 0x55, 0xe3, 0x8e, 0xeb, 0x2a, 0x45, 0x20, 0x1b, 0x81, 0x68, 0xbd, 0x47, + 0xf8, 0x86, 0x40, 0xa8, 0x6b, 0x9c, 0x50, 0xef, 0x18, 0xb2, 0xa4, 0xf4, 0xe5, 0xfa, 0x37, 0x12, + 0x98, 0xa8, 0x23, 0xd7, 0xeb, 0x26, 0xe1, 0x79, 0x91, 0x1e, 0x9e, 0x69, 0xdb, 0x92, 0x60, 0xdb, + 0xfe, 0x6e, 0x46, 0x34, 0xc8, 0x57, 0x28, 0x19, 0xca, 0x53, 0xc4, 0xea, 0xc3, 0x43, 0x42, 0x41, + 0xbe, 0x06, 0x51, 0x4b, 0x5f, 0xba, 0xaf, 0x93, 0x02, 0x1f, 0x10, 0xfe, 0x94, 0x1d, 0x6b, 0x16, + 0x67, 0x0e, 0x9a, 0xc5, 0xe2, 0xa7, 0xec, 0xd8, 0x3a, 0x46, 0x3b, 0x26, 0x24, 0x36, 0x36, 0x46, + 0xe0, 0x33, 0x30, 0x8c, 0xbc, 0x9e, 0x21, 0x83, 0x3c, 0xdd, 0x3c, 0xb8, 0x2b, 0x7e, 0xef, 0x60, + 0xf0, 0xd4, 0xe2, 0x1d, 0x43, 0x98, 0x72, 0x71, 0xcb, 0xf2, 0x01, 0x1b, 0x12, 0xc3, 0xc6, 0x4d, + 0x20, 0x87, 0xa3, 0x10, 0xd3, 0x71, 0x2e, 0x74, 0xf7, 0xf0, 0x49, 0xa8, 0xde, 0x57, 0x8d, 0x64, + 0x4a, 0x8c, 0xc2, 0x08, 0x56, 0xf2, 0x87, 0x41, 0xe1, 0x1b, 0x0a, 0x00, 0x6b, 0xbb, 0x1b, 0x1d, + 0xc3, 0xd9, 0x36, 0x4c, 0xec, 0xfd, 0x35, 0x4d, 0x5f, 0x49, 0x30, 0xdd, 0x58, 0xf3, 0x2f, 0xd2, + 0x28, 0x28, 0x02, 0x79, 0xd7, 0x36, 0xe8, 0x32, 0x80, 0xf7, 0xa8, 0xdc, 0x19, 0x78, 0x48, 0x66, + 0x7b, 0xc2, 0xa8, 0x78, 0x62, 0x08, 0x39, 0x98, 0x63, 0x4a, 0x0f, 0x3d, 0x25, 0xd9, 0x88, 0xc9, + 0x39, 0x3e, 0x62, 0x32, 0x77, 0xb6, 0x3a, 0xdf, 0x73, 0xb6, 0xda, 0xc3, 0xd1, 0x31, 0x9e, 0x86, + 0xb0, 0x53, 0x91, 0xac, 0xe1, 0x67, 0xef, 0x8f, 0xfb, 0x2d, 0xc3, 0xc4, 0x9b, 0x3a, 0xd4, 0x83, + 0x3f, 0x4c, 0x60, 0xfb, 0xbc, 0x49, 0xc1, 0x3e, 0xef, 0xfd, 0xe1, 0xdc, 0xc7, 0x12, 0x34, 0x9c, + 0x13, 0x48, 0x8e, 0x63, 0x37, 0xdb, 0xc3, 0x2e, 0xfc, 0x90, 0x70, 0x50, 0x45, 0x46, 0xc6, 0xb1, + 0xb3, 0x18, 0xca, 0x81, 0x14, 0x70, 0xc0, 0xec, 0x01, 0xc7, 0xf5, 0xc0, 0x83, 0xe8, 0x27, 0xd3, + 0xe5, 0x9d, 0x21, 0xd6, 0x6b, 0x14, 0x30, 0xeb, 0x1f, 0x52, 0xaf, 0xcd, 0xdf, 0xa3, 0x96, 0x1b, + 0x45, 0x74, 0xf0, 0xe0, 0x3a, 0x3e, 0xa2, 0x4e, 0x8e, 0xa3, 0x87, 0x6b, 0x32, 0xf0, 0xbf, 0x4b, + 0x20, 0x4f, 0xcd, 0x8d, 0xbb, 0x0e, 0x09, 0x21, 0x7c, 0xe9, 0x30, 0x90, 0xc4, 0xc6, 0x0a, 0xf9, + 0x44, 0x52, 0x00, 0x46, 0x60, 0x60, 0xdc, 0x97, 0x1a, 0x00, 0xf0, 0xdf, 0x24, 0x90, 0xf5, 0xcc, + 0x20, 0xb1, 0x48, 0x0c, 0x1f, 0x17, 0x76, 0xe3, 0x65, 0x04, 0xe0, 0x91, 0x8f, 0xd0, 0xef, 0x79, + 0x30, 0xd9, 0x25, 0x19, 0x83, 0x38, 0x20, 0xd7, 0x09, 0x74, 0x46, 0x48, 0x0b, 0x7f, 0x83, 0x6f, + 0x17, 0x72, 0x05, 0x8e, 0xe7, 0x27, 0x19, 0x1c, 0xea, 0x28, 0x82, 0x36, 0x6c, 0xc2, 0xef, 0x4b, + 0x00, 0x68, 0xc8, 0xb1, 0x3a, 0x7b, 0x68, 0xdd, 0x36, 0xe0, 0x95, 0x21, 0x00, 0xb4, 0xd9, 0x67, + 0xc2, 0x66, 0xff, 0x29, 0x49, 0xd4, 0xad, 0x97, 0xd3, 0x3c, 0x9f, 0x78, 0x84, 0xf8, 0x9f, 0x0c, + 0x26, 0xa8, 0x1c, 0xa9, 0x4d, 0x29, 0x26, 0x7c, 0xff, 0x27, 0xf8, 0x2e, 0x21, 0xb7, 0x60, 0x11, + 0x8e, 0x92, 0x01, 0x50, 0x1e, 0x02, 0x80, 0xe3, 0x60, 0xca, 0x07, 0x60, 0x5d, 0xab, 0x14, 0x11, + 0x7c, 0x8b, 0x8c, 0x3d, 0x2c, 0xc8, 0xe0, 0x76, 0xf8, 0x9e, 0xe6, 0x6b, 0xc2, 0x93, 0x7d, 0x46, + 0x1e, 0x41, 0xf9, 0x29, 0x01, 0xf4, 0x17, 0x42, 0xb3, 0x7b, 0x01, 0x86, 0x1e, 0x2e, 0xfd, 0xd5, + 0x39, 0x15, 0xcc, 0x70, 0x56, 0x89, 0x72, 0x06, 0x9c, 0xe4, 0x12, 0xc8, 0x78, 0xd7, 0x2e, 0x1e, + 0x53, 0x20, 0x38, 0xcd, 0x7d, 0xa1, 0x2f, 0xa8, 0x5d, 0xcc, 0xc0, 0x37, 0x7e, 0x2e, 0x13, 0xac, + 0xf7, 0xbc, 0x23, 0x4b, 0x57, 0xda, 0x3e, 0xc2, 0x87, 0x9e, 0x6c, 0x59, 0xa6, 0x8b, 0x1e, 0x60, + 0xdc, 0x54, 0x82, 0x84, 0x58, 0xab, 0xe1, 0x0c, 0x98, 0x70, 0x6d, 0xd6, 0x75, 0xc5, 0x7f, 0x65, + 0x15, 0x2b, 0xc7, 0x2b, 0x56, 0x15, 0x9c, 0x33, 0xcc, 0x56, 0x67, 0xb7, 0x8d, 0x34, 0xd4, 0xd1, + 0x3d, 0x19, 0x3a, 0x25, 0x67, 0x01, 0x75, 0x91, 0xd9, 0x46, 0xa6, 0x4b, 0xf8, 0xf4, 0x4f, 0xa1, + 0x0a, 0xe4, 0xe4, 0x95, 0xf1, 0x4e, 0x5e, 0x19, 0x1f, 0xd5, 0x6f, 0x09, 0x37, 0x66, 0xbd, 0xef, + 0x36, 0x00, 0x48, 0xdd, 0xce, 0x1b, 0xe8, 0x12, 0x55, 0xc3, 0x2b, 0x7a, 0x56, 0xfd, 0x6a, 0x41, + 0x06, 0x8d, 0xc9, 0x0c, 0xbf, 0x14, 0xa8, 0xdf, 0xdd, 0x9c, 0xfa, 0xdd, 0x24, 0xc8, 0x42, 0x32, + 0xad, 0xeb, 0x0e, 0xa1, 0x75, 0x33, 0x60, 0x32, 0xdc, 0x4d, 0x96, 0x95, 0x2b, 0xc0, 0x29, 0xdf, + 0xc3, 0xb8, 0xaa, 0xaa, 0x0b, 0xf5, 0xe6, 0xfa, 0xda, 0x92, 0x56, 0x5a, 0x50, 0x8b, 0xc0, 0xd3, + 0x4f, 0xa2, 0x97, 0x81, 0x63, 0x70, 0x16, 0xfe, 0xb5, 0x04, 0x72, 0xf8, 0x08, 0x35, 0xfc, 0xd9, + 0x11, 0x69, 0x8e, 0xc3, 0x39, 0x3d, 0x05, 0xe3, 0xae, 0xf8, 0x95, 0x10, 0x54, 0x98, 0x98, 0xab, + 0x43, 0x5d, 0x09, 0x11, 0x43, 0x28, 0xfd, 0x99, 0x90, 0xd7, 0x24, 0xeb, 0xdb, 0xd6, 0xa5, 0x1f, + 0xe5, 0x26, 0xe9, 0xd5, 0xff, 0x88, 0x9b, 0x64, 0x1f, 0x16, 0xc6, 0xde, 0x24, 0xfb, 0xb4, 0xbb, + 0x98, 0x66, 0x0a, 0x9f, 0x9e, 0x0b, 0xe6, 0x7f, 0xcf, 0x94, 0x0e, 0xb5, 0xf7, 0x55, 0x02, 0x33, + 0x86, 0xe9, 0x22, 0xdb, 0xd4, 0x3b, 0x8b, 0x1d, 0x7d, 0xcb, 0xb7, 0x4f, 0x7b, 0x37, 0x3c, 0x2a, + 0x4c, 0x1e, 0x8d, 0xff, 0x43, 0x39, 0x0b, 0x80, 0x8b, 0x76, 0xba, 0x1d, 0xdd, 0x0d, 0x55, 0x8f, + 0x49, 0x61, 0xb5, 0x2f, 0xcb, 0x6b, 0xdf, 0x63, 0xc1, 0x65, 0x04, 0xb4, 0xc6, 0x7e, 0x17, 0xad, + 0x9b, 0xc6, 0x53, 0x77, 0x71, 0xa4, 0x62, 0xa2, 0xa3, 0xfd, 0x3e, 0x71, 0x3b, 0x40, 0xf9, 0x9e, + 0x1d, 0xa0, 0x7f, 0x16, 0x8e, 0x63, 0xe4, 0xb7, 0xfa, 0x01, 0x71, 0x8c, 0x82, 0x96, 0x26, 0xf7, + 0xb4, 0xb4, 0x60, 0x5d, 0x26, 0x2b, 0xb0, 0x2e, 0xc3, 0xa2, 0x92, 0x13, 0x9c, 0xdf, 0xbf, 0x5c, + 0x28, 0x50, 0x52, 0x5c, 0x35, 0xd2, 0xef, 0xbd, 0xbe, 0x23, 0x83, 0x59, 0x52, 0xf4, 0xbc, 0x65, + 0x5d, 0xdc, 0xd1, 0xed, 0x8b, 0xf0, 0x37, 0x0e, 0xb7, 0x0f, 0x1b, 0xbb, 0xff, 0x14, 0xb5, 0xa9, + 0xda, 0xa3, 0x7e, 0xd9, 0x5e, 0xf5, 0x83, 0x9f, 0x14, 0x9e, 0x54, 0x70, 0xf2, 0xf4, 0x2b, 0x35, + 0x9e, 0x0d, 0x2a, 0xb1, 0xa3, 0x87, 0x22, 0x0c, 0xa6, 0x0f, 0xfc, 0x9f, 0x05, 0xc0, 0xfb, 0x23, + 0x01, 0xbb, 0xb6, 0x3f, 0x4a, 0xdc, 0xe1, 0x97, 0x87, 0xc3, 0xce, 0xe7, 0x6b, 0x08, 0xec, 0x8a, + 0x40, 0xbe, 0x18, 0xb8, 0x13, 0x79, 0x8f, 0x6c, 0x85, 0xb2, 0xe9, 0xa1, 0x19, 0xc1, 0xf2, 0x58, + 0xd0, 0x3c, 0xc9, 0xb3, 0x50, 0xeb, 0xa6, 0x8a, 0xe9, 0x17, 0x85, 0xf7, 0xcc, 0xfa, 0x0a, 0x88, + 0x70, 0x37, 0x9e, 0x56, 0x29, 0xb6, 0xe1, 0x26, 0xce, 0x66, 0xfa, 0x68, 0x3e, 0x27, 0x07, 0x26, + 0xfd, 0x78, 0x52, 0xf8, 0x8e, 0xb5, 0x00, 0xc3, 0xd3, 0x20, 0xef, 0x58, 0xbb, 0x76, 0x0b, 0xd1, + 0x5d, 0x4c, 0xfa, 0x36, 0xc4, 0x8e, 0xdb, 0xc0, 0x01, 0xff, 0x80, 0x4d, 0x91, 0x4d, 0x6c, 0x53, + 0x44, 0x5b, 0xac, 0x71, 0x16, 0xc0, 0x73, 0x85, 0x2f, 0xc6, 0xe0, 0x30, 0xab, 0x23, 0xf7, 0xe1, + 0x68, 0x04, 0xfc, 0x89, 0xd0, 0x7e, 0xce, 0x80, 0x9a, 0x24, 0x53, 0xb9, 0xda, 0x10, 0x96, 0xec, + 0x95, 0xe0, 0x72, 0x3f, 0x07, 0x35, 0x61, 0xb1, 0xc9, 0xba, 0xae, 0xad, 0x14, 0x65, 0xf8, 0x8c, + 0x2c, 0x28, 0x12, 0xd6, 0x6a, 0x81, 0x35, 0x07, 0x5f, 0x98, 0x39, 0x6a, 0x93, 0x35, 0x7a, 0x0e, + 0xfa, 0x69, 0x49, 0x34, 0xf8, 0x36, 0x27, 0xf8, 0xb0, 0x76, 0x11, 0x9a, 0x34, 0x44, 0x33, 0x8b, + 0x51, 0x3e, 0xf8, 0x87, 0x19, 0x91, 0x58, 0xde, 0x62, 0x2c, 0xa6, 0xdf, 0x2b, 0x7d, 0x37, 0xeb, + 0x87, 0x05, 0x5c, 0xb4, 0xad, 0x9d, 0x75, 0xbb, 0x03, 0xff, 0x97, 0xd0, 0x55, 0x09, 0x11, 0xf3, + 0x03, 0x29, 0x7a, 0x7e, 0x80, 0xd7, 0x94, 0x3b, 0xe1, 0x66, 0x56, 0x67, 0x88, 0xe1, 0x5b, 0xb9, + 0x1e, 0xcc, 0xea, 0xed, 0xf6, 0x9a, 0xbe, 0x85, 0xca, 0xde, 0xc4, 0xdb, 0x74, 0x69, 0xc8, 0xb0, + 0x9e, 0xd4, 0xb8, 0xae, 0xa8, 0xa7, 0x8f, 0x9c, 0x38, 0x60, 0x95, 0x8a, 0x2f, 0xa4, 0x72, 0x20, + 0x52, 0xf9, 0x8d, 0x65, 0xf8, 0xf3, 0x86, 0x8c, 0xd6, 0xb6, 0x1e, 0x06, 0x38, 0xa4, 0x6f, 0x82, + 0xde, 0x54, 0x02, 0x7c, 0xa7, 0xaf, 0x79, 0x7f, 0x2c, 0x81, 0x09, 0x0f, 0x8f, 0x52, 0xbb, 0x0d, + 0x1f, 0xc9, 0xc5, 0x01, 0x8d, 0xf4, 0x67, 0xfb, 0x65, 0x61, 0x47, 0x42, 0xbf, 0x86, 0x84, 0x7e, + 0x04, 0x26, 0xa1, 0x10, 0x25, 0x4e, 0x88, 0x62, 0xfe, 0x82, 0xb1, 0x45, 0xa4, 0x2f, 0xbe, 0x8f, + 0x4b, 0x60, 0xc6, 0x9f, 0x67, 0x2c, 0x22, 0xb7, 0xb5, 0x0d, 0x6f, 0x13, 0x5d, 0xa9, 0xa2, 0x2d, + 0x31, 0xd8, 0xd4, 0xed, 0xc0, 0x1f, 0x64, 0x12, 0xaa, 0x3c, 0x57, 0x72, 0xc4, 0x32, 0x5f, 0x22, + 0x5d, 0x8c, 0x23, 0x98, 0xbe, 0x30, 0xbf, 0x24, 0x01, 0xd0, 0xb0, 0x82, 0xc9, 0xf2, 0x21, 0x24, + 0xf9, 0x9b, 0xc2, 0xfb, 0xbd, 0xb4, 0xe2, 0x61, 0xb1, 0xc9, 0x7b, 0x0e, 0x41, 0x77, 0xa8, 0x41, + 0x25, 0x8d, 0xa5, 0xad, 0x4f, 0x2e, 0xec, 0x76, 0x3b, 0x46, 0x4b, 0x77, 0x7b, 0x7d, 0xf8, 0xa2, + 0xc5, 0x8b, 0x2f, 0x28, 0x4e, 0x64, 0x34, 0x06, 0x65, 0x44, 0xc8, 0x92, 0xc4, 0xe0, 0x91, 0xfc, + 0x18, 0x3c, 0x82, 0x7e, 0x39, 0x03, 0x88, 0x8f, 0x41, 0x3d, 0x65, 0x70, 0xbc, 0xd6, 0x45, 0xe6, + 0xbc, 0x8d, 0xf4, 0x76, 0xcb, 0xde, 0xdd, 0xd9, 0x70, 0x58, 0x07, 0xd4, 0x78, 0x1d, 0x65, 0xd6, + 0x9e, 0x25, 0x6e, 0xed, 0x19, 0xfe, 0x92, 0x2c, 0x1a, 0xff, 0x8c, 0xd9, 0x21, 0x61, 0x78, 0x18, + 0x62, 0xa8, 0x4b, 0xe4, 0x36, 0xd5, 0xb3, 0xcc, 0x9c, 0x4d, 0xb2, 0xcc, 0xfc, 0x5a, 0xa1, 0x68, + 0x6a, 0x42, 0xf5, 0x1a, 0x8b, 0xf7, 0xdb, 0x6c, 0x1d, 0xb9, 0x11, 0xf0, 0x5e, 0x07, 0x66, 0x36, + 0xc2, 0x2f, 0x01, 0xc4, 0x7c, 0x62, 0x1f, 0x9f, 0xd4, 0xd7, 0x25, 0x5d, 0xa1, 0xe1, 0x59, 0x88, + 0x40, 0x37, 0x40, 0x50, 0x12, 0x71, 0x7c, 0x4b, 0xb4, 0xdc, 0x12, 0x5b, 0x7e, 0xfa, 0x28, 0x7c, + 0x48, 0x02, 0x53, 0xf8, 0xda, 0xe5, 0xf9, 0x7d, 0x7c, 0x14, 0x53, 0xd0, 0x28, 0x79, 0x0e, 0x2b, + 0x66, 0x05, 0x64, 0x3b, 0x86, 0x79, 0xd1, 0xf7, 0x58, 0xf4, 0x9e, 0xc3, 0x4b, 0x3c, 0xa5, 0x3e, + 0x97, 0x78, 0x06, 0x1b, 0x1d, 0x41, 0xb9, 0x87, 0xba, 0x55, 0x7e, 0x20, 0xb9, 0xf4, 0xc5, 0xf8, + 0x8f, 0x59, 0x90, 0xaf, 0x23, 0xdd, 0x6e, 0x6d, 0xc3, 0x77, 0x48, 0x7d, 0xa7, 0x12, 0x05, 0x7e, + 0x2a, 0xb1, 0x08, 0x26, 0x36, 0x8d, 0x8e, 0x8b, 0x6c, 0xe2, 0xc5, 0xcd, 0x76, 0xed, 0xa4, 0x89, + 0xcf, 0x77, 0xac, 0xd6, 0xc5, 0x39, 0x6a, 0xda, 0xcf, 0xf9, 0xf1, 0x97, 0xe7, 0x16, 0xf1, 0x4f, + 0x9a, 0xff, 0xb3, 0x67, 0x10, 0x3a, 0x96, 0xed, 0x46, 0xdd, 0xe7, 0x13, 0x41, 0xa5, 0x6e, 0xd9, + 0xae, 0x46, 0x7e, 0xf4, 0x60, 0xde, 0xdc, 0xed, 0x74, 0x1a, 0xe8, 0x01, 0xd7, 0x9f, 0xd6, 0xf9, + 0xef, 0x9e, 0xb1, 0x68, 0x6d, 0x6e, 0x3a, 0x88, 0x2c, 0x2a, 0xe4, 0x34, 0xfa, 0xa6, 0x9c, 0x04, + 0xb9, 0x8e, 0xb1, 0x63, 0x90, 0x89, 0x48, 0x4e, 0x23, 0x2f, 0xca, 0x8d, 0xa0, 0x18, 0xce, 0x81, + 0x08, 0xa3, 0x67, 0xf2, 0xb8, 0x69, 0x1e, 0x48, 0xf7, 0x74, 0xe6, 0x22, 0xda, 0x77, 0xce, 0x4c, + 0xe0, 0xef, 0xf8, 0x99, 0x3f, 0x32, 0x23, 0xb2, 0x61, 0x42, 0x24, 0x1e, 0x3d, 0xc3, 0xb5, 0x51, + 0xcb, 0xb2, 0xdb, 0xbe, 0x6c, 0xa2, 0x27, 0x18, 0x34, 0x5f, 0xb2, 0x6d, 0x8e, 0xbe, 0x85, 0xa7, + 0xaf, 0x69, 0x6f, 0xcd, 0x7b, 0xdd, 0xa6, 0x57, 0xf4, 0x05, 0xc3, 0xdd, 0x5e, 0x45, 0xae, 0x0e, + 0xff, 0x51, 0xee, 0xab, 0x71, 0x53, 0xff, 0x5b, 0xe3, 0x06, 0x68, 0x1c, 0x89, 0xda, 0xe5, 0xee, + 0xda, 0xa6, 0x27, 0x47, 0xea, 0x09, 0xcb, 0xa4, 0x28, 0x77, 0x80, 0x2b, 0xc2, 0x37, 0x7f, 0x29, + 0x75, 0x81, 0x71, 0x8e, 0x2d, 0x68, 0xd1, 0x19, 0x94, 0x35, 0x70, 0x2d, 0xf9, 0xb8, 0xdc, 0x58, + 0x5d, 0x59, 0x36, 0xb6, 0xb6, 0x3b, 0xc6, 0xd6, 0xb6, 0xeb, 0x54, 0x4c, 0xc7, 0x45, 0x7a, 0xbb, + 0xb6, 0xa9, 0x91, 0x9b, 0xb8, 0x00, 0xa6, 0x23, 0x92, 0x95, 0xf7, 0xf2, 0x16, 0x1b, 0xdd, 0x58, + 0x4d, 0x89, 0x68, 0x29, 0x4f, 0xf0, 0x5a, 0x8a, 0xb3, 0xdb, 0x09, 0x30, 0xbd, 0xaa, 0x07, 0xd3, + 0x50, 0xd5, 0x77, 0x3b, 0xb8, 0xb9, 0xe0, 0xcc, 0x49, 0xc7, 0xb9, 0x18, 0x4e, 0xd2, 0x6f, 0x36, + 0xff, 0x2b, 0x0f, 0x72, 0x4b, 0xb6, 0xde, 0xdd, 0x86, 0xcf, 0x60, 0xfa, 0xe7, 0x51, 0xb5, 0x89, + 0x40, 0x3b, 0xa5, 0x41, 0xda, 0x29, 0x0f, 0xd0, 0xce, 0x2c, 0xa3, 0x9d, 0xd1, 0x8b, 0xce, 0xe7, + 0xc0, 0x74, 0xcb, 0xea, 0x74, 0x50, 0xcb, 0x93, 0x47, 0xa5, 0x8d, 0x57, 0x7b, 0x26, 0x35, 0x2e, + 0x0d, 0xc7, 0xa8, 0x47, 0x6e, 0x9d, 0xac, 0xb1, 0x13, 0xa5, 0x0f, 0x13, 0xe0, 0x0b, 0x25, 0x90, + 0x55, 0xdb, 0x5b, 0x88, 0x5b, 0x87, 0xcf, 0x30, 0xeb, 0xf0, 0xa7, 0x41, 0xde, 0xd5, 0xed, 0x2d, + 0xe4, 0xfa, 0xeb, 0x04, 0xe4, 0x2d, 0x08, 0x9d, 0x2f, 0x33, 0xa1, 0xf3, 0x7f, 0x12, 0x64, 0x3d, + 0x99, 0x51, 0xc7, 0xf6, 0x6b, 0xfb, 0xc1, 0x8f, 0x65, 0x3f, 0xe7, 0x95, 0x38, 0xe7, 0xd5, 0x5a, + 0xc3, 0x3f, 0xf4, 0x62, 0x9d, 0x3b, 0x80, 0x35, 0xbe, 0x54, 0xb8, 0x65, 0x99, 0x95, 0x1d, 0x7d, + 0x0b, 0xd1, 0x6a, 0x86, 0x09, 0xfe, 0x57, 0x75, 0xc7, 0xba, 0xdf, 0xa0, 0x8b, 0x5a, 0x61, 0x82, + 0x57, 0x85, 0x6d, 0xa3, 0xdd, 0x46, 0x26, 0x6d, 0xd9, 0xf4, 0xed, 0xdc, 0x59, 0x90, 0xf5, 0x78, + 0xf0, 0xf4, 0xc7, 0x33, 0x16, 0x8a, 0xc7, 0x94, 0x69, 0xaf, 0x59, 0x91, 0xc6, 0x5b, 0xcc, 0xf0, + 0x6b, 0xae, 0x22, 0x7e, 0x3f, 0xa4, 0x72, 0xfd, 0x1b, 0xd7, 0x63, 0x40, 0xce, 0xb4, 0xda, 0x68, + 0xe0, 0x20, 0x44, 0x72, 0x29, 0x8f, 0x07, 0x39, 0xd4, 0xf6, 0x7a, 0x05, 0x19, 0x67, 0x3f, 0x1b, + 0x2f, 0x4b, 0x8d, 0x64, 0x4e, 0xe6, 0x5c, 0xd4, 0x8f, 0xdb, 0xf4, 0x1b, 0xe0, 0xaf, 0x4e, 0x80, + 0xe3, 0xa4, 0x0f, 0xa8, 0xef, 0x6e, 0x78, 0xa4, 0x36, 0x10, 0x7c, 0xa8, 0xff, 0xc0, 0x75, 0x9c, + 0x57, 0xf6, 0x93, 0x20, 0xe7, 0xec, 0x6e, 0x04, 0x46, 0x28, 0x79, 0x61, 0x9b, 0xae, 0x34, 0x92, + 0xe1, 0x4c, 0x1e, 0x76, 0x38, 0xe3, 0x86, 0x26, 0xd9, 0x6f, 0xfc, 0xe1, 0x40, 0x46, 0x8e, 0x64, + 0xf8, 0x03, 0x59, 0xbf, 0x61, 0xe8, 0x0c, 0x98, 0xd0, 0x37, 0x5d, 0x64, 0x87, 0x66, 0x22, 0x7d, + 0xf5, 0x86, 0xca, 0x0d, 0xb4, 0x69, 0xd9, 0x9e, 0x58, 0xc8, 0xcd, 0x09, 0xc1, 0x3b, 0xd3, 0x72, + 0x01, 0xb7, 0x83, 0x76, 0x13, 0x38, 0x61, 0x5a, 0x0b, 0xa8, 0x4b, 0xe5, 0x4c, 0x50, 0x9c, 0xc1, + 0x2d, 0xe0, 0xe0, 0x87, 0x03, 0x5d, 0xc9, 0xec, 0xc1, 0xae, 0x04, 0x7e, 0x2a, 0xe9, 0x9c, 0xb9, + 0x07, 0xe8, 0x91, 0x59, 0x68, 0xca, 0x93, 0xc0, 0x74, 0x9b, 0xfa, 0x78, 0xb5, 0x8c, 0xa0, 0x95, + 0x44, 0xfe, 0xc7, 0x65, 0x0e, 0x15, 0x29, 0xcb, 0x2a, 0xd2, 0x12, 0x28, 0xe0, 0xc3, 0xd3, 0x9e, + 0x26, 0xe5, 0x7a, 0x7c, 0xea, 0xf1, 0xb4, 0x2e, 0xa8, 0x14, 0x23, 0xb6, 0xb9, 0x32, 0xfd, 0x45, + 0x0b, 0x7e, 0x4e, 0x36, 0xfb, 0x8e, 0x97, 0x50, 0xfa, 0xcd, 0xf1, 0x8f, 0xf2, 0xe0, 0x8a, 0xb2, + 0x6d, 0x39, 0x0e, 0x3e, 0x44, 0xd3, 0xdb, 0x30, 0x5f, 0x2d, 0x71, 0x97, 0xe8, 0x3c, 0xac, 0x9b, + 0x5f, 0xbf, 0x06, 0x35, 0xbe, 0xa6, 0xf1, 0x35, 0xe1, 0xb0, 0x33, 0xc1, 0xfe, 0x43, 0x84, 0xd0, + 0x7f, 0x34, 0x1a, 0xc9, 0x5b, 0x33, 0x22, 0x91, 0x70, 0x12, 0xca, 0x6a, 0x0c, 0xb7, 0x26, 0x49, + 0xe0, 0xca, 0x5e, 0x6e, 0xd6, 0x4d, 0x27, 0x68, 0x30, 0x57, 0x0f, 0x68, 0x2f, 0x7c, 0xe4, 0x94, + 0xd8, 0x3b, 0x73, 0x23, 0xea, 0xce, 0x94, 0x16, 0xb1, 0x58, 0x12, 0x1e, 0xc9, 0x89, 0xbb, 0x33, + 0x37, 0x31, 0xf9, 0xf4, 0x85, 0xfb, 0xe9, 0x2c, 0x38, 0xbe, 0x64, 0x5b, 0xbb, 0x5d, 0x27, 0xec, + 0x81, 0xfe, 0xae, 0xff, 0x86, 0x6c, 0x5e, 0xc4, 0x34, 0xb8, 0x06, 0x4c, 0xd9, 0xd4, 0x9a, 0x0b, + 0xb7, 0x67, 0xd9, 0x24, 0xb6, 0xf7, 0x92, 0x0f, 0xd3, 0x7b, 0x85, 0xfd, 0x4c, 0x96, 0xeb, 0x67, + 0x7a, 0x7b, 0x8e, 0x5c, 0x9f, 0x9e, 0xe3, 0x6f, 0xa5, 0x84, 0x83, 0x6a, 0x8f, 0x88, 0x22, 0xfa, + 0x8b, 0x32, 0xc8, 0x6f, 0xe1, 0x8c, 0xb4, 0xbb, 0x78, 0xb4, 0x58, 0xcd, 0x30, 0x71, 0x8d, 0xfe, + 0x1a, 0xca, 0x55, 0x66, 0x75, 0x38, 0xd1, 0x00, 0x17, 0xcf, 0x6d, 0xfa, 0x4a, 0xf5, 0x8a, 0x2c, + 0x98, 0x0e, 0x4a, 0xaf, 0xb4, 0x1d, 0x2e, 0x3e, 0x2b, 0xa3, 0x51, 0x33, 0x22, 0x1a, 0x75, 0x60, + 0x9d, 0x39, 0x18, 0x75, 0x64, 0x66, 0xd4, 0xe9, 0x3b, 0xba, 0x4c, 0x47, 0x8c, 0x2e, 0xf0, 0xe9, + 0xb2, 0xe8, 0x35, 0x74, 0x7c, 0xd7, 0x8a, 0x6b, 0xf3, 0x70, 0x1e, 0x2c, 0x04, 0x2f, 0xc3, 0x1b, + 0x5c, 0xab, 0xf4, 0x95, 0xe4, 0xbd, 0x12, 0x38, 0x71, 0xb0, 0x33, 0xff, 0x31, 0xde, 0x4b, 0xcd, + 0xab, 0x93, 0x13, 0x78, 0xa9, 0xe1, 0x37, 0x7e, 0x93, 0x2e, 0x36, 0x8c, 0x09, 0x67, 0xef, 0x0d, + 0xee, 0xc4, 0xc5, 0x02, 0x95, 0x08, 0x12, 0x4d, 0x5f, 0x80, 0xbf, 0x25, 0x83, 0xc9, 0x3a, 0x72, + 0x57, 0xf4, 0x7d, 0x6b, 0xd7, 0x85, 0xba, 0xe8, 0xf6, 0xdc, 0x13, 0x41, 0xbe, 0x83, 0x7f, 0xc1, + 0x1d, 0x0c, 0x1b, 0x36, 0x94, 0xdd, 0xdf, 0xc2, 0xbe, 0x41, 0x84, 0xb4, 0x46, 0xf3, 0xf3, 0xf1, + 0x63, 0x44, 0x76, 0x47, 0x03, 0xee, 0x46, 0xb2, 0xb5, 0x93, 0x68, 0xef, 0x34, 0xaa, 0xe8, 0xf4, + 0x61, 0xf9, 0x25, 0x19, 0xcc, 0xd4, 0x91, 0x5b, 0x71, 0x16, 0xf5, 0x3d, 0xcb, 0x36, 0x5c, 0x04, + 0x97, 0x44, 0xa1, 0x39, 0x0b, 0x80, 0x11, 0xfc, 0x46, 0xa3, 0x5a, 0x31, 0x29, 0xf0, 0x0f, 0x93, + 0x3a, 0x0a, 0x71, 0x7c, 0x8c, 0x04, 0x84, 0x44, 0x3e, 0x16, 0x71, 0xc5, 0x8f, 0xe1, 0x22, 0x6d, + 0x89, 0x02, 0x51, 0xb2, 0x5b, 0xdb, 0xc6, 0x1e, 0x6a, 0x27, 0x04, 0xc2, 0xff, 0x2d, 0x04, 0x22, + 0x20, 0x94, 0xd8, 0x7d, 0x85, 0xe3, 0x63, 0x14, 0xee, 0x2b, 0x71, 0x04, 0xc7, 0x12, 0x98, 0xca, + 0xeb, 0x7a, 0xe8, 0x7a, 0xe6, 0x5d, 0xa2, 0x62, 0x0d, 0x4d, 0x36, 0x89, 0x35, 0xd9, 0x86, 0xea, + 0x58, 0x48, 0xd9, 0x83, 0x74, 0x3a, 0x9b, 0x46, 0xc7, 0xd2, 0xb7, 0xe8, 0xf4, 0x85, 0xfe, 0x76, + 0x19, 0x9c, 0x0a, 0x22, 0xb6, 0xd4, 0x91, 0xbb, 0xa0, 0x3b, 0xdb, 0x1b, 0x96, 0x6e, 0xb7, 0x61, + 0x79, 0x04, 0x47, 0x06, 0xe1, 0xe7, 0x58, 0x10, 0xaa, 0x3c, 0x08, 0x7d, 0x5d, 0x49, 0xfb, 0xf2, + 0x32, 0x8a, 0x4e, 0x26, 0xd6, 0xdb, 0xf5, 0x8d, 0x01, 0x58, 0x3f, 0xc5, 0x81, 0x75, 0xe7, 0xb0, + 0x2c, 0xa6, 0x0f, 0xdc, 0xef, 0x90, 0x11, 0x81, 0xf1, 0x7a, 0xbe, 0x4f, 0x14, 0xb0, 0x08, 0xaf, + 0x57, 0x39, 0xd2, 0xeb, 0x75, 0xa8, 0x31, 0x62, 0xa0, 0xc7, 0x72, 0xba, 0x63, 0xc4, 0x11, 0x7a, + 0x23, 0xbf, 0x59, 0x06, 0x45, 0x1c, 0xb2, 0x8b, 0xf1, 0x08, 0x67, 0x23, 0x60, 0xc7, 0xa3, 0x73, + 0xc0, 0xfb, 0x7c, 0x22, 0xa9, 0xf7, 0x39, 0x7c, 0x53, 0x52, 0x1f, 0xf3, 0x5e, 0x6e, 0x47, 0x82, + 0x58, 0x22, 0x17, 0xf2, 0x01, 0x1c, 0xa4, 0x0f, 0xda, 0xaf, 0xc9, 0x00, 0x78, 0x0d, 0x9a, 0x9e, + 0x8d, 0x78, 0x8a, 0x28, 0x5c, 0x37, 0xb3, 0x7e, 0xf7, 0x1e, 0x50, 0xa7, 0x7a, 0x80, 0x22, 0x14, + 0xc3, 0x53, 0x17, 0x0f, 0x25, 0xf5, 0xad, 0x0c, 0xb9, 0x1a, 0x09, 0x2c, 0x89, 0xbc, 0x2d, 0x23, + 0xcb, 0x4e, 0x1f, 0x90, 0xff, 0x26, 0x81, 0x5c, 0xc3, 0xaa, 0x23, 0xf7, 0xf0, 0xa6, 0x40, 0xe2, + 0x73, 0xff, 0xb8, 0xdc, 0x51, 0x9c, 0xfb, 0xef, 0x47, 0x28, 0x7d, 0xd1, 0xbd, 0x4d, 0x02, 0xd3, + 0x0d, 0xab, 0x1c, 0x2c, 0x4e, 0x89, 0xfb, 0xaa, 0x8a, 0x5f, 0xa5, 0x1f, 0x54, 0x30, 0x2c, 0xe6, + 0x50, 0x57, 0xe9, 0x0f, 0xa6, 0x97, 0xbe, 0xdc, 0x6e, 0x03, 0xc7, 0xd7, 0xcd, 0xb6, 0xa5, 0xa1, + 0xb6, 0x45, 0x57, 0xba, 0x15, 0x05, 0x64, 0x77, 0xcd, 0xb6, 0x85, 0x59, 0xce, 0x69, 0xf8, 0xd9, + 0x4b, 0xb3, 0x51, 0xdb, 0xa2, 0xbe, 0x01, 0xf8, 0x19, 0x7e, 0x4d, 0x06, 0x59, 0xef, 0x5f, 0x71, + 0x51, 0xbf, 0x59, 0x4e, 0x18, 0xc9, 0xc0, 0x23, 0x3f, 0x12, 0x4b, 0xe8, 0x2e, 0x66, 0xed, 0x9f, + 0x78, 0xb0, 0x5e, 0x1b, 0x55, 0x1e, 0x23, 0x8a, 0x70, 0xcd, 0x5f, 0x39, 0x03, 0x26, 0x36, 0x3a, + 0x56, 0xeb, 0x62, 0x78, 0xe0, 0x9e, 0xbe, 0x2a, 0x37, 0x82, 0x9c, 0xad, 0x9b, 0x5b, 0x88, 0xee, + 0x29, 0x9c, 0xec, 0xe9, 0x0b, 0xb1, 0xd7, 0x8b, 0x46, 0xb2, 0xc0, 0x37, 0x25, 0x89, 0xa1, 0xd0, + 0xa7, 0xf2, 0xc9, 0xf4, 0x61, 0x61, 0x88, 0x93, 0x67, 0x45, 0x30, 0x5d, 0x2e, 0x55, 0xc9, 0x4d, + 0x84, 0xb5, 0xf3, 0x6a, 0x51, 0xc6, 0x30, 0x7b, 0x32, 0x49, 0x11, 0x66, 0x8f, 0xfc, 0x8f, 0x2c, + 0xcc, 0x7d, 0x2a, 0x7f, 0x14, 0x30, 0x7f, 0x5c, 0x02, 0x33, 0x2b, 0x86, 0xe3, 0x46, 0x79, 0xfb, + 0xc7, 0x44, 0xec, 0x7d, 0x6e, 0x52, 0x53, 0x99, 0x2b, 0x47, 0x38, 0x54, 0x6f, 0x22, 0x73, 0x38, + 0xae, 0x88, 0xf1, 0x1c, 0x4b, 0xc1, 0x1c, 0x90, 0xab, 0xe3, 0x85, 0x25, 0x99, 0xd8, 0x50, 0x0a, + 0x0b, 0x19, 0xbf, 0xa1, 0x14, 0x59, 0x76, 0xfa, 0xf2, 0xfd, 0x9a, 0x04, 0x4e, 0x78, 0xc5, 0xc7, + 0x2d, 0x4b, 0x45, 0x8b, 0x79, 0xe0, 0xb2, 0x54, 0xe2, 0x95, 0xf1, 0x03, 0xbc, 0x8c, 0x62, 0x65, + 0x7c, 0x10, 0xd1, 0x31, 0x8b, 0x39, 0x62, 0x19, 0x76, 0x90, 0x98, 0x63, 0x96, 0x61, 0x87, 0x17, + 0x73, 0xfc, 0x52, 0xec, 0x90, 0x62, 0x3e, 0xb2, 0x05, 0xd6, 0xdf, 0x97, 0x03, 0x31, 0x47, 0xae, + 0x6d, 0xc4, 0x88, 0x39, 0xf1, 0x89, 0x5e, 0xfe, 0x4e, 0xfd, 0x04, 0x82, 0x1f, 0xf1, 0xfa, 0xc6, + 0x30, 0x30, 0x1d, 0xe1, 0x1a, 0xc7, 0x8b, 0x64, 0x30, 0x4b, 0xb9, 0xe8, 0x3f, 0x65, 0x8e, 0xc1, + 0x28, 0xf1, 0x94, 0x39, 0xf1, 0x19, 0x20, 0x9e, 0xb3, 0xf1, 0x9f, 0x01, 0x8a, 0x2d, 0x3f, 0x7d, + 0x70, 0xbe, 0x9e, 0x05, 0xa7, 0x3d, 0x16, 0x56, 0xad, 0xb6, 0xb1, 0xb9, 0x4f, 0xb8, 0x38, 0xaf, + 0x77, 0x76, 0x91, 0x03, 0xdf, 0x29, 0x89, 0xa2, 0xf4, 0x7f, 0x00, 0x60, 0x75, 0x91, 0x4d, 0x22, + 0xb1, 0x51, 0xa0, 0xee, 0x88, 0xaa, 0xec, 0xc1, 0x92, 0x82, 0x0b, 0x6c, 0x6a, 0x3e, 0x11, 0x8d, + 0xa1, 0xe7, 0x59, 0x85, 0x93, 0xc1, 0x97, 0x5e, 0x07, 0x8f, 0xcc, 0x41, 0x07, 0x8f, 0x1b, 0x80, + 0xac, 0xb7, 0xdb, 0x01, 0x54, 0xbd, 0x9b, 0xd9, 0xb8, 0x4c, 0xcd, 0xcb, 0xe2, 0xe5, 0x74, 0x50, + 0x78, 0x34, 0x2f, 0x22, 0xa7, 0x83, 0x5c, 0x65, 0x0e, 0xe4, 0xc9, 0x85, 0xde, 0xc1, 0x8a, 0x7e, + 0xff, 0xcc, 0x34, 0x17, 0x6f, 0xda, 0xd5, 0x78, 0x35, 0xbc, 0x2d, 0x91, 0x64, 0xfa, 0xf5, 0xd3, + 0xa1, 0x9d, 0xac, 0x71, 0x0a, 0xf6, 0xe4, 0xa1, 0x29, 0x8f, 0x67, 0x37, 0xac, 0xd4, 0xed, 0x76, + 0xf6, 0x1b, 0x34, 0xf0, 0x40, 0xa2, 0xdd, 0x30, 0x26, 0x7e, 0x81, 0x74, 0x20, 0x7e, 0x41, 0xe2, + 0xdd, 0x30, 0x8e, 0x8f, 0x51, 0xec, 0x86, 0xc5, 0x11, 0x4c, 0x5f, 0xb4, 0x1f, 0x2b, 0x10, 0xab, + 0x99, 0xde, 0x27, 0xf0, 0xa9, 0xfe, 0x9e, 0xd5, 0x80, 0x77, 0x76, 0xe9, 0x77, 0xd5, 0x40, 0xec, + 0x3d, 0x2a, 0xca, 0xe3, 0x41, 0x7e, 0xd3, 0xb2, 0x77, 0x74, 0x7f, 0xe3, 0xbe, 0xf7, 0xa4, 0x08, + 0x8d, 0xe1, 0xbf, 0x88, 0xf3, 0x68, 0x34, 0xaf, 0x37, 0x1f, 0x79, 0x9a, 0xd1, 0xa5, 0x61, 0x1b, + 0xbd, 0x47, 0xe5, 0x3a, 0x30, 0x43, 0xa3, 0x37, 0x56, 0x91, 0xe3, 0xa2, 0x36, 0x8d, 0x68, 0xc1, + 0x27, 0x2a, 0xe7, 0xc0, 0x34, 0x4d, 0x58, 0x34, 0x3a, 0xc8, 0xa1, 0x41, 0x2d, 0xb8, 0x34, 0xe5, + 0x34, 0xc8, 0x1b, 0xce, 0x3d, 0x8e, 0x65, 0x62, 0xff, 0xff, 0x82, 0x46, 0xdf, 0x94, 0x1b, 0xc0, + 0x71, 0x9a, 0x2f, 0x30, 0x56, 0xc9, 0x81, 0x9d, 0xde, 0x64, 0x4f, 0xb5, 0x4c, 0x6b, 0xcd, 0xb6, + 0xb6, 0x6c, 0xe4, 0x38, 0xf8, 0xd4, 0x54, 0x41, 0x63, 0x52, 0x94, 0xfb, 0xc0, 0x89, 0x8e, 0x61, + 0x5e, 0x74, 0x70, 0x94, 0xdf, 0x45, 0xea, 0x36, 0x36, 0xdd, 0x27, 0xfa, 0x36, 0xd3, 0xd8, 0xa8, + 0x1c, 0xd8, 0x5f, 0xb4, 0x83, 0x54, 0x94, 0x1b, 0x41, 0x91, 0x72, 0x33, 0xaf, 0xb7, 0x2e, 0xe2, + 0xef, 0xd4, 0x1d, 0xf5, 0x40, 0x3a, 0x7c, 0x7e, 0x06, 0x4c, 0x73, 0x3f, 0xeb, 0x40, 0xf1, 0xbb, + 0x3c, 0xe7, 0xc2, 0xb6, 0xe1, 0x22, 0xaf, 0x60, 0x7a, 0x8e, 0xe5, 0x96, 0x01, 0x8c, 0x69, 0x07, + 0x7e, 0xd4, 0xfa, 0x10, 0xf3, 0x00, 0x20, 0x9d, 0x19, 0xf6, 0x1a, 0x73, 0xa8, 0x1d, 0xca, 0xa5, + 0xc1, 0xa7, 0x01, 0xe5, 0x20, 0x35, 0xc6, 0xc3, 0x23, 0x93, 0xcc, 0xc3, 0xc3, 0x93, 0x89, 0xde, + 0xe9, 0x58, 0x97, 0x50, 0x3b, 0x20, 0x4b, 0xf5, 0xf0, 0x40, 0x3a, 0xfc, 0xcc, 0x30, 0x73, 0xbe, + 0xc4, 0xd7, 0x5e, 0x78, 0x0d, 0x68, 0xb7, 0xd5, 0x42, 0xa8, 0x4d, 0x0f, 0xa5, 0xf9, 0xaf, 0x09, + 0x2f, 0xc4, 0x48, 0x3c, 0x43, 0x3c, 0xa2, 0x1b, 0x31, 0x3e, 0x70, 0x0a, 0xe4, 0xc9, 0xed, 0x72, + 0xf0, 0xf9, 0xb3, 0x7d, 0xfb, 0x91, 0x59, 0xbe, 0x1f, 0x59, 0x07, 0xd3, 0xa6, 0xe5, 0x15, 0xb7, + 0xa6, 0xdb, 0xfa, 0x8e, 0x13, 0xb7, 0x00, 0x4c, 0xe8, 0x06, 0xa3, 0x7d, 0x95, 0xf9, 0x6d, 0xf9, + 0x98, 0xc6, 0x91, 0x51, 0xfe, 0x4f, 0x70, 0x7c, 0x83, 0x06, 0x6f, 0x70, 0x28, 0x65, 0x29, 0xda, + 0x3d, 0xb2, 0x87, 0xf2, 0x3c, 0xff, 0xe7, 0xf2, 0x31, 0xad, 0x97, 0x98, 0xf2, 0x33, 0x60, 0xd6, + 0x7b, 0x6d, 0x5b, 0x97, 0x7c, 0xc6, 0xe5, 0x68, 0x1b, 0xb1, 0x87, 0xfc, 0x2a, 0xf7, 0xe3, 0xf2, + 0x31, 0xad, 0x87, 0x94, 0x52, 0x03, 0x60, 0xdb, 0xdd, 0xe9, 0x50, 0xc2, 0xd9, 0x68, 0x95, 0xec, + 0x21, 0xbc, 0x1c, 0xfc, 0xb4, 0x7c, 0x4c, 0x63, 0x48, 0x28, 0x2b, 0x60, 0xd2, 0x7d, 0xc0, 0xa5, + 0xf4, 0x72, 0xd1, 0x7e, 0x09, 0x3d, 0xf4, 0x1a, 0xfe, 0x3f, 0xcb, 0xc7, 0xb4, 0x90, 0x80, 0x52, + 0x01, 0x85, 0xee, 0x06, 0x25, 0x96, 0x8f, 0xee, 0xcb, 0x7a, 0x88, 0xad, 0x6d, 0x04, 0xb4, 0x82, + 0xdf, 0x3d, 0xc6, 0x5a, 0xce, 0x1e, 0xa5, 0x35, 0x21, 0xcc, 0x58, 0xd9, 0xff, 0xc7, 0x63, 0x2c, + 0x20, 0xa0, 0x54, 0xc0, 0xa4, 0x63, 0xea, 0x5d, 0x67, 0xdb, 0x72, 0x9d, 0x33, 0x85, 0x1e, 0x17, + 0xd6, 0x68, 0x6a, 0x75, 0xfa, 0x8f, 0x16, 0xfe, 0xad, 0x3c, 0x1e, 0x9c, 0xda, 0xed, 0xb6, 0x75, + 0x17, 0xa9, 0x0f, 0x18, 0x8e, 0x6b, 0x98, 0x5b, 0x7e, 0xfc, 0x60, 0x32, 0x10, 0xf4, 0xff, 0xa8, + 0xcc, 0xd1, 0xc3, 0x6c, 0x00, 0xb7, 0x4d, 0xd8, 0xbb, 0x8f, 0x4a, 0x8a, 0x65, 0xce, 0xb0, 0x3d, + 0x09, 0x64, 0xbd, 0x4f, 0x78, 0xe0, 0x98, 0xed, 0xbf, 0x46, 0xdb, 0xab, 0x3b, 0xb8, 0x01, 0x7b, + 0x3f, 0xf5, 0x8c, 0x3d, 0xd3, 0x07, 0xc6, 0x9e, 0x6b, 0xc0, 0x94, 0xe1, 0xac, 0x1a, 0x5b, 0xc4, + 0xf0, 0xa5, 0x63, 0x03, 0x9b, 0x44, 0x16, 0x0a, 0xaa, 0xe8, 0x12, 0xb9, 0x1d, 0xe5, 0xb8, 0xbf, + 0x50, 0xe0, 0xa7, 0xc0, 0xeb, 0xc1, 0x34, 0xdb, 0xc8, 0xc8, 0x15, 0xb5, 0x46, 0x68, 0x36, 0xd3, + 0x37, 0x78, 0x1d, 0x98, 0xe5, 0x75, 0x9a, 0xb1, 0x0e, 0x64, 0xbf, 0x2b, 0x84, 0xd7, 0x82, 0xe3, + 0x3d, 0x0d, 0xcb, 0x0f, 0x07, 0x93, 0x09, 0xc3, 0xc1, 0x5c, 0x03, 0x40, 0xa8, 0xc5, 0x7d, 0xc9, + 0x5c, 0x0d, 0x26, 0x03, 0xbd, 0xec, 0x9b, 0xe1, 0x2b, 0x19, 0x50, 0xf0, 0x95, 0xad, 0x5f, 0x06, + 0x6f, 0x64, 0x32, 0x99, 0xbd, 0x1f, 0x7f, 0x64, 0x62, 0xd3, 0x3c, 0x13, 0x20, 0xf4, 0xb8, 0x6e, + 0x18, 0x6e, 0xc7, 0x3f, 0xb5, 0xd8, 0x9b, 0xac, 0xac, 0x01, 0x60, 0x60, 0x8c, 0x1a, 0xe1, 0x31, + 0xc6, 0xc7, 0x26, 0x68, 0x0f, 0x44, 0x1f, 0x18, 0x1a, 0xe7, 0x7e, 0x8c, 0x9e, 0x31, 0x9c, 0x04, + 0x39, 0x12, 0x44, 0xff, 0x98, 0x32, 0x0b, 0x80, 0xfa, 0x94, 0x35, 0x55, 0xab, 0xa8, 0xd5, 0xb2, + 0x5a, 0xcc, 0xc0, 0x17, 0x4b, 0x60, 0x32, 0x68, 0x04, 0x7d, 0x2b, 0xa9, 0x52, 0xd5, 0x1a, 0x78, + 0x0b, 0xe8, 0xc1, 0x46, 0xc5, 0x2a, 0xd9, 0x13, 0xc1, 0xe5, 0xbb, 0x0e, 0x5a, 0x34, 0x6c, 0xc7, + 0xd5, 0xac, 0x4b, 0x8b, 0x96, 0x1d, 0x0e, 0xac, 0x24, 0x78, 0x6d, 0xd4, 0x67, 0xcf, 0x18, 0x6c, + 0x23, 0x7c, 0x9e, 0x0d, 0xd9, 0x74, 0x51, 0x3f, 0x4c, 0xf0, 0xe8, 0xba, 0xb6, 0x6e, 0x3a, 0x5d, + 0xcb, 0x41, 0x9a, 0x75, 0xc9, 0x29, 0x99, 0xed, 0xb2, 0xd5, 0xd9, 0xdd, 0x31, 0x1d, 0x6a, 0xce, + 0x45, 0x7d, 0xf6, 0xa4, 0x83, 0xef, 0xf8, 0x9d, 0x05, 0xa0, 0x5c, 0x5b, 0x59, 0x51, 0xcb, 0x8d, + 0x4a, 0xad, 0x5a, 0x3c, 0xe6, 0x49, 0xab, 0x51, 0x9a, 0x5f, 0xf1, 0xa4, 0xf3, 0xb3, 0xa0, 0xe0, + 0xb7, 0x69, 0x1a, 0xc1, 0x26, 0xe3, 0x47, 0xb0, 0x51, 0x4a, 0xa0, 0xe0, 0xb7, 0x72, 0x3a, 0x22, + 0x3c, 0xb2, 0xf7, 0xc4, 0xf2, 0x8e, 0x6e, 0xbb, 0xd8, 0x40, 0xf1, 0x89, 0xcc, 0xeb, 0x0e, 0xd2, + 0x82, 0xdf, 0xce, 0x3d, 0x86, 0x72, 0xa0, 0x80, 0xd9, 0xd2, 0xca, 0x4a, 0xb3, 0xa6, 0x35, 0xab, + 0xb5, 0xc6, 0x72, 0xa5, 0xba, 0x44, 0x46, 0xc8, 0xca, 0x52, 0xb5, 0xa6, 0xa9, 0x64, 0x80, 0xac, + 0x17, 0x33, 0xe4, 0x8e, 0xe9, 0xf9, 0x02, 0xc8, 0x77, 0xb1, 0x74, 0xe1, 0x17, 0xe5, 0x84, 0xa1, + 0x0a, 0x02, 0x9c, 0x22, 0x6e, 0xc1, 0xe5, 0x8e, 0x0b, 0x48, 0x7d, 0x8e, 0xf3, 0x9e, 0x03, 0xd3, + 0xc4, 0x0c, 0x77, 0xf0, 0xce, 0x0b, 0x46, 0x4e, 0xd6, 0xb8, 0x34, 0xf8, 0x21, 0x29, 0x41, 0xfc, + 0x82, 0xbe, 0x1c, 0x25, 0x33, 0x2e, 0xfe, 0x2a, 0x33, 0xdc, 0x95, 0x13, 0x95, 0x6a, 0x43, 0xd5, + 0xaa, 0xa5, 0x15, 0x9a, 0x45, 0x56, 0xce, 0x80, 0x93, 0xd5, 0x1a, 0x0d, 0xd7, 0x58, 0x6f, 0x36, + 0x6a, 0xcd, 0xca, 0xea, 0x5a, 0x4d, 0x6b, 0x14, 0x73, 0xca, 0x69, 0xa0, 0x90, 0xe7, 0x66, 0xa5, + 0xde, 0x2c, 0x97, 0xaa, 0x65, 0x75, 0x45, 0x5d, 0x28, 0xe6, 0x95, 0x47, 0x81, 0x6b, 0xc9, 0x15, + 0x46, 0xb5, 0xc5, 0xa6, 0x56, 0xbb, 0x50, 0xf7, 0x10, 0xd4, 0xd4, 0x95, 0x92, 0xa7, 0x48, 0xcc, + 0x5d, 0xd3, 0x13, 0xca, 0x65, 0xe0, 0x38, 0xbe, 0x88, 0x7e, 0xa5, 0x56, 0x5a, 0xa0, 0xe5, 0x15, + 0x94, 0xab, 0xc0, 0x99, 0x4a, 0xb5, 0xbe, 0xbe, 0xb8, 0x58, 0x29, 0x57, 0xd4, 0x6a, 0xa3, 0xb9, + 0xa6, 0x6a, 0xab, 0x95, 0x7a, 0xdd, 0xfb, 0xb7, 0x38, 0x89, 0x6f, 0xf2, 0x25, 0x7d, 0x26, 0x7c, + 0x87, 0x0c, 0x66, 0xce, 0xeb, 0x1d, 0xc3, 0x1b, 0x28, 0xf0, 0x15, 0xdf, 0x3d, 0x27, 0x7d, 0x5c, + 0x7c, 0x15, 0x38, 0x3d, 0x2b, 0x80, 0x5f, 0xe0, 0x2f, 0xca, 0x09, 0x4f, 0xfa, 0x50, 0x20, 0x48, + 0x89, 0x73, 0x5c, 0x69, 0x11, 0xf3, 0xd2, 0x97, 0x4b, 0x09, 0x4e, 0xfa, 0x88, 0x93, 0x4f, 0x06, + 0xfe, 0xef, 0x8e, 0x0a, 0xfc, 0x22, 0x98, 0x5e, 0xaf, 0x96, 0xd6, 0x1b, 0xcb, 0x35, 0xad, 0xf2, + 0xd3, 0x38, 0xd2, 0xfc, 0x0c, 0x98, 0x5c, 0xac, 0x69, 0xf3, 0x95, 0x85, 0x05, 0xb5, 0x5a, 0xcc, + 0x29, 0x97, 0x83, 0xcb, 0xea, 0xaa, 0x76, 0xbe, 0x52, 0x56, 0x9b, 0xeb, 0xd5, 0xd2, 0xf9, 0x52, + 0x65, 0x05, 0xf7, 0x11, 0xf9, 0x98, 0xeb, 0xc9, 0x27, 0xe0, 0xcf, 0x67, 0x01, 0x20, 0x55, 0xc7, + 0x17, 0x2d, 0x31, 0x97, 0x58, 0xff, 0x75, 0xd2, 0x49, 0x43, 0x48, 0x26, 0xa2, 0xfd, 0x56, 0x40, + 0xc1, 0xa6, 0x1f, 0xe8, 0xca, 0xd7, 0x20, 0x3a, 0xe4, 0xd1, 0xa7, 0xa6, 0x05, 0xbf, 0xc3, 0x77, + 0x26, 0x99, 0x23, 0x44, 0x32, 0x96, 0x0c, 0xc9, 0xc5, 0xd1, 0x00, 0x09, 0x9f, 0x93, 0x01, 0xb3, + 0x7c, 0xc5, 0xbc, 0x4a, 0x60, 0x63, 0x4a, 0xac, 0x12, 0xfc, 0xcf, 0x8c, 0x91, 0x75, 0xee, 0x71, + 0x74, 0x38, 0x05, 0x7e, 0xcb, 0x24, 0x87, 0xf6, 0x7d, 0x8b, 0xa5, 0x98, 0xf1, 0x98, 0xf7, 0x8c, + 0x8e, 0xa2, 0xa4, 0x4c, 0x00, 0xb9, 0xf1, 0x80, 0x5b, 0x94, 0xe1, 0x57, 0x64, 0x30, 0xc3, 0xdd, + 0x92, 0x0d, 0x5f, 0x9e, 0x11, 0xb9, 0xc1, 0x96, 0xb9, 0x7f, 0x3b, 0x73, 0xd8, 0xfb, 0xb7, 0xcf, + 0xdd, 0x0c, 0x26, 0x68, 0x1a, 0x96, 0x6f, 0xad, 0xea, 0x99, 0x02, 0xc7, 0xc1, 0xd4, 0x92, 0xda, + 0x68, 0xd6, 0x1b, 0x25, 0xad, 0xa1, 0x2e, 0x14, 0x33, 0xde, 0xc0, 0xa7, 0xae, 0xae, 0x35, 0xee, + 0x2b, 0x4a, 0xc9, 0x9d, 0x27, 0x7b, 0x19, 0x19, 0xb3, 0xf3, 0x64, 0x5c, 0xf1, 0xe9, 0xcf, 0x55, + 0x3f, 0x25, 0x83, 0x22, 0xe1, 0x40, 0x7d, 0xa0, 0x8b, 0x6c, 0x03, 0x99, 0x2d, 0x04, 0x2f, 0x8a, + 0x04, 0x73, 0x3d, 0x10, 0xc6, 0x10, 0xf7, 0xe7, 0x8c, 0x95, 0x48, 0x5e, 0x7a, 0x0c, 0xec, 0xec, + 0x01, 0x03, 0xfb, 0x93, 0x49, 0xbd, 0x27, 0x7b, 0xd9, 0x1d, 0x09, 0x64, 0x1f, 0x4d, 0xe2, 0x3d, + 0x39, 0x80, 0x83, 0xb1, 0xc4, 0x68, 0x8e, 0x18, 0x7f, 0x8b, 0x32, 0x7c, 0xb6, 0x0c, 0x8e, 0x2f, + 0xe8, 0x2e, 0x9a, 0xdf, 0x6f, 0xf8, 0xb7, 0x58, 0x46, 0xdc, 0x3c, 0x9d, 0x39, 0x70, 0xf3, 0x74, + 0x78, 0x11, 0xa6, 0xd4, 0x73, 0x11, 0x26, 0x7c, 0x6b, 0xd2, 0xf3, 0x96, 0x3d, 0x3c, 0x8c, 0x2c, + 0x90, 0x72, 0xb2, 0x73, 0x94, 0xf1, 0x5c, 0xa4, 0xdf, 0xc0, 0xde, 0x30, 0x09, 0x8a, 0x84, 0x15, + 0xc6, 0x41, 0xf0, 0xb7, 0xe8, 0x65, 0xed, 0xcd, 0x04, 0xf1, 0x18, 0xfd, 0x08, 0x17, 0x12, 0x1f, + 0xe1, 0x82, 0x5b, 0x6f, 0x96, 0x7b, 0x9d, 0x3a, 0x92, 0x76, 0x86, 0x8c, 0x37, 0x60, 0x74, 0x08, + 0xdc, 0xf4, 0x3a, 0xc3, 0xd8, 0xe2, 0xc7, 0x73, 0xa1, 0x30, 0xbd, 0xc3, 0x53, 0x15, 0x45, 0x26, + 0xfe, 0xde, 0xf4, 0xa4, 0xae, 0xe1, 0x9c, 0x37, 0x66, 0xcc, 0x65, 0xe2, 0xe9, 0xb9, 0x86, 0x0f, + 0xe2, 0x20, 0x7d, 0x14, 0x7e, 0x20, 0x81, 0x6c, 0xdd, 0xb2, 0xdd, 0x51, 0x61, 0x90, 0x74, 0x3b, + 0x9b, 0x91, 0x40, 0x3d, 0x7a, 0xce, 0x99, 0xde, 0x76, 0x76, 0x7c, 0xf9, 0x63, 0x08, 0x69, 0x79, + 0x1c, 0xcc, 0x12, 0x4e, 0x82, 0xfb, 0x60, 0xbe, 0x2f, 0x91, 0xfe, 0xea, 0x5e, 0x51, 0x44, 0xf0, + 0xc6, 0x47, 0xb0, 0x9d, 0xec, 0x83, 0xc2, 0xa5, 0xc1, 0x57, 0xb3, 0xb8, 0x2c, 0xf0, 0xb8, 0xf4, + 0x9b, 0x71, 0x07, 0x57, 0xaa, 0x8c, 0xaa, 0x67, 0x4a, 0x12, 0x1d, 0x33, 0xa6, 0xf0, 0xf4, 0x11, + 0x79, 0x50, 0x06, 0x79, 0xea, 0xce, 0x37, 0x52, 0x04, 0x92, 0xb6, 0x8c, 0x40, 0x08, 0x62, 0x6e, + 0x7f, 0xf2, 0xa8, 0x5b, 0x46, 0x7c, 0xf9, 0xe9, 0xe3, 0xf0, 0x1f, 0xd4, 0x4f, 0xb5, 0xb4, 0xa7, + 0x1b, 0x1d, 0x7d, 0xa3, 0x93, 0x20, 0x2a, 0xf5, 0x87, 0x12, 0x9e, 0xcc, 0x0b, 0xaa, 0xca, 0x95, + 0x17, 0x21, 0xf1, 0x9f, 0x00, 0x93, 0x36, 0xb7, 0xd7, 0xe7, 0x59, 0x51, 0x3d, 0x3e, 0xc2, 0xf4, + 0xbb, 0x16, 0xe6, 0x4c, 0x74, 0x0c, 0x4f, 0x88, 0x9f, 0xb1, 0x1c, 0x1b, 0x9a, 0x2a, 0xb5, 0xdb, + 0x8b, 0x48, 0x77, 0x77, 0x6d, 0xd4, 0x4e, 0x34, 0x44, 0xd8, 0x3d, 0xdb, 0xa1, 0x8c, 0x24, 0xb8, + 0xb8, 0x90, 0x2b, 0x3c, 0x3a, 0x4f, 0x18, 0xd0, 0x1b, 0xf8, 0xbc, 0x8c, 0xa4, 0x4b, 0x7a, 0x7d, + 0x00, 0x49, 0x8d, 0x83, 0xe4, 0x49, 0xc3, 0x31, 0x91, 0x3e, 0x20, 0x2f, 0x90, 0xc1, 0x2c, 0xb1, + 0x13, 0x46, 0x8d, 0xc9, 0x7b, 0x12, 0xba, 0xff, 0x30, 0x37, 0x6e, 0xb1, 0xec, 0x8c, 0x04, 0x96, + 0x24, 0xce, 0x42, 0x62, 0x7c, 0xa4, 0x8f, 0xcc, 0x33, 0x4f, 0x00, 0xc0, 0xb8, 0x74, 0x7e, 0x28, + 0x1f, 0xc6, 0x68, 0x84, 0x6f, 0xa2, 0xf3, 0x8f, 0x3a, 0x17, 0x30, 0x9c, 0x71, 0xd7, 0x0c, 0x36, + 0xa4, 0xf8, 0x44, 0xa1, 0x51, 0xe5, 0xaf, 0x12, 0xda, 0xbc, 0xd4, 0xa1, 0x72, 0xe0, 0xe0, 0x3e, + 0x64, 0x2f, 0xf7, 0xe1, 0x04, 0xc6, 0xef, 0x20, 0x56, 0x92, 0xa1, 0xb6, 0x32, 0xc4, 0xcc, 0xfe, + 0x0c, 0x38, 0xa9, 0xa9, 0xa5, 0x85, 0x5a, 0x75, 0xe5, 0x3e, 0xf6, 0xfa, 0xa5, 0xa2, 0xcc, 0x4e, + 0x4e, 0x52, 0x81, 0xed, 0x95, 0x09, 0xfb, 0x40, 0x5e, 0x56, 0x71, 0xb3, 0x15, 0x66, 0x71, 0x65, + 0x70, 0xaf, 0x26, 0x40, 0xf6, 0x28, 0x51, 0xf8, 0x76, 0x1e, 0x4c, 0x69, 0xa8, 0x65, 0xed, 0xec, + 0x20, 0xb3, 0x8d, 0xda, 0xf0, 0x95, 0x32, 0x98, 0x0e, 0xf6, 0xfb, 0xea, 0xc8, 0x85, 0x3f, 0x13, + 0x62, 0x73, 0x0e, 0x4c, 0x7b, 0x95, 0xab, 0xf1, 0x41, 0xe0, 0xb9, 0x34, 0xe5, 0x26, 0x70, 0xc2, + 0x47, 0xa1, 0xd6, 0x33, 0x85, 0x39, 0xf8, 0x01, 0xbe, 0x8d, 0xc5, 0x68, 0x9d, 0xc7, 0xe8, 0xae, + 0x68, 0x61, 0x06, 0xec, 0xce, 0xb1, 0xac, 0x46, 0x80, 0xf5, 0x97, 0x01, 0x58, 0x4f, 0xe1, 0xc0, + 0x5a, 0x38, 0x24, 0xfd, 0xa3, 0x44, 0xed, 0xdd, 0x32, 0x38, 0xe9, 0x77, 0xc4, 0xe3, 0x43, 0xeb, + 0xc3, 0x2c, 0x5a, 0x3f, 0xcb, 0xa3, 0xb5, 0x24, 0x22, 0xcd, 0x7e, 0x2c, 0x47, 0xa0, 0xf6, 0x85, + 0x00, 0xb5, 0x9f, 0xe3, 0x50, 0x5b, 0x19, 0x51, 0x39, 0x47, 0x89, 0xde, 0x7b, 0x64, 0x70, 0xc6, + 0x33, 0x3b, 0xcb, 0x96, 0xb9, 0xd9, 0x31, 0x5a, 0xae, 0x61, 0x6e, 0x85, 0x2e, 0x6c, 0x4b, 0x22, + 0x2b, 0x9b, 0xbd, 0xd8, 0x4a, 0x07, 0xb1, 0xe5, 0x63, 0x67, 0x88, 0xb6, 0xad, 0x28, 0xb6, 0x22, + 0x86, 0x30, 0xc6, 0xf1, 0x3a, 0xd4, 0x1c, 0x36, 0x29, 0x79, 0xeb, 0x13, 0xe4, 0xe0, 0x28, 0xf1, + 0x7b, 0x10, 0x30, 0xa6, 0xc7, 0x2f, 0xcb, 0xa0, 0x88, 0xfd, 0x25, 0x71, 0xcf, 0x4e, 0xef, 0x26, + 0xad, 0xf1, 0x5e, 0xf2, 0x5d, 0x5f, 0x40, 0xbe, 0x97, 0xbc, 0x9f, 0xa0, 0x5c, 0x0f, 0x66, 0x5b, + 0xdb, 0xa8, 0x75, 0xb1, 0x62, 0xfa, 0xbe, 0x48, 0xc4, 0x71, 0xa5, 0x27, 0x95, 0x1f, 0xcc, 0xee, + 0xe5, 0xc1, 0xe4, 0x17, 0x1e, 0xb9, 0x89, 0x0d, 0xcb, 0x54, 0x44, 0x43, 0xfb, 0x58, 0x00, 0x50, + 0x95, 0x03, 0xe8, 0xf6, 0xa1, 0xa8, 0x26, 0x83, 0xa5, 0x3a, 0x04, 0x2c, 0x10, 0x9c, 0xae, 0xad, + 0x35, 0x2a, 0xb5, 0x6a, 0x73, 0xbd, 0xae, 0x2e, 0x34, 0xe7, 0x7d, 0x70, 0xea, 0x45, 0x19, 0x7e, + 0x43, 0x02, 0x13, 0x84, 0x2d, 0x07, 0x3e, 0x3a, 0x84, 0x60, 0xe0, 0xf1, 0x00, 0xf8, 0x06, 0xe1, + 0x60, 0x3f, 0x81, 0x20, 0x68, 0x39, 0x11, 0x0d, 0xe3, 0x89, 0x60, 0x82, 0x80, 0xec, 0xef, 0x02, + 0x9c, 0x8d, 0xb0, 0xec, 0x28, 0x19, 0xcd, 0xcf, 0x2e, 0x18, 0xf8, 0x67, 0x00, 0x1b, 0xe9, 0x5b, + 0xe3, 0x4f, 0xcf, 0x92, 0xa5, 0x83, 0x0b, 0x86, 0xbb, 0x8d, 0x4f, 0x0f, 0xc0, 0x9f, 0x12, 0xe9, + 0xb8, 0x6e, 0x02, 0xb9, 0x3d, 0x2f, 0xf7, 0x80, 0x93, 0x18, 0x24, 0x13, 0xfc, 0x5d, 0xe1, 0x38, + 0xd3, 0x9c, 0x7e, 0x06, 0x3c, 0x45, 0x80, 0xb3, 0x0a, 0xb2, 0x1d, 0xc3, 0x71, 0xa9, 0xcd, 0x7d, + 0x5b, 0x22, 0x42, 0xfe, 0x43, 0xc5, 0x45, 0x3b, 0x1a, 0x26, 0x03, 0xef, 0xf1, 0x2c, 0xa6, 0x30, + 0x55, 0xe0, 0x34, 0xca, 0x19, 0x30, 0x41, 0x4f, 0x49, 0xd3, 0x6d, 0x29, 0xff, 0x55, 0x70, 0x2b, + 0x48, 0xa8, 0xb6, 0xe9, 0xeb, 0xc0, 0xff, 0x77, 0x1c, 0x4c, 0x2c, 0x1b, 0x8e, 0x6b, 0xd9, 0xfb, + 0xf0, 0xa1, 0x0c, 0x98, 0x38, 0x8f, 0x6c, 0xc7, 0xb0, 0xcc, 0x03, 0xee, 0x59, 0xd7, 0x80, 0xa9, + 0xae, 0x8d, 0xf6, 0x0c, 0x6b, 0xd7, 0x61, 0x46, 0x09, 0x26, 0x49, 0x81, 0xa0, 0xa0, 0xef, 0xba, + 0xdb, 0x96, 0x1d, 0x06, 0x57, 0xf2, 0xdf, 0x95, 0xb3, 0x00, 0x90, 0xe7, 0xaa, 0xbe, 0x83, 0xfc, + 0xfb, 0xd3, 0xc3, 0x14, 0x45, 0x01, 0x59, 0xd7, 0xd8, 0x41, 0x34, 0xda, 0x3a, 0x7e, 0xf6, 0x04, + 0x8c, 0x23, 0x97, 0xd2, 0x08, 0xb1, 0xb2, 0xe6, 0xbf, 0xc2, 0xcf, 0xc9, 0x60, 0x6a, 0x09, 0xb9, + 0x94, 0x55, 0x07, 0x3e, 0x37, 0x23, 0x74, 0xc1, 0x91, 0x37, 0x2f, 0xe9, 0xe8, 0x8e, 0xff, 0x5f, + 0x30, 0xe4, 0xf2, 0x89, 0x61, 0xe8, 0x77, 0x99, 0xbd, 0xf7, 0x01, 0xc7, 0x01, 0x75, 0x2b, 0xc4, + 0x81, 0x9f, 0x66, 0xa6, 0x1b, 0xc7, 0x07, 0x3f, 0xf0, 0x36, 0x71, 0x6c, 0x0c, 0x0d, 0x2a, 0xfb, + 0x39, 0xa6, 0x3e, 0x91, 0xdd, 0x51, 0x61, 0x8f, 0xe6, 0x38, 0x70, 0xa5, 0x07, 0x4b, 0x89, 0x92, + 0xd1, 0x82, 0xdc, 0x82, 0xd1, 0x37, 0x06, 0x73, 0x32, 0x86, 0x4b, 0x5c, 0x65, 0x30, 0x55, 0xdf, + 0xb6, 0x2e, 0xf9, 0x72, 0xfc, 0x59, 0x31, 0x60, 0xaf, 0x02, 0x93, 0x7b, 0x3d, 0xa0, 0x86, 0x09, + 0xec, 0xbd, 0x71, 0x32, 0x7f, 0x6f, 0xdc, 0xb3, 0xe4, 0xa4, 0x30, 0x31, 0xcc, 0x45, 0xc0, 0xc4, + 0x5f, 0xf5, 0x26, 0x25, 0xb8, 0xea, 0x4d, 0x79, 0x02, 0x98, 0xa0, 0x5c, 0xd3, 0x65, 0xea, 0x78, + 0x80, 0xfd, 0xcc, 0x6c, 0x05, 0xb3, 0x7c, 0x05, 0x93, 0x21, 0x1f, 0x5d, 0xb9, 0xf4, 0x91, 0xff, + 0x73, 0x09, 0xc7, 0x5e, 0xf2, 0x81, 0x2f, 0x8f, 0x00, 0x78, 0xf8, 0xbd, 0x8c, 0xe8, 0x66, 0x4e, + 0x20, 0x81, 0x80, 0x83, 0x43, 0x5d, 0x5e, 0x36, 0x90, 0x5c, 0xfa, 0xf2, 0x7c, 0x71, 0x16, 0x4c, + 0x2f, 0x18, 0x9b, 0x9b, 0x41, 0x27, 0xf9, 0x3c, 0xc1, 0x4e, 0x32, 0xda, 0x85, 0xca, 0xb3, 0x73, + 0x77, 0x6d, 0x1b, 0x99, 0x7e, 0xa5, 0x68, 0x73, 0xea, 0x49, 0x55, 0x6e, 0x00, 0xc7, 0xfd, 0x71, + 0x81, 0xed, 0x28, 0x27, 0xb5, 0xde, 0x64, 0xf8, 0x1d, 0x61, 0x4f, 0x00, 0x5f, 0xa2, 0x6c, 0x95, + 0x22, 0x1a, 0xe0, 0x1d, 0x60, 0x66, 0x9b, 0xe4, 0xc6, 0xcb, 0xa5, 0x7e, 0x67, 0x79, 0xba, 0x27, + 0xb6, 0xfd, 0x2a, 0x72, 0x1c, 0x7d, 0x0b, 0x69, 0x7c, 0xe6, 0x9e, 0xe6, 0x2b, 0x27, 0xb9, 0xa9, + 0x51, 0xcc, 0xa9, 0x40, 0xa0, 0x26, 0x63, 0xd0, 0x8e, 0x73, 0x20, 0xbb, 0x68, 0x74, 0x10, 0xfc, + 0x15, 0x09, 0x4c, 0x7a, 0xb3, 0x6e, 0xb3, 0xe5, 0xbd, 0x31, 0x0e, 0x95, 0xdf, 0xce, 0x88, 0xde, + 0x50, 0xec, 0xd1, 0x99, 0x0b, 0x68, 0x44, 0xb4, 0x1b, 0xb1, 0x9b, 0x88, 0x63, 0x49, 0x8d, 0xe1, + 0x3e, 0x29, 0x6f, 0xea, 0xb1, 0xb9, 0xd9, 0xb1, 0x74, 0x6e, 0xc3, 0xa0, 0xd7, 0x14, 0x0a, 0x0f, + 0xf8, 0x55, 0x2d, 0x77, 0xcd, 0x30, 0xcd, 0x20, 0x66, 0xc6, 0x81, 0x74, 0xde, 0xd7, 0x25, 0x36, + 0xec, 0x18, 0xae, 0x3b, 0x2d, 0x3d, 0x42, 0xb3, 0xaf, 0x07, 0xb3, 0x1b, 0xfb, 0x2e, 0x72, 0x68, + 0x2e, 0x5a, 0x6c, 0x56, 0xeb, 0x49, 0x65, 0x2e, 0x0d, 0x88, 0x0b, 0x4f, 0x16, 0x53, 0x60, 0x32, + 0x51, 0x2f, 0x0f, 0x31, 0x03, 0x3c, 0x09, 0x8a, 0xd5, 0xda, 0x82, 0x8a, 0xfd, 0x7b, 0x7d, 0x8f, + 0xc9, 0x2d, 0xf8, 0x9b, 0x32, 0x98, 0xc6, 0x0e, 0x78, 0x3e, 0x0a, 0xd7, 0x0a, 0xcc, 0x47, 0xe0, + 0x97, 0x84, 0x7d, 0x7f, 0x71, 0x95, 0xd9, 0x02, 0xa2, 0x05, 0xbd, 0x69, 0x74, 0x7a, 0x05, 0x9d, + 0xd3, 0x7a, 0x52, 0xfb, 0x00, 0x22, 0xf7, 0x05, 0xe4, 0xdd, 0x42, 0x0e, 0xc0, 0x83, 0xb8, 0x3b, + 0x2a, 0x54, 0xfe, 0x58, 0x06, 0x53, 0xde, 0x24, 0xc5, 0x07, 0xa5, 0xc6, 0x81, 0x62, 0x99, 0x9d, + 0xfd, 0x70, 0x59, 0xc4, 0x7f, 0x4d, 0xd4, 0x48, 0xfe, 0x46, 0x78, 0xe6, 0x8e, 0x45, 0xc4, 0xf0, + 0x32, 0x26, 0xfc, 0xde, 0x25, 0x34, 0x9f, 0x1f, 0xc0, 0xdc, 0x51, 0xc1, 0xf7, 0xb5, 0x1c, 0xc8, + 0xaf, 0x77, 0x31, 0x72, 0xbf, 0x2b, 0x8b, 0x5c, 0xc0, 0x71, 0xe0, 0xf0, 0x97, 0x67, 0x66, 0x75, + 0xac, 0x96, 0xde, 0x59, 0x0b, 0x4f, 0xd1, 0x86, 0x09, 0xca, 0xed, 0xd4, 0x1f, 0x9c, 0x9c, 0x1e, + 0xbf, 0x3e, 0xf6, 0x6e, 0x0a, 0x2c, 0x23, 0xe6, 0xa0, 0xdd, 0x4d, 0xe0, 0x44, 0xdb, 0x70, 0xf4, + 0x8d, 0x0e, 0x52, 0xcd, 0x96, 0xbd, 0x4f, 0xc4, 0x41, 0xa7, 0x55, 0x07, 0x3e, 0x28, 0x77, 0x82, + 0x9c, 0xe3, 0xee, 0x77, 0xc8, 0x3c, 0x91, 0x3d, 0x97, 0x17, 0x59, 0x54, 0xdd, 0xcb, 0xae, 0x91, + 0xbf, 0x58, 0xb7, 0xce, 0x09, 0x31, 0xb7, 0x4e, 0xe5, 0x71, 0x20, 0x6f, 0xd9, 0xc6, 0x96, 0x41, + 0xae, 0x9b, 0x9b, 0x3d, 0x10, 0x82, 0x95, 0x98, 0x02, 0x35, 0x9c, 0x45, 0xa3, 0x59, 0x95, 0x27, + 0x80, 0x49, 0x63, 0x47, 0xdf, 0x42, 0xf7, 0x1a, 0x26, 0x39, 0xa0, 0x3e, 0x7b, 0xeb, 0x99, 0x03, + 0x47, 0x0e, 0xe9, 0x77, 0x2d, 0xcc, 0x0a, 0xdf, 0x25, 0x89, 0xc6, 0x89, 0xc3, 0x75, 0x23, 0xa0, + 0x0e, 0x71, 0x77, 0x35, 0x23, 0x07, 0x59, 0xd0, 0xbd, 0xf5, 0x65, 0x42, 0x11, 0xdc, 0xa2, 0xd9, + 0x4a, 0x7f, 0xf0, 0xfe, 0xac, 0x04, 0x0a, 0x0b, 0xd6, 0x25, 0x13, 0x2b, 0xfa, 0x6d, 0x62, 0xb6, + 0x6e, 0x9f, 0x83, 0xe1, 0xfc, 0x2d, 0xc8, 0xb1, 0xa7, 0xc0, 0x70, 0x6d, 0xfd, 0x22, 0x23, 0x60, + 0x88, 0x6d, 0x39, 0x82, 0x77, 0xd3, 0xc6, 0x95, 0x93, 0xbe, 0x5c, 0xff, 0x42, 0x06, 0xd9, 0x05, + 0xdb, 0xea, 0xc2, 0xd7, 0x67, 0x12, 0xb8, 0x79, 0xb5, 0x6d, 0xab, 0xdb, 0xc0, 0x97, 0x4b, 0x86, + 0x3b, 0x1b, 0x6c, 0x9a, 0x72, 0x1b, 0x28, 0x74, 0x2d, 0xc7, 0x70, 0xfd, 0x69, 0xc4, 0xec, 0xad, + 0x8f, 0xe8, 0xdb, 0x9a, 0xd7, 0x68, 0x26, 0x2d, 0xc8, 0xee, 0xf5, 0xda, 0x58, 0x84, 0x9e, 0x5c, + 0x3c, 0x31, 0xfa, 0x17, 0x6c, 0xf6, 0xa4, 0xc2, 0xe7, 0xb3, 0x48, 0x3e, 0x89, 0x47, 0xf2, 0x91, + 0x7d, 0x24, 0x6c, 0x5b, 0xdd, 0x91, 0x38, 0x66, 0xbc, 0x24, 0x40, 0xf5, 0xc9, 0x1c, 0xaa, 0x37, + 0x0a, 0x95, 0x99, 0x3e, 0xa2, 0xef, 0xca, 0x02, 0x80, 0xcd, 0x8c, 0x75, 0x6f, 0x02, 0x24, 0x66, + 0x63, 0xfd, 0x52, 0x96, 0x91, 0x65, 0x89, 0x97, 0xe5, 0xa3, 0x23, 0xac, 0x18, 0x4c, 0x3e, 0x42, + 0xa2, 0x25, 0x90, 0xdb, 0xf5, 0x3e, 0x53, 0x89, 0x0a, 0x92, 0xc0, 0xaf, 0x1a, 0xf9, 0x13, 0xfe, + 0x79, 0x06, 0xe4, 0x70, 0x82, 0x72, 0x16, 0x00, 0x3c, 0xb0, 0x93, 0x43, 0x94, 0x19, 0x3c, 0x84, + 0x33, 0x29, 0x58, 0x5b, 0x8d, 0x36, 0xfd, 0x4c, 0x4c, 0xe6, 0x30, 0xc1, 0xfb, 0x1b, 0x0f, 0xf7, + 0x98, 0x16, 0x35, 0x00, 0x98, 0x14, 0xef, 0x6f, 0xfc, 0xb6, 0x82, 0x36, 0x49, 0xdc, 0xff, 0xac, + 0x16, 0x26, 0x04, 0x7f, 0xaf, 0x04, 0xb7, 0x45, 0xfa, 0x7f, 0xe3, 0x14, 0x6f, 0x32, 0x8c, 0xd5, + 0x72, 0x3e, 0x2c, 0x22, 0x8f, 0x33, 0xf5, 0x26, 0xc3, 0x57, 0x06, 0x6a, 0xb3, 0xc0, 0xa9, 0xcd, + 0x63, 0x13, 0x88, 0x37, 0x7d, 0xe5, 0xf9, 0x4a, 0x0e, 0x4c, 0x56, 0xad, 0x36, 0xd5, 0x1d, 0x66, + 0xc2, 0xf8, 0xd1, 0x5c, 0xa2, 0x09, 0x63, 0x40, 0x23, 0x42, 0x41, 0xee, 0xe6, 0x15, 0x44, 0x8c, + 0x02, 0xab, 0x1f, 0xca, 0x3c, 0xc8, 0x63, 0xed, 0x3d, 0x78, 0x0d, 0x61, 0x1c, 0x09, 0x2c, 0x5a, + 0x8d, 0xfe, 0xf9, 0x9f, 0x4e, 0xc7, 0xfe, 0x2b, 0xc8, 0xe1, 0x0a, 0xc6, 0xec, 0xee, 0xf0, 0x15, + 0x95, 0xe2, 0x2b, 0x2a, 0xc7, 0x57, 0x34, 0xdb, 0x5b, 0xd1, 0x24, 0xeb, 0x00, 0x51, 0x1a, 0x92, + 0xbe, 0x8e, 0xff, 0xf3, 0x04, 0x00, 0x55, 0x7d, 0xcf, 0xd8, 0x22, 0xbb, 0xc3, 0x9f, 0xf3, 0xe7, + 0x3f, 0x74, 0x1f, 0xf7, 0xd7, 0x98, 0x81, 0xf0, 0x36, 0x30, 0x41, 0xc7, 0x3d, 0x5a, 0x91, 0xab, + 0xb9, 0x8a, 0x84, 0x54, 0x88, 0x59, 0xfa, 0x80, 0xab, 0xf9, 0xf9, 0xb9, 0x1b, 0xd3, 0xa5, 0x9e, + 0x1b, 0xd3, 0xfb, 0xef, 0x41, 0x44, 0xdc, 0xa3, 0x0e, 0xdf, 0x2e, 0x7c, 0x0a, 0x8a, 0xe1, 0x87, + 0xa9, 0x51, 0x44, 0x13, 0x7c, 0x1c, 0x98, 0xb0, 0x82, 0x0d, 0x6d, 0x39, 0x72, 0x1d, 0xac, 0x62, + 0x6e, 0x5a, 0x9a, 0x9f, 0x53, 0x70, 0xf3, 0x4b, 0x88, 0x8f, 0xb1, 0x1c, 0x34, 0x3c, 0xbd, 0xe4, + 0xc7, 0x50, 0xf4, 0xea, 0x71, 0xc1, 0x70, 0xb7, 0x57, 0x70, 0x64, 0xa6, 0x9f, 0x13, 0xb3, 0x20, + 0x19, 0xfc, 0xa5, 0x64, 0xf8, 0xf3, 0x71, 0x8e, 0xea, 0x3c, 0x6a, 0x77, 0x46, 0x51, 0xe9, 0xcf, + 0x6d, 0x04, 0x80, 0xb7, 0x83, 0x3c, 0x61, 0x94, 0x76, 0xa2, 0xe7, 0x22, 0xf1, 0x0b, 0x28, 0x69, + 0xf4, 0x0f, 0xf8, 0xb6, 0x00, 0xc7, 0xf3, 0x1c, 0x8e, 0xf3, 0x87, 0xe2, 0x2c, 0x75, 0x48, 0xcf, + 0xdd, 0x02, 0x26, 0xa8, 0xa4, 0x95, 0x59, 0xb6, 0x15, 0x17, 0x8f, 0x29, 0x00, 0xe4, 0x57, 0xad, + 0x3d, 0xd4, 0xb0, 0x8a, 0x19, 0xef, 0xd9, 0xe3, 0xaf, 0x61, 0x15, 0x25, 0xf8, 0xd2, 0x02, 0x28, + 0x04, 0xc1, 0xeb, 0x3e, 0x2b, 0x81, 0x62, 0xd9, 0x46, 0xba, 0x8b, 0x16, 0x6d, 0x6b, 0x87, 0xd4, + 0x48, 0xdc, 0xa3, 0xfe, 0x05, 0xc2, 0x2e, 0x1e, 0x41, 0x50, 0xb9, 0xde, 0xc2, 0x22, 0xb0, 0x24, + 0x8b, 0x90, 0x92, 0xbf, 0x08, 0x09, 0x5f, 0x27, 0xe4, 0xf2, 0x21, 0x5a, 0x4a, 0xfa, 0x4d, 0xed, + 0x93, 0x12, 0xc8, 0x95, 0x3b, 0x96, 0x89, 0xd8, 0x63, 0x9f, 0x03, 0xcf, 0x17, 0xf6, 0xdf, 0x89, + 0x80, 0x4f, 0x97, 0x44, 0x6d, 0x8d, 0x50, 0x00, 0x5e, 0xd9, 0x82, 0xb2, 0x15, 0x1b, 0xa4, 0x62, + 0x49, 0xa7, 0x2f, 0xd0, 0x6f, 0x48, 0x60, 0x92, 0xc4, 0x12, 0x2b, 0x75, 0x3a, 0xf0, 0x11, 0xa1, + 0x50, 0xfb, 0x04, 0x00, 0x84, 0xef, 0x16, 0x3e, 0xd6, 0x14, 0xd4, 0x2a, 0xa0, 0x9d, 0x20, 0xa8, + 0x5a, 0xb2, 0x53, 0x36, 0x62, 0x7b, 0x69, 0x03, 0x19, 0x4a, 0x5f, 0xd4, 0x7f, 0x2d, 0x79, 0x06, + 0x80, 0x79, 0x71, 0xcd, 0x46, 0x7b, 0x06, 0xba, 0x04, 0xaf, 0x0c, 0x85, 0x7d, 0x30, 0x50, 0xd2, + 0x6b, 0x84, 0x17, 0x71, 0x18, 0x92, 0x91, 0x5b, 0x59, 0x53, 0x9d, 0x30, 0x13, 0xed, 0xc5, 0x7b, + 0xa3, 0x57, 0x31, 0x64, 0x34, 0x36, 0xbb, 0xe0, 0x9a, 0x4d, 0x34, 0x17, 0xe9, 0x0b, 0xf6, 0xfd, + 0x13, 0xa0, 0xb0, 0x6e, 0x3a, 0xdd, 0x8e, 0xee, 0x6c, 0xc3, 0xef, 0xcb, 0x20, 0x4f, 0x2e, 0xbf, + 0x84, 0x3f, 0xc1, 0xc5, 0x63, 0x79, 0xea, 0x2e, 0xb2, 0x7d, 0x17, 0x1c, 0xf2, 0x12, 0xda, 0x47, + 0x12, 0x63, 0x1f, 0xc1, 0x77, 0xc9, 0xa2, 0x93, 0x54, 0xbf, 0x50, 0x7a, 0xdb, 0x66, 0x74, 0x08, + 0x90, 0xae, 0xd1, 0x72, 0x77, 0x6d, 0xe4, 0xf4, 0x0d, 0x01, 0x12, 0x49, 0x65, 0x8d, 0xfc, 0xa5, + 0x05, 0xbf, 0x43, 0x1d, 0x4c, 0xd0, 0xc4, 0x03, 0xdb, 0x49, 0x07, 0x63, 0x16, 0x9c, 0x06, 0x79, + 0xdd, 0x76, 0x0d, 0xc7, 0xa5, 0x1b, 0xac, 0xf4, 0xcd, 0xeb, 0x2e, 0xc9, 0xd3, 0xba, 0xdd, 0xf1, + 0x23, 0x37, 0x05, 0x09, 0xf0, 0x8f, 0x85, 0xe6, 0x8f, 0xf1, 0x35, 0x4f, 0x06, 0xf9, 0xbd, 0x43, + 0xac, 0x51, 0x5f, 0x0e, 0x2e, 0xd3, 0x4a, 0x0d, 0xb5, 0x49, 0x02, 0xfd, 0x04, 0x31, 0x7d, 0xda, + 0xf0, 0xad, 0x32, 0xb3, 0x7e, 0xb7, 0xcf, 0x8d, 0x11, 0x54, 0x8a, 0xe1, 0x18, 0x11, 0x24, 0xc4, + 0xec, 0x56, 0x73, 0x8b, 0xb0, 0xb2, 0xf8, 0x22, 0xec, 0x1f, 0x09, 0xef, 0x26, 0x05, 0xa2, 0x1c, + 0xb0, 0x06, 0x18, 0x77, 0x39, 0xde, 0x7b, 0x85, 0x76, 0x86, 0x06, 0x95, 0x74, 0x84, 0xb0, 0xbd, + 0x7a, 0x02, 0x4c, 0x2c, 0xe9, 0x9d, 0x0e, 0xb2, 0xf7, 0xbd, 0x21, 0xa9, 0xe8, 0x73, 0xb8, 0xaa, + 0x9b, 0xc6, 0x26, 0x72, 0xdc, 0xf8, 0xce, 0xf2, 0xed, 0xc2, 0x81, 0xd7, 0x69, 0x19, 0x73, 0xbd, + 0xf4, 0x23, 0x64, 0x7e, 0x33, 0xc8, 0x1a, 0xe6, 0xa6, 0x45, 0xbb, 0xcc, 0xde, 0x55, 0x7b, 0xff, + 0x67, 0x3c, 0x75, 0xc1, 0x19, 0x05, 0x63, 0xaf, 0x0b, 0x72, 0x91, 0x7e, 0xcf, 0xf9, 0xc6, 0x2c, + 0x98, 0xf1, 0x99, 0xa8, 0x98, 0x6d, 0xf4, 0x00, 0xbb, 0x14, 0xf3, 0x9b, 0x59, 0xd1, 0x23, 0xb4, + 0xbd, 0xf5, 0xc1, 0xa4, 0x22, 0x44, 0xda, 0x00, 0xa0, 0xa5, 0xbb, 0x68, 0xcb, 0xb2, 0x8d, 0xa0, + 0x3f, 0x7c, 0x7c, 0x12, 0x6a, 0x65, 0xf2, 0xf7, 0xbe, 0xc6, 0xd0, 0x51, 0xee, 0x04, 0x53, 0x28, + 0x88, 0x59, 0xe2, 0x2f, 0xd5, 0xc4, 0xe2, 0xc5, 0xe6, 0x87, 0x7f, 0x2d, 0x74, 0x52, 0x57, 0xa4, + 0x9a, 0xc9, 0x30, 0x6b, 0x0e, 0xd7, 0x86, 0xd6, 0xab, 0xab, 0x25, 0xad, 0xbe, 0x5c, 0x5a, 0x59, + 0xa9, 0x54, 0x97, 0x82, 0x60, 0x59, 0x0a, 0x98, 0x5d, 0xa8, 0x5d, 0xa8, 0x32, 0xd1, 0xcc, 0xb2, + 0x70, 0x0d, 0x14, 0x7c, 0x79, 0xf5, 0xf3, 0xc5, 0x64, 0x65, 0x46, 0x7d, 0x31, 0x99, 0x24, 0xcf, + 0x38, 0x33, 0x5a, 0x81, 0x83, 0x0e, 0x7e, 0x86, 0x7f, 0xa6, 0x83, 0x1c, 0x5e, 0x53, 0x87, 0x6f, + 0xc6, 0xdb, 0x80, 0xdd, 0x8e, 0xde, 0x42, 0x70, 0x27, 0x81, 0x35, 0xee, 0xdf, 0x04, 0x24, 0x1d, + 0xb8, 0x09, 0x08, 0x3f, 0x52, 0xab, 0xef, 0x64, 0xbf, 0x75, 0x7c, 0x8d, 0x64, 0xe1, 0x0f, 0xb5, + 0xc6, 0xee, 0xae, 0x90, 0xe5, 0x7f, 0xca, 0x66, 0x84, 0x4a, 0x46, 0xf3, 0x94, 0xcc, 0x12, 0x15, + 0xdb, 0x87, 0x89, 0xe3, 0x28, 0xfd, 0x16, 0xff, 0xc5, 0x2c, 0xc8, 0xd5, 0xbb, 0x1d, 0xc3, 0x85, + 0x2f, 0x92, 0x46, 0x82, 0x19, 0xb9, 0xbd, 0x49, 0x1e, 0x78, 0x7b, 0x53, 0xb8, 0xeb, 0x9a, 0x15, + 0xd8, 0x75, 0x6d, 0xa0, 0x07, 0x5c, 0x7e, 0xd7, 0xf5, 0x36, 0x1a, 0xf0, 0x92, 0xec, 0xd9, 0x3e, + 0xb2, 0x8f, 0x48, 0x71, 0xb5, 0xfa, 0x44, 0x52, 0x3d, 0x77, 0x0b, 0x0d, 0xe8, 0x08, 0x40, 0x7e, + 0xbe, 0xd6, 0x68, 0xd4, 0x56, 0x8b, 0xc7, 0x70, 0x24, 0xb0, 0xda, 0x1a, 0x09, 0xaf, 0x55, 0xa9, + 0x56, 0x55, 0xad, 0x28, 0xe1, 0x10, 0x93, 0x95, 0xc6, 0x8a, 0x5a, 0x94, 0xf9, 0xab, 0x3c, 0x62, + 0xcd, 0x6f, 0xbe, 0xec, 0x34, 0xd5, 0x4b, 0xcc, 0x10, 0x8f, 0xe6, 0x27, 0x7d, 0xe5, 0xfa, 0x6d, + 0x19, 0xe4, 0x56, 0x91, 0xbd, 0x85, 0xe0, 0x53, 0x13, 0x6c, 0xf2, 0x6d, 0x1a, 0xb6, 0x43, 0x02, + 0x72, 0x86, 0x9b, 0x7c, 0x6c, 0x9a, 0x72, 0x1d, 0x98, 0x71, 0x50, 0xcb, 0x32, 0xdb, 0x7e, 0x26, + 0xd2, 0x1f, 0xf1, 0x89, 0xf0, 0x85, 0x09, 0x21, 0xc3, 0x8c, 0x8e, 0x64, 0xa7, 0x2e, 0x09, 0x30, + 0xfd, 0x4a, 0x4d, 0x1f, 0x98, 0xef, 0xc8, 0xde, 0x4f, 0xdd, 0x7d, 0xf8, 0x42, 0xe1, 0xdd, 0xd7, + 0x9b, 0x40, 0x7e, 0xc3, 0x8f, 0xec, 0x2e, 0x47, 0xf6, 0xc7, 0x34, 0x8f, 0x32, 0x0f, 0x4e, 0x38, + 0xa8, 0x83, 0x5a, 0x2e, 0x6a, 0x7b, 0x4d, 0x57, 0x1b, 0xd8, 0x29, 0x1c, 0xcc, 0x0e, 0xff, 0x92, + 0x05, 0xf0, 0x0e, 0x1e, 0xc0, 0xeb, 0xfb, 0x88, 0xd2, 0xab, 0x50, 0xb4, 0xad, 0xec, 0x55, 0xa3, + 0xde, 0xb1, 0x82, 0x45, 0x71, 0xff, 0xdd, 0xfb, 0xb6, 0xed, 0xee, 0x74, 0xf0, 0x37, 0x7a, 0xc0, + 0xc0, 0x7f, 0x57, 0xe6, 0xc0, 0x84, 0x6e, 0xee, 0xe3, 0x4f, 0xd9, 0x98, 0x5a, 0xfb, 0x99, 0xe0, + 0x4b, 0x03, 0xe4, 0xef, 0xe2, 0x90, 0x7f, 0xb4, 0x18, 0xbb, 0xe9, 0x03, 0xff, 0x8b, 0x13, 0x20, + 0xb7, 0xa6, 0x3b, 0x2e, 0x82, 0xff, 0xaf, 0x2c, 0x8a, 0xfc, 0xf5, 0x60, 0x76, 0xd3, 0x6a, 0xed, + 0x3a, 0xa8, 0xcd, 0x37, 0xca, 0x9e, 0xd4, 0x51, 0x60, 0xae, 0xdc, 0x08, 0x8a, 0x7e, 0x22, 0x25, + 0xeb, 0x6f, 0xc3, 0x1f, 0x48, 0xc7, 0x17, 0x43, 0x38, 0x6b, 0xba, 0xed, 0xd6, 0x36, 0x71, 0x5a, + 0x70, 0x31, 0x04, 0x9b, 0xc8, 0x41, 0x9f, 0x8f, 0x81, 0x7e, 0x22, 0x1a, 0xfa, 0x82, 0x00, 0xf4, + 0x4a, 0x09, 0x14, 0x36, 0x8d, 0x0e, 0xc2, 0x3f, 0x4c, 0xe2, 0x1f, 0xfa, 0x8d, 0x49, 0x58, 0xf6, + 0xc1, 0x98, 0xb4, 0x68, 0x74, 0x90, 0x16, 0xfc, 0xe6, 0x4f, 0x64, 0x40, 0x38, 0x91, 0x59, 0x21, + 0xfe, 0xb4, 0x9e, 0xe1, 0x65, 0xea, 0x3b, 0xc8, 0x5f, 0x7c, 0x33, 0xe9, 0xe1, 0x96, 0xb6, 0xee, + 0xea, 0x18, 0x8c, 0x69, 0x0d, 0x3f, 0xf3, 0x7e, 0x21, 0x72, 0xaf, 0x5f, 0xc8, 0x33, 0xe5, 0x64, + 0x3d, 0xa2, 0xcf, 0x6c, 0x44, 0x8b, 0xda, 0xf0, 0x01, 0x22, 0x96, 0x62, 0xf0, 0xee, 0x01, 0xd3, + 0xd2, 0x6d, 0xe4, 0xae, 0xb1, 0x9e, 0x18, 0x39, 0x8d, 0x4f, 0xc4, 0xae, 0x7c, 0x4e, 0x5d, 0xdf, + 0x21, 0x97, 0x43, 0x94, 0xbd, 0x6f, 0xd4, 0x45, 0xeb, 0x40, 0x7a, 0xd8, 0xff, 0xe6, 0x46, 0xdd, + 0xff, 0xf6, 0xab, 0x63, 0xfa, 0xcd, 0xf0, 0xe5, 0x59, 0x20, 0x97, 0x77, 0xdd, 0x87, 0x75, 0xf7, + 0xfb, 0x03, 0x61, 0x3f, 0x17, 0xda, 0x9f, 0xed, 0xba, 0x47, 0xdb, 0xfb, 0x26, 0xd4, 0x12, 0x31, + 0x7f, 0x9a, 0xa8, 0xba, 0xa5, 0xaf, 0x23, 0xaf, 0x97, 0x03, 0x07, 0xcb, 0x07, 0x33, 0x87, 0x37, + 0xcd, 0x21, 0xe9, 0x9f, 0x98, 0x9e, 0x21, 0x78, 0xf7, 0x3b, 0x9e, 0x2c, 0x17, 0xdf, 0x14, 0x6f, + 0xaf, 0x63, 0x51, 0x4e, 0x6b, 0xe4, 0x05, 0xbe, 0x58, 0xd8, 0xed, 0x9c, 0x88, 0x2d, 0xd6, 0x95, + 0x30, 0x99, 0x4d, 0x25, 0x76, 0x37, 0x76, 0x4c, 0xb1, 0xe9, 0x03, 0xf6, 0x2d, 0xd6, 0x55, 0xb0, + 0x74, 0x68, 0xc4, 0xe0, 0xcb, 0x84, 0xb7, 0xa3, 0x48, 0xb5, 0x07, 0xac, 0x17, 0x26, 0x93, 0xb7, + 0xd8, 0x66, 0x55, 0x6c, 0xc1, 0xe9, 0x4b, 0xfc, 0x9b, 0x32, 0xc8, 0x93, 0x2d, 0x48, 0xf8, 0x5a, + 0xe1, 0x26, 0xe2, 0xf5, 0x46, 0xbc, 0x0b, 0x61, 0xf0, 0x9e, 0x64, 0xcd, 0x81, 0x73, 0x35, 0xcc, + 0x26, 0x72, 0x35, 0xe4, 0xcf, 0x71, 0x0a, 0xb4, 0x23, 0x52, 0xc7, 0x94, 0xa7, 0x93, 0x49, 0x5a, + 0x58, 0x5f, 0x86, 0xd2, 0xc7, 0xfb, 0x97, 0x73, 0x60, 0x9a, 0x14, 0x7d, 0xc1, 0x68, 0x6f, 0x21, + 0x17, 0xbe, 0x55, 0xfa, 0xe1, 0x41, 0x5d, 0xa9, 0x82, 0xe9, 0x4b, 0x98, 0x6d, 0x72, 0x8b, 0x15, + 0x5d, 0xb9, 0xb8, 0x31, 0x76, 0xdd, 0x83, 0xd4, 0xd3, 0xbf, 0xf7, 0x8a, 0xfb, 0xdf, 0x93, 0x31, + 0x59, 0xf0, 0x27, 0x0e, 0x5c, 0x79, 0x6c, 0x64, 0xb1, 0x49, 0xca, 0x69, 0x90, 0xdf, 0x33, 0xd0, + 0xa5, 0x4a, 0x9b, 0x5a, 0xb7, 0xf4, 0x0d, 0xfe, 0x89, 0xf0, 0xbe, 0x2d, 0x0b, 0x37, 0xe5, 0x25, + 0x5d, 0x2d, 0x14, 0xdb, 0xbd, 0x1d, 0xc8, 0xd6, 0x18, 0xce, 0x14, 0xf3, 0x77, 0x4f, 0x97, 0x13, + 0x28, 0x62, 0x94, 0xe1, 0xcc, 0x87, 0xf2, 0x88, 0x3d, 0xb1, 0x42, 0x04, 0x30, 0xe2, 0x6b, 0xa9, + 0xc5, 0xe2, 0x4b, 0x0c, 0x28, 0x3a, 0x7d, 0xc9, 0xbf, 0x52, 0x06, 0x93, 0x75, 0xe4, 0x2e, 0x1a, + 0xa8, 0xd3, 0x76, 0xa0, 0x7d, 0x78, 0xd3, 0xe8, 0x66, 0x90, 0xdf, 0xc4, 0xc4, 0x06, 0x9d, 0x5b, + 0xa0, 0xd9, 0xe0, 0xcb, 0x25, 0xd1, 0x1d, 0x61, 0xba, 0xfa, 0xe6, 0x73, 0x3b, 0x12, 0x98, 0xc4, + 0x3c, 0x7a, 0xe3, 0x4b, 0x1e, 0x43, 0x30, 0x70, 0x19, 0x4c, 0xd3, 0xcb, 0x6a, 0x4b, 0x1d, 0x63, + 0xcb, 0x84, 0xbb, 0x23, 0x68, 0x21, 0xca, 0x63, 0x41, 0x4e, 0xf7, 0xa8, 0xd1, 0xad, 0x57, 0xd8, + 0xb7, 0xf3, 0xc4, 0xe5, 0x69, 0x24, 0x63, 0x82, 0xd0, 0xbb, 0xa1, 0x62, 0xfb, 0x3c, 0x8f, 0x31, + 0xf4, 0xee, 0xc0, 0xc2, 0xd3, 0x47, 0xec, 0xcb, 0x32, 0x38, 0x49, 0x19, 0x38, 0x8f, 0x6c, 0xd7, + 0x68, 0xe9, 0x1d, 0x82, 0xdc, 0x73, 0x32, 0xa3, 0x80, 0x6e, 0x19, 0xcc, 0xec, 0xb1, 0x64, 0x29, + 0x84, 0xe7, 0xfa, 0x42, 0xc8, 0x31, 0xa0, 0xf1, 0x3f, 0x26, 0x08, 0x61, 0xca, 0x49, 0x95, 0xa3, + 0x39, 0xc6, 0x10, 0xa6, 0xc2, 0x4c, 0xa4, 0x0f, 0xf1, 0xf3, 0x69, 0x68, 0x9e, 0xb0, 0xfb, 0xfc, + 0x9c, 0x30, 0xb6, 0xeb, 0x60, 0x0a, 0x63, 0x49, 0x7e, 0xa4, 0xcb, 0x10, 0x31, 0x4a, 0x1c, 0xf4, + 0x3b, 0xf4, 0x92, 0xc5, 0xe0, 0x5f, 0x8d, 0xa5, 0x03, 0x2f, 0x00, 0x10, 0x7e, 0x62, 0x3b, 0xe9, + 0x4c, 0x54, 0x27, 0x2d, 0x89, 0x75, 0xd2, 0xaf, 0x11, 0x0e, 0x96, 0xd2, 0x9f, 0xed, 0xc3, 0xab, + 0x87, 0x58, 0x98, 0x8c, 0xc1, 0xa5, 0xa7, 0xaf, 0x17, 0x2f, 0xa5, 0x7a, 0xb1, 0xb0, 0xdb, 0xed, + 0x18, 0x2d, 0x6f, 0x3e, 0xf5, 0xa1, 0x91, 0xcc, 0xa7, 0xd8, 0xfe, 0x40, 0xee, 0xe9, 0x0f, 0x0e, + 0x61, 0x49, 0xdf, 0x00, 0x8e, 0x93, 0x22, 0xca, 0x01, 0x5b, 0x39, 0x12, 0x0a, 0xa2, 0x27, 0x99, + 0x8f, 0x4b, 0x28, 0xa8, 0x04, 0x81, 0x10, 0x86, 0x58, 0xfa, 0x4c, 0x66, 0xec, 0x26, 0x55, 0x90, + 0x28, 0xce, 0xc6, 0xe0, 0x16, 0x9a, 0x25, 0xd6, 0xee, 0x3a, 0xbe, 0x07, 0x13, 0x7e, 0x21, 0x3b, + 0x8a, 0x11, 0xe1, 0x6e, 0x90, 0xc5, 0x2e, 0xee, 0x72, 0xe4, 0x92, 0x46, 0x58, 0x64, 0x78, 0x49, + 0x29, 0x7a, 0xc0, 0x5d, 0x3e, 0xa6, 0xe1, 0x3f, 0x95, 0x1b, 0xc1, 0xf1, 0x0d, 0xbd, 0x75, 0x71, + 0xcb, 0xb6, 0x76, 0xf1, 0x8d, 0x81, 0x16, 0xbd, 0x7a, 0x10, 0x5f, 0xe1, 0xca, 0x7f, 0x50, 0x6e, + 0xf5, 0x4d, 0x87, 0xdc, 0x20, 0xd3, 0x61, 0xf9, 0x18, 0x35, 0x1e, 0x94, 0x5b, 0x82, 0x4e, 0x27, + 0x1f, 0xdb, 0xe9, 0x2c, 0x1f, 0xf3, 0xbb, 0x1d, 0x65, 0x01, 0x14, 0xda, 0xc6, 0x1e, 0xde, 0xaa, + 0xc6, 0xb3, 0xae, 0x41, 0x47, 0x97, 0x17, 0x8c, 0x3d, 0xb2, 0xb1, 0xbd, 0x7c, 0x4c, 0x0b, 0xfe, + 0x54, 0x96, 0xc0, 0x24, 0xde, 0x16, 0xc0, 0x64, 0x0a, 0x89, 0x8e, 0x25, 0x2f, 0x1f, 0xd3, 0xc2, + 0x7f, 0x3d, 0xeb, 0x23, 0x8b, 0xcf, 0x7e, 0xdc, 0xe5, 0x6f, 0xb7, 0x67, 0x12, 0x6d, 0xb7, 0x7b, + 0xb2, 0x20, 0x1b, 0xee, 0xa7, 0x41, 0xae, 0x85, 0x25, 0x2c, 0x51, 0x09, 0x93, 0x57, 0xe5, 0x0e, + 0x90, 0xdd, 0xd1, 0x6d, 0x7f, 0xf2, 0x7c, 0xfd, 0x60, 0xba, 0xab, 0xba, 0x7d, 0xd1, 0x43, 0xd0, + 0xfb, 0x6b, 0x7e, 0x02, 0xe4, 0xb0, 0xe0, 0x82, 0x07, 0xf8, 0xfa, 0x2c, 0x31, 0x43, 0xca, 0x96, + 0xe9, 0x0d, 0xfb, 0x0d, 0xcb, 0x3f, 0x20, 0xf3, 0x27, 0x99, 0xd1, 0x58, 0x90, 0x97, 0x31, 0x01, + 0x83, 0x4d, 0xe3, 0xa9, 0xbb, 0xe8, 0x5e, 0xb4, 0x4f, 0x97, 0x44, 0xfb, 0x7d, 0xea, 0xb9, 0x4f, + 0x3e, 0xdb, 0x7b, 0x9f, 0x7c, 0xb8, 0x7c, 0x90, 0x1b, 0xec, 0xa8, 0xf2, 0x97, 0x43, 0x98, 0x2e, + 0xbd, 0x82, 0x88, 0x9e, 0x81, 0x77, 0x0c, 0x93, 0xa9, 0xb3, 0xff, 0x9a, 0xb0, 0x53, 0x4a, 0x6a, + 0xd4, 0x0c, 0x60, 0x2f, 0xfd, 0xbe, 0xe9, 0x0f, 0xb3, 0x24, 0x66, 0x2a, 0x39, 0x85, 0xc1, 0xdf, + 0xd1, 0x0b, 0x3f, 0x31, 0x12, 0xa5, 0xe9, 0x33, 0xe0, 0xc8, 0x7d, 0x07, 0x9c, 0x03, 0x87, 0x94, + 0xb3, 0x03, 0x0e, 0x29, 0xe7, 0x92, 0xad, 0x1c, 0xbe, 0x8f, 0xd5, 0x9f, 0x35, 0x5e, 0x7f, 0x6e, + 0x8f, 0x00, 0xa8, 0x9f, 0x5c, 0x46, 0x62, 0xdf, 0xbc, 0x39, 0xd0, 0x94, 0x3a, 0xa7, 0x29, 0x77, + 0x0d, 0xcf, 0x48, 0xfa, 0xda, 0xf2, 0x9e, 0x2c, 0xb8, 0x2c, 0x64, 0xa6, 0x8a, 0x2e, 0x51, 0x45, + 0xf9, 0xec, 0x48, 0x14, 0x25, 0x79, 0x0c, 0x84, 0xb4, 0x35, 0xe6, 0xcf, 0x85, 0xcf, 0x0e, 0xf5, + 0x02, 0x15, 0xc8, 0x26, 0x42, 0x59, 0x4e, 0x83, 0x3c, 0xe9, 0x61, 0x28, 0x34, 0xf4, 0x2d, 0x61, + 0x77, 0x23, 0x76, 0xe2, 0x48, 0x94, 0xb7, 0x31, 0xe8, 0x0f, 0x5d, 0xd7, 0x68, 0xec, 0xda, 0x66, + 0xc5, 0x74, 0x2d, 0xf8, 0x0b, 0x23, 0x51, 0x9c, 0xc0, 0x1b, 0x4e, 0x1e, 0xc6, 0x1b, 0x6e, 0xa8, + 0x55, 0x0e, 0xbf, 0x06, 0x47, 0xb2, 0xca, 0x11, 0x51, 0x78, 0xfa, 0xf8, 0xbd, 0x49, 0x06, 0xa7, + 0xe9, 0x64, 0x6b, 0x9e, 0xb7, 0x10, 0xe1, 0x7d, 0xa3, 0x00, 0xf2, 0xa4, 0x6f, 0x26, 0xd1, 0x9b, + 0x21, 0xf1, 0x0b, 0x7f, 0x52, 0x2a, 0xf6, 0x4e, 0x1c, 0x6e, 0x3a, 0xd8, 0xc3, 0xe1, 0x48, 0x90, + 0x12, 0xbb, 0x0a, 0x27, 0x01, 0x1b, 0xe9, 0x63, 0xf6, 0x3c, 0x19, 0xe4, 0xc9, 0x39, 0x2d, 0xb8, + 0x9e, 0x8a, 0xc3, 0x04, 0x1f, 0xe5, 0x59, 0x60, 0x47, 0x8e, 0x70, 0x93, 0xda, 0x19, 0xb6, 0x24, + 0x7b, 0x71, 0x7d, 0x59, 0x19, 0x83, 0x0b, 0xa1, 0x04, 0xa6, 0xea, 0xc8, 0x2d, 0xeb, 0xb6, 0x6d, + 0xe8, 0x5b, 0xa3, 0xf2, 0xf8, 0x16, 0xf5, 0x1e, 0x86, 0xdf, 0xcd, 0x88, 0x9e, 0xa7, 0x09, 0x16, + 0xc2, 0x7d, 0x56, 0x23, 0x62, 0x09, 0x3e, 0x24, 0x74, 0x66, 0x66, 0x10, 0xb5, 0x31, 0x78, 0x6c, + 0x4b, 0x60, 0xc2, 0x3f, 0x8b, 0x77, 0x33, 0x77, 0x3e, 0x73, 0xdb, 0xdd, 0xf1, 0x8f, 0xc1, 0xe0, + 0xe7, 0x83, 0x67, 0xc0, 0xe0, 0x4b, 0x12, 0x3a, 0xca, 0xc7, 0x1f, 0x24, 0x4c, 0xd6, 0xc6, 0x92, + 0xb8, 0xc3, 0x1f, 0xd5, 0xd1, 0xc1, 0x77, 0x4f, 0xd0, 0xe5, 0xc8, 0x15, 0xdd, 0x45, 0x0f, 0xc0, + 0xcf, 0xc9, 0x60, 0xa2, 0x8e, 0x5c, 0x6f, 0xbc, 0xe5, 0x2e, 0x84, 0x1e, 0x56, 0xc3, 0x15, 0x66, + 0xc5, 0x63, 0x92, 0xae, 0x61, 0xdc, 0x03, 0x26, 0xbb, 0xb6, 0xd5, 0x42, 0x8e, 0x43, 0x57, 0x2f, + 0x58, 0x47, 0xb5, 0x7e, 0xa3, 0x3f, 0x66, 0x6d, 0x6e, 0xcd, 0xff, 0x47, 0x0b, 0x7f, 0x4f, 0x6a, + 0x06, 0x10, 0x4a, 0xb4, 0x82, 0xe3, 0x36, 0x03, 0xe2, 0x0a, 0x4f, 0x1f, 0xe8, 0x4f, 0xcb, 0x60, + 0xba, 0x8e, 0xdc, 0x40, 0x8a, 0x09, 0x36, 0x39, 0xa2, 0xe1, 0xe5, 0xa0, 0x94, 0x0f, 0x07, 0xa5, + 0xf8, 0x75, 0xaa, 0xbc, 0x34, 0x03, 0x62, 0x63, 0xbc, 0x4e, 0x55, 0x8c, 0x83, 0x31, 0x1c, 0x5f, + 0x7b, 0x24, 0x98, 0xc4, 0xbc, 0xe0, 0x06, 0xfb, 0xab, 0xd9, 0xb0, 0xf1, 0x7e, 0x3e, 0xa5, 0xc6, + 0x7b, 0x27, 0xc8, 0xed, 0xe8, 0xf6, 0x45, 0x07, 0x37, 0xdc, 0x29, 0x11, 0xb3, 0x7d, 0xd5, 0xcb, + 0xae, 0x91, 0xbf, 0xfa, 0xfb, 0x69, 0xe6, 0x92, 0xf9, 0x69, 0x3e, 0x24, 0x25, 0x1a, 0x09, 0xc9, + 0xdc, 0x61, 0x84, 0x4d, 0x3e, 0xc1, 0xb8, 0x19, 0x53, 0x76, 0xfa, 0xca, 0xf1, 0x1c, 0x19, 0x14, + 0xbc, 0x71, 0x1b, 0xdb, 0xe3, 0x17, 0x0e, 0xaf, 0x0e, 0xfd, 0x0d, 0xfd, 0x84, 0x3d, 0xb0, 0x2f, + 0x91, 0xd1, 0x99, 0xf7, 0x09, 0x7a, 0xe0, 0xb8, 0xc2, 0xd3, 0xc7, 0xe3, 0x2d, 0x04, 0x0f, 0xdc, + 0x1e, 0xe0, 0xab, 0x64, 0x20, 0x2f, 0x21, 0x77, 0xdc, 0x56, 0xe4, 0x1b, 0x84, 0x43, 0x1c, 0x71, + 0x02, 0xc3, 0x3c, 0xcf, 0x2d, 0xa1, 0xd1, 0x34, 0x20, 0xb1, 0xd8, 0x46, 0x42, 0x0c, 0xa4, 0x8f, + 0xda, 0x3b, 0x08, 0x6a, 0x64, 0x73, 0xe1, 0xe7, 0x47, 0xd0, 0xab, 0x8e, 0x77, 0xe1, 0xc3, 0x17, + 0x20, 0xa6, 0x71, 0x54, 0xed, 0xad, 0x5f, 0xe1, 0x63, 0xb9, 0xbe, 0x14, 0x78, 0x8d, 0x7d, 0x1b, + 0xb5, 0x2e, 0xa2, 0x36, 0x7b, 0x1d, 0xdc, 0xb0, 0xd0, 0x9d, 0x01, 0x13, 0x2d, 0x42, 0x0d, 0x83, + 0x57, 0xd0, 0xfc, 0xd7, 0x04, 0x77, 0xf1, 0xf3, 0x1d, 0x11, 0xf9, 0x7d, 0x8c, 0x77, 0xf1, 0x0b, + 0x14, 0x3f, 0x06, 0xb3, 0x85, 0xcc, 0x32, 0x2a, 0x2d, 0xcb, 0x84, 0xff, 0xe5, 0xf0, 0xb0, 0x5c, + 0x05, 0x26, 0x8d, 0x96, 0x65, 0xe2, 0x30, 0x14, 0xfe, 0x21, 0xa0, 0x20, 0xc1, 0xff, 0xaa, 0xee, + 0x58, 0xf7, 0x1b, 0x74, 0xd7, 0x3c, 0x4c, 0x18, 0xd6, 0x98, 0xf0, 0x58, 0x3f, 0x2a, 0x63, 0xa2, + 0x4f, 0xd9, 0xe9, 0x43, 0xf6, 0xe1, 0xd0, 0xbb, 0x8d, 0x74, 0x85, 0x0f, 0x8b, 0x55, 0xe0, 0x61, + 0x86, 0x33, 0xb6, 0x16, 0x47, 0x32, 0x9c, 0xc5, 0x30, 0x30, 0x86, 0x1b, 0x2b, 0x42, 0x1c, 0x53, + 0x5f, 0x03, 0x3e, 0x04, 0x3a, 0xa3, 0x33, 0x0f, 0x87, 0x44, 0xe7, 0x68, 0x4c, 0xc4, 0xf7, 0xd2, + 0x10, 0x99, 0xd4, 0xe2, 0x81, 0xff, 0x75, 0x14, 0xe0, 0xdc, 0x3e, 0x8c, 0xbf, 0x02, 0xf1, 0x56, + 0x80, 0xaf, 0x93, 0x44, 0x43, 0xa0, 0x1c, 0x90, 0xa0, 0x47, 0x65, 0x24, 0x08, 0xbe, 0x46, 0x28, + 0x36, 0x89, 0x48, 0xf9, 0xe9, 0x03, 0xf8, 0x6c, 0x19, 0xcc, 0x62, 0x1f, 0x81, 0x0e, 0xd2, 0x6d, + 0xd2, 0x51, 0x8e, 0xc4, 0x51, 0xfe, 0x2d, 0xc2, 0x01, 0x7e, 0x78, 0x39, 0x84, 0x7c, 0x8c, 0x04, + 0x0a, 0xb1, 0xe8, 0x3e, 0x82, 0x2c, 0x8c, 0x65, 0x1b, 0xa5, 0x18, 0xb0, 0x40, 0x55, 0x7c, 0x34, + 0x78, 0x24, 0xf4, 0xc8, 0xe5, 0x85, 0xe1, 0x37, 0xb6, 0x31, 0x7b, 0xe4, 0x8a, 0x30, 0x91, 0x3e, + 0x26, 0xaf, 0x7a, 0x2c, 0x5d, 0x70, 0x6e, 0xe8, 0x1b, 0x1d, 0x04, 0x5f, 0x96, 0x0d, 0x4e, 0xb4, + 0x7d, 0x7a, 0x24, 0x1e, 0x98, 0x87, 0x08, 0x88, 0xaf, 0x80, 0xac, 0x6d, 0x5d, 0x22, 0x4b, 0x5b, + 0x33, 0x1a, 0x7e, 0x26, 0xd7, 0x53, 0x76, 0x76, 0x77, 0x4c, 0x72, 0x32, 0x74, 0x46, 0xf3, 0x5f, + 0x95, 0xeb, 0xc0, 0xcc, 0x25, 0xc3, 0xdd, 0x5e, 0x46, 0x7a, 0x1b, 0xd9, 0x9a, 0x75, 0x09, 0x7b, + 0xcc, 0x15, 0x34, 0x3e, 0x91, 0xf7, 0x5f, 0x11, 0xb0, 0x2f, 0x3d, 0xa1, 0x8c, 0xe7, 0xf8, 0x5b, + 0x12, 0xcb, 0x33, 0x9a, 0xab, 0xf4, 0x15, 0xe6, 0x9d, 0x32, 0x98, 0xd4, 0xac, 0x4b, 0x54, 0x49, + 0xfe, 0xef, 0xa3, 0xd5, 0x91, 0xc4, 0x13, 0x3d, 0x2c, 0xb9, 0x80, 0xfd, 0xb1, 0x4f, 0xf4, 0x62, + 0x8b, 0x1f, 0xcb, 0xc9, 0xa5, 0x69, 0xcd, 0xba, 0x54, 0x47, 0x2e, 0x69, 0x11, 0xb0, 0x39, 0x22, + 0x27, 0x6b, 0xc3, 0x21, 0x04, 0xe9, 0x3c, 0x3c, 0x78, 0x4f, 0xba, 0x8b, 0x10, 0x08, 0x28, 0x60, + 0x71, 0xdc, 0xbb, 0x08, 0x03, 0x39, 0x18, 0x43, 0x8c, 0x14, 0x19, 0x4c, 0x69, 0xd6, 0x25, 0x6f, + 0x68, 0x58, 0x34, 0x3a, 0x9d, 0xd1, 0x8c, 0x90, 0x49, 0x8d, 0x7f, 0x5f, 0x0c, 0x3e, 0x17, 0x63, + 0x37, 0xfe, 0x07, 0x30, 0x90, 0x3e, 0x0c, 0xcf, 0x24, 0x8d, 0xc5, 0x1f, 0xa1, 0xcd, 0xd1, 0xe0, + 0x30, 0x6c, 0x83, 0x08, 0xd8, 0x38, 0xb2, 0x06, 0x11, 0xc5, 0xc1, 0x58, 0x76, 0x4e, 0x66, 0xcb, + 0x78, 0x98, 0x1f, 0x6d, 0x9b, 0x78, 0x5b, 0x32, 0xd7, 0x44, 0x3a, 0xec, 0x72, 0x8c, 0x8c, 0x04, + 0x8d, 0x04, 0x2e, 0x88, 0x02, 0x3c, 0xa4, 0x8f, 0xc7, 0x07, 0x64, 0x30, 0x4d, 0x58, 0x78, 0x98, + 0x58, 0x01, 0x43, 0x35, 0x2a, 0xb6, 0x06, 0x47, 0xd3, 0xa8, 0x62, 0x38, 0x18, 0xcb, 0xad, 0xa0, + 0x9e, 0x1d, 0x37, 0xc4, 0xf1, 0xf1, 0x28, 0x04, 0x87, 0x36, 0xc6, 0x46, 0x78, 0x84, 0x7c, 0x18, + 0x63, 0xec, 0x88, 0x8e, 0x91, 0x3f, 0x33, 0x68, 0x45, 0xa3, 0xc4, 0xe0, 0x10, 0x4d, 0x61, 0x84, + 0x30, 0x0c, 0xd9, 0x14, 0x8e, 0x08, 0x89, 0xaf, 0xc8, 0x00, 0x10, 0x06, 0x56, 0xad, 0x3d, 0x7c, + 0x99, 0xcf, 0x08, 0xba, 0xb3, 0x5e, 0xb7, 0x7a, 0x79, 0x80, 0x5b, 0x7d, 0xc2, 0x10, 0x2e, 0x49, + 0x57, 0x02, 0x19, 0x29, 0x7b, 0x95, 0x1c, 0xfb, 0x4a, 0x60, 0x7c, 0xf9, 0xe9, 0x63, 0xfc, 0x25, + 0x62, 0xcd, 0x85, 0x07, 0x4c, 0x7f, 0x67, 0x24, 0x28, 0x33, 0xb3, 0x7f, 0x99, 0x9f, 0xfd, 0x1f, + 0x02, 0xdb, 0x61, 0x6d, 0xc4, 0x41, 0x07, 0x47, 0xd3, 0xb7, 0x11, 0x8f, 0xee, 0x80, 0xe8, 0xcf, + 0x67, 0xc1, 0x71, 0xda, 0x89, 0xfc, 0x30, 0x40, 0x9c, 0xf0, 0x1c, 0x1e, 0xd7, 0x49, 0x0e, 0x40, + 0x79, 0x54, 0x0b, 0x52, 0x49, 0x96, 0x32, 0x05, 0xd8, 0x1b, 0xcb, 0xea, 0x46, 0x5e, 0x7d, 0xa0, + 0xab, 0x9b, 0x6d, 0xf1, 0x70, 0xbf, 0x03, 0x80, 0xf7, 0xd7, 0x1a, 0x65, 0x7e, 0xad, 0xb1, 0xcf, + 0xca, 0x64, 0xe2, 0x9d, 0x6b, 0x2c, 0x32, 0xc2, 0xee, 0xd8, 0x77, 0xae, 0xa3, 0xcb, 0x4e, 0x1f, + 0xa5, 0xb7, 0xc9, 0x20, 0x5b, 0xb7, 0x6c, 0x17, 0x3e, 0x2b, 0x49, 0xeb, 0x24, 0x92, 0x0f, 0x41, + 0xf2, 0xdf, 0x95, 0x32, 0x77, 0x4b, 0xf3, 0xcd, 0xf1, 0x47, 0x9d, 0x75, 0x57, 0xc7, 0x5e, 0xdd, + 0x5e, 0xf9, 0xcc, 0x75, 0xcd, 0x49, 0xe3, 0xe9, 0x10, 0xf9, 0xd5, 0xa3, 0x0f, 0x60, 0xa4, 0x16, + 0x4f, 0x27, 0xb2, 0xe4, 0xf4, 0x71, 0x7b, 0xc5, 0x71, 0xea, 0xdb, 0xba, 0x68, 0x74, 0x10, 0x7c, + 0x16, 0x71, 0x19, 0xa9, 0xea, 0x3b, 0x48, 0xfc, 0x48, 0x4c, 0xac, 0x6b, 0x2b, 0x8e, 0x2f, 0x2b, + 0x87, 0xf1, 0x65, 0x93, 0x36, 0x28, 0x72, 0x00, 0x9d, 0xb0, 0x34, 0xee, 0x06, 0x15, 0x53, 0xf6, + 0x58, 0xe2, 0x74, 0x9e, 0xa8, 0x23, 0x97, 0x18, 0x95, 0x35, 0xff, 0x06, 0x96, 0x9f, 0x1d, 0x49, + 0xc4, 0xce, 0xe0, 0x82, 0x17, 0xb9, 0xe7, 0x82, 0x97, 0x77, 0xb2, 0xe0, 0xac, 0xf2, 0xe0, 0xfc, + 0x64, 0xb4, 0x80, 0x78, 0x26, 0x47, 0x02, 0xd3, 0x1b, 0x02, 0x98, 0xd6, 0x38, 0x98, 0xee, 0x18, + 0x92, 0x8b, 0xf4, 0x01, 0xfb, 0xf5, 0x1c, 0x38, 0x4e, 0x26, 0xfd, 0x25, 0xb3, 0x4d, 0x23, 0xac, + 0xbe, 0x56, 0x3a, 0xe2, 0xcd, 0xb6, 0x83, 0x21, 0x58, 0xb9, 0x58, 0xce, 0xb9, 0xde, 0xdb, 0xf1, + 0xe7, 0x49, 0x38, 0x57, 0xaf, 0x13, 0xc5, 0x3b, 0x6d, 0xe2, 0x37, 0xe4, 0x07, 0xff, 0xf1, 0x77, + 0x19, 0x4d, 0x88, 0xdf, 0x65, 0xf4, 0x17, 0xc9, 0xd6, 0xed, 0x70, 0xd1, 0x3d, 0x02, 0x4f, 0xd9, + 0x76, 0x4a, 0xb0, 0xa2, 0x27, 0xc0, 0xdd, 0x8f, 0x86, 0x3b, 0x59, 0x18, 0x41, 0x64, 0x48, 0x77, + 0x32, 0x4c, 0xe0, 0x28, 0xdd, 0xc9, 0x06, 0x31, 0x30, 0x86, 0x5b, 0xed, 0x73, 0x74, 0x37, 0x1f, + 0xb7, 0x1b, 0xf8, 0xb7, 0x52, 0xea, 0xa3, 0xf4, 0xf7, 0x32, 0x89, 0xfc, 0x9f, 0x31, 0x5f, 0xf1, + 0xc3, 0x74, 0x12, 0x8f, 0xe6, 0x38, 0x72, 0x63, 0x58, 0x37, 0x92, 0xb0, 0x2f, 0xfa, 0x05, 0xa3, + 0xed, 0x6e, 0x8f, 0xe8, 0x44, 0xc7, 0x25, 0x8f, 0x96, 0x7f, 0x3d, 0x32, 0x7e, 0x81, 0xff, 0x33, + 0x93, 0x28, 0x84, 0x54, 0x20, 0x12, 0xcc, 0x56, 0x84, 0x88, 0x13, 0x04, 0x7e, 0x8a, 0xa5, 0x37, + 0x46, 0x8d, 0x3e, 0x6f, 0xb4, 0x91, 0xf5, 0x30, 0xd4, 0x68, 0xcc, 0xd7, 0xe8, 0x34, 0x3a, 0x8e, + 0xdc, 0x8f, 0xa8, 0x46, 0x07, 0x22, 0x19, 0x91, 0x46, 0xc7, 0xd2, 0x4b, 0x5f, 0xc6, 0x2f, 0x99, + 0xa6, 0x13, 0xa9, 0x15, 0xc3, 0xbc, 0x08, 0xff, 0x35, 0xef, 0x5f, 0xcc, 0x7c, 0xc1, 0x70, 0xb7, + 0x69, 0x2c, 0x98, 0xf7, 0x08, 0xdf, 0x8d, 0x32, 0x44, 0xbc, 0x17, 0x3e, 0x9c, 0x54, 0xee, 0x40, + 0x38, 0xa9, 0x12, 0x98, 0x31, 0x4c, 0x17, 0xd9, 0xa6, 0xde, 0x59, 0xec, 0xe8, 0x5b, 0xce, 0x99, + 0x89, 0xbe, 0x97, 0xd7, 0x55, 0x98, 0x3c, 0x1a, 0xff, 0x07, 0x7b, 0x7d, 0x65, 0x81, 0xbf, 0xbe, + 0x32, 0x22, 0xfa, 0xd5, 0x64, 0x74, 0xf4, 0xab, 0x20, 0xba, 0x15, 0x18, 0x1c, 0x1c, 0x5b, 0xd4, + 0x36, 0x4e, 0x18, 0xee, 0xef, 0x66, 0xc1, 0x28, 0x6c, 0x41, 0xe8, 0xc7, 0xdf, 0x93, 0x13, 0xad, + 0xee, 0x79, 0x8a, 0x30, 0xd7, 0xab, 0x04, 0x89, 0x2d, 0x54, 0xb6, 0xf2, 0x72, 0x4f, 0xe5, 0x03, + 0x93, 0x27, 0x2b, 0x60, 0xf2, 0xb0, 0x4a, 0x95, 0x13, 0x53, 0xaa, 0x24, 0x8b, 0x85, 0x22, 0xb5, + 0x1d, 0xc3, 0x69, 0xa4, 0x1c, 0x38, 0xe1, 0x47, 0xbb, 0xed, 0x76, 0x91, 0x6e, 0xeb, 0x66, 0x0b, + 0xc1, 0x0f, 0x4b, 0xa3, 0x30, 0x7b, 0x17, 0x41, 0xc1, 0x68, 0x59, 0x66, 0xdd, 0x78, 0x9a, 0x7f, + 0xb9, 0x5c, 0x7c, 0x90, 0x75, 0x2c, 0x91, 0x0a, 0xfd, 0x43, 0x0b, 0xfe, 0x55, 0x2a, 0x60, 0xb2, + 0xa5, 0xdb, 0x6d, 0x12, 0x84, 0x2f, 0xd7, 0x73, 0x91, 0x53, 0x24, 0xa1, 0xb2, 0xff, 0x8b, 0x16, + 0xfe, 0xad, 0xd4, 0x78, 0x21, 0xe6, 0x7b, 0xa2, 0x79, 0x44, 0x12, 0x5b, 0x08, 0x7f, 0xe2, 0x64, + 0xee, 0x49, 0xc7, 0x46, 0x1d, 0x7c, 0x07, 0x3d, 0xe9, 0x21, 0x26, 0xb5, 0x30, 0x21, 0xe9, 0xf2, + 0x00, 0x2e, 0xea, 0x00, 0x1a, 0xe3, 0x5e, 0x1e, 0x10, 0xe2, 0x22, 0x7d, 0xcd, 0x7c, 0x73, 0x1e, + 0xcc, 0x90, 0x5e, 0x8d, 0x8a, 0x13, 0x3e, 0x1b, 0x5f, 0x21, 0xed, 0xde, 0x8b, 0xf6, 0x61, 0xfd, + 0xf0, 0x63, 0x72, 0x11, 0xc8, 0x17, 0x83, 0x80, 0x83, 0xde, 0x63, 0xd2, 0x7d, 0x7b, 0x9f, 0xaf, + 0x39, 0xc2, 0xd3, 0xb8, 0xf7, 0xed, 0xe3, 0x8b, 0x4f, 0x1f, 0x9f, 0xdf, 0x90, 0x81, 0x5c, 0x6a, + 0xb7, 0x61, 0xeb, 0xf0, 0x50, 0x5c, 0x03, 0xa6, 0xfc, 0x36, 0x13, 0xc6, 0x80, 0x64, 0x93, 0x92, + 0x2e, 0x82, 0x06, 0xb2, 0x29, 0xb5, 0xc7, 0xbe, 0xab, 0x10, 0x53, 0x76, 0xfa, 0xa0, 0x7c, 0x7e, + 0x82, 0x36, 0x9a, 0x79, 0xcb, 0xba, 0x88, 0x8f, 0xca, 0xfc, 0x81, 0x0c, 0x72, 0x8b, 0xc8, 0x6d, + 0x6d, 0x43, 0x67, 0x24, 0x6d, 0x66, 0xd7, 0xee, 0xf8, 0x6d, 0x66, 0xd7, 0xee, 0x0c, 0x0a, 0xca, + 0x99, 0x34, 0xfa, 0xb3, 0xcf, 0xf6, 0x1c, 0x66, 0x79, 0xdc, 0xd1, 0x9f, 0x63, 0x4b, 0x1f, 0xc3, + 0x21, 0xb8, 0x2c, 0x98, 0x0d, 0x56, 0xc0, 0x08, 0x66, 0x6f, 0xcc, 0x3c, 0xec, 0xd6, 0x43, 0x07, + 0xd8, 0xcd, 0xf0, 0xb3, 0xc9, 0x42, 0xac, 0x05, 0x32, 0xe7, 0x6b, 0x9e, 0xf2, 0xc2, 0x64, 0x82, + 0xe0, 0x6b, 0x62, 0x0c, 0x8e, 0x61, 0x05, 0x40, 0x06, 0x05, 0xcc, 0xd0, 0x82, 0xb1, 0x87, 0x5d, + 0x0f, 0xb9, 0x85, 0xca, 0xa7, 0x8f, 0x64, 0xa1, 0xf2, 0x0e, 0x7e, 0xa1, 0x52, 0x30, 0x62, 0xb2, + 0xbf, 0x4e, 0x99, 0xd0, 0x17, 0xc7, 0xfb, 0x7f, 0xe4, 0xcb, 0x94, 0x09, 0x7c, 0x71, 0x06, 0x94, + 0x3f, 0x06, 0xd7, 0xc3, 0xa7, 0xd0, 0xce, 0xda, 0xdf, 0x90, 0x85, 0xff, 0xfd, 0x04, 0xc8, 0x9e, + 0xf7, 0x1e, 0xfe, 0x47, 0x78, 0xa3, 0xd6, 0x0b, 0x47, 0x10, 0xdc, 0xe1, 0xc9, 0x20, 0xeb, 0xd1, + 0xa7, 0xd3, 0x9e, 0x1b, 0xc5, 0x76, 0x87, 0x3d, 0x46, 0x34, 0xfc, 0x9f, 0x72, 0x1a, 0xe4, 0x1d, + 0x6b, 0xd7, 0x6e, 0x79, 0xe6, 0xb7, 0xa7, 0x31, 0xf4, 0x2d, 0x69, 0x50, 0x53, 0x8e, 0xf4, 0xdc, + 0xe8, 0x5c, 0x4e, 0x99, 0x0b, 0x96, 0x64, 0xee, 0x82, 0xa5, 0x04, 0xfb, 0x0f, 0x02, 0xbc, 0xa5, + 0xaf, 0x11, 0x7f, 0x8b, 0xef, 0x1a, 0x6c, 0x8f, 0x0a, 0xf6, 0x08, 0xb1, 0x1c, 0x56, 0x1d, 0x92, + 0x3a, 0x8c, 0xf3, 0xa2, 0x0d, 0xe2, 0xc8, 0x8f, 0xd5, 0x61, 0x5c, 0x80, 0x87, 0xb1, 0x9c, 0x72, + 0xcf, 0x53, 0x27, 0xd7, 0xfb, 0x46, 0x89, 0x6e, 0x96, 0x53, 0xfa, 0x43, 0xa1, 0x33, 0x42, 0xe7, + 0xd7, 0xa1, 0xd1, 0x39, 0x22, 0xf7, 0xd7, 0x3f, 0x95, 0x71, 0x24, 0x4d, 0xdf, 0x08, 0x12, 0xbf, + 0x28, 0x29, 0x31, 0x44, 0xde, 0x18, 0xcc, 0xc5, 0x91, 0x9e, 0x19, 0x3e, 0xb4, 0x38, 0x2f, 0x3a, + 0x86, 0xff, 0x71, 0x87, 0x16, 0x17, 0x65, 0x24, 0x7d, 0x20, 0x7f, 0x9f, 0x5c, 0x4c, 0x56, 0x6a, + 0xb9, 0xc6, 0xde, 0x88, 0x5b, 0x1a, 0x3f, 0xbc, 0x24, 0x8c, 0x26, 0x7c, 0x40, 0x42, 0x84, 0xc3, + 0x71, 0x47, 0x13, 0x16, 0x63, 0x23, 0x7d, 0x98, 0xfe, 0x21, 0xef, 0x49, 0x8f, 0xae, 0xed, 0xbc, + 0x8a, 0xae, 0x26, 0xa0, 0xc3, 0xa3, 0x75, 0x0e, 0x4c, 0x33, 0x4b, 0x07, 0xfe, 0x85, 0x37, 0x5c, + 0x5a, 0xd2, 0x83, 0xf2, 0x81, 0xc8, 0x46, 0xbe, 0xb0, 0x90, 0x60, 0xc1, 0x58, 0x84, 0x89, 0xb1, + 0xdc, 0x27, 0xe7, 0x8f, 0x61, 0x63, 0xc2, 0xea, 0x3d, 0x2c, 0x56, 0x35, 0x1e, 0xab, 0xdb, 0x44, + 0xc4, 0x24, 0x36, 0xa6, 0x09, 0xcd, 0x1b, 0xdf, 0x14, 0xc0, 0xa5, 0x71, 0x70, 0x3d, 0x79, 0x68, + 0x3e, 0xd2, 0x47, 0xec, 0x45, 0xa4, 0x3b, 0xac, 0x13, 0x93, 0x7d, 0x34, 0xdd, 0x21, 0x9d, 0x0d, + 0xc8, 0xdc, 0x6c, 0x20, 0xa1, 0xbf, 0x7e, 0xe8, 0x86, 0xea, 0x33, 0x37, 0x08, 0xa2, 0xec, 0x88, + 0xfd, 0xf5, 0x07, 0x72, 0x90, 0x3e, 0x38, 0xdf, 0x96, 0x01, 0x58, 0xb2, 0xad, 0xdd, 0x6e, 0xcd, + 0x6e, 0x23, 0x1b, 0xfe, 0x7d, 0x38, 0x01, 0xf8, 0xcd, 0x11, 0x4c, 0x00, 0xd6, 0x00, 0xd8, 0x0a, + 0x88, 0x53, 0x0d, 0x7f, 0xac, 0x98, 0xb9, 0x1f, 0x32, 0xa5, 0x31, 0x34, 0xf8, 0x2b, 0x6b, 0x7f, + 0x8a, 0xc7, 0x38, 0xae, 0xcf, 0x0a, 0xc9, 0x8d, 0x72, 0x02, 0xf0, 0x96, 0x00, 0xeb, 0x06, 0x87, + 0xf5, 0xdd, 0x87, 0xe0, 0x24, 0x7d, 0xcc, 0xff, 0x65, 0x02, 0x4c, 0x91, 0xed, 0x3e, 0x22, 0xd3, + 0x7f, 0x0a, 0x41, 0xff, 0x9d, 0x11, 0x80, 0xbe, 0x0e, 0xa6, 0xad, 0x90, 0x3a, 0xe9, 0x53, 0xd9, + 0x05, 0x98, 0x58, 0xd8, 0x19, 0xbe, 0x34, 0x8e, 0x0c, 0xfc, 0x20, 0x8b, 0xbc, 0xc6, 0x23, 0x7f, + 0x47, 0x8c, 0xbc, 0x19, 0x8a, 0xa3, 0x84, 0xfe, 0xad, 0x01, 0xf4, 0xeb, 0x1c, 0xf4, 0xa5, 0xc3, + 0xb0, 0x32, 0x86, 0x70, 0xfd, 0x32, 0xc8, 0xe2, 0xd3, 0x75, 0x7f, 0x98, 0xe2, 0xfc, 0xfe, 0x0c, + 0x98, 0xc0, 0x4d, 0x36, 0x98, 0x77, 0xf8, 0xaf, 0xde, 0x17, 0x7d, 0xd3, 0x45, 0x76, 0xb0, 0x72, + 0xeb, 0xbf, 0x7a, 0x3c, 0xf8, 0x5e, 0xcd, 0xce, 0x99, 0x3c, 0xd9, 0xc8, 0x0c, 0x12, 0x86, 0x9e, + 0x94, 0xb0, 0x12, 0x1f, 0xd9, 0x79, 0xbb, 0x61, 0x26, 0x25, 0x03, 0x18, 0x49, 0x1f, 0xf8, 0x2f, + 0x64, 0xc1, 0x19, 0xb2, 0xaa, 0xb4, 0x68, 0x5b, 0x3b, 0x3d, 0xb7, 0x63, 0x19, 0x87, 0xd7, 0x85, + 0xeb, 0xc1, 0xac, 0xcb, 0xf9, 0x73, 0x53, 0x9d, 0xe8, 0x49, 0x85, 0x7f, 0xc9, 0xfa, 0x64, 0x3c, + 0x85, 0x47, 0x72, 0x3e, 0x46, 0x80, 0x51, 0xbc, 0x27, 0x5e, 0xa8, 0x17, 0x64, 0x94, 0x59, 0xa4, + 0x92, 0x87, 0x5a, 0xb3, 0x0c, 0x74, 0x2a, 0x27, 0xa2, 0x53, 0xef, 0x0a, 0x74, 0xea, 0x67, 0x38, + 0x9d, 0x5a, 0x3a, 0xbc, 0x48, 0xc6, 0xb0, 0x72, 0x31, 0x0b, 0xf2, 0x8b, 0x46, 0xc7, 0x45, 0x36, + 0xfc, 0x12, 0x9d, 0x47, 0xbd, 0x2c, 0xc5, 0xee, 0x65, 0x01, 0xe4, 0x37, 0x71, 0x69, 0xd4, 0x20, + 0xbb, 0x49, 0x0c, 0x1b, 0xc2, 0xa1, 0x46, 0xff, 0x4d, 0x1a, 0x3b, 0xae, 0x87, 0xcc, 0xc8, 0x26, + 0x60, 0x09, 0x62, 0xc7, 0x0d, 0x66, 0x61, 0x2c, 0xd7, 0x26, 0xe5, 0x35, 0xb4, 0xe3, 0x8d, 0x20, + 0x17, 0xd3, 0x43, 0xb8, 0x08, 0x64, 0xa3, 0xed, 0xe0, 0xa6, 0x37, 0xa9, 0x79, 0x8f, 0x49, 0x3d, + 0x59, 0x7a, 0x45, 0x45, 0x58, 0x1e, 0xb7, 0x27, 0x8b, 0x10, 0x17, 0xe9, 0x63, 0xf6, 0x3d, 0xec, + 0xc6, 0xd8, 0xed, 0xe8, 0x2d, 0xe4, 0x71, 0x9f, 0x1a, 0x6a, 0xb3, 0x40, 0x32, 0xfc, 0x11, 0x5f, + 0x32, 0xd8, 0x76, 0x9a, 0x3b, 0x44, 0x3b, 0x1d, 0x76, 0x91, 0x2b, 0x90, 0x39, 0xae, 0xf8, 0x91, + 0x2d, 0x72, 0xc5, 0xb2, 0x31, 0x86, 0x4b, 0x31, 0xfd, 0x63, 0x9e, 0x63, 0x6d, 0xad, 0xc3, 0x6e, + 0x01, 0x50, 0x61, 0x8d, 0xec, 0x48, 0xe7, 0x30, 0x5b, 0x00, 0xd1, 0x3c, 0x8c, 0x01, 0xad, 0x59, + 0x8a, 0xd6, 0x67, 0xe8, 0x30, 0x9a, 0xf2, 0x2e, 0x9c, 0x63, 0xd9, 0x6e, 0xb2, 0x5d, 0x38, 0x8f, + 0x3b, 0x0d, 0xff, 0x97, 0xf4, 0x58, 0x10, 0x7f, 0xea, 0x77, 0x54, 0xc3, 0x67, 0x82, 0x63, 0x41, + 0x83, 0x18, 0x48, 0x1f, 0xde, 0xd7, 0x1d, 0xd1, 0xe0, 0x39, 0x6c, 0x73, 0xa4, 0x6d, 0x60, 0x64, + 0x43, 0xe7, 0x30, 0xcd, 0x31, 0x9a, 0x87, 0xf4, 0xf1, 0xfa, 0x16, 0x33, 0x70, 0xbe, 0x66, 0x8c, + 0x03, 0xa7, 0xdf, 0x32, 0x73, 0x43, 0xb6, 0xcc, 0x61, 0x77, 0x17, 0xa8, 0xac, 0x47, 0x37, 0x60, + 0x0e, 0xb3, 0xbb, 0x10, 0xc3, 0x44, 0xfa, 0x88, 0xbf, 0x56, 0x06, 0xb9, 0xfa, 0xf8, 0xc7, 0xcb, + 0x61, 0xe7, 0x22, 0x58, 0x56, 0xf5, 0x91, 0x0d, 0x97, 0xc3, 0xcc, 0x45, 0x22, 0x59, 0x18, 0x43, + 0x58, 0xf8, 0xe3, 0x60, 0x1a, 0x4f, 0xb8, 0xfd, 0x4d, 0xbc, 0x6f, 0xd1, 0x51, 0xf3, 0xa1, 0x14, + 0xdb, 0xea, 0x3d, 0xa0, 0xe0, 0xef, 0x0e, 0xd1, 0x91, 0x73, 0x4e, 0xac, 0x7d, 0xfa, 0x5c, 0x6a, + 0xc1, 0xff, 0x87, 0xda, 0x6a, 0x1f, 0xf9, 0x4e, 0xe0, 0xb0, 0x5b, 0xed, 0x47, 0xba, 0x1b, 0xf8, + 0x17, 0xe1, 0x88, 0xfa, 0x5f, 0xd2, 0xc3, 0xbc, 0x77, 0x97, 0x30, 0xdb, 0x67, 0x97, 0xf0, 0xc3, + 0x2c, 0x96, 0x75, 0x1e, 0xcb, 0x3b, 0x45, 0x45, 0x38, 0xc2, 0xb1, 0xf6, 0x6d, 0x01, 0x9c, 0xe7, + 0x39, 0x38, 0xe7, 0x0f, 0xc5, 0xcb, 0x18, 0x8e, 0xe5, 0x65, 0xc3, 0x31, 0xf7, 0x23, 0x29, 0xb6, + 0xe3, 0x1e, 0x9f, 0xff, 0xec, 0x01, 0x9f, 0x7f, 0xae, 0xa5, 0xe7, 0x0e, 0xd9, 0xd2, 0x3f, 0xc2, + 0x6a, 0x47, 0x83, 0xd7, 0x8e, 0x27, 0x8b, 0x23, 0x32, 0xba, 0x91, 0xf9, 0xed, 0x81, 0x7a, 0x5c, + 0xe0, 0xd4, 0xa3, 0x7c, 0x38, 0x66, 0xd2, 0xd7, 0x8f, 0x8f, 0xf9, 0x13, 0xda, 0x23, 0x6e, 0xef, + 0xc3, 0x6e, 0x44, 0x72, 0x42, 0x1c, 0xd9, 0xc8, 0x3d, 0xcc, 0x46, 0xe4, 0x20, 0x4e, 0xc6, 0x10, + 0x29, 0x6c, 0x06, 0x4c, 0x61, 0x9e, 0x2e, 0x18, 0xed, 0x2d, 0xe4, 0xc2, 0xdf, 0x23, 0x1e, 0x70, + 0x7e, 0x5c, 0xc6, 0x11, 0x05, 0xcf, 0x89, 0x3a, 0x8d, 0x99, 0xd4, 0x5f, 0x80, 0x30, 0x39, 0xc7, + 0x30, 0x38, 0xee, 0xf8, 0x7e, 0x03, 0x39, 0x48, 0x1f, 0xb2, 0x0f, 0x12, 0x67, 0x8e, 0x15, 0x7d, + 0xdf, 0xda, 0x75, 0xe1, 0x83, 0x23, 0xe8, 0xa0, 0xe7, 0x41, 0xbe, 0x83, 0xa9, 0x51, 0xa7, 0xff, + 0xf8, 0xe9, 0x0e, 0x15, 0x01, 0x29, 0x5f, 0xa3, 0x7f, 0x26, 0xf5, 0xfc, 0x0f, 0xe5, 0x48, 0xe8, + 0x8c, 0xdb, 0xf3, 0x7f, 0x40, 0xf9, 0x63, 0xb9, 0x01, 0xa6, 0xe0, 0x95, 0x6e, 0xec, 0x18, 0xee, + 0x88, 0xe2, 0x0b, 0x74, 0x3c, 0x5a, 0x7e, 0x7c, 0x01, 0xfc, 0x92, 0xf4, 0x3c, 0x23, 0x23, 0x15, + 0xef, 0xf7, 0x71, 0x9f, 0x67, 0x8c, 0x2f, 0x3e, 0x7d, 0x4c, 0x7e, 0x9b, 0xb4, 0xac, 0xf3, 0xc4, + 0xb5, 0x33, 0x45, 0xaf, 0xd1, 0xa1, 0x1b, 0x0b, 0x61, 0xed, 0xe8, 0x1a, 0x4b, 0xdf, 0xf2, 0xd3, + 0x07, 0xe6, 0x0f, 0x7e, 0x1c, 0xe4, 0x16, 0xd0, 0xc6, 0xee, 0x16, 0xbc, 0x03, 0x14, 0x1a, 0x36, + 0x42, 0x15, 0x73, 0xd3, 0xf2, 0xa4, 0xeb, 0x7a, 0xcf, 0x3e, 0x24, 0xf4, 0xcd, 0xc3, 0x63, 0x1b, + 0xe9, 0xed, 0xf0, 0x74, 0x93, 0xff, 0x0a, 0x5f, 0x28, 0x81, 0x6c, 0xdd, 0xd5, 0x5d, 0x38, 0x19, + 0x60, 0x0b, 0x1f, 0x64, 0xb1, 0xb8, 0x83, 0xc7, 0xe2, 0x7a, 0x4e, 0x16, 0x98, 0x83, 0x39, 0xef, + 0xff, 0x08, 0x00, 0x20, 0x28, 0xdc, 0xef, 0x58, 0xa6, 0x97, 0xc3, 0x3f, 0x80, 0xe7, 0xbf, 0xc3, + 0x97, 0x06, 0xe2, 0xbe, 0x8b, 0x13, 0xf7, 0xa3, 0xc5, 0x8a, 0x18, 0xc3, 0x4a, 0x9b, 0x04, 0x26, + 0x3d, 0xd1, 0x2e, 0x23, 0xbd, 0xed, 0xc0, 0x1f, 0x0b, 0x95, 0x3f, 0x42, 0xcc, 0xf0, 0xbd, 0xc2, + 0xa1, 0x22, 0x49, 0xad, 0x02, 0xe2, 0xd1, 0xfe, 0x02, 0x7e, 0xa8, 0x0c, 0x89, 0x0f, 0x95, 0x71, + 0x33, 0xc8, 0x1a, 0xe6, 0xa6, 0x45, 0xbd, 0xd7, 0xae, 0x8c, 0xa0, 0xed, 0xe9, 0x84, 0x86, 0x33, + 0x0a, 0xc6, 0x91, 0x8c, 0x67, 0x6b, 0x2c, 0x57, 0xb2, 0x65, 0xbd, 0xd2, 0xe1, 0xff, 0x35, 0x50, + 0xd8, 0x8a, 0x02, 0xb2, 0x5d, 0xdd, 0xdd, 0xa6, 0x45, 0xe3, 0x67, 0xcf, 0x46, 0xde, 0x35, 0x75, + 0xd3, 0x32, 0xf7, 0x77, 0x8c, 0xa7, 0x05, 0x37, 0xbf, 0x72, 0x69, 0x1e, 0xe7, 0x5b, 0xc8, 0x44, + 0xb6, 0xee, 0xa2, 0xfa, 0xde, 0x16, 0x9e, 0x63, 0x15, 0x34, 0x36, 0x29, 0xb1, 0xfe, 0x7b, 0x1c, + 0x47, 0xeb, 0xff, 0xa6, 0xd1, 0x41, 0x38, 0x8e, 0x10, 0xd5, 0x7f, 0xff, 0x3d, 0x91, 0xfe, 0xf7, + 0x29, 0x22, 0x7d, 0x34, 0xbe, 0x2f, 0x81, 0xe9, 0xba, 0xa7, 0x70, 0xf5, 0xdd, 0x9d, 0x1d, 0xdd, + 0xde, 0x87, 0xd7, 0x86, 0xa8, 0x30, 0xaa, 0x99, 0xe1, 0x54, 0x13, 0xfe, 0xa9, 0xf0, 0xa5, 0xc7, + 0xb4, 0x69, 0x33, 0x25, 0x24, 0x6e, 0x07, 0xb7, 0x80, 0x9c, 0xa7, 0xde, 0xbe, 0x3f, 0x5f, 0x6c, + 0x43, 0x20, 0x39, 0x05, 0xe3, 0x2d, 0x0d, 0xe4, 0x6d, 0x0c, 0xb1, 0x1e, 0x24, 0x70, 0xbc, 0xee, + 0xea, 0xad, 0x8b, 0x4b, 0x96, 0x6d, 0xed, 0xba, 0x86, 0x89, 0x1c, 0xf8, 0x88, 0x10, 0x01, 0x5f, + 0xff, 0x33, 0xa1, 0xfe, 0xc3, 0xff, 0xc8, 0x88, 0x8e, 0xa2, 0x41, 0xb7, 0xca, 0x92, 0x8f, 0x08, + 0x9f, 0x24, 0x36, 0x2e, 0x8a, 0x50, 0x4c, 0x5f, 0x68, 0xaf, 0x91, 0x41, 0x51, 0x7d, 0xa0, 0x6b, + 0xd9, 0xee, 0x8a, 0xd5, 0xd2, 0x3b, 0x8e, 0x6b, 0xd9, 0x08, 0xd6, 0x62, 0xa5, 0xe6, 0xf5, 0x30, + 0x6d, 0xab, 0x15, 0x0e, 0x8e, 0xf4, 0x8d, 0x55, 0x3b, 0x99, 0xd7, 0xf1, 0x0f, 0x0a, 0xef, 0x32, + 0x12, 0xa9, 0xf4, 0x72, 0x14, 0xa1, 0xe7, 0xfd, 0xba, 0xb4, 0x64, 0xae, 0xf8, 0x62, 0x3b, 0x8f, + 0x42, 0x4c, 0x8d, 0x61, 0xa9, 0x5c, 0x02, 0x33, 0xf5, 0xdd, 0x8d, 0x80, 0x88, 0xc3, 0x1a, 0x21, + 0x2f, 0x17, 0x8e, 0x91, 0x40, 0x15, 0x8f, 0x25, 0x14, 0x21, 0xdf, 0xeb, 0xc0, 0x8c, 0xc3, 0x66, + 0xa3, 0x78, 0xf3, 0x89, 0x82, 0xb1, 0x11, 0x06, 0x97, 0x9a, 0xbe, 0x00, 0xdf, 0x2e, 0x81, 0x99, + 0x5a, 0x17, 0x99, 0xa8, 0x4d, 0x7c, 0xec, 0x38, 0x01, 0xbe, 0x30, 0xa1, 0x00, 0x39, 0x42, 0x11, + 0x02, 0x0c, 0xfd, 0x61, 0x17, 0x7c, 0xe1, 0x85, 0x09, 0x89, 0x04, 0x17, 0x57, 0x5a, 0xfa, 0x82, + 0xfb, 0xa2, 0x04, 0xa6, 0xb4, 0x5d, 0x73, 0xcd, 0xb6, 0xbc, 0xd1, 0xd8, 0x86, 0x77, 0x86, 0x1d, + 0xc4, 0x4d, 0xe0, 0x44, 0x7b, 0xd7, 0xc6, 0xeb, 0x4f, 0x15, 0xb3, 0x8e, 0x5a, 0x96, 0xd9, 0x76, + 0x70, 0x3d, 0x72, 0xda, 0xc1, 0x0f, 0xb7, 0x67, 0x9f, 0xf5, 0x75, 0x39, 0x03, 0x9f, 0x2d, 0x1c, + 0x88, 0x85, 0x54, 0x9e, 0x29, 0x5a, 0xbc, 0x27, 0x10, 0x0c, 0xb7, 0x32, 0xa8, 0x84, 0xf4, 0x85, + 0xfb, 0x19, 0x09, 0x28, 0xa5, 0x56, 0xcb, 0xda, 0x35, 0xdd, 0x3a, 0xea, 0xa0, 0x96, 0xdb, 0xb0, + 0xf5, 0x16, 0x62, 0xed, 0xe7, 0x22, 0x90, 0xdb, 0x86, 0x4d, 0xfb, 0x60, 0xef, 0x91, 0xca, 0xf1, + 0x85, 0xc2, 0x3b, 0x8e, 0xa4, 0x96, 0x07, 0x4b, 0x49, 0x20, 0x4e, 0xb1, 0x7d, 0x45, 0xc1, 0x82, + 0xd2, 0x97, 0xea, 0x47, 0x24, 0x30, 0xe9, 0xf7, 0xd8, 0x5b, 0x22, 0xc2, 0xfc, 0xed, 0x84, 0x93, + 0x91, 0x80, 0x78, 0x02, 0x19, 0xbe, 0x39, 0xc1, 0xac, 0x22, 0x8a, 0x7e, 0x32, 0xd1, 0x95, 0x92, + 0x8b, 0xce, 0x7b, 0xad, 0xd6, 0x9a, 0x8b, 0xb5, 0x95, 0x05, 0x55, 0x2b, 0xca, 0xf0, 0x4b, 0x12, + 0xc8, 0xae, 0x19, 0xe6, 0x16, 0x1b, 0x2f, 0xeb, 0xa4, 0x67, 0x47, 0xb6, 0xd1, 0x03, 0xb4, 0xa5, + 0x93, 0x17, 0xe5, 0x56, 0x70, 0xd2, 0xdc, 0xdd, 0xd9, 0x40, 0x76, 0x6d, 0x13, 0x8f, 0xb2, 0x4e, + 0xc3, 0xaa, 0x23, 0x93, 0x18, 0xa1, 0x39, 0xad, 0xef, 0x37, 0xde, 0x04, 0x13, 0x98, 0x3c, 0x78, + 0x9c, 0x44, 0x48, 0x3c, 0x60, 0x4a, 0x62, 0x98, 0x4a, 0x34, 0x6d, 0xe8, 0x43, 0x3c, 0x7d, 0x4d, + 0xfd, 0xb3, 0x1c, 0x38, 0x55, 0x32, 0xf7, 0xb1, 0x4d, 0x41, 0x3a, 0xf8, 0xf2, 0xb6, 0x6e, 0x6e, + 0x21, 0x3c, 0x40, 0x04, 0x12, 0x67, 0x03, 0xc8, 0x67, 0xf8, 0x00, 0xf2, 0x8a, 0x06, 0x26, 0x2c, + 0xbb, 0x8d, 0xec, 0xf9, 0x7d, 0xcc, 0x53, 0xef, 0xb2, 0x33, 0x6d, 0x93, 0xfd, 0x8a, 0x98, 0xa3, + 0xe4, 0xe7, 0x6a, 0xe4, 0x7f, 0xcd, 0x27, 0x74, 0xee, 0x26, 0x30, 0x41, 0xd3, 0x94, 0x69, 0x50, + 0xa8, 0x69, 0x0b, 0xaa, 0xd6, 0xac, 0x2c, 0x14, 0x8f, 0x29, 0x97, 0x81, 0xe3, 0x95, 0x86, 0xaa, + 0x95, 0x1a, 0x95, 0x5a, 0xb5, 0x89, 0xd3, 0x8b, 0x19, 0xf8, 0xcc, 0xac, 0xa8, 0x67, 0x6f, 0x3c, + 0x33, 0xfd, 0x60, 0xd5, 0xc0, 0x44, 0x8b, 0x64, 0xc0, 0x43, 0xe8, 0x54, 0xa2, 0xda, 0x51, 0x82, + 0x24, 0x41, 0xf3, 0x09, 0x29, 0x67, 0x01, 0xb8, 0x64, 0x5b, 0xe6, 0x56, 0x78, 0xa6, 0xad, 0xa0, + 0x31, 0x29, 0xf0, 0xc1, 0x0c, 0xc8, 0x93, 0x7f, 0xf0, 0x85, 0x19, 0xf8, 0x29, 0x14, 0xbc, 0xff, + 0xee, 0x59, 0xbc, 0x58, 0x5e, 0xe1, 0x44, 0x8b, 0xbe, 0x7a, 0xba, 0x48, 0x64, 0x40, 0x2c, 0x61, + 0x5a, 0x95, 0x9b, 0x41, 0x9e, 0xfc, 0x4b, 0xbd, 0x0e, 0xa2, 0x83, 0x5f, 0x92, 0x6c, 0x82, 0x7e, + 0xca, 0xe2, 0x32, 0x4d, 0x5f, 0x9b, 0xdf, 0x27, 0x81, 0x42, 0x15, 0xb9, 0xe5, 0x6d, 0xd4, 0xba, + 0x08, 0x1f, 0xc5, 0x2f, 0x80, 0x76, 0x0c, 0x64, 0xba, 0xf7, 0xed, 0x74, 0x82, 0x05, 0x50, 0x3f, + 0x01, 0xfe, 0x32, 0xdb, 0xf9, 0xde, 0xcd, 0xeb, 0xcf, 0x8d, 0x7d, 0xea, 0xea, 0x97, 0x10, 0xa1, + 0x32, 0xa7, 0x41, 0xde, 0x46, 0xce, 0x6e, 0xc7, 0x5f, 0x44, 0xa3, 0x6f, 0xf0, 0x15, 0x81, 0x38, + 0xcb, 0x9c, 0x38, 0x6f, 0x16, 0x2f, 0x62, 0x0c, 0xd1, 0x34, 0xb3, 0x60, 0xa2, 0x62, 0x1a, 0xae, + 0xa1, 0x77, 0xe0, 0xb3, 0xb3, 0x60, 0xa6, 0x8e, 0xdc, 0x35, 0xdd, 0xd6, 0x77, 0x90, 0x8b, 0x6c, + 0x07, 0x7e, 0x97, 0xef, 0x13, 0xba, 0x1d, 0xdd, 0xdd, 0xb4, 0xec, 0x1d, 0x5f, 0x35, 0xfd, 0x77, + 0x4f, 0x35, 0xf7, 0x90, 0xed, 0x84, 0x7c, 0xf9, 0xaf, 0xde, 0x97, 0x4b, 0x96, 0x7d, 0xd1, 0x1b, + 0x04, 0xe9, 0x34, 0x8d, 0xbe, 0x7a, 0xf4, 0x3a, 0xd6, 0xd6, 0x0a, 0xda, 0x43, 0x7e, 0xb0, 0xae, + 0xe0, 0xdd, 0x9b, 0x0b, 0xb4, 0xad, 0xaa, 0xe5, 0x7a, 0x9d, 0xf6, 0x8a, 0xb5, 0x45, 0xa2, 0x99, + 0x16, 0x34, 0x3e, 0x31, 0xcc, 0xa5, 0xef, 0x21, 0x9c, 0x2b, 0xcf, 0xe6, 0xa2, 0x89, 0xca, 0x1c, + 0x50, 0x82, 0xdf, 0x1a, 0xa8, 0x83, 0x76, 0x90, 0x6b, 0xef, 0xe3, 0x4b, 0x0b, 0x0a, 0x5a, 0x9f, + 0x2f, 0x74, 0x80, 0x16, 0x9f, 0xac, 0x53, 0xe9, 0xcd, 0x71, 0x92, 0x3b, 0xd4, 0x64, 0x5d, 0x84, + 0xe2, 0x58, 0x2e, 0x65, 0x92, 0x3d, 0x6b, 0xe6, 0xc5, 0x32, 0xc8, 0xe2, 0xc1, 0xf3, 0xb5, 0x19, + 0x6e, 0x85, 0x69, 0x07, 0x39, 0x8e, 0xbe, 0x85, 0xfc, 0x15, 0x26, 0xfa, 0xaa, 0xdc, 0x06, 0x72, + 0x1d, 0x8c, 0x29, 0x19, 0x1c, 0xae, 0xe5, 0x6a, 0xe6, 0x19, 0x18, 0x1e, 0xad, 0x60, 0x24, 0xc0, + 0x70, 0x6b, 0xe4, 0x8f, 0x73, 0xf7, 0x80, 0x1c, 0x81, 0x7f, 0x12, 0xe4, 0x16, 0xd4, 0xf9, 0xf5, + 0xa5, 0xe2, 0x31, 0xef, 0xd1, 0xe7, 0x6f, 0x12, 0xe4, 0x16, 0x4b, 0x8d, 0xd2, 0x4a, 0x51, 0xf2, + 0xea, 0x51, 0xa9, 0x2e, 0xd6, 0x8a, 0xb2, 0x97, 0xb8, 0x56, 0xaa, 0x56, 0xca, 0xc5, 0xac, 0x32, + 0x05, 0x26, 0x2e, 0x94, 0xb4, 0x6a, 0xa5, 0xba, 0x54, 0xcc, 0xc1, 0x7f, 0x60, 0xf1, 0xbb, 0x9d, + 0xc7, 0xef, 0xba, 0x28, 0x9e, 0xfa, 0x41, 0xf6, 0xbb, 0x01, 0x64, 0x77, 0x72, 0x90, 0xfd, 0xb8, + 0x08, 0x91, 0x31, 0xb8, 0x33, 0xe5, 0xc1, 0xc4, 0x9a, 0x6d, 0xb5, 0x90, 0xe3, 0xc0, 0x17, 0x48, + 0x20, 0x5f, 0xd6, 0xcd, 0x16, 0xea, 0xc0, 0x2b, 0x42, 0xa8, 0x88, 0xab, 0x68, 0xc6, 0x77, 0x15, + 0x85, 0xdf, 0xce, 0x88, 0xf6, 0x7e, 0x94, 0xee, 0x1c, 0xa1, 0x19, 0x21, 0x1f, 0xb1, 0x5e, 0x2e, + 0x96, 0xd4, 0x18, 0x2e, 0x6e, 0x91, 0xc0, 0x24, 0x5d, 0x0d, 0xd8, 0x40, 0xec, 0x3c, 0xfc, 0xbb, + 0x19, 0xd1, 0xc9, 0xa1, 0x5f, 0x83, 0x80, 0x4c, 0x84, 0x3c, 0xc4, 0x26, 0x82, 0x83, 0xa8, 0x8d, + 0x61, 0xf3, 0x50, 0x02, 0x53, 0xeb, 0xa6, 0xd3, 0x4f, 0x28, 0xe2, 0x51, 0xde, 0xfd, 0x6a, 0x30, + 0x84, 0x0e, 0x15, 0xe5, 0x7d, 0x30, 0xbd, 0xf4, 0x05, 0xf3, 0xdd, 0x0c, 0x38, 0xb9, 0x84, 0x4c, + 0x64, 0x1b, 0x2d, 0x52, 0x03, 0x5f, 0x12, 0x77, 0xf2, 0x92, 0x78, 0x14, 0xc7, 0x79, 0xbf, 0x3f, + 0x78, 0x09, 0xbc, 0x2c, 0x90, 0xc0, 0xdd, 0x9c, 0x04, 0x6e, 0x12, 0xa4, 0x33, 0x86, 0xdb, 0xba, + 0x27, 0xc1, 0x74, 0xd5, 0x72, 0x8d, 0x4d, 0xa3, 0x45, 0x7c, 0xd0, 0x5e, 0x24, 0x83, 0xec, 0x8a, + 0xe1, 0xb8, 0xb0, 0x14, 0x76, 0x27, 0xd7, 0x80, 0x29, 0xc3, 0x6c, 0x75, 0x76, 0xdb, 0x48, 0x43, + 0x3a, 0xe9, 0x57, 0x0a, 0x1a, 0x9b, 0x14, 0x6e, 0xed, 0x7b, 0x6c, 0xc9, 0xfe, 0xd6, 0xfe, 0x27, + 0x85, 0x97, 0x61, 0x58, 0x16, 0x70, 0xb8, 0xc3, 0x08, 0xbb, 0xab, 0x04, 0x66, 0x4c, 0x26, 0xab, + 0x6f, 0xb0, 0xf7, 0x86, 0xbb, 0x67, 0xc9, 0x69, 0xfc, 0x1f, 0xf0, 0x9d, 0x42, 0x8d, 0x75, 0x10, + 0x43, 0xc9, 0x90, 0x59, 0x1c, 0x62, 0x92, 0xac, 0x80, 0xd9, 0x4a, 0xb5, 0xa1, 0x6a, 0xd5, 0xd2, + 0x0a, 0xcd, 0x22, 0xc3, 0xef, 0x4b, 0x20, 0xa7, 0xa1, 0x6e, 0x67, 0x9f, 0x8d, 0x67, 0x4c, 0x1d, + 0xc5, 0x33, 0x81, 0xa3, 0xb8, 0xb2, 0x08, 0x80, 0xde, 0xf2, 0x0a, 0xc6, 0x17, 0x3e, 0x49, 0x7d, + 0xa3, 0x64, 0x72, 0x15, 0x2c, 0x05, 0xb9, 0x35, 0xe6, 0x4f, 0xf8, 0x1c, 0xe1, 0x9d, 0x23, 0x8e, + 0x1a, 0xe6, 0x30, 0xa2, 0x4f, 0x78, 0x97, 0xd0, 0x66, 0xcf, 0x40, 0x72, 0x47, 0x23, 0xfe, 0x2f, + 0x4b, 0x20, 0xdb, 0xf0, 0x7a, 0x4b, 0xa6, 0xe3, 0xfc, 0xc4, 0x70, 0x3a, 0xee, 0x91, 0x89, 0xd0, + 0xf1, 0xbb, 0xc0, 0x34, 0xab, 0xb1, 0xd4, 0x55, 0x22, 0x56, 0xc5, 0xb9, 0x1f, 0x86, 0xd1, 0xf0, + 0x3e, 0xec, 0x1c, 0x8d, 0x88, 0x3f, 0xfa, 0x68, 0x00, 0x56, 0xd1, 0xce, 0x06, 0xb2, 0x9d, 0x6d, + 0xa3, 0x0b, 0xff, 0x51, 0x06, 0x93, 0x4b, 0xc8, 0xad, 0xbb, 0xba, 0xbb, 0xeb, 0xf4, 0x6c, 0x77, + 0x9a, 0x56, 0x59, 0x6f, 0x6d, 0x23, 0xda, 0x1d, 0xf9, 0xaf, 0xf0, 0xad, 0xb2, 0xa8, 0x3f, 0x51, + 0x58, 0xce, 0x5c, 0x50, 0x46, 0x04, 0x26, 0x8f, 0x01, 0xd9, 0xb6, 0xee, 0xea, 0x14, 0x8b, 0x2b, + 0x7a, 0xb0, 0x08, 0x09, 0x69, 0x38, 0x1b, 0x7c, 0xa3, 0x24, 0xe2, 0x50, 0x24, 0x50, 0x7e, 0x32, + 0x10, 0xde, 0x99, 0x19, 0x02, 0x85, 0x13, 0x60, 0xa6, 0x5a, 0x6b, 0x34, 0x57, 0x6a, 0x4b, 0x4b, + 0xaa, 0x97, 0x5a, 0x94, 0x95, 0xd3, 0x40, 0x59, 0x2b, 0xdd, 0xb7, 0xaa, 0x56, 0x1b, 0xcd, 0x6a, + 0x6d, 0x41, 0xa5, 0x7f, 0x66, 0x95, 0xe3, 0x60, 0xaa, 0x5c, 0x2a, 0x2f, 0xfb, 0x09, 0x39, 0xe5, + 0x0c, 0x38, 0xb9, 0xaa, 0xae, 0xce, 0xab, 0x5a, 0x7d, 0xb9, 0xb2, 0xd6, 0xf4, 0xc8, 0x2c, 0xd6, + 0xd6, 0xab, 0x0b, 0xc5, 0xbc, 0x02, 0xc1, 0x69, 0xe6, 0xcb, 0x05, 0xad, 0x56, 0x5d, 0x6a, 0xd6, + 0x1b, 0xa5, 0x86, 0x5a, 0x9c, 0x50, 0x2e, 0x03, 0xc7, 0xcb, 0xa5, 0x2a, 0xce, 0x5e, 0xae, 0x55, + 0xab, 0x6a, 0xb9, 0x51, 0x2c, 0xc0, 0xff, 0xc8, 0x82, 0xa9, 0x8a, 0x53, 0xd5, 0x77, 0xd0, 0x79, + 0xbd, 0x63, 0xb4, 0xe1, 0xb3, 0x99, 0x99, 0xc7, 0x75, 0x60, 0xc6, 0x26, 0x8f, 0xa8, 0xdd, 0x30, + 0x10, 0x41, 0x73, 0x46, 0xe3, 0x13, 0xbd, 0x39, 0xb9, 0x89, 0x09, 0xf8, 0x73, 0x72, 0xf2, 0xa6, + 0xcc, 0x03, 0x40, 0x9e, 0x1a, 0xe1, 0xd5, 0xa3, 0xe7, 0x7a, 0x5b, 0x93, 0xbe, 0x83, 0x1c, 0x64, + 0xef, 0x19, 0x2d, 0xe4, 0xe7, 0xd4, 0x98, 0xbf, 0xe0, 0x57, 0x64, 0xd1, 0xfd, 0x45, 0x06, 0x54, + 0xa6, 0x3a, 0x11, 0xbd, 0xe1, 0xaf, 0xc8, 0x22, 0xbb, 0x83, 0x42, 0x24, 0x93, 0x69, 0xca, 0xf3, + 0xa4, 0xe1, 0x96, 0x6d, 0x1b, 0xb5, 0x5a, 0xb3, 0xbe, 0x5c, 0xd3, 0x1a, 0x45, 0x59, 0x99, 0x06, + 0x05, 0xef, 0x75, 0xa5, 0x56, 0x5d, 0x2a, 0x66, 0x95, 0x53, 0xe0, 0xc4, 0x72, 0xa9, 0xde, 0xac, + 0x54, 0xcf, 0x97, 0x56, 0x2a, 0x0b, 0xcd, 0xf2, 0x72, 0x49, 0xab, 0x17, 0x73, 0xca, 0x15, 0xe0, + 0x54, 0xa3, 0xa2, 0x6a, 0xcd, 0x45, 0xb5, 0xd4, 0x58, 0xd7, 0xd4, 0x7a, 0xb3, 0x5a, 0x6b, 0x56, + 0x4b, 0xab, 0x6a, 0x31, 0xef, 0x35, 0x7f, 0xfc, 0x29, 0x54, 0x9b, 0x89, 0x83, 0xca, 0x58, 0x88, + 0x50, 0xc6, 0xc9, 0x5e, 0x65, 0x04, 0xac, 0x5a, 0x69, 0x6a, 0x5d, 0xd5, 0xce, 0xab, 0xc5, 0xa9, + 0x7e, 0xba, 0x36, 0xad, 0x9c, 0x04, 0x45, 0x8f, 0x87, 0x66, 0xa5, 0xee, 0xe7, 0x5c, 0x28, 0xce, + 0xc0, 0x8f, 0xe4, 0xc1, 0x69, 0x0d, 0x6d, 0x19, 0x8e, 0x8b, 0xec, 0x35, 0x7d, 0x7f, 0x07, 0x99, + 0xae, 0xdf, 0xc9, 0xff, 0x5b, 0x62, 0x65, 0x5c, 0x05, 0x33, 0x5d, 0x42, 0x63, 0x15, 0xb9, 0xdb, + 0x56, 0x9b, 0x8e, 0xc2, 0x8f, 0x8a, 0xec, 0x39, 0xe6, 0xd6, 0xd8, 0xec, 0x1a, 0xff, 0x37, 0xa3, + 0xdb, 0x72, 0x8c, 0x6e, 0x67, 0x87, 0xd1, 0x6d, 0xe5, 0x2a, 0x30, 0xb9, 0xeb, 0x20, 0x5b, 0xdd, + 0xd1, 0x8d, 0x8e, 0x7f, 0x75, 0x64, 0x90, 0x00, 0xdf, 0x94, 0x15, 0x3d, 0xb1, 0xc2, 0xd4, 0xa5, + 0xbf, 0x18, 0x23, 0xfa, 0xd6, 0xb3, 0x00, 0xd0, 0xca, 0xae, 0xdb, 0x1d, 0xaa, 0xac, 0x4c, 0x8a, + 0xc7, 0xdf, 0x86, 0xd1, 0xe9, 0x18, 0xe6, 0x56, 0xb0, 0xef, 0x1f, 0x26, 0xc0, 0xe7, 0xc9, 0x22, + 0x27, 0x58, 0x92, 0xf2, 0x96, 0xac, 0x35, 0x3d, 0x47, 0x1a, 0x73, 0xbf, 0x7b, 0xb0, 0xe9, 0xe4, + 0x95, 0x22, 0x98, 0xc6, 0x69, 0xb4, 0x05, 0x16, 0x27, 0xbc, 0x3e, 0xd8, 0x27, 0xb7, 0xaa, 0x36, + 0x96, 0x6b, 0x0b, 0xc1, 0xb7, 0x82, 0x47, 0xd2, 0x63, 0xa6, 0x54, 0xbd, 0x0f, 0xb7, 0xc6, 0x49, + 0xe5, 0x11, 0xe0, 0x0a, 0xa6, 0xc3, 0x2e, 0xad, 0x68, 0x6a, 0x69, 0xe1, 0xbe, 0xa6, 0xfa, 0x94, + 0x4a, 0xbd, 0x51, 0xe7, 0x1b, 0x97, 0xdf, 0x8e, 0xa6, 0x3c, 0x7e, 0xd5, 0xd5, 0x52, 0x65, 0x85, + 0xf6, 0xef, 0x8b, 0x35, 0x6d, 0xb5, 0xd4, 0x28, 0x4e, 0xc3, 0x17, 0xcb, 0xa0, 0xb8, 0x84, 0xdc, + 0x35, 0xcb, 0x76, 0xf5, 0xce, 0x8a, 0x61, 0x5e, 0x5c, 0xb7, 0x3b, 0xdc, 0x64, 0x53, 0x38, 0x4c, + 0x07, 0x3f, 0x44, 0x72, 0x04, 0xa3, 0x77, 0xc4, 0xbb, 0x38, 0x5b, 0xa8, 0x4c, 0x61, 0x02, 0x7c, + 0xba, 0x24, 0xb2, 0xdc, 0x2d, 0x5e, 0x6a, 0x32, 0x3d, 0x79, 0xc6, 0xb8, 0xc7, 0xe7, 0x3e, 0xa8, + 0xe5, 0xe1, 0xb3, 0xb2, 0xa0, 0xb0, 0x68, 0x98, 0x7a, 0xc7, 0x78, 0x1a, 0x17, 0x1d, 0x33, 0xec, + 0x63, 0x32, 0x31, 0x7d, 0x8c, 0x34, 0xd4, 0xf8, 0xf9, 0x5b, 0xb2, 0xe8, 0xf2, 0x02, 0x23, 0x7b, + 0x9f, 0xc9, 0x88, 0xc1, 0xf3, 0xfd, 0x92, 0xc8, 0xf2, 0xc2, 0x60, 0x7a, 0xc9, 0x30, 0xfc, 0xf8, + 0x0f, 0x87, 0x8d, 0xd5, 0xd3, 0xbe, 0x0b, 0xfd, 0x54, 0x61, 0x12, 0xfe, 0x95, 0x0c, 0xe0, 0x12, + 0x72, 0xcf, 0x23, 0x3b, 0x98, 0x0a, 0xe0, 0x5e, 0x9f, 0xda, 0xdb, 0x4c, 0x93, 0x7d, 0x2d, 0x0b, + 0xe0, 0x05, 0x1e, 0xc0, 0x52, 0x4c, 0xe3, 0x89, 0x20, 0x1d, 0xd1, 0x78, 0x2b, 0x20, 0xef, 0xe0, + 0xef, 0x54, 0xcd, 0x6e, 0x89, 0x1e, 0x2e, 0x31, 0x31, 0x96, 0x3a, 0x21, 0xac, 0x51, 0x02, 0xf0, + 0x7b, 0xc1, 0x24, 0xe8, 0xa7, 0x39, 0xed, 0x58, 0x3c, 0x34, 0xb3, 0xc9, 0xf4, 0xc5, 0x4e, 0x57, + 0x5d, 0xfa, 0xd9, 0x37, 0xf0, 0xfd, 0x39, 0x70, 0xb2, 0x5f, 0x75, 0xe0, 0xbb, 0x33, 0xdc, 0x0e, + 0x3b, 0xc2, 0x43, 0x7e, 0x86, 0x6e, 0x20, 0x7a, 0x2f, 0xca, 0xe3, 0xc1, 0xa9, 0x60, 0x19, 0xae, + 0x61, 0x55, 0xd1, 0x25, 0xa7, 0x83, 0x5c, 0x17, 0xd9, 0xb8, 0x6a, 0x05, 0xad, 0xff, 0x47, 0xe5, + 0x89, 0xe0, 0x72, 0xc3, 0x74, 0x8c, 0x36, 0xb2, 0x1b, 0x46, 0xd7, 0x29, 0x99, 0xed, 0xc6, 0xae, + 0x6b, 0xd9, 0x86, 0x4e, 0x2f, 0x3a, 0x2c, 0x68, 0x51, 0x9f, 0x95, 0x1b, 0x41, 0xd1, 0x70, 0x6a, + 0xe6, 0x86, 0xa5, 0xdb, 0x6d, 0xc3, 0xdc, 0x5a, 0x31, 0x1c, 0x97, 0x7a, 0x00, 0x1f, 0x48, 0x87, + 0xff, 0x24, 0x8b, 0x1e, 0xa6, 0x1b, 0x00, 0x6b, 0x44, 0x87, 0xf2, 0xcb, 0xb2, 0xc8, 0xf1, 0xb8, + 0x64, 0xb4, 0x93, 0x29, 0xcb, 0x33, 0xc7, 0x6d, 0x48, 0xf4, 0x1f, 0xc1, 0x71, 0xd7, 0x42, 0xd2, + 0x7d, 0x43, 0xe0, 0xbc, 0xaa, 0x55, 0x16, 0x2b, 0xaa, 0x67, 0x56, 0x9c, 0x02, 0x27, 0xc2, 0x6f, + 0x0b, 0xf7, 0x35, 0xeb, 0x6a, 0xb5, 0x51, 0x2c, 0x78, 0xfd, 0x14, 0x49, 0x5e, 0x2c, 0x55, 0x56, + 0xd4, 0x85, 0x66, 0xa3, 0xe6, 0x7d, 0x59, 0x18, 0xce, 0xb4, 0x80, 0x0f, 0x66, 0xc1, 0x71, 0x2c, + 0xdb, 0x7d, 0x2c, 0x55, 0x4f, 0x28, 0x3d, 0xbe, 0xb6, 0x01, 0x40, 0x93, 0x44, 0xbc, 0xf0, 0xd3, + 0xc2, 0xf7, 0x38, 0x32, 0x10, 0xf6, 0x94, 0x11, 0xa1, 0x19, 0xdf, 0x95, 0x44, 0x22, 0x54, 0x08, + 0x93, 0x4d, 0xa6, 0x14, 0xff, 0x3e, 0xee, 0x11, 0x27, 0x1a, 0x7c, 0x6c, 0x65, 0x96, 0xf1, 0xcf, + 0x4f, 0x59, 0xab, 0x68, 0x58, 0x1d, 0x66, 0x01, 0xc0, 0x29, 0x58, 0x83, 0x88, 0x1e, 0xf4, 0x1d, + 0xaf, 0xa2, 0xf4, 0xa0, 0x54, 0x6e, 0x54, 0xce, 0xab, 0x51, 0x7a, 0xf0, 0x29, 0x19, 0x14, 0x96, + 0x90, 0xeb, 0xcd, 0xa9, 0x1c, 0xf8, 0x24, 0x81, 0xf5, 0x1f, 0xcf, 0x8c, 0xc1, 0x17, 0xdf, 0x07, + 0xcb, 0x00, 0xe4, 0x0d, 0xfe, 0xd2, 0x30, 0x26, 0x88, 0x5f, 0x74, 0xc4, 0x78, 0xf5, 0x93, 0x20, + 0xe7, 0x7a, 0x9f, 0xe9, 0x32, 0xf4, 0x8f, 0x45, 0x0e, 0x57, 0x1e, 0x91, 0x05, 0xdd, 0xd5, 0x35, + 0x92, 0x9f, 0x19, 0x9d, 0x04, 0x6d, 0x97, 0x08, 0x46, 0x7e, 0x18, 0xed, 0xcf, 0x7f, 0x90, 0xc1, + 0x29, 0xd2, 0x3e, 0x4a, 0xdd, 0x6e, 0xdd, 0xb5, 0x6c, 0xa4, 0xa1, 0x16, 0x32, 0xba, 0x6e, 0xcf, + 0xfa, 0x9e, 0x4d, 0x52, 0xfd, 0xcd, 0x66, 0xfa, 0x0a, 0x5f, 0x25, 0x8b, 0x46, 0xf8, 0x3d, 0xd0, + 0x1e, 0x7b, 0xca, 0x8b, 0x68, 0xec, 0x1f, 0x96, 0x44, 0x62, 0xf6, 0x26, 0x24, 0x9e, 0x0c, 0xa8, + 0x0f, 0x1c, 0x01, 0x50, 0xfe, 0xca, 0x8d, 0xa6, 0x96, 0xd5, 0xca, 0x9a, 0x37, 0x08, 0x5c, 0x0d, + 0xae, 0x5c, 0x5b, 0xd7, 0xca, 0xcb, 0xa5, 0xba, 0xda, 0xd4, 0xd4, 0xa5, 0x4a, 0xbd, 0x41, 0x9d, + 0xb2, 0xc8, 0x5f, 0x13, 0xca, 0x55, 0xe0, 0x4c, 0x7d, 0x7d, 0xbe, 0x5e, 0xd6, 0x2a, 0x6b, 0x38, + 0x5d, 0x53, 0xab, 0xea, 0x05, 0xfa, 0xb5, 0x00, 0xdf, 0x5b, 0x04, 0x53, 0xde, 0x04, 0xa0, 0x4e, + 0xe6, 0x05, 0xf0, 0x9b, 0x59, 0x30, 0xa5, 0x21, 0xc7, 0xea, 0xec, 0xe1, 0x39, 0xc2, 0xb8, 0xa6, + 0x1e, 0xdf, 0x91, 0x45, 0xcf, 0x6f, 0x33, 0xcc, 0xce, 0x31, 0x8c, 0x46, 0x4f, 0x34, 0xf5, 0x3d, + 0xdd, 0xe8, 0xe8, 0x1b, 0xb4, 0xab, 0x29, 0x68, 0x61, 0x82, 0x32, 0x07, 0x14, 0xeb, 0x92, 0x89, + 0xec, 0x7a, 0xeb, 0x92, 0xea, 0x6e, 0x97, 0xda, 0x6d, 0x1b, 0x39, 0x0e, 0x5d, 0xbd, 0xe8, 0xf3, + 0x45, 0xb9, 0x01, 0x1c, 0xc7, 0xa9, 0x4c, 0x66, 0xe2, 0x20, 0xd3, 0x9b, 0x1c, 0xe4, 0x2c, 0x99, + 0xfb, 0x7e, 0xce, 0x1c, 0x93, 0x33, 0x4c, 0x66, 0x8f, 0x4b, 0xe4, 0xf9, 0x53, 0x3a, 0xd7, 0x80, + 0x29, 0x53, 0xdf, 0x41, 0xea, 0x03, 0x5d, 0xc3, 0x46, 0x0e, 0x76, 0x8c, 0x91, 0x35, 0x36, 0x09, + 0xbe, 0x5f, 0xe8, 0xbc, 0xb9, 0x98, 0xc4, 0x92, 0xe9, 0xfe, 0xd2, 0x10, 0xaa, 0xdf, 0xa7, 0x9f, + 0x91, 0xe1, 0x7b, 0x65, 0x30, 0x4d, 0x99, 0x2a, 0x99, 0xfb, 0x95, 0x36, 0xbc, 0x9a, 0x33, 0x7e, + 0x75, 0x2f, 0xcd, 0x37, 0x7e, 0xf1, 0x0b, 0xfc, 0x55, 0x59, 0xd4, 0xdd, 0xb9, 0x4f, 0xc5, 0x71, + 0x19, 0xd1, 0x8e, 0xa3, 0x9b, 0xd6, 0x2e, 0x75, 0x54, 0x2d, 0x68, 0xe4, 0x25, 0xcd, 0x45, 0x3d, + 0xf8, 0x27, 0x42, 0xce, 0xd4, 0x82, 0xd5, 0x38, 0x22, 0x00, 0x3f, 0x2a, 0x83, 0x59, 0xca, 0x55, + 0x9d, 0x9e, 0xf3, 0x11, 0x3a, 0xf0, 0xf6, 0xeb, 0xc2, 0x86, 0x60, 0x9f, 0xfa, 0xd3, 0x92, 0x1e, + 0x36, 0x40, 0x7e, 0x50, 0x28, 0x38, 0x9a, 0x70, 0x45, 0x8e, 0x08, 0xca, 0x37, 0x67, 0xc1, 0xd4, + 0xba, 0x83, 0x6c, 0xea, 0xb7, 0x0f, 0x5f, 0x91, 0x05, 0xf2, 0x12, 0xe2, 0x36, 0x52, 0x9f, 0x2b, + 0xec, 0xe1, 0xcb, 0x56, 0x96, 0x21, 0xea, 0xd9, 0x48, 0x11, 0xb0, 0x5d, 0x0f, 0x66, 0x89, 0x48, + 0x4b, 0xae, 0xeb, 0x19, 0x89, 0xbe, 0x37, 0x6d, 0x4f, 0xea, 0x28, 0xb6, 0x8a, 0x70, 0x59, 0x5e, + 0x96, 0xb2, 0xc7, 0xd3, 0x0a, 0xda, 0x24, 0xf3, 0xd9, 0xac, 0xd6, 0x93, 0x8a, 0x2f, 0xd7, 0xef, + 0x22, 0x72, 0x7e, 0x85, 0xc9, 0x9c, 0xc3, 0x99, 0xfb, 0x7d, 0x82, 0xdf, 0x14, 0xf2, 0xd5, 0x15, + 0x97, 0x4e, 0x32, 0x5d, 0xe8, 0x8e, 0xc6, 0x24, 0x39, 0x09, 0x8a, 0x5e, 0x0e, 0xbc, 0xff, 0xa2, + 0xa9, 0xf5, 0xda, 0xca, 0x79, 0xb5, 0xff, 0x32, 0x46, 0x0e, 0x3e, 0x53, 0x06, 0x93, 0xf3, 0xb6, + 0xa5, 0xb7, 0x5b, 0xba, 0xe3, 0xc2, 0xef, 0x49, 0x60, 0x7a, 0x4d, 0xdf, 0xef, 0x58, 0x7a, 0x1b, + 0xfb, 0xf7, 0xf7, 0xf4, 0x05, 0x5d, 0xf2, 0xc9, 0xef, 0x0b, 0xe8, 0x2b, 0x7f, 0x30, 0x30, 0x38, + 0xba, 0x97, 0x11, 0xb9, 0xae, 0x31, 0xd8, 0xe6, 0x93, 0xfa, 0x05, 0x2b, 0xf5, 0xf9, 0x9a, 0x63, + 0x79, 0x8a, 0xb0, 0x28, 0xdf, 0x2b, 0x16, 0x7e, 0x54, 0x84, 0xe4, 0xd1, 0xec, 0xca, 0x3f, 0xab, + 0x00, 0xf2, 0x0b, 0x08, 0x5b, 0x71, 0xff, 0x4d, 0x02, 0x13, 0x75, 0xe4, 0x62, 0x0b, 0xee, 0x36, + 0xce, 0x53, 0xb8, 0x8d, 0x33, 0x84, 0x4e, 0xec, 0xfe, 0xbb, 0x37, 0x59, 0x67, 0xce, 0x5b, 0xe3, + 0xe7, 0x04, 0x1e, 0x89, 0xa4, 0xdc, 0x39, 0x5a, 0xe6, 0xa1, 0x3c, 0x12, 0x63, 0x49, 0xa5, 0xef, + 0x6b, 0xf5, 0x56, 0x89, 0xba, 0x56, 0x31, 0xbd, 0xde, 0xef, 0xb1, 0xfa, 0x19, 0xeb, 0x6d, 0x46, + 0x99, 0x8f, 0x71, 0x8e, 0x7a, 0x1c, 0x98, 0x20, 0x32, 0xf7, 0xe7, 0xa3, 0xbd, 0x7e, 0x0a, 0x84, + 0x04, 0x3e, 0x7b, 0xed, 0xe7, 0x14, 0x74, 0x51, 0x8b, 0x2e, 0x7c, 0x2c, 0x31, 0x08, 0xa6, 0xab, + 0xc8, 0xbd, 0x64, 0xd9, 0x17, 0xeb, 0xae, 0xee, 0x22, 0xf8, 0xef, 0x12, 0x90, 0xeb, 0xc8, 0x65, + 0xa3, 0x9f, 0x54, 0xc1, 0x09, 0x52, 0x21, 0x9a, 0x11, 0xf7, 0xdf, 0xa4, 0x22, 0xd7, 0xf4, 0x15, + 0x02, 0x93, 0x4f, 0x3b, 0xf8, 0x2b, 0x7c, 0x41, 0xdf, 0xa0, 0x4f, 0x52, 0x9f, 0x49, 0x03, 0x95, + 0x0c, 0xcb, 0xa0, 0xa7, 0x60, 0x11, 0x7a, 0xfa, 0x3e, 0x21, 0xb3, 0x5a, 0x8c, 0xe6, 0xd1, 0x74, + 0x05, 0x1f, 0xbc, 0x02, 0x64, 0xcb, 0xdb, 0xba, 0x0b, 0xdf, 0x22, 0x03, 0x50, 0x6a, 0xb7, 0x57, + 0x89, 0x0f, 0x38, 0xeb, 0x90, 0x76, 0x0e, 0x4c, 0xb7, 0xb6, 0xf5, 0xf0, 0xe6, 0x0c, 0xd2, 0x1f, + 0x70, 0x69, 0xca, 0xe3, 0x43, 0x67, 0x72, 0x22, 0x55, 0xd8, 0x03, 0x93, 0x57, 0x06, 0xa5, 0x1d, + 0x38, 0x9a, 0xf3, 0xa1, 0x30, 0x63, 0x8f, 0xd0, 0x79, 0xbf, 0xcf, 0x85, 0xec, 0x45, 0xcf, 0xe1, + 0x28, 0xe9, 0xe0, 0x80, 0x4d, 0x98, 0x90, 0xf0, 0xa4, 0xb7, 0x58, 0x40, 0x8f, 0x78, 0xbe, 0xc6, + 0x12, 0xba, 0x56, 0x51, 0xdb, 0x86, 0x2f, 0x5a, 0x1a, 0x30, 0x0b, 0x3e, 0x27, 0x93, 0x0c, 0xbe, + 0x78, 0xc1, 0xdd, 0x0d, 0x66, 0x50, 0xdb, 0x70, 0x91, 0x5f, 0x4b, 0x2a, 0xc0, 0x38, 0x88, 0xf9, + 0x1f, 0xe0, 0x33, 0x84, 0x83, 0xae, 0x61, 0x81, 0x1e, 0xac, 0x51, 0x44, 0xfb, 0x13, 0x0b, 0xa3, + 0x26, 0x46, 0x33, 0x7d, 0xb0, 0x7e, 0x49, 0x06, 0xa7, 0x1a, 0xd6, 0xd6, 0x56, 0x07, 0xf9, 0x62, + 0x42, 0xc4, 0x3b, 0x13, 0xea, 0xa3, 0x84, 0x0b, 0xef, 0x04, 0x59, 0xf7, 0x1b, 0xc1, 0x51, 0x32, + 0xef, 0x85, 0x3f, 0x31, 0x15, 0x3b, 0x8b, 0xc2, 0xe2, 0xea, 0xcb, 0x67, 0x04, 0x0a, 0x62, 0x01, + 0x9f, 0x85, 0xc9, 0xa6, 0x0f, 0xc4, 0xe7, 0x25, 0x30, 0x43, 0xee, 0x45, 0xf4, 0x15, 0xf4, 0xde, + 0x11, 0x02, 0x00, 0xbf, 0x97, 0x11, 0xf5, 0xb3, 0xc5, 0x32, 0xe1, 0x38, 0x89, 0x10, 0xb1, 0x58, + 0x50, 0x95, 0x81, 0xe4, 0xd2, 0x17, 0xed, 0x9f, 0xcb, 0x60, 0x6a, 0x09, 0xf9, 0x2d, 0xcd, 0x49, + 0xdc, 0x13, 0x9d, 0x03, 0xd3, 0xf8, 0x72, 0xb0, 0x1a, 0x3d, 0x26, 0x49, 0x56, 0xcd, 0xb8, 0x34, + 0xe5, 0x3a, 0x30, 0xb3, 0x81, 0x36, 0x2d, 0x1b, 0xd5, 0xb8, 0xb3, 0x94, 0x7c, 0x62, 0x44, 0x78, + 0x3a, 0x2e, 0x0e, 0xda, 0x3c, 0x8f, 0xcd, 0x4d, 0x07, 0x85, 0xc9, 0x54, 0x25, 0x62, 0xcc, 0x79, + 0x02, 0x28, 0x50, 0xe4, 0x7d, 0x33, 0x2d, 0xae, 0x5f, 0x0c, 0xf2, 0xc2, 0xdf, 0x0f, 0x10, 0x55, + 0x39, 0x44, 0x6f, 0x49, 0xc2, 0xc4, 0x58, 0x6e, 0x0f, 0x2f, 0x32, 0xe5, 0xcf, 0xef, 0x57, 0xda, + 0x0e, 0x5c, 0x4d, 0x86, 0xe9, 0x59, 0x00, 0x82, 0xc6, 0xe1, 0x87, 0xb5, 0x60, 0x52, 0xf8, 0xc8, + 0xf5, 0xb1, 0x07, 0xf5, 0x7a, 0xc5, 0x81, 0xd9, 0x19, 0x31, 0x30, 0x62, 0x07, 0xfc, 0x44, 0x38, + 0x49, 0x1f, 0x9d, 0x4f, 0xca, 0xe0, 0x54, 0x70, 0xfe, 0x68, 0x45, 0x77, 0xc2, 0x76, 0x57, 0x4e, + 0x06, 0x11, 0x77, 0xe0, 0x23, 0x68, 0x2c, 0xdf, 0x4a, 0x36, 0x66, 0xf4, 0xe5, 0x64, 0xb4, 0xe8, + 0x28, 0x37, 0x81, 0x13, 0xe6, 0xee, 0x4e, 0x20, 0x75, 0xdc, 0xe2, 0x69, 0x0b, 0x3f, 0xf8, 0x21, + 0xc9, 0xc8, 0x24, 0xc2, 0xfc, 0x58, 0xe6, 0x94, 0xdc, 0x91, 0xae, 0xc7, 0x24, 0x82, 0x11, 0xfe, + 0x6b, 0x26, 0x51, 0xef, 0x36, 0xf8, 0xcc, 0x57, 0x82, 0x5e, 0xea, 0x08, 0x0f, 0x7c, 0x9d, 0x9b, + 0x00, 0x39, 0x75, 0xa7, 0xeb, 0xee, 0x9f, 0x7b, 0x24, 0x98, 0xa9, 0xbb, 0x36, 0xd2, 0x77, 0x98, + 0x9d, 0x01, 0xd7, 0xba, 0x88, 0x4c, 0x7f, 0x67, 0x00, 0xbf, 0xdc, 0x7e, 0x1b, 0x98, 0x30, 0xad, + 0xa6, 0xbe, 0xeb, 0x6e, 0x2b, 0x57, 0x1f, 0x38, 0x52, 0x4f, 0xc1, 0xaf, 0xd1, 0x18, 0x46, 0x5f, + 0xb9, 0x03, 0xaf, 0x0d, 0xe7, 0x4d, 0xab, 0xb4, 0xeb, 0x6e, 0xcf, 0x5f, 0xf5, 0xd1, 0xbf, 0x3f, + 0x9b, 0xf9, 0xd4, 0xdf, 0x9f, 0xcd, 0x7c, 0xf9, 0xef, 0xcf, 0x66, 0x7e, 0xfd, 0xab, 0x67, 0x8f, + 0x7d, 0xea, 0xab, 0x67, 0x8f, 0x7d, 0xfe, 0xab, 0x67, 0x8f, 0xfd, 0xb4, 0xd4, 0xdd, 0xd8, 0xc8, + 0x63, 0x2a, 0x8f, 0xfb, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x08, 0xd4, 0x84, 0x03, 0x14, + 0x02, 0x00, } func (m *Rpc) Marshal() (dAtA []byte, err error) { @@ -77309,6 +77352,13 @@ func (m *RpcWalletCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l + if len(m.FulltextPrimaryLanguage) > 0 { + i -= len(m.FulltextPrimaryLanguage) + copy(dAtA[i:], m.FulltextPrimaryLanguage) + i = encodeVarintCommands(dAtA, i, uint64(len(m.FulltextPrimaryLanguage))) + i-- + dAtA[i] = 0x12 + } if len(m.RootPath) > 0 { i -= len(m.RootPath) copy(dAtA[i:], m.RootPath) @@ -77439,6 +77489,13 @@ func (m *RpcWalletRecoverRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l + if len(m.FulltextPrimaryLanguage) > 0 { + i -= len(m.FulltextPrimaryLanguage) + copy(dAtA[i:], m.FulltextPrimaryLanguage) + i = encodeVarintCommands(dAtA, i, uint64(len(m.FulltextPrimaryLanguage))) + i-- + dAtA[i] = 0x1a + } if len(m.Mnemonic) > 0 { i -= len(m.Mnemonic) copy(dAtA[i:], m.Mnemonic) @@ -78703,6 +78760,13 @@ func (m *RpcAccountMigrateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error _ = i var l int _ = l + if len(m.FulltextPrimaryLanguage) > 0 { + i -= len(m.FulltextPrimaryLanguage) + copy(dAtA[i:], m.FulltextPrimaryLanguage) + i = encodeVarintCommands(dAtA, i, uint64(len(m.FulltextPrimaryLanguage))) + i-- + dAtA[i] = 0x1a + } if len(m.RootPath) > 0 { i -= len(m.RootPath) copy(dAtA[i:], m.RootPath) @@ -78956,6 +79020,13 @@ func (m *RpcAccountSelectRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) _ = i var l int _ = l + if len(m.FulltextPrimaryLanguage) > 0 { + i -= len(m.FulltextPrimaryLanguage) + copy(dAtA[i:], m.FulltextPrimaryLanguage) + i = encodeVarintCommands(dAtA, i, uint64(len(m.FulltextPrimaryLanguage))) + i-- + dAtA[i] = 0x42 + } if len(m.JsonApiListenAddr) > 0 { i -= len(m.JsonApiListenAddr) copy(dAtA[i:], m.JsonApiListenAddr) @@ -79590,6 +79661,13 @@ func (m *RpcAccountRecoverFromLegacyExportRequest) MarshalToSizedBuffer(dAtA []b _ = i var l int _ = l + if len(m.FulltextPrimaryLanguage) > 0 { + i -= len(m.FulltextPrimaryLanguage) + copy(dAtA[i:], m.FulltextPrimaryLanguage) + i = encodeVarintCommands(dAtA, i, uint64(len(m.FulltextPrimaryLanguage))) + i-- + dAtA[i] = 0x22 + } if m.Icon != 0 { i = encodeVarintCommands(dAtA, i, uint64(m.Icon)) i-- @@ -121802,6 +121880,10 @@ func (m *RpcWalletCreateRequest) Size() (n int) { if l > 0 { n += 1 + l + sovCommands(uint64(l)) } + l = len(m.FulltextPrimaryLanguage) + if l > 0 { + n += 1 + l + sovCommands(uint64(l)) + } return n } @@ -121861,6 +121943,10 @@ func (m *RpcWalletRecoverRequest) Size() (n int) { if l > 0 { n += 1 + l + sovCommands(uint64(l)) } + l = len(m.FulltextPrimaryLanguage) + if l > 0 { + n += 1 + l + sovCommands(uint64(l)) + } return n } @@ -122391,6 +122477,10 @@ func (m *RpcAccountMigrateRequest) Size() (n int) { if l > 0 { n += 1 + l + sovCommands(uint64(l)) } + l = len(m.FulltextPrimaryLanguage) + if l > 0 { + n += 1 + l + sovCommands(uint64(l)) + } return n } @@ -122514,6 +122604,10 @@ func (m *RpcAccountSelectRequest) Size() (n int) { if l > 0 { n += 1 + l + sovCommands(uint64(l)) } + l = len(m.FulltextPrimaryLanguage) + if l > 0 { + n += 1 + l + sovCommands(uint64(l)) + } return n } @@ -122759,6 +122853,10 @@ func (m *RpcAccountRecoverFromLegacyExportRequest) Size() (n int) { if m.Icon != 0 { n += 1 + sovCommands(uint64(m.Icon)) } + l = len(m.FulltextPrimaryLanguage) + if l > 0 { + n += 1 + l + sovCommands(uint64(l)) + } return n } @@ -147189,6 +147287,38 @@ func (m *RpcWalletCreateRequest) Unmarshal(dAtA []byte) error { } m.RootPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FulltextPrimaryLanguage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommands + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCommands + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCommands + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FulltextPrimaryLanguage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCommands(dAtA[iNdEx:]) @@ -147572,6 +147702,38 @@ func (m *RpcWalletRecoverRequest) Unmarshal(dAtA []byte) error { } m.Mnemonic = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FulltextPrimaryLanguage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommands + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCommands + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCommands + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FulltextPrimaryLanguage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCommands(dAtA[iNdEx:]) @@ -150850,6 +151012,38 @@ func (m *RpcAccountMigrateRequest) Unmarshal(dAtA []byte) error { } m.RootPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FulltextPrimaryLanguage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommands + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCommands + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCommands + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FulltextPrimaryLanguage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCommands(dAtA[iNdEx:]) @@ -151643,6 +151837,38 @@ func (m *RpcAccountSelectRequest) Unmarshal(dAtA []byte) error { } m.JsonApiListenAddr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FulltextPrimaryLanguage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommands + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCommands + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCommands + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FulltextPrimaryLanguage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCommands(dAtA[iNdEx:]) @@ -153180,6 +153406,38 @@ func (m *RpcAccountRecoverFromLegacyExportRequest) Unmarshal(dAtA []byte) error break } } + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FulltextPrimaryLanguage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowCommands + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthCommands + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthCommands + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.FulltextPrimaryLanguage = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipCommands(dAtA[iNdEx:]) diff --git a/pb/protos/commands.proto b/pb/protos/commands.proto index 1146832b7..5931859a7 100644 --- a/pb/protos/commands.proto +++ b/pb/protos/commands.proto @@ -543,6 +543,7 @@ message Rpc { message Request { option (no_auth) = true; string rootPath = 1; // Path to a wallet directory + string fulltextPrimaryLanguage = 2; // optional, default fts language } /** @@ -577,6 +578,7 @@ message Rpc { string rootPath = 1; // Path to a wallet directory string mnemonic = 2; // Mnemonic of a wallet to recover + string fulltextPrimaryLanguage = 3; // optional, default fts language } /** @@ -817,6 +819,7 @@ message Rpc { option (no_auth) = true; string id = 1; // Id of a selected account string rootPath = 2; + string fulltextPrimaryLanguage = 3; // optional, default fts language } message Response { @@ -874,6 +877,7 @@ message Rpc { string networkCustomConfigFilePath = 5; // config path for the custom network mode bool preferYamuxTransport = 6; // optional, default is false, recommended in case of problems with QUIC transport string jsonApiListenAddr = 7; // optional, if empty json api will not be started; 127.0.0.1:31009 should be the default one + string fulltextPrimaryLanguage = 8; // optional, default fts language } /** @@ -1042,6 +1046,7 @@ message Rpc { string path = 1; string rootPath = 2; int64 icon = 3; + string fulltextPrimaryLanguage = 4; // optional, default fts language } message Response { diff --git a/pkg/lib/localstore/ftsearch/autobatchertantivy.go b/pkg/lib/localstore/ftsearch/autobatcher.go similarity index 88% rename from pkg/lib/localstore/ftsearch/autobatchertantivy.go rename to pkg/lib/localstore/ftsearch/autobatcher.go index 7fa4e7190..b82e7bc45 100644 --- a/pkg/lib/localstore/ftsearch/autobatchertantivy.go +++ b/pkg/lib/localstore/ftsearch/autobatcher.go @@ -41,7 +41,7 @@ func (f *ftSearchTantivy) Iterate(objectId string, fields []string, shouldContin defer f.parserPool.Put(parser) searchResult, err := tantivy.GetSearchResults( result, - f.schema, + f.index, func(json string) (*DocumentMatch, error) { value, err := parser.Parse(json) if err != nil { @@ -114,37 +114,22 @@ func (f *ftIndexBatcherTantivy) UpdateDoc(searchDoc SearchDoc) error { return fmt.Errorf("failed to create document") } - err = doc.AddField(fieldId, searchDoc.Id, f.index) + err = doc.AddFields(searchDoc.Id, f.index, fieldId, fieldIdRaw) if err != nil { return err } - err = doc.AddField(fieldIdRaw, searchDoc.Id, f.index) + err = doc.AddField(searchDoc.SpaceId, f.index, fieldSpace) if err != nil { return err } - err = doc.AddField(fieldSpace, searchDoc.SpaceId, f.index) + err = doc.AddFields(searchDoc.Title, f.index, fieldTitle, fieldTitleZh) if err != nil { return err } - err = doc.AddField(fieldTitle, searchDoc.Title, f.index) - if err != nil { - return err - } - - err = doc.AddField(fieldTitleZh, searchDoc.Title, f.index) - if err != nil { - return err - } - - err = doc.AddField(fieldText, searchDoc.Text, f.index) - if err != nil { - return err - } - - err = doc.AddField(fieldTextZh, searchDoc.Text, f.index) + err = doc.AddFields(searchDoc.Text, f.index, fieldText, fieldTextZh) if err != nil { return err } diff --git a/pkg/lib/localstore/ftsearch/ftsearchtantivy.go b/pkg/lib/localstore/ftsearch/ftsearch.go similarity index 93% rename from pkg/lib/localstore/ftsearch/ftsearchtantivy.go rename to pkg/lib/localstore/ftsearch/ftsearch.go index 9b3804f88..979cc50f9 100644 --- a/pkg/lib/localstore/ftsearch/ftsearchtantivy.go +++ b/pkg/lib/localstore/ftsearch/ftsearch.go @@ -91,21 +91,15 @@ type DocumentMatch struct { Fields map[string]any } -var specialChars = map[rune]struct{}{ - '+': {}, '^': {}, '`': {}, ':': {}, '{': {}, - '}': {}, '"': {}, '[': {}, ']': {}, '(': {}, - ')': {}, '~': {}, '!': {}, '\\': {}, '*': {}, -} - type ftSearchTantivy struct { rootPath string ftsPath string builderId string index *tantivy.TantivyContext - schema *tantivy.Schema parserPool *fastjson.ParserPool mu sync.Mutex blevePath string + lang tantivy.Language } func TantivyNew() FTSearch { @@ -144,6 +138,7 @@ func (f *ftSearchTantivy) DeleteObject(objectId string) error { func (f *ftSearchTantivy) Init(a *app.App) error { repoPath := app.MustComponent[wallet.Wallet](a).RepoPath() + f.lang = validateLanguage(app.MustComponent[wallet.Wallet](a).FtsPrimaryLang()) f.rootPath = filepath.Join(repoPath, ftsDir2) f.blevePath = filepath.Join(repoPath, ftsDir) f.ftsPath = filepath.Join(repoPath, ftsDir2, ftsVer) @@ -245,14 +240,13 @@ func (f *ftSearchTantivy) Run(context.Context) error { if err != nil { return err } - f.schema = schema f.index = index f.parserPool = &fastjson.ParserPool{} f.cleanupBleve() f.cleanUpOldIndexes() - err = index.RegisterTextAnalyzerSimple(tantivy.TokenizerSimple, 40, tantivy.English) + err = index.RegisterTextAnalyzerSimple(tantivy.TokenizerSimple, 40, f.lang) if err != nil { return err } @@ -307,31 +301,19 @@ func (f *ftSearchTantivy) Index(doc SearchDoc) error { func (f *ftSearchTantivy) convertDoc(doc SearchDoc) (*tantivy.Document, error) { document := tantivy.NewDocument() - err := document.AddField(fieldId, doc.Id, f.index) + err := document.AddFields(doc.Id, f.index, fieldId, fieldIdRaw) if err != nil { return nil, err } - err = document.AddField(fieldIdRaw, doc.Id, f.index) + err = document.AddField(doc.SpaceId, f.index, fieldSpace) if err != nil { return nil, err } - err = document.AddField(fieldSpace, doc.SpaceId, f.index) + err = document.AddFields(doc.Title, f.index, fieldTitle, fieldTitleZh) if err != nil { return nil, err } - err = document.AddField(fieldTitle, doc.Title, f.index) - if err != nil { - return nil, err - } - err = document.AddField(fieldTitleZh, doc.Title, f.index) - if err != nil { - return nil, err - } - err = document.AddField(fieldText, doc.Text, f.index) - if err != nil { - return nil, err - } - err = document.AddField(fieldTextZh, doc.Text, f.index) + err = document.AddFields(doc.Text, f.index, fieldText, fieldTextZh) if err != nil { return nil, err } @@ -410,7 +392,7 @@ func (f *ftSearchTantivy) performSearch(spaceId, query string, buildQueryFunc fu return tantivy.GetSearchResults( result, - f.schema, + f.index, func(json string) (*DocumentMatch, error) { return parseSearchResult(json, p) }, @@ -549,11 +531,9 @@ func (f *ftSearchTantivy) DocCount() (uint64, error) { } func (f *ftSearchTantivy) Close(ctx context.Context) error { - f.schema = nil if f.index != nil { f.index.Free() f.index = nil - f.schema = nil } return nil } @@ -568,3 +548,17 @@ func prepareQuery(query string) string { query = strings.TrimSpace(query) return query } + +func validateLanguage(lang string) tantivy.Language { + tantivyLang := tantivy.Language(lang) + switch tantivyLang { + case tantivy.Arabic, tantivy.Armenian, tantivy.Basque, tantivy.Catalan, tantivy.Danish, tantivy.Dutch, tantivy.English, + tantivy.Estonian, tantivy.Finnish, tantivy.French, tantivy.German, tantivy.Greek, tantivy.Hindi, tantivy.Hungarian, + tantivy.Indonesian, tantivy.Irish, tantivy.Italian, tantivy.Lithuanian, tantivy.Nepali, tantivy.Norwegian, + tantivy.Portuguese, tantivy.Romanian, tantivy.Russian, tantivy.Serbian, tantivy.Spanish, tantivy.Swedish, + tantivy.Tamil, tantivy.Turkish, tantivy.Yiddish: + return tantivyLang + default: + return tantivy.English + } +} diff --git a/pkg/lib/localstore/ftsearch/ftsearchtantivy_test.go b/pkg/lib/localstore/ftsearch/ftsearch_test.go similarity index 95% rename from pkg/lib/localstore/ftsearch/ftsearchtantivy_test.go rename to pkg/lib/localstore/ftsearch/ftsearch_test.go index 081ae2cdc..b90d58439 100644 --- a/pkg/lib/localstore/ftsearch/ftsearchtantivy_test.go +++ b/pkg/lib/localstore/ftsearch/ftsearch_test.go @@ -273,21 +273,6 @@ func assertChineseFound(t *testing.T, tmpDir string) { _ = ft.Close(nil) } -func assertThaiSubstrFound(t *testing.T, tmpDir string) { - fixture := newFixture(tmpDir, t) - ft := fixture.ft - require.NoError(t, ft.Index(SearchDoc{ - Id: "test", - Title: "ตัวอย่าง", - Text: "พรระเจ้า \n kumamon", - })) - - validateSearch(t, ft, "", "ระเ", 1) - validateSearch(t, ft, "", "ระเ ma", 1) - - _ = ft.Close(nil) -} - func assertProperIds(t *testing.T, tmpDir string) { fixture := newFixture(tmpDir, t) ft := fixture.ft diff --git a/pkg/lib/localstore/objectstore/fixture.go b/pkg/lib/localstore/objectstore/fixture.go index c7ada1739..7cab5efe6 100644 --- a/pkg/lib/localstore/objectstore/fixture.go +++ b/pkg/lib/localstore/objectstore/fixture.go @@ -66,6 +66,10 @@ func newWalletStub(t testing.TB) wallet.Wallet { } } +func (w *walletStub) FtsPrimaryLang() string { + return "" +} + func (w *walletStub) RepoPath() string { return w.tempDir } diff --git a/pkg/lib/localstore/objectstore/spaceindex/fixture.go b/pkg/lib/localstore/objectstore/spaceindex/fixture.go index da5cf3e57..1289a79f9 100644 --- a/pkg/lib/localstore/objectstore/spaceindex/fixture.go +++ b/pkg/lib/localstore/objectstore/spaceindex/fixture.go @@ -73,6 +73,7 @@ func NewStoreFixture(t testing.TB) *StoreFixture { walletService := mock_wallet.NewMockWallet(t) walletService.EXPECT().Name().Return(wallet.CName).Maybe() walletService.EXPECT().RepoPath().Return(t.TempDir()) + walletService.EXPECT().FtsPrimaryLang().Return("") fullText := ftsearch.TantivyNew() testApp := &app.App{} diff --git a/tantivity_sha256.txt b/tantivity_sha256.txt index a3bf21366..2456d1167 100644 --- a/tantivity_sha256.txt +++ b/tantivity_sha256.txt @@ -1,12 +1,12 @@ -bd658eb370191a0154ac47e0f61fa6d91e8313de7e64cfede5078fea93e4eb34 deps/libs/android-386.tar.gz -a5d3083ac3eacbc0970153d0a5891412a595dcefe0dbe5b1134108ae5eac7072 deps/libs/android-amd64.tar.gz -9411be7eda46fbd1548ca2804d1056b735a989df740129f67b924c407a9ce3a1 deps/libs/android-arm.tar.gz -09a8b921b8d1385c7114ec67f6e665a448f7329642b178b84ecfdd7faf1828e1 deps/libs/android-arm64.tar.gz -2f27b349b54d5982347f20b56ae8e4bacce5436fb3a1dd213f3c1bfc3ed60b0b deps/libs/darwin-amd64.tar.gz -a518db7c5f9ebeb267966e390f788b76ee2643353af381e61110111546d3291b deps/libs/darwin-arm64.tar.gz -1da257cbf8cf27bfeda21b5dc4c432412b58e06b80fe3653384b1bc5c12de004 deps/libs/ios-amd64.tar.gz -6d7238b2743a23a745a52a1efb56760e3168e0601b292c96446afb7b737e5096 deps/libs/ios-arm64.tar.gz -d412c6864853d916dd507508ec4a2f63b8eddc48a3e619e74dc7a90aaeb3f1a9 deps/libs/ios-arm64-sim.tar.gz -35db326fee587c60cfec806847bff9706c8a209d46ee7449bb8664ee3ba815d5 deps/libs/linux-amd64-musl.tar.gz -6029bdc9ef576e4473bb15e967255f76f25e12e211ae131cb887211916ca0fed deps/libs/linux-arm64-musl.tar.gz -7475c129c4e18a93dfb8e583da95abf073d70f8a589291cf5d5ca6f8c71021e5 deps/libs/windows-amd64.tar.gz +565dd299ef61edff535b20ec166f34f2399529b8254eed5d137a771a7b2b7c04 deps/libs/android-386.tar.gz +34d9c7d4a400653ddbcf28e64a5c8e055c08ab675df6b921cebedb4c5e667254 deps/libs/android-amd64.tar.gz +d90b501033763687f1ae136d69e284033594870c7143e50624799ff474e12f41 deps/libs/android-arm.tar.gz +3939f7ad6a1d08a0a559566d0ae5195739317a0023381bcb719603a7e2cac10d deps/libs/android-arm64.tar.gz +b7f7c3e82b1054a4c0755e7cd32f98d1dbe2ec55dab49f07e6620c8e2cd3ff83 deps/libs/darwin-amd64.tar.gz +40cdb051d2e063eb374e1a911ca7926beb4586c41a0347e430dc18fe5c216790 deps/libs/darwin-arm64.tar.gz +2dc93d6cb9356df9b5c330a6c566e1da1a4dfb32a17f1262080f2c1a875a5775 deps/libs/ios-amd64.tar.gz +2a949a364f29c5801c3c18607dbc14b5edefdcd002746ce94c89f297bb4f620c deps/libs/ios-arm64.tar.gz +b09afc40d37a37377579ec4096511fd88cc22cdd387518225a77f205c226130a deps/libs/ios-arm64-sim.tar.gz +122010a6f287a3d3b169a64c26918bd5745a1190c99638e7e91a664172781cf7 deps/libs/linux-amd64-musl.tar.gz +2b86930fcd938fe41413f4f915c90a2093d703179c61153ec4a007cdd2ed4a9c deps/libs/linux-arm64-musl.tar.gz +2cdefb8975651849f6c5f41c5a934035d959e797c6fdef9a5a946ec9052e3bee deps/libs/windows-amd64.tar.gz diff --git a/util/builtinobjects/data/get_started.zip b/util/builtinobjects/data/get_started.zip index 01c63e352..418a8320b 100644 Binary files a/util/builtinobjects/data/get_started.zip and b/util/builtinobjects/data/get_started.zip differ diff --git a/util/text/text_test.go b/util/text/text_test.go index 66ef6caf4..fae2d50e4 100644 --- a/util/text/text_test.go +++ b/util/text/text_test.go @@ -32,19 +32,31 @@ func TestTruncateEllipsized(t *testing.T) { expected: " ", }, { - name: "Divine emojie not fit", + name: "Divine emoji not fit", text: "🌍", length: 1, expected: " …", }, { - name: "Divine emojies fit", + name: "Big emoji fit", + text: "👨‍👩‍👧‍👦", + length: 11, + expected: "👨‍👩‍👧‍👦", + }, + { + name: "Big emoji not fit", + text: "👨‍👩‍👧‍👦", + length: 10, + expected: "👨\u200d👩\u200d👧 …", + }, + { + name: "Divine emoji fit", text: "🌍", length: 4, expected: "🌍", }, { - name: "Text with divine emojies not fit", + name: "Text with divine emoji not fit", text: "Hello 🌍", length: 7, expected: "Hello …",