From 88a836003e2f220a987b97585faec5de86000214 Mon Sep 17 00:00:00 2001 From: Tim Buckley Date: Wed, 14 May 2025 11:48:47 -0600 Subject: [PATCH 1/5] MWI: Bound Keypair Joining - Minimal Client Implementation (#54372) * MWI: Bound Keypair Joining - Minimal Client Implementation This contains a minimal client-side implementation of bound keypair joining for `tbot`. This first iteration supports only preregistered keys, and so adds a new `tbot keypair create` subcommand that generates a keypair and prints a public key that can be copied into a token. In an effort to still take advantange of tbot's secure filesystem abstraction and to not permanently tie the new join method to it, this includes a minimal filesystem wrapper to adapt tbot's destinations to a generic file read/write interface. * Rebase join client to handle interactive rotation messages This updates the client implementation to handle the revised challenge handler signature. Rotation still isn't implemented (see TODOs), but the message handler now explicitly accounts for rotation-type requests from the server. * Fix breakage after upstream changes, idempotent key generation The `keypair generate` command is now idempotent and will not generate a new keypair if one already exists in the specified destination. Also, added a `--format=json` flag to print the key as machine-readable JSON. * Remove unnecessary whitespace * Small TODO and doc comment updates * Fix lints * Mark `keypair create` as a hidden command for now This hides it from `tbot help` so we can opt to tweak the CLI contract before fully releasing the feature. It will be unhidden in the near future. * Fix typo --- lib/auth/join/boundkeypair/boundkeypair.go | 214 ++++++++++++++++++ lib/auth/join/join.go | 146 +++++++++++- lib/tbot/cli/keypair_create.go | 47 ++++ lib/tbot/cli/start_shared.go | 23 +- lib/tbot/config/config.go | 13 ++ .../destination_bound_keypair_adapter.go | 55 +++++ lib/tbot/service_bot_identity.go | 15 ++ tool/tbot/keypair.go | 141 ++++++++++++ tool/tbot/main.go | 6 + 9 files changed, 653 insertions(+), 7 deletions(-) create mode 100644 lib/auth/join/boundkeypair/boundkeypair.go create mode 100644 lib/tbot/cli/keypair_create.go create mode 100644 lib/tbot/config/destination_bound_keypair_adapter.go create mode 100644 tool/tbot/keypair.go diff --git a/lib/auth/join/boundkeypair/boundkeypair.go b/lib/auth/join/boundkeypair/boundkeypair.go new file mode 100644 index 0000000000000..a91be7334e1a1 --- /dev/null +++ b/lib/auth/join/boundkeypair/boundkeypair.go @@ -0,0 +1,214 @@ +/* + * Teleport + * Copyright (C) 2025 Gravitational, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package boundkeypair + +import ( + "context" + "os" + "path/filepath" + + "github.com/gravitational/trace" + "golang.org/x/crypto/ssh" + + "github.com/gravitational/teleport/api/utils/keys" + "github.com/gravitational/teleport/lib/auth/join" + "github.com/gravitational/teleport/lib/cryptosuites" +) + +const ( + PrivateKeyPath = "id_bkp" + PublicKeyPath = PrivateKeyPath + ".pub" + JoinStatePath = "bkp_state" + + StandardFileWriteMode = 0600 +) + +// ClientState contains state parameters stored on disk needed to complete the +// bound keypair join process. +type ClientState struct { + // PrivateKey is the parsed private key. + PrivateKey *keys.PrivateKey + + // PrivateKeyBytes contains the private key bytes. This value should always + // be nonempty. + PrivateKeyBytes []byte + + // PublicKeyBytes contains the public key bytes. This value is not used at + // runtime, and is only set when a public key should be written to disk, + // like on first creation or during rotation. To consistently access the + // public key, use `.PrivateKey.Public()`. + PublicKeyBytes []byte + + // JoinStateBytes contains join state bytes. This value will be empty if + // this client has not yet joined. + JoinStateBytes []byte +} + +// ToJoinParams creates joining parameters for use with `join.Register()` from +// this client state. +func (c *ClientState) ToJoinParams(initialJoinSecret string) *join.BoundKeypairParams { + if len(c.JoinStateBytes) > 0 { + // This identity has been bound, so don't pass along the join secret (if + // any) + initialJoinSecret = "" + } + + return &join.BoundKeypairParams{ + // Note: pass the internal signer because go-jose does type assertions + // on the standard library types. + CurrentKey: c.PrivateKey.Signer, + PreviousJoinState: c.JoinStateBytes, + InitialJoinSecret: initialJoinSecret, + } +} + +// ToPublicKeyBytes returns the public key bytes in ssh authorized_keys format. +func (c *ClientState) ToPublicKeyBytes() ([]byte, error) { + sshPubKey, err := ssh.NewPublicKey(c.PrivateKey.Public()) + if err != nil { + return nil, trace.Wrap(err, "creating ssh public key") + } + + return ssh.MarshalAuthorizedKey(sshPubKey), nil +} + +type FS interface { + Read(ctx context.Context, name string) ([]byte, error) + Write(ctx context.Context, name string, data []byte) error +} + +type StandardFS struct { + parentDir string +} + +func (f *StandardFS) Read(ctx context.Context, name string) ([]byte, error) { + data, err := os.ReadFile(name) + if err != nil { + return nil, trace.Wrap(err) + } + + return data, nil +} + +func (f *StandardFS) Write(ctx context.Context, name string, data []byte) error { + path := filepath.Join(f.parentDir, name) + + return trace.Wrap(os.WriteFile(path, data, StandardFileWriteMode)) +} + +// NewStandardFS creates a new standard FS implementation. +func NewStandardFS(parentDir string) FS { + return &StandardFS{ + parentDir: parentDir, + } +} + +// LoadClientState attempts to load bound keypair client state from the given +// filesystem implementation. Callers should expect to handle NotFound errors +// returned here if a private key is not found; this indicates no prior client +// state exists and initial secret joining should be attempted if possible. If +// a keypair has been pregenerated, no prior join state will exist, and the +// join state will be empty; any corresponding errors while reading nonexistent +// join state documents will be ignored. +func LoadClientState(ctx context.Context, fs FS) (*ClientState, error) { + privateKeyBytes, err := fs.Read(ctx, PrivateKeyPath) + if err != nil { + return nil, trace.Wrap(err, "reading private key") + } + + joinStateBytes, err := fs.Read(ctx, JoinStatePath) + if trace.IsNotFound(err) { + // Join state doesn't exist, this is allowed. + } else if err != nil { + return nil, trace.Wrap(err, "reading previous join state") + } + + pk, err := keys.ParsePrivateKey(privateKeyBytes) + if err != nil { + return nil, trace.Wrap(err, "parsing private key") + } + + return &ClientState{ + PrivateKey: pk, + + PrivateKeyBytes: privateKeyBytes, + JoinStateBytes: joinStateBytes, + }, nil +} + +// StoreClientState writes bound keypair client state to the given filesystem +// wrapper. Public keys and join state will only be written if +func StoreClientState(ctx context.Context, fs FS, state *ClientState) error { + if err := fs.Write(ctx, PrivateKeyPath, state.PrivateKeyBytes); err != nil { + return trace.Wrap(err, "writing private key") + } + + // TODO: maybe consider just not writing the public key at all. End users + // aren't really meant to look in the internal storage, and we can just + // derive the public key whenever we want. + + // Only write the public key if it was explicitly provided. This helps save + // an unnecessary file write. + if len(state.PublicKeyBytes) > 0 { + if err := fs.Write(ctx, PublicKeyPath, state.PublicKeyBytes); err != nil { + return trace.Wrap(err, "writing public key") + } + } + + if len(state.JoinStateBytes) > 0 { + if err := fs.Write(ctx, JoinStatePath, state.JoinStateBytes); err != nil { + return trace.Wrap(err, "writing previous join state") + } + } + + return nil +} + +// NewUnboundClientState creates a new client state that has not yet been bound, +// i.e. a new keypair that has not been registered with Auth, and no prior join +// state. +func NewUnboundClientState(ctx context.Context, getSuite cryptosuites.GetSuiteFunc) (*ClientState, error) { + key, err := cryptosuites.GenerateKey(ctx, getSuite, cryptosuites.BoundKeypairJoining) + if err != nil { + return nil, trace.Wrap(err, "generating keypair") + } + + privateKeyBytes, err := keys.MarshalPrivateKey(key) + if err != nil { + return nil, trace.Wrap(err, "marshallng private key") + } + + sshPubKey, err := ssh.NewPublicKey(key.Public()) + if err != nil { + return nil, trace.Wrap(err, "creating ssh public key") + } + + publicKeyBytes := ssh.MarshalAuthorizedKey(sshPubKey) + + pk, err := keys.NewPrivateKey(key) + if err != nil { + return nil, trace.Wrap(err) + } + + return &ClientState{ + PrivateKeyBytes: privateKeyBytes, + PublicKeyBytes: publicKeyBytes, + PrivateKey: pk, + }, nil +} diff --git a/lib/auth/join/join.go b/lib/auth/join/join.go index 4ce551b695a5f..a650381d7204a 100644 --- a/lib/auth/join/join.go +++ b/lib/auth/join/join.go @@ -23,8 +23,10 @@ import ( "log/slog" "net/http" "os" + "strings" "time" + "github.com/go-jose/go-jose/v3" "github.com/gravitational/trace" "github.com/jonboulle/clockwork" "go.opentelemetry.io/otel" @@ -53,6 +55,7 @@ import ( "github.com/gravitational/teleport/lib/defaults" "github.com/gravitational/teleport/lib/githubactions" "github.com/gravitational/teleport/lib/gitlab" + "github.com/gravitational/teleport/lib/jwt" kubetoken "github.com/gravitational/teleport/lib/kube/token" "github.com/gravitational/teleport/lib/spacelift" "github.com/gravitational/teleport/lib/terraformcloud" @@ -82,6 +85,22 @@ type GitlabParams struct { EnvVarName string } +// BoundKeypairParams are parameters specific to bound-keypair joining. +type BoundKeypairParams struct { + // InitialJoinSecret is a one-time-use joining token for use on first join. + // May be unset if a keypair was registered with Auth out of band. + InitialJoinSecret string + + // CurrentKey is the keypair currently registered with Auth. On initial + // join using `InitialJoinSecret`, this should be nil in favor of `NewKey`. + CurrentKey crypto.Signer + + // PreviousJoinState is the previous join state document provided by Auth + // alongside the previous set of certs. If this is initial registration, it + // can be empty. + PreviousJoinState []byte +} + // RegisterParams specifies parameters // for first time register operation with auth server type RegisterParams struct { @@ -153,6 +172,8 @@ type RegisterParams struct { TerraformCloudAudienceTag string // GitlabParams is the parameters specific to the gitlab join method. GitlabParams GitlabParams + // BoundKeypairParams contains parameters specific to bound keypair joining. + BoundKeypairParams *BoundKeypairParams } func (r *RegisterParams) checkAndSetDefaults() error { @@ -281,6 +302,10 @@ func Register(ctx context.Context, params RegisterParams) (result *RegisterResul if err != nil { return nil, trace.Wrap(err) } + case types.JoinMethodBoundKeypair: + if params.BoundKeypairParams == nil { + return nil, trace.BadParameter("bound keypair parameters are required") + } } // If an explicit AuthClient has been provided, we want to go straight to @@ -378,7 +403,9 @@ func registerThroughProxy( case types.JoinMethodIAM, types.JoinMethodAzure, types.JoinMethodTPM, - types.JoinMethodOracle: + types.JoinMethodOracle, + types.JoinMethodBoundKeypair: + // These join methods require gRPC client conn, err := proxyinsecureclient.NewConnection( ctx, @@ -405,6 +432,8 @@ func registerThroughProxy( certs, err = registerUsingTPMMethod(ctx, joinServiceClient, token, hostKeys, params) case types.JoinMethodOracle: certs, err = registerUsingOracleMethod(ctx, joinServiceClient, token, hostKeys, params) + case types.JoinMethodBoundKeypair: + certs, err = registerUsingBoundKeypairMethod(ctx, joinServiceClient, token, hostKeys, params) default: return nil, trace.BadParameter("unhandled join method %q", params.JoinMethod) } @@ -493,6 +522,8 @@ func registerThroughAuthClient( certs, err = registerUsingAzureMethod(ctx, client, token, hostKeys, params) case types.JoinMethodTPM: certs, err = registerUsingTPMMethod(ctx, client, token, hostKeys, params) + case types.JoinMethodBoundKeypair: + certs, err = registerUsingBoundKeypairMethod(ctx, client, token, hostKeys, params) default: // non-IAM join methods use HTTP endpoint // Get the SSH and X509 certificates for a node. @@ -677,6 +708,11 @@ type joinServiceClient interface { tokenReq *types.RegisterUsingTokenRequest, challengeResponse client.RegisterOracleChallengeResponseFunc, ) (*proto.Certs, error) + RegisterUsingBoundKeypairMethod( + ctx context.Context, + req *proto.RegisterUsingBoundKeypairInitialRequest, + challengeResponse client.RegisterUsingBoundKeypairChallengeResponseFunc, + ) (*proto.Certs, string, error) } func registerUsingTokenRequestForParams(token string, hostKeys *newHostKeys, params RegisterParams) *types.RegisterUsingTokenRequest { @@ -857,6 +893,114 @@ func registerUsingOracleMethod( return certs, trace.Wrap(err) } +// sshPubKeyFromSigner returns the public key of the given signer in ssh +// authorized_keys format. +func sshPubKeyFromSigner(signer crypto.Signer) (string, error) { + sshKey, err := ssh.NewPublicKey(signer.Public()) + if err != nil { + return "", trace.Wrap(err, "creating SSH public key from signer") + } + + return strings.TrimSpace(string(ssh.MarshalAuthorizedKey(sshKey))), nil +} + +// registerUsingBoundKeypairMethod performs bound keypair-type registration and +// handles the joining ceremony. +func registerUsingBoundKeypairMethod( + ctx context.Context, + client joinServiceClient, + token string, + hostKeys *newHostKeys, + params RegisterParams, +) (*proto.Certs, error) { + bkParams := params.BoundKeypairParams + + // Build a map of all public keys to signers. At the moment, this is just + // the current key, but may include e.g. previous and next keys for use in + // case of a failed rotation attempt. + // TODO: This implementation is likely to change when rotation is + // implemented. + signers := map[string]crypto.Signer{} + + if bkParams.CurrentKey != nil { + pub, err := sshPubKeyFromSigner(bkParams.CurrentKey) + if err != nil { + return nil, trace.Wrap(err, "generating ssh public key from current key signer") + } + + signers[pub] = bkParams.CurrentKey + } + + initReq := &proto.RegisterUsingBoundKeypairInitialRequest{ + JoinRequest: registerUsingTokenRequestForParams(token, hostKeys, params), + InitialJoinSecret: bkParams.InitialJoinSecret, + PreviousJoinState: bkParams.PreviousJoinState, + } + + // TODO: When implementing rotation, we should make use of the returned + // public key to ensure that key is marked as the primary. + certs, _, err := client.RegisterUsingBoundKeypairMethod( + ctx, + initReq, + func(resp *proto.RegisterUsingBoundKeypairMethodResponse) (*proto.RegisterUsingBoundKeypairMethodRequest, error) { + switch kind := resp.GetResponse().(type) { + case *proto.RegisterUsingBoundKeypairMethodResponse_Challenge: + // Unlike other join methods, this function may be called multiple + // times to complete challenges using one or both signers, so we'll + // use the passed publicKey hint to resolve the proper signer to + // use. + signer, ok := signers[kind.Challenge.PublicKey] + if !ok { + return nil, trace.NotFound("could not complete challenge for unknown public key: %+#v", kind.Challenge.PublicKey) + } + + // TODO: might not be worth exporting this func; may be cheaper to + // just copy the function here instead. + alg, err := jwt.AlgorithmForPublicKey(signer.Public()) + if err != nil { + return nil, trace.Wrap(err, "determining signing algorithm for public key") + } + + opts := (&jose.SignerOptions{}).WithType("JWT") + key := jose.SigningKey{ + Algorithm: alg, + Key: signer, + } + + joseSigner, err := jose.NewSigner(key, opts) + if err != nil { + return nil, trace.Wrap(err, "creating signer") + } + + jws, err := joseSigner.Sign([]byte(kind.Challenge.Challenge)) + if err != nil { + return nil, trace.Wrap(err, "signing challenge") + } + + serialized, err := jws.CompactSerialize() + if err != nil { + return nil, trace.Wrap(err, "serializing signed challenge") + } + + return &proto.RegisterUsingBoundKeypairMethodRequest{ + Payload: &proto.RegisterUsingBoundKeypairMethodRequest_ChallengeResponse{ + ChallengeResponse: &proto.RegisterUsingBoundKeypairChallengeResponse{ + Solution: []byte(serialized), + }, + }, + }, nil + case *proto.RegisterUsingBoundKeypairMethodResponse_Rotation: + // TODO: Follow up implementation + return nil, trace.NotImplemented("keypair rotation not yet implemented") + default: + // Note: certs variant is handled by RegisterUsingBoundKeypairMethod() + return nil, trace.BadParameter("received unexpected challenge response: %v", resp.GetResponse()) + } + }) + + return certs, trace.Wrap(err) +} + // readCA will read in CA that will be used to validate the certificate that // the Auth Server presents. func readCA(path string) (*x509.Certificate, error) { diff --git a/lib/tbot/cli/keypair_create.go b/lib/tbot/cli/keypair_create.go new file mode 100644 index 0000000000000..69df80948ac4f --- /dev/null +++ b/lib/tbot/cli/keypair_create.go @@ -0,0 +1,47 @@ +/* + * Teleport + * Copyright (C) 2025 Gravitational, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package cli + +import "github.com/gravitational/teleport" + +// KeypairCreateCommand handles `tbot keypair create` +type KeypairCreateCommand struct { + *genericExecutorHandler[KeypairCreateCommand] + + ProxyServer string + Storage string + Overwrite bool + Format string +} + +// NewKeypairCreateCommand initializes the `keypair create` command and returns +// a struct to contain the parse result. +func NewKeypairCreateCommand(parentCmd KingpinClause, action func(*KeypairCreateCommand) error) *KeypairCreateCommand { + cmd := parentCmd.Command("create", "Create a keypair to preregister for bound-keypair joining").Hidden() + + c := &KeypairCreateCommand{} + c.genericExecutorHandler = newGenericExecutorHandler(cmd, c, action) + + cmd.Flag("storage", "An internal storage URI to write the keypair, such as file:///var/lib/teleport/bot").Required().StringVar(&c.Storage) + cmd.Flag("proxy-server", "The proxy server, which will be pinged to determine the current cryptographic suite in use").Required().StringVar(&c.ProxyServer) + cmd.Flag("overwrite", "If set, overwrite any existing keypair. If unset and a keypair already exists, its key will be printed for use.").BoolVar(&c.Overwrite) + cmd.Flag("format", "Output format, one of: text, json").Default(teleport.Text).EnumVar(&c.Format, teleport.Text, teleport.JSON) + + return c +} diff --git a/lib/tbot/cli/start_shared.go b/lib/tbot/cli/start_shared.go index 9d567500bf369..a817235af682a 100644 --- a/lib/tbot/cli/start_shared.go +++ b/lib/tbot/cli/start_shared.go @@ -106,12 +106,14 @@ func (a *AuthProxyArgs) ApplyConfig(cfg *config.BotConfig, l *slog.Logger) error type sharedStartArgs struct { *AuthProxyArgs - JoinMethod string - Token string - CAPins []string - CertificateTTL time.Duration - RenewalInterval time.Duration - Storage string + JoinMethod string + Token string + CAPins []string + CertificateTTL time.Duration + RenewalInterval time.Duration + Storage string + InitialJoinSecret string + Keypair string Oneshot bool DiagAddr string @@ -137,6 +139,7 @@ func newSharedStartArgs(cmd *kingpin.CmdClause) *sharedStartArgs { cmd.Flag("oneshot", "If set, quit after the first renewal.").IsSetByUser(&args.oneshotSetByUser).BoolVar(&args.Oneshot) cmd.Flag("diag-addr", "If set and the bot is in debug mode, a diagnostics service will listen on specified address.").StringVar(&args.DiagAddr) cmd.Flag("storage", "A destination URI for tbot's internal storage, e.g. file:///foo/bar").StringVar(&args.Storage) + cmd.Flag("initial-join-secret", "For bound keypair joining, specifies an initial joining secret.").StringVar(&args.InitialJoinSecret) return args } @@ -235,6 +238,14 @@ func (s *sharedStartArgs) ApplyConfig(cfg *config.BotConfig, l *slog.Logger) err cfg.Onboarding.SetToken(s.Token) } + if s.JoinMethod != string(types.JoinMethodBoundKeypair) && s.InitialJoinSecret != "" { + return trace.BadParameter("--initial-join-secret and --keypair are only valid with --join-method=%s", types.JoinMethodBoundKeypair) + } + + if s.InitialJoinSecret != "" { + cfg.Onboarding.BoundKeypair.InitialJoinSecret = s.InitialJoinSecret + } + return nil } diff --git a/lib/tbot/config/config.go b/lib/tbot/config/config.go index eeabf11e32ac9..3ee74ff120759 100644 --- a/lib/tbot/config/config.go +++ b/lib/tbot/config/config.go @@ -64,6 +64,7 @@ var SupportedJoinMethods = []string{ string(types.JoinMethodToken), string(types.JoinMethodTPM), string(types.JoinMethodTerraformCloud), + string(types.JoinMethodBoundKeypair), } // ReservedServiceNames are the service names reserved for internal use. @@ -123,6 +124,15 @@ type GitlabOnboardingConfig struct { TokenEnvVarName string `yaml:"token_env_var_name,omitempty"` } +// BoundKeypairOnboardingConfig contains parameters for the `bound_keypair` join +// method +type BoundKeypairOnboardingConfig struct { + // InitialJoinSecret is the name of the initial joining secret, if any. If + // not specified, a keypair must be created using `tbot keypair create` and + // registered with Teleport in advance. + InitialJoinSecret string +} + // OnboardingConfig contains values relevant to how the bot authenticates with // the Teleport cluster. type OnboardingConfig struct { @@ -152,6 +162,9 @@ type OnboardingConfig struct { // Gitlab holds configuration relevant to the `gitlab` join method. Gitlab GitlabOnboardingConfig `yaml:"gitlab,omitempty"` + + // BoundKeypair holds configuration relevant to the `bound_keypair` join method + BoundKeypair BoundKeypairOnboardingConfig `yaml:"bound_keypair,omitempty"` } // HasToken gives the ability to check if there has been a token value stored diff --git a/lib/tbot/config/destination_bound_keypair_adapter.go b/lib/tbot/config/destination_bound_keypair_adapter.go new file mode 100644 index 0000000000000..bebd82e2a38e9 --- /dev/null +++ b/lib/tbot/config/destination_bound_keypair_adapter.go @@ -0,0 +1,55 @@ +/* + * Teleport + * Copyright (C) 2025 Gravitational, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package config + +import ( + "context" + + "github.com/gravitational/trace" + + "github.com/gravitational/teleport/lib/tbot/bot" +) + +// BoundKeypairBotFSAdapter is an adapter to use bot destinations with the FS +// abstraction for bound keypair joining. This allows keypair and state storage +// to be written to all supported bot destination types. +type BoundKeypairDestinationAdapter struct { + destination bot.Destination +} + +func (f *BoundKeypairDestinationAdapter) Read(ctx context.Context, name string) ([]byte, error) { + bytes, err := f.destination.Read(ctx, name) + if err != nil { + return nil, trace.Wrap(err) + } + + return bytes, nil +} + +func (f *BoundKeypairDestinationAdapter) Write(ctx context.Context, name string, data []byte) error { + return trace.Wrap(f.destination.Write(ctx, name, data)) +} + +// NewBoundkeypairDestinationAdapter creates a new destination adapter for bound +// keypair loading and storage. +func NewBoundkeypairDestinationAdapter(d bot.Destination) *BoundKeypairDestinationAdapter { + return &BoundKeypairDestinationAdapter{ + destination: d, + } +} diff --git a/lib/tbot/service_bot_identity.go b/lib/tbot/service_bot_identity.go index ba5a8ec535139..82d047665d922 100644 --- a/lib/tbot/service_bot_identity.go +++ b/lib/tbot/service_bot_identity.go @@ -36,6 +36,7 @@ import ( "github.com/gravitational/teleport/api/utils/keys" "github.com/gravitational/teleport/api/utils/retryutils" "github.com/gravitational/teleport/lib/auth/join" + "github.com/gravitational/teleport/lib/auth/join/boundkeypair" "github.com/gravitational/teleport/lib/auth/state" "github.com/gravitational/teleport/lib/client" "github.com/gravitational/teleport/lib/cryptosuites" @@ -645,6 +646,20 @@ func botIdentityFromToken( } } + if params.JoinMethod == types.JoinMethodBoundKeypair { + joinSecret := cfg.Onboarding.BoundKeypair.InitialJoinSecret + + adapter := config.NewBoundkeypairDestinationAdapter(cfg.Storage.Destination) + state, err := boundkeypair.LoadClientState(ctx, adapter) + if trace.IsNotFound(err) && joinSecret != "" { + return nil, trace.NotImplemented("no existing client state was found and join secrets are not yet supported") + } else if err != nil { + return nil, trace.Wrap(err, "loading bound keypair client state") + } + + params.BoundKeypairParams = state.ToJoinParams(joinSecret) + } + result, err := join.Register(ctx, params) if err != nil { return nil, trace.Wrap(err) diff --git a/tool/tbot/keypair.go b/tool/tbot/keypair.go new file mode 100644 index 0000000000000..e91820a7be015 --- /dev/null +++ b/tool/tbot/keypair.go @@ -0,0 +1,141 @@ +/* + * Teleport + * Copyright (C) 2025 Gravitational, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package main + +import ( + "context" + "encoding/json" + "fmt" + "strings" + + "github.com/gravitational/trace" + + "github.com/gravitational/teleport" + "github.com/gravitational/teleport/api/client/webclient" + "github.com/gravitational/teleport/api/types" + "github.com/gravitational/teleport/lib/auth/join/boundkeypair" + "github.com/gravitational/teleport/lib/cryptosuites" + "github.com/gravitational/teleport/lib/tbot/cli" + "github.com/gravitational/teleport/lib/tbot/config" +) + +// getSuiteFromProxy fetches cryptosuite config from the given remote proxy. +func getSuiteFromProxy(proxyAddr string, insecure bool) cryptosuites.GetSuiteFunc { + // TODO: It's annoying to need to specify a proxy here. This won't be needed + // for keypairs generated at normal runtime since we'll have a proxy address + // available, but alternatives should be explored, since this UX is not + // good. + return func(ctx context.Context) (types.SignatureAlgorithmSuite, error) { + pr, err := webclient.Find(&webclient.Config{ + Context: ctx, + ProxyAddr: proxyAddr, + Insecure: insecure, + }) + if err != nil { + return types.SignatureAlgorithmSuite_SIGNATURE_ALGORITHM_SUITE_UNSPECIFIED, trace.Wrap(err, "pinging proxy to determine signature algorithm suite") + } + return pr.Auth.SignatureAlgorithmSuite, nil + } +} + +// KeypairDocument is the JSON struct printed to stdout when `--format=json` is +// specified. +type KeypairDocument struct { + PublicKey string `json:"public_key"` +} + +// printKeypair prints the current keypair from the given client state using the +// specified format. +func printKeypair(state *boundkeypair.ClientState, format string) error { + publicKeyBytes, err := state.ToPublicKeyBytes() + if err != nil { + return trace.Wrap(err) + } + + keyString := strings.TrimSpace(string(publicKeyBytes)) + + switch format { + case teleport.Text: + // TODO: maybe just print out an example token resource to copy and paste? Or a tctl command. + fmt.Printf( + "\nTo register the keypair with Teleport, include this public key in the token's\n"+ + "`spec.bound_keypair.onboarding.initial_public_key`:\n\n"+ + "\t%s\n\n", + keyString, + ) + case teleport.JSON: + bytes, err := json.Marshal(&KeypairDocument{ + PublicKey: keyString, + }) + if err != nil { + return trace.Wrap(err, "generating json") + } + + fmt.Printf("%s\n", string(bytes)) + default: + return trace.BadParameter("unsupported output format %s; keypair has been generated", format) + } + + return nil +} + +// onKeypairCreate command handles `tbot keypair create` +func onKeypairCreateCommand(ctx context.Context, globals *cli.GlobalArgs, cmd *cli.KeypairCreateCommand) error { + dest, err := config.DestinationFromURI(cmd.Storage) + if err != nil { + return trace.Wrap(err, "parsing storage URI") + } + + if err := dest.CheckAndSetDefaults(); err != nil { + return trace.Wrap(err, "initializing storage") + } + + fsAdapter := config.NewBoundkeypairDestinationAdapter(dest) + + // Check for existing client state. + state, err := boundkeypair.LoadClientState(ctx, fsAdapter) + if err == nil { + if !cmd.Overwrite { + log.InfoContext(ctx, "Existing client state found, printing existing public key. To generate a new key, pass --overwrite") + return trace.Wrap(printKeypair(state, cmd.Format)) + } else { + log.WarnContext(ctx, "Overwriting existing client state and generating a new keypair.") + } + } + + state, err = boundkeypair.NewUnboundClientState( + ctx, + getSuiteFromProxy(cmd.ProxyServer, globals.Insecure), + ) + if err != nil { + return trace.Wrap(err, "initializing new client state") + } + + if err := boundkeypair.StoreClientState(ctx, fsAdapter, state); err != nil { + return trace.Wrap(err, "writing bound keypair state") + } + + log.InfoContext( + ctx, + "keypair has been written to storage", + "storage", dest.String(), + ) + + return trace.Wrap(printKeypair(state, cmd.Format)) +} diff --git a/tool/tbot/main.go b/tool/tbot/main.go index ac2e444949c64..cadd10b88092e 100644 --- a/tool/tbot/main.go +++ b/tool/tbot/main.go @@ -84,6 +84,8 @@ func Run(args []string, stdout io.Writer) error { configureCmd := app.Command("configure", "Creates a config file based on flags provided, and writes it to stdout or a file (-c ).") configureCmd.Flag("output", "Path to write the generated configuration file to rather than write to stdout.").Short('o').StringVar(&configureOutPath) + keypairCmd := app.Command("keypair", "Manage keypairs for bound-keypair joining") + // TODO: consider discarding config flag for non-legacy. These should always be self contained. // Initialize all new-style commands. @@ -117,6 +119,10 @@ func Run(args []string, stdout io.Writer) error { return onKubeCredentialsCommand(ctx, kubeCredentialsCmd) }), + cli.NewKeypairCreateCommand(keypairCmd, func(keypairCreateCmd *cli.KeypairCreateCommand) error { + return onKeypairCreateCommand(ctx, globalCfg, keypairCreateCmd) + }), + // `start` and `configure` commands cli.NewLegacyCommand(startCmd, buildConfigAndStart(ctx, globalCfg), cli.CommandModeStart), cli.NewLegacyCommand(configureCmd, buildConfigAndConfigure(ctx, globalCfg, &configureOutPath, stdout), cli.CommandModeConfigure), From a8fd9ad6b5da967061ae7302530ee0cc1b02c666 Mon Sep 17 00:00:00 2001 From: Tim Buckley Date: Thu, 15 May 2025 13:08:56 -0600 Subject: [PATCH 2/5] MWI: Add new JWT CA for signing bound keypair documents (#54822) * MWI: Add new JWT CA for signing bound keypair documents This adds a new JWT CA for signing JWT documents related to bound keypair joining, particularly client state document that clients are expected to present back to auth when rejoining. * Fix issues from code review Removes `bound_keypair` from the list of exportable CAs in tctl, and switches the `legacy` suite algorithm to ECDSAP256 due to hsm compatibility requirements. * Add note about FIPS/HSM compatibility for CA suites --- api/types/trust.go | 6 ++++++ lib/auth/auth.go | 4 +++- lib/auth/init.go | 2 +- lib/cache/cache_test.go | 2 +- lib/cryptosuites/suites.go | 12 +++++++++++- lib/services/authority.go | 2 +- tool/tctl/common/auth_rotate_command.go | 3 +++ 7 files changed, 26 insertions(+), 5 deletions(-) diff --git a/api/types/trust.go b/api/types/trust.go index b1a89797ba73c..be89578fd41f1 100644 --- a/api/types/trust.go +++ b/api/types/trust.go @@ -64,6 +64,9 @@ const ( // OktaCA identifies the certificate authority that will be used by the // integration with Okta. OktaCA CertAuthType = "okta" + // BoundKeypairCA identifies the CA used to sign bound keypair client state + // documents. + BoundKeypairCA CertAuthType = "bound_keypair" ) // CertAuthTypes lists all certificate authority types. @@ -78,6 +81,7 @@ var CertAuthTypes = []CertAuthType{ OIDCIdPCA, SPIFFECA, OktaCA, + BoundKeypairCA, } // NewlyAdded should return true for CA types that were added in the current @@ -102,6 +106,8 @@ func (c CertAuthType) addedInMajorVer() int64 { return 15 case OktaCA: return 17 + case BoundKeypairCA: + return 17 default: // We don't care about other CAs added before v4.0.0 return 4 diff --git a/lib/auth/auth.go b/lib/auth/auth.go index 2493a401b17d6..8c01fa854af15 100644 --- a/lib/auth/auth.go +++ b/lib/auth/auth.go @@ -7727,7 +7727,7 @@ func newKeySet(ctx context.Context, keyStore *keystore.Manager, caID types.CertA // Add JWT keys if necessary. switch caID.Type { - case types.JWTSigner, types.OIDCIdPCA, types.SPIFFECA, types.OktaCA: + case types.JWTSigner, types.OIDCIdPCA, types.SPIFFECA, types.OktaCA, types.BoundKeypairCA: jwtKeyPair, err := keyStore.NewJWTKeyPair(ctx, jwtCAKeyPurpose(caID.Type)) if err != nil { return keySet, trace.Wrap(err) @@ -7778,6 +7778,8 @@ func jwtCAKeyPurpose(caType types.CertAuthType) cryptosuites.KeyPurpose { return cryptosuites.SPIFFECAJWT case types.OktaCA: return cryptosuites.OktaCAJWT + case types.BoundKeypairCA: + return cryptosuites.BoundKeypairCAJWT } return cryptosuites.KeyPurposeUnspecified } diff --git a/lib/auth/init.go b/lib/auth/init.go index 9df3ef441d87e..e209d3bdf0d1c 100644 --- a/lib/auth/init.go +++ b/lib/auth/init.go @@ -1446,7 +1446,7 @@ func checkResourceConsistency(ctx context.Context, keyStore *keystore.Manager, c _, signerErr = keyStore.GetSSHSigner(ctx, r) case types.DatabaseCA, types.DatabaseClientCA, types.SAMLIDPCA, types.SPIFFECA: _, _, signerErr = keyStore.GetTLSCertAndSigner(ctx, r) - case types.JWTSigner, types.OIDCIdPCA, types.OktaCA: + case types.JWTSigner, types.OIDCIdPCA, types.OktaCA, types.BoundKeypairCA: _, signerErr = keyStore.GetJWTSigner(ctx, r) default: return trace.BadParameter("unexpected cert_authority type %s for cluster %v", r.GetType(), clusterName) diff --git a/lib/cache/cache_test.go b/lib/cache/cache_test.go index a5327cdc4116e..d9f94a06c6aad 100644 --- a/lib/cache/cache_test.go +++ b/lib/cache/cache_test.go @@ -4471,7 +4471,7 @@ func NewTestCAWithConfig(config TestCAConfig) *types.CertAuthorityV2 { // Add JWT keys if necessary. switch config.Type { - case types.JWTSigner, types.OIDCIdPCA, types.SPIFFECA, types.OktaCA: + case types.JWTSigner, types.OIDCIdPCA, types.SPIFFECA, types.OktaCA, types.BoundKeypairCA: pubKeyPEM, err := keys.MarshalPublicKey(key.Public()) if err != nil { panic(err) diff --git a/lib/cryptosuites/suites.go b/lib/cryptosuites/suites.go index 8d6fbff67e557..a0e0bcdcd946e 100644 --- a/lib/cryptosuites/suites.go +++ b/lib/cryptosuites/suites.go @@ -122,6 +122,9 @@ const ( // identity. BoundKeypairJoining + // BoundKeypairCAJWT represents the JWT key for the bound_keypair CA. + BoundKeypairCAJWT + // keyPurposeMax is 1 greater than the last valid key purpose, used to test that all values less than this // are valid for each suite. keyPurposeMax @@ -165,7 +168,10 @@ type suite map[KeyPurpose]Algorithm var ( // legacy is the original algorithm suite, which exclusively uses RSA2048 // for features developed before ECDSA and Ed25519 support were added. New - // features should always use the new algorithms. + // features should always use the new algorithms, and new CAs should use the + // algorithms in `fipsV1` for compatibility with FIPS mode clusters and + // HSMs. See also: + // https://github.com/gravitational/teleport/blob/master/rfd/0136-modern-signature-algorithms.md#legacy-suite legacy = suite{ UserCATLS: RSA2048, UserCASSH: RSA2048, @@ -198,6 +204,7 @@ var ( EC2InstanceConnect: Ed25519, GitClient: Ed25519, BoundKeypairJoining: Ed25519, + BoundKeypairCAJWT: ECDSAP256, } // balancedV1 strikes a balance between security, compatibility, and @@ -230,6 +237,7 @@ var ( EC2InstanceConnect: Ed25519, GitClient: Ed25519, BoundKeypairJoining: Ed25519, + BoundKeypairCAJWT: Ed25519, } // fipsv1 is an algorithm suite tailored for FIPS compliance. It is based on @@ -263,6 +271,7 @@ var ( EC2InstanceConnect: ECDSAP256, GitClient: ECDSAP256, BoundKeypairJoining: ECDSAP256, + BoundKeypairCAJWT: ECDSAP256, } // hsmv1 in an algorithm suite tailored for clusters using an HSM or KMS @@ -298,6 +307,7 @@ var ( EC2InstanceConnect: Ed25519, GitClient: Ed25519, BoundKeypairJoining: Ed25519, + BoundKeypairCAJWT: ECDSAP256, } allSuites = map[types.SignatureAlgorithmSuite]suite{ diff --git a/lib/services/authority.go b/lib/services/authority.go index 158b58295e3c8..8dcb1594a7be5 100644 --- a/lib/services/authority.go +++ b/lib/services/authority.go @@ -68,7 +68,7 @@ func ValidateCertAuthority(ca types.CertAuthority) (err error) { err = checkDatabaseCA(ca) case types.OpenSSHCA: err = checkOpenSSHCA(ca) - case types.JWTSigner, types.OIDCIdPCA, types.OktaCA: + case types.JWTSigner, types.OIDCIdPCA, types.OktaCA, types.BoundKeypairCA: err = checkJWTKeys(ca) case types.SAMLIDPCA: err = checkSAMLIDPCA(ca) diff --git a/tool/tctl/common/auth_rotate_command.go b/tool/tctl/common/auth_rotate_command.go index b0c5f3b31f5c4..09c0885dbb6c9 100644 --- a/tool/tctl/common/auth_rotate_command.go +++ b/tool/tctl/common/auth_rotate_command.go @@ -1236,6 +1236,9 @@ func manualSteps(caType types.CertAuthType, phase string) []string { case types.OktaCA: // TODO(smallinsky): populate any known manual steps during Okta CA rotation. fallthrough + case types.BoundKeypairCA: + // TODO(timothyb89): add any manual steps; this should mostly be handled automatically. + fallthrough default: return []string{"Consult the CA rotation docs for any manual steps that may be required: https://goteleport.com/docs/admin-guides/management/operations/ca-rotation/"} } From 294c0d54cc8ad1f8c4815daf0dd7d7b555adb77a Mon Sep 17 00:00:00 2001 From: Tim Buckley Date: Fri, 23 May 2025 19:32:28 -0600 Subject: [PATCH 3/5] MWI: Issue and verify join state documents (#54940) * MWI: Issue and verify join state documents This adds join state document issuance and verification to the bound keypair joining process. This is described in more detail in the [RFD], but in short, this adds a mechanism similar to the generation counter to verify bound keypair recovery events. Each time a recovery is performed, the join counter (stored in the token's status field) is incremented. This value is embedded in a JWT and signed by Auth, and the result is passed to the client alongside their cert bundle. This document effectively gives clients permission to lock themselves out in the future: if another client attempts to use their credentials, the original client will eventually present an outdated join state document, and trigger a lockout. [RFD]: https://github.com/gravitational/teleport/blob/rfd/0205-improved-onprem-joining/rfd/0205-improved-onprem-joining.md * Allow selecting all recovery modes * Remove TODO and debug log * Add tests for join state issuance and verification * Add join state tests for RegisterUsingBoundKeypairMethod Adds some minor error message and comment fixes caught while writing tests. * Fix imports * Fix lints * Fix failing unit test * Add notes about lack of expiry field in join state JWTs --- api/client/joinservice.go | 36 +- api/proto/teleport/legacy/types/types.proto | 6 +- api/types/provisioning.go | 14 + api/types/provisioning_test.go | 4 + api/types/types.pb.go | 4097 ++++++++++--------- lib/auth/bot.go | 7 +- lib/auth/join.go | 1 + lib/auth/join/boundkeypair/boundkeypair.go | 14 + lib/auth/join/join.go | 54 +- lib/auth/join_bound_keypair.go | 171 +- lib/auth/join_bound_keypair_test.go | 186 +- lib/boundkeypair/bound_keypair.go | 15 + lib/boundkeypair/join_state.go | 225 + lib/boundkeypair/join_state_test.go | 245 ++ lib/joinserver/joinserver.go | 13 +- lib/joinserver/joinserver_test.go | 19 +- lib/jwt/jwt.go | 36 +- lib/tbot/service_bot_identity.go | 26 +- 18 files changed, 3047 insertions(+), 2122 deletions(-) create mode 100644 lib/boundkeypair/join_state.go create mode 100644 lib/boundkeypair/join_state_test.go diff --git a/api/client/joinservice.go b/api/client/joinservice.go index 32b0f60dfe5db..fcdc437e8c66e 100644 --- a/api/client/joinservice.go +++ b/api/client/joinservice.go @@ -269,6 +269,20 @@ func (c *JoinServiceClient) RegisterUsingOracleMethod( return certs, nil } +// BoundKeypairRegistrationResponse is the response on a successful registration attempt. +type BoundKeypairRegistrationResponse struct { + // Certs is the generated certificate bundle. + Certs *proto.Certs + + // BoundPublicKey is the public key bound at the completion of the joining + // process, in ssh authorized_hosts format. + BoundPublicKey string + + // JoinState is a compact serialized JWT containing join state, to be stored + // by the client and verified on subsequent join attempts. + JoinState []byte +} + // RegisterUsingBoundKeypairMethod attempts to register the caller using // bound-keypair join method. If successful, the public key registered with auth // and a certificate bundle is returned, or an error. Clients must provide a @@ -277,13 +291,13 @@ func (c *JoinServiceClient) RegisterUsingBoundKeypairMethod( ctx context.Context, initReq *proto.RegisterUsingBoundKeypairInitialRequest, challengeFunc RegisterUsingBoundKeypairChallengeResponseFunc, -) (*proto.Certs, string, error) { +) (*BoundKeypairRegistrationResponse, error) { ctx, cancel := context.WithCancel(ctx) defer cancel() stream, err := c.grpcClient.RegisterUsingBoundKeypairMethod(ctx) if err != nil { - return nil, "", trace.Wrap(err) + return nil, trace.Wrap(err) } defer stream.CloseSend() @@ -293,7 +307,7 @@ func (c *JoinServiceClient) RegisterUsingBoundKeypairMethod( }, }) if err != nil { - return nil, "", trace.Wrap(err, "sending initial request") + return nil, trace.Wrap(err, "sending initial request") } // Unlike other methods, the server may send multiple challenges, @@ -304,7 +318,7 @@ func (c *JoinServiceClient) RegisterUsingBoundKeypairMethod( if errors.Is(err, io.EOF) { break } else if err != nil { - return nil, "", trace.Wrap(err, "receiving intermediate bound keypair join response") + return nil, trace.Wrap(err, "receiving intermediate bound keypair join response") } switch kind := res.GetResponse().(type) { @@ -312,7 +326,7 @@ func (c *JoinServiceClient) RegisterUsingBoundKeypairMethod( // If we get certs, we're done, so just return the result. certs := kind.Certs.GetCerts() if certs == nil { - return nil, "", trace.BadParameter("expected Certs, got %T", kind.Certs.Certs) + return nil, trace.BadParameter("expected Certs, got %T", kind.Certs.Certs) } // If we receive a cert bundle, we can return early. Even if we @@ -322,23 +336,27 @@ func (c *JoinServiceClient) RegisterUsingBoundKeypairMethod( // raise an error if rotation fails or is otherwise skipped or not // allowed. - return certs, kind.Certs.GetPublicKey(), nil + return &BoundKeypairRegistrationResponse{ + Certs: certs, + BoundPublicKey: kind.Certs.GetPublicKey(), + JoinState: kind.Certs.JoinState, + }, nil default: // Forward all other responses to the challenge handler. nextRequest, err := challengeFunc(res) if err != nil { - return nil, "", trace.Wrap(err, "solving challenge") + return nil, trace.Wrap(err, "solving challenge") } if err := stream.Send(nextRequest); err != nil { - return nil, "", trace.Wrap(err, "sending solution") + return nil, trace.Wrap(err, "sending solution") } } } // Ideally the server will emit a proper error instead of just hanging up on // us. - return nil, "", trace.AccessDenied("server declined to send certs during bound-keypair join attempt") + return nil, trace.AccessDenied("server declined to send certs during bound-keypair join attempt") } // RegisterUsingToken registers the caller using a token and returns signed diff --git a/api/proto/teleport/legacy/types/types.proto b/api/proto/teleport/legacy/types/types.proto index 790dabfca782d..79550d0072c19 100644 --- a/api/proto/teleport/legacy/types/types.proto +++ b/api/proto/teleport/legacy/types/types.proto @@ -6172,7 +6172,7 @@ message RegisterUsingTokenRequest { (gogoproto.jsontag) = "expires,omitempty" ]; // BotInstanceID is a trusted instance identifier for a Machine ID bot, - // provided when rejoining. This parameters may only be provided by the join + // provided when rejoining. This parameter may only be provided by the join // service and is ignored otherwise; bots should otherwise rejoin with their // existing client certificate to prove their instance identity. string BotInstanceID = 13 [(gogoproto.jsontag) = "bot_instance_id"]; @@ -6181,6 +6181,10 @@ message RegisterUsingTokenRequest { // join method. Rejoining bots supply this value via a client certificate // extension; it is ignored from other sources. int32 BotGeneration = 14 [(gogoproto.jsontag) = "bot_generation"]; + // PreviousBotInstanceID is a trusted previous instance identifier for a + // Machine ID bot. This parameter may only be set internally during certain + // join processes and is ignored otherwise. + string PreviousBotInstanceID = 15 [(gogoproto.jsontag) = "previous_bot_instance_id"]; } // RecoveryCodes holds a user's recovery code information. Recovery codes allows users to regain diff --git a/api/types/provisioning.go b/api/types/provisioning.go index aee5700b02e00..e4759de567e28 100644 --- a/api/types/provisioning.go +++ b/api/types/provisioning.go @@ -1026,6 +1026,9 @@ func (a *ProvisionTokenSpecV2AzureDevops) checkAndSetDefaults() error { } func (a *ProvisionTokenSpecV2BoundKeypair) checkAndSetDefaults() error { + // Note: don't attempt to initialize onboarding - at least for now - as it + // has required keys. This behavior may be relaxed when we add + // server-generated joining secrets. if a.Onboarding == nil { return trace.BadParameter("spec.bound_keypair.onboarding is required") } @@ -1035,5 +1038,16 @@ func (a *ProvisionTokenSpecV2BoundKeypair) checkAndSetDefaults() error { "initial_public_key] is required in spec.bound_keypair.onboarding") } + if a.Recovery == nil { + a.Recovery = &ProvisionTokenSpecV2BoundKeypair_RecoverySpec{} + } + + if a.Recovery.Limit == 0 { + a.Recovery.Limit = 1 + } + + // Note: Recovery.Mode will be interpreted at joining time; it's zero value + // ("") is mapped to RecoveryModeStandard. + return nil } diff --git a/api/types/provisioning_test.go b/api/types/provisioning_test.go index cc62a40cab80f..8fcfe17e7e48e 100644 --- a/api/types/provisioning_test.go +++ b/api/types/provisioning_test.go @@ -1399,6 +1399,10 @@ func TestProvisionTokenV2_CheckAndSetDefaults(t *testing.T) { Onboarding: &ProvisionTokenSpecV2BoundKeypair_OnboardingSpec{ InitialPublicKey: "asdf", }, + Recovery: &ProvisionTokenSpecV2BoundKeypair_RecoverySpec{ + Limit: 1, + Mode: "", + }, }, }, }, diff --git a/api/types/types.pb.go b/api/types/types.pb.go index 0e7d79b1fbbb6..6be287a8d0134 100644 --- a/api/types/types.pb.go +++ b/api/types/types.pb.go @@ -15544,7 +15544,7 @@ type RegisterUsingTokenRequest struct { // node joining. Expires *time.Time `protobuf:"bytes,12,opt,name=Expires,proto3,stdtime" json:"expires,omitempty"` // BotInstanceID is a trusted instance identifier for a Machine ID bot, - // provided when rejoining. This parameters may only be provided by the join + // provided when rejoining. This parameter may only be provided by the join // service and is ignored otherwise; bots should otherwise rejoin with their // existing client certificate to prove their instance identity. BotInstanceID string `protobuf:"bytes,13,opt,name=BotInstanceID,proto3" json:"bot_instance_id"` @@ -15552,10 +15552,14 @@ type RegisterUsingTokenRequest struct { // provided to Auth by the Join Service when bots rejoin via a streamed/gRPC // join method. Rejoining bots supply this value via a client certificate // extension; it is ignored from other sources. - BotGeneration int32 `protobuf:"varint,14,opt,name=BotGeneration,proto3" json:"bot_generation"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + BotGeneration int32 `protobuf:"varint,14,opt,name=BotGeneration,proto3" json:"bot_generation"` + // PreviousBotInstanceID is a trusted previous instance identifier for a + // Machine ID bot. This parameter may only be set internally during certain + // join processes and is ignored otherwise. + PreviousBotInstanceID string `protobuf:"bytes,15,opt,name=PreviousBotInstanceID,proto3" json:"previous_bot_instance_id"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *RegisterUsingTokenRequest) Reset() { *m = RegisterUsingTokenRequest{} } @@ -23313,2026 +23317,2028 @@ func init() { func init() { proto.RegisterFile("teleport/legacy/types/types.proto", fileDescriptor_9198ee693835762e) } var fileDescriptor_9198ee693835762e = []byte{ - // 32304 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6b, 0x70, 0x1c, 0x49, - 0x7a, 0x20, 0x36, 0xdd, 0x8d, 0x47, 0xe3, 0xc3, 0xab, 0x91, 0x00, 0x49, 0x10, 0x1c, 0x4e, 0x73, - 0x8a, 0x33, 0x1c, 0x72, 0x1e, 0xe4, 0x12, 0xdc, 0xe1, 0xee, 0xec, 0x3c, 0x1b, 0xdd, 0x20, 0xd1, - 0x24, 0x08, 0x62, 0xaa, 0x01, 0x62, 0x47, 0xbb, 0xb3, 0xb5, 0x85, 0xee, 0x04, 0x50, 0x83, 0xee, - 0xae, 0xde, 0xaa, 0x6a, 0x92, 0xd0, 0x9e, 0x7c, 0x7a, 0xad, 0x75, 0x0a, 0x59, 0xcf, 0x93, 0x4e, - 0x7b, 0x0e, 0x9d, 0xe2, 0xe2, 0x1e, 0xf6, 0xf9, 0x1c, 0x52, 0xdc, 0x49, 0x77, 0xf6, 0xd9, 0x17, - 0xa7, 0x5b, 0x39, 0xce, 0x3a, 0xf9, 0xe2, 0xc2, 0x52, 0xf8, 0xce, 0x76, 0x78, 0x43, 0x01, 0x85, - 0x2c, 0x87, 0x7f, 0x20, 0xc2, 0x11, 0x92, 0x1d, 0xe1, 0x08, 0xef, 0x59, 0xb2, 0x23, 0xbf, 0xcc, - 0xac, 0xca, 0xac, 0xaa, 0x6e, 0x34, 0x66, 0x38, 0x3a, 0x71, 0x42, 0x7f, 0x48, 0xf4, 0x97, 0xdf, - 0xf7, 0x65, 0xe5, 0xfb, 0xcb, 0x2f, 0xbf, 0x07, 0x3c, 0x1f, 0xd0, 0x26, 0xed, 0xb8, 0x5e, 0x70, - 0xad, 0x49, 0x77, 0xed, 0xfa, 0xc1, 0xb5, 0xe0, 0xa0, 0x43, 0x7d, 0xfe, 0xef, 0xd5, 0x8e, 0xe7, - 0x06, 0x2e, 0x19, 0xc6, 0x1f, 0x0b, 0x73, 0xbb, 0xee, 0xae, 0x8b, 0x90, 0x6b, 0xec, 0x2f, 0x5e, - 0xb8, 0xf0, 0xdc, 0xae, 0xeb, 0xee, 0x36, 0xe9, 0x35, 0xfc, 0xb5, 0xdd, 0xdd, 0xb9, 0xd6, 0xe8, - 0x7a, 0x76, 0xe0, 0xb8, 0x6d, 0x51, 0x5e, 0x8c, 0x97, 0x07, 0x4e, 0x8b, 0xfa, 0x81, 0xdd, 0xea, - 0xf4, 0x62, 0xf0, 0xc8, 0xb3, 0x3b, 0x1d, 0xea, 0x89, 0xda, 0x17, 0xae, 0x84, 0x1f, 0x68, 0x07, - 0x01, 0xa3, 0x64, 0xcc, 0xaf, 0x3d, 0xbc, 0xae, 0xfe, 0x14, 0xa8, 0x37, 0x7b, 0xb4, 0xc5, 0xeb, - 0xfa, 0x01, 0x6d, 0x58, 0x0d, 0xfa, 0xd0, 0xa9, 0x53, 0xcb, 0xa3, 0xdf, 0xe8, 0x3a, 0x1e, 0x6d, - 0xd1, 0x76, 0x20, 0xe8, 0x5e, 0x4b, 0xa7, 0x93, 0x1f, 0x12, 0xfb, 0x22, 0xe3, 0x97, 0x73, 0x30, - 0x76, 0x97, 0xd2, 0x4e, 0xa9, 0xe9, 0x3c, 0xa4, 0xe4, 0x22, 0x0c, 0xad, 0xd9, 0x2d, 0x3a, 0x9f, - 0xb9, 0x90, 0xb9, 0x3c, 0xb6, 0x34, 0x7d, 0x74, 0x58, 0x1c, 0xf7, 0xa9, 0xf7, 0x90, 0x7a, 0x56, - 0xdb, 0x6e, 0x51, 0x13, 0x0b, 0xc9, 0x2b, 0x30, 0xc6, 0xfe, 0xf7, 0x3b, 0x76, 0x9d, 0xce, 0x67, - 0x11, 0x73, 0xf2, 0xe8, 0xb0, 0x38, 0xd6, 0x96, 0x40, 0x33, 0x2a, 0x27, 0x55, 0x18, 0x5d, 0x7e, - 0xdc, 0x71, 0x3c, 0xea, 0xcf, 0x0f, 0x5d, 0xc8, 0x5c, 0x1e, 0x5f, 0x5c, 0xb8, 0xca, 0xfb, 0xe8, - 0xaa, 0xec, 0xa3, 0xab, 0x1b, 0xb2, 0x13, 0x97, 0x66, 0x7f, 0xfb, 0xb0, 0xf8, 0xcc, 0xd1, 0x61, - 0x71, 0x94, 0x72, 0x92, 0x9f, 0xf9, 0xfd, 0x62, 0xc6, 0x94, 0xf4, 0xe4, 0x2d, 0x18, 0xda, 0x38, - 0xe8, 0xd0, 0xf9, 0xb1, 0x0b, 0x99, 0xcb, 0x53, 0x8b, 0xcf, 0x5d, 0xe5, 0xc3, 0x1a, 0x7e, 0x7c, - 0xf4, 0x17, 0xc3, 0x5a, 0xca, 0x1f, 0x1d, 0x16, 0x87, 0x18, 0x8a, 0x89, 0x54, 0xe4, 0x35, 0x18, - 0x59, 0x71, 0xfd, 0xa0, 0x5a, 0x99, 0x07, 0xfc, 0xe4, 0x53, 0x47, 0x87, 0xc5, 0x99, 0x3d, 0xd7, - 0x0f, 0x2c, 0xa7, 0xf1, 0xaa, 0xdb, 0x72, 0x02, 0xda, 0xea, 0x04, 0x07, 0xa6, 0x40, 0x32, 0x1e, - 0xc3, 0xa4, 0xc6, 0x8f, 0x8c, 0xc3, 0xe8, 0xe6, 0xda, 0xdd, 0xb5, 0xfb, 0x5b, 0x6b, 0x85, 0x67, - 0x48, 0x1e, 0x86, 0xd6, 0xee, 0x57, 0x96, 0x0b, 0x19, 0x32, 0x0a, 0xb9, 0xd2, 0xfa, 0x7a, 0x21, - 0x4b, 0x26, 0x20, 0x5f, 0x29, 0x6d, 0x94, 0x96, 0x4a, 0xb5, 0xe5, 0x42, 0x8e, 0xcc, 0xc2, 0xf4, - 0x56, 0x75, 0xad, 0x72, 0x7f, 0xab, 0x66, 0x55, 0x96, 0x6b, 0x77, 0x37, 0xee, 0xaf, 0x17, 0x86, - 0xc8, 0x14, 0xc0, 0xdd, 0xcd, 0xa5, 0x65, 0x73, 0x6d, 0x79, 0x63, 0xb9, 0x56, 0x18, 0x26, 0x73, - 0x50, 0x90, 0x24, 0x56, 0x6d, 0xd9, 0x7c, 0x50, 0x2d, 0x2f, 0x17, 0x46, 0xee, 0x0c, 0xe5, 0x73, - 0x85, 0x21, 0x73, 0x74, 0x95, 0xda, 0x3e, 0xad, 0x56, 0x8c, 0xbf, 0x9d, 0x83, 0xfc, 0x3d, 0x1a, - 0xd8, 0x0d, 0x3b, 0xb0, 0xc9, 0xb3, 0xda, 0xf8, 0x60, 0x13, 0x95, 0x81, 0xb9, 0x98, 0x1c, 0x98, - 0xe1, 0xa3, 0xc3, 0x62, 0xe6, 0x35, 0x75, 0x40, 0xde, 0x84, 0xf1, 0x0a, 0xf5, 0xeb, 0x9e, 0xd3, - 0x61, 0x93, 0x6d, 0x3e, 0x87, 0x68, 0x67, 0x8f, 0x0e, 0x8b, 0xa7, 0x1a, 0x11, 0x58, 0xe9, 0x10, - 0x15, 0x9b, 0x54, 0x61, 0x64, 0xd5, 0xde, 0xa6, 0x4d, 0x7f, 0x7e, 0xf8, 0x42, 0xee, 0xf2, 0xf8, - 0xe2, 0x39, 0x31, 0x08, 0xf2, 0x03, 0xaf, 0xf2, 0xd2, 0xe5, 0x76, 0xe0, 0x1d, 0x2c, 0xcd, 0x1d, - 0x1d, 0x16, 0x0b, 0x4d, 0x04, 0xa8, 0x1d, 0xcc, 0x51, 0x48, 0x2d, 0x9a, 0x18, 0x23, 0xc7, 0x4e, - 0x8c, 0xf3, 0xbf, 0x7d, 0x58, 0xcc, 0xb0, 0x01, 0x13, 0x13, 0x23, 0xe2, 0xa7, 0x4f, 0x91, 0x45, - 0xc8, 0x9b, 0xf4, 0xa1, 0xe3, 0xb3, 0x96, 0xe5, 0xb1, 0x65, 0xa7, 0x8f, 0x0e, 0x8b, 0xc4, 0x13, - 0x30, 0xe5, 0x33, 0x42, 0xbc, 0x85, 0x37, 0x60, 0x5c, 0xf9, 0x6a, 0x52, 0x80, 0xdc, 0x3e, 0x3d, - 0xe0, 0x3d, 0x6c, 0xb2, 0x3f, 0xc9, 0x1c, 0x0c, 0x3f, 0xb4, 0x9b, 0x5d, 0xd1, 0xa5, 0x26, 0xff, - 0xf1, 0xa5, 0xec, 0x17, 0x33, 0x77, 0x86, 0xf2, 0xa3, 0x85, 0xbc, 0x99, 0xad, 0x56, 0x8c, 0x9f, - 0x1b, 0x82, 0xbc, 0xe9, 0xf2, 0x05, 0x4c, 0xae, 0xc0, 0x70, 0x2d, 0xb0, 0x03, 0x39, 0x4c, 0xb3, - 0x47, 0x87, 0xc5, 0x69, 0xb6, 0xb8, 0xa9, 0x52, 0x3f, 0xc7, 0x60, 0xa8, 0xeb, 0x7b, 0xb6, 0x2f, - 0x87, 0x0b, 0x51, 0x3b, 0x0c, 0xa0, 0xa2, 0x22, 0x06, 0xb9, 0x04, 0x43, 0xf7, 0xdc, 0x06, 0x15, - 0x23, 0x46, 0x8e, 0x0e, 0x8b, 0x53, 0x2d, 0xb7, 0xa1, 0x22, 0x62, 0x39, 0x79, 0x15, 0xc6, 0xca, - 0x5d, 0xcf, 0xa3, 0x6d, 0x36, 0xd7, 0x87, 0x10, 0x79, 0xea, 0xe8, 0xb0, 0x08, 0x75, 0x0e, 0xb4, - 0x9c, 0x86, 0x19, 0x21, 0xb0, 0x61, 0xa8, 0x05, 0xb6, 0x17, 0xd0, 0xc6, 0xfc, 0xf0, 0x40, 0xc3, - 0xc0, 0xd6, 0xe7, 0x8c, 0xcf, 0x49, 0xe2, 0xc3, 0x20, 0x38, 0x91, 0x15, 0x18, 0xbf, 0xed, 0xd9, - 0x75, 0xba, 0x4e, 0x3d, 0xc7, 0x6d, 0xe0, 0xf8, 0xe6, 0x96, 0x2e, 0x1d, 0x1d, 0x16, 0x4f, 0xef, - 0x32, 0xb0, 0xd5, 0x41, 0x78, 0x44, 0xfd, 0xbd, 0xc3, 0x62, 0xbe, 0x22, 0xb6, 0x5a, 0x53, 0x25, - 0x25, 0x5f, 0x67, 0x83, 0xe3, 0x07, 0xd8, 0xb5, 0xb4, 0x31, 0x3f, 0x7a, 0xec, 0x27, 0x1a, 0xe2, - 0x13, 0x4f, 0x37, 0x6d, 0x3f, 0xb0, 0x3c, 0x4e, 0x17, 0xfb, 0x4e, 0x95, 0x25, 0xb9, 0x0f, 0xf9, - 0x5a, 0x7d, 0x8f, 0x36, 0xba, 0x4d, 0x8a, 0x53, 0x66, 0x7c, 0xf1, 0x8c, 0x98, 0xd4, 0x72, 0x3c, - 0x65, 0xf1, 0xd2, 0x82, 0xe0, 0x4d, 0x7c, 0x01, 0x51, 0xe7, 0x93, 0xc4, 0xfa, 0x52, 0xfe, 0xdb, - 0x7f, 0xb3, 0xf8, 0xcc, 0x0f, 0xfe, 0xde, 0x85, 0x67, 0x8c, 0xff, 0x32, 0x0b, 0x85, 0x38, 0x13, - 0xb2, 0x03, 0x93, 0x9b, 0x9d, 0x86, 0x1d, 0xd0, 0x72, 0xd3, 0xa1, 0xed, 0xc0, 0xc7, 0x49, 0xd2, - 0xbf, 0x4d, 0x2f, 0x88, 0x7a, 0xe7, 0xbb, 0x48, 0x68, 0xd5, 0x39, 0x65, 0xac, 0x55, 0x3a, 0xdb, - 0xa8, 0x9e, 0x1a, 0x6e, 0xe0, 0x3e, 0xce, 0xb0, 0x93, 0xd5, 0xc3, 0xb7, 0xfe, 0x1e, 0xf5, 0x08, - 0xb6, 0x62, 0x02, 0xb5, 0x1b, 0xdb, 0x07, 0x38, 0x33, 0x07, 0x9f, 0x40, 0x8c, 0x24, 0x65, 0x02, - 0x31, 0xb0, 0xf1, 0xbf, 0x65, 0x60, 0xca, 0xa4, 0xbe, 0xdb, 0xf5, 0xea, 0x74, 0x85, 0xda, 0x0d, - 0xea, 0xb1, 0xe9, 0x7f, 0xd7, 0x69, 0x37, 0xc4, 0x9a, 0xc2, 0xe9, 0xbf, 0xef, 0xb4, 0xd5, 0xad, - 0x1b, 0xcb, 0xc9, 0xe7, 0x60, 0xb4, 0xd6, 0xdd, 0x46, 0xd4, 0x6c, 0xb4, 0x03, 0xf8, 0xdd, 0x6d, - 0x2b, 0x86, 0x2e, 0xd1, 0xc8, 0x35, 0x18, 0x7d, 0x40, 0x3d, 0x3f, 0xda, 0x0d, 0xf1, 0x68, 0x78, - 0xc8, 0x41, 0x2a, 0x81, 0xc0, 0x22, 0xb7, 0xa3, 0x1d, 0x59, 0x1c, 0x6a, 0xd3, 0xb1, 0x7d, 0x30, - 0x9a, 0x2a, 0x2d, 0x01, 0x51, 0xa7, 0x8a, 0xc4, 0x32, 0x7e, 0x36, 0x0b, 0x85, 0x8a, 0x1d, 0xd8, - 0xdb, 0xb6, 0x2f, 0xfa, 0xf3, 0xc1, 0x0d, 0xb6, 0xc7, 0x2b, 0x0d, 0xc5, 0x3d, 0x9e, 0x7d, 0xf9, - 0xc7, 0x6e, 0xde, 0x8b, 0xf1, 0xe6, 0x8d, 0xb3, 0x13, 0x56, 0x34, 0x2f, 0x6a, 0xd4, 0xdb, 0xc7, - 0x37, 0xaa, 0x20, 0x1a, 0x95, 0x97, 0x8d, 0x8a, 0x9a, 0x42, 0xde, 0x86, 0xa1, 0x5a, 0x87, 0xd6, - 0xc5, 0x26, 0x22, 0xcf, 0x05, 0xbd, 0x71, 0x0c, 0xe1, 0xc1, 0x8d, 0xa5, 0x09, 0xc1, 0x66, 0xc8, - 0xef, 0xd0, 0xba, 0x89, 0x64, 0xca, 0xa2, 0xf9, 0x27, 0x39, 0x98, 0x4b, 0x23, 0x53, 0xdb, 0x31, - 0xd2, 0xa7, 0x1d, 0x97, 0x21, 0xcf, 0x8e, 0x70, 0x76, 0x2c, 0xe2, 0x76, 0x31, 0xb6, 0x34, 0xc1, - 0x3e, 0x79, 0x4f, 0xc0, 0xcc, 0xb0, 0x94, 0x5c, 0x0c, 0x25, 0x82, 0x7c, 0xc4, 0x4f, 0x48, 0x04, - 0x52, 0x0e, 0x60, 0x63, 0x2d, 0x97, 0x30, 0x0a, 0x0e, 0x51, 0xb7, 0x48, 0x70, 0x34, 0xd6, 0x9e, - 0x80, 0x68, 0xc7, 0x8c, 0x3c, 0x14, 0x96, 0x21, 0x2f, 0x9b, 0x35, 0x3f, 0x81, 0x8c, 0x66, 0x62, - 0x9d, 0xf4, 0xe0, 0x06, 0x1f, 0xcc, 0x86, 0xf8, 0xad, 0xb2, 0x91, 0x38, 0xe4, 0x06, 0xe4, 0xd7, - 0x3d, 0xf7, 0xf1, 0x41, 0xb5, 0xe2, 0xcf, 0x4f, 0x5e, 0xc8, 0x5d, 0x1e, 0x5b, 0x3a, 0x73, 0x74, - 0x58, 0x9c, 0xed, 0x30, 0x98, 0xe5, 0x34, 0xd4, 0x93, 0x36, 0x44, 0xbc, 0x33, 0x94, 0xcf, 0x14, - 0xb2, 0x77, 0x86, 0xf2, 0xd9, 0x42, 0x8e, 0x8b, 0x17, 0x77, 0x86, 0xf2, 0x43, 0x85, 0xe1, 0x3b, - 0x43, 0xf9, 0x61, 0x14, 0x38, 0xc6, 0x0a, 0x70, 0x67, 0x28, 0x3f, 0x5e, 0x98, 0xd0, 0x4e, 0x7b, - 0x64, 0x10, 0xb8, 0x75, 0xb7, 0x69, 0xe6, 0x36, 0xcd, 0xaa, 0x39, 0x52, 0x2e, 0x95, 0xa9, 0x17, - 0x98, 0xb9, 0xd2, 0x56, 0xcd, 0x9c, 0xac, 0x1c, 0xb4, 0xed, 0x96, 0x53, 0xe7, 0x47, 0xa7, 0x99, - 0xbb, 0x5d, 0x5e, 0x37, 0x4a, 0x30, 0x15, 0xb5, 0x65, 0xd5, 0xf1, 0x03, 0x72, 0x0d, 0xc6, 0x24, - 0x84, 0x6d, 0x74, 0xb9, 0xd4, 0x56, 0x9b, 0x11, 0x8e, 0xf1, 0x5b, 0x59, 0x80, 0xa8, 0xe4, 0x29, - 0x5d, 0x0b, 0x5f, 0xd0, 0xd6, 0xc2, 0xa9, 0xf8, 0x5a, 0xe8, 0xb9, 0x0a, 0xc8, 0xbb, 0x30, 0xc2, - 0xc4, 0x82, 0xae, 0x14, 0x89, 0xce, 0xc4, 0x49, 0xb1, 0xf0, 0xc1, 0x8d, 0xa5, 0x29, 0x41, 0x3c, - 0xe2, 0x23, 0xc4, 0x14, 0x64, 0xca, 0x32, 0xfa, 0xe5, 0xd1, 0x68, 0x30, 0xc4, 0x02, 0xba, 0x0c, - 0xe1, 0x80, 0x8a, 0x0e, 0xc5, 0x95, 0xd1, 0x91, 0x83, 0x1c, 0x96, 0x92, 0xb3, 0xc0, 0x06, 0x5c, - 0x74, 0xea, 0xe8, 0xd1, 0x61, 0x31, 0xd7, 0xf5, 0x1c, 0x9c, 0x04, 0xe4, 0x1a, 0x88, 0x69, 0x20, - 0x3a, 0x90, 0xcd, 0xbe, 0x99, 0xba, 0x6d, 0xd5, 0xa9, 0x17, 0x44, 0x3d, 0x3e, 0x9f, 0x91, 0xb3, - 0x85, 0x74, 0x40, 0x9f, 0x2a, 0xf3, 0x43, 0x38, 0x0d, 0x2e, 0xa7, 0xf6, 0xca, 0x55, 0x0d, 0x95, - 0x8b, 0x91, 0x17, 0xe4, 0xa9, 0xd4, 0xe0, 0x65, 0x56, 0x42, 0xa4, 0xd4, 0x2b, 0x20, 0x37, 0x80, - 0xcd, 0x50, 0xd1, 0xfb, 0x20, 0xea, 0x29, 0x6d, 0xd5, 0x96, 0x4e, 0x09, 0x4e, 0x93, 0xf6, 0x23, - 0x95, 0x9c, 0x61, 0x93, 0x37, 0x81, 0x4d, 0x61, 0xd1, 0xef, 0x44, 0x10, 0xdd, 0x2e, 0xaf, 0x97, - 0x9b, 0x6e, 0xb7, 0x51, 0x7b, 0x7f, 0x35, 0x22, 0xde, 0xad, 0x77, 0x54, 0xe2, 0xdb, 0xe5, 0x75, - 0xf2, 0x26, 0x0c, 0x97, 0xbe, 0xbf, 0xeb, 0x51, 0x21, 0x9f, 0x4c, 0xc8, 0x3a, 0x19, 0x6c, 0xe9, - 0x8c, 0x20, 0x9c, 0xb6, 0xd9, 0x4f, 0x55, 0xae, 0xc3, 0x72, 0x56, 0xf3, 0xc6, 0x6a, 0x4d, 0xc8, - 0x1e, 0x24, 0xd6, 0x2d, 0x1b, 0xab, 0xca, 0x67, 0x07, 0x5a, 0xab, 0x19, 0x15, 0xb9, 0x06, 0xd9, - 0x52, 0x05, 0x6f, 0x44, 0xe3, 0x8b, 0x63, 0xb2, 0xda, 0xca, 0xd2, 0x9c, 0x20, 0x99, 0xb0, 0xd5, - 0x65, 0x90, 0x2d, 0x55, 0xc8, 0x12, 0x0c, 0xdf, 0x3b, 0xa8, 0xbd, 0xbf, 0x2a, 0x36, 0xb3, 0x59, - 0x39, 0xaf, 0x19, 0xec, 0x3e, 0x2e, 0x7b, 0x3f, 0xfa, 0xe2, 0xd6, 0x81, 0xff, 0x8d, 0xa6, 0xfa, - 0xc5, 0x88, 0x46, 0xd6, 0x61, 0xac, 0xd4, 0x68, 0x39, 0xed, 0x4d, 0x9f, 0x7a, 0xf3, 0xe3, 0xc8, - 0x67, 0x3e, 0xf6, 0xdd, 0x61, 0xf9, 0xd2, 0xfc, 0xd1, 0x61, 0x71, 0xce, 0x66, 0x3f, 0xad, 0xae, - 0x4f, 0x3d, 0x85, 0x5b, 0xc4, 0x84, 0xac, 0x03, 0xdc, 0x73, 0xdb, 0xbb, 0x6e, 0x29, 0x68, 0xda, - 0x7e, 0x6c, 0x7b, 0x8c, 0x0a, 0x42, 0xf1, 0xe1, 0x54, 0x8b, 0xc1, 0x2c, 0x9b, 0x01, 0x15, 0x86, - 0x0a, 0x0f, 0x72, 0x0b, 0x46, 0xee, 0x7b, 0x76, 0xbd, 0x49, 0xe7, 0x27, 0x91, 0xdb, 0x9c, 0xe0, - 0xc6, 0x81, 0xb2, 0xa5, 0xf3, 0x82, 0x61, 0xc1, 0x45, 0xb0, 0x7a, 0x4d, 0xe1, 0x88, 0x0b, 0x5b, - 0x40, 0x92, 0x73, 0x32, 0xe5, 0x92, 0xf0, 0x8a, 0x7a, 0x49, 0x88, 0x16, 0x7d, 0xd9, 0x6d, 0xb5, - 0xec, 0x76, 0x03, 0x69, 0x1f, 0x2c, 0x2a, 0x77, 0x07, 0xe3, 0x1b, 0x30, 0x93, 0xe8, 0xac, 0x63, - 0xee, 0x77, 0xef, 0xc0, 0x74, 0x85, 0xee, 0xd8, 0xdd, 0x66, 0x10, 0x9e, 0x24, 0x7c, 0x89, 0xe2, - 0x4d, 0xab, 0xc1, 0x8b, 0x2c, 0x79, 0x7c, 0x98, 0x71, 0x64, 0xe3, 0x6d, 0x98, 0xd4, 0x9a, 0xcf, - 0xae, 0x0a, 0xa5, 0x6e, 0xc3, 0x09, 0x70, 0x20, 0x33, 0xd1, 0x55, 0xc1, 0x66, 0x40, 0x1c, 0x2e, - 0x33, 0x42, 0x30, 0xfe, 0x8e, 0x2a, 0xad, 0x88, 0x9d, 0x88, 0x5d, 0xab, 0xc5, 0x7e, 0x90, 0x89, - 0x64, 0xa7, 0xc4, 0x7e, 0x10, 0xee, 0x06, 0x57, 0xf8, 0xda, 0xcc, 0x26, 0xd6, 0xe6, 0xb8, 0x18, - 0x89, 0x9c, 0xfd, 0xc8, 0xe7, 0x2b, 0x32, 0x9c, 0xa9, 0xb9, 0x8f, 0x3f, 0x53, 0xdf, 0x85, 0x89, - 0x7b, 0x76, 0xdb, 0xde, 0xa5, 0x0d, 0xd6, 0x02, 0xbe, 0xf7, 0x8c, 0x2d, 0x9d, 0x3b, 0x3a, 0x2c, - 0x9e, 0x69, 0x71, 0x38, 0xb6, 0x52, 0x9d, 0x44, 0x1a, 0x01, 0xb9, 0x2e, 0x57, 0xf6, 0x70, 0xca, - 0xca, 0x9e, 0x14, 0xb5, 0x0f, 0xe3, 0xca, 0x16, 0xeb, 0xd9, 0xf8, 0xce, 0x18, 0xb6, 0x91, 0xbc, - 0x0a, 0x23, 0x26, 0xdd, 0x65, 0x47, 0x4d, 0x26, 0x1a, 0x24, 0x0f, 0x21, 0x6a, 0xc7, 0x70, 0x1c, - 0x94, 0x33, 0x68, 0xc3, 0xdf, 0x73, 0x76, 0x02, 0xd1, 0x3b, 0xa1, 0x9c, 0x21, 0xc0, 0x8a, 0x9c, - 0x21, 0x20, 0xfa, 0x75, 0x96, 0xc3, 0xd8, 0xee, 0x67, 0x56, 0x6a, 0xa2, 0xd3, 0x64, 0x0f, 0x9b, - 0x15, 0x65, 0x1b, 0xf1, 0x34, 0x29, 0x81, 0x61, 0x93, 0x9b, 0x30, 0x56, 0xaa, 0xd7, 0xdd, 0xae, - 0x72, 0x67, 0xe4, 0xeb, 0x96, 0x03, 0x75, 0x15, 0x49, 0x84, 0x4a, 0x6a, 0x30, 0xbe, 0xcc, 0x2e, - 0x5a, 0x4e, 0xd9, 0xae, 0xef, 0xc9, 0x4e, 0x92, 0x7b, 0x98, 0x52, 0x12, 0xad, 0x5c, 0x8a, 0xc0, - 0x3a, 0x03, 0xaa, 0x4a, 0x06, 0x05, 0x97, 0x6c, 0xc0, 0x78, 0x8d, 0xd6, 0x3d, 0x1a, 0xd4, 0x02, - 0xd7, 0xa3, 0xb1, 0x2d, 0x59, 0x29, 0x59, 0x7a, 0x4e, 0xde, 0xf5, 0x7c, 0x04, 0x5a, 0x3e, 0x83, - 0xaa, 0x5c, 0x15, 0x64, 0x2e, 0xb4, 0xb7, 0x5c, 0xef, 0xa0, 0xb2, 0x24, 0xb6, 0xe9, 0xe8, 0x4c, - 0xe7, 0x60, 0x55, 0x68, 0x67, 0x90, 0xc6, 0xb6, 0x2e, 0xb4, 0x73, 0x2c, 0x1c, 0xa9, 0x4a, 0x0d, - 0x65, 0x2b, 0xb1, 0x69, 0x4f, 0x47, 0xbd, 0x8c, 0x60, 0x65, 0xa4, 0x1a, 0x3e, 0x4a, 0x66, 0xda, - 0x48, 0x09, 0x2c, 0xd2, 0x01, 0x22, 0x47, 0x8d, 0x0b, 0xba, 0x4d, 0xea, 0xfb, 0x62, 0x2f, 0x3f, - 0x1b, 0x1b, 0xfc, 0x08, 0x61, 0xe9, 0x45, 0xc1, 0xfc, 0xbc, 0x9c, 0x06, 0xe2, 0x9e, 0xc6, 0x0a, - 0x95, 0x7a, 0x52, 0x78, 0x93, 0x37, 0x00, 0x96, 0x1f, 0x07, 0xd4, 0x6b, 0xdb, 0xcd, 0x50, 0x0f, - 0x86, 0xaa, 0x1f, 0x2a, 0xa0, 0xfa, 0x40, 0x2b, 0xc8, 0xa4, 0x0c, 0x93, 0x25, 0xdf, 0xef, 0xb6, - 0xa8, 0xe9, 0x36, 0x69, 0xc9, 0x5c, 0xc3, 0x7d, 0x7f, 0x6c, 0xe9, 0xfc, 0xd1, 0x61, 0xf1, 0xac, - 0x8d, 0x05, 0x96, 0xe7, 0x36, 0xa9, 0x65, 0x7b, 0xea, 0xec, 0xd6, 0x69, 0xc8, 0x7d, 0x80, 0xfb, - 0x1d, 0xda, 0xae, 0x51, 0xdb, 0xab, 0xef, 0xc5, 0xb6, 0xf9, 0xa8, 0x60, 0xe9, 0x59, 0xd1, 0xc2, - 0x39, 0xb7, 0x43, 0xdb, 0x3e, 0xc2, 0xd4, 0xaf, 0x8a, 0x30, 0xc9, 0x16, 0x4c, 0x57, 0x4b, 0xf7, - 0xd6, 0xdd, 0xa6, 0x53, 0x3f, 0x10, 0x92, 0xd3, 0x14, 0x6a, 0x07, 0x4f, 0x0b, 0xae, 0xb1, 0x52, - 0xbe, 0x3d, 0x39, 0x76, 0xcb, 0xea, 0x20, 0xd4, 0x12, 0xf2, 0x53, 0x9c, 0x0b, 0xf9, 0x80, 0xcd, - 0x41, 0x9f, 0x09, 0x83, 0x1b, 0xf6, 0xae, 0x3f, 0x3f, 0xad, 0x69, 0xbb, 0x4a, 0x5b, 0xb5, 0xab, - 0x4a, 0x29, 0x17, 0x53, 0x16, 0xf8, 0x44, 0x44, 0xa8, 0x15, 0xd8, 0xbb, 0xbe, 0x3e, 0x11, 0x43, - 0x6c, 0x72, 0x07, 0xa0, 0xe2, 0xd6, 0xbb, 0x2d, 0xda, 0x0e, 0x2a, 0x4b, 0xf3, 0x05, 0xfd, 0x2a, - 0x10, 0x16, 0x44, 0x5b, 0x5b, 0xc3, 0xad, 0x6b, 0x33, 0x51, 0xa1, 0x5e, 0x78, 0x07, 0x0a, 0xf1, - 0x0f, 0x39, 0xa1, 0x02, 0x6b, 0xb2, 0x30, 0xa5, 0xb4, 0x7e, 0xf9, 0xb1, 0xe3, 0x07, 0xbe, 0xf1, - 0x4d, 0x6d, 0x05, 0xb2, 0xdd, 0xe1, 0x2e, 0x3d, 0x58, 0xf7, 0xe8, 0x8e, 0xf3, 0x58, 0x6c, 0x66, - 0xb8, 0x3b, 0xec, 0xd3, 0x03, 0xab, 0x83, 0x50, 0x75, 0x77, 0x08, 0x51, 0xc9, 0xe7, 0x21, 0x7f, - 0xf7, 0x5e, 0xed, 0x2e, 0x3d, 0xa8, 0x56, 0xc4, 0x41, 0xc5, 0xc9, 0x5a, 0xbe, 0xc5, 0x48, 0xb5, - 0xb9, 0x16, 0x62, 0x1a, 0x4b, 0xd1, 0x4e, 0xc8, 0x6a, 0x2e, 0x37, 0xbb, 0x7e, 0x40, 0xbd, 0x6a, - 0x45, 0xad, 0xb9, 0xce, 0x81, 0xb1, 0x7d, 0x29, 0x44, 0x35, 0xfe, 0xbf, 0x2c, 0xee, 0x82, 0x6c, - 0xc2, 0x57, 0xdb, 0x7e, 0x60, 0xb7, 0xeb, 0x34, 0x64, 0x80, 0x13, 0xde, 0x11, 0xd0, 0xd8, 0x84, - 0x8f, 0x90, 0xf5, 0xaa, 0xb3, 0x03, 0x57, 0xcd, 0xaa, 0x94, 0x9a, 0x8b, 0x6a, 0x45, 0x55, 0xaf, - 0x7a, 0x02, 0x1a, 0xab, 0x32, 0x42, 0x26, 0x97, 0x60, 0xb4, 0x5a, 0xba, 0x57, 0xea, 0x06, 0x7b, - 0xb8, 0x07, 0xe7, 0xb9, 0x7c, 0xce, 0x66, 0xab, 0xdd, 0x0d, 0xf6, 0x4c, 0x59, 0x48, 0xae, 0xe1, - 0xbd, 0xa7, 0x4d, 0x03, 0xae, 0x86, 0x15, 0x87, 0xae, 0xcf, 0x41, 0xb1, 0x6b, 0x0f, 0x03, 0x91, - 0x97, 0x61, 0xf8, 0xc1, 0x7a, 0xb9, 0x5a, 0x11, 0x17, 0x67, 0x3c, 0x89, 0x1e, 0x76, 0xea, 0xfa, - 0x97, 0x70, 0x14, 0xb2, 0x0c, 0x53, 0x35, 0x5a, 0xef, 0x7a, 0x4e, 0x70, 0x70, 0xdb, 0x73, 0xbb, - 0x1d, 0x7f, 0x7e, 0x14, 0xeb, 0xc0, 0x95, 0xee, 0x8b, 0x12, 0x6b, 0x17, 0x8b, 0x14, 0xea, 0x18, - 0x91, 0xf1, 0x9b, 0x99, 0x68, 0x9b, 0x24, 0x97, 0x34, 0xb1, 0x06, 0x75, 0x37, 0x4c, 0xac, 0x51, - 0x75, 0x37, 0x28, 0xe0, 0x98, 0x40, 0xca, 0x5d, 0x3f, 0x70, 0x5b, 0xcb, 0xed, 0x46, 0xc7, 0x75, - 0xda, 0x01, 0x52, 0xf1, 0xce, 0x37, 0x8e, 0x0e, 0x8b, 0xcf, 0xd5, 0xb1, 0xd4, 0xa2, 0xa2, 0xd8, - 0x8a, 0x71, 0x49, 0xa1, 0xfe, 0x04, 0xe3, 0x61, 0xfc, 0xab, 0xac, 0x76, 0xbc, 0xb1, 0xcf, 0x33, - 0x69, 0xa7, 0xe9, 0xd4, 0xf1, 0x46, 0x8f, 0x0d, 0x0d, 0x67, 0x15, 0x7e, 0x9e, 0x17, 0x95, 0xf2, - 0x1e, 0xd2, 0x79, 0xa7, 0x50, 0x93, 0xf7, 0x60, 0x82, 0x49, 0x1a, 0xe2, 0xa7, 0x3f, 0x9f, 0xc5, - 0xce, 0x7e, 0x16, 0xb5, 0x70, 0x3e, 0xf5, 0x42, 0x36, 0x9a, 0x88, 0xa2, 0x52, 0x90, 0x06, 0xcc, - 0x6f, 0x78, 0x76, 0xdb, 0x77, 0x82, 0xe5, 0x76, 0xdd, 0x3b, 0x40, 0xc9, 0x68, 0xb9, 0x6d, 0x6f, - 0x37, 0x69, 0x03, 0x9b, 0x9b, 0x5f, 0xba, 0x7c, 0x74, 0x58, 0x7c, 0x21, 0xe0, 0x38, 0x16, 0x0d, - 0x91, 0x2c, 0xca, 0xb1, 0x14, 0xce, 0x3d, 0x39, 0x31, 0x49, 0x4a, 0x76, 0x2b, 0x3e, 0xc2, 0x70, - 0x21, 0x01, 0x25, 0xa9, 0x70, 0x34, 0xd8, 0x1e, 0xa6, 0x7e, 0xa6, 0x4a, 0x60, 0xfc, 0xdf, 0x99, - 0xe8, 0x00, 0x26, 0x6f, 0xc1, 0xb8, 0x58, 0x31, 0xca, 0xbc, 0xc0, 0x1d, 0x54, 0x2e, 0xaf, 0xd8, - 0xc8, 0xaa, 0xe8, 0xec, 0xde, 0x5f, 0x2a, 0xaf, 0x2a, 0x73, 0x03, 0xef, 0xfd, 0x76, 0xbd, 0x19, - 0xa7, 0x92, 0x68, 0x6c, 0x12, 0x6c, 0xac, 0xd6, 0xf4, 0x5e, 0xc1, 0x49, 0x10, 0x34, 0xfd, 0x94, - 0x6e, 0x50, 0x90, 0x3f, 0x79, 0xc3, 0xff, 0xe7, 0x4c, 0xda, 0x39, 0x4f, 0x96, 0x60, 0x72, 0xcb, - 0xf5, 0xf6, 0x71, 0x7c, 0x95, 0x4e, 0xc0, 0x91, 0x7f, 0x24, 0x0b, 0xe2, 0x0d, 0xd2, 0x49, 0xd4, - 0x6f, 0x53, 0x7a, 0x43, 0xff, 0xb6, 0x18, 0x07, 0x8d, 0x80, 0x8d, 0x43, 0xc8, 0x31, 0x5c, 0x1d, - 0x38, 0x0e, 0xd1, 0x27, 0x68, 0x53, 0x58, 0x45, 0x37, 0xfe, 0x59, 0x46, 0x3d, 0xcf, 0x59, 0x27, - 0x57, 0xdc, 0x96, 0xed, 0xb4, 0x95, 0xe6, 0xf0, 0x87, 0x25, 0x84, 0xc6, 0xbf, 0x44, 0x41, 0x26, - 0x37, 0x20, 0xcf, 0x7f, 0x85, 0x7b, 0x2d, 0x6a, 0xb5, 0x04, 0xa1, 0x7e, 0x50, 0x48, 0xc4, 0xc4, - 0xc8, 0xe4, 0x4e, 0x3a, 0x32, 0xdf, 0xc9, 0xa8, 0x47, 0xf1, 0xc7, 0x3d, 0x6c, 0x62, 0x87, 0x4c, - 0xf6, 0x24, 0x87, 0xcc, 0x27, 0x6e, 0xc2, 0x0f, 0x66, 0x60, 0x5c, 0xd1, 0x52, 0xb0, 0x36, 0xac, - 0x7b, 0xee, 0x47, 0xb4, 0x1e, 0xe8, 0x6d, 0xe8, 0x70, 0x60, 0xac, 0x0d, 0x21, 0xea, 0x27, 0x68, - 0x83, 0xf1, 0xc7, 0x19, 0x71, 0x47, 0x1a, 0x78, 0x9b, 0xd7, 0xb7, 0xe4, 0xec, 0x49, 0x8e, 0xc8, - 0xf7, 0x60, 0xd8, 0xa4, 0x0d, 0xc7, 0x17, 0xf7, 0x9b, 0x19, 0xf5, 0x3e, 0x86, 0x05, 0x91, 0xdc, - 0xe4, 0xb1, 0x9f, 0xea, 0xf9, 0x86, 0xe5, 0x4c, 0x90, 0xad, 0xfa, 0xb7, 0x9a, 0xf4, 0xb1, 0xc3, - 0x17, 0xa3, 0x38, 0x6a, 0xf1, 0x78, 0x73, 0x7c, 0x6b, 0x87, 0x95, 0x08, 0x89, 0x5a, 0x5d, 0x78, - 0x1a, 0x8d, 0xf1, 0x01, 0x40, 0x54, 0x25, 0xb9, 0x0b, 0x05, 0x31, 0x1b, 0x9c, 0xf6, 0x2e, 0x17, - 0xa4, 0x44, 0x1f, 0x14, 0x8f, 0x0e, 0x8b, 0xe7, 0xea, 0x61, 0x99, 0x90, 0x3a, 0x15, 0xbe, 0x09, - 0x42, 0xe3, 0x7f, 0xcf, 0x41, 0xb6, 0x84, 0x03, 0x72, 0x97, 0x1e, 0x04, 0xf6, 0xf6, 0x2d, 0xa7, - 0xa9, 0x2d, 0xa6, 0x7d, 0x84, 0x5a, 0x3b, 0x8e, 0xa6, 0xae, 0x50, 0x90, 0xd9, 0x62, 0xba, 0xeb, - 0x6d, 0xbf, 0x8e, 0x84, 0xca, 0x62, 0xda, 0xf7, 0xb6, 0x5f, 0x8f, 0x93, 0x85, 0x88, 0xc4, 0x80, - 0x11, 0xbe, 0xb0, 0xc4, 0x1c, 0x84, 0xa3, 0xc3, 0xe2, 0x08, 0x5f, 0x7f, 0xa6, 0x28, 0x21, 0x67, - 0x21, 0x57, 0x5b, 0x5f, 0x13, 0x3b, 0x20, 0xaa, 0x05, 0xfd, 0x4e, 0xdb, 0x64, 0x30, 0x56, 0xe7, - 0x6a, 0xa5, 0xb4, 0x8e, 0x8a, 0x80, 0xe1, 0xa8, 0xce, 0x66, 0xc3, 0xee, 0xc4, 0x55, 0x01, 0x21, - 0x22, 0x79, 0x1b, 0xc6, 0xef, 0x56, 0xca, 0x2b, 0xae, 0xcf, 0x77, 0xaf, 0x91, 0x68, 0xf2, 0xef, - 0x37, 0xea, 0x16, 0x6a, 0xe2, 0xe3, 0xc7, 0x80, 0x82, 0x4f, 0x2c, 0x38, 0xcd, 0x58, 0xb1, 0x21, - 0x71, 0xea, 0x54, 0x5c, 0x4a, 0xd7, 0x22, 0xbd, 0xff, 0x4b, 0x47, 0x87, 0xc5, 0x8b, 0xf8, 0x05, - 0x3e, 0x47, 0xb1, 0xe4, 0x75, 0x36, 0xc6, 0xb5, 0x07, 0x1b, 0xf2, 0x55, 0x38, 0x95, 0x2c, 0xa9, - 0x85, 0xef, 0x05, 0x97, 0x8e, 0x0e, 0x8b, 0x46, 0x2a, 0x7f, 0x5f, 0x9b, 0xbf, 0xe9, 0x4c, 0x8c, - 0x6f, 0x65, 0x61, 0x5c, 0x51, 0xf3, 0x91, 0xcf, 0x8b, 0xf7, 0xdd, 0x8c, 0x76, 0x81, 0x51, 0x30, - 0x58, 0x29, 0xd7, 0x09, 0xb5, 0xdc, 0x06, 0x15, 0xaf, 0xbd, 0x91, 0xfe, 0x25, 0x3b, 0x88, 0xfe, - 0xe5, 0x0d, 0x00, 0x3e, 0x85, 0xb1, 0x9f, 0x14, 0x69, 0x48, 0x31, 0xf3, 0x50, 0xa7, 0x55, 0x84, - 0x4c, 0x1e, 0xc0, 0xec, 0x86, 0xd7, 0xf5, 0x83, 0xda, 0x81, 0x1f, 0xd0, 0x16, 0xe3, 0xb6, 0xee, - 0xba, 0x4d, 0xb1, 0x7c, 0x5e, 0x38, 0x3a, 0x2c, 0x5e, 0x40, 0xdb, 0x14, 0xcb, 0xc7, 0x72, 0xfc, - 0x00, 0xab, 0xe3, 0xba, 0xaa, 0x56, 0x26, 0x8d, 0x81, 0x61, 0xc2, 0x84, 0xaa, 0xd3, 0x61, 0x07, - 0xa3, 0x78, 0x0b, 0x13, 0x9a, 0x7a, 0xe5, 0x60, 0x14, 0x5f, 0x99, 0x7c, 0x9b, 0xd3, 0x49, 0x8c, - 0xcf, 0xab, 0xfa, 0xc4, 0x41, 0xf7, 0x25, 0xe3, 0x87, 0x33, 0xd1, 0x2e, 0xf8, 0xe0, 0x3a, 0x79, - 0x13, 0x46, 0xf8, 0xdb, 0xa3, 0x78, 0xa2, 0x3d, 0x15, 0xde, 0xc9, 0xd5, 0x87, 0x49, 0xae, 0xc8, - 0xff, 0x5d, 0x6e, 0x9f, 0xf0, 0x8c, 0x29, 0x48, 0xc2, 0x37, 0x00, 0x5d, 0x1d, 0x28, 0xb9, 0xa3, - 0xb6, 0xfb, 0x7a, 0xda, 0x1b, 0x80, 0xf1, 0xff, 0x0e, 0xc1, 0x94, 0x8e, 0xa6, 0x3e, 0x50, 0x66, - 0x06, 0x7a, 0xa0, 0x7c, 0x0f, 0xf2, 0x62, 0xbe, 0x49, 0x81, 0xf2, 0x05, 0x7c, 0x19, 0x11, 0x30, - 0xed, 0xe1, 0x1d, 0xf8, 0x70, 0xb0, 0x2b, 0xba, 0x19, 0x52, 0x91, 0x45, 0xe5, 0x15, 0x2d, 0x17, - 0xc9, 0x58, 0xf2, 0x15, 0x4d, 0x5d, 0xce, 0xe1, 0x7b, 0xda, 0x6b, 0x30, 0xc2, 0xae, 0x27, 0xa1, - 0x06, 0x09, 0xbf, 0x92, 0xdd, 0x5c, 0x62, 0x16, 0x36, 0x1c, 0x89, 0x6c, 0x41, 0x7e, 0xd5, 0xf6, - 0x83, 0x1a, 0xa5, 0xed, 0x01, 0x4c, 0x0f, 0x8a, 0xa2, 0xab, 0x66, 0xf1, 0x5d, 0xdf, 0xa7, 0xb4, - 0x1d, 0x7b, 0x3b, 0x0e, 0x99, 0x91, 0x0f, 0x01, 0xca, 0x6e, 0x3b, 0xf0, 0xdc, 0xe6, 0xaa, 0xbb, - 0x3b, 0x3f, 0x82, 0x57, 0xf7, 0xe7, 0x62, 0x03, 0x10, 0x21, 0xf0, 0xdb, 0x7b, 0xa8, 0x9f, 0xaa, - 0xf3, 0x02, 0xab, 0xe9, 0xee, 0xaa, 0xeb, 0x20, 0xc2, 0x27, 0xb7, 0xa0, 0x20, 0xf5, 0x22, 0x9b, - 0x9d, 0x5d, 0x0f, 0x27, 0xc8, 0x68, 0x24, 0x38, 0xd1, 0xc7, 0x81, 0xd5, 0x15, 0x70, 0x75, 0xa3, - 0x8f, 0xd3, 0x90, 0xaf, 0xc2, 0x99, 0x38, 0x4c, 0x8e, 0x72, 0x3e, 0xba, 0x52, 0xa8, 0xec, 0x52, - 0xe6, 0x7d, 0x2f, 0x16, 0xe4, 0x26, 0x8c, 0xf3, 0x77, 0x7a, 0xaf, 0xda, 0xde, 0x71, 0x85, 0xb6, - 0x5f, 0x2a, 0xc1, 0x45, 0xc9, 0x83, 0x45, 0x56, 0x66, 0xaa, 0x88, 0xc6, 0xf7, 0xb2, 0x70, 0xa6, - 0x47, 0x27, 0xb1, 0x75, 0x84, 0x52, 0x8a, 0xb2, 0x8e, 0x62, 0xc2, 0x09, 0x37, 0xb5, 0xba, 0x00, - 0x59, 0x71, 0xae, 0x0f, 0x2d, 0x15, 0x8e, 0x0e, 0x8b, 0x13, 0xda, 0xf8, 0x67, 0xab, 0x15, 0x72, - 0x07, 0x86, 0xd8, 0xd0, 0x0e, 0x60, 0x31, 0x20, 0x55, 0x69, 0x53, 0x81, 0xa3, 0x4e, 0x3b, 0x1c, - 0x72, 0xe4, 0x41, 0x3e, 0x0f, 0xb9, 0x8d, 0x8d, 0x55, 0x9c, 0x73, 0x39, 0xec, 0xb3, 0xc9, 0x20, - 0x68, 0x6a, 0x53, 0x7c, 0x92, 0xd1, 0x5e, 0x0d, 0x0d, 0x4c, 0x18, 0x3a, 0xf9, 0x72, 0xcc, 0x92, - 0xe9, 0xe5, 0xfe, 0x13, 0x64, 0x70, 0xc3, 0xa6, 0x4f, 0x60, 0x4f, 0x64, 0xfc, 0x64, 0x46, 0x1a, - 0x6d, 0x88, 0xb1, 0x21, 0x17, 0xe4, 0x30, 0xe2, 0x75, 0x4f, 0x70, 0x51, 0x41, 0xe4, 0x39, 0x00, - 0xfe, 0x73, 0x73, 0x53, 0x74, 0xfa, 0x84, 0xa9, 0x40, 0xc8, 0x97, 0x42, 0x96, 0x42, 0x41, 0x96, - 0xc3, 0xf3, 0x25, 0x36, 0x15, 0x78, 0x99, 0xa9, 0xa3, 0x1a, 0xbf, 0x91, 0x8d, 0xf6, 0xa2, 0x5b, - 0x4e, 0x33, 0xa0, 0x1e, 0x59, 0xe0, 0x5b, 0x4b, 0x24, 0x23, 0x9b, 0xe1, 0x6f, 0x32, 0x1f, 0xed, - 0x53, 0xbc, 0x69, 0xe1, 0x86, 0xf4, 0xb2, 0xb2, 0x21, 0xe5, 0x70, 0x43, 0x9a, 0xea, 0xb9, 0xf5, - 0xbc, 0x9c, 0xb2, 0xbe, 0x70, 0x43, 0x49, 0x59, 0x43, 0x2f, 0xc0, 0xe4, 0x9a, 0xbb, 0xfc, 0x38, - 0x08, 0x11, 0xd9, 0x46, 0x92, 0x37, 0x75, 0x20, 0xe3, 0x78, 0xbf, 0xd9, 0xa0, 0xde, 0xc6, 0x9e, - 0xdd, 0xd6, 0x4c, 0x08, 0xcc, 0x04, 0x9c, 0xe1, 0xae, 0xd1, 0x47, 0x3a, 0xee, 0x28, 0xc7, 0x8d, - 0xc3, 0xe3, 0x83, 0x93, 0x4f, 0x0c, 0x8e, 0xf1, 0x43, 0x59, 0xd9, 0x5d, 0x0f, 0x16, 0x9f, 0xd2, - 0xc7, 0xec, 0xd7, 0xb5, 0xc7, 0xec, 0xd9, 0x50, 0x0d, 0x1f, 0x5a, 0x66, 0x2c, 0x1e, 0x63, 0xd0, - 0xf1, 0x77, 0x46, 0x60, 0x42, 0x45, 0x67, 0xfd, 0x50, 0x6a, 0x34, 0x3c, 0xb5, 0x1f, 0xec, 0x46, - 0xc3, 0x33, 0x11, 0xaa, 0xd9, 0x6f, 0xe4, 0xfa, 0xda, 0x6f, 0x7c, 0x0d, 0xc6, 0xca, 0xad, 0x86, - 0xf6, 0xaa, 0x6c, 0xa4, 0x7c, 0xde, 0xd5, 0x10, 0x89, 0xaf, 0xde, 0x50, 0xbb, 0x5c, 0x6f, 0x35, - 0x92, 0x6f, 0xc9, 0x11, 0x4b, 0xcd, 0xf4, 0x63, 0xf8, 0x93, 0x98, 0x7e, 0xdc, 0x84, 0xb1, 0x4d, - 0x9f, 0x6e, 0x74, 0xdb, 0x6d, 0xda, 0xc4, 0x89, 0x97, 0xe7, 0x97, 0xb2, 0xae, 0x4f, 0xad, 0x00, - 0xa1, 0xea, 0x07, 0x84, 0xa8, 0xea, 0x00, 0x8f, 0xf6, 0x19, 0xe0, 0x1b, 0x90, 0x5f, 0xa7, 0xd4, - 0xc3, 0x3e, 0x1d, 0x8f, 0x64, 0xef, 0x0e, 0xa5, 0x9e, 0xc5, 0x3a, 0x56, 0x33, 0x09, 0x11, 0x88, - 0x9a, 0x1d, 0xc9, 0xc4, 0x80, 0x76, 0x24, 0xe4, 0x79, 0x98, 0xe8, 0x74, 0xb7, 0x9b, 0x4e, 0x1d, - 0xf9, 0x0a, 0x03, 0x14, 0x73, 0x9c, 0xc3, 0x18, 0x5b, 0x9f, 0x7c, 0x19, 0x26, 0xf1, 0x32, 0x1a, - 0x4e, 0xb9, 0x29, 0xed, 0xe4, 0xd1, 0xca, 0xb8, 0x4c, 0x57, 0x67, 0x20, 0x2b, 0xc5, 0x4e, 0x4a, - 0x67, 0x44, 0xee, 0xc0, 0xe8, 0xae, 0x13, 0x58, 0x7b, 0xdd, 0xed, 0xf9, 0x69, 0xcd, 0xc8, 0xe8, - 0xb6, 0x13, 0xac, 0x74, 0xb7, 0xf9, 0x90, 0x87, 0xac, 0x71, 0x8f, 0xde, 0x75, 0x82, 0xbd, 0xae, - 0xaa, 0x3b, 0x1f, 0xd9, 0x45, 0xdc, 0x85, 0x1a, 0x4c, 0xe9, 0xb3, 0xe2, 0x09, 0xbc, 0xe8, 0x86, - 0xf6, 0x35, 0xf9, 0xc2, 0xd8, 0x9d, 0xa1, 0x3c, 0x14, 0xc6, 0xb9, 0x65, 0x8d, 0x09, 0xeb, 0x61, - 0xff, 0x98, 0xe4, 0x6e, 0x77, 0x9b, 0x7a, 0x6d, 0x1a, 0x50, 0x5f, 0xdc, 0xfc, 0x7c, 0x73, 0xa8, - 0xd4, 0xe9, 0xf8, 0xc6, 0x3f, 0xca, 0xc2, 0x68, 0x69, 0xab, 0x86, 0xbb, 0xfe, 0xab, 0xea, 0x73, - 0x9c, 0xfa, 0x2e, 0x1b, 0x3e, 0xc7, 0xa9, 0x8f, 0x70, 0xd7, 0x52, 0xee, 0xee, 0x68, 0xba, 0xad, - 0xdc, 0xdd, 0x35, 0xad, 0x43, 0xf4, 0x32, 0x99, 0x1b, 0xe0, 0x65, 0x32, 0x54, 0x1e, 0x0f, 0x1d, - 0xaf, 0x3c, 0x7e, 0x13, 0xc6, 0xab, 0xed, 0x80, 0xee, 0x7a, 0xd1, 0xaa, 0x09, 0xf5, 0x08, 0x21, - 0x58, 0xbd, 0xcf, 0x29, 0xd8, 0x6c, 0x4a, 0x72, 0x85, 0x75, 0xa8, 0xa8, 0xc6, 0x29, 0xc9, 0xf5, - 0xda, 0x31, 0x25, 0x90, 0x44, 0x34, 0x2a, 0xb1, 0xf9, 0x26, 0xad, 0x3f, 0xb8, 0xc8, 0x3e, 0x15, - 0xbd, 0xd8, 0xb0, 0x8e, 0x5d, 0x9a, 0x49, 0xb7, 0xfe, 0x30, 0xfe, 0x6a, 0x06, 0xe6, 0xd2, 0xa6, - 0x11, 0x79, 0x07, 0x26, 0x5c, 0x6f, 0xd7, 0x6e, 0x3b, 0xdf, 0xcf, 0x5b, 0xa4, 0x68, 0x2a, 0x55, - 0xb8, 0xaa, 0x9f, 0x51, 0xe1, 0xac, 0x43, 0x94, 0x96, 0xeb, 0x8a, 0x95, 0xd4, 0x0e, 0x51, 0xc0, - 0xc6, 0x8f, 0x65, 0x61, 0xbc, 0xd4, 0xe9, 0x3c, 0xe5, 0x96, 0x81, 0x5f, 0xd4, 0x0e, 0x10, 0x79, - 0xaf, 0x0d, 0xdb, 0x35, 0x90, 0x51, 0xe0, 0xaf, 0x66, 0x61, 0x3a, 0x46, 0xa1, 0x7e, 0x7d, 0x66, - 0x40, 0x7b, 0xc0, 0xec, 0x80, 0xf6, 0x80, 0xb9, 0xc1, 0xec, 0x01, 0x87, 0x3e, 0xc9, 0xa1, 0xf0, - 0x12, 0xe4, 0x4a, 0x9d, 0x4e, 0xdc, 0xae, 0xa0, 0xd3, 0x79, 0x70, 0x83, 0xab, 0x56, 0xec, 0x4e, - 0xc7, 0x64, 0x18, 0xda, 0x4e, 0x3d, 0x32, 0xe0, 0x4e, 0x6d, 0xbc, 0x06, 0x63, 0xc8, 0x0b, 0xad, - 0xf0, 0x2e, 0x00, 0x6e, 0x31, 0xc2, 0x00, 0x4f, 0xab, 0x4b, 0x6c, 0x3e, 0xff, 0x2e, 0x03, 0xc3, - 0xf8, 0xfb, 0x29, 0x9d, 0x63, 0x8b, 0xda, 0x1c, 0x2b, 0x28, 0x73, 0x6c, 0x90, 0xd9, 0xf5, 0xf7, - 0x73, 0x00, 0xe5, 0xfb, 0x66, 0x8d, 0x6b, 0xe0, 0xc8, 0x2d, 0x98, 0xb6, 0x9b, 0x4d, 0xf7, 0x11, - 0x6d, 0x58, 0xae, 0xe7, 0xec, 0x3a, 0x6d, 0xde, 0x73, 0xf2, 0xb1, 0x5b, 0x2f, 0x52, 0x9f, 0xc0, - 0x44, 0xd1, 0x7d, 0x5e, 0xa2, 0xf2, 0x69, 0xd1, 0x60, 0xcf, 0x6d, 0xc8, 0xcb, 0xb8, 0xc6, 0x47, - 0x14, 0xa5, 0xf0, 0xb9, 0xc7, 0x4b, 0x54, 0x3e, 0x7b, 0xa8, 0x5c, 0x90, 0x32, 0xb4, 0xc6, 0x47, - 0x14, 0xa5, 0xf0, 0xe1, 0x1a, 0x09, 0x9f, 0xac, 0xc2, 0x0c, 0x42, 0xac, 0xba, 0x47, 0x1b, 0xb4, - 0x1d, 0x38, 0x76, 0xd3, 0x17, 0xea, 0x1b, 0xd4, 0x53, 0x26, 0x0a, 0xd5, 0xeb, 0x2b, 0x16, 0x96, - 0xa3, 0x32, 0x72, 0x15, 0x46, 0x5b, 0xf6, 0x63, 0xcb, 0xde, 0xe5, 0x66, 0x1f, 0x93, 0xfc, 0xba, - 0x2f, 0x40, 0xea, 0x31, 0xd2, 0xb2, 0x1f, 0x97, 0x76, 0x29, 0x6b, 0x05, 0x7d, 0xdc, 0x71, 0x7d, - 0xa5, 0x15, 0x23, 0x51, 0x2b, 0x62, 0x45, 0x6a, 0x2b, 0x44, 0x91, 0x68, 0x85, 0xf1, 0x2b, 0x19, - 0x38, 0x57, 0xc5, 0xaf, 0x08, 0x0e, 0xca, 0xb4, 0x1d, 0x50, 0x6f, 0x9d, 0x7a, 0x2d, 0x07, 0x1f, - 0xc1, 0x6b, 0x34, 0x20, 0x17, 0x21, 0x57, 0x32, 0xd7, 0xc4, 0xfc, 0xe5, 0xfb, 0xbd, 0x66, 0x92, - 0xc0, 0x4a, 0x43, 0x8d, 0x50, 0xf6, 0x18, 0x4d, 0x75, 0x09, 0x26, 0x4a, 0xbe, 0xef, 0xec, 0xb6, - 0x5b, 0xdc, 0x9d, 0x22, 0xa7, 0x19, 0x3d, 0x08, 0x78, 0xe2, 0x89, 0x45, 0x25, 0x31, 0xfe, 0x8b, - 0x0c, 0xcc, 0x94, 0x3a, 0x1d, 0xfd, 0x93, 0x75, 0x83, 0x9b, 0xcc, 0xe0, 0x06, 0x37, 0x0e, 0x4c, - 0x69, 0xcd, 0xe5, 0x53, 0x2a, 0x12, 0x7c, 0xfb, 0xf4, 0x0c, 0xff, 0xec, 0x4e, 0x08, 0xb2, 0x7c, - 0xfd, 0xb5, 0x38, 0xc6, 0xd8, 0xf8, 0xd3, 0x51, 0xdc, 0x43, 0xc4, 0x6e, 0x2b, 0x4c, 0x42, 0x33, - 0x29, 0x26, 0xa1, 0x6f, 0x80, 0x22, 0xe1, 0xa8, 0x47, 0x9c, 0x22, 0x2b, 0xaa, 0xba, 0x94, 0x08, - 0x99, 0xec, 0xc7, 0x8d, 0x43, 0x73, 0xd8, 0x9a, 0x8b, 0xf1, 0x05, 0xfc, 0x44, 0xec, 0x42, 0x57, - 0x80, 0x54, 0xdb, 0xf8, 0x82, 0x4d, 0x6b, 0xfb, 0x4e, 0xe7, 0x01, 0xf5, 0x9c, 0x9d, 0x03, 0xb1, - 0x00, 0xb0, 0xf3, 0x1d, 0x51, 0x6a, 0xf9, 0xfb, 0x4e, 0xc7, 0x7a, 0x88, 0xe5, 0x66, 0x0a, 0x0d, - 0x79, 0x17, 0x46, 0x4d, 0xfa, 0xc8, 0x73, 0x02, 0x69, 0xf2, 0x34, 0x15, 0xaa, 0x06, 0x11, 0xca, - 0xd7, 0x82, 0xc7, 0x7f, 0xa8, 0xbb, 0xa2, 0x28, 0x27, 0x8b, 0x5c, 0x48, 0xe1, 0xa6, 0x4d, 0x93, - 0x51, 0x6b, 0x4b, 0x5b, 0xb5, 0x5e, 0x32, 0x0a, 0xb9, 0x02, 0xc3, 0x28, 0xe9, 0x88, 0xbb, 0x00, - 0xba, 0x0a, 0xa1, 0xec, 0xac, 0x8a, 0x61, 0x88, 0x81, 0x3a, 0x01, 0xf9, 0x44, 0xec, 0xcf, 0xe7, - 0x51, 0x4a, 0x57, 0x20, 0x71, 0x31, 0x6d, 0xec, 0x44, 0x62, 0xda, 0x2a, 0x14, 0x4c, 0xee, 0x75, - 0xd8, 0x28, 0x75, 0xf0, 0x1d, 0xd2, 0x9f, 0x07, 0x5c, 0xc9, 0x17, 0x8e, 0x0e, 0x8b, 0xcf, 0x0a, - 0x8f, 0xc4, 0x86, 0x65, 0x77, 0xf8, 0xf3, 0xa5, 0xb6, 0x8d, 0xc4, 0x29, 0xc9, 0x1b, 0x30, 0xc4, - 0xb6, 0x5e, 0x61, 0x46, 0x2a, 0xdf, 0x73, 0xa2, 0xdd, 0x98, 0x2f, 0xce, 0xba, 0xab, 0xed, 0x09, - 0x48, 0x42, 0x2c, 0x98, 0xd2, 0xa7, 0xbb, 0xb0, 0x28, 0x9a, 0x8f, 0xfa, 0x53, 0x2f, 0x17, 0x8f, - 0x3c, 0x02, 0x66, 0xd5, 0x11, 0xa8, 0xae, 0x80, 0xd8, 0x22, 0x5d, 0x86, 0xfc, 0x46, 0x79, 0x7d, - 0xdd, 0xf5, 0x02, 0x7e, 0xd5, 0x89, 0x4e, 0x16, 0x06, 0x33, 0xed, 0xf6, 0x2e, 0xe5, 0x67, 0x71, - 0x50, 0xef, 0x58, 0x1d, 0x86, 0xa6, 0x9e, 0xc5, 0x92, 0x94, 0x7c, 0x08, 0xa7, 0x36, 0x7d, 0x5a, - 0x6a, 0x1f, 0xe0, 0xe9, 0xac, 0x2c, 0x95, 0x29, 0x9c, 0x7a, 0xf8, 0x4c, 0xc1, 0xae, 0x82, 0x76, - 0xfb, 0xc0, 0xe2, 0xa7, 0x7a, 0xfa, 0xc2, 0x49, 0xe7, 0xf2, 0xe9, 0x59, 0xa8, 0xfe, 0x6a, 0x16, - 0x2e, 0x86, 0x42, 0xd7, 0x7d, 0xaf, 0x56, 0xba, 0xb7, 0x5a, 0x6d, 0xc8, 0x87, 0x8c, 0x75, 0xcf, - 0x7d, 0xe8, 0x34, 0xa8, 0xf7, 0xe0, 0xfa, 0x31, 0x22, 0xc3, 0x2a, 0xdf, 0x45, 0xf8, 0x5b, 0x5b, - 0x56, 0xb3, 0xe5, 0x53, 0x64, 0x5b, 0xb1, 0xfb, 0x75, 0x3a, 0x89, 0xa7, 0xb7, 0x95, 0x67, 0xcc, - 0x88, 0x01, 0xf9, 0xe1, 0x0c, 0x9c, 0x4e, 0xff, 0x10, 0xa1, 0x4b, 0x2c, 0x4a, 0x0d, 0x40, 0x8f, - 0xaf, 0xe5, 0xdd, 0xed, 0xdb, 0xad, 0xa6, 0xe5, 0x34, 0xa2, 0x97, 0x9b, 0x8e, 0x40, 0xd0, 0xea, - 0xed, 0x51, 0xd3, 0x97, 0x40, 0x4a, 0x0e, 0xf3, 0x99, 0x25, 0x80, 0xbc, 0x7c, 0x0f, 0x30, 0xfe, - 0x71, 0x06, 0x94, 0x15, 0x9e, 0x37, 0x69, 0xc3, 0xf1, 0x68, 0x3d, 0x10, 0xd2, 0x83, 0xf0, 0x44, - 0xe4, 0xb0, 0x98, 0xe9, 0x26, 0xc2, 0xc8, 0x3b, 0x30, 0x2a, 0x4e, 0x39, 0xb1, 0xab, 0xcb, 0x9d, - 0x41, 0xbc, 0x34, 0x70, 0x97, 0xd5, 0xc4, 0x09, 0x29, 0x89, 0xd8, 0xa1, 0x72, 0x67, 0x6b, 0xa3, - 0xdc, 0xb4, 0x9d, 0x96, 0x2f, 0x8e, 0x2a, 0xec, 0xd6, 0x8f, 0x1e, 0x05, 0x56, 0x1d, 0xa1, 0xea, - 0xa1, 0x12, 0xa2, 0x1a, 0xb7, 0xe5, 0x43, 0xc7, 0x31, 0xf6, 0xc7, 0x45, 0x18, 0x7e, 0x10, 0x29, - 0x2e, 0x97, 0xc6, 0x8e, 0x0e, 0x8b, 0x7c, 0xba, 0x98, 0x1c, 0x6e, 0x50, 0x18, 0x0b, 0x57, 0x06, - 0xe3, 0xc5, 0x7e, 0x20, 0xaf, 0x49, 0xce, 0x8b, 0xad, 0x11, 0x13, 0xa1, 0x4c, 0x92, 0x5c, 0x6e, - 0x37, 0x10, 0x21, 0x8b, 0x08, 0xd8, 0x3d, 0xb4, 0xdd, 0xc0, 0x85, 0xa4, 0xb6, 0x4e, 0xa0, 0x29, - 0xf2, 0xda, 0x4f, 0x64, 0x60, 0x4a, 0x9f, 0xb6, 0xe4, 0x2a, 0x8c, 0x08, 0x67, 0xc3, 0x0c, 0xea, - 0x81, 0x19, 0xb7, 0x11, 0xee, 0x66, 0xa8, 0x39, 0x17, 0x0a, 0x2c, 0x26, 0x96, 0x0a, 0x0e, 0x42, - 0x26, 0x43, 0xb1, 0xb4, 0xce, 0x41, 0xa6, 0x2c, 0x23, 0x06, 0xbb, 0x29, 0xfb, 0xdd, 0x66, 0xa0, - 0xbe, 0x8a, 0x7a, 0x08, 0x31, 0x45, 0x89, 0x51, 0x86, 0x11, 0xbe, 0x73, 0xc7, 0xcc, 0x2b, 0x33, - 0x27, 0x30, 0xaf, 0x34, 0x0e, 0x33, 0x00, 0xb5, 0xda, 0xca, 0x5d, 0x7a, 0xb0, 0x6e, 0x3b, 0x28, - 0x1e, 0xf0, 0x15, 0x7e, 0x57, 0xac, 0xe1, 0x09, 0xf1, 0x8c, 0xcf, 0x37, 0x86, 0x7d, 0x7a, 0xa0, - 0x3d, 0xe3, 0x4b, 0x54, 0x3c, 0x8a, 0x3d, 0xe7, 0xa1, 0x1d, 0x50, 0x46, 0x88, 0xca, 0x60, 0x71, - 0x14, 0x73, 0x68, 0x8c, 0x52, 0x41, 0x26, 0x1f, 0xc2, 0x54, 0xf4, 0x2b, 0x34, 0x46, 0x98, 0x0a, - 0xf7, 0x09, 0xbd, 0x70, 0xe9, 0xb9, 0xa3, 0xc3, 0xe2, 0x82, 0xc2, 0x35, 0x6e, 0xa6, 0x10, 0x63, - 0x86, 0xb6, 0x22, 0x1b, 0xab, 0x35, 0xd9, 0xc0, 0x4b, 0x30, 0x14, 0x1a, 0x8d, 0x4f, 0x88, 0x3d, - 0x5e, 0x7f, 0xb1, 0xc4, 0x72, 0x26, 0xcd, 0x45, 0x2d, 0xc1, 0x93, 0x51, 0x6f, 0x01, 0x2b, 0x25, - 0xb7, 0x61, 0x74, 0xa0, 0x6f, 0xc6, 0x29, 0x96, 0xf2, 0xad, 0x92, 0x9a, 0x09, 0x39, 0x65, 0x93, - 0x3f, 0x25, 0x4c, 0x70, 0x21, 0xa7, 0xee, 0x35, 0x4d, 0x06, 0xc3, 0x01, 0xba, 0xb3, 0xb5, 0xf1, - 0xd9, 0x1d, 0xa0, 0x9f, 0xce, 0xc2, 0x34, 0xeb, 0xf2, 0x52, 0x37, 0xd8, 0x73, 0x3d, 0x27, 0x38, - 0x78, 0x6a, 0x35, 0xd6, 0x6f, 0x69, 0x97, 0xc1, 0x05, 0x79, 0xce, 0xa9, 0x6d, 0x1b, 0x48, 0x71, - 0xfd, 0xaf, 0x87, 0x61, 0x36, 0x85, 0x8a, 0xbc, 0xaa, 0x3d, 0x83, 0xcd, 0xcb, 0x38, 0x03, 0xdf, - 0x3b, 0x2c, 0x4e, 0x48, 0xf4, 0x8d, 0x28, 0xee, 0xc0, 0xa2, 0x6e, 0xea, 0xc6, 0x7b, 0x0a, 0x5f, - 0xc5, 0x54, 0x53, 0x37, 0xdd, 0xc0, 0xed, 0x0a, 0x0c, 0x9b, 0x6e, 0x93, 0x4a, 0xf3, 0x4e, 0x14, - 0xf5, 0x3c, 0x06, 0xd0, 0xcc, 0x59, 0x18, 0x80, 0xac, 0xc0, 0x28, 0xfb, 0xe3, 0x9e, 0xdd, 0x11, - 0x2f, 0x9d, 0x24, 0x54, 0x47, 0x20, 0xb4, 0xe3, 0xb4, 0x77, 0x55, 0x8d, 0x44, 0x93, 0x5a, 0x2d, - 0xbb, 0xa3, 0xc9, 0xa4, 0x1c, 0x51, 0xd3, 0x6c, 0xe4, 0x7b, 0x6b, 0x36, 0x32, 0xc7, 0x6a, 0x36, - 0x76, 0x00, 0x6a, 0xce, 0x6e, 0xdb, 0x69, 0xef, 0x96, 0x9a, 0xbb, 0x22, 0x5a, 0xc3, 0x95, 0xde, - 0xa3, 0x70, 0x35, 0x42, 0xc6, 0x89, 0x7b, 0x0e, 0xcd, 0x11, 0x38, 0xcc, 0xb2, 0x9b, 0xbb, 0x9a, - 0x57, 0x99, 0xc2, 0x99, 0xac, 0x01, 0x94, 0xea, 0x81, 0xf3, 0x90, 0x4d, 0x61, 0x5f, 0x08, 0x90, - 0xf2, 0x93, 0xcb, 0xa5, 0xbb, 0xf4, 0x00, 0x2f, 0x3d, 0xf2, 0x61, 0xd7, 0x46, 0x54, 0xb6, 0x12, - 0x34, 0x97, 0xa1, 0x88, 0x03, 0xe9, 0xc0, 0xa9, 0x52, 0xa3, 0xe1, 0xb0, 0x36, 0xd8, 0xcd, 0x0d, - 0x1e, 0x67, 0x03, 0x59, 0x4f, 0xa4, 0xb3, 0xbe, 0x22, 0x58, 0x3f, 0x6f, 0x87, 0x54, 0x96, 0x0c, - 0xcf, 0x11, 0xab, 0x26, 0x9d, 0xb1, 0x51, 0x83, 0x29, 0xbd, 0xf1, 0x7a, 0x94, 0x89, 0x09, 0xc8, - 0x9b, 0xb5, 0x92, 0x55, 0x5b, 0x29, 0x5d, 0x2f, 0x64, 0x48, 0x01, 0x26, 0xc4, 0xaf, 0x45, 0x6b, - 0xf1, 0xf5, 0x9b, 0x85, 0xac, 0x06, 0x79, 0xfd, 0xfa, 0x62, 0x21, 0xb7, 0x90, 0x9d, 0xcf, 0xc4, - 0x1c, 0x3c, 0x47, 0x0b, 0x79, 0xae, 0x8c, 0x36, 0x7e, 0x2d, 0x03, 0x79, 0xf9, 0xed, 0xe4, 0x26, - 0xe4, 0x6a, 0xb5, 0x95, 0x98, 0x4b, 0x66, 0x74, 0x00, 0xf1, 0xad, 0xd6, 0xf7, 0x55, 0xbb, 0x7b, - 0x46, 0xc0, 0xe8, 0x36, 0x56, 0x6b, 0x42, 0x3c, 0x91, 0x74, 0xd1, 0xbe, 0xce, 0xe9, 0x52, 0xfc, - 0xd4, 0x6e, 0x42, 0xee, 0xce, 0xd6, 0x86, 0xb8, 0xde, 0x49, 0xba, 0x68, 0x3f, 0xe5, 0x74, 0x1f, - 0x3d, 0x52, 0x0f, 0x00, 0x46, 0x60, 0x98, 0x30, 0xae, 0x4c, 0x64, 0x7e, 0x1e, 0xb7, 0xdc, 0x30, - 0xb4, 0x82, 0x38, 0x8f, 0x19, 0xc4, 0x14, 0x25, 0x4c, 0x4a, 0x59, 0x75, 0xeb, 0x76, 0x53, 0x1c, - 0xec, 0x28, 0xa5, 0x34, 0x19, 0xc0, 0xe4, 0x70, 0xe3, 0x37, 0x33, 0x50, 0x40, 0x59, 0x0e, 0xed, - 0xe6, 0xdd, 0x7d, 0xda, 0x7e, 0x70, 0x9d, 0xbc, 0x26, 0x97, 0x5c, 0x26, 0x54, 0xb1, 0x0d, 0xe3, - 0x92, 0x8b, 0xbd, 0x53, 0x8a, 0x65, 0xa7, 0x44, 0xaf, 0xc8, 0x0e, 0xee, 0xf5, 0x7e, 0x4c, 0xf4, - 0x8a, 0x22, 0x0c, 0xe3, 0xe7, 0x88, 0xcd, 0x11, 0xbf, 0x3c, 0x60, 0x00, 0x93, 0xc3, 0x95, 0xbd, - 0xe9, 0x30, 0x9b, 0x68, 0xc3, 0xe2, 0x67, 0xca, 0x73, 0x5c, 0x6f, 0x5c, 0xef, 0xfd, 0x9a, 0xdc, - 0x8d, 0xf9, 0xcc, 0x9e, 0x4f, 0x67, 0xc0, 0xfd, 0xd5, 0x16, 0xf9, 0xf3, 0x05, 0xf7, 0xfa, 0x50, - 0x95, 0x54, 0x09, 0xff, 0xd9, 0x0f, 0x60, 0x2e, 0xde, 0xbf, 0xa8, 0x4b, 0x2d, 0xc1, 0xb4, 0x0e, - 0x97, 0x6a, 0xd5, 0x33, 0xa9, 0xf5, 0x3e, 0x58, 0x34, 0xe3, 0xf8, 0xc6, 0xff, 0x9a, 0x81, 0x31, - 0xfc, 0xd3, 0xec, 0x36, 0xd1, 0x18, 0xb2, 0xb4, 0x55, 0x13, 0x1a, 0x1e, 0x55, 0x68, 0xb4, 0x1f, - 0xf9, 0xd2, 0xa0, 0x4c, 0xdb, 0xb0, 0x42, 0x64, 0x41, 0xca, 0x9f, 0x69, 0xa4, 0x6e, 0x31, 0x24, - 0xe5, 0xef, 0x39, 0x7e, 0x8c, 0x54, 0x20, 0xa3, 0x09, 0xf5, 0x56, 0x8d, 0xcd, 0x65, 0xd5, 0xbc, - 0x07, 0xe9, 0xdc, 0xa6, 0x6e, 0x42, 0xcd, 0xd1, 0xd0, 0xba, 0x67, 0xab, 0x56, 0x32, 0xd7, 0x34, - 0xeb, 0x1e, 0xf6, 0x8d, 0x9a, 0x7a, 0x4d, 0x20, 0x19, 0xff, 0x6c, 0x32, 0xde, 0x81, 0xe2, 0xf4, - 0x3c, 0xe1, 0x42, 0x7b, 0x13, 0x86, 0x4b, 0xcd, 0xa6, 0xfb, 0x48, 0x6c, 0x39, 0xf2, 0x02, 0x1e, - 0xf6, 0x1f, 0x3f, 0x1c, 0x51, 0x3b, 0xa9, 0xb9, 0xd6, 0x32, 0x00, 0x29, 0xc3, 0x58, 0x69, 0xab, - 0x56, 0xad, 0x56, 0x36, 0x36, 0xb8, 0x1b, 0x61, 0x6e, 0xe9, 0x45, 0xd9, 0x3f, 0x8e, 0xd3, 0xb0, - 0xe2, 0x86, 0x22, 0xd1, 0x3d, 0x21, 0xa2, 0x23, 0x6f, 0x03, 0xdc, 0x71, 0x9d, 0x36, 0xd7, 0xc6, - 0x8a, 0xc6, 0x9f, 0x3f, 0x3a, 0x2c, 0x8e, 0x7f, 0xe4, 0x3a, 0x6d, 0xa1, 0xbe, 0x65, 0xdf, 0x1e, - 0x21, 0x99, 0xca, 0xdf, 0xac, 0xa7, 0x97, 0x5c, 0x6e, 0x96, 0x38, 0x1c, 0xf5, 0xf4, 0xb6, 0x9b, - 0x50, 0x1b, 0x4a, 0x34, 0xd2, 0x82, 0xe9, 0x5a, 0x77, 0x77, 0x97, 0xb2, 0x63, 0x42, 0xa8, 0xc5, - 0x46, 0xc4, 0x95, 0x3d, 0x0c, 0xde, 0xc4, 0xef, 0x3d, 0xec, 0xd2, 0xe5, 0x2f, 0xbd, 0xca, 0x56, - 0xc5, 0x77, 0x0f, 0x8b, 0xc2, 0x00, 0x85, 0xc9, 0x7d, 0xbe, 0xa4, 0x4f, 0x2a, 0xc5, 0xe2, 0xbc, - 0xc9, 0x7d, 0x18, 0xe1, 0x4f, 0x5f, 0xc2, 0x2d, 0xee, 0xf9, 0x3e, 0x2b, 0x90, 0x23, 0xf6, 0x7a, - 0x5c, 0xe5, 0xa5, 0x64, 0x0b, 0xf2, 0x65, 0xc7, 0xab, 0x37, 0x69, 0xb9, 0x2a, 0x04, 0x89, 0x8b, - 0x7d, 0x58, 0x4a, 0x54, 0xde, 0x2f, 0x75, 0xfc, 0x55, 0x77, 0x54, 0xc1, 0x42, 0x62, 0x90, 0xbf, - 0x9a, 0x81, 0x73, 0xe1, 0xd7, 0x97, 0x76, 0x69, 0x3b, 0xb8, 0x67, 0x07, 0xf5, 0x3d, 0xea, 0x89, - 0x5e, 0x1a, 0xeb, 0xd7, 0x4b, 0x5f, 0x4a, 0xf4, 0xd2, 0xe5, 0xa8, 0x97, 0x6c, 0xc6, 0xcc, 0x6a, - 0x71, 0x6e, 0xc9, 0x3e, 0xeb, 0x57, 0x2b, 0xb1, 0x00, 0xa2, 0x47, 0x5d, 0x61, 0x68, 0xf5, 0x62, - 0x9f, 0x06, 0x47, 0xc8, 0xc2, 0x1d, 0x2a, 0xfc, 0xad, 0xd9, 0xf3, 0x86, 0x50, 0x72, 0x57, 0xfa, - 0xa0, 0x72, 0x11, 0xe7, 0x42, 0x1f, 0xde, 0xdc, 0x2f, 0x75, 0xb6, 0x8f, 0xb7, 0x39, 0x1f, 0xed, - 0x55, 0x7b, 0x5b, 0x48, 0x35, 0xc7, 0x8c, 0xf6, 0xaa, 0x1d, 0x8d, 0x76, 0xd3, 0x8e, 0x8f, 0xf6, - 0xaa, 0xbd, 0x4d, 0xca, 0xdc, 0x71, 0x9e, 0x7b, 0x59, 0x3f, 0xd7, 0x8f, 0x5b, 0x79, 0x9d, 0x1f, - 0xf3, 0x29, 0x0e, 0xf4, 0x5f, 0x81, 0xb1, 0x5a, 0xc7, 0xae, 0xd3, 0xa6, 0xb3, 0x13, 0x08, 0x8b, - 0x81, 0x17, 0xfa, 0xb0, 0x0a, 0x71, 0xc5, 0x0b, 0xb1, 0xfc, 0xa9, 0xde, 0xb9, 0x42, 0x1c, 0xf6, - 0x85, 0x1b, 0xeb, 0xf7, 0x84, 0xd1, 0x40, 0xbf, 0x2f, 0xdc, 0x58, 0xbf, 0x27, 0x04, 0x98, 0x4e, - 0x4b, 0x13, 0x60, 0xd6, 0xef, 0x91, 0x0e, 0x4c, 0x6d, 0x50, 0xcf, 0xb3, 0x77, 0x5c, 0xaf, 0xc5, - 0xd5, 0xb0, 0xdc, 0x73, 0xef, 0x4a, 0x3f, 0x7e, 0x1a, 0x01, 0xd7, 0x3e, 0x06, 0x12, 0x66, 0xc5, - 0x75, 0xb7, 0x31, 0xfe, 0xac, 0x4f, 0x96, 0x9c, 0x60, 0xbb, 0x5b, 0xdf, 0xa7, 0xc1, 0xfc, 0xcc, - 0xb1, 0x7d, 0x12, 0xe2, 0xf2, 0x3e, 0xd9, 0x96, 0x3f, 0xd5, 0x3e, 0x09, 0x71, 0xd8, 0x34, 0x10, - 0xee, 0xf1, 0xe4, 0xd8, 0x69, 0xc0, 0x11, 0xf9, 0x34, 0xe8, 0xe5, 0x27, 0x4f, 0xf6, 0x60, 0x62, - 0xc9, 0xed, 0xb6, 0x99, 0x5c, 0xdb, 0xb1, 0x1d, 0x6f, 0x7e, 0x16, 0xd9, 0xbe, 0xd4, 0xef, 0x83, - 0x15, 0x74, 0x6e, 0xf5, 0xbd, 0xcd, 0x20, 0x4c, 0x74, 0x66, 0x20, 0xf5, 0x41, 0x45, 0x45, 0x25, - 0x0d, 0x18, 0xc7, 0xa9, 0x5c, 0xa1, 0x0f, 0xdd, 0x8e, 0x3f, 0x3f, 0x87, 0x15, 0x5d, 0x3a, 0x6e, - 0x51, 0x70, 0x6c, 0xfe, 0x72, 0x8f, 0x4b, 0xc3, 0x6a, 0x20, 0x44, 0xd5, 0x72, 0x2b, 0x88, 0xc6, - 0x3f, 0x1a, 0x86, 0xe2, 0x31, 0xcc, 0xc8, 0x03, 0x79, 0x36, 0x71, 0x09, 0xe0, 0x95, 0xc1, 0xbe, - 0xe1, 0xea, 0xb1, 0xc7, 0xd6, 0x9b, 0x30, 0x75, 0x5f, 0x31, 0x22, 0x08, 0x8d, 0x3a, 0x90, 0x46, - 0x35, 0x2f, 0xb0, 0x9c, 0x86, 0x19, 0x43, 0x5d, 0xf8, 0x77, 0x39, 0x18, 0x42, 0xc1, 0xe2, 0x22, - 0xe4, 0x6a, 0xdd, 0x6d, 0xf5, 0x21, 0xcc, 0xd7, 0xb6, 0x6b, 0x56, 0x4a, 0xde, 0x82, 0x71, 0xe1, - 0x04, 0xa2, 0xdc, 0x4e, 0xb1, 0x93, 0xa4, 0xc7, 0x48, 0xdc, 0x02, 0x5f, 0x41, 0x27, 0xef, 0xc2, - 0xc4, 0xba, 0xd3, 0xa1, 0x4d, 0xa7, 0x4d, 0x15, 0x7b, 0x72, 0x1c, 0xcb, 0x8e, 0x80, 0x27, 0x1e, - 0xc7, 0x54, 0x02, 0xdd, 0x5d, 0x65, 0x68, 0x70, 0x77, 0x95, 0x77, 0x61, 0xa2, 0x42, 0x77, 0x9c, - 0xb6, 0x23, 0xfa, 0x67, 0x38, 0xaa, 0xb8, 0x11, 0xc2, 0x75, 0x6a, 0x8d, 0x80, 0x2c, 0xc1, 0xa4, - 0x49, 0x3b, 0xae, 0xef, 0x04, 0xae, 0x77, 0xb0, 0x69, 0x56, 0x85, 0xc1, 0x09, 0x1a, 0x24, 0x79, - 0x61, 0x81, 0xd5, 0xf5, 0xd4, 0x93, 0x48, 0x27, 0x21, 0x6b, 0x30, 0x13, 0x01, 0x74, 0x43, 0x2d, - 0xf1, 0x12, 0x12, 0xf2, 0x49, 0x1a, 0xee, 0x26, 0x49, 0xf5, 0x6f, 0x32, 0xe9, 0x8e, 0x30, 0x03, - 0x8e, 0x7f, 0x93, 0x47, 0x77, 0xd2, 0xbf, 0xc9, 0xa4, 0x3b, 0xc6, 0x3f, 0xcd, 0xc1, 0x99, 0x1e, - 0x5b, 0x1b, 0x59, 0xd3, 0xa7, 0xeb, 0xc5, 0xfe, 0x3b, 0xe1, 0xf1, 0xd3, 0x74, 0x15, 0x0a, 0xcb, - 0x77, 0xf1, 0x42, 0xcf, 0xdf, 0x99, 0xcb, 0x25, 0x29, 0x84, 0x62, 0xf3, 0xe9, 0x3e, 0xba, 0x00, - 0xc8, 0xf7, 0xe9, 0xba, 0x16, 0xaa, 0x23, 0x41, 0xb9, 0xf0, 0x43, 0x59, 0x31, 0x6f, 0x63, 0x01, - 0x0a, 0x33, 0x27, 0x0a, 0x50, 0xf8, 0x1e, 0x4c, 0x2c, 0xdf, 0xe5, 0xea, 0xb6, 0x15, 0xdb, 0xdf, - 0x13, 0x73, 0x0a, 0xbb, 0x90, 0xee, 0xcb, 0x77, 0x95, 0x3d, 0x5b, 0xbb, 0xd8, 0x6a, 0x14, 0x64, - 0x13, 0x66, 0xf9, 0xb7, 0x39, 0x3b, 0x4e, 0x9d, 0xc7, 0x39, 0x73, 0xec, 0xa6, 0x98, 0x61, 0x17, - 0x8f, 0x0e, 0x8b, 0x45, 0xba, 0x8f, 0xce, 0x0d, 0xa2, 0xdc, 0xf2, 0x11, 0x41, 0xf5, 0x72, 0x48, - 0xa1, 0x57, 0x83, 0x2f, 0x99, 0x63, 0x58, 0x21, 0xab, 0x8d, 0xd5, 0xcd, 0x70, 0x39, 0x92, 0xf1, - 0x47, 0xc3, 0xb0, 0xd0, 0x5b, 0xec, 0x22, 0xef, 0xeb, 0x03, 0x78, 0xe9, 0x58, 0x41, 0xed, 0xf8, - 0x31, 0xfc, 0x32, 0xcc, 0x2d, 0xb7, 0x03, 0xea, 0x75, 0x3c, 0x47, 0x86, 0xdb, 0x5a, 0x71, 0x7d, - 0xe9, 0x4c, 0x82, 0x5e, 0x1d, 0x34, 0x2c, 0x17, 0x6f, 0x33, 0xe8, 0x99, 0xa3, 0xb0, 0x4a, 0xe5, - 0x40, 0x96, 0x61, 0x4a, 0x81, 0x37, 0xbb, 0xbb, 0xea, 0xe3, 0xb9, 0xca, 0xb3, 0xd9, 0x55, 0x2d, - 0xed, 0x63, 0x44, 0xe8, 0xb0, 0x12, 0xd8, 0x81, 0x53, 0xbf, 0xb3, 0x75, 0xb7, 0x26, 0x86, 0x93, - 0x3b, 0xac, 0x20, 0xd4, 0xfa, 0xe8, 0xd1, 0xbe, 0x26, 0x37, 0x45, 0xc8, 0x0b, 0x7f, 0xeb, 0x44, - 0x3b, 0xe1, 0x17, 0x01, 0xa2, 0xa5, 0xa4, 0x3a, 0x7c, 0x47, 0x4b, 0x4f, 0xf7, 0x49, 0x93, 0x50, - 0xb2, 0x02, 0xd3, 0xd1, 0xaf, 0xfb, 0x8f, 0xda, 0xe2, 0x2d, 0x6a, 0x8c, 0xab, 0x60, 0x95, 0x95, - 0xeb, 0xb2, 0x32, 0x55, 0x14, 0x8f, 0x91, 0x91, 0x45, 0xc8, 0x6f, 0xb9, 0xde, 0xfe, 0x0e, 0x1b, - 0xe3, 0xa1, 0xe8, 0xb2, 0xf0, 0x48, 0xc0, 0x54, 0xa1, 0x58, 0xe2, 0xb1, 0xe5, 0xb2, 0xdc, 0x7e, - 0xe8, 0x78, 0x2e, 0x1a, 0x1c, 0xa8, 0x26, 0x77, 0x34, 0x02, 0x6b, 0xa1, 0x36, 0x22, 0x30, 0xb9, - 0x02, 0xc3, 0xa5, 0x7a, 0xe0, 0x7a, 0x62, 0xfb, 0xe3, 0x33, 0x85, 0x01, 0xb4, 0x99, 0xc2, 0x00, - 0xac, 0x13, 0xd9, 0x9e, 0x34, 0x1a, 0x75, 0xa2, 0xbe, 0x11, 0xb1, 0x52, 0x76, 0xd9, 0x31, 0xe9, - 0x0e, 0x6a, 0x47, 0xb5, 0xf0, 0x9b, 0x3b, 0x09, 0x95, 0xbb, 0x40, 0x33, 0x7e, 0x04, 0x7a, 0x4e, - 0x79, 0x26, 0x5d, 0x9e, 0x6c, 0xca, 0xaf, 0xda, 0x03, 0x4c, 0xf9, 0x57, 0x43, 0x4f, 0x37, 0x35, - 0x78, 0x0e, 0x42, 0x54, 0xb9, 0x46, 0xf8, 0xbc, 0xe9, 0xf3, 0x2f, 0x77, 0x92, 0xf9, 0xf7, 0xf7, - 0xf2, 0x27, 0x99, 0x7f, 0xa2, 0x7f, 0xb3, 0x83, 0xf6, 0x6f, 0x6e, 0xa0, 0xfe, 0x65, 0x87, 0x4a, - 0x18, 0xfb, 0x75, 0xdd, 0x0e, 0xb4, 0x1d, 0x31, 0x0c, 0xd8, 0x6b, 0x75, 0xec, 0x40, 0xdd, 0x11, - 0x75, 0x12, 0x45, 0x48, 0x40, 0x0e, 0xc3, 0x49, 0x21, 0x21, 0x46, 0xaf, 0xa2, 0xb3, 0x8d, 0x40, - 0x9e, 0xf9, 0x35, 0x7c, 0x27, 0x15, 0x93, 0x8d, 0x9b, 0xa3, 0x48, 0x31, 0x81, 0x3f, 0xa1, 0x6a, - 0xef, 0x13, 0x1a, 0x51, 0x7c, 0x9e, 0x8f, 0x9e, 0x68, 0x9e, 0x73, 0x0b, 0x6c, 0x6f, 0xd5, 0xdd, - 0x75, 0xa4, 0x77, 0x8d, 0xb4, 0xc0, 0xf6, 0xac, 0x26, 0x83, 0xc6, 0x2c, 0xb0, 0x39, 0x2a, 0x79, - 0x0d, 0x46, 0xd8, 0x8f, 0x6a, 0x45, 0xd8, 0x48, 0xa0, 0xd2, 0x03, 0x89, 0x74, 0x97, 0x26, 0x8e, - 0x24, 0xab, 0x59, 0x6e, 0xd9, 0x4e, 0x53, 0x84, 0x57, 0x89, 0xaa, 0xa1, 0x0c, 0x1a, 0xaf, 0x06, - 0x51, 0x49, 0x1d, 0x26, 0x4c, 0xba, 0xb3, 0xee, 0xb9, 0x01, 0xad, 0x07, 0xb4, 0x21, 0x2e, 0x7a, - 0x52, 0xd7, 0xb1, 0xe4, 0xba, 0xfc, 0x12, 0xbb, 0xf4, 0xda, 0x6f, 0x1f, 0x16, 0x33, 0xdf, 0x3d, - 0x2c, 0x02, 0x03, 0x71, 0x7f, 0x39, 0x26, 0xf2, 0xb0, 0xf1, 0xef, 0x48, 0x62, 0xf5, 0x60, 0x53, - 0x99, 0x92, 0x6f, 0xb2, 0xad, 0x3e, 0xec, 0x92, 0xa8, 0xb2, 0x89, 0x1e, 0x95, 0xbd, 0x9e, 0x5a, - 0x59, 0x51, 0xe9, 0xed, 0xd4, 0x4a, 0x53, 0x2b, 0x21, 0x6f, 0xc3, 0x78, 0xb9, 0x5a, 0x76, 0xdb, - 0x3b, 0xce, 0x6e, 0x6d, 0xa5, 0x84, 0xb7, 0x45, 0x21, 0xaf, 0xd5, 0x1d, 0xab, 0x8e, 0x70, 0xcb, - 0xdf, 0xb3, 0x35, 0x8f, 0xff, 0x08, 0x9f, 0xdc, 0x86, 0x29, 0xf9, 0xd3, 0xa4, 0x3b, 0x4c, 0x5e, - 0x9b, 0x52, 0xfc, 0x6b, 0x43, 0x0e, 0xac, 0x23, 0x74, 0x91, 0x2d, 0x46, 0xc6, 0x26, 0x63, 0x85, - 0x76, 0x9a, 0xee, 0x01, 0xfb, 0xbc, 0x0d, 0x87, 0x7a, 0x78, 0x2d, 0x14, 0x93, 0xb1, 0x11, 0x96, - 0x58, 0x81, 0xa3, 0x5b, 0x86, 0xe8, 0x44, 0x4c, 0xf4, 0x13, 0x53, 0xfc, 0x81, 0xe3, 0x3b, 0xdb, - 0x4e, 0xd3, 0x09, 0x0e, 0xf0, 0x42, 0x28, 0x64, 0x1f, 0xb9, 0x2e, 0x1e, 0x86, 0xa5, 0xaa, 0xe8, - 0x97, 0x20, 0x35, 0x7e, 0x2d, 0x0b, 0xcf, 0xf6, 0x53, 0x8e, 0x90, 0x9a, 0xbe, 0x0f, 0x5e, 0x1e, - 0x40, 0xa1, 0x72, 0xfc, 0x4e, 0xb8, 0xdc, 0xe3, 0x9e, 0x81, 0x9d, 0x11, 0xbb, 0x67, 0xa8, 0x9d, - 0x11, 0xbb, 0x71, 0x3c, 0x14, 0xdb, 0xdc, 0xc7, 0xf5, 0x3d, 0xbf, 0x09, 0x63, 0x65, 0xb7, 0x1d, - 0xd0, 0xc7, 0x41, 0x2c, 0xd2, 0x0a, 0x07, 0xc6, 0xfd, 0xee, 0x25, 0xaa, 0xf1, 0x6f, 0x72, 0x70, - 0xbe, 0xaf, 0x76, 0x80, 0x6c, 0xe8, 0xbd, 0x76, 0x65, 0x10, 0x95, 0xc2, 0xf1, 0xdd, 0xb6, 0x98, - 0xb0, 0x28, 0x3e, 0xde, 0x37, 0xd2, 0x04, 0xc2, 0x03, 0x4a, 0xdc, 0x6e, 0xba, 0xdb, 0xa8, 0x3f, - 0x72, 0xda, 0xbb, 0x22, 0x10, 0x05, 0xf7, 0xf3, 0xc3, 0x52, 0x6b, 0xb7, 0xe9, 0x6e, 0x73, 0x3d, - 0x94, 0xd3, 0x56, 0xc5, 0xa2, 0x14, 0xea, 0x85, 0x7f, 0x93, 0x11, 0x1d, 0xff, 0x39, 0x18, 0xc5, - 0xcf, 0x0f, 0xbb, 0x9d, 0x6b, 0xf6, 0x71, 0x67, 0x77, 0x74, 0xcd, 0x3e, 0x47, 0x23, 0x37, 0x20, - 0x5f, 0xb6, 0x9b, 0x4d, 0x25, 0xb6, 0x0d, 0x2a, 0x0d, 0xea, 0x08, 0x8b, 0x99, 0xda, 0x4b, 0x44, - 0x76, 0x14, 0xf2, 0xbf, 0x95, 0xf3, 0x07, 0x37, 0x60, 0x41, 0x16, 0x3b, 0x82, 0x14, 0x64, 0x8c, - 0x88, 0x5d, 0x77, 0xc3, 0xe8, 0x19, 0x3c, 0x22, 0x36, 0x03, 0x68, 0x11, 0xb1, 0x19, 0xc0, 0xf8, - 0xf5, 0x1c, 0x3c, 0xd7, 0x5f, 0x6d, 0x46, 0x36, 0xf5, 0x61, 0x7d, 0x79, 0x20, 0x65, 0xdb, 0xf1, - 0xe3, 0x2a, 0xe3, 0xcb, 0xf3, 0x0e, 0xb9, 0x9c, 0x74, 0x6f, 0xfc, 0xde, 0x61, 0x51, 0xf1, 0xdf, - 0xb8, 0xe3, 0x3a, 0x6d, 0xe5, 0x9d, 0xf7, 0x1b, 0x09, 0x41, 0x61, 0x7c, 0xf1, 0xe6, 0x60, 0x5f, - 0x16, 0xd1, 0xf1, 0xbd, 0x6a, 0x50, 0x01, 0xe3, 0x4b, 0x50, 0x88, 0x93, 0x92, 0x4b, 0x30, 0x84, - 0x1f, 0xa0, 0xf8, 0x68, 0xc6, 0x38, 0x60, 0xf9, 0xc2, 0x3d, 0x31, 0x77, 0x30, 0xdc, 0x8f, 0xea, - 0x9a, 0x2e, 0x28, 0x45, 0xb8, 0x1f, 0xcd, 0xaf, 0x5d, 0x0f, 0xf7, 0xa3, 0x12, 0x19, 0x7f, 0x92, - 0x81, 0xb3, 0x3d, 0xf5, 0x1e, 0x64, 0x5d, 0x1f, 0xb0, 0x17, 0x8f, 0x53, 0x94, 0x1c, 0x3b, 0x56, - 0x0b, 0x3f, 0x29, 0xe7, 0xfe, 0x3b, 0x30, 0x51, 0xeb, 0x6e, 0xc7, 0xaf, 0x8b, 0x3c, 0x18, 0x97, - 0x02, 0x57, 0x4f, 0x45, 0x15, 0x9f, 0xb5, 0x5f, 0xda, 0x6f, 0x09, 0x73, 0x49, 0xc5, 0x46, 0x3b, - 0x8c, 0x47, 0x91, 0x0c, 0x77, 0xa4, 0x13, 0x19, 0xbf, 0x9a, 0x4d, 0xbf, 0x77, 0xdf, 0x2e, 0xaf, - 0x9f, 0xe4, 0xde, 0x7d, 0xbb, 0xbc, 0x7e, 0x7c, 0xdb, 0xff, 0x1b, 0xd9, 0x76, 0x34, 0x26, 0x11, - 0xbb, 0xa8, 0x7c, 0x4f, 0x11, 0xc6, 0x24, 0x72, 0xc7, 0xf5, 0x75, 0x63, 0x12, 0x89, 0x4c, 0x5e, - 0x87, 0xb1, 0x55, 0x97, 0x47, 0x22, 0x92, 0x2d, 0xe6, 0x01, 0x1b, 0x24, 0x50, 0xdd, 0x72, 0x43, - 0x4c, 0x76, 0xd5, 0xd1, 0x07, 0x5e, 0x9a, 0xa2, 0xe3, 0x55, 0x27, 0x36, 0x5d, 0xf4, 0x57, 0x07, - 0x9d, 0xcc, 0xf8, 0x87, 0xc3, 0x60, 0x1c, 0xaf, 0x33, 0x25, 0x1f, 0xe8, 0x7d, 0x77, 0x75, 0x60, - 0x6d, 0xeb, 0x40, 0xdb, 0x78, 0xa9, 0xdb, 0x70, 0x68, 0xbb, 0xae, 0x87, 0x11, 0x12, 0x30, 0x75, - 0x0b, 0x94, 0x78, 0x1f, 0xc7, 0x2d, 0x7e, 0xe1, 0x5f, 0xe6, 0xa2, 0xa5, 0x16, 0x3b, 0x6e, 0x33, - 0x1f, 0xe3, 0xb8, 0x25, 0x77, 0xa1, 0xa0, 0x42, 0x14, 0xbd, 0x1d, 0x4a, 0x43, 0x1a, 0xa3, 0xd8, - 0x47, 0x25, 0x08, 0xf5, 0x33, 0x3b, 0x37, 0xf8, 0x99, 0x1d, 0xd3, 0x1b, 0x0e, 0x9d, 0x4c, 0x6f, - 0x28, 0xc2, 0x0e, 0xf9, 0xe2, 0xd0, 0x1a, 0xd6, 0xc3, 0x0e, 0xa5, 0x1c, 0x5c, 0x2a, 0xba, 0x8c, - 0x9c, 0x84, 0x3f, 0x95, 0xc0, 0x21, 0x61, 0xe4, 0x24, 0x4e, 0x9f, 0x16, 0x39, 0x29, 0x24, 0x61, - 0x07, 0xa0, 0xd9, 0x6d, 0xf3, 0xd4, 0x0b, 0xa3, 0xd1, 0x01, 0xe8, 0x75, 0xdb, 0x56, 0x3c, 0xfd, - 0x42, 0x88, 0x68, 0xfc, 0x93, 0xa1, 0x74, 0x81, 0x23, 0x52, 0xab, 0x9f, 0x40, 0xe0, 0x08, 0x89, - 0x3e, 0x9d, 0x99, 0xba, 0x09, 0xb3, 0xd2, 0x9a, 0x59, 0xda, 0xad, 0x6e, 0x9a, 0xab, 0x62, 0x88, - 0x51, 0x8d, 0x15, 0xda, 0x41, 0x4b, 0xdb, 0x57, 0xab, 0xeb, 0x69, 0x6a, 0xac, 0x14, 0xfa, 0x85, - 0x7f, 0x2c, 0xb5, 0x74, 0xea, 0x20, 0xa0, 0xe7, 0x79, 0x26, 0x6d, 0x10, 0xba, 0x5d, 0x6d, 0x18, - 0x75, 0x12, 0xbe, 0xf7, 0x86, 0x1a, 0xd5, 0x4d, 0x5d, 0xfe, 0x54, 0xb5, 0xb0, 0x3a, 0x97, 0x18, - 0x11, 0xd9, 0x85, 0xb3, 0x91, 0x78, 0xae, 0xdc, 0x3e, 0x90, 0x23, 0x6f, 0xf0, 0x95, 0xa3, 0xc3, - 0xe2, 0x8b, 0x8a, 0x78, 0xaf, 0x5e, 0x62, 0x62, 0xdc, 0x7b, 0xf3, 0x62, 0xfb, 0xed, 0x92, 0x67, - 0xb7, 0xeb, 0x7b, 0xca, 0x9c, 0xc7, 0xfd, 0x76, 0x1b, 0xa1, 0x89, 0xe0, 0x29, 0x11, 0xb2, 0xf1, - 0xb7, 0xb3, 0xe9, 0x6a, 0x0e, 0xf1, 0x7a, 0x72, 0x02, 0x35, 0x07, 0xa7, 0x38, 0xfe, 0x94, 0xf8, - 0x87, 0xf2, 0x94, 0x78, 0x11, 0x46, 0x37, 0x68, 0xdb, 0x6e, 0x87, 0x41, 0x89, 0xd0, 0x8a, 0x23, - 0xe0, 0x20, 0x53, 0x96, 0x91, 0xf7, 0x81, 0xac, 0xdb, 0x1e, 0x6d, 0x07, 0x65, 0xb7, 0xd5, 0xb1, - 0xbd, 0xa0, 0x85, 0xc9, 0x29, 0xf8, 0xd1, 0xf0, 0xfc, 0xd1, 0x61, 0xf1, 0x7c, 0x07, 0x4b, 0xad, - 0xba, 0x52, 0xac, 0x0a, 0xa8, 0x49, 0x62, 0x72, 0x0d, 0x46, 0xa5, 0x71, 0x42, 0x2e, 0x8a, 0x53, - 0x98, 0x34, 0x4c, 0x90, 0x58, 0xc6, 0xbf, 0x1c, 0x86, 0x0b, 0xc7, 0x3d, 0x15, 0x91, 0x1d, 0x80, - 0xfb, 0xed, 0x6d, 0xd7, 0xf6, 0x1a, 0x4c, 0x84, 0xce, 0x1c, 0x2b, 0x68, 0xa9, 0xc4, 0x57, 0x23, - 0x4a, 0x56, 0xc8, 0xbd, 0x6a, 0xdd, 0x10, 0x66, 0x2a, 0x9c, 0xc9, 0xd7, 0x20, 0x6f, 0xd2, 0xba, - 0xfb, 0x90, 0x0a, 0x75, 0xe0, 0xf8, 0xe2, 0xe7, 0x07, 0xad, 0x45, 0xd2, 0x61, 0x1d, 0xe8, 0x6e, - 0xe8, 0x09, 0x88, 0x19, 0xf2, 0x24, 0x5f, 0x87, 0x71, 0x9e, 0x83, 0xa4, 0xb4, 0x13, 0x84, 0xe6, - 0xeb, 0xc7, 0xa5, 0x36, 0xc9, 0xb0, 0x4d, 0x92, 0x67, 0x35, 0xb1, 0xec, 0x1d, 0xcd, 0x7d, 0x81, - 0xa7, 0x36, 0x51, 0x58, 0x2e, 0xfc, 0x67, 0x59, 0x98, 0xd2, 0x1b, 0x4c, 0x56, 0xa1, 0x50, 0x6d, - 0x3b, 0x81, 0x63, 0x37, 0x75, 0xf3, 0x55, 0x71, 0x6f, 0x75, 0x78, 0x99, 0x95, 0x6a, 0xc6, 0x9a, - 0xa0, 0x64, 0x73, 0x86, 0x0d, 0x9d, 0x1f, 0x70, 0xab, 0x09, 0x1e, 0x33, 0x54, 0x2c, 0xe2, 0xe7, - 0x79, 0x88, 0xda, 0xa8, 0xd4, 0xe2, 0x51, 0x7a, 0xf5, 0x78, 0x88, 0x71, 0x62, 0xf2, 0x10, 0xc8, - 0xbd, 0xae, 0x1f, 0xf0, 0x12, 0xea, 0x2d, 0xd1, 0x1d, 0xd7, 0x1b, 0x24, 0x4e, 0xc8, 0xcb, 0xa2, - 0x73, 0x9e, 0x6b, 0x75, 0xfd, 0xc0, 0xf2, 0x04, 0xb9, 0xb5, 0x8d, 0xf4, 0xb1, 0x4e, 0x4a, 0xa9, - 0x61, 0xe1, 0x1e, 0x4c, 0xa8, 0xa3, 0x86, 0x56, 0x64, 0x4e, 0xcb, 0x91, 0xe6, 0xeb, 0xdc, 0x8a, - 0x8c, 0x01, 0x4c, 0x0e, 0x27, 0xcf, 0x8a, 0x70, 0x4d, 0xd9, 0xc8, 0xd8, 0x2a, 0x0a, 0xcb, 0x64, - 0xfc, 0x68, 0x06, 0x4e, 0xa7, 0x5b, 0x20, 0x91, 0x8f, 0x62, 0x2f, 0xa5, 0x99, 0x7e, 0xef, 0xc8, - 0xd2, 0x6c, 0xe9, 0xe3, 0xbd, 0x95, 0x1a, 0x7f, 0x65, 0x28, 0x21, 0x65, 0xa5, 0x70, 0x24, 0xb7, - 0x53, 0xc7, 0x31, 0xa3, 0x9c, 0x8b, 0xc9, 0x71, 0x4c, 0x1d, 0xbd, 0xb7, 0x60, 0x0a, 0x19, 0x47, - 0x93, 0x4b, 0xd1, 0xb1, 0xf2, 0x4f, 0x8e, 0xa6, 0x96, 0x19, 0xc3, 0x25, 0x55, 0x20, 0x08, 0x59, - 0x72, 0x03, 0xc5, 0xa1, 0x5d, 0xb9, 0x68, 0x72, 0x0e, 0xdb, 0x6e, 0x60, 0xa9, 0xae, 0xed, 0x29, - 0x44, 0xe4, 0x8b, 0x30, 0x29, 0x87, 0xb3, 0x8c, 0xb7, 0x9a, 0x21, 0x1c, 0x46, 0xbc, 0x0f, 0xc9, - 0xb5, 0x68, 0xa1, 0x28, 0x6a, 0xea, 0x88, 0xa4, 0x05, 0xd3, 0x98, 0x1e, 0x88, 0x03, 0x69, 0xa3, - 0x14, 0x0c, 0x10, 0x9d, 0xe8, 0x25, 0x31, 0xfb, 0xce, 0xf1, 0xac, 0x43, 0x92, 0xd6, 0xb2, 0x83, - 0xd8, 0xd4, 0x8b, 0xf3, 0x26, 0xbb, 0x30, 0xa9, 0x64, 0x23, 0x2a, 0x05, 0x03, 0x24, 0xc3, 0x7a, - 0x51, 0x54, 0x76, 0x56, 0x4d, 0x71, 0x94, 0xac, 0x4a, 0xe7, 0x6b, 0xfc, 0x64, 0x16, 0xa6, 0xf8, - 0x6d, 0x91, 0x9b, 0xa1, 0x3d, 0xb5, 0xf6, 0x82, 0x6f, 0x6a, 0xf6, 0x82, 0x32, 0x50, 0xb6, 0xda, - 0xb4, 0x81, 0xac, 0xbb, 0xf7, 0x80, 0x24, 0x69, 0x88, 0x09, 0x13, 0x2a, 0xb4, 0xbf, 0x6d, 0xdf, - 0xf5, 0x28, 0xa6, 0xba, 0xb8, 0xac, 0xa3, 0xb5, 0xa6, 0x6f, 0x6a, 0x3c, 0x8c, 0x9f, 0xc8, 0xc2, - 0xa4, 0x62, 0xdd, 0xfd, 0xd4, 0x76, 0xfc, 0x97, 0xb4, 0x8e, 0x9f, 0x0f, 0x23, 0x7a, 0x84, 0x2d, - 0x1b, 0xa8, 0xdf, 0xbb, 0x30, 0x93, 0x20, 0x89, 0x1b, 0xc9, 0x67, 0x06, 0x31, 0x92, 0x7f, 0x35, - 0x19, 0xa0, 0x99, 0xe7, 0x39, 0x0b, 0xc3, 0x75, 0xaa, 0x11, 0xa1, 0x7f, 0x3a, 0x0b, 0x73, 0xe2, - 0x17, 0x66, 0x34, 0xe0, 0xea, 0x92, 0xa7, 0x76, 0x2c, 0x4a, 0xda, 0x58, 0x14, 0xf5, 0xb1, 0x50, - 0x1a, 0xd8, 0x7b, 0x48, 0x8c, 0x1f, 0x05, 0x98, 0xef, 0x45, 0x30, 0x70, 0xa8, 0xaf, 0x28, 0x94, - 0x48, 0x76, 0x80, 0x50, 0x22, 0xab, 0x50, 0xc0, 0xaa, 0x44, 0xcc, 0x72, 0x7f, 0xd3, 0xac, 0x8a, - 0x4e, 0x42, 0xe9, 0x83, 0xa7, 0x9d, 0x10, 0x31, 0xd4, 0xfd, 0x98, 0x26, 0x3f, 0x41, 0x49, 0xfe, - 0x56, 0x06, 0xa6, 0x10, 0xb8, 0xfc, 0x90, 0x89, 0x9b, 0x8c, 0xd9, 0x90, 0x88, 0x31, 0x11, 0x5a, - 0x00, 0xd6, 0x02, 0xcf, 0x69, 0xef, 0x0a, 0x13, 0xc0, 0x6d, 0x61, 0x02, 0xf8, 0x16, 0x37, 0x5d, - 0xbc, 0x5a, 0x77, 0x5b, 0xd7, 0x76, 0x3d, 0xfb, 0xa1, 0xc3, 0x1d, 0x17, 0xec, 0xe6, 0xb5, 0x28, - 0x3d, 0x67, 0xc7, 0x89, 0x25, 0xce, 0x14, 0xac, 0xd0, 0xbc, 0x92, 0x7f, 0x28, 0xc5, 0x6a, 0xe3, - 0x0f, 0x0e, 0xfa, 0x17, 0x91, 0xef, 0x83, 0x33, 0x5c, 0x75, 0x5b, 0x76, 0xdb, 0x81, 0xd3, 0xee, - 0xba, 0x5d, 0x7f, 0xc9, 0xae, 0xef, 0x77, 0x3b, 0xbe, 0x88, 0x04, 0x84, 0x2d, 0xaf, 0x87, 0x85, - 0xd6, 0x36, 0x2f, 0xd5, 0x62, 0xbc, 0xa5, 0x33, 0x20, 0x2b, 0x30, 0xc3, 0x8b, 0x4a, 0xdd, 0xc0, - 0xad, 0xd5, 0xed, 0x26, 0x13, 0x88, 0x47, 0x91, 0x2b, 0xb7, 0x73, 0xea, 0x06, 0xae, 0xe5, 0x73, - 0xb8, 0xfa, 0xfe, 0x90, 0x20, 0x22, 0x55, 0x98, 0x36, 0xa9, 0xdd, 0xb8, 0x67, 0x3f, 0x2e, 0xdb, - 0x1d, 0xbb, 0xee, 0x04, 0x3c, 0xb5, 0x41, 0x8e, 0xab, 0x14, 0x3c, 0x6a, 0x37, 0xac, 0x96, 0xfd, - 0xd8, 0xaa, 0x8b, 0x42, 0xfd, 0x0d, 0x5b, 0xa3, 0x0b, 0x59, 0x39, 0xed, 0x90, 0xd5, 0x58, 0x9c, - 0x95, 0xd3, 0xee, 0xcd, 0x2a, 0xa2, 0x93, 0xac, 0x36, 0x6c, 0x6f, 0x97, 0x06, 0xdc, 0xf3, 0x10, - 0x2e, 0x64, 0x2e, 0x67, 0x14, 0x56, 0x01, 0x96, 0x59, 0xe8, 0x85, 0x18, 0x67, 0xa5, 0xd0, 0xb1, - 0x99, 0xb7, 0xe5, 0x39, 0x01, 0x55, 0x5b, 0x38, 0x8e, 0x9f, 0x85, 0xfd, 0x8f, 0x3e, 0x9b, 0xbd, - 0x9a, 0x98, 0xa0, 0x8c, 0xb8, 0x29, 0x8d, 0x9c, 0x48, 0x70, 0x4b, 0x6f, 0x65, 0x82, 0x32, 0xe4, - 0xa6, 0xb6, 0x73, 0x12, 0xdb, 0xa9, 0x70, 0xeb, 0xd1, 0xd0, 0x04, 0x25, 0x59, 0x63, 0x9d, 0x16, - 0xb0, 0x9b, 0xbb, 0xdb, 0x16, 0x2e, 0x91, 0x53, 0xf8, 0x69, 0x2f, 0x08, 0xb1, 0xa1, 0xe0, 0xc9, - 0x62, 0x2b, 0xc5, 0x41, 0x32, 0x4e, 0x4c, 0xfe, 0x12, 0x4c, 0x6f, 0xfa, 0xf4, 0x56, 0x75, 0xbd, - 0x26, 0x03, 0x0f, 0xe3, 0x93, 0xd9, 0xd4, 0xe2, 0xf5, 0x63, 0x36, 0x9d, 0xab, 0x2a, 0x0d, 0x66, - 0xbb, 0xe4, 0xe3, 0xd6, 0xf5, 0xa9, 0xb5, 0xe3, 0x74, 0xfc, 0x30, 0x8a, 0xbb, 0x3a, 0x6e, 0xb1, - 0xaa, 0x8c, 0x15, 0x98, 0x49, 0xb0, 0x21, 0x53, 0x00, 0x0c, 0x68, 0x6d, 0xae, 0xd5, 0x96, 0x37, - 0x0a, 0xcf, 0x90, 0x02, 0x4c, 0xe0, 0xef, 0xe5, 0xb5, 0xd2, 0xd2, 0xea, 0x72, 0xa5, 0x90, 0x21, - 0x33, 0x30, 0x89, 0x90, 0x4a, 0xb5, 0xc6, 0x41, 0x59, 0x9e, 0xeb, 0xcc, 0x2c, 0xf0, 0xa5, 0x1b, - 0xe0, 0x63, 0x0b, 0x3b, 0x53, 0x8c, 0xbf, 0x9e, 0x85, 0xb3, 0xf2, 0x58, 0xa1, 0xc1, 0x23, 0xd7, - 0xdb, 0x77, 0xda, 0xbb, 0x4f, 0xf9, 0xe9, 0x70, 0x4b, 0x3b, 0x1d, 0x5e, 0x88, 0x9d, 0xd4, 0xb1, - 0x56, 0xf6, 0x39, 0x22, 0xbe, 0x33, 0x06, 0xe7, 0xfb, 0x52, 0x91, 0xf7, 0xd9, 0x69, 0xee, 0xd0, - 0x76, 0x50, 0x6d, 0x34, 0x29, 0x13, 0x51, 0xdd, 0x6e, 0x20, 0x5c, 0x70, 0x2f, 0xe2, 0x8b, 0x12, - 0x16, 0x5a, 0x4e, 0xa3, 0x49, 0xad, 0x80, 0x17, 0x6b, 0xd3, 0x2d, 0x49, 0xcd, 0x58, 0x86, 0x99, - 0x77, 0xab, 0xed, 0x80, 0x7a, 0x0f, 0xd1, 0x97, 0x27, 0x64, 0xb9, 0x4f, 0x69, 0xc7, 0xb2, 0x59, - 0xa9, 0xe5, 0x88, 0x62, 0x9d, 0x65, 0x82, 0x9a, 0xdc, 0x52, 0x58, 0xa2, 0x94, 0x7f, 0xcf, 0x7e, - 0x2c, 0xfc, 0x01, 0x44, 0x22, 0x8b, 0x90, 0x25, 0x0f, 0xbf, 0xd1, 0xb2, 0x1f, 0x9b, 0x49, 0x12, - 0xf2, 0x21, 0x9c, 0x12, 0x07, 0x90, 0x08, 0x0f, 0x29, 0x5b, 0xcc, 0x83, 0x4f, 0xbe, 0xc4, 0x2e, - 0x66, 0x32, 0x05, 0x88, 0x0c, 0x24, 0x9a, 0xd6, 0xea, 0x74, 0x2e, 0x64, 0x83, 0x1d, 0xc8, 0xb1, - 0xee, 0xb8, 0x47, 0x7d, 0x5f, 0xc6, 0x58, 0x11, 0xba, 0x59, 0xb5, 0x33, 0xad, 0x16, 0x2f, 0x37, - 0x7b, 0x52, 0x92, 0x15, 0x98, 0xda, 0xa2, 0xdb, 0xea, 0xf8, 0x8c, 0x84, 0x5b, 0x55, 0xe1, 0x11, - 0xdd, 0xee, 0x3d, 0x38, 0x31, 0x3a, 0xe2, 0xe0, 0xab, 0xf7, 0xe3, 0x83, 0x55, 0x76, 0x71, 0x6e, - 0x53, 0x0f, 0xef, 0xbf, 0xa3, 0xb8, 0x19, 0xcc, 0x47, 0x12, 0xb2, 0x5e, 0x2e, 0x74, 0x47, 0x18, - 0xd6, 0xa0, 0x29, 0xe0, 0x56, 0x2c, 0x6f, 0x6d, 0x92, 0x2b, 0xf9, 0x3a, 0x4c, 0x9b, 0x6e, 0x37, - 0x70, 0xda, 0xbb, 0x35, 0x76, 0xc3, 0xa4, 0xbb, 0xfc, 0x40, 0x8a, 0xe2, 0x22, 0xc7, 0x4a, 0x85, - 0xad, 0x15, 0x07, 0x5a, 0xbe, 0x80, 0x6a, 0x27, 0x82, 0x4e, 0x40, 0xbe, 0x06, 0x53, 0x3c, 0xcc, - 0x5e, 0x58, 0xc1, 0x98, 0x96, 0x73, 0x4f, 0x2f, 0x7c, 0x70, 0x5d, 0x98, 0x6f, 0x23, 0x34, 0xad, - 0x82, 0x18, 0x37, 0xf2, 0x15, 0xd1, 0x59, 0xeb, 0x4e, 0x7b, 0x37, 0x9c, 0xc6, 0x80, 0x3d, 0xff, - 0x5a, 0xd4, 0x25, 0x1d, 0xf6, 0xb9, 0x72, 0x1a, 0xf7, 0xf0, 0x45, 0x49, 0xf2, 0x21, 0x01, 0x9c, - 0x2f, 0xf9, 0xbe, 0xe3, 0x07, 0xc2, 0x51, 0x7d, 0xf9, 0x31, 0xad, 0x77, 0x19, 0xf2, 0x96, 0xeb, - 0xed, 0x53, 0x8f, 0x7b, 0x43, 0x0e, 0x2f, 0x5d, 0x3d, 0x3a, 0x2c, 0xbe, 0x6c, 0x23, 0xa2, 0x25, - 0x7c, 0xdb, 0x2d, 0x2a, 0x51, 0xad, 0x47, 0x1c, 0x57, 0x69, 0x43, 0x7f, 0xa6, 0xe4, 0x6b, 0x70, - 0xba, 0x6c, 0xfb, 0xb4, 0xda, 0xf6, 0x69, 0xdb, 0x77, 0x02, 0xe7, 0x21, 0x15, 0x9d, 0x8a, 0x87, - 0x5f, 0x9e, 0x07, 0xc4, 0xae, 0xdb, 0x3e, 0x5b, 0x98, 0x21, 0x8a, 0x25, 0x06, 0x45, 0x8d, 0xb7, - 0x9d, 0xce, 0x85, 0x98, 0x30, 0x55, 0xab, 0xad, 0x54, 0x1c, 0x3b, 0x5c, 0x57, 0x93, 0xd8, 0x5f, - 0x2f, 0xe3, 0xe3, 0x92, 0xbf, 0x67, 0x35, 0x1c, 0x3b, 0x5c, 0x50, 0x3d, 0x3a, 0x2b, 0xc6, 0xc1, - 0x38, 0xcc, 0x40, 0x21, 0x3e, 0x94, 0xe4, 0xcb, 0x30, 0xc6, 0x1d, 0x39, 0xa8, 0xbf, 0x27, 0xf4, - 0x2f, 0xd2, 0x2f, 0x20, 0x84, 0xeb, 0x44, 0x22, 0x3e, 0x05, 0x77, 0x13, 0xa1, 0xaa, 0xf9, 0x28, - 0xc6, 0xa7, 0x90, 0x44, 0xa4, 0x01, 0x13, 0x7c, 0xb4, 0x28, 0xc6, 0x74, 0x17, 0x8a, 0xc3, 0xe7, - 0xd5, 0xd5, 0x21, 0x8a, 0x62, 0xfc, 0xb9, 0xd1, 0x34, 0x9f, 0x13, 0x1c, 0x41, 0xab, 0x42, 0xe3, - 0xba, 0x04, 0x90, 0x97, 0x84, 0xc6, 0x59, 0x38, 0xd3, 0xe3, 0x9b, 0x8d, 0x87, 0xa8, 0x73, 0xee, - 0x51, 0x23, 0xf9, 0x32, 0xcc, 0x21, 0x61, 0xd9, 0x6d, 0xb7, 0x69, 0x3d, 0xc0, 0xed, 0x48, 0xbe, - 0xff, 0xe6, 0xb8, 0xe9, 0x27, 0x6f, 0x6f, 0x3d, 0x44, 0xb0, 0xe2, 0xcf, 0xc0, 0xa9, 0x1c, 0x8c, - 0x5f, 0xcc, 0xc2, 0xbc, 0xd8, 0xe1, 0x4c, 0x5a, 0x77, 0x51, 0xfb, 0xf8, 0x94, 0x9f, 0xa8, 0xcb, - 0xda, 0x89, 0x7a, 0x31, 0x0c, 0x33, 0x9a, 0xd6, 0xc8, 0x3e, 0x07, 0xea, 0xaf, 0x66, 0xe0, 0xd9, - 0x7e, 0x44, 0xa1, 0x56, 0x31, 0x93, 0xa6, 0x55, 0x24, 0x1d, 0x98, 0xc5, 0x01, 0x2d, 0xef, 0xd1, - 0xfa, 0xbe, 0xbf, 0xe2, 0xfa, 0x01, 0xfa, 0x27, 0x67, 0x7b, 0x58, 0x70, 0xbd, 0x9a, 0x6a, 0xc1, - 0x75, 0x9a, 0xcf, 0xb2, 0x3a, 0xf2, 0xe0, 0x51, 0xf6, 0xf7, 0xe9, 0x81, 0x6f, 0xa6, 0xb1, 0xc6, - 0x0c, 0xc5, 0xa5, 0x6e, 0xb0, 0xb7, 0xee, 0xd1, 0x1d, 0xea, 0xd1, 0x76, 0x9d, 0x7e, 0xc6, 0xfc, - 0x4c, 0xf5, 0xc6, 0x0d, 0xa4, 0xc1, 0xf8, 0xf6, 0x14, 0xcc, 0xa5, 0x91, 0xb1, 0x7e, 0x51, 0x2e, - 0xcd, 0x79, 0x19, 0x18, 0x40, 0x5c, 0x95, 0xbf, 0x95, 0x81, 0x89, 0x1a, 0xad, 0xbb, 0xed, 0xc6, - 0x2d, 0x34, 0xb1, 0x15, 0xbd, 0x63, 0x73, 0xa1, 0x81, 0xc1, 0xad, 0x9d, 0x98, 0xed, 0xed, 0xf7, - 0x0e, 0x8b, 0xef, 0x0d, 0x76, 0x57, 0xad, 0xbb, 0xa8, 0xfb, 0x0c, 0x30, 0x41, 0x5e, 0x58, 0x05, - 0xff, 0x1a, 0x53, 0xab, 0x96, 0x2c, 0xc1, 0xa4, 0x58, 0xb0, 0xae, 0x9a, 0x05, 0x80, 0xc7, 0x62, - 0x95, 0x05, 0x89, 0xe7, 0x53, 0x8d, 0x84, 0xdc, 0x80, 0xdc, 0xe6, 0xe2, 0x2d, 0x31, 0x0a, 0x32, - 0xc9, 0xe0, 0xe6, 0xe2, 0x2d, 0x54, 0x88, 0xb1, 0x4b, 0xc6, 0x64, 0x77, 0x51, 0x33, 0x5e, 0xdd, - 0x5c, 0xbc, 0x45, 0xfe, 0x32, 0x9c, 0xaa, 0x38, 0xbe, 0xa8, 0x82, 0xfb, 0x3c, 0x37, 0x30, 0x08, - 0xc8, 0x48, 0x8f, 0xf9, 0xfb, 0x85, 0xd4, 0xf9, 0xfb, 0x7c, 0x23, 0x64, 0x62, 0x71, 0x87, 0xea, - 0x46, 0x3c, 0xdb, 0x41, 0x7a, 0x3d, 0xe4, 0x23, 0x98, 0xc2, 0xb7, 0x31, 0x74, 0x03, 0xc7, 0x34, - 0x5b, 0xa3, 0x3d, 0x6a, 0xfe, 0x5c, 0x6a, 0xcd, 0x0b, 0x3c, 0x42, 0x1e, 0x3a, 0x93, 0x63, 0x4a, - 0x2e, 0xed, 0xde, 0xaf, 0x71, 0x26, 0x77, 0x60, 0x5a, 0x08, 0x60, 0xf7, 0x77, 0x36, 0xf6, 0x68, - 0xc5, 0x3e, 0x10, 0x76, 0xa7, 0x78, 0xa7, 0x13, 0x52, 0x9b, 0xe5, 0xee, 0x58, 0xc1, 0x1e, 0xb5, - 0x1a, 0xb6, 0x26, 0xaa, 0xc4, 0x08, 0xc9, 0x37, 0x61, 0x7c, 0xd5, 0xad, 0x33, 0xd9, 0x1b, 0xf7, - 0x06, 0x6e, 0x8a, 0xfa, 0x01, 0x26, 0xb9, 0xe7, 0xe0, 0x98, 0x40, 0xf5, 0xbd, 0xc3, 0xe2, 0x9b, - 0x27, 0x9d, 0x36, 0x4a, 0x05, 0xa6, 0x5a, 0x1b, 0x29, 0x43, 0x7e, 0x8b, 0x6e, 0xb3, 0xd6, 0xc6, - 0x13, 0x60, 0x4b, 0xb0, 0x30, 0x52, 0x17, 0xbf, 0x34, 0x23, 0x75, 0x01, 0x23, 0x1e, 0xcc, 0x60, - 0xff, 0xac, 0xdb, 0xbe, 0xff, 0xc8, 0xf5, 0x1a, 0x98, 0xe9, 0xb0, 0x97, 0x95, 0xeb, 0x62, 0x6a, - 0xe7, 0x3f, 0xcb, 0x3b, 0xbf, 0xa3, 0x70, 0x50, 0x45, 0xc8, 0x04, 0x7b, 0xf2, 0x75, 0x98, 0x12, - 0xd1, 0xc6, 0xee, 0xdd, 0x2a, 0xe1, 0x4a, 0x98, 0xd0, 0xe2, 0xa5, 0xe8, 0x85, 0xf2, 0xbd, 0x0a, - 0x61, 0x52, 0x07, 0x65, 0xb5, 0x76, 0x6c, 0xfd, 0xe1, 0x59, 0x25, 0x21, 0xeb, 0x30, 0x5e, 0xa1, - 0x0f, 0x9d, 0x3a, 0xc5, 0x98, 0x0e, 0xc2, 0x05, 0x32, 0xcc, 0xe0, 0x1b, 0x95, 0x70, 0x6d, 0x4c, - 0x03, 0x01, 0x3c, 0x42, 0x84, 0xee, 0xbe, 0x12, 0x22, 0x92, 0x9b, 0x90, 0xab, 0x56, 0xd6, 0x85, - 0x07, 0xe4, 0x4c, 0x18, 0xd3, 0x6f, 0x5d, 0xe6, 0x3b, 0x45, 0xbb, 0x70, 0xa7, 0xa1, 0xf9, 0x4f, - 0x56, 0x2b, 0xeb, 0x64, 0x07, 0x26, 0xb1, 0x03, 0x56, 0xa8, 0xcd, 0xfb, 0x76, 0xba, 0x47, 0xdf, - 0x5e, 0x4d, 0xed, 0xdb, 0x79, 0xde, 0xb7, 0x7b, 0x82, 0x5a, 0x4b, 0xe0, 0xa8, 0xb2, 0x65, 0x42, - 0xad, 0x48, 0x2a, 0x2b, 0xd3, 0x0e, 0x6e, 0xac, 0xa2, 0xdd, 0xab, 0x10, 0x6a, 0x65, 0x0e, 0xda, - 0x30, 0x0f, 0x62, 0x4f, 0x07, 0xeb, 0x24, 0x1f, 0xf2, 0x25, 0x18, 0xba, 0xbf, 0x1f, 0xd8, 0xc2, - 0xd7, 0x51, 0xf6, 0x23, 0x03, 0xc9, 0xe6, 0xa3, 0x1e, 0xd2, 0xdd, 0xd7, 0xa2, 0x44, 0x23, 0x0d, - 0x1b, 0x8a, 0x15, 0xdb, 0x6b, 0x3c, 0xb2, 0x3d, 0x0c, 0xac, 0x33, 0xab, 0xb1, 0x50, 0x4a, 0xf8, - 0x50, 0xec, 0x09, 0x40, 0xec, 0x81, 0x53, 0x65, 0x41, 0xbe, 0x0f, 0xce, 0xfa, 0xce, 0x6e, 0xdb, - 0x0e, 0xba, 0x1e, 0xb5, 0xec, 0xe6, 0xae, 0xeb, 0x39, 0xc1, 0x5e, 0xcb, 0xf2, 0xbb, 0x4e, 0x40, - 0xd1, 0xe9, 0x70, 0x2a, 0x94, 0x19, 0x6b, 0x12, 0xaf, 0x24, 0xd1, 0x6a, 0x0c, 0xcb, 0x3c, 0xe3, - 0xa7, 0x17, 0x90, 0xaf, 0xc0, 0xa4, 0xba, 0x25, 0xfb, 0xf3, 0xa7, 0x2e, 0xe4, 0x2e, 0x4f, 0x85, - 0x57, 0x8f, 0xf8, 0x16, 0x2e, 0x73, 0x9f, 0x28, 0x67, 0x84, 0xaf, 0xe7, 0x3e, 0x51, 0x78, 0x11, - 0x13, 0xce, 0xf8, 0x5c, 0xbf, 0xd1, 0x6d, 0x3b, 0x8f, 0x31, 0xbf, 0xad, 0xb0, 0x8f, 0x9e, 0x3f, - 0xad, 0x1d, 0x7d, 0x35, 0xc4, 0xda, 0x5c, 0xab, 0x7e, 0x79, 0xd3, 0xa7, 0x9e, 0x30, 0x93, 0x9e, - 0xe3, 0xb4, 0x9b, 0x6d, 0xe7, 0x71, 0x04, 0x0d, 0x13, 0xc5, 0x93, 0xc2, 0xac, 0x39, 0x23, 0x56, - 0x81, 0x18, 0xb9, 0x7b, 0xb7, 0x4a, 0xe6, 0xe8, 0x7a, 0xf5, 0x41, 0xad, 0xe9, 0x06, 0xc6, 0x1e, - 0xcc, 0xa5, 0x71, 0x25, 0xf3, 0x30, 0x2a, 0xb2, 0xac, 0xe1, 0xe1, 0x98, 0x37, 0xe5, 0x4f, 0x72, - 0x0e, 0xc6, 0x76, 0x1c, 0xcf, 0x0f, 0xac, 0xae, 0xc3, 0xe5, 0x85, 0x61, 0x33, 0x8f, 0x80, 0x4d, - 0xa7, 0x41, 0xce, 0x42, 0x1e, 0xdf, 0xb8, 0x58, 0x59, 0x0e, 0xcb, 0x46, 0xd9, 0xef, 0x4d, 0xa7, - 0x61, 0xfc, 0x57, 0x19, 0x3c, 0x82, 0xc8, 0xcb, 0x18, 0xb8, 0x36, 0xb4, 0x3f, 0x41, 0xfd, 0xb3, - 0xdd, 0x89, 0x65, 0x2d, 0xe3, 0x28, 0xe4, 0x55, 0x18, 0xb9, 0x65, 0xd7, 0x69, 0x68, 0xd6, 0x80, - 0xc8, 0x3b, 0x08, 0x51, 0x95, 0xd5, 0x1c, 0x87, 0xc9, 0xc7, 0x7c, 0x69, 0x96, 0x82, 0x80, 0xfa, - 0x7c, 0xff, 0x2c, 0x97, 0xa4, 0x29, 0x03, 0xca, 0xc7, 0x62, 0x49, 0xdb, 0x11, 0x42, 0xcc, 0xcd, - 0x2d, 0x95, 0x83, 0xf1, 0x47, 0x99, 0x68, 0x4f, 0x25, 0x2f, 0xc1, 0x90, 0xb9, 0x1e, 0x7e, 0x3f, - 0x0f, 0xf5, 0x13, 0xfb, 0x7c, 0x44, 0x20, 0x5f, 0x81, 0x53, 0x0a, 0x9f, 0x84, 0xcf, 0xdd, 0x8b, - 0x18, 0x89, 0x46, 0xf9, 0x92, 0x74, 0xc7, 0xbb, 0x74, 0x1e, 0x78, 0x19, 0x88, 0x0a, 0x2a, 0xb4, - 0xed, 0x70, 0xde, 0x4a, 0x63, 0x55, 0xde, 0x0d, 0x44, 0x88, 0x37, 0x36, 0x8d, 0x03, 0x0f, 0x44, - 0x63, 0xfc, 0x46, 0x46, 0xdb, 0x2b, 0xc9, 0x25, 0x4d, 0xce, 0xc5, 0x75, 0x1d, 0x53, 0x0a, 0x70, - 0x89, 0xf7, 0x0d, 0x80, 0x52, 0x37, 0x70, 0x97, 0xdb, 0x9e, 0xdb, 0xe4, 0x5a, 0x20, 0x91, 0xb8, - 0x0f, 0x75, 0xdb, 0x14, 0xc1, 0x5a, 0x88, 0x8b, 0x10, 0x39, 0xd5, 0x3d, 0x31, 0xf7, 0x71, 0xdd, - 0x13, 0x8d, 0x5f, 0xc8, 0x6a, 0x3b, 0x0c, 0x93, 0x72, 0xc5, 0xa4, 0x57, 0x6d, 0xae, 0x3b, 0xce, - 0x43, 0xcb, 0x6f, 0xba, 0x5a, 0xfc, 0x3a, 0x81, 0x46, 0xfe, 0x4a, 0x06, 0x4e, 0x73, 0x3f, 0xbf, - 0xb5, 0x6e, 0x6b, 0x9b, 0x7a, 0x0f, 0xec, 0xa6, 0xd3, 0x88, 0xc2, 0x82, 0x47, 0x46, 0xfd, 0x4a, - 0x35, 0xe9, 0xf8, 0xfc, 0xa2, 0xcd, 0xfd, 0x0e, 0xad, 0x36, 0x16, 0x5a, 0x0f, 0xc3, 0x52, 0xf5, - 0xa2, 0x9d, 0x4e, 0x4f, 0xaa, 0x30, 0xbe, 0xee, 0xb4, 0x31, 0xa9, 0x65, 0x14, 0x19, 0xe3, 0x25, - 0xee, 0xb6, 0xcb, 0xa6, 0x70, 0x7d, 0x8f, 0xf6, 0xd9, 0xba, 0x55, 0x5a, 0xe3, 0xd7, 0x32, 0xf0, - 0xfc, 0xb1, 0x1f, 0x4c, 0xae, 0xc1, 0xe8, 0xb2, 0xba, 0xfe, 0xb9, 0x25, 0x50, 0x32, 0xf1, 0xa2, - 0xc4, 0x22, 0x5f, 0x85, 0x53, 0x2a, 0xab, 0x0d, 0xcf, 0x76, 0x54, 0x0f, 0xe5, 0x94, 0x0e, 0x08, - 0x18, 0x4a, 0x5c, 0x6c, 0x4d, 0x67, 0x62, 0xfc, 0x3f, 0x19, 0x18, 0x0b, 0x5d, 0x9c, 0x9e, 0xd2, - 0xeb, 0xcc, 0x4d, 0xed, 0x3a, 0x23, 0xf3, 0x2b, 0x84, 0xad, 0xe2, 0xa6, 0x47, 0x29, 0x57, 0xd0, - 0x69, 0xc5, 0x21, 0x0c, 0x01, 0x3f, 0x96, 0x85, 0x71, 0xb6, 0x55, 0xf3, 0x37, 0xed, 0xcf, 0x56, - 0x94, 0xf9, 0xb0, 0x5d, 0x03, 0xc5, 0x01, 0xff, 0x83, 0x0c, 0xbe, 0x75, 0xa8, 0x14, 0xac, 0x37, - 0x94, 0xec, 0xf8, 0xd8, 0x1b, 0x98, 0x17, 0x1f, 0xa1, 0x3c, 0x2a, 0xf2, 0xaa, 0xe8, 0x09, 0x11, - 0x15, 0xb9, 0x69, 0x32, 0x18, 0x79, 0x0f, 0x86, 0x37, 0x51, 0x73, 0xab, 0x47, 0xe9, 0x0b, 0xf9, - 0x63, 0x21, 0xdf, 0xef, 0xbb, 0xbe, 0x1e, 0x32, 0x9b, 0x13, 0x92, 0x1a, 0x8c, 0x96, 0x3d, 0x6a, - 0x07, 0xb4, 0x21, 0x3a, 0x64, 0xa0, 0x18, 0x53, 0x75, 0x4e, 0x12, 0x8f, 0x31, 0x25, 0x38, 0xb1, - 0x7d, 0x8c, 0x44, 0x6d, 0x44, 0xab, 0x1d, 0xff, 0xa9, 0x1d, 0xf4, 0x77, 0xb5, 0x41, 0x3f, 0x9f, - 0x18, 0x74, 0xde, 0xbc, 0x81, 0xc6, 0xfe, 0x37, 0x33, 0x70, 0x3a, 0x9d, 0x90, 0x5c, 0x84, 0x91, - 0xfb, 0x1b, 0xeb, 0x91, 0xa5, 0x1c, 0x36, 0xc5, 0xed, 0xa0, 0xda, 0xc4, 0x14, 0x45, 0xe4, 0x35, - 0x18, 0x79, 0xdf, 0x2c, 0x47, 0x06, 0x61, 0xb8, 0xc1, 0x7d, 0x83, 0x49, 0x5e, 0xda, 0xa9, 0x26, - 0x90, 0xd4, 0xb1, 0xcd, 0x3d, 0xb1, 0xb1, 0xfd, 0xe9, 0x2c, 0x4c, 0x97, 0xea, 0x75, 0xea, 0xfb, - 0x4c, 0x44, 0xa3, 0x7e, 0xf0, 0xd4, 0x0e, 0x6c, 0x7a, 0x08, 0x47, 0xad, 0x6d, 0x03, 0x8d, 0xea, - 0x6f, 0x65, 0xe0, 0x94, 0xa4, 0x7a, 0xe8, 0xd0, 0x47, 0x1b, 0x7b, 0x1e, 0xf5, 0xf7, 0xdc, 0x66, - 0x63, 0xe0, 0x5c, 0xa5, 0x4c, 0x66, 0xc4, 0xcc, 0x57, 0xaa, 0x81, 0xc3, 0x0e, 0x42, 0x34, 0x99, - 0x91, 0x67, 0xc7, 0xba, 0x06, 0xa3, 0xa5, 0x4e, 0xc7, 0x73, 0x1f, 0xf2, 0x65, 0x2f, 0x82, 0xe2, - 0xdb, 0x1c, 0xa4, 0x45, 0xd5, 0xe2, 0x20, 0xf6, 0x19, 0x15, 0xda, 0x3e, 0x50, 0xcd, 0xd3, 0x1a, - 0xb4, 0xad, 0x5e, 0x4a, 0xb0, 0xdc, 0xa8, 0x01, 0x59, 0xf7, 0xdc, 0x96, 0x1b, 0xd0, 0x06, 0x6f, - 0x0f, 0x06, 0x23, 0x3b, 0x36, 0x5c, 0xef, 0x86, 0x13, 0x34, 0xb5, 0x70, 0xbd, 0x01, 0x03, 0x98, - 0x1c, 0xce, 0xce, 0xee, 0xf3, 0x5a, 0x9f, 0x56, 0xbc, 0x03, 0xb3, 0xdb, 0x5e, 0x6e, 0x7b, 0x4e, - 0x7d, 0x0f, 0xfd, 0x66, 0xd7, 0x00, 0x4c, 0x6a, 0xfb, 0x6e, 0x5b, 0x11, 0xd6, 0xae, 0xf2, 0x4c, - 0xad, 0x0c, 0x9a, 0xd4, 0x3b, 0xcc, 0x08, 0x4e, 0x11, 0x95, 0xa9, 0x70, 0x20, 0x25, 0x98, 0xe4, - 0xbf, 0x58, 0x63, 0x3a, 0xa1, 0x20, 0x7e, 0x8e, 0x7b, 0xb1, 0x22, 0xcb, 0x0e, 0x96, 0xe8, 0x11, - 0x2e, 0x14, 0x0a, 0xe3, 0xff, 0x1c, 0x86, 0x09, 0x75, 0x48, 0x89, 0xc1, 0xd3, 0x0e, 0xba, 0x9e, - 0x1a, 0x13, 0xd0, 0x46, 0x88, 0x29, 0x4a, 0xa2, 0x80, 0x9a, 0xd9, 0x63, 0x03, 0x6a, 0x6e, 0xc1, - 0xe4, 0xba, 0xe7, 0x62, 0xca, 0x01, 0x7c, 0x6d, 0x16, 0xfb, 0xf7, 0xac, 0xa2, 0x35, 0x60, 0xb3, - 0x0f, 0xdf, 0xb3, 0xf1, 0x5e, 0xd6, 0x11, 0xd8, 0x16, 0x13, 0x7d, 0x35, 0x9d, 0x99, 0xc6, 0x87, - 0x9b, 0xca, 0xb0, 0x96, 0xa8, 0x89, 0x74, 0x78, 0xa3, 0x75, 0x53, 0x19, 0x06, 0x51, 0x37, 0x88, - 0xe1, 0x27, 0xb5, 0x41, 0x90, 0x5f, 0xc8, 0xc0, 0x78, 0xa9, 0xdd, 0x16, 0x81, 0x3a, 0x8f, 0x09, - 0x2b, 0xf6, 0x55, 0x61, 0x2d, 0xf3, 0xe6, 0xc7, 0xb2, 0x96, 0x41, 0x61, 0xcb, 0x47, 0x49, 0x3d, - 0xaa, 0x50, 0x0b, 0xb6, 0x13, 0x81, 0xc9, 0x9b, 0x50, 0x08, 0x57, 0x66, 0xb5, 0xdd, 0xa0, 0x8f, - 0x29, 0xcf, 0x3a, 0x3f, 0x29, 0xf2, 0x18, 0xa9, 0x92, 0x79, 0x1c, 0x91, 0x6c, 0x00, 0xd8, 0xe1, - 0x92, 0x10, 0x8f, 0x78, 0x67, 0xa3, 0x07, 0x97, 0xd8, 0x9a, 0x11, 0xb7, 0x07, 0xfc, 0x8d, 0x0f, - 0x92, 0xea, 0xed, 0x21, 0xe2, 0x43, 0x5a, 0x30, 0x5d, 0xf2, 0xfd, 0x6e, 0x8b, 0xd6, 0x02, 0xdb, - 0x0b, 0x30, 0x59, 0x21, 0x0c, 0x6e, 0x06, 0x6a, 0x23, 0x29, 0x9b, 0x11, 0x5e, 0x60, 0xa5, 0x64, - 0x2e, 0x8c, 0xf3, 0xe6, 0x59, 0xa3, 0xcc, 0x33, 0xc9, 0xef, 0xe5, 0x2b, 0xf5, 0xa7, 0x33, 0x70, - 0x5a, 0x9d, 0xf4, 0xb5, 0xee, 0xb6, 0x48, 0xd5, 0x40, 0xae, 0xc2, 0x98, 0x98, 0x93, 0xe1, 0x25, - 0x32, 0x99, 0x73, 0x31, 0x42, 0x21, 0xcb, 0x6c, 0x1a, 0x32, 0x1e, 0xe2, 0xd6, 0x31, 0x1b, 0xdb, - 0x5c, 0x59, 0xd1, 0xd2, 0xbc, 0x98, 0x50, 0x05, 0x0f, 0x7f, 0xeb, 0xf3, 0x93, 0x41, 0x8c, 0x77, - 0x60, 0x46, 0x1f, 0x89, 0x1a, 0x0d, 0xc8, 0x15, 0x18, 0x95, 0xc3, 0x97, 0x49, 0x1f, 0x3e, 0x59, - 0x6e, 0x6c, 0x01, 0x49, 0xd0, 0xfb, 0x68, 0xd6, 0xc6, 0xee, 0xe7, 0xdc, 0xec, 0x52, 0x3e, 0x2a, - 0x27, 0x10, 0x97, 0x66, 0xc5, 0xf7, 0x8d, 0x6b, 0x8e, 0x8d, 0x98, 0xb6, 0xe2, 0xb7, 0x0a, 0x30, - 0x9b, 0x72, 0x50, 0x1c, 0x23, 0xc8, 0x15, 0xf5, 0x0d, 0x62, 0x2c, 0x8c, 0x4a, 0x28, 0xb7, 0x85, - 0x77, 0x60, 0xf8, 0xd8, 0xed, 0x80, 0xbb, 0xb5, 0xc6, 0x76, 0x01, 0x4e, 0xf6, 0xa9, 0x08, 0x73, - 0x6a, 0x14, 0xd2, 0xe1, 0x27, 0x16, 0x85, 0x14, 0xc3, 0x10, 0x29, 0x9b, 0xb8, 0x1e, 0x1a, 0x09, - 0x0b, 0xac, 0xc4, 0xb6, 0xa5, 0x93, 0x70, 0x1e, 0xbe, 0xdb, 0x7c, 0x48, 0x05, 0x8f, 0x51, 0x95, - 0x07, 0x16, 0xa4, 0xf2, 0x50, 0x48, 0xc8, 0x7f, 0x8e, 0x79, 0xf3, 0x11, 0xa2, 0xee, 0x59, 0xf9, - 0x7e, 0x7b, 0x56, 0xe3, 0xc9, 0xec, 0x59, 0xe7, 0xe5, 0x37, 0xa6, 0xef, 0x5d, 0x29, 0x9f, 0x45, - 0xfe, 0x5e, 0x06, 0x66, 0x78, 0xf4, 0x4a, 0xf5, 0x63, 0xfb, 0x46, 0x24, 0xac, 0x3f, 0x99, 0x8f, - 0x7d, 0x56, 0x24, 0x5c, 0x4e, 0xff, 0xd6, 0xe4, 0x47, 0x91, 0xef, 0x03, 0x08, 0x57, 0x14, 0x4f, - 0xdd, 0x31, 0xbe, 0xf8, 0x6c, 0xca, 0x2e, 0x10, 0x22, 0x45, 0x29, 0x13, 0x83, 0x90, 0x4e, 0xdd, - 0x36, 0x23, 0x6e, 0xe4, 0x2f, 0xc3, 0x1c, 0x5b, 0x2f, 0x21, 0x44, 0x04, 0xee, 0x9d, 0x1f, 0xc7, - 0x5a, 0x3e, 0xdf, 0x5b, 0x90, 0xbb, 0x9a, 0x46, 0xc6, 0x13, 0xbd, 0x84, 0x46, 0xd6, 0x5e, 0xa0, - 0x86, 0xe5, 0x4b, 0xad, 0x08, 0xe3, 0x61, 0xe3, 0xd7, 0xf3, 0xb4, 0x86, 0x3d, 0xf6, 0xb7, 0xb3, - 0x72, 0x2d, 0xf0, 0xfd, 0x2d, 0xe6, 0x8c, 0x84, 0x20, 0xf2, 0x3e, 0x90, 0x30, 0xec, 0x23, 0x87, - 0x51, 0x99, 0xf2, 0x90, 0x3f, 0x16, 0x44, 0xe1, 0x23, 0x3d, 0x59, 0xac, 0x4e, 0x92, 0x24, 0x31, - 0xa1, 0x30, 0x27, 0x1a, 0xcd, 0xa0, 0x32, 0xa9, 0xbd, 0x3f, 0x3f, 0xa5, 0x85, 0x45, 0x8e, 0x4a, - 0x96, 0x9e, 0x13, 0xdf, 0x79, 0x5a, 0xc9, 0x8c, 0xaf, 0xa9, 0xdc, 0xd2, 0xd8, 0x91, 0x9b, 0x30, - 0x86, 0xe1, 0x4b, 0x56, 0xa4, 0xb1, 0x9e, 0x30, 0x1c, 0xc2, 0x40, 0x27, 0xd6, 0x9e, 0x6e, 0x72, - 0x17, 0xa1, 0xb2, 0x3b, 0x0c, 0x97, 0x00, 0x51, 0xa5, 0x2f, 0x94, 0x34, 0x0d, 0xef, 0xc0, 0xf2, - 0xba, 0x7a, 0x68, 0x1c, 0x44, 0x22, 0x5f, 0x87, 0xf1, 0x7b, 0xf6, 0x63, 0xa9, 0x16, 0x12, 0x6a, - 0xfb, 0xe3, 0x1c, 0x98, 0xb0, 0x35, 0x2d, 0xfb, 0xb1, 0xd5, 0xe8, 0xc6, 0xd3, 0xcc, 0x70, 0x07, - 0x26, 0x85, 0x25, 0xf9, 0x10, 0x40, 0x79, 0x67, 0x20, 0xc7, 0x56, 0xf0, 0xbc, 0x0c, 0xf6, 0x9d, - 0xfa, 0xfe, 0x80, 0xfc, 0x15, 0x86, 0x31, 0xc9, 0x61, 0xee, 0xd3, 0x93, 0x1c, 0x4e, 0x7d, 0x7a, - 0x92, 0x03, 0x7f, 0xe6, 0xe2, 0x63, 0x8f, 0x3b, 0xf8, 0x81, 0xd0, 0xf2, 0xf7, 0xab, 0xed, 0x59, - 0x69, 0x0a, 0x8a, 0x47, 0xc1, 0x41, 0xac, 0x8a, 0x18, 0x3f, 0xe2, 0x41, 0x21, 0x7e, 0x31, 0x98, - 0x3f, 0xa3, 0x59, 0x16, 0xf6, 0xbd, 0x44, 0x70, 0x75, 0xab, 0x98, 0x46, 0x16, 0x0d, 0xe1, 0xaa, - 0x50, 0x17, 0xa7, 0x59, 0xd8, 0x86, 0xb3, 0x3d, 0x37, 0x84, 0x94, 0xdc, 0x36, 0xd7, 0xf4, 0xdc, - 0x36, 0x67, 0x7b, 0x09, 0x0e, 0xbe, 0x9e, 0xaf, 0x73, 0xb6, 0x30, 0xd7, 0x5b, 0xe6, 0xfa, 0x6e, - 0x36, 0x26, 0x48, 0x88, 0x3b, 0x1e, 0xcf, 0x6e, 0xdd, 0x4b, 0xd2, 0xca, 0x56, 0x2b, 0xec, 0x52, - 0x87, 0xa2, 0x86, 0x92, 0x5d, 0x8c, 0x89, 0x1a, 0xaa, 0xa8, 0x82, 0x42, 0xc7, 0x27, 0x95, 0x29, - 0xde, 0x82, 0xa9, 0x1a, 0xb5, 0xbd, 0xfa, 0xde, 0x5d, 0x7a, 0xf0, 0xc8, 0xf5, 0x1a, 0x3c, 0x0b, - 0xae, 0xb8, 0x59, 0xf8, 0x58, 0xa2, 0x87, 0x6c, 0x50, 0x71, 0x49, 0x45, 0xc6, 0xe4, 0x18, 0xc6, - 0xda, 0xcf, 0xa6, 0xee, 0xcd, 0x0c, 0xa1, 0x5f, 0xb8, 0x0e, 0xf2, 0x7a, 0x28, 0x7e, 0x52, 0x4f, - 0xcd, 0xda, 0xe9, 0x49, 0x60, 0x8a, 0x14, 0x4a, 0x3d, 0xe3, 0xf7, 0x72, 0x40, 0x78, 0x4d, 0x65, - 0xbb, 0x63, 0x63, 0x14, 0x1c, 0x07, 0x43, 0xdd, 0x16, 0x04, 0x8e, 0xbd, 0xdd, 0xa4, 0x6a, 0x9c, - 0x68, 0x61, 0xf2, 0x1d, 0x96, 0x59, 0xf1, 0xeb, 0x5b, 0x82, 0xb0, 0xc7, 0x06, 0x9e, 0xfd, 0x24, - 0x1b, 0xf8, 0xd7, 0xe1, 0x5c, 0xa9, 0xd3, 0x69, 0x3a, 0xf5, 0xb0, 0x96, 0x5b, 0xae, 0x27, 0x97, - 0x8b, 0x16, 0x0b, 0xc1, 0x0e, 0xd1, 0x12, 0x5f, 0xda, 0x8f, 0x85, 0x22, 0x7d, 0xf1, 0x0b, 0xaf, - 0x1a, 0xaf, 0x4b, 0x4a, 0x5f, 0x69, 0x57, 0x64, 0x85, 0x44, 0xf2, 0x70, 0x3c, 0x29, 0x7d, 0x61, - 0x56, 0xec, 0x88, 0x87, 0xe3, 0xd1, 0x1e, 0x12, 0x5c, 0x48, 0x42, 0xde, 0x82, 0xf1, 0x52, 0x37, - 0x70, 0x05, 0x63, 0xe1, 0xab, 0x10, 0x79, 0x15, 0x88, 0x4f, 0xd1, 0x2e, 0x74, 0x11, 0xba, 0xf1, - 0x87, 0x39, 0x38, 0x9b, 0x1c, 0x5e, 0x51, 0x1a, 0xae, 0x8f, 0xcc, 0x31, 0xeb, 0x23, 0x6d, 0x36, - 0x64, 0xa3, 0x7c, 0x85, 0x4f, 0x62, 0x36, 0xf0, 0x08, 0x3c, 0x1f, 0x73, 0x36, 0xd4, 0x60, 0x5c, - 0x3d, 0xc5, 0x87, 0x3e, 0xee, 0x29, 0xae, 0x72, 0x21, 0x57, 0x60, 0x98, 0x87, 0x29, 0x1b, 0x8e, - 0x1e, 0x04, 0xe3, 0x11, 0xca, 0x38, 0x06, 0xf9, 0x0f, 0xe0, 0x02, 0xdf, 0x93, 0xe2, 0x8d, 0x5d, - 0x3a, 0x90, 0x1c, 0xc5, 0xc0, 0x2d, 0x1e, 0x1d, 0x16, 0xaf, 0x72, 0xad, 0x95, 0x95, 0xe8, 0x36, - 0x6b, 0xfb, 0xc0, 0x92, 0x5f, 0xa6, 0x54, 0x72, 0x2c, 0x6f, 0xa3, 0x0c, 0x67, 0x45, 0x69, 0x14, - 0xcc, 0x46, 0x16, 0xb2, 0x41, 0xde, 0x8f, 0x14, 0x8f, 0x38, 0xc8, 0x31, 0x9d, 0x22, 0x96, 0x63, - 0x62, 0xa0, 0xa8, 0xfd, 0xe4, 0xb5, 0x34, 0x4f, 0x30, 0x9e, 0x9c, 0x89, 0x83, 0x75, 0x27, 0x30, - 0xa9, 0xde, 0xcc, 0xa6, 0xaa, 0x37, 0xa5, 0x7e, 0x2c, 0x97, 0xaa, 0x1f, 0xab, 0xc0, 0x74, 0xad, - 0xbb, 0x2d, 0xeb, 0x8e, 0xc7, 0xb1, 0xf0, 0xbb, 0xdb, 0x69, 0xbd, 0x12, 0x27, 0x31, 0x7e, 0x3c, - 0x0b, 0x13, 0xeb, 0xcd, 0xee, 0xae, 0xd3, 0xae, 0xd8, 0x81, 0xfd, 0xd4, 0x6a, 0x5c, 0xdf, 0xd0, - 0x34, 0xae, 0xa1, 0xc3, 0x63, 0xd8, 0xb0, 0x81, 0xd4, 0xad, 0x3f, 0x9f, 0x81, 0xe9, 0x88, 0x84, - 0x1f, 0xd6, 0x2b, 0x30, 0xc4, 0x7e, 0x88, 0x2b, 0xfd, 0x85, 0x04, 0x63, 0xc4, 0xba, 0x1a, 0xfe, - 0x25, 0x74, 0xa0, 0x7a, 0x26, 0x70, 0xe4, 0xb0, 0xf0, 0x05, 0x18, 0x8b, 0xd8, 0x26, 0x65, 0x80, - 0x39, 0x55, 0x06, 0x18, 0x53, 0x13, 0xd9, 0xfd, 0x7a, 0x06, 0x0a, 0xf1, 0x96, 0x90, 0xbb, 0x30, - 0xca, 0x38, 0x39, 0x54, 0x6a, 0x1b, 0x5e, 0xe8, 0xd1, 0xe6, 0xab, 0x02, 0x8d, 0x7f, 0x1e, 0x76, - 0x3e, 0xe5, 0x10, 0x53, 0x72, 0x58, 0x30, 0x61, 0x42, 0xc5, 0x4a, 0xf9, 0xba, 0x57, 0x75, 0x09, - 0xe5, 0x74, 0x7a, 0x3f, 0xa8, 0x5f, 0xfd, 0x4b, 0xda, 0x57, 0x0b, 0xe1, 0xe3, 0x92, 0x36, 0xb9, - 0x52, 0x57, 0x15, 0x4e, 0x9a, 0xc5, 0x28, 0x2d, 0x9d, 0x3a, 0xcf, 0x52, 0x26, 0x74, 0x88, 0x47, - 0x5e, 0x85, 0x11, 0x5e, 0x9f, 0x9a, 0x16, 0xbc, 0x83, 0x10, 0x55, 0xfa, 0xe7, 0x38, 0xc6, 0xdf, - 0xc8, 0xc1, 0xe9, 0xe8, 0xf3, 0x36, 0x3b, 0x0d, 0x3b, 0xa0, 0xeb, 0xb6, 0x67, 0xb7, 0xfc, 0x63, - 0x56, 0xc0, 0xe5, 0xc4, 0xa7, 0x89, 0x08, 0x09, 0x1c, 0xa6, 0x7c, 0x90, 0x11, 0xfb, 0x20, 0xd4, - 0xec, 0xf2, 0x0f, 0x92, 0x9f, 0x41, 0xee, 0x42, 0xae, 0x46, 0x03, 0xb1, 0xf7, 0x5e, 0x4a, 0xf4, - 0xaa, 0xfa, 0x5d, 0x57, 0x6b, 0x34, 0xe0, 0x83, 0xc8, 0x63, 0x70, 0x6a, 0xb1, 0x08, 0x18, 0x17, - 0xb2, 0x05, 0x23, 0xcb, 0x8f, 0x3b, 0xb4, 0x1e, 0x60, 0xe2, 0x25, 0xc5, 0x29, 0x3f, 0x9d, 0x1f, - 0xc7, 0xe5, 0x2c, 0xe7, 0x84, 0x38, 0xad, 0xe7, 0xf6, 0x13, 0xec, 0x16, 0x6e, 0x42, 0x5e, 0x56, - 0x7e, 0x92, 0x99, 0xbb, 0xf0, 0x06, 0x8c, 0x2b, 0x95, 0x9c, 0x68, 0xd2, 0xff, 0x32, 0xdb, 0x57, - 0xdd, 0x26, 0x15, 0x13, 0x67, 0x39, 0x21, 0x2b, 0x2a, 0x39, 0x8d, 0xb9, 0xac, 0x68, 0xed, 0x8b, - 0xa2, 0x3e, 0x42, 0x63, 0x15, 0xa6, 0x6b, 0xfb, 0x4e, 0x27, 0xca, 0xd3, 0xa1, 0x9d, 0xc8, 0x98, - 0x37, 0x55, 0xa8, 0x23, 0xe2, 0x27, 0x72, 0x9c, 0xce, 0xf8, 0x93, 0x0c, 0x8c, 0xb0, 0xbf, 0x1e, - 0xdc, 0x7c, 0x4a, 0xb7, 0xcc, 0x1b, 0xda, 0x96, 0x39, 0xa3, 0xe4, 0xdd, 0xc2, 0x8d, 0xe3, 0xe6, - 0x31, 0x9b, 0xe5, 0xa1, 0x18, 0x20, 0x8e, 0x4c, 0x6e, 0xc3, 0xa8, 0x30, 0x73, 0x13, 0x1e, 0x09, - 0x6a, 0x22, 0x2f, 0x69, 0x00, 0x17, 0xea, 0x2d, 0xdc, 0x4e, 0x5c, 0xd1, 0x23, 0xa9, 0x99, 0x5c, - 0x2f, 0x33, 0xa6, 0xa8, 0x79, 0x3e, 0x19, 0x9b, 0xb2, 0xdb, 0xe6, 0x69, 0xa8, 0xfc, 0xa5, 0x33, - 0x82, 0x53, 0xaf, 0x98, 0x43, 0x25, 0xf1, 0x30, 0x95, 0xeb, 0xc7, 0xe4, 0xb4, 0x60, 0x92, 0xfe, - 0x66, 0xd5, 0x82, 0xd3, 0xb5, 0xda, 0x0a, 0x9a, 0xc4, 0xae, 0xbb, 0x5e, 0x70, 0xcb, 0xf5, 0x1e, - 0x89, 0xd0, 0x2a, 0x35, 0xdd, 0x1c, 0x24, 0xcd, 0x50, 0xf1, 0xa5, 0x54, 0x43, 0xc5, 0x3e, 0x26, - 0x23, 0x46, 0x1b, 0xce, 0xd4, 0x6a, 0x2b, 0x3c, 0x09, 0xd4, 0x9f, 0x45, 0x7d, 0xbf, 0x9e, 0x81, - 0x99, 0x5a, 0x6d, 0x25, 0x56, 0xd5, 0xaa, 0xcc, 0x3e, 0x95, 0xd1, 0xde, 0xa4, 0xd3, 0x3b, 0x02, - 0x47, 0x21, 0xc3, 0x25, 0xbc, 0xba, 0x16, 0x43, 0x9c, 0x33, 0x21, 0xeb, 0x61, 0xbe, 0xab, 0xac, - 0xe6, 0xa5, 0xd2, 0xa3, 0xa1, 0xa8, 0xb7, 0x17, 0x3e, 0x9e, 0xac, 0x54, 0xd7, 0xdb, 0x33, 0x88, - 0xf1, 0xdf, 0x9e, 0xe6, 0x19, 0xb5, 0xe4, 0x6c, 0x79, 0x1b, 0x26, 0x04, 0x3d, 0xba, 0x72, 0x08, - 0xf3, 0x9c, 0xb3, 0x6c, 0x83, 0xdc, 0xe1, 0x70, 0x9e, 0x1c, 0xe5, 0x7b, 0x87, 0xc5, 0x21, 0xd6, - 0x35, 0xa6, 0x86, 0x4e, 0xee, 0xc3, 0xe4, 0x3d, 0xfb, 0xb1, 0xa2, 0xa4, 0xe1, 0x8e, 0x7a, 0x57, - 0xd8, 0xae, 0xd2, 0xb2, 0x1f, 0x0f, 0x60, 0x08, 0xaa, 0xd3, 0x93, 0x7d, 0x98, 0xd2, 0xdb, 0x24, - 0x66, 0x60, 0x72, 0xc4, 0xae, 0xa7, 0x8e, 0xd8, 0xd9, 0x8e, 0xeb, 0x05, 0xd6, 0x4e, 0x48, 0xae, - 0x65, 0x8f, 0x8b, 0xb1, 0x26, 0x6f, 0xc3, 0x8c, 0x12, 0xa9, 0xfd, 0x96, 0xeb, 0xb5, 0x6c, 0x79, - 0xe1, 0xc2, 0x97, 0x0b, 0xb4, 0x10, 0xdb, 0x41, 0xb0, 0x99, 0xc4, 0x24, 0x5f, 0x49, 0x73, 0x7e, - 0x1c, 0x8e, 0xac, 0x61, 0x53, 0x9c, 0x1f, 0x7b, 0x59, 0xc3, 0x26, 0xdd, 0x20, 0x77, 0xfb, 0x59, - 0xcb, 0xe7, 0x79, 0xeb, 0x07, 0xb2, 0x86, 0x0f, 0x47, 0xae, 0x87, 0x55, 0xfc, 0x22, 0xe4, 0x96, - 0xd6, 0x6f, 0xe1, 0x7b, 0x9b, 0x34, 0x8d, 0x6b, 0xef, 0xd9, 0xed, 0x3a, 0x5e, 0x84, 0x84, 0x8f, - 0x8a, 0x7a, 0x50, 0x2e, 0xad, 0xdf, 0x22, 0x36, 0xcc, 0x62, 0xb6, 0xf0, 0xe0, 0xcb, 0xd7, 0xaf, - 0x2b, 0x43, 0x95, 0xc7, 0x4f, 0xbb, 0x26, 0x3e, 0xad, 0x88, 0xb9, 0xc6, 0x03, 0xeb, 0xf1, 0xf5, - 0xeb, 0xa9, 0x03, 0x12, 0x7e, 0x58, 0x1a, 0x2f, 0x76, 0x60, 0xdd, 0xb3, 0x1f, 0x47, 0xae, 0x45, - 0xbe, 0x70, 0x23, 0x3f, 0x2f, 0xa7, 0x56, 0xe4, 0x96, 0xa4, 0x1d, 0x58, 0x3a, 0x11, 0xbb, 0xc7, - 0x46, 0x13, 0xcc, 0x17, 0x0e, 0x78, 0x0b, 0x52, 0x09, 0x29, 0x63, 0x0d, 0xa8, 0x97, 0x31, 0x05, - 0x9d, 0x6c, 0x86, 0xb7, 0x71, 0x7e, 0x9b, 0x45, 0x9b, 0xf5, 0xb1, 0xa5, 0x6b, 0xea, 0x6d, 0x9c, - 0xab, 0xfe, 0xb4, 0x66, 0x4d, 0x87, 0x2a, 0x1c, 0xee, 0x6b, 0x65, 0xea, 0x5c, 0x92, 0x97, 0xfc, - 0x89, 0x93, 0x5f, 0xf2, 0x29, 0x0c, 0xad, 0xba, 0xf5, 0x7d, 0x11, 0x08, 0xf9, 0x7d, 0xb6, 0x0b, - 0x37, 0xdd, 0xfa, 0xfe, 0x93, 0xf3, 0x02, 0x40, 0xf6, 0x64, 0x8d, 0x07, 0xd2, 0xf1, 0x1a, 0xa2, - 0x4f, 0x84, 0x65, 0xf9, 0x5c, 0x78, 0xcb, 0x55, 0xca, 0xa2, 0xf0, 0x3a, 0x5e, 0x43, 0x76, 0xad, - 0xa9, 0x93, 0x13, 0x0a, 0x85, 0x0a, 0xf5, 0xf7, 0x03, 0xb7, 0x53, 0x6e, 0x3a, 0x1d, 0x8c, 0x4d, - 0x25, 0x32, 0xe9, 0x0c, 0xbc, 0x27, 0x37, 0x38, 0xbd, 0x55, 0x97, 0x0c, 0xcc, 0x04, 0x4b, 0xf2, - 0x15, 0x98, 0x62, 0x93, 0x7b, 0xf9, 0x71, 0x40, 0xdb, 0x7c, 0xe4, 0x67, 0x50, 0xa2, 0x9b, 0x53, - 0xf2, 0x50, 0x86, 0x85, 0x7c, 0x4e, 0xe1, 0x62, 0xa7, 0x21, 0x81, 0x16, 0x44, 0x5a, 0x63, 0x45, - 0x1a, 0x30, 0x7f, 0xcf, 0x7e, 0x1c, 0xdd, 0x79, 0xd5, 0x49, 0x4a, 0x70, 0x82, 0x5d, 0x3e, 0x3a, - 0x2c, 0xbe, 0xc0, 0x26, 0x58, 0x94, 0xdc, 0xa9, 0xc7, 0x7c, 0xed, 0xc9, 0x89, 0x7c, 0x13, 0xce, - 0x88, 0x66, 0x55, 0x30, 0x3d, 0xb4, 0xeb, 0x1d, 0xd4, 0xf6, 0x6c, 0xf4, 0x2a, 0x9c, 0xed, 0xd1, - 0x61, 0xd7, 0xd2, 0xb7, 0x44, 0xd9, 0x61, 0x0d, 0xc9, 0xc7, 0xf2, 0x39, 0x23, 0xb3, 0x57, 0x0d, - 0xe4, 0x23, 0x98, 0xe2, 0x8f, 0x8c, 0x2b, 0xae, 0x1f, 0xa0, 0xb2, 0x66, 0xee, 0x64, 0xae, 0x32, - 0xfc, 0xe5, 0x92, 0xbb, 0x97, 0xc5, 0x94, 0x3b, 0x31, 0xce, 0xe4, 0x4d, 0xb4, 0x46, 0xe5, 0x61, - 0xde, 0xab, 0xeb, 0xa8, 0x2c, 0x17, 0x27, 0x50, 0xc7, 0x69, 0x5b, 0x52, 0x63, 0xd2, 0x09, 0xb7, - 0x0b, 0x15, 0x9b, 0x6c, 0xc1, 0x78, 0xad, 0xb6, 0x72, 0xcb, 0x61, 0x72, 0x49, 0x47, 0xea, 0xbe, - 0x93, 0x5f, 0x79, 0x31, 0xf5, 0x2b, 0x27, 0x7d, 0x7f, 0xcf, 0xda, 0x71, 0x9a, 0xd4, 0xaa, 0xbb, - 0x9d, 0x03, 0x53, 0xe5, 0x94, 0xe2, 0x3e, 0x72, 0xe6, 0x09, 0xbb, 0x8f, 0x54, 0x61, 0x5a, 0x31, - 0x89, 0x46, 0x0b, 0x9b, 0xf9, 0x28, 0x8e, 0xa7, 0xea, 0x2e, 0x12, 0x77, 0x98, 0x8e, 0xd3, 0x49, - 0xbf, 0x91, 0xb3, 0x27, 0xf5, 0x1b, 0x71, 0x60, 0x86, 0x0f, 0x86, 0x98, 0x07, 0x38, 0xd2, 0x0b, - 0x3d, 0xfa, 0xf0, 0x4a, 0x6a, 0x1f, 0xce, 0x8a, 0x91, 0x96, 0x93, 0x0c, 0x1f, 0xd5, 0x93, 0x5c, - 0xc9, 0x0e, 0x10, 0x01, 0xb4, 0x03, 0x7b, 0xdb, 0xf6, 0x29, 0xd6, 0x75, 0xae, 0x47, 0x5d, 0x2f, - 0xa4, 0xd6, 0x35, 0x25, 0xeb, 0xda, 0xe6, 0xd5, 0xa4, 0x70, 0x24, 0x6d, 0x59, 0x8f, 0x9c, 0x5f, - 0xd8, 0xb1, 0xcf, 0x6a, 0x3a, 0xee, 0x24, 0x02, 0x0f, 0x89, 0x19, 0x9f, 0xb4, 0xf1, 0x7e, 0x4f, - 0xe1, 0x4c, 0x1e, 0xc3, 0xe9, 0xe4, 0x57, 0x60, 0x9d, 0xe7, 0xb1, 0xce, 0xf3, 0x5a, 0x9d, 0x71, - 0x24, 0x3e, 0x6f, 0xf4, 0x66, 0xc5, 0x6b, 0xed, 0xc1, 0x9f, 0xfc, 0x68, 0x06, 0xce, 0xdc, 0xbb, - 0x55, 0x7a, 0x40, 0x3d, 0x2e, 0x96, 0x38, 0x6e, 0x3b, 0x74, 0x34, 0x7f, 0x4e, 0xbc, 0x83, 0xc4, - 0xdf, 0x80, 0xa4, 0xc4, 0x81, 0x5b, 0x05, 0x13, 0xdd, 0x2f, 0xb6, 0x76, 0x6c, 0xeb, 0xa1, 0xc2, - 0x22, 0xc5, 0x1b, 0xfd, 0xdb, 0xbf, 0x5f, 0xcc, 0x98, 0xbd, 0xaa, 0x22, 0x4d, 0x58, 0xd0, 0xbb, - 0x45, 0x7a, 0xf6, 0xec, 0xd1, 0x66, 0x73, 0xbe, 0x88, 0x33, 0xfa, 0xd5, 0xa3, 0xc3, 0xe2, 0xe5, - 0x44, 0xef, 0x86, 0xde, 0x42, 0x0c, 0x53, 0x69, 0x70, 0x1f, 0x7e, 0xa4, 0x95, 0x22, 0x74, 0xcf, - 0x5f, 0xd0, 0x22, 0x52, 0x25, 0xca, 0xc3, 0x88, 0x69, 0xe7, 0xd9, 0x7a, 0xef, 0x29, 0x20, 0x9a, - 0x49, 0xce, 0x77, 0x86, 0xf2, 0x93, 0x85, 0xa9, 0x14, 0x97, 0x17, 0xe3, 0x3b, 0xd9, 0xd8, 0xc1, - 0x48, 0xaa, 0x30, 0x2a, 0xe6, 0x7b, 0xcf, 0x4b, 0xc6, 0xf9, 0xd4, 0x59, 0x3d, 0x2a, 0x96, 0x8e, - 0x29, 0xe9, 0xc9, 0x23, 0xc6, 0x0a, 0x1b, 0x2d, 0x6e, 0xbc, 0x1f, 0xf2, 0x73, 0x0f, 0x41, 0xda, - 0x09, 0x5f, 0x39, 0xb9, 0x7b, 0xa8, 0xee, 0x7d, 0x8c, 0x47, 0xbd, 0xac, 0x8d, 0xec, 0xf3, 0xb4, - 0xc0, 0xb9, 0xd0, 0xc3, 0x50, 0xcf, 0x01, 0xfc, 0xc4, 0x2a, 0x64, 0xb5, 0x18, 0xbf, 0x91, 0x81, - 0x49, 0xed, 0x64, 0x25, 0x37, 0x15, 0x07, 0xda, 0x28, 0xa6, 0x84, 0x86, 0x83, 0x9b, 0x6d, 0xdc, - 0xb5, 0xf6, 0xa6, 0x12, 0x8b, 0xb1, 0x07, 0x1d, 0x2e, 0xb6, 0xb8, 0x3f, 0x75, 0x7f, 0xfd, 0x70, - 0x11, 0x86, 0x79, 0x30, 0x9e, 0xa1, 0xc8, 0x7e, 0x12, 0xf5, 0x2b, 0x26, 0x87, 0x1b, 0xff, 0x69, - 0x11, 0xa6, 0xf4, 0x1b, 0x31, 0x79, 0x15, 0x46, 0x50, 0x37, 0x2f, 0xd5, 0x2b, 0xa8, 0x16, 0x42, - 0xf5, 0xbd, 0xe6, 0x62, 0xc4, 0x71, 0xc8, 0x8b, 0x00, 0xa1, 0x2d, 0xbe, 0x7c, 0x99, 0x1a, 0x3e, - 0x3a, 0x2c, 0x66, 0x5e, 0x33, 0x95, 0x02, 0xf2, 0x35, 0x80, 0x35, 0xb7, 0x41, 0x45, 0x96, 0xcb, - 0x5c, 0x3f, 0x9b, 0x92, 0x97, 0x12, 0x59, 0x2e, 0x4f, 0xb5, 0xdd, 0x06, 0x4d, 0xa6, 0xb4, 0x54, - 0x38, 0x92, 0x2f, 0xc1, 0xb0, 0xd9, 0x6d, 0x52, 0xf9, 0x82, 0x31, 0x2e, 0x4f, 0xb8, 0x6e, 0x93, - 0x46, 0x7a, 0x02, 0xaf, 0x1b, 0x37, 0x97, 0x64, 0x00, 0xf2, 0x2e, 0xcf, 0x7e, 0x29, 0x62, 0xa7, - 0x0f, 0x47, 0x6f, 0x75, 0x8a, 0xe4, 0x93, 0x88, 0x9e, 0xae, 0x90, 0x90, 0xfb, 0x30, 0xaa, 0x3e, - 0x32, 0x29, 0x91, 0x18, 0xd4, 0x87, 0x48, 0x45, 0xe9, 0x20, 0x82, 0xc8, 0xc6, 0xdf, 0x9f, 0x24, - 0x17, 0xf2, 0x16, 0x8c, 0x31, 0xf6, 0x6c, 0xe7, 0xf0, 0xc5, 0xad, 0x06, 0x5f, 0xe4, 0x94, 0x0f, - 0x62, 0xbb, 0x8f, 0x16, 0xe1, 0x3c, 0x24, 0x20, 0x5f, 0x81, 0xb1, 0x52, 0xa7, 0x23, 0xba, 0xba, - 0xaf, 0xad, 0xd1, 0xa5, 0x44, 0x57, 0xcf, 0xd9, 0x9d, 0x4e, 0xb2, 0xa7, 0x23, 0x7e, 0x64, 0x37, - 0x0c, 0x04, 0x38, 0x48, 0xc6, 0xd2, 0x97, 0x13, 0x15, 0xcc, 0xcb, 0xd8, 0x76, 0x89, 0x4a, 0x74, - 0xbe, 0xa4, 0x03, 0x85, 0x48, 0xa8, 0x14, 0x75, 0x41, 0xbf, 0xba, 0x5e, 0x4b, 0xd4, 0xa5, 0x0e, - 0x60, 0xa2, 0xba, 0x04, 0x77, 0xd2, 0x80, 0x29, 0x79, 0x40, 0x89, 0xfa, 0xc6, 0xfb, 0xd5, 0xf7, - 0x62, 0xa2, 0xbe, 0xd9, 0xc6, 0x76, 0xb2, 0x9e, 0x18, 0x4f, 0xf2, 0x16, 0x4c, 0x4a, 0x08, 0xae, - 0x0f, 0xb4, 0xf1, 0x11, 0x0a, 0xc1, 0xc6, 0x36, 0x7a, 0xff, 0x68, 0xbd, 0xa2, 0x21, 0xab, 0xd4, - 0x7c, 0x76, 0x4c, 0x6a, 0xd4, 0xf1, 0x59, 0xa1, 0x23, 0x93, 0x0f, 0x60, 0xbc, 0xda, 0x62, 0x0d, - 0x71, 0xdb, 0x76, 0x40, 0x85, 0x8f, 0xae, 0xb4, 0x9b, 0x52, 0x4a, 0x94, 0xa9, 0x8a, 0x16, 0x23, - 0x4e, 0x54, 0xa4, 0x5e, 0x33, 0x15, 0x0a, 0xd6, 0x79, 0xfc, 0x55, 0x51, 0xcc, 0x61, 0xe9, 0xbf, - 0x7b, 0x3e, 0xc5, 0x76, 0x49, 0x61, 0x2f, 0xe2, 0x64, 0x33, 0xa8, 0x7c, 0xd5, 0x8b, 0xe5, 0x28, - 0x50, 0x79, 0x92, 0xb7, 0x61, 0x5c, 0x24, 0x73, 0x2e, 0x99, 0x6b, 0xfe, 0x7c, 0x21, 0x32, 0xbd, - 0x96, 0x79, 0x9f, 0x2d, 0xdb, 0x8b, 0x19, 0xe9, 0x46, 0xf8, 0xe4, 0xcb, 0x30, 0xb7, 0xe5, 0xb4, - 0x1b, 0xee, 0x23, 0x5f, 0x1c, 0x53, 0x62, 0xa3, 0x9b, 0x89, 0x5c, 0x04, 0x1f, 0xf1, 0xf2, 0x50, - 0x16, 0x4c, 0x6c, 0x7c, 0xa9, 0x1c, 0xc8, 0x0f, 0x24, 0x38, 0xf3, 0x19, 0x44, 0xfa, 0xcd, 0xa0, - 0xc5, 0xc4, 0x0c, 0x4a, 0x56, 0x1f, 0x9f, 0x4e, 0xa9, 0xd5, 0x10, 0x17, 0x88, 0x7e, 0xbe, 0xdf, - 0x71, 0x9d, 0xf6, 0xfc, 0x2c, 0xee, 0x85, 0xe7, 0xe2, 0x91, 0x3e, 0x10, 0x6f, 0xdd, 0x6d, 0x3a, - 0xf5, 0x03, 0x9e, 0xb8, 0x25, 0x2e, 0xf3, 0x7f, 0xe4, 0x6a, 0xcf, 0x25, 0x29, 0xac, 0xc9, 0x07, - 0x30, 0xc1, 0xfe, 0x0f, 0x95, 0x12, 0x73, 0x9a, 0xb5, 0xab, 0x82, 0x29, 0xea, 0xc1, 0x31, 0xc2, - 0x6c, 0xd3, 0x29, 0xfa, 0x0a, 0x8d, 0x15, 0x79, 0x03, 0x80, 0x89, 0x4d, 0x62, 0x3b, 0x3e, 0x15, - 0xa5, 0x84, 0x40, 0xa9, 0x2b, 0xb9, 0x11, 0x47, 0xc8, 0xe4, 0x2d, 0x18, 0x67, 0xbf, 0x6a, 0xdd, - 0x86, 0xcb, 0xd6, 0xc6, 0x69, 0xa4, 0xe5, 0xee, 0xd2, 0x8c, 0xd6, 0xe7, 0x70, 0xcd, 0x5d, 0x3a, - 0x42, 0x27, 0x2b, 0x30, 0x8d, 0xa9, 0x3b, 0x44, 0xd0, 0x78, 0x87, 0xfa, 0xf3, 0x67, 0x14, 0x6b, - 0x08, 0xcc, 0xb8, 0xea, 0x84, 0x65, 0xea, 0x5d, 0x26, 0x46, 0x46, 0x7c, 0x98, 0x4d, 0x3e, 0x27, - 0xfb, 0xf3, 0xf3, 0xd8, 0x49, 0x52, 0x82, 0x4f, 0x62, 0xf0, 0xfd, 0x98, 0x8d, 0x88, 0xb2, 0x71, - 0xc9, 0x47, 0x25, 0xb5, 0xc2, 0x34, 0xee, 0xc4, 0x04, 0x72, 0xbb, 0xbc, 0x1e, 0xcf, 0x6d, 0x71, - 0x16, 0x5b, 0x80, 0xc3, 0xbc, 0x5b, 0xef, 0x58, 0x7d, 0xf2, 0x5b, 0xa4, 0x50, 0x93, 0xef, 0x87, - 0x53, 0x72, 0x07, 0x11, 0x45, 0x62, 0x5e, 0x2f, 0x9c, 0x70, 0x27, 0x6e, 0x6c, 0x87, 0x55, 0x27, - 0xa6, 0x74, 0x7a, 0x15, 0xc4, 0x86, 0x71, 0x1c, 0x56, 0x51, 0xe3, 0xb9, 0x7e, 0x35, 0x5e, 0x4e, - 0xd4, 0x78, 0x1a, 0x27, 0x4a, 0xb2, 0x32, 0x95, 0x27, 0x59, 0x82, 0x49, 0xb1, 0x8e, 0xc4, 0x6c, - 0x7b, 0x16, 0x7b, 0x0b, 0x95, 0x58, 0x72, 0x05, 0x26, 0x26, 0x9c, 0x4e, 0xa2, 0xee, 0xc8, 0xfc, - 0x31, 0xe9, 0xbc, 0xb6, 0x23, 0xc7, 0xdf, 0x90, 0x74, 0x64, 0xb6, 0x23, 0x45, 0x52, 0xcc, 0xf2, - 0xe3, 0x8e, 0x27, 0x54, 0x54, 0xcf, 0x45, 0xc9, 0x2b, 0x15, 0xe1, 0xc7, 0xa2, 0x21, 0x86, 0xba, - 0x25, 0xa4, 0x71, 0x20, 0x9b, 0x30, 0x1b, 0x9e, 0xda, 0x0a, 0xe3, 0x62, 0x94, 0x3d, 0x21, 0x3a, - 0xea, 0xd3, 0xf9, 0xa6, 0xd1, 0x13, 0x1b, 0xce, 0x68, 0xe7, 0xb4, 0xc2, 0xfa, 0x02, 0xb2, 0x7e, - 0x89, 0xdd, 0xc8, 0xf4, 0x43, 0x3e, 0x9d, 0x7d, 0x2f, 0x3e, 0xe4, 0x23, 0x58, 0x88, 0x9f, 0xcd, - 0x4a, 0x2d, 0xcf, 0x63, 0x2d, 0x2f, 0x1f, 0x1d, 0x16, 0x2f, 0x25, 0x8e, 0xf7, 0xf4, 0x8a, 0xfa, - 0x70, 0x23, 0x5f, 0x83, 0x79, 0xfd, 0x7c, 0x56, 0x6a, 0x32, 0xb0, 0x26, 0x5c, 0x3a, 0xe1, 0xc1, - 0x9e, 0x5e, 0x43, 0x4f, 0x1e, 0x24, 0x80, 0x62, 0xea, 0xec, 0x56, 0xaa, 0xb9, 0x18, 0x35, 0x28, - 0xb1, 0x4a, 0xd2, 0xab, 0x3b, 0x8e, 0x25, 0x79, 0x04, 0xcf, 0xa5, 0x1d, 0x13, 0x4a, 0xa5, 0x2f, - 0x84, 0x4a, 0xe0, 0x57, 0xd2, 0x8f, 0x9c, 0xf4, 0x9a, 0x8f, 0x61, 0x4b, 0xbe, 0x02, 0xa7, 0x94, - 0xf5, 0xa5, 0xd4, 0xf7, 0x22, 0xd6, 0x87, 0x0e, 0xfe, 0xea, 0xc2, 0x4c, 0xaf, 0x25, 0x9d, 0x07, - 0x69, 0xc1, 0xac, 0x6c, 0x38, 0x6a, 0xdb, 0xc5, 0xd1, 0x73, 0x49, 0xdb, 0x55, 0x93, 0x18, 0x4b, - 0x17, 0xc4, 0xae, 0x3a, 0xdf, 0xd8, 0xb6, 0x3a, 0x11, 0xa1, 0x3a, 0xd3, 0x53, 0xf8, 0x92, 0x15, - 0x18, 0xa9, 0xad, 0x57, 0x6f, 0xdd, 0x5a, 0x9e, 0x7f, 0x09, 0x6b, 0x90, 0x2e, 0x7c, 0x1c, 0xa8, - 0x5d, 0x9a, 0x84, 0xb9, 0x62, 0xc7, 0xd9, 0xd9, 0xd1, 0x1e, 0xac, 0x38, 0x2a, 0xf9, 0x01, 0x34, - 0x14, 0x64, 0x3b, 0x6a, 0xc9, 0xf7, 0x9d, 0xdd, 0x36, 0xcf, 0x4b, 0xf1, 0xb2, 0xf6, 0xde, 0x2f, - 0x33, 0x95, 0x94, 0x31, 0xaf, 0x6c, 0x02, 0x9d, 0x4b, 0x9b, 0xec, 0xfe, 0x2f, 0x76, 0x6e, 0xcb, - 0x8e, 0x58, 0xa9, 0x9b, 0x78, 0xb2, 0x22, 0xd6, 0x6f, 0xbb, 0x4e, 0x60, 0xed, 0x75, 0xb5, 0xe6, - 0xcf, 0xbf, 0xa2, 0xc5, 0x05, 0xe7, 0xd9, 0x76, 0x95, 0x5e, 0x7b, 0x41, 0x54, 0xf8, 0x2c, 0xbf, - 0x2d, 0xf7, 0xe8, 0xb9, 0x99, 0xdd, 0x18, 0x9d, 0x4f, 0x7e, 0x24, 0x03, 0xa7, 0xb7, 0x5c, 0x6f, - 0xbf, 0xe9, 0xda, 0x0d, 0xd9, 0x2a, 0xb1, 0x87, 0xbf, 0xda, 0x6f, 0x0f, 0xff, 0x7c, 0x62, 0x0f, - 0x37, 0x1e, 0x09, 0x36, 0x56, 0x98, 0xe8, 0x25, 0xb1, 0x9f, 0xf7, 0xa8, 0x8a, 0xfc, 0x00, 0x5c, - 0x48, 0x2f, 0x51, 0x26, 0xe5, 0x6b, 0x38, 0x29, 0xaf, 0x1f, 0x1d, 0x16, 0x5f, 0xeb, 0x55, 0x53, - 0xfa, 0x04, 0x3d, 0x96, 0xf5, 0x9d, 0xa1, 0xfc, 0xe5, 0xc2, 0x95, 0x3b, 0x43, 0xf9, 0x2b, 0x85, - 0x97, 0xcd, 0x67, 0x6b, 0xa5, 0x7b, 0xab, 0xd5, 0x86, 0x3c, 0x5c, 0x65, 0x2e, 0x1a, 0x4e, 0x63, - 0x5e, 0xea, 0x57, 0x1a, 0x71, 0x34, 0xfe, 0x5a, 0x06, 0x8a, 0xc7, 0x4c, 0x12, 0x76, 0x9e, 0x45, - 0x23, 0x51, 0x0b, 0xf3, 0x1f, 0x70, 0x1f, 0xbf, 0xb0, 0xc0, 0xd2, 0xcd, 0x46, 0x74, 0x12, 0xf4, - 0xff, 0x14, 0x69, 0xd4, 0x14, 0x37, 0xe0, 0x64, 0xfa, 0x34, 0x89, 0x65, 0xac, 0x42, 0x21, 0x3e, - 0x79, 0xc8, 0x17, 0x61, 0x52, 0x4d, 0xe2, 0x24, 0x55, 0x09, 0x3c, 0xf8, 0x8d, 0xb7, 0xab, 0x1d, - 0x88, 0x1a, 0xa2, 0xf1, 0xcb, 0x19, 0x98, 0x4d, 0x59, 0x61, 0xe4, 0x12, 0x0c, 0x61, 0xe6, 0x56, - 0xc5, 0x6a, 0x28, 0x96, 0xb1, 0x15, 0xcb, 0xc9, 0xe7, 0x60, 0xb4, 0xb2, 0x56, 0xab, 0x95, 0xd6, - 0xa4, 0x32, 0x82, 0x1f, 0xc4, 0x6d, 0xdf, 0xf2, 0x6d, 0xdd, 0xd8, 0x40, 0xa0, 0x91, 0xd7, 0x60, - 0xa4, 0xba, 0x8e, 0x04, 0x4a, 0x86, 0x17, 0xa7, 0x13, 0xc7, 0x17, 0x48, 0xc6, 0x4f, 0x66, 0x80, - 0x24, 0xb7, 0x0b, 0x72, 0x1d, 0xc6, 0xd5, 0x4d, 0x89, 0xb7, 0x17, 0x5f, 0x60, 0x95, 0x85, 0x63, - 0xaa, 0x38, 0xa4, 0x02, 0xc3, 0x98, 0x08, 0x31, 0xb4, 0x72, 0x48, 0x5d, 0x16, 0x67, 0x12, 0xcb, - 0x62, 0x18, 0x93, 0x2b, 0x9a, 0x9c, 0xd8, 0xf8, 0xad, 0x0c, 0x90, 0x74, 0xdb, 0xc5, 0x81, 0xac, - 0xac, 0x5e, 0x57, 0xc2, 0x48, 0xa8, 0x79, 0x14, 0xc3, 0xc4, 0xba, 0xaa, 0x1a, 0x20, 0x0a, 0x38, - 0x71, 0x49, 0x53, 0x3b, 0xf5, 0xf6, 0x3d, 0xbe, 0x02, 0xc3, 0x0f, 0xa8, 0xb7, 0x2d, 0xcd, 0xba, - 0xd1, 0x14, 0xf4, 0x21, 0x03, 0xa8, 0x6a, 0x18, 0xc4, 0x30, 0xfe, 0x30, 0x03, 0x73, 0x69, 0x77, - 0x94, 0x63, 0x5c, 0x84, 0x8d, 0x98, 0x77, 0x33, 0x5a, 0x58, 0x71, 0x3b, 0xd1, 0xd0, 0xa7, 0xb9, - 0x08, 0xc3, 0xac, 0xb1, 0x72, 0x84, 0x51, 0x0d, 0xc6, 0x7a, 0xc3, 0x37, 0x39, 0x9c, 0x21, 0x44, - 0x39, 0x36, 0x86, 0x39, 0x02, 0x4f, 0xad, 0xc1, 0xe1, 0x0c, 0xe1, 0x9e, 0xdb, 0xa0, 0x52, 0x3d, - 0x84, 0x08, 0x2d, 0x06, 0x30, 0x39, 0x9c, 0x5c, 0x82, 0xd1, 0xfb, 0xed, 0x55, 0x6a, 0x3f, 0x94, - 0xb9, 0xbc, 0xd0, 0x22, 0xcc, 0x6d, 0x5b, 0x4d, 0x06, 0x33, 0x65, 0xa1, 0xf1, 0xf3, 0x19, 0x98, - 0x49, 0x5c, 0x8f, 0x8e, 0xf7, 0x82, 0xee, 0xef, 0xd9, 0x37, 0x48, 0xfb, 0xf8, 0xe7, 0x0f, 0xa5, - 0x7f, 0xbe, 0xf1, 0xdf, 0x8d, 0xc0, 0x99, 0x1e, 0xda, 0xaa, 0xc8, 0xf3, 0x38, 0x73, 0xac, 0xe7, - 0xf1, 0x57, 0x61, 0xb2, 0xdc, 0xb4, 0x9d, 0x96, 0xbf, 0xe1, 0x46, 0x5f, 0x1c, 0x39, 0x30, 0x61, - 0x99, 0xf0, 0x83, 0x08, 0x3d, 0x5d, 0xce, 0xd6, 0x91, 0xc2, 0x0a, 0xdc, 0xa4, 0xb0, 0xac, 0x31, - 0x4b, 0xf8, 0xfe, 0xe6, 0xfe, 0x9c, 0xf8, 0xfe, 0xea, 0xde, 0x68, 0x43, 0x4f, 0xd4, 0x1b, 0x2d, - 0xdd, 0xe6, 0x7b, 0xf8, 0x93, 0x78, 0x00, 0x94, 0x61, 0x92, 0x9b, 0xc4, 0x95, 0x7c, 0x3e, 0x48, - 0x23, 0x09, 0x33, 0x3a, 0xdb, 0x4f, 0x8e, 0x85, 0x46, 0x43, 0x56, 0x74, 0xcf, 0xa9, 0x51, 0x7c, - 0x33, 0xbe, 0xd4, 0xdb, 0x33, 0x4a, 0x0f, 0xbf, 0xa3, 0x7a, 0x48, 0x7d, 0x13, 0xe6, 0xd2, 0xae, - 0xbb, 0xf3, 0x79, 0xcd, 0xda, 0xb6, 0xa7, 0x95, 0xf6, 0xe0, 0x97, 0xe6, 0xfd, 0xd4, 0x4b, 0xb3, - 0xf4, 0x68, 0x1f, 0xeb, 0xed, 0x0e, 0x14, 0xad, 0x05, 0x8e, 0xdb, 0xdf, 0xef, 0xdd, 0xf8, 0x6a, - 0x2c, 0x24, 0x41, 0x9c, 0x9c, 0xbc, 0xa9, 0x45, 0x8e, 0x7a, 0x29, 0x19, 0x39, 0x2a, 0x3d, 0x0a, - 0x01, 0x4f, 0xcb, 0xf4, 0xf3, 0x59, 0xdd, 0x8f, 0xfa, 0xcf, 0xe3, 0x42, 0xbd, 0x02, 0xc3, 0x5b, - 0x7b, 0xd4, 0x93, 0xc7, 0x03, 0x7e, 0xc8, 0x23, 0x06, 0x50, 0x3f, 0x04, 0x31, 0xc8, 0x2d, 0x98, - 0x5a, 0xe7, 0x13, 0x57, 0xce, 0xc6, 0xa1, 0x48, 0xe7, 0xd2, 0x11, 0x9a, 0xc1, 0x94, 0xe9, 0x18, - 0xa3, 0x32, 0x6e, 0xc7, 0x3a, 0x5d, 0xc4, 0xbd, 0xe2, 0x9e, 0x51, 0x5c, 0x80, 0x98, 0x8a, 0x3c, - 0xdc, 0xa2, 0xcd, 0xd6, 0x8c, 0x41, 0x8d, 0x1d, 0x78, 0xae, 0x2f, 0x23, 0x76, 0x6e, 0x43, 0x27, - 0xfc, 0x15, 0xb3, 0xbc, 0xee, 0x4b, 0x6a, 0x2a, 0x74, 0xc6, 0x37, 0x61, 0x42, 0xed, 0x65, 0x3c, + // 32329 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6b, 0x70, 0x24, 0x49, + 0x7a, 0x18, 0xb6, 0xdd, 0x8d, 0x47, 0xe3, 0xc3, 0xab, 0x91, 0xc0, 0xcc, 0x60, 0xb0, 0x3b, 0xdb, + 0xb3, 0xb5, 0xbb, 0xb3, 0x33, 0xfb, 0x98, 0xb9, 0xc1, 0xde, 0xce, 0xdd, 0xde, 0xbe, 0xae, 0xd1, + 0x8d, 0x19, 0xf4, 0x0c, 0x06, 0xd3, 0x5b, 0x0d, 0x0c, 0x6e, 0x79, 0xb7, 0x57, 0x57, 0xe8, 0x4e, + 0x00, 0xb5, 0xe8, 0xee, 0xea, 0xab, 0xaa, 0x9e, 0x19, 0xf0, 0x44, 0x8b, 0xaf, 0x33, 0xc5, 0xa0, + 0xf9, 0x14, 0x29, 0x52, 0x0e, 0x8a, 0xa1, 0xd0, 0xc3, 0x96, 0xe5, 0x20, 0x43, 0x22, 0x25, 0x5b, + 0xb6, 0x42, 0x14, 0xe9, 0x90, 0x29, 0x5a, 0xa1, 0x30, 0x19, 0x92, 0x6c, 0x87, 0x2f, 0x18, 0x60, + 0xd0, 0x74, 0xf8, 0x07, 0x22, 0x1c, 0x41, 0xda, 0x11, 0x8e, 0xf0, 0xc9, 0x94, 0x15, 0xf9, 0x65, + 0x66, 0x55, 0x66, 0x55, 0x75, 0xa3, 0xb1, 0x3b, 0x4b, 0x71, 0x36, 0xf8, 0x67, 0x06, 0xfd, 0xe5, + 0xf7, 0x7d, 0x59, 0xf9, 0xfe, 0xf2, 0xcb, 0xef, 0x01, 0xcf, 0x05, 0xb4, 0x45, 0xbb, 0xae, 0x17, + 0x5c, 0x6b, 0xd1, 0x3d, 0xbb, 0x71, 0x78, 0x2d, 0x38, 0xec, 0x52, 0x9f, 0xff, 0x7b, 0xb5, 0xeb, + 0xb9, 0x81, 0x4b, 0x46, 0xf1, 0xc7, 0xd2, 0xc2, 0x9e, 0xbb, 0xe7, 0x22, 0xe4, 0x1a, 0xfb, 0x8b, + 0x17, 0x2e, 0x3d, 0xbb, 0xe7, 0xba, 0x7b, 0x2d, 0x7a, 0x0d, 0x7f, 0xed, 0xf4, 0x76, 0xaf, 0x35, + 0x7b, 0x9e, 0x1d, 0x38, 0x6e, 0x47, 0x94, 0x17, 0xe3, 0xe5, 0x81, 0xd3, 0xa6, 0x7e, 0x60, 0xb7, + 0xbb, 0xfd, 0x18, 0x3c, 0xf4, 0xec, 0x6e, 0x97, 0x7a, 0xa2, 0xf6, 0xa5, 0x2b, 0xe1, 0x07, 0xda, + 0x41, 0xc0, 0x28, 0x19, 0xf3, 0x6b, 0x0f, 0xae, 0xab, 0x3f, 0x05, 0xea, 0x8d, 0x3e, 0x6d, 0xf1, + 0x7a, 0x7e, 0x40, 0x9b, 0x56, 0x93, 0x3e, 0x70, 0x1a, 0xd4, 0xf2, 0xe8, 0x37, 0x7b, 0x8e, 0x47, + 0xdb, 0xb4, 0x13, 0x08, 0xba, 0xd7, 0xd2, 0xe9, 0xe4, 0x87, 0xc4, 0xbe, 0xc8, 0xf8, 0xa5, 0x1c, + 0x4c, 0xdc, 0xa1, 0xb4, 0x5b, 0x6a, 0x39, 0x0f, 0x28, 0x79, 0x1e, 0x46, 0x36, 0xec, 0x36, 0x5d, + 0xcc, 0x5c, 0xcc, 0x5c, 0x9e, 0x58, 0x99, 0x3d, 0x3e, 0x2a, 0x4e, 0xfa, 0xd4, 0x7b, 0x40, 0x3d, + 0xab, 0x63, 0xb7, 0xa9, 0x89, 0x85, 0xe4, 0x15, 0x98, 0x60, 0xff, 0xfb, 0x5d, 0xbb, 0x41, 0x17, + 0xb3, 0x88, 0x39, 0x7d, 0x7c, 0x54, 0x9c, 0xe8, 0x48, 0xa0, 0x19, 0x95, 0x93, 0x2a, 0x8c, 0xaf, + 0x3e, 0xea, 0x3a, 0x1e, 0xf5, 0x17, 0x47, 0x2e, 0x66, 0x2e, 0x4f, 0x2e, 0x2f, 0x5d, 0xe5, 0x7d, + 0x74, 0x55, 0xf6, 0xd1, 0xd5, 0x4d, 0xd9, 0x89, 0x2b, 0xf3, 0xbf, 0x7d, 0x54, 0x7c, 0xea, 0xf8, + 0xa8, 0x38, 0x4e, 0x39, 0xc9, 0x4f, 0xfd, 0x7e, 0x31, 0x63, 0x4a, 0x7a, 0xf2, 0x36, 0x8c, 0x6c, + 0x1e, 0x76, 0xe9, 0xe2, 0xc4, 0xc5, 0xcc, 0xe5, 0x99, 0xe5, 0x67, 0xaf, 0xf2, 0x61, 0x0d, 0x3f, + 0x3e, 0xfa, 0x8b, 0x61, 0xad, 0xe4, 0x8f, 0x8f, 0x8a, 0x23, 0x0c, 0xc5, 0x44, 0x2a, 0xf2, 0x1a, + 0x8c, 0xad, 0xb9, 0x7e, 0x50, 0xad, 0x2c, 0x02, 0x7e, 0xf2, 0x99, 0xe3, 0xa3, 0xe2, 0xdc, 0xbe, + 0xeb, 0x07, 0x96, 0xd3, 0x7c, 0xd5, 0x6d, 0x3b, 0x01, 0x6d, 0x77, 0x83, 0x43, 0x53, 0x20, 0x19, + 0x8f, 0x60, 0x5a, 0xe3, 0x47, 0x26, 0x61, 0x7c, 0x6b, 0xe3, 0xce, 0xc6, 0xbd, 0xed, 0x8d, 0xc2, + 0x53, 0x24, 0x0f, 0x23, 0x1b, 0xf7, 0x2a, 0xab, 0x85, 0x0c, 0x19, 0x87, 0x5c, 0xa9, 0x56, 0x2b, + 0x64, 0xc9, 0x14, 0xe4, 0x2b, 0xa5, 0xcd, 0xd2, 0x4a, 0xa9, 0xbe, 0x5a, 0xc8, 0x91, 0x79, 0x98, + 0xdd, 0xae, 0x6e, 0x54, 0xee, 0x6d, 0xd7, 0xad, 0xca, 0x6a, 0xfd, 0xce, 0xe6, 0xbd, 0x5a, 0x61, + 0x84, 0xcc, 0x00, 0xdc, 0xd9, 0x5a, 0x59, 0x35, 0x37, 0x56, 0x37, 0x57, 0xeb, 0x85, 0x51, 0xb2, + 0x00, 0x05, 0x49, 0x62, 0xd5, 0x57, 0xcd, 0xfb, 0xd5, 0xf2, 0x6a, 0x61, 0xec, 0xf6, 0x48, 0x3e, + 0x57, 0x18, 0x31, 0xc7, 0xd7, 0xa9, 0xed, 0xd3, 0x6a, 0xc5, 0xf8, 0x9b, 0x39, 0xc8, 0xdf, 0xa5, + 0x81, 0xdd, 0xb4, 0x03, 0x9b, 0x3c, 0xa3, 0x8d, 0x0f, 0x36, 0x51, 0x19, 0x98, 0xe7, 0x93, 0x03, + 0x33, 0x7a, 0x7c, 0x54, 0xcc, 0xbc, 0xa6, 0x0e, 0xc8, 0x5b, 0x30, 0x59, 0xa1, 0x7e, 0xc3, 0x73, + 0xba, 0x6c, 0xb2, 0x2d, 0xe6, 0x10, 0xed, 0xfc, 0xf1, 0x51, 0xf1, 0x4c, 0x33, 0x02, 0x2b, 0x1d, + 0xa2, 0x62, 0x93, 0x2a, 0x8c, 0xad, 0xdb, 0x3b, 0xb4, 0xe5, 0x2f, 0x8e, 0x5e, 0xcc, 0x5d, 0x9e, + 0x5c, 0x7e, 0x5a, 0x0c, 0x82, 0xfc, 0xc0, 0xab, 0xbc, 0x74, 0xb5, 0x13, 0x78, 0x87, 0x2b, 0x0b, + 0xc7, 0x47, 0xc5, 0x42, 0x0b, 0x01, 0x6a, 0x07, 0x73, 0x14, 0x52, 0x8f, 0x26, 0xc6, 0xd8, 0x89, + 0x13, 0xe3, 0xc2, 0x6f, 0x1f, 0x15, 0x33, 0x6c, 0xc0, 0xc4, 0xc4, 0x88, 0xf8, 0xe9, 0x53, 0x64, + 0x19, 0xf2, 0x26, 0x7d, 0xe0, 0xf8, 0xac, 0x65, 0x79, 0x6c, 0xd9, 0xd9, 0xe3, 0xa3, 0x22, 0xf1, + 0x04, 0x4c, 0xf9, 0x8c, 0x10, 0x6f, 0xe9, 0x4d, 0x98, 0x54, 0xbe, 0x9a, 0x14, 0x20, 0x77, 0x40, + 0x0f, 0x79, 0x0f, 0x9b, 0xec, 0x4f, 0xb2, 0x00, 0xa3, 0x0f, 0xec, 0x56, 0x4f, 0x74, 0xa9, 0xc9, + 0x7f, 0x7c, 0x29, 0xfb, 0xc5, 0xcc, 0xed, 0x91, 0xfc, 0x78, 0x21, 0x6f, 0x66, 0xab, 0x15, 0xe3, + 0x67, 0x46, 0x20, 0x6f, 0xba, 0x7c, 0x01, 0x93, 0x2b, 0x30, 0x5a, 0x0f, 0xec, 0x40, 0x0e, 0xd3, + 0xfc, 0xf1, 0x51, 0x71, 0x96, 0x2d, 0x6e, 0xaa, 0xd4, 0xcf, 0x31, 0x18, 0x6a, 0x6d, 0xdf, 0xf6, + 0xe5, 0x70, 0x21, 0x6a, 0x97, 0x01, 0x54, 0x54, 0xc4, 0x20, 0x97, 0x60, 0xe4, 0xae, 0xdb, 0xa4, + 0x62, 0xc4, 0xc8, 0xf1, 0x51, 0x71, 0xa6, 0xed, 0x36, 0x55, 0x44, 0x2c, 0x27, 0xaf, 0xc2, 0x44, + 0xb9, 0xe7, 0x79, 0xb4, 0xc3, 0xe6, 0xfa, 0x08, 0x22, 0xcf, 0x1c, 0x1f, 0x15, 0xa1, 0xc1, 0x81, + 0x96, 0xd3, 0x34, 0x23, 0x04, 0x36, 0x0c, 0xf5, 0xc0, 0xf6, 0x02, 0xda, 0x5c, 0x1c, 0x1d, 0x6a, + 0x18, 0xd8, 0xfa, 0x9c, 0xf3, 0x39, 0x49, 0x7c, 0x18, 0x04, 0x27, 0xb2, 0x06, 0x93, 0xb7, 0x3c, + 0xbb, 0x41, 0x6b, 0xd4, 0x73, 0xdc, 0x26, 0x8e, 0x6f, 0x6e, 0xe5, 0xd2, 0xf1, 0x51, 0xf1, 0xec, + 0x1e, 0x03, 0x5b, 0x5d, 0x84, 0x47, 0xd4, 0xdf, 0x3d, 0x2a, 0xe6, 0x2b, 0x62, 0xab, 0x35, 0x55, + 0x52, 0xf2, 0x0d, 0x36, 0x38, 0x7e, 0x80, 0x5d, 0x4b, 0x9b, 0x8b, 0xe3, 0x27, 0x7e, 0xa2, 0x21, + 0x3e, 0xf1, 0x6c, 0xcb, 0xf6, 0x03, 0xcb, 0xe3, 0x74, 0xb1, 0xef, 0x54, 0x59, 0x92, 0x7b, 0x90, + 0xaf, 0x37, 0xf6, 0x69, 0xb3, 0xd7, 0xa2, 0x38, 0x65, 0x26, 0x97, 0xcf, 0x89, 0x49, 0x2d, 0xc7, + 0x53, 0x16, 0xaf, 0x2c, 0x09, 0xde, 0xc4, 0x17, 0x10, 0x75, 0x3e, 0x49, 0xac, 0x2f, 0xe5, 0x7f, + 0xe1, 0xaf, 0x17, 0x9f, 0xfa, 0xfe, 0xdf, 0xbb, 0xf8, 0x94, 0xf1, 0x5f, 0x67, 0xa1, 0x10, 0x67, + 0x42, 0x76, 0x61, 0x7a, 0xab, 0xdb, 0xb4, 0x03, 0x5a, 0x6e, 0x39, 0xb4, 0x13, 0xf8, 0x38, 0x49, + 0x06, 0xb7, 0xe9, 0x05, 0x51, 0xef, 0x62, 0x0f, 0x09, 0xad, 0x06, 0xa7, 0x8c, 0xb5, 0x4a, 0x67, + 0x1b, 0xd5, 0x53, 0xc7, 0x0d, 0xdc, 0xc7, 0x19, 0x76, 0xba, 0x7a, 0xf8, 0xd6, 0xdf, 0xa7, 0x1e, + 0xc1, 0x56, 0x4c, 0xa0, 0x4e, 0x73, 0xe7, 0x10, 0x67, 0xe6, 0xf0, 0x13, 0x88, 0x91, 0xa4, 0x4c, + 0x20, 0x06, 0x36, 0xfe, 0xf7, 0x0c, 0xcc, 0x98, 0xd4, 0x77, 0x7b, 0x5e, 0x83, 0xae, 0x51, 0xbb, + 0x49, 0x3d, 0x36, 0xfd, 0xef, 0x38, 0x9d, 0xa6, 0x58, 0x53, 0x38, 0xfd, 0x0f, 0x9c, 0x8e, 0xba, + 0x75, 0x63, 0x39, 0xf9, 0x1c, 0x8c, 0xd7, 0x7b, 0x3b, 0x88, 0x9a, 0x8d, 0x76, 0x00, 0xbf, 0xb7, + 0x63, 0xc5, 0xd0, 0x25, 0x1a, 0xb9, 0x06, 0xe3, 0xf7, 0xa9, 0xe7, 0x47, 0xbb, 0x21, 0x1e, 0x0d, + 0x0f, 0x38, 0x48, 0x25, 0x10, 0x58, 0xe4, 0x56, 0xb4, 0x23, 0x8b, 0x43, 0x6d, 0x36, 0xb6, 0x0f, + 0x46, 0x53, 0xa5, 0x2d, 0x20, 0xea, 0x54, 0x91, 0x58, 0xc6, 0x4f, 0x67, 0xa1, 0x50, 0xb1, 0x03, + 0x7b, 0xc7, 0xf6, 0x45, 0x7f, 0xde, 0x7f, 0x9d, 0xed, 0xf1, 0x4a, 0x43, 0x71, 0x8f, 0x67, 0x5f, + 0xfe, 0xb1, 0x9b, 0xf7, 0x62, 0xbc, 0x79, 0x93, 0xec, 0x84, 0x15, 0xcd, 0x8b, 0x1a, 0xf5, 0xce, + 0xc9, 0x8d, 0x2a, 0x88, 0x46, 0xe5, 0x65, 0xa3, 0xa2, 0xa6, 0x90, 0x77, 0x60, 0xa4, 0xde, 0xa5, + 0x0d, 0xb1, 0x89, 0xc8, 0x73, 0x41, 0x6f, 0x1c, 0x43, 0xb8, 0xff, 0xfa, 0xca, 0x94, 0x60, 0x33, + 0xe2, 0x77, 0x69, 0xc3, 0x44, 0x32, 0x65, 0xd1, 0xfc, 0xa3, 0x1c, 0x2c, 0xa4, 0x91, 0xa9, 0xed, + 0x18, 0x1b, 0xd0, 0x8e, 0xcb, 0x90, 0x67, 0x47, 0x38, 0x3b, 0x16, 0x71, 0xbb, 0x98, 0x58, 0x99, + 0x62, 0x9f, 0xbc, 0x2f, 0x60, 0x66, 0x58, 0x4a, 0x9e, 0x0f, 0x25, 0x82, 0x7c, 0xc4, 0x4f, 0x48, + 0x04, 0x52, 0x0e, 0x60, 0x63, 0x2d, 0x97, 0x30, 0x0a, 0x0e, 0x51, 0xb7, 0x48, 0x70, 0x34, 0xd6, + 0x9e, 0x80, 0x68, 0xc7, 0x8c, 0x3c, 0x14, 0x56, 0x21, 0x2f, 0x9b, 0xb5, 0x38, 0x85, 0x8c, 0xe6, + 0x62, 0x9d, 0x74, 0xff, 0x75, 0x3e, 0x98, 0x4d, 0xf1, 0x5b, 0x65, 0x23, 0x71, 0xc8, 0xeb, 0x90, + 0xaf, 0x79, 0xee, 0xa3, 0xc3, 0x6a, 0xc5, 0x5f, 0x9c, 0xbe, 0x98, 0xbb, 0x3c, 0xb1, 0x72, 0xee, + 0xf8, 0xa8, 0x38, 0xdf, 0x65, 0x30, 0xcb, 0x69, 0xaa, 0x27, 0x6d, 0x88, 0x78, 0x7b, 0x24, 0x9f, + 0x29, 0x64, 0x6f, 0x8f, 0xe4, 0xb3, 0x85, 0x1c, 0x17, 0x2f, 0x6e, 0x8f, 0xe4, 0x47, 0x0a, 0xa3, + 0xb7, 0x47, 0xf2, 0xa3, 0x28, 0x70, 0x4c, 0x14, 0xe0, 0xf6, 0x48, 0x7e, 0xb2, 0x30, 0xa5, 0x9d, + 0xf6, 0xc8, 0x20, 0x70, 0x1b, 0x6e, 0xcb, 0xcc, 0x6d, 0x99, 0x55, 0x73, 0xac, 0x5c, 0x2a, 0x53, + 0x2f, 0x30, 0x73, 0xa5, 0xed, 0xba, 0x39, 0x5d, 0x39, 0xec, 0xd8, 0x6d, 0xa7, 0xc1, 0x8f, 0x4e, + 0x33, 0x77, 0xab, 0x5c, 0x33, 0x4a, 0x30, 0x13, 0xb5, 0x65, 0xdd, 0xf1, 0x03, 0x72, 0x0d, 0x26, + 0x24, 0x84, 0x6d, 0x74, 0xb9, 0xd4, 0x56, 0x9b, 0x11, 0x8e, 0xf1, 0x5b, 0x59, 0x80, 0xa8, 0xe4, + 0x09, 0x5d, 0x0b, 0x5f, 0xd0, 0xd6, 0xc2, 0x99, 0xf8, 0x5a, 0xe8, 0xbb, 0x0a, 0xc8, 0x7b, 0x30, + 0xc6, 0xc4, 0x82, 0x9e, 0x14, 0x89, 0xce, 0xc5, 0x49, 0xb1, 0xf0, 0xfe, 0xeb, 0x2b, 0x33, 0x82, + 0x78, 0xcc, 0x47, 0x88, 0x29, 0xc8, 0x94, 0x65, 0xf4, 0x4b, 0xe3, 0xd1, 0x60, 0x88, 0x05, 0x74, + 0x19, 0xc2, 0x01, 0x15, 0x1d, 0x8a, 0x2b, 0xa3, 0x2b, 0x07, 0x39, 0x2c, 0x25, 0xe7, 0x81, 0x0d, + 0xb8, 0xe8, 0xd4, 0xf1, 0xe3, 0xa3, 0x62, 0xae, 0xe7, 0x39, 0x38, 0x09, 0xc8, 0x35, 0x10, 0xd3, + 0x40, 0x74, 0x20, 0x9b, 0x7d, 0x73, 0x0d, 0xdb, 0x6a, 0x50, 0x2f, 0x88, 0x7a, 0x7c, 0x31, 0x23, + 0x67, 0x0b, 0xe9, 0x82, 0x3e, 0x55, 0x16, 0x47, 0x70, 0x1a, 0x5c, 0x4e, 0xed, 0x95, 0xab, 0x1a, + 0x2a, 0x17, 0x23, 0x2f, 0xca, 0x53, 0xa9, 0xc9, 0xcb, 0xac, 0x84, 0x48, 0xa9, 0x57, 0x40, 0x5e, + 0x07, 0x36, 0x43, 0x45, 0xef, 0x83, 0xa8, 0xa7, 0xb4, 0x5d, 0x5f, 0x39, 0x23, 0x38, 0x4d, 0xdb, + 0x0f, 0x55, 0x72, 0x86, 0x4d, 0xde, 0x02, 0x36, 0x85, 0x45, 0xbf, 0x13, 0x41, 0x74, 0xab, 0x5c, + 0x2b, 0xb7, 0xdc, 0x5e, 0xb3, 0xfe, 0xfe, 0x7a, 0x44, 0xbc, 0xd7, 0xe8, 0xaa, 0xc4, 0xb7, 0xca, + 0x35, 0xf2, 0x16, 0x8c, 0x96, 0xbe, 0xb7, 0xe7, 0x51, 0x21, 0x9f, 0x4c, 0xc9, 0x3a, 0x19, 0x6c, + 0xe5, 0x9c, 0x20, 0x9c, 0xb5, 0xd9, 0x4f, 0x55, 0xae, 0xc3, 0x72, 0x56, 0xf3, 0xe6, 0x7a, 0x5d, + 0xc8, 0x1e, 0x24, 0xd6, 0x2d, 0x9b, 0xeb, 0xca, 0x67, 0x07, 0x5a, 0xab, 0x19, 0x15, 0xb9, 0x06, + 0xd9, 0x52, 0x05, 0x6f, 0x44, 0x93, 0xcb, 0x13, 0xb2, 0xda, 0xca, 0xca, 0x82, 0x20, 0x99, 0xb2, + 0xd5, 0x65, 0x90, 0x2d, 0x55, 0xc8, 0x0a, 0x8c, 0xde, 0x3d, 0xac, 0xbf, 0xbf, 0x2e, 0x36, 0xb3, + 0x79, 0x39, 0xaf, 0x19, 0xec, 0x1e, 0x2e, 0x7b, 0x3f, 0xfa, 0xe2, 0xf6, 0xa1, 0xff, 0xcd, 0x96, + 0xfa, 0xc5, 0x88, 0x46, 0x6a, 0x30, 0x51, 0x6a, 0xb6, 0x9d, 0xce, 0x96, 0x4f, 0xbd, 0xc5, 0x49, + 0xe4, 0xb3, 0x18, 0xfb, 0xee, 0xb0, 0x7c, 0x65, 0xf1, 0xf8, 0xa8, 0xb8, 0x60, 0xb3, 0x9f, 0x56, + 0xcf, 0xa7, 0x9e, 0xc2, 0x2d, 0x62, 0x42, 0x6a, 0x00, 0x77, 0xdd, 0xce, 0x9e, 0x5b, 0x0a, 0x5a, + 0xb6, 0x1f, 0xdb, 0x1e, 0xa3, 0x82, 0x50, 0x7c, 0x38, 0xd3, 0x66, 0x30, 0xcb, 0x66, 0x40, 0x85, + 0xa1, 0xc2, 0x83, 0xdc, 0x84, 0xb1, 0x7b, 0x9e, 0xdd, 0x68, 0xd1, 0xc5, 0x69, 0xe4, 0xb6, 0x20, + 0xb8, 0x71, 0xa0, 0x6c, 0xe9, 0xa2, 0x60, 0x58, 0x70, 0x11, 0xac, 0x5e, 0x53, 0x38, 0xe2, 0xd2, + 0x36, 0x90, 0xe4, 0x9c, 0x4c, 0xb9, 0x24, 0xbc, 0xa2, 0x5e, 0x12, 0xa2, 0x45, 0x5f, 0x76, 0xdb, + 0x6d, 0xbb, 0xd3, 0x44, 0xda, 0xfb, 0xcb, 0xca, 0xdd, 0xc1, 0xf8, 0x26, 0xcc, 0x25, 0x3a, 0xeb, + 0x84, 0xfb, 0xdd, 0xbb, 0x30, 0x5b, 0xa1, 0xbb, 0x76, 0xaf, 0x15, 0x84, 0x27, 0x09, 0x5f, 0xa2, + 0x78, 0xd3, 0x6a, 0xf2, 0x22, 0x4b, 0x1e, 0x1f, 0x66, 0x1c, 0xd9, 0x78, 0x07, 0xa6, 0xb5, 0xe6, + 0xb3, 0xab, 0x42, 0xa9, 0xd7, 0x74, 0x02, 0x1c, 0xc8, 0x4c, 0x74, 0x55, 0xb0, 0x19, 0x10, 0x87, + 0xcb, 0x8c, 0x10, 0x8c, 0xbf, 0xa5, 0x4a, 0x2b, 0x62, 0x27, 0x62, 0xd7, 0x6a, 0xb1, 0x1f, 0x64, + 0x22, 0xd9, 0x29, 0xb1, 0x1f, 0x84, 0xbb, 0xc1, 0x15, 0xbe, 0x36, 0xb3, 0x89, 0xb5, 0x39, 0x29, + 0x46, 0x22, 0x67, 0x3f, 0xf4, 0xf9, 0x8a, 0x0c, 0x67, 0x6a, 0xee, 0xe3, 0xcf, 0xd4, 0xf7, 0x60, + 0xea, 0xae, 0xdd, 0xb1, 0xf7, 0x68, 0x93, 0xb5, 0x80, 0xef, 0x3d, 0x13, 0x2b, 0x4f, 0x1f, 0x1f, + 0x15, 0xcf, 0xb5, 0x39, 0x1c, 0x5b, 0xa9, 0x4e, 0x22, 0x8d, 0x80, 0x5c, 0x97, 0x2b, 0x7b, 0x34, + 0x65, 0x65, 0x4f, 0x8b, 0xda, 0x47, 0x71, 0x65, 0x8b, 0xf5, 0x6c, 0xfc, 0xc6, 0x04, 0xb6, 0x91, + 0xbc, 0x0a, 0x63, 0x26, 0xdd, 0x63, 0x47, 0x4d, 0x26, 0x1a, 0x24, 0x0f, 0x21, 0x6a, 0xc7, 0x70, + 0x1c, 0x94, 0x33, 0x68, 0xd3, 0xdf, 0x77, 0x76, 0x03, 0xd1, 0x3b, 0xa1, 0x9c, 0x21, 0xc0, 0x8a, + 0x9c, 0x21, 0x20, 0xfa, 0x75, 0x96, 0xc3, 0xd8, 0xee, 0x67, 0x56, 0xea, 0xa2, 0xd3, 0x64, 0x0f, + 0x9b, 0x15, 0x65, 0x1b, 0xf1, 0x34, 0x29, 0x81, 0x61, 0x93, 0x1b, 0x30, 0x51, 0x6a, 0x34, 0xdc, + 0x9e, 0x72, 0x67, 0xe4, 0xeb, 0x96, 0x03, 0x75, 0x15, 0x49, 0x84, 0x4a, 0xea, 0x30, 0xb9, 0xca, + 0x2e, 0x5a, 0x4e, 0xd9, 0x6e, 0xec, 0xcb, 0x4e, 0x92, 0x7b, 0x98, 0x52, 0x12, 0xad, 0x5c, 0x8a, + 0xc0, 0x06, 0x03, 0xaa, 0x4a, 0x06, 0x05, 0x97, 0x6c, 0xc2, 0x64, 0x9d, 0x36, 0x3c, 0x1a, 0xd4, + 0x03, 0xd7, 0xa3, 0xb1, 0x2d, 0x59, 0x29, 0x59, 0x79, 0x56, 0xde, 0xf5, 0x7c, 0x04, 0x5a, 0x3e, + 0x83, 0xaa, 0x5c, 0x15, 0x64, 0x2e, 0xb4, 0xb7, 0x5d, 0xef, 0xb0, 0xb2, 0x22, 0xb6, 0xe9, 0xe8, + 0x4c, 0xe7, 0x60, 0x55, 0x68, 0x67, 0x90, 0xe6, 0x8e, 0x2e, 0xb4, 0x73, 0x2c, 0x1c, 0xa9, 0x4a, + 0x1d, 0x65, 0x2b, 0xb1, 0x69, 0xcf, 0x46, 0xbd, 0x8c, 0x60, 0x65, 0xa4, 0x9a, 0x3e, 0x4a, 0x66, + 0xda, 0x48, 0x09, 0x2c, 0xd2, 0x05, 0x22, 0x47, 0x8d, 0x0b, 0xba, 0x2d, 0xea, 0xfb, 0x62, 0x2f, + 0x3f, 0x1f, 0x1b, 0xfc, 0x08, 0x61, 0xe5, 0x45, 0xc1, 0xfc, 0x82, 0x9c, 0x06, 0xe2, 0x9e, 0xc6, + 0x0a, 0x95, 0x7a, 0x52, 0x78, 0x93, 0x37, 0x01, 0x56, 0x1f, 0x05, 0xd4, 0xeb, 0xd8, 0xad, 0x50, + 0x0f, 0x86, 0xaa, 0x1f, 0x2a, 0xa0, 0xfa, 0x40, 0x2b, 0xc8, 0xa4, 0x0c, 0xd3, 0x25, 0xdf, 0xef, + 0xb5, 0xa9, 0xe9, 0xb6, 0x68, 0xc9, 0xdc, 0xc0, 0x7d, 0x7f, 0x62, 0xe5, 0xc2, 0xf1, 0x51, 0xf1, + 0xbc, 0x8d, 0x05, 0x96, 0xe7, 0xb6, 0xa8, 0x65, 0x7b, 0xea, 0xec, 0xd6, 0x69, 0xc8, 0x3d, 0x80, + 0x7b, 0x5d, 0xda, 0xa9, 0x53, 0xdb, 0x6b, 0xec, 0xc7, 0xb6, 0xf9, 0xa8, 0x60, 0xe5, 0x19, 0xd1, + 0xc2, 0x05, 0xb7, 0x4b, 0x3b, 0x3e, 0xc2, 0xd4, 0xaf, 0x8a, 0x30, 0xc9, 0x36, 0xcc, 0x56, 0x4b, + 0x77, 0x6b, 0x6e, 0xcb, 0x69, 0x1c, 0x0a, 0xc9, 0x69, 0x06, 0xb5, 0x83, 0x67, 0x05, 0xd7, 0x58, + 0x29, 0xdf, 0x9e, 0x1c, 0xbb, 0x6d, 0x75, 0x11, 0x6a, 0x09, 0xf9, 0x29, 0xce, 0x85, 0x7c, 0xc0, + 0xe6, 0xa0, 0xcf, 0x84, 0xc1, 0x4d, 0x7b, 0xcf, 0x5f, 0x9c, 0xd5, 0xb4, 0x5d, 0xa5, 0xed, 0xfa, + 0x55, 0xa5, 0x94, 0x8b, 0x29, 0x4b, 0x7c, 0x22, 0x22, 0xd4, 0x0a, 0xec, 0x3d, 0x5f, 0x9f, 0x88, + 0x21, 0x36, 0xb9, 0x0d, 0x50, 0x71, 0x1b, 0xbd, 0x36, 0xed, 0x04, 0x95, 0x95, 0xc5, 0x82, 0x7e, + 0x15, 0x08, 0x0b, 0xa2, 0xad, 0xad, 0xe9, 0x36, 0xb4, 0x99, 0xa8, 0x50, 0x2f, 0xbd, 0x0b, 0x85, + 0xf8, 0x87, 0x9c, 0x52, 0x81, 0x35, 0x5d, 0x98, 0x51, 0x5a, 0xbf, 0xfa, 0xc8, 0xf1, 0x03, 0xdf, + 0xf8, 0x96, 0xb6, 0x02, 0xd9, 0xee, 0x70, 0x87, 0x1e, 0xd6, 0x3c, 0xba, 0xeb, 0x3c, 0x12, 0x9b, + 0x19, 0xee, 0x0e, 0x07, 0xf4, 0xd0, 0xea, 0x22, 0x54, 0xdd, 0x1d, 0x42, 0x54, 0xf2, 0x79, 0xc8, + 0xdf, 0xb9, 0x5b, 0xbf, 0x43, 0x0f, 0xab, 0x15, 0x71, 0x50, 0x71, 0xb2, 0xb6, 0x6f, 0x31, 0x52, + 0x6d, 0xae, 0x85, 0x98, 0xc6, 0x4a, 0xb4, 0x13, 0xb2, 0x9a, 0xcb, 0xad, 0x9e, 0x1f, 0x50, 0xaf, + 0x5a, 0x51, 0x6b, 0x6e, 0x70, 0x60, 0x6c, 0x5f, 0x0a, 0x51, 0x8d, 0xff, 0x3f, 0x8b, 0xbb, 0x20, + 0x9b, 0xf0, 0xd5, 0x8e, 0x1f, 0xd8, 0x9d, 0x06, 0x0d, 0x19, 0xe0, 0x84, 0x77, 0x04, 0x34, 0x36, + 0xe1, 0x23, 0x64, 0xbd, 0xea, 0xec, 0xd0, 0x55, 0xb3, 0x2a, 0xa5, 0xe6, 0xa2, 0x5a, 0x51, 0xd5, + 0xab, 0x9e, 0x80, 0xc6, 0xaa, 0x8c, 0x90, 0xc9, 0x25, 0x18, 0xaf, 0x96, 0xee, 0x96, 0x7a, 0xc1, + 0x3e, 0xee, 0xc1, 0x79, 0x2e, 0x9f, 0xb3, 0xd9, 0x6a, 0xf7, 0x82, 0x7d, 0x53, 0x16, 0x92, 0x6b, + 0x78, 0xef, 0xe9, 0xd0, 0x80, 0xab, 0x61, 0xc5, 0xa1, 0xeb, 0x73, 0x50, 0xec, 0xda, 0xc3, 0x40, + 0xe4, 0x65, 0x18, 0xbd, 0x5f, 0x2b, 0x57, 0x2b, 0xe2, 0xe2, 0x8c, 0x27, 0xd1, 0x83, 0x6e, 0x43, + 0xff, 0x12, 0x8e, 0x42, 0x56, 0x61, 0xa6, 0x4e, 0x1b, 0x3d, 0xcf, 0x09, 0x0e, 0x6f, 0x79, 0x6e, + 0xaf, 0xeb, 0x2f, 0x8e, 0x63, 0x1d, 0xb8, 0xd2, 0x7d, 0x51, 0x62, 0xed, 0x61, 0x91, 0x42, 0x1d, + 0x23, 0x32, 0x7e, 0x33, 0x13, 0x6d, 0x93, 0xe4, 0x92, 0x26, 0xd6, 0xa0, 0xee, 0x86, 0x89, 0x35, + 0xaa, 0xee, 0x06, 0x05, 0x1c, 0x13, 0x48, 0xb9, 0xe7, 0x07, 0x6e, 0x7b, 0xb5, 0xd3, 0xec, 0xba, + 0x4e, 0x27, 0x40, 0x2a, 0xde, 0xf9, 0xc6, 0xf1, 0x51, 0xf1, 0xd9, 0x06, 0x96, 0x5a, 0x54, 0x14, + 0x5b, 0x31, 0x2e, 0x29, 0xd4, 0x9f, 0x60, 0x3c, 0x8c, 0x7f, 0x91, 0xd5, 0x8e, 0x37, 0xf6, 0x79, + 0x26, 0xed, 0xb6, 0x9c, 0x06, 0xde, 0xe8, 0xb1, 0xa1, 0xe1, 0xac, 0xc2, 0xcf, 0xf3, 0xa2, 0x52, + 0xde, 0x43, 0x3a, 0xef, 0x14, 0x6a, 0xf2, 0x65, 0x98, 0x62, 0x92, 0x86, 0xf8, 0xe9, 0x2f, 0x66, + 0xb1, 0xb3, 0x9f, 0x41, 0x2d, 0x9c, 0x4f, 0xbd, 0x90, 0x8d, 0x26, 0xa2, 0xa8, 0x14, 0xa4, 0x09, + 0x8b, 0x9b, 0x9e, 0xdd, 0xf1, 0x9d, 0x60, 0xb5, 0xd3, 0xf0, 0x0e, 0x51, 0x32, 0x5a, 0xed, 0xd8, + 0x3b, 0x2d, 0xda, 0xc4, 0xe6, 0xe6, 0x57, 0x2e, 0x1f, 0x1f, 0x15, 0x5f, 0x08, 0x38, 0x8e, 0x45, + 0x43, 0x24, 0x8b, 0x72, 0x2c, 0x85, 0x73, 0x5f, 0x4e, 0x4c, 0x92, 0x92, 0xdd, 0x8a, 0x8f, 0x30, + 0x5c, 0x48, 0x40, 0x49, 0x2a, 0x1c, 0x0d, 0xb6, 0x87, 0xa9, 0x9f, 0xa9, 0x12, 0x18, 0xff, 0x4f, + 0x26, 0x3a, 0x80, 0xc9, 0xdb, 0x30, 0x29, 0x56, 0x8c, 0x32, 0x2f, 0x70, 0x07, 0x95, 0xcb, 0x2b, + 0x36, 0xb2, 0x2a, 0x3a, 0xbb, 0xf7, 0x97, 0xca, 0xeb, 0xca, 0xdc, 0xc0, 0x7b, 0xbf, 0xdd, 0x68, + 0xc5, 0xa9, 0x24, 0x1a, 0x9b, 0x04, 0x9b, 0xeb, 0x75, 0xbd, 0x57, 0x70, 0x12, 0x04, 0x2d, 0x3f, + 0xa5, 0x1b, 0x14, 0xe4, 0x4f, 0xde, 0xf0, 0xff, 0x25, 0x93, 0x76, 0xce, 0x93, 0x15, 0x98, 0xde, + 0x76, 0xbd, 0x03, 0x1c, 0x5f, 0xa5, 0x13, 0x70, 0xe4, 0x1f, 0xca, 0x82, 0x78, 0x83, 0x74, 0x12, + 0xf5, 0xdb, 0x94, 0xde, 0xd0, 0xbf, 0x2d, 0xc6, 0x41, 0x23, 0x60, 0xe3, 0x10, 0x72, 0x0c, 0x57, + 0x07, 0x8e, 0x43, 0xf4, 0x09, 0xda, 0x14, 0x56, 0xd1, 0x8d, 0x7f, 0x92, 0x51, 0xcf, 0x73, 0xd6, + 0xc9, 0x15, 0xb7, 0x6d, 0x3b, 0x1d, 0xa5, 0x39, 0xfc, 0x61, 0x09, 0xa1, 0xf1, 0x2f, 0x51, 0x90, + 0xc9, 0xeb, 0x90, 0xe7, 0xbf, 0xc2, 0xbd, 0x16, 0xb5, 0x5a, 0x82, 0x50, 0x3f, 0x28, 0x24, 0x62, + 0x62, 0x64, 0x72, 0xa7, 0x1d, 0x99, 0xdf, 0xc8, 0xa8, 0x47, 0xf1, 0xc7, 0x3d, 0x6c, 0x62, 0x87, + 0x4c, 0xf6, 0x34, 0x87, 0xcc, 0x27, 0x6e, 0xc2, 0xf7, 0x67, 0x60, 0x52, 0xd1, 0x52, 0xb0, 0x36, + 0xd4, 0x3c, 0xf7, 0x23, 0xda, 0x08, 0xf4, 0x36, 0x74, 0x39, 0x30, 0xd6, 0x86, 0x10, 0xf5, 0x13, + 0xb4, 0xc1, 0xf8, 0xe3, 0x8c, 0xb8, 0x23, 0x0d, 0xbd, 0xcd, 0xeb, 0x5b, 0x72, 0xf6, 0x34, 0x47, + 0xe4, 0x97, 0x61, 0xd4, 0xa4, 0x4d, 0xc7, 0x17, 0xf7, 0x9b, 0x39, 0xf5, 0x3e, 0x86, 0x05, 0x91, + 0xdc, 0xe4, 0xb1, 0x9f, 0xea, 0xf9, 0x86, 0xe5, 0x4c, 0x90, 0xad, 0xfa, 0x37, 0x5b, 0xf4, 0x91, + 0xc3, 0x17, 0xa3, 0x38, 0x6a, 0xf1, 0x78, 0x73, 0x7c, 0x6b, 0x97, 0x95, 0x08, 0x89, 0x5a, 0x5d, + 0x78, 0x1a, 0x8d, 0xf1, 0x01, 0x40, 0x54, 0x25, 0xb9, 0x03, 0x05, 0x31, 0x1b, 0x9c, 0xce, 0x1e, + 0x17, 0xa4, 0x44, 0x1f, 0x14, 0x8f, 0x8f, 0x8a, 0x4f, 0x37, 0xc2, 0x32, 0x21, 0x75, 0x2a, 0x7c, + 0x13, 0x84, 0xc6, 0xff, 0x91, 0x83, 0x6c, 0x09, 0x07, 0xe4, 0x0e, 0x3d, 0x0c, 0xec, 0x9d, 0x9b, + 0x4e, 0x4b, 0x5b, 0x4c, 0x07, 0x08, 0xb5, 0x76, 0x1d, 0x4d, 0x5d, 0xa1, 0x20, 0xb3, 0xc5, 0x74, + 0xc7, 0xdb, 0x79, 0x03, 0x09, 0x95, 0xc5, 0x74, 0xe0, 0xed, 0xbc, 0x11, 0x27, 0x0b, 0x11, 0x89, + 0x01, 0x63, 0x7c, 0x61, 0x89, 0x39, 0x08, 0xc7, 0x47, 0xc5, 0x31, 0xbe, 0xfe, 0x4c, 0x51, 0x42, + 0xce, 0x43, 0xae, 0x5e, 0xdb, 0x10, 0x3b, 0x20, 0xaa, 0x05, 0xfd, 0x6e, 0xc7, 0x64, 0x30, 0x56, + 0xe7, 0x7a, 0xa5, 0x54, 0x43, 0x45, 0xc0, 0x68, 0x54, 0x67, 0xab, 0x69, 0x77, 0xe3, 0xaa, 0x80, + 0x10, 0x91, 0xbc, 0x03, 0x93, 0x77, 0x2a, 0xe5, 0x35, 0xd7, 0xe7, 0xbb, 0xd7, 0x58, 0x34, 0xf9, + 0x0f, 0x9a, 0x0d, 0x0b, 0x35, 0xf1, 0xf1, 0x63, 0x40, 0xc1, 0x27, 0x16, 0x9c, 0x65, 0xac, 0xd8, + 0x90, 0x38, 0x0d, 0x2a, 0x2e, 0xa5, 0x1b, 0x91, 0xde, 0xff, 0xa5, 0xe3, 0xa3, 0xe2, 0xf3, 0xf8, + 0x05, 0x3e, 0x47, 0xb1, 0xe4, 0x75, 0x36, 0xc6, 0xb5, 0x0f, 0x1b, 0xf2, 0x35, 0x38, 0x93, 0x2c, + 0xa9, 0x87, 0xef, 0x05, 0x97, 0x8e, 0x8f, 0x8a, 0x46, 0x2a, 0x7f, 0x5f, 0x9b, 0xbf, 0xe9, 0x4c, + 0x8c, 0x6f, 0x67, 0x61, 0x52, 0x51, 0xf3, 0x91, 0xcf, 0x8b, 0xf7, 0xdd, 0x8c, 0x76, 0x81, 0x51, + 0x30, 0x58, 0x29, 0xd7, 0x09, 0xb5, 0xdd, 0x26, 0x15, 0xaf, 0xbd, 0x91, 0xfe, 0x25, 0x3b, 0x8c, + 0xfe, 0xe5, 0x4d, 0x00, 0x3e, 0x85, 0xb1, 0x9f, 0x14, 0x69, 0x48, 0x31, 0xf3, 0x50, 0xa7, 0x55, + 0x84, 0x4c, 0xee, 0xc3, 0xfc, 0xa6, 0xd7, 0xf3, 0x83, 0xfa, 0xa1, 0x1f, 0xd0, 0x36, 0xe3, 0x56, + 0x73, 0xdd, 0x96, 0x58, 0x3e, 0x2f, 0x1c, 0x1f, 0x15, 0x2f, 0xa2, 0x6d, 0x8a, 0xe5, 0x63, 0x39, + 0x7e, 0x80, 0xd5, 0x75, 0x5d, 0x55, 0x2b, 0x93, 0xc6, 0xc0, 0x30, 0x61, 0x4a, 0xd5, 0xe9, 0xb0, + 0x83, 0x51, 0xbc, 0x85, 0x09, 0x4d, 0xbd, 0x72, 0x30, 0x8a, 0xaf, 0x4c, 0xbe, 0xcd, 0xe9, 0x24, + 0xc6, 0xe7, 0x55, 0x7d, 0xe2, 0xb0, 0xfb, 0x92, 0xf1, 0x83, 0x99, 0x68, 0x17, 0xbc, 0x7f, 0x9d, + 0xbc, 0x05, 0x63, 0xfc, 0xed, 0x51, 0x3c, 0xd1, 0x9e, 0x09, 0xef, 0xe4, 0xea, 0xc3, 0x24, 0x57, + 0xe4, 0xff, 0x2e, 0xb7, 0x4f, 0x78, 0xca, 0x14, 0x24, 0xe1, 0x1b, 0x80, 0xae, 0x0e, 0x94, 0xdc, + 0x51, 0xdb, 0x7d, 0x3d, 0xed, 0x0d, 0xc0, 0xf8, 0xff, 0x46, 0x60, 0x46, 0x47, 0x53, 0x1f, 0x28, + 0x33, 0x43, 0x3d, 0x50, 0x7e, 0x19, 0xf2, 0x62, 0xbe, 0x49, 0x81, 0xf2, 0x05, 0x7c, 0x19, 0x11, + 0x30, 0xed, 0xe1, 0x1d, 0xf8, 0x70, 0xb0, 0x2b, 0xba, 0x19, 0x52, 0x91, 0x65, 0xe5, 0x15, 0x2d, + 0x17, 0xc9, 0x58, 0xf2, 0x15, 0x4d, 0x5d, 0xce, 0xe1, 0x7b, 0xda, 0x6b, 0x30, 0xc6, 0xae, 0x27, + 0xa1, 0x06, 0x09, 0xbf, 0x92, 0xdd, 0x5c, 0x62, 0x16, 0x36, 0x1c, 0x89, 0x6c, 0x43, 0x7e, 0xdd, + 0xf6, 0x83, 0x3a, 0xa5, 0x9d, 0x21, 0x4c, 0x0f, 0x8a, 0xa2, 0xab, 0xe6, 0xf1, 0x5d, 0xdf, 0xa7, + 0xb4, 0x13, 0x7b, 0x3b, 0x0e, 0x99, 0x91, 0x0f, 0x01, 0xca, 0x6e, 0x27, 0xf0, 0xdc, 0xd6, 0xba, + 0xbb, 0xb7, 0x38, 0x86, 0x57, 0xf7, 0x67, 0x63, 0x03, 0x10, 0x21, 0xf0, 0xdb, 0x7b, 0xa8, 0x9f, + 0x6a, 0xf0, 0x02, 0xab, 0xe5, 0xee, 0xa9, 0xeb, 0x20, 0xc2, 0x27, 0x37, 0xa1, 0x20, 0xf5, 0x22, + 0x5b, 0xdd, 0x3d, 0x0f, 0x27, 0xc8, 0x78, 0x24, 0x38, 0xd1, 0x47, 0x81, 0xd5, 0x13, 0x70, 0x75, + 0xa3, 0x8f, 0xd3, 0x90, 0xaf, 0xc1, 0xb9, 0x38, 0x4c, 0x8e, 0x72, 0x3e, 0xba, 0x52, 0xa8, 0xec, + 0x52, 0xe6, 0x7d, 0x3f, 0x16, 0xe4, 0x06, 0x4c, 0xf2, 0x77, 0x7a, 0xaf, 0xda, 0xd9, 0x75, 0x85, + 0xb6, 0x5f, 0x2a, 0xc1, 0x45, 0xc9, 0xfd, 0x65, 0x56, 0x66, 0xaa, 0x88, 0xc6, 0x77, 0xb3, 0x70, + 0xae, 0x4f, 0x27, 0xb1, 0x75, 0x84, 0x52, 0x8a, 0xb2, 0x8e, 0x62, 0xc2, 0x09, 0x37, 0xb5, 0xba, + 0x08, 0x59, 0x71, 0xae, 0x8f, 0xac, 0x14, 0x8e, 0x8f, 0x8a, 0x53, 0xda, 0xf8, 0x67, 0xab, 0x15, + 0x72, 0x1b, 0x46, 0xd8, 0xd0, 0x0e, 0x61, 0x31, 0x20, 0x55, 0x69, 0x33, 0x81, 0xa3, 0x4e, 0x3b, + 0x1c, 0x72, 0xe4, 0x41, 0x3e, 0x0f, 0xb9, 0xcd, 0xcd, 0x75, 0x9c, 0x73, 0x39, 0xec, 0xb3, 0xe9, + 0x20, 0x68, 0x69, 0x53, 0x7c, 0x9a, 0xd1, 0x5e, 0x0d, 0x0d, 0x4c, 0x18, 0x3a, 0xf9, 0x4a, 0xcc, + 0x92, 0xe9, 0xe5, 0xc1, 0x13, 0x64, 0x78, 0xc3, 0xa6, 0x4f, 0x60, 0x4f, 0x64, 0xfc, 0x78, 0x46, + 0x1a, 0x6d, 0x88, 0xb1, 0x21, 0x17, 0xe5, 0x30, 0xe2, 0x75, 0x4f, 0x70, 0x51, 0x41, 0xe4, 0x59, + 0x00, 0xfe, 0x73, 0x6b, 0x4b, 0x74, 0xfa, 0x94, 0xa9, 0x40, 0xc8, 0x97, 0x42, 0x96, 0x42, 0x41, + 0x96, 0xc3, 0xf3, 0x25, 0x36, 0x15, 0x78, 0x99, 0xa9, 0xa3, 0x1a, 0xbf, 0x9e, 0x8d, 0xf6, 0xa2, + 0x9b, 0x4e, 0x2b, 0xa0, 0x1e, 0x59, 0xe2, 0x5b, 0x4b, 0x24, 0x23, 0x9b, 0xe1, 0x6f, 0xb2, 0x18, + 0xed, 0x53, 0xbc, 0x69, 0xe1, 0x86, 0xf4, 0xb2, 0xb2, 0x21, 0xe5, 0x70, 0x43, 0x9a, 0xe9, 0xbb, + 0xf5, 0xbc, 0x9c, 0xb2, 0xbe, 0x70, 0x43, 0x49, 0x59, 0x43, 0x2f, 0xc0, 0xf4, 0x86, 0xbb, 0xfa, + 0x28, 0x08, 0x11, 0xd9, 0x46, 0x92, 0x37, 0x75, 0x20, 0xe3, 0x78, 0xaf, 0xd5, 0xa4, 0xde, 0xe6, + 0xbe, 0xdd, 0xd1, 0x4c, 0x08, 0xcc, 0x04, 0x9c, 0xe1, 0x6e, 0xd0, 0x87, 0x3a, 0xee, 0x38, 0xc7, + 0x8d, 0xc3, 0xe3, 0x83, 0x93, 0x4f, 0x0c, 0x8e, 0xf1, 0x03, 0x59, 0xd9, 0x5d, 0xf7, 0x97, 0x9f, + 0xd0, 0xc7, 0xec, 0x37, 0xb4, 0xc7, 0xec, 0xf9, 0x50, 0x0d, 0x1f, 0x5a, 0x66, 0x2c, 0x9f, 0x60, + 0xd0, 0xf1, 0xb7, 0xc6, 0x60, 0x4a, 0x45, 0x67, 0xfd, 0x50, 0x6a, 0x36, 0x3d, 0xb5, 0x1f, 0xec, + 0x66, 0xd3, 0x33, 0x11, 0xaa, 0xd9, 0x6f, 0xe4, 0x06, 0xda, 0x6f, 0x7c, 0x1d, 0x26, 0xca, 0xed, + 0xa6, 0xf6, 0xaa, 0x6c, 0xa4, 0x7c, 0xde, 0xd5, 0x10, 0x89, 0xaf, 0xde, 0x50, 0xbb, 0xdc, 0x68, + 0x37, 0x93, 0x6f, 0xc9, 0x11, 0x4b, 0xcd, 0xf4, 0x63, 0xf4, 0x93, 0x98, 0x7e, 0xdc, 0x80, 0x89, + 0x2d, 0x9f, 0x6e, 0xf6, 0x3a, 0x1d, 0xda, 0xc2, 0x89, 0x97, 0xe7, 0x97, 0xb2, 0x9e, 0x4f, 0xad, + 0x00, 0xa1, 0xea, 0x07, 0x84, 0xa8, 0xea, 0x00, 0x8f, 0x0f, 0x18, 0xe0, 0xd7, 0x21, 0x5f, 0xa3, + 0xd4, 0xc3, 0x3e, 0x9d, 0x8c, 0x64, 0xef, 0x2e, 0xa5, 0x9e, 0xc5, 0x3a, 0x56, 0x33, 0x09, 0x11, + 0x88, 0x9a, 0x1d, 0xc9, 0xd4, 0x90, 0x76, 0x24, 0xe4, 0x39, 0x98, 0xea, 0xf6, 0x76, 0x5a, 0x4e, + 0x03, 0xf9, 0x0a, 0x03, 0x14, 0x73, 0x92, 0xc3, 0x18, 0x5b, 0x9f, 0x7c, 0x05, 0xa6, 0xf1, 0x32, + 0x1a, 0x4e, 0xb9, 0x19, 0xed, 0xe4, 0xd1, 0xca, 0xb8, 0x4c, 0xd7, 0x60, 0x20, 0x2b, 0xc5, 0x4e, + 0x4a, 0x67, 0x44, 0x6e, 0xc3, 0xf8, 0x9e, 0x13, 0x58, 0xfb, 0xbd, 0x9d, 0xc5, 0x59, 0xcd, 0xc8, + 0xe8, 0x96, 0x13, 0xac, 0xf5, 0x76, 0xf8, 0x90, 0x87, 0xac, 0x71, 0x8f, 0xde, 0x73, 0x82, 0xfd, + 0x9e, 0xaa, 0x3b, 0x1f, 0xdb, 0x43, 0xdc, 0xa5, 0x3a, 0xcc, 0xe8, 0xb3, 0xe2, 0x31, 0xbc, 0xe8, + 0x86, 0xf6, 0x35, 0xf9, 0xc2, 0xc4, 0xed, 0x91, 0x3c, 0x14, 0x26, 0xb9, 0x65, 0x8d, 0x09, 0xb5, + 0xb0, 0x7f, 0x4c, 0x72, 0xa7, 0xb7, 0x43, 0xbd, 0x0e, 0x0d, 0xa8, 0x2f, 0x6e, 0x7e, 0xbe, 0x39, + 0x52, 0xea, 0x76, 0x7d, 0xe3, 0x1f, 0x64, 0x61, 0xbc, 0xb4, 0x5d, 0xc7, 0x5d, 0xff, 0x55, 0xf5, + 0x39, 0x4e, 0x7d, 0x97, 0x0d, 0x9f, 0xe3, 0xd4, 0x47, 0xb8, 0x6b, 0x29, 0x77, 0x77, 0x34, 0xdd, + 0x56, 0xee, 0xee, 0x9a, 0xd6, 0x21, 0x7a, 0x99, 0xcc, 0x0d, 0xf1, 0x32, 0x19, 0x2a, 0x8f, 0x47, + 0x4e, 0x56, 0x1e, 0xbf, 0x05, 0x93, 0xd5, 0x4e, 0x40, 0xf7, 0xbc, 0x68, 0xd5, 0x84, 0x7a, 0x84, + 0x10, 0xac, 0xde, 0xe7, 0x14, 0x6c, 0x36, 0x25, 0xb9, 0xc2, 0x3a, 0x54, 0x54, 0xe3, 0x94, 0xe4, + 0x7a, 0xed, 0x98, 0x12, 0x48, 0x22, 0x1a, 0x95, 0xd8, 0x7c, 0x93, 0xd6, 0x1f, 0x5c, 0x64, 0x9f, + 0x89, 0x5e, 0x6c, 0x58, 0xc7, 0xae, 0xcc, 0xa5, 0x5b, 0x7f, 0x18, 0x7f, 0x39, 0x03, 0x0b, 0x69, + 0xd3, 0x88, 0xbc, 0x0b, 0x53, 0xae, 0xb7, 0x67, 0x77, 0x9c, 0xef, 0xe5, 0x2d, 0x52, 0x34, 0x95, + 0x2a, 0x5c, 0xd5, 0xcf, 0xa8, 0x70, 0xd6, 0x21, 0x4a, 0xcb, 0x75, 0xc5, 0x4a, 0x6a, 0x87, 0x28, + 0x60, 0xe3, 0x47, 0xb2, 0x30, 0x59, 0xea, 0x76, 0x9f, 0x70, 0xcb, 0xc0, 0x2f, 0x6a, 0x07, 0x88, + 0xbc, 0xd7, 0x86, 0xed, 0x1a, 0xca, 0x28, 0xf0, 0x57, 0xb2, 0x30, 0x1b, 0xa3, 0x50, 0xbf, 0x3e, + 0x33, 0xa4, 0x3d, 0x60, 0x76, 0x48, 0x7b, 0xc0, 0xdc, 0x70, 0xf6, 0x80, 0x23, 0x9f, 0xe4, 0x50, + 0x78, 0x09, 0x72, 0xa5, 0x6e, 0x37, 0x6e, 0x57, 0xd0, 0xed, 0xde, 0x7f, 0x9d, 0xab, 0x56, 0xec, + 0x6e, 0xd7, 0x64, 0x18, 0xda, 0x4e, 0x3d, 0x36, 0xe4, 0x4e, 0x6d, 0xbc, 0x06, 0x13, 0xc8, 0x0b, + 0xad, 0xf0, 0x2e, 0x02, 0x6e, 0x31, 0xc2, 0x00, 0x4f, 0xab, 0x4b, 0x6c, 0x3e, 0xff, 0x36, 0x03, + 0xa3, 0xf8, 0xfb, 0x09, 0x9d, 0x63, 0xcb, 0xda, 0x1c, 0x2b, 0x28, 0x73, 0x6c, 0x98, 0xd9, 0xf5, + 0x77, 0x73, 0x00, 0xe5, 0x7b, 0x66, 0x9d, 0x6b, 0xe0, 0xc8, 0x4d, 0x98, 0xb5, 0x5b, 0x2d, 0xf7, + 0x21, 0x6d, 0x5a, 0xae, 0xe7, 0xec, 0x39, 0x1d, 0xde, 0x73, 0xf2, 0xb1, 0x5b, 0x2f, 0x52, 0x9f, + 0xc0, 0x44, 0xd1, 0x3d, 0x5e, 0xa2, 0xf2, 0x69, 0xd3, 0x60, 0xdf, 0x6d, 0xca, 0xcb, 0xb8, 0xc6, + 0x47, 0x14, 0xa5, 0xf0, 0xb9, 0xcb, 0x4b, 0x54, 0x3e, 0xfb, 0xa8, 0x5c, 0x90, 0x32, 0xb4, 0xc6, + 0x47, 0x14, 0xa5, 0xf0, 0xe1, 0x1a, 0x09, 0x9f, 0xac, 0xc3, 0x1c, 0x42, 0xac, 0x86, 0x47, 0x9b, + 0xb4, 0x13, 0x38, 0x76, 0xcb, 0x17, 0xea, 0x1b, 0xd4, 0x53, 0x26, 0x0a, 0xd5, 0xeb, 0x2b, 0x16, + 0x96, 0xa3, 0x32, 0x72, 0x15, 0xc6, 0xdb, 0xf6, 0x23, 0xcb, 0xde, 0xe3, 0x66, 0x1f, 0xd3, 0xfc, + 0xba, 0x2f, 0x40, 0xea, 0x31, 0xd2, 0xb6, 0x1f, 0x95, 0xf6, 0x28, 0x6b, 0x05, 0x7d, 0xd4, 0x75, + 0x7d, 0xa5, 0x15, 0x63, 0x51, 0x2b, 0x62, 0x45, 0x6a, 0x2b, 0x44, 0x91, 0x68, 0x85, 0xf1, 0xcb, + 0x19, 0x78, 0xba, 0x8a, 0x5f, 0x11, 0x1c, 0x96, 0x69, 0x27, 0xa0, 0x5e, 0x8d, 0x7a, 0x6d, 0x07, + 0x1f, 0xc1, 0xeb, 0x34, 0x20, 0xcf, 0x43, 0xae, 0x64, 0x6e, 0x88, 0xf9, 0xcb, 0xf7, 0x7b, 0xcd, + 0x24, 0x81, 0x95, 0x86, 0x1a, 0xa1, 0xec, 0x09, 0x9a, 0xea, 0x12, 0x4c, 0x95, 0x7c, 0xdf, 0xd9, + 0xeb, 0xb4, 0xb9, 0x3b, 0x45, 0x4e, 0x33, 0x7a, 0x10, 0xf0, 0xc4, 0x13, 0x8b, 0x4a, 0x62, 0xfc, + 0x57, 0x19, 0x98, 0x2b, 0x75, 0xbb, 0xfa, 0x27, 0xeb, 0x06, 0x37, 0x99, 0xe1, 0x0d, 0x6e, 0x1c, + 0x98, 0xd1, 0x9a, 0xcb, 0xa7, 0x54, 0x24, 0xf8, 0x0e, 0xe8, 0x19, 0xfe, 0xd9, 0xdd, 0x10, 0x64, + 0xf9, 0xfa, 0x6b, 0x71, 0x8c, 0xb1, 0xf1, 0xef, 0xc6, 0x71, 0x0f, 0x11, 0xbb, 0xad, 0x30, 0x09, + 0xcd, 0xa4, 0x98, 0x84, 0xbe, 0x09, 0x8a, 0x84, 0xa3, 0x1e, 0x71, 0x8a, 0xac, 0xa8, 0xea, 0x52, + 0x22, 0x64, 0x72, 0x10, 0x37, 0x0e, 0xcd, 0x61, 0x6b, 0x9e, 0x8f, 0x2f, 0xe0, 0xc7, 0x62, 0x17, + 0xba, 0x06, 0xa4, 0xda, 0xc1, 0x17, 0x6c, 0x5a, 0x3f, 0x70, 0xba, 0xf7, 0xa9, 0xe7, 0xec, 0x1e, + 0x8a, 0x05, 0x80, 0x9d, 0xef, 0x88, 0x52, 0xcb, 0x3f, 0x70, 0xba, 0xd6, 0x03, 0x2c, 0x37, 0x53, + 0x68, 0xc8, 0x7b, 0x30, 0x6e, 0xd2, 0x87, 0x9e, 0x13, 0x48, 0x93, 0xa7, 0x99, 0x50, 0x35, 0x88, + 0x50, 0xbe, 0x16, 0x3c, 0xfe, 0x43, 0xdd, 0x15, 0x45, 0x39, 0x59, 0xe6, 0x42, 0x0a, 0x37, 0x6d, + 0x9a, 0x8e, 0x5a, 0x5b, 0xda, 0xae, 0xf7, 0x93, 0x51, 0xc8, 0x15, 0x18, 0x45, 0x49, 0x47, 0xdc, + 0x05, 0xd0, 0x55, 0x08, 0x65, 0x67, 0x55, 0x0c, 0x43, 0x0c, 0xd4, 0x09, 0xc8, 0x27, 0x62, 0x7f, + 0x31, 0x8f, 0x52, 0xba, 0x02, 0x89, 0x8b, 0x69, 0x13, 0xa7, 0x12, 0xd3, 0xd6, 0xa1, 0x60, 0x72, + 0xaf, 0xc3, 0x66, 0xa9, 0x8b, 0xef, 0x90, 0xfe, 0x22, 0xe0, 0x4a, 0xbe, 0x78, 0x7c, 0x54, 0x7c, + 0x46, 0x78, 0x24, 0x36, 0x2d, 0xbb, 0xcb, 0x9f, 0x2f, 0xb5, 0x6d, 0x24, 0x4e, 0x49, 0xde, 0x84, + 0x11, 0xb6, 0xf5, 0x0a, 0x33, 0x52, 0xf9, 0x9e, 0x13, 0xed, 0xc6, 0x7c, 0x71, 0x36, 0x5c, 0x6d, + 0x4f, 0x40, 0x12, 0x62, 0xc1, 0x8c, 0x3e, 0xdd, 0x85, 0x45, 0xd1, 0x62, 0xd4, 0x9f, 0x7a, 0xb9, + 0x78, 0xe4, 0x11, 0x30, 0xab, 0x81, 0x40, 0x75, 0x05, 0xc4, 0x16, 0xe9, 0x2a, 0xe4, 0x37, 0xcb, + 0xb5, 0x9a, 0xeb, 0x05, 0xfc, 0xaa, 0x13, 0x9d, 0x2c, 0x0c, 0x66, 0xda, 0x9d, 0x3d, 0xca, 0xcf, + 0xe2, 0xa0, 0xd1, 0xb5, 0xba, 0x0c, 0x4d, 0x3d, 0x8b, 0x25, 0x29, 0xf9, 0x10, 0xce, 0x6c, 0xf9, + 0xb4, 0xd4, 0x39, 0xc4, 0xd3, 0x59, 0x59, 0x2a, 0x33, 0x38, 0xf5, 0xf0, 0x99, 0x82, 0x5d, 0x05, + 0xed, 0xce, 0xa1, 0xc5, 0x4f, 0xf5, 0xf4, 0x85, 0x93, 0xce, 0xe5, 0xd3, 0xb3, 0x50, 0xfd, 0x95, + 0x2c, 0x3c, 0x1f, 0x0a, 0x5d, 0xf7, 0xbc, 0x7a, 0xe9, 0xee, 0x7a, 0xb5, 0x29, 0x1f, 0x32, 0x6a, + 0x9e, 0xfb, 0xc0, 0x69, 0x52, 0xef, 0xfe, 0xf5, 0x13, 0x44, 0x86, 0x75, 0xbe, 0x8b, 0xf0, 0xb7, + 0xb6, 0xac, 0x66, 0xcb, 0xa7, 0xc8, 0xb6, 0x62, 0xf7, 0xeb, 0x76, 0x13, 0x4f, 0x6f, 0x6b, 0x4f, + 0x99, 0x11, 0x03, 0xf2, 0x83, 0x19, 0x38, 0x9b, 0xfe, 0x21, 0x42, 0x97, 0x58, 0x94, 0x1a, 0x80, + 0x3e, 0x5f, 0xcb, 0xbb, 0xdb, 0xb7, 0xdb, 0x2d, 0xcb, 0x69, 0x46, 0x2f, 0x37, 0x5d, 0x81, 0xa0, + 0xd5, 0xdb, 0xa7, 0xa6, 0x2f, 0x81, 0x94, 0x1c, 0x16, 0x33, 0x2b, 0x00, 0x79, 0xf9, 0x1e, 0x60, + 0xfc, 0xc3, 0x0c, 0x28, 0x2b, 0x3c, 0x6f, 0xd2, 0xa6, 0xe3, 0xd1, 0x46, 0x20, 0xa4, 0x07, 0xe1, + 0x89, 0xc8, 0x61, 0x31, 0xd3, 0x4d, 0x84, 0x91, 0x77, 0x61, 0x5c, 0x9c, 0x72, 0x62, 0x57, 0x97, + 0x3b, 0x83, 0x78, 0x69, 0xe0, 0x2e, 0xab, 0x89, 0x13, 0x52, 0x12, 0xb1, 0x43, 0xe5, 0xf6, 0xf6, + 0x66, 0xb9, 0x65, 0x3b, 0x6d, 0x5f, 0x1c, 0x55, 0xd8, 0xad, 0x1f, 0x3d, 0x0c, 0xac, 0x06, 0x42, + 0xd5, 0x43, 0x25, 0x44, 0x35, 0x6e, 0xc9, 0x87, 0x8e, 0x13, 0xec, 0x8f, 0x8b, 0x30, 0x7a, 0x3f, + 0x52, 0x5c, 0xae, 0x4c, 0x1c, 0x1f, 0x15, 0xf9, 0x74, 0x31, 0x39, 0xdc, 0xa0, 0x30, 0x11, 0xae, + 0x0c, 0xc6, 0x8b, 0xfd, 0x40, 0x5e, 0xd3, 0x9c, 0x17, 0x5b, 0x23, 0x26, 0x42, 0x99, 0x24, 0xb9, + 0xda, 0x69, 0x22, 0x42, 0x16, 0x11, 0xb0, 0x7b, 0x68, 0xa7, 0x89, 0x0b, 0x49, 0x6d, 0x9d, 0x40, + 0x53, 0xe4, 0xb5, 0x1f, 0xcb, 0xc0, 0x8c, 0x3e, 0x6d, 0xc9, 0x55, 0x18, 0x13, 0xce, 0x86, 0x19, + 0xd4, 0x03, 0x33, 0x6e, 0x63, 0xdc, 0xcd, 0x50, 0x73, 0x2e, 0x14, 0x58, 0x4c, 0x2c, 0x15, 0x1c, + 0x84, 0x4c, 0x86, 0x62, 0x69, 0x83, 0x83, 0x4c, 0x59, 0x46, 0x0c, 0x76, 0x53, 0xf6, 0x7b, 0xad, + 0x40, 0x7d, 0x15, 0xf5, 0x10, 0x62, 0x8a, 0x12, 0xa3, 0x0c, 0x63, 0x7c, 0xe7, 0x8e, 0x99, 0x57, + 0x66, 0x4e, 0x61, 0x5e, 0x69, 0x1c, 0x65, 0x00, 0xea, 0xf5, 0xb5, 0x3b, 0xf4, 0xb0, 0x66, 0x3b, + 0x28, 0x1e, 0xf0, 0x15, 0x7e, 0x47, 0xac, 0xe1, 0x29, 0xf1, 0x8c, 0xcf, 0x37, 0x86, 0x03, 0x7a, + 0xa8, 0x3d, 0xe3, 0x4b, 0x54, 0x3c, 0x8a, 0x3d, 0xe7, 0x81, 0x1d, 0x50, 0x46, 0x88, 0xca, 0x60, + 0x71, 0x14, 0x73, 0x68, 0x8c, 0x52, 0x41, 0x26, 0x1f, 0xc2, 0x4c, 0xf4, 0x2b, 0x34, 0x46, 0x98, + 0x09, 0xf7, 0x09, 0xbd, 0x70, 0xe5, 0xd9, 0xe3, 0xa3, 0xe2, 0x92, 0xc2, 0x35, 0x6e, 0xa6, 0x10, + 0x63, 0x86, 0xb6, 0x22, 0x9b, 0xeb, 0x75, 0xd9, 0xc0, 0x4b, 0x30, 0x12, 0x1a, 0x8d, 0x4f, 0x89, + 0x3d, 0x5e, 0x7f, 0xb1, 0xc4, 0x72, 0x26, 0xcd, 0x45, 0x2d, 0xc1, 0x93, 0x51, 0x6f, 0x01, 0x2b, + 0x25, 0xb7, 0x60, 0x7c, 0xa8, 0x6f, 0xc6, 0x29, 0x96, 0xf2, 0xad, 0x92, 0x9a, 0x09, 0x39, 0x65, + 0x93, 0x3f, 0x25, 0x4c, 0x71, 0x21, 0xa7, 0xe1, 0xb5, 0x4c, 0x06, 0xc3, 0x01, 0xba, 0xbd, 0xbd, + 0xf9, 0xd9, 0x1d, 0xa0, 0x9f, 0xcc, 0xc2, 0x2c, 0xeb, 0xf2, 0x52, 0x2f, 0xd8, 0x77, 0x3d, 0x27, + 0x38, 0x7c, 0x62, 0x35, 0xd6, 0x6f, 0x6b, 0x97, 0xc1, 0x25, 0x79, 0xce, 0xa9, 0x6d, 0x1b, 0x4a, + 0x71, 0xfd, 0x2f, 0x47, 0x61, 0x3e, 0x85, 0x8a, 0xbc, 0xaa, 0x3d, 0x83, 0x2d, 0xca, 0x38, 0x03, + 0xdf, 0x3d, 0x2a, 0x4e, 0x49, 0xf4, 0xcd, 0x28, 0xee, 0xc0, 0xb2, 0x6e, 0xea, 0xc6, 0x7b, 0x0a, + 0x5f, 0xc5, 0x54, 0x53, 0x37, 0xdd, 0xc0, 0xed, 0x0a, 0x8c, 0x9a, 0x6e, 0x8b, 0x4a, 0xf3, 0x4e, + 0x14, 0xf5, 0x3c, 0x06, 0xd0, 0xcc, 0x59, 0x18, 0x80, 0xac, 0xc1, 0x38, 0xfb, 0xe3, 0xae, 0xdd, + 0x15, 0x2f, 0x9d, 0x24, 0x54, 0x47, 0x20, 0xb4, 0xeb, 0x74, 0xf6, 0x54, 0x8d, 0x44, 0x8b, 0x5a, + 0x6d, 0xbb, 0xab, 0xc9, 0xa4, 0x1c, 0x51, 0xd3, 0x6c, 0xe4, 0xfb, 0x6b, 0x36, 0x32, 0x27, 0x6a, + 0x36, 0x76, 0x01, 0xea, 0xce, 0x5e, 0xc7, 0xe9, 0xec, 0x95, 0x5a, 0x7b, 0x22, 0x5a, 0xc3, 0x95, + 0xfe, 0xa3, 0x70, 0x35, 0x42, 0xc6, 0x89, 0xfb, 0x34, 0x9a, 0x23, 0x70, 0x98, 0x65, 0xb7, 0xf6, + 0x34, 0xaf, 0x32, 0x85, 0x33, 0xd9, 0x00, 0x28, 0x35, 0x02, 0xe7, 0x01, 0x9b, 0xc2, 0xbe, 0x10, + 0x20, 0xe5, 0x27, 0x97, 0x4b, 0x77, 0xe8, 0x21, 0x5e, 0x7a, 0xe4, 0xc3, 0xae, 0x8d, 0xa8, 0x6c, + 0x25, 0x68, 0x2e, 0x43, 0x11, 0x07, 0xd2, 0x85, 0x33, 0xa5, 0x66, 0xd3, 0x61, 0x6d, 0xb0, 0x5b, + 0x9b, 0x3c, 0xce, 0x06, 0xb2, 0x9e, 0x4a, 0x67, 0x7d, 0x45, 0xb0, 0x7e, 0xce, 0x0e, 0xa9, 0x2c, + 0x19, 0x9e, 0x23, 0x56, 0x4d, 0x3a, 0x63, 0xa3, 0x0e, 0x33, 0x7a, 0xe3, 0xf5, 0x28, 0x13, 0x53, + 0x90, 0x37, 0xeb, 0x25, 0xab, 0xbe, 0x56, 0xba, 0x5e, 0xc8, 0x90, 0x02, 0x4c, 0x89, 0x5f, 0xcb, + 0xd6, 0xf2, 0x1b, 0x37, 0x0a, 0x59, 0x0d, 0xf2, 0xc6, 0xf5, 0xe5, 0x42, 0x6e, 0x29, 0xbb, 0x98, + 0x89, 0x39, 0x78, 0x8e, 0x17, 0xf2, 0x5c, 0x19, 0x6d, 0xfc, 0x6a, 0x06, 0xf2, 0xf2, 0xdb, 0xc9, + 0x0d, 0xc8, 0xd5, 0xeb, 0x6b, 0x31, 0x97, 0xcc, 0xe8, 0x00, 0xe2, 0x5b, 0xad, 0xef, 0xab, 0x76, + 0xf7, 0x8c, 0x80, 0xd1, 0x6d, 0xae, 0xd7, 0x85, 0x78, 0x22, 0xe9, 0xa2, 0x7d, 0x9d, 0xd3, 0xa5, + 0xf8, 0xa9, 0xdd, 0x80, 0xdc, 0xed, 0xed, 0x4d, 0x71, 0xbd, 0x93, 0x74, 0xd1, 0x7e, 0xca, 0xe9, + 0x3e, 0x7a, 0xa8, 0x1e, 0x00, 0x8c, 0xc0, 0x30, 0x61, 0x52, 0x99, 0xc8, 0xfc, 0x3c, 0x6e, 0xbb, + 0x61, 0x68, 0x05, 0x71, 0x1e, 0x33, 0x88, 0x29, 0x4a, 0x98, 0x94, 0xb2, 0xee, 0x36, 0xec, 0x96, + 0x38, 0xd8, 0x51, 0x4a, 0x69, 0x31, 0x80, 0xc9, 0xe1, 0xc6, 0x6f, 0x66, 0xa0, 0x80, 0xb2, 0x1c, + 0xda, 0xcd, 0xbb, 0x07, 0xb4, 0x73, 0xff, 0x3a, 0x79, 0x4d, 0x2e, 0xb9, 0x4c, 0xa8, 0x62, 0x1b, + 0xc5, 0x25, 0x17, 0x7b, 0xa7, 0x14, 0xcb, 0x4e, 0x89, 0x5e, 0x91, 0x1d, 0xde, 0xeb, 0xfd, 0x84, + 0xe8, 0x15, 0x45, 0x18, 0xc5, 0xcf, 0x11, 0x9b, 0x23, 0x7e, 0x79, 0xc0, 0x00, 0x26, 0x87, 0x2b, + 0x7b, 0xd3, 0x51, 0x36, 0xd1, 0x86, 0xe5, 0xcf, 0x94, 0xe7, 0xb8, 0xde, 0xb8, 0xfe, 0xfb, 0x35, + 0xb9, 0x13, 0xf3, 0x99, 0xbd, 0x90, 0xce, 0x80, 0xfb, 0xab, 0x2d, 0xf3, 0xe7, 0x0b, 0xee, 0xf5, + 0xa1, 0x2a, 0xa9, 0x12, 0xfe, 0xb3, 0x1f, 0xc0, 0x42, 0xbc, 0x7f, 0x51, 0x97, 0x5a, 0x82, 0x59, + 0x1d, 0x2e, 0xd5, 0xaa, 0xe7, 0x52, 0xeb, 0xbd, 0xbf, 0x6c, 0xc6, 0xf1, 0x8d, 0xff, 0x2d, 0x03, + 0x13, 0xf8, 0xa7, 0xd9, 0x6b, 0xa1, 0x31, 0x64, 0x69, 0xbb, 0x2e, 0x34, 0x3c, 0xaa, 0xd0, 0x68, + 0x3f, 0xf4, 0xa5, 0x41, 0x99, 0xb6, 0x61, 0x85, 0xc8, 0x82, 0x94, 0x3f, 0xd3, 0x48, 0xdd, 0x62, + 0x48, 0xca, 0xdf, 0x73, 0xfc, 0x18, 0xa9, 0x40, 0x46, 0x13, 0xea, 0xed, 0x3a, 0x9b, 0xcb, 0xaa, + 0x79, 0x0f, 0xd2, 0xb9, 0x2d, 0xdd, 0x84, 0x9a, 0xa3, 0xa1, 0x75, 0xcf, 0x76, 0xbd, 0x64, 0x6e, + 0x68, 0xd6, 0x3d, 0xec, 0x1b, 0x35, 0xf5, 0x9a, 0x40, 0x32, 0xfe, 0xc9, 0x74, 0xbc, 0x03, 0xc5, + 0xe9, 0x79, 0xca, 0x85, 0xf6, 0x16, 0x8c, 0x96, 0x5a, 0x2d, 0xf7, 0xa1, 0xd8, 0x72, 0xe4, 0x05, + 0x3c, 0xec, 0x3f, 0x7e, 0x38, 0xa2, 0x76, 0x52, 0x73, 0xad, 0x65, 0x00, 0x52, 0x86, 0x89, 0xd2, + 0x76, 0xbd, 0x5a, 0xad, 0x6c, 0x6e, 0x72, 0x37, 0xc2, 0xdc, 0xca, 0x8b, 0xb2, 0x7f, 0x1c, 0xa7, + 0x69, 0xc5, 0x0d, 0x45, 0xa2, 0x7b, 0x42, 0x44, 0x47, 0xde, 0x01, 0xb8, 0xed, 0x3a, 0x1d, 0xae, + 0x8d, 0x15, 0x8d, 0xbf, 0x70, 0x7c, 0x54, 0x9c, 0xfc, 0xc8, 0x75, 0x3a, 0x42, 0x7d, 0xcb, 0xbe, + 0x3d, 0x42, 0x32, 0x95, 0xbf, 0x59, 0x4f, 0xaf, 0xb8, 0xdc, 0x2c, 0x71, 0x34, 0xea, 0xe9, 0x1d, + 0x37, 0xa1, 0x36, 0x94, 0x68, 0xa4, 0x0d, 0xb3, 0xf5, 0xde, 0xde, 0x1e, 0x65, 0xc7, 0x84, 0x50, + 0x8b, 0x8d, 0x89, 0x2b, 0x7b, 0x18, 0xbc, 0x89, 0xdf, 0x7b, 0xd8, 0xa5, 0xcb, 0x5f, 0x79, 0x95, + 0xad, 0x8a, 0xef, 0x1c, 0x15, 0x85, 0x01, 0x0a, 0x93, 0xfb, 0x7c, 0x49, 0x9f, 0x54, 0x8a, 0xc5, + 0x79, 0x93, 0x7b, 0x30, 0xc6, 0x9f, 0xbe, 0x84, 0x5b, 0xdc, 0x73, 0x03, 0x56, 0x20, 0x47, 0xec, + 0xf7, 0xb8, 0xca, 0x4b, 0xc9, 0x36, 0xe4, 0xcb, 0x8e, 0xd7, 0x68, 0xd1, 0x72, 0x55, 0x08, 0x12, + 0xcf, 0x0f, 0x60, 0x29, 0x51, 0x79, 0xbf, 0x34, 0xf0, 0x57, 0xc3, 0x51, 0x05, 0x0b, 0x89, 0x41, + 0xfe, 0x72, 0x06, 0x9e, 0x0e, 0xbf, 0xbe, 0xb4, 0x47, 0x3b, 0xc1, 0x5d, 0x3b, 0x68, 0xec, 0x53, + 0x4f, 0xf4, 0xd2, 0xc4, 0xa0, 0x5e, 0xfa, 0x52, 0xa2, 0x97, 0x2e, 0x47, 0xbd, 0x64, 0x33, 0x66, + 0x56, 0x9b, 0x73, 0x4b, 0xf6, 0xd9, 0xa0, 0x5a, 0x89, 0x05, 0x10, 0x3d, 0xea, 0x0a, 0x43, 0xab, + 0x17, 0x07, 0x34, 0x38, 0x42, 0x16, 0xee, 0x50, 0xe1, 0x6f, 0xcd, 0x9e, 0x37, 0x84, 0x92, 0x3b, + 0xd2, 0x07, 0x95, 0x8b, 0x38, 0x17, 0x07, 0xf0, 0xe6, 0x7e, 0xa9, 0xf3, 0x03, 0xbc, 0xcd, 0xf9, + 0x68, 0xaf, 0xdb, 0x3b, 0x42, 0xaa, 0x39, 0x61, 0xb4, 0xd7, 0xed, 0x68, 0xb4, 0x5b, 0x76, 0x7c, + 0xb4, 0xd7, 0xed, 0x1d, 0x52, 0xe6, 0x8e, 0xf3, 0xdc, 0xcb, 0xfa, 0xd9, 0x41, 0xdc, 0xca, 0x35, + 0x7e, 0xcc, 0xa7, 0x38, 0xd0, 0x7f, 0x15, 0x26, 0xea, 0x5d, 0xbb, 0x41, 0x5b, 0xce, 0x6e, 0x20, + 0x2c, 0x06, 0x5e, 0x18, 0xc0, 0x2a, 0xc4, 0x15, 0x2f, 0xc4, 0xf2, 0xa7, 0x7a, 0xe7, 0x0a, 0x71, + 0xd8, 0x17, 0x6e, 0xd6, 0xee, 0x0a, 0xa3, 0x81, 0x41, 0x5f, 0xb8, 0x59, 0xbb, 0x2b, 0x04, 0x98, + 0x6e, 0x5b, 0x13, 0x60, 0x6a, 0x77, 0x49, 0x17, 0x66, 0x36, 0xa9, 0xe7, 0xd9, 0xbb, 0xae, 0xd7, + 0xe6, 0x6a, 0x58, 0xee, 0xb9, 0x77, 0x65, 0x10, 0x3f, 0x8d, 0x80, 0x6b, 0x1f, 0x03, 0x09, 0xb3, + 0xe2, 0xba, 0xdb, 0x18, 0x7f, 0xd6, 0x27, 0x2b, 0x4e, 0xb0, 0xd3, 0x6b, 0x1c, 0xd0, 0x60, 0x71, + 0xee, 0xc4, 0x3e, 0x09, 0x71, 0x79, 0x9f, 0xec, 0xc8, 0x9f, 0x6a, 0x9f, 0x84, 0x38, 0x6c, 0x1a, + 0x08, 0xf7, 0x78, 0x72, 0xe2, 0x34, 0xe0, 0x88, 0x7c, 0x1a, 0xf4, 0xf3, 0x93, 0x27, 0xfb, 0x30, + 0xb5, 0xe2, 0xf6, 0x3a, 0x4c, 0xae, 0xed, 0xda, 0x8e, 0xb7, 0x38, 0x8f, 0x6c, 0x5f, 0x1a, 0xf4, + 0xc1, 0x0a, 0x3a, 0xb7, 0xfa, 0xde, 0x61, 0x10, 0x26, 0x3a, 0x33, 0x90, 0xfa, 0xa0, 0xa2, 0xa2, + 0x92, 0x26, 0x4c, 0xe2, 0x54, 0xae, 0xd0, 0x07, 0x6e, 0xd7, 0x5f, 0x5c, 0xc0, 0x8a, 0x2e, 0x9d, + 0xb4, 0x28, 0x38, 0x36, 0x7f, 0xb9, 0xc7, 0xa5, 0x61, 0x35, 0x11, 0xa2, 0x6a, 0xb9, 0x15, 0x44, + 0xe3, 0x1f, 0x8c, 0x42, 0xf1, 0x04, 0x66, 0xe4, 0xbe, 0x3c, 0x9b, 0xb8, 0x04, 0xf0, 0xca, 0x70, + 0xdf, 0x70, 0xf5, 0xc4, 0x63, 0xeb, 0x2d, 0x98, 0xb9, 0xa7, 0x18, 0x11, 0x84, 0x46, 0x1d, 0x48, + 0xa3, 0x9a, 0x17, 0x58, 0x4e, 0xd3, 0x8c, 0xa1, 0x2e, 0xfd, 0xdb, 0x1c, 0x8c, 0xa0, 0x60, 0xf1, + 0x3c, 0xe4, 0xea, 0xbd, 0x1d, 0xf5, 0x21, 0xcc, 0xd7, 0xb6, 0x6b, 0x56, 0x4a, 0xde, 0x86, 0x49, + 0xe1, 0x04, 0xa2, 0xdc, 0x4e, 0xb1, 0x93, 0xa4, 0xc7, 0x48, 0xdc, 0x02, 0x5f, 0x41, 0x27, 0xef, + 0xc1, 0x54, 0xcd, 0xe9, 0xd2, 0x96, 0xd3, 0xa1, 0x8a, 0x3d, 0x39, 0x8e, 0x65, 0x57, 0xc0, 0x13, + 0x8f, 0x63, 0x2a, 0x81, 0xee, 0xae, 0x32, 0x32, 0xbc, 0xbb, 0xca, 0x7b, 0x30, 0x55, 0xa1, 0xbb, + 0x4e, 0xc7, 0x11, 0xfd, 0x33, 0x1a, 0x55, 0xdc, 0x0c, 0xe1, 0x3a, 0xb5, 0x46, 0x40, 0x56, 0x60, + 0xda, 0xa4, 0x5d, 0xd7, 0x77, 0x02, 0xd7, 0x3b, 0xdc, 0x32, 0xab, 0xc2, 0xe0, 0x04, 0x0d, 0x92, + 0xbc, 0xb0, 0xc0, 0xea, 0x79, 0xea, 0x49, 0xa4, 0x93, 0x90, 0x0d, 0x98, 0x8b, 0x00, 0xba, 0xa1, + 0x96, 0x78, 0x09, 0x09, 0xf9, 0x24, 0x0d, 0x77, 0x93, 0xa4, 0xfa, 0x37, 0x99, 0x74, 0x57, 0x98, + 0x01, 0xc7, 0xbf, 0xc9, 0xa3, 0xbb, 0xe9, 0xdf, 0x64, 0xd2, 0x5d, 0xe3, 0x1f, 0xe7, 0xe0, 0x5c, + 0x9f, 0xad, 0x8d, 0x6c, 0xe8, 0xd3, 0xf5, 0xf9, 0xc1, 0x3b, 0xe1, 0xc9, 0xd3, 0x74, 0x1d, 0x0a, + 0xab, 0x77, 0xf0, 0x42, 0xcf, 0xdf, 0x99, 0xcb, 0x25, 0x29, 0x84, 0x62, 0xf3, 0xe9, 0x01, 0xba, + 0x00, 0xc8, 0xf7, 0xe9, 0x86, 0x16, 0xaa, 0x23, 0x41, 0xb9, 0xf4, 0x03, 0x59, 0x31, 0x6f, 0x63, + 0x01, 0x0a, 0x33, 0xa7, 0x0a, 0x50, 0xf8, 0x65, 0x98, 0x5a, 0xbd, 0xc3, 0xd5, 0x6d, 0x6b, 0xb6, + 0xbf, 0x2f, 0xe6, 0x14, 0x76, 0x21, 0x3d, 0x90, 0xef, 0x2a, 0xfb, 0xb6, 0x76, 0xb1, 0xd5, 0x28, + 0xc8, 0x16, 0xcc, 0xf3, 0x6f, 0x73, 0x76, 0x9d, 0x06, 0x8f, 0x73, 0xe6, 0xd8, 0x2d, 0x31, 0xc3, + 0x9e, 0x3f, 0x3e, 0x2a, 0x16, 0xe9, 0x01, 0x3a, 0x37, 0x88, 0x72, 0xcb, 0x47, 0x04, 0xd5, 0xcb, + 0x21, 0x85, 0x5e, 0x0d, 0xbe, 0x64, 0x4e, 0x60, 0x85, 0xac, 0x36, 0x56, 0x37, 0xc3, 0xe5, 0x48, + 0xc6, 0x1f, 0x8d, 0xc2, 0x52, 0x7f, 0xb1, 0x8b, 0xbc, 0xaf, 0x0f, 0xe0, 0xa5, 0x13, 0x05, 0xb5, + 0x93, 0xc7, 0xf0, 0x2b, 0xb0, 0xb0, 0xda, 0x09, 0xa8, 0xd7, 0xf5, 0x1c, 0x19, 0x6e, 0x6b, 0xcd, + 0xf5, 0xa5, 0x33, 0x09, 0x7a, 0x75, 0xd0, 0xb0, 0x5c, 0xbc, 0xcd, 0xa0, 0x67, 0x8e, 0xc2, 0x2a, + 0x95, 0x03, 0x59, 0x85, 0x19, 0x05, 0xde, 0xea, 0xed, 0xa9, 0x8f, 0xe7, 0x2a, 0xcf, 0x56, 0x4f, + 0xb5, 0xb4, 0x8f, 0x11, 0xa1, 0xc3, 0x4a, 0x60, 0x07, 0x4e, 0xe3, 0xf6, 0xf6, 0x9d, 0xba, 0x18, + 0x4e, 0xee, 0xb0, 0x82, 0x50, 0xeb, 0xa3, 0x87, 0x07, 0x9a, 0xdc, 0x14, 0x21, 0x2f, 0xfd, 0x8d, + 0x53, 0xed, 0x84, 0x5f, 0x04, 0x88, 0x96, 0x92, 0xea, 0xf0, 0x1d, 0x2d, 0x3d, 0xdd, 0x27, 0x4d, + 0x42, 0xc9, 0x1a, 0xcc, 0x46, 0xbf, 0xee, 0x3d, 0xec, 0x88, 0xb7, 0xa8, 0x09, 0xae, 0x82, 0x55, + 0x56, 0xae, 0xcb, 0xca, 0x54, 0x51, 0x3c, 0x46, 0x46, 0x96, 0x21, 0xbf, 0xed, 0x7a, 0x07, 0xbb, + 0x6c, 0x8c, 0x47, 0xa2, 0xcb, 0xc2, 0x43, 0x01, 0x53, 0x85, 0x62, 0x89, 0xc7, 0x96, 0xcb, 0x6a, + 0xe7, 0x81, 0xe3, 0xb9, 0x68, 0x70, 0xa0, 0x9a, 0xdc, 0xd1, 0x08, 0xac, 0x85, 0xda, 0x88, 0xc0, + 0xe4, 0x0a, 0x8c, 0x96, 0x1a, 0x81, 0xeb, 0x89, 0xed, 0x8f, 0xcf, 0x14, 0x06, 0xd0, 0x66, 0x0a, + 0x03, 0xb0, 0x4e, 0x64, 0x7b, 0xd2, 0x78, 0xd4, 0x89, 0xfa, 0x46, 0xc4, 0x4a, 0xd9, 0x65, 0xc7, + 0xa4, 0xbb, 0xa8, 0x1d, 0xd5, 0xc2, 0x6f, 0xee, 0x26, 0x54, 0xee, 0x02, 0xcd, 0xf8, 0x21, 0xe8, + 0x3b, 0xe5, 0x99, 0x74, 0x79, 0xba, 0x29, 0xbf, 0x6e, 0x0f, 0x31, 0xe5, 0x5f, 0x0d, 0x3d, 0xdd, + 0xd4, 0xe0, 0x39, 0x08, 0x51, 0xe5, 0x1a, 0xe1, 0xf3, 0xa6, 0xcf, 0xbf, 0xdc, 0x69, 0xe6, 0xdf, + 0xdf, 0xc9, 0x9f, 0x66, 0xfe, 0x89, 0xfe, 0xcd, 0x0e, 0xdb, 0xbf, 0xb9, 0xa1, 0xfa, 0x97, 0x1d, + 0x2a, 0x61, 0xec, 0xd7, 0x9a, 0x1d, 0x68, 0x3b, 0x62, 0x18, 0xb0, 0xd7, 0xea, 0xda, 0x81, 0xba, + 0x23, 0xea, 0x24, 0x8a, 0x90, 0x80, 0x1c, 0x46, 0x93, 0x42, 0x42, 0x8c, 0x5e, 0x45, 0x67, 0x1b, + 0x81, 0x3c, 0xf3, 0xeb, 0xf8, 0x4e, 0x2a, 0x26, 0x1b, 0x37, 0x47, 0x91, 0x62, 0x02, 0x7f, 0x42, + 0xd5, 0xde, 0x27, 0x34, 0xa2, 0xf8, 0x3c, 0x1f, 0x3f, 0xd5, 0x3c, 0xe7, 0x16, 0xd8, 0xde, 0xba, + 0xbb, 0xe7, 0x48, 0xef, 0x1a, 0x69, 0x81, 0xed, 0x59, 0x2d, 0x06, 0x8d, 0x59, 0x60, 0x73, 0x54, + 0xf2, 0x1a, 0x8c, 0xb1, 0x1f, 0xd5, 0x8a, 0xb0, 0x91, 0x40, 0xa5, 0x07, 0x12, 0xe9, 0x2e, 0x4d, + 0x1c, 0x49, 0x56, 0xb3, 0xda, 0xb6, 0x9d, 0x96, 0x08, 0xaf, 0x12, 0x55, 0x43, 0x19, 0x34, 0x5e, + 0x0d, 0xa2, 0x92, 0x06, 0x4c, 0x99, 0x74, 0xb7, 0xe6, 0xb9, 0x01, 0x6d, 0x04, 0xb4, 0x29, 0x2e, + 0x7a, 0x52, 0xd7, 0xb1, 0xe2, 0xba, 0xfc, 0x12, 0xbb, 0xf2, 0xda, 0x6f, 0x1f, 0x15, 0x33, 0xdf, + 0x39, 0x2a, 0x02, 0x03, 0x71, 0x7f, 0x39, 0x26, 0xf2, 0xb0, 0xf1, 0xef, 0x4a, 0x62, 0xf5, 0x60, + 0x53, 0x99, 0x92, 0x6f, 0xb1, 0xad, 0x3e, 0xec, 0x92, 0xa8, 0xb2, 0xa9, 0x3e, 0x95, 0xbd, 0x91, + 0x5a, 0x59, 0x51, 0xe9, 0xed, 0xd4, 0x4a, 0x53, 0x2b, 0x21, 0xef, 0xc0, 0x64, 0xb9, 0x5a, 0x76, + 0x3b, 0xbb, 0xce, 0x5e, 0x7d, 0xad, 0x84, 0xb7, 0x45, 0x21, 0xaf, 0x35, 0x1c, 0xab, 0x81, 0x70, + 0xcb, 0xdf, 0xb7, 0x35, 0x8f, 0xff, 0x08, 0x9f, 0xdc, 0x82, 0x19, 0xf9, 0xd3, 0xa4, 0xbb, 0x4c, + 0x5e, 0x9b, 0x51, 0xfc, 0x6b, 0x43, 0x0e, 0xac, 0x23, 0x74, 0x91, 0x2d, 0x46, 0xc6, 0x26, 0x63, + 0x85, 0x76, 0x5b, 0xee, 0x21, 0xfb, 0xbc, 0x4d, 0x87, 0x7a, 0x78, 0x2d, 0x14, 0x93, 0xb1, 0x19, + 0x96, 0x58, 0x81, 0xa3, 0x5b, 0x86, 0xe8, 0x44, 0x4c, 0xf4, 0x13, 0x53, 0xfc, 0xbe, 0xe3, 0x3b, + 0x3b, 0x4e, 0xcb, 0x09, 0x0e, 0xf1, 0x42, 0x28, 0x64, 0x1f, 0xb9, 0x2e, 0x1e, 0x84, 0xa5, 0xaa, + 0xe8, 0x97, 0x20, 0x35, 0x7e, 0x35, 0x0b, 0xcf, 0x0c, 0x52, 0x8e, 0x90, 0xba, 0xbe, 0x0f, 0x5e, + 0x1e, 0x42, 0xa1, 0x72, 0xf2, 0x4e, 0xb8, 0xda, 0xe7, 0x9e, 0x81, 0x9d, 0x11, 0xbb, 0x67, 0xa8, + 0x9d, 0x11, 0xbb, 0x71, 0x3c, 0x10, 0xdb, 0xdc, 0xc7, 0xf5, 0x3d, 0xbf, 0x01, 0x13, 0x65, 0xb7, + 0x13, 0xd0, 0x47, 0x41, 0x2c, 0xd2, 0x0a, 0x07, 0xc6, 0xfd, 0xee, 0x25, 0xaa, 0xf1, 0xaf, 0x73, + 0x70, 0x61, 0xa0, 0x76, 0x80, 0x6c, 0xea, 0xbd, 0x76, 0x65, 0x18, 0x95, 0xc2, 0xc9, 0xdd, 0xb6, + 0x9c, 0xb0, 0x28, 0x3e, 0xd9, 0x37, 0xd2, 0x04, 0xc2, 0x03, 0x4a, 0xdc, 0x6a, 0xb9, 0x3b, 0xa8, + 0x3f, 0x72, 0x3a, 0x7b, 0x22, 0x10, 0x05, 0xf7, 0xf3, 0xc3, 0x52, 0x6b, 0xaf, 0xe5, 0xee, 0x70, + 0x3d, 0x94, 0xd3, 0x51, 0xc5, 0xa2, 0x14, 0xea, 0xa5, 0x7f, 0x9d, 0x11, 0x1d, 0xff, 0x39, 0x18, + 0xc7, 0xcf, 0x0f, 0xbb, 0x9d, 0x6b, 0xf6, 0x71, 0x67, 0x77, 0x74, 0xcd, 0x3e, 0x47, 0x23, 0xaf, + 0x43, 0xbe, 0x6c, 0xb7, 0x5a, 0x4a, 0x6c, 0x1b, 0x54, 0x1a, 0x34, 0x10, 0x16, 0x33, 0xb5, 0x97, + 0x88, 0xec, 0x28, 0xe4, 0x7f, 0x2b, 0xe7, 0x0f, 0x6e, 0xc0, 0x82, 0x2c, 0x76, 0x04, 0x29, 0xc8, + 0x18, 0x11, 0xbb, 0xe1, 0x86, 0xd1, 0x33, 0x78, 0x44, 0x6c, 0x06, 0xd0, 0x22, 0x62, 0x33, 0x80, + 0xf1, 0x6b, 0x39, 0x78, 0x76, 0xb0, 0xda, 0x8c, 0x6c, 0xe9, 0xc3, 0xfa, 0xf2, 0x50, 0xca, 0xb6, + 0x93, 0xc7, 0x55, 0xc6, 0x97, 0xe7, 0x1d, 0x72, 0x39, 0xe9, 0xde, 0xf8, 0xdd, 0xa3, 0xa2, 0xe2, + 0xbf, 0x71, 0xdb, 0x75, 0x3a, 0xca, 0x3b, 0xef, 0x37, 0x13, 0x82, 0xc2, 0xe4, 0xf2, 0x8d, 0xe1, + 0xbe, 0x2c, 0xa2, 0xe3, 0x7b, 0xd5, 0xb0, 0x02, 0xc6, 0x97, 0xa0, 0x10, 0x27, 0x25, 0x97, 0x60, + 0x04, 0x3f, 0x40, 0xf1, 0xd1, 0x8c, 0x71, 0xc0, 0xf2, 0xa5, 0xbb, 0x62, 0xee, 0x60, 0xb8, 0x1f, + 0xd5, 0x35, 0x5d, 0x50, 0x8a, 0x70, 0x3f, 0x9a, 0x5f, 0xbb, 0x1e, 0xee, 0x47, 0x25, 0x32, 0xfe, + 0x24, 0x03, 0xe7, 0xfb, 0xea, 0x3d, 0x48, 0x4d, 0x1f, 0xb0, 0x17, 0x4f, 0x52, 0x94, 0x9c, 0x38, + 0x56, 0x4b, 0x3f, 0x2e, 0xe7, 0xfe, 0xbb, 0x30, 0x55, 0xef, 0xed, 0xc4, 0xaf, 0x8b, 0x3c, 0x18, + 0x97, 0x02, 0x57, 0x4f, 0x45, 0x15, 0x9f, 0xb5, 0x5f, 0xda, 0x6f, 0x09, 0x73, 0x49, 0xc5, 0x46, + 0x3b, 0x8c, 0x47, 0x91, 0x0c, 0x77, 0xa4, 0x13, 0x19, 0xbf, 0x92, 0x4d, 0xbf, 0x77, 0xdf, 0x2a, + 0xd7, 0x4e, 0x73, 0xef, 0xbe, 0x55, 0xae, 0x9d, 0xdc, 0xf6, 0xff, 0x4e, 0xb6, 0x1d, 0x8d, 0x49, + 0xc4, 0x2e, 0x2a, 0xdf, 0x53, 0x84, 0x31, 0x89, 0xdc, 0x71, 0x7d, 0xdd, 0x98, 0x44, 0x22, 0x93, + 0x37, 0x60, 0x62, 0xdd, 0xe5, 0x91, 0x88, 0x64, 0x8b, 0x79, 0xc0, 0x06, 0x09, 0x54, 0xb7, 0xdc, + 0x10, 0x93, 0x5d, 0x75, 0xf4, 0x81, 0x97, 0xa6, 0xe8, 0x78, 0xd5, 0x89, 0x4d, 0x17, 0xfd, 0xd5, + 0x41, 0x27, 0x33, 0xfe, 0xfe, 0x28, 0x18, 0x27, 0xeb, 0x4c, 0xc9, 0x07, 0x7a, 0xdf, 0x5d, 0x1d, + 0x5a, 0xdb, 0x3a, 0xd4, 0x36, 0x5e, 0xea, 0x35, 0x1d, 0xda, 0x69, 0xe8, 0x61, 0x84, 0x04, 0x4c, + 0xdd, 0x02, 0x25, 0xde, 0xc7, 0x71, 0x8b, 0x5f, 0xfa, 0xe7, 0xb9, 0x68, 0xa9, 0xc5, 0x8e, 0xdb, + 0xcc, 0xc7, 0x38, 0x6e, 0xc9, 0x1d, 0x28, 0xa8, 0x10, 0x45, 0x6f, 0x87, 0xd2, 0x90, 0xc6, 0x28, + 0xf6, 0x51, 0x09, 0x42, 0xfd, 0xcc, 0xce, 0x0d, 0x7f, 0x66, 0xc7, 0xf4, 0x86, 0x23, 0xa7, 0xd3, + 0x1b, 0x8a, 0xb0, 0x43, 0xbe, 0x38, 0xb4, 0x46, 0xf5, 0xb0, 0x43, 0x29, 0x07, 0x97, 0x8a, 0x2e, + 0x23, 0x27, 0xe1, 0x4f, 0x25, 0x70, 0x48, 0x18, 0x39, 0x89, 0xd3, 0xa7, 0x45, 0x4e, 0x0a, 0x49, + 0xd8, 0x01, 0x68, 0xf6, 0x3a, 0x3c, 0xf5, 0xc2, 0x78, 0x74, 0x00, 0x7a, 0xbd, 0x8e, 0x15, 0x4f, + 0xbf, 0x10, 0x22, 0x1a, 0xff, 0x68, 0x24, 0x5d, 0xe0, 0x88, 0xd4, 0xea, 0xa7, 0x10, 0x38, 0x42, + 0xa2, 0x4f, 0x67, 0xa6, 0x6e, 0xc1, 0xbc, 0xb4, 0x66, 0x96, 0x76, 0xab, 0x5b, 0xe6, 0xba, 0x18, + 0x62, 0x54, 0x63, 0x85, 0x76, 0xd0, 0xd2, 0xf6, 0xd5, 0xea, 0x79, 0x9a, 0x1a, 0x2b, 0x85, 0x7e, + 0xe9, 0x1f, 0x4a, 0x2d, 0x9d, 0x3a, 0x08, 0xe8, 0x79, 0x9e, 0x49, 0x1b, 0x84, 0x5e, 0x4f, 0x1b, + 0x46, 0x9d, 0x84, 0xef, 0xbd, 0xa1, 0x46, 0x75, 0x4b, 0x97, 0x3f, 0x55, 0x2d, 0xac, 0xce, 0x25, + 0x46, 0x44, 0xf6, 0xe0, 0x7c, 0x24, 0x9e, 0x2b, 0xb7, 0x0f, 0xe4, 0xc8, 0x1b, 0x7c, 0xe5, 0xf8, + 0xa8, 0xf8, 0xa2, 0x22, 0xde, 0xab, 0x97, 0x98, 0x18, 0xf7, 0xfe, 0xbc, 0xd8, 0x7e, 0xbb, 0xe2, + 0xd9, 0x9d, 0xc6, 0xbe, 0x32, 0xe7, 0x71, 0xbf, 0xdd, 0x41, 0x68, 0x22, 0x78, 0x4a, 0x84, 0x6c, + 0xfc, 0xcd, 0x6c, 0xba, 0x9a, 0x43, 0xbc, 0x9e, 0x9c, 0x42, 0xcd, 0xc1, 0x29, 0x4e, 0x3e, 0x25, + 0xfe, 0xbe, 0x3c, 0x25, 0x5e, 0x84, 0xf1, 0x4d, 0xda, 0xb1, 0x3b, 0x61, 0x50, 0x22, 0xb4, 0xe2, + 0x08, 0x38, 0xc8, 0x94, 0x65, 0xe4, 0x7d, 0x20, 0x35, 0xdb, 0xa3, 0x9d, 0xa0, 0xec, 0xb6, 0xbb, + 0xb6, 0x17, 0xb4, 0x31, 0x39, 0x05, 0x3f, 0x1a, 0x9e, 0x3b, 0x3e, 0x2a, 0x5e, 0xe8, 0x62, 0xa9, + 0xd5, 0x50, 0x8a, 0x55, 0x01, 0x35, 0x49, 0x4c, 0xae, 0xc1, 0xb8, 0x34, 0x4e, 0xc8, 0x45, 0x71, + 0x0a, 0x93, 0x86, 0x09, 0x12, 0xcb, 0xf8, 0xe7, 0xa3, 0x70, 0xf1, 0xa4, 0xa7, 0x22, 0xb2, 0x0b, + 0x70, 0xaf, 0xb3, 0xe3, 0xda, 0x5e, 0x93, 0x89, 0xd0, 0x99, 0x13, 0x05, 0x2d, 0x95, 0xf8, 0x6a, + 0x44, 0xc9, 0x0a, 0xb9, 0x57, 0xad, 0x1b, 0xc2, 0x4c, 0x85, 0x33, 0xf9, 0x3a, 0xe4, 0x4d, 0xda, + 0x70, 0x1f, 0x50, 0xa1, 0x0e, 0x9c, 0x5c, 0xfe, 0xfc, 0xb0, 0xb5, 0x48, 0x3a, 0xac, 0x03, 0xdd, + 0x0d, 0x3d, 0x01, 0x31, 0x43, 0x9e, 0xe4, 0x1b, 0x30, 0xc9, 0x73, 0x90, 0x94, 0x76, 0x83, 0xd0, + 0x7c, 0xfd, 0xa4, 0xd4, 0x26, 0x19, 0xb6, 0x49, 0xf2, 0xac, 0x26, 0x96, 0xbd, 0xab, 0xb9, 0x2f, + 0xf0, 0xd4, 0x26, 0x0a, 0xcb, 0xa5, 0xff, 0x22, 0x0b, 0x33, 0x7a, 0x83, 0xc9, 0x3a, 0x14, 0xaa, + 0x1d, 0x27, 0x70, 0xec, 0x96, 0x6e, 0xbe, 0x2a, 0xee, 0xad, 0x0e, 0x2f, 0xb3, 0x52, 0xcd, 0x58, + 0x13, 0x94, 0x6c, 0xce, 0xb0, 0xa1, 0xf3, 0x03, 0x6e, 0x35, 0xc1, 0x63, 0x86, 0x8a, 0x45, 0xfc, + 0x1c, 0x0f, 0x51, 0x1b, 0x95, 0x5a, 0x3c, 0x4a, 0xaf, 0x1e, 0x0f, 0x31, 0x4e, 0x4c, 0x1e, 0x00, + 0xb9, 0xdb, 0xf3, 0x03, 0x5e, 0x42, 0xbd, 0x15, 0xba, 0xeb, 0x7a, 0xc3, 0xc4, 0x09, 0x79, 0x59, + 0x74, 0xce, 0xb3, 0xed, 0x9e, 0x1f, 0x58, 0x9e, 0x20, 0xb7, 0x76, 0x90, 0x3e, 0xd6, 0x49, 0x29, + 0x35, 0x2c, 0xdd, 0x85, 0x29, 0x75, 0xd4, 0xd0, 0x8a, 0xcc, 0x69, 0x3b, 0xd2, 0x7c, 0x9d, 0x5b, + 0x91, 0x31, 0x80, 0xc9, 0xe1, 0xe4, 0x19, 0x11, 0xae, 0x29, 0x1b, 0x19, 0x5b, 0x45, 0x61, 0x99, + 0x8c, 0x1f, 0xce, 0xc0, 0xd9, 0x74, 0x0b, 0x24, 0xf2, 0x51, 0xec, 0xa5, 0x34, 0x33, 0xe8, 0x1d, + 0x59, 0x9a, 0x2d, 0x7d, 0xbc, 0xb7, 0x52, 0xe3, 0x2f, 0x8d, 0x24, 0xa4, 0xac, 0x14, 0x8e, 0xe4, + 0x56, 0xea, 0x38, 0x66, 0x94, 0x73, 0x31, 0x39, 0x8e, 0xa9, 0xa3, 0xf7, 0x36, 0xcc, 0x20, 0xe3, + 0x68, 0x72, 0x29, 0x3a, 0x56, 0xfe, 0xc9, 0xd1, 0xd4, 0x32, 0x63, 0xb8, 0xa4, 0x0a, 0x04, 0x21, + 0x2b, 0x6e, 0xa0, 0x38, 0xb4, 0x2b, 0x17, 0x4d, 0xce, 0x61, 0xc7, 0x0d, 0x2c, 0xd5, 0xb5, 0x3d, + 0x85, 0x88, 0x7c, 0x11, 0xa6, 0xe5, 0x70, 0x96, 0xf1, 0x56, 0x33, 0x82, 0xc3, 0x88, 0xf7, 0x21, + 0xb9, 0x16, 0x2d, 0x14, 0x45, 0x4d, 0x1d, 0x91, 0xb4, 0x61, 0x16, 0xd3, 0x03, 0x71, 0x20, 0x6d, + 0x96, 0x82, 0x21, 0xa2, 0x13, 0xbd, 0x24, 0x66, 0xdf, 0xd3, 0x3c, 0xeb, 0x90, 0xa4, 0xb5, 0xec, + 0x20, 0x36, 0xf5, 0xe2, 0xbc, 0xc9, 0x1e, 0x4c, 0x2b, 0xd9, 0x88, 0x4a, 0xc1, 0x10, 0xc9, 0xb0, + 0x5e, 0x14, 0x95, 0x9d, 0x57, 0x53, 0x1c, 0x25, 0xab, 0xd2, 0xf9, 0x1a, 0x3f, 0x9e, 0x85, 0x19, + 0x7e, 0x5b, 0xe4, 0x66, 0x68, 0x4f, 0xac, 0xbd, 0xe0, 0x5b, 0x9a, 0xbd, 0xa0, 0x0c, 0x94, 0xad, + 0x36, 0x6d, 0x28, 0xeb, 0xee, 0x7d, 0x20, 0x49, 0x1a, 0x62, 0xc2, 0x94, 0x0a, 0x1d, 0x6c, 0xdb, + 0x77, 0x3d, 0x8a, 0xa9, 0x2e, 0x2e, 0xeb, 0x68, 0xad, 0xe9, 0x9b, 0x1a, 0x0f, 0xe3, 0xc7, 0xb2, + 0x30, 0xad, 0x58, 0x77, 0x3f, 0xb1, 0x1d, 0xff, 0x25, 0xad, 0xe3, 0x17, 0xc3, 0x88, 0x1e, 0x61, + 0xcb, 0x86, 0xea, 0xf7, 0x1e, 0xcc, 0x25, 0x48, 0xe2, 0x46, 0xf2, 0x99, 0x61, 0x8c, 0xe4, 0x5f, + 0x4d, 0x06, 0x68, 0xe6, 0x79, 0xce, 0xc2, 0x70, 0x9d, 0x6a, 0x44, 0xe8, 0x9f, 0xcc, 0xc2, 0x82, + 0xf8, 0x85, 0x19, 0x0d, 0xb8, 0xba, 0xe4, 0x89, 0x1d, 0x8b, 0x92, 0x36, 0x16, 0x45, 0x7d, 0x2c, + 0x94, 0x06, 0xf6, 0x1f, 0x12, 0xe3, 0x87, 0x01, 0x16, 0xfb, 0x11, 0x0c, 0x1d, 0xea, 0x2b, 0x0a, + 0x25, 0x92, 0x1d, 0x22, 0x94, 0xc8, 0x3a, 0x14, 0xb0, 0x2a, 0x11, 0xb3, 0xdc, 0xdf, 0x32, 0xab, + 0xa2, 0x93, 0x50, 0xfa, 0xe0, 0x69, 0x27, 0x44, 0x0c, 0x75, 0x3f, 0xa6, 0xc9, 0x4f, 0x50, 0x92, + 0xbf, 0x91, 0x81, 0x19, 0x04, 0xae, 0x3e, 0x60, 0xe2, 0x26, 0x63, 0x36, 0x22, 0x62, 0x4c, 0x84, + 0x16, 0x80, 0xf5, 0xc0, 0x73, 0x3a, 0x7b, 0xc2, 0x04, 0x70, 0x47, 0x98, 0x00, 0xbe, 0xcd, 0x4d, + 0x17, 0xaf, 0x36, 0xdc, 0xf6, 0xb5, 0x3d, 0xcf, 0x7e, 0xe0, 0x70, 0xc7, 0x05, 0xbb, 0x75, 0x2d, + 0x4a, 0xcf, 0xd9, 0x75, 0x62, 0x89, 0x33, 0x05, 0x2b, 0x34, 0xaf, 0xe4, 0x1f, 0x4a, 0xb1, 0xda, + 0xf8, 0x83, 0x83, 0xfe, 0x45, 0xe4, 0x7b, 0xe0, 0x1c, 0x57, 0xdd, 0x96, 0xdd, 0x4e, 0xe0, 0x74, + 0x7a, 0x6e, 0xcf, 0x5f, 0xb1, 0x1b, 0x07, 0xbd, 0xae, 0x2f, 0x22, 0x01, 0x61, 0xcb, 0x1b, 0x61, + 0xa1, 0xb5, 0xc3, 0x4b, 0xb5, 0x18, 0x6f, 0xe9, 0x0c, 0xc8, 0x1a, 0xcc, 0xf1, 0xa2, 0x52, 0x2f, + 0x70, 0xeb, 0x0d, 0xbb, 0xc5, 0x04, 0xe2, 0x71, 0xe4, 0xca, 0xed, 0x9c, 0x7a, 0x81, 0x6b, 0xf9, + 0x1c, 0xae, 0xbe, 0x3f, 0x24, 0x88, 0x48, 0x15, 0x66, 0x4d, 0x6a, 0x37, 0xef, 0xda, 0x8f, 0xca, + 0x76, 0xd7, 0x6e, 0x38, 0x01, 0x4f, 0x6d, 0x90, 0xe3, 0x2a, 0x05, 0x8f, 0xda, 0x4d, 0xab, 0x6d, + 0x3f, 0xb2, 0x1a, 0xa2, 0x50, 0x7f, 0xc3, 0xd6, 0xe8, 0x42, 0x56, 0x4e, 0x27, 0x64, 0x35, 0x11, + 0x67, 0xe5, 0x74, 0xfa, 0xb3, 0x8a, 0xe8, 0x24, 0xab, 0x4d, 0xdb, 0xdb, 0xa3, 0x01, 0xf7, 0x3c, + 0x84, 0x8b, 0x99, 0xcb, 0x19, 0x85, 0x55, 0x80, 0x65, 0x16, 0x7a, 0x21, 0xc6, 0x59, 0x29, 0x74, + 0x6c, 0xe6, 0x6d, 0x7b, 0x4e, 0x40, 0xd5, 0x16, 0x4e, 0xe2, 0x67, 0x61, 0xff, 0xa3, 0xcf, 0x66, + 0xbf, 0x26, 0x26, 0x28, 0x23, 0x6e, 0x4a, 0x23, 0xa7, 0x12, 0xdc, 0xd2, 0x5b, 0x99, 0xa0, 0x0c, + 0xb9, 0xa9, 0xed, 0x9c, 0xc6, 0x76, 0x2a, 0xdc, 0xfa, 0x34, 0x34, 0x41, 0x49, 0x36, 0x58, 0xa7, + 0x05, 0xec, 0xe6, 0xee, 0x76, 0x84, 0x4b, 0xe4, 0x0c, 0x7e, 0xda, 0x0b, 0x42, 0x6c, 0x28, 0x78, + 0xb2, 0xd8, 0x4a, 0x71, 0x90, 0x8c, 0x13, 0x93, 0xbf, 0x00, 0xb3, 0x5b, 0x3e, 0xbd, 0x59, 0xad, + 0xd5, 0x65, 0xe0, 0x61, 0x7c, 0x32, 0x9b, 0x59, 0xbe, 0x7e, 0xc2, 0xa6, 0x73, 0x55, 0xa5, 0xc1, + 0x6c, 0x97, 0x7c, 0xdc, 0x7a, 0x3e, 0xb5, 0x76, 0x9d, 0xae, 0x1f, 0x46, 0x71, 0x57, 0xc7, 0x2d, + 0x56, 0x95, 0xb1, 0x06, 0x73, 0x09, 0x36, 0x64, 0x06, 0x80, 0x01, 0xad, 0xad, 0x8d, 0xfa, 0xea, + 0x66, 0xe1, 0x29, 0x52, 0x80, 0x29, 0xfc, 0xbd, 0xba, 0x51, 0x5a, 0x59, 0x5f, 0xad, 0x14, 0x32, + 0x64, 0x0e, 0xa6, 0x11, 0x52, 0xa9, 0xd6, 0x39, 0x28, 0xcb, 0x73, 0x9d, 0x99, 0x05, 0xbe, 0x74, + 0x03, 0x7c, 0x6c, 0x61, 0x67, 0x8a, 0xf1, 0x57, 0xb3, 0x70, 0x5e, 0x1e, 0x2b, 0x34, 0x78, 0xe8, + 0x7a, 0x07, 0x4e, 0x67, 0xef, 0x09, 0x3f, 0x1d, 0x6e, 0x6a, 0xa7, 0xc3, 0x0b, 0xb1, 0x93, 0x3a, + 0xd6, 0xca, 0x01, 0x47, 0xc4, 0x6f, 0x4c, 0xc0, 0x85, 0x81, 0x54, 0xe4, 0x7d, 0x76, 0x9a, 0x3b, + 0xb4, 0x13, 0x54, 0x9b, 0x2d, 0xca, 0x44, 0x54, 0xb7, 0x17, 0x08, 0x17, 0xdc, 0xe7, 0xf1, 0x45, + 0x09, 0x0b, 0x2d, 0xa7, 0xd9, 0xa2, 0x56, 0xc0, 0x8b, 0xb5, 0xe9, 0x96, 0xa4, 0x66, 0x2c, 0xc3, + 0xcc, 0xbb, 0xd5, 0x4e, 0x40, 0xbd, 0x07, 0xe8, 0xcb, 0x13, 0xb2, 0x3c, 0xa0, 0xb4, 0x6b, 0xd9, + 0xac, 0xd4, 0x72, 0x44, 0xb1, 0xce, 0x32, 0x41, 0x4d, 0x6e, 0x2a, 0x2c, 0x51, 0xca, 0xbf, 0x6b, + 0x3f, 0x12, 0xfe, 0x00, 0x22, 0x91, 0x45, 0xc8, 0x92, 0x87, 0xdf, 0x68, 0xdb, 0x8f, 0xcc, 0x24, + 0x09, 0xf9, 0x10, 0xce, 0x88, 0x03, 0x48, 0x84, 0x87, 0x94, 0x2d, 0xe6, 0xc1, 0x27, 0x5f, 0x62, + 0x17, 0x33, 0x99, 0x02, 0x44, 0x06, 0x12, 0x4d, 0x6b, 0x75, 0x3a, 0x17, 0xb2, 0xc9, 0x0e, 0xe4, + 0x58, 0x77, 0xdc, 0xa5, 0xbe, 0x2f, 0x63, 0xac, 0x08, 0xdd, 0xac, 0xda, 0x99, 0x56, 0x9b, 0x97, + 0x9b, 0x7d, 0x29, 0xc9, 0x1a, 0xcc, 0x6c, 0xd3, 0x1d, 0x75, 0x7c, 0xc6, 0xc2, 0xad, 0xaa, 0xf0, + 0x90, 0xee, 0xf4, 0x1f, 0x9c, 0x18, 0x1d, 0x71, 0xf0, 0xd5, 0xfb, 0xd1, 0xe1, 0x3a, 0xbb, 0x38, + 0x77, 0xa8, 0x87, 0xf7, 0xdf, 0x71, 0xdc, 0x0c, 0x16, 0x23, 0x09, 0x59, 0x2f, 0x17, 0xba, 0x23, + 0x0c, 0x6b, 0xd0, 0x12, 0x70, 0x2b, 0x96, 0xb7, 0x36, 0xc9, 0x95, 0x7c, 0x03, 0x66, 0x4d, 0xb7, + 0x17, 0x38, 0x9d, 0xbd, 0x3a, 0xbb, 0x61, 0xd2, 0x3d, 0x7e, 0x20, 0x45, 0x71, 0x91, 0x63, 0xa5, + 0xc2, 0xd6, 0x8a, 0x03, 0x2d, 0x5f, 0x40, 0xb5, 0x13, 0x41, 0x27, 0x20, 0x5f, 0x87, 0x19, 0x1e, + 0x66, 0x2f, 0xac, 0x60, 0x42, 0xcb, 0xb9, 0xa7, 0x17, 0xde, 0xbf, 0x2e, 0xcc, 0xb7, 0x11, 0x9a, + 0x56, 0x41, 0x8c, 0x1b, 0xf9, 0xaa, 0xe8, 0xac, 0x9a, 0xd3, 0xd9, 0x0b, 0xa7, 0x31, 0x60, 0xcf, + 0xbf, 0x16, 0x75, 0x49, 0x97, 0x7d, 0xae, 0x9c, 0xc6, 0x7d, 0x7c, 0x51, 0x92, 0x7c, 0x48, 0x00, + 0x17, 0x4a, 0xbe, 0xef, 0xf8, 0x81, 0x70, 0x54, 0x5f, 0x7d, 0x44, 0x1b, 0x3d, 0x86, 0xbc, 0xed, + 0x7a, 0x07, 0xd4, 0xe3, 0xde, 0x90, 0xa3, 0x2b, 0x57, 0x8f, 0x8f, 0x8a, 0x2f, 0xdb, 0x88, 0x68, + 0x09, 0xdf, 0x76, 0x8b, 0x4a, 0x54, 0xeb, 0x21, 0xc7, 0x55, 0xda, 0x30, 0x98, 0x29, 0xf9, 0x3a, + 0x9c, 0x2d, 0xdb, 0x3e, 0xad, 0x76, 0x7c, 0xda, 0xf1, 0x9d, 0xc0, 0x79, 0x40, 0x45, 0xa7, 0xe2, + 0xe1, 0x97, 0xe7, 0x01, 0xb1, 0x1b, 0xb6, 0xcf, 0x16, 0x66, 0x88, 0x62, 0x89, 0x41, 0x51, 0xe3, + 0x6d, 0xa7, 0x73, 0x21, 0x26, 0xcc, 0xd4, 0xeb, 0x6b, 0x15, 0xc7, 0x0e, 0xd7, 0xd5, 0x34, 0xf6, + 0xd7, 0xcb, 0xf8, 0xb8, 0xe4, 0xef, 0x5b, 0x4d, 0xc7, 0x0e, 0x17, 0x54, 0x9f, 0xce, 0x8a, 0x71, + 0x30, 0x8e, 0x32, 0x50, 0x88, 0x0f, 0x25, 0xf9, 0x0a, 0x4c, 0x70, 0x47, 0x0e, 0xea, 0xef, 0x0b, + 0xfd, 0x8b, 0xf4, 0x0b, 0x08, 0xe1, 0x3a, 0x91, 0x88, 0x4f, 0xc1, 0xdd, 0x44, 0xa8, 0x6a, 0x3e, + 0x8a, 0xf1, 0x29, 0x24, 0x11, 0x69, 0xc2, 0x14, 0x1f, 0x2d, 0x8a, 0x31, 0xdd, 0x85, 0xe2, 0xf0, + 0x39, 0x75, 0x75, 0x88, 0xa2, 0x18, 0x7f, 0x6e, 0x34, 0xcd, 0xe7, 0x04, 0x47, 0xd0, 0xaa, 0xd0, + 0xb8, 0xae, 0x00, 0xe4, 0x25, 0xa1, 0x71, 0x1e, 0xce, 0xf5, 0xf9, 0x66, 0xe3, 0x01, 0xea, 0x9c, + 0xfb, 0xd4, 0x48, 0xbe, 0x02, 0x0b, 0x48, 0x58, 0x76, 0x3b, 0x1d, 0xda, 0x08, 0x70, 0x3b, 0x92, + 0xef, 0xbf, 0x39, 0x6e, 0xfa, 0xc9, 0xdb, 0xdb, 0x08, 0x11, 0xac, 0xf8, 0x33, 0x70, 0x2a, 0x07, + 0xe3, 0xe7, 0xb3, 0xb0, 0x28, 0x76, 0x38, 0x93, 0x36, 0x5c, 0xd4, 0x3e, 0x3e, 0xe1, 0x27, 0xea, + 0xaa, 0x76, 0xa2, 0x3e, 0x1f, 0x86, 0x19, 0x4d, 0x6b, 0xe4, 0x80, 0x03, 0xf5, 0x57, 0x32, 0xf0, + 0xcc, 0x20, 0xa2, 0x50, 0xab, 0x98, 0x49, 0xd3, 0x2a, 0x92, 0x2e, 0xcc, 0xe3, 0x80, 0x96, 0xf7, + 0x69, 0xe3, 0xc0, 0x5f, 0x73, 0xfd, 0x00, 0xfd, 0x93, 0xb3, 0x7d, 0x2c, 0xb8, 0x5e, 0x4d, 0xb5, + 0xe0, 0x3a, 0xcb, 0x67, 0x59, 0x03, 0x79, 0xf0, 0x28, 0xfb, 0x07, 0xf4, 0xd0, 0x37, 0xd3, 0x58, + 0x63, 0x86, 0xe2, 0x52, 0x2f, 0xd8, 0xaf, 0x79, 0x74, 0x97, 0x7a, 0xb4, 0xd3, 0xa0, 0x9f, 0x31, + 0x3f, 0x53, 0xbd, 0x71, 0x43, 0x69, 0x30, 0x7e, 0x61, 0x06, 0x16, 0xd2, 0xc8, 0x58, 0xbf, 0x28, + 0x97, 0xe6, 0xbc, 0x0c, 0x0c, 0x20, 0xae, 0xca, 0xdf, 0xce, 0xc0, 0x54, 0x9d, 0x36, 0xdc, 0x4e, + 0xf3, 0x26, 0x9a, 0xd8, 0x8a, 0xde, 0xb1, 0xb9, 0xd0, 0xc0, 0xe0, 0xd6, 0x6e, 0xcc, 0xf6, 0xf6, + 0xbb, 0x47, 0xc5, 0x2f, 0x0f, 0x77, 0x57, 0x6d, 0xb8, 0xa8, 0xfb, 0x0c, 0x30, 0x41, 0x5e, 0x58, + 0x05, 0xff, 0x1a, 0x53, 0xab, 0x96, 0xac, 0xc0, 0xb4, 0x58, 0xb0, 0xae, 0x9a, 0x05, 0x80, 0xc7, + 0x62, 0x95, 0x05, 0x89, 0xe7, 0x53, 0x8d, 0x84, 0xbc, 0x0e, 0xb9, 0xad, 0xe5, 0x9b, 0x62, 0x14, + 0x64, 0x92, 0xc1, 0xad, 0xe5, 0x9b, 0xa8, 0x10, 0x63, 0x97, 0x8c, 0xe9, 0xde, 0xb2, 0x66, 0xbc, + 0xba, 0xb5, 0x7c, 0x93, 0xfc, 0x45, 0x38, 0x53, 0x71, 0x7c, 0x51, 0x05, 0xf7, 0x79, 0x6e, 0x62, + 0x10, 0x90, 0xb1, 0x3e, 0xf3, 0xf7, 0x0b, 0xa9, 0xf3, 0xf7, 0xb9, 0x66, 0xc8, 0xc4, 0xe2, 0x0e, + 0xd5, 0xcd, 0x78, 0xb6, 0x83, 0xf4, 0x7a, 0xc8, 0x47, 0x30, 0x83, 0x6f, 0x63, 0xe8, 0x06, 0x8e, + 0x69, 0xb6, 0xc6, 0xfb, 0xd4, 0xfc, 0xb9, 0xd4, 0x9a, 0x97, 0x78, 0x84, 0x3c, 0x74, 0x26, 0xc7, + 0x94, 0x5c, 0xda, 0xbd, 0x5f, 0xe3, 0x4c, 0x6e, 0xc3, 0xac, 0x10, 0xc0, 0xee, 0xed, 0x6e, 0xee, + 0xd3, 0x8a, 0x7d, 0x28, 0xec, 0x4e, 0xf1, 0x4e, 0x27, 0xa4, 0x36, 0xcb, 0xdd, 0xb5, 0x82, 0x7d, + 0x6a, 0x35, 0x6d, 0x4d, 0x54, 0x89, 0x11, 0x92, 0x6f, 0xc1, 0xe4, 0xba, 0xdb, 0x60, 0xb2, 0x37, + 0xee, 0x0d, 0xdc, 0x14, 0xf5, 0x03, 0x4c, 0x72, 0xcf, 0xc1, 0x31, 0x81, 0xea, 0xbb, 0x47, 0xc5, + 0xb7, 0x4e, 0x3b, 0x6d, 0x94, 0x0a, 0x4c, 0xb5, 0x36, 0x52, 0x86, 0xfc, 0x36, 0xdd, 0x61, 0xad, + 0x8d, 0x27, 0xc0, 0x96, 0x60, 0x61, 0xa4, 0x2e, 0x7e, 0x69, 0x46, 0xea, 0x02, 0x46, 0x3c, 0x98, + 0xc3, 0xfe, 0xa9, 0xd9, 0xbe, 0xff, 0xd0, 0xf5, 0x9a, 0x98, 0xe9, 0xb0, 0x9f, 0x95, 0xeb, 0x72, + 0x6a, 0xe7, 0x3f, 0xc3, 0x3b, 0xbf, 0xab, 0x70, 0x50, 0x45, 0xc8, 0x04, 0x7b, 0xf2, 0x0d, 0x98, + 0x11, 0xd1, 0xc6, 0xee, 0xde, 0x2c, 0xe1, 0x4a, 0x98, 0xd2, 0xe2, 0xa5, 0xe8, 0x85, 0xf2, 0xbd, + 0x0a, 0x61, 0x52, 0x07, 0x65, 0xb5, 0x77, 0x6d, 0xfd, 0xe1, 0x59, 0x25, 0x21, 0x35, 0x98, 0xac, + 0xd0, 0x07, 0x4e, 0x83, 0x62, 0x4c, 0x07, 0xe1, 0x02, 0x19, 0x66, 0xf0, 0x8d, 0x4a, 0xb8, 0x36, + 0xa6, 0x89, 0x00, 0x1e, 0x21, 0x42, 0x77, 0x5f, 0x09, 0x11, 0xc9, 0x0d, 0xc8, 0x55, 0x2b, 0x35, + 0xe1, 0x01, 0x39, 0x17, 0xc6, 0xf4, 0xab, 0xc9, 0x7c, 0xa7, 0x68, 0x17, 0xee, 0x34, 0x35, 0xff, + 0xc9, 0x6a, 0xa5, 0x46, 0x76, 0x61, 0x1a, 0x3b, 0x60, 0x8d, 0xda, 0xbc, 0x6f, 0x67, 0xfb, 0xf4, + 0xed, 0xd5, 0xd4, 0xbe, 0x5d, 0xe4, 0x7d, 0xbb, 0x2f, 0xa8, 0xb5, 0x04, 0x8e, 0x2a, 0x5b, 0x26, + 0xd4, 0x8a, 0xa4, 0xb2, 0x32, 0xed, 0xe0, 0xe6, 0x3a, 0xda, 0xbd, 0x0a, 0xa1, 0x56, 0xe6, 0xa0, + 0x0d, 0xf3, 0x20, 0xf6, 0x75, 0xb0, 0x4e, 0xf2, 0x21, 0x5f, 0x82, 0x91, 0x7b, 0x07, 0x81, 0x2d, + 0x7c, 0x1d, 0x65, 0x3f, 0x32, 0x90, 0x6c, 0x3e, 0xea, 0x21, 0xdd, 0x03, 0x2d, 0x4a, 0x34, 0xd2, + 0xb0, 0xa1, 0x58, 0xb3, 0xbd, 0xe6, 0x43, 0xdb, 0xc3, 0xc0, 0x3a, 0xf3, 0x1a, 0x0b, 0xa5, 0x84, + 0x0f, 0xc5, 0xbe, 0x00, 0xc4, 0x1e, 0x38, 0x55, 0x16, 0xe4, 0x7b, 0xe0, 0xbc, 0xef, 0xec, 0x75, + 0xec, 0xa0, 0xe7, 0x51, 0xcb, 0x6e, 0xed, 0xb9, 0x9e, 0x13, 0xec, 0xb7, 0x2d, 0xbf, 0xe7, 0x04, + 0x14, 0x9d, 0x0e, 0x67, 0x42, 0x99, 0xb1, 0x2e, 0xf1, 0x4a, 0x12, 0xad, 0xce, 0xb0, 0xcc, 0x73, + 0x7e, 0x7a, 0x01, 0xf9, 0x2a, 0x4c, 0xab, 0x5b, 0xb2, 0xbf, 0x78, 0xe6, 0x62, 0xee, 0xf2, 0x4c, + 0x78, 0xf5, 0x88, 0x6f, 0xe1, 0x32, 0xf7, 0x89, 0x72, 0x46, 0xf8, 0x7a, 0xee, 0x13, 0x85, 0x17, + 0x31, 0xe1, 0x9c, 0xcf, 0xf5, 0x1b, 0xbd, 0x8e, 0xf3, 0x08, 0xf3, 0xdb, 0x0a, 0xfb, 0xe8, 0xc5, + 0xb3, 0xda, 0xd1, 0x57, 0x47, 0xac, 0xad, 0x8d, 0xea, 0x57, 0xb6, 0x7c, 0xea, 0x09, 0x33, 0xe9, + 0x05, 0x4e, 0xbb, 0xd5, 0x71, 0x1e, 0x45, 0xd0, 0x30, 0x51, 0x3c, 0x29, 0xcc, 0x9b, 0x73, 0x62, + 0x15, 0x88, 0x91, 0xbb, 0x7b, 0xb3, 0x64, 0x8e, 0xd7, 0xaa, 0xf7, 0xeb, 0x2d, 0x37, 0x30, 0xf6, + 0x61, 0x21, 0x8d, 0x2b, 0x59, 0x84, 0x71, 0x91, 0x65, 0x0d, 0x0f, 0xc7, 0xbc, 0x29, 0x7f, 0x92, + 0xa7, 0x61, 0x62, 0xd7, 0xf1, 0xfc, 0xc0, 0xea, 0x39, 0x5c, 0x5e, 0x18, 0x35, 0xf3, 0x08, 0xd8, + 0x72, 0x9a, 0xe4, 0x3c, 0xe4, 0xf1, 0x8d, 0x8b, 0x95, 0xe5, 0xb0, 0x6c, 0x9c, 0xfd, 0xde, 0x72, + 0x9a, 0xc6, 0x7f, 0x93, 0xc1, 0x23, 0x88, 0xbc, 0x8c, 0x81, 0x6b, 0x43, 0xfb, 0x13, 0xd4, 0x3f, + 0xdb, 0xdd, 0x58, 0xd6, 0x32, 0x8e, 0x42, 0x5e, 0x85, 0xb1, 0x9b, 0x76, 0x83, 0x86, 0x66, 0x0d, + 0x88, 0xbc, 0x8b, 0x10, 0x55, 0x59, 0xcd, 0x71, 0x98, 0x7c, 0xcc, 0x97, 0x66, 0x29, 0x08, 0xa8, + 0xcf, 0xf7, 0xcf, 0x72, 0x49, 0x9a, 0x32, 0xa0, 0x7c, 0x2c, 0x96, 0xb4, 0x1d, 0x21, 0xc4, 0xdc, + 0xdc, 0x52, 0x39, 0x18, 0x7f, 0x94, 0x89, 0xf6, 0x54, 0xf2, 0x12, 0x8c, 0x98, 0xb5, 0xf0, 0xfb, + 0x79, 0xa8, 0x9f, 0xd8, 0xe7, 0x23, 0x02, 0xf9, 0x2a, 0x9c, 0x51, 0xf8, 0x24, 0x7c, 0xee, 0x5e, + 0xc4, 0x48, 0x34, 0xca, 0x97, 0xa4, 0x3b, 0xde, 0xa5, 0xf3, 0xc0, 0xcb, 0x40, 0x54, 0x50, 0xa1, + 0x1d, 0x87, 0xf3, 0x56, 0x1a, 0xab, 0xf2, 0x6e, 0x22, 0x42, 0xbc, 0xb1, 0x69, 0x1c, 0x78, 0x20, + 0x1a, 0xe3, 0xd7, 0x33, 0xda, 0x5e, 0x49, 0x2e, 0x69, 0x72, 0x2e, 0xae, 0xeb, 0x98, 0x52, 0x80, + 0x4b, 0xbc, 0x6f, 0x02, 0x94, 0x7a, 0x81, 0xbb, 0xda, 0xf1, 0xdc, 0x16, 0xd7, 0x02, 0x89, 0xc4, + 0x7d, 0xa8, 0xdb, 0xa6, 0x08, 0xd6, 0x42, 0x5c, 0x84, 0xc8, 0xa9, 0xee, 0x89, 0xb9, 0x8f, 0xeb, + 0x9e, 0x68, 0xfc, 0x5c, 0x56, 0xdb, 0x61, 0x98, 0x94, 0x2b, 0x26, 0xbd, 0x6a, 0x73, 0xdd, 0x75, + 0x1e, 0x58, 0x7e, 0xcb, 0xd5, 0xe2, 0xd7, 0x09, 0x34, 0xf2, 0x97, 0x32, 0x70, 0x96, 0xfb, 0xf9, + 0x6d, 0xf4, 0xda, 0x3b, 0xd4, 0xbb, 0x6f, 0xb7, 0x9c, 0x66, 0x14, 0x16, 0x3c, 0x32, 0xea, 0x57, + 0xaa, 0x49, 0xc7, 0xe7, 0x17, 0x6d, 0xee, 0x77, 0x68, 0x75, 0xb0, 0xd0, 0x7a, 0x10, 0x96, 0xaa, + 0x17, 0xed, 0x74, 0x7a, 0x52, 0x85, 0xc9, 0x9a, 0xd3, 0xc1, 0xa4, 0x96, 0x51, 0x64, 0x8c, 0x97, + 0xb8, 0xdb, 0x2e, 0x9b, 0xc2, 0x8d, 0x7d, 0x3a, 0x60, 0xeb, 0x56, 0x69, 0x8d, 0x5f, 0xcd, 0xc0, + 0x73, 0x27, 0x7e, 0x30, 0xb9, 0x06, 0xe3, 0xab, 0xea, 0xfa, 0xe7, 0x96, 0x40, 0xc9, 0xc4, 0x8b, + 0x12, 0x8b, 0x7c, 0x0d, 0xce, 0xa8, 0xac, 0x36, 0x3d, 0xdb, 0x51, 0x3d, 0x94, 0x53, 0x3a, 0x20, + 0x60, 0x28, 0x71, 0xb1, 0x35, 0x9d, 0x89, 0xf1, 0xff, 0x66, 0x60, 0x22, 0x74, 0x71, 0x7a, 0x42, + 0xaf, 0x33, 0x37, 0xb4, 0xeb, 0x8c, 0xcc, 0xaf, 0x10, 0xb6, 0x8a, 0x9b, 0x1e, 0xa5, 0x5c, 0x41, + 0x67, 0x15, 0x87, 0x30, 0x04, 0xfc, 0x48, 0x16, 0x26, 0xd9, 0x56, 0xcd, 0xdf, 0xb4, 0x3f, 0x5b, + 0x51, 0xe6, 0xc3, 0x76, 0x0d, 0x15, 0x07, 0xfc, 0x0f, 0x32, 0xf8, 0xd6, 0xa1, 0x52, 0xb0, 0xde, + 0x50, 0xb2, 0xe3, 0x63, 0x6f, 0x60, 0x5e, 0x7c, 0x84, 0xf2, 0xa8, 0xc8, 0xeb, 0xa2, 0x27, 0x44, + 0x54, 0xe4, 0x96, 0xc9, 0x60, 0xe4, 0xcb, 0x30, 0xba, 0x85, 0x9a, 0x5b, 0x3d, 0x4a, 0x5f, 0xc8, + 0x1f, 0x0b, 0xf9, 0x7e, 0xdf, 0xf3, 0xf5, 0x90, 0xd9, 0x9c, 0x90, 0xd4, 0x61, 0xbc, 0xec, 0x51, + 0x3b, 0xa0, 0x4d, 0xd1, 0x21, 0x43, 0xc5, 0x98, 0x6a, 0x70, 0x92, 0x78, 0x8c, 0x29, 0xc1, 0x89, + 0xed, 0x63, 0x24, 0x6a, 0x23, 0x5a, 0xed, 0xf8, 0x4f, 0xec, 0xa0, 0xbf, 0xa7, 0x0d, 0xfa, 0x85, + 0xc4, 0xa0, 0xf3, 0xe6, 0x0d, 0x35, 0xf6, 0xbf, 0x99, 0x81, 0xb3, 0xe9, 0x84, 0xe4, 0x79, 0x18, + 0xbb, 0xb7, 0x59, 0x8b, 0x2c, 0xe5, 0xb0, 0x29, 0x6e, 0x17, 0xd5, 0x26, 0xa6, 0x28, 0x22, 0xaf, + 0xc1, 0xd8, 0xfb, 0x66, 0x39, 0x32, 0x08, 0xc3, 0x0d, 0xee, 0x9b, 0x4c, 0xf2, 0xd2, 0x4e, 0x35, + 0x81, 0xa4, 0x8e, 0x6d, 0xee, 0xb1, 0x8d, 0xed, 0x4f, 0x66, 0x61, 0xb6, 0xd4, 0x68, 0x50, 0xdf, + 0x67, 0x22, 0x1a, 0xf5, 0x83, 0x27, 0x76, 0x60, 0xd3, 0x43, 0x38, 0x6a, 0x6d, 0x1b, 0x6a, 0x54, + 0x7f, 0x2b, 0x03, 0x67, 0x24, 0xd5, 0x03, 0x87, 0x3e, 0xdc, 0xdc, 0xf7, 0xa8, 0xbf, 0xef, 0xb6, + 0x9a, 0x43, 0xe7, 0x2a, 0x65, 0x32, 0x23, 0x66, 0xbe, 0x52, 0x0d, 0x1c, 0x76, 0x11, 0xa2, 0xc9, + 0x8c, 0x3c, 0x3b, 0xd6, 0x35, 0x18, 0x2f, 0x75, 0xbb, 0x9e, 0xfb, 0x80, 0x2f, 0x7b, 0x11, 0x14, + 0xdf, 0xe6, 0x20, 0x2d, 0xaa, 0x16, 0x07, 0xb1, 0xcf, 0xa8, 0xd0, 0xce, 0xa1, 0x6a, 0x9e, 0xd6, + 0xa4, 0x1d, 0xf5, 0x52, 0x82, 0xe5, 0x46, 0x1d, 0x48, 0xcd, 0x73, 0xdb, 0x6e, 0x40, 0x9b, 0xbc, + 0x3d, 0x18, 0x8c, 0xec, 0xc4, 0x70, 0xbd, 0x9b, 0x4e, 0xd0, 0xd2, 0xc2, 0xf5, 0x06, 0x0c, 0x60, + 0x72, 0x38, 0x3b, 0xbb, 0x2f, 0x68, 0x7d, 0x5a, 0xf1, 0x0e, 0xcd, 0x5e, 0x67, 0xb5, 0xe3, 0x39, + 0x8d, 0x7d, 0xf4, 0x9b, 0xdd, 0x00, 0x30, 0xa9, 0xed, 0xbb, 0x1d, 0x45, 0x58, 0xbb, 0xca, 0x33, + 0xb5, 0x32, 0x68, 0x52, 0xef, 0x30, 0x27, 0x38, 0x45, 0x54, 0xa6, 0xc2, 0x81, 0x94, 0x60, 0x9a, + 0xff, 0x62, 0x8d, 0xe9, 0x86, 0x82, 0xf8, 0xd3, 0xdc, 0x8b, 0x15, 0x59, 0x76, 0xb1, 0x44, 0x8f, + 0x70, 0xa1, 0x50, 0x18, 0xff, 0xd7, 0x28, 0x4c, 0xa9, 0x43, 0x4a, 0x0c, 0x9e, 0x76, 0xd0, 0xf5, + 0xd4, 0x98, 0x80, 0x36, 0x42, 0x4c, 0x51, 0x12, 0x05, 0xd4, 0xcc, 0x9e, 0x18, 0x50, 0x73, 0x1b, + 0xa6, 0x6b, 0x9e, 0x8b, 0x29, 0x07, 0xf0, 0xb5, 0x59, 0xec, 0xdf, 0xf3, 0x8a, 0xd6, 0x80, 0xcd, + 0x3e, 0x7c, 0xcf, 0xc6, 0x7b, 0x59, 0x57, 0x60, 0x5b, 0x4c, 0xf4, 0xd5, 0x74, 0x66, 0x1a, 0x1f, + 0x6e, 0x2a, 0xc3, 0x5a, 0xa2, 0x26, 0xd2, 0xe1, 0x8d, 0xd6, 0x4d, 0x65, 0x18, 0x44, 0xdd, 0x20, + 0x46, 0x1f, 0xd7, 0x06, 0x41, 0x7e, 0x2e, 0x03, 0x93, 0xa5, 0x4e, 0x47, 0x04, 0xea, 0x3c, 0x21, + 0xac, 0xd8, 0xd7, 0x84, 0xb5, 0xcc, 0x5b, 0x1f, 0xcb, 0x5a, 0x06, 0x85, 0x2d, 0x1f, 0x25, 0xf5, + 0xa8, 0x42, 0x2d, 0xd8, 0x4e, 0x04, 0x26, 0x6f, 0x41, 0x21, 0x5c, 0x99, 0xd5, 0x4e, 0x93, 0x3e, + 0xa2, 0x3c, 0xeb, 0xfc, 0xb4, 0xc8, 0x63, 0xa4, 0x4a, 0xe6, 0x71, 0x44, 0xb2, 0x09, 0x60, 0x87, + 0x4b, 0x42, 0x3c, 0xe2, 0x9d, 0x8f, 0x1e, 0x5c, 0x62, 0x6b, 0x46, 0xdc, 0x1e, 0xf0, 0x37, 0x3e, + 0x48, 0xaa, 0xb7, 0x87, 0x88, 0x0f, 0x69, 0xc3, 0x6c, 0xc9, 0xf7, 0x7b, 0x6d, 0x5a, 0x0f, 0x6c, + 0x2f, 0xc0, 0x64, 0x85, 0x30, 0xbc, 0x19, 0xa8, 0x8d, 0xa4, 0x6c, 0x46, 0x78, 0x81, 0x95, 0x92, + 0xb9, 0x30, 0xce, 0x9b, 0x67, 0x8d, 0x32, 0xcf, 0x25, 0xbf, 0x97, 0xaf, 0xd4, 0x9f, 0xcc, 0xc0, + 0x59, 0x75, 0xd2, 0xd7, 0x7b, 0x3b, 0x22, 0x55, 0x03, 0xb9, 0x0a, 0x13, 0x62, 0x4e, 0x86, 0x97, + 0xc8, 0x64, 0xce, 0xc5, 0x08, 0x85, 0xac, 0xb2, 0x69, 0xc8, 0x78, 0x88, 0x5b, 0xc7, 0x7c, 0x6c, + 0x73, 0x65, 0x45, 0x2b, 0x8b, 0x62, 0x42, 0x15, 0x3c, 0xfc, 0xad, 0xcf, 0x4f, 0x06, 0x31, 0xde, + 0x85, 0x39, 0x7d, 0x24, 0xea, 0x34, 0x20, 0x57, 0x60, 0x5c, 0x0e, 0x5f, 0x26, 0x7d, 0xf8, 0x64, + 0xb9, 0xb1, 0x0d, 0x24, 0x41, 0xef, 0xa3, 0x59, 0x1b, 0xbb, 0x9f, 0x73, 0xb3, 0x4b, 0xf9, 0xa8, + 0x9c, 0x40, 0x5c, 0x99, 0x17, 0xdf, 0x37, 0xa9, 0x39, 0x36, 0x62, 0xda, 0x8a, 0xdf, 0x2a, 0xc0, + 0x7c, 0xca, 0x41, 0x71, 0x82, 0x20, 0x57, 0xd4, 0x37, 0x88, 0x89, 0x30, 0x2a, 0xa1, 0xdc, 0x16, + 0xde, 0x85, 0xd1, 0x13, 0xb7, 0x03, 0xee, 0xd6, 0x1a, 0xdb, 0x05, 0x38, 0xd9, 0xa7, 0x22, 0xcc, + 0xa9, 0x51, 0x48, 0x47, 0x1f, 0x5b, 0x14, 0x52, 0x0c, 0x43, 0xa4, 0x6c, 0xe2, 0x7a, 0x68, 0x24, + 0x2c, 0xb0, 0x12, 0xdb, 0x96, 0x4e, 0xc2, 0x79, 0xf8, 0x6e, 0xeb, 0x01, 0x15, 0x3c, 0xc6, 0x55, + 0x1e, 0x58, 0x90, 0xca, 0x43, 0x21, 0x21, 0xff, 0x25, 0xe6, 0xcd, 0x47, 0x88, 0xba, 0x67, 0xe5, + 0x07, 0xed, 0x59, 0xcd, 0xc7, 0xb3, 0x67, 0x5d, 0x90, 0xdf, 0x98, 0xbe, 0x77, 0xa5, 0x7c, 0x16, + 0xf9, 0x3b, 0x19, 0x98, 0xe3, 0xd1, 0x2b, 0xd5, 0x8f, 0x1d, 0x18, 0x91, 0xb0, 0xf1, 0x78, 0x3e, + 0xf6, 0x19, 0x91, 0x70, 0x39, 0xfd, 0x5b, 0x93, 0x1f, 0x45, 0xbe, 0x07, 0x20, 0x5c, 0x51, 0x3c, + 0x75, 0xc7, 0xe4, 0xf2, 0x33, 0x29, 0xbb, 0x40, 0x88, 0x14, 0xa5, 0x4c, 0x0c, 0x42, 0x3a, 0x75, + 0xdb, 0x8c, 0xb8, 0x91, 0xbf, 0x08, 0x0b, 0x6c, 0xbd, 0x84, 0x10, 0x11, 0xb8, 0x77, 0x71, 0x12, + 0x6b, 0xf9, 0x7c, 0x7f, 0x41, 0xee, 0x6a, 0x1a, 0x19, 0x4f, 0xf4, 0x12, 0x1a, 0x59, 0x7b, 0x81, + 0x1a, 0x96, 0x2f, 0xb5, 0x22, 0x8c, 0x87, 0x8d, 0x5f, 0xcf, 0xd3, 0x1a, 0xf6, 0xd9, 0xdf, 0xce, + 0xcb, 0xb5, 0xc0, 0xf7, 0xb7, 0x98, 0x33, 0x12, 0x82, 0xc8, 0xfb, 0x40, 0xc2, 0xb0, 0x8f, 0x1c, + 0x46, 0x65, 0xca, 0x43, 0xfe, 0x58, 0x10, 0x85, 0x8f, 0xf4, 0x64, 0xb1, 0x3a, 0x49, 0x92, 0xc4, + 0x84, 0xc2, 0x82, 0x68, 0x34, 0x83, 0xca, 0xa4, 0xf6, 0xfe, 0xe2, 0x8c, 0x16, 0x16, 0x39, 0x2a, + 0x59, 0x79, 0x56, 0x7c, 0xe7, 0x59, 0x25, 0x33, 0xbe, 0xa6, 0x72, 0x4b, 0x63, 0x47, 0x6e, 0xc0, + 0x04, 0x86, 0x2f, 0x59, 0x93, 0xc6, 0x7a, 0xc2, 0x70, 0x08, 0x03, 0x9d, 0x58, 0xfb, 0xba, 0xc9, + 0x5d, 0x84, 0xca, 0xee, 0x30, 0x5c, 0x02, 0x44, 0x95, 0xbe, 0x50, 0xd2, 0x34, 0xbd, 0x43, 0xcb, + 0xeb, 0xe9, 0xa1, 0x71, 0x10, 0x89, 0x7c, 0x03, 0x26, 0xef, 0xda, 0x8f, 0xa4, 0x5a, 0x48, 0xa8, + 0xed, 0x4f, 0x72, 0x60, 0xc2, 0xd6, 0xb4, 0xed, 0x47, 0x56, 0xb3, 0x17, 0x4f, 0x33, 0xc3, 0x1d, + 0x98, 0x14, 0x96, 0xe4, 0x43, 0x00, 0xe5, 0x9d, 0x81, 0x9c, 0x58, 0xc1, 0x73, 0x32, 0xd8, 0x77, + 0xea, 0xfb, 0x03, 0xf2, 0x57, 0x18, 0xc6, 0x24, 0x87, 0x85, 0x4f, 0x4f, 0x72, 0x38, 0xf3, 0xe9, + 0x49, 0x0e, 0xfc, 0x99, 0x8b, 0x8f, 0x3d, 0xee, 0xe0, 0x87, 0x42, 0xcb, 0x3f, 0xa8, 0xb6, 0x67, + 0xa4, 0x29, 0x28, 0x1e, 0x05, 0x87, 0xb1, 0x2a, 0x62, 0xfc, 0x88, 0x07, 0x85, 0xf8, 0xc5, 0x60, + 0xf1, 0x9c, 0x66, 0x59, 0x38, 0xf0, 0x12, 0xc1, 0xd5, 0xad, 0x62, 0x1a, 0x59, 0x34, 0x84, 0xab, + 0x42, 0x5d, 0x9c, 0x66, 0x69, 0x07, 0xce, 0xf7, 0xdd, 0x10, 0x52, 0x72, 0xdb, 0x5c, 0xd3, 0x73, + 0xdb, 0x9c, 0xef, 0x27, 0x38, 0xf8, 0x7a, 0xbe, 0xce, 0xf9, 0xc2, 0x42, 0x7f, 0x99, 0xeb, 0x3b, + 0xd9, 0x98, 0x20, 0x21, 0xee, 0x78, 0x3c, 0xbb, 0x75, 0x3f, 0x49, 0x2b, 0x5b, 0xad, 0xb0, 0x4b, + 0x1d, 0x8a, 0x1a, 0x4a, 0x76, 0x31, 0x26, 0x6a, 0xa8, 0xa2, 0x0a, 0x0a, 0x1d, 0x9f, 0x54, 0xa6, + 0x78, 0x1b, 0x66, 0xea, 0xd4, 0xf6, 0x1a, 0xfb, 0x77, 0xe8, 0xe1, 0x43, 0xd7, 0x6b, 0xf2, 0x2c, + 0xb8, 0xe2, 0x66, 0xe1, 0x63, 0x89, 0x1e, 0xb2, 0x41, 0xc5, 0x25, 0x15, 0x19, 0x93, 0x63, 0x14, + 0x6b, 0x3f, 0x9f, 0xba, 0x37, 0x33, 0x84, 0x41, 0xe1, 0x3a, 0xc8, 0x1b, 0xa1, 0xf8, 0x49, 0x3d, + 0x35, 0x6b, 0xa7, 0x27, 0x81, 0x29, 0x52, 0x28, 0xf5, 0x8c, 0xdf, 0xcb, 0x01, 0xe1, 0x35, 0x95, + 0xed, 0xae, 0x8d, 0x51, 0x70, 0x1c, 0x0c, 0x75, 0x5b, 0x10, 0x38, 0xf6, 0x4e, 0x8b, 0xaa, 0x71, + 0xa2, 0x85, 0xc9, 0x77, 0x58, 0x66, 0xc5, 0xaf, 0x6f, 0x09, 0xc2, 0x3e, 0x1b, 0x78, 0xf6, 0x93, + 0x6c, 0xe0, 0xdf, 0x80, 0xa7, 0x4b, 0xdd, 0x6e, 0xcb, 0x69, 0x84, 0xb5, 0xdc, 0x74, 0x3d, 0xb9, + 0x5c, 0xb4, 0x58, 0x08, 0x76, 0x88, 0x96, 0xf8, 0xd2, 0x41, 0x2c, 0x14, 0xe9, 0x8b, 0x5f, 0x78, + 0xd5, 0x78, 0x5d, 0x52, 0xfa, 0x4a, 0xbb, 0x22, 0x2b, 0x24, 0x92, 0x87, 0xe3, 0x49, 0xe9, 0x0b, + 0xb3, 0x62, 0x47, 0x3c, 0x1c, 0x8f, 0xf6, 0x91, 0xe0, 0x42, 0x12, 0xf2, 0x36, 0x4c, 0x96, 0x7a, + 0x81, 0x2b, 0x18, 0x0b, 0x5f, 0x85, 0xc8, 0xab, 0x40, 0x7c, 0x8a, 0x76, 0xa1, 0x8b, 0xd0, 0x8d, + 0x3f, 0xcc, 0xc1, 0xf9, 0xe4, 0xf0, 0x8a, 0xd2, 0x70, 0x7d, 0x64, 0x4e, 0x58, 0x1f, 0x69, 0xb3, + 0x21, 0x1b, 0xe5, 0x2b, 0x7c, 0x1c, 0xb3, 0x81, 0x47, 0xe0, 0xf9, 0x98, 0xb3, 0xa1, 0x0e, 0x93, + 0xea, 0x29, 0x3e, 0xf2, 0x71, 0x4f, 0x71, 0x95, 0x0b, 0xb9, 0x02, 0xa3, 0x3c, 0x4c, 0xd9, 0x68, + 0xf4, 0x20, 0x18, 0x8f, 0x50, 0xc6, 0x31, 0xc8, 0x7f, 0x04, 0x17, 0xf9, 0x9e, 0x14, 0x6f, 0xec, + 0xca, 0xa1, 0xe4, 0x28, 0x06, 0x6e, 0xf9, 0xf8, 0xa8, 0x78, 0x95, 0x6b, 0xad, 0xac, 0x44, 0xb7, + 0x59, 0x3b, 0x87, 0x96, 0xfc, 0x32, 0xa5, 0x92, 0x13, 0x79, 0x1b, 0x65, 0x38, 0x2f, 0x4a, 0xa3, + 0x60, 0x36, 0xb2, 0x90, 0x0d, 0xf2, 0x41, 0xa4, 0x78, 0xc4, 0x41, 0x8e, 0xe9, 0x14, 0xb1, 0x1c, + 0x13, 0x03, 0x45, 0xed, 0x27, 0xaf, 0xa5, 0x79, 0x82, 0xf1, 0xe4, 0x4c, 0x1c, 0xac, 0x3b, 0x81, + 0x49, 0xf5, 0x66, 0x36, 0x55, 0xbd, 0x29, 0xf5, 0x63, 0xb9, 0x54, 0xfd, 0x58, 0x05, 0x66, 0xeb, + 0xbd, 0x1d, 0x59, 0x77, 0x3c, 0x8e, 0x85, 0xdf, 0xdb, 0x49, 0xeb, 0x95, 0x38, 0x89, 0xf1, 0xa3, + 0x59, 0x98, 0xaa, 0xb5, 0x7a, 0x7b, 0x4e, 0xa7, 0x62, 0x07, 0xf6, 0x13, 0xab, 0x71, 0x7d, 0x53, + 0xd3, 0xb8, 0x86, 0x0e, 0x8f, 0x61, 0xc3, 0x86, 0x52, 0xb7, 0xfe, 0x6c, 0x06, 0x66, 0x23, 0x12, + 0x7e, 0x58, 0xaf, 0xc1, 0x08, 0xfb, 0x21, 0xae, 0xf4, 0x17, 0x13, 0x8c, 0x11, 0xeb, 0x6a, 0xf8, + 0x97, 0xd0, 0x81, 0xea, 0x99, 0xc0, 0x91, 0xc3, 0xd2, 0x17, 0x60, 0x22, 0x62, 0x9b, 0x94, 0x01, + 0x16, 0x54, 0x19, 0x60, 0x42, 0x4d, 0x64, 0xf7, 0x6b, 0x19, 0x28, 0xc4, 0x5b, 0x42, 0xee, 0xc0, + 0x38, 0xe3, 0xe4, 0x50, 0xa9, 0x6d, 0x78, 0xa1, 0x4f, 0x9b, 0xaf, 0x0a, 0x34, 0xfe, 0x79, 0xd8, + 0xf9, 0x94, 0x43, 0x4c, 0xc9, 0x61, 0xc9, 0x84, 0x29, 0x15, 0x2b, 0xe5, 0xeb, 0x5e, 0xd5, 0x25, + 0x94, 0xb3, 0xe9, 0xfd, 0xa0, 0x7e, 0xf5, 0x2f, 0x6a, 0x5f, 0x2d, 0x84, 0x8f, 0x4b, 0xda, 0xe4, + 0x4a, 0x5d, 0x55, 0x38, 0x69, 0x96, 0xa3, 0xb4, 0x74, 0xea, 0x3c, 0x4b, 0x99, 0xd0, 0x21, 0x1e, + 0x79, 0x15, 0xc6, 0x78, 0x7d, 0x6a, 0x5a, 0xf0, 0x2e, 0x42, 0x54, 0xe9, 0x9f, 0xe3, 0x18, 0x7f, + 0x2d, 0x07, 0x67, 0xa3, 0xcf, 0xdb, 0xea, 0x36, 0xed, 0x80, 0xd6, 0x6c, 0xcf, 0x6e, 0xfb, 0x27, + 0xac, 0x80, 0xcb, 0x89, 0x4f, 0x13, 0x11, 0x12, 0x38, 0x4c, 0xf9, 0x20, 0x23, 0xf6, 0x41, 0xa8, + 0xd9, 0xe5, 0x1f, 0x24, 0x3f, 0x83, 0xdc, 0x81, 0x5c, 0x9d, 0x06, 0x62, 0xef, 0xbd, 0x94, 0xe8, + 0x55, 0xf5, 0xbb, 0xae, 0xd6, 0x69, 0xc0, 0x07, 0x91, 0xc7, 0xe0, 0xd4, 0x62, 0x11, 0x30, 0x2e, + 0x64, 0x1b, 0xc6, 0x56, 0x1f, 0x75, 0x69, 0x23, 0xc0, 0xc4, 0x4b, 0x8a, 0x53, 0x7e, 0x3a, 0x3f, + 0x8e, 0xcb, 0x59, 0x2e, 0x08, 0x71, 0x5a, 0xcf, 0xed, 0x27, 0xd8, 0x2d, 0xdd, 0x80, 0xbc, 0xac, + 0xfc, 0x34, 0x33, 0x77, 0xe9, 0x4d, 0x98, 0x54, 0x2a, 0x39, 0xd5, 0xa4, 0xff, 0x25, 0xb6, 0xaf, + 0xba, 0x2d, 0x2a, 0x26, 0xce, 0x6a, 0x42, 0x56, 0x54, 0x72, 0x1a, 0x73, 0x59, 0xd1, 0x3a, 0x10, + 0x45, 0x03, 0x84, 0xc6, 0x2a, 0xcc, 0xd6, 0x0f, 0x9c, 0x6e, 0x94, 0xa7, 0x43, 0x3b, 0x91, 0x31, + 0x6f, 0xaa, 0x50, 0x47, 0xc4, 0x4f, 0xe4, 0x38, 0x9d, 0xf1, 0x27, 0x19, 0x18, 0x63, 0x7f, 0xdd, + 0xbf, 0xf1, 0x84, 0x6e, 0x99, 0xaf, 0x6b, 0x5b, 0xe6, 0x9c, 0x92, 0x77, 0x0b, 0x37, 0x8e, 0x1b, + 0x27, 0x6c, 0x96, 0x47, 0x62, 0x80, 0x38, 0x32, 0xb9, 0x05, 0xe3, 0xc2, 0xcc, 0x4d, 0x78, 0x24, + 0xa8, 0x89, 0xbc, 0xa4, 0x01, 0x5c, 0xa8, 0xb7, 0x70, 0xbb, 0x71, 0x45, 0x8f, 0xa4, 0x66, 0x72, + 0xbd, 0xcc, 0x98, 0xa2, 0xe6, 0xf9, 0x64, 0x6c, 0xca, 0x6e, 0x87, 0xa7, 0xa1, 0xf2, 0x57, 0xce, + 0x09, 0x4e, 0xfd, 0x62, 0x0e, 0x95, 0xc4, 0xc3, 0x54, 0x6e, 0x10, 0x93, 0xb3, 0x82, 0x49, 0xfa, + 0x9b, 0x55, 0x1b, 0xce, 0xd6, 0xeb, 0x6b, 0x68, 0x12, 0x5b, 0x73, 0xbd, 0xe0, 0xa6, 0xeb, 0x3d, + 0x14, 0xa1, 0x55, 0xea, 0xba, 0x39, 0x48, 0x9a, 0xa1, 0xe2, 0x4b, 0xa9, 0x86, 0x8a, 0x03, 0x4c, + 0x46, 0x8c, 0x0e, 0x9c, 0xab, 0xd7, 0xd7, 0x78, 0x12, 0xa8, 0x3f, 0x8d, 0xfa, 0x7e, 0x2d, 0x03, + 0x73, 0xf5, 0xfa, 0x5a, 0xac, 0xaa, 0x75, 0x99, 0x7d, 0x2a, 0xa3, 0xbd, 0x49, 0xa7, 0x77, 0x04, + 0x8e, 0x42, 0x86, 0x4b, 0x78, 0x0d, 0x2d, 0x86, 0x38, 0x67, 0x42, 0x6a, 0x61, 0xbe, 0xab, 0xac, + 0xe6, 0xa5, 0xd2, 0xa7, 0xa1, 0xa8, 0xb7, 0x17, 0x3e, 0x9e, 0xac, 0x54, 0xd7, 0xdb, 0x33, 0x88, + 0xf1, 0xdf, 0x9f, 0xe5, 0x19, 0xb5, 0xe4, 0x6c, 0x79, 0x07, 0xa6, 0x04, 0x3d, 0xba, 0x72, 0x08, + 0xf3, 0x9c, 0xf3, 0x6c, 0x83, 0xdc, 0xe5, 0x70, 0x9e, 0x1c, 0xe5, 0xbb, 0x47, 0xc5, 0x11, 0xd6, + 0x35, 0xa6, 0x86, 0x4e, 0xee, 0xc1, 0xf4, 0x5d, 0xfb, 0x91, 0xa2, 0xa4, 0xe1, 0x8e, 0x7a, 0x57, + 0xd8, 0xae, 0xd2, 0xb6, 0x1f, 0x0d, 0x61, 0x08, 0xaa, 0xd3, 0x93, 0x03, 0x98, 0xd1, 0xdb, 0x24, + 0x66, 0x60, 0x72, 0xc4, 0xae, 0xa7, 0x8e, 0xd8, 0xf9, 0xae, 0xeb, 0x05, 0xd6, 0x6e, 0x48, 0xae, + 0x65, 0x8f, 0x8b, 0xb1, 0x26, 0xef, 0xc0, 0x9c, 0x12, 0xa9, 0xfd, 0xa6, 0xeb, 0xb5, 0x6d, 0x79, + 0xe1, 0xc2, 0x97, 0x0b, 0xb4, 0x10, 0xdb, 0x45, 0xb0, 0x99, 0xc4, 0x24, 0x5f, 0x4d, 0x73, 0x7e, + 0x1c, 0x8d, 0xac, 0x61, 0x53, 0x9c, 0x1f, 0xfb, 0x59, 0xc3, 0x26, 0xdd, 0x20, 0xf7, 0x06, 0x59, + 0xcb, 0xe7, 0x79, 0xeb, 0x87, 0xb2, 0x86, 0x0f, 0x47, 0xae, 0x8f, 0x55, 0xfc, 0x32, 0xe4, 0x56, + 0x6a, 0x37, 0xf1, 0xbd, 0x4d, 0x9a, 0xc6, 0x75, 0xf6, 0xed, 0x4e, 0x03, 0x2f, 0x42, 0xc2, 0x47, + 0x45, 0x3d, 0x28, 0x57, 0x6a, 0x37, 0x89, 0x0d, 0xf3, 0x98, 0x2d, 0x3c, 0xf8, 0xca, 0xf5, 0xeb, + 0xca, 0x50, 0xe5, 0xf1, 0xd3, 0xae, 0x89, 0x4f, 0x2b, 0x62, 0xae, 0xf1, 0xc0, 0x7a, 0x74, 0xfd, + 0x7a, 0xea, 0x80, 0x84, 0x1f, 0x96, 0xc6, 0x8b, 0x1d, 0x58, 0x77, 0xed, 0x47, 0x91, 0x6b, 0x91, + 0x2f, 0xdc, 0xc8, 0x2f, 0xc8, 0xa9, 0x15, 0xb9, 0x25, 0x69, 0x07, 0x96, 0x4e, 0xc4, 0xee, 0xb1, + 0xd1, 0x04, 0xf3, 0x85, 0x03, 0xde, 0x92, 0x54, 0x42, 0xca, 0x58, 0x03, 0xea, 0x65, 0x4c, 0x41, + 0x27, 0x5b, 0xe1, 0x6d, 0x9c, 0xdf, 0x66, 0xd1, 0x66, 0x7d, 0x62, 0xe5, 0x9a, 0x7a, 0x1b, 0xe7, + 0xaa, 0x3f, 0xad, 0x59, 0xb3, 0xa1, 0x0a, 0x87, 0xfb, 0x5a, 0x99, 0x3a, 0x97, 0xe4, 0x25, 0x7f, + 0xea, 0xf4, 0x97, 0x7c, 0x0a, 0x23, 0xeb, 0x6e, 0xe3, 0x40, 0x04, 0x42, 0x7e, 0x9f, 0xed, 0xc2, + 0x2d, 0xb7, 0x71, 0xf0, 0xf8, 0xbc, 0x00, 0x90, 0x3d, 0xd9, 0xe0, 0x81, 0x74, 0xbc, 0xa6, 0xe8, + 0x13, 0x61, 0x59, 0xbe, 0x10, 0xde, 0x72, 0x95, 0xb2, 0x28, 0xbc, 0x8e, 0xd7, 0x94, 0x5d, 0x6b, + 0xea, 0xe4, 0x84, 0x42, 0xa1, 0x42, 0xfd, 0x83, 0xc0, 0xed, 0x96, 0x5b, 0x4e, 0x17, 0x63, 0x53, + 0x89, 0x4c, 0x3a, 0x43, 0xef, 0xc9, 0x4d, 0x4e, 0x6f, 0x35, 0x24, 0x03, 0x33, 0xc1, 0x92, 0x7c, + 0x15, 0x66, 0xd8, 0xe4, 0x5e, 0x7d, 0x14, 0xd0, 0x0e, 0x1f, 0xf9, 0x39, 0x94, 0xe8, 0x16, 0x94, + 0x3c, 0x94, 0x61, 0x21, 0x9f, 0x53, 0xb8, 0xd8, 0x69, 0x48, 0xa0, 0x05, 0x91, 0xd6, 0x58, 0x91, + 0x26, 0x2c, 0xde, 0xb5, 0x1f, 0x45, 0x77, 0x5e, 0x75, 0x92, 0x12, 0x9c, 0x60, 0x97, 0x8f, 0x8f, + 0x8a, 0x2f, 0xb0, 0x09, 0x16, 0x25, 0x77, 0xea, 0x33, 0x5f, 0xfb, 0x72, 0x22, 0xdf, 0x82, 0x73, + 0xa2, 0x59, 0x15, 0x4c, 0x0f, 0xed, 0x7a, 0x87, 0xf5, 0x7d, 0x1b, 0xbd, 0x0a, 0xe7, 0xfb, 0x74, + 0xd8, 0xb5, 0xf4, 0x2d, 0x51, 0x76, 0x58, 0x53, 0xf2, 0xb1, 0x7c, 0xce, 0xc8, 0xec, 0x57, 0x03, + 0xf9, 0x08, 0x66, 0xf8, 0x23, 0xe3, 0x9a, 0xeb, 0x07, 0xa8, 0xac, 0x59, 0x38, 0x9d, 0xab, 0x0c, + 0x7f, 0xb9, 0xe4, 0xee, 0x65, 0x31, 0xe5, 0x4e, 0x8c, 0x33, 0x79, 0x0b, 0xad, 0x51, 0x79, 0x98, + 0xf7, 0x6a, 0x0d, 0x95, 0xe5, 0xe2, 0x04, 0xea, 0x3a, 0x1d, 0x4b, 0x6a, 0x4c, 0xba, 0xe1, 0x76, + 0xa1, 0x62, 0x93, 0x6d, 0x98, 0xac, 0xd7, 0xd7, 0x6e, 0x3a, 0x4c, 0x2e, 0xe9, 0x4a, 0xdd, 0x77, + 0xf2, 0x2b, 0x9f, 0x4f, 0xfd, 0xca, 0x69, 0xdf, 0xdf, 0xb7, 0x76, 0x9d, 0x16, 0xb5, 0x1a, 0x6e, + 0xf7, 0xd0, 0x54, 0x39, 0xa5, 0xb8, 0x8f, 0x9c, 0x7b, 0xcc, 0xee, 0x23, 0x55, 0x98, 0x55, 0x4c, + 0xa2, 0xd1, 0xc2, 0x66, 0x31, 0x8a, 0xe3, 0xa9, 0xba, 0x8b, 0xc4, 0x1d, 0xa6, 0xe3, 0x74, 0xd2, + 0x6f, 0xe4, 0xfc, 0x69, 0xfd, 0x46, 0x1c, 0x98, 0xe3, 0x83, 0x21, 0xe6, 0x01, 0x8e, 0xf4, 0x52, + 0x9f, 0x3e, 0xbc, 0x92, 0xda, 0x87, 0xf3, 0x62, 0xa4, 0xe5, 0x24, 0xc3, 0x47, 0xf5, 0x24, 0x57, + 0xb2, 0x0b, 0x44, 0x00, 0xed, 0xc0, 0xde, 0xb1, 0x7d, 0x8a, 0x75, 0x3d, 0xdd, 0xa7, 0xae, 0x17, + 0x52, 0xeb, 0x9a, 0x91, 0x75, 0xed, 0xf0, 0x6a, 0x52, 0x38, 0x92, 0x8e, 0xac, 0x47, 0xce, 0x2f, + 0xec, 0xd8, 0x67, 0x34, 0x1d, 0x77, 0x12, 0x81, 0x87, 0xc4, 0x8c, 0x4f, 0xda, 0x78, 0xbf, 0xa7, + 0x70, 0x26, 0x8f, 0xe0, 0x6c, 0xf2, 0x2b, 0xb0, 0xce, 0x0b, 0x58, 0xe7, 0x05, 0xad, 0xce, 0x38, + 0x12, 0x9f, 0x37, 0x7a, 0xb3, 0xe2, 0xb5, 0xf6, 0xe1, 0x4f, 0x7e, 0x38, 0x03, 0xe7, 0xee, 0xde, + 0x2c, 0xdd, 0xa7, 0x1e, 0x17, 0x4b, 0x1c, 0xb7, 0x13, 0x3a, 0x9a, 0x3f, 0x2b, 0xde, 0x41, 0xe2, + 0x6f, 0x40, 0x52, 0xe2, 0xc0, 0xad, 0x82, 0x89, 0xee, 0xcf, 0xb7, 0x77, 0x6d, 0xeb, 0x81, 0xc2, + 0x22, 0xc5, 0x1b, 0xfd, 0x17, 0x7e, 0xbf, 0x98, 0x31, 0xfb, 0x55, 0x45, 0x5a, 0xb0, 0xa4, 0x77, + 0x8b, 0xf4, 0xec, 0xd9, 0xa7, 0xad, 0xd6, 0x62, 0x11, 0x67, 0xf4, 0xab, 0xc7, 0x47, 0xc5, 0xcb, + 0x89, 0xde, 0x0d, 0xbd, 0x85, 0x18, 0xa6, 0xd2, 0xe0, 0x01, 0xfc, 0x48, 0x3b, 0x45, 0xe8, 0x5e, + 0xbc, 0xa8, 0x45, 0xa4, 0x4a, 0x94, 0x87, 0x11, 0xd3, 0x2e, 0xb0, 0xf5, 0xde, 0x57, 0x40, 0x34, + 0x93, 0x9c, 0x6f, 0x8f, 0xe4, 0xa7, 0x0b, 0x33, 0x29, 0x2e, 0x2f, 0xc6, 0x6f, 0x64, 0x63, 0x07, + 0x23, 0xa9, 0xc2, 0xb8, 0x98, 0xef, 0x7d, 0x2f, 0x19, 0x17, 0x52, 0x67, 0xf5, 0xb8, 0x58, 0x3a, + 0xa6, 0xa4, 0x27, 0x0f, 0x19, 0x2b, 0x6c, 0xb4, 0xb8, 0xf1, 0x7e, 0xc8, 0xcf, 0x3d, 0x04, 0x69, + 0x27, 0x7c, 0xe5, 0xf4, 0xee, 0xa1, 0xba, 0xf7, 0x31, 0x1e, 0xf5, 0xb2, 0x36, 0x72, 0xc0, 0xd3, + 0x02, 0xe7, 0x42, 0x0f, 0x43, 0x3d, 0x07, 0xf0, 0x63, 0xab, 0x90, 0xd5, 0x62, 0xfc, 0x7a, 0x06, + 0xa6, 0xb5, 0x93, 0x95, 0xdc, 0x50, 0x1c, 0x68, 0xa3, 0x98, 0x12, 0x1a, 0x0e, 0x6e, 0xb6, 0x71, + 0xd7, 0xda, 0x1b, 0x4a, 0x2c, 0xc6, 0x3e, 0x74, 0xb8, 0xd8, 0xe2, 0xfe, 0xd4, 0x83, 0xf5, 0xc3, + 0x45, 0x18, 0xe5, 0xc1, 0x78, 0x46, 0x22, 0xfb, 0x49, 0xd4, 0xaf, 0x98, 0x1c, 0x6e, 0xfc, 0xe7, + 0x45, 0x98, 0xd1, 0x6f, 0xc4, 0xe4, 0x55, 0x18, 0x43, 0xdd, 0xbc, 0x54, 0xaf, 0xa0, 0x5a, 0x08, + 0xd5, 0xf7, 0x9a, 0x8b, 0x11, 0xc7, 0x21, 0x2f, 0x02, 0x84, 0xb6, 0xf8, 0xf2, 0x65, 0x6a, 0xf4, + 0xf8, 0xa8, 0x98, 0x79, 0xcd, 0x54, 0x0a, 0xc8, 0xd7, 0x01, 0x36, 0xdc, 0x26, 0x15, 0x59, 0x2e, + 0x73, 0x83, 0x6c, 0x4a, 0x5e, 0x4a, 0x64, 0xb9, 0x3c, 0xd3, 0x71, 0x9b, 0x34, 0x99, 0xd2, 0x52, + 0xe1, 0x48, 0xbe, 0x04, 0xa3, 0x66, 0xaf, 0x45, 0xe5, 0x0b, 0xc6, 0xa4, 0x3c, 0xe1, 0x7a, 0x2d, + 0x1a, 0xe9, 0x09, 0xbc, 0x5e, 0xdc, 0x5c, 0x92, 0x01, 0xc8, 0x7b, 0x3c, 0xfb, 0xa5, 0x88, 0x9d, + 0x3e, 0x1a, 0xbd, 0xd5, 0x29, 0x92, 0x4f, 0x22, 0x7a, 0xba, 0x42, 0x42, 0xee, 0xc1, 0xb8, 0xfa, + 0xc8, 0xa4, 0x44, 0x62, 0x50, 0x1f, 0x22, 0x15, 0xa5, 0x83, 0x08, 0x22, 0x1b, 0x7f, 0x7f, 0x92, + 0x5c, 0xc8, 0xdb, 0x30, 0xc1, 0xd8, 0xb3, 0x9d, 0xc3, 0x17, 0xb7, 0x1a, 0x7c, 0x91, 0x53, 0x3e, + 0x88, 0xed, 0x3e, 0x5a, 0x84, 0xf3, 0x90, 0x80, 0x7c, 0x15, 0x26, 0x4a, 0xdd, 0xae, 0xe8, 0xea, + 0x81, 0xb6, 0x46, 0x97, 0x12, 0x5d, 0xbd, 0x60, 0x77, 0xbb, 0xc9, 0x9e, 0x8e, 0xf8, 0x91, 0xbd, + 0x30, 0x10, 0xe0, 0x30, 0x19, 0x4b, 0x5f, 0x4e, 0x54, 0xb0, 0x28, 0x63, 0xdb, 0x25, 0x2a, 0xd1, + 0xf9, 0x92, 0x2e, 0x14, 0x22, 0xa1, 0x52, 0xd4, 0x05, 0x83, 0xea, 0x7a, 0x2d, 0x51, 0x97, 0x3a, + 0x80, 0x89, 0xea, 0x12, 0xdc, 0x49, 0x13, 0x66, 0xe4, 0x01, 0x25, 0xea, 0x9b, 0x1c, 0x54, 0xdf, + 0x8b, 0x89, 0xfa, 0xe6, 0x9b, 0x3b, 0xc9, 0x7a, 0x62, 0x3c, 0xc9, 0xdb, 0x30, 0x2d, 0x21, 0xb8, + 0x3e, 0xd0, 0xc6, 0x47, 0x28, 0x04, 0x9b, 0x3b, 0xe8, 0xfd, 0xa3, 0xf5, 0x8a, 0x86, 0xac, 0x52, + 0xf3, 0xd9, 0x31, 0xad, 0x51, 0xc7, 0x67, 0x85, 0x8e, 0x4c, 0x3e, 0x80, 0xc9, 0x6a, 0x9b, 0x35, + 0xc4, 0xed, 0xd8, 0x01, 0x15, 0x3e, 0xba, 0xd2, 0x6e, 0x4a, 0x29, 0x51, 0xa6, 0x2a, 0x5a, 0x8c, + 0x38, 0x51, 0x91, 0x7a, 0xcd, 0x54, 0x28, 0x58, 0xe7, 0xf1, 0x57, 0x45, 0x31, 0x87, 0xa5, 0xff, + 0xee, 0x85, 0x14, 0xdb, 0x25, 0x85, 0xbd, 0x88, 0x93, 0xcd, 0xa0, 0xf2, 0x55, 0x2f, 0x96, 0xa3, + 0x40, 0xe5, 0x49, 0xde, 0x81, 0x49, 0x91, 0xcc, 0xb9, 0x64, 0x6e, 0xf8, 0x8b, 0x85, 0xc8, 0xf4, + 0x5a, 0xe6, 0x7d, 0xb6, 0x6c, 0x2f, 0x66, 0xa4, 0x1b, 0xe1, 0x93, 0xaf, 0xc0, 0xc2, 0xb6, 0xd3, + 0x69, 0xba, 0x0f, 0x7d, 0x71, 0x4c, 0x89, 0x8d, 0x6e, 0x2e, 0x72, 0x11, 0x7c, 0xc8, 0xcb, 0x43, + 0x59, 0x30, 0xb1, 0xf1, 0xa5, 0x72, 0x20, 0xdf, 0x97, 0xe0, 0xcc, 0x67, 0x10, 0x19, 0x34, 0x83, + 0x96, 0x13, 0x33, 0x28, 0x59, 0x7d, 0x7c, 0x3a, 0xa5, 0x56, 0x43, 0x5c, 0x20, 0xfa, 0xf9, 0x7e, + 0xdb, 0x75, 0x3a, 0x8b, 0xf3, 0xb8, 0x17, 0x3e, 0x1d, 0x8f, 0xf4, 0x81, 0x78, 0x35, 0xb7, 0xe5, + 0x34, 0x0e, 0x79, 0xe2, 0x96, 0xb8, 0xcc, 0xff, 0x91, 0xab, 0x3d, 0x97, 0xa4, 0xb0, 0x26, 0x1f, + 0xc0, 0x14, 0xfb, 0x3f, 0x54, 0x4a, 0x2c, 0x68, 0xd6, 0xae, 0x0a, 0xa6, 0xa8, 0x07, 0xc7, 0x08, + 0xb3, 0x4d, 0xa7, 0xe8, 0x2b, 0x34, 0x56, 0xe4, 0x4d, 0x00, 0x26, 0x36, 0x89, 0xed, 0xf8, 0x4c, + 0x94, 0x12, 0x02, 0xa5, 0xae, 0xe4, 0x46, 0x1c, 0x21, 0x93, 0xb7, 0x61, 0x92, 0xfd, 0xaa, 0xf7, + 0x9a, 0x2e, 0x5b, 0x1b, 0x67, 0x91, 0x96, 0xbb, 0x4b, 0x33, 0x5a, 0x9f, 0xc3, 0x35, 0x77, 0xe9, + 0x08, 0x9d, 0xac, 0xc1, 0x2c, 0xa6, 0xee, 0x10, 0x41, 0xe3, 0x1d, 0xea, 0x2f, 0x9e, 0x53, 0xac, + 0x21, 0x30, 0xe3, 0xaa, 0x13, 0x96, 0xa9, 0x77, 0x99, 0x18, 0x19, 0xf1, 0x61, 0x3e, 0xf9, 0x9c, + 0xec, 0x2f, 0x2e, 0x62, 0x27, 0x49, 0x09, 0x3e, 0x89, 0xc1, 0xf7, 0x63, 0x36, 0x22, 0xca, 0xc6, + 0x25, 0x1f, 0x95, 0xd4, 0x0a, 0xd3, 0xb8, 0x13, 0x13, 0xc8, 0xad, 0x72, 0x2d, 0x9e, 0xdb, 0xe2, + 0x3c, 0xb6, 0x00, 0x87, 0x79, 0xaf, 0xd1, 0xb5, 0x06, 0xe4, 0xb7, 0x48, 0xa1, 0x26, 0xdf, 0x0b, + 0x67, 0xe4, 0x0e, 0x22, 0x8a, 0xc4, 0xbc, 0x5e, 0x3a, 0xe5, 0x4e, 0xdc, 0xdc, 0x09, 0xab, 0x4e, + 0x4c, 0xe9, 0xf4, 0x2a, 0x88, 0x0d, 0x93, 0x38, 0xac, 0xa2, 0xc6, 0xa7, 0x07, 0xd5, 0x78, 0x39, + 0x51, 0xe3, 0x59, 0x9c, 0x28, 0xc9, 0xca, 0x54, 0x9e, 0x64, 0x05, 0xa6, 0xc5, 0x3a, 0x12, 0xb3, + 0xed, 0x19, 0xec, 0x2d, 0x54, 0x62, 0xc9, 0x15, 0x98, 0x98, 0x70, 0x3a, 0x89, 0xba, 0x23, 0xf3, + 0xc7, 0xa4, 0x0b, 0xda, 0x8e, 0x1c, 0x7f, 0x43, 0xd2, 0x91, 0xd9, 0x8e, 0x14, 0x49, 0x31, 0xab, + 0x8f, 0xba, 0x9e, 0x50, 0x51, 0x3d, 0x1b, 0x25, 0xaf, 0x54, 0x84, 0x1f, 0x8b, 0x86, 0x18, 0xea, + 0x96, 0x90, 0xc6, 0x81, 0x6c, 0xc1, 0x7c, 0x78, 0x6a, 0x2b, 0x8c, 0x8b, 0x51, 0xf6, 0x84, 0xe8, + 0xa8, 0x4f, 0xe7, 0x9b, 0x46, 0x4f, 0x6c, 0x38, 0xa7, 0x9d, 0xd3, 0x0a, 0xeb, 0x8b, 0xc8, 0xfa, + 0x25, 0x76, 0x23, 0xd3, 0x0f, 0xf9, 0x74, 0xf6, 0xfd, 0xf8, 0x90, 0x8f, 0x60, 0x29, 0x7e, 0x36, + 0x2b, 0xb5, 0x3c, 0x87, 0xb5, 0xbc, 0x7c, 0x7c, 0x54, 0xbc, 0x94, 0x38, 0xde, 0xd3, 0x2b, 0x1a, + 0xc0, 0x8d, 0x7c, 0x1d, 0x16, 0xf5, 0xf3, 0x59, 0xa9, 0xc9, 0xc0, 0x9a, 0x70, 0xe9, 0x84, 0x07, + 0x7b, 0x7a, 0x0d, 0x7d, 0x79, 0x90, 0x00, 0x8a, 0xa9, 0xb3, 0x5b, 0xa9, 0xe6, 0xf9, 0xa8, 0x41, + 0x89, 0x55, 0x92, 0x5e, 0xdd, 0x49, 0x2c, 0xc9, 0x43, 0x78, 0x36, 0xed, 0x98, 0x50, 0x2a, 0x7d, + 0x21, 0x54, 0x02, 0xbf, 0x92, 0x7e, 0xe4, 0xa4, 0xd7, 0x7c, 0x02, 0x5b, 0xf2, 0x55, 0x38, 0xa3, + 0xac, 0x2f, 0xa5, 0xbe, 0x17, 0xb1, 0x3e, 0x74, 0xf0, 0x57, 0x17, 0x66, 0x7a, 0x2d, 0xe9, 0x3c, + 0x48, 0x1b, 0xe6, 0x65, 0xc3, 0x51, 0xdb, 0x2e, 0x8e, 0x9e, 0x4b, 0xda, 0xae, 0x9a, 0xc4, 0x58, + 0xb9, 0x28, 0x76, 0xd5, 0xc5, 0xe6, 0x8e, 0xd5, 0x8d, 0x08, 0xd5, 0x99, 0x9e, 0xc2, 0x97, 0xac, + 0xc1, 0x58, 0xbd, 0x56, 0xbd, 0x79, 0x73, 0x75, 0xf1, 0x25, 0xac, 0x41, 0xba, 0xf0, 0x71, 0xa0, + 0x76, 0x69, 0x12, 0xe6, 0x8a, 0x5d, 0x67, 0x77, 0x57, 0x7b, 0xb0, 0xe2, 0xa8, 0xe4, 0xfb, 0xd0, + 0x50, 0x90, 0xed, 0xa8, 0x25, 0xdf, 0x77, 0xf6, 0x3a, 0x3c, 0x2f, 0xc5, 0xcb, 0xda, 0x7b, 0xbf, + 0xcc, 0x54, 0x52, 0xc6, 0xbc, 0xb2, 0x09, 0x74, 0x2e, 0x6d, 0xb2, 0xfb, 0xbf, 0xd8, 0xb9, 0x2d, + 0x3b, 0x62, 0xa5, 0x6e, 0xe2, 0xc9, 0x8a, 0x58, 0xbf, 0xed, 0x39, 0x81, 0xb5, 0xdf, 0xd3, 0x9a, + 0xbf, 0xf8, 0x8a, 0x16, 0x17, 0x9c, 0x67, 0xdb, 0x55, 0x7a, 0xed, 0x05, 0x51, 0xe1, 0x33, 0xfc, + 0xb6, 0xdc, 0xa7, 0xe7, 0xe6, 0xf6, 0x62, 0x74, 0x3e, 0xf9, 0xa1, 0x0c, 0x9c, 0xdd, 0x76, 0xbd, + 0x83, 0x96, 0x6b, 0x37, 0x65, 0xab, 0xc4, 0x1e, 0xfe, 0xea, 0xa0, 0x3d, 0xfc, 0xf3, 0x89, 0x3d, + 0xdc, 0x78, 0x28, 0xd8, 0x58, 0x61, 0xa2, 0x97, 0xc4, 0x7e, 0xde, 0xa7, 0x2a, 0xf2, 0x7d, 0x70, + 0x31, 0xbd, 0x44, 0x99, 0x94, 0xaf, 0xe1, 0xa4, 0xbc, 0x7e, 0x7c, 0x54, 0x7c, 0xad, 0x5f, 0x4d, + 0xe9, 0x13, 0xf4, 0x44, 0xd6, 0xb7, 0x47, 0xf2, 0x97, 0x0b, 0x57, 0x6e, 0x8f, 0xe4, 0xaf, 0x14, + 0x5e, 0x36, 0x9f, 0xa9, 0x97, 0xee, 0xae, 0x57, 0x9b, 0xf2, 0x70, 0x95, 0xb9, 0x68, 0x38, 0x8d, + 0x79, 0x69, 0x50, 0x69, 0xc4, 0xd1, 0xf8, 0x2b, 0x19, 0x28, 0x9e, 0x30, 0x49, 0xd8, 0x79, 0x16, + 0x8d, 0x44, 0x3d, 0xcc, 0x7f, 0xc0, 0x7d, 0xfc, 0xc2, 0x02, 0x4b, 0x37, 0x1b, 0xd1, 0x49, 0xd0, + 0xff, 0x53, 0xa4, 0x51, 0x53, 0xdc, 0x80, 0x93, 0xe9, 0xd3, 0x24, 0x96, 0xb1, 0x0e, 0x85, 0xf8, + 0xe4, 0x21, 0x5f, 0x84, 0x69, 0x35, 0x89, 0x93, 0x54, 0x25, 0xf0, 0xe0, 0x37, 0xde, 0x9e, 0x76, + 0x20, 0x6a, 0x88, 0xc6, 0x2f, 0x65, 0x60, 0x3e, 0x65, 0x85, 0x91, 0x4b, 0x30, 0x82, 0x99, 0x5b, + 0x15, 0xab, 0xa1, 0x58, 0xc6, 0x56, 0x2c, 0x27, 0x9f, 0x83, 0xf1, 0xca, 0x46, 0xbd, 0x5e, 0xda, + 0x90, 0xca, 0x08, 0x7e, 0x10, 0x77, 0x7c, 0xcb, 0xb7, 0x75, 0x63, 0x03, 0x81, 0x46, 0x5e, 0x83, + 0xb1, 0x6a, 0x0d, 0x09, 0x94, 0x0c, 0x2f, 0x4e, 0x37, 0x8e, 0x2f, 0x90, 0x8c, 0x1f, 0xcf, 0x00, + 0x49, 0x6e, 0x17, 0xe4, 0x3a, 0x4c, 0xaa, 0x9b, 0x12, 0x6f, 0x2f, 0xbe, 0xc0, 0x2a, 0x0b, 0xc7, + 0x54, 0x71, 0x48, 0x05, 0x46, 0x31, 0x11, 0x62, 0x68, 0xe5, 0x90, 0xba, 0x2c, 0xce, 0x25, 0x96, + 0xc5, 0x28, 0x26, 0x57, 0x34, 0x39, 0xb1, 0xf1, 0x5b, 0x19, 0x20, 0xe9, 0xb6, 0x8b, 0x43, 0x59, + 0x59, 0xbd, 0xa1, 0x84, 0x91, 0x50, 0xf3, 0x28, 0x86, 0x89, 0x75, 0x55, 0x35, 0x40, 0x14, 0x70, + 0xe2, 0x92, 0xa6, 0x76, 0xea, 0xef, 0x7b, 0x7c, 0x05, 0x46, 0xef, 0x53, 0x6f, 0x47, 0x9a, 0x75, + 0xa3, 0x29, 0xe8, 0x03, 0x06, 0x50, 0xd5, 0x30, 0x88, 0x61, 0xfc, 0x61, 0x06, 0x16, 0xd2, 0xee, + 0x28, 0x27, 0xb8, 0x08, 0x1b, 0x31, 0xef, 0x66, 0xb4, 0xb0, 0xe2, 0x76, 0xa2, 0xa1, 0x4f, 0x73, + 0x11, 0x46, 0x59, 0x63, 0xe5, 0x08, 0xa3, 0x1a, 0x8c, 0xf5, 0x86, 0x6f, 0x72, 0x38, 0x43, 0x88, + 0x72, 0x6c, 0x8c, 0x72, 0x04, 0x9e, 0x5a, 0x83, 0xc3, 0x19, 0xc2, 0x5d, 0xb7, 0x49, 0xa5, 0x7a, + 0x08, 0x11, 0xda, 0x0c, 0x60, 0x72, 0x38, 0xb9, 0x04, 0xe3, 0xf7, 0x3a, 0xeb, 0xd4, 0x7e, 0x20, + 0x73, 0x79, 0xa1, 0x45, 0x98, 0xdb, 0xb1, 0x5a, 0x0c, 0x66, 0xca, 0x42, 0xe3, 0x67, 0x33, 0x30, + 0x97, 0xb8, 0x1e, 0x9d, 0xec, 0x05, 0x3d, 0xd8, 0xb3, 0x6f, 0x98, 0xf6, 0xf1, 0xcf, 0x1f, 0x49, + 0xff, 0x7c, 0xe3, 0x7f, 0x18, 0x83, 0x73, 0x7d, 0xb4, 0x55, 0x91, 0xe7, 0x71, 0xe6, 0x44, 0xcf, + 0xe3, 0xaf, 0xc1, 0x74, 0xb9, 0x65, 0x3b, 0x6d, 0x7f, 0xd3, 0x8d, 0xbe, 0x38, 0x72, 0x60, 0xc2, + 0x32, 0xe1, 0x07, 0x11, 0x7a, 0xba, 0x9c, 0x6f, 0x20, 0x85, 0x15, 0xb8, 0x49, 0x61, 0x59, 0x63, + 0x96, 0xf0, 0xfd, 0xcd, 0xfd, 0x19, 0xf1, 0xfd, 0xd5, 0xbd, 0xd1, 0x46, 0x1e, 0xab, 0x37, 0x5a, + 0xba, 0xcd, 0xf7, 0xe8, 0x27, 0xf1, 0x00, 0x28, 0xc3, 0x34, 0x37, 0x89, 0x2b, 0xf9, 0x7c, 0x90, + 0xc6, 0x12, 0x66, 0x74, 0xb6, 0x9f, 0x1c, 0x0b, 0x8d, 0x86, 0xac, 0xe9, 0x9e, 0x53, 0xe3, 0xf8, + 0x66, 0x7c, 0xa9, 0xbf, 0x67, 0x94, 0x1e, 0x7e, 0x47, 0xf5, 0x90, 0xfa, 0x16, 0x2c, 0xa4, 0x5d, + 0x77, 0x17, 0xf3, 0x9a, 0xb5, 0x6d, 0x5f, 0x2b, 0xed, 0xe1, 0x2f, 0xcd, 0x07, 0xa9, 0x97, 0x66, + 0xe9, 0xd1, 0x3e, 0xd1, 0xdf, 0x1d, 0x28, 0x5a, 0x0b, 0x1c, 0x77, 0xb0, 0xdf, 0xbb, 0xf1, 0xb5, + 0x58, 0x48, 0x82, 0x38, 0x39, 0x79, 0x4b, 0x8b, 0x1c, 0xf5, 0x52, 0x32, 0x72, 0x54, 0x7a, 0x14, + 0x02, 0x9e, 0x96, 0xe9, 0x67, 0xb3, 0xba, 0x1f, 0xf5, 0x9f, 0xc5, 0x85, 0x7a, 0x05, 0x46, 0xb7, + 0xf7, 0xa9, 0x27, 0x8f, 0x07, 0xfc, 0x90, 0x87, 0x0c, 0xa0, 0x7e, 0x08, 0x62, 0x90, 0x9b, 0x30, + 0x53, 0xe3, 0x13, 0x57, 0xce, 0xc6, 0x91, 0x48, 0xe7, 0xd2, 0x15, 0x9a, 0xc1, 0x94, 0xe9, 0x18, + 0xa3, 0x32, 0x6e, 0xc5, 0x3a, 0x5d, 0xc4, 0xbd, 0xe2, 0x9e, 0x51, 0x5c, 0x80, 0x98, 0x89, 0x3c, + 0xdc, 0xa2, 0xcd, 0xd6, 0x8c, 0x41, 0x8d, 0x5d, 0x78, 0x76, 0x20, 0x23, 0x76, 0x6e, 0x43, 0x37, + 0xfc, 0x15, 0xb3, 0xbc, 0x1e, 0x48, 0x6a, 0x2a, 0x74, 0xc6, 0xb7, 0x60, 0x4a, 0xed, 0x65, 0x3c, 0x82, 0xd8, 0x6f, 0x31, 0x2b, 0xf8, 0x11, 0xc4, 0x00, 0x26, 0x87, 0x47, 0x6f, 0x39, 0xd9, 0xf4, - 0xb7, 0x9c, 0x68, 0xf8, 0x73, 0xc7, 0x0d, 0x3f, 0xab, 0x1c, 0x77, 0x38, 0xa5, 0x72, 0xfc, 0xad, - 0x56, 0x8e, 0xd1, 0xa8, 0x4c, 0x0e, 0x7f, 0xa2, 0x95, 0xff, 0x0b, 0x99, 0xd6, 0x0f, 0x1d, 0xaf, - 0xe4, 0x72, 0xcf, 0x44, 0x19, 0x5c, 0xd3, 0x56, 0x6f, 0x84, 0x19, 0xc9, 0x14, 0xd9, 0xe3, 0x64, - 0x8a, 0x93, 0x4c, 0x44, 0x94, 0x7b, 0xf9, 0x90, 0x0e, 0x45, 0x72, 0xa0, 0x9d, 0xb0, 0x76, 0x91, - 0x58, 0xc6, 0xb7, 0x33, 0x70, 0x2a, 0x55, 0x67, 0xce, 0x6a, 0xe5, 0xca, 0x79, 0x65, 0x1d, 0xc6, - 0x35, 0xf3, 0x1c, 0xe3, 0x24, 0x51, 0x3d, 0x06, 0x6f, 0x8b, 0xf1, 0x3c, 0x8c, 0x85, 0x2f, 0xb6, - 0x64, 0x4e, 0x0e, 0x1d, 0x0f, 0x5b, 0x28, 0x1e, 0xfe, 0x6a, 0x00, 0xec, 0x0b, 0x9e, 0xa8, 0x69, - 0xb5, 0xf1, 0x2f, 0xb2, 0x30, 0xc2, 0xb8, 0x3e, 0xb5, 0x01, 0x96, 0xd3, 0xed, 0xa1, 0x59, 0x93, - 0x7a, 0x87, 0x55, 0x26, 0xcb, 0x30, 0xc2, 0x53, 0xd2, 0x89, 0xd7, 0xbf, 0x59, 0x95, 0x4c, 0xe6, - 0xaa, 0x0b, 0xc3, 0x51, 0xf8, 0x08, 0xd1, 0xb4, 0x04, 0x08, 0x51, 0xcc, 0xaa, 0x7f, 0x27, 0x03, - 0x13, 0x2a, 0x31, 0xf9, 0x00, 0xa6, 0x64, 0xd0, 0x58, 0x1e, 0xa2, 0x45, 0x3c, 0x2f, 0x4b, 0x53, - 0x30, 0x19, 0x34, 0x56, 0x0d, 0xe9, 0xa2, 0xe1, 0xab, 0x5b, 0x75, 0x47, 0x45, 0x26, 0x0d, 0x20, - 0xad, 0x1d, 0xdb, 0x7a, 0x44, 0xed, 0x7d, 0xea, 0x07, 0x16, 0x37, 0xd9, 0x11, 0xaf, 0xd0, 0x92, - 0xfd, 0xbd, 0x5b, 0x25, 0x6e, 0xad, 0xc3, 0x46, 0x42, 0x44, 0xff, 0x4d, 0xd0, 0xa8, 0x4f, 0x6b, - 0xad, 0x1d, 0x7b, 0x8b, 0x17, 0x72, 0x3a, 0xe3, 0x8f, 0x46, 0xf8, 0x74, 0x13, 0x51, 0xa6, 0xb7, - 0x61, 0xea, 0x7e, 0xb5, 0x52, 0x56, 0x14, 0xed, 0x7a, 0x92, 0xb2, 0xe5, 0xc7, 0x01, 0xf5, 0xda, - 0x76, 0x53, 0xde, 0x77, 0xa3, 0x23, 0xc8, 0x75, 0x1a, 0xf5, 0x74, 0x25, 0x7c, 0x8c, 0x23, 0xab, - 0x83, 0xdf, 0xac, 0xc3, 0x3a, 0xb2, 0x03, 0xd6, 0xe1, 0xdb, 0xad, 0x66, 0x8f, 0x3a, 0x74, 0x8e, - 0x64, 0x0f, 0xaf, 0xbe, 0x7b, 0xdd, 0x6d, 0xa5, 0x96, 0x5c, 0xff, 0x5a, 0x2e, 0x8a, 0x5a, 0xce, - 0x09, 0xb5, 0x4a, 0x6a, 0x3d, 0x09, 0xae, 0xd1, 0x3e, 0x31, 0x74, 0xec, 0x3e, 0xf1, 0x1f, 0x66, - 0x60, 0x84, 0x8b, 0xaf, 0x62, 0x1a, 0xf7, 0x10, 0x90, 0xb7, 0x9e, 0x8c, 0x80, 0x5c, 0xc0, 0x73, - 0x42, 0x9b, 0xd0, 0xbc, 0x8c, 0x54, 0x62, 0xeb, 0x42, 0x7a, 0x03, 0xe0, 0x93, 0x19, 0x2f, 0x39, - 0x7e, 0x59, 0x90, 0x6a, 0x14, 0x20, 0x64, 0xf4, 0x58, 0xaf, 0x70, 0x19, 0x54, 0x65, 0x54, 0x04, - 0x08, 0xd1, 0xc3, 0x82, 0xac, 0xc2, 0x98, 0x08, 0x3b, 0xb2, 0x74, 0x20, 0x1e, 0xc6, 0x0b, 0x9a, - 0x69, 0x53, 0x63, 0xe9, 0x20, 0x12, 0xcd, 0x45, 0xe0, 0x12, 0x6b, 0x5b, 0x75, 0x0b, 0x88, 0x18, - 0x90, 0xfb, 0x3c, 0xff, 0x38, 0x8f, 0xc2, 0xad, 0x27, 0xde, 0x08, 0xe1, 0x22, 0x0a, 0x9b, 0x8c, - 0x5d, 0x90, 0x12, 0x74, 0x3b, 0xe2, 0x41, 0x56, 0xa1, 0x80, 0xe6, 0x70, 0xb4, 0xc1, 0x57, 0x4d, - 0xb5, 0xc2, 0x43, 0x5b, 0x08, 0x93, 0xe6, 0x80, 0x97, 0x89, 0xe5, 0x16, 0xf3, 0xbf, 0x4c, 0x50, - 0x1a, 0x3f, 0x97, 0x85, 0x42, 0x7c, 0xf6, 0x91, 0xb7, 0x60, 0x3c, 0x8c, 0x82, 0x1e, 0x7a, 0x80, - 0xe3, 0x03, 0x59, 0x14, 0x36, 0x5d, 0xcf, 0x5a, 0xad, 0xa0, 0x93, 0x45, 0xc8, 0xb3, 0x45, 0xdc, - 0x8e, 0x82, 0x58, 0xe2, 0xb6, 0xdd, 0x15, 0x30, 0xd5, 0x23, 0x4b, 0xe2, 0x91, 0x1a, 0xcc, 0xb2, - 0x45, 0x53, 0x73, 0xda, 0xbb, 0x4d, 0xba, 0xea, 0xee, 0xba, 0xdd, 0x20, 0x4a, 0xe2, 0xcc, 0x2f, - 0x30, 0x76, 0xab, 0xa9, 0x15, 0xeb, 0x29, 0x9c, 0x53, 0xa8, 0xc9, 0x6b, 0xfc, 0x98, 0xa9, 0x56, - 0x84, 0x5d, 0x0b, 0x1e, 0xd5, 0x68, 0x8f, 0xa5, 0x7d, 0xbc, 0x40, 0x52, 0x76, 0xd6, 0xdf, 0xcf, - 0xc2, 0xb8, 0x32, 0xfd, 0xc8, 0x15, 0xc8, 0x57, 0xfd, 0x55, 0xb7, 0xbe, 0x1f, 0x46, 0xf5, 0x9c, - 0x3c, 0x3a, 0x2c, 0x8e, 0x39, 0xbe, 0xd5, 0x44, 0xa0, 0x19, 0x16, 0x93, 0x25, 0x98, 0xe4, 0x7f, - 0xc9, 0x74, 0x36, 0xd9, 0x48, 0xb7, 0xc6, 0x91, 0x65, 0x22, 0x1b, 0x75, 0xb3, 0xd5, 0x48, 0xc8, - 0x87, 0x00, 0x1c, 0x80, 0x21, 0x15, 0x72, 0x83, 0x07, 0x83, 0x10, 0x15, 0xa4, 0x04, 0x53, 0x50, - 0x18, 0x92, 0xaf, 0xf3, 0x20, 0xeb, 0x72, 0xb9, 0x0c, 0x0d, 0x1e, 0xcd, 0x82, 0xf1, 0xb7, 0xd2, - 0x83, 0xea, 0xa8, 0x2c, 0x45, 0x06, 0xaa, 0x05, 0x99, 0x6e, 0xb4, 0x14, 0x20, 0xa2, 0x82, 0x61, - 0xfc, 0x2f, 0x19, 0x65, 0x91, 0x91, 0x35, 0x18, 0x0b, 0x27, 0x90, 0x30, 0x29, 0x0b, 0xaf, 0x18, - 0x12, 0x6e, 0xd2, 0x9d, 0xa5, 0x73, 0xc2, 0xba, 0x6d, 0x36, 0x9c, 0x86, 0xda, 0x9a, 0x93, 0x40, - 0xf2, 0x1e, 0x0c, 0x61, 0xd7, 0x65, 0x8f, 0x6d, 0x9a, 0x3c, 0xe5, 0x87, 0x58, 0x9f, 0x61, 0x43, - 0x90, 0x92, 0x7c, 0x4e, 0x38, 0x6e, 0xf3, 0xce, 0x9f, 0x52, 0x8e, 0x6a, 0xf6, 0x1d, 0xe1, 0xf1, - 0x1e, 0xc5, 0x55, 0x52, 0x66, 0xcf, 0x5f, 0xcb, 0x42, 0x21, 0xbe, 0xb4, 0xc9, 0xbb, 0x30, 0x21, - 0x8f, 0xdf, 0x15, 0x5b, 0xe4, 0x62, 0x99, 0x10, 0xb9, 0x50, 0xe4, 0x19, 0xbc, 0x67, 0xab, 0x26, - 0x68, 0xa6, 0x46, 0xc0, 0x64, 0xa1, 0x0d, 0x11, 0x9c, 0x51, 0x59, 0x54, 0x81, 0x1b, 0x74, 0x62, - 0xb1, 0xbd, 0x25, 0x1a, 0x79, 0x1d, 0x72, 0xf7, 0x6e, 0x95, 0x84, 0x83, 0x5f, 0x21, 0x7e, 0x48, - 0x73, 0x4b, 0x59, 0xdd, 0x6e, 0x97, 0xe1, 0x93, 0x55, 0x25, 0x0c, 0xfe, 0x88, 0x66, 0x6e, 0x28, - 0xc1, 0x61, 0xe3, 0x8e, 0x8f, 0x87, 0x7f, 0x67, 0x28, 0x9f, 0x2b, 0x0c, 0x89, 0xd0, 0xc8, 0xff, - 0x43, 0x0e, 0xc6, 0xc2, 0xfa, 0x09, 0x51, 0xdd, 0xa6, 0xb9, 0x8b, 0x34, 0x39, 0x0b, 0x79, 0x29, - 0xdd, 0x09, 0x3f, 0xbf, 0x51, 0x5f, 0x48, 0x76, 0xf3, 0x20, 0xc5, 0x38, 0xbe, 0x2b, 0x98, 0xf2, - 0x27, 0xb9, 0x0e, 0xa1, 0x8c, 0xd6, 0x4b, 0x98, 0x1b, 0x62, 0x03, 0x66, 0x86, 0x68, 0x64, 0x0a, - 0xb2, 0x0e, 0x0f, 0x37, 0x37, 0x66, 0x66, 0x9d, 0x06, 0x79, 0x17, 0xf2, 0x76, 0xa3, 0x81, 0xb9, - 0x65, 0x07, 0x48, 0x4b, 0x9b, 0x67, 0xdc, 0xf8, 0x99, 0x81, 0x54, 0xa5, 0x80, 0x94, 0x60, 0x8c, - 0xc7, 0xef, 0xf6, 0x69, 0x63, 0x80, 0x03, 0x28, 0xe2, 0x80, 0x61, 0xbf, 0x37, 0x7d, 0xda, 0x20, - 0x2f, 0xc1, 0x10, 0x1b, 0x4d, 0x71, 0xe2, 0x48, 0xa1, 0x92, 0x0d, 0x26, 0xef, 0xb0, 0x95, 0x67, - 0x4c, 0x44, 0x20, 0x2f, 0x40, 0xae, 0xbb, 0xb8, 0x23, 0xce, 0x92, 0x42, 0x94, 0x92, 0x22, 0x44, - 0x63, 0xc5, 0xe4, 0x06, 0xe4, 0x1f, 0xe9, 0xd9, 0x0c, 0x4e, 0xc5, 0x86, 0x31, 0xc4, 0x0f, 0x11, - 0xc9, 0x4b, 0x90, 0xf3, 0x7d, 0x57, 0x18, 0x34, 0xcd, 0x86, 0x56, 0xa6, 0xf7, 0xc3, 0x51, 0x63, - 0xdc, 0x7d, 0xdf, 0x5d, 0xca, 0xc3, 0x08, 0x3f, 0x60, 0x8c, 0xe7, 0x00, 0xa2, 0x6f, 0x4c, 0xfa, - 0x6d, 0x1a, 0x1f, 0xc2, 0x58, 0xf8, 0x6d, 0xe4, 0x3c, 0xc0, 0x3e, 0x3d, 0xb0, 0xf6, 0xec, 0x76, - 0xa3, 0xc9, 0xa5, 0xd3, 0x09, 0x73, 0x6c, 0x9f, 0x1e, 0xac, 0x20, 0x80, 0x9c, 0x81, 0xd1, 0x0e, - 0x1b, 0x7e, 0x31, 0xc7, 0x27, 0xcc, 0x91, 0x4e, 0x77, 0x9b, 0x4d, 0xe5, 0x79, 0x18, 0x45, 0x3d, - 0xab, 0x58, 0x91, 0x93, 0xa6, 0xfc, 0x69, 0xfc, 0x71, 0x0e, 0x93, 0x7e, 0x29, 0x0d, 0x22, 0x17, - 0x61, 0xb2, 0xee, 0x51, 0x3c, 0xcb, 0x6c, 0x26, 0xa1, 0x89, 0x7a, 0x26, 0x22, 0x60, 0xb5, 0x41, - 0x2e, 0xc1, 0x74, 0x94, 0x9f, 0xd9, 0xaa, 0x6f, 0x8b, 0x2c, 0x25, 0x13, 0xe6, 0x64, 0x47, 0x66, - 0x69, 0x2e, 0x6f, 0x63, 0x3c, 0xc5, 0x82, 0x1a, 0x0e, 0x9c, 0xf5, 0x88, 0x98, 0x7f, 0xd3, 0x0a, - 0x1c, 0x6d, 0x33, 0x4f, 0xc3, 0x88, 0x6d, 0xef, 0x76, 0x1d, 0x1e, 0xf7, 0x6c, 0xc2, 0x14, 0xbf, - 0xc8, 0x2b, 0x30, 0x13, 0xc5, 0xd7, 0x97, 0xcd, 0x18, 0xc6, 0x66, 0x14, 0xc2, 0x82, 0x32, 0x87, - 0x93, 0xd7, 0x80, 0xa8, 0xf5, 0xb9, 0xdb, 0x1f, 0xd1, 0x3a, 0x9f, 0x93, 0x13, 0xe6, 0x8c, 0x52, - 0x72, 0x1f, 0x0b, 0xc8, 0xf3, 0x30, 0xe1, 0x51, 0x1f, 0xa5, 0x43, 0xec, 0x36, 0xcc, 0x89, 0x69, - 0x8e, 0x4b, 0x18, 0xeb, 0xbb, 0xcb, 0x50, 0x50, 0xba, 0x03, 0x23, 0xae, 0xf3, 0x04, 0x1d, 0xe6, - 0x54, 0x04, 0x37, 0x3b, 0xd5, 0x06, 0xf9, 0x32, 0x2c, 0x28, 0x98, 0x3c, 0x3d, 0xa7, 0x45, 0x9b, - 0xce, 0xae, 0xb3, 0xdd, 0xa4, 0x62, 0xbe, 0x25, 0x67, 0x75, 0x78, 0x85, 0x34, 0xe7, 0x23, 0x6a, - 0x9e, 0xb8, 0x73, 0x59, 0xd0, 0x92, 0x55, 0x98, 0x8b, 0x71, 0xa6, 0x0d, 0xab, 0xdb, 0xe9, 0x19, - 0x68, 0x30, 0xe2, 0x49, 0x74, 0x9e, 0xb4, 0xb1, 0xd9, 0x31, 0xbe, 0x09, 0x13, 0xea, 0x9c, 0x64, - 0x9d, 0xa0, 0xca, 0x25, 0x62, 0xf6, 0x8d, 0x87, 0xb0, 0x2a, 0xbb, 0x17, 0x4e, 0x45, 0x28, 0x38, - 0x88, 0x7c, 0x7b, 0x99, 0x0c, 0xa1, 0x38, 0x84, 0xcf, 0xc3, 0x44, 0xc3, 0xf1, 0x3b, 0x4d, 0xfb, - 0x00, 0x2d, 0xec, 0xc4, 0x48, 0x8f, 0x0b, 0x18, 0x2a, 0x7e, 0x96, 0x60, 0x26, 0xb1, 0x0f, 0x2a, - 0x92, 0x06, 0xdf, 0xd7, 0xfb, 0x4b, 0x1a, 0x46, 0x1b, 0x26, 0xd4, 0x73, 0xed, 0x98, 0x74, 0x3a, - 0xa7, 0x31, 0x0c, 0x0f, 0xdf, 0xf4, 0x47, 0x8e, 0x0e, 0x8b, 0x59, 0xa7, 0x81, 0xc1, 0x77, 0x2e, - 0x43, 0x5e, 0x4a, 0x6c, 0x42, 0x50, 0xc2, 0xc7, 0x04, 0xf9, 0x34, 0x69, 0x86, 0xa5, 0xc6, 0x4b, - 0x30, 0x2a, 0x8e, 0xae, 0xfe, 0x4f, 0x08, 0xc6, 0xb7, 0xb2, 0x30, 0x6d, 0x52, 0xb6, 0xb1, 0x52, - 0x9e, 0x43, 0xeb, 0xa9, 0xbd, 0xa2, 0xa7, 0xc7, 0xd5, 0xd5, 0xda, 0xd6, 0x27, 0x7b, 0xd5, 0xaf, - 0x64, 0x60, 0x36, 0x05, 0xf7, 0x63, 0x65, 0x6f, 0xbe, 0x09, 0x63, 0x15, 0xc7, 0x6e, 0x96, 0x1a, - 0x8d, 0x30, 0x26, 0x0f, 0xca, 0xf9, 0x98, 0xe2, 0xcd, 0x66, 0x50, 0x55, 0x88, 0x09, 0x51, 0xc9, - 0xcb, 0x62, 0x52, 0xe4, 0xc2, 0x6e, 0xc5, 0x49, 0xf1, 0xbd, 0xc3, 0x22, 0xf0, 0x6f, 0xda, 0x08, - 0xa7, 0x08, 0xc6, 0xba, 0xe6, 0xc0, 0xc8, 0xaf, 0xea, 0xa9, 0x1d, 0xba, 0xf4, 0x58, 0xd7, 0xf1, - 0xe6, 0x0d, 0x94, 0xc0, 0xea, 0xa7, 0xb2, 0x70, 0x3a, 0x9d, 0xf0, 0xe3, 0x26, 0xe2, 0xc6, 0xd4, - 0x61, 0x4a, 0x7c, 0x7e, 0x4c, 0xc4, 0xcd, 0xf3, 0x8c, 0x21, 0x7e, 0x84, 0x40, 0x76, 0x78, 0xc2, - 0xfb, 0x15, 0x6a, 0x7b, 0xc1, 0x36, 0xb5, 0x83, 0x01, 0x24, 0x79, 0x69, 0x4d, 0x31, 0x8f, 0xc2, - 0xc4, 0x9e, 0xa4, 0x4c, 0xcb, 0x77, 0x1f, 0xb2, 0x0d, 0x27, 0xca, 0xd0, 0x00, 0x13, 0xe5, 0x1b, - 0x30, 0x5d, 0xa3, 0x2d, 0xbb, 0xb3, 0xe7, 0x7a, 0x32, 0x5e, 0xc2, 0x55, 0x98, 0x0c, 0x41, 0xa9, - 0xb3, 0x45, 0x2f, 0xd6, 0xf0, 0x95, 0x8e, 0x88, 0xb6, 0x12, 0xbd, 0xd8, 0xf8, 0xeb, 0x59, 0x38, - 0x53, 0xaa, 0x0b, 0xd3, 0x50, 0x51, 0x20, 0x2d, 0xd8, 0x3f, 0xe5, 0xba, 0xc9, 0x35, 0x18, 0xbb, - 0x67, 0x3f, 0x5e, 0xa5, 0xb6, 0x4f, 0x7d, 0x91, 0xfc, 0x81, 0x8b, 0xbd, 0xf6, 0xe3, 0xe8, 0xf1, - 0xc7, 0x8c, 0x70, 0x54, 0x35, 0xc2, 0xd0, 0x27, 0x54, 0x23, 0x18, 0x30, 0xb2, 0xe2, 0x36, 0x1b, - 0xe2, 0xac, 0x17, 0x2f, 0xce, 0x7b, 0x08, 0x31, 0x45, 0x89, 0xf1, 0x87, 0x19, 0x98, 0x0a, 0xbf, - 0x18, 0x3f, 0xe1, 0x53, 0xef, 0x92, 0x4b, 0x30, 0x8a, 0x15, 0x55, 0x2b, 0xea, 0xa1, 0xd1, 0xa4, - 0x98, 0xcc, 0xb2, 0x61, 0xca, 0x42, 0xb5, 0x27, 0x86, 0x3f, 0x59, 0x4f, 0x18, 0x7f, 0x1f, 0x1f, - 0xb3, 0xd5, 0x56, 0xb2, 0x93, 0x48, 0xf9, 0x90, 0xcc, 0x80, 0x1f, 0x92, 0x7d, 0x62, 0x43, 0x92, - 0xeb, 0x39, 0x24, 0x3f, 0x96, 0x85, 0xf1, 0xf0, 0x63, 0x3f, 0x63, 0x49, 0x22, 0xc2, 0x76, 0x0d, - 0x14, 0xe3, 0xa8, 0xa6, 0xec, 0x15, 0x22, 0x94, 0xd0, 0x7b, 0x30, 0x22, 0x16, 0x53, 0x26, 0x66, - 0xc9, 0x1d, 0x1b, 0xdd, 0xa5, 0x29, 0xc1, 0x7a, 0x04, 0x07, 0xd4, 0x37, 0x05, 0x1d, 0x06, 0x91, - 0xda, 0xa2, 0xdb, 0xc2, 0xb6, 0xe1, 0xa9, 0x3d, 0xa3, 0xd2, 0x83, 0x48, 0x45, 0x0d, 0x1b, 0xe8, - 0x74, 0xfa, 0xef, 0xf3, 0x50, 0x88, 0x93, 0x1c, 0x9f, 0x86, 0x63, 0xbd, 0xbb, 0xcd, 0xaf, 0x2a, - 0x3c, 0x0d, 0x47, 0xa7, 0xbb, 0x6d, 0x32, 0x18, 0x9a, 0x3e, 0x79, 0xce, 0x43, 0x6c, 0xf5, 0x84, - 0x30, 0x7d, 0xf2, 0x9c, 0x87, 0x9a, 0xe9, 0x93, 0xe7, 0x3c, 0x44, 0x45, 0xc2, 0x6a, 0x0d, 0x03, - 0x2c, 0xe0, 0x3d, 0x45, 0x28, 0x12, 0x9a, 0x7e, 0x3c, 0xb7, 0xa0, 0x44, 0x63, 0x47, 0xe5, 0x12, - 0xb5, 0x3d, 0x91, 0x32, 0x42, 0x6c, 0x67, 0x78, 0x54, 0x6e, 0x23, 0xd8, 0x0a, 0x18, 0xdc, 0x54, - 0x91, 0x48, 0x13, 0x88, 0xf2, 0x53, 0x2e, 0xe0, 0xe3, 0xef, 0xd6, 0xd2, 0x0a, 0x73, 0x4e, 0x65, - 0x6d, 0xa9, 0xab, 0x39, 0x85, 0xef, 0x93, 0xd4, 0xfe, 0xae, 0x8b, 0x90, 0xb2, 0xa8, 0x40, 0xca, - 0x1f, 0xcb, 0x4c, 0x06, 0x86, 0x01, 0x1e, 0x72, 0x36, 0x54, 0x23, 0x45, 0x4c, 0xc8, 0x3b, 0x30, - 0xae, 0x86, 0xcd, 0xe0, 0xc1, 0x1d, 0x9e, 0xe5, 0xf1, 0x34, 0x7b, 0xe4, 0xa3, 0x56, 0x09, 0xc8, - 0x36, 0x9c, 0x29, 0xbb, 0x6d, 0xbf, 0xdb, 0x92, 0x91, 0x3b, 0xa3, 0x28, 0xe8, 0x80, 0x43, 0x81, - 0x3e, 0xf8, 0x75, 0x81, 0x22, 0xa2, 0x34, 0x48, 0x37, 0x19, 0xfd, 0x02, 0xd2, 0x8b, 0x11, 0xd9, - 0x80, 0x71, 0xd4, 0xa0, 0x0a, 0x93, 0xc7, 0x71, 0x7d, 0xdb, 0x88, 0x4a, 0x2a, 0x6c, 0x61, 0xf0, - 0xa8, 0x71, 0x76, 0xab, 0x29, 0xbd, 0x34, 0x54, 0x4d, 0xb0, 0x82, 0x4c, 0x3e, 0x84, 0x29, 0x7e, - 0x45, 0xdb, 0xa2, 0xdb, 0x7c, 0xee, 0x4c, 0x68, 0x9a, 0x08, 0xbd, 0x90, 0x3f, 0xe6, 0x0b, 0xbd, - 0xf5, 0x23, 0xba, 0xcd, 0xc7, 0x5e, 0xf3, 0x91, 0xd2, 0xf0, 0xc9, 0x26, 0xcc, 0xae, 0xd8, 0x3e, - 0x07, 0x2a, 0xf1, 0x0f, 0x26, 0x51, 0x43, 0x8b, 0xb6, 0xeb, 0x7b, 0xb6, 0x2f, 0x15, 0xe1, 0xa9, - 0xf1, 0x0e, 0xd2, 0xe8, 0xc9, 0xb7, 0x32, 0x30, 0xaf, 0xe9, 0xc9, 0x85, 0x9d, 0x19, 0x86, 0x83, - 0x9d, 0xc2, 0x27, 0xaf, 0xa2, 0x14, 0x4a, 0x7b, 0xa0, 0xf1, 0x21, 0x89, 0xa9, 0xe2, 0xbd, 0xa8, - 0x5c, 0x35, 0x0a, 0xef, 0xc5, 0x43, 0x2c, 0x54, 0x5c, 0xd3, 0xd3, 0xfa, 0x42, 0x8d, 0xad, 0x6b, - 0x89, 0x66, 0xdc, 0x8c, 0xf7, 0xb7, 0x50, 0x74, 0x65, 0x42, 0x45, 0xd7, 0x1c, 0x0c, 0x63, 0xaf, - 0xca, 0x28, 0x5a, 0xf8, 0xc3, 0xf8, 0x9c, 0xba, 0x0f, 0x09, 0xb1, 0xb0, 0xef, 0x3e, 0x64, 0xfc, - 0x8f, 0x23, 0x30, 0x1d, 0x9b, 0x16, 0xe2, 0x9e, 0x9a, 0x49, 0xdc, 0x53, 0x6b, 0x00, 0x5c, 0xd5, - 0x3b, 0xa0, 0x4e, 0x56, 0x3a, 0x62, 0x8e, 0x0b, 0x37, 0xea, 0x70, 0x4d, 0x29, 0x6c, 0x18, 0x53, - 0xbe, 0x62, 0x07, 0xd4, 0x91, 0x87, 0x4c, 0xf9, 0xa2, 0x57, 0x98, 0x46, 0x6c, 0x48, 0x11, 0x86, - 0x31, 0x7e, 0xae, 0xea, 0x07, 0xeb, 0x30, 0x80, 0xc9, 0xe1, 0xe4, 0x22, 0x8c, 0x30, 0x21, 0xaa, - 0x5a, 0x11, 0x9b, 0x20, 0x9e, 0x2d, 0x4c, 0xca, 0x62, 0x12, 0x8b, 0x28, 0x22, 0x37, 0x61, 0x82, - 0xff, 0x25, 0xc2, 0xec, 0x8c, 0xe8, 0xc6, 0x8f, 0x96, 0xd3, 0x90, 0x91, 0x76, 0x34, 0x3c, 0x76, - 0xbb, 0xa8, 0x75, 0x51, 0xad, 0x53, 0xad, 0x88, 0x30, 0xf2, 0x78, 0xbb, 0xf0, 0x39, 0x90, 0x55, - 0x11, 0x21, 0x30, 0x59, 0x46, 0x78, 0xa3, 0xe4, 0xf1, 0x4e, 0x89, 0xb2, 0x0c, 0xf7, 0x42, 0x31, - 0x45, 0x09, 0xb9, 0xc2, 0x5f, 0x62, 0x50, 0x2c, 0xe4, 0xb9, 0x54, 0xf1, 0xdd, 0x02, 0x15, 0x13, - 0x28, 0x1b, 0x86, 0xc5, 0xac, 0x72, 0xf6, 0xf7, 0x72, 0xcb, 0x76, 0x9a, 0x62, 0x5b, 0xc1, 0xca, - 0x11, 0x97, 0x32, 0xa8, 0x19, 0x21, 0x90, 0xb7, 0x60, 0x8a, 0xe7, 0x3c, 0x6c, 0xb5, 0xdc, 0x36, - 0xb2, 0x1f, 0x8f, 0x02, 0xe9, 0x89, 0x3c, 0x8c, 0xac, 0x88, 0xd7, 0x12, 0xc3, 0x65, 0xe7, 0x09, - 0xbe, 0xf2, 0x76, 0xf9, 0x1b, 0xd1, 0x44, 0x74, 0x9e, 0x20, 0xa9, 0xcf, 0xe1, 0xa6, 0x8a, 0x44, - 0xde, 0x80, 0x49, 0xf6, 0xf3, 0xb6, 0xf3, 0x90, 0xf2, 0x0a, 0x27, 0x23, 0xf3, 0x06, 0xa4, 0xda, - 0x65, 0x25, 0xbc, 0x3e, 0x1d, 0x93, 0xbc, 0x0f, 0xa7, 0x90, 0x53, 0xdd, 0xed, 0xd0, 0x46, 0x69, - 0x67, 0xc7, 0x69, 0x3a, 0xdc, 0x1a, 0x8d, 0x07, 0x94, 0x41, 0x1d, 0x3c, 0xaf, 0x18, 0x31, 0x2c, - 0x3b, 0x42, 0x31, 0xd3, 0x29, 0xc9, 0x16, 0x14, 0xca, 0x5d, 0x3f, 0x70, 0x5b, 0xa5, 0x20, 0xf0, - 0x9c, 0xed, 0x6e, 0x40, 0xfd, 0xf9, 0x69, 0x2d, 0xec, 0x0a, 0x5b, 0x1c, 0x61, 0x21, 0xd7, 0x07, - 0xd5, 0x91, 0xc2, 0xb2, 0x43, 0x12, 0x33, 0xc1, 0xc4, 0xf8, 0xb7, 0x19, 0x98, 0xd4, 0x48, 0xc9, - 0xeb, 0x30, 0x71, 0xcb, 0x73, 0x68, 0xbb, 0xd1, 0x3c, 0x50, 0x2e, 0xaa, 0x78, 0x8b, 0xd9, 0x11, - 0x70, 0xde, 0x6a, 0x0d, 0x2d, 0xd4, 0xf3, 0x64, 0x53, 0x4d, 0x45, 0xaf, 0x71, 0x77, 0x6c, 0x31, - 0x41, 0x73, 0x51, 0x1c, 0x28, 0x9c, 0xa0, 0x62, 0x76, 0x2a, 0x28, 0xe4, 0x6d, 0x18, 0xe1, 0xef, - 0xc1, 0xc2, 0x6e, 0xf1, 0x6c, 0x5a, 0x33, 0xb9, 0xeb, 0x3f, 0x4e, 0x44, 0x34, 0xfa, 0xf1, 0x4d, - 0x41, 0x64, 0xfc, 0x42, 0x06, 0x48, 0x12, 0xf5, 0x18, 0xbd, 0xd7, 0xb1, 0xc6, 0x44, 0xef, 0x85, - 0xab, 0x31, 0xa7, 0xe9, 0xcc, 0x59, 0x4d, 0xbc, 0x80, 0x77, 0xbc, 0x58, 0x75, 0xaa, 0x22, 0x8e, - 0x17, 0x1b, 0x3f, 0x9a, 0x05, 0x88, 0xb0, 0xc9, 0x17, 0x79, 0xc6, 0xb8, 0xf7, 0xbb, 0x76, 0xd3, - 0xd9, 0x71, 0xf4, 0xb8, 0xbd, 0xc8, 0xe4, 0x1b, 0xb2, 0xc4, 0xd4, 0x11, 0xc9, 0xbb, 0x30, 0x5d, - 0x5b, 0xd7, 0x69, 0x15, 0xb3, 0x78, 0xbf, 0x63, 0xc5, 0xc8, 0xe3, 0xd8, 0x68, 0x9f, 0xac, 0x8e, - 0x06, 0xb7, 0x4f, 0xe6, 0x03, 0x21, 0x4a, 0xd8, 0xc6, 0x52, 0x5b, 0x17, 0x96, 0xff, 0x8d, 0xf0, - 0x55, 0x13, 0xbf, 0xce, 0xef, 0x58, 0x1d, 0xe1, 0x12, 0xc0, 0xf6, 0x09, 0x0d, 0x2f, 0xea, 0xc8, - 0xe1, 0x1e, 0xee, 0xfd, 0xbf, 0x88, 0x6a, 0xbf, 0x96, 0x1b, 0x50, 0xa1, 0xed, 0x78, 0x6a, 0xef, - 0x3d, 0x91, 0x31, 0xc1, 0xb0, 0xe6, 0xb5, 0xac, 0xb5, 0x4e, 0x18, 0xcc, 0xdc, 0x88, 0x2e, 0x29, - 0xdc, 0xac, 0x20, 0xc5, 0xc6, 0xe6, 0xef, 0x66, 0xe0, 0x54, 0x2a, 0x2d, 0xb9, 0x0a, 0x10, 0xe9, - 0x94, 0x44, 0x2f, 0xe1, 0x8e, 0x19, 0x45, 0x3f, 0x32, 0x15, 0x0c, 0xf2, 0xd5, 0xb8, 0x36, 0xe8, - 0xf8, 0x83, 0x70, 0x41, 0x06, 0x1d, 0xd4, 0xb5, 0x41, 0x29, 0x3a, 0x20, 0xe3, 0x57, 0x72, 0x30, - 0xa3, 0x04, 0x57, 0xe2, 0xdf, 0x7a, 0x8c, 0xbd, 0xf8, 0x3e, 0x4c, 0xb0, 0xd6, 0x38, 0x75, 0xe1, - 0x76, 0xc3, 0x0d, 0x5f, 0x5e, 0x4e, 0xf8, 0x9d, 0x0a, 0x6e, 0x57, 0x55, 0x64, 0x1e, 0x0a, 0x14, - 0xb7, 0x4e, 0x7c, 0x90, 0xa8, 0x27, 0x5d, 0x6e, 0x34, 0xe6, 0xc4, 0x87, 0xc9, 0xca, 0x41, 0xdb, - 0x6e, 0x85, 0xb5, 0x71, 0x03, 0x98, 0x57, 0x7a, 0xd6, 0xa6, 0x61, 0xf3, 0xea, 0x22, 0x0f, 0x2d, - 0x5e, 0x96, 0x12, 0x1c, 0x40, 0xa3, 0x5a, 0x78, 0x17, 0x66, 0x12, 0x1f, 0x7d, 0xa2, 0xa8, 0xa4, - 0x5b, 0x40, 0x92, 0xdf, 0x91, 0xc2, 0xe1, 0x15, 0x3d, 0xe6, 0xed, 0xa9, 0xf0, 0xf1, 0xba, 0xd5, - 0xb2, 0xdb, 0x0d, 0x6e, 0x4e, 0xb3, 0xa8, 0xc6, 0x2c, 0xfd, 0xc5, 0xac, 0xea, 0xfb, 0xfb, 0xb4, - 0xaf, 0xba, 0xf7, 0xb4, 0xdb, 0xf0, 0x73, 0xbd, 0xc6, 0x74, 0x20, 0xad, 0xc3, 0x77, 0x73, 0x70, - 0xa6, 0x07, 0x25, 0x39, 0x88, 0x4f, 0x22, 0xae, 0x85, 0xb8, 0xde, 0xbf, 0xc2, 0x27, 0x31, 0x95, - 0xc8, 0x17, 0x79, 0xf4, 0x0f, 0x91, 0x5e, 0x9a, 0xdf, 0xbf, 0x51, 0x8d, 0xbf, 0x1f, 0x42, 0xe3, - 0x61, 0x3f, 0x38, 0x94, 0xbc, 0x0b, 0xc3, 0xe8, 0xf8, 0x1d, 0x0b, 0xef, 0xc8, 0x30, 0x10, 0xae, - 0x04, 0x28, 0x65, 0x3f, 0xb5, 0x00, 0xa5, 0x0c, 0x40, 0xbe, 0x00, 0xb9, 0xd2, 0x56, 0x4d, 0x8c, - 0xcb, 0x94, 0x4a, 0xbe, 0x55, 0x8b, 0x52, 0xc6, 0xd8, 0x5a, 0x6e, 0x17, 0x46, 0xc1, 0x08, 0x6f, - 0x97, 0xd7, 0xc5, 0xa8, 0xa8, 0x84, 0xb7, 0xcb, 0xeb, 0x11, 0xe1, 0x6e, 0x5d, 0x0b, 0x96, 0x75, - 0xbb, 0xbc, 0xfe, 0xe9, 0x4d, 0xfb, 0xff, 0x28, 0xcb, 0x43, 0x96, 0xf0, 0x86, 0xbd, 0x0b, 0x13, - 0x5a, 0x4c, 0xf2, 0x4c, 0x24, 0x8f, 0x85, 0xf1, 0xe3, 0x63, 0x16, 0x43, 0x1a, 0x81, 0x4c, 0xbe, - 0xc4, 0x7e, 0xa3, 0xc4, 0xab, 0x1a, 0xdb, 0x84, 0x1c, 0x50, 0x26, 0x8e, 0x27, 0x5f, 0x0a, 0x49, - 0xc8, 0x0d, 0xc8, 0x6f, 0xd0, 0xb6, 0xdd, 0x0e, 0x42, 0x85, 0x28, 0x1a, 0x17, 0x07, 0x08, 0xd3, - 0xa5, 0x86, 0x10, 0x11, 0x0d, 0x61, 0xbb, 0xdb, 0x7e, 0xdd, 0x73, 0x30, 0xb4, 0x51, 0x78, 0x16, - 0x73, 0x43, 0x58, 0xa5, 0x44, 0x67, 0x10, 0x23, 0x32, 0x7e, 0x31, 0x03, 0xa3, 0x62, 0x20, 0x79, - 0xd2, 0xbc, 0xdd, 0xe8, 0x2c, 0x11, 0xce, 0x03, 0xbb, 0x4e, 0xdc, 0x79, 0x60, 0x97, 0xc7, 0x0f, - 0x1a, 0x13, 0x8e, 0x75, 0xe1, 0xd3, 0x20, 0xce, 0x46, 0xe9, 0xf6, 0xa9, 0xe7, 0x44, 0x0b, 0x51, - 0x07, 0x75, 0xc8, 0x32, 0xfe, 0x86, 0xf8, 0xb2, 0xdb, 0xe5, 0x75, 0xb2, 0x08, 0xf9, 0x55, 0x97, - 0x87, 0xc2, 0x52, 0x33, 0x40, 0x37, 0x05, 0x4c, 0xed, 0x20, 0x89, 0xc7, 0xbe, 0x6f, 0xdd, 0x73, - 0xc5, 0x5d, 0x46, 0xf9, 0xbe, 0x0e, 0x07, 0xc6, 0xbe, 0x2f, 0x44, 0x1d, 0xf8, 0xfb, 0x68, 0xca, - 0x26, 0xf1, 0xe0, 0x06, 0x66, 0xa5, 0xb9, 0xa3, 0x3a, 0xba, 0x89, 0x22, 0xb9, 0x53, 0x2c, 0xf4, - 0xda, 0x29, 0x1e, 0xdc, 0x30, 0x53, 0xa8, 0xf0, 0x5d, 0x2d, 0x02, 0xd7, 0xa8, 0xf7, 0xf0, 0x29, - 0xde, 0xa5, 0xd3, 0xdf, 0xd5, 0xe2, 0xcd, 0x1b, 0x68, 0x93, 0xfe, 0x9d, 0x2c, 0x9c, 0x4e, 0x27, - 0x54, 0xdb, 0x92, 0xe9, 0xd3, 0x96, 0xcb, 0x90, 0x5f, 0x71, 0xfd, 0x40, 0x31, 0x12, 0x44, 0xf5, - 0xff, 0x9e, 0x80, 0x99, 0x61, 0x29, 0xbb, 0x73, 0xb3, 0xbf, 0xc3, 0xe5, 0x89, 0xfc, 0x30, 0x50, - 0x07, 0xbb, 0x73, 0xf3, 0x22, 0x72, 0x1b, 0xf2, 0xa6, 0x70, 0xb4, 0x8a, 0x75, 0x8d, 0x04, 0x87, - 0xd2, 0x14, 0xf1, 0x04, 0x44, 0x0b, 0x0d, 0x2f, 0x60, 0xa4, 0x04, 0xa3, 0x62, 0xf4, 0x63, 0x4f, - 0xc7, 0x29, 0x53, 0x46, 0xcf, 0xd6, 0x20, 0xe9, 0xd8, 0x8e, 0x82, 0x8f, 0x80, 0xd5, 0x8a, 0xf4, - 0x99, 0xc2, 0x1d, 0x85, 0x3f, 0x12, 0xea, 0xf6, 0x98, 0x21, 0xa2, 0xf1, 0xad, 0x2c, 0x80, 0xd4, - 0xda, 0x3c, 0xb5, 0x33, 0xec, 0x0b, 0xda, 0x0c, 0x53, 0xec, 0x8d, 0x06, 0xcf, 0x4c, 0x7d, 0x1f, - 0xcd, 0x79, 0x06, 0xcf, 0x4b, 0x5d, 0x84, 0xe1, 0x8d, 0x48, 0xa1, 0x25, 0x5c, 0x52, 0x50, 0x1d, - 0xcd, 0xe1, 0xc6, 0x36, 0xcc, 0xdd, 0xa6, 0x41, 0xa4, 0xde, 0x92, 0x4f, 0x8f, 0xfd, 0xd9, 0xbe, - 0x0a, 0x63, 0x02, 0x3f, 0xdc, 0xbf, 0xb8, 0x2e, 0x46, 0xc4, 0xbe, 0x41, 0x5d, 0x8c, 0x44, 0x60, - 0xbb, 0x51, 0x85, 0x36, 0x69, 0x40, 0x3f, 0xdd, 0x6a, 0x6a, 0x40, 0x78, 0x53, 0xb0, 0x65, 0x83, - 0xd5, 0x70, 0x6c, 0xff, 0x3c, 0x80, 0x53, 0xe1, 0xb7, 0x3f, 0x49, 0xbe, 0xd7, 0xd8, 0x95, 0x52, - 0x24, 0x3a, 0x88, 0x38, 0xf6, 0xb1, 0x3d, 0xf9, 0xbd, 0x0c, 0x2c, 0x48, 0x8a, 0x2d, 0x27, 0xb4, - 0x9c, 0x1c, 0x88, 0x98, 0xbc, 0x05, 0xe3, 0x0a, 0x8d, 0x88, 0xd4, 0x8f, 0x7a, 0xea, 0x47, 0x4e, - 0xb0, 0x67, 0xf9, 0x1c, 0xae, 0xea, 0xa9, 0x15, 0x74, 0xb2, 0x0d, 0x0b, 0xb5, 0xd2, 0xbd, 0xd5, - 0x28, 0x8d, 0xff, 0x9a, 0x7b, 0xcb, 0x6d, 0x36, 0xdd, 0x47, 0x9b, 0xe6, 0xaa, 0xcc, 0x9c, 0x83, - 0x01, 0x3e, 0x50, 0xe9, 0xfd, 0x30, 0x44, 0xb3, 0xda, 0xae, 0xb5, 0x83, 0x88, 0x56, 0xd7, 0x6b, - 0xfa, 0x66, 0x1f, 0x2e, 0xc6, 0x3f, 0xcf, 0xc0, 0xb9, 0xd0, 0x39, 0x29, 0xa5, 0x7d, 0xb1, 0x16, - 0x64, 0x9e, 0x64, 0x0b, 0xb2, 0x4f, 0xa4, 0x05, 0x6b, 0xd1, 0xf8, 0x54, 0xdb, 0xa1, 0x8f, 0xb7, - 0xfc, 0x7e, 0xa2, 0x8e, 0x8f, 0x18, 0x95, 0x67, 0x13, 0x5e, 0xe3, 0x8a, 0x73, 0xb8, 0xf1, 0xa6, - 0xd2, 0x21, 0x29, 0x0c, 0x35, 0xe2, 0x4c, 0x9c, 0xf8, 0x5b, 0x59, 0x98, 0xbe, 0x5f, 0xad, 0x94, - 0x43, 0x3b, 0xaa, 0xcf, 0x58, 0x06, 0x70, 0xad, 0x6d, 0xbd, 0x77, 0x4e, 0x63, 0x13, 0x66, 0x63, - 0xdd, 0x80, 0x42, 0xd0, 0x3b, 0xdc, 0x75, 0x26, 0x04, 0x4b, 0x01, 0xe8, 0x74, 0x1a, 0xfb, 0x07, - 0x37, 0xcc, 0x18, 0xb6, 0xf1, 0x5f, 0x43, 0x8c, 0xaf, 0xd8, 0x8c, 0x5f, 0x85, 0xb1, 0xaa, 0xef, - 0x77, 0xa9, 0xb7, 0x69, 0xae, 0xaa, 0x4a, 0x0f, 0x07, 0x81, 0x6c, 0x0e, 0x99, 0x11, 0x02, 0xb9, - 0x02, 0x79, 0x11, 0xee, 0x5d, 0xee, 0x6e, 0xa8, 0x7f, 0x0e, 0xa3, 0xc5, 0x9b, 0x61, 0x31, 0x79, - 0x1d, 0x26, 0xf8, 0xdf, 0x7c, 0x46, 0x8b, 0x0e, 0x47, 0x35, 0xa7, 0x40, 0xe7, 0x2b, 0xc0, 0xd4, - 0xd0, 0xc8, 0xcb, 0x90, 0x2b, 0x95, 0x4d, 0xa1, 0xd8, 0x12, 0x12, 0xb0, 0x67, 0x71, 0xed, 0xa3, - 0x76, 0x1d, 0x2a, 0x9b, 0x4c, 0x8e, 0x95, 0x61, 0x33, 0x84, 0x4e, 0x1e, 0x67, 0x80, 0xd4, 0x9b, - 0xc5, 0x8e, 0x65, 0x84, 0x91, 0x6b, 0x30, 0x5a, 0xe1, 0xc6, 0x7f, 0x42, 0x23, 0xcf, 0x33, 0x45, - 0x72, 0x90, 0x16, 0x26, 0x82, 0x83, 0xc8, 0x15, 0x99, 0x6b, 0x2e, 0x1f, 0x79, 0xe0, 0xf4, 0x48, - 0x28, 0xf7, 0x2a, 0x8c, 0x88, 0xa0, 0xe8, 0x63, 0x4a, 0x16, 0x9a, 0x78, 0x30, 0x74, 0x81, 0x93, - 0x74, 0xc5, 0x85, 0x27, 0xe9, 0x8a, 0xbb, 0x0d, 0x67, 0x6e, 0xa3, 0x1e, 0x4a, 0x0f, 0xed, 0xb5, - 0x69, 0x56, 0x85, 0x66, 0x1f, 0x1f, 0xb4, 0xb8, 0xaa, 0x2a, 0x1e, 0x1d, 0xcc, 0xea, 0x7a, 0x6a, - 0xe2, 0xe3, 0x5e, 0x8c, 0xc8, 0x97, 0x61, 0x2e, 0xad, 0x48, 0xe8, 0xff, 0x31, 0x88, 0x55, 0x7a, - 0x05, 0x6a, 0x10, 0xab, 0x34, 0x0e, 0x64, 0x15, 0x0a, 0x1c, 0x5e, 0x6a, 0xb4, 0x9c, 0x36, 0x7f, - 0xc3, 0xe0, 0xef, 0x03, 0xe8, 0x12, 0x23, 0xb8, 0xda, 0xac, 0x90, 0xbf, 0x65, 0x68, 0x4e, 0x54, - 0x31, 0x4a, 0xf2, 0x33, 0x19, 0x76, 0x2f, 0xe5, 0x21, 0xc4, 0x71, 0xfb, 0x9c, 0x12, 0xaf, 0xa1, - 0xa1, 0x57, 0x53, 0x2d, 0xf0, 0x9c, 0xf6, 0xae, 0x70, 0x90, 0xda, 0x10, 0x0e, 0x52, 0x6f, 0x7d, - 0x2c, 0x07, 0x29, 0xce, 0xca, 0x3f, 0x3a, 0x2c, 0x4e, 0x78, 0xa2, 0x4e, 0x5c, 0x45, 0xda, 0x17, - 0xb0, 0xae, 0x43, 0x2f, 0xe1, 0xcd, 0x36, 0x0f, 0x60, 0x4c, 0x1b, 0xbc, 0x91, 0xd3, 0xb8, 0xb1, - 0x63, 0xd7, 0xd9, 0x7c, 0x13, 0x0f, 0x11, 0x12, 0x0d, 0x4d, 0xe5, 0xc0, 0xae, 0xd0, 0xd2, 0x09, - 0x87, 0xfb, 0x15, 0x17, 0xa2, 0x2b, 0xb4, 0xf4, 0xd8, 0xb1, 0x70, 0x1a, 0xa9, 0x93, 0x47, 0x23, - 0x21, 0xd7, 0x60, 0xe4, 0x9e, 0xfd, 0xb8, 0xb4, 0x4b, 0x45, 0x66, 0xd4, 0x49, 0xb9, 0xfd, 0x21, - 0x70, 0x29, 0xff, 0xbb, 0xdc, 0x6b, 0xe3, 0x19, 0x53, 0xa0, 0x91, 0x1f, 0xcc, 0xc0, 0x69, 0xbe, - 0x8c, 0x65, 0x2b, 0x6b, 0x34, 0x08, 0x58, 0x3f, 0x88, 0x48, 0x88, 0x17, 0x22, 0xd3, 0xf3, 0x74, - 0x3c, 0x8c, 0x21, 0x60, 0x88, 0x9d, 0x21, 0xec, 0x38, 0x5f, 0x94, 0x6a, 0x21, 0xa5, 0x53, 0xe9, - 0xc9, 0x06, 0x8c, 0xdf, 0xbb, 0x55, 0x0a, 0xab, 0xe5, 0x71, 0xe6, 0x8b, 0x69, 0xbb, 0xa3, 0x82, - 0x96, 0xe6, 0x33, 0xa1, 0xb2, 0x11, 0x7e, 0x0e, 0x5f, 0x90, 0xfd, 0x41, 0x5e, 0x53, 0x9d, 0x6a, - 0x73, 0x78, 0x0f, 0x18, 0x6d, 0xd9, 0x8f, 0x2d, 0x7b, 0x97, 0x6a, 0xef, 0xfd, 0x42, 0x0f, 0xff, - 0xf3, 0x19, 0x38, 0xdb, 0xb3, 0xc9, 0xe4, 0x26, 0x9c, 0xb1, 0xb9, 0xab, 0xb8, 0xb5, 0x17, 0x04, - 0x1d, 0xdf, 0x92, 0x97, 0x25, 0xe1, 0x86, 0x6b, 0x9e, 0x12, 0xc5, 0x2b, 0xac, 0x54, 0xde, 0x9f, - 0x7c, 0xf2, 0x2e, 0x3c, 0xeb, 0xb4, 0x7d, 0x5a, 0xef, 0x7a, 0xd4, 0x92, 0x0c, 0xea, 0x4e, 0xc3, - 0xb3, 0x3c, 0xbb, 0xbd, 0x2b, 0x7d, 0x8a, 0xcd, 0xb3, 0x12, 0x47, 0xb8, 0xa3, 0x97, 0x9d, 0x86, - 0x67, 0x22, 0x82, 0xf1, 0x6f, 0x33, 0x30, 0xdf, 0xab, 0x4b, 0xc8, 0x3c, 0x8c, 0x52, 0x25, 0xe3, - 0x4c, 0xde, 0x94, 0x3f, 0xc9, 0x39, 0x88, 0x76, 0x7a, 0x71, 0xfa, 0xe7, 0xeb, 0x22, 0xfb, 0x07, - 0x1a, 0xe9, 0xab, 0xfb, 0xba, 0x30, 0xb5, 0x9e, 0xa8, 0xab, 0xbb, 0xfb, 0x79, 0x80, 0x68, 0x3b, - 0xe7, 0x2a, 0x16, 0x73, 0xcc, 0xae, 0x7b, 0x7c, 0xe5, 0x91, 0xd3, 0x30, 0xc2, 0xb7, 0x4b, 0xe1, - 0xc9, 0x21, 0x7e, 0xb1, 0x73, 0x5b, 0x74, 0x32, 0xee, 0xf3, 0xb9, 0xa5, 0x09, 0xad, 0xb3, 0x47, - 0x5a, 0x38, 0x38, 0xc6, 0xcf, 0x4e, 0x72, 0x11, 0xa2, 0xd4, 0x0d, 0xf6, 0xa4, 0xd0, 0xb1, 0x98, - 0xe6, 0xf9, 0xc6, 0xad, 0x42, 0x15, 0x0b, 0x73, 0xdd, 0xdf, 0x4d, 0xbe, 0x62, 0x65, 0x53, 0x5f, - 0xb1, 0x5e, 0x85, 0xb1, 0xf2, 0x1e, 0xad, 0xef, 0x87, 0xee, 0x44, 0x79, 0xf1, 0x4c, 0xc0, 0x80, - 0x3c, 0xb8, 0x7b, 0x84, 0x40, 0xae, 0x01, 0xa0, 0xc3, 0x2d, 0x97, 0xad, 0x95, 0x04, 0x2d, 0xe8, - 0x9f, 0x2b, 0x0c, 0x6d, 0x14, 0x14, 0x64, 0x5f, 0x33, 0x6f, 0xa9, 0x96, 0x39, 0x9c, 0xbd, 0xef, - 0xed, 0x08, 0xf4, 0x08, 0x81, 0x35, 0x4f, 0xd9, 0x57, 0xc4, 0x29, 0x58, 0x48, 0x6c, 0x3e, 0x2a, - 0x12, 0xb9, 0x0a, 0x63, 0xeb, 0xd2, 0x25, 0x02, 0x0f, 0xc1, 0x09, 0xa4, 0x80, 0xc8, 0x7d, 0x62, - 0x3e, 0x63, 0x46, 0x28, 0xe4, 0x0b, 0x30, 0x5a, 0xa6, 0x5e, 0xb0, 0xb1, 0xb1, 0x8a, 0xe6, 0x33, - 0x3c, 0x8f, 0x49, 0x1e, 0x73, 0x4e, 0x04, 0x41, 0xf3, 0x7b, 0x87, 0xc5, 0xc9, 0xc0, 0x69, 0xd1, - 0x30, 0x3e, 0xbb, 0x29, 0xb1, 0xc9, 0x12, 0x14, 0xf8, 0x03, 0x7f, 0x74, 0x8b, 0xc2, 0x93, 0x31, - 0xcf, 0xcf, 0x69, 0x61, 0x0d, 0xf0, 0x88, 0x6e, 0x87, 0x19, 0x37, 0x12, 0xf8, 0x64, 0x59, 0x26, - 0xaa, 0x51, 0x9b, 0x09, 0x91, 0x5a, 0x2f, 0xbe, 0x63, 0xb0, 0xd6, 0x26, 0x29, 0x48, 0x09, 0x26, - 0xcb, 0x6e, 0xab, 0x63, 0x07, 0x0e, 0x66, 0xf4, 0x3c, 0x10, 0x87, 0x20, 0xaa, 0x26, 0xeb, 0x6a, - 0x81, 0x76, 0xa2, 0xaa, 0x05, 0xe4, 0x16, 0x4c, 0x99, 0x6e, 0x97, 0x0d, 0x93, 0xd4, 0x27, 0xf0, - 0x73, 0x0e, 0x8d, 0x5c, 0x3c, 0x56, 0xc2, 0x8e, 0x65, 0xa1, 0x3c, 0xd0, 0x62, 0xd9, 0x6a, 0x54, - 0x64, 0x2d, 0xe5, 0x61, 0x47, 0x3d, 0xdc, 0xd4, 0xbc, 0x1b, 0x09, 0x66, 0x29, 0x6f, 0x42, 0x37, - 0x60, 0xbc, 0x56, 0xbb, 0xbf, 0x41, 0xfd, 0xe0, 0x56, 0xd3, 0x7d, 0x84, 0x67, 0x5b, 0x5e, 0xa4, - 0x89, 0xf3, 0x5d, 0x2b, 0xa0, 0x7e, 0x60, 0xed, 0x34, 0xdd, 0x47, 0xa6, 0x8a, 0x45, 0xbe, 0xc6, - 0xfa, 0x43, 0x91, 0x04, 0x45, 0xd4, 0xde, 0x7e, 0xc2, 0x2a, 0x9e, 0x20, 0xd1, 0xa2, 0x61, 0x22, - 0xab, 0xde, 0x59, 0x0a, 0x3a, 0x7a, 0xc7, 0x79, 0xee, 0xe3, 0x83, 0x52, 0xa3, 0xe1, 0x51, 0xdf, - 0x17, 0x87, 0x10, 0xf7, 0x8e, 0x43, 0xb5, 0x89, 0xcd, 0x0b, 0x34, 0xef, 0x38, 0x85, 0x80, 0xfc, - 0x78, 0x06, 0x4e, 0xa9, 0x7e, 0x33, 0xb8, 0x5c, 0xd0, 0x60, 0x87, 0x1f, 0x49, 0xaf, 0x5d, 0x95, - 0x87, 0xf0, 0x55, 0x05, 0xed, 0xea, 0xc3, 0xeb, 0x57, 0x4b, 0xd1, 0xcf, 0x9a, 0x24, 0xc2, 0x08, - 0x84, 0xc5, 0x54, 0x7e, 0x5a, 0x96, 0xa5, 0x39, 0x3b, 0x85, 0x98, 0x94, 0x99, 0xa4, 0xc6, 0x66, - 0x14, 0x9a, 0x80, 0x55, 0xd7, 0xf1, 0x4c, 0x13, 0xba, 0x61, 0x31, 0xff, 0xb8, 0xb1, 0x98, 0xd3, - 0xd1, 0x05, 0x32, 0x85, 0x86, 0x54, 0x61, 0x9a, 0x03, 0xd8, 0xb6, 0xc0, 0x13, 0x56, 0xcd, 0x46, - 0x29, 0x33, 0x04, 0x1b, 0xb4, 0x5a, 0xc0, 0xa4, 0x55, 0x6a, 0x98, 0xd9, 0x18, 0x1d, 0x79, 0x17, - 0xa6, 0x30, 0x1b, 0x40, 0xb4, 0x5e, 0xe7, 0x70, 0x15, 0x63, 0xb4, 0x5c, 0x51, 0x12, 0xf3, 0x21, - 0x9c, 0xf0, 0xfd, 0xbd, 0x68, 0x45, 0xbf, 0x0b, 0x53, 0x68, 0x75, 0x14, 0x31, 0x38, 0x15, 0x31, - 0x10, 0x25, 0x71, 0x06, 0x41, 0xd3, 0x8f, 0x18, 0xfc, 0x5c, 0x06, 0xce, 0xb2, 0x8a, 0xd2, 0x47, - 0xe8, 0xf4, 0xc7, 0x19, 0x21, 0x8c, 0x1f, 0xda, 0x93, 0xa7, 0x2a, 0x8e, 0xfa, 0xfe, 0x5e, 0x1a, - 0x07, 0xfc, 0x28, 0xf6, 0xf1, 0xe9, 0x1f, 0x75, 0xe6, 0x63, 0x7f, 0x54, 0x4f, 0x9e, 0xea, 0x47, - 0x05, 0x4d, 0x3f, 0x8d, 0x03, 0x5e, 0x6b, 0xd9, 0x15, 0x3c, 0xba, 0x9b, 0x7d, 0xb6, 0x1c, 0x70, - 0xb4, 0xb6, 0xf5, 0x71, 0xc0, 0xd9, 0xe4, 0xfe, 0xe0, 0x4a, 0x37, 0xc8, 0x6b, 0xad, 0x06, 0x8e, - 0x5f, 0x6b, 0x63, 0x34, 0x66, 0x0c, 0xdb, 0xf8, 0xd6, 0x78, 0x8c, 0xaf, 0x30, 0xba, 0x35, 0x60, - 0x84, 0xdf, 0x5a, 0x45, 0x27, 0xa3, 0xf5, 0x05, 0xbf, 0xd3, 0x9a, 0xa2, 0x84, 0x9c, 0x85, 0x5c, - 0xad, 0x76, 0x5f, 0x74, 0x32, 0x9a, 0xde, 0xfa, 0xbe, 0x6b, 0x32, 0x18, 0x1b, 0x21, 0xb4, 0xa7, - 0x55, 0xb2, 0x2b, 0xb0, 0xf3, 0xce, 0x44, 0x28, 0xeb, 0x6f, 0x79, 0x87, 0x1c, 0x8a, 0xfa, 0x5b, - 0xdc, 0x21, 0xa3, 0x9b, 0x63, 0x19, 0xe6, 0x4b, 0xbe, 0x4f, 0x3d, 0x36, 0x21, 0x84, 0x99, 0xa6, - 0x27, 0xee, 0x39, 0xe2, 0x60, 0xc7, 0x4a, 0xed, 0xba, 0x6f, 0xf6, 0x44, 0x24, 0x97, 0x21, 0x5f, - 0xea, 0x36, 0x1c, 0xda, 0xae, 0x6b, 0x01, 0xe6, 0x6c, 0x01, 0x33, 0xc3, 0x52, 0xf2, 0x3e, 0x9c, - 0x8a, 0xc5, 0x92, 0x14, 0x3d, 0x30, 0x1a, 0xed, 0xbd, 0xf2, 0x1e, 0x16, 0x99, 0x96, 0xf0, 0x2e, - 0x49, 0xa7, 0x24, 0x25, 0x28, 0x2c, 0xa3, 0xc3, 0x59, 0x85, 0xf2, 0x57, 0x2e, 0xd7, 0xe3, 0x9e, - 0x86, 0xfc, 0xd6, 0x2c, 0x22, 0x66, 0x36, 0xc2, 0x42, 0x33, 0x81, 0x4e, 0xee, 0xc2, 0x6c, 0x1c, - 0xc6, 0x4e, 0x70, 0x7e, 0x41, 0xc6, 0xfd, 0x26, 0xc1, 0x05, 0xcf, 0xf0, 0x34, 0x2a, 0xb2, 0x0d, - 0x33, 0x91, 0x69, 0x95, 0x7e, 0x6d, 0x96, 0x16, 0xdb, 0x61, 0xb9, 0xbc, 0x3a, 0x9f, 0x13, 0x93, - 0x71, 0x36, 0x32, 0xd3, 0x0a, 0xaf, 0xcf, 0x66, 0x92, 0x1d, 0x69, 0xc0, 0x54, 0xcd, 0xd9, 0x6d, - 0x3b, 0xed, 0xdd, 0xbb, 0xf4, 0x60, 0xdd, 0x76, 0x3c, 0x61, 0x3b, 0x2b, 0x2d, 0xe3, 0x4b, 0xfe, - 0x41, 0xab, 0x45, 0x03, 0x0f, 0x37, 0x42, 0x56, 0x8e, 0xde, 0xf4, 0xec, 0x3a, 0xb4, 0xe0, 0x73, - 0x3a, 0x74, 0x40, 0xed, 0xd8, 0x8e, 0x26, 0x04, 0xe8, 0x3c, 0x35, 0xd5, 0xc5, 0xc4, 0x80, 0xaa, - 0x8b, 0x26, 0xcc, 0x2c, 0xb7, 0xeb, 0xde, 0x01, 0x3e, 0x36, 0xca, 0x8f, 0x9b, 0x3c, 0xe6, 0xe3, - 0x5e, 0x10, 0x1f, 0xf7, 0xac, 0x2d, 0x67, 0x58, 0xda, 0xe7, 0x25, 0x19, 0x93, 0x1a, 0xcc, 0xe0, - 0xc5, 0xa1, 0x5a, 0x59, 0xaf, 0xb6, 0x9d, 0xc0, 0xb1, 0x03, 0xda, 0x10, 0xc2, 0x45, 0x98, 0x93, - 0x86, 0x5f, 0x51, 0x9d, 0x46, 0xc7, 0x72, 0x24, 0x8a, 0xca, 0x34, 0x41, 0xdf, 0xef, 0x9e, 0x38, - 0xfd, 0x67, 0x74, 0x4f, 0xac, 0xc2, 0x74, 0x3c, 0x28, 0x45, 0x21, 0x3a, 0x87, 0x7d, 0x2c, 0x62, - 0xc7, 0xb9, 0xdb, 0x45, 0x61, 0x52, 0x4b, 0x03, 0x1b, 0x0b, 0x47, 0x11, 0xbb, 0x72, 0xce, 0x68, - 0x57, 0x4e, 0x6d, 0x57, 0x3a, 0xc1, 0x95, 0x93, 0xac, 0x03, 0xdc, 0x72, 0xbd, 0x3a, 0x2d, 0xa1, - 0xa7, 0x37, 0xd1, 0x32, 0x77, 0x31, 0xa6, 0x51, 0x21, 0x5f, 0x3f, 0x3b, 0xec, 0xb7, 0x15, 0x77, - 0xd8, 0x57, 0x78, 0x10, 0x1b, 0xce, 0xac, 0x7b, 0x74, 0x87, 0x7a, 0x1e, 0x6d, 0x88, 0x7b, 0xd1, - 0x92, 0xd3, 0x6e, 0xc8, 0x74, 0x6c, 0x22, 0x76, 0x77, 0x47, 0xa2, 0x84, 0x96, 0xe6, 0xdb, 0x1c, - 0x49, 0x3d, 0xe6, 0x7a, 0xf0, 0x31, 0x7e, 0x22, 0x0b, 0xf3, 0xbd, 0x5a, 0xdc, 0xe7, 0x46, 0xf9, - 0x0a, 0x24, 0x37, 0x11, 0x71, 0xb3, 0x2c, 0xd0, 0xf8, 0x56, 0xb2, 0x08, 0xe9, 0x7b, 0x85, 0xb8, - 0x69, 0xce, 0xc6, 0x09, 0x36, 0xbd, 0x26, 0xb9, 0x09, 0xe3, 0x4a, 0xff, 0xe0, 0x76, 0xdd, 0xab, - 0x37, 0x4d, 0xd8, 0x89, 0xba, 0xec, 0x34, 0x88, 0xd3, 0x42, 0xde, 0x44, 0xf9, 0x2f, 0x52, 0xe0, - 0xfe, 0xf4, 0x23, 0xdc, 0x64, 0xc2, 0xf7, 0x5d, 0x42, 0x00, 0x8f, 0x06, 0xbe, 0xcb, 0x9a, 0xf8, - 0xb7, 0xf1, 0xab, 0x93, 0xfc, 0xd0, 0x57, 0x2f, 0xa2, 0xbd, 0x8c, 0xa9, 0x63, 0x17, 0xd4, 0xec, - 0x49, 0x2e, 0xa8, 0xb9, 0xe3, 0x2f, 0xa8, 0x43, 0xc7, 0x5d, 0x50, 0x63, 0x37, 0xc8, 0xe1, 0x13, - 0xdf, 0x20, 0x47, 0x4e, 0x74, 0x83, 0x1c, 0x3d, 0xd1, 0x0d, 0x52, 0xbb, 0x0c, 0xe7, 0x8f, 0xbb, - 0x0c, 0xff, 0xc5, 0x7d, 0xf3, 0x69, 0xbd, 0x6f, 0xa6, 0x49, 0x91, 0x27, 0xba, 0x6f, 0xfe, 0x58, - 0xcf, 0xeb, 0x62, 0xe1, 0xe3, 0xc8, 0xfd, 0x17, 0x07, 0xb8, 0x2e, 0x0e, 0x7a, 0x59, 0x9c, 0x79, - 0x32, 0x97, 0x45, 0xf2, 0xc4, 0x2e, 0x8b, 0xb3, 0x9f, 0xf4, 0xb2, 0x38, 0xf7, 0x24, 0x2f, 0x8b, - 0xa7, 0xfe, 0x3c, 0x5e, 0x16, 0x4f, 0xff, 0x7b, 0xb9, 0x2c, 0xa2, 0xa1, 0x89, 0xeb, 0x07, 0xb7, - 0x5c, 0xaf, 0x85, 0xf7, 0xd5, 0x09, 0x61, 0x68, 0xe2, 0xfa, 0x3c, 0x97, 0xb3, 0x26, 0x16, 0x0a, - 0x44, 0xb2, 0x24, 0x27, 0x9c, 0xbc, 0x03, 0xce, 0x47, 0x0a, 0x7f, 0x31, 0x53, 0xc4, 0x55, 0x30, - 0x39, 0xdf, 0x04, 0x89, 0xf1, 0x97, 0xa0, 0x10, 0x17, 0x9c, 0x8f, 0x8f, 0x4d, 0xfd, 0xc4, 0x02, - 0x83, 0x32, 0xb1, 0x3e, 0x2e, 0xb8, 0x92, 0x6b, 0x00, 0xeb, 0x9e, 0xf3, 0xd0, 0x0e, 0xe8, 0x5d, - 0x69, 0xa3, 0x28, 0xe2, 0xaa, 0x73, 0x28, 0x9b, 0x72, 0xa6, 0x82, 0x12, 0xde, 0xd9, 0xb2, 0x69, - 0x77, 0x36, 0xe3, 0xc7, 0xb3, 0x30, 0xc3, 0xa3, 0xeb, 0x3d, 0xfd, 0x0f, 0xcc, 0xef, 0x68, 0x37, - 0xf1, 0x67, 0xa3, 0x4c, 0x0e, 0x6a, 0xeb, 0xfa, 0x3c, 0x31, 0x7f, 0x08, 0xa7, 0x12, 0x5d, 0x81, - 0xb7, 0xf1, 0x8a, 0x8c, 0x6b, 0x98, 0xb8, 0x8f, 0xcf, 0xa7, 0x57, 0xf2, 0xe0, 0x86, 0x99, 0xa0, - 0x30, 0xfe, 0x78, 0x28, 0xc1, 0x5f, 0x3c, 0x36, 0xab, 0xcf, 0xc7, 0x99, 0x93, 0x3d, 0x1f, 0x67, - 0x07, 0x7b, 0x3e, 0x8e, 0x49, 0x33, 0xb9, 0x41, 0xa4, 0x99, 0xf7, 0x61, 0x72, 0x83, 0xda, 0x2d, - 0x7f, 0xc3, 0x15, 0x69, 0xc1, 0xb8, 0x47, 0x8c, 0x0c, 0x5b, 0xc8, 0xca, 0xe4, 0x65, 0x32, 0xb4, - 0xec, 0x0d, 0x18, 0x01, 0x3b, 0x7f, 0x79, 0x9e, 0x30, 0x53, 0xe7, 0xa0, 0x6a, 0x08, 0x86, 0xfb, - 0x68, 0x08, 0x6a, 0x30, 0x21, 0xe8, 0xa2, 0x80, 0xdc, 0xd1, 0x55, 0x96, 0x15, 0x21, 0x5c, 0xd6, - 0x2e, 0x5d, 0x53, 0xa7, 0xc2, 0xda, 0xf9, 0x2d, 0x56, 0x63, 0xc2, 0xba, 0x60, 0xb9, 0xdd, 0xe8, - 0xb8, 0x4e, 0x1b, 0xbb, 0x60, 0x34, 0xea, 0x02, 0x2a, 0xc0, 0xbc, 0x0b, 0x14, 0x24, 0xf2, 0x16, - 0x4c, 0x95, 0xd6, 0xab, 0x2a, 0x59, 0x3e, 0x7a, 0xc1, 0xb6, 0x3b, 0x8e, 0xa5, 0x91, 0xc6, 0x70, - 0xfb, 0xdd, 0xea, 0xc6, 0xfe, 0x6c, 0x6e, 0x75, 0xc6, 0xbf, 0x9e, 0x94, 0xcb, 0xfb, 0xd3, 0x7d, - 0xfc, 0xd1, 0x9f, 0x73, 0x72, 0x27, 0x7c, 0xce, 0x19, 0x3a, 0x4e, 0x82, 0xd5, 0x04, 0xeb, 0xe1, - 0x13, 0x09, 0xd6, 0x23, 0x9f, 0xf8, 0x69, 0x66, 0xf4, 0x84, 0xa2, 0x72, 0x6c, 0xad, 0xe5, 0x07, - 0x59, 0x6b, 0xa9, 0xe2, 0xf5, 0xd8, 0x27, 0x17, 0xaf, 0xe1, 0xc4, 0xe2, 0x75, 0x2d, 0xf2, 0x30, - 0x1f, 0x3f, 0xd6, 0x71, 0xe7, 0xbc, 0xd0, 0x78, 0xcc, 0xa4, 0xc7, 0x4a, 0x0c, 0x7d, 0xcd, 0x3f, - 0x53, 0x32, 0xfb, 0xd7, 0xd3, 0x65, 0xf6, 0xfe, 0xe7, 0xcd, 0x89, 0xa4, 0xf6, 0x1f, 0x7f, 0xb2, - 0x52, 0xfb, 0x93, 0x7d, 0xe4, 0xf9, 0x0b, 0xb9, 0xfd, 0x2f, 0xe4, 0xf6, 0x01, 0xe5, 0xf6, 0xfb, - 0x40, 0xec, 0x6e, 0xb0, 0x47, 0xdb, 0x81, 0x53, 0xc7, 0xd8, 0xc1, 0x6c, 0x88, 0x51, 0x82, 0x17, - 0xeb, 0x35, 0x59, 0xaa, 0xae, 0x57, 0xad, 0x14, 0xbd, 0xf1, 0x3d, 0x5c, 0xaf, 0x5b, 0xb6, 0xd7, - 0x46, 0x05, 0xda, 0x35, 0x18, 0x95, 0xd1, 0x67, 0x33, 0x91, 0xfa, 0x3d, 0x19, 0x76, 0x56, 0x62, - 0x91, 0x45, 0xc8, 0x4b, 0x62, 0x35, 0x1d, 0xd2, 0x23, 0x01, 0xd3, 0x02, 0x7b, 0x0a, 0x98, 0xf1, - 0x9f, 0x0c, 0xc9, 0x33, 0x81, 0x7d, 0xc2, 0xba, 0xed, 0xd9, 0x2d, 0xcc, 0x94, 0x18, 0x2e, 0x59, - 0xe5, 0x36, 0x10, 0x5b, 0xe5, 0x31, 0x8f, 0x0e, 0x9d, 0xe4, 0x63, 0x85, 0x0f, 0x8e, 0x92, 0x51, - 0xe7, 0x06, 0x48, 0x46, 0xfd, 0x86, 0x96, 0xc9, 0x79, 0x28, 0x4a, 0x1d, 0xca, 0xf6, 0xc9, 0xfe, - 0x39, 0x9c, 0x6f, 0xaa, 0x29, 0x97, 0x87, 0xa3, 0x60, 0x6e, 0x48, 0xd9, 0x27, 0xd9, 0x72, 0x78, - 0xbd, 0x19, 0x39, 0x49, 0x60, 0xee, 0xd1, 0x7f, 0xaf, 0x81, 0xb9, 0x97, 0x01, 0xc4, 0xd9, 0x1d, - 0xd9, 0x72, 0xbc, 0x88, 0xdb, 0x89, 0xb0, 0x4e, 0x0f, 0x82, 0x66, 0x8f, 0xcc, 0x2d, 0x0a, 0xa1, - 0xf1, 0xaf, 0x08, 0xcc, 0xd4, 0x6a, 0xf7, 0x2b, 0x8e, 0xbd, 0xdb, 0x76, 0xfd, 0xc0, 0xa9, 0x57, - 0xdb, 0x3b, 0x2e, 0x93, 0xed, 0xc3, 0xf3, 0x45, 0x09, 0xa9, 0x1c, 0x9d, 0x2d, 0x61, 0x31, 0xbb, - 0x3b, 0x2e, 0x7b, 0x9e, 0xd4, 0xf4, 0xf2, 0xbb, 0x23, 0x65, 0x00, 0x93, 0xc3, 0x99, 0xf8, 0x5c, - 0xeb, 0x62, 0x40, 0x13, 0x61, 0x60, 0x83, 0xe2, 0xb3, 0xcf, 0x41, 0xa6, 0x2c, 0x23, 0x34, 0x39, - 0x61, 0xc5, 0x75, 0xea, 0x8c, 0x16, 0xde, 0x3b, 0x2a, 0xe6, 0xab, 0x51, 0x48, 0x37, 0xb8, 0x0f, - 0x77, 0x10, 0xae, 0x9a, 0x0f, 0x26, 0xd6, 0xc0, 0x01, 0x9c, 0xd2, 0x5c, 0xdd, 0x07, 0x7d, 0x79, - 0x7a, 0x59, 0x88, 0xeb, 0x06, 0x9a, 0x68, 0xa7, 0x3c, 0x3f, 0xa9, 0xa9, 0x0f, 0x53, 0x6b, 0x60, - 0x07, 0xe4, 0xf9, 0xd4, 0x92, 0x70, 0x75, 0x8f, 0x6b, 0x21, 0xd6, 0x95, 0x4d, 0x83, 0x27, 0x79, - 0xec, 0x55, 0xb5, 0x95, 0xb2, 0x15, 0xf4, 0xaf, 0x89, 0xfc, 0xd3, 0x0c, 0x9c, 0xd1, 0x30, 0xc2, - 0xfd, 0xcf, 0x0f, 0xa3, 0xc0, 0xa4, 0xce, 0xeb, 0x8f, 0x9e, 0xcc, 0xbc, 0xbe, 0xa8, 0xb7, 0x25, - 0xda, 0xa1, 0xd5, 0x36, 0xf4, 0xfa, 0x42, 0xf2, 0x10, 0x66, 0xb0, 0x48, 0xbe, 0x82, 0xb1, 0x39, - 0x2b, 0x1e, 0xcf, 0xe6, 0xa2, 0xcf, 0xe6, 0xe1, 0x1b, 0x30, 0x51, 0xff, 0xe2, 0x77, 0x0f, 0x8b, - 0x93, 0x1a, 0xba, 0x0c, 0x5a, 0x6e, 0x45, 0x4f, 0x69, 0x4e, 0x7b, 0xc7, 0x55, 0x77, 0xf2, 0x44, - 0x15, 0xe4, 0x9f, 0x67, 0xf8, 0xc3, 0x08, 0x6f, 0xc6, 0x2d, 0xcf, 0x6d, 0x85, 0xe5, 0xd2, 0x0e, - 0xb5, 0x47, 0xb7, 0x35, 0x9f, 0x4c, 0xb7, 0xbd, 0x88, 0x9f, 0xcc, 0xf7, 0x04, 0x6b, 0xc7, 0x73, - 0x5b, 0xd1, 0xe7, 0xab, 0x1d, 0xd7, 0xf3, 0x23, 0xc9, 0x0f, 0x65, 0xe0, 0xac, 0xa6, 0x9f, 0x55, - 0x33, 0xc8, 0x88, 0x20, 0x19, 0xb3, 0x61, 0xf8, 0x9c, 0xa8, 0x68, 0xe9, 0xaa, 0x98, 0xff, 0x97, - 0xf0, 0x0b, 0x94, 0x68, 0xad, 0x0c, 0xc9, 0x6a, 0x71, 0x2c, 0xe5, 0x13, 0x7a, 0xd7, 0x42, 0x1c, - 0x98, 0x41, 0x93, 0x24, 0xcd, 0x5e, 0x7a, 0xae, 0xb7, 0xbd, 0x74, 0x98, 0x1b, 0x0a, 0xf3, 0x46, - 0xf4, 0x36, 0x9a, 0x4e, 0x72, 0x25, 0x3f, 0x00, 0x67, 0x13, 0xc0, 0x70, 0xb5, 0x9d, 0xea, 0xb9, - 0xda, 0x5e, 0x39, 0x3a, 0x2c, 0xbe, 0x94, 0x56, 0x5b, 0xda, 0x4a, 0xeb, 0x5d, 0x03, 0xb1, 0x01, - 0xa2, 0x42, 0x21, 0xcf, 0xa4, 0x4f, 0xd0, 0x57, 0xc4, 0xfc, 0x50, 0xf0, 0xd9, 0x5e, 0xae, 0x7c, - 0x83, 0x7a, 0xe4, 0x45, 0x48, 0x84, 0xc2, 0x84, 0x92, 0x33, 0xe3, 0x40, 0x58, 0xc6, 0xf4, 0xa8, - 0xe4, 0xbb, 0x87, 0x45, 0x0d, 0x9b, 0xdd, 0xb0, 0xd4, 0x64, 0x1c, 0x9a, 0xf8, 0xa8, 0x22, 0x92, - 0x5f, 0xcf, 0xc0, 0x1c, 0x03, 0x44, 0x93, 0x4a, 0x34, 0x6a, 0xbe, 0xdf, 0xac, 0xdf, 0x7b, 0x32, - 0xb3, 0xfe, 0x79, 0xfc, 0x46, 0x75, 0xd6, 0x27, 0xba, 0x24, 0xf5, 0xe3, 0x70, 0xb6, 0x6b, 0xd6, - 0x6f, 0xda, 0x6c, 0x3f, 0x3b, 0xc0, 0x6c, 0xe7, 0x03, 0x70, 0xfc, 0x6c, 0xef, 0x59, 0x0b, 0xd9, - 0x80, 0x09, 0x71, 0xb9, 0xe2, 0x1d, 0xf6, 0x9c, 0x16, 0xbd, 0x5b, 0x2d, 0xe2, 0x37, 0x5e, 0x91, - 0x52, 0x24, 0xd1, 0x42, 0x8d, 0x0b, 0x69, 0xc3, 0x2c, 0xff, 0xad, 0x2b, 0xbb, 0x8a, 0x3d, 0x95, - 0x5d, 0x97, 0x45, 0x8b, 0x2e, 0x08, 0xfe, 0x31, 0x9d, 0x97, 0x1a, 0x75, 0x2b, 0x85, 0x31, 0xe9, - 0x00, 0xd1, 0xc0, 0x7c, 0xd1, 0x5e, 0xe8, 0xaf, 0xe2, 0x7a, 0x49, 0xd4, 0x59, 0x8c, 0xd7, 0x19, - 0x5f, 0xb9, 0x29, 0xbc, 0x89, 0x0d, 0xd3, 0x02, 0xea, 0xee, 0x53, 0xbe, 0xc3, 0x3f, 0xaf, 0xc5, - 0x3d, 0x8b, 0x95, 0xf2, 0x5b, 0x99, 0xac, 0x09, 0xe3, 0xd2, 0xc5, 0x36, 0xf4, 0x38, 0x3f, 0x72, - 0x1f, 0x66, 0x4a, 0x9d, 0x4e, 0xd3, 0xa1, 0x0d, 0x6c, 0xa5, 0xd9, 0x65, 0x6d, 0x32, 0xa2, 0xac, - 0x7c, 0x36, 0x2f, 0x14, 0x57, 0x45, 0xaf, 0x1b, 0xdb, 0x6e, 0x12, 0xb4, 0xc6, 0x8f, 0x65, 0x12, - 0x1f, 0x4d, 0x5e, 0x85, 0x31, 0xfc, 0xa1, 0x84, 0xd2, 0x41, 0x9d, 0x11, 0xff, 0x44, 0xd4, 0x46, - 0x45, 0x08, 0x4c, 0x58, 0x52, 0xc3, 0x69, 0xe6, 0xb8, 0xb0, 0x24, 0x14, 0x15, 0x91, 0x6a, 0xa2, - 0x28, 0xfd, 0x58, 0x72, 0x91, 0xd0, 0x85, 0x7e, 0x2c, 0xc2, 0x7b, 0xc5, 0xf8, 0x07, 0x59, 0x7d, - 0xda, 0x91, 0xcb, 0x8a, 0xdc, 0xae, 0x04, 0xf4, 0x94, 0x72, 0xbb, 0x22, 0xad, 0xff, 0xdd, 0x0c, - 0xcc, 0xde, 0x57, 0xd2, 0xb9, 0x6e, 0xb8, 0x38, 0x2e, 0xfd, 0x13, 0x9c, 0x3e, 0xa9, 0x44, 0x8d, - 0x6a, 0x1e, 0x59, 0x36, 0x53, 0x70, 0xca, 0x98, 0x69, 0xdf, 0x83, 0x3e, 0x8e, 0xf8, 0x61, 0x4a, - 0xbe, 0x4c, 0x8e, 0xce, 0xe1, 0x27, 0x4c, 0x30, 0x62, 0xfc, 0x54, 0x16, 0xc6, 0x95, 0x15, 0x43, - 0x3e, 0x0f, 0x13, 0x6a, 0xb5, 0xaa, 0xc2, 0x51, 0xfd, 0x4a, 0x53, 0xc3, 0x42, 0x8d, 0x23, 0xb5, - 0x5b, 0x9a, 0xc6, 0x91, 0xad, 0x0b, 0x84, 0x9e, 0xf0, 0x26, 0xf4, 0x6e, 0xca, 0x4d, 0x08, 0x67, - 0xb9, 0xa2, 0x31, 0xea, 0x7b, 0x1f, 0x7a, 0x2b, 0x79, 0x1f, 0x42, 0xe5, 0x95, 0x42, 0xdf, 0xfb, - 0x56, 0x64, 0xfc, 0x6c, 0x06, 0x0a, 0xf1, 0x35, 0xfd, 0xa9, 0xf4, 0xca, 0x09, 0x5e, 0x97, 0x7e, - 0x32, 0x1b, 0xe6, 0xd7, 0x91, 0x8e, 0xde, 0x4f, 0xab, 0x09, 0xe6, 0xdb, 0xda, 0xc3, 0xcf, 0x39, - 0x3d, 0x66, 0xa1, 0x1a, 0x22, 0x25, 0x3d, 0x50, 0xe9, 0xd0, 0xb7, 0xff, 0x66, 0xf1, 0x19, 0xe3, - 0x03, 0x98, 0x8b, 0x77, 0x07, 0x3e, 0xfe, 0x94, 0x60, 0x5a, 0x87, 0xc7, 0xb3, 0x73, 0xc5, 0xa9, - 0xcc, 0x38, 0xbe, 0xf1, 0xbb, 0xd9, 0x38, 0x6f, 0x61, 0x8e, 0xc9, 0xf6, 0x28, 0xd5, 0x02, 0x48, - 0xec, 0x51, 0x1c, 0x64, 0xca, 0xb2, 0x93, 0x64, 0xc5, 0x0b, 0xdd, 0x95, 0x73, 0xe9, 0xee, 0xca, - 0xe4, 0x66, 0xcc, 0x02, 0x5d, 0x89, 0xad, 0xf5, 0x88, 0x6e, 0x5b, 0x91, 0x15, 0x7a, 0xcc, 0xf0, - 0xbc, 0x0c, 0x73, 0x5a, 0xa0, 0x78, 0x49, 0x3f, 0x1c, 0xe9, 0xfa, 0x03, 0x2c, 0xe0, 0xc4, 0xa9, - 0xc8, 0x64, 0x05, 0x46, 0xd9, 0x67, 0xde, 0xb3, 0x3b, 0xe2, 0x4d, 0x87, 0x84, 0xc1, 0x0b, 0x9a, - 0xe1, 0xfd, 0x50, 0x89, 0x5f, 0xd0, 0xa4, 0x4c, 0x42, 0x50, 0x27, 0x96, 0x40, 0x34, 0xfe, 0xaf, - 0x0c, 0x5b, 0xff, 0xf5, 0xfd, 0xcf, 0x58, 0x6a, 0x3d, 0xd6, 0xa4, 0x3e, 0xd6, 0xc2, 0x7f, 0x90, - 0xe5, 0x19, 0x93, 0xc4, 0xf4, 0x79, 0x03, 0x46, 0x36, 0x6c, 0x6f, 0x57, 0x24, 0x36, 0xd7, 0xb9, - 0xf0, 0x82, 0x28, 0xf2, 0x57, 0x80, 0xbf, 0x4d, 0x41, 0xa0, 0xaa, 0xce, 0xb2, 0x03, 0xa9, 0xce, - 0x94, 0x77, 0x81, 0xdc, 0x13, 0x7b, 0x17, 0xf8, 0xbe, 0x30, 0x39, 0x52, 0x29, 0x18, 0x20, 0x0e, - 0xf9, 0x85, 0x78, 0x2e, 0xb2, 0x44, 0xc4, 0xf8, 0x88, 0x1d, 0xb9, 0xa9, 0x66, 0x37, 0x53, 0xfc, - 0x66, 0x8f, 0xc9, 0x63, 0x66, 0xfc, 0x41, 0x8e, 0xf7, 0xb1, 0xe8, 0xa8, 0x4b, 0x5a, 0x74, 0x00, - 0x5c, 0x27, 0x31, 0x3d, 0x25, 0x8f, 0x13, 0x70, 0x09, 0x86, 0xd8, 0xdc, 0x14, 0xbd, 0x89, 0x78, - 0x6c, 0xfe, 0xaa, 0x78, 0xac, 0x9c, 0xad, 0x65, 0x3c, 0x93, 0xd4, 0xb4, 0x95, 0x78, 0x6c, 0xa9, - 0x6b, 0x19, 0x31, 0xc8, 0x65, 0x18, 0x5a, 0x73, 0x1b, 0x32, 0xde, 0xfd, 0x1c, 0xc6, 0x88, 0xd1, - 0xf2, 0xe2, 0xce, 0x67, 0x4c, 0xc4, 0x60, 0x6d, 0x0d, 0xb3, 0x84, 0xa8, 0x6d, 0x6d, 0xed, 0xd8, - 0xc9, 0x74, 0x84, 0x4a, 0x6a, 0xa2, 0x65, 0x98, 0xda, 0x72, 0xda, 0x0d, 0xf7, 0x91, 0x5f, 0xa1, - 0xfe, 0x7e, 0xe0, 0x76, 0x84, 0x2d, 0x35, 0x6a, 0xf7, 0x1f, 0xf1, 0x12, 0xab, 0xc1, 0x8b, 0xd4, - 0x67, 0x19, 0x9d, 0x88, 0x2c, 0xc1, 0xa4, 0x16, 0x67, 0x57, 0x3c, 0xae, 0xa2, 0x36, 0x54, 0x8f, - 0xd2, 0xab, 0x6a, 0x43, 0x35, 0x12, 0x76, 0x9e, 0x8b, 0xef, 0x57, 0x9e, 0x58, 0x13, 0xdf, 0x2e, - 0x70, 0xc8, 0x0d, 0xc8, 0xf3, 0x60, 0x2c, 0xd5, 0x8a, 0xfa, 0x4c, 0xe6, 0x23, 0x2c, 0x16, 0xcc, - 0x48, 0x22, 0x2a, 0xc1, 0x37, 0x3e, 0x07, 0x05, 0xb1, 0x25, 0x45, 0x19, 0xf5, 0x9f, 0x85, 0xa1, - 0x72, 0xb5, 0x62, 0xaa, 0xdb, 0x48, 0xdd, 0x69, 0x78, 0x26, 0x42, 0xd1, 0x63, 0x71, 0x8d, 0x06, - 0x8f, 0x5c, 0x6f, 0xdf, 0xa4, 0x7e, 0xe0, 0x39, 0x3c, 0xeb, 0x29, 0x2e, 0xc4, 0xcf, 0x93, 0xb7, - 0x60, 0x18, 0x8d, 0x7a, 0x63, 0x27, 0x43, 0xbc, 0x8e, 0xa5, 0x49, 0x31, 0x81, 0x87, 0xd1, 0x42, - 0xd8, 0xe4, 0x44, 0xe4, 0x0d, 0x18, 0xaa, 0xd0, 0xf6, 0x41, 0x2c, 0x21, 0x63, 0x82, 0x38, 0xdc, - 0x10, 0x1a, 0xb4, 0x7d, 0x60, 0x22, 0x89, 0xf1, 0xb3, 0x59, 0x38, 0x95, 0xf2, 0x59, 0x0f, 0x3e, - 0xff, 0x94, 0xee, 0x8a, 0x4b, 0xda, 0xae, 0x28, 0xdf, 0xc7, 0x7b, 0x76, 0x7c, 0xea, 0x26, 0xf9, - 0x4b, 0x19, 0x38, 0xa3, 0x4f, 0x50, 0x61, 0xc5, 0xff, 0xe0, 0x06, 0x79, 0x13, 0x46, 0x56, 0xa8, - 0xdd, 0xa0, 0x32, 0xfb, 0xda, 0xa9, 0x30, 0x6c, 0x22, 0x8f, 0xcf, 0xc0, 0x0b, 0x39, 0xdb, 0xc8, - 0x9b, 0x97, 0x43, 0x49, 0x45, 0x7c, 0x1c, 0x17, 0xdf, 0x0d, 0x19, 0xf5, 0x25, 0xad, 0xaa, 0x3e, - 0x56, 0x26, 0xdf, 0xcd, 0xc0, 0xb9, 0x3e, 0x34, 0x6c, 0xe0, 0xd8, 0xd0, 0xab, 0x03, 0x87, 0x27, - 0x2a, 0x42, 0xc9, 0x3b, 0x30, 0xbd, 0x21, 0xc4, 0x7f, 0x39, 0x1c, 0xd9, 0x68, 0xbd, 0xc8, 0x9b, - 0x81, 0xb4, 0x6c, 0x32, 0xe3, 0xc8, 0x5a, 0x38, 0xa2, 0x5c, 0xdf, 0x70, 0x44, 0x6a, 0x74, 0x9f, - 0xa1, 0x41, 0xa3, 0xfb, 0x7c, 0x00, 0x73, 0x7a, 0xdb, 0x44, 0x90, 0xe5, 0x28, 0xb6, 0x51, 0xa6, - 0x77, 0x6c, 0xa3, 0xbe, 0xa1, 0x5c, 0x8d, 0x9f, 0xca, 0x40, 0x41, 0xe7, 0xfd, 0x49, 0xc7, 0xf3, - 0x6d, 0x6d, 0x3c, 0xcf, 0xa5, 0x8f, 0x67, 0xef, 0x81, 0xfc, 0x3f, 0x32, 0xf1, 0xc6, 0x0e, 0x34, - 0x82, 0x06, 0x8c, 0x54, 0xdc, 0x96, 0xed, 0xc8, 0x81, 0x43, 0x17, 0x9c, 0x06, 0x42, 0x4c, 0x51, - 0x32, 0x58, 0x28, 0xa8, 0x0b, 0x30, 0xbc, 0xe6, 0xb6, 0x4b, 0x15, 0x61, 0xcb, 0x8c, 0x7c, 0xda, - 0x6e, 0xdb, 0xb2, 0x1b, 0x26, 0x2f, 0x20, 0xab, 0x00, 0xb5, 0xba, 0x47, 0x69, 0xbb, 0xe6, 0x7c, - 0x3f, 0x8d, 0x49, 0x1a, 0xac, 0x87, 0x9a, 0x5d, 0xdc, 0x58, 0xf8, 0xd3, 0x29, 0x22, 0x5a, 0xbe, - 0xf3, 0xfd, 0xea, 0x7e, 0xab, 0xd0, 0xe3, 0xba, 0x12, 0xd1, 0xf2, 0x62, 0xe3, 0x70, 0xfd, 0xd3, - 0x58, 0x57, 0xa9, 0x55, 0x61, 0x0f, 0x5f, 0x4f, 0x1d, 0x8e, 0xdf, 0xc9, 0xc0, 0xb9, 0x3e, 0x34, - 0x4f, 0x60, 0x54, 0xfe, 0xac, 0x3b, 0x9c, 0x02, 0x44, 0x44, 0x98, 0xef, 0xda, 0x69, 0x04, 0x3c, - 0xa3, 0xe2, 0xa4, 0xc8, 0x77, 0xcd, 0x00, 0x5a, 0xbe, 0x6b, 0x06, 0x60, 0x67, 0xe9, 0x0a, 0x75, - 0x76, 0xf7, 0xb8, 0x79, 0xd8, 0x24, 0xdf, 0x1b, 0xf6, 0x10, 0xa2, 0x9e, 0xa5, 0x1c, 0xc7, 0xf8, - 0xd3, 0x61, 0x38, 0x6b, 0xd2, 0x5d, 0x87, 0xdd, 0x4b, 0x36, 0x7d, 0xa7, 0xbd, 0xab, 0x45, 0x47, - 0x32, 0x62, 0x2b, 0x57, 0xa4, 0x12, 0x61, 0x90, 0x70, 0x26, 0x5e, 0x81, 0x3c, 0x13, 0x43, 0x94, - 0xc5, 0x8b, 0x6f, 0x5c, 0x4c, 0x58, 0x11, 0xe1, 0xb7, 0x65, 0x31, 0x79, 0x59, 0x88, 0x49, 0x4a, - 0xb2, 0x27, 0x26, 0x26, 0x7d, 0xef, 0xb0, 0x08, 0xb5, 0x03, 0x3f, 0xa0, 0x78, 0x45, 0x16, 0xa2, - 0x52, 0x78, 0x97, 0x19, 0xea, 0x71, 0x97, 0xb9, 0x07, 0x73, 0xa5, 0x06, 0x3f, 0x1d, 0xed, 0xe6, - 0xba, 0xe7, 0xb4, 0xeb, 0x4e, 0xc7, 0x6e, 0xca, 0xfb, 0x39, 0xf6, 0xb2, 0x1d, 0x96, 0x5b, 0x9d, - 0x10, 0xc1, 0x4c, 0x25, 0x63, 0xcd, 0xa8, 0xac, 0xd5, 0x30, 0xf4, 0x8e, 0x78, 0xbe, 0xc4, 0x66, - 0x34, 0xda, 0x3e, 0xb6, 0xc2, 0x37, 0xc3, 0x62, 0xbc, 0x45, 0xa1, 0x41, 0xc0, 0xc6, 0x6a, 0x2d, - 0x72, 0x17, 0xe7, 0xb9, 0x28, 0xb8, 0x61, 0x41, 0xd0, 0xf4, 0xd1, 0x14, 0x53, 0xc3, 0x8b, 0xe8, - 0x6a, 0xb5, 0x15, 0x46, 0x97, 0x4f, 0xd0, 0xf9, 0xfe, 0x9e, 0x4a, 0xc7, 0xf1, 0xc8, 0x35, 0x36, - 0x15, 0x5a, 0x6e, 0x40, 0x71, 0x0a, 0x8f, 0x45, 0x77, 0x2e, 0x0f, 0xa1, 0xfc, 0xce, 0xa5, 0xa0, - 0x90, 0xb7, 0x60, 0x76, 0xb9, 0xbc, 0x28, 0x95, 0xce, 0x15, 0xb7, 0xde, 0x45, 0x43, 0x00, 0xc0, - 0xfa, 0x70, 0x0c, 0x69, 0x7d, 0x91, 0xed, 0x26, 0x69, 0x68, 0xe4, 0x12, 0x8c, 0x56, 0x2b, 0xbc, - 0xef, 0xc7, 0xd5, 0x84, 0x6b, 0xc2, 0x32, 0x4b, 0x16, 0x92, 0xfb, 0xd1, 0xa5, 0x60, 0xe2, 0x58, - 0xe9, 0xfd, 0xec, 0x00, 0x17, 0x82, 0x37, 0x60, 0x72, 0xc9, 0x0d, 0xaa, 0x6d, 0x3f, 0xb0, 0xdb, - 0x75, 0x5a, 0xad, 0xa8, 0xd1, 0xcf, 0xb7, 0xdd, 0xc0, 0x72, 0x44, 0x09, 0xfb, 0x72, 0x1d, 0x93, - 0x7c, 0x11, 0x49, 0x6f, 0xd3, 0x36, 0xf5, 0xa2, 0xa8, 0xe7, 0xc3, 0xbc, 0x6f, 0x19, 0xe9, 0x6e, - 0x58, 0x62, 0xea, 0x88, 0x22, 0x19, 0x1c, 0x4f, 0xe1, 0x5a, 0x76, 0x1b, 0xd4, 0xe7, 0xbb, 0xc5, - 0x67, 0x28, 0x19, 0x9c, 0xd2, 0xb6, 0x3e, 0x3b, 0xe8, 0x7f, 0x8c, 0xc9, 0xe0, 0x12, 0xb8, 0xe4, - 0x8b, 0x30, 0x8c, 0x3f, 0x85, 0x74, 0x3b, 0x9b, 0xc2, 0x36, 0x92, 0x6c, 0xeb, 0x0c, 0xd3, 0xe4, - 0x04, 0xa4, 0x0a, 0xa3, 0xe2, 0x62, 0x75, 0x92, 0x94, 0x46, 0xe2, 0x86, 0xc6, 0x67, 0x86, 0xa0, - 0x37, 0x1a, 0x30, 0xa1, 0x56, 0xc8, 0x56, 0xc4, 0x8a, 0xed, 0xef, 0xd1, 0x06, 0xfb, 0x25, 0xb2, - 0x11, 0xe2, 0x8a, 0xd8, 0x43, 0xa8, 0xc5, 0xbe, 0xc3, 0x54, 0x50, 0xd8, 0x99, 0x5a, 0xf5, 0x37, - 0x7d, 0xf1, 0x29, 0x42, 0xd5, 0xe2, 0xa0, 0xda, 0xae, 0x61, 0x8a, 0x22, 0xe3, 0xfb, 0x60, 0x6e, - 0xad, 0xdb, 0x6c, 0xda, 0xdb, 0x4d, 0x2a, 0xb3, 0xd5, 0x60, 0x5a, 0xf8, 0x25, 0x18, 0xae, 0x29, - 0x89, 0xe6, 0xc3, 0x8c, 0xa1, 0x0a, 0x0e, 0x1a, 0xc1, 0x66, 0x30, 0x0c, 0x52, 0x2c, 0xc5, 0x3c, - 0x27, 0x35, 0x7e, 0x3b, 0x03, 0x73, 0xd2, 0x5c, 0xc0, 0xb3, 0xeb, 0xfb, 0xd4, 0x13, 0xc2, 0xd1, - 0x25, 0x6d, 0xae, 0xe1, 0x84, 0x8d, 0x4d, 0x23, 0x3e, 0xeb, 0xee, 0xc8, 0x8f, 0xd0, 0x05, 0x96, - 0xb4, 0x0f, 0x3e, 0xee, 0x63, 0xc8, 0x5b, 0x30, 0x2e, 0x8e, 0x47, 0x25, 0x0c, 0x29, 0x46, 0x61, - 0x13, 0xd7, 0xbd, 0xb8, 0xf1, 0x8a, 0x8a, 0x8e, 0xb2, 0x98, 0xde, 0x94, 0x4f, 0x2a, 0x03, 0xa4, - 0xcb, 0x62, 0x7a, 0x1d, 0x7d, 0xa6, 0xee, 0x77, 0xc6, 0xe3, 0x7d, 0x2b, 0xe6, 0xee, 0x4d, 0x35, - 0xf0, 0x60, 0x26, 0xba, 0x19, 0x47, 0x81, 0x07, 0xd5, 0x9b, 0x71, 0x88, 0x1a, 0x8e, 0x49, 0xf6, - 0x98, 0x31, 0x79, 0x47, 0x8e, 0x49, 0xae, 0xf7, 0xc4, 0x98, 0xed, 0x33, 0x0e, 0xb5, 0x68, 0x85, - 0x0c, 0x0d, 0xa4, 0x56, 0x79, 0x06, 0x33, 0x2c, 0x70, 0x92, 0xf8, 0x2e, 0x2a, 0x38, 0xa9, 0xba, - 0x9a, 0xe1, 0xc1, 0x99, 0x1e, 0xb3, 0x35, 0x7f, 0x09, 0x26, 0x4a, 0x41, 0x60, 0xd7, 0xf7, 0x68, - 0xa3, 0xc2, 0xb6, 0x27, 0x25, 0xb2, 0x98, 0x2d, 0xe0, 0xea, 0x1b, 0x9b, 0x8a, 0xcb, 0x63, 0xfe, - 0xda, 0xbe, 0x30, 0xa6, 0x0d, 0x63, 0xfe, 0x32, 0x88, 0x1e, 0xf3, 0x97, 0x41, 0xc8, 0x35, 0x18, - 0xad, 0xb6, 0x1f, 0x3a, 0xac, 0x4f, 0x78, 0x70, 0x31, 0xd4, 0x4d, 0x39, 0x1c, 0xa4, 0x6e, 0xae, - 0x02, 0x8b, 0xbc, 0xa1, 0x5c, 0x6a, 0xc6, 0x22, 0x05, 0x06, 0x57, 0x79, 0x85, 0xd1, 0x83, 0xd4, - 0x0b, 0x4b, 0x78, 0xcb, 0xb9, 0x09, 0xa3, 0x52, 0x93, 0x09, 0x91, 0xd2, 0x42, 0x50, 0x26, 0x83, - 0x71, 0x48, 0x64, 0xcc, 0x1c, 0xaf, 0x64, 0x55, 0x1c, 0x57, 0x32, 0xc7, 0x2b, 0x59, 0x15, 0xb5, - 0xcc, 0xf1, 0x4a, 0x7e, 0xc5, 0x50, 0x09, 0x34, 0x71, 0xac, 0x12, 0xe8, 0x01, 0x4c, 0xac, 0xdb, - 0x5e, 0xe0, 0x30, 0x19, 0xa5, 0x1d, 0xf8, 0xf3, 0x93, 0x9a, 0xde, 0x54, 0x29, 0x5a, 0x7a, 0x4e, - 0x66, 0x2f, 0xef, 0x28, 0xf8, 0x7a, 0x9a, 0xed, 0x08, 0x9e, 0x6e, 0x4a, 0x3b, 0xf5, 0x49, 0x4c, - 0x69, 0xb1, 0x53, 0x51, 0x57, 0x36, 0x1d, 0x69, 0x64, 0xf0, 0xd2, 0x12, 0x53, 0x98, 0x85, 0x88, - 0xe4, 0xab, 0x30, 0xc1, 0xfe, 0x5e, 0x77, 0x9b, 0x4e, 0xdd, 0xa1, 0xfe, 0x7c, 0x01, 0x1b, 0xf7, - 0x5c, 0xea, 0xea, 0x47, 0xa4, 0x83, 0x1a, 0x0d, 0xf8, 0x02, 0x46, 0xc6, 0x71, 0x25, 0xb8, 0xc6, - 0x8d, 0xbc, 0x0b, 0x13, 0x6c, 0xf6, 0x6d, 0xdb, 0x3e, 0x17, 0x4d, 0x67, 0x22, 0x63, 0xe8, 0x86, - 0x80, 0x27, 0xc2, 0x6e, 0xab, 0x04, 0xec, 0x98, 0x2f, 0x75, 0xf8, 0x06, 0x49, 0x94, 0xd9, 0xde, - 0x49, 0x6c, 0x8e, 0x12, 0x8d, 0xbc, 0x07, 0x13, 0xa5, 0x4e, 0x27, 0xda, 0x71, 0x66, 0x15, 0x45, - 0x58, 0xa7, 0x63, 0xa5, 0xee, 0x3a, 0x1a, 0x45, 0x7c, 0x63, 0x9e, 0x3b, 0xd1, 0xc6, 0x4c, 0x5e, - 0x0b, 0xa5, 0xf5, 0x53, 0x91, 0x56, 0x57, 0x5c, 0x1c, 0x35, 0xd1, 0x9f, 0x0b, 0xee, 0x65, 0x98, - 0xe4, 0x6a, 0x4e, 0x29, 0xcd, 0x9c, 0x4e, 0xac, 0x9e, 0x14, 0xa1, 0x46, 0xa7, 0x21, 0xcb, 0x30, - 0xc5, 0x3d, 0xd9, 0x9b, 0x22, 0x1e, 0xfa, 0xfc, 0x19, 0x5c, 0xb5, 0xc8, 0x85, 0x3b, 0xc0, 0x37, - 0x31, 0x4d, 0x8e, 0xad, 0x71, 0x89, 0x11, 0x19, 0x7f, 0x98, 0x81, 0x33, 0x3d, 0x46, 0x3c, 0x8c, - 0x96, 0x9d, 0xe9, 0x1f, 0x2d, 0x9b, 0xed, 0x1c, 0xba, 0x56, 0x04, 0xdb, 0x9f, 0x74, 0xf3, 0x0a, - 0xe5, 0x2d, 0x17, 0x88, 0xc8, 0x44, 0x25, 0xaa, 0xbe, 0xe3, 0xa2, 0x6a, 0x36, 0x97, 0x3c, 0x84, - 0x04, 0x1e, 0xff, 0x28, 0x1e, 0x63, 0x54, 0x24, 0xba, 0x0a, 0x87, 0xf5, 0x23, 0x57, 0x5b, 0xc1, - 0x29, 0xac, 0x8d, 0xc3, 0x0c, 0x8c, 0x2b, 0xeb, 0x90, 0x5c, 0x50, 0xdc, 0x9f, 0x0b, 0x3c, 0x55, - 0x9a, 0xc2, 0x21, 0xcb, 0x4f, 0x22, 0x5c, 0x54, 0xd9, 0xe3, 0x15, 0xd0, 0xf7, 0x98, 0x28, 0xa4, - 0x44, 0x14, 0x6f, 0x69, 0xda, 0x62, 0x13, 0xcb, 0xc9, 0x87, 0x00, 0xab, 0xb6, 0x1f, 0x94, 0xea, - 0x81, 0xf3, 0x90, 0x0e, 0x70, 0xe8, 0xc8, 0x18, 0x8b, 0xa7, 0x30, 0x39, 0x87, 0x8d, 0x64, 0xb1, - 0x33, 0x42, 0x61, 0x68, 0xfc, 0x70, 0x06, 0x60, 0xb3, 0x5a, 0xc6, 0x94, 0x00, 0x9f, 0x54, 0x28, - 0x48, 0x0f, 0xb3, 0x2c, 0xb9, 0xf7, 0x11, 0x07, 0xfe, 0xa7, 0x0c, 0x4c, 0xe9, 0x68, 0xe4, 0x1d, - 0x98, 0xae, 0xd5, 0x3d, 0xb7, 0xd9, 0xdc, 0xb6, 0xeb, 0xfb, 0xab, 0x4e, 0x9b, 0xf2, 0xd0, 0xb3, - 0xc3, 0xfc, 0x2c, 0xf2, 0xc3, 0x22, 0xab, 0xc9, 0xca, 0xcc, 0x38, 0x32, 0xf9, 0x91, 0x0c, 0x4c, - 0xd6, 0xf6, 0xdc, 0x47, 0x61, 0x24, 0x57, 0x31, 0x20, 0x1f, 0xb2, 0xb5, 0xed, 0xef, 0xb9, 0x8f, - 0xa2, 0x3c, 0xab, 0x9a, 0xad, 0xe8, 0xdb, 0x83, 0x3d, 0xe3, 0xd7, 0x5d, 0xbc, 0xc9, 0x04, 0xfe, - 0x55, 0xad, 0x12, 0x53, 0xaf, 0xd3, 0xf8, 0x93, 0x0c, 0x8c, 0xe3, 0x9d, 0xa7, 0xd9, 0x44, 0x99, - 0xeb, 0xb3, 0x94, 0xb4, 0x33, 0x6c, 0x57, 0x9f, 0x81, 0x7d, 0x1d, 0xa6, 0x63, 0x68, 0xc4, 0x80, - 0x91, 0x1a, 0x46, 0x36, 0x50, 0x15, 0x14, 0x3c, 0xd6, 0x81, 0x29, 0x4a, 0x8c, 0x65, 0x85, 0xec, - 0xc1, 0x75, 0x7c, 0xd6, 0x5d, 0x04, 0x70, 0x24, 0x48, 0xde, 0x6c, 0x48, 0xfc, 0x4b, 0x1e, 0x5c, - 0x37, 0x15, 0x2c, 0x63, 0x0d, 0x46, 0x6a, 0xae, 0x17, 0x2c, 0x1d, 0xf0, 0xcb, 0x44, 0x85, 0xfa, - 0x75, 0xf5, 0xdd, 0xd6, 0xc1, 0xb7, 0x92, 0xba, 0x29, 0x8a, 0x48, 0x11, 0x86, 0x6f, 0x39, 0xb4, - 0xd9, 0x50, 0xed, 0x79, 0x77, 0x18, 0xc0, 0xe4, 0x70, 0x76, 0xe1, 0x3a, 0x1d, 0x65, 0xce, 0x89, - 0x0c, 0x87, 0x3f, 0xe9, 0xba, 0x29, 0x6b, 0xfd, 0xfb, 0x7c, 0x98, 0xad, 0x22, 0x59, 0x53, 0x9f, - 0xae, 0xfe, 0x07, 0x19, 0x58, 0xe8, 0x4d, 0xa2, 0xda, 0x22, 0x67, 0xfa, 0xd8, 0x22, 0xbf, 0x18, - 0x7f, 0x67, 0x44, 0x34, 0xf1, 0xce, 0x18, 0xbd, 0x2e, 0x56, 0xd0, 0x14, 0xbc, 0x4e, 0x65, 0xba, - 0x9c, 0x0b, 0x7d, 0xbe, 0x19, 0x11, 0xf9, 0x30, 0x07, 0x48, 0x63, 0x0a, 0x5a, 0xe3, 0x37, 0x86, - 0xe0, 0x6c, 0x4f, 0x0a, 0xb2, 0xa2, 0x24, 0xe1, 0x9a, 0x0a, 0xd3, 0xff, 0xf4, 0xc4, 0xbf, 0x8a, - 0xff, 0xa2, 0xb5, 0x5f, 0xdc, 0xdb, 0xed, 0x7e, 0x98, 0x7c, 0x29, 0x8b, 0xbc, 0x5e, 0x39, 0x96, - 0x17, 0x47, 0x47, 0x66, 0x90, 0xcc, 0xc3, 0x84, 0x7e, 0x91, 0x34, 0xb0, 0x9d, 0xa6, 0xaf, 0x2e, - 0xbb, 0x06, 0x07, 0x99, 0xb2, 0x2c, 0x32, 0x10, 0x1f, 0x4a, 0x37, 0x10, 0x37, 0xfe, 0x34, 0x03, - 0x63, 0xe1, 0x67, 0x93, 0x05, 0x38, 0xbd, 0x61, 0x96, 0xca, 0xcb, 0xd6, 0xc6, 0x07, 0xeb, 0xcb, - 0xd6, 0xe6, 0x5a, 0x6d, 0x7d, 0xb9, 0x5c, 0xbd, 0x55, 0x5d, 0xae, 0x14, 0x9e, 0x21, 0x33, 0x30, - 0xb9, 0xb9, 0x76, 0x77, 0xed, 0xfe, 0xd6, 0x9a, 0xb5, 0x6c, 0x9a, 0xf7, 0xcd, 0x42, 0x86, 0x4c, - 0xc2, 0x98, 0xb9, 0x54, 0x2a, 0x5b, 0x6b, 0xf7, 0x2b, 0xcb, 0x85, 0x2c, 0x29, 0xc0, 0x44, 0xf9, - 0xfe, 0xda, 0xda, 0x72, 0x79, 0xa3, 0xfa, 0xa0, 0xba, 0xf1, 0x41, 0x21, 0x47, 0x08, 0x4c, 0x21, - 0xc2, 0xba, 0x59, 0x5d, 0x2b, 0x57, 0xd7, 0x4b, 0xab, 0x85, 0x21, 0x06, 0x63, 0xf8, 0x0a, 0x6c, - 0x38, 0x64, 0x74, 0x77, 0x73, 0x69, 0xb9, 0x30, 0xc2, 0x50, 0xd8, 0x5f, 0x0a, 0xca, 0x28, 0xab, - 0x1e, 0x51, 0x2a, 0xa5, 0x8d, 0xd2, 0x52, 0xa9, 0xb6, 0x5c, 0xc8, 0x93, 0x33, 0x30, 0xab, 0x81, - 0xac, 0xd5, 0xfb, 0xb7, 0xab, 0x6b, 0x85, 0x31, 0x32, 0x07, 0x85, 0x10, 0x56, 0x59, 0xb2, 0x36, - 0x6b, 0xcb, 0x66, 0x01, 0xe2, 0xd0, 0xb5, 0xd2, 0xbd, 0xe5, 0xc2, 0xb8, 0xf1, 0x36, 0xf7, 0x43, - 0xe4, 0x5d, 0x4d, 0x4e, 0x03, 0xa9, 0x6d, 0x94, 0x36, 0x36, 0x6b, 0xb1, 0xc6, 0x8f, 0xc3, 0x68, - 0x6d, 0xb3, 0x5c, 0x5e, 0xae, 0xd5, 0x0a, 0x19, 0x02, 0x30, 0x72, 0xab, 0x54, 0x5d, 0x5d, 0xae, - 0x14, 0xb2, 0xc6, 0xcf, 0x64, 0x60, 0x46, 0x4a, 0x80, 0xf2, 0xd1, 0xe8, 0x13, 0xae, 0xc5, 0x77, - 0xb4, 0x8b, 0xad, 0x74, 0x12, 0x8b, 0x55, 0xd2, 0x67, 0x19, 0xfe, 0x52, 0x06, 0x4e, 0xa5, 0x62, - 0x93, 0x0f, 0xa0, 0x20, 0xbf, 0xe0, 0x9e, 0x1d, 0xd4, 0xf7, 0xa2, 0x7d, 0xec, 0xb9, 0x58, 0x2d, - 0x31, 0x34, 0xae, 0xd6, 0x8c, 0xd2, 0x82, 0x27, 0xd8, 0x0c, 0x9e, 0xb4, 0xc2, 0xf8, 0x76, 0x06, - 0xce, 0xfc, 0xff, 0xec, 0x7d, 0x5b, 0x6c, 0x24, 0x49, 0x72, 0xd8, 0x54, 0x77, 0x93, 0x6c, 0x06, - 0x5f, 0xc5, 0x1c, 0xce, 0x0c, 0xe7, 0x3d, 0x53, 0x3b, 0x3b, 0xda, 0xe1, 0xde, 0xee, 0xed, 0xcc, - 0x7a, 0x6f, 0x77, 0x4e, 0x77, 0xbb, 0x2a, 0x76, 0x37, 0xc9, 0x9e, 0xe9, 0xd7, 0x55, 0x35, 0x39, - 0x9a, 0x5b, 0x49, 0xad, 0x9a, 0xee, 0x22, 0x59, 0xbb, 0xcd, 0xee, 0xbe, 0xaa, 0xea, 0x9d, 0xe3, - 0xc1, 0x80, 0x4f, 0x10, 0x70, 0x02, 0x6c, 0xcb, 0xb2, 0xcf, 0x32, 0xbc, 0x10, 0x60, 0xc8, 0x80, - 0x0f, 0x86, 0x3e, 0xf4, 0xe7, 0x1f, 0xc3, 0xf7, 0x75, 0x7f, 0x07, 0x08, 0x32, 0x04, 0xf8, 0xef, - 0x64, 0x2f, 0xe4, 0x05, 0x6c, 0x18, 0xb2, 0xff, 0x04, 0xfb, 0x43, 0x80, 0x01, 0x23, 0x23, 0x23, - 0xab, 0xb2, 0xaa, 0xab, 0x7b, 0x38, 0xb7, 0x7b, 0xb6, 0x05, 0xe8, 0x8b, 0xec, 0xc8, 0x88, 0xa8, - 0x7c, 0x67, 0x64, 0x44, 0x64, 0xc4, 0x94, 0xcf, 0xb0, 0x12, 0xcc, 0x47, 0xe9, 0x8b, 0x66, 0x38, - 0xbc, 0x6d, 0xfc, 0xec, 0xb3, 0x9b, 0x84, 0x88, 0x79, 0x94, 0xf1, 0x3f, 0x6b, 0x3e, 0xca, 0x47, - 0x84, 0x49, 0x81, 0x44, 0xf7, 0x5d, 0x4e, 0xf5, 0x3c, 0x7d, 0xc9, 0x7c, 0x62, 0x6f, 0x2f, 0x51, - 0xdf, 0xe5, 0x9d, 0xe7, 0x01, 0x66, 0x05, 0x32, 0x7e, 0x5f, 0xe3, 0xc2, 0x5d, 0x1a, 0x91, 0xcb, - 0xbc, 0x66, 0x10, 0x8c, 0x4f, 0x5c, 0x6b, 0xd8, 0x77, 0x4d, 0xab, 0x41, 0xc7, 0x06, 0x4a, 0xab, - 0x0e, 0x16, 0xe0, 0xb5, 0xa2, 0xe3, 0xf8, 0x89, 0xc0, 0x00, 0x09, 0x1a, 0xf6, 0x10, 0xa0, 0xf2, - 0xdd, 0xd0, 0xf5, 0x07, 0x4e, 0x3f, 0x0a, 0x4e, 0x23, 0xa2, 0x76, 0x11, 0x34, 0x29, 0x6f, 0x2b, - 0xc8, 0xc6, 0x0f, 0x34, 0x58, 0xa6, 0x4b, 0x93, 0xd9, 0x77, 0xfd, 0xf0, 0x8b, 0x4d, 0xaf, 0x87, - 0x89, 0xe9, 0x15, 0xbd, 0xef, 0x50, 0xf8, 0xf3, 0xe2, 0xcc, 0x99, 0xf5, 0xef, 0x35, 0xd0, 0xd3, - 0x88, 0xec, 0x7d, 0x28, 0xda, 0xee, 0x27, 0xae, 0xef, 0x85, 0xa7, 0xb4, 0x51, 0xca, 0x44, 0x8f, - 0x02, 0x87, 0xca, 0xc4, 0x7c, 0x08, 0xe8, 0x97, 0x15, 0xd1, 0x9c, 0x75, 0xbf, 0x57, 0xd4, 0x1e, - 0xf9, 0x2f, 0x4b, 0xed, 0x61, 0xfc, 0x45, 0x0e, 0x2e, 0xed, 0xba, 0xa1, 0xda, 0xa6, 0xc8, 0xbd, - 0xe0, 0xad, 0xb3, 0xb5, 0x4b, 0x69, 0xc9, 0x26, 0x2c, 0x60, 0x91, 0x1c, 0x5f, 0x4b, 0xfe, 0x64, - 0xdb, 0xd1, 0xbc, 0xce, 0x27, 0x32, 0xc9, 0x4d, 0xf9, 0xf6, 0x9b, 0x4a, 0x6e, 0xa9, 0x68, 0x5a, - 0xdf, 0x85, 0x55, 0x4c, 0x6b, 0x30, 0xe6, 0xcb, 0xc1, 0xed, 0x91, 0xfa, 0xa7, 0x68, 0xa5, 0xa0, - 0x6c, 0x0b, 0x74, 0x0e, 0x31, 0xbb, 0x1f, 0x0f, 0x86, 0xcf, 0xfb, 0x6e, 0xef, 0xc8, 0xed, 0xe1, - 0xb1, 0x5e, 0xb4, 0x26, 0xe0, 0x92, 0xe7, 0xfe, 0x40, 0x5c, 0xdd, 0xdc, 0x1e, 0xea, 0x68, 0x88, - 0x67, 0x0c, 0xbd, 0xf2, 0x10, 0x96, 0x7e, 0xce, 0x3c, 0x71, 0xc6, 0x9f, 0x6b, 0xb0, 0x81, 0x8d, - 0x53, 0x3e, 0x2c, 0x73, 0xf8, 0xca, 0xde, 0x52, 0x52, 0x27, 0x39, 0x1c, 0x94, 0x5c, 0x0a, 0x51, - 0x2f, 0xc6, 0x3a, 0xa1, 0xdc, 0x19, 0x74, 0x42, 0x8a, 0x4a, 0xab, 0xf0, 0x65, 0xa9, 0xb4, 0x1e, - 0x15, 0x8a, 0x79, 0xbd, 0x10, 0x0f, 0xb9, 0xf1, 0xdb, 0x39, 0x58, 0xb0, 0x5c, 0x4c, 0xe4, 0xce, - 0xee, 0xc2, 0x42, 0x63, 0x18, 0xba, 0x41, 0x3d, 0x91, 0xb5, 0x7f, 0xc0, 0x41, 0x9d, 0x93, 0x9e, - 0x25, 0x0b, 0xf9, 0x84, 0x6f, 0xf9, 0xc3, 0xde, 0xb8, 0x1b, 0xaa, 0x13, 0x7e, 0x24, 0x40, 0x96, - 0x2c, 0x63, 0x5f, 0x81, 0x45, 0xe2, 0x1c, 0x19, 0x75, 0xd1, 0x77, 0xd9, 0x17, 0x40, 0x4c, 0x80, - 0x12, 0x21, 0xa0, 0x4c, 0x2b, 0x04, 0x8c, 0x82, 0x22, 0xd3, 0x4e, 0xc8, 0x0c, 0x52, 0x54, 0x9f, - 0x9b, 0x21, 0xaa, 0xbf, 0x05, 0xf3, 0x66, 0x10, 0xb8, 0xa1, 0x8c, 0xa2, 0xb0, 0x1c, 0x85, 0xc4, - 0x0b, 0xdc, 0x50, 0x30, 0x76, 0xb0, 0xdc, 0x22, 0x3c, 0xe3, 0xaf, 0x72, 0x30, 0x87, 0xff, 0xa2, - 0xc9, 0xd4, 0xef, 0x1e, 0x27, 0x4c, 0xa6, 0x7e, 0xf7, 0xd8, 0x42, 0x28, 0xbb, 0x8f, 0x9a, 0x0a, - 0x99, 0xe5, 0x8b, 0x5a, 0x8f, 0x2a, 0xf8, 0x5e, 0x0c, 0xb6, 0x54, 0x9c, 0xc8, 0xc2, 0x9f, 0xcf, - 0x8c, 0x9d, 0x72, 0x11, 0x72, 0x4d, 0x9b, 0x5a, 0x8c, 0xa1, 0xc0, 0x86, 0x81, 0x95, 0x6b, 0xda, - 0xd8, 0x1b, 0x7b, 0xe6, 0x83, 0x77, 0xbe, 0x46, 0x0d, 0x15, 0xbd, 0x71, 0xec, 0x3c, 0x78, 0xe7, - 0x6b, 0x16, 0x95, 0xf0, 0xfe, 0xc5, 0x3a, 0xa3, 0xe1, 0x55, 0xbc, 0xf9, 0xc7, 0xfe, 0xc5, 0xb6, - 0xa1, 0x91, 0xd5, 0x8a, 0x11, 0xd8, 0x03, 0x58, 0xa2, 0x58, 0x13, 0x88, 0xaf, 0xc4, 0x82, 0xa0, - 0x58, 0x14, 0x82, 0x42, 0x45, 0x12, 0x26, 0x38, 0x1a, 0x20, 0x99, 0x8b, 0x98, 0x4c, 0x70, 0x72, - 0x08, 0x03, 0x4b, 0x41, 0xe1, 0x55, 0x12, 0x36, 0xbc, 0xf8, 0x2d, 0xff, 0xaa, 0x12, 0xb4, 0x00, - 0x53, 0x48, 0x44, 0x08, 0xc6, 0x1f, 0xe5, 0xa0, 0xd8, 0xea, 0x8f, 0x8f, 0xbc, 0xc1, 0xc1, 0x7d, - 0xc6, 0x00, 0xaf, 0x71, 0x32, 0xc7, 0x08, 0xff, 0x9f, 0x5d, 0x86, 0xa2, 0xbc, 0xb9, 0xc9, 0x0d, - 0x29, 0xa0, 0x5b, 0xdb, 0x26, 0xc8, 0x71, 0xa7, 0x98, 0x6f, 0xf2, 0x27, 0xbb, 0x0f, 0xd1, 0xfd, - 0x6b, 0xda, 0x45, 0xad, 0xc0, 0x17, 0x8b, 0x15, 0xa1, 0xb1, 0x37, 0x00, 0x0f, 0x09, 0xba, 0x3c, - 0x48, 0x85, 0xb6, 0xa8, 0x1a, 0xc9, 0x29, 0x82, 0x04, 0xd1, 0xd8, 0xdb, 0x40, 0x13, 0x93, 0x72, - 0xde, 0x5f, 0x48, 0x12, 0x88, 0x2c, 0xa2, 0x92, 0x84, 0x50, 0xd9, 0x37, 0x60, 0xa9, 0xeb, 0xbb, - 0x68, 0x75, 0x74, 0xfa, 0x71, 0x2a, 0x7b, 0x95, 0xb2, 0x14, 0x97, 0x1f, 0xdc, 0xb7, 0x54, 0x74, - 0xe3, 0x3f, 0x15, 0x61, 0x59, 0xad, 0x0f, 0xb3, 0xe0, 0x7c, 0xd0, 0xe7, 0x77, 0x77, 0x72, 0x36, - 0x1b, 0x61, 0x21, 0x1d, 0xa7, 0xb7, 0x92, 0x15, 0xe2, 0x78, 0xc2, 0xf3, 0x4c, 0x06, 0xc9, 0xd8, - 0x3b, 0x67, 0xad, 0x07, 0x31, 0x58, 0xe0, 0x31, 0x13, 0x8a, 0xc3, 0x51, 0x70, 0xe4, 0x0e, 0x3c, - 0x69, 0x6f, 0x79, 0x25, 0xc1, 0xa8, 0x49, 0x85, 0x13, 0xbc, 0x22, 0x32, 0xf6, 0x0e, 0xcc, 0x0f, - 0x47, 0xee, 0xc0, 0xf1, 0xe8, 0x8c, 0xbb, 0x9a, 0x62, 0xe0, 0x0e, 0xcc, 0xaa, 0x42, 0x48, 0xc8, - 0xec, 0xab, 0x50, 0x18, 0x7e, 0x1c, 0x8d, 0xd7, 0xe5, 0x24, 0xd1, 0xc7, 0xa1, 0xa3, 0x90, 0x20, - 0x22, 0x27, 0xf8, 0xc8, 0x39, 0x39, 0xa4, 0x11, 0x4b, 0x12, 0x3c, 0x72, 0x4e, 0x0e, 0x55, 0x02, - 0x8e, 0xc8, 0x3e, 0x00, 0x18, 0x39, 0x47, 0xae, 0xdf, 0xe9, 0x8d, 0xc3, 0x53, 0x1a, 0xb7, 0x1b, - 0x09, 0xb2, 0x16, 0x2f, 0x2e, 0x8f, 0xc3, 0x53, 0x85, 0x76, 0x71, 0x24, 0x81, 0xcc, 0x04, 0x38, - 0x71, 0xc2, 0xd0, 0xf5, 0x4f, 0x86, 0xe4, 0xed, 0x17, 0x07, 0x78, 0x14, 0x0c, 0xea, 0x51, 0xb1, - 0xc2, 0x41, 0x21, 0xc2, 0x4a, 0x7b, 0xbe, 0x83, 0x16, 0xf0, 0x89, 0x4a, 0x7b, 0x7e, 0xa2, 0x95, - 0x1c, 0x91, 0xbd, 0x07, 0x0b, 0x3d, 0x2f, 0xe8, 0x0e, 0xfd, 0x1e, 0x45, 0x4f, 0xb9, 0x96, 0xa0, - 0x29, 0x8b, 0x32, 0x85, 0x4c, 0xa2, 0xf3, 0xda, 0x52, 0x80, 0xd7, 0xc6, 0xf0, 0x39, 0xaa, 0xf9, - 0xd3, 0xb5, 0xb5, 0xa3, 0x62, 0xb5, 0xb6, 0x31, 0x11, 0x1f, 0xca, 0x23, 0x2f, 0xec, 0x3b, 0xcf, - 0xc8, 0xce, 0x9d, 0x1c, 0xca, 0x5d, 0x2c, 0x52, 0x87, 0x52, 0x20, 0xb3, 0x87, 0x50, 0x74, 0x07, - 0xa1, 0xef, 0x74, 0xbc, 0x1e, 0x3d, 0xaa, 0x4c, 0x56, 0x9a, 0x1f, 0xc0, 0x4e, 0xb5, 0xac, 0x56, - 0x1a, 0xf1, 0xab, 0x3d, 0xde, 0x3f, 0x41, 0xd7, 0x3b, 0xa1, 0xb7, 0x90, 0xc9, 0xfe, 0xb1, 0x4b, - 0xd5, 0xba, 0xda, 0x3f, 0x1c, 0x91, 0xbd, 0x0f, 0x0b, 0x7c, 0xfd, 0xf6, 0x86, 0x47, 0x14, 0x90, - 0xc2, 0x48, 0xf6, 0x8f, 0x28, 0x9b, 0x98, 0xae, 0x92, 0x88, 0x2f, 0x64, 0xe7, 0x79, 0xd0, 0xf1, - 0xba, 0x14, 0x64, 0x22, 0xb9, 0x1c, 0xcd, 0x27, 0x76, 0xb5, 0xa4, 0x90, 0xcd, 0x39, 0xcf, 0x83, - 0x6a, 0x97, 0x3d, 0x80, 0x39, 0x4c, 0xbf, 0x41, 0x41, 0x3e, 0x93, 0x34, 0x98, 0x78, 0x43, 0xa5, - 0x41, 0x54, 0x3e, 0x90, 0x27, 0x01, 0x3e, 0x2f, 0xa1, 0x24, 0x18, 0xc9, 0x3e, 0xa9, 0xdb, 0xf8, - 0xe6, 0x44, 0xad, 0x22, 0xa1, 0xf3, 0x2a, 0x0e, 0xdc, 0xb0, 0xe3, 0x7d, 0x87, 0xd2, 0x58, 0x24, - 0x3f, 0xd7, 0x70, 0xc3, 0xea, 0xb7, 0xd4, 0xcf, 0x0d, 0xdc, 0xb0, 0xfa, 0x1d, 0x76, 0x03, 0x20, - 0x36, 0xfd, 0x0b, 0x43, 0x8d, 0xa5, 0x40, 0xbe, 0x5e, 0xf8, 0x6f, 0xff, 0xf2, 0xa6, 0xb6, 0x0d, - 0x50, 0x94, 0x61, 0x75, 0x8c, 0x1a, 0x5c, 0x9e, 0xba, 0x59, 0xb0, 0x7b, 0xa0, 0x1f, 0x3a, 0xa4, - 0x2a, 0xec, 0x1e, 0x3b, 0x83, 0x81, 0xdb, 0xa7, 0x6d, 0x7a, 0x4d, 0xc2, 0x4b, 0x02, 0x2c, 0x38, - 0x1b, 0x1f, 0xc0, 0x46, 0xd6, 0x2c, 0x61, 0xb7, 0x61, 0x59, 0x8d, 0x20, 0x44, 0x4c, 0x96, 0x9c, - 0x91, 0x27, 0x63, 0x08, 0x11, 0x83, 0x1f, 0x6b, 0x70, 0x6d, 0xd6, 0x9e, 0xc3, 0xae, 0x40, 0x71, - 0xe4, 0x7b, 0x43, 0x94, 0x6d, 0x29, 0xfd, 0x84, 0xfc, 0x8d, 0x99, 0x25, 0x50, 0x08, 0x0b, 0x9d, - 0x23, 0x7a, 0x15, 0x62, 0x2d, 0x22, 0xa4, 0xed, 0x1c, 0x05, 0xec, 0x75, 0x58, 0xef, 0xb9, 0x87, - 0xce, 0xb8, 0x1f, 0x76, 0x82, 0xee, 0xb1, 0xdb, 0xc3, 0x77, 0x5b, 0xe8, 0xed, 0x67, 0xe9, 0x54, - 0x60, 0x4b, 0xf8, 0x44, 0x8d, 0xe7, 0xa6, 0xd4, 0xf8, 0x51, 0xa1, 0xa8, 0xe9, 0x39, 0x0b, 0xdd, - 0xab, 0x8c, 0xef, 0xe7, 0x60, 0x73, 0xda, 0x22, 0x63, 0xdf, 0xcc, 0xea, 0x03, 0x61, 0xed, 0x50, - 0xe1, 0xaa, 0xb5, 0x43, 0xf9, 0x1a, 0x7b, 0x00, 0xd1, 0xab, 0xab, 0x17, 0x45, 0x50, 0x90, 0x30, - 0x4e, 0x33, 0x72, 0x82, 0xe0, 0x39, 0xdf, 0x47, 0xf2, 0x4a, 0x84, 0x61, 0x82, 0xa9, 0x34, 0x12, - 0xc6, 0xde, 0x05, 0xe8, 0xf6, 0x87, 0x81, 0x8b, 0x4e, 0x05, 0x24, 0xa0, 0x08, 0x5f, 0xf2, 0x08, - 0xaa, 0x5a, 0x91, 0x11, 0x5a, 0x1a, 0xf6, 0x5c, 0x1a, 0x40, 0x07, 0x2e, 0x4d, 0xd9, 0x55, 0xf9, - 0xf0, 0xe0, 0x33, 0x2a, 0xb1, 0x88, 0x28, 0xf9, 0x17, 0x87, 0x88, 0xa4, 0x35, 0xe9, 0x1e, 0xcf, - 0x4d, 0x9b, 0x23, 0xa7, 0xc0, 0x26, 0xb7, 0x4e, 0xce, 0x9d, 0x3c, 0xa2, 0xc7, 0x7e, 0xc4, 0x5d, - 0x40, 0xf6, 0xfd, 0x3e, 0xbb, 0x09, 0x4b, 0x32, 0x4d, 0x29, 0xbf, 0x00, 0x08, 0xe6, 0x40, 0xa0, - 0xc7, 0x2e, 0x4e, 0x1e, 0x8c, 0xef, 0x8a, 0x6f, 0xeb, 0x48, 0xb4, 0x58, 0x44, 0x48, 0xfb, 0x74, - 0x24, 0x5b, 0x77, 0x4d, 0xce, 0xef, 0xe4, 0x81, 0x46, 0xa5, 0xff, 0x4c, 0x93, 0xc3, 0x3f, 0x79, - 0x22, 0xbc, 0xa8, 0x7e, 0x0c, 0xf0, 0x69, 0x13, 0x55, 0x0c, 0xff, 0xe7, 0xa2, 0x8e, 0x5c, 0x75, - 0x24, 0xea, 0xd0, 0x4f, 0x76, 0x17, 0xd6, 0x7c, 0xe1, 0xfc, 0x1a, 0x0e, 0xa9, 0x3f, 0x45, 0x22, - 0x95, 0x15, 0x01, 0x6e, 0x0f, 0xb1, 0x4f, 0xa9, 0x5e, 0x8f, 0xa2, 0x0e, 0x53, 0x0e, 0x48, 0xf6, - 0x26, 0x2c, 0xf2, 0x03, 0x12, 0xc3, 0xf3, 0xa4, 0xde, 0x54, 0x20, 0x1e, 0x8a, 0x1b, 0x56, 0xf1, - 0x23, 0xfa, 0x9f, 0x78, 0x7d, 0x9a, 0x93, 0xcc, 0xd4, 0xe3, 0x99, 0x5d, 0x82, 0x85, 0xa1, 0x7f, - 0xa4, 0x34, 0x6d, 0x7e, 0xe8, 0x1f, 0xf1, 0x76, 0xbd, 0x06, 0xba, 0x78, 0xe2, 0x23, 0x42, 0x2d, - 0x04, 0xa7, 0x03, 0x71, 0x7f, 0x2f, 0x5a, 0xab, 0x02, 0xbe, 0x1f, 0xb8, 0xbe, 0x7d, 0x3a, 0xe8, - 0x72, 0xcc, 0x20, 0x18, 0x76, 0xd4, 0xa8, 0x5c, 0xd4, 0xec, 0xd5, 0x20, 0x18, 0xc6, 0xe1, 0xb9, - 0x7a, 0x6c, 0x1b, 0x56, 0x38, 0x9f, 0x28, 0x36, 0x18, 0x49, 0x0f, 0xd7, 0x27, 0xa5, 0x87, 0xd3, - 0x41, 0x57, 0x56, 0xd1, 0x5a, 0x0e, 0x94, 0x5f, 0xec, 0x31, 0xe8, 0x8a, 0x98, 0x85, 0x6f, 0x3e, - 0x53, 0x8e, 0xd8, 0x31, 0x1b, 0x45, 0x3c, 0xab, 0x0e, 0x0e, 0x87, 0xd6, 0x5a, 0x37, 0x09, 0xa0, - 0xae, 0xf9, 0x43, 0x4d, 0xee, 0xa5, 0x19, 0x44, 0xcc, 0x80, 0x95, 0x63, 0x27, 0xe8, 0x04, 0xc1, - 0x89, 0x70, 0x2c, 0xa3, 0x30, 0xc8, 0x4b, 0xc7, 0x4e, 0x60, 0x07, 0x27, 0x32, 0x93, 0xcb, 0x05, - 0x8e, 0x33, 0x74, 0xc6, 0xe1, 0x71, 0x47, 0x15, 0x1a, 0x45, 0x8f, 0x9d, 0x3f, 0x76, 0x82, 0x26, - 0x2f, 0x53, 0x78, 0xb3, 0x3b, 0xb0, 0x8a, 0x7c, 0xbb, 0x9e, 0x64, 0x8c, 0xe1, 0x32, 0xac, 0x65, - 0xce, 0xb8, 0xeb, 0x09, 0xce, 0x54, 0xc3, 0x1f, 0x16, 0xe0, 0x62, 0x76, 0xef, 0xe0, 0xf4, 0xe4, - 0x7d, 0x8a, 0x0f, 0xfb, 0xa8, 0x6e, 0x8b, 0x1c, 0x22, 0x42, 0x9d, 0x64, 0x0d, 0x4e, 0x2e, 0x73, - 0x70, 0xb6, 0x60, 0x1d, 0x19, 0x91, 0x78, 0xda, 0xf7, 0x82, 0x90, 0x22, 0x78, 0x58, 0x6b, 0xbc, - 0x40, 0xec, 0xe7, 0x35, 0x0e, 0x66, 0xaf, 0xc2, 0xaa, 0xdc, 0x91, 0x87, 0xcf, 0x07, 0xfc, 0xc3, - 0x62, 0x3b, 0x5e, 0x21, 0x68, 0x13, 0x81, 0xec, 0x02, 0xcc, 0x3b, 0xa3, 0x11, 0xff, 0xa4, 0xd8, - 0x85, 0xe7, 0x9c, 0xd1, 0x48, 0x64, 0x1b, 0xc2, 0x67, 0x8c, 0x9d, 0x43, 0x74, 0x2d, 0x22, 0x3f, - 0x46, 0x6b, 0x19, 0x81, 0xc2, 0xdd, 0x28, 0xe0, 0xeb, 0x9e, 0xd3, 0x4a, 0x94, 0x05, 0x44, 0x01, - 0x67, 0x14, 0x21, 0x5c, 0x86, 0xa2, 0x34, 0x72, 0x8b, 0xd7, 0x18, 0xd6, 0x82, 0x43, 0x06, 0xee, - 0x77, 0xe0, 0x52, 0xcf, 0x0b, 0x70, 0xf2, 0x8a, 0x26, 0x8d, 0x46, 0xf4, 0x70, 0x52, 0x84, 0x14, - 0xb6, 0x36, 0xa8, 0x98, 0xf7, 0xa4, 0x39, 0x1a, 0x45, 0xcf, 0x27, 0xaf, 0x48, 0xb2, 0x67, 0x9e, - 0x88, 0x57, 0x26, 0x9c, 0x32, 0x71, 0xf2, 0x03, 0x52, 0x6e, 0x12, 0xc6, 0xb6, 0x8a, 0x20, 0x97, - 0x41, 0xb4, 0x52, 0x3a, 0x42, 0x29, 0x46, 0x07, 0x39, 0x9a, 0x42, 0x71, 0xd0, 0x10, 0xca, 0x3e, - 0x80, 0x6b, 0xf2, 0x3b, 0x4e, 0x10, 0x78, 0x47, 0x83, 0x8e, 0xec, 0x4c, 0x74, 0x15, 0x40, 0x21, - 0xac, 0x68, 0x5d, 0x26, 0x1c, 0x13, 0x51, 0xca, 0x02, 0x03, 0xdf, 0xcf, 0xd1, 0xa4, 0x78, 0x0f, - 0xd6, 0x48, 0x9e, 0xa4, 0xb3, 0x1c, 0x3b, 0x8d, 0x76, 0x1a, 0x7e, 0xd1, 0xa3, 0x44, 0x54, 0x40, - 0xa0, 0x6a, 0x4f, 0x52, 0xfe, 0x47, 0x0d, 0x2e, 0x64, 0x0a, 0xa4, 0xec, 0x37, 0x41, 0x3c, 0x68, - 0x0b, 0x87, 0x1d, 0xdf, 0xed, 0x7a, 0x23, 0x0f, 0x23, 0x84, 0x08, 0x85, 0xed, 0x83, 0x59, 0xa2, - 0x2c, 0x3e, 0x8e, 0x6b, 0x0f, 0xad, 0x88, 0x48, 0x68, 0x92, 0x74, 0x3f, 0x05, 0xbe, 0xf2, 0x21, - 0x5c, 0xc8, 0x44, 0xcd, 0xd0, 0xf0, 0x7c, 0x25, 0x99, 0xd0, 0x5c, 0x9a, 0xe0, 0x52, 0x8d, 0x56, - 0x34, 0x3f, 0xd4, 0xbc, 0x9f, 0x44, 0xcd, 0x4b, 0x89, 0xae, 0xac, 0x92, 0xde, 0x80, 0xb2, 0x6e, - 0x5f, 0x92, 0x68, 0xfa, 0x1e, 0xf4, 0x21, 0x5c, 0xa0, 0x55, 0x72, 0xe4, 0x3b, 0xa3, 0xe3, 0x98, - 0x9d, 0xa8, 0xe8, 0x2f, 0x65, 0xb1, 0x13, 0xcb, 0x67, 0x97, 0xe3, 0x47, 0x5c, 0xcf, 0x3b, 0x93, - 0x40, 0x6a, 0xc3, 0x6f, 0xe5, 0xe4, 0x9e, 0x94, 0x51, 0x9d, 0x8c, 0xf5, 0xa7, 0x65, 0xad, 0xbf, - 0xb3, 0x2f, 0xfe, 0x06, 0x30, 0x75, 0x57, 0xa5, 0xe9, 0x2b, 0xdc, 0xc5, 0xe4, 0x2d, 0x84, 0x2a, - 0xa2, 0xec, 0x61, 0x62, 0x3e, 0x5b, 0xeb, 0xdd, 0x34, 0x88, 0x5d, 0x85, 0xc5, 0x28, 0x67, 0x3b, - 0x9d, 0x70, 0x45, 0x01, 0xa8, 0xf6, 0xd8, 0x2d, 0x58, 0x16, 0x17, 0x8e, 0xc4, 0xe6, 0x00, 0x08, - 0x33, 0xf9, 0x0e, 0x21, 0xfb, 0x40, 0x83, 0x5b, 0x2f, 0xea, 0x43, 0xf6, 0x04, 0x2e, 0xa2, 0xd3, - 0x4a, 0x30, 0x8c, 0x86, 0xa1, 0xd3, 0x75, 0xba, 0xc7, 0x2e, 0xcd, 0x5a, 0x23, 0x73, 0x30, 0x46, - 0x23, 0xdb, 0x6e, 0x2a, 0xe3, 0x30, 0x1a, 0xd9, 0xc1, 0x50, 0xfe, 0x2e, 0x71, 0x72, 0xaa, 0x43, - 0x0f, 0xae, 0xce, 0xa0, 0x54, 0x76, 0x38, 0x4d, 0xdd, 0xe1, 0x5e, 0x03, 0xfd, 0xd0, 0xed, 0x71, - 0xe1, 0xdd, 0xed, 0x61, 0xd5, 0x3e, 0x79, 0x80, 0x1d, 0xbf, 0x6c, 0xad, 0x46, 0x70, 0x3b, 0x18, - 0x1e, 0x3c, 0xa0, 0xaf, 0x9c, 0xc8, 0xb3, 0x59, 0xbd, 0x34, 0xb1, 0x37, 0xe1, 0x7c, 0x2a, 0xfa, - 0x4a, 0xfc, 0x9c, 0xdf, 0x5a, 0xe7, 0x45, 0xc9, 0x58, 0x5d, 0xb7, 0x61, 0x59, 0xdd, 0x48, 0xa4, - 0x20, 0xd6, 0x8b, 0xb7, 0x0e, 0xfa, 0xdc, 0x58, 0x36, 0x2a, 0xf3, 0xbe, 0x75, 0x06, 0xa1, 0x9f, - 0xbd, 0x01, 0x2c, 0xba, 0x60, 0x44, 0x1b, 0x05, 0x7d, 0x70, 0x5d, 0x96, 0x44, 0x2b, 0x9c, 0x3e, - 0xfb, 0x6f, 0xe6, 0xe1, 0x7c, 0xc6, 0x45, 0x8d, 0xbd, 0x01, 0xba, 0x37, 0x08, 0xdd, 0x23, 0x9f, - 0x92, 0xe0, 0xc6, 0x4e, 0x34, 0xb9, 0x4d, 0xcd, 0x5a, 0x53, 0xca, 0x48, 0x03, 0x37, 0x2f, 0x32, - 0xf1, 0xd3, 0xf7, 0xe8, 0x17, 0xdf, 0x40, 0x1c, 0x5f, 0x2a, 0x97, 0xf8, 0xbf, 0xac, 0x0a, 0xeb, - 0x98, 0x94, 0x23, 0xf0, 0x86, 0x98, 0xdb, 0x03, 0x25, 0xa6, 0x42, 0xe2, 0x3a, 0x87, 0x35, 0x69, - 0x29, 0x48, 0x5c, 0x64, 0xb2, 0xf4, 0x51, 0x0a, 0xc2, 0x7e, 0x19, 0xae, 0x28, 0x07, 0x63, 0x27, - 0xb5, 0xfa, 0xd0, 0x97, 0xdf, 0xba, 0xe4, 0x44, 0x47, 0x64, 0x39, 0xb1, 0x0e, 0xb7, 0x41, 0x64, - 0xfa, 0xf5, 0x7a, 0xa3, 0xce, 0x44, 0x16, 0x17, 0x6c, 0xae, 0xc8, 0x49, 0x70, 0x85, 0x63, 0x55, - 0x7b, 0xa3, 0x54, 0x42, 0x17, 0x6c, 0x75, 0x2b, 0x73, 0x85, 0x2e, 0xe0, 0x0a, 0xbd, 0xae, 0x36, - 0x66, 0x62, 0x7d, 0x62, 0x2f, 0x66, 0xac, 0xd1, 0x23, 0x58, 0x8f, 0x0f, 0x2c, 0x79, 0xce, 0x16, - 0x13, 0x99, 0xf9, 0x91, 0xa1, 0x14, 0xf4, 0xc4, 0xc1, 0x2b, 0x22, 0x12, 0x4c, 0x10, 0xaa, 0x71, - 0x37, 0xc6, 0x09, 0x82, 0x80, 0xd5, 0x60, 0x83, 0x5f, 0xda, 0x29, 0x7f, 0x68, 0x10, 0x7d, 0x6b, - 0x71, 0xf2, 0x5b, 0xd2, 0x9c, 0x24, 0x48, 0x2d, 0xe6, 0x3c, 0x0f, 0x28, 0xad, 0x68, 0x20, 0xb9, - 0x7d, 0x04, 0x4c, 0x48, 0x0f, 0x89, 0x7a, 0xc3, 0x8b, 0x78, 0x51, 0xf2, 0xd1, 0x09, 0x4a, 0x35, - 0x7a, 0x18, 0x96, 0xaa, 0x35, 0x6f, 0x27, 0x55, 0x80, 0x4b, 0x09, 0xfb, 0x55, 0xba, 0xb7, 0x85, - 0x6d, 0x4d, 0xc1, 0x57, 0x6f, 0x84, 0x0a, 0x18, 0x2f, 0x01, 0x18, 0x5d, 0x08, 0xeb, 0x71, 0xc2, - 0xaf, 0x6b, 0xcb, 0x74, 0x09, 0xe0, 0x60, 0x5e, 0x81, 0x7a, 0x7c, 0x31, 0xfb, 0x54, 0x03, 0x3d, - 0xfd, 0x29, 0xf6, 0x0d, 0x98, 0x0f, 0xf0, 0x25, 0x0a, 0x9d, 0x60, 0x46, 0x76, 0x9d, 0xc4, 0x48, - 0x8b, 0x37, 0x2b, 0x7b, 0xe7, 0x2c, 0xa2, 0x61, 0x5f, 0x83, 0xc2, 0xd0, 0xeb, 0x49, 0x7b, 0xdc, - 0xad, 0x59, 0xb4, 0xcd, 0x6a, 0xb9, 0x84, 0x3a, 0x3c, 0xaf, 0x47, 0x37, 0x89, 0xed, 0x22, 0xcc, - 0x8b, 0x8e, 0x35, 0x3e, 0x82, 0xab, 0x33, 0x3e, 0xc8, 0x2a, 0xb0, 0x96, 0xb2, 0x55, 0x9e, 0xd1, - 0x8c, 0xe9, 0xc4, 0x66, 0x4c, 0x5f, 0x8a, 0xc0, 0x7d, 0xb8, 0x3c, 0xb5, 0x82, 0xac, 0x3a, 0x75, - 0x07, 0xc1, 0xf8, 0x17, 0xe9, 0x32, 0x75, 0xb2, 0xa6, 0x76, 0x17, 0xfa, 0xda, 0xef, 0xe6, 0xe0, - 0x7c, 0xc6, 0x24, 0x62, 0x06, 0xe4, 0xe4, 0x5e, 0x3f, 0xe9, 0x09, 0xb7, 0x77, 0xce, 0xca, 0x79, - 0x3d, 0xf6, 0x10, 0x00, 0xf3, 0xb4, 0xfa, 0xee, 0x91, 0xfb, 0x5d, 0xba, 0xf2, 0xe3, 0x45, 0x3c, - 0x86, 0x26, 0x68, 0x16, 0xd1, 0xba, 0xc0, 0xc1, 0xec, 0x3e, 0x80, 0xfb, 0xdd, 0x6e, 0x7f, 0xdc, - 0x73, 0xa3, 0x4b, 0x54, 0xc6, 0x67, 0x34, 0x6b, 0x91, 0xb0, 0xaa, 0x3d, 0xb6, 0x07, 0x4c, 0x92, - 0x28, 0x5f, 0x2d, 0xbc, 0xe0, 0xab, 0x9a, 0xa5, 0x13, 0x55, 0x43, 0x7e, 0x9c, 0x46, 0x77, 0x11, - 0x16, 0xbc, 0x01, 0x96, 0xf0, 0x7f, 0x09, 0xc9, 0xf8, 0x63, 0x8d, 0xfa, 0x23, 0xb9, 0x19, 0xb0, - 0x36, 0x90, 0x29, 0x9c, 0x36, 0x8e, 0xbb, 0xd3, 0x37, 0x0e, 0xd5, 0xc2, 0x48, 0x81, 0x50, 0x10, - 0xa0, 0xda, 0xd1, 0x04, 0xe4, 0x0b, 0xd8, 0xfe, 0x68, 0xf8, 0x3e, 0x84, 0x0b, 0x99, 0x1b, 0x3b, - 0xbf, 0x34, 0xa0, 0x47, 0x6d, 0x7c, 0xdf, 0x5d, 0xe0, 0xbf, 0xf9, 0x85, 0xf7, 0x36, 0x2c, 0x3f, - 0x73, 0x1d, 0xdf, 0xf5, 0xe9, 0x36, 0x46, 0xa7, 0xa7, 0x80, 0xa9, 0x97, 0xb1, 0x5e, 0xf2, 0x14, - 0x23, 0xe3, 0x01, 0xab, 0xc3, 0x79, 0xb1, 0xbb, 0x78, 0x27, 0x78, 0xc1, 0x27, 0x83, 0x83, 0x96, - 0xb8, 0xe2, 0x22, 0x09, 0x5e, 0x37, 0xaa, 0x88, 0x25, 0xa8, 0xad, 0xf5, 0xa3, 0x34, 0x88, 0x0b, - 0x3f, 0x17, 0xb3, 0xb1, 0xd9, 0x36, 0x2c, 0x09, 0xe6, 0x42, 0xd5, 0x23, 0x2c, 0xc5, 0xb7, 0x67, - 0x7e, 0xa1, 0x84, 0x0f, 0x4d, 0x82, 0xe8, 0x7f, 0x7e, 0x07, 0x43, 0xa7, 0x9c, 0xce, 0x89, 0x6a, - 0x08, 0xb7, 0x96, 0x11, 0x48, 0x06, 0x70, 0xe3, 0x3f, 0x68, 0xb2, 0xa9, 0x09, 0x2d, 0x29, 0x3f, - 0x81, 0x03, 0x77, 0x20, 0x9d, 0x01, 0x16, 0x2d, 0xfa, 0xf5, 0x92, 0x52, 0x01, 0x7b, 0x17, 0x96, - 0x39, 0xdb, 0xa3, 0xf1, 0x40, 0x9c, 0xcc, 0xf9, 0x44, 0x80, 0xb6, 0xba, 0x28, 0xe2, 0xc3, 0xb6, - 0x77, 0xce, 0x5a, 0x3a, 0x89, 0x7f, 0xb2, 0x37, 0x61, 0x31, 0x38, 0x09, 0x47, 0xea, 0x79, 0x2e, - 0x2d, 0x46, 0x76, 0xbd, 0xdd, 0x22, 0x92, 0x22, 0xc7, 0x89, 0x35, 0x20, 0xdb, 0xf3, 0xc2, 0x66, - 0x64, 0xbc, 0x0e, 0x4b, 0x0a, 0x6f, 0xde, 0x18, 0xf1, 0x84, 0x52, 0x36, 0x46, 0xfc, 0xa2, 0xc1, - 0x7e, 0x06, 0x45, 0xc9, 0x92, 0x31, 0x28, 0x1c, 0x0f, 0x03, 0x29, 0x0f, 0xe1, 0xff, 0x1c, 0xc6, - 0x7b, 0x19, 0x1b, 0x39, 0x67, 0xe1, 0xff, 0x28, 0x76, 0x87, 0x8e, 0x1f, 0xe2, 0xf3, 0xba, 0x11, - 0xba, 0xe2, 0x46, 0x0a, 0x11, 0x0e, 0x6f, 0xf7, 0x03, 0xe1, 0xa0, 0x4b, 0xdf, 0xf8, 0xb7, 0xd1, - 0x7d, 0x25, 0xa5, 0x56, 0x9e, 0x26, 0x5e, 0x26, 0xa4, 0xeb, 0xdc, 0xa4, 0x74, 0x2d, 0x02, 0x6f, - 0x11, 0xa5, 0xf8, 0x32, 0x20, 0x0c, 0xa5, 0x6b, 0x45, 0x80, 0x2a, 0x24, 0x04, 0x28, 0x45, 0xcf, - 0x1a, 0x8f, 0x9e, 0x10, 0xce, 0xa5, 0x9e, 0x35, 0x2d, 0xd2, 0xfd, 0x28, 0x9a, 0x21, 0x09, 0xc5, - 0x36, 0x7b, 0x00, 0x17, 0x84, 0x32, 0x84, 0x52, 0xd1, 0xa7, 0x64, 0xc9, 0xf3, 0x58, 0x28, 0x12, - 0xd5, 0x45, 0x32, 0xe5, 0x8b, 0xf5, 0x88, 0xec, 0x2d, 0xd8, 0x88, 0x92, 0x27, 0x07, 0x1f, 0x7b, - 0xa3, 0x0e, 0xa6, 0xcf, 0x3e, 0x25, 0x35, 0x05, 0x93, 0x65, 0xf6, 0xc7, 0xde, 0xe8, 0x00, 0x4b, - 0xa8, 0x9a, 0xff, 0x3a, 0x27, 0xb5, 0xd3, 0xdb, 0xc3, 0x61, 0x18, 0x84, 0xbe, 0x33, 0x4a, 0x98, - 0xee, 0xd8, 0x09, 0x5c, 0xc6, 0x2a, 0x3d, 0xc0, 0x5c, 0x53, 0x43, 0x5f, 0x86, 0xa4, 0x8a, 0x16, - 0xd8, 0xd2, 0x83, 0xaf, 0x26, 0xd5, 0x4b, 0x26, 0xc7, 0x36, 0x55, 0x64, 0xbe, 0xae, 0x14, 0xae, - 0x7b, 0xe7, 0xac, 0x4b, 0x82, 0xe7, 0x04, 0x16, 0xdb, 0xcb, 0xd8, 0x6b, 0xd2, 0xb6, 0xbb, 0xed, - 0x78, 0xe3, 0x49, 0x72, 0x55, 0xb7, 0x24, 0xf6, 0x3e, 0x2c, 0x7a, 0x3d, 0x35, 0x6b, 0x73, 0xda, - 0x6a, 0x54, 0xed, 0x89, 0xec, 0x0a, 0x31, 0x0f, 0xbe, 0x34, 0x3c, 0x82, 0x6e, 0xaf, 0x24, 0x24, - 0x1c, 0x63, 0x5b, 0x2a, 0x42, 0x27, 0xc9, 0xd8, 0x6a, 0x7c, 0xf6, 0xe1, 0x39, 0x87, 0xbb, 0x40, - 0x9c, 0xdf, 0xc1, 0xa2, 0x5f, 0xc6, 0xdf, 0x85, 0xd7, 0xce, 0xda, 0x47, 0x7c, 0xc7, 0x98, 0xd2, - 0xe1, 0x8b, 0x22, 0xb4, 0x72, 0xb2, 0xdf, 0x6e, 0x83, 0x1a, 0x9e, 0xde, 0x93, 0x53, 0x44, 0xc2, - 0xf6, 0x7d, 0xcf, 0xf8, 0x1f, 0x79, 0x58, 0x4d, 0x9a, 0x75, 0xd9, 0xeb, 0x50, 0x50, 0x36, 0xca, - 0x4b, 0x19, 0xb6, 0x5f, 0xdc, 0x1e, 0x11, 0xe9, 0x4c, 0x1b, 0x23, 0x7b, 0x04, 0xab, 0xe8, 0x68, - 0x8e, 0x02, 0x5c, 0xe8, 0x91, 0xb3, 0xc0, 0x6c, 0x7f, 0x8f, 0xe2, 0x4f, 0x3f, 0xbb, 0x79, 0x0e, - 0x5d, 0x3b, 0x96, 0x39, 0x2d, 0x3f, 0x18, 0x79, 0xa1, 0x62, 0xb5, 0x2b, 0x4c, 0xb7, 0xda, 0x51, - 0x53, 0xa6, 0x58, 0xed, 0xe6, 0x66, 0x58, 0xed, 0x62, 0x4a, 0xd5, 0x6a, 0x87, 0xb6, 0xdb, 0x85, - 0x69, 0xb6, 0xdb, 0x98, 0x46, 0xd8, 0x6e, 0x63, 0xab, 0x5b, 0x71, 0xaa, 0xd5, 0x2d, 0xa6, 0x21, - 0xab, 0x5b, 0x6c, 0x07, 0x5b, 0x9c, 0x6a, 0x07, 0x53, 0x88, 0x84, 0x1d, 0xec, 0x0e, 0x75, 0xac, - 0xef, 0x3c, 0xef, 0x60, 0x8f, 0xd3, 0xcd, 0x08, 0xbb, 0xcc, 0x72, 0x9e, 0xa3, 0x07, 0x29, 0x17, - 0x4c, 0xc8, 0xed, 0xd4, 0xf8, 0x71, 0x6a, 0x03, 0x92, 0x63, 0xfe, 0x2a, 0xac, 0x8a, 0x73, 0x98, - 0x42, 0x76, 0x8b, 0x83, 0x78, 0xc5, 0x5a, 0x91, 0x50, 0xa1, 0x1e, 0xfd, 0x25, 0x58, 0x8b, 0xd0, - 0x48, 0x43, 0x88, 0xaf, 0xd1, 0xad, 0x88, 0x9a, 0x74, 0x83, 0x2a, 0x3f, 0x9f, 0x82, 0x97, 0x25, - 0xf8, 0x89, 0xc8, 0x56, 0x6f, 0x00, 0x8b, 0xd1, 0x22, 0x27, 0xfc, 0x02, 0xa2, 0xae, 0x47, 0xa8, - 0x91, 0xa7, 0xfc, 0x3f, 0xd5, 0x52, 0x76, 0xb7, 0x5f, 0x54, 0xf5, 0x5f, 0x87, 0xe8, 0xeb, 0x1d, - 0xb2, 0x9d, 0xc8, 0x16, 0xe8, 0xb2, 0xa0, 0x45, 0x70, 0xe3, 0x28, 0xad, 0x3e, 0xfb, 0x05, 0xd5, - 0xca, 0xf8, 0x49, 0x3e, 0x61, 0x93, 0x90, 0x9f, 0xe1, 0xf2, 0x4d, 0x30, 0xec, 0xd0, 0x10, 0xd3, - 0xf6, 0x7b, 0x7b, 0xca, 0x34, 0x25, 0xb7, 0x63, 0xdb, 0x6e, 0x5a, 0x10, 0x04, 0x43, 0xe9, 0x85, - 0xdc, 0x11, 0x6a, 0x21, 0xe5, 0xbe, 0x27, 0xd9, 0x89, 0xbd, 0x76, 0x6b, 0x36, 0x3b, 0xa9, 0x14, - 0xe6, 0xab, 0x14, 0xd5, 0x43, 0xd1, 0x2f, 0xf9, 0x81, 0x7d, 0x40, 0x13, 0x5e, 0x90, 0x64, 0x9e, - 0xcf, 0x50, 0x00, 0x4e, 0x30, 0xc7, 0x5e, 0x42, 0xce, 0xa8, 0x31, 0x0e, 0x54, 0xb6, 0x15, 0x58, - 0x46, 0x8b, 0x80, 0x64, 0x58, 0xc8, 0xb0, 0x92, 0x4f, 0x36, 0xbe, 0x54, 0xad, 0x5b, 0x4b, 0x9c, - 0x4e, 0xb2, 0x39, 0x86, 0xcb, 0xaa, 0x1e, 0x3f, 0x59, 0xc9, 0x39, 0x19, 0x68, 0x7f, 0x66, 0x0f, - 0xc4, 0xea, 0x7e, 0xac, 0xea, 0x45, 0x27, 0x09, 0x20, 0x34, 0xf4, 0xc0, 0x9f, 0x3e, 0x26, 0x33, - 0xd2, 0x47, 0xc6, 0xb2, 0x4d, 0x4e, 0x95, 0x6d, 0x54, 0xb5, 0x7e, 0x3e, 0xa9, 0xd6, 0xdf, 0x81, - 0x5b, 0x7c, 0x3b, 0xa2, 0x41, 0x75, 0x3f, 0x71, 0xfd, 0xd3, 0xe1, 0x00, 0x83, 0xaf, 0x8d, 0xa2, - 0x55, 0x29, 0xec, 0x10, 0xd7, 0x38, 0x1e, 0x0e, 0x59, 0x85, 0xb0, 0xea, 0x88, 0x24, 0x82, 0x0a, - 0xfe, 0xab, 0x3c, 0xbc, 0x72, 0x86, 0x71, 0x9f, 0x51, 0xf7, 0x5f, 0x49, 0x4a, 0xe0, 0xb9, 0x84, - 0x9e, 0x94, 0x33, 0xa5, 0xc3, 0xe5, 0x74, 0xd0, 0x9d, 0x22, 0x7f, 0xff, 0x26, 0xac, 0x89, 0x13, - 0x44, 0x3c, 0x41, 0x38, 0x1c, 0xf7, 0xcf, 0x70, 0x84, 0x5c, 0x95, 0xef, 0xa5, 0x53, 0xa4, 0x78, - 0xaa, 0xe0, 0xc6, 0x69, 0x47, 0x30, 0xd6, 0x86, 0x25, 0x44, 0x3b, 0x74, 0xbc, 0xfe, 0x99, 0x1e, - 0xee, 0xca, 0xd7, 0xd8, 0x2a, 0x99, 0x78, 0x39, 0xc5, 0x01, 0x3b, 0xf8, 0x9b, 0xdd, 0x85, 0xb5, - 0xc1, 0xf8, 0x84, 0xcb, 0x96, 0x62, 0x52, 0x91, 0xa7, 0xe7, 0x9c, 0xb5, 0x32, 0x18, 0x9f, 0x98, - 0xa3, 0x11, 0xce, 0x0d, 0x74, 0x09, 0x5d, 0xe7, 0x78, 0x62, 0xf9, 0x4b, 0xcc, 0x79, 0xc4, 0xe4, - 0x0c, 0xc4, 0x06, 0x40, 0xb8, 0x1b, 0x20, 0x1e, 0x08, 0x50, 0x1a, 0x4e, 0xf1, 0xc3, 0xf8, 0x5f, - 0x39, 0xa9, 0xfd, 0x9d, 0xbe, 0x80, 0xfe, 0x76, 0x88, 0x32, 0x86, 0xe8, 0x35, 0xd0, 0x79, 0xd7, - 0xc7, 0xbb, 0x53, 0x34, 0x46, 0xab, 0x83, 0xf1, 0x49, 0xd4, 0x77, 0x6a, 0xc7, 0xcf, 0xab, 0x1d, - 0xff, 0xae, 0xd4, 0x0e, 0x67, 0xee, 0x33, 0xd3, 0xbb, 0x9c, 0x8b, 0x5e, 0x77, 0xcf, 0xb6, 0x9b, - 0xfc, 0xed, 0xb8, 0x65, 0x8c, 0x5b, 0xca, 0xe2, 0x39, 0x37, 0x61, 0xf1, 0xcc, 0x58, 0x7b, 0xf3, - 0x59, 0x6b, 0x6f, 0xc2, 0xbe, 0xba, 0x90, 0x61, 0x5f, 0xcd, 0x5c, 0xa0, 0xc5, 0x17, 0x2c, 0xd0, - 0x45, 0x75, 0x9e, 0xfc, 0xd7, 0x9c, 0x14, 0xbd, 0x92, 0x77, 0xa9, 0x0f, 0xe1, 0xbc, 0xbc, 0x4b, - 0x89, 0x23, 0x28, 0x36, 0x9b, 0x2f, 0x3d, 0xb8, 0x97, 0x75, 0x8b, 0x42, 0xb4, 0x8c, 0x9b, 0xce, - 0x3a, 0xdd, 0x9f, 0xe2, 0xf2, 0xff, 0x7f, 0x6e, 0x4e, 0xec, 0x29, 0x5c, 0xc4, 0x5c, 0x32, 0x5d, - 0xd5, 0xe0, 0xdf, 0xf1, 0xdd, 0x43, 0x9a, 0x0f, 0xb7, 0x27, 0xee, 0x19, 0x5e, 0x57, 0xa9, 0x8e, - 0xe5, 0x1e, 0xee, 0x9d, 0xb3, 0x36, 0x82, 0x0c, 0x78, 0xfa, 0x52, 0xf6, 0xc7, 0x1a, 0x18, 0x2f, - 0xee, 0x2f, 0xbc, 0x3f, 0xa7, 0x3b, 0x9c, 0xdf, 0x9f, 0x95, 0xde, 0x7b, 0x05, 0x56, 0x7c, 0xf7, - 0xd0, 0x77, 0x83, 0xe3, 0x84, 0x92, 0x6b, 0x99, 0x80, 0xb2, 0x63, 0x64, 0x00, 0xea, 0x97, 0xba, - 0xd5, 0x48, 0x22, 0x63, 0x27, 0xba, 0x6b, 0x67, 0x8e, 0x03, 0x9f, 0x4d, 0x6a, 0x05, 0xc5, 0x8f, - 0x47, 0x85, 0x62, 0x4e, 0xcf, 0x5b, 0x14, 0x26, 0xfb, 0xd0, 0xeb, 0xbb, 0xc6, 0xbf, 0x8b, 0x24, - 0x8b, 0xac, 0xce, 0x63, 0x1f, 0x2a, 0x0f, 0x77, 0xf2, 0x13, 0xf2, 0x4c, 0x16, 0xc9, 0x59, 0x34, - 0x90, 0xb5, 0x2f, 0x49, 0x03, 0xf9, 0x50, 0x7a, 0xff, 0xf2, 0x3d, 0xef, 0xe0, 0x3e, 0xbb, 0x07, - 0x0b, 0xc2, 0xe1, 0x57, 0x56, 0x77, 0x2d, 0x51, 0xdd, 0x83, 0xfb, 0x96, 0x2c, 0x37, 0x3e, 0x8d, - 0xdc, 0x51, 0x26, 0x1a, 0x71, 0x70, 0x9f, 0xbd, 0x7b, 0xb6, 0x87, 0x38, 0x45, 0xf9, 0x10, 0x27, - 0x7a, 0x84, 0xf3, 0x5e, 0xe2, 0x11, 0xce, 0x9d, 0xd9, 0xbd, 0x45, 0x4e, 0x44, 0x22, 0xf4, 0x70, - 0x1c, 0x92, 0xf2, 0x67, 0x39, 0xb8, 0x3e, 0x93, 0x82, 0x5d, 0x83, 0xa2, 0xd9, 0xaa, 0xb6, 0xe3, - 0xf1, 0xe5, 0x6b, 0x46, 0x42, 0xd8, 0x2e, 0x2c, 0x6e, 0x3b, 0x81, 0xd7, 0xe5, 0xd3, 0x38, 0xd3, - 0x58, 0x3e, 0xc1, 0x36, 0x42, 0xdf, 0x3b, 0x67, 0xc5, 0xb4, 0xac, 0x03, 0xeb, 0xb8, 0x16, 0x12, - 0x69, 0x26, 0xf3, 0x19, 0x7a, 0x9a, 0x09, 0x86, 0x13, 0x64, 0x7c, 0x9f, 0x99, 0x00, 0xb2, 0x67, - 0xc0, 0x6c, 0x7b, 0xaf, 0xe4, 0xfa, 0x21, 0xe9, 0x2f, 0x42, 0x2f, 0x7a, 0xd5, 0xf1, 0xd6, 0x0b, - 0xfa, 0x6e, 0x82, 0x6e, 0xef, 0x9c, 0x95, 0xc1, 0x2d, 0xbd, 0xcc, 0x3f, 0x91, 0xf2, 0xce, 0xf4, - 0x4e, 0x78, 0x89, 0xb0, 0xee, 0xaf, 0x41, 0xb1, 0x25, 0x5d, 0x08, 0x95, 0xd7, 0x71, 0xd2, 0x5d, - 0xd0, 0x8a, 0x4a, 0x8d, 0x7f, 0xa8, 0x49, 0x85, 0xcd, 0x8b, 0x3b, 0x4b, 0xc9, 0x02, 0xda, 0x9b, - 0x9d, 0x05, 0xb4, 0xf7, 0x73, 0x66, 0x01, 0x35, 0x3c, 0xb8, 0x77, 0xe6, 0x8e, 0x65, 0xdf, 0x00, - 0x1d, 0x13, 0x26, 0x3a, 0xca, 0x20, 0x89, 0xf5, 0xb5, 0x1e, 0xe5, 0xf9, 0xd8, 0xa3, 0xac, 0xb4, - 0xd6, 0x5a, 0x37, 0x49, 0x6d, 0xfc, 0x11, 0xe5, 0x77, 0xa9, 0xf6, 0x5a, 0x29, 0x93, 0xeb, 0x17, - 0x7d, 0x50, 0x59, 0x49, 0x2c, 0xb6, 0x57, 0x94, 0x4c, 0xd9, 0x93, 0xdf, 0x9a, 0xfe, 0xae, 0x52, - 0x59, 0x79, 0xff, 0x3c, 0x0f, 0xd7, 0x66, 0x91, 0x33, 0x13, 0xf4, 0x4a, 0x2a, 0x87, 0xbe, 0x9a, - 0x6f, 0x6c, 0x22, 0xf9, 0xbe, 0x35, 0x81, 0xce, 0xc7, 0x56, 0xc0, 0xa2, 0xd7, 0x82, 0x38, 0xb6, - 0x44, 0xca, 0xc7, 0x56, 0x16, 0xb3, 0x57, 0x60, 0xde, 0x2c, 0xd9, 0x71, 0x96, 0x56, 0x7c, 0xd6, - 0xe3, 0x74, 0x03, 0x7c, 0x30, 0x42, 0x45, 0xec, 0x37, 0x26, 0x13, 0x13, 0x53, 0x7a, 0xd6, 0xab, - 0x4a, 0x87, 0x4c, 0xa4, 0x5e, 0xc2, 0xfa, 0xc6, 0xa9, 0x82, 0x28, 0xfb, 0x86, 0x35, 0x99, 0xe4, - 0xd8, 0x80, 0xf9, 0x96, 0xef, 0x06, 0x6e, 0xa8, 0x3e, 0xb9, 0x19, 0x21, 0xc4, 0xa2, 0x12, 0x7a, - 0x10, 0xe3, 0x9c, 0x8a, 0xf8, 0x47, 0xf3, 0x6a, 0x4c, 0x3a, 0x7c, 0x41, 0xc3, 0xc1, 0x96, 0x82, - 0xc2, 0x09, 0x6a, 0xce, 0x78, 0xd0, 0x3d, 0xde, 0xb7, 0x6a, 0x24, 0x39, 0x09, 0x82, 0x3e, 0x42, - 0x79, 0x03, 0x03, 0x4b, 0x41, 0x31, 0x7e, 0x47, 0x83, 0x8d, 0xac, 0x76, 0xb0, 0x6b, 0x50, 0x18, - 0x64, 0xe6, 0x60, 0x1e, 0x88, 0xb0, 0x2d, 0x4b, 0x68, 0x99, 0x3b, 0x1c, 0xfa, 0x27, 0x4e, 0xa8, - 0x3e, 0x4c, 0x52, 0xc0, 0x16, 0x5a, 0x12, 0x77, 0xf0, 0x7f, 0x76, 0x53, 0x1e, 0x39, 0xf9, 0x89, - 0xac, 0xcd, 0xf8, 0xc7, 0x30, 0x01, 0xaa, 0xbd, 0x56, 0x73, 0x24, 0x52, 0xff, 0xbc, 0x0d, 0x05, - 0x5e, 0xad, 0xd4, 0xec, 0xe5, 0xf3, 0xc7, 0xac, 0xd7, 0x08, 0x49, 0xd4, 0x2a, 0x70, 0x4e, 0xfa, - 0x16, 0x22, 0x1b, 0x4f, 0x60, 0x35, 0x89, 0xc1, 0x2a, 0xc9, 0xe8, 0xef, 0x4b, 0x0f, 0x74, 0xe2, - 0xb4, 0x3d, 0x1c, 0x8a, 0xc7, 0xb1, 0xdb, 0x97, 0x7f, 0xf6, 0xd9, 0x4d, 0xe0, 0x3f, 0x05, 0x4d, - 0x56, 0x74, 0x78, 0xe3, 0xf7, 0x72, 0xb0, 0x11, 0xc7, 0xe3, 0x91, 0x6b, 0xe8, 0x6f, 0x6c, 0x70, - 0x08, 0x33, 0x11, 0xbc, 0x40, 0xca, 0x8d, 0x93, 0x0d, 0x9c, 0xf1, 0x66, 0x7a, 0x17, 0x36, 0xa7, - 0xe1, 0xb3, 0xd7, 0x61, 0x11, 0x43, 0x38, 0x8e, 0x9c, 0xae, 0xab, 0x6e, 0xb3, 0x03, 0x09, 0xb4, - 0xe2, 0x72, 0xe3, 0x4f, 0x35, 0xb8, 0x42, 0x4f, 0x3a, 0xeb, 0x8e, 0x37, 0x40, 0x43, 0x50, 0xd7, - 0xfd, 0x72, 0x82, 0x9b, 0xec, 0x26, 0xf6, 0xb1, 0x57, 0x93, 0x2f, 0x77, 0x27, 0xbe, 0x36, 0xbd, - 0xb5, 0xec, 0x1e, 0x86, 0x25, 0x25, 0x9f, 0xb2, 0x82, 0x08, 0x26, 0x35, 0xe0, 0x00, 0x35, 0x98, - 0x14, 0x62, 0x18, 0x7f, 0x0f, 0x6e, 0xcc, 0xfe, 0x00, 0xfb, 0x75, 0x58, 0xc1, 0x3c, 0x9b, 0xfb, - 0xa3, 0x23, 0xdf, 0xe9, 0xb9, 0x52, 0x45, 0x28, 0x35, 0xd9, 0x6a, 0x99, 0x88, 0xb2, 0x4a, 0xc1, - 0x8d, 0x8e, 0x30, 0x83, 0x27, 0x11, 0x25, 0xde, 0x4d, 0xab, 0xdc, 0x8c, 0xef, 0x6b, 0xc0, 0x26, - 0x79, 0xb0, 0xaf, 0xc1, 0xf2, 0x7e, 0xbb, 0x64, 0x87, 0x8e, 0x1f, 0xee, 0x0d, 0xc7, 0x3e, 0x85, - 0x38, 0x15, 0xb1, 0x6e, 0xc2, 0x6e, 0x47, 0x98, 0xfc, 0x8e, 0x87, 0x63, 0xdf, 0x4a, 0xe0, 0x61, - 0x3e, 0x47, 0xd7, 0xfd, 0xb8, 0xe7, 0x9c, 0x26, 0xf3, 0x39, 0x12, 0x2c, 0x91, 0xcf, 0x91, 0x60, - 0xc6, 0x8f, 0x34, 0xb8, 0x2a, 0xdf, 0x34, 0xf4, 0x32, 0xea, 0x52, 0xc2, 0x88, 0x6e, 0xbe, 0x8c, - 0xa9, 0x3f, 0x4b, 0x42, 0x5f, 0x97, 0x41, 0x0f, 0xb1, 0x82, 0x28, 0xaa, 0x0b, 0x5a, 0xf6, 0x2b, - 0x50, 0xb0, 0xc3, 0xe1, 0xe8, 0x0c, 0x51, 0x0f, 0xf5, 0x68, 0x44, 0xc3, 0xe1, 0x08, 0x59, 0x20, - 0xa5, 0xe1, 0xc2, 0x86, 0x5a, 0x39, 0x59, 0x63, 0x56, 0x87, 0x05, 0x0a, 0x6f, 0x9b, 0xf2, 0xc2, - 0x9b, 0xd1, 0xa6, 0xed, 0x35, 0x19, 0x5a, 0x91, 0x62, 0xba, 0x5b, 0x92, 0x87, 0xf1, 0x8f, 0x34, - 0x58, 0xe2, 0x82, 0x0d, 0x5e, 0x4a, 0xbf, 0xe8, 0x94, 0x4e, 0xca, 0xc1, 0xd2, 0xa9, 0x34, 0x62, - 0x7f, 0xa6, 0xd3, 0xf8, 0x1d, 0x58, 0x4b, 0x11, 0x30, 0x03, 0x83, 0x6a, 0xf5, 0xbd, 0xae, 0x23, - 0xd2, 0xc3, 0x09, 0x87, 0xcc, 0x04, 0xcc, 0xf8, 0xfb, 0x1a, 0x6c, 0x34, 0x3f, 0x0e, 0x1d, 0x61, - 0x99, 0xb7, 0xc6, 0x7d, 0xb9, 0xde, 0xb9, 0xb0, 0x26, 0x1f, 0xc7, 0x88, 0x80, 0x3f, 0x42, 0x58, - 0x23, 0x98, 0x15, 0x95, 0xb2, 0x3d, 0x28, 0xd2, 0xf9, 0x12, 0x50, 0x28, 0xf6, 0x1b, 0x8a, 0x6e, - 0x24, 0x66, 0x4c, 0x48, 0xbc, 0x25, 0xb8, 0x85, 0x11, 0x8d, 0x15, 0x51, 0x1b, 0x7f, 0xa5, 0xc1, - 0xa5, 0x29, 0x34, 0xec, 0x9b, 0x30, 0x87, 0xc1, 0x08, 0x68, 0xf4, 0xae, 0x4d, 0xf9, 0x44, 0xd8, - 0x3d, 0x3e, 0xb8, 0x2f, 0x0e, 0xa2, 0x13, 0xfe, 0xc3, 0x12, 0x54, 0xec, 0x43, 0x58, 0x34, 0x7b, - 0x3d, 0xba, 0x9d, 0xe5, 0x12, 0xb7, 0xb3, 0x29, 0x5f, 0x7c, 0x33, 0xc2, 0x17, 0xb7, 0x33, 0xf1, - 0x2c, 0xb6, 0xd7, 0xeb, 0x50, 0xa0, 0x85, 0x98, 0xdf, 0x95, 0x6f, 0xc0, 0x6a, 0x12, 0xf9, 0xa5, - 0xde, 0x86, 0x7f, 0xaa, 0x81, 0x9e, 0xac, 0xc3, 0x2f, 0x26, 0x28, 0x64, 0xd6, 0x30, 0xbf, 0x60, - 0x52, 0xfd, 0x93, 0x1c, 0x5c, 0xc8, 0xec, 0x61, 0xf6, 0x06, 0xcc, 0x9b, 0xa3, 0x51, 0xb5, 0x4c, - 0xb3, 0x8a, 0x24, 0x24, 0x54, 0x9e, 0x27, 0x2e, 0xaf, 0x02, 0x89, 0xbd, 0x0d, 0x45, 0xe1, 0x00, - 0x52, 0x96, 0x1b, 0x0e, 0x46, 0xb9, 0x23, 0xef, 0x94, 0x64, 0x50, 0x74, 0x89, 0xc8, 0x76, 0x60, - 0x95, 0xe2, 0xc3, 0xa1, 0x37, 0x50, 0x94, 0x9d, 0x07, 0x1d, 0xa8, 0xa4, 0x46, 0x5e, 0xf8, 0x11, - 0x25, 0xf6, 0xce, 0x14, 0x15, 0xab, 0x81, 0x8e, 0x3c, 0x55, 0x4e, 0x22, 0x32, 0xbb, 0xe2, 0x80, - 0x37, 0x85, 0xd7, 0x04, 0x65, 0x34, 0x5c, 0xc2, 0x09, 0xfe, 0xc4, 0x1d, 0x84, 0xbf, 0xb8, 0xe1, - 0x8a, 0xbf, 0x71, 0xa6, 0xe1, 0xfa, 0xfd, 0x82, 0x58, 0xcc, 0x69, 0x32, 0x2e, 0xd1, 0x28, 0xc9, - 0x38, 0x50, 0xa2, 0xe1, 0xf7, 0x33, 0x8a, 0x80, 0x56, 0x86, 0x05, 0x11, 0x99, 0x4e, 0xae, 0x8c, - 0xeb, 0x99, 0x55, 0x10, 0x38, 0x07, 0xf7, 0x85, 0xf8, 0x22, 0xa2, 0x22, 0x04, 0x96, 0x24, 0x65, - 0x07, 0xb0, 0x54, 0xea, 0xbb, 0xce, 0x60, 0x3c, 0x6a, 0x9f, 0xcd, 0xfa, 0xbc, 0x49, 0x6d, 0x59, - 0xee, 0x0a, 0x32, 0xb4, 0x5a, 0xe3, 0x4e, 0xae, 0x32, 0x62, 0xed, 0xe8, 0xa1, 0x74, 0x01, 0x15, - 0xaf, 0x6f, 0xcd, 0xe8, 0x9f, 0x34, 0x10, 0xe9, 0x92, 0x51, 0x00, 0xe8, 0x25, 0x75, 0x07, 0x56, - 0x6b, 0x4e, 0x10, 0xb6, 0x7d, 0x67, 0x10, 0x60, 0x44, 0xeb, 0x33, 0x44, 0xfc, 0xbc, 0x4a, 0x15, - 0x16, 0x0a, 0xd9, 0x30, 0x22, 0x15, 0x0a, 0xd9, 0x24, 0x3b, 0x2e, 0x2f, 0xed, 0x78, 0x03, 0xa7, - 0xef, 0x7d, 0x4f, 0xc6, 0x93, 0x10, 0xf2, 0xd2, 0xa1, 0x04, 0x5a, 0x71, 0xb9, 0xf1, 0x6b, 0x13, - 0xe3, 0x26, 0x6a, 0xb9, 0x04, 0x0b, 0x14, 0x6d, 0x48, 0x44, 0xdf, 0x69, 0x55, 0x1a, 0xe5, 0x6a, - 0x63, 0x57, 0xd7, 0xd8, 0x2a, 0x40, 0xcb, 0x6a, 0x96, 0x2a, 0xb6, 0xcd, 0x7f, 0xe7, 0xf8, 0x6f, - 0x0a, 0xcd, 0xb3, 0xb3, 0x5f, 0xd3, 0xf3, 0x4a, 0x74, 0x9e, 0x82, 0xf1, 0x27, 0x1a, 0x5c, 0xcc, - 0x1e, 0x4a, 0xd6, 0x06, 0x8c, 0xcf, 0x44, 0x7e, 0x08, 0x5f, 0x9b, 0x39, 0xee, 0x99, 0xe0, 0x74, - 0x9c, 0xa7, 0x50, 0xc4, 0x0f, 0xca, 0x49, 0x1b, 0x9a, 0x08, 0x48, 0xe0, 0xf5, 0xac, 0x9c, 0xd7, - 0x33, 0x4a, 0xb0, 0x39, 0x8d, 0x47, 0xb2, 0xa9, 0x6b, 0xb0, 0x64, 0xb6, 0x5a, 0xb5, 0x6a, 0xc9, - 0x6c, 0x57, 0x9b, 0x0d, 0x5d, 0x63, 0x8b, 0x30, 0xb7, 0x6b, 0x35, 0xf7, 0x5b, 0x7a, 0xce, 0xf8, - 0xa1, 0x06, 0x2b, 0xd5, 0xd8, 0x43, 0xf2, 0x8b, 0x2e, 0xbe, 0xaf, 0x27, 0x16, 0xdf, 0x66, 0x14, - 0xc9, 0x2c, 0xfa, 0xc0, 0x99, 0x56, 0xde, 0xe7, 0x39, 0x58, 0x9f, 0xa0, 0x61, 0x36, 0x2c, 0x98, - 0x4f, 0xec, 0x66, 0xb5, 0x5c, 0xa2, 0x9a, 0xdd, 0x8c, 0x3d, 0xe2, 0x30, 0xb7, 0xe5, 0xc4, 0x57, - 0x44, 0xf4, 0x8f, 0xe7, 0x41, 0x67, 0xe8, 0xf5, 0xba, 0x09, 0x97, 0x4c, 0xc9, 0x09, 0x4f, 0xb2, - 0xef, 0x8d, 0x7d, 0xf4, 0x32, 0xa5, 0x5a, 0x47, 0x8e, 0x76, 0x12, 0x3e, 0xc9, 0x18, 0xfd, 0x2e, - 0x1d, 0x5e, 0x3e, 0xc9, 0x3a, 0xe6, 0xc7, 0x1a, 0x30, 0xbf, 0xeb, 0x85, 0x7b, 0xe3, 0x67, 0xb4, - 0x7e, 0x6f, 0xc4, 0x99, 0x0e, 0xf7, 0xc6, 0xcf, 0x26, 0xd9, 0xa2, 0xca, 0x52, 0x44, 0xea, 0x4b, - 0xb0, 0x24, 0x2e, 0xe9, 0x80, 0x05, 0x85, 0x97, 0x0a, 0x58, 0xb0, 0xbd, 0x02, 0x4b, 0x74, 0x87, - 0xc2, 0xeb, 0xc9, 0x4f, 0x34, 0xd8, 0x9c, 0xd6, 0x73, 0xfc, 0x5a, 0x96, 0x0c, 0x4c, 0x74, 0x31, - 0x4a, 0x85, 0x95, 0x74, 0xe5, 0x95, 0x68, 0xec, 0x03, 0x58, 0x12, 0xee, 0x5e, 0xf6, 0xdb, 0xfb, - 0x56, 0x95, 0xa6, 0xeb, 0xf5, 0xbf, 0xfc, 0xec, 0xe6, 0x25, 0xf2, 0x10, 0x0b, 0xde, 0xee, 0x8c, - 0x7d, 0x2f, 0x91, 0x36, 0x48, 0xa5, 0xe0, 0x52, 0xb4, 0x33, 0xee, 0x79, 0xae, 0xbc, 0x43, 0xc8, - 0xe0, 0x2d, 0x04, 0x53, 0xcf, 0x34, 0x09, 0x33, 0x7e, 0xa0, 0xc1, 0x95, 0xe9, 0xc3, 0xc4, 0xcf, - 0xc9, 0xb6, 0xf0, 0x9a, 0x93, 0xe1, 0x53, 0xf0, 0x9c, 0x8c, 0x5c, 0xeb, 0x54, 0x9e, 0x12, 0x91, - 0x13, 0x91, 0x86, 0x4b, 0x2a, 0x49, 0x90, 0x28, 0x52, 0x80, 0xa9, 0x44, 0x12, 0xd1, 0x78, 0x0a, - 0x97, 0xa6, 0x0c, 0x2a, 0x7b, 0x3f, 0x33, 0xc1, 0x1e, 0xbe, 0x2e, 0x56, 0x13, 0xec, 0x25, 0x32, - 0xb5, 0x2a, 0x70, 0xe3, 0xbf, 0xe7, 0xe0, 0x22, 0x5f, 0x5d, 0x7d, 0x37, 0x08, 0xcc, 0x38, 0x17, - 0x3d, 0xdf, 0x15, 0xdf, 0x85, 0xf9, 0xe3, 0x97, 0x53, 0x15, 0x0b, 0x74, 0xc6, 0x00, 0x4f, 0x2c, - 0xf9, 0xa6, 0x95, 0xff, 0xcf, 0x6e, 0x83, 0x8c, 0x09, 0xc2, 0x65, 0xad, 0x3c, 0x86, 0x32, 0xcf, - 0x6d, 0x6a, 0xd6, 0xa2, 0x80, 0x3e, 0x76, 0x4f, 0xd9, 0x7b, 0x30, 0x87, 0xfa, 0x14, 0x3a, 0x3b, - 0xa4, 0xcc, 0x9f, 0x5d, 0x3b, 0xd4, 0xb6, 0x58, 0x82, 0x80, 0x7d, 0x15, 0x20, 0xce, 0x02, 0x45, - 0x87, 0x83, 0xd4, 0x33, 0x44, 0x89, 0xa0, 0xac, 0xc5, 0x93, 0x43, 0x87, 0x52, 0x2b, 0x6d, 0xc1, - 0xba, 0xec, 0xf1, 0x91, 0x8c, 0x80, 0x4c, 0x56, 0xcc, 0x35, 0x51, 0x50, 0x1d, 0xc9, 0x28, 0xc8, - 0x77, 0x60, 0x35, 0x08, 0x8e, 0x3b, 0x4a, 0xed, 0x31, 0x11, 0x82, 0xb5, 0x1c, 0x04, 0xc7, 0xad, - 0xa8, 0xf2, 0x77, 0x60, 0x15, 0xdd, 0x35, 0x63, 0xac, 0xa2, 0xc0, 0x0a, 0xfb, 0x41, 0x84, 0x65, - 0xfc, 0x97, 0x1c, 0x2c, 0x3e, 0xe1, 0x52, 0x19, 0xea, 0x1a, 0x66, 0xeb, 0x2e, 0x1e, 0xc0, 0x52, - 0x6d, 0xe8, 0x90, 0xb9, 0x88, 0x9e, 0x82, 0x0a, 0x6f, 0xee, 0xfe, 0xd0, 0x91, 0x96, 0xa7, 0xc0, - 0x52, 0x91, 0x5e, 0x10, 0x7b, 0xe6, 0x11, 0xcc, 0x0b, 0xf3, 0x1d, 0xa9, 0xd1, 0xa4, 0x5c, 0x1e, - 0xd5, 0xe8, 0x4d, 0x51, 0xac, 0x58, 0x38, 0x84, 0x09, 0x50, 0x15, 0x12, 0xc9, 0x73, 0x5b, 0xd1, - 0xac, 0xcc, 0x9d, 0x4d, 0xb3, 0xa2, 0xc4, 0xad, 0x9d, 0x3f, 0x4b, 0xdc, 0xda, 0x2b, 0x0f, 0x61, - 0x49, 0xa9, 0xcf, 0x4b, 0x89, 0xe9, 0xbf, 0x95, 0x83, 0x15, 0x6c, 0x55, 0xe4, 0x14, 0xf4, 0x37, - 0x53, 0x4f, 0xf4, 0xf5, 0x84, 0x9e, 0x68, 0x53, 0x1d, 0x2f, 0xd1, 0xb2, 0x19, 0x0a, 0xa2, 0x47, - 0xb0, 0x3e, 0x81, 0xc8, 0xde, 0x81, 0x39, 0x5e, 0x7d, 0x79, 0xaf, 0xd6, 0xd3, 0x33, 0x20, 0xce, - 0x71, 0xc0, 0x1b, 0x1e, 0x58, 0x02, 0xdb, 0xf8, 0x9f, 0x1a, 0x2c, 0x53, 0x8a, 0xb1, 0xc1, 0xe1, - 0xf0, 0x85, 0xdd, 0x79, 0x37, 0xdd, 0x9d, 0x22, 0x92, 0x1a, 0x75, 0xe7, 0xff, 0xed, 0x4e, 0x7c, - 0x98, 0xe8, 0xc4, 0x4b, 0x51, 0xc4, 0x63, 0xd9, 0x9c, 0x19, 0x7d, 0xf8, 0x63, 0xcc, 0x01, 0x90, - 0x44, 0x64, 0xbf, 0x01, 0x8b, 0x0d, 0xf7, 0x79, 0xe2, 0x7a, 0x7a, 0x77, 0x0a, 0xd3, 0x37, 0x23, - 0x44, 0xb1, 0xa6, 0xc4, 0x8b, 0x0a, 0xf7, 0x79, 0x67, 0xc2, 0x72, 0x18, 0xb3, 0xe4, 0x37, 0xd4, - 0x24, 0xd9, 0xcb, 0x4c, 0x7d, 0x8a, 0x4b, 0x81, 0xc1, 0x01, 0x7f, 0x27, 0x0f, 0x10, 0x3f, 0xe9, - 0xe7, 0x0b, 0x30, 0xe1, 0x34, 0x21, 0x35, 0xfb, 0x08, 0x52, 0xe7, 0xb8, 0xf4, 0xa5, 0xb8, 0x4b, - 0x1a, 0xe8, 0xdc, 0xf4, 0x88, 0xd4, 0xa8, 0x8b, 0x2e, 0xd1, 0x1b, 0xf2, 0x9e, 0xdb, 0x77, 0xc4, - 0xde, 0x9e, 0xdf, 0xbe, 0x83, 0x09, 0x08, 0x22, 0x68, 0x22, 0x5c, 0x70, 0xb1, 0x3c, 0xa6, 0x24, - 0x25, 0xf8, 0xd2, 0xbc, 0xcc, 0x11, 0x26, 0xc2, 0x64, 0x14, 0x5e, 0x2e, 0x4c, 0x46, 0x0b, 0x16, - 0xbd, 0xc1, 0x27, 0xee, 0x20, 0x1c, 0xfa, 0xa7, 0xa8, 0x76, 0x8f, 0xf5, 0x79, 0xbc, 0x0b, 0xaa, - 0xb2, 0x4c, 0x8c, 0x03, 0x9e, 0xb9, 0x11, 0xbe, 0x3a, 0x0c, 0x11, 0x30, 0x0a, 0xf3, 0x31, 0xa7, - 0xcf, 0x3f, 0x2a, 0x14, 0xe7, 0xf5, 0x85, 0x47, 0x85, 0x62, 0x51, 0x5f, 0x7c, 0x54, 0x28, 0x2e, - 0xea, 0x60, 0x29, 0x36, 0xb3, 0xc8, 0x26, 0xa6, 0x98, 0xb1, 0x92, 0x26, 0x2a, 0xe3, 0xaf, 0x73, - 0xc0, 0x26, 0xab, 0xc1, 0xbe, 0x0e, 0x4b, 0x62, 0x83, 0xed, 0xf8, 0xc1, 0x77, 0xe8, 0x45, 0x89, - 0x78, 0x06, 0xa6, 0x80, 0xd5, 0x10, 0x8b, 0x02, 0x6c, 0x05, 0xdf, 0xe9, 0xb3, 0x5f, 0x87, 0xf3, - 0xd8, 0xbd, 0x23, 0xd7, 0xf7, 0x86, 0xbd, 0x0e, 0xc6, 0xc3, 0x77, 0xfa, 0x94, 0x06, 0xfa, 0x8d, - 0xbf, 0xfc, 0xec, 0xe6, 0xf5, 0x8c, 0xe2, 0x29, 0xc3, 0x80, 0x2f, 0xf7, 0x5b, 0x88, 0xd9, 0x12, - 0x88, 0xac, 0x0d, 0xba, 0x4a, 0x7f, 0x38, 0xee, 0xf7, 0x69, 0x64, 0xb7, 0xf8, 0x8d, 0x3e, 0x5d, - 0x36, 0x85, 0xf1, 0x6a, 0xcc, 0x78, 0x67, 0xdc, 0xef, 0xb3, 0x77, 0x01, 0x86, 0x83, 0xce, 0x89, - 0x17, 0x04, 0xc2, 0x98, 0x13, 0xbd, 0x32, 0x8a, 0xa1, 0xea, 0x60, 0x0c, 0x07, 0x75, 0x01, 0x64, - 0x7f, 0x07, 0x30, 0x32, 0x13, 0x86, 0x2c, 0x13, 0xde, 0x48, 0x94, 0xa9, 0x4d, 0x02, 0x93, 0x31, - 0x4d, 0x8e, 0x5c, 0xdb, 0xfb, 0x9e, 0x7c, 0x8c, 0xf5, 0x6d, 0x58, 0x27, 0xc7, 0xeb, 0x27, 0x5e, - 0x78, 0x4c, 0x57, 0x89, 0x2f, 0x72, 0x0f, 0x51, 0xee, 0x12, 0x7f, 0x5e, 0x00, 0x30, 0x9f, 0xd8, - 0x32, 0x1a, 0xe8, 0x3d, 0x98, 0xe3, 0x17, 0x24, 0xa9, 0x68, 0x41, 0x35, 0x35, 0xf2, 0x55, 0xd5, - 0xd4, 0x88, 0xc1, 0x57, 0xa3, 0x85, 0xef, 0x26, 0xa4, 0x92, 0x05, 0x57, 0xa3, 0x78, 0x4a, 0x91, - 0xc8, 0xc6, 0x40, 0x58, 0xac, 0x06, 0x10, 0xc7, 0xe7, 0x24, 0x91, 0x7f, 0x3d, 0x0e, 0x74, 0x47, - 0x05, 0x94, 0x11, 0x2a, 0x7e, 0x1c, 0xa7, 0x4e, 0x9f, 0x18, 0x8d, 0x3d, 0x86, 0x42, 0xdb, 0x89, - 0x42, 0x68, 0x4c, 0x89, 0x5a, 0x7a, 0x8b, 0xd2, 0x74, 0xc7, 0x91, 0x4b, 0x57, 0x43, 0xe7, 0x48, - 0xad, 0x1d, 0x32, 0x61, 0x15, 0x98, 0x6f, 0x39, 0xbe, 0x73, 0x12, 0x4c, 0x8b, 0x76, 0x2d, 0x4a, - 0x65, 0x8e, 0x0b, 0x04, 0xaa, 0x32, 0x85, 0x28, 0x66, 0x0f, 0x20, 0x6f, 0xdb, 0x75, 0x8a, 0xd5, - 0xb5, 0x12, 0x5f, 0xbf, 0x6c, 0xbb, 0x2e, 0xec, 0xbe, 0x41, 0x70, 0xa2, 0x90, 0x71, 0x64, 0xf6, - 0xcb, 0xb0, 0xa4, 0x08, 0xc5, 0x14, 0xe5, 0x0e, 0xfb, 0x40, 0x79, 0x99, 0xa7, 0x6e, 0x1a, 0x0a, - 0x36, 0xab, 0x81, 0xfe, 0x78, 0xfc, 0xcc, 0x35, 0x47, 0x23, 0x0c, 0x0a, 0xf0, 0x89, 0xeb, 0x0b, - 0xb1, 0xad, 0x18, 0xa7, 0x87, 0xc0, 0x67, 0x30, 0x3d, 0x59, 0xaa, 0x2a, 0x9b, 0xd2, 0x94, 0xac, - 0x05, 0xeb, 0xb6, 0x1b, 0x8e, 0x47, 0xc2, 0xbf, 0x66, 0x67, 0xe8, 0xf3, 0xfb, 0x8d, 0x88, 0x89, - 0x87, 0x91, 0xf4, 0x03, 0x5e, 0x28, 0x9d, 0x9a, 0x0e, 0x87, 0x7e, 0xea, 0xae, 0x33, 0x49, 0x6c, - 0xb8, 0xea, 0x90, 0xf3, 0x53, 0x35, 0x79, 0x6b, 0xc2, 0x53, 0x55, 0xde, 0x9a, 0xe2, 0xbb, 0xd2, - 0x57, 0x33, 0xe2, 0xb6, 0xa2, 0x65, 0x50, 0x89, 0xdb, 0x9a, 0x88, 0xd6, 0xfa, 0xa3, 0x82, 0x12, - 0x3a, 0x9c, 0xc6, 0xe2, 0x9b, 0x00, 0x8f, 0x86, 0xde, 0xa0, 0xee, 0x86, 0xc7, 0xc3, 0x9e, 0xf2, - 0xee, 0x72, 0xe9, 0xa3, 0xa1, 0x37, 0xe8, 0x9c, 0x20, 0xf8, 0xaf, 0x3f, 0xbb, 0xa9, 0x20, 0x59, - 0xca, 0xff, 0xec, 0x2b, 0xb0, 0xc8, 0x7f, 0xb5, 0x63, 0x2f, 0x21, 0xa1, 0x93, 0x45, 0x6a, 0x91, - 0x60, 0x2b, 0x46, 0x60, 0x0f, 0x31, 0xa5, 0x9c, 0x37, 0x0a, 0x15, 0xe1, 0x55, 0xe6, 0x8f, 0xf3, - 0x46, 0x61, 0xfa, 0xd1, 0xa5, 0x82, 0xcc, 0xf6, 0xa2, 0xaa, 0xcb, 0x2c, 0x90, 0x94, 0xb9, 0x8e, - 0x5e, 0x6e, 0x62, 0x51, 0x47, 0x86, 0xa1, 0x57, 0x5f, 0x6e, 0xa6, 0xc8, 0xb0, 0x12, 0xf6, 0x5e, - 0x59, 0x58, 0x8a, 0x48, 0xa8, 0x15, 0x95, 0x08, 0x8e, 0x7b, 0x9d, 0x2e, 0x82, 0x13, 0x95, 0x88, - 0x90, 0xd9, 0x36, 0xac, 0x09, 0x19, 0x3f, 0xca, 0x26, 0x4d, 0x22, 0x2e, 0xee, 0x6d, 0x71, 0xba, - 0x69, 0xf5, 0xf3, 0x29, 0x02, 0xb6, 0x03, 0x73, 0x78, 0xd7, 0xa4, 0x67, 0x15, 0x57, 0x55, 0x35, - 0x41, 0x7a, 0x1d, 0xe1, 0xbe, 0x82, 0x0a, 0x02, 0x75, 0x5f, 0x41, 0x54, 0xf6, 0xab, 0x00, 0x95, - 0x81, 0x3f, 0xec, 0xf7, 0x31, 0x51, 0x42, 0x31, 0xf1, 0xc0, 0x9b, 0xf8, 0x20, 0x97, 0x18, 0x89, - 0x82, 0xfa, 0xe2, 0xef, 0x4e, 0x2a, 0x9d, 0x82, 0xc2, 0xcb, 0xa8, 0xc2, 0xbc, 0x58, 0x8c, 0x98, - 0x74, 0x84, 0xd2, 0xa8, 0x29, 0x29, 0x2b, 0x44, 0xd2, 0x11, 0x82, 0x4f, 0x26, 0x1d, 0x51, 0x08, - 0x8c, 0xc7, 0xb0, 0x91, 0xd5, 0xb0, 0xc4, 0xed, 0x58, 0x3b, 0xeb, 0xed, 0xf8, 0x0f, 0xf3, 0xb0, - 0x8c, 0xdc, 0xe4, 0x2e, 0x6c, 0xc2, 0x8a, 0x3d, 0x7e, 0x16, 0x45, 0xe4, 0x94, 0xbb, 0x31, 0xd6, - 0x2f, 0x50, 0x0b, 0x54, 0x1b, 0x5e, 0x82, 0x82, 0x55, 0x60, 0x55, 0x9e, 0x04, 0xbb, 0xf2, 0x09, - 0x42, 0x94, 0xef, 0x43, 0xbe, 0xcc, 0x98, 0xcc, 0xa6, 0x9f, 0x22, 0x8a, 0xcf, 0x83, 0xfc, 0xcb, - 0x9c, 0x07, 0x85, 0x33, 0x9d, 0x07, 0x1f, 0xc2, 0xb2, 0xfc, 0x1a, 0xee, 0xe4, 0x73, 0x5f, 0x6c, - 0x27, 0x4f, 0x30, 0x63, 0xb5, 0x68, 0x47, 0x9f, 0x9f, 0xb9, 0xa3, 0xa3, 0x61, 0x54, 0xae, 0xb2, - 0x11, 0xc2, 0x26, 0x37, 0x76, 0x4c, 0x37, 0xbd, 0x5b, 0x6a, 0xfd, 0x1c, 0xa7, 0xe4, 0x3b, 0xb0, - 0x58, 0x1b, 0x4a, 0x9b, 0x98, 0x62, 0x8c, 0xe8, 0x4b, 0xa0, 0x2a, 0x2e, 0x44, 0x98, 0xd1, 0xe9, - 0x96, 0xff, 0x32, 0x4e, 0xb7, 0x87, 0x00, 0xf4, 0xb6, 0x25, 0x4e, 0x13, 0x8b, 0x4b, 0x46, 0x06, - 0x16, 0x4b, 0xda, 0x44, 0x14, 0x64, 0xbe, 0x3b, 0x91, 0xbb, 0x8d, 0x0c, 0x43, 0x40, 0x79, 0x1b, - 0x71, 0x77, 0x92, 0xb1, 0x1c, 0x64, 0x64, 0x03, 0x75, 0x7b, 0x48, 0x91, 0x7d, 0xb9, 0x03, 0xc2, - 0xbe, 0x15, 0x39, 0x3f, 0x2e, 0xcc, 0xea, 0x21, 0x63, 0xa2, 0x87, 0xa6, 0xba, 0x3c, 0x1a, 0x7f, - 0xa2, 0xa9, 0xc9, 0x96, 0x7e, 0x8e, 0xa1, 0x7e, 0x0f, 0x20, 0x72, 0x4a, 0x90, 0x63, 0x1d, 0xbd, - 0x40, 0x17, 0x50, 0xb5, 0x97, 0x63, 0x5c, 0xa5, 0x35, 0xf9, 0x2f, 0xab, 0x35, 0x6d, 0x58, 0x6a, - 0x7e, 0x1c, 0x3a, 0xb1, 0x17, 0x0b, 0xd8, 0x91, 0x24, 0x8b, 0x3b, 0x53, 0x7e, 0xfb, 0x55, 0x3c, - 0x1b, 0x62, 0x39, 0x78, 0x8a, 0x08, 0xac, 0x10, 0x1a, 0xff, 0x5b, 0x83, 0x35, 0x35, 0x08, 0xcd, - 0xe9, 0xa0, 0xcb, 0xde, 0x17, 0xb1, 0xdf, 0xb5, 0xc4, 0x95, 0x45, 0x41, 0xe2, 0x5b, 0xee, 0xe9, - 0xa0, 0x2b, 0x04, 0x20, 0xe7, 0xb9, 0x5a, 0x59, 0x4e, 0xc8, 0x9e, 0xc1, 0x72, 0x6b, 0xd8, 0xef, - 0x73, 0xb1, 0xc6, 0xff, 0x84, 0x2e, 0x00, 0x9c, 0x51, 0xda, 0x34, 0x22, 0x2b, 0xb4, 0xfd, 0x0a, - 0xdd, 0x73, 0x2f, 0x8d, 0xf8, 0x7e, 0xef, 0x11, 0x5d, 0xcc, 0xf6, 0x53, 0x7c, 0x63, 0xa8, 0xf2, - 0x8c, 0xcf, 0xa6, 0x64, 0xd2, 0x20, 0xb5, 0x96, 0xbc, 0x18, 0xeb, 0x39, 0xe3, 0x6c, 0x32, 0xfe, - 0x4c, 0x03, 0x36, 0xd9, 0x34, 0x75, 0xeb, 0xd3, 0xfe, 0x1f, 0x88, 0xc2, 0x29, 0x11, 0xb2, 0xf0, - 0x32, 0x22, 0xa4, 0xf1, 0x07, 0x1a, 0x6c, 0x64, 0xf5, 0x03, 0x3f, 0x41, 0xd4, 0x23, 0x25, 0x3a, - 0xd0, 0xf0, 0x04, 0x51, 0x4f, 0xa1, 0xe4, 0xb1, 0x96, 0x22, 0x4a, 0x57, 0x2e, 0xf7, 0x32, 0x95, - 0xdb, 0xfa, 0xc7, 0x1a, 0xac, 0x55, 0xcd, 0x3a, 0xe5, 0x98, 0x12, 0x66, 0xaa, 0xdb, 0x70, 0xbd, - 0x6a, 0xd6, 0x3b, 0xad, 0x66, 0xad, 0x5a, 0x7a, 0xda, 0xc9, 0x4c, 0x1d, 0x71, 0x1d, 0x2e, 0x4f, - 0xa2, 0xc4, 0xe6, 0xac, 0x6b, 0xb0, 0x39, 0x59, 0x2c, 0xd3, 0x4b, 0x64, 0x13, 0xcb, 0x4c, 0x14, - 0xf9, 0xad, 0x0f, 0x60, 0x4d, 0xa6, 0x52, 0x68, 0xd7, 0x6c, 0x4c, 0xd6, 0xb4, 0x06, 0x4b, 0x07, - 0x15, 0xab, 0xba, 0xf3, 0xb4, 0xb3, 0xb3, 0x5f, 0xab, 0xe9, 0xe7, 0xd8, 0x0a, 0x2c, 0x12, 0xa0, - 0x64, 0xea, 0x1a, 0x5b, 0x86, 0x62, 0xb5, 0x61, 0x57, 0x4a, 0xfb, 0x56, 0x45, 0xcf, 0x6d, 0xfd, - 0x0b, 0x0d, 0x56, 0xf6, 0x47, 0x3d, 0x27, 0x74, 0x7d, 0x6a, 0xd1, 0x0d, 0xb8, 0xb2, 0xdf, 0x2a, - 0x9b, 0xed, 0x8a, 0x95, 0xdd, 0x9c, 0x0b, 0xb0, 0x9e, 0x2a, 0x6f, 0x3e, 0xd6, 0x35, 0x76, 0x15, - 0x2e, 0xa5, 0xc0, 0xe5, 0xaa, 0x6d, 0x6e, 0x8b, 0x56, 0x5c, 0x86, 0x0b, 0xa9, 0xc2, 0x56, 0xb5, - 0xd1, 0xa8, 0x94, 0xf5, 0x3c, 0x6f, 0xe0, 0xc4, 0xe7, 0xac, 0x8a, 0x59, 0xe6, 0xa4, 0x7a, 0x61, - 0xeb, 0x03, 0x58, 0x6d, 0xf9, 0xde, 0x27, 0x4e, 0xe8, 0x3e, 0x76, 0x4f, 0xd1, 0x5a, 0xb6, 0x00, - 0x79, 0xcb, 0x7c, 0xa2, 0x9f, 0x63, 0x00, 0xf3, 0xad, 0xc7, 0x25, 0xfb, 0xfe, 0x7d, 0x5d, 0x63, - 0x4b, 0xb0, 0xb0, 0x5b, 0x6a, 0x75, 0x1e, 0xd7, 0x6d, 0x3d, 0xc7, 0x7f, 0x98, 0x4f, 0x6c, 0xfc, - 0x91, 0xdf, 0x7a, 0x0b, 0xd6, 0x51, 0x2a, 0xac, 0x79, 0x41, 0xe8, 0x0e, 0x5c, 0x1f, 0xfb, 0x68, - 0x19, 0x8a, 0xb6, 0xcb, 0xb7, 0xf3, 0xd0, 0x15, 0x1d, 0x54, 0x1f, 0xf7, 0x43, 0x6f, 0xd4, 0x77, - 0xbf, 0xab, 0x6b, 0x5b, 0x0f, 0x61, 0xcd, 0x1a, 0x8e, 0x43, 0x6f, 0x70, 0x64, 0x87, 0x1c, 0xe3, - 0xe8, 0x14, 0xdb, 0xdc, 0x30, 0xeb, 0xdb, 0xd5, 0xdd, 0xfd, 0xe6, 0xbe, 0xdd, 0xa9, 0x9b, 0xed, - 0xd2, 0x9e, 0xb0, 0xd5, 0xd5, 0x9b, 0x76, 0xbb, 0x63, 0x55, 0x4a, 0x95, 0x46, 0x5b, 0xd7, 0xb6, - 0x7e, 0x0f, 0x15, 0x5c, 0xdd, 0xe1, 0xa0, 0xb7, 0xe3, 0x74, 0xc3, 0xa1, 0x8f, 0x15, 0x36, 0xe0, - 0x86, 0x5d, 0x29, 0x35, 0x1b, 0xe5, 0xce, 0x8e, 0x59, 0x6a, 0x37, 0xad, 0xac, 0xdc, 0x2a, 0x57, - 0xe0, 0x62, 0x06, 0x4e, 0xb3, 0xdd, 0xd2, 0x35, 0x76, 0x13, 0xae, 0x66, 0x94, 0x3d, 0xa9, 0x6c, - 0x9b, 0xfb, 0xed, 0xbd, 0x86, 0x9e, 0x9b, 0x42, 0x6c, 0xdb, 0x4d, 0x3d, 0xbf, 0xf5, 0x0f, 0x34, - 0x58, 0xdd, 0x0f, 0xc8, 0xef, 0x7f, 0x1f, 0x9f, 0x4b, 0xdf, 0x82, 0x6b, 0xfb, 0x76, 0xc5, 0xea, - 0xb4, 0x9b, 0x8f, 0x2b, 0x8d, 0xce, 0xbe, 0x6d, 0xee, 0xa6, 0x6b, 0x73, 0x13, 0xae, 0x2a, 0x18, - 0x56, 0xa5, 0xd4, 0x3c, 0xa8, 0x58, 0x9d, 0x96, 0x69, 0xdb, 0x4f, 0x9a, 0x56, 0x59, 0xd7, 0xf8, - 0x17, 0x33, 0x10, 0xea, 0x3b, 0xa6, 0xa8, 0x4d, 0xa2, 0xac, 0x51, 0x79, 0x62, 0xd6, 0x3a, 0xdb, - 0xcd, 0xb6, 0x9e, 0xdf, 0xaa, 0x73, 0x21, 0x0b, 0x33, 0x1c, 0x08, 0xf7, 0xce, 0x22, 0x14, 0x1a, - 0xcd, 0x46, 0x25, 0x6d, 0xe1, 0x5d, 0x86, 0xa2, 0xd9, 0x6a, 0x59, 0xcd, 0x03, 0x9c, 0x3c, 0x00, - 0xf3, 0xe5, 0x4a, 0xa3, 0x8a, 0xb3, 0x65, 0x19, 0x8a, 0x2d, 0xab, 0x59, 0x6f, 0xb6, 0x2b, 0x65, - 0xbd, 0xb0, 0x65, 0xc9, 0xfd, 0x4f, 0x32, 0xed, 0x0e, 0x85, 0x39, 0xb5, 0x5c, 0xd9, 0x31, 0xf7, - 0x6b, 0x6d, 0x1a, 0xa2, 0xa7, 0x1d, 0xab, 0xf2, 0xad, 0xfd, 0x8a, 0xdd, 0xb6, 0x75, 0x8d, 0xe9, - 0xb0, 0xdc, 0xa8, 0x54, 0xca, 0x76, 0xc7, 0xaa, 0x1c, 0x54, 0x2b, 0x4f, 0xf4, 0x1c, 0xe7, 0x29, - 0xfe, 0xe7, 0x5f, 0xd8, 0xfa, 0x91, 0x06, 0x4c, 0x64, 0x87, 0x90, 0x29, 0x07, 0x71, 0xc6, 0xdc, - 0x80, 0x2b, 0x7b, 0x7c, 0xa8, 0xb1, 0x69, 0xf5, 0x66, 0x39, 0xdd, 0x65, 0x17, 0x81, 0xa5, 0xca, - 0x9b, 0x3b, 0x3b, 0xb8, 0x2c, 0xce, 0xa7, 0xe0, 0x65, 0xab, 0xd9, 0xd2, 0x73, 0x57, 0x72, 0x45, - 0x8d, 0x5d, 0x9a, 0x28, 0x7c, 0x5c, 0xa9, 0xb4, 0xf4, 0x3c, 0x1f, 0xa2, 0x54, 0x81, 0x5c, 0xb2, - 0x82, 0xbc, 0xb0, 0xf5, 0x03, 0x0d, 0x2e, 0x8a, 0x6a, 0xca, 0xf5, 0x1f, 0x55, 0xf5, 0x1a, 0x6c, - 0x52, 0xce, 0x9b, 0xac, 0x8a, 0x6e, 0x80, 0x9e, 0x28, 0x15, 0xd5, 0xbc, 0x00, 0xeb, 0x09, 0x28, - 0xd6, 0x23, 0xc7, 0x77, 0xb7, 0x04, 0x78, 0xbb, 0x62, 0xb7, 0x3b, 0x95, 0x9d, 0x9d, 0xa6, 0xd5, - 0x16, 0x15, 0xc9, 0x6f, 0x19, 0xb0, 0x5e, 0x72, 0xfd, 0x90, 0xdf, 0x7f, 0x07, 0x81, 0x37, 0x1c, - 0x60, 0x15, 0x56, 0x60, 0xb1, 0xf2, 0xab, 0xed, 0x4a, 0xc3, 0xae, 0x36, 0x1b, 0xfa, 0xb9, 0xad, - 0x6b, 0x29, 0x1c, 0xb9, 0x8e, 0x6d, 0x7b, 0x4f, 0x3f, 0xb7, 0xe5, 0xc0, 0x8a, 0xf4, 0x7e, 0x17, - 0xb3, 0xe2, 0x06, 0x5c, 0x91, 0x73, 0x0d, 0xf7, 0x84, 0x74, 0x13, 0x36, 0x61, 0x63, 0xb2, 0xbc, - 0xd2, 0xd6, 0x35, 0x3e, 0x0a, 0xa9, 0x12, 0x0e, 0xcf, 0x6d, 0xfd, 0xb6, 0x06, 0x2b, 0x91, 0xe5, - 0x0a, 0x75, 0xe5, 0x37, 0xe1, 0x6a, 0x7d, 0xc7, 0xec, 0x94, 0x2b, 0x07, 0xd5, 0x52, 0xa5, 0xf3, - 0xb8, 0xda, 0x28, 0xa7, 0x3e, 0x72, 0x19, 0x2e, 0x64, 0x20, 0xe0, 0x57, 0x36, 0x61, 0x23, 0x5d, - 0xd4, 0xe6, 0x4b, 0x35, 0xc7, 0xbb, 0x3e, 0x5d, 0x12, 0xad, 0xd3, 0xfc, 0xd6, 0x01, 0xac, 0xda, - 0x66, 0xbd, 0xb6, 0x33, 0xf4, 0xbb, 0xae, 0x39, 0x0e, 0x8f, 0x07, 0x7c, 0xd3, 0xdc, 0x69, 0x5a, - 0xa5, 0x4a, 0x07, 0x51, 0x52, 0x35, 0x38, 0x0f, 0x6b, 0x6a, 0xe1, 0xd3, 0x0a, 0x9f, 0xbe, 0x0c, - 0x56, 0x55, 0x60, 0xa3, 0xa9, 0xe7, 0xb6, 0x7e, 0x0d, 0x96, 0x13, 0x99, 0x87, 0x2f, 0xc1, 0x79, - 0xf5, 0x77, 0xcb, 0x1d, 0xf4, 0xbc, 0xc1, 0x91, 0x7e, 0x2e, 0x5d, 0x60, 0x8d, 0x07, 0x03, 0x5e, - 0x80, 0xeb, 0x59, 0x2d, 0x68, 0xbb, 0xfe, 0x89, 0x37, 0x70, 0x42, 0xb7, 0xa7, 0xe7, 0xb6, 0xde, - 0x84, 0x95, 0x44, 0xbe, 0x13, 0x3e, 0x70, 0xb5, 0x26, 0x6d, 0xc0, 0xf5, 0x4a, 0xb9, 0xba, 0x5f, - 0xd7, 0xe7, 0xf8, 0x4a, 0xde, 0xab, 0xee, 0xee, 0xe9, 0xb0, 0xf5, 0x43, 0x8d, 0x5f, 0xf6, 0x30, - 0x8b, 0x61, 0x7d, 0xc7, 0x94, 0x43, 0xcd, 0xa7, 0x99, 0xc8, 0xa2, 0x54, 0xb1, 0x6d, 0xe1, 0xd8, - 0x70, 0x0d, 0x36, 0xe9, 0x47, 0xc7, 0x6c, 0x94, 0x3b, 0x7b, 0xa6, 0x55, 0x7e, 0x62, 0x5a, 0x7c, - 0xee, 0x3d, 0xd5, 0x73, 0xb8, 0xa0, 0x14, 0x48, 0xa7, 0xdd, 0xdc, 0x2f, 0xed, 0xe9, 0x79, 0x3e, - 0x7f, 0x13, 0xf0, 0x56, 0xb5, 0xa1, 0x17, 0x70, 0x79, 0x4e, 0x60, 0x23, 0x5b, 0x5e, 0x3e, 0xb7, - 0xf5, 0xb9, 0x06, 0x97, 0x6c, 0xef, 0x68, 0xe0, 0x84, 0x63, 0xdf, 0x35, 0xfb, 0x47, 0x43, 0xdf, - 0x0b, 0x8f, 0x4f, 0xec, 0xb1, 0x17, 0xba, 0xec, 0x1e, 0xbc, 0x6a, 0x57, 0x77, 0x1b, 0x66, 0x9b, - 0x2f, 0x2f, 0xb3, 0xb6, 0xdb, 0xb4, 0xaa, 0xed, 0xbd, 0x7a, 0xc7, 0xde, 0xaf, 0x4e, 0xcc, 0xbc, - 0x3b, 0x70, 0x6b, 0x3a, 0x6a, 0xad, 0xb2, 0x6b, 0x96, 0x9e, 0xea, 0xda, 0x6c, 0x86, 0xdb, 0x66, - 0xcd, 0x6c, 0x94, 0x2a, 0xe5, 0xce, 0xc1, 0x7d, 0x3d, 0xc7, 0x5e, 0x85, 0xdb, 0xd3, 0x51, 0x77, - 0xaa, 0x2d, 0x9b, 0xa3, 0xe5, 0x67, 0x7f, 0x77, 0xcf, 0xae, 0x73, 0xac, 0xc2, 0xd6, 0x1f, 0x68, - 0xb0, 0x39, 0x2d, 0x2c, 0x24, 0xbb, 0x0b, 0x46, 0xa5, 0xd1, 0xb6, 0xcc, 0x6a, 0xb9, 0x53, 0xb2, - 0x2a, 0xe5, 0x4a, 0xa3, 0x5d, 0x35, 0x6b, 0x76, 0xc7, 0x6e, 0xee, 0xf3, 0xd9, 0x14, 0xfb, 0x9f, - 0xbc, 0x02, 0x37, 0x67, 0xe0, 0x35, 0xab, 0xe5, 0x92, 0xae, 0xb1, 0xfb, 0xf0, 0xc6, 0x0c, 0x24, - 0xfb, 0xa9, 0xdd, 0xae, 0xd4, 0xd5, 0x12, 0x3d, 0x87, 0x1b, 0x56, 0x76, 0x44, 0x3c, 0xde, 0x3a, - 0x2c, 0x99, 0x5d, 0xb1, 0xdb, 0x70, 0x7d, 0x2a, 0x16, 0x55, 0xeb, 0x15, 0xb8, 0x39, 0x15, 0x45, - 0x54, 0x4a, 0xcf, 0x6d, 0x7d, 0x08, 0x57, 0xa6, 0x47, 0x65, 0xe2, 0xe7, 0x45, 0x72, 0xc8, 0x8b, - 0x50, 0x28, 0xf3, 0x23, 0x2a, 0x91, 0xf5, 0x8b, 0xcf, 0x4e, 0xab, 0x52, 0xad, 0xb7, 0xf8, 0x46, - 0x48, 0x87, 0x0b, 0x9e, 0x1e, 0xdf, 0xd7, 0x40, 0x4f, 0x87, 0x32, 0x99, 0x70, 0x65, 0xb2, 0xf6, - 0x1b, 0x0d, 0x71, 0xd0, 0xad, 0xc1, 0x52, 0xb3, 0xbd, 0x57, 0xb1, 0x28, 0xa1, 0x1a, 0x66, 0x50, - 0xdb, 0x6f, 0xf0, 0xa5, 0xdd, 0xb4, 0xaa, 0xdf, 0xc6, 0x13, 0x6f, 0x13, 0x36, 0xec, 0x9a, 0x59, - 0x7a, 0xdc, 0x69, 0x34, 0xdb, 0x9d, 0x6a, 0xa3, 0x53, 0xda, 0x33, 0x1b, 0x8d, 0x4a, 0x4d, 0x07, - 0xbe, 0x67, 0x37, 0x1f, 0xb7, 0xcd, 0x4e, 0xa9, 0xd9, 0xd8, 0xa9, 0xee, 0x12, 0x8b, 0x0d, 0x9c, - 0x05, 0xd3, 0x5e, 0xe6, 0xb2, 0xaf, 0xc0, 0x6b, 0x48, 0xd3, 0xaa, 0xed, 0xef, 0x56, 0x1b, 0x1d, - 0xfb, 0x69, 0xa3, 0x24, 0xc5, 0xae, 0xd2, 0xe4, 0x59, 0xf1, 0x1a, 0xdc, 0x99, 0x89, 0x1d, 0x67, - 0x44, 0xbb, 0x0b, 0xc6, 0x4c, 0x4c, 0x6a, 0xdf, 0xd6, 0x9f, 0x6a, 0x70, 0x75, 0x86, 0x07, 0x02, - 0x7b, 0x03, 0xee, 0xed, 0x55, 0xcc, 0x72, 0xad, 0x62, 0xdb, 0xb8, 0xc3, 0xf1, 0x41, 0x14, 0x9e, - 0x50, 0x99, 0x27, 0xc1, 0x3d, 0x78, 0x75, 0x36, 0x7a, 0x2c, 0x53, 0xbc, 0x06, 0x77, 0x66, 0xa3, - 0x92, 0x8c, 0x91, 0x63, 0x5b, 0x70, 0x77, 0x36, 0x66, 0x24, 0x9b, 0xe4, 0xb7, 0x7e, 0x57, 0x83, - 0x8b, 0xd9, 0x6a, 0x40, 0x5e, 0xb7, 0x6a, 0xc3, 0x6e, 0x9b, 0xb5, 0x5a, 0xa7, 0x65, 0x5a, 0x66, - 0xbd, 0x53, 0x69, 0x58, 0xcd, 0x5a, 0x2d, 0xeb, 0x4c, 0xbe, 0x03, 0xb7, 0xa6, 0xa3, 0xda, 0x25, - 0xab, 0xda, 0xe2, 0xc7, 0x8e, 0x01, 0x37, 0xa6, 0x63, 0x55, 0xaa, 0xa5, 0x8a, 0x9e, 0xdb, 0xfe, - 0xe6, 0x4f, 0xff, 0xf3, 0x8d, 0x73, 0x3f, 0xfd, 0xfc, 0x86, 0xf6, 0x67, 0x9f, 0xdf, 0xd0, 0xfe, - 0xe2, 0xf3, 0x1b, 0xda, 0xb7, 0x5f, 0x3f, 0x5b, 0x32, 0x51, 0xbc, 0xed, 0x3d, 0x9b, 0xc7, 0xfb, - 0xed, 0xdb, 0xff, 0x27, 0x00, 0x00, 0xff, 0xff, 0x12, 0x7f, 0xfc, 0xa7, 0x43, 0xd9, 0x01, 0x00, + 0xb7, 0x9c, 0x68, 0xf8, 0x73, 0x27, 0x0d, 0x3f, 0xab, 0x1c, 0x77, 0x38, 0xa5, 0x72, 0xfc, 0xad, + 0x56, 0x8e, 0xd1, 0xa8, 0x4c, 0x0e, 0x7f, 0xac, 0x95, 0xff, 0x33, 0x99, 0xd6, 0x0f, 0x1d, 0xaf, + 0xe4, 0x72, 0xcf, 0x44, 0x19, 0x5c, 0xd3, 0x56, 0x6f, 0x84, 0x19, 0xc9, 0x14, 0xd9, 0x93, 0x64, + 0x8a, 0xd3, 0x4c, 0x44, 0x94, 0x7b, 0xf9, 0x90, 0x8e, 0x44, 0x72, 0xa0, 0x9d, 0xb0, 0x76, 0x91, + 0x58, 0xc6, 0x2f, 0x64, 0xe0, 0x4c, 0xaa, 0xce, 0x9c, 0xd5, 0xca, 0x95, 0xf3, 0xca, 0x3a, 0x8c, + 0x6b, 0xe6, 0x39, 0xc6, 0x69, 0xa2, 0x7a, 0x0c, 0xdf, 0x16, 0xe3, 0x39, 0x98, 0x08, 0x5f, 0x6c, + 0xc9, 0x82, 0x1c, 0x3a, 0x1e, 0xb6, 0x50, 0x3c, 0xfc, 0xd5, 0x01, 0xd8, 0x17, 0x3c, 0x56, 0xd3, + 0x6a, 0xe3, 0x9f, 0x65, 0x61, 0x8c, 0x71, 0x7d, 0x62, 0x03, 0x2c, 0xa7, 0xdb, 0x43, 0xb3, 0x26, + 0xf5, 0x0f, 0xab, 0x4c, 0x56, 0x61, 0x8c, 0xa7, 0xa4, 0x13, 0xaf, 0x7f, 0xf3, 0x2a, 0x99, 0xcc, + 0x55, 0x17, 0x86, 0xa3, 0xf0, 0x11, 0xa2, 0x69, 0x09, 0x10, 0xa2, 0x98, 0x55, 0xff, 0x4e, 0x06, + 0xa6, 0x54, 0x62, 0xf2, 0x01, 0xcc, 0xc8, 0xa0, 0xb1, 0x3c, 0x44, 0x8b, 0x78, 0x5e, 0x96, 0xa6, + 0x60, 0x32, 0x68, 0xac, 0x1a, 0xd2, 0x45, 0xc3, 0x57, 0xb7, 0xea, 0xae, 0x8a, 0x4c, 0x9a, 0x40, + 0xda, 0xbb, 0xb6, 0xf5, 0x90, 0xda, 0x07, 0xd4, 0x0f, 0x2c, 0x6e, 0xb2, 0x23, 0x5e, 0xa1, 0x25, + 0xfb, 0xbb, 0x37, 0x4b, 0xdc, 0x5a, 0x87, 0x8d, 0x84, 0x88, 0xfe, 0x9b, 0xa0, 0x51, 0x9f, 0xd6, + 0xda, 0xbb, 0xf6, 0x36, 0x2f, 0xe4, 0x74, 0xc6, 0x1f, 0x8d, 0xf1, 0xe9, 0x26, 0xa2, 0x4c, 0xef, + 0xc0, 0xcc, 0xbd, 0x6a, 0xa5, 0xac, 0x28, 0xda, 0xf5, 0x24, 0x65, 0xab, 0x8f, 0x02, 0xea, 0x75, + 0xec, 0x96, 0xbc, 0xef, 0x46, 0x47, 0x90, 0xeb, 0x34, 0x1b, 0xe9, 0x4a, 0xf8, 0x18, 0x47, 0x56, + 0x07, 0xbf, 0x59, 0x87, 0x75, 0x64, 0x87, 0xac, 0xc3, 0xb7, 0xdb, 0xad, 0x3e, 0x75, 0xe8, 0x1c, + 0xc9, 0x3e, 0x5e, 0x7d, 0xf7, 0x7b, 0x3b, 0x4a, 0x2d, 0xb9, 0xc1, 0xb5, 0x3c, 0x2f, 0x6a, 0x79, + 0x5a, 0xa8, 0x55, 0x52, 0xeb, 0x49, 0x70, 0x8d, 0xf6, 0x89, 0x91, 0x13, 0xf7, 0x89, 0xff, 0x38, + 0x03, 0x63, 0x5c, 0x7c, 0x15, 0xd3, 0xb8, 0x8f, 0x80, 0xbc, 0xfd, 0x78, 0x04, 0xe4, 0x02, 0x9e, + 0x13, 0xda, 0x84, 0xe6, 0x65, 0xa4, 0x12, 0x5b, 0x17, 0xd2, 0x1b, 0x00, 0x9f, 0xcc, 0x78, 0xc9, + 0xc9, 0xcb, 0x82, 0x54, 0xa3, 0x00, 0x21, 0xe3, 0x27, 0x7a, 0x85, 0xcb, 0xa0, 0x2a, 0xe3, 0x22, + 0x40, 0x88, 0x1e, 0x16, 0x64, 0x1d, 0x26, 0x44, 0xd8, 0x91, 0x95, 0x43, 0xf1, 0x30, 0x5e, 0xd0, + 0x4c, 0x9b, 0x9a, 0x2b, 0x87, 0x91, 0x68, 0x2e, 0x02, 0x97, 0x58, 0x3b, 0xaa, 0x5b, 0x40, 0xc4, + 0x80, 0xdc, 0xe3, 0xf9, 0xc7, 0x79, 0x14, 0x6e, 0x3d, 0xf1, 0x46, 0x08, 0x17, 0x51, 0xd8, 0x64, + 0xec, 0x82, 0x94, 0xa0, 0xdb, 0x11, 0x0f, 0xb2, 0x0e, 0x05, 0x34, 0x87, 0xa3, 0x4d, 0xbe, 0x6a, + 0xaa, 0x15, 0x1e, 0xda, 0x42, 0x98, 0x34, 0x07, 0xbc, 0x4c, 0x2c, 0xb7, 0x98, 0xff, 0x65, 0x82, + 0xd2, 0xf8, 0x99, 0x2c, 0x14, 0xe2, 0xb3, 0x8f, 0xbc, 0x0d, 0x93, 0x61, 0x14, 0xf4, 0xd0, 0x03, + 0x1c, 0x1f, 0xc8, 0xa2, 0xb0, 0xe9, 0x7a, 0xd6, 0x6a, 0x05, 0x9d, 0x2c, 0x43, 0x9e, 0x2d, 0xe2, + 0x4e, 0x14, 0xc4, 0x12, 0xb7, 0xed, 0x9e, 0x80, 0xa9, 0x1e, 0x59, 0x12, 0x8f, 0xd4, 0x61, 0x9e, + 0x2d, 0x9a, 0xba, 0xd3, 0xd9, 0x6b, 0xd1, 0x75, 0x77, 0xcf, 0xed, 0x05, 0x51, 0x12, 0x67, 0x7e, + 0x81, 0xb1, 0xdb, 0x2d, 0xad, 0x58, 0x4f, 0xe1, 0x9c, 0x42, 0x4d, 0x5e, 0xe3, 0xc7, 0x4c, 0xb5, + 0x22, 0xec, 0x5a, 0xf0, 0xa8, 0x46, 0x7b, 0x2c, 0xed, 0xe3, 0x05, 0x92, 0xb2, 0xb3, 0xfe, 0x7e, + 0x16, 0x26, 0x95, 0xe9, 0x47, 0xae, 0x40, 0xbe, 0xea, 0xaf, 0xbb, 0x8d, 0x83, 0x30, 0xaa, 0xe7, + 0xf4, 0xf1, 0x51, 0x71, 0xc2, 0xf1, 0xad, 0x16, 0x02, 0xcd, 0xb0, 0x98, 0xac, 0xc0, 0x34, 0xff, + 0x4b, 0xa6, 0xb3, 0xc9, 0x46, 0xba, 0x35, 0x8e, 0x2c, 0x13, 0xd9, 0xa8, 0x9b, 0xad, 0x46, 0x42, + 0x3e, 0x04, 0xe0, 0x00, 0x0c, 0xa9, 0x90, 0x1b, 0x3e, 0x18, 0x84, 0xa8, 0x20, 0x25, 0x98, 0x82, + 0xc2, 0x90, 0x7c, 0x83, 0x07, 0x59, 0x97, 0xcb, 0x65, 0x64, 0xf8, 0x68, 0x16, 0x8c, 0xbf, 0x95, + 0x1e, 0x54, 0x47, 0x65, 0x29, 0x32, 0x50, 0x2d, 0xc9, 0x74, 0xa3, 0xa5, 0x00, 0x11, 0x15, 0x0c, + 0xe3, 0x7f, 0xcd, 0x28, 0x8b, 0x8c, 0x6c, 0xc0, 0x44, 0x38, 0x81, 0x84, 0x49, 0x59, 0x78, 0xc5, + 0x90, 0x70, 0x93, 0xee, 0xae, 0x3c, 0x2d, 0xac, 0xdb, 0xe6, 0xc3, 0x69, 0xa8, 0xad, 0x39, 0x09, + 0x24, 0x5f, 0x86, 0x11, 0xec, 0xba, 0xec, 0x89, 0x4d, 0x93, 0xa7, 0xfc, 0x08, 0xeb, 0x33, 0x6c, + 0x08, 0x52, 0x92, 0xcf, 0x09, 0xc7, 0x6d, 0xde, 0xf9, 0x33, 0xca, 0x51, 0xcd, 0xbe, 0x23, 0x3c, + 0xde, 0xa3, 0xb8, 0x4a, 0xca, 0xec, 0xf9, 0x2b, 0x59, 0x28, 0xc4, 0x97, 0x36, 0x79, 0x0f, 0xa6, + 0xe4, 0xf1, 0xbb, 0x66, 0x8b, 0x5c, 0x2c, 0x53, 0x22, 0x17, 0x8a, 0x3c, 0x83, 0xf7, 0x6d, 0xd5, + 0x04, 0xcd, 0xd4, 0x08, 0x98, 0x2c, 0xb4, 0x29, 0x82, 0x33, 0x2a, 0x8b, 0x2a, 0x70, 0x83, 0x6e, + 0x2c, 0xb6, 0xb7, 0x44, 0x23, 0x6f, 0x40, 0xee, 0xee, 0xcd, 0x92, 0x70, 0xf0, 0x2b, 0xc4, 0x0f, + 0x69, 0x6e, 0x29, 0xab, 0xdb, 0xed, 0x32, 0x7c, 0xb2, 0xae, 0x84, 0xc1, 0x1f, 0xd3, 0xcc, 0x0d, + 0x25, 0x38, 0x6c, 0xdc, 0xc9, 0xf1, 0xf0, 0x6f, 0x8f, 0xe4, 0x73, 0x85, 0x11, 0x11, 0x1a, 0xf9, + 0x5f, 0xe5, 0x60, 0x22, 0xac, 0x9f, 0x10, 0xd5, 0x6d, 0x9a, 0xbb, 0x48, 0x93, 0xf3, 0x90, 0x97, + 0xd2, 0x9d, 0xf0, 0xf3, 0x1b, 0xf7, 0x85, 0x64, 0xb7, 0x08, 0x52, 0x8c, 0xe3, 0xbb, 0x82, 0x29, + 0x7f, 0x92, 0xeb, 0x10, 0xca, 0x68, 0xfd, 0x84, 0xb9, 0x11, 0x36, 0x60, 0x66, 0x88, 0x46, 0x66, + 0x20, 0xeb, 0xf0, 0x70, 0x73, 0x13, 0x66, 0xd6, 0x69, 0x92, 0xf7, 0x20, 0x6f, 0x37, 0x9b, 0x98, + 0x5b, 0x76, 0x88, 0xb4, 0xb4, 0x79, 0xc6, 0x8d, 0x9f, 0x19, 0x48, 0x55, 0x0a, 0x48, 0x09, 0x26, + 0x78, 0xfc, 0x6e, 0x9f, 0x36, 0x87, 0x38, 0x80, 0x22, 0x0e, 0x18, 0xf6, 0x7b, 0xcb, 0xa7, 0x4d, + 0xf2, 0x12, 0x8c, 0xb0, 0xd1, 0x14, 0x27, 0x8e, 0x14, 0x2a, 0xd9, 0x60, 0xf2, 0x0e, 0x5b, 0x7b, + 0xca, 0x44, 0x04, 0xf2, 0x02, 0xe4, 0x7a, 0xcb, 0xbb, 0xe2, 0x2c, 0x29, 0x44, 0x29, 0x29, 0x42, + 0x34, 0x56, 0x4c, 0x5e, 0x87, 0xfc, 0x43, 0x3d, 0x9b, 0xc1, 0x99, 0xd8, 0x30, 0x86, 0xf8, 0x21, + 0x22, 0x79, 0x09, 0x72, 0xbe, 0xef, 0x0a, 0x83, 0xa6, 0xf9, 0xd0, 0xca, 0xf4, 0x5e, 0x38, 0x6a, + 0x8c, 0xbb, 0xef, 0xbb, 0x2b, 0x79, 0x18, 0xe3, 0x07, 0x8c, 0xf1, 0x2c, 0x40, 0xf4, 0x8d, 0x49, + 0xbf, 0x4d, 0xe3, 0x43, 0x98, 0x08, 0xbf, 0x8d, 0x5c, 0x00, 0x38, 0xa0, 0x87, 0xd6, 0xbe, 0xdd, + 0x69, 0xb6, 0xb8, 0x74, 0x3a, 0x65, 0x4e, 0x1c, 0xd0, 0xc3, 0x35, 0x04, 0x90, 0x73, 0x30, 0xde, + 0x65, 0xc3, 0x2f, 0xe6, 0xf8, 0x94, 0x39, 0xd6, 0xed, 0xed, 0xb0, 0xa9, 0xbc, 0x08, 0xe3, 0xa8, + 0x67, 0x15, 0x2b, 0x72, 0xda, 0x94, 0x3f, 0x8d, 0x3f, 0xce, 0x61, 0xd2, 0x2f, 0xa5, 0x41, 0xe4, + 0x79, 0x98, 0x6e, 0x78, 0x14, 0xcf, 0x32, 0x9b, 0x49, 0x68, 0xa2, 0x9e, 0xa9, 0x08, 0x58, 0x6d, + 0x92, 0x4b, 0x30, 0x1b, 0xe5, 0x67, 0xb6, 0x1a, 0x3b, 0x22, 0x4b, 0xc9, 0x94, 0x39, 0xdd, 0x95, + 0x59, 0x9a, 0xcb, 0x3b, 0x18, 0x4f, 0xb1, 0xa0, 0x86, 0x03, 0x67, 0x3d, 0x22, 0xe6, 0xdf, 0xac, + 0x02, 0x47, 0xdb, 0xcc, 0xb3, 0x30, 0x66, 0xdb, 0x7b, 0x3d, 0x87, 0xc7, 0x3d, 0x9b, 0x32, 0xc5, + 0x2f, 0xf2, 0x0a, 0xcc, 0x45, 0xf1, 0xf5, 0x65, 0x33, 0x46, 0xb1, 0x19, 0x85, 0xb0, 0xa0, 0xcc, + 0xe1, 0xe4, 0x35, 0x20, 0x6a, 0x7d, 0xee, 0xce, 0x47, 0xb4, 0xc1, 0xe7, 0xe4, 0x94, 0x39, 0xa7, + 0x94, 0xdc, 0xc3, 0x02, 0xf2, 0x1c, 0x4c, 0x79, 0xd4, 0x47, 0xe9, 0x10, 0xbb, 0x0d, 0x73, 0x62, + 0x9a, 0x93, 0x12, 0xc6, 0xfa, 0xee, 0x32, 0x14, 0x94, 0xee, 0xc0, 0x88, 0xeb, 0x3c, 0x41, 0x87, + 0x39, 0x13, 0xc1, 0xcd, 0x6e, 0xb5, 0x49, 0xbe, 0x02, 0x4b, 0x0a, 0x26, 0x4f, 0xcf, 0x69, 0xd1, + 0x96, 0xb3, 0xe7, 0xec, 0xb4, 0xa8, 0x98, 0x6f, 0xc9, 0x59, 0x1d, 0x5e, 0x21, 0xcd, 0xc5, 0x88, + 0x9a, 0x27, 0xee, 0x5c, 0x15, 0xb4, 0x64, 0x1d, 0x16, 0x62, 0x9c, 0x69, 0xd3, 0xea, 0x75, 0xfb, + 0x06, 0x1a, 0x8c, 0x78, 0x12, 0x9d, 0x27, 0x6d, 0x6e, 0x75, 0x8d, 0x6f, 0xc1, 0x94, 0x3a, 0x27, + 0x59, 0x27, 0xa8, 0x72, 0x89, 0x98, 0x7d, 0x93, 0x21, 0xac, 0xca, 0xee, 0x85, 0x33, 0x11, 0x0a, + 0x0e, 0x22, 0xdf, 0x5e, 0xa6, 0x43, 0x28, 0x0e, 0xe1, 0x73, 0x30, 0xd5, 0x74, 0xfc, 0x6e, 0xcb, + 0x3e, 0x44, 0x0b, 0x3b, 0x31, 0xd2, 0x93, 0x02, 0x86, 0x8a, 0x9f, 0x15, 0x98, 0x4b, 0xec, 0x83, + 0x8a, 0xa4, 0xc1, 0xf7, 0xf5, 0xc1, 0x92, 0x86, 0xd1, 0x81, 0x29, 0xf5, 0x5c, 0x3b, 0x21, 0x9d, + 0xce, 0x59, 0x0c, 0xc3, 0xc3, 0x37, 0xfd, 0xb1, 0xe3, 0xa3, 0x62, 0xd6, 0x69, 0x62, 0xf0, 0x9d, + 0xcb, 0x90, 0x97, 0x12, 0x9b, 0x10, 0x94, 0xf0, 0x31, 0x41, 0x3e, 0x4d, 0x9a, 0x61, 0xa9, 0xf1, + 0x12, 0x8c, 0x8b, 0xa3, 0x6b, 0xf0, 0x13, 0x82, 0xf1, 0xed, 0x2c, 0xcc, 0x9a, 0x94, 0x6d, 0xac, + 0x94, 0xe7, 0xd0, 0x7a, 0x62, 0xaf, 0xe8, 0xe9, 0x71, 0x75, 0xb5, 0xb6, 0x0d, 0xc8, 0x5e, 0xf5, + 0xcb, 0x19, 0x98, 0x4f, 0xc1, 0xfd, 0x58, 0xd9, 0x9b, 0x6f, 0xc0, 0x44, 0xc5, 0xb1, 0x5b, 0xa5, + 0x66, 0x33, 0x8c, 0xc9, 0x83, 0x72, 0x3e, 0xa6, 0x78, 0xb3, 0x19, 0x54, 0x15, 0x62, 0x42, 0x54, + 0xf2, 0xb2, 0x98, 0x14, 0xb9, 0xb0, 0x5b, 0x71, 0x52, 0x7c, 0xf7, 0xa8, 0x08, 0xfc, 0x9b, 0x36, + 0xc3, 0x29, 0x82, 0xb1, 0xae, 0x39, 0x30, 0xf2, 0xab, 0x7a, 0x62, 0x87, 0x2e, 0x3d, 0xd6, 0x75, + 0xbc, 0x79, 0x43, 0x25, 0xb0, 0xfa, 0x89, 0x2c, 0x9c, 0x4d, 0x27, 0xfc, 0xb8, 0x89, 0xb8, 0x31, + 0x75, 0x98, 0x12, 0x9f, 0x1f, 0x13, 0x71, 0xf3, 0x3c, 0x63, 0x88, 0x1f, 0x21, 0x90, 0x5d, 0x9e, + 0xf0, 0x7e, 0x8d, 0xda, 0x5e, 0xb0, 0x43, 0xed, 0x60, 0x08, 0x49, 0x5e, 0x5a, 0x53, 0x2c, 0xa2, + 0x30, 0xb1, 0x2f, 0x29, 0xd3, 0xf2, 0xdd, 0x87, 0x6c, 0xc3, 0x89, 0x32, 0x32, 0xc4, 0x44, 0xf9, + 0x26, 0xcc, 0xd6, 0x69, 0xdb, 0xee, 0xee, 0xbb, 0x9e, 0x8c, 0x97, 0x70, 0x15, 0xa6, 0x43, 0x50, + 0xea, 0x6c, 0xd1, 0x8b, 0x35, 0x7c, 0xa5, 0x23, 0xa2, 0xad, 0x44, 0x2f, 0x36, 0xfe, 0x6a, 0x16, + 0xce, 0x95, 0x1a, 0xc2, 0x34, 0x54, 0x14, 0x48, 0x0b, 0xf6, 0x4f, 0xb9, 0x6e, 0x72, 0x0d, 0x26, + 0xee, 0xda, 0x8f, 0xd6, 0xa9, 0xed, 0x53, 0x5f, 0x24, 0x7f, 0xe0, 0x62, 0xaf, 0xfd, 0x28, 0x7a, + 0xfc, 0x31, 0x23, 0x1c, 0x55, 0x8d, 0x30, 0xf2, 0x09, 0xd5, 0x08, 0x06, 0x8c, 0xad, 0xb9, 0xad, + 0xa6, 0x38, 0xeb, 0xc5, 0x8b, 0xf3, 0x3e, 0x42, 0x4c, 0x51, 0x62, 0xfc, 0x61, 0x06, 0x66, 0xc2, + 0x2f, 0xc6, 0x4f, 0xf8, 0xd4, 0xbb, 0xe4, 0x12, 0x8c, 0x63, 0x45, 0xd5, 0x8a, 0x7a, 0x68, 0xb4, + 0x28, 0x26, 0xb3, 0x6c, 0x9a, 0xb2, 0x50, 0xed, 0x89, 0xd1, 0x4f, 0xd6, 0x13, 0xc6, 0xdf, 0xc5, + 0xc7, 0x6c, 0xb5, 0x95, 0xec, 0x24, 0x52, 0x3e, 0x24, 0x33, 0xe4, 0x87, 0x64, 0x1f, 0xdb, 0x90, + 0xe4, 0xfa, 0x0e, 0xc9, 0x8f, 0x64, 0x61, 0x32, 0xfc, 0xd8, 0xcf, 0x58, 0x92, 0x88, 0xb0, 0x5d, + 0x43, 0xc5, 0x38, 0xaa, 0x2b, 0x7b, 0x85, 0x08, 0x25, 0xf4, 0x65, 0x18, 0x13, 0x8b, 0x29, 0x13, + 0xb3, 0xe4, 0x8e, 0x8d, 0xee, 0xca, 0x8c, 0x60, 0x3d, 0x86, 0x03, 0xea, 0x9b, 0x82, 0x0e, 0x83, + 0x48, 0x6d, 0xd3, 0x1d, 0x61, 0xdb, 0xf0, 0xc4, 0x9e, 0x51, 0xe9, 0x41, 0xa4, 0xa2, 0x86, 0x0d, + 0x75, 0x3a, 0xfd, 0x8f, 0x79, 0x28, 0xc4, 0x49, 0x4e, 0x4e, 0xc3, 0x51, 0xeb, 0xed, 0xf0, 0xab, + 0x0a, 0x4f, 0xc3, 0xd1, 0xed, 0xed, 0x98, 0x0c, 0x86, 0xa6, 0x4f, 0x9e, 0xf3, 0x00, 0x5b, 0x3d, + 0x25, 0x4c, 0x9f, 0x3c, 0xe7, 0x81, 0x66, 0xfa, 0xe4, 0x39, 0x0f, 0x50, 0x91, 0xb0, 0x5e, 0xc7, + 0x00, 0x0b, 0x78, 0x4f, 0x11, 0x8a, 0x84, 0x96, 0x1f, 0xcf, 0x2d, 0x28, 0xd1, 0xd8, 0x51, 0xb9, + 0x42, 0x6d, 0x4f, 0xa4, 0x8c, 0x10, 0xdb, 0x19, 0x1e, 0x95, 0x3b, 0x08, 0xb6, 0x02, 0x06, 0x37, + 0x55, 0x24, 0xd2, 0x02, 0xa2, 0xfc, 0x94, 0x0b, 0xf8, 0xe4, 0xbb, 0xb5, 0xb4, 0xc2, 0x5c, 0x50, + 0x59, 0x5b, 0xea, 0x6a, 0x4e, 0xe1, 0xfb, 0x38, 0xb5, 0xbf, 0x35, 0x11, 0x52, 0x16, 0x15, 0x48, + 0xf9, 0x13, 0x99, 0xc9, 0xc0, 0x30, 0xc0, 0x43, 0xce, 0x86, 0x6a, 0xa4, 0x88, 0x09, 0x79, 0x17, + 0x26, 0xd5, 0xb0, 0x19, 0x3c, 0xb8, 0xc3, 0x33, 0x3c, 0x9e, 0x66, 0x9f, 0x7c, 0xd4, 0x2a, 0x01, + 0xd9, 0x81, 0x73, 0x65, 0xb7, 0xe3, 0xf7, 0xda, 0x32, 0x72, 0x67, 0x14, 0x05, 0x1d, 0x70, 0x28, + 0xd0, 0x07, 0xbf, 0x21, 0x50, 0x44, 0x94, 0x06, 0xe9, 0x26, 0xa3, 0x5f, 0x40, 0xfa, 0x31, 0x22, + 0x9b, 0x30, 0x89, 0x1a, 0x54, 0x61, 0xf2, 0x38, 0xa9, 0x6f, 0x1b, 0x51, 0x49, 0x85, 0x2d, 0x0c, + 0x1e, 0x35, 0xce, 0x6e, 0xb7, 0xa4, 0x97, 0x86, 0xaa, 0x09, 0x56, 0x90, 0xc9, 0x87, 0x30, 0xc3, + 0xaf, 0x68, 0xdb, 0x74, 0x87, 0xcf, 0x9d, 0x29, 0x4d, 0x13, 0xa1, 0x17, 0xf2, 0xc7, 0x7c, 0xa1, + 0xb7, 0x7e, 0x48, 0x77, 0xf8, 0xd8, 0x6b, 0x3e, 0x52, 0x1a, 0x3e, 0xd9, 0x82, 0xf9, 0x35, 0xdb, + 0xe7, 0x40, 0x25, 0xfe, 0xc1, 0x34, 0x6a, 0x68, 0xd1, 0x76, 0x7d, 0xdf, 0xf6, 0xa5, 0x22, 0x3c, + 0x35, 0xde, 0x41, 0x1a, 0x3d, 0xf9, 0x76, 0x06, 0x16, 0x35, 0x3d, 0xb9, 0xb0, 0x33, 0xc3, 0x70, + 0xb0, 0x33, 0xf8, 0xe4, 0x55, 0x94, 0x42, 0x69, 0x1f, 0x34, 0x3e, 0x24, 0x31, 0x55, 0xbc, 0x17, + 0x95, 0xab, 0x46, 0xe1, 0xfd, 0x78, 0x88, 0x85, 0x8a, 0x6b, 0x7a, 0x56, 0x5f, 0xa8, 0xb1, 0x75, + 0x2d, 0xd1, 0x8c, 0x1b, 0xf1, 0xfe, 0x16, 0x8a, 0xae, 0x4c, 0xa8, 0xe8, 0x5a, 0x80, 0x51, 0xec, + 0x55, 0x19, 0x45, 0x0b, 0x7f, 0x18, 0x9f, 0x53, 0xf7, 0x21, 0x21, 0x16, 0x0e, 0xdc, 0x87, 0x8c, + 0xff, 0x69, 0x0c, 0x66, 0x63, 0xd3, 0x42, 0xdc, 0x53, 0x33, 0x89, 0x7b, 0x6a, 0x1d, 0x80, 0xab, + 0x7a, 0x87, 0xd4, 0xc9, 0x4a, 0x47, 0xcc, 0x49, 0xe1, 0x46, 0x1d, 0xae, 0x29, 0x85, 0x0d, 0x63, + 0xca, 0x57, 0xec, 0x90, 0x3a, 0xf2, 0x90, 0x29, 0x5f, 0xf4, 0x0a, 0xd3, 0x88, 0x0d, 0x29, 0xc2, + 0x28, 0xc6, 0xcf, 0x55, 0xfd, 0x60, 0x1d, 0x06, 0x30, 0x39, 0x9c, 0x3c, 0x0f, 0x63, 0x4c, 0x88, + 0xaa, 0x56, 0xc4, 0x26, 0x88, 0x67, 0x0b, 0x93, 0xb2, 0x98, 0xc4, 0x22, 0x8a, 0xc8, 0x0d, 0x98, + 0xe2, 0x7f, 0x89, 0x30, 0x3b, 0x63, 0xba, 0xf1, 0xa3, 0xe5, 0x34, 0x65, 0xa4, 0x1d, 0x0d, 0x8f, + 0xdd, 0x2e, 0xea, 0x3d, 0x54, 0xeb, 0x54, 0x2b, 0x22, 0x8c, 0x3c, 0xde, 0x2e, 0x7c, 0x0e, 0x64, + 0x55, 0x44, 0x08, 0x4c, 0x96, 0x11, 0xde, 0x28, 0x79, 0xbc, 0x53, 0xa2, 0x2c, 0xc3, 0xbd, 0x50, + 0x4c, 0x51, 0x42, 0xae, 0xf0, 0x97, 0x18, 0x14, 0x0b, 0x79, 0x2e, 0x55, 0x7c, 0xb7, 0x40, 0xc5, + 0x04, 0xca, 0x86, 0x61, 0x31, 0xab, 0x9c, 0xfd, 0xbd, 0xda, 0xb6, 0x9d, 0x96, 0xd8, 0x56, 0xb0, + 0x72, 0xc4, 0xa5, 0x0c, 0x6a, 0x46, 0x08, 0xe4, 0x6d, 0x98, 0xe1, 0x39, 0x0f, 0xdb, 0x6d, 0xb7, + 0x83, 0xec, 0x27, 0xa3, 0x40, 0x7a, 0x22, 0x0f, 0x23, 0x2b, 0xe2, 0xb5, 0xc4, 0x70, 0xd9, 0x79, + 0x82, 0xaf, 0xbc, 0x3d, 0xfe, 0x46, 0x34, 0x15, 0x9d, 0x27, 0x48, 0xea, 0x73, 0xb8, 0xa9, 0x22, + 0x91, 0x37, 0x61, 0x9a, 0xfd, 0xbc, 0xe5, 0x3c, 0xa0, 0xbc, 0xc2, 0xe9, 0xc8, 0xbc, 0x01, 0xa9, + 0xf6, 0x58, 0x09, 0xaf, 0x4f, 0xc7, 0x24, 0xef, 0xc3, 0x19, 0xe4, 0xd4, 0x70, 0xbb, 0xb4, 0x59, + 0xda, 0xdd, 0x75, 0x5a, 0x0e, 0xb7, 0x46, 0xe3, 0x01, 0x65, 0x50, 0x07, 0xcf, 0x2b, 0x46, 0x0c, + 0xcb, 0x8e, 0x50, 0xcc, 0x74, 0x4a, 0xb2, 0x0d, 0x85, 0x72, 0xcf, 0x0f, 0xdc, 0x76, 0x29, 0x08, + 0x3c, 0x67, 0xa7, 0x17, 0x50, 0x7f, 0x71, 0x56, 0x0b, 0xbb, 0xc2, 0x16, 0x47, 0x58, 0xc8, 0xf5, + 0x41, 0x0d, 0xa4, 0xb0, 0xec, 0x90, 0xc4, 0x4c, 0x30, 0x31, 0xfe, 0x4d, 0x06, 0xa6, 0x35, 0x52, + 0xf2, 0x06, 0x4c, 0xdd, 0xf4, 0x1c, 0xda, 0x69, 0xb6, 0x0e, 0x95, 0x8b, 0x2a, 0xde, 0x62, 0x76, + 0x05, 0x9c, 0xb7, 0x5a, 0x43, 0x0b, 0xf5, 0x3c, 0xd9, 0x54, 0x53, 0xd1, 0x6b, 0xdc, 0x1d, 0x5b, + 0x4c, 0xd0, 0x5c, 0x14, 0x07, 0x0a, 0x27, 0xa8, 0x98, 0x9d, 0x0a, 0x0a, 0x79, 0x07, 0xc6, 0xf8, + 0x7b, 0xb0, 0xb0, 0x5b, 0x3c, 0x9f, 0xd6, 0x4c, 0xee, 0xfa, 0x8f, 0x13, 0x11, 0x8d, 0x7e, 0x7c, + 0x53, 0x10, 0x19, 0x3f, 0x97, 0x01, 0x92, 0x44, 0x3d, 0x41, 0xef, 0x75, 0xa2, 0x31, 0xd1, 0x97, + 0xc3, 0xd5, 0x98, 0xd3, 0x74, 0xe6, 0xac, 0x26, 0x5e, 0xc0, 0x3b, 0x5e, 0xac, 0x3a, 0x55, 0x11, + 0xc7, 0x8b, 0x8d, 0x1f, 0xce, 0x02, 0x44, 0xd8, 0xe4, 0x8b, 0x3c, 0x63, 0xdc, 0xfb, 0x3d, 0xbb, + 0xe5, 0xec, 0x3a, 0x7a, 0xdc, 0x5e, 0x64, 0xf2, 0x4d, 0x59, 0x62, 0xea, 0x88, 0xe4, 0x3d, 0x98, + 0xad, 0xd7, 0x74, 0x5a, 0xc5, 0x2c, 0xde, 0xef, 0x5a, 0x31, 0xf2, 0x38, 0x36, 0xda, 0x27, 0xab, + 0xa3, 0xc1, 0xed, 0x93, 0xf9, 0x40, 0x88, 0x12, 0xb6, 0xb1, 0xd4, 0x6b, 0xc2, 0xf2, 0xbf, 0x19, + 0xbe, 0x6a, 0xe2, 0xd7, 0xf9, 0x5d, 0xab, 0x2b, 0x5c, 0x02, 0xd8, 0x3e, 0xa1, 0xe1, 0x45, 0x1d, + 0x39, 0xda, 0xc7, 0xbd, 0xff, 0xe7, 0x51, 0xed, 0xd7, 0x76, 0x03, 0x2a, 0xb4, 0x1d, 0x4f, 0xec, + 0xbd, 0x27, 0x32, 0x26, 0x18, 0xd5, 0xbc, 0x96, 0xb5, 0xd6, 0x09, 0x83, 0x99, 0xd7, 0xa3, 0x4b, + 0x0a, 0x37, 0x2b, 0x48, 0xb1, 0xb1, 0xf9, 0xdb, 0x19, 0x38, 0x93, 0x4a, 0x4b, 0xae, 0x02, 0x44, + 0x3a, 0x25, 0xd1, 0x4b, 0xb8, 0x63, 0x46, 0xd1, 0x8f, 0x4c, 0x05, 0x83, 0x7c, 0x2d, 0xae, 0x0d, + 0x3a, 0xf9, 0x20, 0x5c, 0x92, 0x41, 0x07, 0x75, 0x6d, 0x50, 0x8a, 0x0e, 0xc8, 0xf8, 0xe5, 0x1c, + 0xcc, 0x29, 0xc1, 0x95, 0xf8, 0xb7, 0x9e, 0x60, 0x2f, 0x7e, 0x00, 0x53, 0xac, 0x35, 0x4e, 0x43, + 0xb8, 0xdd, 0x70, 0xc3, 0x97, 0x97, 0x13, 0x7e, 0xa7, 0x82, 0xdb, 0x55, 0x15, 0x99, 0x87, 0x02, + 0xc5, 0xad, 0x13, 0x1f, 0x24, 0x1a, 0x49, 0x97, 0x1b, 0x8d, 0x39, 0xf1, 0x61, 0xba, 0x72, 0xd8, + 0xb1, 0xdb, 0x61, 0x6d, 0xdc, 0x00, 0xe6, 0x95, 0xbe, 0xb5, 0x69, 0xd8, 0xbc, 0xba, 0xc8, 0x43, + 0x8b, 0x97, 0xa5, 0x04, 0x07, 0xd0, 0xa8, 0x96, 0xde, 0x83, 0xb9, 0xc4, 0x47, 0x9f, 0x2a, 0x2a, + 0xe9, 0x36, 0x90, 0xe4, 0x77, 0xa4, 0x70, 0x78, 0x45, 0x8f, 0x79, 0x7b, 0x26, 0x7c, 0xbc, 0x6e, + 0xb7, 0xed, 0x4e, 0x93, 0x9b, 0xd3, 0x2c, 0xab, 0x31, 0x4b, 0x7f, 0x3e, 0xab, 0xfa, 0xfe, 0x3e, + 0xe9, 0xab, 0xee, 0xcb, 0xda, 0x6d, 0xf8, 0xd9, 0x7e, 0x63, 0x3a, 0x94, 0xd6, 0xe1, 0x3b, 0x39, + 0x38, 0xd7, 0x87, 0x92, 0x1c, 0xc6, 0x27, 0x11, 0xd7, 0x42, 0x5c, 0x1f, 0x5c, 0xe1, 0xe3, 0x98, + 0x4a, 0xe4, 0x8b, 0x3c, 0xfa, 0x87, 0x48, 0x2f, 0xcd, 0xef, 0xdf, 0xa8, 0xc6, 0x3f, 0x08, 0xa1, + 0xf1, 0xb0, 0x1f, 0x1c, 0x4a, 0xde, 0x83, 0x51, 0x74, 0xfc, 0x8e, 0x85, 0x77, 0x64, 0x18, 0x08, + 0x57, 0x02, 0x94, 0xb2, 0x9f, 0x5a, 0x80, 0x52, 0x06, 0x20, 0x5f, 0x80, 0x5c, 0x69, 0xbb, 0x2e, + 0xc6, 0x65, 0x46, 0x25, 0xdf, 0xae, 0x47, 0x29, 0x63, 0x6c, 0x2d, 0xb7, 0x0b, 0xa3, 0x60, 0x84, + 0xb7, 0xca, 0x35, 0x31, 0x2a, 0x2a, 0xe1, 0xad, 0x72, 0x2d, 0x22, 0xdc, 0x6b, 0x68, 0xc1, 0xb2, + 0x6e, 0x95, 0x6b, 0x9f, 0xde, 0xb4, 0xff, 0x4f, 0xb2, 0x3c, 0x64, 0x09, 0x6f, 0xd8, 0x7b, 0x30, + 0xa5, 0xc5, 0x24, 0xcf, 0x44, 0xf2, 0x58, 0x18, 0x3f, 0x3e, 0x66, 0x31, 0xa4, 0x11, 0xc8, 0xe4, + 0x4b, 0xec, 0x37, 0x4a, 0xbc, 0xaa, 0xb1, 0x4d, 0xc8, 0x01, 0x65, 0xe2, 0x78, 0xf2, 0xa5, 0x90, + 0x84, 0xbc, 0x0e, 0xf9, 0x4d, 0xda, 0xb1, 0x3b, 0x41, 0xa8, 0x10, 0x45, 0xe3, 0xe2, 0x00, 0x61, + 0xba, 0xd4, 0x10, 0x22, 0xa2, 0x21, 0x6c, 0x6f, 0xc7, 0x6f, 0x78, 0x0e, 0x86, 0x36, 0x0a, 0xcf, + 0x62, 0x6e, 0x08, 0xab, 0x94, 0xe8, 0x0c, 0x62, 0x44, 0xc6, 0xcf, 0x67, 0x60, 0x5c, 0x0c, 0x24, + 0x4f, 0x9a, 0xb7, 0x17, 0x9d, 0x25, 0xc2, 0x79, 0x60, 0xcf, 0x89, 0x3b, 0x0f, 0xec, 0xf1, 0xf8, + 0x41, 0x13, 0xc2, 0xb1, 0x2e, 0x7c, 0x1a, 0xc4, 0xd9, 0x28, 0xdd, 0x3e, 0xf5, 0x9c, 0x68, 0x21, + 0xea, 0xb0, 0x0e, 0x59, 0xc6, 0x5f, 0x13, 0x5f, 0x76, 0xab, 0x5c, 0x23, 0xcb, 0x90, 0x5f, 0x77, + 0x79, 0x28, 0x2c, 0x35, 0x03, 0x74, 0x4b, 0xc0, 0xd4, 0x0e, 0x92, 0x78, 0xec, 0xfb, 0x6a, 0x9e, + 0x2b, 0xee, 0x32, 0xca, 0xf7, 0x75, 0x39, 0x30, 0xf6, 0x7d, 0x21, 0xea, 0xd0, 0xdf, 0x47, 0x53, + 0x36, 0x89, 0xfb, 0xaf, 0x63, 0x56, 0x9a, 0xdb, 0xaa, 0xa3, 0x9b, 0x28, 0x92, 0x3b, 0xc5, 0x52, + 0xbf, 0x9d, 0xe2, 0xfe, 0xeb, 0x66, 0x0a, 0x15, 0xbe, 0xab, 0x45, 0xe0, 0x3a, 0xf5, 0x1e, 0x3c, + 0xc1, 0xbb, 0x74, 0xfa, 0xbb, 0x5a, 0xbc, 0x79, 0x43, 0x6d, 0xd2, 0xbf, 0x93, 0x85, 0xb3, 0xe9, + 0x84, 0x6a, 0x5b, 0x32, 0x03, 0xda, 0x72, 0x19, 0xf2, 0x6b, 0xae, 0x1f, 0x28, 0x46, 0x82, 0xa8, + 0xfe, 0xdf, 0x17, 0x30, 0x33, 0x2c, 0x65, 0x77, 0x6e, 0xf6, 0x77, 0xb8, 0x3c, 0x91, 0x1f, 0x06, + 0xea, 0x60, 0x77, 0x6e, 0x5e, 0x44, 0x6e, 0x41, 0xde, 0x14, 0x8e, 0x56, 0xb1, 0xae, 0x91, 0xe0, + 0x50, 0x9a, 0x22, 0x9e, 0x80, 0x68, 0xa1, 0xe1, 0x05, 0x8c, 0x94, 0x60, 0x5c, 0x8c, 0x7e, 0xec, + 0xe9, 0x38, 0x65, 0xca, 0xe8, 0xd9, 0x1a, 0x24, 0x1d, 0xdb, 0x51, 0xf0, 0x11, 0xb0, 0x5a, 0x91, + 0x3e, 0x53, 0xb8, 0xa3, 0xf0, 0x47, 0x42, 0xdd, 0x1e, 0x33, 0x44, 0x34, 0xbe, 0x9d, 0x05, 0x90, + 0x5a, 0x9b, 0x27, 0x76, 0x86, 0x7d, 0x41, 0x9b, 0x61, 0x8a, 0xbd, 0xd1, 0xf0, 0x99, 0xa9, 0xef, + 0xa1, 0x39, 0xcf, 0xf0, 0x79, 0xa9, 0x8b, 0x30, 0xba, 0x19, 0x29, 0xb4, 0x84, 0x4b, 0x0a, 0xaa, + 0xa3, 0x39, 0xdc, 0xd8, 0x81, 0x85, 0x5b, 0x34, 0x88, 0xd4, 0x5b, 0xf2, 0xe9, 0x71, 0x30, 0xdb, + 0x57, 0x61, 0x42, 0xe0, 0x87, 0xfb, 0x17, 0xd7, 0xc5, 0x88, 0xd8, 0x37, 0xa8, 0x8b, 0x91, 0x08, + 0x6c, 0x37, 0xaa, 0xd0, 0x16, 0x0d, 0xe8, 0xa7, 0x5b, 0x4d, 0x1d, 0x08, 0x6f, 0x0a, 0xb6, 0x6c, + 0xb8, 0x1a, 0x4e, 0xec, 0x9f, 0xfb, 0x70, 0x26, 0xfc, 0xf6, 0xc7, 0xc9, 0xf7, 0x1a, 0xbb, 0x52, + 0x8a, 0x44, 0x07, 0x11, 0xc7, 0x01, 0xb6, 0x27, 0xbf, 0x97, 0x81, 0x25, 0x49, 0xb1, 0xed, 0x84, + 0x96, 0x93, 0x43, 0x11, 0x93, 0xb7, 0x61, 0x52, 0xa1, 0x11, 0x91, 0xfa, 0x51, 0x4f, 0xfd, 0xd0, + 0x09, 0xf6, 0x2d, 0x9f, 0xc3, 0x55, 0x3d, 0xb5, 0x82, 0x4e, 0x76, 0x60, 0xa9, 0x5e, 0xba, 0xbb, + 0x1e, 0xa5, 0xf1, 0xdf, 0x70, 0x6f, 0xba, 0xad, 0x96, 0xfb, 0x70, 0xcb, 0x5c, 0x97, 0x99, 0x73, + 0x30, 0xc0, 0x07, 0x2a, 0xbd, 0x1f, 0x84, 0x68, 0x56, 0xc7, 0xb5, 0x76, 0x11, 0xd1, 0xea, 0x79, + 0x2d, 0xdf, 0x1c, 0xc0, 0xc5, 0xf8, 0xa7, 0x19, 0x78, 0x3a, 0x74, 0x4e, 0x4a, 0x69, 0x5f, 0xac, + 0x05, 0x99, 0xc7, 0xd9, 0x82, 0xec, 0x63, 0x69, 0xc1, 0x46, 0x34, 0x3e, 0xd5, 0x4e, 0xe8, 0xe3, + 0x2d, 0xbf, 0x9f, 0xa8, 0xe3, 0x23, 0x46, 0xe5, 0x99, 0x84, 0xd7, 0xb8, 0xe2, 0x1c, 0x6e, 0xbc, + 0xa5, 0x74, 0x48, 0x0a, 0x43, 0x8d, 0x38, 0x13, 0x27, 0xfe, 0x76, 0x16, 0x66, 0xef, 0x55, 0x2b, + 0xe5, 0xd0, 0x8e, 0xea, 0x33, 0x96, 0x01, 0x5c, 0x6b, 0x5b, 0xff, 0x9d, 0xd3, 0xd8, 0x82, 0xf9, + 0x58, 0x37, 0xa0, 0x10, 0xf4, 0x2e, 0x77, 0x9d, 0x09, 0xc1, 0x52, 0x00, 0x3a, 0x9b, 0xc6, 0xfe, + 0xfe, 0xeb, 0x66, 0x0c, 0xdb, 0xf8, 0x6f, 0x21, 0xc6, 0x57, 0x6c, 0xc6, 0xaf, 0xc2, 0x44, 0xd5, + 0xf7, 0x7b, 0xd4, 0xdb, 0x32, 0xd7, 0x55, 0xa5, 0x87, 0x83, 0x40, 0x36, 0x87, 0xcc, 0x08, 0x81, + 0x5c, 0x81, 0xbc, 0x08, 0xf7, 0x2e, 0x77, 0x37, 0xd4, 0x3f, 0x87, 0xd1, 0xe2, 0xcd, 0xb0, 0x98, + 0xbc, 0x01, 0x53, 0xfc, 0x6f, 0x3e, 0xa3, 0x45, 0x87, 0xa3, 0x9a, 0x53, 0xa0, 0xf3, 0x15, 0x60, + 0x6a, 0x68, 0xe4, 0x65, 0xc8, 0x95, 0xca, 0xa6, 0x50, 0x6c, 0x09, 0x09, 0xd8, 0xb3, 0xb8, 0xf6, + 0x51, 0xbb, 0x0e, 0x95, 0x4d, 0x26, 0xc7, 0xca, 0xb0, 0x19, 0x42, 0x27, 0x8f, 0x33, 0x40, 0xea, + 0xcd, 0x62, 0xc7, 0x32, 0xc2, 0xc8, 0x35, 0x18, 0xaf, 0x70, 0xe3, 0x3f, 0xa1, 0x91, 0xe7, 0x99, + 0x22, 0x39, 0x48, 0x0b, 0x13, 0xc1, 0x41, 0xe4, 0x8a, 0xcc, 0x35, 0x97, 0x8f, 0x3c, 0x70, 0xfa, + 0x24, 0x94, 0x7b, 0x15, 0xc6, 0x44, 0x50, 0xf4, 0x09, 0x25, 0x0b, 0x4d, 0x3c, 0x18, 0xba, 0xc0, + 0x49, 0xba, 0xe2, 0xc2, 0xe3, 0x74, 0xc5, 0xdd, 0x81, 0x73, 0xb7, 0x50, 0x0f, 0xa5, 0x87, 0xf6, + 0xda, 0x32, 0xab, 0x42, 0xb3, 0x8f, 0x0f, 0x5a, 0x5c, 0x55, 0x15, 0x8f, 0x0e, 0x66, 0xf5, 0x3c, + 0x35, 0xf1, 0x71, 0x3f, 0x46, 0xe4, 0x2b, 0xb0, 0x90, 0x56, 0x24, 0xf4, 0xff, 0x18, 0xc4, 0x2a, + 0xbd, 0x02, 0x35, 0x88, 0x55, 0x1a, 0x07, 0xb2, 0x0e, 0x05, 0x0e, 0x2f, 0x35, 0xdb, 0x4e, 0x87, + 0xbf, 0x61, 0xf0, 0xf7, 0x01, 0x74, 0x89, 0x11, 0x5c, 0x6d, 0x56, 0xc8, 0xdf, 0x32, 0x34, 0x27, + 0xaa, 0x18, 0x25, 0xf9, 0xa9, 0x0c, 0xbb, 0x97, 0xf2, 0x10, 0xe2, 0xb8, 0x7d, 0xce, 0x88, 0xd7, + 0xd0, 0xd0, 0xab, 0xa9, 0x1e, 0x78, 0x4e, 0x67, 0x4f, 0x38, 0x48, 0x6d, 0x0a, 0x07, 0xa9, 0xb7, + 0x3f, 0x96, 0x83, 0x14, 0x67, 0xe5, 0x1f, 0x1f, 0x15, 0xa7, 0x3c, 0x51, 0x27, 0xae, 0x22, 0xed, + 0x0b, 0x58, 0xd7, 0xa1, 0x97, 0xf0, 0x56, 0x87, 0x07, 0x30, 0xa6, 0x4d, 0xde, 0xc8, 0x59, 0xdc, + 0xd8, 0xb1, 0xeb, 0x6c, 0xbe, 0x89, 0x87, 0x08, 0x89, 0x86, 0xa6, 0x72, 0x60, 0x57, 0x68, 0xe9, + 0x84, 0xc3, 0xfd, 0x8a, 0x0b, 0xd1, 0x15, 0x5a, 0x7a, 0xec, 0x58, 0x38, 0x8d, 0xd4, 0xc9, 0xa3, + 0x91, 0x90, 0x6b, 0x30, 0x76, 0xd7, 0x7e, 0x54, 0xda, 0xa3, 0x22, 0x33, 0xea, 0xb4, 0xdc, 0xfe, + 0x10, 0xb8, 0x92, 0xff, 0x5d, 0xee, 0xb5, 0xf1, 0x94, 0x29, 0xd0, 0xc8, 0xf7, 0x67, 0xe0, 0x2c, + 0x5f, 0xc6, 0xb2, 0x95, 0x75, 0x1a, 0x04, 0xac, 0x1f, 0x44, 0x24, 0xc4, 0x8b, 0x91, 0xe9, 0x79, + 0x3a, 0x1e, 0xc6, 0x10, 0x30, 0xc4, 0xce, 0x10, 0x76, 0x9c, 0x2f, 0x4a, 0xb5, 0x90, 0xd2, 0xa9, + 0xf4, 0x64, 0x13, 0x26, 0xef, 0xde, 0x2c, 0x85, 0xd5, 0xf2, 0x38, 0xf3, 0xc5, 0xb4, 0xdd, 0x51, + 0x41, 0x4b, 0xf3, 0x99, 0x50, 0xd9, 0x08, 0x3f, 0x87, 0x2f, 0xc8, 0xfe, 0x20, 0xaf, 0xa9, 0x4e, + 0xb5, 0x39, 0xbc, 0x07, 0x8c, 0xb7, 0xed, 0x47, 0x96, 0xbd, 0x47, 0xb5, 0xf7, 0x7e, 0xa1, 0x87, + 0xff, 0xd9, 0x0c, 0x9c, 0xef, 0xdb, 0x64, 0x72, 0x03, 0xce, 0xd9, 0xdc, 0x55, 0xdc, 0xda, 0x0f, + 0x82, 0xae, 0x6f, 0xc9, 0xcb, 0x92, 0x70, 0xc3, 0x35, 0xcf, 0x88, 0xe2, 0x35, 0x56, 0x2a, 0xef, + 0x4f, 0x3e, 0x79, 0x0f, 0x9e, 0x71, 0x3a, 0x3e, 0x6d, 0xf4, 0x3c, 0x6a, 0x49, 0x06, 0x0d, 0xa7, + 0xe9, 0x59, 0x9e, 0xdd, 0xd9, 0x93, 0x3e, 0xc5, 0xe6, 0x79, 0x89, 0x23, 0xdc, 0xd1, 0xcb, 0x4e, + 0xd3, 0x33, 0x11, 0xc1, 0xf8, 0x37, 0x19, 0x58, 0xec, 0xd7, 0x25, 0x64, 0x11, 0xc6, 0xa9, 0x92, + 0x71, 0x26, 0x6f, 0xca, 0x9f, 0xe4, 0x69, 0x88, 0x76, 0x7a, 0x71, 0xfa, 0xe7, 0x1b, 0x22, 0xfb, + 0x07, 0x1a, 0xe9, 0xab, 0xfb, 0xba, 0x30, 0xb5, 0x9e, 0x6a, 0xa8, 0xbb, 0xfb, 0x05, 0x80, 0x68, + 0x3b, 0xe7, 0x2a, 0x16, 0x73, 0xc2, 0x6e, 0x78, 0x7c, 0xe5, 0x91, 0xb3, 0x30, 0xc6, 0xb7, 0x4b, + 0xe1, 0xc9, 0x21, 0x7e, 0xb1, 0x73, 0x5b, 0x74, 0x32, 0xee, 0xf3, 0xb9, 0x95, 0x29, 0xad, 0xb3, + 0xc7, 0xda, 0x38, 0x38, 0xc6, 0x4f, 0x4f, 0x73, 0x11, 0xa2, 0xd4, 0x0b, 0xf6, 0xa5, 0xd0, 0xb1, + 0x9c, 0xe6, 0xf9, 0xc6, 0xad, 0x42, 0x15, 0x0b, 0x73, 0xdd, 0xdf, 0x4d, 0xbe, 0x62, 0x65, 0x53, + 0x5f, 0xb1, 0x5e, 0x85, 0x89, 0xf2, 0x3e, 0x6d, 0x1c, 0x84, 0xee, 0x44, 0x79, 0xf1, 0x4c, 0xc0, + 0x80, 0x3c, 0xb8, 0x7b, 0x84, 0x40, 0xae, 0x01, 0xa0, 0xc3, 0x2d, 0x97, 0xad, 0x95, 0x04, 0x2d, + 0xe8, 0x9f, 0x2b, 0x0c, 0x6d, 0x14, 0x14, 0x64, 0x5f, 0x37, 0x6f, 0xaa, 0x96, 0x39, 0x9c, 0xbd, + 0xef, 0xed, 0x0a, 0xf4, 0x08, 0x81, 0x35, 0x4f, 0xd9, 0x57, 0xc4, 0x29, 0x58, 0x48, 0x6c, 0x3e, + 0x2a, 0x12, 0xb9, 0x0a, 0x13, 0x35, 0xe9, 0x12, 0x81, 0x87, 0xe0, 0x14, 0x52, 0x40, 0xe4, 0x3e, + 0xb1, 0x98, 0x31, 0x23, 0x14, 0xf2, 0x05, 0x18, 0x2f, 0x53, 0x2f, 0xd8, 0xdc, 0x5c, 0x47, 0xf3, + 0x19, 0x9e, 0xc7, 0x24, 0x8f, 0x39, 0x27, 0x82, 0xa0, 0xf5, 0xdd, 0xa3, 0xe2, 0x74, 0xe0, 0xb4, + 0x69, 0x18, 0x9f, 0xdd, 0x94, 0xd8, 0x64, 0x05, 0x0a, 0xfc, 0x81, 0x3f, 0xba, 0x45, 0xe1, 0xc9, + 0x98, 0xe7, 0xe7, 0xb4, 0xb0, 0x06, 0x78, 0x48, 0x77, 0xc2, 0x8c, 0x1b, 0x09, 0x7c, 0xb2, 0x2a, + 0x13, 0xd5, 0xa8, 0xcd, 0x84, 0x48, 0xad, 0x17, 0xdf, 0x31, 0x58, 0x6b, 0x93, 0x14, 0xa4, 0x04, + 0xd3, 0x65, 0xb7, 0xdd, 0xb5, 0x03, 0x07, 0x33, 0x7a, 0x1e, 0x8a, 0x43, 0x10, 0x55, 0x93, 0x0d, + 0xb5, 0x40, 0x3b, 0x51, 0xd5, 0x02, 0x72, 0x13, 0x66, 0x4c, 0xb7, 0xc7, 0x86, 0x49, 0xea, 0x13, + 0xf8, 0x39, 0x87, 0x46, 0x2e, 0x1e, 0x2b, 0x61, 0xc7, 0xb2, 0x50, 0x1e, 0x68, 0xb1, 0x6c, 0x35, + 0x2a, 0xb2, 0x91, 0xf2, 0xb0, 0xa3, 0x1e, 0x6e, 0x6a, 0xde, 0x8d, 0x04, 0xb3, 0x94, 0x37, 0xa1, + 0xd7, 0x61, 0xb2, 0x5e, 0xbf, 0xb7, 0x49, 0xfd, 0xe0, 0x66, 0xcb, 0x7d, 0x88, 0x67, 0x5b, 0x5e, + 0xa4, 0x89, 0xf3, 0x5d, 0x2b, 0xa0, 0x7e, 0x60, 0xed, 0xb6, 0xdc, 0x87, 0xa6, 0x8a, 0x45, 0xbe, + 0xce, 0xfa, 0x43, 0x91, 0x04, 0x45, 0xd4, 0xde, 0x41, 0xc2, 0x2a, 0x9e, 0x20, 0xd1, 0xa2, 0x61, + 0x22, 0xab, 0xde, 0x59, 0x0a, 0x3a, 0x7a, 0xc7, 0x79, 0xee, 0xa3, 0xc3, 0x52, 0xb3, 0xe9, 0x51, + 0xdf, 0x17, 0x87, 0x10, 0xf7, 0x8e, 0x43, 0xb5, 0x89, 0xcd, 0x0b, 0x34, 0xef, 0x38, 0x85, 0x80, + 0xfc, 0x68, 0x06, 0xce, 0xa8, 0x7e, 0x33, 0xb8, 0x5c, 0xd0, 0x60, 0x87, 0x1f, 0x49, 0xaf, 0x5d, + 0x95, 0x87, 0xf0, 0x55, 0x05, 0xed, 0xea, 0x83, 0xeb, 0x57, 0x4b, 0xd1, 0xcf, 0xba, 0x24, 0xc2, + 0x08, 0x84, 0xc5, 0x54, 0x7e, 0x5a, 0x96, 0xa5, 0x05, 0x3b, 0x85, 0x98, 0x94, 0x99, 0xa4, 0xc6, + 0x66, 0x14, 0x9a, 0x80, 0x55, 0x6b, 0x78, 0xa6, 0x09, 0xdd, 0xb0, 0x98, 0x7f, 0xdc, 0x58, 0xcc, + 0xe9, 0xea, 0x02, 0x99, 0x42, 0x43, 0xaa, 0x30, 0xcb, 0x01, 0x6c, 0x5b, 0xe0, 0x09, 0xab, 0xe6, + 0xa3, 0x94, 0x19, 0x82, 0x0d, 0x5a, 0x2d, 0x60, 0xd2, 0x2a, 0x35, 0xcc, 0x6c, 0x8c, 0x8e, 0xbc, + 0x07, 0x33, 0x98, 0x0d, 0x20, 0x5a, 0xaf, 0x0b, 0xb8, 0x8a, 0x31, 0x5a, 0xae, 0x28, 0x89, 0xf9, + 0x10, 0x4e, 0xf9, 0xfe, 0x7e, 0xb4, 0xa2, 0xdf, 0x83, 0x19, 0xb4, 0x3a, 0x8a, 0x18, 0x9c, 0x89, + 0x18, 0x88, 0x92, 0x38, 0x83, 0xa0, 0xe5, 0x47, 0x0c, 0x7e, 0x26, 0x03, 0xe7, 0x59, 0x45, 0xe9, + 0x23, 0x74, 0xf6, 0xe3, 0x8c, 0x10, 0xc6, 0x0f, 0xed, 0xcb, 0x53, 0x15, 0x47, 0x7d, 0x7f, 0x3f, + 0x8d, 0x03, 0x7e, 0x14, 0xfb, 0xf8, 0xf4, 0x8f, 0x3a, 0xf7, 0xb1, 0x3f, 0xaa, 0x2f, 0x4f, 0xf5, + 0xa3, 0x82, 0x96, 0x9f, 0xc6, 0x01, 0xaf, 0xb5, 0xec, 0x0a, 0x1e, 0xdd, 0xcd, 0x3e, 0x5b, 0x0e, + 0x38, 0x5a, 0xdb, 0x06, 0x38, 0xe0, 0x6c, 0x71, 0x7f, 0x70, 0xa5, 0x1b, 0xe4, 0xb5, 0x56, 0x03, + 0xc7, 0xaf, 0xb5, 0x31, 0x1a, 0x33, 0x86, 0x6d, 0x7c, 0x7b, 0x32, 0xc6, 0x57, 0x18, 0xdd, 0x1a, + 0x30, 0xc6, 0x6f, 0xad, 0xa2, 0x93, 0xd1, 0xfa, 0x82, 0xdf, 0x69, 0x4d, 0x51, 0x42, 0xce, 0x43, + 0xae, 0x5e, 0xbf, 0x27, 0x3a, 0x19, 0x4d, 0x6f, 0x7d, 0xdf, 0x35, 0x19, 0x8c, 0x8d, 0x10, 0xda, + 0xd3, 0x2a, 0xd9, 0x15, 0xd8, 0x79, 0x67, 0x22, 0x94, 0xf5, 0xb7, 0xbc, 0x43, 0x8e, 0x44, 0xfd, + 0x2d, 0xee, 0x90, 0xd1, 0xcd, 0xb1, 0x0c, 0x8b, 0x25, 0xdf, 0xa7, 0x1e, 0x9b, 0x10, 0xc2, 0x4c, + 0xd3, 0x13, 0xf7, 0x1c, 0x71, 0xb0, 0x63, 0xa5, 0x76, 0xc3, 0x37, 0xfb, 0x22, 0x92, 0xcb, 0x90, + 0x2f, 0xf5, 0x9a, 0x0e, 0xed, 0x34, 0xb4, 0x00, 0x73, 0xb6, 0x80, 0x99, 0x61, 0x29, 0x79, 0x1f, + 0xce, 0xc4, 0x62, 0x49, 0x8a, 0x1e, 0x18, 0x8f, 0xf6, 0x5e, 0x79, 0x0f, 0x8b, 0x4c, 0x4b, 0x78, + 0x97, 0xa4, 0x53, 0x92, 0x12, 0x14, 0x56, 0xd1, 0xe1, 0xac, 0x42, 0xf9, 0x2b, 0x97, 0xeb, 0x71, + 0x4f, 0x43, 0x7e, 0x6b, 0x16, 0x11, 0x33, 0x9b, 0x61, 0xa1, 0x99, 0x40, 0x27, 0x77, 0x60, 0x3e, + 0x0e, 0x63, 0x27, 0x38, 0xbf, 0x20, 0xe3, 0x7e, 0x93, 0xe0, 0x82, 0x67, 0x78, 0x1a, 0x15, 0xd9, + 0x81, 0xb9, 0xc8, 0xb4, 0x4a, 0xbf, 0x36, 0x4b, 0x8b, 0xed, 0xb0, 0x5c, 0x5e, 0x9d, 0x9f, 0x16, + 0x93, 0x71, 0x3e, 0x32, 0xd3, 0x0a, 0xaf, 0xcf, 0x66, 0x92, 0x1d, 0x69, 0xc2, 0x4c, 0xdd, 0xd9, + 0xeb, 0x38, 0x9d, 0xbd, 0x3b, 0xf4, 0xb0, 0x66, 0x3b, 0x9e, 0xb0, 0x9d, 0x95, 0x96, 0xf1, 0x25, + 0xff, 0xb0, 0xdd, 0xa6, 0x81, 0x87, 0x1b, 0x21, 0x2b, 0x47, 0x6f, 0x7a, 0x76, 0x1d, 0x5a, 0xf2, + 0x39, 0x1d, 0x3a, 0xa0, 0x76, 0x6d, 0x47, 0x13, 0x02, 0x74, 0x9e, 0x9a, 0xea, 0x62, 0x6a, 0x48, + 0xd5, 0x45, 0x0b, 0xe6, 0x56, 0x3b, 0x0d, 0xef, 0x10, 0x1f, 0x1b, 0xe5, 0xc7, 0x4d, 0x9f, 0xf0, + 0x71, 0x2f, 0x88, 0x8f, 0x7b, 0xc6, 0x96, 0x33, 0x2c, 0xed, 0xf3, 0x92, 0x8c, 0x49, 0x1d, 0xe6, + 0xf0, 0xe2, 0x50, 0xad, 0xd4, 0xaa, 0x1d, 0x27, 0x70, 0xec, 0x80, 0x36, 0x85, 0x70, 0x11, 0xe6, + 0xa4, 0xe1, 0x57, 0x54, 0xa7, 0xd9, 0xb5, 0x1c, 0x89, 0xa2, 0x32, 0x4d, 0xd0, 0x0f, 0xba, 0x27, + 0xce, 0xfe, 0x29, 0xdd, 0x13, 0xab, 0x30, 0x1b, 0x0f, 0x4a, 0x51, 0x88, 0xce, 0x61, 0x1f, 0x8b, + 0xd8, 0x71, 0xee, 0xf6, 0x50, 0x98, 0xd4, 0xd2, 0xc0, 0xc6, 0xc2, 0x51, 0xc4, 0xae, 0x9c, 0x73, + 0xda, 0x95, 0x53, 0xdb, 0x95, 0x4e, 0x71, 0xe5, 0x24, 0x35, 0x80, 0x9b, 0xae, 0xd7, 0xa0, 0x25, + 0xf4, 0xf4, 0x26, 0x5a, 0xe6, 0x2e, 0xc6, 0x34, 0x2a, 0xe4, 0xeb, 0x67, 0x97, 0xfd, 0xb6, 0xe2, + 0x0e, 0xfb, 0x0a, 0x0f, 0x62, 0xc3, 0xb9, 0x9a, 0x47, 0x77, 0xa9, 0xe7, 0xd1, 0xa6, 0xb8, 0x17, + 0xad, 0x38, 0x9d, 0xa6, 0x4c, 0xc7, 0x26, 0x62, 0x77, 0x77, 0x25, 0x4a, 0x68, 0x69, 0xbe, 0xc3, + 0x91, 0xd4, 0x63, 0xae, 0x0f, 0x1f, 0xe3, 0xc7, 0xb2, 0xb0, 0xd8, 0xaf, 0xc5, 0x03, 0x6e, 0x94, + 0xaf, 0x40, 0x72, 0x13, 0x11, 0x37, 0xcb, 0x02, 0x8d, 0x6f, 0x25, 0xcb, 0x90, 0xbe, 0x57, 0x88, + 0x9b, 0xe6, 0x7c, 0x9c, 0x60, 0xcb, 0x6b, 0x91, 0x1b, 0x30, 0xa9, 0xf4, 0x0f, 0x6e, 0xd7, 0xfd, + 0x7a, 0xd3, 0x84, 0xdd, 0xa8, 0xcb, 0xce, 0x82, 0x38, 0x2d, 0xe4, 0x4d, 0x94, 0xff, 0x22, 0x05, + 0xee, 0x4f, 0x3f, 0xc6, 0x4d, 0x26, 0x7c, 0xdf, 0x25, 0x04, 0xf0, 0x68, 0xe0, 0xbb, 0xac, 0x89, + 0x7f, 0x1b, 0xbf, 0x32, 0xcd, 0x0f, 0x7d, 0xf5, 0x22, 0xda, 0xcf, 0x98, 0x3a, 0x76, 0x41, 0xcd, + 0x9e, 0xe6, 0x82, 0x9a, 0x3b, 0xf9, 0x82, 0x3a, 0x72, 0xd2, 0x05, 0x35, 0x76, 0x83, 0x1c, 0x3d, + 0xf5, 0x0d, 0x72, 0xec, 0x54, 0x37, 0xc8, 0xf1, 0x53, 0xdd, 0x20, 0xb5, 0xcb, 0x70, 0xfe, 0xa4, + 0xcb, 0xf0, 0x9f, 0xdf, 0x37, 0x9f, 0xd4, 0xfb, 0x66, 0x9a, 0x14, 0x79, 0xaa, 0xfb, 0xe6, 0x8f, + 0xf4, 0xbd, 0x2e, 0x16, 0x3e, 0x8e, 0xdc, 0xff, 0xfc, 0x10, 0xd7, 0xc5, 0x61, 0x2f, 0x8b, 0x73, + 0x8f, 0xe7, 0xb2, 0x48, 0x1e, 0xdb, 0x65, 0x71, 0xfe, 0x93, 0x5e, 0x16, 0x17, 0x1e, 0xe7, 0x65, + 0xf1, 0xcc, 0x9f, 0xc5, 0xcb, 0xe2, 0xd9, 0xff, 0x20, 0x97, 0x45, 0x34, 0x34, 0x71, 0xfd, 0xe0, + 0xa6, 0xeb, 0xb5, 0xf1, 0xbe, 0x3a, 0x25, 0x0c, 0x4d, 0x5c, 0x9f, 0xe7, 0x72, 0xd6, 0xc4, 0x42, + 0x81, 0x48, 0x56, 0xe4, 0x84, 0x93, 0x77, 0xc0, 0xc5, 0x48, 0xe1, 0x2f, 0x66, 0x8a, 0xb8, 0x0a, + 0x26, 0xe7, 0x9b, 0x20, 0x31, 0xfe, 0x02, 0x14, 0xe2, 0x82, 0xf3, 0xc9, 0xb1, 0xa9, 0x1f, 0x5b, + 0x60, 0x50, 0x26, 0xd6, 0xc7, 0x05, 0x57, 0x72, 0x0d, 0xa0, 0xe6, 0x39, 0x0f, 0xec, 0x80, 0xde, + 0x91, 0x36, 0x8a, 0x22, 0xae, 0x3a, 0x87, 0xb2, 0x29, 0x67, 0x2a, 0x28, 0xe1, 0x9d, 0x2d, 0x9b, + 0x76, 0x67, 0x33, 0x7e, 0x34, 0x0b, 0x73, 0x3c, 0xba, 0xde, 0x93, 0xff, 0xc0, 0xfc, 0xae, 0x76, + 0x13, 0x7f, 0x26, 0xca, 0xe4, 0xa0, 0xb6, 0x6e, 0xc0, 0x13, 0xf3, 0x87, 0x70, 0x26, 0xd1, 0x15, + 0x78, 0x1b, 0xaf, 0xc8, 0xb8, 0x86, 0x89, 0xfb, 0xf8, 0x62, 0x7a, 0x25, 0xf7, 0x5f, 0x37, 0x13, + 0x14, 0xc6, 0x1f, 0x8f, 0x24, 0xf8, 0x8b, 0xc7, 0x66, 0xf5, 0xf9, 0x38, 0x73, 0xba, 0xe7, 0xe3, + 0xec, 0x70, 0xcf, 0xc7, 0x31, 0x69, 0x26, 0x37, 0x8c, 0x34, 0xf3, 0x3e, 0x4c, 0x6f, 0x52, 0xbb, + 0xed, 0x6f, 0xba, 0x22, 0x2d, 0x18, 0xf7, 0x88, 0x91, 0x61, 0x0b, 0x59, 0x99, 0xbc, 0x4c, 0x86, + 0x96, 0xbd, 0x01, 0x23, 0x60, 0xe7, 0x2f, 0xcf, 0x13, 0x66, 0xea, 0x1c, 0x54, 0x0d, 0xc1, 0xe8, + 0x00, 0x0d, 0x41, 0x1d, 0xa6, 0x04, 0x5d, 0x14, 0x90, 0x3b, 0xba, 0xca, 0xb2, 0x22, 0x84, 0xcb, + 0xda, 0xa5, 0x6b, 0xea, 0x4c, 0x58, 0x3b, 0xbf, 0xc5, 0x6a, 0x4c, 0x58, 0x17, 0xac, 0x76, 0x9a, + 0x5d, 0xd7, 0xe9, 0x60, 0x17, 0x8c, 0x47, 0x5d, 0x40, 0x05, 0x98, 0x77, 0x81, 0x82, 0x44, 0xde, + 0x86, 0x99, 0x52, 0xad, 0xaa, 0x92, 0xe5, 0xa3, 0x17, 0x6c, 0xbb, 0xeb, 0x58, 0x1a, 0x69, 0x0c, + 0x77, 0xd0, 0xad, 0x6e, 0xe2, 0x4f, 0xe7, 0x56, 0x67, 0xfc, 0xcb, 0x69, 0xb9, 0xbc, 0x3f, 0xdd, + 0xc7, 0x1f, 0xfd, 0x39, 0x27, 0x77, 0xca, 0xe7, 0x9c, 0x91, 0x93, 0x24, 0x58, 0x4d, 0xb0, 0x1e, + 0x3d, 0x95, 0x60, 0x3d, 0xf6, 0x89, 0x9f, 0x66, 0xc6, 0x4f, 0x29, 0x2a, 0xc7, 0xd6, 0x5a, 0x7e, + 0x98, 0xb5, 0x96, 0x2a, 0x5e, 0x4f, 0x7c, 0x72, 0xf1, 0x1a, 0x4e, 0x2d, 0x5e, 0xd7, 0x23, 0x0f, + 0xf3, 0xc9, 0x13, 0x1d, 0x77, 0x2e, 0x08, 0x8d, 0xc7, 0x5c, 0x7a, 0xac, 0xc4, 0xd0, 0xd7, 0xfc, + 0x33, 0x25, 0xb3, 0x7f, 0x23, 0x5d, 0x66, 0x1f, 0x7c, 0xde, 0x9c, 0x4a, 0x6a, 0xff, 0xd1, 0xc7, + 0x2b, 0xb5, 0x3f, 0xde, 0x47, 0x9e, 0x3f, 0x97, 0xdb, 0xff, 0x5c, 0x6e, 0x1f, 0x52, 0x6e, 0xbf, + 0x07, 0xc4, 0xee, 0x05, 0xfb, 0xb4, 0x13, 0x38, 0x0d, 0x8c, 0x1d, 0xcc, 0x86, 0x18, 0x25, 0x78, + 0xb1, 0x5e, 0x93, 0xa5, 0xea, 0x7a, 0xd5, 0x4a, 0xd1, 0x1b, 0xdf, 0xc3, 0xf5, 0xba, 0x6d, 0x7b, + 0x1d, 0x54, 0xa0, 0x5d, 0x83, 0x71, 0x19, 0x7d, 0x36, 0x13, 0xa9, 0xdf, 0x93, 0x61, 0x67, 0x25, + 0x16, 0x59, 0x86, 0xbc, 0x24, 0x56, 0xd3, 0x21, 0x3d, 0x14, 0x30, 0x2d, 0xb0, 0xa7, 0x80, 0x19, + 0xff, 0xd9, 0x88, 0x3c, 0x13, 0xd8, 0x27, 0xd4, 0x6c, 0xcf, 0x6e, 0x63, 0xa6, 0xc4, 0x70, 0xc9, + 0x2a, 0xb7, 0x81, 0xd8, 0x2a, 0x8f, 0x79, 0x74, 0xe8, 0x24, 0x1f, 0x2b, 0x7c, 0x70, 0x94, 0x8c, + 0x3a, 0x37, 0x44, 0x32, 0xea, 0x37, 0xb5, 0x4c, 0xce, 0x23, 0x51, 0xea, 0x50, 0xb6, 0x4f, 0x0e, + 0xce, 0xe1, 0x7c, 0x43, 0x4d, 0xb9, 0x3c, 0x1a, 0x05, 0x73, 0x43, 0xca, 0x01, 0xc9, 0x96, 0xc3, + 0xeb, 0xcd, 0xd8, 0x69, 0x02, 0x73, 0x8f, 0xff, 0x07, 0x0d, 0xcc, 0xbd, 0x0a, 0x20, 0xce, 0xee, + 0xc8, 0x96, 0xe3, 0x45, 0xdc, 0x4e, 0x84, 0x75, 0x7a, 0x10, 0xb4, 0xfa, 0x64, 0x6e, 0x51, 0x08, + 0x8d, 0x7f, 0x41, 0x60, 0xae, 0x5e, 0xbf, 0x57, 0x71, 0xec, 0xbd, 0x8e, 0xeb, 0x07, 0x4e, 0xa3, + 0xda, 0xd9, 0x75, 0x99, 0x6c, 0x1f, 0x9e, 0x2f, 0x4a, 0x48, 0xe5, 0xe8, 0x6c, 0x09, 0x8b, 0xd9, + 0xdd, 0x71, 0xd5, 0xf3, 0xa4, 0xa6, 0x97, 0xdf, 0x1d, 0x29, 0x03, 0x98, 0x1c, 0xce, 0xc4, 0xe7, + 0x7a, 0x0f, 0x03, 0x9a, 0x08, 0x03, 0x1b, 0x14, 0x9f, 0x7d, 0x0e, 0x32, 0x65, 0x19, 0xa1, 0xc9, + 0x09, 0x2b, 0xae, 0x53, 0xe7, 0xb4, 0xf0, 0xde, 0x51, 0x31, 0x5f, 0x8d, 0x42, 0xba, 0xc1, 0x7d, + 0xb8, 0x8b, 0x70, 0xd5, 0x7c, 0x30, 0xb1, 0x06, 0x0e, 0xe1, 0x8c, 0xe6, 0xea, 0x3e, 0xec, 0xcb, + 0xd3, 0xcb, 0x42, 0x5c, 0x37, 0xd0, 0x44, 0x3b, 0xe5, 0xf9, 0x49, 0x4d, 0x7d, 0x98, 0x5a, 0x03, + 0x3b, 0x20, 0x2f, 0xa4, 0x96, 0x84, 0xab, 0x7b, 0x52, 0x0b, 0xb1, 0xae, 0x6c, 0x1a, 0x3c, 0xc9, + 0x63, 0xbf, 0xaa, 0xad, 0x94, 0xad, 0x60, 0x70, 0x4d, 0xe4, 0x1f, 0x67, 0xe0, 0x9c, 0x86, 0x11, + 0xee, 0x7f, 0x7e, 0x18, 0x05, 0x26, 0x75, 0x5e, 0x7f, 0xf4, 0x78, 0xe6, 0xf5, 0xf3, 0x7a, 0x5b, + 0xa2, 0x1d, 0x5a, 0x6d, 0x43, 0xbf, 0x2f, 0x24, 0x0f, 0x60, 0x0e, 0x8b, 0xe4, 0x2b, 0x18, 0x9b, + 0xb3, 0xe2, 0xf1, 0x6c, 0x21, 0xfa, 0x6c, 0x1e, 0xbe, 0x01, 0x13, 0xf5, 0x2f, 0x7f, 0xe7, 0xa8, + 0x38, 0xad, 0xa1, 0xcb, 0xa0, 0xe5, 0x56, 0xf4, 0x94, 0xe6, 0x74, 0x76, 0x5d, 0x75, 0x27, 0x4f, + 0x54, 0x41, 0xfe, 0x69, 0x86, 0x3f, 0x8c, 0xf0, 0x66, 0xdc, 0xf4, 0xdc, 0x76, 0x58, 0x2e, 0xed, + 0x50, 0xfb, 0x74, 0x5b, 0xeb, 0xf1, 0x74, 0xdb, 0x8b, 0xf8, 0xc9, 0x7c, 0x4f, 0xb0, 0x76, 0x3d, + 0xb7, 0x1d, 0x7d, 0xbe, 0xda, 0x71, 0x7d, 0x3f, 0x92, 0xfc, 0x40, 0x06, 0xce, 0x6b, 0xfa, 0x59, + 0x35, 0x83, 0x8c, 0x08, 0x92, 0x31, 0x1f, 0x86, 0xcf, 0x89, 0x8a, 0x56, 0xae, 0x8a, 0xf9, 0x7f, + 0x09, 0xbf, 0x40, 0x89, 0xd6, 0xca, 0x90, 0xac, 0x36, 0xc7, 0x52, 0x3e, 0xa1, 0x7f, 0x2d, 0xc4, + 0x81, 0x39, 0x34, 0x49, 0xd2, 0xec, 0xa5, 0x17, 0xfa, 0xdb, 0x4b, 0x87, 0xb9, 0xa1, 0x30, 0x6f, + 0x44, 0x7f, 0xa3, 0xe9, 0x24, 0x57, 0xf2, 0x7d, 0x70, 0x3e, 0x01, 0x0c, 0x57, 0xdb, 0x99, 0xbe, + 0xab, 0xed, 0x95, 0xe3, 0xa3, 0xe2, 0x4b, 0x69, 0xb5, 0xa5, 0xad, 0xb4, 0xfe, 0x35, 0x10, 0x1b, + 0x20, 0x2a, 0x14, 0xf2, 0x4c, 0xfa, 0x04, 0x7d, 0x45, 0xcc, 0x0f, 0x05, 0x9f, 0xed, 0xe5, 0xca, + 0x37, 0xa8, 0x47, 0x5e, 0x84, 0x44, 0x28, 0x4c, 0x29, 0x39, 0x33, 0x0e, 0x85, 0x65, 0x4c, 0x9f, + 0x4a, 0xbe, 0x73, 0x54, 0xd4, 0xb0, 0xd9, 0x0d, 0x4b, 0x4d, 0xc6, 0xa1, 0x89, 0x8f, 0x2a, 0x22, + 0xf9, 0xb5, 0x0c, 0x2c, 0x30, 0x40, 0x34, 0xa9, 0x44, 0xa3, 0x16, 0x07, 0xcd, 0xfa, 0xfd, 0xc7, + 0x33, 0xeb, 0x9f, 0xc3, 0x6f, 0x54, 0x67, 0x7d, 0xa2, 0x4b, 0x52, 0x3f, 0x0e, 0x67, 0xbb, 0x66, + 0xfd, 0xa6, 0xcd, 0xf6, 0xf3, 0x43, 0xcc, 0x76, 0x3e, 0x00, 0x27, 0xcf, 0xf6, 0xbe, 0xb5, 0x90, + 0x4d, 0x98, 0x12, 0x97, 0x2b, 0xde, 0x61, 0xcf, 0x6a, 0xd1, 0xbb, 0xd5, 0x22, 0x7e, 0xe3, 0x15, + 0x29, 0x45, 0x12, 0x2d, 0xd4, 0xb8, 0x90, 0x0e, 0xcc, 0xf3, 0xdf, 0xba, 0xb2, 0xab, 0xd8, 0x57, + 0xd9, 0x75, 0x59, 0xb4, 0xe8, 0xa2, 0xe0, 0x1f, 0xd3, 0x79, 0xa9, 0x51, 0xb7, 0x52, 0x18, 0x93, + 0x2e, 0x10, 0x0d, 0xcc, 0x17, 0xed, 0xc5, 0xc1, 0x2a, 0xae, 0x97, 0x44, 0x9d, 0xc5, 0x78, 0x9d, + 0xf1, 0x95, 0x9b, 0xc2, 0x9b, 0xd8, 0x30, 0x2b, 0xa0, 0xee, 0x01, 0xe5, 0x3b, 0xfc, 0x73, 0x5a, + 0xdc, 0xb3, 0x58, 0x29, 0xbf, 0x95, 0xc9, 0x9a, 0x30, 0x2e, 0x5d, 0x6c, 0x43, 0x8f, 0xf3, 0x23, + 0xf7, 0x60, 0xae, 0xd4, 0xed, 0xb6, 0x1c, 0xda, 0xc4, 0x56, 0x9a, 0x3d, 0xd6, 0x26, 0x23, 0xca, + 0xca, 0x67, 0xf3, 0x42, 0x71, 0x55, 0xf4, 0x7a, 0xb1, 0xed, 0x26, 0x41, 0x6b, 0xfc, 0x48, 0x26, + 0xf1, 0xd1, 0xe4, 0x55, 0x98, 0xc0, 0x1f, 0x4a, 0x28, 0x1d, 0xd4, 0x19, 0xf1, 0x4f, 0x44, 0x6d, + 0x54, 0x84, 0xc0, 0x84, 0x25, 0x35, 0x9c, 0x66, 0x8e, 0x0b, 0x4b, 0x42, 0x51, 0x11, 0xa9, 0x26, + 0x8a, 0xd2, 0x8f, 0x25, 0x17, 0x09, 0x5d, 0xe8, 0xc7, 0x22, 0xbc, 0x57, 0x8c, 0xbf, 0x97, 0xd5, + 0xa7, 0x1d, 0xb9, 0xac, 0xc8, 0xed, 0x4a, 0x40, 0x4f, 0x29, 0xb7, 0x2b, 0xd2, 0xfa, 0xdf, 0xce, + 0xc0, 0xfc, 0x3d, 0x25, 0x9d, 0xeb, 0xa6, 0x8b, 0xe3, 0x32, 0x38, 0xc1, 0xe9, 0xe3, 0x4a, 0xd4, + 0xa8, 0xe6, 0x91, 0x65, 0x33, 0x05, 0xa7, 0x8c, 0x99, 0xf6, 0x3d, 0xe8, 0xe3, 0x88, 0x1f, 0xa6, + 0xe4, 0xcb, 0xe4, 0xe8, 0x1c, 0x7e, 0xca, 0x04, 0x23, 0xc6, 0x4f, 0x64, 0x61, 0x52, 0x59, 0x31, + 0xe4, 0xf3, 0x30, 0xa5, 0x56, 0xab, 0x2a, 0x1c, 0xd5, 0xaf, 0x34, 0x35, 0x2c, 0xd4, 0x38, 0x52, + 0xbb, 0xad, 0x69, 0x1c, 0xd9, 0xba, 0x40, 0xe8, 0x29, 0x6f, 0x42, 0xef, 0xa5, 0xdc, 0x84, 0x70, + 0x96, 0x2b, 0x1a, 0xa3, 0x81, 0xf7, 0xa1, 0xb7, 0x93, 0xf7, 0x21, 0x54, 0x5e, 0x29, 0xf4, 0xfd, + 0x6f, 0x45, 0xc6, 0x4f, 0x67, 0xa0, 0x10, 0x5f, 0xd3, 0x9f, 0x4a, 0xaf, 0x9c, 0xe2, 0x75, 0xe9, + 0xc7, 0xb3, 0x61, 0x7e, 0x1d, 0xe9, 0xe8, 0xfd, 0xa4, 0x9a, 0x60, 0xbe, 0xa3, 0x3d, 0xfc, 0x3c, + 0xad, 0xc7, 0x2c, 0x54, 0x43, 0xa4, 0xa4, 0x07, 0x2a, 0x1d, 0xf9, 0x85, 0xbf, 0x5e, 0x7c, 0xca, + 0xf8, 0x00, 0x16, 0xe2, 0xdd, 0x81, 0x8f, 0x3f, 0x25, 0x98, 0xd5, 0xe1, 0xf1, 0xec, 0x5c, 0x71, + 0x2a, 0x33, 0x8e, 0x6f, 0xfc, 0x6e, 0x36, 0xce, 0x5b, 0x98, 0x63, 0xb2, 0x3d, 0x4a, 0xb5, 0x00, + 0x12, 0x7b, 0x14, 0x07, 0x99, 0xb2, 0xec, 0x34, 0x59, 0xf1, 0x42, 0x77, 0xe5, 0x5c, 0xba, 0xbb, + 0x32, 0xb9, 0x11, 0xb3, 0x40, 0x57, 0x62, 0x6b, 0x3d, 0xa4, 0x3b, 0x56, 0x64, 0x85, 0x1e, 0x33, + 0x3c, 0x2f, 0xc3, 0x82, 0x16, 0x28, 0x5e, 0xd2, 0x8f, 0x46, 0xba, 0xfe, 0x00, 0x0b, 0x38, 0x71, + 0x2a, 0x32, 0x59, 0x83, 0x71, 0xf6, 0x99, 0x77, 0xed, 0xae, 0x78, 0xd3, 0x21, 0x61, 0xf0, 0x82, + 0x56, 0x78, 0x3f, 0x54, 0xe2, 0x17, 0xb4, 0x28, 0x93, 0x10, 0xd4, 0x89, 0x25, 0x10, 0x8d, 0xff, + 0x3b, 0xc3, 0xd6, 0x7f, 0xe3, 0xe0, 0x33, 0x96, 0x5a, 0x8f, 0x35, 0x69, 0x80, 0xb5, 0xf0, 0x1f, + 0x64, 0x79, 0xc6, 0x24, 0x31, 0x7d, 0xde, 0x84, 0xb1, 0x4d, 0xdb, 0xdb, 0x13, 0x89, 0xcd, 0x75, + 0x2e, 0xbc, 0x20, 0x8a, 0xfc, 0x15, 0xe0, 0x6f, 0x53, 0x10, 0xa8, 0xaa, 0xb3, 0xec, 0x50, 0xaa, + 0x33, 0xe5, 0x5d, 0x20, 0xf7, 0xd8, 0xde, 0x05, 0xbe, 0x27, 0x4c, 0x8e, 0x54, 0x0a, 0x86, 0x88, + 0x43, 0x7e, 0x31, 0x9e, 0x8b, 0x2c, 0x11, 0x31, 0x3e, 0x62, 0x47, 0x6e, 0xa8, 0xd9, 0xcd, 0x14, + 0xbf, 0xd9, 0x13, 0xf2, 0x98, 0x19, 0x7f, 0x90, 0xe3, 0x7d, 0x2c, 0x3a, 0xea, 0x92, 0x16, 0x1d, + 0x00, 0xd7, 0x49, 0x4c, 0x4f, 0xc9, 0xe3, 0x04, 0x5c, 0x82, 0x11, 0x36, 0x37, 0x45, 0x6f, 0x22, + 0x1e, 0x9b, 0xbf, 0x2a, 0x1e, 0x2b, 0x67, 0x6b, 0x19, 0xcf, 0x24, 0x35, 0x6d, 0x25, 0x1e, 0x5b, + 0xea, 0x5a, 0x46, 0x0c, 0x72, 0x19, 0x46, 0x36, 0xdc, 0xa6, 0x8c, 0x77, 0xbf, 0x80, 0x31, 0x62, + 0xb4, 0xbc, 0xb8, 0x8b, 0x19, 0x13, 0x31, 0x58, 0x5b, 0xc3, 0x2c, 0x21, 0x6a, 0x5b, 0xdb, 0xbb, + 0x76, 0x32, 0x1d, 0xa1, 0x92, 0x9a, 0x68, 0x15, 0x66, 0xb6, 0x9d, 0x4e, 0xd3, 0x7d, 0xe8, 0x57, + 0xa8, 0x7f, 0x10, 0xb8, 0x5d, 0x61, 0x4b, 0x8d, 0xda, 0xfd, 0x87, 0xbc, 0xc4, 0x6a, 0xf2, 0x22, + 0xf5, 0x59, 0x46, 0x27, 0x22, 0x2b, 0x30, 0xad, 0xc5, 0xd9, 0x15, 0x8f, 0xab, 0xa8, 0x0d, 0xd5, + 0xa3, 0xf4, 0xaa, 0xda, 0x50, 0x8d, 0x84, 0x9d, 0xe7, 0xe2, 0xfb, 0x95, 0x27, 0xd6, 0xc4, 0xb7, + 0x0b, 0x1c, 0xf2, 0x3a, 0xe4, 0x79, 0x30, 0x96, 0x6a, 0x45, 0x7d, 0x26, 0xf3, 0x11, 0x16, 0x0b, + 0x66, 0x24, 0x11, 0x95, 0xe0, 0x1b, 0x9f, 0x83, 0x82, 0xd8, 0x92, 0xa2, 0x8c, 0xfa, 0xcf, 0xc0, + 0x48, 0xb9, 0x5a, 0x31, 0xd5, 0x6d, 0xa4, 0xe1, 0x34, 0x3d, 0x13, 0xa1, 0xe8, 0xb1, 0xb8, 0x41, + 0x83, 0x87, 0xae, 0x77, 0x60, 0x52, 0x3f, 0xf0, 0x1c, 0x9e, 0xf5, 0x14, 0x17, 0xe2, 0xe7, 0xc9, + 0xdb, 0x30, 0x8a, 0x46, 0xbd, 0xb1, 0x93, 0x21, 0x5e, 0xc7, 0xca, 0xb4, 0x98, 0xc0, 0xa3, 0x68, + 0x21, 0x6c, 0x72, 0x22, 0xf2, 0x26, 0x8c, 0x54, 0x68, 0xe7, 0x30, 0x96, 0x90, 0x31, 0x41, 0x1c, + 0x6e, 0x08, 0x4d, 0xda, 0x39, 0x34, 0x91, 0xc4, 0xf8, 0xe9, 0x2c, 0x9c, 0x49, 0xf9, 0xac, 0xfb, + 0x9f, 0x7f, 0x42, 0x77, 0xc5, 0x15, 0x6d, 0x57, 0x94, 0xef, 0xe3, 0x7d, 0x3b, 0x3e, 0x75, 0x93, + 0xfc, 0xc5, 0x0c, 0x9c, 0xd3, 0x27, 0xa8, 0xb0, 0xe2, 0xbf, 0xff, 0x3a, 0x79, 0x0b, 0xc6, 0xd6, + 0xa8, 0xdd, 0xa4, 0x32, 0xfb, 0xda, 0x99, 0x30, 0x6c, 0x22, 0x8f, 0xcf, 0xc0, 0x0b, 0x39, 0xdb, + 0xc8, 0x9b, 0x97, 0x43, 0x49, 0x45, 0x7c, 0x1c, 0x17, 0xdf, 0x0d, 0x19, 0xf5, 0x25, 0xad, 0xaa, + 0x01, 0x56, 0x26, 0xdf, 0xc9, 0xc0, 0xd3, 0x03, 0x68, 0xd8, 0xc0, 0xb1, 0xa1, 0x57, 0x07, 0x0e, + 0x4f, 0x54, 0x84, 0x92, 0x77, 0x61, 0x76, 0x53, 0x88, 0xff, 0x72, 0x38, 0xb2, 0xd1, 0x7a, 0x91, + 0x37, 0x03, 0x69, 0xd9, 0x64, 0xc6, 0x91, 0xb5, 0x70, 0x44, 0xb9, 0x81, 0xe1, 0x88, 0xd4, 0xe8, + 0x3e, 0x23, 0xc3, 0x46, 0xf7, 0xf9, 0x00, 0x16, 0xf4, 0xb6, 0x89, 0x20, 0xcb, 0x51, 0x6c, 0xa3, + 0x4c, 0xff, 0xd8, 0x46, 0x03, 0x43, 0xb9, 0x1a, 0x3f, 0x91, 0x81, 0x82, 0xce, 0xfb, 0x93, 0x8e, + 0xe7, 0x3b, 0xda, 0x78, 0x3e, 0x9d, 0x3e, 0x9e, 0xfd, 0x07, 0xf2, 0xff, 0xcc, 0xc4, 0x1b, 0x3b, + 0xd4, 0x08, 0x1a, 0x30, 0x56, 0x71, 0xdb, 0xb6, 0x23, 0x07, 0x0e, 0x5d, 0x70, 0x9a, 0x08, 0x31, + 0x45, 0xc9, 0x70, 0xa1, 0xa0, 0x2e, 0xc2, 0xe8, 0x86, 0xdb, 0x29, 0x55, 0x84, 0x2d, 0x33, 0xf2, + 0xe9, 0xb8, 0x1d, 0xcb, 0x6e, 0x9a, 0xbc, 0x80, 0xac, 0x03, 0xd4, 0x1b, 0x1e, 0xa5, 0x9d, 0xba, + 0xf3, 0xbd, 0x34, 0x26, 0x69, 0xb0, 0x1e, 0x6a, 0xf5, 0x70, 0x63, 0xe1, 0x4f, 0xa7, 0x88, 0x68, + 0xf9, 0xce, 0xf7, 0xaa, 0xfb, 0xad, 0x42, 0x8f, 0xeb, 0x4a, 0x44, 0xcb, 0x8b, 0x8d, 0xc3, 0xf5, + 0x4f, 0x63, 0x5d, 0xa5, 0x56, 0x85, 0x3d, 0x7c, 0x3d, 0x75, 0x38, 0x7e, 0x27, 0x03, 0x4f, 0x0f, + 0xa0, 0x79, 0x0c, 0xa3, 0xf2, 0xa7, 0xdd, 0xe1, 0x14, 0x20, 0x22, 0xc2, 0x7c, 0xd7, 0x4e, 0x33, + 0xe0, 0x19, 0x15, 0xa7, 0x45, 0xbe, 0x6b, 0x06, 0xd0, 0xf2, 0x5d, 0x33, 0x00, 0x3b, 0x4b, 0xd7, + 0xa8, 0xb3, 0xb7, 0xcf, 0xcd, 0xc3, 0xa6, 0xf9, 0xde, 0xb0, 0x8f, 0x10, 0xf5, 0x2c, 0xe5, 0x38, + 0xc6, 0xbf, 0x1a, 0x83, 0xf3, 0x26, 0xdd, 0x73, 0xd8, 0xbd, 0x64, 0xcb, 0x77, 0x3a, 0x7b, 0x5a, + 0x74, 0x24, 0x23, 0xb6, 0x72, 0x45, 0x2a, 0x11, 0x06, 0x09, 0x67, 0xe2, 0x15, 0xc8, 0x33, 0x31, + 0x44, 0x59, 0xbc, 0xf8, 0xc6, 0xc5, 0x84, 0x15, 0x11, 0x7e, 0x5b, 0x16, 0x93, 0x97, 0x85, 0x98, + 0xa4, 0x24, 0x7b, 0x62, 0x62, 0xd2, 0x77, 0x8f, 0x8a, 0x50, 0x3f, 0xf4, 0x03, 0x8a, 0x57, 0x64, + 0x21, 0x2a, 0x85, 0x77, 0x99, 0x91, 0x3e, 0x77, 0x99, 0xbb, 0xb0, 0x50, 0x6a, 0xf2, 0xd3, 0xd1, + 0x6e, 0xd5, 0x3c, 0xa7, 0xd3, 0x70, 0xba, 0x76, 0x4b, 0xde, 0xcf, 0xb1, 0x97, 0xed, 0xb0, 0xdc, + 0xea, 0x86, 0x08, 0x66, 0x2a, 0x19, 0x6b, 0x46, 0x65, 0xa3, 0x8e, 0xa1, 0x77, 0xc4, 0xf3, 0x25, + 0x36, 0xa3, 0xd9, 0xf1, 0xb1, 0x15, 0xbe, 0x19, 0x16, 0xe3, 0x2d, 0x0a, 0x0d, 0x02, 0x36, 0xd7, + 0xeb, 0x91, 0xbb, 0x38, 0xcf, 0x45, 0xc1, 0x0d, 0x0b, 0x82, 0x96, 0x8f, 0xa6, 0x98, 0x1a, 0x5e, + 0x44, 0x57, 0xaf, 0xaf, 0x31, 0xba, 0x7c, 0x82, 0xce, 0xf7, 0xf7, 0x55, 0x3a, 0x8e, 0x47, 0xae, + 0xb1, 0xa9, 0xd0, 0x76, 0x03, 0x8a, 0x53, 0x78, 0x22, 0xba, 0x73, 0x79, 0x08, 0xe5, 0x77, 0x2e, + 0x05, 0x85, 0xbc, 0x0d, 0xf3, 0xab, 0xe5, 0x65, 0xa9, 0x74, 0xae, 0xb8, 0x8d, 0x1e, 0x1a, 0x02, + 0x00, 0xd6, 0x87, 0x63, 0x48, 0x1b, 0xcb, 0x6c, 0x37, 0x49, 0x43, 0x23, 0x97, 0x60, 0xbc, 0x5a, + 0xe1, 0x7d, 0x3f, 0xa9, 0x26, 0x5c, 0x13, 0x96, 0x59, 0xb2, 0x90, 0xdc, 0x8b, 0x2e, 0x05, 0x53, + 0x27, 0x4a, 0xef, 0xe7, 0x87, 0xb8, 0x10, 0xbc, 0x09, 0xd3, 0x2b, 0x6e, 0x50, 0xed, 0xf8, 0x81, + 0xdd, 0x69, 0xd0, 0x6a, 0x45, 0x8d, 0x7e, 0xbe, 0xe3, 0x06, 0x96, 0x23, 0x4a, 0xd8, 0x97, 0xeb, + 0x98, 0xe4, 0x8b, 0x48, 0x7a, 0x8b, 0x76, 0xa8, 0x17, 0x45, 0x3d, 0x1f, 0xe5, 0x7d, 0xcb, 0x48, + 0xf7, 0xc2, 0x12, 0x53, 0x47, 0x24, 0x26, 0x9c, 0xa9, 0x79, 0xf4, 0x81, 0xe3, 0xf6, 0x7c, 0xbd, + 0xf2, 0xd9, 0x48, 0x8c, 0xed, 0x0a, 0x04, 0x2b, 0xfe, 0x15, 0xe9, 0xa4, 0x22, 0xc1, 0x1c, 0x4f, + 0x0b, 0x5b, 0x76, 0x9b, 0xd4, 0xe7, 0x3b, 0xd0, 0x67, 0x28, 0xc1, 0x9c, 0xd2, 0xb6, 0x01, 0xbb, + 0xf2, 0x7f, 0x8a, 0x09, 0xe6, 0x12, 0xb8, 0xe4, 0x8b, 0x30, 0x8a, 0x3f, 0x85, 0xc4, 0x3c, 0x9f, + 0xc2, 0x36, 0x92, 0x96, 0x1b, 0x0c, 0xd3, 0xe4, 0x04, 0xa4, 0x0a, 0xe3, 0xe2, 0xb2, 0x76, 0x9a, + 0x34, 0x49, 0xe2, 0xd6, 0xc7, 0x67, 0x9b, 0xa0, 0x37, 0x9a, 0x30, 0xa5, 0x56, 0xc8, 0x56, 0xd9, + 0x9a, 0xed, 0xef, 0xd3, 0x26, 0xfb, 0x25, 0x32, 0x1c, 0xe2, 0x2a, 0xdb, 0x47, 0xa8, 0xc5, 0xbe, + 0xc3, 0x54, 0x50, 0xd8, 0x39, 0x5d, 0xf5, 0xb7, 0x7c, 0xf1, 0x29, 0x42, 0x7d, 0xe3, 0xa0, 0x2a, + 0xb0, 0x69, 0x8a, 0x22, 0xe3, 0x7b, 0x60, 0x61, 0xa3, 0xd7, 0x6a, 0xd9, 0x3b, 0x2d, 0x2a, 0x33, + 0xe0, 0x60, 0xaa, 0xf9, 0x15, 0x18, 0xad, 0x2b, 0xc9, 0xeb, 0xc3, 0x2c, 0xa4, 0x0a, 0x0e, 0x1a, + 0xd6, 0x66, 0x30, 0xb4, 0x52, 0x2c, 0x6d, 0x3d, 0x27, 0x35, 0x7e, 0x3b, 0x03, 0x0b, 0xd2, 0x04, + 0xc1, 0xb3, 0x1b, 0x07, 0xd4, 0x13, 0x02, 0xd7, 0x25, 0x6d, 0xae, 0xe1, 0x22, 0x88, 0x4d, 0x23, + 0x3e, 0xeb, 0x6e, 0xcb, 0x8f, 0xd0, 0x85, 0xa0, 0xb4, 0x0f, 0x3e, 0xe9, 0x63, 0xc8, 0xdb, 0x30, + 0x29, 0x8e, 0x5c, 0x25, 0xb4, 0x29, 0x46, 0x76, 0x13, 0x57, 0xc8, 0xb8, 0x41, 0x8c, 0x8a, 0x8e, + 0xf2, 0x9d, 0xde, 0x94, 0x4f, 0x2a, 0x57, 0xa4, 0xcb, 0x77, 0x7a, 0x1d, 0x03, 0xa6, 0xee, 0x6f, + 0x4c, 0xc6, 0xfb, 0x56, 0xcc, 0xdd, 0x1b, 0x6a, 0x30, 0xc3, 0x4c, 0x74, 0xdb, 0x8e, 0x82, 0x19, + 0xaa, 0xb7, 0xed, 0x10, 0x35, 0x1c, 0x93, 0xec, 0x09, 0x63, 0xf2, 0xae, 0x1c, 0x93, 0x5c, 0xff, + 0x89, 0x31, 0x3f, 0x60, 0x1c, 0xea, 0xd1, 0x0a, 0x19, 0x19, 0x4a, 0x55, 0xf3, 0x14, 0x66, 0x6d, + 0xe0, 0x24, 0xf1, 0x9d, 0x59, 0x70, 0x52, 0xf5, 0x3f, 0xa3, 0xc3, 0x33, 0x3d, 0x61, 0xbb, 0xff, + 0x12, 0x4c, 0x95, 0x82, 0xc0, 0x6e, 0xec, 0xd3, 0x66, 0x85, 0x6d, 0x4f, 0x4a, 0xb4, 0x32, 0x5b, + 0xc0, 0xd5, 0x77, 0x3b, 0x15, 0x97, 0xc7, 0x11, 0xb6, 0x7d, 0x61, 0xa0, 0x1b, 0xc6, 0x11, 0x66, + 0x10, 0x3d, 0x8e, 0x30, 0x83, 0x90, 0x6b, 0x30, 0x5e, 0xed, 0x3c, 0x70, 0x58, 0x9f, 0xf0, 0x80, + 0x65, 0xa8, 0xef, 0x72, 0x38, 0x48, 0xdd, 0x5c, 0x05, 0x16, 0x79, 0x53, 0xb9, 0x28, 0x4d, 0x44, + 0x4a, 0x11, 0xae, 0x46, 0x0b, 0x23, 0x12, 0xa9, 0x97, 0xa0, 0xf0, 0xe6, 0x74, 0x03, 0xc6, 0xa5, + 0x76, 0x14, 0xa2, 0x13, 0x44, 0x50, 0x26, 0x03, 0x7c, 0x48, 0x64, 0xcc, 0x46, 0xaf, 0x64, 0x6a, + 0x9c, 0x54, 0xb2, 0xd1, 0x2b, 0x99, 0x1a, 0xb5, 0x6c, 0xf4, 0x4a, 0xce, 0xc6, 0x50, 0xb1, 0x34, + 0x75, 0xa2, 0x62, 0xe9, 0x3e, 0x4c, 0xd5, 0x6c, 0x2f, 0x70, 0x98, 0xdc, 0xd3, 0x09, 0xfc, 0xc5, + 0x69, 0x4d, 0x17, 0xab, 0x14, 0xad, 0x3c, 0x2b, 0x33, 0xa2, 0x77, 0x15, 0x7c, 0x3d, 0x75, 0x77, + 0x04, 0x4f, 0x37, 0xcf, 0x9d, 0xf9, 0x24, 0xe6, 0xb9, 0xd8, 0xa9, 0xa8, 0x7f, 0x9b, 0x8d, 0xb4, + 0x3c, 0x78, 0x11, 0x8a, 0x29, 0xe1, 0x42, 0x44, 0xf2, 0x35, 0x98, 0x62, 0x7f, 0xd7, 0xdc, 0x96, + 0xd3, 0x70, 0xa8, 0xbf, 0x58, 0xc0, 0xc6, 0x3d, 0x9b, 0xba, 0xfa, 0x11, 0xe9, 0xb0, 0x4e, 0x03, + 0xbe, 0x80, 0x91, 0x71, 0x5c, 0xb1, 0xae, 0x71, 0x23, 0xef, 0xc1, 0x14, 0x9b, 0x7d, 0x3b, 0xb6, + 0xcf, 0xc5, 0xdd, 0xb9, 0xc8, 0xc0, 0xba, 0x29, 0xe0, 0x89, 0x50, 0xde, 0x2a, 0x01, 0x3b, 0xe6, + 0x4b, 0x5d, 0xbe, 0x41, 0x12, 0x65, 0xb6, 0x77, 0x13, 0x9b, 0xa3, 0x44, 0x23, 0x5f, 0x86, 0xa9, + 0x52, 0xb7, 0x1b, 0xed, 0x38, 0xf3, 0x8a, 0x72, 0xad, 0xdb, 0xb5, 0x52, 0x77, 0x1d, 0x8d, 0x22, + 0xbe, 0x31, 0x2f, 0x9c, 0x6a, 0x63, 0x26, 0xaf, 0x85, 0x37, 0x80, 0x33, 0x91, 0xa6, 0x58, 0x5c, + 0x46, 0xb5, 0xeb, 0x04, 0xbf, 0x0c, 0x94, 0x61, 0x9a, 0xab, 0x4e, 0xa5, 0x34, 0x73, 0x36, 0xb1, + 0x7a, 0x52, 0x84, 0x1a, 0x9d, 0x86, 0xac, 0xc2, 0x0c, 0xf7, 0x8e, 0x6f, 0x89, 0x18, 0xeb, 0x8b, + 0xe7, 0x70, 0xd5, 0x22, 0x17, 0xee, 0x54, 0xdf, 0xc2, 0xd4, 0x3b, 0xb6, 0xc6, 0x25, 0x46, 0x64, + 0xfc, 0x61, 0x06, 0xce, 0xf5, 0x19, 0xf1, 0x30, 0x02, 0x77, 0x66, 0x70, 0x04, 0x6e, 0xb6, 0x73, + 0xe8, 0x9a, 0x16, 0x6c, 0x7f, 0xd2, 0x75, 0x2c, 0x94, 0xb7, 0x5c, 0x20, 0x22, 0xbb, 0x95, 0xa8, + 0xfa, 0xb6, 0x8b, 0xea, 0xde, 0x5c, 0xf2, 0x10, 0x12, 0x78, 0xfc, 0xa3, 0x78, 0xdc, 0x52, 0x91, + 0x3c, 0x2b, 0x1c, 0xd6, 0x8f, 0x5c, 0x6d, 0x05, 0xa7, 0xb0, 0x36, 0x8e, 0x32, 0x30, 0xa9, 0xac, + 0x43, 0x72, 0x51, 0x71, 0xa9, 0x2e, 0xf0, 0xf4, 0x6b, 0x0a, 0x87, 0x2c, 0x3f, 0x89, 0x70, 0x51, + 0x65, 0x4f, 0x56, 0x6a, 0xdf, 0x65, 0xa2, 0x90, 0x12, 0xa5, 0xbc, 0xad, 0x69, 0xa0, 0x4d, 0x2c, + 0x27, 0x1f, 0x02, 0xac, 0xdb, 0x7e, 0x50, 0x6a, 0x04, 0xce, 0x03, 0x3a, 0xc4, 0xa1, 0x23, 0xe3, + 0x36, 0x9e, 0xc1, 0x84, 0x1f, 0x36, 0x92, 0xc5, 0xce, 0x08, 0x85, 0xa1, 0xf1, 0x83, 0x19, 0x80, + 0xad, 0x6a, 0x19, 0xd3, 0x0c, 0x7c, 0x52, 0xa1, 0x20, 0x3d, 0x74, 0xb3, 0xe4, 0x3e, 0x40, 0x1c, + 0xf8, 0x9f, 0x33, 0x30, 0xa3, 0xa3, 0x91, 0x77, 0x61, 0xb6, 0xde, 0xf0, 0xdc, 0x56, 0x6b, 0xc7, + 0x6e, 0x1c, 0xac, 0x3b, 0x1d, 0xca, 0xc3, 0xd9, 0x8e, 0xf2, 0xb3, 0xc8, 0x0f, 0x8b, 0xac, 0x16, + 0x2b, 0x33, 0xe3, 0xc8, 0xe4, 0x87, 0x32, 0x30, 0x5d, 0xdf, 0x77, 0x1f, 0x86, 0xd1, 0x61, 0xc5, + 0x80, 0x7c, 0xc8, 0xd6, 0xb6, 0xbf, 0xef, 0x3e, 0x8c, 0x72, 0xb7, 0x6a, 0xf6, 0xa7, 0xef, 0x0c, + 0x67, 0x1a, 0xd0, 0x70, 0xf1, 0x3e, 0x12, 0xf8, 0x57, 0xb5, 0x4a, 0x4c, 0xbd, 0x4e, 0xe3, 0x4f, + 0x32, 0x30, 0x89, 0x37, 0x97, 0x56, 0x0b, 0x65, 0xae, 0xcf, 0x52, 0x22, 0xd0, 0xb0, 0x5d, 0x03, + 0x06, 0xf6, 0x0d, 0x98, 0x8d, 0xa1, 0x11, 0x03, 0xc6, 0xea, 0x18, 0x2d, 0x41, 0x55, 0x7a, 0xf0, + 0xf8, 0x09, 0xa6, 0x28, 0x31, 0x56, 0x15, 0xb2, 0xfb, 0xd7, 0xf1, 0xa9, 0x78, 0x19, 0xc0, 0x91, + 0x20, 0x79, 0xb3, 0x21, 0xf1, 0x2f, 0xb9, 0x7f, 0xdd, 0x54, 0xb0, 0x8c, 0x0d, 0x18, 0xab, 0xbb, + 0x5e, 0xb0, 0x72, 0xc8, 0x2f, 0x13, 0x15, 0xea, 0x37, 0xd4, 0xb7, 0x60, 0x07, 0xdf, 0x5f, 0x1a, + 0xa6, 0x28, 0x22, 0x45, 0x18, 0xbd, 0xe9, 0xd0, 0x56, 0x53, 0xb5, 0x11, 0xde, 0x65, 0x00, 0x93, + 0xc3, 0xd9, 0x85, 0xeb, 0x6c, 0x94, 0x8d, 0x27, 0x32, 0x46, 0xfe, 0xa4, 0xeb, 0xa6, 0xac, 0xf5, + 0xef, 0x73, 0x61, 0x06, 0x8c, 0x64, 0x4d, 0x03, 0xba, 0xfa, 0xef, 0x65, 0x60, 0xa9, 0x3f, 0x89, + 0x6a, 0xdf, 0x9c, 0x19, 0x60, 0xdf, 0xfc, 0x62, 0xfc, 0xed, 0x12, 0xd1, 0xc4, 0xdb, 0x65, 0xf4, + 0x62, 0x59, 0x41, 0xf3, 0xf2, 0x06, 0x95, 0x29, 0x78, 0x2e, 0x0e, 0xf8, 0x66, 0x44, 0xe4, 0xc3, + 0x1c, 0x20, 0x8d, 0x29, 0x68, 0x8d, 0x5f, 0x1f, 0x81, 0xf3, 0x7d, 0x29, 0xc8, 0x9a, 0x92, 0xd8, + 0x6b, 0x26, 0x4c, 0x29, 0xd4, 0x17, 0xff, 0x2a, 0xfe, 0x8b, 0x16, 0x84, 0x71, 0x0f, 0xba, 0x7b, + 0x61, 0x42, 0xa7, 0x2c, 0xf2, 0x7a, 0xe5, 0x44, 0x5e, 0x1c, 0x1d, 0x99, 0x41, 0x32, 0xb7, 0x13, + 0xfa, 0x5a, 0xd2, 0xc0, 0x76, 0x5a, 0xbe, 0xba, 0xec, 0x9a, 0x1c, 0x64, 0xca, 0xb2, 0xc8, 0xe8, + 0x7c, 0x24, 0xdd, 0xe8, 0xdc, 0xf8, 0x77, 0x19, 0x98, 0x08, 0x3f, 0x9b, 0x2c, 0xc1, 0xd9, 0x4d, + 0xb3, 0x54, 0x5e, 0xb5, 0x36, 0x3f, 0xa8, 0xad, 0x5a, 0x5b, 0x1b, 0xf5, 0xda, 0x6a, 0xb9, 0x7a, + 0xb3, 0xba, 0x5a, 0x29, 0x3c, 0x45, 0xe6, 0x60, 0x7a, 0x6b, 0xe3, 0xce, 0xc6, 0xbd, 0xed, 0x0d, + 0x6b, 0xd5, 0x34, 0xef, 0x99, 0x85, 0x0c, 0x99, 0x86, 0x09, 0x73, 0xa5, 0x54, 0xb6, 0x36, 0xee, + 0x55, 0x56, 0x0b, 0x59, 0x52, 0x80, 0xa9, 0xf2, 0xbd, 0x8d, 0x8d, 0xd5, 0xf2, 0x66, 0xf5, 0x7e, + 0x75, 0xf3, 0x83, 0x42, 0x8e, 0x10, 0x98, 0x41, 0x84, 0x9a, 0x59, 0xdd, 0x28, 0x57, 0x6b, 0xa5, + 0xf5, 0xc2, 0x08, 0x83, 0x31, 0x7c, 0x05, 0x36, 0x1a, 0x32, 0xba, 0xb3, 0xb5, 0xb2, 0x5a, 0x18, + 0x63, 0x28, 0xec, 0x2f, 0x05, 0x65, 0x9c, 0x55, 0x8f, 0x28, 0x95, 0xd2, 0x66, 0x69, 0xa5, 0x54, + 0x5f, 0x2d, 0xe4, 0xc9, 0x39, 0x98, 0xd7, 0x40, 0xd6, 0xfa, 0xbd, 0x5b, 0xd5, 0x8d, 0xc2, 0x04, + 0x59, 0x80, 0x42, 0x08, 0xab, 0xac, 0x58, 0x5b, 0xf5, 0x55, 0xb3, 0x00, 0x71, 0xe8, 0x46, 0xe9, + 0xee, 0x6a, 0x61, 0xd2, 0x78, 0x87, 0xfb, 0x36, 0xf2, 0xae, 0x26, 0x67, 0x81, 0xd4, 0x37, 0x4b, + 0x9b, 0x5b, 0xf5, 0x58, 0xe3, 0x27, 0x61, 0xbc, 0xbe, 0x55, 0x2e, 0xaf, 0xd6, 0xeb, 0x85, 0x0c, + 0x01, 0x18, 0xbb, 0x59, 0xaa, 0xae, 0xaf, 0x56, 0x0a, 0x59, 0xe3, 0xa7, 0x32, 0x30, 0x27, 0x25, + 0x40, 0xf9, 0x10, 0xf5, 0x09, 0xd7, 0xe2, 0xbb, 0xda, 0xc5, 0x56, 0x3a, 0x9e, 0xc5, 0x2a, 0x19, + 0xb0, 0x0c, 0x7f, 0x31, 0x03, 0x67, 0x52, 0xb1, 0xc9, 0x07, 0xf0, 0xef, 0xd9, 0xfb, 0xb6, 0xd8, + 0x48, 0x92, 0xe4, 0xb0, 0xa9, 0xee, 0x26, 0xd9, 0x0c, 0xbe, 0x8a, 0x39, 0x9c, 0x19, 0xce, 0x7b, + 0xa6, 0x76, 0x76, 0xb4, 0xc3, 0xbd, 0xdd, 0xdb, 0x99, 0xf5, 0xde, 0xee, 0x9c, 0xee, 0x76, 0x55, + 0xec, 0x6e, 0x92, 0x3d, 0xd3, 0xaf, 0xab, 0x6a, 0x72, 0x34, 0xb7, 0x92, 0x5a, 0x35, 0xdd, 0x45, + 0xb2, 0x76, 0x9b, 0xdd, 0x7d, 0x55, 0xd5, 0x3b, 0xc7, 0x83, 0x01, 0x9f, 0x20, 0xe0, 0x04, 0xd8, + 0x96, 0x65, 0x9f, 0x65, 0x78, 0x21, 0xc0, 0x90, 0x01, 0x1f, 0x0c, 0x7d, 0xe8, 0xcf, 0x3f, 0x86, + 0xef, 0xeb, 0xfe, 0x0e, 0x10, 0x64, 0x08, 0xf0, 0xdf, 0xc9, 0x5e, 0xc8, 0x0b, 0xd8, 0x30, 0x64, + 0xff, 0x09, 0xf6, 0x87, 0x00, 0x03, 0x46, 0x46, 0x46, 0x56, 0x65, 0x55, 0x57, 0xf7, 0x70, 0x6e, + 0xf7, 0x6c, 0x0b, 0xd0, 0x17, 0xd9, 0x91, 0x11, 0x51, 0xf9, 0xce, 0xc8, 0x88, 0xc8, 0x08, 0x5d, + 0xd6, 0xa0, 0xee, 0x84, 0xdd, 0xe3, 0x78, 0x1f, 0xbb, 0x91, 0xfa, 0x4a, 0x0a, 0x4d, 0xa8, 0x4a, + 0xe3, 0x54, 0xe3, 0x13, 0x6c, 0xce, 0x9e, 0x08, 0xc3, 0xf8, 0x54, 0x83, 0x4b, 0x53, 0x3e, 0xc3, + 0x4a, 0x30, 0x1f, 0xa5, 0x44, 0x9a, 0xe1, 0x44, 0xb7, 0xf1, 0xb3, 0xcf, 0x6e, 0x12, 0x22, 0xe6, + 0x66, 0xc6, 0xff, 0xac, 0xf9, 0x28, 0xc7, 0x11, 0x26, 0x1a, 0x12, 0xdd, 0x77, 0x39, 0xd5, 0xf3, + 0xf4, 0x25, 0xf3, 0x89, 0xbd, 0xbd, 0x44, 0x7d, 0x97, 0x77, 0x9e, 0x07, 0x98, 0x69, 0xc8, 0xf8, + 0x7d, 0x8d, 0x0b, 0x77, 0x69, 0x44, 0x2e, 0xf3, 0x9a, 0x41, 0x30, 0x3e, 0x71, 0xad, 0x61, 0xdf, + 0x35, 0xad, 0x06, 0x1d, 0x1b, 0x28, 0xad, 0x3a, 0x58, 0x80, 0xd7, 0x8a, 0x8e, 0xe3, 0x27, 0x82, + 0x0d, 0x24, 0x68, 0xd8, 0x43, 0x80, 0xca, 0x77, 0x43, 0xd7, 0x1f, 0x38, 0xfd, 0x28, 0xe0, 0x8d, + 0x88, 0x04, 0x46, 0xd0, 0xa4, 0xbc, 0xad, 0x20, 0x1b, 0x3f, 0xd0, 0x60, 0x99, 0x2e, 0x4d, 0x66, + 0xdf, 0xf5, 0xc3, 0x2f, 0x36, 0xbd, 0x1e, 0x26, 0xa6, 0x57, 0xf4, 0x66, 0x44, 0xe1, 0xcf, 0x8b, + 0x33, 0x67, 0xd6, 0xbf, 0xd7, 0x40, 0x4f, 0x23, 0xb2, 0xf7, 0xa1, 0x68, 0xbb, 0x9f, 0xb8, 0xbe, + 0x17, 0x9e, 0xd2, 0x46, 0x29, 0x93, 0x47, 0x0a, 0x1c, 0x2a, 0x13, 0xf3, 0x21, 0xa0, 0x5f, 0x56, + 0x44, 0x73, 0xd6, 0xfd, 0x5e, 0x51, 0x7b, 0xe4, 0xbf, 0x2c, 0xb5, 0x87, 0xf1, 0x17, 0x39, 0xb8, + 0xb4, 0xeb, 0x86, 0x6a, 0x9b, 0x22, 0x97, 0x85, 0xb7, 0xce, 0xd6, 0x2e, 0xa5, 0x25, 0x9b, 0xb0, + 0x80, 0x45, 0x72, 0x7c, 0x2d, 0xf9, 0x93, 0x6d, 0x47, 0xf3, 0x3a, 0x9f, 0xc8, 0x4e, 0x37, 0xe5, + 0xdb, 0x6f, 0x2a, 0xf9, 0xaa, 0xa2, 0x69, 0x7d, 0x17, 0x56, 0x31, 0x55, 0xc2, 0x98, 0x2f, 0x07, + 0xb7, 0x47, 0xea, 0x9f, 0xa2, 0x95, 0x82, 0xb2, 0x2d, 0xd0, 0x39, 0xc4, 0xec, 0x7e, 0x3c, 0x18, + 0x3e, 0xef, 0xbb, 0xbd, 0x23, 0xb7, 0x87, 0xc7, 0x7a, 0xd1, 0x9a, 0x80, 0x4b, 0x9e, 0xfb, 0x03, + 0x71, 0x75, 0x73, 0x7b, 0xa8, 0xa3, 0x21, 0x9e, 0x31, 0xf4, 0xca, 0x43, 0x58, 0xfa, 0x39, 0x73, + 0xcf, 0x19, 0x7f, 0xae, 0xc1, 0x06, 0x36, 0x4e, 0xf9, 0xb0, 0xcc, 0x0b, 0x2c, 0x7b, 0x4b, 0x49, + 0xc7, 0xe4, 0x70, 0x50, 0x72, 0x29, 0x44, 0xbd, 0x18, 0xeb, 0x84, 0x72, 0x67, 0xd0, 0x09, 0x29, + 0x2a, 0xad, 0xc2, 0x97, 0xa5, 0xd2, 0x7a, 0x54, 0x28, 0xe6, 0xf5, 0x42, 0x3c, 0xe4, 0xc6, 0x6f, + 0xe7, 0x60, 0xc1, 0x72, 0x31, 0x39, 0x3c, 0xbb, 0x0b, 0x0b, 0x8d, 0x61, 0xe8, 0x06, 0xf5, 0xb2, + 0xea, 0x38, 0x3c, 0xe0, 0xa0, 0xce, 0x49, 0xcf, 0x92, 0x85, 0x7c, 0xc2, 0xb7, 0xfc, 0x61, 0x6f, + 0xdc, 0x0d, 0xd5, 0x09, 0x3f, 0x12, 0x20, 0x4b, 0x96, 0xb1, 0xaf, 0xc0, 0x22, 0x71, 0x8e, 0x0c, + 0xc5, 0xe8, 0x0f, 0xed, 0x0b, 0x20, 0x26, 0x55, 0x89, 0x10, 0x50, 0xa6, 0x15, 0x02, 0x46, 0x41, + 0x91, 0x69, 0x27, 0x64, 0x06, 0x29, 0xaa, 0xcf, 0xcd, 0x10, 0xd5, 0xdf, 0x82, 0x79, 0x33, 0x08, + 0xdc, 0x50, 0x46, 0x66, 0x58, 0x8e, 0xc2, 0xec, 0x05, 0x6e, 0x28, 0x18, 0x3b, 0x58, 0x6e, 0x11, + 0x9e, 0xf1, 0x57, 0x39, 0x98, 0xc3, 0x7f, 0xd1, 0x0c, 0xeb, 0x77, 0x8f, 0x13, 0x66, 0x58, 0xbf, + 0x7b, 0x6c, 0x21, 0x94, 0xdd, 0x47, 0x4d, 0x85, 0xcc, 0x1c, 0x46, 0xad, 0x47, 0x15, 0x7c, 0x2f, + 0x06, 0x5b, 0x2a, 0x4e, 0xe4, 0x35, 0x90, 0xcf, 0x8c, 0xc7, 0x72, 0x11, 0x72, 0x4d, 0x9b, 0x5a, + 0x8c, 0xe1, 0xc5, 0x86, 0x81, 0x95, 0x6b, 0xda, 0xd8, 0x1b, 0x7b, 0xe6, 0x83, 0x77, 0xbe, 0x46, + 0x0d, 0x15, 0xbd, 0x71, 0xec, 0x3c, 0x78, 0xe7, 0x6b, 0x16, 0x95, 0xf0, 0xfe, 0xc5, 0x3a, 0xa3, + 0x31, 0x57, 0xc4, 0x11, 0xc0, 0xfe, 0xc5, 0xb6, 0xa1, 0xe1, 0xd6, 0x8a, 0x11, 0xd8, 0x03, 0x58, + 0xa2, 0xf8, 0x15, 0x88, 0xaf, 0xc4, 0x97, 0xa0, 0xf8, 0x16, 0x82, 0x42, 0x45, 0x12, 0x66, 0x3d, + 0x1a, 0x20, 0x99, 0xdf, 0x98, 0xcc, 0x7a, 0x72, 0x08, 0x03, 0x4b, 0x41, 0xe1, 0x55, 0x12, 0x76, + 0xc1, 0x38, 0x3e, 0xc0, 0xaa, 0x12, 0x08, 0x01, 0xd3, 0x52, 0x44, 0x08, 0xc6, 0x1f, 0xe5, 0xa0, + 0xd8, 0xea, 0x8f, 0x8f, 0xbc, 0xc1, 0xc1, 0x7d, 0xc6, 0x00, 0xaf, 0x71, 0x32, 0x6f, 0x09, 0xff, + 0x9f, 0x5d, 0x86, 0xa2, 0xbc, 0xb9, 0xc9, 0x0d, 0x29, 0xa0, 0x5b, 0xdb, 0x26, 0xc8, 0x71, 0xa7, + 0x38, 0x72, 0xf2, 0x27, 0xbb, 0x0f, 0xd1, 0xfd, 0x6b, 0xda, 0x45, 0xad, 0xc0, 0x17, 0x8b, 0x15, + 0xa1, 0xb1, 0x37, 0x00, 0x0f, 0x09, 0xba, 0x3c, 0x48, 0x85, 0xb6, 0xa8, 0x1a, 0xc9, 0x29, 0x82, + 0x04, 0xd1, 0xd8, 0xdb, 0x40, 0x13, 0x93, 0xf2, 0xe8, 0x5f, 0x48, 0x12, 0x88, 0xcc, 0xa4, 0x92, + 0x84, 0x50, 0xd9, 0x37, 0x60, 0xa9, 0xeb, 0xbb, 0x68, 0xc9, 0x74, 0xfa, 0x71, 0x7a, 0x7c, 0x95, + 0xb2, 0x14, 0x97, 0x1f, 0xdc, 0xb7, 0x54, 0x74, 0xe3, 0x3f, 0x15, 0x61, 0x59, 0xad, 0x0f, 0xb3, + 0xe0, 0x7c, 0xd0, 0xe7, 0x77, 0x77, 0x72, 0x60, 0x1b, 0x61, 0x21, 0x1d, 0xa7, 0xb7, 0x92, 0x15, + 0xe2, 0x78, 0xc2, 0x9b, 0x4d, 0x06, 0xde, 0xd8, 0x3b, 0x67, 0xad, 0x07, 0x31, 0x58, 0xe0, 0x31, + 0x13, 0x8a, 0xc3, 0x51, 0x70, 0xe4, 0x0e, 0x3c, 0x69, 0x6f, 0x79, 0x25, 0xc1, 0xa8, 0x49, 0x85, + 0x13, 0xbc, 0x22, 0x32, 0xf6, 0x0e, 0xcc, 0x0f, 0x47, 0xee, 0xc0, 0xf1, 0xe8, 0x8c, 0xbb, 0x9a, + 0x62, 0xe0, 0x0e, 0xcc, 0xaa, 0x42, 0x48, 0xc8, 0xec, 0xab, 0x50, 0x18, 0x7e, 0x1c, 0x8d, 0xd7, + 0xe5, 0x24, 0xd1, 0xc7, 0xa1, 0xa3, 0x90, 0x20, 0x22, 0x27, 0xf8, 0xc8, 0x39, 0x39, 0xa4, 0x11, + 0x4b, 0x12, 0x3c, 0x72, 0x4e, 0x0e, 0x55, 0x02, 0x8e, 0xc8, 0x3e, 0x00, 0x18, 0x39, 0x47, 0xae, + 0xdf, 0xe9, 0x8d, 0xc3, 0x53, 0x1a, 0xb7, 0x1b, 0x09, 0xb2, 0x16, 0x2f, 0x2e, 0x8f, 0xc3, 0x53, + 0x85, 0x76, 0x71, 0x24, 0x81, 0xcc, 0x04, 0x38, 0x71, 0xc2, 0xd0, 0xf5, 0x4f, 0x86, 0xe4, 0x41, + 0x18, 0x07, 0x8d, 0x14, 0x0c, 0xea, 0x51, 0xb1, 0xc2, 0x41, 0x21, 0xc2, 0x4a, 0x7b, 0xbe, 0x83, + 0x56, 0xf5, 0x89, 0x4a, 0x7b, 0x7e, 0xa2, 0x95, 0x1c, 0x91, 0xbd, 0x07, 0x0b, 0x3d, 0x2f, 0xe8, + 0x0e, 0xfd, 0x1e, 0x45, 0x64, 0xb9, 0x96, 0xa0, 0x29, 0x8b, 0x32, 0x85, 0x4c, 0xa2, 0xf3, 0xda, + 0x52, 0xd0, 0xd8, 0xc6, 0xf0, 0x39, 0xaa, 0xf9, 0xd3, 0xb5, 0xb5, 0xa3, 0x62, 0xb5, 0xb6, 0x31, + 0x11, 0x1f, 0xca, 0x23, 0x2f, 0xec, 0x3b, 0xcf, 0xc8, 0x76, 0x9e, 0x1c, 0xca, 0x5d, 0x2c, 0x52, + 0x87, 0x52, 0x20, 0xb3, 0x87, 0x50, 0x74, 0x07, 0xa1, 0xef, 0x74, 0xbc, 0x1e, 0x3d, 0xd4, 0x4c, + 0x56, 0x9a, 0x1f, 0xc0, 0x4e, 0xb5, 0xac, 0x56, 0x1a, 0xf1, 0xab, 0x3d, 0xde, 0x3f, 0x41, 0xd7, + 0x3b, 0xa1, 0xf7, 0x95, 0xc9, 0xfe, 0xb1, 0x4b, 0xd5, 0xba, 0xda, 0x3f, 0x1c, 0x91, 0xbd, 0x0f, + 0x0b, 0x7c, 0xfd, 0xf6, 0x86, 0x47, 0x14, 0xe4, 0xc2, 0x48, 0xf6, 0x8f, 0x28, 0x9b, 0x98, 0xae, + 0x92, 0x88, 0x2f, 0x64, 0xe7, 0x79, 0xd0, 0xf1, 0xba, 0x14, 0xb8, 0x22, 0xb9, 0x1c, 0xcd, 0x27, + 0x76, 0xb5, 0xa4, 0x90, 0xcd, 0x39, 0xcf, 0x83, 0x6a, 0x97, 0x3d, 0x80, 0x39, 0x4c, 0xe9, 0x41, + 0x81, 0x43, 0x93, 0x34, 0x98, 0xcc, 0x43, 0xa5, 0x41, 0x54, 0x3e, 0x90, 0x27, 0x01, 0x3e, 0x59, + 0xa1, 0xc4, 0x1a, 0xc9, 0x3e, 0xa9, 0xdb, 0xf8, 0x8e, 0x45, 0xad, 0x22, 0xa1, 0xf3, 0x2a, 0x0e, + 0xdc, 0xb0, 0xe3, 0x7d, 0x87, 0x52, 0x63, 0x24, 0x3f, 0xd7, 0x70, 0xc3, 0xea, 0xb7, 0xd4, 0xcf, + 0x0d, 0xdc, 0xb0, 0xfa, 0x1d, 0x76, 0x03, 0x20, 0x76, 0x27, 0x10, 0x86, 0x1a, 0x4b, 0x81, 0x7c, + 0xbd, 0xf0, 0xdf, 0xfe, 0xe5, 0x4d, 0x6d, 0x1b, 0xa0, 0x28, 0x43, 0xf5, 0x18, 0x35, 0xb8, 0x3c, + 0x75, 0xb3, 0x60, 0xf7, 0x40, 0x3f, 0x74, 0x48, 0x55, 0xd8, 0x3d, 0x76, 0x06, 0x03, 0xb7, 0x4f, + 0xdb, 0xf4, 0x9a, 0x84, 0x97, 0x04, 0x58, 0x70, 0x36, 0x3e, 0x80, 0x8d, 0xac, 0x59, 0xc2, 0x6e, + 0xc3, 0xb2, 0x1a, 0x95, 0x88, 0x98, 0x2c, 0x39, 0x23, 0x4f, 0xc6, 0x25, 0x22, 0x06, 0x3f, 0xd6, + 0xe0, 0xda, 0xac, 0x3d, 0x87, 0x5d, 0x81, 0xe2, 0xc8, 0xf7, 0x86, 0x28, 0xdb, 0x52, 0x4a, 0x0b, + 0xf9, 0x1b, 0xb3, 0x55, 0xa0, 0x10, 0x16, 0x3a, 0x47, 0xf4, 0xd2, 0xc4, 0x5a, 0x44, 0x48, 0xdb, + 0x39, 0x0a, 0xd8, 0xeb, 0xb0, 0xde, 0x73, 0x0f, 0x9d, 0x71, 0x3f, 0xec, 0x04, 0xdd, 0x63, 0xb7, + 0x87, 0x6f, 0xc1, 0xd0, 0x83, 0xd0, 0xd2, 0xa9, 0xc0, 0x96, 0xf0, 0x89, 0x1a, 0xcf, 0x4d, 0xa9, + 0xf1, 0xa3, 0x42, 0x51, 0xd3, 0x73, 0x16, 0xba, 0x6c, 0x19, 0xdf, 0xcf, 0xc1, 0xe6, 0xb4, 0x45, + 0xc6, 0xbe, 0x99, 0xd5, 0x07, 0xc2, 0xda, 0xa1, 0xc2, 0x55, 0x6b, 0x87, 0xf2, 0x35, 0xf6, 0x00, + 0xa2, 0x97, 0x5c, 0x2f, 0x8a, 0xca, 0x20, 0x61, 0x9c, 0x66, 0xe4, 0x04, 0xc1, 0x73, 0xbe, 0x8f, + 0xe4, 0x95, 0xa8, 0xc5, 0x04, 0x53, 0x69, 0x24, 0x8c, 0xbd, 0x0b, 0xd0, 0xed, 0x0f, 0x03, 0x17, + 0x9d, 0x0a, 0x48, 0x40, 0x11, 0xfe, 0xe9, 0x11, 0x54, 0xb5, 0x22, 0x23, 0xb4, 0x34, 0xec, 0xb9, + 0x34, 0x80, 0x0e, 0x5c, 0x9a, 0xb2, 0xab, 0xf2, 0xe1, 0xc1, 0xa7, 0x59, 0x62, 0x11, 0x51, 0x42, + 0x31, 0x0e, 0x11, 0x89, 0x70, 0xd2, 0x3d, 0x9e, 0x9b, 0x36, 0x47, 0x4e, 0x81, 0x4d, 0x6e, 0x9d, + 0x9c, 0x3b, 0x79, 0x59, 0x8f, 0xfd, 0x88, 0xbb, 0x80, 0xec, 0xfb, 0x7d, 0x76, 0x13, 0x96, 0x64, + 0xea, 0x53, 0x7e, 0x01, 0x10, 0xcc, 0x81, 0x40, 0x8f, 0x5d, 0x9c, 0x3c, 0x18, 0x33, 0x16, 0xdf, + 0xeb, 0x91, 0x68, 0xb1, 0x88, 0x90, 0xf6, 0xe9, 0x48, 0xb6, 0xee, 0x9a, 0x9c, 0xdf, 0xc9, 0x03, + 0x8d, 0x4a, 0xff, 0x99, 0x26, 0x87, 0x7f, 0xf2, 0x44, 0x78, 0x51, 0xfd, 0x18, 0xe0, 0x73, 0x29, + 0xaa, 0x18, 0xfe, 0xcf, 0x45, 0x1d, 0xb9, 0xea, 0x48, 0xd4, 0xa1, 0x9f, 0xec, 0x2e, 0xac, 0xf9, + 0xc2, 0xa1, 0x36, 0x1c, 0x52, 0x7f, 0x8a, 0xe4, 0x2c, 0x2b, 0x02, 0xdc, 0x1e, 0x62, 0x9f, 0x52, + 0xbd, 0x1e, 0x45, 0x1d, 0xa6, 0x1c, 0x90, 0xec, 0x4d, 0x58, 0xe4, 0x07, 0x24, 0x86, 0xfc, 0x49, + 0xbd, 0xd3, 0x40, 0x3c, 0x14, 0x37, 0xac, 0xe2, 0x47, 0xf4, 0x3f, 0xf1, 0xfa, 0x34, 0x27, 0x99, + 0xa9, 0xc7, 0x33, 0xbb, 0x04, 0x0b, 0x43, 0xff, 0x48, 0x69, 0xda, 0xfc, 0xd0, 0x3f, 0xe2, 0xed, + 0x7a, 0x0d, 0x74, 0xf1, 0x6c, 0x48, 0x84, 0x6f, 0x08, 0x4e, 0x07, 0xe2, 0xfe, 0x5e, 0xb4, 0x56, + 0x05, 0x7c, 0x3f, 0x70, 0x7d, 0xfb, 0x74, 0xd0, 0xe5, 0x98, 0x41, 0x30, 0xec, 0xa8, 0x91, 0xbe, + 0xa8, 0xd9, 0xab, 0x41, 0x30, 0x8c, 0x43, 0x7e, 0xf5, 0xd8, 0x36, 0xac, 0x70, 0x3e, 0x51, 0xbc, + 0x31, 0x92, 0x1e, 0xae, 0x4f, 0x4a, 0x0f, 0xa7, 0x83, 0xae, 0xac, 0xa2, 0xb5, 0x1c, 0x28, 0xbf, + 0xd8, 0x63, 0xd0, 0x15, 0x31, 0x0b, 0xdf, 0x91, 0xa6, 0x9c, 0xbb, 0x63, 0x36, 0x8a, 0x78, 0x56, + 0x1d, 0x1c, 0x0e, 0xad, 0xb5, 0x6e, 0x12, 0x40, 0x5d, 0xf3, 0x87, 0x9a, 0xdc, 0x4b, 0x33, 0x88, + 0x98, 0x01, 0x2b, 0xc7, 0x4e, 0xd0, 0x09, 0x82, 0x13, 0xe1, 0xac, 0x46, 0xa1, 0x95, 0x97, 0x8e, + 0x9d, 0xc0, 0x0e, 0x4e, 0x64, 0x76, 0x98, 0x0b, 0x1c, 0x67, 0xe8, 0x8c, 0xc3, 0xe3, 0x8e, 0x2a, + 0x34, 0x8a, 0x1e, 0x3b, 0x7f, 0xec, 0x04, 0x4d, 0x5e, 0xa6, 0xf0, 0x66, 0x77, 0x60, 0x15, 0xf9, + 0x76, 0x3d, 0xc9, 0x18, 0x43, 0x70, 0x58, 0xcb, 0x9c, 0x71, 0xd7, 0x13, 0x9c, 0xa9, 0x86, 0x3f, + 0x2c, 0xc0, 0xc5, 0xec, 0xde, 0xc1, 0xe9, 0xc9, 0xfb, 0x14, 0x1f, 0x0b, 0x52, 0xdd, 0x16, 0x39, + 0x44, 0x84, 0x4f, 0xc9, 0x1a, 0x9c, 0x5c, 0xe6, 0xe0, 0x6c, 0xc1, 0x3a, 0x32, 0x22, 0xf1, 0xb4, + 0xef, 0x05, 0x21, 0x45, 0x05, 0xb1, 0xd6, 0x78, 0x81, 0xd8, 0xcf, 0x6b, 0x1c, 0xcc, 0x5e, 0x85, + 0x55, 0xb9, 0x23, 0x0f, 0x9f, 0x0f, 0xf8, 0x87, 0xc5, 0x76, 0xbc, 0x42, 0xd0, 0x26, 0x02, 0xd9, + 0x05, 0x98, 0x77, 0x46, 0x23, 0xfe, 0x49, 0xb1, 0x0b, 0xcf, 0x39, 0xa3, 0x91, 0xc8, 0x60, 0x84, + 0x4f, 0x23, 0x3b, 0x87, 0xe8, 0x5a, 0x44, 0xbe, 0x91, 0xd6, 0x32, 0x02, 0x85, 0xbb, 0x51, 0xc0, + 0xd7, 0x3d, 0xa7, 0x95, 0x28, 0x0b, 0x88, 0x02, 0xce, 0x28, 0x42, 0xb8, 0x0c, 0x45, 0x69, 0xe4, + 0x16, 0x2f, 0x3c, 0xac, 0x05, 0x87, 0x0c, 0xdc, 0xef, 0xc0, 0xa5, 0x9e, 0x17, 0xe0, 0xe4, 0x15, + 0x4d, 0x1a, 0x8d, 0xe8, 0x31, 0xa6, 0x08, 0x53, 0x6c, 0x6d, 0x50, 0x31, 0xef, 0x49, 0x73, 0x34, + 0x8a, 0x9e, 0x64, 0x5e, 0x91, 0x64, 0xcf, 0x3c, 0x11, 0x03, 0x4d, 0x38, 0x7a, 0xe2, 0xe4, 0x07, + 0xa4, 0xdc, 0x24, 0x8c, 0x6d, 0x15, 0x41, 0x2e, 0x83, 0x68, 0xa5, 0x74, 0x84, 0x52, 0x8c, 0x0e, + 0x72, 0x34, 0x85, 0xe2, 0xa0, 0x21, 0x94, 0x7d, 0x00, 0xd7, 0xe4, 0x77, 0x9c, 0x20, 0xf0, 0x8e, + 0x06, 0x1d, 0xd9, 0x99, 0xe8, 0x2a, 0x80, 0x42, 0x58, 0xd1, 0xba, 0x4c, 0x38, 0x26, 0xa2, 0x94, + 0x05, 0x06, 0xbe, 0xc9, 0xa3, 0x49, 0xf1, 0x1e, 0xac, 0x91, 0x3c, 0x49, 0x67, 0x39, 0x76, 0x1a, + 0xed, 0x34, 0xfc, 0xa2, 0x47, 0xc9, 0xad, 0x80, 0x40, 0xd5, 0x9e, 0xa4, 0xfc, 0x8f, 0x1a, 0x5c, + 0xc8, 0x14, 0x48, 0xd9, 0x6f, 0x82, 0x78, 0x24, 0x17, 0x0e, 0x3b, 0xbe, 0xdb, 0xf5, 0x46, 0x1e, + 0x46, 0x1d, 0x11, 0x0a, 0xdb, 0x07, 0xb3, 0x44, 0x59, 0x7c, 0x70, 0xd7, 0x1e, 0x5a, 0x11, 0x91, + 0xd0, 0x24, 0xe9, 0x7e, 0x0a, 0x7c, 0xe5, 0x43, 0xb8, 0x90, 0x89, 0x9a, 0xa1, 0xe1, 0xf9, 0x4a, + 0x32, 0x49, 0xba, 0x34, 0xc1, 0xa5, 0x1a, 0xad, 0x68, 0x7e, 0xa8, 0x79, 0x3f, 0x89, 0x9a, 0x97, + 0x12, 0x5d, 0x59, 0x25, 0xbd, 0x01, 0x65, 0xdd, 0xbe, 0x24, 0xd1, 0xf4, 0x3d, 0xe8, 0x43, 0xb8, + 0x40, 0xab, 0xe4, 0xc8, 0x77, 0x46, 0xc7, 0x31, 0x3b, 0x51, 0xd1, 0x5f, 0xca, 0x62, 0x27, 0x96, + 0xcf, 0x2e, 0xc7, 0x8f, 0xb8, 0x9e, 0x77, 0x26, 0x81, 0xd4, 0x86, 0xdf, 0xca, 0xc9, 0x3d, 0x29, + 0xa3, 0x3a, 0x19, 0xeb, 0x4f, 0xcb, 0x5a, 0x7f, 0x67, 0x5f, 0xfc, 0x0d, 0x60, 0xea, 0xae, 0x4a, + 0xd3, 0x57, 0xb8, 0x8b, 0xc9, 0x5b, 0x08, 0x55, 0x44, 0xd9, 0xc3, 0xc4, 0x7c, 0xb6, 0xd6, 0xbb, + 0x69, 0x10, 0xbb, 0x0a, 0x8b, 0x51, 0x1e, 0x78, 0x3a, 0xe1, 0x8a, 0x02, 0x50, 0xed, 0xb1, 0x5b, + 0xb0, 0x2c, 0x2e, 0x1c, 0x89, 0xcd, 0x01, 0x10, 0x66, 0xf2, 0x1d, 0x42, 0xf6, 0x81, 0x06, 0xb7, + 0x5e, 0xd4, 0x87, 0xec, 0x09, 0x5c, 0x44, 0xa7, 0x95, 0x60, 0x18, 0x0d, 0x43, 0xa7, 0xeb, 0x74, + 0x8f, 0x5d, 0x9a, 0xb5, 0x46, 0xe6, 0x60, 0x8c, 0x46, 0xb6, 0xdd, 0x54, 0xc6, 0x61, 0x34, 0xb2, + 0x83, 0xa1, 0xfc, 0x5d, 0xe2, 0xe4, 0x54, 0x87, 0x1e, 0x5c, 0x9d, 0x41, 0xa9, 0xec, 0x70, 0x9a, + 0xba, 0xc3, 0xbd, 0x06, 0xfa, 0xa1, 0xdb, 0xe3, 0xc2, 0xbb, 0xdb, 0xc3, 0xaa, 0x7d, 0xf2, 0x00, + 0x3b, 0x7e, 0xd9, 0x5a, 0x8d, 0xe0, 0x76, 0x30, 0x3c, 0x78, 0x40, 0x5f, 0x39, 0x91, 0x67, 0xb3, + 0x7a, 0x69, 0x62, 0x6f, 0xc2, 0xf9, 0x54, 0x44, 0x97, 0x38, 0x44, 0x80, 0xb5, 0xce, 0x8b, 0x92, + 0xf1, 0xbf, 0x6e, 0xc3, 0xb2, 0xba, 0x91, 0x48, 0x41, 0xac, 0x17, 0x6f, 0x1d, 0xf4, 0xb9, 0xb1, + 0x6c, 0x54, 0xe6, 0x7d, 0xeb, 0x0c, 0x42, 0x3f, 0x7b, 0x03, 0x58, 0x74, 0xc1, 0x88, 0x36, 0x0a, + 0xfa, 0xe0, 0xba, 0x2c, 0x89, 0x56, 0x38, 0x7d, 0xf6, 0xdf, 0xcc, 0xc3, 0xf9, 0x8c, 0x8b, 0x1a, + 0x7b, 0x03, 0x74, 0x6f, 0x10, 0xba, 0x47, 0x3e, 0x25, 0xd6, 0x8d, 0x9d, 0x68, 0x72, 0x9b, 0x9a, + 0xb5, 0xa6, 0x94, 0x91, 0x06, 0x6e, 0x5e, 0x64, 0xf7, 0xa7, 0xef, 0xd1, 0x2f, 0xbe, 0x81, 0x38, + 0xbe, 0x54, 0x2e, 0xf1, 0x7f, 0x59, 0x15, 0xd6, 0x31, 0xd1, 0x47, 0xe0, 0x0d, 0x31, 0x5f, 0x08, + 0x4a, 0x4c, 0x85, 0xc4, 0x75, 0x0e, 0x6b, 0xd2, 0x52, 0x90, 0xb8, 0xc8, 0x64, 0xe9, 0xa3, 0x14, + 0x84, 0xfd, 0x32, 0x5c, 0x51, 0x0e, 0xc6, 0x4e, 0x6a, 0xf5, 0xe1, 0xfb, 0x00, 0xeb, 0x92, 0x13, + 0x1d, 0x91, 0xe5, 0xc4, 0x3a, 0xdc, 0x06, 0x91, 0x3d, 0xd8, 0xeb, 0x8d, 0x3a, 0x13, 0x99, 0x61, + 0xb0, 0xb9, 0x22, 0xcf, 0xc1, 0x15, 0x8e, 0x55, 0xed, 0x8d, 0x52, 0x49, 0x62, 0xb0, 0xd5, 0xad, + 0xcc, 0x15, 0xba, 0x80, 0x2b, 0xf4, 0xba, 0xda, 0x98, 0x89, 0xf5, 0x89, 0xbd, 0x98, 0xb1, 0x46, + 0x8f, 0x60, 0x3d, 0x3e, 0xb0, 0xe4, 0x39, 0x5b, 0x4c, 0x64, 0xfb, 0x47, 0x86, 0x52, 0xd0, 0x13, + 0x07, 0xaf, 0x88, 0x72, 0x30, 0x41, 0xa8, 0xc6, 0xf2, 0x18, 0x27, 0x08, 0x02, 0x56, 0x83, 0x0d, + 0x7e, 0x69, 0xa7, 0x9c, 0xa4, 0x41, 0xf4, 0xad, 0xc5, 0xc9, 0x6f, 0x49, 0x73, 0x92, 0x20, 0xb5, + 0x98, 0xf3, 0x3c, 0xa0, 0x54, 0xa5, 0x81, 0xe4, 0xf6, 0x11, 0x30, 0x21, 0x3d, 0x24, 0xea, 0x0d, + 0x2f, 0xe2, 0x45, 0x09, 0x4d, 0x27, 0x28, 0xd5, 0x88, 0x64, 0x58, 0xaa, 0xd6, 0xbc, 0x9d, 0x54, + 0x01, 0x2e, 0x25, 0xec, 0x57, 0xe9, 0xde, 0x16, 0xb6, 0x35, 0x05, 0x5f, 0xbd, 0x11, 0x2a, 0x60, + 0xbc, 0x04, 0x60, 0xc4, 0x22, 0xac, 0xc7, 0x09, 0xbf, 0xae, 0x2d, 0xd3, 0x25, 0x80, 0x83, 0x79, + 0x05, 0xea, 0xf1, 0xc5, 0xec, 0x53, 0x0d, 0xf4, 0xf4, 0xa7, 0xd8, 0x37, 0x60, 0x3e, 0xc0, 0xd7, + 0x2d, 0x74, 0x82, 0x19, 0xd9, 0x75, 0x12, 0x23, 0x2d, 0xde, 0xc1, 0xec, 0x9d, 0xb3, 0x88, 0x86, + 0x7d, 0x0d, 0x0a, 0x43, 0xaf, 0x27, 0xed, 0x71, 0xb7, 0x66, 0xd1, 0x36, 0xab, 0xe5, 0x12, 0xea, + 0xf0, 0xbc, 0x1e, 0xdd, 0x24, 0xb6, 0x8b, 0x30, 0x2f, 0x3a, 0xd6, 0xf8, 0x08, 0xae, 0xce, 0xf8, + 0x20, 0xab, 0xc0, 0x5a, 0xca, 0x56, 0x79, 0x46, 0x33, 0xa6, 0x13, 0x9b, 0x31, 0x7d, 0x29, 0x02, + 0xf7, 0xe1, 0xf2, 0xd4, 0x0a, 0xb2, 0xea, 0xd4, 0x1d, 0x04, 0x63, 0x6a, 0xa4, 0xcb, 0xd4, 0xc9, + 0x9a, 0xda, 0x5d, 0xe8, 0x6b, 0xbf, 0x9b, 0x83, 0xf3, 0x19, 0x93, 0x88, 0x19, 0x90, 0x93, 0x7b, + 0xfd, 0xa4, 0x27, 0xdc, 0xde, 0x39, 0x2b, 0xe7, 0xf5, 0xd8, 0x43, 0x00, 0xcc, 0xfd, 0xea, 0xbb, + 0x47, 0xee, 0x77, 0xe9, 0xca, 0x8f, 0x17, 0xf1, 0x18, 0x9a, 0xa0, 0x59, 0x44, 0xeb, 0x02, 0x07, + 0xb3, 0xfb, 0x00, 0xee, 0x77, 0xbb, 0xfd, 0x71, 0xcf, 0x8d, 0x2e, 0x51, 0x19, 0x9f, 0xd1, 0xac, + 0x45, 0xc2, 0xaa, 0xf6, 0xd8, 0x1e, 0x30, 0x49, 0xa2, 0x7c, 0xb5, 0xf0, 0x82, 0xaf, 0x6a, 0x96, + 0x4e, 0x54, 0x0d, 0xf9, 0x71, 0x1a, 0xdd, 0x45, 0x58, 0xf0, 0x06, 0x58, 0xc2, 0xff, 0x25, 0x24, + 0xe3, 0x8f, 0x35, 0xea, 0x8f, 0xe4, 0x66, 0xc0, 0xda, 0x40, 0xa6, 0x70, 0xda, 0x38, 0xee, 0x4e, + 0xdf, 0x38, 0x54, 0x0b, 0x23, 0x05, 0x57, 0x41, 0x80, 0x6a, 0x47, 0x13, 0x90, 0x2f, 0x60, 0xfb, + 0xa3, 0xe1, 0xfb, 0x10, 0x2e, 0x64, 0x6e, 0xec, 0xfc, 0xd2, 0x80, 0x1e, 0xb5, 0xf1, 0x7d, 0x77, + 0x81, 0xff, 0xe6, 0x17, 0xde, 0xdb, 0xb0, 0xfc, 0xcc, 0x75, 0x7c, 0xd7, 0xa7, 0xdb, 0x18, 0x9d, + 0x9e, 0x02, 0xa6, 0x5e, 0xc6, 0x7a, 0xc9, 0x53, 0x8c, 0x8c, 0x07, 0xac, 0x0e, 0xe7, 0xc5, 0xee, + 0xe2, 0x9d, 0xe0, 0x05, 0x9f, 0x0c, 0x0e, 0x5a, 0xe2, 0x8a, 0x8b, 0x24, 0x78, 0xdd, 0xa8, 0x22, + 0x96, 0xa0, 0xb6, 0xd6, 0x8f, 0xd2, 0x20, 0x2e, 0xfc, 0x5c, 0xcc, 0xc6, 0x66, 0xdb, 0xb0, 0x24, + 0x98, 0x0b, 0x55, 0x8f, 0xb0, 0x14, 0xdf, 0x9e, 0xf9, 0x85, 0x12, 0x3e, 0x34, 0x09, 0xa2, 0xff, + 0xf9, 0x1d, 0x0c, 0x9d, 0x72, 0x3a, 0x27, 0xaa, 0x21, 0xdc, 0x5a, 0x46, 0x20, 0x19, 0xc0, 0x8d, + 0xff, 0xa0, 0xc9, 0xa6, 0x26, 0xb4, 0xa4, 0xfc, 0x04, 0x0e, 0xdc, 0x81, 0x74, 0x06, 0x58, 0xb4, + 0xe8, 0xd7, 0x4b, 0x4a, 0x05, 0xec, 0x5d, 0x58, 0xe6, 0x6c, 0x8f, 0xc6, 0x03, 0x71, 0x32, 0xe7, + 0x13, 0x41, 0xdf, 0xea, 0xa2, 0x88, 0x0f, 0xdb, 0xde, 0x39, 0x6b, 0xe9, 0x24, 0xfe, 0xc9, 0xde, + 0x84, 0xc5, 0xe0, 0x24, 0x1c, 0xa9, 0xe7, 0xb9, 0xb4, 0x18, 0xd9, 0xf5, 0x76, 0x8b, 0x48, 0x8a, + 0x1c, 0x27, 0xd6, 0x80, 0x6c, 0xcf, 0x0b, 0x9b, 0x91, 0xf1, 0x3a, 0x2c, 0x29, 0xbc, 0x79, 0x63, + 0xc4, 0xb3, 0x4c, 0xd9, 0x18, 0xf1, 0x8b, 0x06, 0xfb, 0x19, 0x14, 0x25, 0x4b, 0xc6, 0xa0, 0x70, + 0x3c, 0x0c, 0xa4, 0x3c, 0x84, 0xff, 0x73, 0x18, 0xef, 0x65, 0x6c, 0xe4, 0x9c, 0x85, 0xff, 0xa3, + 0xd8, 0x1d, 0x3a, 0x7e, 0x88, 0x4f, 0xf6, 0x46, 0xe8, 0x8a, 0x1b, 0x29, 0x44, 0x38, 0xbc, 0xdd, + 0x0f, 0x84, 0x83, 0x2e, 0x7d, 0xe3, 0xdf, 0x46, 0xf7, 0x95, 0x94, 0x5a, 0x79, 0x9a, 0x78, 0x99, + 0x90, 0xae, 0x73, 0x93, 0xd2, 0xb5, 0x08, 0xe6, 0x45, 0x94, 0xe2, 0xcb, 0x80, 0x30, 0x94, 0xae, + 0x15, 0x01, 0xaa, 0x90, 0x10, 0xa0, 0x14, 0x3d, 0x6b, 0x3c, 0x7a, 0x42, 0x38, 0x97, 0x7a, 0xd6, + 0xb4, 0x48, 0xf7, 0xa3, 0x68, 0x86, 0x24, 0x14, 0xdb, 0xec, 0x01, 0x5c, 0x10, 0xca, 0x10, 0x4a, + 0x6f, 0x9f, 0x92, 0x25, 0xcf, 0x63, 0xa1, 0x48, 0x7e, 0x17, 0xc9, 0x94, 0x2f, 0xd6, 0x23, 0xb2, + 0xb7, 0x60, 0x23, 0x4a, 0xc8, 0x1c, 0x7c, 0xec, 0x8d, 0x3a, 0x98, 0x92, 0xfb, 0x94, 0xd4, 0x14, + 0x4c, 0x96, 0xd9, 0x1f, 0x7b, 0xa3, 0x03, 0x2c, 0xa1, 0x6a, 0xfe, 0xeb, 0x9c, 0xd4, 0x4e, 0x6f, + 0x0f, 0x87, 0x61, 0x10, 0xfa, 0xce, 0x28, 0x61, 0xba, 0x63, 0x27, 0x70, 0x19, 0xab, 0xf4, 0x00, + 0xf3, 0x57, 0x0d, 0x7d, 0x19, 0xe6, 0x2a, 0x5a, 0x60, 0x4b, 0x0f, 0xbe, 0x9a, 0x54, 0x2f, 0x99, + 0x1c, 0xdb, 0x54, 0x91, 0xf9, 0xba, 0x52, 0xb8, 0xee, 0x9d, 0xb3, 0x2e, 0x09, 0x9e, 0x13, 0x58, + 0x6c, 0x2f, 0x63, 0xaf, 0x49, 0xdb, 0xee, 0xb6, 0xe3, 0x8d, 0x27, 0xc9, 0x55, 0xdd, 0x92, 0xd8, + 0xfb, 0xb0, 0xe8, 0xf5, 0xd4, 0x4c, 0xd0, 0x69, 0xab, 0x51, 0xb5, 0x27, 0x32, 0x36, 0xc4, 0x3c, + 0xf8, 0xd2, 0xf0, 0x08, 0xba, 0xbd, 0x92, 0x90, 0x70, 0x8c, 0x6d, 0xa9, 0x08, 0x9d, 0x24, 0x63, + 0xab, 0xf1, 0xd9, 0x87, 0xe7, 0x1c, 0xee, 0x02, 0x71, 0xce, 0x08, 0x8b, 0x7e, 0x19, 0x7f, 0x17, + 0x5e, 0x3b, 0x6b, 0x1f, 0xf1, 0x1d, 0x63, 0x4a, 0x87, 0x2f, 0x8a, 0x70, 0xcd, 0xc9, 0x7e, 0xbb, + 0x0d, 0x6a, 0xc8, 0x7b, 0x4f, 0x4e, 0x11, 0x09, 0xdb, 0xf7, 0x3d, 0xe3, 0x7f, 0xe4, 0x61, 0x35, + 0x69, 0xd6, 0x65, 0xaf, 0x43, 0x41, 0xd9, 0x28, 0x2f, 0x65, 0xd8, 0x7e, 0x71, 0x7b, 0x44, 0xa4, + 0x33, 0x6d, 0x8c, 0xec, 0x11, 0xac, 0xa2, 0xa3, 0x39, 0x0a, 0x70, 0xa1, 0x47, 0xce, 0x02, 0xb3, + 0xfd, 0x3d, 0x8a, 0x3f, 0xfd, 0xec, 0xe6, 0x39, 0x74, 0xed, 0x58, 0xe6, 0xb4, 0xfc, 0x60, 0xe4, + 0x85, 0x8a, 0xd5, 0xae, 0x30, 0xdd, 0x6a, 0x47, 0x4d, 0x99, 0x62, 0xb5, 0x9b, 0x9b, 0x61, 0xb5, + 0x8b, 0x29, 0x55, 0xab, 0x1d, 0xda, 0x6e, 0x17, 0xa6, 0xd9, 0x6e, 0x63, 0x1a, 0x61, 0xbb, 0x8d, + 0xad, 0x6e, 0xc5, 0xa9, 0x56, 0xb7, 0x98, 0x86, 0xac, 0x6e, 0xb1, 0x1d, 0x6c, 0x71, 0xaa, 0x1d, + 0x4c, 0x21, 0x12, 0x76, 0xb0, 0x3b, 0xd4, 0xb1, 0xbe, 0xf3, 0xbc, 0x83, 0x3d, 0x4e, 0x37, 0x23, + 0xec, 0x32, 0xcb, 0x79, 0x8e, 0x1e, 0xa4, 0x5c, 0x30, 0x21, 0xb7, 0x53, 0xe3, 0xc7, 0xa9, 0x0d, + 0x48, 0x8e, 0xf9, 0xab, 0xb0, 0x2a, 0xce, 0x61, 0x0a, 0x03, 0x2e, 0x0e, 0xe2, 0x15, 0x6b, 0x45, + 0x42, 0x85, 0x7a, 0xf4, 0x97, 0x60, 0x2d, 0x42, 0x23, 0x0d, 0x21, 0xbe, 0x70, 0xb7, 0x22, 0x6a, + 0xd2, 0x0d, 0xaa, 0xfc, 0x7c, 0x0a, 0x88, 0x96, 0xe0, 0x27, 0xa2, 0x65, 0xbd, 0x01, 0x2c, 0x46, + 0x8b, 0x9c, 0xf0, 0x0b, 0x88, 0xba, 0x1e, 0xa1, 0x46, 0x9e, 0xf2, 0xff, 0x54, 0x4b, 0xd9, 0xdd, + 0x7e, 0x51, 0xd5, 0x7f, 0x1d, 0xa2, 0xaf, 0x77, 0xc8, 0x76, 0x22, 0x5b, 0xa0, 0xcb, 0x82, 0x16, + 0xc1, 0x8d, 0xa3, 0xb4, 0xfa, 0xec, 0x17, 0x54, 0x2b, 0xe3, 0x27, 0xf9, 0x84, 0x4d, 0x42, 0x7e, + 0x86, 0xcb, 0x37, 0xc1, 0xb0, 0x43, 0x43, 0x4c, 0xdb, 0xef, 0xed, 0x29, 0xd3, 0x94, 0xdc, 0x8e, + 0x6d, 0xbb, 0x69, 0x41, 0x10, 0x0c, 0xa5, 0x17, 0x72, 0x47, 0xa8, 0x85, 0x94, 0xfb, 0x9e, 0x64, + 0x27, 0xf6, 0xda, 0xad, 0xd9, 0xec, 0xa4, 0x52, 0x98, 0xaf, 0x52, 0x54, 0x0f, 0x45, 0xbf, 0xe4, + 0x07, 0xf6, 0x01, 0x4d, 0x78, 0x41, 0x92, 0x79, 0x3e, 0x43, 0x01, 0x38, 0xc1, 0x1c, 0x7b, 0x09, + 0x39, 0xa3, 0xc6, 0x38, 0x50, 0xd9, 0x56, 0x60, 0x19, 0x2d, 0x02, 0x92, 0x61, 0x21, 0xc3, 0x4a, + 0x3e, 0xd9, 0xf8, 0x52, 0xb5, 0x6e, 0x2d, 0x71, 0x3a, 0xc9, 0xe6, 0x18, 0x2e, 0xab, 0x7a, 0xfc, + 0x64, 0x25, 0xe7, 0x64, 0xf0, 0xfe, 0x99, 0x3d, 0x10, 0xab, 0xfb, 0xb1, 0xaa, 0x17, 0x9d, 0x24, + 0x80, 0xd0, 0xd0, 0x03, 0x7f, 0xfa, 0x98, 0xcc, 0x48, 0x49, 0x19, 0xcb, 0x36, 0x39, 0x55, 0xb6, + 0x51, 0xd5, 0xfa, 0xf9, 0xa4, 0x5a, 0x7f, 0x07, 0x6e, 0xf1, 0xed, 0x88, 0x06, 0xd5, 0xfd, 0xc4, + 0xf5, 0x4f, 0x87, 0x03, 0x0c, 0xe8, 0x36, 0x8a, 0x56, 0xa5, 0xb0, 0x43, 0x5c, 0xe3, 0x78, 0x38, + 0x64, 0x15, 0xc2, 0xaa, 0x23, 0x92, 0x08, 0x54, 0xf8, 0xaf, 0xf2, 0xf0, 0xca, 0x19, 0xc6, 0x7d, + 0x46, 0xdd, 0x7f, 0x25, 0x29, 0x81, 0xe7, 0x12, 0x7a, 0x52, 0xce, 0x94, 0x0e, 0x97, 0xd3, 0x41, + 0x77, 0x8a, 0xfc, 0xfd, 0x9b, 0xb0, 0x26, 0x4e, 0x10, 0xf1, 0x04, 0xe1, 0x70, 0xdc, 0x3f, 0xc3, + 0x11, 0x72, 0x55, 0xbe, 0x97, 0x4e, 0x91, 0xe2, 0xa9, 0x82, 0x1b, 0xa7, 0x1d, 0xc1, 0x58, 0x1b, + 0x96, 0x10, 0xed, 0xd0, 0xf1, 0xfa, 0x67, 0x7a, 0xb8, 0x2b, 0x5f, 0x63, 0xab, 0x64, 0xe2, 0xe5, + 0x14, 0x07, 0xec, 0xe0, 0x6f, 0x76, 0x17, 0xd6, 0x06, 0xe3, 0x13, 0x2e, 0x5b, 0x8a, 0x49, 0x45, + 0x9e, 0x9e, 0x73, 0xd6, 0xca, 0x60, 0x7c, 0x62, 0x8e, 0x46, 0x38, 0x37, 0xd0, 0x25, 0x74, 0x9d, + 0xe3, 0x89, 0xe5, 0x2f, 0x31, 0xe7, 0x11, 0x93, 0x33, 0x10, 0x1b, 0x00, 0xe1, 0x6e, 0x80, 0x78, + 0x20, 0x40, 0xa9, 0x3d, 0xc5, 0x0f, 0xe3, 0x7f, 0xe5, 0xa4, 0xf6, 0x77, 0xfa, 0x02, 0xfa, 0xdb, + 0x21, 0xca, 0x18, 0xa2, 0xd7, 0x40, 0xe7, 0x5d, 0x1f, 0xef, 0x4e, 0xd1, 0x18, 0xad, 0x0e, 0xc6, + 0x27, 0x51, 0xdf, 0xa9, 0x1d, 0x3f, 0xaf, 0x76, 0xfc, 0xbb, 0x52, 0x3b, 0x9c, 0xb9, 0xcf, 0x4c, + 0xef, 0x72, 0x2e, 0x7a, 0xdd, 0x3d, 0xdb, 0x6e, 0xf2, 0xb7, 0xe3, 0x96, 0x31, 0x6e, 0x29, 0x8b, + 0xe7, 0xdc, 0x84, 0xc5, 0x33, 0x63, 0xed, 0xcd, 0x67, 0xad, 0xbd, 0x09, 0xfb, 0xea, 0x42, 0x86, + 0x7d, 0x35, 0x73, 0x81, 0x16, 0x5f, 0xb0, 0x40, 0x17, 0xd5, 0x79, 0xf2, 0x5f, 0x73, 0x52, 0xf4, + 0x4a, 0xde, 0xa5, 0x3e, 0x84, 0xf3, 0xf2, 0x2e, 0x25, 0x8e, 0xa0, 0xd8, 0x6c, 0xbe, 0xf4, 0xe0, + 0x5e, 0xd6, 0x2d, 0x0a, 0xd1, 0x32, 0x6e, 0x3a, 0xeb, 0x74, 0x7f, 0x8a, 0xcb, 0xff, 0xff, 0xb9, + 0x39, 0xb1, 0xa7, 0x70, 0x11, 0xf3, 0xd3, 0x74, 0x55, 0x83, 0x7f, 0xc7, 0x77, 0x0f, 0x69, 0x3e, + 0xdc, 0x9e, 0xb8, 0x67, 0x78, 0x5d, 0xa5, 0x3a, 0x96, 0x7b, 0xb8, 0x77, 0xce, 0xda, 0x08, 0x32, + 0xe0, 0xe9, 0x4b, 0xd9, 0x1f, 0x6b, 0x60, 0xbc, 0xb8, 0xbf, 0xf0, 0xfe, 0x9c, 0xee, 0x70, 0x7e, + 0x7f, 0x56, 0x7a, 0xef, 0x15, 0x58, 0xf1, 0xdd, 0x43, 0xdf, 0x0d, 0x8e, 0x13, 0x4a, 0xae, 0x65, + 0x02, 0xca, 0x8e, 0x91, 0x41, 0xad, 0x5f, 0xea, 0x56, 0x23, 0x89, 0x8c, 0x9d, 0xe8, 0xae, 0x9d, + 0x39, 0x0e, 0x7c, 0x36, 0xa9, 0x15, 0x14, 0x3f, 0x1e, 0x15, 0x8a, 0x39, 0x3d, 0x6f, 0x51, 0xe8, + 0xed, 0x43, 0xaf, 0xef, 0x1a, 0xff, 0x2e, 0x92, 0x2c, 0xb2, 0x3a, 0x8f, 0x7d, 0xa8, 0x3c, 0xdc, + 0xc9, 0x4f, 0xc8, 0x33, 0x59, 0x24, 0x67, 0xd1, 0x40, 0xd6, 0xbe, 0x24, 0x0d, 0xe4, 0x43, 0xe9, + 0xfd, 0xcb, 0xf7, 0xbc, 0x83, 0xfb, 0xec, 0x1e, 0x2c, 0x08, 0x87, 0x5f, 0x59, 0xdd, 0xb5, 0x44, + 0x75, 0x0f, 0xee, 0x5b, 0xb2, 0xdc, 0xf8, 0x34, 0x72, 0x47, 0x99, 0x68, 0xc4, 0xc1, 0x7d, 0xf6, + 0xee, 0xd9, 0x1e, 0xe2, 0x14, 0xe5, 0x43, 0x9c, 0xe8, 0x11, 0xce, 0x7b, 0x89, 0x47, 0x38, 0x77, + 0x66, 0xf7, 0x16, 0x39, 0x11, 0x89, 0x70, 0xc6, 0x71, 0x98, 0xcb, 0x9f, 0xe5, 0xe0, 0xfa, 0x4c, + 0x0a, 0x76, 0x0d, 0x8a, 0x66, 0xab, 0xda, 0x8e, 0xc7, 0x97, 0xaf, 0x19, 0x09, 0x61, 0xbb, 0xb0, + 0xb8, 0xed, 0x04, 0x5e, 0x97, 0x4f, 0xe3, 0x4c, 0x63, 0xf9, 0x04, 0xdb, 0x08, 0x7d, 0xef, 0x9c, + 0x15, 0xd3, 0xb2, 0x0e, 0xac, 0xe3, 0x5a, 0x48, 0xa4, 0xae, 0xcc, 0x67, 0xe8, 0x69, 0x26, 0x18, + 0x4e, 0x90, 0xf1, 0x7d, 0x66, 0x02, 0xc8, 0x9e, 0x01, 0xb3, 0xed, 0xbd, 0x92, 0xeb, 0x87, 0xa4, + 0xbf, 0x08, 0xbd, 0xe8, 0x55, 0xc7, 0x5b, 0x2f, 0xe8, 0xbb, 0x09, 0xba, 0xbd, 0x73, 0x56, 0x06, + 0xb7, 0xf4, 0x32, 0xff, 0x44, 0xca, 0x3b, 0xd3, 0x3b, 0xe1, 0x25, 0x42, 0xc5, 0xbf, 0x06, 0xc5, + 0x96, 0x74, 0x21, 0x54, 0x5e, 0xc7, 0x49, 0x77, 0x41, 0x2b, 0x2a, 0x35, 0xfe, 0xa1, 0x26, 0x15, + 0x36, 0x2f, 0xee, 0x2c, 0x25, 0xb3, 0x68, 0x6f, 0x76, 0x66, 0xd1, 0xde, 0xcf, 0x99, 0x59, 0xd4, + 0xf0, 0xe0, 0xde, 0x99, 0x3b, 0x96, 0x7d, 0x03, 0x74, 0x4c, 0xc2, 0xe8, 0x28, 0x83, 0x24, 0xd6, + 0xd7, 0x7a, 0x94, 0x3b, 0x64, 0x8f, 0x32, 0xdd, 0x5a, 0x6b, 0xdd, 0x24, 0xb5, 0xf1, 0x47, 0x94, + 0x33, 0xa6, 0xda, 0x6b, 0xa5, 0x4c, 0xae, 0x5f, 0xf4, 0x41, 0x65, 0x25, 0xb1, 0xd8, 0x5e, 0x51, + 0xb2, 0x6f, 0x4f, 0x7e, 0x6b, 0xfa, 0xbb, 0x4a, 0x65, 0xe5, 0xfd, 0xf3, 0x3c, 0x5c, 0x9b, 0x45, + 0xce, 0x4c, 0xd0, 0x2b, 0xa9, 0xbc, 0xfc, 0x6a, 0x0e, 0xb3, 0x89, 0x84, 0xfe, 0xd6, 0x04, 0x3a, + 0x1f, 0x5b, 0x01, 0x8b, 0x5e, 0x0b, 0xe2, 0xd8, 0x12, 0x29, 0x1f, 0x5b, 0x59, 0xcc, 0x5e, 0x81, + 0x79, 0xb3, 0x64, 0xc7, 0x99, 0x5f, 0xf1, 0x59, 0x8f, 0xd3, 0x0d, 0xf0, 0xc1, 0x08, 0x15, 0xb1, + 0xdf, 0x98, 0x4c, 0x76, 0x4c, 0x29, 0x5f, 0xaf, 0x2a, 0x1d, 0x32, 0x91, 0xce, 0x09, 0xeb, 0x1b, + 0xa7, 0x1f, 0xa2, 0x8c, 0x1e, 0xd6, 0x64, 0xe2, 0x64, 0x03, 0xe6, 0x5b, 0xbe, 0x1b, 0xb8, 0xa1, + 0xfa, 0xe4, 0x66, 0x84, 0x10, 0x8b, 0x4a, 0xe8, 0x41, 0x8c, 0x73, 0x2a, 0xe2, 0x1f, 0xcd, 0xab, + 0x71, 0xee, 0xf0, 0x05, 0x0d, 0x07, 0x5b, 0x0a, 0x0a, 0x27, 0xa8, 0x39, 0xe3, 0x41, 0xf7, 0x78, + 0xdf, 0xaa, 0x91, 0xe4, 0x24, 0x08, 0xfa, 0x08, 0xe5, 0x0d, 0x0c, 0x2c, 0x05, 0xc5, 0xf8, 0x1d, + 0x0d, 0x36, 0xb2, 0xda, 0xc1, 0xae, 0x41, 0x61, 0x90, 0x99, 0xd7, 0x79, 0x20, 0xc2, 0xb6, 0x2c, + 0xa1, 0x65, 0xee, 0x70, 0xe8, 0x9f, 0x38, 0xa1, 0xfa, 0x30, 0x49, 0x01, 0x5b, 0x68, 0x49, 0xdc, + 0xc1, 0xff, 0xd9, 0x4d, 0x79, 0xe4, 0xe4, 0x27, 0x32, 0x41, 0xe3, 0x1f, 0xc3, 0x04, 0xa8, 0xf6, + 0x5a, 0xcd, 0x91, 0x48, 0x27, 0xf4, 0x36, 0x14, 0x78, 0xb5, 0x52, 0xb3, 0x97, 0xcf, 0x1f, 0xb3, + 0x5e, 0x23, 0x24, 0x51, 0xab, 0xc0, 0x39, 0xe9, 0x5b, 0x88, 0x6c, 0x3c, 0x81, 0xd5, 0x24, 0x06, + 0xab, 0x24, 0x23, 0xca, 0x2f, 0x3d, 0xd0, 0x89, 0xd3, 0xf6, 0x70, 0x28, 0x1e, 0xc7, 0x6e, 0x5f, + 0xfe, 0xd9, 0x67, 0x37, 0x81, 0xff, 0x14, 0x34, 0x59, 0x11, 0xe7, 0x8d, 0xdf, 0xcb, 0xc1, 0x46, + 0x1c, 0x8f, 0x47, 0xae, 0xa1, 0xbf, 0xb1, 0xc1, 0x21, 0xcc, 0x44, 0xf0, 0x02, 0x29, 0x37, 0x4e, + 0x36, 0x70, 0xc6, 0x9b, 0xe9, 0x5d, 0xd8, 0x9c, 0x86, 0xcf, 0x5e, 0x87, 0x45, 0x0c, 0x0b, 0x39, + 0x72, 0xba, 0xae, 0xba, 0xcd, 0x0e, 0x24, 0xd0, 0x8a, 0xcb, 0x8d, 0x3f, 0xd5, 0xe0, 0x0a, 0x3d, + 0xe9, 0xac, 0x3b, 0xde, 0x00, 0x0d, 0x41, 0x5d, 0xf7, 0xcb, 0x09, 0x6e, 0xb2, 0x9b, 0xd8, 0xc7, + 0x5e, 0x4d, 0xbe, 0xdc, 0x9d, 0xf8, 0xda, 0xf4, 0xd6, 0xb2, 0x7b, 0x18, 0xea, 0x94, 0x7c, 0xca, + 0x0a, 0x22, 0x98, 0xd4, 0x80, 0x03, 0xd4, 0x60, 0x52, 0x88, 0x61, 0xfc, 0x3d, 0xb8, 0x31, 0xfb, + 0x03, 0xec, 0xd7, 0x61, 0x05, 0x73, 0x77, 0xee, 0x8f, 0x8e, 0x7c, 0xa7, 0xe7, 0x4a, 0x15, 0xa1, + 0xd4, 0x64, 0xab, 0x65, 0x22, 0x72, 0x2b, 0x05, 0x37, 0x3a, 0xc2, 0xac, 0xa0, 0x44, 0x94, 0x78, + 0x37, 0xad, 0x72, 0x33, 0xbe, 0xaf, 0x01, 0x9b, 0xe4, 0xc1, 0xbe, 0x06, 0xcb, 0xfb, 0xed, 0x92, + 0x1d, 0x3a, 0x7e, 0xb8, 0x37, 0x1c, 0xfb, 0x14, 0x36, 0x55, 0xc4, 0xba, 0x09, 0xbb, 0x1d, 0x61, + 0xf2, 0x3b, 0x1e, 0x8e, 0x7d, 0x2b, 0x81, 0x87, 0x39, 0x22, 0x5d, 0xf7, 0xe3, 0x9e, 0x73, 0x9a, + 0xcc, 0x11, 0x49, 0xb0, 0x44, 0x8e, 0x48, 0x82, 0x19, 0x3f, 0xd2, 0xe0, 0xaa, 0x7c, 0xd3, 0xd0, + 0xcb, 0xa8, 0x4b, 0x09, 0x23, 0xba, 0xf9, 0x32, 0x4e, 0xff, 0x2c, 0x09, 0x7d, 0x5d, 0x06, 0x3d, + 0xc4, 0x0a, 0xa2, 0xa8, 0x2e, 0x68, 0xd9, 0xaf, 0x40, 0xc1, 0x0e, 0x87, 0xa3, 0x33, 0x44, 0x3d, + 0xd4, 0xa3, 0x11, 0x0d, 0x87, 0x23, 0x64, 0x81, 0x94, 0x86, 0x0b, 0x1b, 0x6a, 0xe5, 0x64, 0x8d, + 0x59, 0x1d, 0x16, 0x28, 0x64, 0x6e, 0xca, 0x0b, 0x6f, 0x46, 0x9b, 0xb6, 0xd7, 0x64, 0x68, 0x45, + 0x8a, 0x13, 0x6f, 0x49, 0x1e, 0xc6, 0x3f, 0xd2, 0x60, 0x89, 0x0b, 0x36, 0x78, 0x29, 0xfd, 0xa2, + 0x53, 0x3a, 0x29, 0x07, 0x4b, 0xa7, 0xd2, 0x88, 0xfd, 0x99, 0x4e, 0xe3, 0x77, 0x60, 0x2d, 0x45, + 0xc0, 0x0c, 0x0c, 0xaa, 0xd5, 0xf7, 0xba, 0x8e, 0x48, 0x39, 0x27, 0x1c, 0x32, 0x13, 0x30, 0xe3, + 0xef, 0x6b, 0xb0, 0xd1, 0xfc, 0x38, 0x74, 0x84, 0x65, 0xde, 0x1a, 0xf7, 0xe5, 0x7a, 0xe7, 0xc2, + 0x9a, 0x7c, 0x1c, 0x23, 0x02, 0xfe, 0x08, 0x61, 0x8d, 0x60, 0x56, 0x54, 0xca, 0xf6, 0xa0, 0x48, + 0xe7, 0x4b, 0x40, 0xe1, 0xdd, 0x6f, 0x28, 0xba, 0x91, 0x98, 0x31, 0x21, 0xf1, 0x96, 0xe0, 0x16, + 0x46, 0x34, 0x56, 0x44, 0x6d, 0xfc, 0x95, 0x06, 0x97, 0xa6, 0xd0, 0xb0, 0x6f, 0xc2, 0x1c, 0x06, + 0x23, 0xa0, 0xd1, 0xbb, 0x36, 0xe5, 0x13, 0x61, 0xf7, 0xf8, 0xe0, 0xbe, 0x38, 0x88, 0x4e, 0xf8, + 0x0f, 0x4b, 0x50, 0xb1, 0x0f, 0x61, 0xd1, 0xec, 0xf5, 0xe8, 0x76, 0x96, 0x4b, 0xdc, 0xce, 0xa6, + 0x7c, 0xf1, 0xcd, 0x08, 0x5f, 0xdc, 0xce, 0xc4, 0xb3, 0xd8, 0x5e, 0xaf, 0x43, 0x81, 0x16, 0x62, + 0x7e, 0x57, 0xbe, 0x01, 0xab, 0x49, 0xe4, 0x97, 0x7a, 0x1b, 0xfe, 0xa9, 0x06, 0x7a, 0xb2, 0x0e, + 0xbf, 0x98, 0xa0, 0x90, 0x59, 0xc3, 0xfc, 0x82, 0x49, 0xf5, 0x4f, 0x72, 0x70, 0x21, 0xb3, 0x87, + 0xd9, 0x1b, 0x30, 0x6f, 0x8e, 0x46, 0xd5, 0x32, 0xcd, 0x2a, 0x92, 0x90, 0x50, 0x79, 0x9e, 0xb8, + 0xbc, 0x0a, 0x24, 0xf6, 0x36, 0x14, 0x85, 0x03, 0x48, 0x59, 0x6e, 0x38, 0x18, 0xe5, 0x8e, 0xbc, + 0x53, 0x92, 0x81, 0xd6, 0x25, 0x22, 0xdb, 0x81, 0x55, 0x8a, 0x0f, 0x87, 0xde, 0x40, 0x51, 0xc6, + 0x1f, 0x74, 0xa0, 0x92, 0x1a, 0x79, 0xe1, 0x47, 0x94, 0xd8, 0x3b, 0x53, 0x54, 0xac, 0x06, 0x3a, + 0xf2, 0x54, 0x39, 0x89, 0x68, 0xef, 0x8a, 0x03, 0xde, 0x14, 0x5e, 0x13, 0x94, 0xd1, 0x70, 0x09, + 0x27, 0xf8, 0x13, 0x77, 0x10, 0xfe, 0xe2, 0x86, 0x2b, 0xfe, 0xc6, 0x99, 0x86, 0xeb, 0xf7, 0x0b, + 0x62, 0x31, 0xa7, 0xc9, 0xb8, 0x44, 0xa3, 0x24, 0xf8, 0x40, 0x89, 0x86, 0xdf, 0xcf, 0x28, 0x02, + 0x5a, 0x19, 0x16, 0x44, 0x64, 0x3a, 0xb9, 0x32, 0xae, 0x67, 0x56, 0x41, 0xe0, 0x1c, 0xdc, 0x17, + 0xe2, 0x8b, 0x88, 0x8a, 0x10, 0x58, 0x92, 0x94, 0x1d, 0xc0, 0x52, 0xa9, 0xef, 0x3a, 0x83, 0xf1, + 0xa8, 0x7d, 0x36, 0xeb, 0xf3, 0x26, 0xb5, 0x65, 0xb9, 0x2b, 0xc8, 0xd0, 0x6a, 0x8d, 0x3b, 0xb9, + 0xca, 0x88, 0xb5, 0xa3, 0x87, 0xd2, 0x05, 0x54, 0xbc, 0xbe, 0x35, 0xa3, 0x7f, 0xd2, 0x40, 0xa4, + 0x4b, 0x46, 0x01, 0xa0, 0x97, 0xd4, 0x1d, 0x58, 0xad, 0x39, 0x41, 0xd8, 0xf6, 0x9d, 0x41, 0x80, + 0x51, 0xb2, 0xcf, 0x10, 0xf1, 0xf3, 0x2a, 0x55, 0x58, 0x28, 0x64, 0xc3, 0x88, 0x54, 0x28, 0x64, + 0x93, 0xec, 0xb8, 0xbc, 0xb4, 0xe3, 0x0d, 0x9c, 0xbe, 0xf7, 0x3d, 0x19, 0x4f, 0x42, 0xc8, 0x4b, + 0x87, 0x12, 0x68, 0xc5, 0xe5, 0xc6, 0xaf, 0x4d, 0x8c, 0x9b, 0xa8, 0xe5, 0x12, 0x2c, 0x50, 0xb4, + 0x21, 0x11, 0x7d, 0xa7, 0x55, 0x69, 0x94, 0xab, 0x8d, 0x5d, 0x5d, 0x63, 0xab, 0x00, 0x2d, 0xab, + 0x59, 0xaa, 0xd8, 0x36, 0xff, 0x9d, 0xe3, 0xbf, 0x29, 0x34, 0xcf, 0xce, 0x7e, 0x4d, 0xcf, 0x2b, + 0xd1, 0x79, 0x0a, 0xc6, 0x9f, 0x68, 0x70, 0x31, 0x7b, 0x28, 0x59, 0x1b, 0x30, 0x3e, 0x13, 0xf9, + 0x21, 0x7c, 0x6d, 0xe6, 0xb8, 0x67, 0x82, 0xd3, 0x71, 0x9e, 0x42, 0x11, 0x3f, 0x28, 0x27, 0x6d, + 0x68, 0x22, 0x20, 0x81, 0xd7, 0xb3, 0x72, 0x5e, 0xcf, 0x28, 0xc1, 0xe6, 0x34, 0x1e, 0xc9, 0xa6, + 0xae, 0xc1, 0x92, 0xd9, 0x6a, 0xd5, 0xaa, 0x25, 0xb3, 0x5d, 0x6d, 0x36, 0x74, 0x8d, 0x2d, 0xc2, + 0xdc, 0xae, 0xd5, 0xdc, 0x6f, 0xe9, 0x39, 0xe3, 0x87, 0x1a, 0xac, 0x54, 0x63, 0x0f, 0xc9, 0x2f, + 0xba, 0xf8, 0xbe, 0x9e, 0x58, 0x7c, 0x9b, 0x51, 0x24, 0xb3, 0xe8, 0x03, 0x67, 0x5a, 0x79, 0x9f, + 0xe7, 0x60, 0x7d, 0x82, 0x86, 0xd9, 0xb0, 0x60, 0x3e, 0xb1, 0x9b, 0xd5, 0x72, 0x89, 0x6a, 0x76, + 0x33, 0xf6, 0x88, 0xc3, 0x7c, 0x99, 0x13, 0x5f, 0x11, 0xd1, 0x3f, 0x9e, 0x07, 0x9d, 0xa1, 0xd7, + 0xeb, 0x26, 0x5c, 0x32, 0x25, 0x27, 0x3c, 0xc9, 0xbe, 0x37, 0xf6, 0xd1, 0xcb, 0x94, 0x6a, 0x1d, + 0x39, 0xda, 0x49, 0xf8, 0x24, 0x63, 0xf4, 0xbb, 0x74, 0x78, 0xf9, 0x24, 0xeb, 0x98, 0x1f, 0x6b, + 0xc0, 0xfc, 0xae, 0x17, 0xee, 0x8d, 0x9f, 0xd1, 0xfa, 0xbd, 0x11, 0x67, 0x4f, 0xdc, 0x1b, 0x3f, + 0x9b, 0x64, 0x8b, 0x2a, 0x4b, 0x11, 0xa9, 0x2f, 0xc1, 0x92, 0xb8, 0xa4, 0x03, 0x16, 0x14, 0x5e, + 0x2a, 0x60, 0xc1, 0xf6, 0x0a, 0x2c, 0xd1, 0x1d, 0x0a, 0xaf, 0x27, 0x3f, 0xd1, 0x60, 0x73, 0x5a, + 0xcf, 0xf1, 0x6b, 0x59, 0x32, 0x30, 0xd1, 0xc5, 0x28, 0xbd, 0x56, 0xd2, 0x95, 0x57, 0xa2, 0xb1, + 0x0f, 0x60, 0x49, 0xb8, 0x7b, 0xd9, 0x6f, 0xef, 0x5b, 0x55, 0x9a, 0xae, 0xd7, 0xff, 0xf2, 0xb3, + 0x9b, 0x97, 0xc8, 0x43, 0x2c, 0x78, 0xbb, 0x33, 0xf6, 0xbd, 0x44, 0x2a, 0x22, 0x95, 0x82, 0x4b, + 0xd1, 0xce, 0xb8, 0xe7, 0xb9, 0xf2, 0x0e, 0x21, 0x83, 0xb7, 0x10, 0x4c, 0x3d, 0xd3, 0x24, 0xcc, + 0xf8, 0x81, 0x06, 0x57, 0xa6, 0x0f, 0x13, 0x3f, 0x27, 0xdb, 0xc2, 0x6b, 0x4e, 0x86, 0x4f, 0xc1, + 0x73, 0x32, 0x72, 0xad, 0x53, 0x79, 0x4a, 0x44, 0x4e, 0x44, 0x1a, 0x2e, 0xa9, 0x24, 0x41, 0xa2, + 0x48, 0x01, 0xa6, 0x12, 0x49, 0x44, 0xe3, 0x29, 0x5c, 0x9a, 0x32, 0xa8, 0xec, 0xfd, 0xcc, 0xa4, + 0x7d, 0xf8, 0xba, 0x58, 0x4d, 0xda, 0x97, 0xc8, 0xfe, 0xaa, 0xc0, 0x8d, 0xff, 0x9e, 0x83, 0x8b, + 0x7c, 0x75, 0xf5, 0xdd, 0x20, 0x30, 0xe3, 0xfc, 0xf6, 0x7c, 0x57, 0x7c, 0x17, 0xe6, 0x8f, 0x5f, + 0x4e, 0x55, 0x2c, 0xd0, 0x19, 0x03, 0x3c, 0xb1, 0xe4, 0x9b, 0x56, 0xfe, 0x3f, 0xbb, 0x0d, 0x32, + 0x26, 0x08, 0x97, 0xb5, 0xf2, 0x18, 0xca, 0x3c, 0xb7, 0xa9, 0x59, 0x8b, 0x02, 0xfa, 0xd8, 0x3d, + 0x65, 0xef, 0xc1, 0x1c, 0xea, 0x53, 0xe8, 0xec, 0x90, 0x32, 0x7f, 0x76, 0xed, 0x50, 0xdb, 0x62, + 0x09, 0x02, 0xf6, 0x55, 0x80, 0x38, 0xb3, 0x14, 0x1d, 0x0e, 0x52, 0xcf, 0x10, 0x25, 0x97, 0xb2, + 0x16, 0x4f, 0x0e, 0x1d, 0x4a, 0xd7, 0xb4, 0x05, 0xeb, 0xb2, 0xc7, 0x47, 0x32, 0x02, 0x32, 0x59, + 0x31, 0xd7, 0x44, 0x41, 0x75, 0x24, 0xa3, 0x20, 0xdf, 0x81, 0xd5, 0x20, 0x38, 0xee, 0x28, 0xb5, + 0xc7, 0xe4, 0x0a, 0xd6, 0x72, 0x10, 0x1c, 0xb7, 0xa2, 0xca, 0xdf, 0x81, 0x55, 0x74, 0xd7, 0x8c, + 0xb1, 0x8a, 0x02, 0x2b, 0xec, 0x07, 0x11, 0x96, 0xf1, 0x5f, 0x72, 0xb0, 0xf8, 0x84, 0x4b, 0x65, + 0xa8, 0x6b, 0x98, 0xad, 0xbb, 0x78, 0x00, 0x4b, 0xb5, 0xa1, 0x43, 0xe6, 0x22, 0x7a, 0x0a, 0x2a, + 0xbc, 0xb9, 0xfb, 0x43, 0x47, 0x5a, 0x9e, 0x02, 0x4b, 0x45, 0x7a, 0x41, 0xec, 0x99, 0x47, 0x30, + 0x2f, 0xcc, 0x77, 0xa4, 0x46, 0x93, 0x72, 0x79, 0x54, 0xa3, 0x37, 0x45, 0xb1, 0x62, 0xe1, 0x10, + 0x26, 0x40, 0x55, 0x48, 0x24, 0xcf, 0x6d, 0x45, 0xb3, 0x32, 0x77, 0x36, 0xcd, 0x8a, 0x12, 0xb7, + 0x76, 0xfe, 0x2c, 0x71, 0x6b, 0xaf, 0x3c, 0x84, 0x25, 0xa5, 0x3e, 0x2f, 0x25, 0xa6, 0xff, 0x56, + 0x0e, 0x56, 0xb0, 0x55, 0x91, 0x53, 0xd0, 0xdf, 0x4c, 0x3d, 0xd1, 0xd7, 0x13, 0x7a, 0xa2, 0x4d, + 0x75, 0xbc, 0x44, 0xcb, 0x66, 0x28, 0x88, 0x1e, 0xc1, 0xfa, 0x04, 0x22, 0x7b, 0x07, 0xe6, 0x78, + 0xf5, 0xe5, 0xbd, 0x5a, 0x4f, 0xcf, 0x80, 0x38, 0xc7, 0x01, 0x6f, 0x78, 0x60, 0x09, 0x6c, 0xe3, + 0x7f, 0x6a, 0xb0, 0x4c, 0x69, 0xcb, 0x06, 0x87, 0xc3, 0x17, 0x76, 0xe7, 0xdd, 0x74, 0x77, 0x8a, + 0x48, 0x6a, 0xd4, 0x9d, 0xff, 0xb7, 0x3b, 0xf1, 0x61, 0xa2, 0x13, 0x2f, 0x45, 0x11, 0x8f, 0x65, + 0x73, 0x66, 0xf4, 0xe1, 0x8f, 0x31, 0x07, 0x40, 0x12, 0x91, 0xfd, 0x06, 0x2c, 0x36, 0xdc, 0xe7, + 0x89, 0xeb, 0xe9, 0xdd, 0x29, 0x4c, 0xdf, 0x8c, 0x10, 0xc5, 0x9a, 0x12, 0x2f, 0x2a, 0xdc, 0xe7, + 0x9d, 0x09, 0xcb, 0x61, 0xcc, 0x92, 0xdf, 0x50, 0x93, 0x64, 0x2f, 0x33, 0xf5, 0x29, 0x2e, 0x05, + 0x06, 0x07, 0xfc, 0x9d, 0x3c, 0x40, 0xfc, 0xa4, 0x9f, 0x2f, 0xc0, 0x84, 0xd3, 0x84, 0xd4, 0xec, + 0x23, 0x48, 0x9d, 0xe3, 0xd2, 0x97, 0xe2, 0x2e, 0x69, 0xa0, 0x73, 0xd3, 0x23, 0x52, 0xa3, 0x2e, + 0xba, 0x44, 0x6f, 0xc8, 0x7b, 0x6e, 0xdf, 0x11, 0x7b, 0x7b, 0x7e, 0xfb, 0x0e, 0x26, 0x20, 0x88, + 0xa0, 0x89, 0x70, 0xc1, 0xc5, 0xf2, 0x98, 0x12, 0x9f, 0xe0, 0x4b, 0xf3, 0x32, 0x47, 0x98, 0x08, + 0x93, 0x51, 0x78, 0xb9, 0x30, 0x19, 0x2d, 0x58, 0xf4, 0x06, 0x9f, 0xb8, 0x83, 0x70, 0xe8, 0x9f, + 0xa2, 0xda, 0x3d, 0xd6, 0xe7, 0xf1, 0x2e, 0xa8, 0xca, 0x32, 0x31, 0x0e, 0x78, 0xe6, 0x46, 0xf8, + 0xea, 0x30, 0x44, 0xc0, 0x28, 0xcc, 0xc7, 0x9c, 0x3e, 0xff, 0xa8, 0x50, 0x9c, 0xd7, 0x17, 0x1e, + 0x15, 0x8a, 0x45, 0x7d, 0xf1, 0x51, 0xa1, 0xb8, 0xa8, 0x83, 0xa5, 0xd8, 0xcc, 0x22, 0x9b, 0x98, + 0x62, 0xc6, 0x4a, 0x9a, 0xa8, 0x8c, 0xbf, 0xce, 0x01, 0x9b, 0xac, 0x06, 0xfb, 0x3a, 0x2c, 0x89, + 0x0d, 0xb6, 0xe3, 0x07, 0xdf, 0xa1, 0x17, 0x25, 0xe2, 0x19, 0x98, 0x02, 0x56, 0x43, 0x2c, 0x0a, + 0xb0, 0x15, 0x7c, 0xa7, 0xcf, 0x7e, 0x1d, 0xce, 0x63, 0xf7, 0x8e, 0x5c, 0xdf, 0x1b, 0xf6, 0x3a, + 0x18, 0x0f, 0xdf, 0xe9, 0x53, 0x6a, 0xe9, 0x37, 0xfe, 0xf2, 0xb3, 0x9b, 0xd7, 0x33, 0x8a, 0xa7, + 0x0c, 0x03, 0xbe, 0xdc, 0x6f, 0x21, 0x66, 0x4b, 0x20, 0xb2, 0x36, 0xe8, 0x2a, 0xfd, 0xe1, 0xb8, + 0xdf, 0xa7, 0x91, 0xdd, 0xe2, 0x37, 0xfa, 0x74, 0xd9, 0x14, 0xc6, 0xab, 0x31, 0xe3, 0x9d, 0x71, + 0xbf, 0xcf, 0xde, 0x05, 0x18, 0x0e, 0x3a, 0x27, 0x5e, 0x10, 0x08, 0x63, 0x4e, 0xf4, 0xca, 0x28, + 0x86, 0xaa, 0x83, 0x31, 0x1c, 0xd4, 0x05, 0x90, 0xfd, 0x1d, 0xc0, 0xc8, 0x4c, 0x18, 0xb2, 0x4c, + 0x78, 0x23, 0x51, 0xf6, 0x37, 0x09, 0x4c, 0xc6, 0x34, 0x39, 0x72, 0x6d, 0xef, 0x7b, 0xf2, 0x31, + 0xd6, 0xb7, 0x61, 0x9d, 0x1c, 0xaf, 0x9f, 0x78, 0xe1, 0x31, 0x5d, 0x25, 0xbe, 0xc8, 0x3d, 0x44, + 0xb9, 0x4b, 0xfc, 0x79, 0x01, 0xc0, 0x7c, 0x62, 0xcb, 0x68, 0xa0, 0xf7, 0x60, 0x8e, 0x5f, 0x90, + 0xa4, 0xa2, 0x05, 0xd5, 0xd4, 0xc8, 0x57, 0x55, 0x53, 0x23, 0x06, 0x5f, 0x8d, 0x16, 0xbe, 0x9b, + 0x90, 0x4a, 0x16, 0x5c, 0x8d, 0xe2, 0x29, 0x45, 0x22, 0x1b, 0x03, 0x61, 0xb1, 0x1a, 0x40, 0x1c, + 0x9f, 0x93, 0x44, 0xfe, 0xf5, 0x38, 0xd0, 0x1d, 0x15, 0x50, 0x96, 0xa9, 0xf8, 0x71, 0x9c, 0x3a, + 0x7d, 0x62, 0x34, 0xf6, 0x18, 0x0a, 0x6d, 0x27, 0x0a, 0xa1, 0x31, 0x25, 0x6a, 0xe9, 0x2d, 0x4a, + 0xfd, 0x1d, 0x47, 0x2e, 0x5d, 0x0d, 0x9d, 0x23, 0xb5, 0x76, 0xc8, 0x84, 0x55, 0x60, 0xbe, 0xe5, + 0xf8, 0xce, 0x49, 0x30, 0x2d, 0xda, 0xb5, 0x28, 0x95, 0x39, 0x2e, 0x10, 0xa8, 0xca, 0x14, 0xa2, + 0x98, 0x3d, 0x80, 0xbc, 0x6d, 0xd7, 0x29, 0x56, 0xd7, 0x4a, 0x7c, 0xfd, 0xb2, 0xed, 0xba, 0xb0, + 0xfb, 0x06, 0xc1, 0x89, 0x42, 0xc6, 0x91, 0xd9, 0x2f, 0xc3, 0x92, 0x22, 0x14, 0x53, 0x94, 0x3b, + 0xec, 0x03, 0xe5, 0x65, 0x9e, 0xba, 0x69, 0x28, 0xd8, 0xac, 0x06, 0xfa, 0xe3, 0xf1, 0x33, 0xd7, + 0x1c, 0x8d, 0x30, 0x28, 0xc0, 0x27, 0xae, 0x2f, 0xc4, 0xb6, 0x62, 0x9c, 0x1e, 0x02, 0x9f, 0xc1, + 0xf4, 0x64, 0xa9, 0xaa, 0x6c, 0x4a, 0x53, 0xb2, 0x16, 0xac, 0xdb, 0x6e, 0x38, 0x1e, 0x09, 0xff, + 0x9a, 0x9d, 0xa1, 0xcf, 0xef, 0x37, 0x22, 0x26, 0x1e, 0x46, 0xd2, 0x0f, 0x78, 0xa1, 0x74, 0x6a, + 0x3a, 0x1c, 0xfa, 0xa9, 0xbb, 0xce, 0x24, 0xb1, 0xe1, 0xaa, 0x43, 0xce, 0x4f, 0xd5, 0xe4, 0xad, + 0x09, 0x4f, 0x55, 0x79, 0x6b, 0x8a, 0xef, 0x4a, 0x5f, 0xcd, 0x88, 0xdb, 0x8a, 0x96, 0x41, 0x25, + 0x6e, 0x6b, 0x22, 0x5a, 0xeb, 0x8f, 0x0a, 0x4a, 0xe8, 0x70, 0x1a, 0x8b, 0x6f, 0x02, 0x3c, 0x1a, + 0x7a, 0x83, 0xba, 0x1b, 0x1e, 0x0f, 0x7b, 0xca, 0xbb, 0xcb, 0xa5, 0x8f, 0x86, 0xde, 0xa0, 0x73, + 0x82, 0xe0, 0xbf, 0xfe, 0xec, 0xa6, 0x82, 0x64, 0x29, 0xff, 0xb3, 0xaf, 0xc0, 0x22, 0xff, 0xd5, + 0x8e, 0xbd, 0x84, 0x84, 0x4e, 0x16, 0xa9, 0x45, 0xd2, 0xae, 0x18, 0x81, 0x3d, 0xc4, 0x34, 0x75, + 0xde, 0x28, 0x54, 0x84, 0x57, 0x99, 0x93, 0xce, 0x1b, 0x85, 0xe9, 0x47, 0x97, 0x0a, 0x32, 0xdb, + 0x8b, 0xaa, 0x2e, 0x33, 0x4b, 0x52, 0x36, 0x3c, 0x7a, 0xb9, 0x89, 0x45, 0x1d, 0x19, 0x86, 0x5e, + 0x7d, 0xb9, 0x99, 0x22, 0xc3, 0x4a, 0xd8, 0x7b, 0x65, 0x61, 0x29, 0x22, 0xa1, 0x56, 0x54, 0x22, + 0x38, 0xee, 0x75, 0xba, 0x08, 0x4e, 0x54, 0x22, 0x42, 0x66, 0xdb, 0xb0, 0x26, 0x64, 0xfc, 0x28, + 0x43, 0x35, 0x89, 0xb8, 0xb8, 0xb7, 0xc5, 0x29, 0xac, 0xd5, 0xcf, 0xa7, 0x08, 0xd8, 0x0e, 0xcc, + 0xe1, 0x5d, 0x93, 0x9e, 0x55, 0x5c, 0x55, 0xd5, 0x04, 0xe9, 0x75, 0x84, 0xfb, 0x0a, 0x2a, 0x08, + 0xd4, 0x7d, 0x05, 0x51, 0xd9, 0xaf, 0x02, 0x54, 0x06, 0xfe, 0xb0, 0xdf, 0xc7, 0x44, 0x09, 0xc5, + 0xc4, 0x03, 0x6f, 0xe2, 0x83, 0x5c, 0x62, 0x24, 0x0a, 0xea, 0x8b, 0xbf, 0x3b, 0xa9, 0x74, 0x0a, + 0x0a, 0x2f, 0xa3, 0x0a, 0xf3, 0x62, 0x31, 0x62, 0xd2, 0x11, 0x4a, 0xcd, 0xa6, 0xa4, 0xac, 0x10, + 0x49, 0x47, 0x08, 0x3e, 0x99, 0x74, 0x44, 0x21, 0x30, 0x1e, 0xc3, 0x46, 0x56, 0xc3, 0x12, 0xb7, + 0x63, 0xed, 0xac, 0xb7, 0xe3, 0x3f, 0xcc, 0xc3, 0x32, 0x72, 0x93, 0xbb, 0xb0, 0x09, 0x2b, 0xf6, + 0xf8, 0x59, 0x14, 0x91, 0x53, 0xee, 0xc6, 0x58, 0xbf, 0x40, 0x2d, 0x50, 0x6d, 0x78, 0x09, 0x0a, + 0x56, 0x81, 0x55, 0x79, 0x12, 0xec, 0xca, 0x27, 0x08, 0x51, 0xbe, 0x0f, 0xf9, 0x32, 0x63, 0x32, + 0x43, 0x7f, 0x8a, 0x28, 0x3e, 0x0f, 0xf2, 0x2f, 0x73, 0x1e, 0x14, 0xce, 0x74, 0x1e, 0x7c, 0x08, + 0xcb, 0xf2, 0x6b, 0xb8, 0x93, 0xcf, 0x7d, 0xb1, 0x9d, 0x3c, 0xc1, 0x8c, 0xd5, 0xa2, 0x1d, 0x7d, + 0x7e, 0xe6, 0x8e, 0x8e, 0x86, 0x51, 0xb9, 0xca, 0x46, 0x08, 0x9b, 0xdc, 0xd8, 0x31, 0x85, 0xf5, + 0x6e, 0xa9, 0xf5, 0x73, 0x9c, 0x92, 0xef, 0xc0, 0x62, 0x6d, 0x28, 0x6d, 0x62, 0x8a, 0x31, 0xa2, + 0x2f, 0x81, 0xaa, 0xb8, 0x10, 0x61, 0x46, 0xa7, 0x5b, 0xfe, 0xcb, 0x38, 0xdd, 0x1e, 0x02, 0xd0, + 0xdb, 0x96, 0x38, 0xf5, 0x2c, 0x2e, 0x19, 0x19, 0x58, 0x2c, 0x69, 0x13, 0x51, 0x90, 0xf9, 0xee, + 0x44, 0xee, 0x36, 0x32, 0x0c, 0x01, 0xe5, 0x82, 0xc4, 0xdd, 0x49, 0xc6, 0x72, 0x90, 0x91, 0x0d, + 0xd4, 0xed, 0x21, 0x45, 0xf6, 0xe5, 0x0e, 0x08, 0xfb, 0x56, 0xe4, 0xfc, 0xb8, 0x30, 0xab, 0x87, + 0x8c, 0x89, 0x1e, 0x9a, 0xea, 0xf2, 0x68, 0xfc, 0x89, 0xa6, 0x26, 0x5b, 0xfa, 0x39, 0x86, 0xfa, + 0x3d, 0x80, 0xc8, 0x29, 0x41, 0x8e, 0x75, 0xf4, 0x02, 0x5d, 0x40, 0xd5, 0x5e, 0x8e, 0x71, 0x95, + 0xd6, 0xe4, 0xbf, 0xac, 0xd6, 0xb4, 0x61, 0xa9, 0xf9, 0x71, 0xe8, 0xc4, 0x5e, 0x2c, 0x60, 0x47, + 0x92, 0x2c, 0xee, 0x4c, 0xf9, 0xed, 0x57, 0xf1, 0x6c, 0x88, 0xe5, 0xe0, 0x29, 0x22, 0xb0, 0x42, + 0x68, 0xfc, 0x6f, 0x0d, 0xd6, 0xd4, 0x20, 0x34, 0xa7, 0x83, 0x2e, 0x7b, 0x5f, 0xc4, 0x7e, 0xd7, + 0x12, 0x57, 0x16, 0x05, 0x89, 0x6f, 0xb9, 0xa7, 0x83, 0xae, 0x10, 0x80, 0x9c, 0xe7, 0x6a, 0x65, + 0x39, 0x21, 0x7b, 0x06, 0xcb, 0xad, 0x61, 0xbf, 0xcf, 0xc5, 0x1a, 0xff, 0x13, 0xba, 0x00, 0x70, + 0x46, 0x69, 0xd3, 0x88, 0xac, 0xd0, 0xf6, 0x2b, 0x74, 0xcf, 0xbd, 0x34, 0xe2, 0xfb, 0xbd, 0x47, + 0x74, 0x31, 0xdb, 0x4f, 0xf1, 0x8d, 0xa1, 0xca, 0x33, 0x3e, 0x9b, 0x92, 0x49, 0x83, 0xd4, 0x5a, + 0xf2, 0x62, 0xac, 0xe7, 0x8c, 0xb3, 0xc9, 0xf8, 0x33, 0x0d, 0xd8, 0x64, 0xd3, 0xd4, 0xad, 0x4f, + 0xfb, 0x7f, 0x20, 0x0a, 0xa7, 0x44, 0xc8, 0xc2, 0xcb, 0x88, 0x90, 0xc6, 0x1f, 0x68, 0xb0, 0x91, + 0xd5, 0x0f, 0xfc, 0x04, 0x51, 0x8f, 0x94, 0xe8, 0x40, 0xc3, 0x13, 0x44, 0x3d, 0x85, 0x92, 0xc7, + 0x5a, 0x8a, 0x28, 0x5d, 0xb9, 0xdc, 0xcb, 0x54, 0x6e, 0xeb, 0x1f, 0x6b, 0xb0, 0x56, 0x35, 0xeb, + 0x94, 0x63, 0x4a, 0x98, 0xa9, 0x6e, 0xc3, 0xf5, 0xaa, 0x59, 0xef, 0xb4, 0x9a, 0xb5, 0x6a, 0xe9, + 0x69, 0x27, 0x33, 0x75, 0xc4, 0x75, 0xb8, 0x3c, 0x89, 0x12, 0x9b, 0xb3, 0xae, 0xc1, 0xe6, 0x64, + 0xb1, 0x4c, 0x2f, 0x91, 0x4d, 0x2c, 0x33, 0x51, 0xe4, 0xb7, 0x3e, 0x80, 0x35, 0x99, 0x4a, 0xa1, + 0x5d, 0xb3, 0x31, 0x59, 0xd3, 0x1a, 0x2c, 0x1d, 0x54, 0xac, 0xea, 0xce, 0xd3, 0xce, 0xce, 0x7e, + 0xad, 0xa6, 0x9f, 0x63, 0x2b, 0xb0, 0x48, 0x80, 0x92, 0xa9, 0x6b, 0x6c, 0x19, 0x8a, 0xd5, 0x86, + 0x5d, 0x29, 0xed, 0x5b, 0x15, 0x3d, 0xb7, 0xf5, 0x2f, 0x34, 0x58, 0xd9, 0x1f, 0xf5, 0x9c, 0xd0, + 0xf5, 0xa9, 0x45, 0x37, 0xe0, 0xca, 0x7e, 0xab, 0x6c, 0xb6, 0x2b, 0x56, 0x76, 0x73, 0x2e, 0xc0, + 0x7a, 0xaa, 0xbc, 0xf9, 0x58, 0xd7, 0xd8, 0x55, 0xb8, 0x94, 0x02, 0x97, 0xab, 0xb6, 0xb9, 0x2d, + 0x5a, 0x71, 0x19, 0x2e, 0xa4, 0x0a, 0x5b, 0xd5, 0x46, 0xa3, 0x52, 0xd6, 0xf3, 0xbc, 0x81, 0x13, + 0x9f, 0xb3, 0x2a, 0x66, 0x99, 0x93, 0xea, 0x85, 0xad, 0x0f, 0x60, 0xb5, 0xe5, 0x7b, 0x9f, 0x38, + 0xa1, 0xfb, 0xd8, 0x3d, 0x45, 0x6b, 0xd9, 0x02, 0xe4, 0x2d, 0xf3, 0x89, 0x7e, 0x8e, 0x01, 0xcc, + 0xb7, 0x1e, 0x97, 0xec, 0xfb, 0xf7, 0x75, 0x8d, 0x2d, 0xc1, 0xc2, 0x6e, 0xa9, 0xd5, 0x79, 0x5c, + 0xb7, 0xf5, 0x1c, 0xff, 0x61, 0x3e, 0xb1, 0xf1, 0x47, 0x7e, 0xeb, 0x2d, 0x58, 0x47, 0xa9, 0xb0, + 0xe6, 0x05, 0xa1, 0x3b, 0x70, 0x7d, 0xec, 0xa3, 0x65, 0x28, 0xda, 0x2e, 0xdf, 0xce, 0x43, 0x57, + 0x74, 0x50, 0x7d, 0xdc, 0x0f, 0xbd, 0x51, 0xdf, 0xfd, 0xae, 0xae, 0x6d, 0x3d, 0x84, 0x35, 0x6b, + 0x38, 0x0e, 0xbd, 0xc1, 0x91, 0x1d, 0x72, 0x8c, 0xa3, 0x53, 0x6c, 0x73, 0xc3, 0xac, 0x6f, 0x57, + 0x77, 0xf7, 0x9b, 0xfb, 0x76, 0xa7, 0x6e, 0xb6, 0x4b, 0x7b, 0xc2, 0x56, 0x57, 0x6f, 0xda, 0xed, + 0x8e, 0x55, 0x29, 0x55, 0x1a, 0x6d, 0x5d, 0xdb, 0xfa, 0x3d, 0x54, 0x70, 0x75, 0x87, 0x83, 0xde, + 0x8e, 0xd3, 0x0d, 0x87, 0x3e, 0x56, 0xd8, 0x80, 0x1b, 0x76, 0xa5, 0xd4, 0x6c, 0x94, 0x3b, 0x3b, + 0x66, 0xa9, 0xdd, 0xb4, 0xb2, 0x72, 0xab, 0x5c, 0x81, 0x8b, 0x19, 0x38, 0xcd, 0x76, 0x4b, 0xd7, + 0xd8, 0x4d, 0xb8, 0x9a, 0x51, 0xf6, 0xa4, 0xb2, 0x6d, 0xee, 0xb7, 0xf7, 0x1a, 0x7a, 0x6e, 0x0a, + 0xb1, 0x6d, 0x37, 0xf5, 0xfc, 0xd6, 0x3f, 0xd0, 0x60, 0x75, 0x3f, 0x20, 0xbf, 0xff, 0x7d, 0x7c, + 0x2e, 0x7d, 0x0b, 0xae, 0xed, 0xdb, 0x15, 0xab, 0xd3, 0x6e, 0x3e, 0xae, 0x34, 0x3a, 0xfb, 0xb6, + 0xb9, 0x9b, 0xae, 0xcd, 0x4d, 0xb8, 0xaa, 0x60, 0x58, 0x95, 0x52, 0xf3, 0xa0, 0x62, 0x75, 0x5a, + 0xa6, 0x6d, 0x3f, 0x69, 0x5a, 0x65, 0x5d, 0xe3, 0x5f, 0xcc, 0x40, 0xa8, 0xef, 0x98, 0xa2, 0x36, + 0x89, 0xb2, 0x46, 0xe5, 0x89, 0x59, 0xeb, 0x6c, 0x37, 0xdb, 0x7a, 0x7e, 0xab, 0xce, 0x85, 0x2c, + 0xcc, 0x70, 0x20, 0xdc, 0x3b, 0x8b, 0x50, 0x68, 0x34, 0x1b, 0x95, 0xb4, 0x85, 0x77, 0x19, 0x8a, + 0x66, 0xab, 0x65, 0x35, 0x0f, 0x70, 0xf2, 0x00, 0xcc, 0x97, 0x2b, 0x8d, 0x2a, 0xce, 0x96, 0x65, + 0x28, 0xb6, 0xac, 0x66, 0xbd, 0xd9, 0xae, 0x94, 0xf5, 0xc2, 0x96, 0x25, 0xf7, 0x3f, 0xc9, 0xb4, + 0x3b, 0x14, 0xe6, 0xd4, 0x72, 0x65, 0xc7, 0xdc, 0xaf, 0xb5, 0x69, 0x88, 0x9e, 0x76, 0xac, 0xca, + 0xb7, 0xf6, 0x2b, 0x76, 0xdb, 0xd6, 0x35, 0xa6, 0xc3, 0x72, 0xa3, 0x52, 0x29, 0xdb, 0x1d, 0xab, + 0x72, 0x50, 0xad, 0x3c, 0xd1, 0x73, 0x9c, 0xa7, 0xf8, 0x9f, 0x7f, 0x61, 0xeb, 0x47, 0x1a, 0x30, + 0x91, 0x1d, 0x42, 0xa6, 0x1c, 0xc4, 0x19, 0x73, 0x03, 0xae, 0xec, 0xf1, 0xa1, 0xc6, 0xa6, 0xd5, + 0x9b, 0xe5, 0x74, 0x97, 0x5d, 0x04, 0x96, 0x2a, 0x6f, 0xee, 0xec, 0xe0, 0xb2, 0x38, 0x9f, 0x82, + 0x97, 0xad, 0x66, 0x4b, 0xcf, 0x5d, 0xc9, 0x15, 0x35, 0x76, 0x69, 0xa2, 0xf0, 0x71, 0xa5, 0xd2, + 0xd2, 0xf3, 0x7c, 0x88, 0x52, 0x05, 0x72, 0xc9, 0x0a, 0xf2, 0xc2, 0xd6, 0x0f, 0x34, 0xb8, 0x28, + 0xaa, 0x29, 0xd7, 0x7f, 0x54, 0xd5, 0x6b, 0xb0, 0x49, 0x39, 0x6f, 0xb2, 0x2a, 0xba, 0x01, 0x7a, + 0xa2, 0x54, 0x54, 0xf3, 0x02, 0xac, 0x27, 0xa0, 0x58, 0x8f, 0x1c, 0xdf, 0xdd, 0x12, 0xe0, 0xed, + 0x8a, 0xdd, 0xee, 0x54, 0x76, 0x76, 0x9a, 0x56, 0x5b, 0x54, 0x24, 0xbf, 0x65, 0xc0, 0x7a, 0xc9, + 0xf5, 0x43, 0x7e, 0xff, 0x1d, 0x04, 0xde, 0x70, 0x80, 0x55, 0x58, 0x81, 0xc5, 0xca, 0xaf, 0xb6, + 0x2b, 0x0d, 0xbb, 0xda, 0x6c, 0xe8, 0xe7, 0xb6, 0xae, 0xa5, 0x70, 0xe4, 0x3a, 0xb6, 0xed, 0x3d, + 0xfd, 0xdc, 0x96, 0x03, 0x2b, 0xd2, 0xfb, 0x5d, 0xcc, 0x8a, 0x1b, 0x70, 0x45, 0xce, 0x35, 0xdc, + 0x13, 0xd2, 0x4d, 0xd8, 0x84, 0x8d, 0xc9, 0xf2, 0x4a, 0x5b, 0xd7, 0xf8, 0x28, 0xa4, 0x4a, 0x38, + 0x3c, 0xb7, 0xf5, 0xdb, 0x1a, 0xac, 0x44, 0x96, 0x2b, 0xd4, 0x95, 0xdf, 0x84, 0xab, 0xf5, 0x1d, + 0xb3, 0x53, 0xae, 0x1c, 0x54, 0x4b, 0x95, 0xce, 0xe3, 0x6a, 0xa3, 0x9c, 0xfa, 0xc8, 0x65, 0xb8, + 0x90, 0x81, 0x80, 0x5f, 0xd9, 0x84, 0x8d, 0x74, 0x51, 0x9b, 0x2f, 0xd5, 0x1c, 0xef, 0xfa, 0x74, + 0x49, 0xb4, 0x4e, 0xf3, 0x5b, 0x07, 0xb0, 0x6a, 0x9b, 0xf5, 0xda, 0xce, 0xd0, 0xef, 0xba, 0xe6, + 0x38, 0x3c, 0x1e, 0xf0, 0x4d, 0x73, 0xa7, 0x69, 0x95, 0x2a, 0x1d, 0x44, 0x49, 0xd5, 0xe0, 0x3c, + 0xac, 0xa9, 0x85, 0x4f, 0x2b, 0x7c, 0xfa, 0x32, 0x58, 0x55, 0x81, 0x8d, 0xa6, 0x9e, 0xdb, 0xfa, + 0x35, 0x58, 0x4e, 0x64, 0x1e, 0xbe, 0x04, 0xe7, 0xd5, 0xdf, 0x2d, 0x77, 0xd0, 0xf3, 0x06, 0x47, + 0xfa, 0xb9, 0x74, 0x81, 0x35, 0x1e, 0x0c, 0x78, 0x01, 0xae, 0x67, 0xb5, 0xa0, 0xed, 0xfa, 0x27, + 0xde, 0xc0, 0x09, 0xdd, 0x9e, 0x9e, 0xdb, 0x7a, 0x13, 0x56, 0x12, 0xf9, 0x4e, 0xf8, 0xc0, 0xd5, + 0x9a, 0xb4, 0x01, 0xd7, 0x2b, 0xe5, 0xea, 0x7e, 0x5d, 0x9f, 0xe3, 0x2b, 0x79, 0xaf, 0xba, 0xbb, + 0xa7, 0xc3, 0xd6, 0x0f, 0x35, 0x7e, 0xd9, 0xc3, 0x2c, 0x86, 0xf5, 0x1d, 0x53, 0x0e, 0x35, 0x9f, + 0x66, 0x22, 0x8b, 0x52, 0xc5, 0xb6, 0x85, 0x63, 0xc3, 0x35, 0xd8, 0xa4, 0x1f, 0x1d, 0xb3, 0x51, + 0xee, 0xec, 0x99, 0x56, 0xf9, 0x89, 0x69, 0xf1, 0xb9, 0xf7, 0x54, 0xcf, 0xe1, 0x82, 0x52, 0x20, + 0x9d, 0x76, 0x73, 0xbf, 0xb4, 0xa7, 0xe7, 0xf9, 0xfc, 0x4d, 0xc0, 0x5b, 0xd5, 0x86, 0x5e, 0xc0, + 0xe5, 0x39, 0x81, 0x8d, 0x6c, 0x79, 0xf9, 0xdc, 0xd6, 0xe7, 0x1a, 0x5c, 0xb2, 0xbd, 0xa3, 0x81, + 0x13, 0x8e, 0x7d, 0xd7, 0xec, 0x1f, 0x0d, 0x7d, 0x2f, 0x3c, 0x3e, 0xb1, 0xc7, 0x5e, 0xe8, 0xb2, + 0x7b, 0xf0, 0xaa, 0x5d, 0xdd, 0x6d, 0x98, 0x6d, 0xbe, 0xbc, 0xcc, 0xda, 0x6e, 0xd3, 0xaa, 0xb6, + 0xf7, 0xea, 0x1d, 0x7b, 0xbf, 0x3a, 0x31, 0xf3, 0xee, 0xc0, 0xad, 0xe9, 0xa8, 0xb5, 0xca, 0xae, + 0x59, 0x7a, 0xaa, 0x6b, 0xb3, 0x19, 0x6e, 0x9b, 0x35, 0xb3, 0x51, 0xaa, 0x94, 0x3b, 0x07, 0xf7, + 0xf5, 0x1c, 0x7b, 0x15, 0x6e, 0x4f, 0x47, 0xdd, 0xa9, 0xb6, 0x6c, 0x8e, 0x96, 0x9f, 0xfd, 0xdd, + 0x3d, 0xbb, 0xce, 0xb1, 0x0a, 0x5b, 0x7f, 0xa0, 0xc1, 0xe6, 0xb4, 0xb0, 0x90, 0xec, 0x2e, 0x18, + 0x95, 0x46, 0xdb, 0x32, 0xab, 0xe5, 0x4e, 0xc9, 0xaa, 0x94, 0x2b, 0x8d, 0x76, 0xd5, 0xac, 0xd9, + 0x1d, 0xbb, 0xb9, 0xcf, 0x67, 0x53, 0xec, 0x7f, 0xf2, 0x0a, 0xdc, 0x9c, 0x81, 0xd7, 0xac, 0x96, + 0x4b, 0xba, 0xc6, 0xee, 0xc3, 0x1b, 0x33, 0x90, 0xec, 0xa7, 0x76, 0xbb, 0x52, 0x57, 0x4b, 0xf4, + 0x1c, 0x6e, 0x58, 0xd9, 0x11, 0xf1, 0x78, 0xeb, 0xb0, 0x64, 0x76, 0xc5, 0x6e, 0xc3, 0xf5, 0xa9, + 0x58, 0x54, 0xad, 0x57, 0xe0, 0xe6, 0x54, 0x14, 0x51, 0x29, 0x3d, 0xb7, 0xf5, 0x21, 0x5c, 0x99, + 0x1e, 0x95, 0x89, 0x9f, 0x17, 0xc9, 0x21, 0x2f, 0x42, 0xa1, 0xcc, 0x8f, 0xa8, 0x44, 0xd6, 0x2f, + 0x3e, 0x3b, 0xad, 0x4a, 0xb5, 0xde, 0xe2, 0x1b, 0x21, 0x1d, 0x2e, 0x78, 0x7a, 0x7c, 0x5f, 0x03, + 0x3d, 0x1d, 0xca, 0x64, 0xc2, 0x95, 0xc9, 0xda, 0x6f, 0x34, 0xc4, 0x41, 0xb7, 0x06, 0x4b, 0xcd, + 0xf6, 0x5e, 0xc5, 0xa2, 0x84, 0x6a, 0x98, 0x41, 0x6d, 0xbf, 0xc1, 0x97, 0x76, 0xd3, 0xaa, 0x7e, + 0x1b, 0x4f, 0xbc, 0x4d, 0xd8, 0xb0, 0x6b, 0x66, 0xe9, 0x71, 0xa7, 0xd1, 0x6c, 0x77, 0xaa, 0x8d, + 0x4e, 0x69, 0xcf, 0x6c, 0x34, 0x2a, 0x35, 0x1d, 0xf8, 0x9e, 0xdd, 0x7c, 0xdc, 0x36, 0x3b, 0xa5, + 0x66, 0x63, 0xa7, 0xba, 0x4b, 0x2c, 0x36, 0x70, 0x16, 0x4c, 0x7b, 0x99, 0xcb, 0xbe, 0x02, 0xaf, + 0x21, 0x4d, 0xab, 0xb6, 0xbf, 0x5b, 0x6d, 0x74, 0xec, 0xa7, 0x8d, 0x92, 0x14, 0xbb, 0x4a, 0x93, + 0x67, 0xc5, 0x6b, 0x70, 0x67, 0x26, 0x76, 0x9c, 0x11, 0xed, 0x2e, 0x18, 0x33, 0x31, 0xa9, 0x7d, + 0x5b, 0x7f, 0xaa, 0xc1, 0xd5, 0x19, 0x1e, 0x08, 0xec, 0x0d, 0xb8, 0xb7, 0x57, 0x31, 0xcb, 0xb5, + 0x8a, 0x6d, 0xe3, 0x0e, 0xc7, 0x07, 0x51, 0x78, 0x42, 0x65, 0x9e, 0x04, 0xf7, 0xe0, 0xd5, 0xd9, + 0xe8, 0xb1, 0x4c, 0xf1, 0x1a, 0xdc, 0x99, 0x8d, 0x4a, 0x32, 0x46, 0x8e, 0x6d, 0xc1, 0xdd, 0xd9, + 0x98, 0x91, 0x6c, 0x92, 0xdf, 0xfa, 0x5d, 0x0d, 0x2e, 0x66, 0xab, 0x01, 0x79, 0xdd, 0xaa, 0x0d, + 0xbb, 0x6d, 0xd6, 0x6a, 0x9d, 0x96, 0x69, 0x99, 0xf5, 0x4e, 0xa5, 0x61, 0x35, 0x6b, 0xb5, 0xac, + 0x33, 0xf9, 0x0e, 0xdc, 0x9a, 0x8e, 0x6a, 0x97, 0xac, 0x6a, 0x8b, 0x1f, 0x3b, 0x06, 0xdc, 0x98, + 0x8e, 0x55, 0xa9, 0x96, 0x2a, 0x7a, 0x6e, 0xfb, 0x9b, 0x3f, 0xfd, 0xcf, 0x37, 0xce, 0xfd, 0xf4, + 0xf3, 0x1b, 0xda, 0x9f, 0x7d, 0x7e, 0x43, 0xfb, 0x8b, 0xcf, 0x6f, 0x68, 0xdf, 0x7e, 0xfd, 0x6c, + 0xc9, 0x44, 0xf1, 0xb6, 0xf7, 0x6c, 0x1e, 0xef, 0xb7, 0x6f, 0xff, 0x9f, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x6b, 0xf4, 0xca, 0x4f, 0x97, 0xd9, 0x01, 0x00, } func (this *PluginSpecV1) Equal(that interface{}) bool { @@ -45513,6 +45519,13 @@ func (m *RegisterUsingTokenRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if len(m.PreviousBotInstanceID) > 0 { + i -= len(m.PreviousBotInstanceID) + copy(dAtA[i:], m.PreviousBotInstanceID) + i = encodeVarintTypes(dAtA, i, uint64(len(m.PreviousBotInstanceID))) + i-- + dAtA[i] = 0x7a + } if m.BotGeneration != 0 { i = encodeVarintTypes(dAtA, i, uint64(m.BotGeneration)) i-- @@ -62009,6 +62022,10 @@ func (m *RegisterUsingTokenRequest) Size() (n int) { if m.BotGeneration != 0 { n += 1 + sovTypes(uint64(m.BotGeneration)) } + l = len(m.PreviousBotInstanceID) + if l > 0 { + n += 1 + l + sovTypes(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -120392,6 +120409,38 @@ func (m *RegisterUsingTokenRequest) Unmarshal(dAtA []byte) error { break } } + case 15: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PreviousBotInstanceID", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTypes + } + 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 ErrInvalidLengthTypes + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTypes + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.PreviousBotInstanceID = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTypes(dAtA[iNdEx:]) diff --git a/lib/auth/bot.go b/lib/auth/bot.go index 840fe80195444..904dae2f5e264 100644 --- a/lib/auth/bot.go +++ b/lib/auth/bot.go @@ -489,7 +489,7 @@ func (a *Server) generateInitialBotCerts( sshPubKey, tlsPubKey []byte, expires time.Time, renewable bool, initialAuth *machineidv1pb.BotInstanceStatusAuthentication, - existingInstanceID string, currentIdentityGeneration int32, + existingInstanceID string, previousInstanceID string, currentIdentityGeneration int32, joinAttrs *workloadidentityv1pb.JoinAttrs, ) (*proto.Certs, string, error) { var err error @@ -553,8 +553,9 @@ func (a *Server) generateInitialBotCerts( initialAuth.Generation = 1 bi := newBotInstance(&machineidv1pb.BotInstanceSpec{ - BotName: botName, - InstanceId: uuid.String(), + BotName: botName, + InstanceId: uuid.String(), + PreviousInstanceId: previousInstanceID, }, initialAuth, expires.Add(machineidv1.ExpiryMargin)) _, err = a.BotInstance.CreateBotInstance(ctx, bi) diff --git a/lib/auth/join.go b/lib/auth/join.go index f21136ffa4dd5..b19fd48d544c8 100644 --- a/lib/auth/join.go +++ b/lib/auth/join.go @@ -453,6 +453,7 @@ func (a *Server) generateCertsBot( renewable, auth, req.BotInstanceID, + req.PreviousBotInstanceID, req.BotGeneration, attrs, ) diff --git a/lib/auth/join/boundkeypair/boundkeypair.go b/lib/auth/join/boundkeypair/boundkeypair.go index a91be7334e1a1..ffff96253cacf 100644 --- a/lib/auth/join/boundkeypair/boundkeypair.go +++ b/lib/auth/join/boundkeypair/boundkeypair.go @@ -78,6 +78,20 @@ func (c *ClientState) ToJoinParams(initialJoinSecret string) *join.BoundKeypairP } } +// UpdateFromRegisterResult updates this client state from the register result. +func (c *ClientState) UpdateFromRegisterResult(result *join.RegisterResult) error { + if result.BoundKeypair == nil { + return trace.BadParameter("register result is missing bound keypair parameters") + } + + c.JoinStateBytes = result.BoundKeypair.JoinState + + // TODO: When implementing rotation, use the bound public key value to set + // the current public key. + + return nil +} + // ToPublicKeyBytes returns the public key bytes in ssh authorized_keys format. func (c *ClientState) ToPublicKeyBytes() ([]byte, error) { sshPubKey, err := ssh.NewPublicKey(c.PrivateKey.Public()) diff --git a/lib/auth/join/join.go b/lib/auth/join/join.go index a650381d7204a..d63c1ae3c9a44 100644 --- a/lib/auth/join/join.go +++ b/lib/auth/join/join.go @@ -212,6 +212,21 @@ func (r *RegisterParams) verifyAuthOrProxyAddress() error { return nil } +// BoundKeypairRegistrationResult is the result from a successful bound keypair +// registration attempt. This contains additional values clients are expected to +// store for subsequent join attempts. +type BoundKeypairRegisterResult struct { + // BoundPublicKey is the public key trusted by the server after the join + // attempt, and can be used to confirm the current public key after + // registration or rotation. + BoundPublicKey string + + // JoinState is a serialized join state JWT. This should be committed to the + // bound keypair client state and provided via `BoundKeypairParams` on the + // next join attempt. + JoinState []byte +} + // RegisterResult contains the certificates and the private key generated during // the registration process. type RegisterResult struct { @@ -221,6 +236,9 @@ type RegisterResult struct { // generated according to the current signature algorithm suite configured // in the cluster. PrivateKey crypto.Signer + // BoundKeypair contains additional results from bound keypair registration + // attempts. This is only set when bound keypair joining is used. + BoundKeypair *BoundKeypairRegisterResult } // Register is used to get signed certificates when a node, proxy, or bot is @@ -433,7 +451,14 @@ func registerThroughProxy( case types.JoinMethodOracle: certs, err = registerUsingOracleMethod(ctx, joinServiceClient, token, hostKeys, params) case types.JoinMethodBoundKeypair: - certs, err = registerUsingBoundKeypairMethod(ctx, joinServiceClient, token, hostKeys, params) + // Bound keypair joining needs to set additional fields on the + // result, so it constructs the struct internally. + result, err := registerUsingBoundKeypairMethod(ctx, joinServiceClient, token, hostKeys, params) + if err != nil { + return nil, trace.Wrap(err) + } + + return result, nil default: return nil, trace.BadParameter("unhandled join method %q", params.JoinMethod) } @@ -523,7 +548,14 @@ func registerThroughAuthClient( case types.JoinMethodTPM: certs, err = registerUsingTPMMethod(ctx, client, token, hostKeys, params) case types.JoinMethodBoundKeypair: - certs, err = registerUsingBoundKeypairMethod(ctx, client, token, hostKeys, params) + // Bound keypair joining has additional return values, so it constructs + // its RegisterResult internally. + result, err := registerUsingBoundKeypairMethod(ctx, client, token, hostKeys, params) + if err != nil { + return nil, trace.Wrap(err) + } + + return result, nil default: // non-IAM join methods use HTTP endpoint // Get the SSH and X509 certificates for a node. @@ -712,7 +744,7 @@ type joinServiceClient interface { ctx context.Context, req *proto.RegisterUsingBoundKeypairInitialRequest, challengeResponse client.RegisterUsingBoundKeypairChallengeResponseFunc, - ) (*proto.Certs, string, error) + ) (*client.BoundKeypairRegistrationResponse, error) } func registerUsingTokenRequestForParams(token string, hostKeys *newHostKeys, params RegisterParams) *types.RegisterUsingTokenRequest { @@ -912,7 +944,7 @@ func registerUsingBoundKeypairMethod( token string, hostKeys *newHostKeys, params RegisterParams, -) (*proto.Certs, error) { +) (*RegisterResult, error) { bkParams := params.BoundKeypairParams // Build a map of all public keys to signers. At the moment, this is just @@ -939,7 +971,7 @@ func registerUsingBoundKeypairMethod( // TODO: When implementing rotation, we should make use of the returned // public key to ensure that key is marked as the primary. - certs, _, err := client.RegisterUsingBoundKeypairMethod( + regResponse, err := client.RegisterUsingBoundKeypairMethod( ctx, initReq, func(resp *proto.RegisterUsingBoundKeypairMethodResponse) (*proto.RegisterUsingBoundKeypairMethodRequest, error) { @@ -997,8 +1029,18 @@ func registerUsingBoundKeypairMethod( return nil, trace.BadParameter("received unexpected challenge response: %v", resp.GetResponse()) } }) + if err != nil { + return nil, trace.Wrap(err) + } - return certs, trace.Wrap(err) + return &RegisterResult{ + PrivateKey: hostKeys.privateKey, + Certs: regResponse.Certs, + BoundKeypair: &BoundKeypairRegisterResult{ + BoundPublicKey: regResponse.BoundPublicKey, + JoinState: regResponse.JoinState, + }, + }, nil } // readCA will read in CA that will be used to validate the certificate that diff --git a/lib/auth/join_bound_keypair.go b/lib/auth/join_bound_keypair.go index 3e2adcf565b43..4bb7746cc289d 100644 --- a/lib/auth/join_bound_keypair.go +++ b/lib/auth/join_bound_keypair.go @@ -68,10 +68,6 @@ func validateBoundKeypairTokenSpec(spec *types.ProvisionTokenSpecV2BoundKeypair) return trace.BadParameter("spec.recovery: field is required") } - if spec.Recovery.Mode != boundkeypair.RecoveryModeInsecure { - return trace.NotImplemented("spec.bound_keypair.recovery.mode currently must be %s", boundkeypair.RecoveryModeInsecure) - } - return nil } @@ -126,6 +122,8 @@ func (a *Server) UpsertBoundKeypairToken(ctx context.Context, token types.Provis // TODO: Follow up with proper checking for a preexisting resource so // generated fields are handled properly, i.e. initial secret generation. + // Implementation note: checkAndSetDefaults() impl for this token type is + // called at insertion time as part of `tokenToItem()` return trace.Wrap(a.UpsertToken(ctx, token)) } @@ -212,8 +210,9 @@ func (a *Server) issueBoundKeypairChallenge( type boundKeypairStatusMutator func(*types.ProvisionTokenSpecV2BoundKeypair, *types.ProvisionTokenStatusV2BoundKeypair) error // mutateStatusConsumeJoin consumes a "hard" join on the backend, incrementing -// the join counter. This verifies that the backend join count has not changed, -// and that total join count is at least the value when the mutator was created. +// the recovery counter. This verifies that the backend recovery count has not +// changed, and that total join count is at least the value when the mutator was +// created. func mutateStatusConsumeJoin(mode boundkeypair.RecoveryMode, expectRecoveryCount uint32, expectMinRecoveryLimit uint32) boundKeypairStatusMutator { now := time.Now() @@ -230,11 +229,6 @@ func mutateStatusConsumeJoin(mode boundkeypair.RecoveryMode, expectRecoveryCount return trace.AccessDenied("unexpected backend state") } - if mode == boundkeypair.RecoveryModeStandard { - // TODO: to be removed in a future PR - return trace.NotImplemented("only unlimited rejoining is currently supported") - } - status.RecoveryCount += 1 status.LastRecoveredAt = &now @@ -273,12 +267,12 @@ func mutateStatusBoundBotInstance(newBotInstance, expectPreviousBotInstance stri } // RegisterUsingBoundKeypairMethod handles joining requests for the bound -// keypair join method. +// keypair join method. If successful, returns func (a *Server) RegisterUsingBoundKeypairMethod( ctx context.Context, req *proto.RegisterUsingBoundKeypairInitialRequest, challengeResponse client.RegisterUsingBoundKeypairChallengeResponseFunc, -) (_ *proto.Certs, _ string, err error) { +) (_ *client.BoundKeypairRegistrationResponse, err error) { var provisionToken types.ProvisionToken var joinFailureMetadata any defer func() { @@ -293,25 +287,25 @@ func (a *Server) RegisterUsingBoundKeypairMethod( // First, check the specified token exists, and is a bound keypair-type join // token. if err := req.JoinRequest.CheckAndSetDefaults(); err != nil { - return nil, "", trace.Wrap(err) + return nil, trace.Wrap(err) } // Only bot joining is supported at the moment - unique ID verification is // required and this is currently only implemented for bots. if req.JoinRequest.Role != types.RoleBot { - return nil, "", trace.BadParameter("bound keypair joining is only supported for bots") + return nil, trace.BadParameter("bound keypair joining is only supported for bots") } provisionToken, err = a.checkTokenJoinRequestCommon(ctx, req.JoinRequest) if err != nil { - return nil, "", trace.Wrap(err) + return nil, trace.Wrap(err) } ptv2, ok := provisionToken.(*types.ProvisionTokenV2) if !ok { - return nil, "", trace.BadParameter("expected *types.ProvisionTokenV2, got %T", provisionToken) + return nil, trace.BadParameter("expected *types.ProvisionTokenV2, got %T", provisionToken) } if ptv2.Spec.JoinMethod != types.JoinMethodBoundKeypair { - return nil, "", trace.BadParameter("specified join token is not for `%s` method", types.JoinMethodBoundKeypair) + return nil, trace.BadParameter("specified join token is not for `%s` method", types.JoinMethodBoundKeypair) } if ptv2.Status == nil { @@ -321,6 +315,11 @@ func (a *Server) RegisterUsingBoundKeypairMethod( ptv2.Status.BoundKeypair = &types.ProvisionTokenStatusV2BoundKeypair{} } + clusterName, err := a.GetClusterName() + if err != nil { + return nil, trace.Wrap(err) + } + spec := ptv2.Spec.BoundKeypair status := ptv2.Status.BoundKeypair hasBoundPublicKey := status.BoundPublicKey != "" @@ -328,6 +327,16 @@ func (a *Server) RegisterUsingBoundKeypairMethod( hasIncomingBotInstance := req.JoinRequest.BotInstanceID != "" hasJoinsRemaining := status.RecoveryCount < spec.Recovery.Limit + recoveryMode, err := boundkeypair.ParseRecoveryMode(spec.Recovery.Mode) + if err != nil { + return nil, trace.Wrap(err, "parsing recovery mode") + } + + // Join state is required after the initial join (first recovery), so long + // as the mode is not insecure. + joinStateRequired := status.RecoveryCount > 0 && recoveryMode != boundkeypair.RecoveryModeInsecure + hasIncomingJoinState := len(req.PreviousJoinState) > 0 + // if set, the bound bot instance will be updated in the backend expectNewBotInstance := false @@ -338,20 +347,68 @@ func (a *Server) RegisterUsingBoundKeypairMethod( // Mutators to use during the token resource status patch at the end. var mutators []boundKeypairStatusMutator + // Get the join state JWT signer CA + ca, err := a.GetCertAuthority(ctx, types.CertAuthID{ + Type: types.BoundKeypairCA, + DomainName: clusterName.GetClusterName(), + }, /* loadKeys */ true) + if err != nil { + return nil, trace.Wrap(err) + } + + var joinState *boundkeypair.JoinState + if joinStateRequired { + // If join state is required but missing, raise an error. + if !hasIncomingJoinState { + return nil, trace.AccessDenied("previous join state is required but was not provided") + } + + a.logger.DebugContext(ctx, "join state verification required, verifying") + joinState, err = boundkeypair.VerifyJoinState( + ca, + string(req.PreviousJoinState), + &boundkeypair.JoinStateParams{ + Clock: a.clock, + ClusterName: clusterName.GetClusterName(), + Token: ptv2, + }, + ) + if err != nil { + // TODO: Once we have token-specific locking, generate a lock; this + // indicates the keypair may have been compromised. + // TODO: Audit log event for this. + a.logger.ErrorContext(ctx, "bound keypair join state verification failed", "error", err) + return nil, trace.AccessDenied("join state verification failed") + } + + // Now that we've verified it, make sure the previous bot instance ID is + // passed along to generateCerts. This will only be used if a new bot + // instance is generated. + req.JoinRequest.PreviousBotInstanceID = joinState.BotInstanceID + + a.logger.DebugContext(ctx, "join state verified successfully", "join_state", joinState) + + // Note: we don't verify join state if it isn't expected. This is partly + // to ensure server-side recovery will work if join state desyncs - a + // cluster admin can change the recovery mode to insecure or reset the + // recovery counter to zero and start over with a fresh join state, with + // no client intervention. + } + switch { case !hasBoundPublicKey && !hasIncomingBotInstance: // Normal initial join attempt. No bound key, and no incoming bot - // instance. Consumes a rejoin. + // instance. Consumes a recovery attempt. if spec.Onboarding.RegistrationSecret != "" { - return nil, "", trace.NotImplemented("initial joining secrets are not yet supported") + return nil, trace.NotImplemented("initial joining secrets are not yet supported") } if spec.Onboarding.InitialPublicKey == "" { - return nil, "", trace.BadParameter("an initial public key is required") + return nil, trace.BadParameter("an initial public key is required") } - if spec.Recovery.Mode == string(boundkeypair.RecoveryModeStandard) && !hasJoinsRemaining { - return nil, "", trace.AccessDenied("no joins remaining") + if recoveryMode == boundkeypair.RecoveryModeStandard && !hasJoinsRemaining { + return nil, trace.AccessDenied("no recovery attempts remaining") } if err := a.issueBoundKeypairChallenge( @@ -359,14 +416,14 @@ func (a *Server) RegisterUsingBoundKeypairMethod( spec.Onboarding.InitialPublicKey, challengeResponse, ); err != nil { - return nil, "", trace.Wrap(err) + return nil, trace.Wrap(err) } // Now that we've confirmed the key, we can consider it bound. mutators = append( mutators, mutateStatusBoundPublicKey(spec.Onboarding.InitialPublicKey, ""), - mutateStatusConsumeJoin(boundkeypair.RecoveryMode(spec.Recovery.Mode), status.RecoveryCount, spec.Recovery.Limit), + mutateStatusConsumeJoin(recoveryMode, status.RecoveryCount, spec.Recovery.Limit), ) expectNewBotInstance = true @@ -374,16 +431,16 @@ func (a *Server) RegisterUsingBoundKeypairMethod( case !hasBoundPublicKey && hasIncomingBotInstance: // Not allowed, at least at the moment. This would imply e.g. trying to // change auth methods. - return nil, "", trace.BadParameter("cannot perform first bound keypair join with existing credentials") + return nil, trace.BadParameter("cannot perform first bound keypair join with existing credentials") case hasBoundPublicKey && !hasBoundBotInstance: // TODO: Bad backend state, or maybe an incomplete previous join // attempt. This shouldn't be a possible state, but we should handle it // sanely anyway. - return nil, "", trace.BadParameter("bad backend state, please recreate the join token") + return nil, trace.BadParameter("bad backend state, please recreate the join token") case hasBoundPublicKey && hasBoundBotInstance && hasIncomingBotInstance: // Standard rejoin case, does not consume a rejoin. if status.BoundBotInstanceID != req.JoinRequest.BotInstanceID { - return nil, "", trace.AccessDenied("bot instance mismatch") + return nil, trace.AccessDenied("bot instance mismatch") } if err := a.issueBoundKeypairChallenge( @@ -391,16 +448,16 @@ func (a *Server) RegisterUsingBoundKeypairMethod( spec.Onboarding.InitialPublicKey, challengeResponse, ); err != nil { - return nil, "", trace.Wrap(err) + return nil, trace.Wrap(err) } // Nothing else to do, no key change case hasBoundPublicKey && hasBoundBotInstance && !hasIncomingBotInstance: // Hard rejoin case, the client identity expired and a new bot instance // is required. Consumes a rejoin. - if spec.Recovery.Mode == string(boundkeypair.RecoveryModeStandard) && !hasJoinsRemaining { + if recoveryMode == boundkeypair.RecoveryModeStandard && !hasJoinsRemaining { // Recovery limit only applies in "standard" mode. - return nil, "", trace.AccessDenied("no rejoins remaining") + return nil, trace.AccessDenied("no rejoins remaining") } if err := a.issueBoundKeypairChallenge( @@ -408,12 +465,12 @@ func (a *Server) RegisterUsingBoundKeypairMethod( status.BoundPublicKey, challengeResponse, ); err != nil { - return nil, "", trace.Wrap(err) + return nil, trace.Wrap(err) } mutators = append( mutators, - mutateStatusConsumeJoin(boundkeypair.RecoveryMode(spec.Recovery.Mode), status.RecoveryCount, spec.Recovery.Limit), + mutateStatusConsumeJoin(recoveryMode, status.RecoveryCount, spec.Recovery.Limit), ) expectNewBotInstance = true @@ -426,20 +483,15 @@ func (a *Server) RegisterUsingBoundKeypairMethod( "spec", spec, "status", status, ) - return nil, "", trace.BadParameter("unexpected state") + return nil, trace.BadParameter("unexpected state") } if spec.RotateAfter != nil { // TODO, to be implemented in a future PR. `boundPublicKey` will need to // be updated. - return nil, "", trace.NotImplemented("key rotation not yet supported") + return nil, trace.NotImplemented("key rotation not yet supported") } - // TODO: We should pass along the previous bot instance ID - if any - based - // on the join state, once that is implemented. It will need to be passed - // either via extended claims, or by a new protected field in the join - // request like the current bot instance ID, i.e. cleared when set by an - // untrusted source. certs, botInstanceID, err := a.generateCertsBot( ctx, ptv2, @@ -455,8 +507,12 @@ func (a *Server) RegisterUsingBoundKeypairMethod( ) } + // A reference to the final provision token state; may be modified below via + // mutators. + finalToken := ptv2 + if len(mutators) > 0 { - if _, err := a.PatchToken(ctx, ptv2.GetName(), func(token types.ProvisionToken) (types.ProvisionToken, error) { + patched, err := a.PatchToken(ctx, ptv2.GetName(), func(token types.ProvisionToken) (types.ProvisionToken, error) { ptv2, ok := provisionToken.(*types.ProvisionTokenV2) if !ok { return nil, trace.BadParameter("expected *types.ProvisionTokenV2, got %T", provisionToken) @@ -471,10 +527,37 @@ func (a *Server) RegisterUsingBoundKeypairMethod( } return ptv2, nil - }); err != nil { - return nil, "", trace.Wrap(err, "committing updated token state, please try again") + }) + if err != nil { + return nil, trace.Wrap(err, "committing updated token state, please try again") } + + finalToken, ok = patched.(*types.ProvisionTokenV2) + if !ok { + // This should be impossible, but if it did fail, we can't generate + // a join state without an accurate token. The certs we just + // generated will be useless, so just return an error. + return nil, trace.BadParameter("expected *types.ProvisionTokenV2, got %T", provisionToken) + } + } + + signer, err := a.GetKeyStore().GetJWTSigner(ctx, ca) + if err != nil { + return nil, trace.Wrap(err, "issuing join state document") + } + + newJoinState, err := boundkeypair.IssueJoinState(signer, &boundkeypair.JoinStateParams{ + Clock: a.clock, + ClusterName: clusterName.GetClusterName(), + Token: finalToken, + }) + if err != nil { + return nil, trace.Wrap(err, "issuing join state document") } - return certs, boundPublicKey, trace.Wrap(err) + return &client.BoundKeypairRegistrationResponse{ + Certs: certs, + BoundPublicKey: boundPublicKey, + JoinState: []byte(newJoinState), + }, nil } diff --git a/lib/auth/join_bound_keypair_test.go b/lib/auth/join_bound_keypair_test.go index b284c3f2c5332..6f950a7f216b0 100644 --- a/lib/auth/join_bound_keypair_test.go +++ b/lib/auth/join_bound_keypair_test.go @@ -24,6 +24,7 @@ import ( "testing" "time" + "github.com/go-jose/go-jose/v3/jwt" "github.com/gravitational/trace" "github.com/stretchr/testify/require" @@ -81,6 +82,18 @@ func testBoundKeypair(t *testing.T) (crypto.Signer, string) { return key.Signer, string(key.MarshalSSHPublicKey()) } +// parseJoinState parses a join state token without verification, for testing +// purposes only. +func parseJoinState(t *testing.T, state []byte) *boundkeypair.JoinState { + token, err := jwt.ParseSigned(string(state)) + require.NoError(t, err) + + var doc boundkeypair.JoinState + require.NoError(t, token.UnsafeClaimsWithoutVerification(&doc)) + + return &doc +} + func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { ctx := context.Background() @@ -122,6 +135,18 @@ func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { tlsPublicKey, err := authtest.PrivateKeyToPublicKeyTLS(sshPrivateKey) require.NoError(t, err) + jwtCA, err := authServer.GetCertAuthority(ctx, types.CertAuthID{ + Type: types.BoundKeypairCA, + DomainName: srv.ClusterName(), + }, /* loadKeys */ true) + require.NoError(t, err) + + jwtSigner, err := authServer.GetKeyStore().GetJWTSigner(ctx, jwtCA) + require.NoError(t, err) + + // An invalid signer for signing "fake" JWTs. + invalidJWTSigner, _ := testBoundKeypair(t) + makeToken := func(mutators ...func(v2 *types.ProvisionTokenV2)) types.ProvisionTokenV2 { token := types.ProvisionTokenV2{ Spec: types.ProvisionTokenSpecV2{ @@ -148,6 +173,38 @@ func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { return token } + withRecovery := func(mode string, count, limit uint32, botInstanceID string) func(*types.ProvisionTokenV2) { + return func(v2 *types.ProvisionTokenV2) { + v2.Spec.BoundKeypair.Recovery.Mode = mode + v2.Spec.BoundKeypair.Recovery.Limit = limit + v2.Status.BoundKeypair.RecoveryCount = count + v2.Status.BoundKeypair.BoundBotInstanceID = botInstanceID + } + } + + makeJoinState := func(signer crypto.Signer, mutators ...func(s *boundkeypair.JoinStateParams)) string { + params := &boundkeypair.JoinStateParams{ + Clock: srv.Clock(), + ClusterName: srv.ClusterName(), + } + + for _, mutator := range mutators { + mutator(params) + } + + state, err := boundkeypair.IssueJoinState(signer, params) + require.NoError(t, err) + + return state + } + + withToken := func(mutators ...func(v2 *types.ProvisionTokenV2)) func(*boundkeypair.JoinStateParams) { + return func(jsp *boundkeypair.JoinStateParams) { + token := makeToken(mutators...) + jsp.Token = &token + } + } + makeInitReq := func(mutators ...func(r *proto.RegisterUsingBoundKeypairInitialRequest)) *proto.RegisterUsingBoundKeypairInitialRequest { req := &proto.RegisterUsingBoundKeypairInitialRequest{ JoinRequest: &types.RegisterUsingTokenRequest{ @@ -163,6 +220,13 @@ func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { return req } + withJoinState := func(signer crypto.Signer, mutators ...func(s *boundkeypair.JoinStateParams)) func(*proto.RegisterUsingBoundKeypairInitialRequest) { + return func(req *proto.RegisterUsingBoundKeypairInitialRequest) { + state := makeJoinState(signer, mutators...) + req.PreviousJoinState = []byte(state) + } + } + makeSolver := func(publicKey string) client.RegisterUsingBoundKeypairChallengeResponseFunc { return func(challenge *proto.RegisterUsingBoundKeypairMethodResponse) (*proto.RegisterUsingBoundKeypairMethodRequest, error) { switch r := challenge.Response.(type) { @@ -194,7 +258,7 @@ func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { solver client.RegisterUsingBoundKeypairChallengeResponseFunc assertError require.ErrorAssertionFunc - assertSuccess func(t *testing.T, v2 *types.ProvisionTokenV2) + assertSuccess func(t *testing.T, v2 *types.ProvisionTokenV2, res *client.BoundKeypairRegistrationResponse) }{ { // no bound key, no bound bot instance, aka initial join without @@ -206,7 +270,7 @@ func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { solver: makeSolver(correctPublicKey), assertError: require.NoError, - assertSuccess: func(t *testing.T, v2 *types.ProvisionTokenV2) { + assertSuccess: func(t *testing.T, v2 *types.ProvisionTokenV2, _ *client.BoundKeypairRegistrationResponse) { // join count should be incremented require.Equal(t, uint32(1), v2.Status.BoundKeypair.RecoveryCount) require.NotEmpty(t, v2.Status.BoundKeypair.BoundBotInstanceID) @@ -241,7 +305,7 @@ func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { solver: makeSolver(correctPublicKey), assertError: require.NoError, - assertSuccess: func(t *testing.T, v2 *types.ProvisionTokenV2) { + assertSuccess: func(t *testing.T, v2 *types.ProvisionTokenV2, _ *client.BoundKeypairRegistrationResponse) { // join count should not be incremented require.Equal(t, uint32(0), v2.Status.BoundKeypair.RecoveryCount) }, @@ -278,7 +342,7 @@ func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { solver: makeSolver(correctPublicKey), assertError: require.NoError, - assertSuccess: func(t *testing.T, v2 *types.ProvisionTokenV2) { + assertSuccess: func(t *testing.T, v2 *types.ProvisionTokenV2, _ *client.BoundKeypairRegistrationResponse) { require.Equal(t, uint32(1), v2.Status.BoundKeypair.RecoveryCount) // Should generate a new bot instance @@ -340,6 +404,116 @@ func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { require.ErrorContains(tt, err, "key rotation not yet supported") }, }, + { + name: "standard-initial-recovery-success", + token: makeToken(withRecovery("standard", 0, 1, "")), + initReq: makeInitReq(), + solver: makeSolver(correctPublicKey), + assertError: require.NoError, + assertSuccess: func(t *testing.T, v2 *types.ProvisionTokenV2, res *client.BoundKeypairRegistrationResponse) { + require.Equal(t, uint32(1), v2.Status.BoundKeypair.RecoveryCount) + + require.NotNil(t, res) + require.NotEmpty(t, res.JoinState) + }, + }, + { + name: "standard-success-second-recovery", + token: makeToken(withRecovery("standard", 1, 2, "id")), + initReq: makeInitReq(withJoinState(jwtSigner, withToken(withRecovery("standard", 1, 2, "id")))), + solver: makeSolver(correctPublicKey), + assertError: require.NoError, + assertSuccess: func(t *testing.T, v2 *types.ProvisionTokenV2, res *client.BoundKeypairRegistrationResponse) { + require.Equal(t, uint32(2), v2.Status.BoundKeypair.RecoveryCount) + require.NotNil(t, res) + state := parseJoinState(t, res.JoinState) + require.Equal(t, v2.Status.BoundKeypair.RecoveryCount, state.RecoverySequence) + }, + }, + { + name: "standard-failure-missing-join-state", + token: makeToken(withRecovery("standard", 1, 2, "id")), + initReq: makeInitReq(), + solver: makeSolver(correctPublicKey), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "previous join state is required") + }, + }, + { + name: "standard-failure-limit-exhausted", + token: makeToken(withRecovery("standard", 2, 2, "id")), + initReq: makeInitReq(withJoinState(jwtSigner, withToken(withRecovery("standard", 2, 2, "id")))), + solver: makeSolver(correctPublicKey), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "no recovery attempts remaining") + }, + }, + { + // Attempts to join with an outdated join state document should fail. + name: "standard-failure-recovery-count-mismatch", + token: makeToken(withRecovery("standard", 2, 3, "id")), + initReq: makeInitReq(withJoinState(jwtSigner, withToken(withRecovery("standard", 1, 3, "id")))), + solver: makeSolver(correctPublicKey), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "join state verification failed") + }, + }, + { + name: "standard-failure-invalid-jwt", + token: makeToken(withRecovery("standard", 1, 2, "id")), + initReq: makeInitReq(func(r *proto.RegisterUsingBoundKeypairInitialRequest) { + r.PreviousJoinState = []byte("asdf") + }), + solver: makeSolver(correctPublicKey), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "join state verification failed") + }, + }, + { + name: "standard-failure-invalid-jwt-signature", + token: makeToken(withRecovery("standard", 1, 2, "id")), + initReq: makeInitReq(withJoinState(invalidJWTSigner, withToken(withRecovery("standard", 1, 2, "id")))), + solver: makeSolver(correctPublicKey), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "join state verification failed") + }, + }, + { + name: "standard-failure-invalid-instance-id", + token: makeToken(withRecovery("standard", 1, 2, "foo")), + initReq: makeInitReq(withJoinState(jwtSigner, withToken(withRecovery("standard", 1, 2, "id")))), + solver: makeSolver(correctPublicKey), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "join state verification failed") + }, + }, + { + name: "standard-failure-invalid-cluster", + token: makeToken(withRecovery("standard", 1, 2, "foo")), + initReq: makeInitReq(withJoinState(jwtSigner, withToken(withRecovery("standard", 1, 2, "id")), func(s *boundkeypair.JoinStateParams) { + s.ClusterName = "wrong-cluster" + })), + solver: makeSolver(correctPublicKey), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "join state verification failed") + }, + }, + { + name: "relaxed-success-count-over-limit", + token: makeToken(withRecovery("relaxed", 1, 0, "id")), + initReq: makeInitReq(withJoinState(jwtSigner, withToken(withRecovery("relaxed", 1, 0, "id")))), + solver: makeSolver(correctPublicKey), + assertError: require.NoError, + assertSuccess: func(t *testing.T, v2 *types.ProvisionTokenV2, res *client.BoundKeypairRegistrationResponse) { + require.Equal(t, uint32(2), v2.Status.BoundKeypair.RecoveryCount) + + require.NotNil(t, res) + require.NotEmpty(t, res.JoinState) + + state := parseJoinState(t, res.JoinState) + require.Equal(t, v2.Status.BoundKeypair.RecoveryCount, state.RecoverySequence) + }, + }, } for _, tt := range tests { @@ -351,7 +525,7 @@ func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { require.NoError(t, authServer.CreateToken(ctx, token)) tt.initReq.JoinRequest.Token = tt.name - _, _, err = authServer.RegisterUsingBoundKeypairMethod(ctx, tt.initReq, tt.solver) + response, err := authServer.RegisterUsingBoundKeypairMethod(ctx, tt.initReq, tt.solver) tt.assertError(t, err) if tt.assertSuccess != nil { @@ -361,7 +535,7 @@ func TestServer_RegisterUsingBoundKeypairMethod(t *testing.T) { ptv2, ok := pt.(*types.ProvisionTokenV2) require.True(t, ok) - tt.assertSuccess(t, ptv2) + tt.assertSuccess(t, ptv2, response) } }) } diff --git a/lib/boundkeypair/bound_keypair.go b/lib/boundkeypair/bound_keypair.go index d19714a65633b..e35c10f8f9f21 100644 --- a/lib/boundkeypair/bound_keypair.go +++ b/lib/boundkeypair/bound_keypair.go @@ -67,6 +67,20 @@ func RecoveryModes() []RecoveryMode { } } +// ParseRecoveryMode parses a recovery mode from its string form. +func ParseRecoveryMode(s string) (RecoveryMode, error) { + switch s { + case RecoveryModeInsecure: + return RecoveryModeInsecure, nil + case RecoveryModeRelaxed: + return RecoveryModeRelaxed, nil + case "", string(RecoveryModeStandard): + return RecoveryModeStandard, nil + default: + return "", trace.BadParameter("invalid recovery mode: %s", s) + } +} + // ChallengeDocument is a bound keypair challenge document. These documents are // sent in JSON form to clients attempting to authenticate, and are expected to // be sent back signed with the private counterpart of a known public key. @@ -108,6 +122,7 @@ func NewChallengeValidator( }, nil } +// IssueChallenge generates a new challenge document using the configured clock. func (v *ChallengeValidator) IssueChallenge() (*ChallengeDocument, error) { // Implementation note: these challenges are only ever sent to a single // client once, and we expect a valid reply as the next exchange in the diff --git a/lib/boundkeypair/join_state.go b/lib/boundkeypair/join_state.go new file mode 100644 index 0000000000000..3ce76549af948 --- /dev/null +++ b/lib/boundkeypair/join_state.go @@ -0,0 +1,225 @@ +// Teleport +// Copyright (C) 2025 Gravitational, Inc. +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +package boundkeypair + +import ( + "crypto" + "time" + + "github.com/go-jose/go-jose/v3" + "github.com/go-jose/go-jose/v3/jwt" + "github.com/gravitational/trace" + "github.com/jonboulle/clockwork" + + "github.com/gravitational/teleport/api/types" + "github.com/gravitational/teleport/api/utils/keys" + libjwt "github.com/gravitational/teleport/lib/jwt" +) + +// JoinState is a signed JWT stored on joining clients alongside their usual +// certificate bundle, used as an additional layer of verification for +// subsequent join attempts. +type JoinState struct { + *jwt.Claims + + // BotInstanceID is the bot instance ID associated with this join state when + // it was generated. A new bot instance may be created during the joining + // process if the previous instance expired. The + // `(bot_instance_id, recovery_sequence)` tuple is considered functionally + // unique to each issued join state for verification purposes, and will + // remain unchanged until the next successful recovery. + BotInstanceID string `json:"bot_instance_id"` + + // RecoverySequence is the recovery sequence number. This is incremented + // each time a recovery is performed, including on first join. This counter + // is not reset if a new bot instance is generated. + RecoverySequence uint32 `json:"recovery_sequence"` + + // RecoveryLimit is the maximum number of recovery attempts allowed as of + // the time this join state was issued. This field is informational, and is + // expected to be modified server-side to allow additional joins once the + // limit is reached. + RecoveryLimit uint32 `json:"recovery_limit"` + + // RecoveryMode is the currently configured recovery mode set in + // `spec.bound_keypair.recovery.mode`. This field is informational; clients + // may opt to use this and the recovery limit to, e.g., generate a warning + // if recovery limits are enforced and the remaining attempts are below some + // threshold. + RecoveryMode string `json:"recovery_mode"` +} + +// JoinStateParams contains parameters for issuing and verifying join state +// JWTs. +type JoinStateParams struct { + Clock clockwork.Clock + + ClusterName string + Token *types.ProvisionTokenV2 +} + +// IssueJoinState generates a join state document from the provided token and +// returns a compact serialized, signed JWT. The token must be up-to-date at the +// time of issuance, i.e. the recovery count must have been incremented already. +func IssueJoinState(signer crypto.Signer, params *JoinStateParams) (string, error) { + spec := params.Token.Spec.BoundKeypair + if spec == nil { + return "", trace.BadParameter("spec.bound_keypair: required field is missing") + } + + if params.Token.Status == nil || params.Token.Status.BoundKeypair == nil { + return "", trace.BadParameter("status.bound_keypair: required field is missing") + } + + status := params.Token.Status.BoundKeypair + + if params.Token.Spec.BotName == "" { + return "", trace.BadParameter("spec.bot_name: required field is empty") + } + + state := &JoinState{ + Claims: &jwt.Claims{ + // We'll reuse the challengeNotBeforeOffset here; the value is sane + // enough. + NotBefore: jwt.NewNumericDate(params.Clock.Now().Add(challengeNotBeforeOffset)), + IssuedAt: jwt.NewNumericDate(params.Clock.Now()), + Issuer: params.ClusterName, + Audience: jwt.Audience{params.ClusterName}, + Subject: params.Token.Spec.BotName, + + // Note: These documents aren't meant to expire, so no expiration is + // included. We may opt to trust (or not) a given document during + // verification based on its `iat` in the future. + }, + BotInstanceID: status.BoundBotInstanceID, + RecoverySequence: status.RecoveryCount, + RecoveryLimit: spec.Recovery.Limit, + RecoveryMode: spec.Recovery.Mode, + } + + // Derive the key ID for inclusion in the header. + kid, err := libjwt.KeyID(signer.Public()) + if err != nil { + return "", trace.Wrap(err, "generating key ID") + } + + signingKey, err := libjwt.SigningKeyFromPrivateKey(signer) + if err != nil { + return "", trace.Wrap(err) + } + + opts := (&jose.SignerOptions{}).WithType("JWT").WithHeader("kid", kid) + joseSigner, err := jose.NewSigner(signingKey, opts) + if err != nil { + return "", trace.Wrap(err, "creating signer") + } + + serialized, err := jwt.Signed(joseSigner).Claims(state).CompactSerialize() + if err != nil { + return "", trace.Wrap(err) + } + + return serialized, nil +} + +func verifyJoinStateInner(key crypto.PublicKey, parsed *jwt.JSONWebToken, params *JoinStateParams) (*JoinState, error) { + if params.Token.Status == nil || params.Token.Status.BoundKeypair == nil { + return nil, trace.BadParameter("invalid token status") + } + + var document JoinState + if err := parsed.Claims(key, &document); err != nil { + return nil, trace.Wrap(err) + } + + // Note: We don't verify expiry here, only `iat` and `nbf`. These documents + // are meant to remain "valid" indefinitely and we decide to trust them (or + // not) at verification time. + // There are no time-based recovery restrictions yet, but we may opt to add + // some in the future based on the verified `iat` value of this JWT. + const leeway time.Duration = time.Minute + if err := document.Claims.ValidateWithLeeway(jwt.Expected{ + Issuer: params.ClusterName, + Audience: jwt.Audience{params.ClusterName}, + Subject: params.Token.Spec.BotName, + Time: params.Clock.Now(), + }, leeway); err != nil { + return nil, trace.Wrap(err, "validating join state claims") + } + + // Ensure the non-informational claims in the join state match what we + // expect. + var errors []error + if document.RecoverySequence != params.Token.Status.BoundKeypair.RecoveryCount { + errors = append(errors, trace.AccessDenied("recovery counter mismatch")) + } + if document.BotInstanceID != params.Token.Status.BoundKeypair.BoundBotInstanceID { + errors = append(errors, trace.AccessDenied("bot instance mismatch")) + } + + if len(errors) > 0 { + return nil, trace.NewAggregate(errors...) + } + + return &document, nil +} + +// VerifyJoinState attempts to verify the given serialized join state JWT +// against the trusted keys in the provided CA and expected join state +// parameters. Note that verification must take place before join state has been +// modified; that is, if a new bot instance is generated or the recovery counter +// is incremented, verification must be done against the original state. +func VerifyJoinState(ca types.CertAuthority, serializedJoinState string, params *JoinStateParams) (*JoinState, error) { + parsed, err := jwt.ParseSigned(serializedJoinState) + if err != nil { + return nil, trace.Wrap(err, "parsing serialized join state") + } + + if len(parsed.Headers) == 0 { + return nil, trace.BadParameter("invalid JWT header") + } + + expectedKeyID := parsed.Headers[0].KeyID + if expectedKeyID == "" { + return nil, trace.BadParameter("required key ID is missing from JWT header") + } + + // Attempt to find the key that signed this JWT. + for _, k := range ca.GetTrustedJWTKeyPairs() { + pubKey, err := keys.ParsePublicKey(k.PublicKey) + if err != nil { + return nil, trace.Wrap(err, "parsing public key") + } + + kid, err := libjwt.KeyID(pubKey) + if err != nil { + return nil, trace.Wrap(err, "deriving key ID") + } + + if kid == expectedKeyID { + joinState, err := verifyJoinStateInner(pubKey, parsed, params) + if err != nil { + return nil, trace.Wrap(err) + } + + return joinState, err + } + } + + // No matching keys were found, bail. + return nil, trace.AccessDenied("join state could not be verified") +} diff --git a/lib/boundkeypair/join_state_test.go b/lib/boundkeypair/join_state_test.go new file mode 100644 index 0000000000000..a345d1ceb9d1a --- /dev/null +++ b/lib/boundkeypair/join_state_test.go @@ -0,0 +1,245 @@ +/* + * Teleport + * Copyright (C) 2025 Gravitational, Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +package boundkeypair + +import ( + "crypto" + "testing" + "time" + + "github.com/jonboulle/clockwork" + "github.com/stretchr/testify/require" + + "github.com/gravitational/teleport/api/types" + "github.com/gravitational/teleport/api/utils/keys" +) + +type mockCA struct { + types.CertAuthority + + keys []*types.JWTKeyPair +} + +func (m *mockCA) GetTrustedJWTKeyPairs() []*types.JWTKeyPair { + return m.keys +} + +func newJWTKeyPair(t *testing.T) (crypto.Signer, *types.JWTKeyPair) { + t.Helper() + + signer := newTestKeypair(t) + private, err := keys.MarshalPrivateKey(signer) + require.NoError(t, err) + + public, err := keys.MarshalPublicKey(signer.Public()) + require.NoError(t, err) + + return signer, &types.JWTKeyPair{ + PublicKey: public, + PrivateKey: private, + PrivateKeyType: types.PrivateKeyType_RAW, + } +} + +func TestIssueAndVerifyJoinState(t *testing.T) { + activeSigner, activeKeypair := newJWTKeyPair(t) + standbySigner, standbyKeypair := newJWTKeyPair(t) + invalidSigner, _ := newJWTKeyPair(t) + + clock := clockwork.NewFakeClock() + + ca := &mockCA{ + keys: []*types.JWTKeyPair{ + activeKeypair, + standbyKeypair, + }, + } + + makeParams := func(mutators ...func(*JoinStateParams)) *JoinStateParams { + token := &types.ProvisionTokenV2{ + Spec: types.ProvisionTokenSpecV2{ + JoinMethod: types.JoinMethodBoundKeypair, + Roles: []types.SystemRole{types.RoleBot}, + BotName: "test", + BoundKeypair: &types.ProvisionTokenSpecV2BoundKeypair{ + Onboarding: &types.ProvisionTokenSpecV2BoundKeypair_OnboardingSpec{ + InitialPublicKey: "abcd", + }, + Recovery: &types.ProvisionTokenSpecV2BoundKeypair_RecoverySpec{ + Mode: string(RecoveryModeStandard), + }, + }, + }, + Status: &types.ProvisionTokenStatusV2{ + BoundKeypair: &types.ProvisionTokenStatusV2BoundKeypair{}, + }, + } + + params := &JoinStateParams{ + Clock: clock, + ClusterName: "example.com", + Token: token, + } + + for _, mutator := range mutators { + mutator(params) + } + + return params + } + + withRecovery := func(count, limit uint32) func(*JoinStateParams) { + return func(params *JoinStateParams) { + params.Token.Status.BoundKeypair.RecoveryCount = count + params.Token.Spec.BoundKeypair.Recovery.Limit = limit + } + } + + withInstanceID := func(id string) func(*JoinStateParams) { + return func(params *JoinStateParams) { + params.Token.Status.BoundKeypair.BoundBotInstanceID = id + } + } + + makeIssuer := func(signer crypto.Signer, params *JoinStateParams) func(*testing.T, clockwork.Clock) string { + return func(t *testing.T, clock clockwork.Clock) string { + params.Clock = clock + + state, err := IssueJoinState(signer, params) + require.NoError(t, err) + + return state + } + } + + tests := []struct { + name string + + issue func(t *testing.T, clock clockwork.Clock) string + verifyParams *JoinStateParams + + clockMod func(clock *clockwork.FakeClock) + + assertError require.ErrorAssertionFunc + assertSuccess func(t *testing.T, s *JoinState) + }{ + { + name: "success", + issue: makeIssuer(activeSigner, makeParams(withRecovery(0, 1))), + verifyParams: makeParams(withRecovery(0, 1)), + assertError: require.NoError, + }, + { + name: "success with alternate signer", + issue: makeIssuer(standbySigner, makeParams(withRecovery(0, 1))), + verifyParams: makeParams(withRecovery(0, 1)), + assertError: require.NoError, + }, + { + name: "invalid join state", + issue: func(t *testing.T, _ clockwork.Clock) string { + return "asdf" + }, + verifyParams: makeParams(withRecovery(0, 1)), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "parsing serialized join state") + }, + }, + { + name: "invalid count", + issue: makeIssuer(activeSigner, makeParams(withRecovery(0, 1))), + verifyParams: makeParams(withRecovery(1, 1)), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "recovery counter mismatch") + }, + }, + { + name: "invalid instance ID", + issue: makeIssuer(activeSigner, makeParams(withRecovery(0, 1), withInstanceID("foo"))), + verifyParams: makeParams(withRecovery(0, 1), withInstanceID("bar")), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "bot instance mismatch") + }, + }, + { + name: "untrusted signer", + issue: makeIssuer(invalidSigner, makeParams(withRecovery(0, 1), withInstanceID("foo"))), + verifyParams: makeParams(withRecovery(0, 1), withInstanceID("bar")), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "join state could not be verified") + }, + }, + { + name: "issued too early", + issue: makeIssuer(activeSigner, makeParams(withRecovery(0, 1))), + verifyParams: makeParams(withRecovery(0, 1)), + clockMod: func(clock *clockwork.FakeClock) { + clock.Advance(-10 * time.Minute) + }, + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "token not valid yet") + }, + }, + { + name: "cluster name must match", + issue: makeIssuer(activeSigner, makeParams(withRecovery(0, 1), func(jsp *JoinStateParams) { + jsp.ClusterName = "invalid" + })), + verifyParams: makeParams(withRecovery(0, 1)), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "invalid issuer claim") + }, + }, + { + name: "subject must match", + issue: makeIssuer(activeSigner, makeParams(withRecovery(0, 1), func(jsp *JoinStateParams) { + jsp.Token.Spec.BotName = "invalid" + })), + verifyParams: makeParams(withRecovery(0, 1)), + assertError: func(tt require.TestingT, err error, i ...interface{}) { + require.ErrorContains(tt, err, "invalid subject claim") + }, + }, + { + name: "informational parameters can be modified", + issue: makeIssuer(activeSigner, makeParams(withRecovery(0, 1), func(jsp *JoinStateParams) { + jsp.Token.Spec.BoundKeypair.Recovery.Mode = "relaxed" + jsp.Token.Spec.BoundKeypair.Recovery.Limit = 123 + })), + verifyParams: makeParams(withRecovery(0, 1)), + assertError: require.NoError, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + clock := clockwork.NewFakeClock() + + signedState := tt.issue(t, clock) + + if tt.clockMod != nil { + tt.clockMod(clock) + } + + tt.verifyParams.Clock = clock + _, err := VerifyJoinState(ca, signedState, tt.verifyParams) + tt.assertError(t, err) + }) + } +} diff --git a/lib/joinserver/joinserver.go b/lib/joinserver/joinserver.go index e7ea8a8959622..13f26c9f64575 100644 --- a/lib/joinserver/joinserver.go +++ b/lib/joinserver/joinserver.go @@ -60,7 +60,7 @@ type joinServiceClient interface { ctx context.Context, req *proto.RegisterUsingBoundKeypairInitialRequest, challengeResponse client.RegisterUsingBoundKeypairChallengeResponseFunc, - ) (*proto.Certs, string, error) + ) (*client.BoundKeypairRegistrationResponse, error) RegisterUsingToken( ctx context.Context, req *types.RegisterUsingTokenRequest, @@ -176,6 +176,10 @@ func setClientRemoteAddr(ctx context.Context, req *types.RegisterUsingTokenReque // setBotParameters extracts a bot instance ID from either the incoming request // or the context identity. func setBotParameters(ctx context.Context, req *types.RegisterUsingTokenRequest) { + // The previous bot instance can never be set at this point; it's set by the + // join method handler if at all. + req.PreviousBotInstanceID = "" + user, err := authz.UserFromContext(ctx) if err != nil { // No authenticated user, we don't want to trust the values provided in @@ -415,7 +419,7 @@ func (s *JoinServiceGRPCServer) registerUsingBoundKeypair(srv proto.JoinService_ setBotParameters(ctx, initReq.JoinRequest) - certs, pubKey, err := s.joinServiceClient.RegisterUsingBoundKeypairMethod(ctx, initReq, func(resp *proto.RegisterUsingBoundKeypairMethodResponse) (*proto.RegisterUsingBoundKeypairMethodRequest, error) { + regResponse, err := s.joinServiceClient.RegisterUsingBoundKeypairMethod(ctx, initReq, func(resp *proto.RegisterUsingBoundKeypairMethodResponse) (*proto.RegisterUsingBoundKeypairMethodRequest, error) { // First, forward the challenge from Auth to the client. err := srv.Send(resp) if err != nil { @@ -444,8 +448,9 @@ func (s *JoinServiceGRPCServer) registerUsingBoundKeypair(srv proto.JoinService_ return trace.Wrap(srv.Send(&proto.RegisterUsingBoundKeypairMethodResponse{ Response: &proto.RegisterUsingBoundKeypairMethodResponse_Certs{ Certs: &proto.RegisterUsingBoundKeypairCertificates{ - Certs: certs, - PublicKey: pubKey, + Certs: regResponse.Certs, + PublicKey: regResponse.BoundPublicKey, + JoinState: regResponse.JoinState, }, }, })) diff --git a/lib/joinserver/joinserver_test.go b/lib/joinserver/joinserver_test.go index dcd954f8d815c..2934ed3e08a29 100644 --- a/lib/joinserver/joinserver_test.go +++ b/lib/joinserver/joinserver_test.go @@ -93,7 +93,7 @@ func (c *mockJoinServiceClient) RegisterUsingBoundKeypairMethod( ctx context.Context, req *proto.RegisterUsingBoundKeypairInitialRequest, challengeResponse client.RegisterUsingBoundKeypairChallengeResponseFunc, -) (*proto.Certs, string, error) { +) (*client.BoundKeypairRegistrationResponse, error) { c.gotBoundKeypairInitReq = req resp, err := challengeResponse(&proto.RegisterUsingBoundKeypairMethodResponse{ Response: &proto.RegisterUsingBoundKeypairMethodResponse_Challenge{ @@ -104,12 +104,19 @@ func (c *mockJoinServiceClient) RegisterUsingBoundKeypairMethod( }, }) if err != nil { - return nil, "", trace.Wrap(err) + return nil, trace.Wrap(err) } c.gotBoundKeypairChallengeResponse = resp - return c.returnCerts, c.boundKeypairPublicKey, c.returnError + if c.returnError != nil { + return nil, c.returnError + } + + return &client.BoundKeypairRegistrationResponse{ + Certs: c.returnCerts, + BoundPublicKey: c.boundKeypairPublicKey, + }, nil } func (c *mockJoinServiceClient) RegisterUsingOracleMethod( @@ -646,7 +653,7 @@ func TestJoinServiceGRPCServer_RegisterUsingBoundKeypairMethodSimple(t *testing. "_proxy": testPack.proxyClient, } { t.Run(tc.desc+suffix, func(t *testing.T) { - certs, pubKey, err := clt.RegisterUsingBoundKeypairMethod( + response, err := clt.RegisterUsingBoundKeypairMethod( context.Background(), tc.req, challengeResponder, ) if tc.challengeResponseErr != nil { @@ -659,7 +666,7 @@ func TestJoinServiceGRPCServer_RegisterUsingBoundKeypairMethodSimple(t *testing. return } require.NoError(t, err) - require.Equal(t, tc.certs, certs) + require.Equal(t, tc.certs, response.Certs) expectedInitReq := tc.req expectedInitReq.JoinRequest.RemoteAddr = "bufconn" @@ -671,7 +678,7 @@ func TestJoinServiceGRPCServer_RegisterUsingBoundKeypairMethodSimple(t *testing. testPack.mockAuthServer.gotBoundKeypairChallengeResponse, ) - require.Equal(t, tc.publicKey, pubKey) + require.Equal(t, tc.publicKey, response.BoundPublicKey) }) } }) diff --git a/lib/jwt/jwt.go b/lib/jwt/jwt.go index e5d57defabea9..01ff10ba4f37c 100644 --- a/lib/jwt/jwt.go +++ b/lib/jwt/jwt.go @@ -161,22 +161,10 @@ func (k *Key) getSigner(opts *jose.SignerOptions) (jose.Signer, error) { return nil, trace.BadParameter("can not sign token with non-signing key") } - // Create a signer with configured private key and algorithm. - var signer interface{} - switch k.config.PrivateKey.(type) { - case *rsa.PrivateKey, *ecdsa.PrivateKey, ed25519.PrivateKey: - signer = k.config.PrivateKey - default: - signer = cryptosigner.Opaque(k.config.PrivateKey) - } - algorithm, err := AlgorithmForPublicKey(k.config.PrivateKey.Public()) + signingKey, err := SigningKeyFromPrivateKey(k.config.PrivateKey) if err != nil { return nil, trace.Wrap(err) } - signingKey := jose.SigningKey{ - Algorithm: algorithm, - Key: signer, - } if opts == nil { opts = &jose.SignerOptions{} @@ -202,6 +190,28 @@ func AlgorithmForPublicKey(pub crypto.PublicKey) (jose.SignatureAlgorithm, error return "", trace.BadParameter("unsupported public key type %T", pub) } +// SigningKeyFromPrivateKey creates a jose.SigningKey from the given signer, +// wrapping it in an opaque signer if necessary. +func SigningKeyFromPrivateKey(priv crypto.Signer) (jose.SigningKey, error) { + // Create a signer with configured private key and algorithm. + var signer interface{} + switch priv.(type) { + case *rsa.PrivateKey, *ecdsa.PrivateKey, ed25519.PrivateKey: + signer = priv + default: + signer = cryptosigner.Opaque(priv) + } + algorithm, err := AlgorithmForPublicKey(priv.Public()) + if err != nil { + return jose.SigningKey{}, trace.Wrap(err) + } + + return jose.SigningKey{ + Algorithm: algorithm, + Key: signer, + }, nil +} + func (k *Key) Sign(p SignParams) (string, error) { if err := p.Check(); err != nil { return "", trace.Wrap(err) diff --git a/lib/tbot/service_bot_identity.go b/lib/tbot/service_bot_identity.go index 82d047665d922..65e77d2323baa 100644 --- a/lib/tbot/service_bot_identity.go +++ b/lib/tbot/service_bot_identity.go @@ -633,6 +633,10 @@ func botIdentityFromToken( return nil, trace.BadParameter("unsupported address kind: %v", addrKind) } + // Only set during bound keypair joining, but used both before and after. + var boundKeypairAdapter boundkeypair.FS + var boundKeypairState *boundkeypair.ClientState + switch params.JoinMethod { case types.JoinMethodAzure: params.AzureParams = join.AzureParams{ @@ -644,20 +648,18 @@ func botIdentityFromToken( params.GitlabParams = join.GitlabParams{ EnvVarName: cfg.Onboarding.Gitlab.TokenEnvVarName, } - } - - if params.JoinMethod == types.JoinMethodBoundKeypair { + case types.JoinMethodBoundKeypair: joinSecret := cfg.Onboarding.BoundKeypair.InitialJoinSecret - adapter := config.NewBoundkeypairDestinationAdapter(cfg.Storage.Destination) - state, err := boundkeypair.LoadClientState(ctx, adapter) + boundKeypairAdapter = config.NewBoundkeypairDestinationAdapter(cfg.Storage.Destination) + boundKeypairState, err = boundkeypair.LoadClientState(ctx, boundKeypairAdapter) if trace.IsNotFound(err) && joinSecret != "" { return nil, trace.NotImplemented("no existing client state was found and join secrets are not yet supported") } else if err != nil { return nil, trace.Wrap(err, "loading bound keypair client state") } - params.BoundKeypairParams = state.ToJoinParams(joinSecret) + params.BoundKeypairParams = boundKeypairState.ToJoinParams(joinSecret) } result, err := join.Register(ctx, params) @@ -665,6 +667,18 @@ func botIdentityFromToken( return nil, trace.Wrap(err) } + if boundKeypairState != nil { + if err := boundKeypairState.UpdateFromRegisterResult(result); err != nil { + return nil, trace.Wrap(err) + } + + log.DebugContext(ctx, "updating bound keypair client state") + + if err := boundkeypair.StoreClientState(ctx, boundKeypairAdapter, boundKeypairState); err != nil { + return nil, trace.Wrap(err) + } + } + privateKeyPEM, err := keys.MarshalPrivateKey(result.PrivateKey) if err != nil { return nil, trace.Wrap(err) From 49fcb63628dec4181585512e11f1255ea05c2c7d Mon Sep 17 00:00:00 2001 From: Tim Buckley Date: Fri, 15 Aug 2025 18:35:55 -0600 Subject: [PATCH 4/5] Fix missing CAs in tests --- lib/auth/authtest/authtest.go | 2 +- lib/services/local/suite_test.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/auth/authtest/authtest.go b/lib/auth/authtest/authtest.go index 419214bda142f..ff81a031e3777 100644 --- a/lib/auth/authtest/authtest.go +++ b/lib/auth/authtest/authtest.go @@ -1665,7 +1665,7 @@ func NewTestCAWithConfig(config TestCAConfig) *types.CertAuthorityV2 { // Add JWT keys if necessary. switch config.Type { - case types.JWTSigner, types.OIDCIdPCA, types.SPIFFECA, types.OktaCA: + case types.JWTSigner, types.OIDCIdPCA, types.SPIFFECA, types.OktaCA, types.BoundKeypairCA: pubKeyPEM, err := keys.MarshalPublicKey(key.Public()) if err != nil { panic(err) diff --git a/lib/services/local/suite_test.go b/lib/services/local/suite_test.go index e398103b63426..ccde54cacc39a 100644 --- a/lib/services/local/suite_test.go +++ b/lib/services/local/suite_test.go @@ -2173,7 +2173,7 @@ func NewTestCAWithConfig(config TestCAConfig) *types.CertAuthorityV2 { // Add JWT keys if necessary. switch config.Type { - case types.JWTSigner, types.OIDCIdPCA, types.SPIFFECA, types.OktaCA: + case types.JWTSigner, types.OIDCIdPCA, types.SPIFFECA, types.OktaCA, types.BoundKeypairCA: pubKeyPEM, err := keys.MarshalPublicKey(key.Public()) if err != nil { panic(err) From fab404981b7fe9052517e1a7a3a60867779daffe Mon Sep 17 00:00:00 2001 From: Tim Buckley Date: Fri, 15 Aug 2025 20:21:21 -0600 Subject: [PATCH 5/5] Fix broken test --- lib/boundkeypair/join_state_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/boundkeypair/join_state_test.go b/lib/boundkeypair/join_state_test.go index a345d1ceb9d1a..22406f18f4d19 100644 --- a/lib/boundkeypair/join_state_test.go +++ b/lib/boundkeypair/join_state_test.go @@ -134,7 +134,7 @@ func TestIssueAndVerifyJoinState(t *testing.T) { issue func(t *testing.T, clock clockwork.Clock) string verifyParams *JoinStateParams - clockMod func(clock *clockwork.FakeClock) + clockMod func(clock clockwork.FakeClock) assertError require.ErrorAssertionFunc assertSuccess func(t *testing.T, s *JoinState) @@ -189,7 +189,7 @@ func TestIssueAndVerifyJoinState(t *testing.T) { name: "issued too early", issue: makeIssuer(activeSigner, makeParams(withRecovery(0, 1))), verifyParams: makeParams(withRecovery(0, 1)), - clockMod: func(clock *clockwork.FakeClock) { + clockMod: func(clock clockwork.FakeClock) { clock.Advance(-10 * time.Minute) }, assertError: func(tt require.TestingT, err error, i ...interface{}) {