diff --git a/contract-tests/.papi/descriptors/dist/chunk-7P6ASYW6.mjs b/contract-tests/.papi/descriptors/dist/chunk-7P6ASYW6.mjs new file mode 100644 index 0000000000..bf4ad0eb02 --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/chunk-7P6ASYW6.mjs @@ -0,0 +1,9 @@ +var __defProp = Object.defineProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; + +export { + __export +}; diff --git a/contract-tests/.papi/descriptors/dist/common-types.d.ts b/contract-tests/.papi/descriptors/dist/common-types.d.ts new file mode 100644 index 0000000000..c883025696 --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/common-types.d.ts @@ -0,0 +1,9229 @@ +import { Enum, GetEnum, FixedSizeBinary, Binary, SS58String, FixedSizeArray, ResultPayload, TxCallData } from "polkadot-api"; +type AnonymousEnum = T & { + __anonymous: true; +}; +type MyTuple = [T, ...T[]]; +type SeparateUndefined = undefined extends T ? undefined | Exclude : T; +type Anonymize = SeparateUndefined ? number extends L ? Binary : FixedSizeBinary : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum ? T : T extends AnonymousEnum ? Enum : T extends MyTuple ? { + [K in keyof T]: T[K]; +} : T extends [] ? [] : T extends FixedSizeArray ? number extends L ? Array : FixedSizeArray : { + [K in keyof T & string]: T[K]; +}>; +export type I5sesotjlssv2d = { + "nonce": number; + "consumers": number; + "providers": number; + "sufficients": number; + "data": Anonymize; +}; +export type I1q8tnt1cluu5j = { + "free": bigint; + "reserved": bigint; + "frozen": bigint; + "flags": bigint; +}; +export type Iffmde3ekjedi9 = { + "normal": Anonymize; + "operational": Anonymize; + "mandatory": Anonymize; +}; +export type I4q39t5hn830vp = { + "ref_time": bigint; + "proof_size": bigint; +}; +export type I4mddgoa69c0a2 = Array; +export type DigestItem = Enum<{ + "PreRuntime": [FixedSizeBinary<4>, Binary]; + "Consensus": [FixedSizeBinary<4>, Binary]; + "Seal": [FixedSizeBinary<4>, Binary]; + "Other": Binary; + "RuntimeEnvironmentUpdated": undefined; +}>; +export declare const DigestItem: GetEnum; +export type Icr4vaj0vrd6je = Array<{ + "phase": Phase; + "event": Enum<{ + "System": Anonymize; + "Grandpa": GrandpaEvent; + "Balances": Anonymize; + "TransactionPayment": TransactionPaymentEvent; + "SubtensorModule": Anonymize; + "Utility": Anonymize; + "Sudo": Anonymize; + "Multisig": Anonymize; + "Preimage": PreimageEvent; + "Scheduler": Anonymize; + "Proxy": Anonymize; + "Registry": Anonymize; + "Commitments": Anonymize; + "AdminUtils": Anonymize; + "SafeMode": Anonymize; + "Ethereum": Anonymize; + "EVM": Anonymize; + "BaseFee": Anonymize; + "Drand": Anonymize; + "Crowdloan": Anonymize; + "Swap": Anonymize; + "Contracts": Anonymize; + "MevShield": Anonymize; + }>; + "topics": Anonymize; +}>; +export type Phase = Enum<{ + "ApplyExtrinsic": number; + "Finalization": undefined; + "Initialization": undefined; +}>; +export declare const Phase: GetEnum; +export type Icfds8s8ncea16 = AnonymousEnum<{ + /** + * An extrinsic completed successfully. + */ + "ExtrinsicSuccess": Anonymize; + /** + * An extrinsic failed. + */ + "ExtrinsicFailed": Anonymize; + /** + * `:code` was updated. + */ + "CodeUpdated": undefined; + /** + * A new account was created. + */ + "NewAccount": Anonymize; + /** + * An account was reaped. + */ + "KilledAccount": Anonymize; + /** + * On on-chain remark happened. + */ + "Remarked": Anonymize; + /** + * An upgrade was authorized. + */ + "UpgradeAuthorized": Anonymize; + /** + * An invalid authorized upgrade was rejected while trying to apply it. + */ + "RejectedInvalidAuthorizedUpgrade": Anonymize; +}>; +export type Ia82mnkmeo2rhc = { + "dispatch_info": Anonymize; +}; +export type Ic9s8f85vjtncc = { + "weight": Anonymize; + "class": DispatchClass; + "pays_fee": Anonymize; +}; +export type DispatchClass = Enum<{ + "Normal": undefined; + "Operational": undefined; + "Mandatory": undefined; +}>; +export declare const DispatchClass: GetEnum; +export type Iehg04bj71rkd = AnonymousEnum<{ + "Yes": undefined; + "No": undefined; +}>; +export type I6u3ru0d29kkj0 = { + "dispatch_error": Anonymize; + "dispatch_info": Anonymize; +}; +export type Ic871mj76419vm = AnonymousEnum<{ + "Other": undefined; + "CannotLookup": undefined; + "BadOrigin": undefined; + "Module": Enum<{ + "System": Anonymize; + "RandomnessCollectiveFlip": undefined; + "Timestamp": undefined; + "Aura": undefined; + "Grandpa": Anonymize; + "Balances": Anonymize; + "TransactionPayment": undefined; + "SubtensorModule": Anonymize; + "Utility": Anonymize; + "Sudo": Anonymize; + "Multisig": Anonymize; + "Preimage": Anonymize; + "Scheduler": Anonymize; + "Proxy": Anonymize; + "Registry": Anonymize; + "Commitments": Anonymize; + "AdminUtils": Anonymize; + "SafeMode": Anonymize; + "Ethereum": Anonymize; + "EVM": Anonymize; + "EVMChainId": undefined; + "BaseFee": undefined; + "Drand": Anonymize; + "Crowdloan": Anonymize; + "Swap": Anonymize; + "Contracts": Anonymize; + "MevShield": Anonymize; + }>; + "ConsumerRemaining": undefined; + "NoProviders": undefined; + "TooManyConsumers": undefined; + "Token": TokenError; + "Arithmetic": ArithmeticError; + "Transactional": TransactionalError; + "Exhausted": undefined; + "Corruption": undefined; + "Unavailable": undefined; + "RootNotAllowed": undefined; + "Trie": Enum<{ + "InvalidStateRoot": undefined; + "IncompleteDatabase": undefined; + "ValueAtIncompleteKey": undefined; + "DecoderError": undefined; + "InvalidHash": undefined; + "DuplicateKey": undefined; + "ExtraneousNode": undefined; + "ExtraneousValue": undefined; + "ExtraneousHashReference": undefined; + "InvalidChildReference": undefined; + "ValueMismatch": undefined; + "IncompleteProof": undefined; + "RootMismatch": undefined; + "DecodeError": undefined; + }>; +}>; +export type I5o0s7c8q1cc9b = AnonymousEnum<{ + /** + * The name of specification does not match between the current runtime + * and the new runtime. + */ + "InvalidSpecName": undefined; + /** + * The specification version is not allowed to decrease between the current runtime + * and the new runtime. + */ + "SpecVersionNeedsToIncrease": undefined; + /** + * Failed to extract the runtime version from the new runtime. + * + * Either calling `Core_version` or decoding `RuntimeVersion` failed. + */ + "FailedToExtractRuntimeVersion": undefined; + /** + * Suicide called when the account has non-default composite data. + */ + "NonDefaultComposite": undefined; + /** + * There is a non-zero reference count preventing the account from being purged. + */ + "NonZeroRefCount": undefined; + /** + * The origin filter prevent the call to be dispatched. + */ + "CallFiltered": undefined; + /** + * A multi-block migration is ongoing and prevents the current code from being replaced. + */ + "MultiBlockMigrationsOngoing": undefined; + /** + * No upgrade authorized. + */ + "NothingAuthorized": undefined; + /** + * The submitted code is not authorized. + */ + "Unauthorized": undefined; +}>; +export type I7q8i0pp1gkas6 = AnonymousEnum<{ + /** + * Attempt to signal GRANDPA pause when the authority set isn't live + * (either paused or already pending pause). + */ + "PauseFailed": undefined; + /** + * Attempt to signal GRANDPA resume when the authority set isn't paused + * (either live or already pending resume). + */ + "ResumeFailed": undefined; + /** + * Attempt to signal GRANDPA change with one already pending. + */ + "ChangePending": undefined; + /** + * Cannot signal forced change so soon after last. + */ + "TooSoon": undefined; + /** + * A key ownership proof provided as part of an equivocation report is invalid. + */ + "InvalidKeyOwnershipProof": undefined; + /** + * An equivocation proof provided as part of an equivocation report is invalid. + */ + "InvalidEquivocationProof": undefined; + /** + * A given equivocation report is valid but already previously reported. + */ + "DuplicateOffenceReport": undefined; +}>; +export type Idj13i7adlomht = AnonymousEnum<{ + /** + * Vesting balance too high to send value. + */ + "VestingBalance": undefined; + /** + * Account liquidity restrictions prevent withdrawal. + */ + "LiquidityRestrictions": undefined; + /** + * Balance too low to send value. + */ + "InsufficientBalance": undefined; + /** + * Value too low to create account due to existential deposit. + */ + "ExistentialDeposit": undefined; + /** + * Transfer/payment would kill account. + */ + "Expendability": undefined; + /** + * A vesting schedule already exists for this account. + */ + "ExistingVestingSchedule": undefined; + /** + * Beneficiary account must pre-exist. + */ + "DeadAccount": undefined; + /** + * Number of named reserves exceed `MaxReserves`. + */ + "TooManyReserves": undefined; + /** + * Number of holds exceed `VariantCountOf`. + */ + "TooManyHolds": undefined; + /** + * Number of freezes exceed `MaxFreezes`. + */ + "TooManyFreezes": undefined; + /** + * The issuance cannot be modified since it is already deactivated. + */ + "IssuanceDeactivated": undefined; + /** + * The delta cannot be zero. + */ + "DeltaZero": undefined; +}>; +export type Ib31febi51tc1 = AnonymousEnum<{ + /** + * The root network does not exist. + */ + "RootNetworkDoesNotExist": undefined; + /** + * The user is trying to serve an axon which is not of type 4 (IPv4) or 6 (IPv6). + */ + "InvalidIpType": undefined; + /** + * An invalid IP address is passed to the serve function. + */ + "InvalidIpAddress": undefined; + /** + * An invalid port is passed to the serve function. + */ + "InvalidPort": undefined; + /** + * The hotkey is not registered in subnet + */ + "HotKeyNotRegisteredInSubNet": undefined; + /** + * The hotkey does not exists + */ + "HotKeyAccountNotExists": undefined; + /** + * The hotkey is not registered in any subnet. + */ + "HotKeyNotRegisteredInNetwork": undefined; + /** + * Request to stake, unstake or subscribe is made by a coldkey that is not associated with + * the hotkey account. + */ + "NonAssociatedColdKey": undefined; + /** + * DEPRECATED: Stake amount to withdraw is zero. + * The caller does not have enought stake to perform this action. + */ + "NotEnoughStake": undefined; + /** + * The caller is requesting removing more stake than there exists in the staking account. + * See: "[remove_stake()]". + */ + "NotEnoughStakeToWithdraw": undefined; + /** + * The caller is requesting to set weights but the caller has less than minimum stake + * required to set weights (less than WeightsMinStake). + */ + "NotEnoughStakeToSetWeights": undefined; + /** + * The parent hotkey doesn't have enough own stake to set childkeys. + */ + "NotEnoughStakeToSetChildkeys": undefined; + /** + * The caller is requesting adding more stake than there exists in the coldkey account. + * See: "[add_stake()]" + */ + "NotEnoughBalanceToStake": undefined; + /** + * The caller is trying to add stake, but for some reason the requested amount could not be + * withdrawn from the coldkey account. + */ + "BalanceWithdrawalError": undefined; + /** + * Unsuccessfully withdraw, balance could be zero (can not make account exist) after + * withdrawal. + */ + "ZeroBalanceAfterWithdrawn": undefined; + /** + * The caller is attempting to set non-self weights without being a permitted validator. + */ + "NeuronNoValidatorPermit": undefined; + /** + * The caller is attempting to set the weight keys and values but these vectors have + * different size. + */ + "WeightVecNotEqualSize": undefined; + /** + * The caller is attempting to set weights with duplicate UIDs in the weight matrix. + */ + "DuplicateUids": undefined; + /** + * The caller is attempting to set weight to at least one UID that does not exist in the + * metagraph. + */ + "UidVecContainInvalidOne": undefined; + /** + * The dispatch is attempting to set weights on chain with fewer elements than are allowed. + */ + "WeightVecLengthIsLow": undefined; + /** + * Number of registrations in this block exceeds the allowed number (i.e., exceeds the + * subnet hyperparameter "max_regs_per_block"). + */ + "TooManyRegistrationsThisBlock": undefined; + /** + * The caller is requesting registering a neuron which already exists in the active set. + */ + "HotKeyAlreadyRegisteredInSubNet": undefined; + /** + * The new hotkey is the same as old one + */ + "NewHotKeyIsSameWithOld": undefined; + /** + * The supplied PoW hash block is in the future or negative. + */ + "InvalidWorkBlock": undefined; + /** + * The supplied PoW hash block does not meet the network difficulty. + */ + "InvalidDifficulty": undefined; + /** + * The supplied PoW hash seal does not match the supplied work. + */ + "InvalidSeal": undefined; + /** + * The dispatch is attempting to set weights on chain with weight value exceeding the + * configured max weight limit (currently `u16::MAX`). + */ + "MaxWeightExceeded": undefined; + /** + * The hotkey is attempting to become a delegate when the hotkey is already a delegate. + */ + "HotKeyAlreadyDelegate": undefined; + /** + * A transactor exceeded the rate limit for setting weights. + */ + "SettingWeightsTooFast": undefined; + /** + * A validator is attempting to set weights from a validator with incorrect weight version. + */ + "IncorrectWeightVersionKey": undefined; + /** + * An axon or prometheus serving exceeded the rate limit for a registered neuron. + */ + "ServingRateLimitExceeded": undefined; + /** + * The caller is attempting to set weights with more UIDs than allowed. + */ + "UidsLengthExceedUidsInSubNet": undefined; + /** + * A transactor exceeded the rate limit for add network transaction. + */ + "NetworkTxRateLimitExceeded": undefined; + /** + * A transactor exceeded the rate limit for delegate transaction. + */ + "DelegateTxRateLimitExceeded": undefined; + /** + * A transactor exceeded the rate limit for setting or swapping hotkey. + */ + "HotKeySetTxRateLimitExceeded": undefined; + /** + * A transactor exceeded the rate limit for staking. + */ + "StakingRateLimitExceeded": undefined; + /** + * Registration is disabled. + */ + "SubNetRegistrationDisabled": undefined; + /** + * The number of registration attempts exceeded the allowed number in the interval. + */ + "TooManyRegistrationsThisInterval": undefined; + /** + * The hotkey is required to be the origin. + */ + "TransactorAccountShouldBeHotKey": undefined; + /** + * Faucet is disabled. + */ + "FaucetDisabled": undefined; + /** + * Not a subnet owner. + */ + "NotSubnetOwner": undefined; + /** + * Operation is not permitted on the root subnet. + */ + "RegistrationNotPermittedOnRootSubnet": undefined; + /** + * A hotkey with too little stake is attempting to join the root subnet. + */ + "StakeTooLowForRoot": undefined; + /** + * All subnets are in the immunity period. + */ + "AllNetworksInImmunity": undefined; + /** + * Not enough balance to pay swapping hotkey. + */ + "NotEnoughBalanceToPaySwapHotKey": undefined; + /** + * Netuid does not match for setting root network weights. + */ + "NotRootSubnet": undefined; + /** + * Can not set weights for the root network. + */ + "CanNotSetRootNetworkWeights": undefined; + /** + * No neuron ID is available. + */ + "NoNeuronIdAvailable": undefined; + /** + * Delegate take is too low. + */ + "DelegateTakeTooLow": undefined; + /** + * Delegate take is too high. + */ + "DelegateTakeTooHigh": undefined; + /** + * No commit found for the provided hotkey+netuid combination when attempting to reveal the + * weights. + */ + "NoWeightsCommitFound": undefined; + /** + * Committed hash does not equal the hashed reveal data. + */ + "InvalidRevealCommitHashNotMatch": undefined; + /** + * Attempting to call set_weights when commit/reveal is enabled + */ + "CommitRevealEnabled": undefined; + /** + * Attemtping to commit/reveal weights when disabled. + */ + "CommitRevealDisabled": undefined; + /** + * Attempting to set alpha high/low while disabled + */ + "LiquidAlphaDisabled": undefined; + /** + * Alpha high is too low: alpha_high > 0.8 + */ + "AlphaHighTooLow": undefined; + /** + * Alpha low is out of range: alpha_low > 0 && alpha_low < 0.8 + */ + "AlphaLowOutOfRange": undefined; + /** + * The coldkey has already been swapped + */ + "ColdKeyAlreadyAssociated": undefined; + /** + * The coldkey balance is not enough to pay for the swap + */ + "NotEnoughBalanceToPaySwapColdKey": undefined; + /** + * Attempting to set an invalid child for a hotkey on a network. + */ + "InvalidChild": undefined; + /** + * Duplicate child when setting children. + */ + "DuplicateChild": undefined; + /** + * Proportion overflow when setting children. + */ + "ProportionOverflow": undefined; + /** + * Too many children MAX 5. + */ + "TooManyChildren": undefined; + /** + * Default transaction rate limit exceeded. + */ + "TxRateLimitExceeded": undefined; + /** + * Coldkey swap announcement not found + */ + "ColdkeySwapAnnouncementNotFound": undefined; + /** + * Coldkey swap too early. + */ + "ColdkeySwapTooEarly": undefined; + /** + * Coldkey swap reannounced too early. + */ + "ColdkeySwapReannouncedTooEarly": undefined; + /** + * The announced coldkey hash does not match the new coldkey hash. + */ + "AnnouncedColdkeyHashDoesNotMatch": undefined; + /** + * Coldkey swap already disputed + */ + "ColdkeySwapAlreadyDisputed": undefined; + /** + * New coldkey is hotkey + */ + "NewColdKeyIsHotkey": undefined; + /** + * Childkey take is invalid. + */ + "InvalidChildkeyTake": undefined; + /** + * Childkey take rate limit exceeded. + */ + "TxChildkeyTakeRateLimitExceeded": undefined; + /** + * Invalid identity. + */ + "InvalidIdentity": undefined; + /** + * Subnet mechanism does not exist. + */ + "MechanismDoesNotExist": undefined; + /** + * Trying to unstake your lock amount. + */ + "CannotUnstakeLock": undefined; + /** + * Trying to perform action on non-existent subnet. + */ + "SubnetNotExists": undefined; + /** + * Maximum commit limit reached + */ + "TooManyUnrevealedCommits": undefined; + /** + * Attempted to reveal weights that are expired. + */ + "ExpiredWeightCommit": undefined; + /** + * Attempted to reveal weights too early. + */ + "RevealTooEarly": undefined; + /** + * Attempted to batch reveal weights with mismatched vector input lenghts. + */ + "InputLengthsUnequal": undefined; + /** + * A transactor exceeded the rate limit for setting weights. + */ + "CommittingWeightsTooFast": undefined; + /** + * Stake amount is too low. + */ + "AmountTooLow": undefined; + /** + * Not enough liquidity. + */ + "InsufficientLiquidity": undefined; + /** + * Slippage is too high for the transaction. + */ + "SlippageTooHigh": undefined; + /** + * Subnet disallows transfer. + */ + "TransferDisallowed": undefined; + /** + * Activity cutoff is being set too low. + */ + "ActivityCutoffTooLow": undefined; + /** + * Call is disabled + */ + "CallDisabled": undefined; + /** + * FirstEmissionBlockNumber is already set. + */ + "FirstEmissionBlockNumberAlreadySet": undefined; + /** + * need wait for more blocks to accept the start call extrinsic. + */ + "NeedWaitingMoreBlocksToStarCall": undefined; + /** + * Not enough AlphaOut on the subnet to recycle + */ + "NotEnoughAlphaOutToRecycle": undefined; + /** + * Cannot burn or recycle TAO from root subnet + */ + "CannotBurnOrRecycleOnRootSubnet": undefined; + /** + * Public key cannot be recovered. + */ + "UnableToRecoverPublicKey": undefined; + /** + * Recovered public key is invalid. + */ + "InvalidRecoveredPublicKey": undefined; + /** + * SubToken disabled now + */ + "SubtokenDisabled": undefined; + /** + * Too frequent hotkey swap on subnet + */ + "HotKeySwapOnSubnetIntervalNotPassed": undefined; + /** + * Zero max stake amount + */ + "ZeroMaxStakeAmount": undefined; + /** + * Invalid netuid duplication + */ + "SameNetuid": undefined; + /** + * The caller does not have enough balance for the operation. + */ + "InsufficientBalance": undefined; + /** + * Too frequent staking operations + */ + "StakingOperationRateLimitExceeded": undefined; + /** + * Invalid lease beneficiary to register the leased network. + */ + "InvalidLeaseBeneficiary": undefined; + /** + * Lease cannot end in the past. + */ + "LeaseCannotEndInThePast": undefined; + /** + * Couldn't find the lease netuid. + */ + "LeaseNetuidNotFound": undefined; + /** + * Lease does not exist. + */ + "LeaseDoesNotExist": undefined; + /** + * Lease has no end block. + */ + "LeaseHasNoEndBlock": undefined; + /** + * Lease has not ended. + */ + "LeaseHasNotEnded": undefined; + /** + * An overflow occurred. + */ + "Overflow": undefined; + /** + * Beneficiary does not own hotkey. + */ + "BeneficiaryDoesNotOwnHotkey": undefined; + /** + * Expected beneficiary origin. + */ + "ExpectedBeneficiaryOrigin": undefined; + /** + * Admin operation is prohibited during the protected weights window + */ + "AdminActionProhibitedDuringWeightsWindow": undefined; + /** + * Symbol does not exist. + */ + "SymbolDoesNotExist": undefined; + /** + * Symbol already in use. + */ + "SymbolAlreadyInUse": undefined; + /** + * Incorrect commit-reveal version. + */ + "IncorrectCommitRevealVersion": undefined; + /** + * Reveal period is too large. + */ + "RevealPeriodTooLarge": undefined; + /** + * Reveal period is too small. + */ + "RevealPeriodTooSmall": undefined; + /** + * Generic error for out-of-range parameter value + */ + "InvalidValue": undefined; + /** + * Subnet limit reached & there is no eligible subnet to prune + */ + "SubnetLimitReached": undefined; + /** + * Insufficient funds to meet the subnet lock cost + */ + "CannotAffordLockCost": undefined; + /** + * exceeded the rate limit for associating an EVM key. + */ + "EvmKeyAssociateRateLimitExceeded": undefined; + /** + * Same auto stake hotkey already set + */ + "SameAutoStakeHotkeyAlreadySet": undefined; + /** + * The UID map for the subnet could not be cleared + */ + "UidMapCouldNotBeCleared": undefined; + /** + * Trimming would exceed the max immune neurons percentage + */ + "TrimmingWouldExceedMaxImmunePercentage": undefined; + /** + * Violating the rules of Childkey-Parentkey consistency + */ + "ChildParentInconsistency": undefined; + /** + * Invalid number of root claims + */ + "InvalidNumRootClaim": undefined; + /** + * Invalid value of root claim threshold + */ + "InvalidRootClaimThreshold": undefined; + /** + * Exceeded subnet limit number or zero. + */ + "InvalidSubnetNumber": undefined; + /** + * The maximum allowed UIDs times mechanism count should not exceed 256. + */ + "TooManyUIDsPerMechanism": undefined; + /** + * Voting power tracking is not enabled for this subnet. + */ + "VotingPowerTrackingNotEnabled": undefined; + /** + * Invalid voting power EMA alpha value (must be <= 10^18). + */ + "InvalidVotingPowerEmaAlpha": undefined; + /** + * Unintended precision loss when unstaking alpha + */ + "PrecisionLoss": undefined; + /** + * Deprecated call. + */ + "Deprecated": undefined; + /** + * "Add stake and burn" exceeded the operation rate limit + */ + "AddStakeBurnRateLimitExceeded": undefined; +}>; +export type I499qmubmch1cg = AnonymousEnum<{ + /** + * Too many calls batched. + */ + "TooManyCalls": undefined; + /** + * Bad input data for derived account ID + */ + "InvalidDerivedAccount": undefined; +}>; +export type Iaug04qjhbli00 = AnonymousEnum<{ + /** + * Sender must be the Sudo account. + */ + "RequireSudo": undefined; +}>; +export type Ia76qmhhg4jvb9 = AnonymousEnum<{ + /** + * Threshold must be 2 or greater. + */ + "MinimumThreshold": undefined; + /** + * Call is already approved by this signatory. + */ + "AlreadyApproved": undefined; + /** + * Call doesn't need any (more) approvals. + */ + "NoApprovalsNeeded": undefined; + /** + * There are too few signatories in the list. + */ + "TooFewSignatories": undefined; + /** + * There are too many signatories in the list. + */ + "TooManySignatories": undefined; + /** + * The signatories were provided out of order; they should be ordered. + */ + "SignatoriesOutOfOrder": undefined; + /** + * The sender was contained in the other signatories; it shouldn't be. + */ + "SenderInSignatories": undefined; + /** + * Multisig operation not found in storage. + */ + "NotFound": undefined; + /** + * Only the account that originally created the multisig is able to cancel it or update + * its deposits. + */ + "NotOwner": undefined; + /** + * No timepoint was given, yet the multisig operation is already underway. + */ + "NoTimepoint": undefined; + /** + * A different timepoint was given to the multisig operation that is underway. + */ + "WrongTimepoint": undefined; + /** + * A timepoint was given, yet no multisig operation is underway. + */ + "UnexpectedTimepoint": undefined; + /** + * The maximum weight information provided was too low. + */ + "MaxWeightTooLow": undefined; + /** + * The data to be stored is already stored. + */ + "AlreadyStored": undefined; +}>; +export type I4cfhml1prt4lu = AnonymousEnum<{ + /** + * Preimage is too large to store on-chain. + */ + "TooBig": undefined; + /** + * Preimage has already been noted on-chain. + */ + "AlreadyNoted": undefined; + /** + * The user is not authorized to perform this action. + */ + "NotAuthorized": undefined; + /** + * The preimage cannot be removed since it has not yet been noted. + */ + "NotNoted": undefined; + /** + * A preimage may not be removed when there are outstanding requests. + */ + "Requested": undefined; + /** + * The preimage request cannot be removed since no outstanding requests exist. + */ + "NotRequested": undefined; + /** + * More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once. + */ + "TooMany": undefined; + /** + * Too few hashes were requested to be upgraded (i.e. zero). + */ + "TooFew": undefined; +}>; +export type If7oa8fprnilo5 = AnonymousEnum<{ + /** + * Failed to schedule a call + */ + "FailedToSchedule": undefined; + /** + * Cannot find the scheduled call. + */ + "NotFound": undefined; + /** + * Given target block number is in the past. + */ + "TargetBlockNumberInPast": undefined; + /** + * Reschedule failed because it does not change scheduled time. + */ + "RescheduleNoChange": undefined; + /** + * Attempt to use a non-named function on a named task. + */ + "Named": undefined; +}>; +export type I7ae37ntp06co6 = AnonymousEnum<{ + /** + * There are too many proxies registered or too many announcements pending. + */ + "TooMany": undefined; + /** + * Proxy registration not found. + */ + "NotFound": undefined; + /** + * Sender is not a proxy of the account to be proxied. + */ + "NotProxy": undefined; + /** + * A call which is incompatible with the proxy type's filter was attempted. + */ + "Unproxyable": undefined; + /** + * Account is already a proxy. + */ + "Duplicate": undefined; + /** + * Call may not be made by proxy because it may escalate its privileges. + */ + "NoPermission": undefined; + /** + * Announcement, if made at all, was made too recently. + */ + "Unannounced": undefined; + /** + * Cannot add self as proxy. + */ + "NoSelfProxy": undefined; + /** + * Invariant violated: deposit recomputation returned None after updating announcements. + */ + "AnnouncementDepositInvariantViolated": undefined; + /** + * Failed to derive a valid account id from the provided entropy. + */ + "InvalidDerivedAccountId": undefined; +}>; +export type Id6jmtdau2lr6l = AnonymousEnum<{ + /** + * Account attempted to register an identity but does not meet the requirements. + */ + "CannotRegister": undefined; + /** + * Account passed too many additional fields to their identity + */ + "TooManyFieldsInIdentityInfo": undefined; + /** + * Account doesn't have a registered identity + */ + "NotRegistered": undefined; +}>; +export type I8a8dfn9etteh2 = AnonymousEnum<{ + /** + * Account passed too many additional fields to their commitment + */ + "TooManyFieldsInCommitmentInfo": undefined; + /** + * Account is not allowed to make commitments to the chain + */ + "AccountNotAllowedCommit": undefined; + /** + * Space Limit Exceeded for the current interval + */ + "SpaceLimitExceeded": undefined; + /** + * Indicates that unreserve returned a leftover, which is unexpected. + */ + "UnexpectedUnreserveLeftover": undefined; +}>; +export type I8br6rdnlvg28h = AnonymousEnum<{ + /** + * The subnet does not exist, check the netuid parameter + */ + "SubnetDoesNotExist": undefined; + /** + * The maximum number of subnet validators must be less than the maximum number of allowed UIDs in the subnet. + */ + "MaxValidatorsLargerThanMaxUIds": undefined; + /** + * The maximum number of subnet validators must be more than the current number of UIDs already in the subnet. + */ + "MaxAllowedUIdsLessThanCurrentUIds": undefined; + /** + * The maximum value for bonds moving average is reached + */ + "BondsMovingAverageMaxReached": undefined; + /** + * Only root can set negative sigmoid steepness values + */ + "NegativeSigmoidSteepness": undefined; + /** + * Value not in allowed bounds. + */ + "ValueNotInBounds": undefined; + /** + * The minimum allowed UIDs must be less than the current number of UIDs in the subnet. + */ + "MinAllowedUidsGreaterThanCurrentUids": undefined; + /** + * The minimum allowed UIDs must be less than the maximum allowed UIDs. + */ + "MinAllowedUidsGreaterThanMaxAllowedUids": undefined; + /** + * The maximum allowed UIDs must be greater than the minimum allowed UIDs. + */ + "MaxAllowedUidsLessThanMinAllowedUids": undefined; + /** + * The maximum allowed UIDs must be less than the default maximum allowed UIDs. + */ + "MaxAllowedUidsGreaterThanDefaultMaxAllowedUids": undefined; + /** + * Bad parameter value + */ + "InvalidValue": undefined; +}>; +export type I65gapcjsc3grr = AnonymousEnum<{ + /** + * The safe-mode is (already or still) entered. + */ + "Entered": undefined; + /** + * The safe-mode is (already or still) exited. + */ + "Exited": undefined; + /** + * This functionality of the pallet is disabled by the configuration. + */ + "NotConfigured": undefined; + /** + * There is no balance reserved. + */ + "NoDeposit": undefined; + /** + * The account already has a deposit reserved and can therefore not enter or extend again. + */ + "AlreadyDeposited": undefined; + /** + * This deposit cannot be released yet. + */ + "CannotReleaseYet": undefined; + /** + * An error from the underlying `Currency`. + */ + "CurrencyError": undefined; +}>; +export type I1mp6vnoh32l4q = AnonymousEnum<{ + /** + * Signature is invalid. + */ + "InvalidSignature": undefined; + /** + * Pre-log is present, therefore transact is not allowed. + */ + "PreLogExists": undefined; +}>; +export type I226s9mgj51cd2 = AnonymousEnum<{ + /** + * Not enough balance to perform action + */ + "BalanceLow": undefined; + /** + * Calculating total fee overflowed + */ + "FeeOverflow": undefined; + /** + * Calculating total payment overflowed + */ + "PaymentOverflow": undefined; + /** + * Withdraw fee failed + */ + "WithdrawFailed": undefined; + /** + * Gas price is too low. + */ + "GasPriceTooLow": undefined; + /** + * Nonce is invalid + */ + "InvalidNonce": undefined; + /** + * Gas limit is too low. + */ + "GasLimitTooLow": undefined; + /** + * Gas limit is too high. + */ + "GasLimitTooHigh": undefined; + /** + * The chain id is invalid. + */ + "InvalidChainId": undefined; + /** + * the signature is invalid. + */ + "InvalidSignature": undefined; + /** + * EVM reentrancy + */ + "Reentrancy": undefined; + /** + * EIP-3607, + */ + "TransactionMustComeFromEOA": undefined; + /** + * Undefined error. + */ + "Undefined": undefined; + /** + * Origin is not allowed to perform the operation. + */ + "NotAllowed": undefined; + /** + * Address not allowed to deploy contracts either via CREATE or CALL(CREATE). + */ + "CreateOriginNotAllowed": undefined; +}>; +export type I8veee4gumsdel = AnonymousEnum<{ + /** + * The value retrieved was `None` as no value was previously set. + */ + "NoneValue": undefined; + /** + * There was an attempt to increment the value in storage over `u32::MAX`. + */ + "StorageOverflow": undefined; + /** + * failed to connect to the + */ + "DrandConnectionFailure": undefined; + /** + * the pulse is invalid + */ + "UnverifiedPulse": undefined; + /** + * the round number did not increment + */ + "InvalidRoundNumber": undefined; + /** + * the pulse could not be verified + */ + "PulseVerificationError": undefined; +}>; +export type I1ots9pukq67tt = AnonymousEnum<{ + /** + * The crowdloan initial deposit is too low. + */ + "DepositTooLow": undefined; + /** + * The crowdloan cap is too low. + */ + "CapTooLow": undefined; + /** + * The minimum contribution is too low. + */ + "MinimumContributionTooLow": undefined; + /** + * The crowdloan cannot end in the past. + */ + "CannotEndInPast": undefined; + /** + * The crowdloan block duration is too short. + */ + "BlockDurationTooShort": undefined; + /** + * The block duration is too long. + */ + "BlockDurationTooLong": undefined; + /** + * The account does not have enough balance to pay for the initial deposit/contribution. + */ + "InsufficientBalance": undefined; + /** + * An overflow occurred. + */ + "Overflow": undefined; + /** + * The crowdloan id is invalid. + */ + "InvalidCrowdloanId": undefined; + /** + * The crowdloan cap has been fully raised. + */ + "CapRaised": undefined; + /** + * The contribution period has ended. + */ + "ContributionPeriodEnded": undefined; + /** + * The contribution is too low. + */ + "ContributionTooLow": undefined; + /** + * The origin of this call is invalid. + */ + "InvalidOrigin": undefined; + /** + * The crowdloan has already been finalized. + */ + "AlreadyFinalized": undefined; + /** + * The crowdloan contribution period has not ended yet. + */ + "ContributionPeriodNotEnded": undefined; + /** + * The contributor has no contribution for this crowdloan. + */ + "NoContribution": undefined; + /** + * The crowdloan cap has not been raised. + */ + "CapNotRaised": undefined; + /** + * An underflow occurred. + */ + "Underflow": undefined; + /** + * Call to dispatch was not found in the preimage storage. + */ + "CallUnavailable": undefined; + /** + * The crowdloan is not ready to be dissolved, it still has contributions. + */ + "NotReadyToDissolve": undefined; + /** + * The deposit cannot be withdrawn from the crowdloan. + */ + "DepositCannotBeWithdrawn": undefined; + /** + * The maximum number of contributors has been reached. + */ + "MaxContributorsReached": undefined; +}>; +export type I581cn6i0ettg7 = AnonymousEnum<{ + /** + * The fee rate is too high + */ + "FeeRateTooHigh": undefined; + /** + * The provided amount is insufficient for the swap. + */ + "InsufficientInputAmount": undefined; + /** + * The provided liquidity is insufficient for the operation. + */ + "InsufficientLiquidity": undefined; + /** + * The operation would exceed the price limit. + */ + "PriceLimitExceeded": undefined; + /** + * The caller does not have enough balance for the operation. + */ + "InsufficientBalance": undefined; + /** + * Attempted to remove liquidity that does not exist. + */ + "LiquidityNotFound": undefined; + /** + * The provided tick range is invalid. + */ + "InvalidTickRange": undefined; + /** + * Maximum user positions exceeded + */ + "MaxPositionsExceeded": undefined; + /** + * Too many swap steps + */ + "TooManySwapSteps": undefined; + /** + * Provided liquidity parameter is invalid (likely too small) + */ + "InvalidLiquidityValue": undefined; + /** + * Reserves too low for operation. + */ + "ReservesTooLow": undefined; + /** + * The subnet does not exist. + */ + "MechanismDoesNotExist": undefined; + /** + * User liquidity operations are disabled for this subnet + */ + "UserLiquidityDisabled": undefined; + /** + * The subnet does not have subtoken enabled + */ + "SubtokenDisabled": undefined; +}>; +export type I2489g9rnboo1t = AnonymousEnum<{ + /** + * Invalid schedule supplied, e.g. with zero weight of a basic operation. + */ + "InvalidSchedule": undefined; + /** + * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`. + */ + "InvalidCallFlags": undefined; + /** + * The executed contract exhausted its gas limit. + */ + "OutOfGas": undefined; + /** + * The output buffer supplied to a contract API call was too small. + */ + "OutputBufferTooSmall": undefined; + /** + * Performing the requested transfer failed. Probably because there isn't enough + * free balance in the sender's account. + */ + "TransferFailed": undefined; + /** + * Performing a call was denied because the calling depth reached the limit + * of what is specified in the schedule. + */ + "MaxCallDepthReached": undefined; + /** + * No contract was found at the specified address. + */ + "ContractNotFound": undefined; + /** + * The code supplied to `instantiate_with_code` exceeds the limit specified in the + * current schedule. + */ + "CodeTooLarge": undefined; + /** + * No code could be found at the supplied code hash. + */ + "CodeNotFound": undefined; + /** + * No code info could be found at the supplied code hash. + */ + "CodeInfoNotFound": undefined; + /** + * A buffer outside of sandbox memory was passed to a contract API function. + */ + "OutOfBounds": undefined; + /** + * Input passed to a contract API function failed to decode as expected type. + */ + "DecodingFailed": undefined; + /** + * Contract trapped during execution. + */ + "ContractTrapped": undefined; + /** + * The size defined in `T::MaxValueSize` was exceeded. + */ + "ValueTooLarge": undefined; + /** + * Termination of a contract is not allowed while the contract is already + * on the call stack. Can be triggered by `seal_terminate`. + */ + "TerminatedWhileReentrant": undefined; + /** + * `seal_call` forwarded this contracts input. It therefore is no longer available. + */ + "InputForwarded": undefined; + /** + * The subject passed to `seal_random` exceeds the limit. + */ + "RandomSubjectTooLong": undefined; + /** + * The amount of topics passed to `seal_deposit_events` exceeds the limit. + */ + "TooManyTopics": undefined; + /** + * The chain does not provide a chain extension. Calling the chain extension results + * in this error. Note that this usually shouldn't happen as deploying such contracts + * is rejected. + */ + "NoChainExtension": undefined; + /** + * Failed to decode the XCM program. + */ + "XCMDecodeFailed": undefined; + /** + * A contract with the same AccountId already exists. + */ + "DuplicateContract": undefined; + /** + * A contract self destructed in its constructor. + * + * This can be triggered by a call to `seal_terminate`. + */ + "TerminatedInConstructor": undefined; + /** + * A call tried to invoke a contract that is flagged as non-reentrant. + * The only other cause is that a call from a contract into the runtime tried to call back + * into `pallet-contracts`. This would make the whole pallet reentrant with regard to + * contract code execution which is not supported. + */ + "ReentranceDenied": undefined; + /** + * A contract attempted to invoke a state modifying API while being in read-only mode. + */ + "StateChangeDenied": undefined; + /** + * Origin doesn't have enough balance to pay the required storage deposits. + */ + "StorageDepositNotEnoughFunds": undefined; + /** + * More storage was created than allowed by the storage deposit limit. + */ + "StorageDepositLimitExhausted": undefined; + /** + * Code removal was denied because the code is still in use by at least one contract. + */ + "CodeInUse": undefined; + /** + * The contract ran to completion but decided to revert its storage changes. + * Please note that this error is only returned from extrinsics. When called directly + * or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags + * to determine whether a reversion has taken place. + */ + "ContractReverted": undefined; + /** + * The contract's code was found to be invalid during validation. + * + * The most likely cause of this is that an API was used which is not supported by the + * node. This happens if an older node is used with a new version of ink!. Try updating + * your node to the newest available version. + * + * A more detailed error can be found on the node console if debug messages are enabled + * by supplying `-lruntime::contracts=debug`. + */ + "CodeRejected": undefined; + /** + * An indeterministic code was used in a context where this is not permitted. + */ + "Indeterministic": undefined; + /** + * A pending migration needs to complete before the extrinsic can be called. + */ + "MigrationInProgress": undefined; + /** + * Migrate dispatch call was attempted but no migration was performed. + */ + "NoMigrationPerformed": undefined; + /** + * The contract has reached its maximum number of delegate dependencies. + */ + "MaxDelegateDependenciesReached": undefined; + /** + * The dependency was not found in the contract's delegate dependencies. + */ + "DelegateDependencyNotFound": undefined; + /** + * The contract already depends on the given delegate dependency. + */ + "DelegateDependencyAlreadyExists": undefined; + /** + * Can not add a delegate dependency to the code hash of the contract itself. + */ + "CannotAddSelfAsDelegateDependency": undefined; + /** + * Can not add more data to transient storage. + */ + "OutOfTransientStorage": undefined; +}>; +export type I4ngcc5keahtro = AnonymousEnum<{ + /** + * A submission with the same id already exists in `Submissions`. + */ + "SubmissionAlreadyExists": undefined; + /** + * The referenced submission id does not exist in `Submissions`. + */ + "MissingSubmission": undefined; + /** + * The recomputed commitment does not match the stored commitment. + */ + "CommitmentMismatch": undefined; + /** + * The provided signature over the payload is invalid. + */ + "SignatureInvalid": undefined; + /** + * The announced ML‑KEM public key length is invalid. + */ + "BadPublicKeyLen": undefined; + /** + * The MEV‑Shield key epoch for this submission has expired and is no longer accepted. + */ + "KeyExpired": undefined; + /** + * The provided `key_hash` does not match the expected epoch key hash. + */ + "KeyHashMismatch": undefined; +}>; +export type TokenError = Enum<{ + "FundsUnavailable": undefined; + "OnlyProvider": undefined; + "BelowMinimum": undefined; + "CannotCreate": undefined; + "UnknownAsset": undefined; + "Frozen": undefined; + "Unsupported": undefined; + "CannotCreateHold": undefined; + "NotExpendable": undefined; + "Blocked": undefined; +}>; +export declare const TokenError: GetEnum; +export type ArithmeticError = Enum<{ + "Underflow": undefined; + "Overflow": undefined; + "DivisionByZero": undefined; +}>; +export declare const ArithmeticError: GetEnum; +export type TransactionalError = Enum<{ + "LimitReached": undefined; + "NoLayer": undefined; +}>; +export declare const TransactionalError: GetEnum; +export type Icbccs0ug47ilf = { + "account": SS58String; +}; +export type I855j4i3kr8ko1 = { + "sender": SS58String; + "hash": FixedSizeBinary<32>; +}; +export type Ibgl04rn6nbfm6 = { + "code_hash": FixedSizeBinary<32>; + "check_version": boolean; +}; +export type Ibk0nulspilods = { + "code_hash": FixedSizeBinary<32>; + "error": Anonymize; +}; +export type GrandpaEvent = Enum<{ + /** + * New authority set has been applied. + */ + "NewAuthorities": Anonymize; + /** + * Current authority set has been paused. + */ + "Paused": undefined; + /** + * Current authority set has been resumed. + */ + "Resumed": undefined; +}>; +export declare const GrandpaEvent: GetEnum; +export type I5768ac424h061 = { + "authority_set": Anonymize; +}; +export type I3geksg000c171 = Array<[FixedSizeBinary<32>, bigint]>; +export type Iao8h4hv7atnq3 = AnonymousEnum<{ + /** + * An account was created with some free balance. + */ + "Endowed": Anonymize; + /** + * An account was removed whose balance was non-zero but below ExistentialDeposit, + * resulting in an outright loss. + */ + "DustLost": Anonymize; + /** + * Transfer succeeded. + */ + "Transfer": Anonymize; + /** + * A balance was set by root. + */ + "BalanceSet": Anonymize; + /** + * Some balance was reserved (moved from free to reserved). + */ + "Reserved": Anonymize; + /** + * Some balance was unreserved (moved from reserved to free). + */ + "Unreserved": Anonymize; + /** + * Some balance was moved from the reserve of the first account to the second account. + * Final argument indicates the destination balance type. + */ + "ReserveRepatriated": Anonymize; + /** + * Some amount was deposited (e.g. for transaction fees). + */ + "Deposit": Anonymize; + /** + * Some amount was withdrawn from the account (e.g. for transaction fees). + */ + "Withdraw": Anonymize; + /** + * Some amount was removed from the account (e.g. for misbehavior). + */ + "Slashed": Anonymize; + /** + * Some amount was minted into an account. + */ + "Minted": Anonymize; + /** + * Some amount was burned from an account. + */ + "Burned": Anonymize; + /** + * Some amount was suspended from an account (it can be restored later). + */ + "Suspended": Anonymize; + /** + * Some amount was restored into an account. + */ + "Restored": Anonymize; + /** + * An account was upgraded. + */ + "Upgraded": Anonymize; + /** + * Total issuance was increased by `amount`, creating a credit to be balanced. + */ + "Issued": Anonymize; + /** + * Total issuance was decreased by `amount`, creating a debt to be balanced. + */ + "Rescinded": Anonymize; + /** + * Some balance was locked. + */ + "Locked": Anonymize; + /** + * Some balance was unlocked. + */ + "Unlocked": Anonymize; + /** + * Some balance was frozen. + */ + "Frozen": Anonymize; + /** + * Some balance was thawed. + */ + "Thawed": Anonymize; + /** + * The `TotalIssuance` was forcefully changed. + */ + "TotalIssuanceForced": Anonymize; +}>; +export type Icv68aq8841478 = { + "account": SS58String; + "free_balance": bigint; +}; +export type Ic262ibdoec56a = { + "account": SS58String; + "amount": bigint; +}; +export type Iflcfm9b6nlmdd = { + "from": SS58String; + "to": SS58String; + "amount": bigint; +}; +export type Ijrsf4mnp3eka = { + "who": SS58String; + "free": bigint; +}; +export type Id5fm4p8lj5qgi = { + "who": SS58String; + "amount": bigint; +}; +export type I8tjvj9uq4b7hi = { + "from": SS58String; + "to": SS58String; + "amount": bigint; + "destination_status": BalanceStatus; +}; +export type BalanceStatus = Enum<{ + "Free": undefined; + "Reserved": undefined; +}>; +export declare const BalanceStatus: GetEnum; +export type I4cbvqmqadhrea = { + "who": SS58String; +}; +export type I3qt1hgg4djhgb = { + "amount": bigint; +}; +export type I4fooe9dun9o0t = { + "old": bigint; + "new": bigint; +}; +export type TransactionPaymentEvent = Enum<{ + /** + * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee, + * has been paid by `who`. + */ + "TransactionFeePaid": Anonymize; +}>; +export declare const TransactionPaymentEvent: GetEnum; +export type Ier2cke86dqbr2 = { + "who": SS58String; + "actual_fee": bigint; + "tip": bigint; +}; +export type I2hado50khaobu = AnonymousEnum<{ + /** + * a new network is added. + */ + "NetworkAdded": Anonymize; + /** + * a network is removed. + */ + "NetworkRemoved": number; + /** + * stake has been transferred from the a coldkey account onto the hotkey staking account. + */ + "StakeAdded": Anonymize; + /** + * stake has been removed from the hotkey staking account onto the coldkey account. + */ + "StakeRemoved": Anonymize; + /** + * stake has been moved from origin (hotkey, subnet ID) to destination (hotkey, subnet ID) of this amount (in TAO). + */ + "StakeMoved": Anonymize; + /** + * a caller successfully sets their weights on a subnetwork. + */ + "WeightsSet": Anonymize; + /** + * a new neuron account has been registered to the chain. + */ + "NeuronRegistered": Anonymize; + /** + * multiple uids have been concurrently registered. + */ + "BulkNeuronsRegistered": Anonymize; + /** + * FIXME: Not used yet + */ + "BulkBalancesSet": Anonymize; + /** + * max allowed uids has been set for a subnetwork. + */ + "MaxAllowedUidsSet": Anonymize; + /** + * DEPRECATED: max weight limit updates are no longer supported. + */ + "MaxWeightLimitSet": Anonymize; + /** + * the difficulty has been set for a subnet. + */ + "DifficultySet": Anonymize; + /** + * the adjustment interval is set for a subnet. + */ + "AdjustmentIntervalSet": Anonymize; + /** + * registration per interval is set for a subnet. + */ + "RegistrationPerIntervalSet": Anonymize; + /** + * we set max registrations per block. + */ + "MaxRegistrationsPerBlockSet": Anonymize; + /** + * an activity cutoff is set for a subnet. + */ + "ActivityCutoffSet": Anonymize; + /** + * Rho value is set. + */ + "RhoSet": Anonymize; + /** + * steepness of the sigmoid used to compute alpha values. + */ + "AlphaSigmoidSteepnessSet": Anonymize; + /** + * Kappa is set for a subnet. + */ + "KappaSet": Anonymize; + /** + * minimum allowed weight is set for a subnet. + */ + "MinAllowedWeightSet": Anonymize; + /** + * the validator pruning length has been set. + */ + "ValidatorPruneLenSet": Anonymize; + /** + * the scaling law power has been set for a subnet. + */ + "ScalingLawPowerSet": Anonymize; + /** + * weights set rate limit has been set for a subnet. + */ + "WeightsSetRateLimitSet": Anonymize; + /** + * immunity period is set for a subnet. + */ + "ImmunityPeriodSet": Anonymize; + /** + * bonds moving average is set for a subnet. + */ + "BondsMovingAverageSet": Anonymize; + /** + * bonds penalty is set for a subnet. + */ + "BondsPenaltySet": Anonymize; + /** + * bonds reset is set for a subnet. + */ + "BondsResetOnSet": Anonymize; + /** + * setting the max number of allowed validators on a subnet. + */ + "MaxAllowedValidatorsSet": Anonymize; + /** + * the axon server information is added to the network. + */ + "AxonServed": Anonymize; + /** + * the prometheus server information is added to the network. + */ + "PrometheusServed": Anonymize; + /** + * a hotkey has become a delegate. + */ + "DelegateAdded": Anonymize; + /** + * the default take is set. + */ + "DefaultTakeSet": number; + /** + * weights version key is set for a network. + */ + "WeightsVersionKeySet": Anonymize; + /** + * setting min difficulty on a network. + */ + "MinDifficultySet": Anonymize; + /** + * setting max difficulty on a network. + */ + "MaxDifficultySet": Anonymize; + /** + * setting the prometheus serving rate limit. + */ + "ServingRateLimitSet": Anonymize; + /** + * setting burn on a network. + */ + "BurnSet": Anonymize; + /** + * setting max burn on a network. + */ + "MaxBurnSet": Anonymize; + /** + * setting min burn on a network. + */ + "MinBurnSet": Anonymize; + /** + * setting the transaction rate limit. + */ + "TxRateLimitSet": bigint; + /** + * setting the delegate take transaction rate limit. + */ + "TxDelegateTakeRateLimitSet": bigint; + /** + * setting the childkey take transaction rate limit. + */ + "TxChildKeyTakeRateLimitSet": bigint; + /** + * setting the admin freeze window length (last N blocks of tempo) + */ + "AdminFreezeWindowSet": number; + /** + * setting the owner hyperparameter rate limit in epochs + */ + "OwnerHyperparamRateLimitSet": number; + /** + * minimum childkey take set + */ + "MinChildKeyTakeSet": number; + /** + * maximum childkey take set + */ + "MaxChildKeyTakeSet": number; + /** + * childkey take set + */ + "ChildKeyTakeSet": Anonymize; + /** + * a sudo call is done. + */ + "Sudid": Anonymize; + /** + * registration is allowed/disallowed for a subnet. + */ + "RegistrationAllowed": Anonymize; + /** + * POW registration is allowed/disallowed for a subnet. + */ + "PowRegistrationAllowed": Anonymize; + /** + * setting tempo on a network + */ + "TempoSet": Anonymize; + /** + * setting the RAO recycled for registration. + */ + "RAORecycledForRegistrationSet": Anonymize; + /** + * min stake is set for validators to set weights. + */ + "StakeThresholdSet": bigint; + /** + * setting the adjustment alpha on a subnet. + */ + "AdjustmentAlphaSet": Anonymize; + /** + * the faucet it called on the test net. + */ + "Faucet": Anonymize; + /** + * the subnet owner cut is set. + */ + "SubnetOwnerCutSet": number; + /** + * the network creation rate limit is set. + */ + "NetworkRateLimitSet": bigint; + /** + * the network immunity period is set. + */ + "NetworkImmunityPeriodSet": bigint; + /** + * the start call delay is set. + */ + "StartCallDelaySet": bigint; + /** + * the network minimum locking cost is set. + */ + "NetworkMinLockCostSet": bigint; + /** + * the maximum number of subnets is set + */ + "SubnetLimitSet": number; + /** + * the lock cost reduction is set + */ + "NetworkLockCostReductionIntervalSet": bigint; + /** + * the take for a delegate is decreased. + */ + "TakeDecreased": Anonymize; + /** + * the take for a delegate is increased. + */ + "TakeIncreased": Anonymize; + /** + * the hotkey is swapped + */ + "HotkeySwapped": Anonymize; + /** + * maximum delegate take is set by sudo/admin transaction + */ + "MaxDelegateTakeSet": number; + /** + * minimum delegate take is set by sudo/admin transaction + */ + "MinDelegateTakeSet": number; + /** + * A coldkey swap announcement has been made. + */ + "ColdkeySwapAnnounced": Anonymize; + /** + * A coldkey swap has been reset. + */ + "ColdkeySwapReset": Anonymize; + /** + * A coldkey has been swapped. + */ + "ColdkeySwapped": Anonymize; + /** + * A coldkey swap has been disputed. + */ + "ColdkeySwapDisputed": Anonymize; + /** + * All balance of a hotkey has been unstaked and transferred to a new coldkey + */ + "AllBalanceUnstakedAndTransferredToNewColdkey": Anonymize; + /** + * The arbitration period has been extended + */ + "ArbitrationPeriodExtended": Anonymize; + /** + * Setting of children of a hotkey have been scheduled + */ + "SetChildrenScheduled": Anonymize; + /** + * The children of a hotkey have been set + */ + "SetChildren": Anonymize; + /** + * The identity of a coldkey has been set + */ + "ChainIdentitySet": SS58String; + /** + * The identity of a subnet has been set + */ + "SubnetIdentitySet": number; + /** + * The identity of a subnet has been removed + */ + "SubnetIdentityRemoved": number; + /** + * A dissolve network extrinsic scheduled. + */ + "DissolveNetworkScheduled": Anonymize; + /** + * The coldkey swap announcement delay has been set. + */ + "ColdkeySwapAnnouncementDelaySet": number; + /** + * The coldkey swap reannouncement delay has been set. + */ + "ColdkeySwapReannouncementDelaySet": number; + /** + * The duration of dissolve network has been set + */ + "DissolveNetworkScheduleDurationSet": number; + /** + * Commit-reveal v3 weights have been successfully committed. + * + * - **who**: The account ID of the user committing the weights. + * - **netuid**: The network identifier. + * - **commit_hash**: The hash representing the committed weights. + */ + "CRV3WeightsCommitted": Anonymize; + /** + * Weights have been successfully committed. + * + * - **who**: The account ID of the user committing the weights. + * - **netuid**: The network identifier. + * - **commit_hash**: The hash representing the committed weights. + */ + "WeightsCommitted": Anonymize; + /** + * Weights have been successfully revealed. + * + * - **who**: The account ID of the user revealing the weights. + * - **netuid**: The network identifier. + * - **commit_hash**: The hash of the revealed weights. + */ + "WeightsRevealed": Anonymize; + /** + * Weights have been successfully batch revealed. + * + * - **who**: The account ID of the user revealing the weights. + * - **netuid**: The network identifier. + * - **revealed_hashes**: A vector of hashes representing each revealed weight set. + */ + "WeightsBatchRevealed": Anonymize; + /** + * A batch of weights (or commits) have been force-set. + * + * - **netuids**: The netuids these weights were successfully set/committed for. + * - **who**: The hotkey that set this batch. + */ + "BatchWeightsCompleted": Anonymize; + /** + * A batch extrinsic completed but with some errors. + */ + "BatchCompletedWithErrors": undefined; + /** + * A weight set among a batch of weights failed. + * + * - **error**: The dispatch error emitted by the failed item. + */ + "BatchWeightItemFailed": Anonymize; + /** + * Stake has been transferred from one coldkey to another on the same subnet. + * Parameters: + * (origin_coldkey, destination_coldkey, hotkey, origin_netuid, destination_netuid, amount) + */ + "StakeTransferred": Anonymize; + /** + * Stake has been swapped from one subnet to another for the same coldkey-hotkey pair. + * + * Parameters: + * (coldkey, hotkey, origin_netuid, destination_netuid, amount) + */ + "StakeSwapped": Anonymize; + /** + * Event called when transfer is toggled on a subnet. + * + * Parameters: + * (netuid, bool) + */ + "TransferToggle": Anonymize; + /** + * The owner hotkey for a subnet has been set. + * + * Parameters: + * (netuid, new_hotkey) + */ + "SubnetOwnerHotkeySet": Anonymize; + /** + * FirstEmissionBlockNumber is set via start call extrinsic + * + * Parameters: + * netuid + * block number + */ + "FirstEmissionBlockNumberSet": Anonymize; + /** + * Alpha has been recycled, reducing AlphaOut on a subnet. + * + * Parameters: + * (coldkey, hotkey, amount, subnet_id) + */ + "AlphaRecycled": Anonymize; + /** + * Alpha have been burned without reducing AlphaOut. + * + * Parameters: + * (coldkey, hotkey, amount, subnet_id) + */ + "AlphaBurned": Anonymize; + /** + * An EVM key has been associated with a hotkey. + */ + "EvmKeyAssociated": Anonymize; + /** + * CRV3 Weights have been successfully revealed. + * + * - **netuid**: The network identifier. + * - **who**: The account ID of the user revealing the weights. + */ + "CRV3WeightsRevealed": Anonymize; + /** + * Commit-Reveal periods has been successfully set. + * + * - **netuid**: The network identifier. + * - **periods**: The number of epochs before the reveal. + */ + "CommitRevealPeriodsSet": Anonymize; + /** + * Commit-Reveal has been successfully toggled. + * + * - **netuid**: The network identifier. + * - **Enabled**: Is Commit-Reveal enabled. + */ + "CommitRevealEnabled": Anonymize; + /** + * the hotkey is swapped + */ + "HotkeySwappedOnSubnet": Anonymize; + /** + * A subnet lease has been created. + */ + "SubnetLeaseCreated": Anonymize; + /** + * A subnet lease has been terminated. + */ + "SubnetLeaseTerminated": Anonymize; + /** + * The symbol for a subnet has been updated. + */ + "SymbolUpdated": Anonymize; + /** + * Commit Reveal Weights version has been updated. + * + * - **version**: The required version. + */ + "CommitRevealVersionSet": number; + /** + * Timelocked weights have been successfully committed. + * + * - **who**: The account ID of the user committing the weights. + * - **netuid**: The network identifier. + * - **commit_hash**: The hash representing the committed weights. + * - **reveal_round**: The round at which weights can be revealed. + */ + "TimelockedWeightsCommitted": Anonymize; + /** + * Timelocked Weights have been successfully revealed. + * + * - **netuid**: The network identifier. + * - **who**: The account ID of the user revealing the weights. + */ + "TimelockedWeightsRevealed": Anonymize; + /** + * Auto-staking hotkey received stake + */ + "AutoStakeAdded": Anonymize; + /** + * End-of-epoch miner incentive alpha by UID + */ + "IncentiveAlphaEmittedToMiners": Anonymize; + /** + * The minimum allowed UIDs for a subnet have been set. + */ + "MinAllowedUidsSet": Anonymize; + /** + * The auto stake destination has been set. + * + * - **coldkey**: The account ID of the coldkey. + * - **netuid**: The network identifier. + * - **hotkey**: The account ID of the hotkey. + */ + "AutoStakeDestinationSet": Anonymize; + /** + * The minimum allowed non-Immune UIDs has been set. + */ + "MinNonImmuneUidsSet": Anonymize; + /** + * Root emissions have been claimed for a coldkey on all subnets and hotkeys. + * Parameters: + * (coldkey) + */ + "RootClaimed": Anonymize; + /** + * Root claim type for a coldkey has been set. + * Parameters: + * (coldkey, u8) + */ + "RootClaimTypeSet": Anonymize; + /** + * Voting power tracking has been enabled for a subnet. + */ + "VotingPowerTrackingEnabled": Anonymize; + /** + * Voting power tracking has been scheduled for disabling. + * Tracking will continue until disable_at_block, then stop and clear entries. + */ + "VotingPowerTrackingDisableScheduled": Anonymize; + /** + * Voting power tracking has been fully disabled and entries cleared. + */ + "VotingPowerTrackingDisabled": Anonymize; + /** + * Voting power EMA alpha has been set for a subnet. + */ + "VotingPowerEmaAlphaSet": Anonymize; + /** + * Subnet lease dividends have been distributed. + */ + "SubnetLeaseDividendsDistributed": Anonymize; + /** + * "Add stake and burn" event: alpha token was purchased and burned. + */ + "AddStakeBurn": Anonymize; +}>; +export type I9jd27rnpm8ttv = FixedSizeArray<2, number>; +export type Io45lnue7n40k = [SS58String, SS58String, bigint, bigint, number, bigint]; +export type I83e4tgdv5ohg1 = [SS58String, SS58String, number, SS58String, number, bigint]; +export type I6o6dmud53u1fj = [number, number, SS58String]; +export type I4ojmnsk1dchql = [number, bigint]; +export type I5g2vv0ckl2m8b = [number, number]; +export type I39p6ln31i4n46 = [number, boolean]; +export type I7svnfko10tq2e = [number, SS58String]; +export type I7svrbkiu01iec = [SS58String, SS58String, number]; +export type I6ouflveob4eli = [SS58String, number]; +export type Ibq6c27da62s2q = ResultPayload>; +export type I95l2k9b1re95f = [SS58String, bigint]; +export type Ifkgc6cte1k96e = { + /** + * the account ID of coldkey + */ + "coldkey": SS58String; + /** + * the account ID of old hotkey + */ + "old_hotkey": SS58String; + /** + * the account ID of new hotkey + */ + "new_hotkey": SS58String; +}; +export type I6kvs2mb8unk0t = { + /** + * The account ID of the coldkey that made the announcement. + */ + "who": SS58String; + /** + * The hash of the new coldkey. + */ + "new_coldkey_hash": FixedSizeBinary<32>; +}; +export type Idbuci3sr3i1f7 = { + /** + * The account ID of old coldkey. + */ + "old_coldkey": SS58String; + /** + * The account ID of new coldkey. + */ + "new_coldkey": SS58String; +}; +export type I375tmdui1ejfc = { + /** + * The account ID of the coldkey that was disputed. + */ + "coldkey": SS58String; +}; +export type I73drt1hl9e70v = { + /** + * The account ID of the current coldkey + */ + "current_coldkey": SS58String; + /** + * The account ID of the new coldkey + */ + "new_coldkey": SS58String; + /** + * The total balance of the hotkey + */ + "total_balance": bigint; +}; +export type I1dm4sip108q0g = [SS58String, number, bigint, Anonymize]; +export type I5n8gpu725k1nu = Array<[bigint, SS58String]>; +export type Iajgphfb1fka7l = [SS58String, number, Anonymize]; +export type I4hnmf90qkrer9 = { + /** + * The account ID schedule the dissolve network extrinsic + */ + "account": SS58String; + /** + * network ID will be dissolved + */ + "netuid": number; + /** + * extrinsic execution block number + */ + "execution_block": number; +}; +export type Ijsohbv0raf36 = [SS58String, number, FixedSizeBinary<32>]; +export type I4ga01hppthoe1 = [SS58String, number, Anonymize]; +export type Ic5m5lp1oioo8r = Array>; +export type I4hckkcv10tcue = [Anonymize, SS58String]; +export type Icgljjb6j82uhn = Array; +export type If2ieedn10ujdv = [SS58String, SS58String, SS58String, number, number, bigint]; +export type Iaseh340tnovdh = [SS58String, SS58String, number, number, bigint]; +export type I8m5umt6snnmlj = [SS58String, SS58String, bigint, number]; +export type I5aeg4u9kpsp8o = { + /** + * The subnet that the hotkey belongs to. + */ + "netuid": number; + /** + * The hotkey associated with the EVM key. + */ + "hotkey": SS58String; + /** + * The EVM key being associated with the hotkey. + */ + "evm_key": FixedSizeBinary<20>; + /** + * The block where the association happened. + */ + "block_associated": bigint; +}; +export type I3fsv5f1boeqf3 = { + /** + * the account ID of coldkey + */ + "coldkey": SS58String; + /** + * the account ID of old hotkey + */ + "old_hotkey": SS58String; + /** + * the account ID of new hotkey + */ + "new_hotkey": SS58String; + /** + * the subnet ID + */ + "netuid": number; +}; +export type Ifoov68qt28nbm = { + /** + * The beneficiary of the lease. + */ + "beneficiary": SS58String; + /** + * The lease ID + */ + "lease_id": number; + /** + * The subnet ID + */ + "netuid": number; + /** + * The end block of the lease + */ + "end_block"?: Anonymize; +}; +export type I4arjljr6dpflb = (number) | undefined; +export type Ib937mhlbop6j7 = { + /** + * The beneficiary of the lease. + */ + "beneficiary": SS58String; + /** + * The subnet ID + */ + "netuid": number; +}; +export type I62rrikn5vj0p5 = { + /** + * The subnet ID + */ + "netuid": number; + /** + * The symbol that has been updated. + */ + "symbol": Binary; +}; +export type I838gqvljm75tj = [SS58String, number, FixedSizeBinary<32>, bigint]; +export type I1cu36qostj5d8 = { + /** + * Subnet identifier. + */ + "netuid": number; + /** + * Destination account that received the auto-staked funds. + */ + "destination": SS58String; + /** + * Hotkey account whose stake was auto-staked. + */ + "hotkey": SS58String; + /** + * Owner (coldkey) account associated with the hotkey. + */ + "owner": SS58String; + /** + * Amount of alpha auto-staked. + */ + "incentive": bigint; +}; +export type I4r2ptfsrl017r = { + /** + * Subnet identifier. + */ + "netuid": number; + /** + * UID-indexed array of miner incentive alpha; index equals UID. + */ + "emissions": Anonymize; +}; +export type Iafqnechp3omqg = Array; +export type Ielglukq9ekcit = { + /** + * The account ID of the coldkey. + */ + "coldkey": SS58String; + /** + * The network identifier. + */ + "netuid": number; + /** + * The account ID of the hotkey. + */ + "hotkey": SS58String; +}; +export type I1clsdhcok4nle = { + /** + * Claim coldkey + */ + "coldkey": SS58String; + /** + * Claim type + */ + "root_claim_type": Anonymize; +}; +export type Iapm6e7vtp0l6r = AnonymousEnum<{ + "Swap": undefined; + "Keep": undefined; + "KeepSubnets": Anonymize; +}>; +export type I2t4b7068rtebl = { + "subnets": Anonymize; +}; +export type I6cm4c5a1euio9 = { + /** + * The subnet ID + */ + "netuid": number; +}; +export type Iemddv6u2buvfn = { + /** + * The subnet ID + */ + "netuid": number; + /** + * Block at which tracking will be disabled + */ + "disable_at_block": bigint; +}; +export type I4guv8rii4s6je = { + /** + * The subnet ID + */ + "netuid": number; + /** + * The new alpha value (u64 with 18 decimal precision) + */ + "alpha": bigint; +}; +export type Ic149bnrif7lpr = { + /** + * The lease ID + */ + "lease_id": number; + /** + * The contributor + */ + "contributor": SS58String; + /** + * The amount of alpha distributed + */ + "alpha": bigint; +}; +export type I89dsvf7sdo4ko = { + /** + * The subnet ID + */ + "netuid": number; + /** + * hotky account ID + */ + "hotkey": SS58String; + /** + * Tao provided + */ + "amount": bigint; + /** + * Alpha burned + */ + "alpha": bigint; +}; +export type If1btu4npshog7 = AnonymousEnum<{ + /** + * Batch of dispatches did not complete fully. Index of first failing dispatch given, as + * well as the error. + */ + "BatchInterrupted": Anonymize; + /** + * Batch of dispatches completed fully with no error. + */ + "BatchCompleted": undefined; + /** + * Batch of dispatches completed but has errors. + */ + "BatchCompletedWithErrors": undefined; + /** + * A single item within a Batch of dispatches has completed with no error. + */ + "ItemCompleted": undefined; + /** + * A single item within a Batch of dispatches has completed with error. + */ + "ItemFailed": Anonymize; + /** + * A call was dispatched. + */ + "DispatchedAs": Anonymize; + /** + * Main call was dispatched. + */ + "IfElseMainSuccess": undefined; + /** + * The fallback call was dispatched. + */ + "IfElseFallbackCalled": Anonymize; +}>; +export type I804q3c12638a0 = { + "index": number; + "error": Anonymize; +}; +export type Idguve298jnare = { + "error": Anonymize; +}; +export type Idi3fb8585u2lp = { + "result": Anonymize; +}; +export type I1327b77famnt3 = { + "main_error": Anonymize; +}; +export type I8gl492p92bk6l = AnonymousEnum<{ + /** + * A sudo call just took place. + */ + "Sudid": Anonymize; + /** + * The sudo key has been updated. + */ + "KeyChanged": Anonymize; + /** + * The key was permanently removed. + */ + "KeyRemoved": undefined; + /** + * A [sudo_as](Pallet::sudo_as) call just took place. + */ + "SudoAsDone": Anonymize; +}>; +export type If58ibsptjm2at = { + /** + * The result of the call made by the sudo user. + */ + "sudo_result": Anonymize; +}; +export type I5rtkmhm2dng4u = { + /** + * The old sudo key (if one was previously set). + */ + "old"?: Anonymize; + /** + * The new sudo key (if one was set). + */ + "new": SS58String; +}; +export type Ihfphjolmsqq1 = (SS58String) | undefined; +export type Ibmokdg2doop8d = AnonymousEnum<{ + /** + * A new multisig operation has begun. + */ + "NewMultisig": Anonymize; + /** + * A multisig operation has been approved by someone. + */ + "MultisigApproval": Anonymize; + /** + * A multisig operation has been executed. + */ + "MultisigExecuted": Anonymize; + /** + * A multisig operation has been cancelled. + */ + "MultisigCancelled": Anonymize; + /** + * The deposit for a multisig operation has been updated/poked. + */ + "DepositPoked": Anonymize; +}>; +export type Iep27ialq4a7o7 = { + "approving": SS58String; + "multisig": SS58String; + "call_hash": FixedSizeBinary<32>; +}; +export type Iasu5jvoqr43mv = { + "approving": SS58String; + "timepoint": Anonymize; + "multisig": SS58String; + "call_hash": FixedSizeBinary<32>; +}; +export type Itvprrpb0nm3o = { + "height": number; + "index": number; +}; +export type I88p4dmln8611r = { + "approving": SS58String; + "timepoint": Anonymize; + "multisig": SS58String; + "call_hash": FixedSizeBinary<32>; + "result": Anonymize; +}; +export type I5qolde99acmd1 = { + "cancelling": SS58String; + "timepoint": Anonymize; + "multisig": SS58String; + "call_hash": FixedSizeBinary<32>; +}; +export type I8gtde5abn1g9a = { + "who": SS58String; + "call_hash": FixedSizeBinary<32>; + "old_deposit": bigint; + "new_deposit": bigint; +}; +export type PreimageEvent = Enum<{ + /** + * A preimage has been noted. + */ + "Noted": Anonymize; + /** + * A preimage has been requested. + */ + "Requested": Anonymize; + /** + * A preimage has ben cleared. + */ + "Cleared": Anonymize; +}>; +export declare const PreimageEvent: GetEnum; +export type I1jm8m1rh9e20v = { + "hash": FixedSizeBinary<32>; +}; +export type Iav5po3qov3sjo = AnonymousEnum<{ + /** + * Scheduled some task. + */ + "Scheduled": Anonymize; + /** + * Canceled some task. + */ + "Canceled": Anonymize; + /** + * Dispatched some task. + */ + "Dispatched": Anonymize; + /** + * Set a retry configuration for some task. + */ + "RetrySet": Anonymize; + /** + * Cancel a retry configuration for some task. + */ + "RetryCancelled": Anonymize; + /** + * The call for the provided hash was not found so the task has been aborted. + */ + "CallUnavailable": Anonymize; + /** + * The given task was unable to be renewed since the agenda is full at that block. + */ + "PeriodicFailed": Anonymize; + /** + * The given task was unable to be retried since the agenda is full at that block or there + * was not enough weight to reschedule it. + */ + "RetryFailed": Anonymize; + /** + * The given task can never be executed since it is overweight. + */ + "PermanentlyOverweight": Anonymize; + /** + * Agenda is incomplete from `when`. + */ + "AgendaIncomplete": Anonymize; +}>; +export type I5n4sebgkfr760 = { + "when": number; + "index": number; +}; +export type I3dvon8akhmsut = { + "task": Anonymize; + "id"?: Anonymize; + "result": Anonymize; +}; +export type I4s6vifaf8k998 = (FixedSizeBinary<32>) | undefined; +export type Ia3c82eadg79bj = { + "task": Anonymize; + "id"?: Anonymize; + "period": number; + "retries": number; +}; +export type Ienusoeb625ftq = { + "task": Anonymize; + "id"?: Anonymize; +}; +export type Ibtsa3docbr9el = { + "when": number; +}; +export type I65un9enf26o4o = AnonymousEnum<{ + /** + * A proxy was executed correctly, with the given. + */ + "ProxyExecuted": Anonymize; + /** + * A pure account has been created by new proxy with given + * disambiguation index and proxy type. + */ + "PureCreated": Anonymize; + /** + * A pure proxy was killed by its spawner. + */ + "PureKilled": Anonymize; + /** + * An announcement was placed to make a call in the future. + */ + "Announced": Anonymize; + /** + * A proxy was added. + */ + "ProxyAdded": Anonymize; + /** + * A proxy was removed. + */ + "ProxyRemoved": Anonymize; + /** + * A deposit stored for proxies or announcements was poked / updated. + */ + "DepositPoked": Anonymize; +}>; +export type Iek6442ldi23n3 = { + "pure": SS58String; + "who": SS58String; + "proxy_type": Anonymize; + "disambiguation_index": number; +}; +export type I8v1041j74kmaj = AnonymousEnum<{ + "Any": undefined; + "Owner": undefined; + "NonCritical": undefined; + "NonTransfer": undefined; + "Senate": undefined; + "NonFungible": undefined; + "Triumvirate": undefined; + "Governance": undefined; + "Staking": undefined; + "Registration": undefined; + "Transfer": undefined; + "SmallTransfer": undefined; + "RootWeights": undefined; + "ChildKeys": undefined; + "SudoUncheckedSetCode": undefined; + "SwapHotkey": undefined; + "SubnetLeaseBeneficiary": undefined; + "RootClaim": undefined; +}>; +export type Idpdo54rotesu2 = { + "pure": SS58String; + "spawner": SS58String; + "proxy_type": Anonymize; + "disambiguation_index": number; +}; +export type I2ur0oeqg495j8 = { + "real": SS58String; + "proxy": SS58String; + "call_hash": FixedSizeBinary<32>; +}; +export type Ibco2bqthggul0 = { + "delegator": SS58String; + "delegatee": SS58String; + "proxy_type": Anonymize; + "delay": number; +}; +export type I1bhd210c3phjj = { + "who": SS58String; + "kind": Enum<{ + "Proxies": undefined; + "Announcements": undefined; + }>; + "old_deposit": bigint; + "new_deposit": bigint; +}; +export type I626vh1cit09ni = AnonymousEnum<{ + /** + * Emitted when a user registers an identity + */ + "IdentitySet": Anonymize; + /** + * Emitted when a user dissolves an identity + */ + "IdentityDissolved": Anonymize; +}>; +export type I5ohlg8gv4pe9g = AnonymousEnum<{ + /** + * A commitment was set + */ + "Commitment": Anonymize; + /** + * A timelock-encrypted commitment was set + */ + "TimelockCommitment": Anonymize; + /** + * A timelock-encrypted commitment was auto-revealed + */ + "CommitmentRevealed": Anonymize; +}>; +export type Idcqgi2844k5he = { + /** + * The netuid of the commitment + */ + "netuid": number; + /** + * The account + */ + "who": SS58String; +}; +export type Iej2173ou338sm = { + /** + * The netuid of the commitment + */ + "netuid": number; + /** + * The account + */ + "who": SS58String; + /** + * The drand round to reveal + */ + "reveal_round": bigint; +}; +export type Ic1vmbif9o0nug = AnonymousEnum<{ + /** + * Event emitted when a precompile operation is updated. + */ + "PrecompileUpdated": Anonymize; + /** + * Event emitted when the Yuma3 enable is toggled. + */ + "Yuma3EnableToggled": Anonymize; + /** + * Event emitted when Bonds Reset is toggled. + */ + "BondsResetToggled": Anonymize; +}>; +export type I1sj8huj7of8mb = { + /** + * The type of precompile operation being updated. + */ + "precompile_id": Anonymize; + /** + * Indicates if the precompile operation is enabled or not. + */ + "enabled": boolean; +}; +export type I8un1ap2r4hhbj = AnonymousEnum<{ + "BalanceTransfer": undefined; + "Staking": undefined; + "Subnet": undefined; + "Metagraph": undefined; + "Neuron": undefined; + "UidLookup": undefined; + "Alpha": undefined; + "Crowdloan": undefined; + "Proxy": undefined; + "Leasing": undefined; + "AddressMapping": undefined; + "VotingPower": undefined; +}>; +export type Ie31ro5s5e089f = { + /** + * The network identifier. + */ + "netuid": number; + /** + * Indicates if the Yuma3 enable was enabled or disabled. + */ + "enabled": boolean; +}; +export type I3q8c83f5dvokp = AnonymousEnum<{ + /** + * The safe-mode was entered until inclusively this block. + */ + "Entered": Anonymize; + /** + * The safe-mode was extended until inclusively this block. + */ + "Extended": Anonymize; + /** + * Exited the safe-mode for a specific reason. + */ + "Exited": Anonymize; + /** + * An account reserved funds for either entering or extending the safe-mode. + */ + "DepositPlaced": Anonymize; + /** + * An account had a reserve released that was reserved. + */ + "DepositReleased": Anonymize; + /** + * An account had reserve slashed that was reserved. + */ + "DepositSlashed": Anonymize; + /** + * Could not hold funds for entering or extending the safe-mode. + * + * This error comes from the underlying `Currency`. + */ + "CannotDeposit": undefined; + /** + * Could not release funds for entering or extending the safe-mode. + * + * This error comes from the underlying `Currency`. + */ + "CannotRelease": undefined; +}>; +export type I20e9ph536u7ti = { + "until": number; +}; +export type I8kcpmsh450rp = { + "reason": Enum<{ + "Timeout": undefined; + "Force": undefined; + }>; +}; +export type I510u4q1qqh897 = AnonymousEnum<{ + /** + * An ethereum transaction was successfully executed. + */ + "Executed": Anonymize; +}>; +export type Iea4g5ovhnolus = { + "from": FixedSizeBinary<20>; + "to": FixedSizeBinary<20>; + "transaction_hash": FixedSizeBinary<32>; + "exit_reason": Anonymize; + "extra_data": Binary; +}; +export type Iag9iovb9j5ijo = AnonymousEnum<{ + "Succeed": Enum<{ + "Stopped": undefined; + "Returned": undefined; + "Suicided": undefined; + }>; + "Error": Anonymize; + "Revert": Enum<{ + "Reverted": undefined; + }>; + "Fatal": Enum<{ + "NotSupported": undefined; + "UnhandledInterrupt": undefined; + "CallErrorAsFatal": Anonymize; + "Other": string; + }>; +}>; +export type I5ksr7ru2gk4nh = AnonymousEnum<{ + "StackUnderflow": undefined; + "StackOverflow": undefined; + "InvalidJump": undefined; + "InvalidRange": undefined; + "DesignatedInvalid": undefined; + "CallTooDeep": undefined; + "CreateCollision": undefined; + "CreateContractLimit": undefined; + "InvalidCode": number; + "OutOfOffset": undefined; + "OutOfGas": undefined; + "OutOfFund": undefined; + "PCUnderflow": undefined; + "CreateEmpty": undefined; + "Other": string; + "MaxNonce": undefined; +}>; +export type I9k071kk4cn1u8 = AnonymousEnum<{ + /** + * Ethereum events from contracts. + */ + "Log": Anonymize; + /** + * A contract has been created at given address. + */ + "Created": Anonymize; + /** + * A contract was attempted to be created, but the execution failed. + */ + "CreatedFailed": Anonymize; + /** + * A contract has been executed successfully with states applied. + */ + "Executed": Anonymize; + /** + * A contract has been executed with errors. States are reverted with only gas fees applied. + */ + "ExecutedFailed": Anonymize; +}>; +export type Ifmc9boeeia623 = { + "log": Anonymize; +}; +export type I10qb03fpuk6em = { + "address": FixedSizeBinary<20>; + "topics": Anonymize; + "data": Binary; +}; +export type Itmchvgqfl28g = { + "address": FixedSizeBinary<20>; +}; +export type I3bmatomsds8j7 = AnonymousEnum<{ + "NewBaseFeePerGas": Anonymize; + "BaseFeeOverflow": undefined; + "NewElasticity": Anonymize; +}>; +export type I7vi74gbubc8u5 = { + "fee": Anonymize; +}; +export type I4totqt881mlti = FixedSizeArray<4, bigint>; +export type I3u0knmtb1ueq7 = { + "elasticity": number; +}; +export type Ibdlgbf9b95hbj = AnonymousEnum<{ + /** + * Beacon Configuration has changed. + */ + "BeaconConfigChanged": undefined; + /** + * Successfully set a new pulse(s). + */ + "NewPulse": Anonymize; + /** + * Oldest Stored Round has been set. + */ + "SetOldestStoredRound": bigint; +}>; +export type I5tf7b5o64mfpl = { + "rounds": Anonymize; +}; +export type Ifj1h07t3i0np9 = AnonymousEnum<{ + /** + * A crowdloan was created. + */ + "Created": Anonymize; + /** + * A contribution was made to an active crowdloan. + */ + "Contributed": Anonymize; + /** + * A contribution was withdrawn from a failed crowdloan. + */ + "Withdrew": Anonymize; + /** + * A refund was partially processed for a failed crowdloan. + */ + "PartiallyRefunded": Anonymize; + /** + * A refund was fully processed for a failed crowdloan. + */ + "AllRefunded": Anonymize; + /** + * A crowdloan was finalized, funds were transferred and the call was dispatched. + */ + "Finalized": Anonymize; + /** + * A crowdloan was dissolved. + */ + "Dissolved": Anonymize; + /** + * The minimum contribution was updated. + */ + "MinContributionUpdated": Anonymize; + /** + * The end was updated. + */ + "EndUpdated": Anonymize; + /** + * The cap was updated. + */ + "CapUpdated": Anonymize; +}>; +export type If71d2q730qf6n = { + "crowdloan_id": number; + "creator": SS58String; + "end": number; + "cap": bigint; +}; +export type If0sk51c1n7ri8 = { + "crowdloan_id": number; + "contributor": SS58String; + "amount": bigint; +}; +export type I5dueehi6i2dg9 = { + "crowdloan_id": number; +}; +export type I64ev05f6q10es = { + "crowdloan_id": number; + "new_min_contribution": bigint; +}; +export type Ikc5h15joooak = { + "crowdloan_id": number; + "new_end": number; +}; +export type Ie8f436ua5fs59 = { + "crowdloan_id": number; + "new_cap": bigint; +}; +export type I6qodidnq3s4e1 = AnonymousEnum<{ + /** + * Event emitted when the fee rate has been updated for a subnet + */ + "FeeRateSet": Anonymize; + /** + * Event emitted when user liquidity operations are enabled for a subnet. + * First enable even indicates a switch from V2 to V3 swap. + */ + "UserLiquidityToggled": Anonymize; + /** + * Event emitted when a liquidity position is added to a subnet's liquidity pool. + */ + "LiquidityAdded": Anonymize; + /** + * Event emitted when a liquidity position is removed from a subnet's liquidity pool. + */ + "LiquidityRemoved": Anonymize; + /** + * Event emitted when a liquidity position is modified in a subnet's liquidity pool. + * Modifying causes the fees to be claimed. + */ + "LiquidityModified": Anonymize; +}>; +export type I3mkis681qg30e = { + "netuid": number; + "rate": number; +}; +export type I2foqo7cbqf35v = { + "netuid": number; + "enable": boolean; +}; +export type I4b2eh3b1oi815 = { + /** + * The coldkey account that owns the position + */ + "coldkey": SS58String; + /** + * The hotkey account where Alpha comes from + */ + "hotkey": SS58String; + /** + * The subnet identifier + */ + "netuid": number; + /** + * Unique identifier for the liquidity position + */ + "position_id": bigint; + /** + * The amount of liquidity added to the position + */ + "liquidity": bigint; + /** + * The amount of TAO tokens committed to the position + */ + "tao": bigint; + /** + * The amount of Alpha tokens committed to the position + */ + "alpha": bigint; + /** + * the lower tick + */ + "tick_low": number; + /** + * the upper tick + */ + "tick_high": number; +}; +export type I57q620f4fu1bl = { + /** + * The coldkey account that owns the position + */ + "coldkey": SS58String; + /** + * The hotkey account where Alpha goes to + */ + "hotkey": SS58String; + /** + * The subnet identifier + */ + "netuid": number; + /** + * Unique identifier for the liquidity position + */ + "position_id": bigint; + /** + * The amount of liquidity removed from the position + */ + "liquidity": bigint; + /** + * The amount of TAO tokens returned to the user + */ + "tao": bigint; + /** + * The amount of Alpha tokens returned to the user + */ + "alpha": bigint; + /** + * The amount of TAO fees earned from the position + */ + "fee_tao": bigint; + /** + * The amount of Alpha fees earned from the position + */ + "fee_alpha": bigint; + /** + * the lower tick + */ + "tick_low": number; + /** + * the upper tick + */ + "tick_high": number; +}; +export type I211sbjvh5hjqu = AnonymousEnum<{ + /** + * Contract deployed by address at the specified address. + */ + "Instantiated": Anonymize; + /** + * Contract has been removed. + * + * # Note + * + * The only way for a contract to be removed and emitting this event is by calling + * `seal_terminate`. + */ + "Terminated": Anonymize; + /** + * Code with the specified hash has been stored. + */ + "CodeStored": Anonymize; + /** + * A custom event emitted by the contract. + */ + "ContractEmitted": Anonymize; + /** + * A code with the specified hash was removed. + */ + "CodeRemoved": Anonymize; + /** + * A contract's code was updated. + */ + "ContractCodeUpdated": Anonymize; + /** + * A contract was called either by a plain account or another contract. + * + * # Note + * + * Please keep in mind that like all events this is only emitted for successful + * calls. This is because on failure all storage changes including events are + * rolled back. + */ + "Called": Anonymize; + /** + * A contract delegate called a code hash. + * + * # Note + * + * Please keep in mind that like all events this is only emitted for successful + * calls. This is because on failure all storage changes including events are + * rolled back. + */ + "DelegateCalled": Anonymize; + /** + * Some funds have been transferred and held as storage deposit. + */ + "StorageDepositTransferredAndHeld": Anonymize; + /** + * Some storage deposit funds have been transferred and released. + */ + "StorageDepositTransferredAndReleased": Anonymize; +}>; +export type Ie5222qfrr24ek = { + "deployer": SS58String; + "contract": SS58String; +}; +export type I28g8sphdu312k = { + /** + * The contract that was terminated. + */ + "contract": SS58String; + /** + * The account that received the contracts remaining balance + */ + "beneficiary": SS58String; +}; +export type Idqbjt2c6r46t6 = { + "code_hash": FixedSizeBinary<32>; + "deposit_held": bigint; + "uploader": SS58String; +}; +export type I853aigjva3f0t = { + /** + * The contract that emitted the event. + */ + "contract": SS58String; + /** + * Data supplied by the contract. Metadata generated during contract compilation + * is needed to decode it. + */ + "data": Binary; +}; +export type I9uehhems5hkqm = { + "code_hash": FixedSizeBinary<32>; + "deposit_released": bigint; + "remover": SS58String; +}; +export type I7q5qk4uoanhof = { + /** + * The contract that has been updated. + */ + "contract": SS58String; + /** + * New code hash that was set for the contract. + */ + "new_code_hash": FixedSizeBinary<32>; + /** + * Previous code hash of the contract. + */ + "old_code_hash": FixedSizeBinary<32>; +}; +export type Iehpbs40l3jkit = { + /** + * The caller of the `contract`. + */ + "caller": Enum<{ + "Root": undefined; + "Signed": SS58String; + }>; + /** + * The contract that was called. + */ + "contract": SS58String; +}; +export type Idht9upmipvd4j = { + /** + * The contract that performed the delegate call and hence in whose context + * the `code_hash` is executed. + */ + "contract": SS58String; + /** + * The code hash that was delegate called. + */ + "code_hash": FixedSizeBinary<32>; +}; +export type I70thgcbmbqm91 = AnonymousEnum<{ + /** + * Encrypted wrapper accepted. + */ + "EncryptedSubmitted": Anonymize; + /** + * Decrypted call executed. + */ + "DecryptedExecuted": Anonymize; + /** + * Decrypted execution rejected. + */ + "DecryptedRejected": Anonymize; + /** + * Decryption failed - validator could not decrypt the submission. + */ + "DecryptionFailed": Anonymize; +}>; +export type Icns2sqr5hp8s3 = { + "id": FixedSizeBinary<32>; + "who": SS58String; +}; +export type I9n4hs8p3rlkag = { + "id": FixedSizeBinary<32>; + "signer": SS58String; +}; +export type I6a8j73186lfdf = { + "id": FixedSizeBinary<32>; + "reason": { + "post_info": { + "actual_weight"?: Anonymize; + "pays_fee": Anonymize; + }; + "error": Anonymize; + }; +}; +export type Iasb8k6ash5mjn = (Anonymize) | undefined; +export type I602p6mm30elei = { + "id": FixedSizeBinary<32>; + "reason": Binary; +}; +export type I95g6i7ilua7lq = Array>; +export type Ieniouoqkq4icf = { + "spec_version": number; + "spec_name": string; +}; +export type GrandpaStoredState = Enum<{ + "Live": undefined; + "PendingPause": { + "scheduled_at": number; + "delay": number; + }; + "Paused": undefined; + "PendingResume": { + "scheduled_at": number; + "delay": number; + }; +}>; +export declare const GrandpaStoredState: GetEnum; +export type I7pe2me3i3vtn9 = { + "scheduled_at": number; + "delay": number; + "next_authorities": Anonymize; + "forced"?: Anonymize; +}; +export type I8ds64oj6581v0 = Array<{ + "id": FixedSizeBinary<8>; + "amount": bigint; + "reasons": BalancesTypesReasons; +}>; +export type BalancesTypesReasons = Enum<{ + "Fee": undefined; + "Misc": undefined; + "All": undefined; +}>; +export declare const BalancesTypesReasons: GetEnum; +export type Ia7pdug7cdsg8g = Array<{ + "id": FixedSizeBinary<8>; + "amount": bigint; +}>; +export type I2hnk9r4ukuj1p = Array<{ + "id": Enum<{ + "Preimage": PreimagePalletHoldReason; + "Registry": Enum<{ + "RegistryIdentity": undefined; + }>; + "SafeMode": Enum<{ + "EnterOrExtend": undefined; + }>; + "Contracts": Enum<{ + "CodeUploadDepositReserve": undefined; + "StorageDepositReserve": undefined; + }>; + }>; + "amount": bigint; +}>; +export type PreimagePalletHoldReason = Enum<{ + "Preimage": undefined; +}>; +export declare const PreimagePalletHoldReason: GetEnum; +export type I9bin2jc70qt6q = Array>; +export type TransactionPaymentReleases = Enum<{ + "V1Ancient": undefined; + "V2": undefined; +}>; +export declare const TransactionPaymentReleases: GetEnum; +export type Idoeu5t0dum8va = [Anonymize, bigint]; +export type Ia2lhg7l2hilo3 = Array; +export type I4p5t2krb1gmvp = [number, FixedSizeBinary<32>]; +export type Iabpgqcjikia83 = (Binary) | undefined; +export type I2j729bmgsdiuo = [bigint, bigint]; +export type Iakavvne152v30 = AnonymousEnum<{ + "SetSNOwnerHotkey": number; + "OwnerHyperparamUpdate": [number, Enum<{ + "Unknown": undefined; + "ServingRateLimit": undefined; + "MaxDifficulty": undefined; + "AdjustmentAlpha": undefined; + "MaxWeightLimit": undefined; + "ImmunityPeriod": undefined; + "MinAllowedWeights": undefined; + "Kappa": undefined; + "Rho": undefined; + "ActivityCutoff": undefined; + "PowRegistrationAllowed": undefined; + "MinBurn": undefined; + "MaxBurn": undefined; + "BondsMovingAverage": undefined; + "BondsPenalty": undefined; + "CommitRevealEnabled": undefined; + "LiquidAlphaEnabled": undefined; + "AlphaValues": undefined; + "WeightCommitInterval": undefined; + "TransferEnabled": undefined; + "AlphaSigmoidSteepness": undefined; + "Yuma3Enabled": undefined; + "BondsResetEnabled": undefined; + "ImmuneNeuronLimit": undefined; + "RecycleOrBurn": undefined; + "MaxAllowedUids": undefined; + }>]; + "NetworkLastRegistered": undefined; + "LastTxBlock": SS58String; + "LastTxBlockChildKeyTake": SS58String; + "LastTxBlockDelegateTake": SS58String; + "AddStakeBurn": number; +}>; +export type Ib9tptuv3cggfs = AnonymousEnum<{ + "Burn": undefined; + "Recycle": undefined; +}>; +export type I4h6ivgjtd51lv = Array<[SS58String, bigint, bigint]>; +export type I9eir063evtfb6 = Array; +export type Ibc83gdj8hi3rc = { + "block": bigint; + "version": number; + "ip": bigint; + "port": number; + "ip_type": number; + "protocol": number; + "placeholder1": number; + "placeholder2": number; +}; +export type I9lpjucl20l82d = { + "public_key": Binary; + "algorithm": number; +}; +export type Iaap7oohdmr1sb = { + "block": bigint; + "version": number; + "ip": bigint; + "port": number; + "ip_type": number; +}; +export type Ifjlj958aeheic = { + "name": Binary; + "url": Binary; + "github_repo": Binary; + "image": Binary; + "discord": Binary; + "description": Binary; + "additional": Binary; +}; +export type I4tc54pa558g5n = { + "subnet_name": Binary; + "github_repo": Binary; + "subnet_contact": Binary; + "subnet_url": Binary; + "discord": Binary; + "description": Binary; + "logo_url": Binary; + "additional": Binary; +}; +export type Id32h28hjj1tch = [SS58String, number, number]; +export type Icrrf4uohj5gb0 = Array<[FixedSizeBinary<32>, bigint, bigint, bigint]>; +export type I76jd8kl1mtn5g = Array<[SS58String, bigint, Binary, bigint]>; +export type I4jqk5si14p5oi = Array<[SS58String, Binary, bigint]>; +export type I2na29tt2afp0j = FixedSizeArray<2, SS58String>; +export type If9jidduiuq7vv = Array>; +export type I2brm5b9jij1st = [number, SS58String, SS58String]; +export type I7tof95tckt2r = [FixedSizeBinary<20>, bigint]; +export type Ieruonr5pk2d7h = { + "beneficiary": SS58String; + "coldkey": SS58String; + "hotkey": SS58String; + "emissions_share": number; + "end_block"?: Anonymize; + "netuid": number; + "cost": bigint; +}; +export type Iag146hmjgqfgj = { + "when": Anonymize; + "deposit": bigint; + "depositor": SS58String; + "approvals": Anonymize; +}; +export type I8uo3fpd3bcc6f = [SS58String, FixedSizeBinary<32>]; +export type PreimageOldRequestStatus = Enum<{ + "Unrequested": { + "deposit": Anonymize; + "len": number; + }; + "Requested": { + "deposit"?: Anonymize; + "count": number; + "len"?: Anonymize; + }; +}>; +export declare const PreimageOldRequestStatus: GetEnum; +export type I92hdo1clkbp4g = (Anonymize) | undefined; +export type PreimageRequestStatus = Enum<{ + "Unrequested": { + "ticket": Anonymize; + "len": number; + }; + "Requested": { + "maybe_ticket"?: Anonymize; + "count": number; + "maybe_len"?: Anonymize; + }; +}>; +export declare const PreimageRequestStatus: GetEnum; +export type I4pact7n2e9a0i = [FixedSizeBinary<32>, number]; +export type I11tetbe8ces3o = Array<({ + "maybe_id"?: Anonymize; + "priority": number; + "call": PreimagesBounded; + "maybe_periodic"?: Anonymize; + "origin": Anonymize; +}) | undefined>; +export type PreimagesBounded = Enum<{ + "Legacy": Anonymize; + "Inline": Binary; + "Lookup": { + "hash": FixedSizeBinary<32>; + "len": number; + }; +}>; +export declare const PreimagesBounded: GetEnum; +export type Iep7au1720bm0e = (Anonymize) | undefined; +export type I32es0rp64745v = AnonymousEnum<{ + "system": Enum<{ + "Root": undefined; + "Signed": SS58String; + "None": undefined; + "Authorized": undefined; + }>; + "Ethereum": Enum<{ + "EthereumTransaction": FixedSizeBinary<20>; + }>; +}>; +export type I56u24ncejr5kt = { + "total_retries": number; + "remaining": number; + "period": number; +}; +export type I6tqrno2gaos08 = [Array<{ + "delegate": SS58String; + "proxy_type": Anonymize; + "delay": number; +}>, bigint]; +export type I9p9lq3rej5bhc = [Array<{ + "real": SS58String; + "call_hash": FixedSizeBinary<32>; + "height": number; +}>, bigint]; +export type Ib6u9l1gtc5l4t = { + "deposit": bigint; + "info": Anonymize; +}; +export type Ifiu33afi2n7qs = { + "additional": Array>>; + "display": Anonymize; + "legal": Anonymize; + "web": Anonymize; + "riot": Anonymize; + "email": Anonymize; + "pgp_fingerprint"?: Anonymize; + "image": Anonymize; + "twitter": Anonymize; +}; +export type I2fomq92gvvqhc = AnonymousEnum<{ + "None": undefined; + "Raw0": undefined; + "Raw1": number; + "Raw2": FixedSizeBinary<2>; + "Raw3": FixedSizeBinary<3>; + "Raw4": FixedSizeBinary<4>; + "Raw5": FixedSizeBinary<5>; + "Raw6": FixedSizeBinary<6>; + "Raw7": FixedSizeBinary<7>; + "Raw8": FixedSizeBinary<8>; + "Raw9": FixedSizeBinary<9>; + "Raw10": FixedSizeBinary<10>; + "Raw11": FixedSizeBinary<11>; + "Raw12": FixedSizeBinary<12>; + "Raw13": FixedSizeBinary<13>; + "Raw14": FixedSizeBinary<14>; + "Raw15": FixedSizeBinary<15>; + "Raw16": FixedSizeBinary<16>; + "Raw17": FixedSizeBinary<17>; + "Raw18": FixedSizeBinary<18>; + "Raw19": FixedSizeBinary<19>; + "Raw20": FixedSizeBinary<20>; + "Raw21": FixedSizeBinary<21>; + "Raw22": FixedSizeBinary<22>; + "Raw23": FixedSizeBinary<23>; + "Raw24": FixedSizeBinary<24>; + "Raw25": FixedSizeBinary<25>; + "Raw26": FixedSizeBinary<26>; + "Raw27": FixedSizeBinary<27>; + "Raw28": FixedSizeBinary<28>; + "Raw29": FixedSizeBinary<29>; + "Raw30": FixedSizeBinary<30>; + "Raw31": FixedSizeBinary<31>; + "Raw32": FixedSizeBinary<32>; + "Raw33": FixedSizeBinary<33>; + "Raw34": FixedSizeBinary<34>; + "Raw35": FixedSizeBinary<35>; + "Raw36": FixedSizeBinary<36>; + "Raw37": FixedSizeBinary<37>; + "Raw38": FixedSizeBinary<38>; + "Raw39": FixedSizeBinary<39>; + "Raw40": FixedSizeBinary<40>; + "Raw41": FixedSizeBinary<41>; + "Raw42": FixedSizeBinary<42>; + "Raw43": FixedSizeBinary<43>; + "Raw44": FixedSizeBinary<44>; + "Raw45": FixedSizeBinary<45>; + "Raw46": FixedSizeBinary<46>; + "Raw47": FixedSizeBinary<47>; + "Raw48": FixedSizeBinary<48>; + "Raw49": FixedSizeBinary<49>; + "Raw50": FixedSizeBinary<50>; + "Raw51": FixedSizeBinary<51>; + "Raw52": FixedSizeBinary<52>; + "Raw53": FixedSizeBinary<53>; + "Raw54": FixedSizeBinary<54>; + "Raw55": FixedSizeBinary<55>; + "Raw56": FixedSizeBinary<56>; + "Raw57": FixedSizeBinary<57>; + "Raw58": FixedSizeBinary<58>; + "Raw59": FixedSizeBinary<59>; + "Raw60": FixedSizeBinary<60>; + "Raw61": FixedSizeBinary<61>; + "Raw62": FixedSizeBinary<62>; + "Raw63": FixedSizeBinary<63>; + "Raw64": FixedSizeBinary<64>; + "BlakeTwo256": FixedSizeBinary<32>; + "Sha256": FixedSizeBinary<32>; + "Keccak256": FixedSizeBinary<32>; + "ShaThree256": FixedSizeBinary<32>; +}>; +export type If7b8240vgt2q5 = (FixedSizeBinary<20>) | undefined; +export type I7nkl7ntqohel8 = Array>; +export type I3m6d7ohcp5n4v = { + "deposit": bigint; + "block": number; + "info": Anonymize; +}; +export type I4122t6tpcniur = Array; + "Raw3": FixedSizeBinary<3>; + "Raw4": FixedSizeBinary<4>; + "Raw5": FixedSizeBinary<5>; + "Raw6": FixedSizeBinary<6>; + "Raw7": FixedSizeBinary<7>; + "Raw8": FixedSizeBinary<8>; + "Raw9": FixedSizeBinary<9>; + "Raw10": FixedSizeBinary<10>; + "Raw11": FixedSizeBinary<11>; + "Raw12": FixedSizeBinary<12>; + "Raw13": FixedSizeBinary<13>; + "Raw14": FixedSizeBinary<14>; + "Raw15": FixedSizeBinary<15>; + "Raw16": FixedSizeBinary<16>; + "Raw17": FixedSizeBinary<17>; + "Raw18": FixedSizeBinary<18>; + "Raw19": FixedSizeBinary<19>; + "Raw20": FixedSizeBinary<20>; + "Raw21": FixedSizeBinary<21>; + "Raw22": FixedSizeBinary<22>; + "Raw23": FixedSizeBinary<23>; + "Raw24": FixedSizeBinary<24>; + "Raw25": FixedSizeBinary<25>; + "Raw26": FixedSizeBinary<26>; + "Raw27": FixedSizeBinary<27>; + "Raw28": FixedSizeBinary<28>; + "Raw29": FixedSizeBinary<29>; + "Raw30": FixedSizeBinary<30>; + "Raw31": FixedSizeBinary<31>; + "Raw32": FixedSizeBinary<32>; + "Raw33": FixedSizeBinary<33>; + "Raw34": FixedSizeBinary<34>; + "Raw35": FixedSizeBinary<35>; + "Raw36": FixedSizeBinary<36>; + "Raw37": FixedSizeBinary<37>; + "Raw38": FixedSizeBinary<38>; + "Raw39": FixedSizeBinary<39>; + "Raw40": FixedSizeBinary<40>; + "Raw41": FixedSizeBinary<41>; + "Raw42": FixedSizeBinary<42>; + "Raw43": FixedSizeBinary<43>; + "Raw44": FixedSizeBinary<44>; + "Raw45": FixedSizeBinary<45>; + "Raw46": FixedSizeBinary<46>; + "Raw47": FixedSizeBinary<47>; + "Raw48": FixedSizeBinary<48>; + "Raw49": FixedSizeBinary<49>; + "Raw50": FixedSizeBinary<50>; + "Raw51": FixedSizeBinary<51>; + "Raw52": FixedSizeBinary<52>; + "Raw53": FixedSizeBinary<53>; + "Raw54": FixedSizeBinary<54>; + "Raw55": FixedSizeBinary<55>; + "Raw56": FixedSizeBinary<56>; + "Raw57": FixedSizeBinary<57>; + "Raw58": FixedSizeBinary<58>; + "Raw59": FixedSizeBinary<59>; + "Raw60": FixedSizeBinary<60>; + "Raw61": FixedSizeBinary<61>; + "Raw62": FixedSizeBinary<62>; + "Raw63": FixedSizeBinary<63>; + "Raw64": FixedSizeBinary<64>; + "Raw65": FixedSizeBinary<65>; + "Raw66": FixedSizeBinary<66>; + "Raw67": FixedSizeBinary<67>; + "Raw68": FixedSizeBinary<68>; + "Raw69": FixedSizeBinary<69>; + "Raw70": FixedSizeBinary<70>; + "Raw71": FixedSizeBinary<71>; + "Raw72": FixedSizeBinary<72>; + "Raw73": FixedSizeBinary<73>; + "Raw74": FixedSizeBinary<74>; + "Raw75": FixedSizeBinary<75>; + "Raw76": FixedSizeBinary<76>; + "Raw77": FixedSizeBinary<77>; + "Raw78": FixedSizeBinary<78>; + "Raw79": FixedSizeBinary<79>; + "Raw80": FixedSizeBinary<80>; + "Raw81": FixedSizeBinary<81>; + "Raw82": FixedSizeBinary<82>; + "Raw83": FixedSizeBinary<83>; + "Raw84": FixedSizeBinary<84>; + "Raw85": FixedSizeBinary<85>; + "Raw86": FixedSizeBinary<86>; + "Raw87": FixedSizeBinary<87>; + "Raw88": FixedSizeBinary<88>; + "Raw89": FixedSizeBinary<89>; + "Raw90": FixedSizeBinary<90>; + "Raw91": FixedSizeBinary<91>; + "Raw92": FixedSizeBinary<92>; + "Raw93": FixedSizeBinary<93>; + "Raw94": FixedSizeBinary<94>; + "Raw95": FixedSizeBinary<95>; + "Raw96": FixedSizeBinary<96>; + "Raw97": FixedSizeBinary<97>; + "Raw98": FixedSizeBinary<98>; + "Raw99": FixedSizeBinary<99>; + "Raw100": FixedSizeBinary<100>; + "Raw101": FixedSizeBinary<101>; + "Raw102": FixedSizeBinary<102>; + "Raw103": FixedSizeBinary<103>; + "Raw104": FixedSizeBinary<104>; + "Raw105": FixedSizeBinary<105>; + "Raw106": FixedSizeBinary<106>; + "Raw107": FixedSizeBinary<107>; + "Raw108": FixedSizeBinary<108>; + "Raw109": FixedSizeBinary<109>; + "Raw110": FixedSizeBinary<110>; + "Raw111": FixedSizeBinary<111>; + "Raw112": FixedSizeBinary<112>; + "Raw113": FixedSizeBinary<113>; + "Raw114": FixedSizeBinary<114>; + "Raw115": FixedSizeBinary<115>; + "Raw116": FixedSizeBinary<116>; + "Raw117": FixedSizeBinary<117>; + "Raw118": FixedSizeBinary<118>; + "Raw119": FixedSizeBinary<119>; + "Raw120": FixedSizeBinary<120>; + "Raw121": FixedSizeBinary<121>; + "Raw122": FixedSizeBinary<122>; + "Raw123": FixedSizeBinary<123>; + "Raw124": FixedSizeBinary<124>; + "Raw125": FixedSizeBinary<125>; + "Raw126": FixedSizeBinary<126>; + "Raw127": FixedSizeBinary<127>; + "Raw128": FixedSizeBinary<128>; + "BlakeTwo256": FixedSizeBinary<32>; + "Sha256": FixedSizeBinary<32>; + "Keccak256": FixedSizeBinary<32>; + "ShaThree256": FixedSizeBinary<32>; + "TimelockEncrypted": { + "encrypted": Binary; + "reveal_round": bigint; + }; + "ResetBondsFlag": undefined; + "BigRaw": Binary; +}>>; +export type Ib9pv5dg6upo6t = Array<[Binary, bigint]>; +export type I27ub49plcvb4c = { + "last_epoch": bigint; + "used_space": bigint; +}; +export type Ic3l568el19b24 = [Anonymize, Anonymize, Anonymize]; +export type Ibjuap2vk03rp6 = AnonymousEnum<{ + "Legacy": { + "nonce": Anonymize; + "gas_price": Anonymize; + "gas_limit": Anonymize; + "action": Anonymize; + "value": Anonymize; + "input": Binary; + "signature": { + "v": bigint; + "r": FixedSizeBinary<32>; + "s": FixedSizeBinary<32>; + }; + }; + "EIP2930": { + "chain_id": bigint; + "nonce": Anonymize; + "gas_price": Anonymize; + "gas_limit": Anonymize; + "action": Anonymize; + "value": Anonymize; + "input": Binary; + "access_list": Anonymize; + "signature": Anonymize; + }; + "EIP1559": { + "chain_id": bigint; + "nonce": Anonymize; + "max_priority_fee_per_gas": Anonymize; + "max_fee_per_gas": Anonymize; + "gas_limit": Anonymize; + "action": Anonymize; + "value": Anonymize; + "input": Binary; + "access_list": Anonymize; + "signature": Anonymize; + }; + "EIP7702": { + "chain_id": bigint; + "nonce": Anonymize; + "max_priority_fee_per_gas": Anonymize; + "max_fee_per_gas": Anonymize; + "gas_limit": Anonymize; + "destination": Anonymize; + "value": Anonymize; + "data": Binary; + "access_list": Anonymize; + "authorization_list": Anonymize; + "signature": Anonymize; + }; +}>; +export type I2do93a3gr3ege = AnonymousEnum<{ + "Call": FixedSizeBinary<20>; + "Create": undefined; +}>; +export type Ieap15h2pjii9u = Array<{ + "address": FixedSizeBinary<20>; + "storage_keys": Anonymize; +}>; +export type I9veufneid0sta = { + "odd_y_parity": boolean; + "r": FixedSizeBinary<32>; + "s": FixedSizeBinary<32>; +}; +export type Idg0qi60379vnh = Array<{ + "chain_id": bigint; + "address": FixedSizeBinary<20>; + "nonce": Anonymize; + "signature": Anonymize; +}>; +export type Ifoernv5r40rfc = { + "transaction_hash": FixedSizeBinary<32>; + "transaction_index": number; + "from": FixedSizeBinary<20>; + "to"?: Anonymize; + "contract_address"?: Anonymize; + "logs": Anonymize; + "logs_bloom": FixedSizeBinary<256>; +}; +export type Ids7ng2qsv7snu = Array>; +export type Ideko6oeomboa6 = AnonymousEnum<{ + "Legacy": { + "status_code": number; + "used_gas": Anonymize; + "logs_bloom": FixedSizeBinary<256>; + "logs": Anonymize; + }; + "EIP2930": { + "status_code": number; + "used_gas": Anonymize; + "logs_bloom": FixedSizeBinary<256>; + "logs": Anonymize; + }; + "EIP1559": { + "status_code": number; + "used_gas": Anonymize; + "logs_bloom": FixedSizeBinary<256>; + "logs": Anonymize; + }; + "EIP7702": { + "status_code": number; + "used_gas": Anonymize; + "logs_bloom": FixedSizeBinary<256>; + "logs": Anonymize; + }; +}>; +export type Ib0hfhkohlekcj = { + "header": Anonymize; + "transactions": Anonymize; + "ommers": Array>; +}; +export type I4v962mnhj6j6r = { + "parent_hash": FixedSizeBinary<32>; + "ommers_hash": FixedSizeBinary<32>; + "beneficiary": FixedSizeBinary<20>; + "state_root": FixedSizeBinary<32>; + "transactions_root": FixedSizeBinary<32>; + "receipts_root": FixedSizeBinary<32>; + "logs_bloom": FixedSizeBinary<256>; + "difficulty": Anonymize; + "number": Anonymize; + "gas_limit": Anonymize; + "gas_used": Anonymize; + "timestamp": bigint; + "extra_data": Binary; + "mix_hash": FixedSizeBinary<32>; + "nonce": FixedSizeBinary<8>; +}; +export type Ie30stbbeaul1o = Array>; +export type I32lgu058i52q9 = Array>; +export type Ie7atdsih6q14b = Array>; +export type I7jidl7qnnq87c = { + "size": bigint; + "hash": FixedSizeBinary<32>; +}; +export type I82cps8ng2jtug = [FixedSizeBinary<20>, FixedSizeBinary<32>]; +export type I4gqmlq9k6jlk3 = Array>; +export type I494mq1ertfc9k = { + "public_key": Binary; + "period": number; + "genesis_time": number; + "hash": Binary; + "group_hash": Binary; + "scheme_id": Binary; + "metadata": Binary; +}; +export type Ialchst9lgd11u = { + "round": bigint; + "randomness": Binary; + "signature": Binary; +}; +export type If0p9hvn3kegj1 = { + "creator": SS58String; + "deposit": bigint; + "min_contribution": bigint; + "end": number; + "cap": bigint; + "funds_account": SS58String; + "raised": bigint; + "target_address"?: Anonymize; + "call"?: (PreimagesBounded) | undefined; + "finalized": boolean; + "contributors_count": number; +}; +export type I8ac0r18acljm6 = { + "liquidity_net": bigint; + "liquidity_gross": bigint; + "fees_out_tao": bigint; + "fees_out_alpha": bigint; +}; +export type I5mi4kb05lrsa9 = { + "id": bigint; + "netuid": number; + "tick_low": number; + "tick_high": number; + "liquidity": bigint; + "fees_tao": bigint; + "fees_alpha": bigint; +}; +export type Icsknfl0f6r973 = [number, SS58String, bigint]; +export type I1ptic1rnhda0n = [number, Enum<{ + "Top": undefined; + "Middle": undefined; + "Bottom": undefined; +}>, number]; +export type I5kulbesqc1h1t = { + "owner": SS58String; + "deposit": bigint; + "refcount": bigint; + "determinism": Anonymize; + "code_len": number; +}; +export type I2dfliekq1ed7e = AnonymousEnum<{ + "Enforced": undefined; + "Relaxed": undefined; +}>; +export type I36dvimehsh2tm = { + "trie_id": Binary; + "code_hash": FixedSizeBinary<32>; + "storage_bytes": number; + "storage_items": number; + "storage_byte_deposit": bigint; + "storage_item_deposit": bigint; + "storage_base_deposit": bigint; + "delegate_dependencies": Anonymize; +}; +export type I8t4pajubp34g3 = { + "insert_counter": number; + "delete_counter": number; +}; +export type Ifdiflqufkknl8 = { + "author": SS58String; + "commitment": FixedSizeBinary<32>; + "ciphertext": Binary; + "submitted_in": number; +}; +export type In7a38730s6qs = { + "base_block": Anonymize; + "max_block": Anonymize; + "per_class": { + "normal": { + "base_extrinsic": Anonymize; + "max_extrinsic"?: Anonymize; + "max_total"?: Anonymize; + "reserved"?: Anonymize; + }; + "operational": { + "base_extrinsic": Anonymize; + "max_extrinsic"?: Anonymize; + "max_total"?: Anonymize; + "reserved"?: Anonymize; + }; + "mandatory": { + "base_extrinsic": Anonymize; + "max_extrinsic"?: Anonymize; + "max_total"?: Anonymize; + "reserved"?: Anonymize; + }; + }; +}; +export type If15el53dd76v9 = { + "normal": number; + "operational": number; + "mandatory": number; +}; +export type I9s0ave7t0vnrk = { + "read": bigint; + "write": bigint; +}; +export type I4fo08joqmcqnm = { + "spec_name": string; + "impl_name": string; + "authoring_version": number; + "spec_version": number; + "impl_version": number; + "apis": Array<[FixedSizeBinary<8>, number]>; + "transaction_version": number; + "system_version": number; +}; +export type I35p85j063s0il = (bigint) | undefined; +export type Ijc5n210o8bbf = { + "limits": { + "event_topics": number; + "memory_pages": number; + "subject_len": number; + "payload_len": number; + "runtime_memory": number; + "validator_runtime_memory": number; + "event_ref_time": bigint; + }; + "instruction_weights": number; +}; +export type I3m5sq54sjdlso = {}; +export type Iekve0i6djpd9f = AnonymousEnum<{ + /** + * Make some on-chain remark. + * + * Can be executed by every `origin`. + */ + "remark": Anonymize; + /** + * Set the number of pages in the WebAssembly environment's heap. + */ + "set_heap_pages": Anonymize; + /** + * Set the new runtime code. + */ + "set_code": Anonymize; + /** + * Set the new runtime code without doing any checks of the given `code`. + * + * Note that runtime upgrades will not run if this is called with a not-increasing spec + * version! + */ + "set_code_without_checks": Anonymize; + /** + * Set some items of storage. + */ + "set_storage": Anonymize; + /** + * Kill some items from storage. + */ + "kill_storage": Anonymize; + /** + * Kill all storage items with a key that starts with the given prefix. + * + * **NOTE:** We rely on the Root origin to provide us the number of subkeys under + * the prefix we are removing to accurately calculate the weight of this function. + */ + "kill_prefix": Anonymize; + /** + * Make some on-chain remark and emit event. + */ + "remark_with_event": Anonymize; + /** + * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied + * later. + * + * This call requires Root origin. + */ + "authorize_upgrade": Anonymize; + /** + * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied + * later. + * + * WARNING: This authorizes an upgrade that will take place without any safety checks, for + * example that the spec name remains the same and that the version number increases. Not + * recommended for normal use. Use `authorize_upgrade` instead. + * + * This call requires Root origin. + */ + "authorize_upgrade_without_checks": Anonymize; + /** + * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized. + * + * If the authorization required a version check, this call will ensure the spec name + * remains unchanged and that the spec version has increased. + * + * Depending on the runtime's `OnSetCode` configuration, this function may directly apply + * the new `code` in the same block or attempt to schedule the upgrade. + * + * All origins are allowed. + */ + "apply_authorized_upgrade": Anonymize; +}>; +export type I8ofcg5rbj0g2c = { + "remark": Binary; +}; +export type I4adgbll7gku4i = { + "pages": bigint; +}; +export type I6pjjpfvhvcfru = { + "code": Binary; +}; +export type I9pj91mj79qekl = { + "items": Array>; +}; +export type I39uah9nss64h9 = { + "keys": Anonymize; +}; +export type Itom7fk49o0c9 = Array; +export type Ik64dknsq7k08 = { + "prefix": Binary; + "subkeys": number; +}; +export type Ib51vk42m1po4n = { + "code_hash": FixedSizeBinary<32>; +}; +export type I7d75gqfg6jh9c = AnonymousEnum<{ + /** + * Set the current time. + * + * This call should be invoked exactly once per block. It will panic at the finalization + * phase, if this call hasn't been invoked by that time. + * + * The timestamp should be greater than the previous one by the amount specified by + * [`Config::MinimumPeriod`]. + * + * The dispatch origin for this call must be _None_. + * + * This dispatch class is _Mandatory_ to ensure it gets executed in the block. Be aware + * that changing the complexity of this call could result exhausting the resources in a + * block to execute any other calls. + * + * ## Complexity + * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`) + * - 1 storage read and 1 storage mutation (codec `O(1)` because of `DidUpdate::take` in + * `on_finalize`) + * - 1 event handler `on_timestamp_set`. Must be `O(1)`. + */ + "set": Anonymize; +}>; +export type Idcr6u6361oad9 = { + "now": bigint; +}; +export type Ibck9ekr2i96uj = AnonymousEnum<{ + /** + * Report voter equivocation/misbehavior. This method will verify the + * equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence + * will be reported. + */ + "report_equivocation": Anonymize; + /** + * Report voter equivocation/misbehavior. This method will verify the + * equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence + * will be reported. + * + * This extrinsic must be called unsigned and it is expected that only + * block authors will call it (validated in `ValidateUnsigned`), as such + * if the block author is defined it will be defined as the equivocation + * reporter. + */ + "report_equivocation_unsigned": Anonymize; + /** + * Note that the current authority set of the GRANDPA finality gadget has stalled. + * + * This will trigger a forced authority set change at the beginning of the next session, to + * be enacted `delay` blocks after that. The `delay` should be high enough to safely assume + * that the block signalling the forced change will not be re-orged e.g. 1000 blocks. + * The block production rate (which may be slowed down because of finality lagging) should + * be taken into account when choosing the `delay`. The GRANDPA voters based on the new + * authority will start voting on top of `best_finalized_block_number` for new finalized + * blocks. `best_finalized_block_number` should be the highest of the latest finalized + * block of all validators of the new authority set. + * + * Only callable by root. + */ + "note_stalled": Anonymize; +}>; +export type I3a5kuu5t5jj3g = { + "equivocation_proof": Anonymize; +}; +export type I9puqgoda8ofk4 = { + "set_id": bigint; + "equivocation": GrandpaEquivocation; +}; +export type GrandpaEquivocation = Enum<{ + "Prevote": { + "round_number": bigint; + "identity": FixedSizeBinary<32>; + "first": [{ + "target_hash": FixedSizeBinary<32>; + "target_number": number; + }, FixedSizeBinary<64>]; + "second": [{ + "target_hash": FixedSizeBinary<32>; + "target_number": number; + }, FixedSizeBinary<64>]; + }; + "Precommit": { + "round_number": bigint; + "identity": FixedSizeBinary<32>; + "first": [{ + "target_hash": FixedSizeBinary<32>; + "target_number": number; + }, FixedSizeBinary<64>]; + "second": [{ + "target_hash": FixedSizeBinary<32>; + "target_number": number; + }, FixedSizeBinary<64>]; + }; +}>; +export declare const GrandpaEquivocation: GetEnum; +export type I2hviml3snvhhn = { + "delay": number; + "best_finalized_block_number": number; +}; +export type I9svldsp29mh87 = AnonymousEnum<{ + /** + * Transfer some liquid free balance to another account. + * + * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver. + * If the sender's account is below the existential deposit as a result + * of the transfer, the account will be reaped. + * + * The dispatch origin for this call must be `Signed` by the transactor. + */ + "transfer_allow_death": Anonymize; + /** + * Exactly as `transfer_allow_death`, except the origin must be root and the source account + * may be specified. + */ + "force_transfer": Anonymize; + /** + * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not + * kill the origin account. + * + * 99% of the time you want [`transfer_allow_death`] instead. + * + * [`transfer_allow_death`]: struct.Pallet.html#method.transfer + */ + "transfer_keep_alive": Anonymize; + /** + * Transfer the entire transferable balance from the caller account. + * + * NOTE: This function only attempts to transfer _transferable_ balances. This means that + * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be + * transferred by this function. To ensure that this function results in a killed account, + * you might need to prepare the account by removing any reference counters, storage + * deposits, etc... + * + * The dispatch origin of this call must be Signed. + * + * - `dest`: The recipient of the transfer. + * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all + * of the funds the account has, causing the sender account to be killed (false), or + * transfer everything except at least the existential deposit, which will guarantee to + * keep the sender account alive (true). + */ + "transfer_all": Anonymize; + /** + * Unreserve some balance from a user by force. + * + * Can only be called by ROOT. + */ + "force_unreserve": Anonymize; + /** + * Upgrade a specified account. + * + * - `origin`: Must be `Signed`. + * - `who`: The account to be upgraded. + * + * This will waive the transaction fee if at least all but 10% of the accounts needed to + * be upgraded. (We let some not have to be upgraded just in order to allow for the + * possibility of churn). + */ + "upgrade_accounts": Anonymize; + /** + * Set the regular balance of a given account. + * + * The dispatch origin for this call is `root`. + */ + "force_set_balance": Anonymize; + /** + * Adjust the total issuance in a saturating way. + * + * Can only be called by root and always needs a positive `delta`. + * + * # Example + */ + "force_adjust_total_issuance": Anonymize; + /** + * Burn the specified liquid free balance from the origin account. + * + * If the origin's account ends up below the existential deposit as a result + * of the burn and `keep_alive` is false, the account will be reaped. + * + * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible, + * this `burn` operation will reduce total issuance by the amount _burned_. + */ + "burn": Anonymize; +}>; +export type I4ktuaksf5i1gk = { + "dest": MultiAddress; + "value": bigint; +}; +export type MultiAddress = Enum<{ + "Id": SS58String; + "Index": undefined; + "Raw": Binary; + "Address32": FixedSizeBinary<32>; + "Address20": FixedSizeBinary<20>; +}>; +export declare const MultiAddress: GetEnum; +export type I9bqtpv2ii35mp = { + "source": MultiAddress; + "dest": MultiAddress; + "value": bigint; +}; +export type I9j7pagd6d4bda = { + "dest": MultiAddress; + "keep_alive": boolean; +}; +export type I2h9pmio37r7fb = { + "who": MultiAddress; + "amount": bigint; +}; +export type Ibmr18suc9ikh9 = { + "who": Anonymize; +}; +export type I9iq22t0burs89 = { + "who": MultiAddress; + "new_free": bigint; +}; +export type I5u8olqbbvfnvf = { + "direction": BalancesAdjustmentDirection; + "delta": bigint; +}; +export type BalancesAdjustmentDirection = Enum<{ + "Increase": undefined; + "Decrease": undefined; +}>; +export declare const BalancesAdjustmentDirection: GetEnum; +export type I5utcetro501ir = { + "value": bigint; + "keep_alive": boolean; +}; +export type I70bgb5j7tau9l = AnonymousEnum<{ + /** + * --- Sets the caller weights for the incentive mechanism. The call can be + * made from the hotkey account so is potentially insecure, however, the damage + * of changing weights is minimal if caught early. This function includes all the + * checks that the passed weights meet the requirements. Stored as u16s they represent + * rational values in the range [0,1] which sum to 1 and can be interpreted as + * probabilities. The specific weights determine how inflation propagates outward + * from this peer. + * + * Note: The 16 bit integers weights should represent 1.0 as the max u16. + * However, the function normalizes all integers to u16_max anyway. This means that if the sum of all + * elements is larger or smaller than the amount of elements * u16_max, all elements + * will be corrected for this deviation. + * + * # Args: + * * `origin`: (Origin): + * - The caller, a hotkey who wishes to set their weights. + * + * * `netuid` (u16): + * - The network uid we are setting these weights on. + * + * * `dests` (Vec): + * - The edge endpoint for the weight, i.e. j for w_ij. + * + * * 'weights' (Vec): + * - The u16 integer encoded weights. Interpreted as rational + * values in the range [0,1]. They must sum to in32::MAX. + * + * * 'version_key' ( u64 ): + * - The network version key to check if the validator is up to date. + * + * # Event: + * * WeightsSet; + * - On successfully setting the weights on chain. + * + * # Raises: + * * 'MechanismDoesNotExist': + * - Attempting to set weights on a non-existent network. + * + * * 'NotRegistered': + * - Attempting to set weights from a non registered account. + * + * * 'WeightVecNotEqualSize': + * - Attempting to set weights with uids not of same length. + * + * * 'DuplicateUids': + * - Attempting to set weights with duplicate uids. + * + * * 'UidsLengthExceedUidsInSubNet': + * - Attempting to set weights above the max allowed uids. + * + * * 'UidVecContainInvalidOne': + * - Attempting to set weights with invalid uids. + * + * * 'WeightVecLengthIsLow': + * - Attempting to set weights with fewer weights than min. + * + * * 'MaxWeightExceeded': + * - Attempting to set weights with max value exceeding limit. + */ + "set_weights": Anonymize; + /** + * --- Sets the caller weights for the incentive mechanism for mechanisms. The call + * can be made from the hotkey account so is potentially insecure, however, the damage + * of changing weights is minimal if caught early. This function includes all the + * checks that the passed weights meet the requirements. Stored as u16s they represent + * rational values in the range [0,1] which sum to 1 and can be interpreted as + * probabilities. The specific weights determine how inflation propagates outward + * from this peer. + * + * Note: The 16 bit integers weights should represent 1.0 as the max u16. + * However, the function normalizes all integers to u16_max anyway. This means that if the sum of all + * elements is larger or smaller than the amount of elements * u16_max, all elements + * will be corrected for this deviation. + * + * # Args: + * * `origin`: (Origin): + * - The caller, a hotkey who wishes to set their weights. + * + * * `netuid` (u16): + * - The network uid we are setting these weights on. + * + * * `mecid` (`u8`): + * - The u8 mechnism identifier. + * + * * `dests` (Vec): + * - The edge endpoint for the weight, i.e. j for w_ij. + * + * * 'weights' (Vec): + * - The u16 integer encoded weights. Interpreted as rational + * values in the range [0,1]. They must sum to in32::MAX. + * + * * 'version_key' ( u64 ): + * - The network version key to check if the validator is up to date. + * + * # Event: + * * WeightsSet; + * - On successfully setting the weights on chain. + * + * # Raises: + * * 'MechanismDoesNotExist': + * - Attempting to set weights on a non-existent network. + * + * * 'NotRegistered': + * - Attempting to set weights from a non registered account. + * + * * 'WeightVecNotEqualSize': + * - Attempting to set weights with uids not of same length. + * + * * 'DuplicateUids': + * - Attempting to set weights with duplicate uids. + * + * * 'UidsLengthExceedUidsInSubNet': + * - Attempting to set weights above the max allowed uids. + * + * * 'UidVecContainInvalidOne': + * - Attempting to set weights with invalid uids. + * + * * 'WeightVecLengthIsLow': + * - Attempting to set weights with fewer weights than min. + * + * * 'MaxWeightExceeded': + * - Attempting to set weights with max value exceeding limit. + */ + "set_mechanism_weights": Anonymize; + /** + * --- Allows a hotkey to set weights for multiple netuids as a batch. + * + * # Args: + * * `origin`: (Origin): + * - The caller, a hotkey who wishes to set their weights. + * + * * `netuids` (Vec>): + * - The network uids we are setting these weights on. + * + * * `weights` (Vec, Compact)>): + * - The weights to set for each network. [(uid, weight), ...] + * + * * `version_keys` (Vec>): + * - The network version keys to check if the validator is up to date. + * + * # Event: + * * WeightsSet; + * - On successfully setting the weights on chain. + * * BatchWeightsCompleted; + * - On success of the batch. + * * BatchCompletedWithErrors; + * - On failure of any of the weights in the batch. + * * BatchWeightItemFailed; + * - On failure for each failed item in the batch. + * + */ + "batch_set_weights": Anonymize; + /** + * ---- Used to commit a hash of your weight values to later be revealed. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The signature of the committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `commit_hash` (`H256`): + * - The hash representing the committed weights. + * + * # Raises: + * * `CommitRevealDisabled`: + * - Attempting to commit when the commit-reveal mechanism is disabled. + * + * * `TooManyUnrevealedCommits`: + * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. + * + */ + "commit_weights": Anonymize; + /** + * ---- Used to commit a hash of your weight values to later be revealed for mechanisms. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The signature of the committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `mecid` (`u8`): + * - The u8 mechanism identifier. + * + * * `commit_hash` (`H256`): + * - The hash representing the committed weights. + * + * # Raises: + * * `CommitRevealDisabled`: + * - Attempting to commit when the commit-reveal mechanism is disabled. + * + * * `TooManyUnrevealedCommits`: + * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. + * + */ + "commit_mechanism_weights": Anonymize; + /** + * --- Allows a hotkey to commit weight hashes for multiple netuids as a batch. + * + * # Args: + * * `origin`: (Origin): + * - The caller, a hotkey who wishes to set their weights. + * + * * `netuids` (Vec>): + * - The network uids we are setting these weights on. + * + * * `commit_hashes` (Vec): + * - The commit hashes to commit. + * + * # Event: + * * WeightsSet; + * - On successfully setting the weights on chain. + * * BatchWeightsCompleted; + * - On success of the batch. + * * BatchCompletedWithErrors; + * - On failure of any of the weights in the batch. + * * BatchWeightItemFailed; + * - On failure for each failed item in the batch. + * + */ + "batch_commit_weights": Anonymize; + /** + * ---- Used to reveal the weights for a previously committed hash. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The signature of the revealing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `uids` (`Vec`): + * - The uids for the weights being revealed. + * + * * `values` (`Vec`): + * - The values of the weights being revealed. + * + * * `salt` (`Vec`): + * - The salt used to generate the commit hash. + * + * * `version_key` (`u64`): + * - The network version key. + * + * # Raises: + * * `CommitRevealDisabled`: + * - Attempting to reveal weights when the commit-reveal mechanism is disabled. + * + * * `NoWeightsCommitFound`: + * - Attempting to reveal weights without an existing commit. + * + * * `ExpiredWeightCommit`: + * - Attempting to reveal a weight commit that has expired. + * + * * `RevealTooEarly`: + * - Attempting to reveal weights outside the valid reveal period. + * + * * `InvalidRevealCommitHashNotMatch`: + * - The revealed hash does not match any committed hash. + * + */ + "reveal_weights": Anonymize; + /** + * ---- Used to reveal the weights for a previously committed hash for mechanisms. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The signature of the revealing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `mecid` (`u8`): + * - The u8 mechanism identifier. + * + * * `uids` (`Vec`): + * - The uids for the weights being revealed. + * + * * `values` (`Vec`): + * - The values of the weights being revealed. + * + * * `salt` (`Vec`): + * - The salt used to generate the commit hash. + * + * * `version_key` (`u64`): + * - The network version key. + * + * # Raises: + * * `CommitRevealDisabled`: + * - Attempting to reveal weights when the commit-reveal mechanism is disabled. + * + * * `NoWeightsCommitFound`: + * - Attempting to reveal weights without an existing commit. + * + * * `ExpiredWeightCommit`: + * - Attempting to reveal a weight commit that has expired. + * + * * `RevealTooEarly`: + * - Attempting to reveal weights outside the valid reveal period. + * + * * `InvalidRevealCommitHashNotMatch`: + * - The revealed hash does not match any committed hash. + * + */ + "reveal_mechanism_weights": Anonymize; + /** + * ---- Used to commit encrypted commit-reveal v3 weight values to later be revealed. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `commit` (`Vec`): + * - The encrypted compressed commit. + * The steps for this are: + * 1. Instantiate [`WeightsTlockPayload`] + * 2. Serialize it using the `parity_scale_codec::Encode` trait + * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] + * to produce a [`TLECiphertext`] type. + * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. + * + * * reveal_round (`u64`): + * - The drand reveal round which will be avaliable during epoch `n+1` from the current + * epoch. + * + * # Raises: + * * `CommitRevealV3Disabled`: + * - Attempting to commit when the commit-reveal mechanism is disabled. + * + * * `TooManyUnrevealedCommits`: + * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. + * + * ---- Used to commit encrypted commit-reveal v3 weight values to later be revealed for mechanisms. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `mecid` (`u8`): + * - The u8 mechanism identifier. + * + * * `commit` (`Vec`): + * - The encrypted compressed commit. + * The steps for this are: + * 1. Instantiate [`WeightsTlockPayload`] + * 2. Serialize it using the `parity_scale_codec::Encode` trait + * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] + * to produce a [`TLECiphertext`] type. + * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. + * + * * reveal_round (`u64`): + * - The drand reveal round which will be avaliable during epoch `n+1` from the current + * epoch. + * + * # Raises: + * * `CommitRevealV3Disabled`: + * - Attempting to commit when the commit-reveal mechanism is disabled. + * + * * `TooManyUnrevealedCommits`: + * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. + * + */ + "commit_crv3_mechanism_weights": Anonymize; + /** + * ---- The implementation for batch revealing committed weights. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The signature of the revealing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `uids_list` (`Vec>`): + * - A list of uids for each set of weights being revealed. + * + * * `values_list` (`Vec>`): + * - A list of values for each set of weights being revealed. + * + * * `salts_list` (`Vec>`): + * - A list of salts used to generate the commit hashes. + * + * * `version_keys` (`Vec`): + * - A list of network version keys. + * + * # Raises: + * * `CommitRevealDisabled`: + * - Attempting to reveal weights when the commit-reveal mechanism is disabled. + * + * * `NoWeightsCommitFound`: + * - Attempting to reveal weights without an existing commit. + * + * * `ExpiredWeightCommit`: + * - Attempting to reveal a weight commit that has expired. + * + * * `RevealTooEarly`: + * - Attempting to reveal weights outside the valid reveal period. + * + * * `InvalidRevealCommitHashNotMatch`: + * - The revealed hash does not match any committed hash. + * + * * `InvalidInputLengths`: + * - The input vectors are of mismatched lengths. + */ + "batch_reveal_weights": Anonymize; + /** + * --- Allows delegates to decrease its take value. + * + * # Args: + * * 'origin': (::Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The hotkey we are delegating (must be owned by the coldkey.) + * + * * 'netuid' (u16): + * - Subnet ID to decrease take for + * + * * 'take' (u16): + * - The new stake proportion that this hotkey takes from delegations. + * The new value can be between 0 and 11_796 and should be strictly + * lower than the previous value. It T is the new value (rational number), + * the the parameter is calculated as [65535 * T]. For example, 1% would be + * [0.01 * 65535] = [655.35] = 655 + * + * # Event: + * * TakeDecreased; + * - On successfully setting a decreased take for this hotkey. + * + * # Raises: + * * 'NotRegistered': + * - The hotkey we are delegating is not registered on the network. + * + * * 'NonAssociatedColdKey': + * - The hotkey we are delegating is not owned by the calling coldkey. + * + * * 'DelegateTakeTooLow': + * - The delegate is setting a take which is not lower than the previous. + * + */ + "decrease_take": Anonymize; + /** + * --- Allows delegates to increase its take value. This call is rate-limited. + * + * # Args: + * * 'origin': (::Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The hotkey we are delegating (must be owned by the coldkey.) + * + * * 'take' (u16): + * - The new stake proportion that this hotkey takes from delegations. + * The new value can be between 0 and 11_796 and should be strictly + * greater than the previous value. T is the new value (rational number), + * the the parameter is calculated as [65535 * T]. For example, 1% would be + * [0.01 * 65535] = [655.35] = 655 + * + * # Event: + * * TakeIncreased; + * - On successfully setting a increased take for this hotkey. + * + * # Raises: + * * 'NotRegistered': + * - The hotkey we are delegating is not registered on the network. + * + * * 'NonAssociatedColdKey': + * - The hotkey we are delegating is not owned by the calling coldkey. + * + * * 'DelegateTakeTooHigh': + * - The delegate is setting a take which is not greater than the previous. + * + */ + "increase_take": Anonymize; + /** + * --- Adds stake to a hotkey. The call is made from a coldkey account. + * This delegates stake to the hotkey. + * + * Note: the coldkey account may own the hotkey, in which case they are + * delegating to themselves. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The associated hotkey account. + * + * * 'netuid' (u16): + * - Subnetwork UID + * + * * 'amount_staked' (u64): + * - The amount of stake to be added to the hotkey staking account. + * + * # Event: + * * StakeAdded; + * - On the successfully adding stake to a global account. + * + * # Raises: + * * 'NotEnoughBalanceToStake': + * - Not enough balance on the coldkey to add onto the global account. + * + * * 'NonAssociatedColdKey': + * - The calling coldkey is not associated with this hotkey. + * + * * 'BalanceWithdrawalError': + * - Errors stemming from transaction pallet. + * + */ + "add_stake": Anonymize; + /** + * Remove stake from the staking account. The call must be made + * from the coldkey account attached to the neuron metadata. Only this key + * has permission to make staking and unstaking requests. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The associated hotkey account. + * + * * 'netuid' (u16): + * - Subnetwork UID + * + * * 'amount_unstaked' (u64): + * - The amount of stake to be added to the hotkey staking account. + * + * # Event: + * * StakeRemoved; + * - On the successfully removing stake from the hotkey account. + * + * # Raises: + * * 'NotRegistered': + * - Thrown if the account we are attempting to unstake from is non existent. + * + * * 'NonAssociatedColdKey': + * - Thrown if the coldkey does not own the hotkey we are unstaking from. + * + * * 'NotEnoughStakeToWithdraw': + * - Thrown if there is not enough stake on the hotkey to withdwraw this amount. + * + */ + "remove_stake": Anonymize; + /** + * Serves or updates axon /prometheus information for the neuron associated with the caller. If the caller is + * already registered the metadata is updated. If the caller is not registered this call throws NotRegistered. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller. + * + * * 'netuid' (u16): + * - The u16 network identifier. + * + * * 'version' (u64): + * - The bittensor version identifier. + * + * * 'ip' (u64): + * - The endpoint ip information as a u128 encoded integer. + * + * * 'port' (u16): + * - The endpoint port information as a u16 encoded integer. + * + * * 'ip_type' (u8): + * - The endpoint ip version as a u8, 4 or 6. + * + * * 'protocol' (u8): + * - UDP:1 or TCP:0 + * + * * 'placeholder1' (u8): + * - Placeholder for further extra params. + * + * * 'placeholder2' (u8): + * - Placeholder for further extra params. + * + * # Event: + * * AxonServed; + * - On successfully serving the axon info. + * + * # Raises: + * * 'MechanismDoesNotExist': + * - Attempting to set weights on a non-existent network. + * + * * 'NotRegistered': + * - Attempting to set weights from a non registered account. + * + * * 'InvalidIpType': + * - The ip type is not 4 or 6. + * + * * 'InvalidIpAddress': + * - The numerically encoded ip address does not resolve to a proper ip. + * + * * 'ServingRateLimitExceeded': + * - Attempting to set prometheus information withing the rate limit min. + * + */ + "serve_axon": Anonymize; + /** + * Same as `serve_axon` but takes a certificate as an extra optional argument. + * Serves or updates axon /prometheus information for the neuron associated with the caller. If the caller is + * already registered the metadata is updated. If the caller is not registered this call throws NotRegistered. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller. + * + * * 'netuid' (u16): + * - The u16 network identifier. + * + * * 'version' (u64): + * - The bittensor version identifier. + * + * * 'ip' (u64): + * - The endpoint ip information as a u128 encoded integer. + * + * * 'port' (u16): + * - The endpoint port information as a u16 encoded integer. + * + * * 'ip_type' (u8): + * - The endpoint ip version as a u8, 4 or 6. + * + * * 'protocol' (u8): + * - UDP:1 or TCP:0 + * + * * 'placeholder1' (u8): + * - Placeholder for further extra params. + * + * * 'placeholder2' (u8): + * - Placeholder for further extra params. + * + * * 'certificate' (Vec): + * - TLS certificate for inter neuron communitation. + * + * # Event: + * * AxonServed; + * - On successfully serving the axon info. + * + * # Raises: + * * 'MechanismDoesNotExist': + * - Attempting to set weights on a non-existent network. + * + * * 'NotRegistered': + * - Attempting to set weights from a non registered account. + * + * * 'InvalidIpType': + * - The ip type is not 4 or 6. + * + * * 'InvalidIpAddress': + * - The numerically encoded ip address does not resolve to a proper ip. + * + * * 'ServingRateLimitExceeded': + * - Attempting to set prometheus information withing the rate limit min. + * + */ + "serve_axon_tls": Anonymize; + /** + * ---- Set prometheus information for the neuron. + * # Args: + * * 'origin': (Origin): + * - The signature of the calling hotkey. + * + * * 'netuid' (u16): + * - The u16 network identifier. + * + * * 'version' (u16): + * - The bittensor version identifier. + * + * * 'ip' (u128): + * - The prometheus ip information as a u128 encoded integer. + * + * * 'port' (u16): + * - The prometheus port information as a u16 encoded integer. + * + * * 'ip_type' (u8): + * - The ip type v4 or v6. + * + */ + "serve_prometheus": Anonymize; + /** + * ---- Registers a new neuron to the subnetwork. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the calling hotkey. + * + * * 'netuid' (u16): + * - The u16 network identifier. + * + * * 'block_number' ( u64 ): + * - Block hash used to prove work done. + * + * * 'nonce' ( u64 ): + * - Positive integer nonce used in POW. + * + * * 'work' ( Vec ): + * - Vector encoded bytes representing work done. + * + * * 'hotkey' ( T::AccountId ): + * - Hotkey to be registered to the network. + * + * * 'coldkey' ( T::AccountId ): + * - Associated coldkey account. + * + * # Event: + * * NeuronRegistered; + * - On successfully registering a uid to a neuron slot on a subnetwork. + * + * # Raises: + * * 'MechanismDoesNotExist': + * - Attempting to register to a non existent network. + * + * * 'TooManyRegistrationsThisBlock': + * - This registration exceeds the total allowed on this network this block. + * + * * 'HotKeyAlreadyRegisteredInSubNet': + * - The hotkey is already registered on this network. + * + * * 'InvalidWorkBlock': + * - The work has been performed on a stale, future, or non existent block. + * + * * 'InvalidDifficulty': + * - The work does not match the difficulty. + * + * * 'InvalidSeal': + * - The seal is incorrect. + * + */ + "register": Anonymize; + /** + * Register the hotkey to root network + */ + "root_register": Anonymize; + /** + * User register a new subnetwork via burning token + */ + "burned_register": Anonymize; + /** + * The extrinsic for user to change its hotkey in subnet or all subnets. + */ + "swap_hotkey": Anonymize; + /** + * Performs an arbitrary coldkey swap for any coldkey. + * + * Only callable by root as it doesn't require an announcement and can be used to swap any coldkey. + */ + "swap_coldkey": Anonymize; + /** + * Sets the childkey take for a given hotkey. + * + * This function allows a coldkey to set the childkey take for a given hotkey. + * The childkey take determines the proportion of stake that the hotkey keeps for itself + * when distributing stake to its children. + * + * # Arguments: + * * `origin` (::RuntimeOrigin): + * - The signature of the calling coldkey. Setting childkey take can only be done by the coldkey. + * + * * `hotkey` (T::AccountId): + * - The hotkey for which the childkey take will be set. + * + * * `take` (u16): + * - The new childkey take value. This is a percentage represented as a value between 0 and 10000, + * where 10000 represents 100%. + * + * # Events: + * * `ChildkeyTakeSet`: + * - On successfully setting the childkey take for a hotkey. + * + * # Errors: + * * `NonAssociatedColdKey`: + * - The coldkey does not own the hotkey. + * * `InvalidChildkeyTake`: + * - The provided take value is invalid (greater than the maximum allowed take). + * * `TxChildkeyTakeRateLimitExceeded`: + * - The rate limit for changing childkey take has been exceeded. + * + */ + "set_childkey_take": Anonymize; + /** + * Sets the transaction rate limit for changing childkey take. + * + * This function can only be called by the root origin. + * + * # Arguments: + * * `origin` - The origin of the call, must be root. + * * `tx_rate_limit` - The new rate limit in blocks. + * + * # Errors: + * * `BadOrigin` - If the origin is not root. + * + */ + "sudo_set_tx_childkey_take_rate_limit": Anonymize; + /** + * Sets the minimum allowed childkey take. + * + * This function can only be called by the root origin. + * + * # Arguments: + * * `origin` - The origin of the call, must be root. + * * `take` - The new minimum childkey take value. + * + * # Errors: + * * `BadOrigin` - If the origin is not root. + * + */ + "sudo_set_min_childkey_take": Anonymize; + /** + * Sets the maximum allowed childkey take. + * + * This function can only be called by the root origin. + * + * # Arguments: + * * `origin` - The origin of the call, must be root. + * * `take` - The new maximum childkey take value. + * + * # Errors: + * * `BadOrigin` - If the origin is not root. + * + */ + "sudo_set_max_childkey_take": Anonymize; + /** + * User register a new subnetwork + */ + "register_network": Anonymize; + /** + * Facility extrinsic for user to get taken from faucet + * It is only available when pow-faucet feature enabled + * Just deployed in testnet and devnet for testing purpose + */ + "faucet": Anonymize; + /** + * Remove a user's subnetwork + * The caller must be the owner of the network + */ + "dissolve_network": Anonymize; + /** + * Set a single child for a given hotkey on a specified network. + * + * This function allows a coldkey to set a single child for a given hotkey on a specified network. + * The proportion of the hotkey's stake to be allocated to the child is also specified. + * + * # Arguments: + * * `origin` (::RuntimeOrigin): + * - The signature of the calling coldkey. Setting a hotkey child can only be done by the coldkey. + * + * * `hotkey` (T::AccountId): + * - The hotkey which will be assigned the child. + * + * * `child` (T::AccountId): + * - The child which will be assigned to the hotkey. + * + * * `netuid` (u16): + * - The u16 network identifier where the childkey will exist. + * + * * `proportion` (u64): + * - Proportion of the hotkey's stake to be given to the child, the value must be u64 normalized. + * + * # Events: + * * `ChildAddedSingular`: + * - On successfully registering a child to a hotkey. + * + * # Errors: + * * `MechanismDoesNotExist`: + * - Attempting to register to a non-existent network. + * * `RegistrationNotPermittedOnRootSubnet`: + * - Attempting to register a child on the root network. + * * `NonAssociatedColdKey`: + * - The coldkey does not own the hotkey or the child is the same as the hotkey. + * * `HotKeyAccountNotExists`: + * - The hotkey account does not exist. + * + * # Detailed Explanation of Checks: + * 1. **Signature Verification**: Ensures that the caller has signed the transaction, verifying the coldkey. + * 2. **Root Network Check**: Ensures that the delegation is not on the root network, as child hotkeys are not valid on the root. + * 3. **Network Existence Check**: Ensures that the specified network exists. + * 4. **Ownership Verification**: Ensures that the coldkey owns the hotkey. + * 5. **Hotkey Account Existence Check**: Ensures that the hotkey account already exists. + * 6. **Child-Hotkey Distinction**: Ensures that the child is not the same as the hotkey. + * 7. **Old Children Cleanup**: Removes the hotkey from the parent list of its old children. + * 8. **New Children Assignment**: Assigns the new child to the hotkey and updates the parent list for the new child. + */ + "set_children": Anonymize; + /** + * Schedules a coldkey swap operation to be executed at a future block. + * + * WARNING: This function is deprecated, please migrate to `announce_coldkey_swap`/`coldkey_swap` + */ + "schedule_swap_coldkey": Anonymize; + /** + * ---- Set prometheus information for the neuron. + * # Args: + * * 'origin': (Origin): + * - The signature of the calling hotkey. + * + * * 'netuid' (u16): + * - The u16 network identifier. + * + * * 'version' (u16): + * - The bittensor version identifier. + * + * * 'ip' (u128): + * - The prometheus ip information as a u128 encoded integer. + * + * * 'port' (u16): + * - The prometheus port information as a u16 encoded integer. + * + * * 'ip_type' (u8): + * - The ip type v4 or v6. + * + */ + "set_identity": Anonymize; + /** + * ---- Set the identity information for a subnet. + * # Args: + * * `origin` - (::Origin): + * - The signature of the calling coldkey, which must be the owner of the subnet. + * + * * `netuid` (u16): + * - The unique network identifier of the subnet. + * + * * `subnet_name` (Vec): + * - The name of the subnet. + * + * * `github_repo` (Vec): + * - The GitHub repository associated with the subnet identity. + * + * * `subnet_contact` (Vec): + * - The contact information for the subnet. + */ + "set_subnet_identity": Anonymize; + /** + * User register a new subnetwork + */ + "register_network_with_identity": Anonymize; + /** + * ---- The implementation for the extrinsic unstake_all: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey. + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `hotkey` (T::AccountId): + * - The associated hotkey account. + * + * # Event: + * * StakeRemoved; + * - On the successfully removing stake from the hotkey account. + * + * # Raises: + * * `NotRegistered`: + * - Thrown if the account we are attempting to unstake from is non existent. + * + * * `NonAssociatedColdKey`: + * - Thrown if the coldkey does not own the hotkey we are unstaking from. + * + * * `NotEnoughStakeToWithdraw`: + * - Thrown if there is not enough stake on the hotkey to withdraw this amount. + * + * * `TxRateLimitExceeded`: + * - Thrown if key has hit transaction rate limit + */ + "unstake_all": Anonymize; + /** + * ---- The implementation for the extrinsic unstake_all: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey. + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `hotkey` (T::AccountId): + * - The associated hotkey account. + * + * # Event: + * * StakeRemoved; + * - On the successfully removing stake from the hotkey account. + * + * # Raises: + * * `NotRegistered`: + * - Thrown if the account we are attempting to unstake from is non existent. + * + * * `NonAssociatedColdKey`: + * - Thrown if the coldkey does not own the hotkey we are unstaking from. + * + * * `NotEnoughStakeToWithdraw`: + * - Thrown if there is not enough stake on the hotkey to withdraw this amount. + * + * * `TxRateLimitExceeded`: + * - Thrown if key has hit transaction rate limit + */ + "unstake_all_alpha": Anonymize; + /** + * ---- The implementation for the extrinsic move_stake: Moves specified amount of stake from a hotkey to another across subnets. + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `origin_hotkey` (T::AccountId): + * - The hotkey account to move stake from. + * + * * `destination_hotkey` (T::AccountId): + * - The hotkey account to move stake to. + * + * * `origin_netuid` (T::AccountId): + * - The subnet ID to move stake from. + * + * * `destination_netuid` (T::AccountId): + * - The subnet ID to move stake to. + * + * * `alpha_amount` (T::AccountId): + * - The alpha stake amount to move. + * + */ + "move_stake": Anonymize; + /** + * Transfers a specified amount of stake from one coldkey to another, optionally across subnets, + * while keeping the same hotkey. + * + * # Arguments + * * `origin` - The origin of the transaction, which must be signed by the `origin_coldkey`. + * * `destination_coldkey` - The coldkey to which the stake is transferred. + * * `hotkey` - The hotkey associated with the stake. + * * `origin_netuid` - The network/subnet ID to move stake from. + * * `destination_netuid` - The network/subnet ID to move stake to (for cross-subnet transfer). + * * `alpha_amount` - The amount of stake to transfer. + * + * # Errors + * Returns an error if: + * * The origin is not signed by the correct coldkey. + * * Either subnet does not exist. + * * The hotkey does not exist. + * * There is insufficient stake on `(origin_coldkey, hotkey, origin_netuid)`. + * * The transfer amount is below the minimum stake requirement. + * + * # Events + * May emit a `StakeTransferred` event on success. + */ + "transfer_stake": Anonymize; + /** + * Swaps a specified amount of stake from one subnet to another, while keeping the same coldkey and hotkey. + * + * # Arguments + * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. + * * `hotkey` - The hotkey whose stake is being swapped. + * * `origin_netuid` - The network/subnet ID from which stake is removed. + * * `destination_netuid` - The network/subnet ID to which stake is added. + * * `alpha_amount` - The amount of stake to swap. + * + * # Errors + * Returns an error if: + * * The transaction is not signed by the correct coldkey (i.e., `coldkey_owns_hotkey` fails). + * * Either `origin_netuid` or `destination_netuid` does not exist. + * * The hotkey does not exist. + * * There is insufficient stake on `(coldkey, hotkey, origin_netuid)`. + * * The swap amount is below the minimum stake requirement. + * + * # Events + * May emit a `StakeSwapped` event on success. + */ + "swap_stake": Anonymize; + /** + * --- Adds stake to a hotkey on a subnet with a price limit. + * This extrinsic allows to specify the limit price for alpha token + * at which or better (lower) the staking should execute. + * + * In case if slippage occurs and the price shall move beyond the limit + * price, the staking order may execute only partially or not execute + * at all. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The associated hotkey account. + * + * * 'netuid' (u16): + * - Subnetwork UID + * + * * 'amount_staked' (u64): + * - The amount of stake to be added to the hotkey staking account. + * + * * 'limit_price' (u64): + * - The limit price expressed in units of RAO per one Alpha. + * + * * 'allow_partial' (bool): + * - Allows partial execution of the amount. If set to false, this becomes + * fill or kill type or order. + * + * # Event: + * * StakeAdded; + * - On the successfully adding stake to a global account. + * + * # Raises: + * * 'NotEnoughBalanceToStake': + * - Not enough balance on the coldkey to add onto the global account. + * + * * 'NonAssociatedColdKey': + * - The calling coldkey is not associated with this hotkey. + * + * * 'BalanceWithdrawalError': + * - Errors stemming from transaction pallet. + * + */ + "add_stake_limit": Anonymize; + /** + * --- Removes stake from a hotkey on a subnet with a price limit. + * This extrinsic allows to specify the limit price for alpha token + * at which or better (higher) the staking should execute. + * + * In case if slippage occurs and the price shall move beyond the limit + * price, the staking order may execute only partially or not execute + * at all. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The associated hotkey account. + * + * * 'netuid' (u16): + * - Subnetwork UID + * + * * 'amount_unstaked' (u64): + * - The amount of stake to be added to the hotkey staking account. + * + * * 'limit_price' (u64): + * - The limit price expressed in units of RAO per one Alpha. + * + * * 'allow_partial' (bool): + * - Allows partial execution of the amount. If set to false, this becomes + * fill or kill type or order. + * + * # Event: + * * StakeRemoved; + * - On the successfully removing stake from the hotkey account. + * + * # Raises: + * * 'NotRegistered': + * - Thrown if the account we are attempting to unstake from is non existent. + * + * * 'NonAssociatedColdKey': + * - Thrown if the coldkey does not own the hotkey we are unstaking from. + * + * * 'NotEnoughStakeToWithdraw': + * - Thrown if there is not enough stake on the hotkey to withdwraw this amount. + * + */ + "remove_stake_limit": Anonymize; + /** + * Swaps a specified amount of stake from one subnet to another, while keeping the same coldkey and hotkey. + * + * # Arguments + * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. + * * `hotkey` - The hotkey whose stake is being swapped. + * * `origin_netuid` - The network/subnet ID from which stake is removed. + * * `destination_netuid` - The network/subnet ID to which stake is added. + * * `alpha_amount` - The amount of stake to swap. + * * `limit_price` - The limit price expressed in units of RAO per one Alpha. + * * `allow_partial` - Allows partial execution of the amount. If set to false, this becomes fill or kill type or order. + * + * # Errors + * Returns an error if: + * * The transaction is not signed by the correct coldkey (i.e., `coldkey_owns_hotkey` fails). + * * Either `origin_netuid` or `destination_netuid` does not exist. + * * The hotkey does not exist. + * * There is insufficient stake on `(coldkey, hotkey, origin_netuid)`. + * * The swap amount is below the minimum stake requirement. + * + * # Events + * May emit a `StakeSwapped` event on success. + */ + "swap_stake_limit": Anonymize; + /** + * Attempts to associate a hotkey with a coldkey. + * + * # Arguments + * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. + * * `hotkey` - The hotkey to associate with the coldkey. + * + * # Note + * Will charge based on the weight even if the hotkey is already associated with a coldkey. + */ + "try_associate_hotkey": Anonymize; + /** + * Initiates a call on a subnet. + * + * # Arguments + * * `origin` - The origin of the call, which must be signed by the subnet owner. + * * `netuid` - The unique identifier of the subnet on which the call is being initiated. + * + * # Events + * Emits a `FirstEmissionBlockNumberSet` event on success. + */ + "start_call": Anonymize; + /** + * Attempts to associate a hotkey with an EVM key. + * + * The signature will be checked to see if the recovered public key matches the `evm_key` provided. + * + * The EVM key is expected to sign the message according to this formula to produce the signature: + * ```text + * keccak_256(hotkey ++ keccak_256(block_number)) + * ``` + * + * # Arguments + * * `origin` - The origin of the transaction, which must be signed by the `hotkey`. + * * `netuid` - The netuid that the `hotkey` belongs to. + * * `evm_key` - The EVM key to associate with the `hotkey`. + * * `block_number` - The block number used in the `signature`. + * * `signature` - A signed message by the `evm_key` containing the `hotkey` and the hashed `block_number`. + * + * # Errors + * Returns an error if: + * * The transaction is not signed. + * * The hotkey does not belong to the subnet identified by the netuid. + * * The EVM key cannot be recovered from the signature. + * * The EVM key recovered from the signature does not match the given EVM key. + * + * # Events + * May emit a `EvmKeyAssociated` event on success + */ + "associate_evm_key": Anonymize; + /** + * Recycles alpha from a cold/hot key pair, reducing AlphaOut on a subnet + * + * # Arguments + * * `origin` - The origin of the call (must be signed by the coldkey) + * * `hotkey` - The hotkey account + * * `amount` - The amount of alpha to recycle + * * `netuid` - The subnet ID + * + * # Events + * Emits a `TokensRecycled` event on success. + */ + "recycle_alpha": Anonymize; + /** + * Burns alpha from a cold/hot key pair without reducing `AlphaOut` + * + * # Arguments + * * `origin` - The origin of the call (must be signed by the coldkey) + * * `hotkey` - The hotkey account + * * `amount` - The amount of alpha to burn + * * `netuid` - The subnet ID + * + * # Events + * Emits a `TokensBurned` event on success. + */ + "burn_alpha": Anonymize; + /** + * Sets the pending childkey cooldown (in blocks). Root only. + */ + "set_pending_childkey_cooldown": Anonymize; + /** + * Removes all stake from a hotkey on a subnet with a price limit. + * This extrinsic allows to specify the limit price for alpha token + * at which or better (higher) the staking should execute. + * Without limit_price it remove all the stake similar to `remove_stake` extrinsic + */ + "remove_stake_full_limit": Anonymize; + /** + * Register a new leased network. + * + * The crowdloan's contributions are used to compute the share of the emissions that the contributors + * will receive as dividends. + * + * The leftover cap is refunded to the contributors and the beneficiary. + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `emissions_share` (Percent): + * - The share of the emissions that the contributors will receive as dividends. + * + * * `end_block` (Option>): + * - The block at which the lease will end. If not defined, the lease is perpetual. + */ + "register_leased_network": Anonymize; + /** + * Terminate a lease. + * + * The beneficiary can terminate the lease after the end block has passed and get the subnet ownership. + * The subnet is transferred to the beneficiary and the lease is removed from storage. + * + * **The hotkey must be owned by the beneficiary coldkey.** + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `lease_id` (LeaseId): + * - The ID of the lease to terminate. + * + * * `hotkey` (T::AccountId): + * - The hotkey of the beneficiary to mark as subnet owner hotkey. + */ + "terminate_lease": Anonymize; + /** + * Updates the symbol for a subnet. + * + * # Arguments + * * `origin` - The origin of the call, which must be the subnet owner or root. + * * `netuid` - The unique identifier of the subnet on which the symbol is being set. + * * `symbol` - The symbol to set for the subnet. + * + * # Errors + * Returns an error if: + * * The transaction is not signed by the subnet owner. + * * The symbol does not exist. + * * The symbol is already in use by another subnet. + * + * # Events + * Emits a `SymbolUpdated` event on success. + */ + "update_symbol": Anonymize; + /** + * ---- Used to commit timelock encrypted commit-reveal weight values to later be revealed. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `commit` (`Vec`): + * - The encrypted compressed commit. + * The steps for this are: + * 1. Instantiate [`WeightsTlockPayload`] + * 2. Serialize it using the `parity_scale_codec::Encode` trait + * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] + * to produce a [`TLECiphertext`] type. + * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. + * + * * reveal_round (`u64`): + * - The drand reveal round which will be avaliable during epoch `n+1` from the current + * epoch. + * + * * commit_reveal_version (`u16`): + * - The client (bittensor-drand) version + */ + "commit_timelocked_weights": Anonymize; + /** + * Set the autostake destination hotkey for a coldkey. + * + * The caller selects a hotkey where all future rewards + * will be automatically staked. + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `hotkey` (T::AccountId): + * - The hotkey account to designate as the autostake destination. + */ + "set_coldkey_auto_stake_hotkey": Anonymize; + /** + * ---- Used to commit timelock encrypted commit-reveal weight values to later be revealed for + * a mechanism. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `mecid` (`u8`): + * - The u8 mechanism identifier. + * + * * `commit` (`Vec`): + * - The encrypted compressed commit. + * The steps for this are: + * 1. Instantiate [`WeightsTlockPayload`] + * 2. Serialize it using the `parity_scale_codec::Encode` trait + * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] + * to produce a [`TLECiphertext`] type. + * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. + * + * * reveal_round (`u64`): + * - The drand reveal round which will be avaliable during epoch `n+1` from the current + * epoch. + * + * * commit_reveal_version (`u16`): + * - The client (bittensor-drand) version + */ + "commit_timelocked_mechanism_weights": Anonymize; + /** + * Remove a subnetwork + * The caller must be root + */ + "root_dissolve_network": Anonymize; + /** + * --- Claims the root emissions for a coldkey. + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * # Event: + * * RootClaimed; + * - On the successfully claiming the root emissions for a coldkey. + * + * # Raises: + * + */ + "claim_root": Anonymize; + /** + * --- Sets the root claim type for the coldkey. + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * # Event: + * * RootClaimTypeSet; + * - On the successfully setting the root claim type for the coldkey. + * + */ + "set_root_claim_type": Anonymize; + /** + * --- Sets root claim number (sudo extrinsic). Zero disables auto-claim. + */ + "sudo_set_num_root_claims": Anonymize; + /** + * --- Sets root claim threshold for subnet (sudo or owner origin). + */ + "sudo_set_root_claim_threshold": Anonymize; + /** + * Announces a coldkey swap using BlakeTwo256 hash of the new coldkey. + * + * This is required before the coldkey swap can be performed + * after the delay period. + * + * It can be reannounced after a delay of `ColdkeySwapReannouncementDelay` following + * the first valid execution block of the original announcement. + * + * The dispatch origin of this call must be the original coldkey that made the announcement. + * + * - `new_coldkey_hash`: The hash of the new coldkey using BlakeTwo256. + * + * The `ColdkeySwapAnnounced` event is emitted on successful announcement. + * + */ + "announce_coldkey_swap": Anonymize; + /** + * Performs a coldkey swap if an announcement has been made. + * + * The dispatch origin of this call must be the original coldkey that made the announcement. + * + * - `new_coldkey`: The new coldkey to swap to. The BlakeTwo256 hash of the new coldkey must be + * the same as the announced coldkey hash. + * + * The `ColdkeySwapped` event is emitted on successful swap. + */ + "swap_coldkey_announced": Anonymize; + /** + * Dispute a coldkey swap. + * + * This will prevent any further actions on the coldkey swap + * until triumvirate step in to resolve the issue. + * + * - `coldkey`: The coldkey to dispute the swap for. + * + */ + "dispute_coldkey_swap": undefined; + /** + * Reset a coldkey swap by clearing the announcement and dispute status. + * + * The dispatch origin of this call must be root. + * + * - `coldkey`: The coldkey to reset the swap for. + * + */ + "reset_coldkey_swap": Anonymize; + /** + * Enables voting power tracking for a subnet. + * + * This function can be called by the subnet owner or root. + * When enabled, voting power EMA is updated every epoch for all validators. + * Voting power starts at 0 and increases over epochs. + * + * # Arguments: + * * `origin` - The origin of the call, must be subnet owner or root. + * * `netuid` - The subnet to enable voting power tracking for. + * + * # Errors: + * * `SubnetNotExist` - If the subnet does not exist. + * * `NotSubnetOwner` - If the caller is not the subnet owner or root. + */ + "enable_voting_power_tracking": Anonymize; + /** + * Schedules disabling of voting power tracking for a subnet. + * + * This function can be called by the subnet owner or root. + * Voting power tracking will continue for 14 days (grace period) after this call, + * then automatically disable and clear all VotingPower entries for the subnet. + * + * # Arguments: + * * `origin` - The origin of the call, must be subnet owner or root. + * * `netuid` - The subnet to schedule disabling voting power tracking for. + * + * # Errors: + * * `SubnetNotExist` - If the subnet does not exist. + * * `NotSubnetOwner` - If the caller is not the subnet owner or root. + * * `VotingPowerTrackingNotEnabled` - If voting power tracking is not enabled. + */ + "disable_voting_power_tracking": Anonymize; + /** + * Sets the EMA alpha value for voting power calculation on a subnet. + * + * This function can only be called by root (sudo). + * Higher alpha = faster response to stake changes. + * Alpha is stored as u64 with 18 decimal precision (1.0 = 10^18). + * + * # Arguments: + * * `origin` - The origin of the call, must be root. + * * `netuid` - The subnet to set the alpha for. + * * `alpha` - The new alpha value (u64 with 18 decimal precision). + * + * # Errors: + * * `BadOrigin` - If the origin is not root. + * * `SubnetNotExist` - If the subnet does not exist. + * * `InvalidVotingPowerEmaAlpha` - If alpha is greater than 10^18 (1.0). + */ + "sudo_set_voting_power_ema_alpha": Anonymize; + /** + * --- The extrinsic is a combination of add_stake(add_stake_limit) and burn_alpha. We buy + * alpha token first and immediately burn the acquired amount of alpha (aka Subnet buyback). + */ + "add_stake_burn": Anonymize; +}>; +export type Icv6ofu4lqekr4 = { + "netuid": number; + "dests": Anonymize; + "weights": Anonymize; + "version_key": bigint; +}; +export type I48embv0n659kj = { + "netuid": number; + "mecid": number; + "dests": Anonymize; + "weights": Anonymize; + "version_key": bigint; +}; +export type I8l6dbd18t5aja = { + "netuids": Anonymize; + "weights": Array>; + "version_keys": Anonymize; +}; +export type I513du23unvan = { + "netuid": number; + "commit_hash": FixedSizeBinary<32>; +}; +export type I36o6oho99gjm8 = { + "netuid": number; + "mecid": number; + "commit_hash": FixedSizeBinary<32>; +}; +export type If3mvus4cmnb7l = { + "netuids": Anonymize; + "commit_hashes": Anonymize; +}; +export type I3qrhi1ua10nnf = { + "netuid": number; + "uids": Anonymize; + "values": Anonymize; + "salt": Anonymize; + "version_key": bigint; +}; +export type I2hpc4ev2drsf2 = { + "netuid": number; + "mecid": number; + "uids": Anonymize; + "values": Anonymize; + "salt": Anonymize; + "version_key": bigint; +}; +export type I73q6qh9ckhm04 = { + "netuid": number; + "mecid": number; + "commit": Binary; + "reveal_round": bigint; +}; +export type Idia8cmqvul6et = { + "netuid": number; + "uids_list": Array>; + "values_list": Array>; + "salts_list": Array>; + "version_keys": Anonymize; +}; +export type Idardmhchnv8aa = { + "hotkey": SS58String; + "take": number; +}; +export type Icud5m8j0nlgtj = { + "hotkey": SS58String; + "netuid": number; + "amount_staked": bigint; +}; +export type I850u7ir5o34um = { + "hotkey": SS58String; + "netuid": number; + "amount_unstaked": bigint; +}; +export type Ica88a899k1afk = { + "netuid": number; + "version": number; + "ip": bigint; + "port": number; + "ip_type": number; + "protocol": number; + "placeholder1": number; + "placeholder2": number; +}; +export type I4tfn6eb3ekqt2 = { + "netuid": number; + "version": number; + "ip": bigint; + "port": number; + "ip_type": number; + "protocol": number; + "placeholder1": number; + "placeholder2": number; + "certificate": Binary; +}; +export type Ia5r6mm7trbg6a = { + "netuid": number; + "version": number; + "ip": bigint; + "port": number; + "ip_type": number; +}; +export type I27gr0ss2ikvqh = { + "netuid": number; + "block_number": bigint; + "nonce": bigint; + "work": Binary; + "hotkey": SS58String; + "coldkey": SS58String; +}; +export type Ie7hipi75c7vn0 = { + "hotkey": SS58String; +}; +export type I7f38r2vt6r9k1 = { + "netuid": number; + "hotkey": SS58String; +}; +export type I6b53cjq4m9nsr = { + "hotkey": SS58String; + "new_hotkey": SS58String; + "netuid"?: Anonymize; +}; +export type I216fvnrl9nq6l = { + "old_coldkey": SS58String; + "new_coldkey": SS58String; + "swap_cost": bigint; +}; +export type I9n4d52k0luroe = { + "hotkey": SS58String; + "netuid": number; + "take": number; +}; +export type I3gk6eeddm0hsd = { + "tx_rate_limit": bigint; +}; +export type I6ue7qc27uhiev = { + "take": number; +}; +export type Ifp8lgrkla2dig = { + "block_number": bigint; + "nonce": bigint; + "work": Binary; +}; +export type I30l38oi9ed9dj = { + "coldkey": SS58String; + "netuid": number; +}; +export type Ifj9gf4ekq9snm = { + "hotkey": SS58String; + "netuid": number; + "children": Anonymize; +}; +export type If2k69ql8jgivj = { + "new_coldkey": SS58String; +}; +export type I4378ieh1uba9u = { + "netuid": number; + "subnet_name": Binary; + "github_repo": Binary; + "subnet_contact": Binary; + "subnet_url": Binary; + "discord": Binary; + "description": Binary; + "logo_url": Binary; + "additional": Binary; +}; +export type I8e6f7r9dtk9c1 = { + "hotkey": SS58String; + "identity"?: Anonymize; +}; +export type I3m38saj8mvtpv = (Anonymize) | undefined; +export type I9d117ni3tprb = { + "origin_hotkey": SS58String; + "destination_hotkey": SS58String; + "origin_netuid": number; + "destination_netuid": number; + "alpha_amount": bigint; +}; +export type I340k0hbj1hc6r = { + "destination_coldkey": SS58String; + "hotkey": SS58String; + "origin_netuid": number; + "destination_netuid": number; + "alpha_amount": bigint; +}; +export type Ibapoov2fa817a = { + "hotkey": SS58String; + "origin_netuid": number; + "destination_netuid": number; + "alpha_amount": bigint; +}; +export type I2eon60c4gde7f = { + "hotkey": SS58String; + "netuid": number; + "amount_staked": bigint; + "limit_price": bigint; + "allow_partial": boolean; +}; +export type I7egr0053sjpci = { + "hotkey": SS58String; + "netuid": number; + "amount_unstaked": bigint; + "limit_price": bigint; + "allow_partial": boolean; +}; +export type I6r22p9usi2mkl = { + "hotkey": SS58String; + "origin_netuid": number; + "destination_netuid": number; + "alpha_amount": bigint; + "limit_price": bigint; + "allow_partial": boolean; +}; +export type I96k3nrdjfd63k = { + "netuid": number; + "evm_key": FixedSizeBinary<20>; + "block_number": bigint; + "signature": FixedSizeBinary<65>; +}; +export type Ibg3cp8vjl5u55 = { + "hotkey": SS58String; + "amount": bigint; + "netuid": number; +}; +export type Ibtu1gfmdnou5k = { + "cooldown": bigint; +}; +export type Iaoomvri5btde = { + "hotkey": SS58String; + "netuid": number; + "limit_price"?: Anonymize; +}; +export type Ic80igo4eds6rq = { + "emissions_share": number; + "end_block"?: Anonymize; +}; +export type Iflrm8un6aibtn = { + "lease_id": number; + "hotkey": SS58String; +}; +export type Ietm4rjshhu7sf = { + "netuid": number; + "commit": Binary; + "reveal_round": bigint; + "commit_reveal_version": number; +}; +export type I1v9m3ms1elitm = { + "netuid": number; + "mecid": number; + "commit": Binary; + "reveal_round": bigint; + "commit_reveal_version": number; +}; +export type I7a99hd3nbic2l = { + "new_root_claim_type": Anonymize; +}; +export type Ie8hpsm3jhsvo3 = { + "new_value": bigint; +}; +export type Ifcj247vgfdg56 = { + "netuid": number; + "new_value": bigint; +}; +export type Ic21uicfit5vcu = { + "new_coldkey_hash": FixedSizeBinary<32>; +}; +export type I2t2h3sjr2mdj0 = { + "hotkey": SS58String; + "netuid": number; + "amount": bigint; + "limit"?: Anonymize; +}; +export type If4ks1adspb2ai = AnonymousEnum<{ + /** + * Send a batch of dispatch calls. + * + * May be called from any origin except `None`. + * + * - `calls`: The calls to be dispatched from the same origin. The number of call must not + * exceed the constant: `batched_calls_limit` (available in constant metadata). + * + * If origin is root then the calls are dispatched without checking origin filter. (This + * includes bypassing `frame_system::Config::BaseCallFilter`). + * + * ## Complexity + * - O(C) where C is the number of calls to be batched. + * + * This will return `Ok` in all circumstances. To determine the success of the batch, an + * event is deposited. If a call failed and the batch was interrupted, then the + * `BatchInterrupted` event is deposited, along with the number of successful calls made + * and the error of the failed call. If all were successful, then the `BatchCompleted` + * event is deposited. + */ + "batch": Anonymize; + /** + * Send a call through an indexed pseudonym of the sender. + * + * Filter from origin are passed along. The call will be dispatched with an origin which + * use the same filter as the origin of this call. + * + * NOTE: If you need to ensure that any account-based filtering is not honored (i.e. + * because you expect `proxy` to have been used prior in the call stack and you do not want + * the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1` + * in the Multisig pallet instead. + * + * NOTE: Prior to version *12, this was called `as_limited_sub`. + * + * The dispatch origin for this call must be _Signed_. + */ + "as_derivative": Anonymize; + /** + * Send a batch of dispatch calls and atomically execute them. + * The whole transaction will rollback and fail if any of the calls failed. + * + * May be called from any origin except `None`. + * + * - `calls`: The calls to be dispatched from the same origin. The number of call must not + * exceed the constant: `batched_calls_limit` (available in constant metadata). + * + * If origin is root then the calls are dispatched without checking origin filter. (This + * includes bypassing `frame_system::Config::BaseCallFilter`). + * + * ## Complexity + * - O(C) where C is the number of calls to be batched. + */ + "batch_all": Anonymize; + /** + * Dispatches a function call with a provided origin. + * + * The dispatch origin for this call must be _Root_. + * + * ## Complexity + * - O(1). + */ + "dispatch_as": Anonymize; + /** + * Send a batch of dispatch calls. + * Unlike `batch`, it allows errors and won't interrupt. + * + * May be called from any origin except `None`. + * + * - `calls`: The calls to be dispatched from the same origin. The number of call must not + * exceed the constant: `batched_calls_limit` (available in constant metadata). + * + * If origin is root then the calls are dispatch without checking origin filter. (This + * includes bypassing `frame_system::Config::BaseCallFilter`). + * + * ## Complexity + * - O(C) where C is the number of calls to be batched. + */ + "force_batch": Anonymize; + /** + * Dispatch a function call with a specified weight. + * + * This function does not check the weight of the call, and instead allows the + * Root origin to specify the weight of the call. + * + * The dispatch origin for this call must be _Root_. + */ + "with_weight": Anonymize; + /** + * Dispatch a fallback call in the event the main call fails to execute. + * May be called from any origin except `None`. + * + * This function first attempts to dispatch the `main` call. + * If the `main` call fails, the `fallback` is attemted. + * if the fallback is successfully dispatched, the weights of both calls + * are accumulated and an event containing the main call error is deposited. + * + * In the event of a fallback failure the whole call fails + * with the weights returned. + * + * - `main`: The main call to be dispatched. This is the primary action to execute. + * - `fallback`: The fallback call to be dispatched in case the `main` call fails. + * + * ## Dispatch Logic + * - If the origin is `root`, both the main and fallback calls are executed without + * applying any origin filters. + * - If the origin is not `root`, the origin filter is applied to both the `main` and + * `fallback` calls. + * + * ## Use Case + * - Some use cases might involve submitting a `batch` type call in either main, fallback + * or both. + */ + "if_else": Anonymize; + /** + * Dispatches a function call with a provided origin. + * + * Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call. + * + * The dispatch origin for this call must be _Root_. + */ + "dispatch_as_fallible": Anonymize; +}>; +export type I80tnmsfsu19sl = { + "calls": Array; +}; +export type Ib7nn1mns0usdp = { + "index": number; + "call": TxCallData; +}; +export type I4fivl1mrn0hhc = { + "as_origin": Anonymize; + "call": TxCallData; +}; +export type I2ead8rm0h16hm = { + "call": TxCallData; + "weight": Anonymize; +}; +export type I25l72483lbgf9 = { + "main": TxCallData; + "fallback": TxCallData; +}; +export type Ic3n0u1krodt07 = AnonymousEnum<{ + /** + * Authenticates the sudo key and dispatches a function call with `Root` origin. + */ + "sudo": Anonymize; + /** + * Authenticates the sudo key and dispatches a function call with `Root` origin. + * This function does not check the weight of the call, and instead allows the + * Sudo user to specify the weight of the call. + * + * The dispatch origin for this call must be _Signed_. + */ + "sudo_unchecked_weight": Anonymize; + /** + * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo + * key. + */ + "set_key": Anonymize; + /** + * Authenticates the sudo key and dispatches a function call with `Signed` origin from + * a given account. + * + * The dispatch origin for this call must be _Signed_. + */ + "sudo_as": Anonymize; + /** + * Permanently removes the sudo key. + * + * **This cannot be un-done.** + */ + "remove_key": undefined; +}>; +export type I9okvr56cd7277 = { + "call": TxCallData; +}; +export type I8k3rnvpeeh4hv = { + "new": MultiAddress; +}; +export type I56sht7incdimf = { + "who": MultiAddress; + "call": TxCallData; +}; +export type I92oc1s48b79mg = AnonymousEnum<{ + /** + * Immediately dispatch a multi-signature call using a single approval from the caller. + * + * The dispatch origin for this call must be _Signed_. + * + * - `other_signatories`: The accounts (other than the sender) who are part of the + * multi-signature, but do not participate in the approval process. + * - `call`: The call to be executed. + * + * Result is equivalent to the dispatched result. + * + * ## Complexity + * O(Z + C) where Z is the length of the call and C its execution weight. + */ + "as_multi_threshold_1": Anonymize; + /** + * Register approval for a dispatch to be made from a deterministic composite account if + * approved by a total of `threshold - 1` of `other_signatories`. + * + * If there are enough, then dispatch the call. + * + * Payment: `DepositBase` will be reserved if this is the first approval, plus + * `threshold` times `DepositFactor`. It is returned once this dispatch happens or + * is cancelled. + * + * The dispatch origin for this call must be _Signed_. + * + * - `threshold`: The total number of approvals for this dispatch before it is executed. + * - `other_signatories`: The accounts (other than the sender) who can approve this + * dispatch. May not be empty. + * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is + * not the first approval, then it must be `Some`, with the timepoint (block number and + * transaction index) of the first approval transaction. + * - `call`: The call to be executed. + * + * NOTE: Unless this is the final approval, you will generally want to use + * `approve_as_multi` instead, since it only requires a hash of the call. + * + * Result is equivalent to the dispatched result if `threshold` is exactly `1`. Otherwise + * on success, result is `Ok` and the result from the interior call, if it was executed, + * may be found in the deposited `MultisigExecuted` event. + * + * ## Complexity + * - `O(S + Z + Call)`. + * - Up to one balance-reserve or unreserve operation. + * - One passthrough operation, one insert, both `O(S)` where `S` is the number of + * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. + * - One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len. + * - One encode & hash, both of complexity `O(S)`. + * - Up to one binary search and insert (`O(logS + S)`). + * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. + * - One event. + * - The weight of the `call`. + * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit + * taken for its lifetime of `DepositBase + threshold * DepositFactor`. + */ + "as_multi": Anonymize; + /** + * Register approval for a dispatch to be made from a deterministic composite account if + * approved by a total of `threshold - 1` of `other_signatories`. + * + * Payment: `DepositBase` will be reserved if this is the first approval, plus + * `threshold` times `DepositFactor`. It is returned once this dispatch happens or + * is cancelled. + * + * The dispatch origin for this call must be _Signed_. + * + * - `threshold`: The total number of approvals for this dispatch before it is executed. + * - `other_signatories`: The accounts (other than the sender) who can approve this + * dispatch. May not be empty. + * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is + * not the first approval, then it must be `Some`, with the timepoint (block number and + * transaction index) of the first approval transaction. + * - `call_hash`: The hash of the call to be executed. + * + * NOTE: If this is the final approval, you will want to use `as_multi` instead. + * + * ## Complexity + * - `O(S)`. + * - Up to one balance-reserve or unreserve operation. + * - One passthrough operation, one insert, both `O(S)` where `S` is the number of + * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. + * - One encode & hash, both of complexity `O(S)`. + * - Up to one binary search and insert (`O(logS + S)`). + * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. + * - One event. + * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit + * taken for its lifetime of `DepositBase + threshold * DepositFactor`. + */ + "approve_as_multi": Anonymize; + /** + * Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously + * for this operation will be unreserved on success. + * + * The dispatch origin for this call must be _Signed_. + * + * - `threshold`: The total number of approvals for this dispatch before it is executed. + * - `other_signatories`: The accounts (other than the sender) who can approve this + * dispatch. May not be empty. + * - `timepoint`: The timepoint (block number and transaction index) of the first approval + * transaction for this dispatch. + * - `call_hash`: The hash of the call to be executed. + * + * ## Complexity + * - `O(S)`. + * - Up to one balance-reserve or unreserve operation. + * - One passthrough operation, one insert, both `O(S)` where `S` is the number of + * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. + * - One encode & hash, both of complexity `O(S)`. + * - One event. + * - I/O: 1 read `O(S)`, one remove. + * - Storage: removes one item. + */ + "cancel_as_multi": Anonymize; + /** + * Poke the deposit reserved for an existing multisig operation. + * + * The dispatch origin for this call must be _Signed_ and must be the original depositor of + * the multisig operation. + * + * The transaction fee is waived if the deposit amount has changed. + * + * - `threshold`: The total number of approvals needed for this multisig. + * - `other_signatories`: The accounts (other than the sender) who are part of the + * multisig. + * - `call_hash`: The hash of the call this deposit is reserved for. + * + * Emits `DepositPoked` if successful. + */ + "poke_deposit": Anonymize; +}>; +export type I8hge8nrufr05f = { + "other_signatories": Anonymize; + "call": TxCallData; +}; +export type I5v0mk7rggegmh = { + "threshold": number; + "other_signatories": Anonymize; + "maybe_timepoint"?: Anonymize; + "call": TxCallData; + "max_weight": Anonymize; +}; +export type I95jfd8j5cr5eh = (Anonymize) | undefined; +export type Ideaemvoneh309 = { + "threshold": number; + "other_signatories": Anonymize; + "maybe_timepoint"?: Anonymize; + "call_hash": FixedSizeBinary<32>; + "max_weight": Anonymize; +}; +export type I3d9o9d7epp66v = { + "threshold": number; + "other_signatories": Anonymize; + "timepoint": Anonymize; + "call_hash": FixedSizeBinary<32>; +}; +export type I6lqh1vgb4mcja = { + "threshold": number; + "other_signatories": Anonymize; + "call_hash": FixedSizeBinary<32>; +}; +export type If81ks88t5mpk5 = AnonymousEnum<{ + /** + * Register a preimage on-chain. + * + * If the preimage was previously requested, no fees or deposits are taken for providing + * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage. + */ + "note_preimage": Anonymize; + /** + * Clear an unrequested preimage from the runtime storage. + * + * If `len` is provided, then it will be a much cheaper operation. + * + * - `hash`: The hash of the preimage to be removed from the store. + * - `len`: The length of the preimage of `hash`. + */ + "unnote_preimage": Anonymize; + /** + * Request a preimage be uploaded to the chain without paying any fees or deposits. + * + * If the preimage requests has already been provided on-chain, we unreserve any deposit + * a user may have paid, and take the control of the preimage out of their hands. + */ + "request_preimage": Anonymize; + /** + * Clear a previously made request for a preimage. + * + * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`. + */ + "unrequest_preimage": Anonymize; + /** + * Ensure that the bulk of pre-images is upgraded. + * + * The caller pays no fee if at least 90% of pre-images were successfully updated. + */ + "ensure_updated": Anonymize; +}>; +export type I82nfqfkd48n10 = { + "bytes": Binary; +}; +export type I3o5j3bli1pd8e = { + "hashes": Anonymize; +}; +export type I8joseop2odch3 = AnonymousEnum<{ + /** + * Anonymously schedule a task. + */ + "schedule": Anonymize; + /** + * Cancel an anonymously scheduled task. + */ + "cancel": Anonymize; + /** + * Schedule a named task. + */ + "schedule_named": Anonymize; + /** + * Cancel a named scheduled task. + */ + "cancel_named": Anonymize; + /** + * Anonymously schedule a task after a delay. + */ + "schedule_after": Anonymize; + /** + * Schedule a named task after a delay. + */ + "schedule_named_after": Anonymize; + /** + * Set a retry configuration for a task so that, in case its scheduled run fails, it will + * be retried after `period` blocks, for a total amount of `retries` retries or until it + * succeeds. + * + * Tasks which need to be scheduled for a retry are still subject to weight metering and + * agenda space, same as a regular task. If a periodic task fails, it will be scheduled + * normally while the task is retrying. + * + * Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic + * clones of the original task. Their retry configuration will be derived from the + * original task's configuration, but will have a lower value for `remaining` than the + * original `total_retries`. + */ + "set_retry": Anonymize; + /** + * Set a retry configuration for a named task so that, in case its scheduled run fails, it + * will be retried after `period` blocks, for a total amount of `retries` retries or until + * it succeeds. + * + * Tasks which need to be scheduled for a retry are still subject to weight metering and + * agenda space, same as a regular task. If a periodic task fails, it will be scheduled + * normally while the task is retrying. + * + * Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic + * clones of the original task. Their retry configuration will be derived from the + * original task's configuration, but will have a lower value for `remaining` than the + * original `total_retries`. + */ + "set_retry_named": Anonymize; + /** + * Removes the retry configuration of a task. + */ + "cancel_retry": Anonymize; + /** + * Cancel the retry configuration of a named task. + */ + "cancel_retry_named": Anonymize; +}>; +export type Ivqkjqsbgj1dj = { + "when": number; + "maybe_periodic"?: Anonymize; + "priority": number; + "call": TxCallData; +}; +export type Ib6bm2ug64rldc = { + "id": FixedSizeBinary<32>; + "when": number; + "maybe_periodic"?: Anonymize; + "priority": number; + "call": TxCallData; +}; +export type Ifs1i5fk9cqvr6 = { + "id": FixedSizeBinary<32>; +}; +export type I5q3t0hm83a58h = { + "after": number; + "maybe_periodic"?: Anonymize; + "priority": number; + "call": TxCallData; +}; +export type I2gnaqoj2eimi0 = { + "id": FixedSizeBinary<32>; + "after": number; + "maybe_periodic"?: Anonymize; + "priority": number; + "call": TxCallData; +}; +export type Ieg3fd8p4pkt10 = { + "task": Anonymize; + "retries": number; + "period": number; +}; +export type I8kg5ll427kfqq = { + "id": FixedSizeBinary<32>; + "retries": number; + "period": number; +}; +export type I467333262q1l9 = { + "task": Anonymize; +}; +export type Ia2ee5fnr4ukkf = AnonymousEnum<{ + /** + * Dispatch the given `call` from an account that the sender is authorised for through + * `add_proxy`. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `real`: The account that the proxy will make a call on behalf of. + * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call. + * - `call`: The call to be made by the `real` account. + */ + "proxy": Anonymize; + /** + * Register a proxy account for the sender that is able to make calls on its behalf. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `proxy`: The account that the `caller` would like to make a proxy. + * - `proxy_type`: The permissions allowed for this proxy account. + * - `delay`: The announcement period required of the initial proxy. Will generally be + * zero. + */ + "add_proxy": Anonymize; + /** + * Unregister a proxy account for the sender. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `proxy`: The account that the `caller` would like to remove as a proxy. + * - `proxy_type`: The permissions currently enabled for the removed proxy account. + */ + "remove_proxy": Anonymize; + /** + * Unregister all proxy accounts for the sender. + * + * The dispatch origin for this call must be _Signed_. + * + * WARNING: This may be called on accounts created by `create_pure`, however if done, then + * the unreserved fees will be inaccessible. **All access to this account will be lost.** + */ + "remove_proxies": undefined; + /** + * Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and + * initialize it with a proxy of `proxy_type` for `origin` sender. + * + * Requires a `Signed` origin. + * + * - `proxy_type`: The type of the proxy that the sender will be registered as over the + * new account. This will almost always be the most permissive `ProxyType` possible to + * allow for maximum flexibility. + * - `index`: A disambiguation index, in case this is called multiple times in the same + * transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just + * want to use `0`. + * - `delay`: The announcement period required of the initial proxy. Will generally be + * zero. + * + * Fails with `Duplicate` if this has already been called in this transaction, from the + * same sender, with the same parameters. + * + * Fails if there are insufficient funds to pay for deposit. + */ + "create_pure": Anonymize; + /** + * Removes a previously spawned pure proxy. + * + * WARNING: **All access to this account will be lost.** Any funds held in it will be + * inaccessible. + * + * Requires a `Signed` origin, and the sender account must have been created by a call to + * `create_pure` with corresponding parameters. + * + * - `spawner`: The account that originally called `create_pure` to create this account. + * - `index`: The disambiguation index originally passed to `create_pure`. Probably `0`. + * - `proxy_type`: The proxy type originally passed to `create_pure`. + * - `height`: The height of the chain when the call to `create_pure` was processed. + * - `ext_index`: The extrinsic index in which the call to `create_pure` was processed. + * + * Fails with `NoPermission` in case the caller is not a previously created pure + * account whose `create_pure` call has corresponding parameters. + */ + "kill_pure": Anonymize; + /** + * Publish the hash of a proxy-call that will be made in the future. + * + * This must be called some number of blocks before the corresponding `proxy` is attempted + * if the delay associated with the proxy relationship is greater than zero. + * + * No more than `MaxPending` announcements may be made at any one time. + * + * This will take a deposit of `AnnouncementDepositFactor` as well as + * `AnnouncementDepositBase` if there are no other pending announcements. + * + * The dispatch origin for this call must be _Signed_ and a proxy of `real`. + * + * Parameters: + * - `real`: The account that the proxy will make a call on behalf of. + * - `call_hash`: The hash of the call to be made by the `real` account. + */ + "announce": Anonymize; + /** + * Remove a given announcement. + * + * May be called by a proxy account to remove a call they previously announced and return + * the deposit. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `real`: The account that the proxy will make a call on behalf of. + * - `call_hash`: The hash of the call to be made by the `real` account. + */ + "remove_announcement": Anonymize; + /** + * Remove the given announcement of a delegate. + * + * May be called by a target (proxied) account to remove a call that one of their delegates + * (`delegate`) has announced they want to execute. The deposit is returned. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `delegate`: The account that previously announced the call. + * - `call_hash`: The hash of the call to be made. + */ + "reject_announcement": Anonymize; + /** + * Dispatch the given `call` from an account that the sender is authorized for through + * `add_proxy`. + * + * Removes any corresponding announcement(s). + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `real`: The account that the proxy will make a call on behalf of. + * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call. + * - `call`: The call to be made by the `real` account. + */ + "proxy_announced": Anonymize; + /** + * Poke / Adjust deposits made for proxies and announcements based on current values. + * This can be used by accounts to possibly lower their locked amount. + * + * The dispatch origin for this call must be _Signed_. + * + * The transaction fee is waived if the deposit amount has changed. + * + * Emits `DepositPoked` if successful. + */ + "poke_deposit": undefined; +}>; +export type Idlqs144rc48hk = { + "real": MultiAddress; + "force_proxy_type"?: Anonymize; + "call": TxCallData; +}; +export type Iccd9gbcgdpjso = (Anonymize) | undefined; +export type It11trpppbc3l = { + "delegate": MultiAddress; + "proxy_type": Anonymize; + "delay": number; +}; +export type Ietml13sclqs1q = { + "proxy_type": Anonymize; + "delay": number; + "index": number; +}; +export type Iftfic7p3uban2 = { + "spawner": MultiAddress; + "proxy_type": Anonymize; + "index": number; + "height": number; + "ext_index": number; +}; +export type I2eb501t8s6hsq = { + "real": MultiAddress; + "call_hash": FixedSizeBinary<32>; +}; +export type Ianmuoljk2sk1u = { + "delegate": MultiAddress; + "call_hash": FixedSizeBinary<32>; +}; +export type I7hgtlnpelk0fc = { + "delegate": MultiAddress; + "real": MultiAddress; + "force_proxy_type"?: Anonymize; + "call": TxCallData; +}; +export type Ifml9odtov51l3 = AnonymousEnum<{ + /** + * Register an identity for an account. This will overwrite any existing identity. + */ + "set_identity": Anonymize; + /** + * Clear the identity of an account. + */ + "clear_identity": Anonymize; +}>; +export type I3p6khp3nv37cu = { + "identified": SS58String; + "info": Anonymize; +}; +export type I6pnnj50tnq448 = { + "identified": SS58String; +}; +export type I5bqhvupj937er = AnonymousEnum<{ + /** + * Set the commitment for a given netuid + */ + "set_commitment": Anonymize; + /** + * Sudo-set MaxSpace + */ + "set_max_space": Anonymize; +}>; +export type I57v1t6776pl3a = { + "netuid": number; + "info": Anonymize; +}; +export type I1il5mj68vvsms = { + "new_limit": number; +}; +export type Iemvun0dttbcqs = AnonymousEnum<{ + /** + * The extrinsic sets the new authorities for Aura consensus. + * It is only callable by the root account. + * The extrinsic will call the Aura pallet to change the authorities. + */ + "swap_authorities": Anonymize; + /** + * The extrinsic sets the default take for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the default take. + */ + "sudo_set_default_take": Anonymize; + /** + * The extrinsic sets the transaction rate limit for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the transaction rate limit. + */ + "sudo_set_tx_rate_limit": Anonymize; + /** + * The extrinsic sets the serving rate limit for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the serving rate limit. + */ + "sudo_set_serving_rate_limit": Anonymize; + /** + * The extrinsic sets the minimum difficulty for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the minimum difficulty. + */ + "sudo_set_min_difficulty": Anonymize; + /** + * The extrinsic sets the maximum difficulty for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the maximum difficulty. + */ + "sudo_set_max_difficulty": Anonymize; + /** + * The extrinsic sets the weights version key for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the weights version key. + */ + "sudo_set_weights_version_key": Anonymize; + /** + * The extrinsic sets the weights set rate limit for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the weights set rate limit. + */ + "sudo_set_weights_set_rate_limit": Anonymize; + /** + * The extrinsic sets the adjustment interval for a subnet. + * It is only callable by the root account, not changeable by the subnet owner. + * The extrinsic will call the Subtensor pallet to set the adjustment interval. + */ + "sudo_set_adjustment_interval": Anonymize; + /** + * The extrinsic sets the adjustment alpha for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the adjustment alpha. + */ + "sudo_set_adjustment_alpha": Anonymize; + /** + * The extrinsic sets the immunity period for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the immunity period. + */ + "sudo_set_immunity_period": Anonymize; + /** + * The extrinsic sets the minimum allowed weights for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the minimum allowed weights. + */ + "sudo_set_min_allowed_weights": Anonymize; + /** + * The extrinsic sets the maximum allowed UIDs for a subnet. + * It is only callable by the root account and subnet owner. + * The extrinsic will call the Subtensor pallet to set the maximum allowed UIDs for a subnet. + */ + "sudo_set_max_allowed_uids": Anonymize; + /** + * The extrinsic sets the kappa for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the kappa. + */ + "sudo_set_kappa": Anonymize; + /** + * The extrinsic sets the rho for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the rho. + */ + "sudo_set_rho": Anonymize; + /** + * The extrinsic sets the activity cutoff for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the activity cutoff. + */ + "sudo_set_activity_cutoff": Anonymize; + /** + * The extrinsic sets the network registration allowed for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the network registration allowed. + */ + "sudo_set_network_registration_allowed": Anonymize; + /** + * The extrinsic sets the network PoW registration allowed for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the network PoW registration allowed. + */ + "sudo_set_network_pow_registration_allowed": Anonymize; + /** + * The extrinsic sets the target registrations per interval for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the target registrations per interval. + */ + "sudo_set_target_registrations_per_interval": Anonymize; + /** + * The extrinsic sets the minimum burn for a subnet. + * It is only callable by root and subnet owner. + * The extrinsic will call the Subtensor pallet to set the minimum burn. + */ + "sudo_set_min_burn": Anonymize; + /** + * The extrinsic sets the maximum burn for a subnet. + * It is only callable by root and subnet owner. + * The extrinsic will call the Subtensor pallet to set the maximum burn. + */ + "sudo_set_max_burn": Anonymize; + /** + * The extrinsic sets the difficulty for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the difficulty. + */ + "sudo_set_difficulty": Anonymize; + /** + * The extrinsic sets the maximum allowed validators for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the maximum allowed validators. + */ + "sudo_set_max_allowed_validators": Anonymize; + /** + * The extrinsic sets the bonds moving average for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the bonds moving average. + */ + "sudo_set_bonds_moving_average": Anonymize; + /** + * The extrinsic sets the bonds penalty for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the bonds penalty. + */ + "sudo_set_bonds_penalty": Anonymize; + /** + * The extrinsic sets the maximum registrations per block for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the maximum registrations per block. + */ + "sudo_set_max_registrations_per_block": Anonymize; + /** + * The extrinsic sets the subnet owner cut for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the subnet owner cut. + */ + "sudo_set_subnet_owner_cut": Anonymize; + /** + * The extrinsic sets the network rate limit for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the network rate limit. + */ + "sudo_set_network_rate_limit": Anonymize; + /** + * The extrinsic sets the tempo for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the tempo. + */ + "sudo_set_tempo": Anonymize; + /** + * The extrinsic sets the total issuance for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the issuance for the network. + */ + "sudo_set_total_issuance": Anonymize; + /** + * The extrinsic sets the immunity period for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the immunity period for the network. + */ + "sudo_set_network_immunity_period": Anonymize; + /** + * The extrinsic sets the min lock cost for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the min lock cost for the network. + */ + "sudo_set_network_min_lock_cost": Anonymize; + /** + * The extrinsic sets the subnet limit for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the subnet limit. + */ + "sudo_set_subnet_limit": Anonymize; + /** + * The extrinsic sets the lock reduction interval for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the lock reduction interval. + */ + "sudo_set_lock_reduction_interval": Anonymize; + /** + * The extrinsic sets the recycled RAO for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the recycled RAO. + */ + "sudo_set_rao_recycled": Anonymize; + /** + * The extrinsic sets the weights min stake. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the weights min stake. + */ + "sudo_set_stake_threshold": Anonymize; + /** + * The extrinsic sets the minimum stake required for nominators. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the minimum stake required for nominators. + */ + "sudo_set_nominator_min_required_stake": Anonymize; + /** + * The extrinsic sets the rate limit for delegate take transactions. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the rate limit for delegate take transactions. + */ + "sudo_set_tx_delegate_take_rate_limit": Anonymize; + /** + * The extrinsic sets the minimum delegate take. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the minimum delegate take. + */ + "sudo_set_min_delegate_take": Anonymize; + /** + * The extrinsic enabled/disables commit/reaveal for a given subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the value. + */ + "sudo_set_commit_reveal_weights_enabled": Anonymize; + /** + * Enables or disables Liquid Alpha for a given subnet. + * + * # Parameters + * - `origin`: The origin of the call, which must be the root account or subnet owner. + * - `netuid`: The unique identifier for the subnet. + * - `enabled`: A boolean flag to enable or disable Liquid Alpha. + * + * # Weight + * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. + */ + "sudo_set_liquid_alpha_enabled": Anonymize; + /** + * Sets values for liquid alpha + */ + "sudo_set_alpha_values": Anonymize; + /** + * Sets the duration of the dissolve network schedule. + * + * This extrinsic allows the root account to set the duration for the dissolve network schedule. + * The dissolve network schedule determines how long it takes for a network dissolution operation to complete. + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `duration` - The new duration for the dissolve network schedule, in number of blocks. + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + "sudo_set_dissolve_network_schedule_duration": Anonymize; + /** + * Sets the commit-reveal weights periods for a specific subnet. + * + * This extrinsic allows the subnet owner or root account to set the duration (in epochs) during which committed weights must be revealed. + * The commit-reveal mechanism ensures that users commit weights in advance and reveal them only within a specified period. + * + * # Arguments + * * `origin` - The origin of the call, which must be the subnet owner or the root account. + * * `netuid` - The unique identifier of the subnet for which the periods are being set. + * * `periods` - The number of epochs that define the commit-reveal period. + * + * # Errors + * * `BadOrigin` - If the caller is neither the subnet owner nor the root account. + * * `SubnetDoesNotExist` - If the specified subnet does not exist. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + "sudo_set_commit_reveal_weights_interval": Anonymize; + /** + * Sets the EVM ChainID. + * + * # Arguments + * * `origin` - The origin of the call, which must be the subnet owner or the root account. + * * `chainId` - The u64 chain ID + * + * # Errors + * * `BadOrigin` - If the caller is neither the subnet owner nor the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + "sudo_set_evm_chain_id": Anonymize; + /** + * A public interface for `pallet_grandpa::Pallet::schedule_grandpa_change`. + * + * Schedule a change in the authorities. + * + * The change will be applied at the end of execution of the block `in_blocks` after the + * current block. This value may be 0, in which case the change is applied at the end of + * the current block. + * + * If the `forced` parameter is defined, this indicates that the current set has been + * synchronously determined to be offline and that after `in_blocks` the given change + * should be applied. The given block number indicates the median last finalized block + * number and it should be used as the canon block when starting the new grandpa voter. + * + * No change should be signaled while any change is pending. Returns an error if a change + * is already pending. + */ + "schedule_grandpa_change": Anonymize; + /** + * Enable or disable atomic alpha transfers for a given subnet. + * + * # Parameters + * - `origin`: The origin of the call, which must be the root account or subnet owner. + * - `netuid`: The unique identifier for the subnet. + * - `enabled`: A boolean flag to enable or disable Liquid Alpha. + * + * # Weight + * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. + */ + "sudo_set_toggle_transfer": Anonymize; + /** + * Set the behaviour of the "burn" UID(s) for a given subnet. + * If set to `Burn`, the miner emission sent to the burn UID(s) will be burned. + * If set to `Recycle`, the miner emission sent to the burn UID(s) will be recycled. + * + * # Parameters + * - `origin`: The origin of the call, which must be the root account or subnet owner. + * - `netuid`: The unique identifier for the subnet. + * - `recycle_or_burn`: The desired behaviour of the "burn" UID(s) for the subnet. + * + */ + "sudo_set_recycle_or_burn": Anonymize; + /** + * Toggles the enablement of an EVM precompile. + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `precompile_id` - The identifier of the EVM precompile to toggle. + * * `enabled` - The new enablement state of the precompile. + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + "sudo_toggle_evm_precompile": Anonymize; + /** + * + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `alpha` - The new moving alpha value for the SubnetMovingAlpha. + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + "sudo_set_subnet_moving_alpha": Anonymize; + /** + * Change the SubnetOwnerHotkey for a given subnet. + * + * # Arguments + * * `origin` - The origin of the call, which must be the subnet owner. + * * `netuid` - The unique identifier for the subnet. + * * `hotkey` - The new hotkey for the subnet owner. + * + * # Errors + * * `BadOrigin` - If the caller is not the subnet owner or root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + "sudo_set_subnet_owner_hotkey": Anonymize; + /** + * + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `ema_alpha_period` - Number of blocks for EMA price to halve + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + "sudo_set_ema_price_halving_period": Anonymize; + /** + * + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `netuid` - The unique identifier for the subnet. + * * `steepness` - The Steepness for the alpha sigmoid function. (range is 0-int16::MAX, + * negative values are reserved for future use) + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * * `SubnetDoesNotExist` - If the specified subnet does not exist. + * * `NegativeSigmoidSteepness` - If the steepness is negative and the caller is + * root. + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + "sudo_set_alpha_sigmoid_steepness": Anonymize; + /** + * Enables or disables Yuma3 for a given subnet. + * + * # Parameters + * - `origin`: The origin of the call, which must be the root account or subnet owner. + * - `netuid`: The unique identifier for the subnet. + * - `enabled`: A boolean flag to enable or disable Yuma3. + * + * # Weight + * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. + */ + "sudo_set_yuma3_enabled": Anonymize; + /** + * Enables or disables Bonds Reset for a given subnet. + * + * # Parameters + * - `origin`: The origin of the call, which must be the root account or subnet owner. + * - `netuid`: The unique identifier for the subnet. + * - `enabled`: A boolean flag to enable or disable Bonds Reset. + * + * # Weight + * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. + */ + "sudo_set_bonds_reset_enabled": Anonymize; + /** + * Sets or updates the hotkey account associated with the owner of a specific subnet. + * + * This function allows either the root origin or the current subnet owner to set or update + * the hotkey for a given subnet. The subnet must already exist. To prevent abuse, the call is + * rate-limited to once per configured interval (default: one week) per subnet. + * + * # Parameters + * - `origin`: The dispatch origin of the call. Must be either root or the current owner of the subnet. + * - `netuid`: The unique identifier of the subnet whose owner hotkey is being set. + * - `hotkey`: The new hotkey account to associate with the subnet owner. + * + * # Returns + * - `DispatchResult`: Returns `Ok(())` if the hotkey was successfully set, or an appropriate error otherwise. + * + * # Errors + * - `Error::SubnetNotExists`: If the specified subnet does not exist. + * - `Error::TxRateLimitExceeded`: If the function is called more frequently than the allowed rate limit. + * + * # Access Control + * Only callable by: + * - Root origin, or + * - The coldkey account that owns the subnet. + * + * # Storage + * - Updates [`SubnetOwnerHotkey`] for the given `netuid`. + * - Reads and updates [`LastRateLimitedBlock`] for rate-limiting. + * - Reads [`DefaultSetSNOwnerHotkeyRateLimit`] to determine the interval between allowed updates. + * + * # Rate Limiting + * This function is rate-limited to one call per subnet per interval (e.g., one week). + */ + "sudo_set_sn_owner_hotkey": Anonymize; + /** + * Enables or disables subtoken trading for a given subnet. + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `netuid` - The unique identifier of the subnet. + * * `subtoken_enabled` - A boolean indicating whether subtoken trading should be enabled or disabled. + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + "sudo_set_subtoken_enabled": Anonymize; + /** + * Sets the commit-reveal weights version for all subnets + */ + "sudo_set_commit_reveal_version": Anonymize; + /** + * Sets the number of immune owner neurons + */ + "sudo_set_owner_immune_neuron_limit": Anonymize; + /** + * Sets the childkey burn for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the childkey burn. + */ + "sudo_set_ck_burn": Anonymize; + /** + * Sets the admin freeze window length (in blocks) at the end of a tempo. + * Only callable by root. + */ + "sudo_set_admin_freeze_window": Anonymize; + /** + * Sets the owner hyperparameter rate limit in epochs (global multiplier). + * Only callable by root. + */ + "sudo_set_owner_hparam_rate_limit": Anonymize; + /** + * Sets the desired number of mechanisms in a subnet + */ + "sudo_set_mechanism_count": Anonymize; + /** + * Sets the emission split between mechanisms in a subnet + */ + "sudo_set_mechanism_emission_split": Anonymize; + /** + * Trims the maximum number of UIDs for a subnet. + * + * The trimming is done by sorting the UIDs by emission descending and then trimming + * the lowest emitters while preserving temporally and owner immune UIDs. The UIDs are + * then compressed to the left and storage is migrated to the new compressed UIDs. + */ + "sudo_trim_to_max_allowed_uids": Anonymize; + /** + * The extrinsic sets the minimum allowed UIDs for a subnet. + * It is only callable by the root account. + */ + "sudo_set_min_allowed_uids": Anonymize; + /** + * Sets TAO flow cutoff value (A) + */ + "sudo_set_tao_flow_cutoff": Anonymize; + /** + * Sets TAO flow normalization exponent (p) + */ + "sudo_set_tao_flow_normalization_exponent": Anonymize; + /** + * Sets TAO flow smoothing factor (alpha) + */ + "sudo_set_tao_flow_smoothing_factor": Anonymize; + /** + * Sets the global maximum number of mechanisms in a subnet + */ + "sudo_set_max_mechanism_count": Anonymize; + /** + * Sets the minimum number of non-immortal & non-immune UIDs that must remain in a subnet + */ + "sudo_set_min_non_immune_uids": Anonymize; + /** + * Sets the delay before a subnet can call start + */ + "sudo_set_start_call_delay": Anonymize; + /** + * Sets the announcement delay for coldkey swap. + */ + "sudo_set_coldkey_swap_announcement_delay": Anonymize; + /** + * Sets the coldkey swap reannouncement delay. + */ + "sudo_set_coldkey_swap_reannouncement_delay": Anonymize; +}>; +export type I42mob3hqe6j7h = { + "new_authorities": Anonymize; +}; +export type Icdbq0j31b3g9c = { + "default_take": number; +}; +export type I2t2rlclb0ce3e = { + "netuid": number; + "serving_rate_limit": bigint; +}; +export type Iar87gdqmug5o7 = { + "netuid": number; + "min_difficulty": bigint; +}; +export type I3oullii9p80a1 = { + "netuid": number; + "max_difficulty": bigint; +}; +export type I8t8ta6lfbia9e = { + "netuid": number; + "weights_version_key": bigint; +}; +export type I3akfmjle982qg = { + "netuid": number; + "weights_set_rate_limit": bigint; +}; +export type Ibaje86kdit7s6 = { + "netuid": number; + "adjustment_interval": number; +}; +export type I90lra4vl5j4db = { + "netuid": number; + "adjustment_alpha": bigint; +}; +export type I1q480m57ftcms = { + "netuid": number; + "immunity_period": number; +}; +export type Ie2bjglo51atf6 = { + "netuid": number; + "min_allowed_weights": number; +}; +export type Ievma38tc25kil = { + "netuid": number; + "max_allowed_uids": number; +}; +export type I2er75v4akf5cc = { + "netuid": number; + "kappa": number; +}; +export type I5pldh0j0v0u4l = { + "netuid": number; + "rho": number; +}; +export type Ifhou5p0slv68r = { + "netuid": number; + "activity_cutoff": number; +}; +export type I9m89dnau2i4tt = { + "netuid": number; + "registration_allowed": boolean; +}; +export type Ifunpjbsc4jrrr = { + "netuid": number; + "target_registrations_per_interval": number; +}; +export type I85uujfpnu8gum = { + "netuid": number; + "min_burn": bigint; +}; +export type I7bl5t0it6ck2m = { + "netuid": number; + "max_burn": bigint; +}; +export type I4iope0tjiqgu4 = { + "netuid": number; + "difficulty": bigint; +}; +export type Iptqa236frcvo = { + "netuid": number; + "max_allowed_validators": number; +}; +export type I8hbi1vrve1i2 = { + "netuid": number; + "bonds_moving_average": bigint; +}; +export type I1v9a50gjqk26k = { + "netuid": number; + "bonds_penalty": number; +}; +export type Idv4d3rktbigfh = { + "netuid": number; + "max_registrations_per_block": number; +}; +export type I56j1e9gqlq602 = { + "subnet_owner_cut": number; +}; +export type Ib6k4vik9ruq8h = { + "rate_limit": bigint; +}; +export type I9u9gu9aa92l5m = { + "netuid": number; + "tempo": number; +}; +export type Idmd4tos09qd68 = { + "total_issuance": bigint; +}; +export type Ia0sp2p68e9k16 = { + "immunity_period": bigint; +}; +export type Ie318529rgoagk = { + "lock_cost": bigint; +}; +export type Iam4iou8r3isc1 = { + "max_subnets": number; +}; +export type I21ajnsdtbutjh = { + "interval": bigint; +}; +export type I203rofi4rpmo4 = { + "netuid": number; + "rao_recycled": bigint; +}; +export type I1e290fmo892vi = { + "min_stake": bigint; +}; +export type I71lu4gpn88cf0 = { + "netuid": number; + "alpha_low": number; + "alpha_high": number; +}; +export type I98iornf3ajrp9 = { + "duration": number; +}; +export type I9893mbk9nh201 = { + "netuid": number; + "interval": bigint; +}; +export type I623eo8t3jrbeo = { + "chain_id": bigint; +}; +export type Ieo8qamskgm4dk = { + "next_authorities": Anonymize; + "in_blocks": number; + "forced"?: Anonymize; +}; +export type Ift1efpssa32g2 = { + "netuid": number; + "toggle": boolean; +}; +export type Ibk3v0rrpo1bio = { + "netuid": number; + "recycle_or_burn": Anonymize; +}; +export type I6av3sq9jkhmm3 = { + "alpha": bigint; +}; +export type I70cd7doki8rme = { + "netuid": number; + "ema_halving": bigint; +}; +export type Iam7j42j9f1go6 = { + "netuid": number; + "steepness": number; +}; +export type Idco9ambhipg4i = { + "netuid": number; + "subtoken_enabled": boolean; +}; +export type I6s1nbislhk619 = { + "version": number; +}; +export type I9jtu7slb30qvs = { + "netuid": number; + "immune_neurons": number; +}; +export type Idv3j6a15pjc16 = { + "burn": bigint; +}; +export type I206qvjkjun95i = { + "window": number; +}; +export type I4qhb3plq4ifmq = { + "epochs": number; +}; +export type Ic58lhlh1ocpm1 = { + "netuid": number; + "mechanism_count": number; +}; +export type I6uopd4b2os90n = { + "netuid": number; + "maybe_split"?: Anonymize; +}; +export type I35lk2003i8c8g = (Anonymize) | undefined; +export type I6idbvi8v00o5j = { + "netuid": number; + "max_n": number; +}; +export type Ifbgbhkj74b35k = { + "netuid": number; + "min_allowed_uids": number; +}; +export type Ibt4a800kb7frq = { + "flow_cutoff": bigint; +}; +export type Icb4un8h4cokoo = { + "exponent": bigint; +}; +export type I1up607q6ce947 = { + "smoothing_factor": bigint; +}; +export type I7hktg5sccf8op = { + "max_mechanism_count": number; +}; +export type Ib1d0bomkbrqv1 = { + "netuid": number; + "min": number; +}; +export type Iaflrold1ds0nq = { + "delay": bigint; +}; +export type I48eehof2eias5 = AnonymousEnum<{ + /** + * Enter safe-mode permissionlessly for [`Config::EnterDuration`] blocks. + * + * Reserves [`Config::EnterDepositAmount`] from the caller's account. + * Emits an [`Event::Entered`] event on success. + * Errors with [`Error::Entered`] if the safe-mode is already entered. + * Errors with [`Error::NotConfigured`] if the deposit amount is `None`. + */ + "enter": undefined; + /** + * Enter safe-mode by force for a per-origin configured number of blocks. + * + * Emits an [`Event::Entered`] event on success. + * Errors with [`Error::Entered`] if the safe-mode is already entered. + * + * Can only be called by the [`Config::ForceEnterOrigin`] origin. + */ + "force_enter": undefined; + /** + * Extend the safe-mode permissionlessly for [`Config::ExtendDuration`] blocks. + * + * This accumulates on top of the current remaining duration. + * Reserves [`Config::ExtendDepositAmount`] from the caller's account. + * Emits an [`Event::Extended`] event on success. + * Errors with [`Error::Exited`] if the safe-mode is entered. + * Errors with [`Error::NotConfigured`] if the deposit amount is `None`. + * + * This may be called by any signed origin with [`Config::ExtendDepositAmount`] free + * currency to reserve. This call can be disabled for all origins by configuring + * [`Config::ExtendDepositAmount`] to `None`. + */ + "extend": undefined; + /** + * Extend the safe-mode by force for a per-origin configured number of blocks. + * + * Emits an [`Event::Extended`] event on success. + * Errors with [`Error::Exited`] if the safe-mode is inactive. + * + * Can only be called by the [`Config::ForceExtendOrigin`] origin. + */ + "force_extend": undefined; + /** + * Exit safe-mode by force. + * + * Emits an [`Event::Exited`] with [`ExitReason::Force`] event on success. + * Errors with [`Error::Exited`] if the safe-mode is inactive. + * + * Note: `safe-mode` will be automatically deactivated by [`Pallet::on_initialize`] hook + * after the block height is greater than the [`EnteredUntil`] storage item. + * Emits an [`Event::Exited`] with [`ExitReason::Timeout`] event when deactivated in the + * hook. + */ + "force_exit": undefined; + /** + * Slash a deposit for an account that entered or extended safe-mode at a given + * historical block. + * + * This can only be called while safe-mode is entered. + * + * Emits a [`Event::DepositSlashed`] event on success. + * Errors with [`Error::Entered`] if safe-mode is entered. + * + * Can only be called by the [`Config::ForceDepositOrigin`] origin. + */ + "force_slash_deposit": Anonymize; + /** + * Permissionlessly release a deposit for an account that entered safe-mode at a + * given historical block. + * + * The call can be completely disabled by setting [`Config::ReleaseDelay`] to `None`. + * This cannot be called while safe-mode is entered and not until + * [`Config::ReleaseDelay`] blocks have passed since safe-mode was entered. + * + * Emits a [`Event::DepositReleased`] event on success. + * Errors with [`Error::Entered`] if the safe-mode is entered. + * Errors with [`Error::CannotReleaseYet`] if [`Config::ReleaseDelay`] block have not + * passed since safe-mode was entered. Errors with [`Error::NoDeposit`] if the payee has no + * reserved currency at the block specified. + */ + "release_deposit": Anonymize; + /** + * Force to release a deposit for an account that entered safe-mode at a given + * historical block. + * + * This can be called while safe-mode is still entered. + * + * Emits a [`Event::DepositReleased`] event on success. + * Errors with [`Error::Entered`] if safe-mode is entered. + * Errors with [`Error::NoDeposit`] if the payee has no reserved currency at the + * specified block. + * + * Can only be called by the [`Config::ForceDepositOrigin`] origin. + */ + "force_release_deposit": Anonymize; +}>; +export type I1ssp78ejl639m = { + "account": SS58String; + "block": number; +}; +export type I3lo8is2egp8k4 = AnonymousEnum<{ + /** + * Transact an Ethereum transaction. + */ + "transact": Anonymize; +}>; +export type I13qib3vtm9cs3 = { + "transaction": Anonymize; +}; +export type Iafltn68socb5h = AnonymousEnum<{ + /** + * Withdraw balance from EVM into currency/balances pallet. + */ + "withdraw": Anonymize; + /** + * Issue an EVM call operation. This is similar to a message call transaction in Ethereum. + */ + "call": Anonymize; + /** + * Issue an EVM create operation. This is similar to a contract creation transaction in + * Ethereum. + */ + "create": Anonymize; + /** + * Issue an EVM create2 operation. + */ + "create2": Anonymize; + "set_whitelist": Anonymize; + "disable_whitelist": Anonymize; +}>; +export type Idcabvplu05lea = { + "address": FixedSizeBinary<20>; + "value": bigint; +}; +export type Id38gdpcotl637 = { + "source": FixedSizeBinary<20>; + "target": FixedSizeBinary<20>; + "input": Binary; + "value": Anonymize; + "gas_limit": bigint; + "max_fee_per_gas": Anonymize; + "max_priority_fee_per_gas"?: Anonymize; + "nonce"?: Anonymize; + "access_list": Anonymize; + "authorization_list": Anonymize; +}; +export type Ic4rgfgksgmm3e = (Anonymize) | undefined; +export type I1bsfec060j604 = Array<[FixedSizeBinary<20>, Anonymize]>; +export type I73q3qf5u7nnqg = { + "source": FixedSizeBinary<20>; + "init": Binary; + "value": Anonymize; + "gas_limit": bigint; + "max_fee_per_gas": Anonymize; + "max_priority_fee_per_gas"?: Anonymize; + "nonce"?: Anonymize; + "access_list": Anonymize; + "authorization_list": Anonymize; +}; +export type Idpm1bc2cr6dgj = { + "source": FixedSizeBinary<20>; + "init": Binary; + "salt": FixedSizeBinary<32>; + "value": Anonymize; + "gas_limit": bigint; + "max_fee_per_gas": Anonymize; + "max_priority_fee_per_gas"?: Anonymize; + "nonce"?: Anonymize; + "access_list": Anonymize; + "authorization_list": Anonymize; +}; +export type I837c61fc07ine = { + "new": Anonymize; +}; +export type I6m0oguilvhn8 = { + "disabled": boolean; +}; +export type I2aqcjbjlffus = AnonymousEnum<{ + "set_base_fee_per_gas": Anonymize; + "set_elasticity": Anonymize; +}>; +export type Ibdf4fkp7qcokd = AnonymousEnum<{ + /** + * Verify and write a pulse from the beacon into the runtime + */ + "write_pulse": Anonymize; + /** + * allows the root user to set the beacon configuration + * generally this would be called from an offchain worker context. + * there is no verification of configurations, so be careful with this. + * + * * `origin`: the root user + * * `config`: the beacon configuration + */ + "set_beacon_config": Anonymize; + /** + * allows the root user to set the oldest stored round + */ + "set_oldest_stored_round": Anonymize; +}>; +export type I87tlou92i0bot = { + "pulses_payload": { + "block_number": number; + "pulses": Array>; + "public": MultiSigner; + }; + "signature"?: Anonymize; +}; +export type MultiSigner = Enum<{ + "Ed25519": FixedSizeBinary<32>; + "Sr25519": FixedSizeBinary<32>; + "Ecdsa": FixedSizeBinary<33>; +}>; +export declare const MultiSigner: GetEnum; +export type I86cdjmsf3a81s = (MultiSignature) | undefined; +export type MultiSignature = Enum<{ + "Ed25519": FixedSizeBinary<64>; + "Sr25519": FixedSizeBinary<64>; + "Ecdsa": FixedSizeBinary<65>; +}>; +export declare const MultiSignature: GetEnum; +export type Ifd3mkud9g8rb1 = { + "config_payload": { + "block_number": number; + "config": Anonymize; + "public": MultiSigner; + }; + "signature"?: Anonymize; +}; +export type Iakvbbhvger3oa = { + "oldest_round": bigint; +}; +export type I6nul30pateutj = AnonymousEnum<{ + /** + * Create a crowdloan that will raise funds up to a maximum cap and if successful, + * will transfer funds to the target address if provided and dispatch the call + * (using creator origin). + * + * The initial deposit will be transfered to the crowdloan account and will be refunded + * in case the crowdloan fails to raise the cap. Additionally, the creator will pay for + * the execution of the call. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `deposit`: The initial deposit from the creator. + * - `min_contribution`: The minimum contribution required to contribute to the crowdloan. + * - `cap`: The maximum amount of funds that can be raised. + * - `end`: The block number at which the crowdloan will end. + * - `call`: The call to dispatch when the crowdloan is finalized. + * - `target_address`: The address to transfer the raised funds to if provided. + */ + "create": Anonymize; + /** + * Contribute to an active crowdloan. + * + * The contribution will be transfered to the crowdloan account and will be refunded + * if the crowdloan fails to raise the cap. If the contribution would raise the amount above the cap, + * the contribution will be set to the amount that is left to be raised. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to contribute to. + * - `amount`: The amount to contribute. + */ + "contribute": Anonymize; + /** + * Withdraw a contribution from an active (not yet finalized or dissolved) crowdloan. + * + * Only contributions over the deposit can be withdrawn by the creator. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to withdraw from. + */ + "withdraw": Anonymize; + /** + * Finalize crowdloan that has reached the cap. + * + * The call will transfer the raised amount to the target address if it was provided when the crowdloan was created + * and dispatch the call that was provided using the creator origin. The CurrentCrowdloanId will be set to the + * crowdloan id being finalized so the dispatched call can access it temporarily by accessing + * the `CurrentCrowdloanId` storage item. + * + * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to finalize. + */ + "finalize": Anonymize; + /** + * Refund contributors of a non-finalized crowdloan. + * + * The call will try to refund all contributors (excluding the creator) up to the limit defined by the `RefundContributorsLimit`. + * If the limit is reached, the call will stop and the crowdloan will be marked as partially refunded. + * It may be needed to dispatch this call multiple times to refund all contributors. + * + * The dispatch origin for this call must be _Signed_ and doesn't need to be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to refund. + */ + "refund": Anonymize; + /** + * Dissolve a crowdloan. + * + * The crowdloan will be removed from the storage. + * All contributions must have been refunded before the crowdloan can be dissolved (except the creator's one). + * + * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to dissolve. + */ + "dissolve": Anonymize; + /** + * Update the minimum contribution of a non-finalized crowdloan. + * + * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to update the minimum contribution of. + * - `new_min_contribution`: The new minimum contribution. + */ + "update_min_contribution": Anonymize; + /** + * Update the end block of a non-finalized crowdloan. + * + * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to update the end block of. + * - `new_end`: The new end block. + */ + "update_end": Anonymize; + /** + * Update the cap of a non-finalized crowdloan. + * + * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to update the cap of. + * - `new_cap`: The new cap. + */ + "update_cap": Anonymize; +}>; +export type I92t98snpjjcts = { + "deposit": bigint; + "min_contribution": bigint; + "cap": bigint; + "end": number; + "call"?: (TxCallData) | undefined; + "target_address"?: Anonymize; +}; +export type Iet4pe2le7ku09 = { + "crowdloan_id": number; + "amount": bigint; +}; +export type Id0qcnu1chac12 = AnonymousEnum<{ + /** + * Set the fee rate for swaps on a specific subnet (normalized value). + * For example, 0.3% is approximately 196. + * + * Only callable by the admin origin + */ + "set_fee_rate": Anonymize; + /** + * Enable user liquidity operations for a specific subnet. This switches the + * subnet from V2 to V3 swap mode. Thereafter, adding new user liquidity can be disabled + * by toggling this flag to false, but the swap mode will remain V3 because of existing + * user liquidity until all users withdraw their liquidity. + * + * Only sudo or subnet owner can enable user liquidity. + * Only sudo can disable user liquidity. + */ + "toggle_user_liquidity": Anonymize; + /** + * Add liquidity to a specific price range for a subnet. + * + * Parameters: + * - origin: The origin of the transaction + * - netuid: Subnet ID + * - tick_low: Lower bound of the price range + * - tick_high: Upper bound of the price range + * - liquidity: Amount of liquidity to add + * + * Emits `Event::LiquidityAdded` on success + */ + "add_liquidity": Anonymize; + /** + * Remove liquidity from a specific position. + * + * Parameters: + * - origin: The origin of the transaction + * - netuid: Subnet ID + * - position_id: ID of the position to remove + * + * Emits `Event::LiquidityRemoved` on success + */ + "remove_liquidity": Anonymize; + /** + * Modify a liquidity position. + * + * Parameters: + * - origin: The origin of the transaction + * - netuid: Subnet ID + * - position_id: ID of the position to remove + * - liquidity_delta: Liquidity to add (if positive) or remove (if negative) + * + * Emits `Event::LiquidityRemoved` on success + */ + "modify_position": Anonymize; + /** + * Disable user liquidity in all subnets. + * + * Emits `Event::UserLiquidityToggled` on success + */ + "disable_lp": undefined; +}>; +export type I3mcu79ge1e54v = { + "hotkey": SS58String; + "netuid": number; + "tick_low": number; + "tick_high": number; + "liquidity": bigint; +}; +export type Icf66vuktncksu = { + "hotkey": SS58String; + "netuid": number; + "position_id": bigint; +}; +export type Id69glo8rcjef = { + "hotkey": SS58String; + "netuid": number; + "position_id": bigint; + "liquidity_delta": bigint; +}; +export type I6jivj2j5qp8sa = AnonymousEnum<{ + /** + * Deprecated version if [`Self::call`] for use in an in-storage `Call`. + */ + "call_old_weight": Anonymize; + /** + * Deprecated version if [`Self::instantiate_with_code`] for use in an in-storage `Call`. + */ + "instantiate_with_code_old_weight": Anonymize; + /** + * Deprecated version if [`Self::instantiate`] for use in an in-storage `Call`. + */ + "instantiate_old_weight": Anonymize; + /** + * Upload new `code` without instantiating a contract from it. + * + * If the code does not already exist a deposit is reserved from the caller + * and unreserved only when [`Self::remove_code`] is called. The size of the reserve + * depends on the size of the supplied `code`. + * + * If the code already exists in storage it will still return `Ok` and upgrades + * the in storage version to the current + * [`InstructionWeights::version`](InstructionWeights). + * + * - `determinism`: If this is set to any other value but [`Determinism::Enforced`] then + * the only way to use this code is to delegate call into it from an offchain execution. + * Set to [`Determinism::Enforced`] if in doubt. + * + * # Note + * + * Anyone can instantiate a contract from any uploaded code and thus prevent its removal. + * To avoid this situation a constructor could employ access control so that it can + * only be instantiated by permissioned entities. The same is true when uploading + * through [`Self::instantiate_with_code`]. + * + * Use [`Determinism::Relaxed`] exclusively for non-deterministic code. If the uploaded + * code is deterministic, specifying [`Determinism::Relaxed`] will be disregarded and + * result in higher gas costs. + */ + "upload_code": Anonymize; + /** + * Remove the code stored under `code_hash` and refund the deposit to its owner. + * + * A code can only be removed by its original uploader (its owner) and only if it is + * not used by any contract. + */ + "remove_code": Anonymize; + /** + * Privileged function that changes the code of an existing contract. + * + * This takes care of updating refcounts and all other necessary operations. Returns + * an error if either the `code_hash` or `dest` do not exist. + * + * # Note + * + * This does **not** change the address of the contract in question. This means + * that the contract address is no longer derived from its code hash after calling + * this dispatchable. + */ + "set_code": Anonymize; + /** + * Makes a call to an account, optionally transferring some balance. + * + * # Parameters + * + * * `dest`: Address of the contract to call. + * * `value`: The balance to transfer from the `origin` to `dest`. + * * `gas_limit`: The gas limit enforced when executing the constructor. + * * `storage_deposit_limit`: The maximum amount of balance that can be charged from the + * caller to pay for the storage consumed. + * * `data`: The input data to pass to the contract. + * + * * If the account is a smart-contract account, the associated code will be + * executed and any value will be transferred. + * * If the account is a regular account, any value will be transferred. + * * If no account exists and the call value is not less than `existential_deposit`, + * a regular account will be created and any value will be transferred. + */ + "call": Anonymize; + /** + * Instantiates a new contract from the supplied `code` optionally transferring + * some balance. + * + * This dispatchable has the same effect as calling [`Self::upload_code`] + + * [`Self::instantiate`]. Bundling them together provides efficiency gains. Please + * also check the documentation of [`Self::upload_code`]. + * + * # Parameters + * + * * `value`: The balance to transfer from the `origin` to the newly created contract. + * * `gas_limit`: The gas limit enforced when executing the constructor. + * * `storage_deposit_limit`: The maximum amount of balance that can be charged/reserved + * from the caller to pay for the storage consumed. + * * `code`: The contract code to deploy in raw bytes. + * * `data`: The input data to pass to the contract constructor. + * * `salt`: Used for the address derivation. See [`Pallet::contract_address`]. + * + * Instantiation is executed as follows: + * + * - The supplied `code` is deployed, and a `code_hash` is created for that code. + * - If the `code_hash` already exists on the chain the underlying `code` will be shared. + * - The destination address is computed based on the sender, code_hash and the salt. + * - The smart-contract account is created at the computed address. + * - The `value` is transferred to the new account. + * - The `deploy` function is executed in the context of the newly-created account. + */ + "instantiate_with_code": Anonymize; + /** + * Instantiates a contract from a previously deployed wasm binary. + * + * This function is identical to [`Self::instantiate_with_code`] but without the + * code deployment step. Instead, the `code_hash` of an on-chain deployed wasm binary + * must be supplied. + */ + "instantiate": Anonymize; + /** + * When a migration is in progress, this dispatchable can be used to run migration steps. + * Calls that contribute to advancing the migration have their fees waived, as it's helpful + * for the chain. Note that while the migration is in progress, the pallet will also + * leverage the `on_idle` hooks to run migration steps. + */ + "migrate": Anonymize; +}>; +export type Ia2rnh5pfua40a = { + "dest": MultiAddress; + "value": bigint; + "gas_limit": bigint; + "storage_deposit_limit"?: Anonymize; + "data": Binary; +}; +export type I3otc7e9a35k1k = { + "value": bigint; + "gas_limit": bigint; + "storage_deposit_limit"?: Anonymize; + "code": Binary; + "data": Binary; + "salt": Binary; +}; +export type I89ier5tb9ne0s = { + "value": bigint; + "gas_limit": bigint; + "storage_deposit_limit"?: Anonymize; + "code_hash": FixedSizeBinary<32>; + "data": Binary; + "salt": Binary; +}; +export type Im2f0numhevg3 = { + "code": Binary; + "storage_deposit_limit"?: Anonymize; + "determinism": Anonymize; +}; +export type I2agkcpojhkk43 = { + "dest": MultiAddress; + "code_hash": FixedSizeBinary<32>; +}; +export type I32rvg545edabm = { + "dest": MultiAddress; + "value": bigint; + "gas_limit": Anonymize; + "storage_deposit_limit"?: Anonymize; + "data": Binary; +}; +export type I83fv0vi59md7i = { + "value": bigint; + "gas_limit": Anonymize; + "storage_deposit_limit"?: Anonymize; + "code": Binary; + "data": Binary; + "salt": Binary; +}; +export type I5tjjqcdd4tae0 = { + "value": bigint; + "gas_limit": Anonymize; + "storage_deposit_limit"?: Anonymize; + "code_hash": FixedSizeBinary<32>; + "data": Binary; + "salt": Binary; +}; +export type I1894dm1lf1ae7 = { + "weight_limit": Anonymize; +}; +export type I1o2fkthdkdbjl = AnonymousEnum<{ + /** + * Announce the ML‑KEM public key that will become `CurrentKey` in + * the following block. + */ + "announce_next_key": Anonymize; + /** + * Users submit an encrypted wrapper. + * + * Client‑side: + * + * 1. Read `NextKey` (ML‑KEM public key bytes) from storage. + * 2. Sign your extrinsic so that it can be executed when added to the pool, + * i.e. you may need to increment the nonce if you submit using the same account. + * 3. `commitment = Hashing::hash(signed_extrinsic)`. + * 4. Encrypt: + * + * plaintext = signed_extrinsic + * + * with ML‑KEM‑768 + XChaCha20‑Poly1305, producing + * + * ciphertext = [u16 kem_len] || kem_ct || nonce24 || aead_ct + * + */ + "submit_encrypted": Anonymize; + /** + * Marks a submission as failed to decrypt and removes it from storage. + * + * Called by the block author when decryption fails at any stage (e.g., ML-KEM decapsulate + * failed, AEAD decrypt failed, invalid ciphertext format, etc.). This allows clients to be + * notified of decryption failures through on-chain events. + * + * # Arguments + * + * * `id` - The wrapper id (hash of (author, commitment, ciphertext)) + * * `reason` - Human-readable reason for the decryption failure (e.g., "ML-KEM decapsulate failed") + */ + "mark_decryption_failed": Anonymize; +}>; +export type Idkfsqnep2hpeb = { + "public_key": Binary; +}; +export type I2u5b4034ft9hp = { + "commitment": FixedSizeBinary<32>; + "ciphertext": Binary; +}; +export type I8vbtb6bd00lm0 = AnonymousEnum<{ + "System": Anonymize; + "Timestamp": Anonymize; + "Grandpa": Anonymize; + "Balances": Anonymize; + "SubtensorModule": Anonymize; + "Utility": Anonymize; + "Sudo": Anonymize; + "Multisig": Anonymize; + "Preimage": Anonymize; + "Scheduler": Anonymize; + "Proxy": Anonymize; + "Registry": Anonymize; + "Commitments": Anonymize; + "AdminUtils": Anonymize; + "SafeMode": Anonymize; + "Ethereum": Anonymize; + "EVM": Anonymize; + "BaseFee": Anonymize; + "Drand": Anonymize; + "Crowdloan": Anonymize; + "Swap": Anonymize; + "Contracts": Anonymize; + "MevShield": Anonymize; +}>; +export type Iaqet9jc3ihboe = { + "header": Anonymize; + "extrinsics": Anonymize; +}; +export type Ic952bubvq4k7d = { + "parent_hash": FixedSizeBinary<32>; + "number": number; + "state_root": FixedSizeBinary<32>; + "extrinsics_root": FixedSizeBinary<32>; + "digest": Anonymize; +}; +export type I2v50gu3s1aqk6 = AnonymousEnum<{ + "AllExtrinsics": undefined; + "OnlyInherents": undefined; +}>; +export type Ibmofsd95figtn = ResultPayload, Anonymize>; +export type I5nrjkj9qumobs = AnonymousEnum<{ + "Invalid": Enum<{ + "Call": undefined; + "Payment": undefined; + "Future": undefined; + "Stale": undefined; + "BadProof": undefined; + "AncientBirthBlock": undefined; + "ExhaustsResources": undefined; + "Custom": number; + "BadMandatory": undefined; + "MandatoryValidation": undefined; + "BadSigner": undefined; + "IndeterminateImplicit": undefined; + "UnknownOrigin": undefined; + }>; + "Unknown": TransactionValidityUnknownTransaction; +}>; +export type TransactionValidityUnknownTransaction = Enum<{ + "CannotLookup": undefined; + "NoUnsignedValidator": undefined; + "Custom": number; +}>; +export declare const TransactionValidityUnknownTransaction: GetEnum; +export type If7uv525tdvv7a = Array<[FixedSizeBinary<8>, Binary]>; +export type I2an1fs2eiebjp = { + "okay": boolean; + "fatal_error": boolean; + "errors": Anonymize; +}; +export type Ie9sr1iqcg3cgm = ResultPayload; +export type I1mqgk2tmnn9i2 = (string) | undefined; +export type I6lr8sctk0bi4e = Array; +export type TransactionValidityTransactionSource = Enum<{ + "InBlock": undefined; + "Local": undefined; + "External": undefined; +}>; +export declare const TransactionValidityTransactionSource: GetEnum; +export type I9ask1o4tfvcvs = ResultPayload<{ + "priority": bigint; + "requires": Anonymize; + "provides": Anonymize; + "longevity": bigint; + "propagate": boolean; +}, Anonymize>; +export type Icerf8h8pdu8ss = (Array<[Binary, FixedSizeBinary<4>]>) | undefined; +export type I6spmpef2c7svf = { + "weight": Anonymize; + "class": DispatchClass; + "partial_fee": bigint; +}; +export type Iei2mvq0mjvt81 = { + "inclusion_fee"?: ({ + "base_fee": bigint; + "len_fee": bigint; + "adjusted_weight_fee": bigint; + }) | undefined; + "tip": bigint; +}; +export type If08sfhqn8ujfr = { + "balance": Anonymize; + "nonce": Anonymize; +}; +export type I3dj14b7k3rkm5 = (Anonymize) | undefined; +export type Ic5egmm215ml6k = (Anonymize) | undefined; +export type Ibg4am9lqg35ku = ResultPayload<{ + "exit_reason": Anonymize; + "value": Binary; + "used_gas": Anonymize; + "weight_info"?: Anonymize; + "logs": Anonymize; +}, Anonymize>; +export type I8mgv59to1hjie = { + "standard": Anonymize; + "effective": Anonymize; +}; +export type Ib72ii9bshc8f5 = ({ + "ref_time_limit"?: Anonymize; + "proof_size_limit"?: Anonymize; + "ref_time_usage"?: Anonymize; + "proof_size_usage"?: Anonymize; +}) | undefined; +export type I7efspe2svrt0g = ResultPayload<{ + "exit_reason": Anonymize; + "value": FixedSizeBinary<20>; + "used_gas": Anonymize; + "weight_info"?: Anonymize; + "logs": Anonymize; +}, Anonymize>; +export type I5fvdd841odbi3 = (Anonymize) | undefined; +export type I35vouom6s9r2 = (Anonymize) | undefined; +export type Ie6kgk6f04rsvk = (Anonymize) | undefined; +export type Ifgqf2rskq94om = [Anonymize, Anonymize, Anonymize]; +export type I7aold6s47n103 = [Anonymize, Anonymize]; +export type Ifla7g8u5j9k68 = { + "gas_consumed": Anonymize; + "gas_required": Anonymize; + "storage_deposit": Anonymize; + "debug_message": Binary; + "result": ResultPayload, Anonymize>; + "events"?: Anonymize; +}; +export type If7bmpttbdmqu4 = AnonymousEnum<{ + "Refund": bigint; + "Charge": bigint; +}>; +export type I620n7irgfspm4 = { + "flags": number; + "data": Binary; +}; +export type I6taghk79roh1q = (Anonymize) | undefined; +export type I9sijb8gfrns29 = AnonymousEnum<{ + "Upload": Binary; + "Existing": FixedSizeBinary<32>; +}>; +export type I17s97pb2d5tj3 = { + "gas_consumed": Anonymize; + "gas_required": Anonymize; + "storage_deposit": Anonymize; + "debug_message": Binary; + "result": ResultPayload<{ + "result": Anonymize; + "account_id": SS58String; + }, Anonymize>; + "events"?: Anonymize; +}; +export type I4gah17u2nc33h = ResultPayload<{ + "code_hash": FixedSizeBinary<32>; + "deposit": bigint; +}, Anonymize>; +export type I9u22scd4ksrjm = ResultPayload, Enum<{ + "DoesntExist": undefined; + "KeyDecodingFailed": undefined; + "MigrationInProgress": undefined; +}>>; +export type Ibil6rvg3saeb3 = Array>; +export type I4dh58q3tkaf4j = { + "delegate_ss58": SS58String; + "take": number; + "nominators": Array<[SS58String, Anonymize]>; + "owner_ss58": SS58String; + "registrations": Anonymize; + "validator_permits": Anonymize; + "return_per_1000": bigint; + "total_daily_return": bigint; +}; +export type I97cs1i8k87lnm = (Anonymize) | undefined; +export type I874e758ge6pa9 = Array<[Anonymize, Anonymize]>; +export type I86tq0h1o8f1g5 = Array>; +export type I89nj65vjrv1i8 = { + "hotkey": SS58String; + "coldkey": SS58String; + "uid": number; + "netuid": number; + "active": boolean; + "axon_info": Anonymize; + "prometheus_info": Anonymize; + "stake": Anonymize; + "rank": number; + "emission": bigint; + "incentive": number; + "consensus": number; + "trust": number; + "validator_trust": number; + "dividends": number; + "last_update": bigint; + "validator_permit": boolean; + "weights": Anonymize; + "bonds": Anonymize; + "pruning_score": number; +}; +export type Iba9inugg1atvo = Array>; +export type I78cq8c9mego2f = (Anonymize) | undefined; +export type I64hm01ml98m4p = Array>; +export type If8j022vmi07bv = { + "hotkey": SS58String; + "coldkey": SS58String; + "uid": number; + "netuid": number; + "active": boolean; + "axon_info": Anonymize; + "prometheus_info": Anonymize; + "stake": Anonymize; + "rank": number; + "emission": bigint; + "incentive": number; + "consensus": number; + "trust": number; + "validator_trust": number; + "dividends": number; + "last_update": bigint; + "validator_permit": boolean; + "pruning_score": number; +}; +export type I3gjbugrk45her = (Anonymize) | undefined; +export type I9nvi04b7jiso4 = ({ + "netuid": number; + "rho": number; + "kappa": number; + "difficulty": bigint; + "immunity_period": number; + "max_allowed_validators": number; + "min_allowed_weights": number; + "max_weights_limit": number; + "scaling_law_power": number; + "subnetwork_n": number; + "max_allowed_uids": number; + "blocks_since_last_step": bigint; + "tempo": number; + "network_modality": number; + "network_connect": Anonymize; + "emission_values": bigint; + "burn": bigint; + "owner": SS58String; +}) | undefined; +export type I6s1052v0hl6mr = Array>; +export type I31p8sd8onusg0 = ({ + "netuid": number; + "rho": number; + "kappa": number; + "difficulty": bigint; + "immunity_period": number; + "max_allowed_validators": number; + "min_allowed_weights": number; + "max_weights_limit": number; + "scaling_law_power": number; + "subnetwork_n": number; + "max_allowed_uids": number; + "blocks_since_last_step": bigint; + "tempo": number; + "network_modality": number; + "network_connect": Anonymize; + "emission_value": bigint; + "burn": bigint; + "owner": SS58String; + "identity"?: Anonymize; +}) | undefined; +export type I2vgg418k9gfnm = Array>; +export type I7dp6t7k7a8r36 = ({ + "rho": number; + "kappa": number; + "immunity_period": number; + "min_allowed_weights": number; + "max_weights_limit": number; + "tempo": number; + "min_difficulty": bigint; + "max_difficulty": bigint; + "weights_version": bigint; + "weights_rate_limit": bigint; + "adjustment_interval": number; + "activity_cutoff": number; + "registration_allowed": boolean; + "target_regs_per_interval": number; + "min_burn": bigint; + "max_burn": bigint; + "bonds_moving_avg": bigint; + "max_regs_per_block": number; + "serving_rate_limit": bigint; + "max_validators": number; + "adjustment_alpha": bigint; + "difficulty": bigint; + "commit_reveal_period": bigint; + "commit_reveal_weights_enabled": boolean; + "alpha_high": number; + "alpha_low": number; + "liquid_alpha_enabled": boolean; +}) | undefined; +export type Ibtpedbm9ai3hp = ({ + "rho": number; + "kappa": number; + "immunity_period": number; + "min_allowed_weights": number; + "max_weights_limit": number; + "tempo": number; + "min_difficulty": bigint; + "max_difficulty": bigint; + "weights_version": bigint; + "weights_rate_limit": bigint; + "adjustment_interval": number; + "activity_cutoff": number; + "registration_allowed": boolean; + "target_regs_per_interval": number; + "min_burn": bigint; + "max_burn": bigint; + "bonds_moving_avg": bigint; + "max_regs_per_block": number; + "serving_rate_limit": bigint; + "max_validators": number; + "adjustment_alpha": bigint; + "difficulty": bigint; + "commit_reveal_period": bigint; + "commit_reveal_weights_enabled": boolean; + "alpha_high": number; + "alpha_low": number; + "liquid_alpha_enabled": boolean; + "alpha_sigmoid_steepness": bigint; + "yuma_version": number; + "subnet_is_active": boolean; + "transfers_enabled": boolean; + "bonds_reset_enabled": boolean; + "user_liquidity_enabled": boolean; +}) | undefined; +export type I8ivaf995pho4u = Array>; +export type Ibjoh8vk2j7bqd = ({ + "netuid": number; + "owner_hotkey": SS58String; + "owner_coldkey": SS58String; + "subnet_name": Anonymize; + "token_symbol": Anonymize; + "tempo": number; + "last_step": bigint; + "blocks_since_last_step": bigint; + "emission": bigint; + "alpha_in": bigint; + "alpha_out": bigint; + "tao_in": bigint; + "alpha_out_emission": bigint; + "alpha_in_emission": bigint; + "tao_in_emission": bigint; + "pending_alpha_emission": bigint; + "pending_root_emission": bigint; + "subnet_volume": bigint; + "network_registered_at": bigint; + "subnet_identity"?: Anonymize; + "moving_price": bigint; +}) | undefined; +export type Icr6rj04unermu = Array>; +export type I5gfdo8kg6rloq = ({ + "netuid": number; + "name": Anonymize; + "symbol": Anonymize; + "identity"?: Anonymize; + "network_registered_at": bigint; + "owner_hotkey": SS58String; + "owner_coldkey": SS58String; + "block": bigint; + "tempo": number; + "last_step": bigint; + "blocks_since_last_step": bigint; + "subnet_emission": bigint; + "alpha_in": bigint; + "alpha_out": bigint; + "tao_in": bigint; + "alpha_out_emission": bigint; + "alpha_in_emission": bigint; + "tao_in_emission": bigint; + "pending_alpha_emission": bigint; + "pending_root_emission": bigint; + "subnet_volume": bigint; + "moving_price": bigint; + "rho": number; + "kappa": number; + "min_allowed_weights": number; + "max_weights_limit": number; + "weights_version": bigint; + "weights_rate_limit": bigint; + "activity_cutoff": number; + "max_validators": number; + "num_uids": number; + "max_uids": number; + "burn": bigint; + "difficulty": bigint; + "registration_allowed": boolean; + "pow_registration_allowed": boolean; + "immunity_period": number; + "min_difficulty": bigint; + "max_difficulty": bigint; + "min_burn": bigint; + "max_burn": bigint; + "adjustment_alpha": bigint; + "adjustment_interval": number; + "target_regs_per_interval": number; + "max_regs_per_block": number; + "serving_rate_limit": bigint; + "commit_reveal_weights_enabled": boolean; + "commit_reveal_period": bigint; + "liquid_alpha_enabled": boolean; + "alpha_high": number; + "alpha_low": number; + "bonds_moving_avg": bigint; + "hotkeys": Anonymize; + "coldkeys": Anonymize; + "identities": Anonymize; + "axons": Anonymize; + "active": Anonymize; + "validator_permit": Anonymize; + "pruning_score": Anonymize; + "last_update": Anonymize; + "emission": Anonymize; + "dividends": Anonymize; + "incentives": Anonymize; + "consensus": Anonymize; + "trust": Anonymize; + "rank": Anonymize; + "block_at_registration": Anonymize; + "alpha_stake": Anonymize; + "tao_stake": Anonymize; + "total_stake": Anonymize; + "tao_dividends_per_hotkey": Anonymize; + "alpha_dividends_per_hotkey": Anonymize; +}) | undefined; +export type Iaf9dcc3cspgj7 = Array<(Anonymize) | undefined>; +export type Iemjgg2q8584r9 = Array>; +export type I2u4s5o1c0r3fu = ({ + "netuid": number; + "hotkeys": Anonymize; + "coldkeys": Anonymize; + "active": Anonymize; + "validator_permit": Anonymize; + "pruning_score": Anonymize; + "last_update": Anonymize; + "emission": Anonymize; + "dividends": Anonymize; + "incentives": Anonymize; + "consensus": Anonymize; + "trust": Anonymize; + "rank": Anonymize; + "block_at_registration": Anonymize; + "alpha_stake": Anonymize; + "tao_stake": Anonymize; + "total_stake": Anonymize; + "emission_history": Array>; +}) | undefined; +export type Ic0g2vnp5r296p = ({ + "netuid": number; + "name"?: Anonymize; + "symbol"?: Anonymize; + "identity"?: (Anonymize) | undefined; + "network_registered_at"?: Anonymize; + "owner_hotkey"?: Anonymize; + "owner_coldkey"?: Anonymize; + "block"?: Anonymize; + "tempo"?: Anonymize; + "last_step"?: Anonymize; + "blocks_since_last_step"?: Anonymize; + "subnet_emission"?: Anonymize; + "alpha_in"?: Anonymize; + "alpha_out"?: Anonymize; + "tao_in"?: Anonymize; + "alpha_out_emission"?: Anonymize; + "alpha_in_emission"?: Anonymize; + "tao_in_emission"?: Anonymize; + "pending_alpha_emission"?: Anonymize; + "pending_root_emission"?: Anonymize; + "subnet_volume"?: Anonymize; + "moving_price"?: Anonymize; + "rho"?: Anonymize; + "kappa"?: Anonymize; + "min_allowed_weights"?: Anonymize; + "max_weights_limit"?: Anonymize; + "weights_version"?: Anonymize; + "weights_rate_limit"?: Anonymize; + "activity_cutoff"?: Anonymize; + "max_validators"?: Anonymize; + "num_uids"?: Anonymize; + "max_uids"?: Anonymize; + "burn"?: Anonymize; + "difficulty"?: Anonymize; + "registration_allowed"?: (boolean) | undefined; + "pow_registration_allowed"?: (boolean) | undefined; + "immunity_period"?: Anonymize; + "min_difficulty"?: Anonymize; + "max_difficulty"?: Anonymize; + "min_burn"?: Anonymize; + "max_burn"?: Anonymize; + "adjustment_alpha"?: Anonymize; + "adjustment_interval"?: Anonymize; + "target_regs_per_interval"?: Anonymize; + "max_regs_per_block"?: Anonymize; + "serving_rate_limit"?: Anonymize; + "commit_reveal_weights_enabled"?: (boolean) | undefined; + "commit_reveal_period"?: Anonymize; + "liquid_alpha_enabled"?: (boolean) | undefined; + "alpha_high"?: Anonymize; + "alpha_low"?: Anonymize; + "bonds_moving_avg"?: Anonymize; + "hotkeys"?: (Anonymize) | undefined; + "coldkeys"?: (Anonymize) | undefined; + "identities"?: (Anonymize) | undefined; + "axons"?: (Anonymize) | undefined; + "active"?: (Anonymize) | undefined; + "validator_permit"?: (Anonymize) | undefined; + "pruning_score"?: Anonymize; + "last_update"?: (Anonymize) | undefined; + "emission"?: (Anonymize) | undefined; + "dividends"?: Anonymize; + "incentives"?: Anonymize; + "consensus"?: Anonymize; + "trust"?: Anonymize; + "rank"?: Anonymize; + "block_at_registration"?: (Anonymize) | undefined; + "alpha_stake"?: (Anonymize) | undefined; + "tao_stake"?: (Anonymize) | undefined; + "total_stake"?: (Anonymize) | undefined; + "tao_dividends_per_hotkey"?: (Anonymize) | undefined; + "alpha_dividends_per_hotkey"?: (Anonymize) | undefined; + "validators"?: Anonymize; + "commitments"?: (Array<[SS58String, Anonymize]>) | undefined; +}) | undefined; +export type Ic9fkrj2ggjleq = Array>; +export type I66h6oadnuebe = { + "hotkey": SS58String; + "coldkey": SS58String; + "netuid": number; + "stake": bigint; + "locked": bigint; + "emission": bigint; + "tao_emission": bigint; + "drain": bigint; + "is_registered": boolean; +}; +export type Ifi9cmevnosufh = Array<[SS58String, Anonymize]>; +export type I1i5jfmqcsjper = (Anonymize) | undefined; +export type I3pbrjdm4vnbsa = (Anonymize) | undefined; +export type Iems84l8lk2v0c = { + "slot_duration": bigint; + "epoch_length": bigint; + "c": Anonymize; + "authorities": Anonymize; + "randomness": FixedSizeBinary<32>; + "allowed_slots": BabeAllowedSlots; +}; +export type I200n1ov5tbcvr = FixedSizeArray<2, bigint>; +export type BabeAllowedSlots = Enum<{ + "PrimarySlots": undefined; + "PrimaryAndSecondaryPlainSlots": undefined; + "PrimaryAndSecondaryVRFSlots": undefined; +}>; +export declare const BabeAllowedSlots: GetEnum; +export type I1r5ke30ueqo0r = { + "epoch_index": bigint; + "start_slot": bigint; + "duration": bigint; + "authorities": Anonymize; + "randomness": FixedSizeBinary<32>; + "config": { + "c": Anonymize; + "allowed_slots": BabeAllowedSlots; + }; +}; +export type I68ii5ik8avr9o = { + "offender": FixedSizeBinary<32>; + "slot": bigint; + "first_header": Anonymize; + "second_header": Anonymize; +}; +export type I8slfm2rri67ri = Array<{ + "netuid": number; + "price": bigint; +}>; +export type I34n2itmpoq7on = { + "tao_amount": bigint; + "alpha_amount": bigint; + "tao_fee": bigint; + "alpha_fee": bigint; + "tao_slippage": bigint; + "alpha_slippage": bigint; +}; +export {}; diff --git a/contract-tests/.papi/descriptors/dist/common.d.ts b/contract-tests/.papi/descriptors/dist/common.d.ts new file mode 100644 index 0000000000..28f5c6ce9f --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/common.d.ts @@ -0,0 +1 @@ +export declare const toBinary: (base64: string) => Uint8Array; diff --git a/contract-tests/.papi/descriptors/dist/contracts/bittensor.d.ts b/contract-tests/.papi/descriptors/dist/contracts/bittensor.d.ts new file mode 100644 index 0000000000..ecf845cf6d --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/contracts/bittensor.d.ts @@ -0,0 +1,187 @@ +import type { FixedSizeBinary, SS58String, ResultPayload, Enum, Binary, FixedSizeArray } from 'polkadot-api'; +import type { InkDescriptors } from 'polkadot-api/ink'; +type AnonymousEnum = T & { + __anonymous: true; +}; +type MyTuple = [T, ...T[]]; +type SeparateUndefined = undefined extends T ? undefined | Exclude : T; +type Anonymize = SeparateUndefined ? number extends L ? Binary : FixedSizeBinary : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum ? T : T extends AnonymousEnum ? Enum : T extends MyTuple ? { + [K in keyof T]: T[K]; +} : T extends [] ? [] : T extends FixedSizeArray ? number extends L ? Array : FixedSizeArray : { + [K in keyof T & string]: T[K]; +}>; +type T0 = ResultPayload>; +type T1 = Enum<{ + "CouldNotReadInput": undefined; +}>; +type T2 = Enum<{ + "ReadFailed": undefined; + "WriteFailed": undefined; +}>; +type T3 = ResultPayload>, Anonymize>; +type StorageDescriptor = { + "": { + "key": undefined; + "value": undefined; + }; +}; +type MessagesDescriptor = { + "get_stake_info_for_hotkey_coldkey_netuid": { + "message": { + "hotkey": FixedSizeBinary<32>; + "coldkey": FixedSizeBinary<32>; + "netuid": number; + }; + "response": ResultPayload>, Anonymize>; + }; + "add_stake": { + "message": { + "hotkey": FixedSizeBinary<32>; + "netuid": number; + "amount": bigint; + }; + "response": Anonymize; + }; + "remove_stake": { + "message": { + "hotkey": FixedSizeBinary<32>; + "netuid": number; + "amount": bigint; + }; + "response": Anonymize; + }; + "unstake_all": { + "message": { + "hotkey": FixedSizeBinary<32>; + }; + "response": Anonymize; + }; + "unstake_all_alpha": { + "message": { + "hotkey": FixedSizeBinary<32>; + }; + "response": Anonymize; + }; + "move_stake": { + "message": { + "origin_hotkey": FixedSizeBinary<32>; + "destination_hotkey": FixedSizeBinary<32>; + "origin_netuid": number; + "destination_netuid": number; + "amount": bigint; + }; + "response": Anonymize; + }; + "transfer_stake": { + "message": { + "destination_coldkey": FixedSizeBinary<32>; + "hotkey": FixedSizeBinary<32>; + "origin_netuid": number; + "destination_netuid": number; + "amount": bigint; + }; + "response": Anonymize; + }; + "swap_stake": { + "message": { + "hotkey": FixedSizeBinary<32>; + "origin_netuid": number; + "destination_netuid": number; + "amount": bigint; + }; + "response": Anonymize; + }; + "add_stake_limit": { + "message": { + "hotkey": FixedSizeBinary<32>; + "netuid": number; + "amount": bigint; + "limit_price": bigint; + "allow_partial": boolean; + }; + "response": Anonymize; + }; + "remove_stake_limit": { + "message": { + "hotkey": FixedSizeBinary<32>; + "netuid": number; + "amount": bigint; + "limit_price": bigint; + "allow_partial": boolean; + }; + "response": Anonymize; + }; + "swap_stake_limit": { + "message": { + "hotkey": FixedSizeBinary<32>; + "origin_netuid": number; + "destination_netuid": number; + "amount": bigint; + "limit_price": bigint; + "allow_partial": boolean; + }; + "response": Anonymize; + }; + "remove_stake_full_limit": { + "message": { + "hotkey": FixedSizeBinary<32>; + "netuid": number; + "limit_price": bigint; + }; + "response": Anonymize; + }; + "set_coldkey_auto_stake_hotkey": { + "message": { + "netuid": number; + "hotkey": FixedSizeBinary<32>; + }; + "response": Anonymize; + }; + "add_proxy": { + "message": { + "delegate": FixedSizeBinary<32>; + }; + "response": Anonymize; + }; + "remove_proxy": { + "message": { + "delegate": FixedSizeBinary<32>; + }; + "response": Anonymize; + }; + "get_alpha_price": { + "message": { + "netuid": number; + }; + "response": ResultPayload>, Anonymize>; + }; +}; +type ConstructorsDescriptor = { + /** + * Constructor + */ + "new": { + "message": {}; + "response": Anonymize; + }; + /** + * Constructor + */ + "default": { + "message": {}; + "response": Anonymize; + }; +}; +type EventDescriptor = Enum<{}>; +export declare const descriptor: InkDescriptors; +export {}; diff --git a/contract-tests/.papi/descriptors/dist/contracts/index.d.ts b/contract-tests/.papi/descriptors/dist/contracts/index.d.ts new file mode 100644 index 0000000000..cdd4a702ba --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/contracts/index.d.ts @@ -0,0 +1 @@ +export { descriptor as bittensor } from './bittensor'; diff --git a/contract-tests/.papi/descriptors/dist/descriptors-UMN7HDMZ.mjs b/contract-tests/.papi/descriptors/dist/descriptors-UMN7HDMZ.mjs new file mode 100644 index 0000000000..1a3dfc3a07 --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/descriptors-UMN7HDMZ.mjs @@ -0,0 +1,29 @@ +import "./chunk-7P6ASYW6.mjs"; + +// .papi/descriptors/src/descriptors.ts +var [minified, commonTrees, tokens] = JSON.parse(`[{"devnet":{"storage":{"2":{"0":0,"1":4,"ExtrinsicCount":1,"InherentsApplied":2,"BlockWeight":3,"AllExtrinsicsLen":1,"ExtrinsicData":5,"Number":1,"ParentHash":6,"Digest":7,"Events":8,"EventCount":1,"EventTopics":9,"LastRuntimeUpgrade":10,"UpgradedToU32RefCount":2,"UpgradedToTripleRefCount":2,"ExecutionPhase":11,"AuthorizedUpgrade":12,"ExtrinsicWeightReclaimed":13},"3":{"RandomMaterial":33},"4":{"Now":34,"DidUpdate":2},"6":{"5":33,"CurrentSlot":34},"7":{"5":40,"State":36,"PendingChange":37,"NextForced":1,"Stalled":38,"CurrentSetId":34,"SetIdSession":39},"9":{"0":44,"8":34,"InactiveIssuance":34,"Locks":45,"Reserves":46,"Holds":47,"Freezes":48},"10":{"NextFeeMultiplier":34,"StorageVersion":66},"17":{"8":34,"11":86,"12":86,"13":86,"14":86,"15":112,"16":117,"MinActivityCutoff":1,"AdminFreezeWindow":1,"OwnerHyperparamRateLimit":1,"DissolveNetworkScheduleDuration":1,"LastHotkeySwapOnNetuid":68,"NextStakeJobId":34,"TaoWeight":34,"CKBurn":34,"MaxDelegateTake":1,"MinDelegateTake":1,"MaxChildkeyTake":1,"MinChildkeyTake":1,"Owner":69,"Delegates":70,"ChildkeyTake":71,"PendingChildKeys":72,"ChildKeys":73,"ParentKeys":73,"AlphaDividendsPerSubnet":68,"RootAlphaDividendsPerSubnet":68,"BlockEmission":34,"LastHotkeyEmissionOnNetuid":74,"SubnetLimit":1,"TotalStake":34,"SubnetMovingAlpha":34,"SubnetMovingPrice":75,"RootProp":75,"SubnetVolume":75,"SubnetTAO":75,"SubnetTaoProvided":75,"SubnetAlphaInEmission":75,"SubnetAlphaOutEmission":75,"SubnetTaoInEmission":75,"SubnetAlphaIn":75,"SubnetAlphaInProvided":75,"SubnetAlphaOut":75,"StakingHotkeys":76,"OwnedHotkeys":76,"AutoStakeDestination":77,"AutoStakeDestinationColdkeys":78,"ColdkeySwapAnnouncementDelay":1,"ColdkeySwapReannouncementDelay":1,"ColdkeySwapAnnouncements":79,"ColdkeySwapDisputes":70,"TotalHotkeyAlpha":74,"TotalHotkeyAlphaLastEpoch":74,"TotalHotkeyShares":74,"Alpha":80,"AlphaMapLastKey":81,"TokenSymbol":5,"SubnetTaoFlow":75,"SubnetEmaTaoFlow":82,"TaoFlowCutoff":34,"FlowNormExponent":34,"FlowEmaSmoothingFactor":34,"UsedWork":83,"MaxRegistrationsPerBlock":84,"TotalNetworks":1,"NetworkImmunityPeriod":34,"StartCallDelay":34,"NetworkMinLockCost":34,"NetworkLastLockCost":34,"NetworkLockReductionInterval":34,"SubnetOwnerCut":1,"NetworkRateLimit":34,"NominatorMinRequiredStake":34,"WeightsVersionKeyRateLimit":34,"LastRateLimitedBlock":85,"SubnetLocked":75,"LargestLocked":75,"Tempo":84,"FirstEmissionBlockNumber":75,"SubnetMechanism":84,"SubnetworkN":84,"NetworksAdded":86,"IsNetworkMember":87,"NetworkRegistrationAllowed":86,"NetworkPowRegistrationAllowed":86,"NetworkRegisteredAt":75,"PendingServerEmission":75,"PendingValidatorEmission":75,"PendingRootAlphaDivs":75,"PendingOwnerCut":75,"BlocksSinceLastStep":75,"LastMechansimStepBlock":75,"SubnetOwner":88,"SubnetOwnerHotkey":88,"RecycleOrBurn":89,"ServingRateLimit":75,"Rho":84,"AlphaSigmoidSteepness":84,"Kappa":84,"RegistrationsThisInterval":84,"POWRegistrationsThisInterval":84,"BurnRegistrationsThisInterval":84,"MinAllowedUids":84,"MaxAllowedUids":84,"ImmunityPeriod":84,"ActivityCutoff":84,"MaxWeightsLimit":84,"WeightsVersionKey":75,"MinAllowedWeights":84,"MaxAllowedValidators":84,"AdjustmentInterval":84,"BondsMovingAverage":75,"BondsPenalty":84,"BondsResetOn":86,"WeightsSetRateLimit":75,"ValidatorPruneLen":75,"ScalingLawPower":84,"TargetRegistrationsPerInterval":84,"AdjustmentAlpha":75,"CommitRevealWeightsEnabled":86,"Burn":75,"Difficulty":75,"MinBurn":75,"MaxBurn":75,"MinDifficulty":75,"MaxDifficulty":75,"LastAdjustmentBlock":75,"RegistrationsThisBlock":84,"EMAPriceHalvingBlocks":75,"RAORecycledForRegistration":75,"TxRateLimit":34,"TxDelegateTakeRateLimit":34,"TxChildkeyTakeRateLimit":34,"AlphaValues":90,"SubtokenEnabled":86,"VotingPower":68,"VotingPowerDisableAtBlock":75,"VotingPowerEmaAlpha":75,"ImmuneOwnerUidsLimit":84,"StakeWeight":91,"Uids":92,"Keys":93,"LoadedEmission":94,"Active":95,"Rank":91,"Trust":91,"Consensus":91,"Incentive":91,"Dividends":91,"Emission":96,"LastUpdate":96,"ValidatorTrust":91,"PruningScores":91,"ValidatorPermit":95,"Weights":97,"Bonds":97,"BlockAtRegistration":98,"Axons":99,"NeuronCertificates":100,"Prometheus":101,"IdentitiesV2":102,"SubnetIdentitiesV3":103,"TransactionKeyLastBlock":104,"LastTxBlock":105,"LastTxBlockChildKeyTake":105,"LastTxBlockDelegateTake":105,"StakeThreshold":34,"WeightCommits":106,"TimelockedWeightCommits":107,"CRV3WeightCommits":108,"CRV3WeightCommitsV2":107,"RevealPeriodEpochs":75,"LastColdkeyHotkeyStakeBlock":109,"StakingOperationRateLimiter":110,"RootClaimableThreshold":75,"RootClaimable":111,"RootClaimType":113,"StakingColdkeysByIndex":114,"StakingColdkeys":105,"NumStakingColdkeys":34,"NumRootClaim":34,"AssociatedEvmAddress":115,"SubnetLeases":116,"SubnetLeaseShares":68,"SubnetUidToLeaseId":84,"NextSubnetLeaseId":1,"AccumulatedLeaseDividends":75,"CommitRevealWeightsVersion":1,"NetworkRegistrationStartBlock":34,"MinNonImmuneUids":84,"MaxMechanismCount":1,"MechanismCountCurrent":84,"MechanismEmissionSplit":91,"PendingChildKeyCooldown":34},"18":0,"19":{"Key":228},"20":{"Multisigs":234},"21":{"StatusFor":245,"RequestStatusFor":246,"PreimageFor":247},"22":{"IncompleteSince":1,"Agenda":252,"Retries":253,"Lookup":254},"23":{"Proxies":269,"Announcements":270,"LastCallResult":271},"24":{"IdentityOf":286},"25":{"TimelockedIndex":289,"CommitmentOf":290,"LastCommitment":92,"LastBondsReset":92,"RevealedCommitments":291,"UsedSpaceOf":292,"MaxSpace":1},"26":{"PrecompileEnable":297},"27":{"EnteredUntil":1,"Deposits":74},"28":{"1":371,"Pending":367,"CounterForPending":1,"CurrentBlock":368,"CurrentReceipts":369,"CurrentTransactionStatuses":370},"29":{"AccountCodes":374,"AccountCodesMetadata":375,"AccountStorages":376,"WhitelistedCreators":377,"DisableWhitelistCheck":2},"30":{"ChainId":34},"31":{"BaseFeePerGas":386,"Elasticity":1},"32":{"16":117,"BeaconConfig":391,"Pulses":392,"LastStoredRound":34,"OldestStoredRound":34,"NextUnsignedAt":1},"33":{"16":117,"Crowdloans":397,"NextCrowdloanId":1,"Contributions":68,"CurrentCrowdloanId":1},"34":{"FeeRate":84,"FeeGlobalTao":75,"FeeGlobalAlpha":75,"Ticks":411,"SwapV3Initialized":86,"AlphaSqrtPrice":75,"CurrentTick":84,"CurrentLiquidity":75,"EnabledUserLiquidity":86,"Positions":412,"LastPositionId":34,"TickIndexBitmapWords":413,"ScrapReservoirTao":75,"ScrapReservoirAlpha":75},"35":{"PristineCode":423,"CodeInfoOf":424,"Nonce":34,"ContractInfoOf":425,"DeletionQueue":5,"DeletionQueueCounter":426,"MigrationInProgress":427},"36":{"CurrentKey":427,"NextKey":427,"Submissions":447,"KeyHashByBlock":4}},"tx":{"2":{"37":20,"remark":18,"set_heap_pages":19,"set_code_without_checks":20,"set_storage":21,"kill_storage":22,"kill_prefix":23,"remark_with_event":18,"authorize_upgrade":24,"authorize_upgrade_without_checks":24,"apply_authorized_upgrade":20},"3":0,"4":{"set":35},"6":0,"7":{"report_equivocation":41,"report_equivocation_unsigned":41,"note_stalled":42},"9":{"transfer_allow_death":49,"force_transfer":50,"transfer_keep_alive":49,"transfer_all":51,"force_unreserve":52,"upgrade_accounts":53,"force_set_balance":54,"force_adjust_total_issuance":55,"burn":56},"10":0,"17":{"38":146,"set_weights":118,"set_mechanism_weights":119,"batch_set_weights":120,"commit_weights":121,"commit_mechanism_weights":122,"batch_commit_weights":123,"reveal_weights":124,"reveal_mechanism_weights":125,"commit_crv3_mechanism_weights":126,"batch_reveal_weights":127,"decrease_take":128,"increase_take":128,"add_stake":129,"remove_stake":130,"serve_axon":131,"serve_axon_tls":132,"serve_prometheus":133,"register":134,"root_register":135,"burned_register":136,"swap_hotkey":137,"swap_coldkey":138,"set_childkey_take":139,"sudo_set_tx_childkey_take_rate_limit":140,"sudo_set_min_childkey_take":141,"sudo_set_max_childkey_take":141,"register_network":135,"faucet":142,"dissolve_network":143,"set_children":144,"schedule_swap_coldkey":145,"set_subnet_identity":147,"register_network_with_identity":148,"unstake_all":135,"unstake_all_alpha":135,"move_stake":149,"transfer_stake":150,"swap_stake":151,"add_stake_limit":152,"remove_stake_limit":153,"swap_stake_limit":154,"try_associate_hotkey":135,"start_call":155,"associate_evm_key":156,"recycle_alpha":157,"burn_alpha":157,"set_pending_childkey_cooldown":158,"remove_stake_full_limit":159,"register_leased_network":160,"terminate_lease":161,"update_symbol":162,"commit_timelocked_weights":163,"set_coldkey_auto_stake_hotkey":136,"commit_timelocked_mechanism_weights":164,"root_dissolve_network":155,"claim_root":165,"set_root_claim_type":166,"sudo_set_num_root_claims":167,"sudo_set_root_claim_threshold":168,"announce_coldkey_swap":169,"swap_coldkey_announced":145,"dispute_coldkey_swap":170,"reset_coldkey_swap":171,"enable_voting_power_tracking":155,"disable_voting_power_tracking":155,"sudo_set_voting_power_ema_alpha":172,"add_stake_burn":173},"18":{"batch":219,"as_derivative":220,"batch_all":219,"dispatch_as":221,"force_batch":219,"with_weight":222,"if_else":223,"dispatch_as_fallible":221},"19":{"sudo":229,"sudo_unchecked_weight":222,"set_key":230,"sudo_as":231,"remove_key":170},"20":{"39":239,"as_multi_threshold_1":235,"as_multi":236,"approve_as_multi":237,"cancel_as_multi":238},"21":{"note_preimage":248,"unnote_preimage":249,"request_preimage":249,"unrequest_preimage":249,"ensure_updated":250},"22":{"schedule":255,"cancel":256,"schedule_named":257,"cancel_named":258,"schedule_after":259,"schedule_named_after":260,"set_retry":261,"set_retry_named":262,"cancel_retry":263,"cancel_retry_named":258},"23":{"39":170,"proxy":274,"add_proxy":275,"remove_proxy":275,"remove_proxies":170,"create_pure":276,"kill_pure":277,"announce":278,"remove_announcement":278,"reject_announcement":279,"proxy_announced":280},"24":{"38":287,"clear_identity":288},"25":{"set_commitment":293,"set_max_space":294},"26":{"swap_authorities":298,"sudo_set_default_take":299,"sudo_set_tx_rate_limit":140,"sudo_set_serving_rate_limit":300,"sudo_set_min_difficulty":301,"sudo_set_max_difficulty":302,"sudo_set_weights_version_key":303,"sudo_set_weights_set_rate_limit":304,"sudo_set_adjustment_interval":305,"sudo_set_adjustment_alpha":306,"sudo_set_immunity_period":307,"sudo_set_min_allowed_weights":308,"sudo_set_max_allowed_uids":309,"sudo_set_kappa":310,"sudo_set_rho":311,"sudo_set_activity_cutoff":312,"sudo_set_network_registration_allowed":313,"sudo_set_network_pow_registration_allowed":313,"sudo_set_target_registrations_per_interval":314,"sudo_set_min_burn":315,"sudo_set_max_burn":316,"sudo_set_difficulty":317,"sudo_set_max_allowed_validators":318,"sudo_set_bonds_moving_average":319,"sudo_set_bonds_penalty":320,"sudo_set_max_registrations_per_block":321,"sudo_set_subnet_owner_cut":322,"sudo_set_network_rate_limit":323,"sudo_set_tempo":324,"sudo_set_total_issuance":325,"sudo_set_network_immunity_period":326,"sudo_set_network_min_lock_cost":327,"sudo_set_subnet_limit":328,"sudo_set_lock_reduction_interval":329,"sudo_set_rao_recycled":330,"sudo_set_stake_threshold":331,"sudo_set_nominator_min_required_stake":331,"sudo_set_tx_delegate_take_rate_limit":140,"sudo_set_min_delegate_take":141,"sudo_set_commit_reveal_weights_enabled":332,"sudo_set_liquid_alpha_enabled":332,"sudo_set_alpha_values":333,"sudo_set_dissolve_network_schedule_duration":334,"sudo_set_commit_reveal_weights_interval":335,"sudo_set_evm_chain_id":336,"schedule_grandpa_change":337,"sudo_set_toggle_transfer":338,"sudo_set_recycle_or_burn":339,"sudo_toggle_evm_precompile":340,"sudo_set_subnet_moving_alpha":341,"sudo_set_subnet_owner_hotkey":136,"sudo_set_ema_price_halving_period":342,"sudo_set_alpha_sigmoid_steepness":343,"sudo_set_yuma3_enabled":332,"sudo_set_bonds_reset_enabled":332,"sudo_set_sn_owner_hotkey":136,"sudo_set_subtoken_enabled":344,"sudo_set_commit_reveal_version":345,"sudo_set_owner_immune_neuron_limit":346,"sudo_set_ck_burn":347,"sudo_set_admin_freeze_window":348,"sudo_set_owner_hparam_rate_limit":349,"sudo_set_mechanism_count":350,"sudo_set_mechanism_emission_split":351,"sudo_trim_to_max_allowed_uids":352,"sudo_set_min_allowed_uids":353,"sudo_set_tao_flow_cutoff":354,"sudo_set_tao_flow_normalization_exponent":355,"sudo_set_tao_flow_smoothing_factor":356,"sudo_set_max_mechanism_count":357,"sudo_set_min_non_immune_uids":358,"sudo_set_start_call_delay":359,"sudo_set_coldkey_swap_announcement_delay":334,"sudo_set_coldkey_swap_reannouncement_delay":334},"27":{"enter":170,"force_enter":170,"extend":170,"force_extend":170,"force_exit":170,"force_slash_deposit":364,"release_deposit":364,"force_release_deposit":364},"28":{"transact":372},"29":{"40":378,"41":379,"42":380,"create2":381,"set_whitelist":382,"disable_whitelist":383},"30":0,"31":{"set_base_fee_per_gas":387,"set_elasticity":388},"32":{"write_pulse":393,"set_beacon_config":394,"set_oldest_stored_round":395},"33":{"40":401,"42":399,"contribute":400,"finalize":401,"refund":401,"dissolve":401,"update_min_contribution":402,"update_end":403,"update_cap":404},"34":{"set_fee_rate":414,"toggle_user_liquidity":415,"add_liquidity":416,"remove_liquidity":417,"modify_position":418,"disable_lp":170},"35":{"37":434,"41":435,"43":433,"44":437,"call_old_weight":430,"instantiate_with_code_old_weight":431,"instantiate_old_weight":432,"remove_code":24,"instantiate_with_code":436,"migrate":438},"36":{"announce_next_key":448,"submit_encrypted":449,"mark_decryption_failed":450}},"events":{"2":{"ExtrinsicSuccess":25,"ExtrinsicFailed":26,"CodeUpdated":27,"NewAccount":28,"KilledAccount":28,"Remarked":29,"UpgradeAuthorized":30,"RejectedInvalidAuthorizedUpgrade":31},"3":0,"4":0,"6":0,"7":{"NewAuthorities":43,"Paused":27,"Resumed":27},"9":{"Endowed":57,"DustLost":58,"Transfer":59,"BalanceSet":60,"Reserved":61,"Unreserved":61,"ReserveRepatriated":62,"Deposit":61,"Withdraw":61,"Slashed":61,"Minted":61,"Burned":61,"Suspended":61,"Restored":61,"Upgraded":63,"Issued":64,"Rescinded":64,"Locked":61,"Unlocked":61,"Frozen":61,"Thawed":61,"TotalIssuanceForced":65},"10":{"TransactionFeePaid":67},"17":{"11":181,"14":214,"15":191,"45":186,"46":27,"NetworkAdded":174,"NetworkRemoved":175,"StakeAdded":176,"StakeRemoved":176,"StakeMoved":177,"WeightsSet":174,"NeuronRegistered":178,"BulkNeuronsRegistered":174,"BulkBalancesSet":174,"MaxAllowedUidsSet":174,"MaxWeightLimitSet":174,"DifficultySet":179,"AdjustmentIntervalSet":174,"RegistrationPerIntervalSet":174,"MaxRegistrationsPerBlockSet":174,"ActivityCutoffSet":174,"RhoSet":174,"AlphaSigmoidSteepnessSet":180,"KappaSet":174,"MinAllowedWeightSet":174,"ValidatorPruneLenSet":179,"ScalingLawPowerSet":174,"WeightsSetRateLimitSet":179,"ImmunityPeriodSet":174,"BondsMovingAverageSet":179,"BondsPenaltySet":174,"BondsResetOnSet":181,"MaxAllowedValidatorsSet":174,"AxonServed":182,"PrometheusServed":182,"DelegateAdded":183,"DefaultTakeSet":175,"WeightsVersionKeySet":179,"MinDifficultySet":179,"MaxDifficultySet":179,"ServingRateLimitSet":179,"BurnSet":179,"MaxBurnSet":179,"MinBurnSet":179,"TxRateLimitSet":184,"TxDelegateTakeRateLimitSet":184,"TxChildKeyTakeRateLimitSet":184,"AdminFreezeWindowSet":175,"OwnerHyperparamRateLimitSet":175,"MinChildKeyTakeSet":175,"MaxChildKeyTakeSet":175,"ChildKeyTakeSet":185,"RegistrationAllowed":181,"PowRegistrationAllowed":181,"TempoSet":174,"RAORecycledForRegistrationSet":179,"StakeThresholdSet":184,"AdjustmentAlphaSet":179,"Faucet":187,"SubnetOwnerCutSet":175,"NetworkRateLimitSet":184,"NetworkImmunityPeriodSet":184,"StartCallDelaySet":184,"NetworkMinLockCostSet":184,"SubnetLimitSet":175,"NetworkLockCostReductionIntervalSet":184,"TakeDecreased":183,"TakeIncreased":183,"HotkeySwapped":188,"MaxDelegateTakeSet":175,"MinDelegateTakeSet":175,"ColdkeySwapAnnounced":189,"ColdkeySwapReset":63,"ColdkeySwapped":190,"ColdkeySwapDisputed":191,"AllBalanceUnstakedAndTransferredToNewColdkey":192,"ArbitrationPeriodExtended":191,"SetChildrenScheduled":193,"SetChildren":194,"ChainIdentitySet":195,"SubnetIdentitySet":175,"SubnetIdentityRemoved":175,"DissolveNetworkScheduled":196,"ColdkeySwapAnnouncementDelaySet":175,"ColdkeySwapReannouncementDelaySet":175,"DissolveNetworkScheduleDurationSet":175,"CRV3WeightsCommitted":197,"WeightsCommitted":197,"WeightsRevealed":197,"WeightsBatchRevealed":198,"BatchWeightsCompleted":199,"BatchWeightItemFailed":200,"StakeTransferred":201,"StakeSwapped":202,"SubnetOwnerHotkeySet":182,"FirstEmissionBlockNumberSet":179,"AlphaRecycled":203,"AlphaBurned":203,"EvmKeyAssociated":204,"CRV3WeightsRevealed":182,"CommitRevealPeriodsSet":179,"CommitRevealEnabled":181,"HotkeySwappedOnSubnet":205,"SubnetLeaseCreated":206,"SubnetLeaseTerminated":207,"SymbolUpdated":208,"CommitRevealVersionSet":175,"TimelockedWeightsCommitted":209,"TimelockedWeightsRevealed":182,"AutoStakeAdded":210,"IncentiveAlphaEmittedToMiners":211,"MinAllowedUidsSet":174,"AutoStakeDestinationSet":212,"MinNonImmuneUidsSet":174,"RootClaimTypeSet":213,"VotingPowerTrackingDisableScheduled":215,"VotingPowerTrackingDisabled":214,"VotingPowerEmaAlphaSet":216,"SubnetLeaseDividendsDistributed":217,"AddStakeBurn":218},"18":{"46":27,"BatchInterrupted":224,"BatchCompleted":27,"ItemCompleted":27,"ItemFailed":225,"DispatchedAs":226,"IfElseMainSuccess":27,"IfElseFallbackCalled":227},"19":{"45":232,"KeyChanged":233,"KeyRemoved":27,"SudoAsDone":232},"20":{"47":244,"NewMultisig":240,"MultisigApproval":241,"MultisigExecuted":242,"MultisigCancelled":243},"21":{"Noted":251,"Requested":251,"Cleared":251},"22":{"Scheduled":264,"Canceled":264,"Dispatched":265,"RetrySet":266,"RetryCancelled":267,"CallUnavailable":267,"PeriodicFailed":267,"RetryFailed":267,"PermanentlyOverweight":267,"AgendaIncomplete":268},"23":{"47":285,"ProxyExecuted":226,"PureCreated":281,"PureKilled":282,"Announced":283,"ProxyAdded":284,"ProxyRemoved":284},"24":{"IdentitySet":63,"IdentityDissolved":63},"25":{"Commitment":295,"TimelockCommitment":296,"CommitmentRevealed":295},"26":{"PrecompileUpdated":360,"Yuma3EnableToggled":361,"BondsResetToggled":361},"27":{"Entered":365,"Extended":365,"Exited":366,"DepositPlaced":58,"DepositReleased":58,"DepositSlashed":58,"CannotDeposit":27,"CannotRelease":27},"28":{"48":373},"29":{"48":385,"49":385,"Log":384,"CreatedFailed":385,"ExecutedFailed":385},"30":0,"31":{"NewBaseFeePerGas":389,"BaseFeeOverflow":27,"NewElasticity":390},"32":{"BeaconConfigChanged":27,"NewPulse":396,"SetOldestStoredRound":184},"33":{"49":405,"Contributed":406,"Withdrew":406,"PartiallyRefunded":407,"AllRefunded":407,"Finalized":407,"Dissolved":407,"MinContributionUpdated":408,"EndUpdated":409,"CapUpdated":410},"34":{"FeeRateSet":419,"UserLiquidityToggled":420,"LiquidityAdded":421,"LiquidityRemoved":422,"LiquidityModified":422},"35":{"Instantiated":439,"Terminated":440,"CodeStored":441,"ContractEmitted":442,"CodeRemoved":443,"ContractCodeUpdated":444,"Called":445,"DelegateCalled":446,"StorageDepositTransferredAndHeld":59,"StorageDepositTransferredAndReleased":59},"36":{"EncryptedSubmitted":451,"DecryptedExecuted":452,"DecryptedRejected":453,"DecryptionFailed":454}},"constants":{"2":{"BlockWeights":14,"BlockLength":15,"BlockHashCount":1,"DbWeight":16,"Version":17,"SS58Prefix":1},"3":0,"4":{"MinimumPeriod":34},"6":{"SlotDuration":34},"7":{"MaxAuthorities":1,"MaxNominators":1,"MaxSetIdSessionEntries":34},"9":{"ExistentialDeposit":34,"MaxLocks":1,"MaxReserves":1,"MaxFreezes":1},"10":{"OperationalFeeMultiplier":1},"17":{"12":2,"13":2,"InitialIssuance":34,"InitialMinAllowedWeights":1,"InitialEmissionValue":1,"InitialTempo":1,"InitialDifficulty":34,"InitialMaxDifficulty":34,"InitialMinDifficulty":34,"InitialRAORecycledForRegistration":34,"InitialBurn":34,"InitialMaxBurn":34,"InitialMinBurn":34,"MinBurnUpperBound":34,"MaxBurnLowerBound":34,"InitialAdjustmentInterval":1,"InitialBondsMovingAverage":34,"InitialBondsPenalty":1,"InitialBondsResetOn":2,"InitialTargetRegistrationsPerInterval":1,"InitialRho":1,"InitialAlphaSigmoidSteepness":1,"InitialKappa":1,"InitialMinAllowedUids":1,"InitialMaxAllowedUids":1,"InitialValidatorPruneLen":34,"InitialScalingLawPower":1,"InitialImmunityPeriod":1,"InitialActivityCutoff":1,"InitialMaxRegistrationsPerBlock":1,"InitialPruningScore":1,"InitialMaxAllowedValidators":1,"InitialDefaultDelegateTake":1,"InitialMinDelegateTake":1,"InitialDefaultChildKeyTake":1,"InitialMinChildKeyTake":1,"InitialMaxChildKeyTake":1,"InitialWeightsVersionKey":34,"InitialServingRateLimit":34,"InitialTxRateLimit":34,"InitialTxDelegateTakeRateLimit":34,"InitialTxChildKeyTakeRateLimit":34,"InitialAdjustmentAlpha":34,"InitialNetworkImmunityPeriod":34,"InitialNetworkMinLockCost":34,"InitialSubnetOwnerCut":1,"InitialNetworkLockReductionInterval":34,"InitialNetworkRateLimit":34,"KeySwapCost":34,"AlphaHigh":1,"AlphaLow":1,"InitialColdkeySwapAnnouncementDelay":1,"InitialColdkeySwapReannouncementDelay":1,"InitialDissolveNetworkScheduleDuration":1,"InitialTaoWeight":34,"InitialEmaPriceHalvingPeriod":34,"InitialStartCallDelay":34,"KeySwapOnSubnetCost":34,"HotkeySwapOnSubnetInterval":34,"LeaseDividendsDistributionInterval":1,"MaxImmuneUidsPercentage":1},"18":{"batched_calls_limit":1},"19":0,"20":{"DepositBase":34,"DepositFactor":34,"MaxSignatories":1},"21":0,"22":{"MaximumWeight":13,"MaxScheduledPerBlock":1},"23":{"ProxyDepositBase":34,"ProxyDepositFactor":34,"MaxProxies":1,"MaxPending":1,"AnnouncementDepositBase":34,"AnnouncementDepositFactor":34},"24":{"50":34,"51":34,"MaxAdditionalFields":1},"25":{"50":34,"51":34,"MaxFields":1},"26":0,"27":{"EnterDuration":1,"ExtendDuration":1,"EnterDepositAmount":362,"ExtendDepositAmount":362,"ReleaseDelay":363},"28":0,"29":0,"30":0,"31":0,"32":{"UnsignedPriority":34,"HttpFetchTimeout":34},"33":{"PalletId":398,"MinimumDeposit":34,"AbsoluteMinimumContribution":34,"MinimumBlockDuration":1,"MaximumBlockDuration":1,"RefundContributorsLimit":1,"MaxContributors":1},"34":{"ProtocolId":398,"MaxFeeRate":1,"MaxPositions":1,"MinimumLiquidity":34,"MinimumReserve":34},"35":{"Schedule":428,"DepositPerByte":34,"DefaultDepositLimit":34,"DepositPerItem":34,"CodeHashLockupDepositPercent":1,"MaxCodeLen":1,"MaxStorageKeyLen":1,"MaxTransientStorageSize":1,"MaxDelegateDependencies":1,"UnsafeUnstableInterface":2,"MaxDebugBufferLen":1,"Environment":429,"ApiVersion":1},"36":0},"viewFns":{"2":0,"3":0,"4":0,"6":0,"7":0,"9":0,"10":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":{"check_permissions":272,"is_superset":273},"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0},"apis":{"Core":{"version":455,"execute_block":456,"initialize_block":457},"Metadata":{"metadata":458,"metadata_at_version":459,"metadata_versions":460},"BlockBuilder":{"apply_extrinsic":461,"finalize_block":462,"inherent_extrinsics":463,"check_inherents":464},"GenesisBuilder":{"build_state":465,"get_preset":466,"preset_names":467},"TaggedTransactionQueue":{"validate_transaction":468},"OffchainWorkerApi":{"offchain_worker":469},"AuraApi":{"slot_duration":470,"authorities":471},"SessionKeys":{"generate_session_keys":472,"decode_session_keys":473},"GrandpaApi":{"52":475,"53":476,"grandpa_authorities":474,"current_set_id":470},"AccountNonceApi":{"account_nonce":477},"TransactionPaymentApi":{"54":480,"55":481,"query_info":478,"query_fee_details":479},"TransactionPaymentCallApi":{"54":480,"55":481,"query_call_info":482,"query_call_fee_details":483},"EthereumRuntimeRPCApi":{"41":489,"42":490,"chain_id":470,"account_basic":484,"gas_price":485,"account_code_at":486,"author":487,"storage_at":488,"current_block":491,"current_receipts":492,"current_transaction_statuses":493,"current_all":494,"extrinsic_filter":495,"elasticity":496,"gas_limit_multiplier_support":497,"pending_block":498,"initialize_pending_block":469},"ConvertTransactionRuntimeApi":{"convert_transaction":499},"ContractsApi":{"41":500,"43":502,"44":501,"get_storage":503},"DelegateInfoRuntimeApi":{"get_delegates":504,"get_delegate":505,"get_delegated":506},"NeuronInfoRuntimeApi":{"get_neurons":507,"get_neuron":508,"get_neurons_lite":509,"get_neuron_lite":510},"SubnetInfoRuntimeApi":{"get_subnet_info":511,"get_subnets_info":512,"get_subnet_info_v2":513,"get_subnets_info_v2":514,"get_subnet_hyperparams":515,"get_subnet_hyperparams_v2":516,"get_all_dynamic_info":517,"get_all_metagraphs":518,"get_metagraph":519,"get_all_mechagraphs":518,"get_mechagraph":520,"get_dynamic_info":521,"get_subnet_state":522,"get_selective_metagraph":523,"get_coldkey_auto_stake_hotkey":524,"get_selective_mechagraph":525,"get_subnet_to_prune":496},"StakeInfoRuntimeApi":{"get_stake_info_for_coldkey":526,"get_stake_info_for_coldkeys":527,"get_stake_info_for_hotkey_coldkey_netuid":528,"get_stake_fee":529},"SubnetRegistrationRuntimeApi":{"get_network_registration_cost":470},"BabeApi":{"52":533,"53":532,"configuration":530,"current_epoch_start":470,"current_epoch":531,"next_epoch":531},"SwapRuntimeApi":{"current_alpha_price":534,"current_alpha_price_all":535,"sim_swap_tao_for_alpha":536,"sim_swap_alpha_for_tao":537}}}},[{}],["Account","BlockHash","System","RandomnessCollectiveFlip","Timestamp","Authorities","Aura","Grandpa","TotalIssuance","Balances","TransactionPayment","TransferToggle","LiquidAlphaOn","Yuma3On","VotingPowerTrackingEnabled","RootClaimed","HasMigrationRun","SubtensorModule","Utility","Sudo","Multisig","Preimage","Scheduler","Proxy","Registry","Commitments","AdminUtils","SafeMode","Ethereum","EVM","EVMChainId","BaseFee","Drand","Crowdloan","Swap","Contracts","MevShield","set_code","set_identity","poke_deposit","withdraw","call","create","upload_code","instantiate","Sudid","BatchCompletedWithErrors","DepositPoked","Executed","Created","InitialDeposit","FieldDeposit","submit_report_equivocation_unsigned_extrinsic","generate_key_ownership_proof","query_weight_to_fee","query_length_to_fee"]]`); +var replaceTokens = (obj) => Object.fromEntries( + Object.entries(obj).map(([key, value]) => { + const unwrappedValue = typeof value === "object" ? replaceTokens(value) : value; + const numericKey = Number(key); + if (Number.isNaN(numericKey)) { + return [key, unwrappedValue]; + } + return [tokens[numericKey], unwrappedValue]; + }) +); +var tokenizedCommonTrees = commonTrees.map(replaceTokens); +var unwrap = (obj, depth) => depth === 0 ? obj : Object.fromEntries( + Object.entries(obj).map(([key, value]) => [ + key, + unwrap( + typeof value === "object" ? value : tokenizedCommonTrees[value], + depth - 1 + ) + ]) +); +var getChainDescriptors = (key) => unwrap(replaceTokens(minified[key]), 2); +var Devnet = getChainDescriptors("devnet"); +export { + Devnet +}; diff --git a/contract-tests/.papi/descriptors/dist/descriptors.d.ts b/contract-tests/.papi/descriptors/dist/descriptors.d.ts new file mode 100644 index 0000000000..406970a3f1 --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/descriptors.d.ts @@ -0,0 +1 @@ +export declare const Devnet: Record; diff --git a/contract-tests/.papi/descriptors/dist/devnet.d.ts b/contract-tests/.papi/descriptors/dist/devnet.d.ts new file mode 100644 index 0000000000..eed219964c --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/devnet.d.ts @@ -0,0 +1,8736 @@ +import { StorageDescriptor, PlainDescriptor, TxDescriptor, RuntimeDescriptor, Enum, ApisFromDef, QueryFromPalletsDef, TxFromPalletsDef, EventsFromPalletsDef, ErrorsFromPalletsDef, ConstFromPalletsDef, ViewFnsFromPalletsDef, SS58String, FixedSizeBinary, Binary, FixedSizeArray } from "polkadot-api"; +import { I5sesotjlssv2d, Iffmde3ekjedi9, I4mddgoa69c0a2, Icr4vaj0vrd6je, I95g6i7ilua7lq, Ieniouoqkq4icf, Phase, Ibgl04rn6nbfm6, I4q39t5hn830vp, Ic5m5lp1oioo8r, GrandpaStoredState, I7pe2me3i3vtn9, I9jd27rnpm8ttv, I3geksg000c171, I1q8tnt1cluu5j, I8ds64oj6581v0, Ia7pdug7cdsg8g, I2hnk9r4ukuj1p, I9bin2jc70qt6q, TransactionPaymentReleases, I7svnfko10tq2e, I6ouflveob4eli, Idoeu5t0dum8va, I5n8gpu725k1nu, Ia2lhg7l2hilo3, I4p5t2krb1gmvp, I7svrbkiu01iec, Iabpgqcjikia83, I2j729bmgsdiuo, Iakavvne152v30, Ib9tptuv3cggfs, Icgljjb6j82uhn, I4h6ivgjtd51lv, I9eir063evtfb6, Iafqnechp3omqg, Ibc83gdj8hi3rc, I9lpjucl20l82d, Iaap7oohdmr1sb, Ifjlj958aeheic, I4tc54pa558g5n, Id32h28hjj1tch, Icrrf4uohj5gb0, I76jd8kl1mtn5g, I4ojmnsk1dchql, I4jqk5si14p5oi, I2na29tt2afp0j, If9jidduiuq7vv, I2brm5b9jij1st, Iapm6e7vtp0l6r, I7tof95tckt2r, Ieruonr5pk2d7h, Iag146hmjgqfgj, I8uo3fpd3bcc6f, PreimageOldRequestStatus, PreimageRequestStatus, I4pact7n2e9a0i, I11tetbe8ces3o, I56u24ncejr5kt, I6tqrno2gaos08, I9p9lq3rej5bhc, Ibq6c27da62s2q, Ib6u9l1gtc5l4t, I7nkl7ntqohel8, I3m6d7ohcp5n4v, Ib9pv5dg6upo6t, I27ub49plcvb4c, I8un1ap2r4hhbj, Ic3l568el19b24, Ib0hfhkohlekcj, I32lgu058i52q9, Ie7atdsih6q14b, I4totqt881mlti, I7jidl7qnnq87c, I82cps8ng2jtug, I4gqmlq9k6jlk3, I494mq1ertfc9k, Ialchst9lgd11u, If0p9hvn3kegj1, I8ac0r18acljm6, I5g2vv0ckl2m8b, I5mi4kb05lrsa9, Icsknfl0f6r973, I1ptic1rnhda0n, I5kulbesqc1h1t, I36dvimehsh2tm, I8t4pajubp34g3, Ifdiflqufkknl8, In7a38730s6qs, If15el53dd76v9, I9s0ave7t0vnrk, I4fo08joqmcqnm, I35p85j063s0il, I4arjljr6dpflb, Ijc5n210o8bbf, I3m5sq54sjdlso, I8ofcg5rbj0g2c, I4adgbll7gku4i, I6pjjpfvhvcfru, I9pj91mj79qekl, I39uah9nss64h9, Ik64dknsq7k08, Ib51vk42m1po4n, Idcr6u6361oad9, I3a5kuu5t5jj3g, I2hviml3snvhhn, I4ktuaksf5i1gk, I9bqtpv2ii35mp, I9j7pagd6d4bda, I2h9pmio37r7fb, Ibmr18suc9ikh9, I9iq22t0burs89, I5u8olqbbvfnvf, I5utcetro501ir, Icv6ofu4lqekr4, I48embv0n659kj, I8l6dbd18t5aja, I513du23unvan, I36o6oho99gjm8, If3mvus4cmnb7l, I3qrhi1ua10nnf, I2hpc4ev2drsf2, I73q6qh9ckhm04, Idia8cmqvul6et, Idardmhchnv8aa, Icud5m8j0nlgtj, I850u7ir5o34um, Ica88a899k1afk, I4tfn6eb3ekqt2, Ia5r6mm7trbg6a, I27gr0ss2ikvqh, Ie7hipi75c7vn0, I7f38r2vt6r9k1, I6b53cjq4m9nsr, I216fvnrl9nq6l, I9n4d52k0luroe, I3gk6eeddm0hsd, I6ue7qc27uhiev, Ifp8lgrkla2dig, I30l38oi9ed9dj, Ifj9gf4ekq9snm, If2k69ql8jgivj, I4378ieh1uba9u, I8e6f7r9dtk9c1, I9d117ni3tprb, I340k0hbj1hc6r, Ibapoov2fa817a, I2eon60c4gde7f, I7egr0053sjpci, I6r22p9usi2mkl, I6cm4c5a1euio9, I96k3nrdjfd63k, Ibg3cp8vjl5u55, Ibtu1gfmdnou5k, Iaoomvri5btde, Ic80igo4eds6rq, Iflrm8un6aibtn, I62rrikn5vj0p5, Ietm4rjshhu7sf, I1v9m3ms1elitm, I2t4b7068rtebl, I7a99hd3nbic2l, Ie8hpsm3jhsvo3, Ifcj247vgfdg56, Ic21uicfit5vcu, I375tmdui1ejfc, I4guv8rii4s6je, I2t2h3sjr2mdj0, I80tnmsfsu19sl, Ib7nn1mns0usdp, I4fivl1mrn0hhc, I2ead8rm0h16hm, I25l72483lbgf9, I9okvr56cd7277, I8k3rnvpeeh4hv, I56sht7incdimf, I8hge8nrufr05f, I5v0mk7rggegmh, Ideaemvoneh309, I3d9o9d7epp66v, I6lqh1vgb4mcja, I82nfqfkd48n10, I1jm8m1rh9e20v, I3o5j3bli1pd8e, Ivqkjqsbgj1dj, I5n4sebgkfr760, Ib6bm2ug64rldc, Ifs1i5fk9cqvr6, I5q3t0hm83a58h, I2gnaqoj2eimi0, Ieg3fd8p4pkt10, I8kg5ll427kfqq, I467333262q1l9, Idlqs144rc48hk, It11trpppbc3l, Ietml13sclqs1q, Iftfic7p3uban2, I2eb501t8s6hsq, Ianmuoljk2sk1u, I7hgtlnpelk0fc, I3p6khp3nv37cu, I6pnnj50tnq448, I57v1t6776pl3a, I1il5mj68vvsms, I42mob3hqe6j7h, Icdbq0j31b3g9c, I2t2rlclb0ce3e, Iar87gdqmug5o7, I3oullii9p80a1, I8t8ta6lfbia9e, I3akfmjle982qg, Ibaje86kdit7s6, I90lra4vl5j4db, I1q480m57ftcms, Ie2bjglo51atf6, Ievma38tc25kil, I2er75v4akf5cc, I5pldh0j0v0u4l, Ifhou5p0slv68r, I9m89dnau2i4tt, Ifunpjbsc4jrrr, I85uujfpnu8gum, I7bl5t0it6ck2m, I4iope0tjiqgu4, Iptqa236frcvo, I8hbi1vrve1i2, I1v9a50gjqk26k, Idv4d3rktbigfh, I56j1e9gqlq602, Ib6k4vik9ruq8h, I9u9gu9aa92l5m, Idmd4tos09qd68, Ia0sp2p68e9k16, Ie318529rgoagk, Iam4iou8r3isc1, I21ajnsdtbutjh, I203rofi4rpmo4, I1e290fmo892vi, Ie31ro5s5e089f, I71lu4gpn88cf0, I98iornf3ajrp9, I9893mbk9nh201, I623eo8t3jrbeo, Ieo8qamskgm4dk, Ift1efpssa32g2, Ibk3v0rrpo1bio, I1sj8huj7of8mb, I6av3sq9jkhmm3, I70cd7doki8rme, Iam7j42j9f1go6, Idco9ambhipg4i, I6s1nbislhk619, I9jtu7slb30qvs, Idv3j6a15pjc16, I206qvjkjun95i, I4qhb3plq4ifmq, Ic58lhlh1ocpm1, I6uopd4b2os90n, I6idbvi8v00o5j, Ifbgbhkj74b35k, Ibt4a800kb7frq, Icb4un8h4cokoo, I1up607q6ce947, I7hktg5sccf8op, Ib1d0bomkbrqv1, Iaflrold1ds0nq, I1ssp78ejl639m, I13qib3vtm9cs3, Idcabvplu05lea, Id38gdpcotl637, I73q3qf5u7nnqg, Idpm1bc2cr6dgj, I837c61fc07ine, I6m0oguilvhn8, I7vi74gbubc8u5, I3u0knmtb1ueq7, I87tlou92i0bot, Ifd3mkud9g8rb1, Iakvbbhvger3oa, I92t98snpjjcts, Iet4pe2le7ku09, I5dueehi6i2dg9, I64ev05f6q10es, Ikc5h15joooak, Ie8f436ua5fs59, I3mkis681qg30e, I2foqo7cbqf35v, I3mcu79ge1e54v, Icf66vuktncksu, Id69glo8rcjef, Ia2rnh5pfua40a, I3otc7e9a35k1k, I89ier5tb9ne0s, Im2f0numhevg3, I2agkcpojhkk43, I32rvg545edabm, I83fv0vi59md7i, I5tjjqcdd4tae0, I1894dm1lf1ae7, Idkfsqnep2hpeb, I2u5b4034ft9hp, I602p6mm30elei, Ia82mnkmeo2rhc, I6u3ru0d29kkj0, Icbccs0ug47ilf, I855j4i3kr8ko1, Ibk0nulspilods, I5768ac424h061, Icv68aq8841478, Ic262ibdoec56a, Iflcfm9b6nlmdd, Ijrsf4mnp3eka, Id5fm4p8lj5qgi, I8tjvj9uq4b7hi, I4cbvqmqadhrea, I3qt1hgg4djhgb, I4fooe9dun9o0t, Ier2cke86dqbr2, Io45lnue7n40k, I83e4tgdv5ohg1, I6o6dmud53u1fj, I39p6ln31i4n46, I95l2k9b1re95f, Ifkgc6cte1k96e, I6kvs2mb8unk0t, Idbuci3sr3i1f7, I73drt1hl9e70v, I1dm4sip108q0g, Iajgphfb1fka7l, I4hnmf90qkrer9, Ijsohbv0raf36, I4ga01hppthoe1, I4hckkcv10tcue, Ic871mj76419vm, If2ieedn10ujdv, Iaseh340tnovdh, I8m5umt6snnmlj, I5aeg4u9kpsp8o, I3fsv5f1boeqf3, Ifoov68qt28nbm, Ib937mhlbop6j7, I838gqvljm75tj, I1cu36qostj5d8, I4r2ptfsrl017r, Ielglukq9ekcit, I1clsdhcok4nle, Iemddv6u2buvfn, Ic149bnrif7lpr, I89dsvf7sdo4ko, I804q3c12638a0, Idguve298jnare, Idi3fb8585u2lp, I1327b77famnt3, If58ibsptjm2at, I5rtkmhm2dng4u, Iep27ialq4a7o7, Iasu5jvoqr43mv, I88p4dmln8611r, I5qolde99acmd1, I8gtde5abn1g9a, I3dvon8akhmsut, Ia3c82eadg79bj, Ienusoeb625ftq, Ibtsa3docbr9el, Iek6442ldi23n3, Idpdo54rotesu2, I2ur0oeqg495j8, Ibco2bqthggul0, I1bhd210c3phjj, Idcqgi2844k5he, Iej2173ou338sm, I20e9ph536u7ti, I8kcpmsh450rp, Iea4g5ovhnolus, Ifmc9boeeia623, Itmchvgqfl28g, I5tf7b5o64mfpl, If71d2q730qf6n, If0sk51c1n7ri8, I4b2eh3b1oi815, I57q620f4fu1bl, Ie5222qfrr24ek, I28g8sphdu312k, Idqbjt2c6r46t6, I853aigjva3f0t, I9uehhems5hkqm, I7q5qk4uoanhof, Iehpbs40l3jkit, Idht9upmipvd4j, Icns2sqr5hp8s3, I9n4hs8p3rlkag, I6a8j73186lfdf, I8vbtb6bd00lm0, I8v1041j74kmaj, Iaqet9jc3ihboe, Ic952bubvq4k7d, I2v50gu3s1aqk6, Ibmofsd95figtn, If7uv525tdvv7a, Itom7fk49o0c9, I2an1fs2eiebjp, Ie9sr1iqcg3cgm, I1mqgk2tmnn9i2, I6lr8sctk0bi4e, TransactionValidityTransactionSource, I9ask1o4tfvcvs, Icerf8h8pdu8ss, I9puqgoda8ofk4, I6spmpef2c7svf, Iei2mvq0mjvt81, If08sfhqn8ujfr, Ic4rgfgksgmm3e, I3dj14b7k3rkm5, Ic5egmm215ml6k, Ibg4am9lqg35ku, I7efspe2svrt0g, I5fvdd841odbi3, I35vouom6s9r2, Ie6kgk6f04rsvk, Ifgqf2rskq94om, Ie30stbbeaul1o, I7aold6s47n103, Ibjuap2vk03rp6, Iasb8k6ash5mjn, Ifla7g8u5j9k68, I9sijb8gfrns29, I17s97pb2d5tj3, I2dfliekq1ed7e, I4gah17u2nc33h, I9u22scd4ksrjm, Ibil6rvg3saeb3, I97cs1i8k87lnm, I874e758ge6pa9, I86tq0h1o8f1g5, I78cq8c9mego2f, I64hm01ml98m4p, I3gjbugrk45her, I9nvi04b7jiso4, I6s1052v0hl6mr, I31p8sd8onusg0, I2vgg418k9gfnm, I7dp6t7k7a8r36, Ibtpedbm9ai3hp, I8ivaf995pho4u, Icr6rj04unermu, I5gfdo8kg6rloq, Ibjoh8vk2j7bqd, I2u4s5o1c0r3fu, Ic0g2vnp5r296p, Ihfphjolmsqq1, Ic9fkrj2ggjleq, Ifi9cmevnosufh, I1i5jfmqcsjper, I3pbrjdm4vnbsa, Iems84l8lk2v0c, I1r5ke30ueqo0r, I68ii5ik8avr9o, I8slfm2rri67ri, I34n2itmpoq7on } from "./common-types"; +type AnonymousEnum = T & { + __anonymous: true; +}; +type MyTuple = [T, ...T[]]; +type SeparateUndefined = undefined extends T ? undefined | Exclude : T; +type Anonymize = SeparateUndefined ? number extends L ? Binary : FixedSizeBinary : T extends string | number | bigint | boolean | void | undefined | null | symbol | Uint8Array | Enum ? T : T extends AnonymousEnum ? Enum : T extends MyTuple ? { + [K in keyof T]: T[K]; +} : T extends [] ? [] : T extends FixedSizeArray ? number extends L ? Array : FixedSizeArray : { + [K in keyof T & string]: T[K]; +}>; +type IStorage = { + System: { + /** + * The full account information for a particular account ID. + */ + Account: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + * Total extrinsics count for the current block. + */ + ExtrinsicCount: StorageDescriptor<[], number, true, never>; + /** + * Whether all inherents have been applied. + */ + InherentsApplied: StorageDescriptor<[], boolean, false, never>; + /** + * The current weight for the block. + */ + BlockWeight: StorageDescriptor<[], Anonymize, false, never>; + /** + * Total length (in bytes) for all extrinsics put together, for the current block. + */ + AllExtrinsicsLen: StorageDescriptor<[], number, true, never>; + /** + * Map of block numbers to block hashes. + */ + BlockHash: StorageDescriptor<[Key: number], FixedSizeBinary<32>, false, never>; + /** + * Extrinsics data for the current block (maps an extrinsic's index to its data). + */ + ExtrinsicData: StorageDescriptor<[Key: number], Binary, false, never>; + /** + * The current block number being processed. Set by `execute_block`. + */ + Number: StorageDescriptor<[], number, false, never>; + /** + * Hash of the previous block. + */ + ParentHash: StorageDescriptor<[], FixedSizeBinary<32>, false, never>; + /** + * Digest of the current block, also part of the block header. + */ + Digest: StorageDescriptor<[], Anonymize, false, never>; + /** + * Events deposited for the current block. + * + * NOTE: The item is unbound and should therefore never be read on chain. + * It could otherwise inflate the PoV size of a block. + * + * Events have a large in-memory size. Box the events to not go out-of-memory + * just in case someone still reads them from within the runtime. + */ + Events: StorageDescriptor<[], Anonymize, false, never>; + /** + * The number of events in the `Events` list. + */ + EventCount: StorageDescriptor<[], number, false, never>; + /** + * Mapping between a topic (represented by T::Hash) and a vector of indexes + * of events in the `>` list. + * + * All topic vectors have deterministic storage locations depending on the topic. This + * allows light-clients to leverage the changes trie storage tracking mechanism and + * in case of changes fetch the list of events of interest. + * + * The value has the type `(BlockNumberFor, EventIndex)` because if we used only just + * the `EventIndex` then in case if the topic has the same contents on the next block + * no notification will be triggered thus the event might be lost. + */ + EventTopics: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize, false, never>; + /** + * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened. + */ + LastRuntimeUpgrade: StorageDescriptor<[], Anonymize, true, never>; + /** + * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not. + */ + UpgradedToU32RefCount: StorageDescriptor<[], boolean, false, never>; + /** + * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False + * (default) if not. + */ + UpgradedToTripleRefCount: StorageDescriptor<[], boolean, false, never>; + /** + * The execution phase of the block. + */ + ExecutionPhase: StorageDescriptor<[], Phase, true, never>; + /** + * `Some` if a code upgrade has been authorized. + */ + AuthorizedUpgrade: StorageDescriptor<[], Anonymize, true, never>; + /** + * The weight reclaimed for the extrinsic. + * + * This information is available until the end of the extrinsic execution. + * More precisely this information is removed in `note_applied_extrinsic`. + * + * Logic doing some post dispatch weight reduction must update this storage to avoid duplicate + * reduction. + */ + ExtrinsicWeightReclaimed: StorageDescriptor<[], Anonymize, false, never>; + }; + RandomnessCollectiveFlip: { + /** + * Series of block headers from the last 81 blocks that acts as random seed material. This + * is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of + * the oldest hash. + */ + RandomMaterial: StorageDescriptor<[], Anonymize, false, never>; + }; + Timestamp: { + /** + * The current time for the current block. + */ + Now: StorageDescriptor<[], bigint, false, never>; + /** + * Whether the timestamp has been updated in this block. + * + * This value is updated to `true` upon successful submission of a timestamp by a node. + * It is then checked at the end of each block execution in the `on_finalize` hook. + */ + DidUpdate: StorageDescriptor<[], boolean, false, never>; + }; + Aura: { + /** + * The current authority set. + */ + Authorities: StorageDescriptor<[], Anonymize, false, never>; + /** + * The current slot of this block. + * + * This will be set in `on_initialize`. + */ + CurrentSlot: StorageDescriptor<[], bigint, false, never>; + }; + Grandpa: { + /** + * State of the current authority set. + */ + State: StorageDescriptor<[], GrandpaStoredState, false, never>; + /** + * Pending change: (signaled at, scheduled change). + */ + PendingChange: StorageDescriptor<[], Anonymize, true, never>; + /** + * next block number where we can force a change. + */ + NextForced: StorageDescriptor<[], number, true, never>; + /** + * `true` if we are currently stalled. + */ + Stalled: StorageDescriptor<[], Anonymize, true, never>; + /** + * The number of changes (both in terms of keys and underlying economic responsibilities) + * in the "set" of Grandpa validators from genesis. + */ + CurrentSetId: StorageDescriptor<[], bigint, false, never>; + /** + * A mapping from grandpa set ID to the index of the *most recent* session for which its + * members were responsible. + * + * This is only used for validating equivocation proofs. An equivocation proof must + * contains a key-ownership proof for a given session, therefore we need a way to tie + * together sessions and GRANDPA set ids, i.e. we need to validate that a validator + * was the owner of a given key on a given session, and what the active set ID was + * during that session. + * + * TWOX-NOTE: `SetId` is not under user control. + */ + SetIdSession: StorageDescriptor<[Key: bigint], number, true, never>; + /** + * The current list of authorities. + */ + Authorities: StorageDescriptor<[], Anonymize, false, never>; + }; + Balances: { + /** + * The total units issued in the system. + */ + TotalIssuance: StorageDescriptor<[], bigint, false, never>; + /** + * The total units of outstanding deactivated balance in the system. + */ + InactiveIssuance: StorageDescriptor<[], bigint, false, never>; + /** + * The Balances pallet example of storing the balance of an account. + * + * # Example + * + * ```nocompile + * impl pallet_balances::Config for Runtime { + * type AccountStore = StorageMapShim, frame_system::Provider, AccountId, Self::AccountData> + * } + * ``` + * + * You can also store the balance of an account in the `System` pallet. + * + * # Example + * + * ```nocompile + * impl pallet_balances::Config for Runtime { + * type AccountStore = System + * } + * ``` + * + * But this comes with tradeoffs, storing account balances in the system pallet stores + * `frame_system` data alongside the account data contrary to storing account balances in the + * `Balances` pallet, which uses a `StorageMap` to store balances data only. + * NOTE: This is only used in the case that this pallet is used to store balances. + */ + Account: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + * Any liquidity locks on some account balances. + * NOTE: Should only be accessed when setting, changing and freeing a lock. + * + * Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/` + */ + Locks: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + * Named reserves on some account balances. + * + * Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/` + */ + Reserves: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + * Holds on account balances. + */ + Holds: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + * Freeze locks on account balances. + */ + Freezes: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + }; + TransactionPayment: { + /** + + */ + NextFeeMultiplier: StorageDescriptor<[], bigint, false, never>; + /** + + */ + StorageVersion: StorageDescriptor<[], TransactionPaymentReleases, false, never>; + }; + SubtensorModule: { + /** + + */ + MinActivityCutoff: StorageDescriptor<[], number, false, never>; + /** + * Global window (in blocks) at the end of each tempo where admin ops are disallowed + */ + AdminFreezeWindow: StorageDescriptor<[], number, false, never>; + /** + * Global number of epochs used to rate limit subnet owner hyperparameter updates + */ + OwnerHyperparamRateLimit: StorageDescriptor<[], number, false, never>; + /** + * Duration of dissolve network schedule before execution + */ + DissolveNetworkScheduleDuration: StorageDescriptor<[], number, false, never>; + /** + * --- DMap ( netuid, coldkey ) --> blocknumber | last hotkey swap on network. + */ + LastHotkeySwapOnNetuid: StorageDescriptor, bigint, false, never>; + /** + * Ensures unique IDs for StakeJobs storage map + */ + NextStakeJobId: StorageDescriptor<[], bigint, false, never>; + /** + * ============================ + * ==== Staking Variables ==== + * ============================ + * The Subtensor [`TotalIssuance`] represents the total issuance of tokens on the Bittensor network. + * + * It is comprised of three parts: + * - The total amount of issued tokens, tracked in the TotalIssuance of the Balances pallet + * - The total amount of tokens staked in the system, tracked in [`TotalStake`] + * - The total amount of tokens locked up for subnet reg, tracked in [`TotalSubnetLocked`] attained by iterating over subnet lock. + * + * Eventually, Bittensor should migrate to using Holds afterwhich time we will not require this + * separate accounting. + * --- ITEM --> Global weight + */ + TaoWeight: StorageDescriptor<[], bigint, false, never>; + /** + * --- ITEM --> CK burn + */ + CKBurn: StorageDescriptor<[], bigint, false, never>; + /** + * --- ITEM ( default_delegate_take ) + */ + MaxDelegateTake: StorageDescriptor<[], number, false, never>; + /** + * --- ITEM ( min_delegate_take ) + */ + MinDelegateTake: StorageDescriptor<[], number, false, never>; + /** + * --- ITEM ( default_childkey_take ) + */ + MaxChildkeyTake: StorageDescriptor<[], number, false, never>; + /** + * --- ITEM ( min_childkey_take ) + */ + MinChildkeyTake: StorageDescriptor<[], number, false, never>; + /** + * MAP ( hot ) --> cold | Returns the controlling coldkey for a hotkey + */ + Owner: StorageDescriptor<[Key: SS58String], SS58String, false, never>; + /** + * MAP ( hot ) --> take | Returns the hotkey delegation take. And signals that this key is open for delegation + */ + Delegates: StorageDescriptor<[Key: SS58String], number, false, never>; + /** + * DMAP ( hot, netuid ) --> take | Returns the hotkey childkey take for a specific subnet + */ + ChildkeyTake: StorageDescriptor, number, false, never>; + /** + * DMAP ( netuid, parent ) --> (Vec<(proportion,child)>, cool_down_block) + */ + PendingChildKeys: StorageDescriptor, Anonymize, false, never>; + /** + * DMAP ( parent, netuid ) --> Vec<(proportion,child)> + */ + ChildKeys: StorageDescriptor, Anonymize, false, never>; + /** + * DMAP ( child, netuid ) --> Vec<(proportion,parent)> + */ + ParentKeys: StorageDescriptor, Anonymize, false, never>; + /** + * --- DMAP ( netuid, hotkey ) --> u64 | Last alpha dividend this hotkey got on tempo. + */ + AlphaDividendsPerSubnet: StorageDescriptor, bigint, false, never>; + /** + * --- DMAP ( netuid, hotkey ) --> u64 | Last root alpha dividend this hotkey got on tempo. + */ + RootAlphaDividendsPerSubnet: StorageDescriptor, bigint, false, never>; + /** + * ================== + * ==== Coinbase ==== + * ================== + * --- ITEM ( global_block_emission ) + */ + BlockEmission: StorageDescriptor<[], bigint, false, never>; + /** + * --- DMap ( hot, netuid ) --> emission | last hotkey emission on network. + */ + LastHotkeyEmissionOnNetuid: StorageDescriptor, bigint, false, never>; + /** + * ========================== + * ==== Staking Counters ==== + * ========================== + * The Subtensor [`TotalIssuance`] represents the total issuance of tokens on the Bittensor network. + * + * It is comprised of three parts: + * - The total amount of issued tokens, tracked in the TotalIssuance of the Balances pallet + * - The total amount of tokens staked in the system, tracked in [`TotalStake`] + * - The total amount of tokens locked up for subnet reg, tracked in [`TotalSubnetLocked`] attained by iterating over subnet lock. + * + * Eventually, Bittensor should migrate to using Holds afterwhich time we will not require this + * separate accounting. + * --- ITEM ( maximum_number_of_networks ) + */ + SubnetLimit: StorageDescriptor<[], number, false, never>; + /** + * --- ITEM ( total_issuance ) + */ + TotalIssuance: StorageDescriptor<[], bigint, false, never>; + /** + * --- ITEM ( total_stake ) + */ + TotalStake: StorageDescriptor<[], bigint, false, never>; + /** + * --- ITEM ( moving_alpha ) -- subnet moving alpha. + */ + SubnetMovingAlpha: StorageDescriptor<[], bigint, false, never>; + /** + * --- MAP ( netuid ) --> moving_price | The subnet moving price. + */ + SubnetMovingPrice: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> root_prop | The subnet root proportion. + */ + RootProp: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> total_volume | The total amount of TAO bought and sold since the start of the network. + */ + SubnetVolume: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> tao_in_subnet | Returns the amount of TAO in the subnet. + */ + SubnetTAO: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> tao_in_user_subnet | Returns the amount of TAO in the subnet reserve provided by users as liquidity. + */ + SubnetTaoProvided: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> alpha_in_emission | Returns the amount of alph in emission into the pool per block. + */ + SubnetAlphaInEmission: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> alpha_out_emission | Returns the amount of alpha out emission into the network per block. + */ + SubnetAlphaOutEmission: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> tao_in_emission | Returns the amount of tao emitted into this subent on the last block. + */ + SubnetTaoInEmission: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> alpha_supply_in_pool | Returns the amount of alpha in the pool. + */ + SubnetAlphaIn: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> alpha_supply_user_in_pool | Returns the amount of alpha in the pool provided by users as liquidity. + */ + SubnetAlphaInProvided: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> alpha_supply_in_subnet | Returns the amount of alpha in the subnet. + */ + SubnetAlphaOut: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( cold ) --> Vec | Maps coldkey to hotkeys that stake to it + */ + StakingHotkeys: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + * --- MAP ( cold ) --> Vec | Returns the vector of hotkeys controlled by this coldkey. + */ + OwnedHotkeys: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + * --- DMAP ( cold, netuid )--> hot | Returns the hotkey a coldkey will autostake to with mining rewards. + */ + AutoStakeDestination: StorageDescriptor, SS58String, true, never>; + /** + * --- DMAP ( hot, netuid )--> Vec | Returns a list of coldkeys that are autostaking to a hotkey + */ + AutoStakeDestinationColdkeys: StorageDescriptor, Anonymize, false, never>; + /** + * The delay after an announcement before a coldkey swap can be performed. + */ + ColdkeySwapAnnouncementDelay: StorageDescriptor<[], number, false, never>; + /** + * The delay after the initial delay has passed before a new announcement can be made. + */ + ColdkeySwapReannouncementDelay: StorageDescriptor<[], number, false, never>; + /** + * A map of the coldkey swap announcements from a coldkey + * to the block number the coldkey swap can be performed. + */ + ColdkeySwapAnnouncements: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; + /** + * A map of the coldkey swap disputes from a coldkey to the + * block number the coldkey swap was disputed. + */ + ColdkeySwapDisputes: StorageDescriptor<[Key: SS58String], number, true, never>; + /** + * --- DMAP ( hot, netuid ) --> alpha | Returns the total amount of alpha a hotkey owns. + */ + TotalHotkeyAlpha: StorageDescriptor, bigint, false, never>; + /** + * --- DMAP ( hot, netuid ) --> alpha | Returns the total amount of alpha a hotkey owned in the last epoch. + */ + TotalHotkeyAlphaLastEpoch: StorageDescriptor, bigint, false, never>; + /** + * DMAP ( hot, netuid ) --> total_alpha_shares | Returns the number of alpha shares for a hotkey on a subnet. + */ + TotalHotkeyShares: StorageDescriptor, bigint, false, never>; + /** + * --- NMAP ( hot, cold, netuid ) --> alpha | Returns the alpha shares for a hotkey, coldkey, netuid triplet. + */ + Alpha: StorageDescriptor, bigint, false, never>; + /** + * Contains last Alpha storage map key to iterate (check first) + */ + AlphaMapLastKey: StorageDescriptor<[], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> token_symbol | Returns the token symbol for a subnet. + */ + TokenSymbol: StorageDescriptor<[Key: number], Binary, false, never>; + /** + * --- MAP ( netuid ) --> subnet_tao_flow | Returns the TAO inflow-outflow balance. + */ + SubnetTaoFlow: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> subnet_ema_tao_flow | Returns the EMA of TAO inflow-outflow balance. + */ + SubnetEmaTaoFlow: StorageDescriptor<[Key: number], Anonymize, true, never>; + /** + * --- ITEM --> TAO Flow Cutoff + */ + TaoFlowCutoff: StorageDescriptor<[], bigint, false, never>; + /** + * --- ITEM --> Flow Normalization Exponent (p) + */ + FlowNormExponent: StorageDescriptor<[], bigint, false, never>; + /** + * --- ITEM --> Flow EMA smoothing factor (flow alpha), u64 normalized + */ + FlowEmaSmoothingFactor: StorageDescriptor<[], bigint, false, never>; + /** + * ============================ + * ==== Global Parameters ===== + * ============================ + * --- StorageItem Global Used Work. + */ + UsedWork: StorageDescriptor<[Key: Binary], bigint, false, never>; + /** + * --- ITEM( global_max_registrations_per_block ) + */ + MaxRegistrationsPerBlock: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- ITEM( total_number_of_existing_networks ) + */ + TotalNetworks: StorageDescriptor<[], number, false, never>; + /** + * ITEM( network_immunity_period ) + */ + NetworkImmunityPeriod: StorageDescriptor<[], bigint, false, never>; + /** + * ITEM( start_call_delay ) + */ + StartCallDelay: StorageDescriptor<[], bigint, false, never>; + /** + * ITEM( min_network_lock_cost ) + */ + NetworkMinLockCost: StorageDescriptor<[], bigint, false, never>; + /** + * ITEM( last_network_lock_cost ) + */ + NetworkLastLockCost: StorageDescriptor<[], bigint, false, never>; + /** + * ITEM( network_lock_reduction_interval ) + */ + NetworkLockReductionInterval: StorageDescriptor<[], bigint, false, never>; + /** + * ITEM( subnet_owner_cut ) + */ + SubnetOwnerCut: StorageDescriptor<[], number, false, never>; + /** + * ITEM( network_rate_limit ) + */ + NetworkRateLimit: StorageDescriptor<[], bigint, false, never>; + /** + * --- ITEM( nominator_min_required_stake ) --- Factor of DefaultMinStake in per-mill format. + */ + NominatorMinRequiredStake: StorageDescriptor<[], bigint, false, never>; + /** + * ITEM( weights_version_key_rate_limit ) --- Rate limit in tempos. + */ + WeightsVersionKeyRateLimit: StorageDescriptor<[], bigint, false, never>; + /** + * ============================ + * ==== Rate Limiting ===== + * ============================ + * --- MAP ( RateLimitKey ) --> Block number in which the last rate limited operation occured + */ + LastRateLimitedBlock: StorageDescriptor<[Key: Anonymize], bigint, false, never>; + /** + * ============================ + * ==== Subnet Locks ===== + * ============================ + * --- MAP ( netuid ) --> transfer_toggle + */ + TransferToggle: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * --- MAP ( netuid ) --> total_subnet_locked + */ + SubnetLocked: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> largest_locked + */ + LargestLocked: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * ================= + * ==== Tempos ===== + * ================= + * --- MAP ( netuid ) --> tempo + */ + Tempo: StorageDescriptor<[Key: number], number, false, never>; + /** + * ============================ + * ==== Subnet Parameters ===== + * ============================ + * --- MAP ( netuid ) --> block number of first emission + */ + FirstEmissionBlockNumber: StorageDescriptor<[Key: number], bigint, true, never>; + /** + * --- MAP ( netuid ) --> subnet mechanism + */ + SubnetMechanism: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> subnetwork_n (Number of UIDs in the network). + */ + SubnetworkN: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> network_is_added + */ + NetworksAdded: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * --- DMAP ( hotkey, netuid ) --> bool + */ + IsNetworkMember: StorageDescriptor, boolean, false, never>; + /** + * --- MAP ( netuid ) --> network_registration_allowed + */ + NetworkRegistrationAllowed: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * --- MAP ( netuid ) --> network_pow_allowed + */ + NetworkPowRegistrationAllowed: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * --- MAP ( netuid ) --> block_created + */ + NetworkRegisteredAt: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> pending_server_emission + */ + PendingServerEmission: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> pending_validator_emission + */ + PendingValidatorEmission: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> pending_root_alpha_emission + */ + PendingRootAlphaDivs: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> pending_owner_cut + */ + PendingOwnerCut: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> blocks_since_last_step + */ + BlocksSinceLastStep: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> last_mechanism_step_block + */ + LastMechansimStepBlock: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> subnet_owner + */ + SubnetOwner: StorageDescriptor<[Key: number], SS58String, false, never>; + /** + * --- MAP ( netuid ) --> subnet_owner_hotkey + */ + SubnetOwnerHotkey: StorageDescriptor<[Key: number], SS58String, false, never>; + /** + * --- MAP ( netuid ) --> recycle_or_burn + */ + RecycleOrBurn: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> serving_rate_limit + */ + ServingRateLimit: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> Rho + */ + Rho: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> AlphaSigmoidSteepness + */ + AlphaSigmoidSteepness: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> Kappa + */ + Kappa: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> registrations_this_interval + */ + RegistrationsThisInterval: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> pow_registrations_this_interval + */ + POWRegistrationsThisInterval: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> burn_registrations_this_interval + */ + BurnRegistrationsThisInterval: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> min_allowed_uids + */ + MinAllowedUids: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> max_allowed_uids + */ + MaxAllowedUids: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> immunity_period + */ + ImmunityPeriod: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> activity_cutoff + */ + ActivityCutoff: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> max_weight_limit + */ + MaxWeightsLimit: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> weights_version_key + */ + WeightsVersionKey: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> min_allowed_weights + */ + MinAllowedWeights: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> max_allowed_validators + */ + MaxAllowedValidators: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> adjustment_interval + */ + AdjustmentInterval: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> bonds_moving_average + */ + BondsMovingAverage: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> bonds_penalty + */ + BondsPenalty: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> bonds_reset + */ + BondsResetOn: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * --- MAP ( netuid ) --> weights_set_rate_limit + */ + WeightsSetRateLimit: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> validator_prune_len + */ + ValidatorPruneLen: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> scaling_law_power + */ + ScalingLawPower: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> target_registrations_this_interval + */ + TargetRegistrationsPerInterval: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> adjustment_alpha + */ + AdjustmentAlpha: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> commit reveal v2 weights are enabled + */ + CommitRevealWeightsEnabled: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * --- MAP ( netuid ) --> Burn + */ + Burn: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> Difficulty + */ + Difficulty: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> MinBurn + */ + MinBurn: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> MaxBurn + */ + MaxBurn: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> MinDifficulty + */ + MinDifficulty: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> MaxDifficulty + */ + MaxDifficulty: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> Block at last adjustment. + */ + LastAdjustmentBlock: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> Registrations of this Block. + */ + RegistrationsThisBlock: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> Halving time of average moving price. + */ + EMAPriceHalvingBlocks: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> global_RAO_recycled_for_registration + */ + RAORecycledForRegistration: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- ITEM ( tx_rate_limit ) + */ + TxRateLimit: StorageDescriptor<[], bigint, false, never>; + /** + * --- ITEM ( tx_delegate_take_rate_limit ) + */ + TxDelegateTakeRateLimit: StorageDescriptor<[], bigint, false, never>; + /** + * --- ITEM ( tx_childkey_take_rate_limit ) + */ + TxChildkeyTakeRateLimit: StorageDescriptor<[], bigint, false, never>; + /** + * --- MAP ( netuid ) --> Whether or not Liquid Alpha is enabled + */ + LiquidAlphaOn: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * --- MAP ( netuid ) --> Whether or not Yuma3 is enabled + */ + Yuma3On: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * MAP ( netuid ) --> (alpha_low, alpha_high) + */ + AlphaValues: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> If subtoken trading enabled + */ + SubtokenEnabled: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * --- DMAP ( netuid, hotkey ) --> voting_power | EMA of stake for voting + * This tracks stake EMA updated every epoch when VotingPowerTrackingEnabled is true. + * Used by smart contracts to determine validator voting power for subnet governance. + */ + VotingPower: StorageDescriptor, bigint, false, never>; + /** + * --- MAP ( netuid ) --> bool | Whether voting power tracking is enabled for this subnet. + * When enabled, VotingPower EMA is updated every epoch. Default is false. + * When disabled with disable_at_block set, tracking continues until that block. + */ + VotingPowerTrackingEnabled: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * --- MAP ( netuid ) --> block_number | Block at which voting power tracking will be disabled. + * When set (non-zero), tracking continues until this block, then automatically disables + * and clears VotingPower entries for the subnet. Provides a 14-day grace period. + */ + VotingPowerDisableAtBlock: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> u64 | EMA alpha value for voting power calculation. + * Higher alpha = faster response to stake changes. + * Stored as u64 with 18 decimal precision (1.0 = 10^18). + * Only settable by sudo/root. + */ + VotingPowerEmaAlpha: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- MAP ( netuid ) --> Burn key limit + */ + ImmuneOwnerUidsLimit: StorageDescriptor<[Key: number], number, false, never>; + /** + * ======================================= + * ==== Subnetwork Consensus Storage ==== + * ======================================= + * --- DMAP ( netuid ) --> stake_weight | weight for stake used in YC. + */ + StakeWeight: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- DMAP ( netuid, hotkey ) --> uid + */ + Uids: StorageDescriptor, number, true, never>; + /** + * --- DMAP ( netuid, uid ) --> hotkey + */ + Keys: StorageDescriptor, SS58String, false, never>; + /** + * --- MAP ( netuid ) --> (hotkey, se, ve) + */ + LoadedEmission: StorageDescriptor<[Key: number], Anonymize, true, never>; + /** + * --- MAP ( netuid ) --> active + */ + Active: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> rank + */ + Rank: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> trust + */ + Trust: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> consensus + */ + Consensus: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> incentive + */ + Incentive: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> dividends + */ + Dividends: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> emission + */ + Emission: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> last_update + */ + LastUpdate: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> validator_trust + */ + ValidatorTrust: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> pruning_scores + */ + PruningScores: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- MAP ( netuid ) --> validator_permit + */ + ValidatorPermit: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * --- DMAP ( netuid, uid ) --> weights + */ + Weights: StorageDescriptor, Anonymize, false, never>; + /** + * --- DMAP ( netuid, uid ) --> bonds + */ + Bonds: StorageDescriptor, Anonymize, false, never>; + /** + * --- DMAP ( netuid, uid ) --> block_at_registration + */ + BlockAtRegistration: StorageDescriptor, bigint, false, never>; + /** + * --- MAP ( netuid, hotkey ) --> axon_info + */ + Axons: StorageDescriptor, Anonymize, true, never>; + /** + * --- MAP ( netuid, hotkey ) --> certificate + */ + NeuronCertificates: StorageDescriptor, Anonymize, true, never>; + /** + * --- MAP ( netuid, hotkey ) --> prometheus_info + */ + Prometheus: StorageDescriptor, Anonymize, true, never>; + /** + * --- MAP ( coldkey ) --> identity + */ + IdentitiesV2: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; + /** + * --- MAP ( netuid ) --> SubnetIdentityOfV3 + */ + SubnetIdentitiesV3: StorageDescriptor<[Key: number], Anonymize, true, never>; + /** + * ================================= + * ==== Axon / Promo Endpoints ===== + * ================================= + * --- NMAP ( hot, netuid, name ) --> last_block | Returns the last block of a transaction for a given key, netuid, and name. + */ + TransactionKeyLastBlock: StorageDescriptor, bigint, false, never>; + /** + * --- MAP ( key ) --> last_block + */ + LastTxBlock: StorageDescriptor<[Key: SS58String], bigint, false, never>; + /** + * --- MAP ( key ) --> last_tx_block_childkey_take + */ + LastTxBlockChildKeyTake: StorageDescriptor<[Key: SS58String], bigint, false, never>; + /** + * --- MAP ( key ) --> last_tx_block_delegate_take + */ + LastTxBlockDelegateTake: StorageDescriptor<[Key: SS58String], bigint, false, never>; + /** + * ITEM( weights_min_stake ) + */ + StakeThreshold: StorageDescriptor<[], bigint, false, never>; + /** + * --- MAP (netuid, who) --> VecDeque<(hash, commit_block, first_reveal_block, last_reveal_block)> | Stores a queue of commits for an account on a given netuid. + */ + WeightCommits: StorageDescriptor, Anonymize, true, never>; + /** + * MAP (netuid, epoch) → VecDeque<(who, commit_block, ciphertext, reveal_round)> + * Stores a queue of weight commits for an account on a given subnet. + */ + TimelockedWeightCommits: StorageDescriptor, Anonymize, false, never>; + /** + * MAP (netuid, epoch) → VecDeque<(who, ciphertext, reveal_round)> + * DEPRECATED for CRV3WeightCommitsV2 + */ + CRV3WeightCommits: StorageDescriptor, Anonymize, false, never>; + /** + * MAP (netuid, epoch) → VecDeque<(who, commit_block, ciphertext, reveal_round)> + * DEPRECATED for TimelockedWeightCommits + */ + CRV3WeightCommitsV2: StorageDescriptor, Anonymize, false, never>; + /** + * --- Map (netuid) --> Number of epochs allowed for commit reveal periods + */ + RevealPeriodEpochs: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- Map (coldkey, hotkey) --> u64 the last block at which stake was added/removed. + */ + LastColdkeyHotkeyStakeBlock: StorageDescriptor, bigint, true, never>; + /** + * DMAP ( hot, cold, netuid ) --> rate limits for staking operations + * Value contains just a marker: we use this map as a set. + */ + StakingOperationRateLimiter: StorageDescriptor, boolean, false, never>; + /** + + */ + RootClaimableThreshold: StorageDescriptor<[Key: number], bigint, false, never>; + /** + + */ + RootClaimable: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + + */ + RootClaimed: StorageDescriptor, bigint, false, never>; + /** + + */ + RootClaimType: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + + */ + StakingColdkeysByIndex: StorageDescriptor<[Key: bigint], SS58String, true, never>; + /** + + */ + StakingColdkeys: StorageDescriptor<[Key: SS58String], bigint, true, never>; + /** + + */ + NumStakingColdkeys: StorageDescriptor<[], bigint, false, never>; + /** + + */ + NumRootClaim: StorageDescriptor<[], bigint, false, never>; + /** + * ============================= + * ==== EVM related storage ==== + * ============================= + * --- DMAP (netuid, uid) --> (H160, last_block_where_ownership_was_proven) + */ + AssociatedEvmAddress: StorageDescriptor, Anonymize, true, never>; + /** + * ======================== + * ==== Subnet Leasing ==== + * ======================== + * --- MAP ( lease_id ) --> subnet lease | The subnet lease for a given lease id. + */ + SubnetLeases: StorageDescriptor<[Key: number], Anonymize, true, never>; + /** + * --- DMAP ( lease_id, contributor ) --> shares | The shares of a contributor for a given lease. + */ + SubnetLeaseShares: StorageDescriptor, bigint, false, never>; + /** + * --- MAP ( netuid ) --> lease_id | The lease id for a given netuid. + */ + SubnetUidToLeaseId: StorageDescriptor<[Key: number], number, true, never>; + /** + * --- ITEM ( next_lease_id ) | The next lease id. + */ + NextSubnetLeaseId: StorageDescriptor<[], number, false, never>; + /** + * --- MAP ( lease_id ) --> accumulated_dividends | The accumulated dividends for a given lease that needs to be distributed. + */ + AccumulatedLeaseDividends: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * --- ITEM ( CommitRevealWeightsVersion ) + */ + CommitRevealWeightsVersion: StorageDescriptor<[], number, false, never>; + /** + * ITEM( NetworkRegistrationStartBlock ) + */ + NetworkRegistrationStartBlock: StorageDescriptor<[], bigint, false, never>; + /** + * --- MAP ( netuid ) --> minimum required number of non-immortal & non-immune UIDs + */ + MinNonImmuneUids: StorageDescriptor<[Key: number], number, false, never>; + /** + * ITEM( max_mechanism_count ) + */ + MaxMechanismCount: StorageDescriptor<[], number, false, never>; + /** + * --- MAP ( netuid ) --> Current number of subnet mechanisms + */ + MechanismCountCurrent: StorageDescriptor<[Key: number], number, false, never>; + /** + * --- MAP ( netuid ) --> Normalized vector of emission split proportion between subnet mechanisms + */ + MechanismEmissionSplit: StorageDescriptor<[Key: number], Anonymize, true, never>; + /** + * ================== + * ==== Genesis ===== + * ================== + * --- Storage for migration run status + */ + HasMigrationRun: StorageDescriptor<[Key: Binary], boolean, false, never>; + /** + * Storage value for pending childkey cooldown, settable by root. + */ + PendingChildKeyCooldown: StorageDescriptor<[], bigint, false, never>; + }; + Sudo: { + /** + * The `AccountId` of the sudo key. + */ + Key: StorageDescriptor<[], SS58String, true, never>; + }; + Multisig: { + /** + * The set of open multisig operations. + */ + Multisigs: StorageDescriptor, Anonymize, true, never>; + }; + Preimage: { + /** + * The request status of a given hash. + */ + StatusFor: StorageDescriptor<[Key: FixedSizeBinary<32>], PreimageOldRequestStatus, true, never>; + /** + * The request status of a given hash. + */ + RequestStatusFor: StorageDescriptor<[Key: FixedSizeBinary<32>], PreimageRequestStatus, true, never>; + /** + + */ + PreimageFor: StorageDescriptor<[Key: Anonymize], Binary, true, never>; + }; + Scheduler: { + /** + * Block number at which the agenda began incomplete execution. + */ + IncompleteSince: StorageDescriptor<[], number, true, never>; + /** + * Items to be executed, indexed by the block number that they should be executed on. + */ + Agenda: StorageDescriptor<[Key: number], Anonymize, false, never>; + /** + * Retry configurations for items to be executed, indexed by task address. + */ + Retries: StorageDescriptor<[Key: Anonymize], Anonymize, true, never>; + /** + * Lookup from a name to the block number and index of the task. + * + * For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v4 + * identities. + */ + Lookup: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize, true, never>; + }; + Proxy: { + /** + * The set of account proxies. Maps the account which has delegated to the accounts + * which are being delegated to, together with the amount held on deposit. + */ + Proxies: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + * The announcements made by the proxy (key). + */ + Announcements: StorageDescriptor<[Key: SS58String], Anonymize, false, never>; + /** + * The result of the last call made by the proxy (key). + */ + LastCallResult: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; + }; + Registry: { + /** + * Identity data by account + */ + IdentityOf: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; + }; + Commitments: { + /** + * Tracks all CommitmentOf that have at least one timelocked field. + */ + TimelockedIndex: StorageDescriptor<[], Anonymize, false, never>; + /** + * Identity data by account + */ + CommitmentOf: StorageDescriptor, Anonymize, true, never>; + /** + + */ + LastCommitment: StorageDescriptor, number, true, never>; + /** + + */ + LastBondsReset: StorageDescriptor, number, true, never>; + /** + + */ + RevealedCommitments: StorageDescriptor, Anonymize, true, never>; + /** + * Maps (netuid, who) -> usage (how many “bytes” they've committed) + * in the RateLimit window + */ + UsedSpaceOf: StorageDescriptor, Anonymize, true, never>; + /** + + */ + MaxSpace: StorageDescriptor<[], number, false, never>; + }; + AdminUtils: { + /** + * Map PrecompileEnum --> enabled + */ + PrecompileEnable: StorageDescriptor<[Key: Anonymize], boolean, false, never>; + }; + SafeMode: { + /** + * Contains the last block number that the safe-mode will remain entered in. + * + * Set to `None` when safe-mode is exited. + * + * Safe-mode is automatically exited when the current block number exceeds this value. + */ + EnteredUntil: StorageDescriptor<[], number, true, never>; + /** + * Holds the reserve that was taken from an account at a specific block number. + * + * This helps governance to have an overview of outstanding deposits that should be returned or + * slashed. + */ + Deposits: StorageDescriptor, bigint, true, never>; + }; + Ethereum: { + /** + * Mapping from transaction index to transaction in the current building block. + */ + Pending: StorageDescriptor<[Key: number], Anonymize, true, never>; + /** + * Counter for the related counted storage map + */ + CounterForPending: StorageDescriptor<[], number, false, never>; + /** + * The current Ethereum block. + */ + CurrentBlock: StorageDescriptor<[], Anonymize, true, never>; + /** + * The current Ethereum receipts. + */ + CurrentReceipts: StorageDescriptor<[], Anonymize, true, never>; + /** + * The current transaction statuses. + */ + CurrentTransactionStatuses: StorageDescriptor<[], Anonymize, true, never>; + /** + + */ + BlockHash: StorageDescriptor<[Key: Anonymize], FixedSizeBinary<32>, false, never>; + }; + EVM: { + /** + + */ + AccountCodes: StorageDescriptor<[Key: FixedSizeBinary<20>], Binary, false, never>; + /** + + */ + AccountCodesMetadata: StorageDescriptor<[Key: FixedSizeBinary<20>], Anonymize, true, never>; + /** + + */ + AccountStorages: StorageDescriptor, FixedSizeBinary<32>, false, never>; + /** + + */ + WhitelistedCreators: StorageDescriptor<[], Anonymize, false, never>; + /** + + */ + DisableWhitelistCheck: StorageDescriptor<[], boolean, false, never>; + }; + EVMChainId: { + /** + * The EVM chain ID. + */ + ChainId: StorageDescriptor<[], bigint, false, never>; + }; + BaseFee: { + /** + + */ + BaseFeePerGas: StorageDescriptor<[], Anonymize, false, never>; + /** + + */ + Elasticity: StorageDescriptor<[], number, false, never>; + }; + Drand: { + /** + * the drand beacon configuration + */ + BeaconConfig: StorageDescriptor<[], Anonymize, false, never>; + /** + * Storage for migration run status + */ + HasMigrationRun: StorageDescriptor<[Key: Binary], boolean, false, never>; + /** + * map round number to pulse + */ + Pulses: StorageDescriptor<[Key: bigint], Anonymize, true, never>; + /** + + */ + LastStoredRound: StorageDescriptor<[], bigint, false, never>; + /** + * oldest stored round + */ + OldestStoredRound: StorageDescriptor<[], bigint, false, never>; + /** + * Defines the block when next unsigned transaction will be accepted. + * + * To prevent spam of unsigned (and unpaid!) transactions on the network, + * we only allow one transaction per block. + * This storage entry defines when new transaction is going to be accepted. + */ + NextUnsignedAt: StorageDescriptor<[], number, false, never>; + }; + Crowdloan: { + /** + * A map of crowdloan ids to their information. + */ + Crowdloans: StorageDescriptor<[Key: number], Anonymize, true, never>; + /** + * The next incrementing crowdloan id. + */ + NextCrowdloanId: StorageDescriptor<[], number, false, never>; + /** + * A map of crowdloan ids to their contributors and their contributions. + */ + Contributions: StorageDescriptor, bigint, true, never>; + /** + * The current crowdloan id that will be set during the finalize call, making it + * temporarily accessible to the dispatched call. + */ + CurrentCrowdloanId: StorageDescriptor<[], number, true, never>; + /** + * Storage for the migration run status. + */ + HasMigrationRun: StorageDescriptor<[Key: Binary], boolean, false, never>; + }; + Swap: { + /** + * The fee rate applied to swaps per subnet, normalized value between 0 and u16::MAX + */ + FeeRate: StorageDescriptor<[Key: number], number, false, never>; + /** + + */ + FeeGlobalTao: StorageDescriptor<[Key: number], bigint, false, never>; + /** + + */ + FeeGlobalAlpha: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * Storage for all ticks, using subnet ID as the primary key and tick index as the secondary key + */ + Ticks: StorageDescriptor, Anonymize, true, never>; + /** + * Storage to determine whether swap V3 was initialized for a specific subnet. + */ + SwapV3Initialized: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * Storage for the square root price of Alpha token for each subnet. + */ + AlphaSqrtPrice: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * Storage for the current price tick. + */ + CurrentTick: StorageDescriptor<[Key: number], number, false, never>; + /** + * Storage for the current liquidity amount for each subnet. + */ + CurrentLiquidity: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * Indicates whether a subnet has been switched to V3 swap from V2. + * If `true`, the subnet is permanently on V3 swap mode allowing add/remove liquidity + * operations. Once set to `true` for a subnet, it cannot be changed back to `false`. + */ + EnabledUserLiquidity: StorageDescriptor<[Key: number], boolean, false, never>; + /** + * Storage for user positions, using subnet ID and account ID as keys + * The value is a bounded vector of Position structs with details about the liquidity positions + */ + Positions: StorageDescriptor, Anonymize, true, never>; + /** + * Position ID counter. + */ + LastPositionId: StorageDescriptor<[], bigint, false, never>; + /** + * Tick index bitmap words storage + */ + TickIndexBitmapWords: StorageDescriptor, bigint, false, never>; + /** + * TAO reservoir for scraps of protocol claimed fees. + */ + ScrapReservoirTao: StorageDescriptor<[Key: number], bigint, false, never>; + /** + * Alpha reservoir for scraps of protocol claimed fees. + */ + ScrapReservoirAlpha: StorageDescriptor<[Key: number], bigint, false, never>; + }; + Contracts: { + /** + * A mapping from a contract's code hash to its code. + */ + PristineCode: StorageDescriptor<[Key: FixedSizeBinary<32>], Binary, true, never>; + /** + * A mapping from a contract's code hash to its code info. + */ + CodeInfoOf: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize, true, never>; + /** + * This is a **monotonic** counter incremented on contract instantiation. + * + * This is used in order to generate unique trie ids for contracts. + * The trie id of a new contract is calculated from hash(account_id, nonce). + * The nonce is required because otherwise the following sequence would lead to + * a possible collision of storage: + * + * 1. Create a new contract. + * 2. Terminate the contract. + * 3. Immediately recreate the contract with the same account_id. + * + * This is bad because the contents of a trie are deleted lazily and there might be + * storage of the old instantiation still in it when the new contract is created. Please + * note that we can't replace the counter by the block number because the sequence above + * can happen in the same block. We also can't keep the account counter in memory only + * because storage is the only way to communicate across different extrinsics in the + * same block. + * + * # Note + * + * Do not use it to determine the number of contracts. It won't be decremented if + * a contract is destroyed. + */ + Nonce: StorageDescriptor<[], bigint, false, never>; + /** + * The code associated with a given account. + * + * TWOX-NOTE: SAFE since `AccountId` is a secure hash. + */ + ContractInfoOf: StorageDescriptor<[Key: SS58String], Anonymize, true, never>; + /** + * Evicted contracts that await child trie deletion. + * + * Child trie deletion is a heavy operation depending on the amount of storage items + * stored in said trie. Therefore this operation is performed lazily in `on_idle`. + */ + DeletionQueue: StorageDescriptor<[Key: number], Binary, true, never>; + /** + * A pair of monotonic counters used to track the latest contract marked for deletion + * and the latest deleted contract in queue. + */ + DeletionQueueCounter: StorageDescriptor<[], Anonymize, false, never>; + /** + * A migration can span across multiple blocks. This storage defines a cursor to track the + * progress of the migration, enabling us to resume from the last completed position. + */ + MigrationInProgress: StorageDescriptor<[], Binary, true, never>; + }; + MevShield: { + /** + * Current ML‑KEM‑768 public key bytes (encoded form). + */ + CurrentKey: StorageDescriptor<[], Binary, true, never>; + /** + * Next ML‑KEM‑768 public key bytes, announced by the block author. + */ + NextKey: StorageDescriptor<[], Binary, true, never>; + /** + * Buffered encrypted submissions, indexed by wrapper id. + */ + Submissions: StorageDescriptor<[Key: FixedSizeBinary<32>], Anonymize, true, never>; + /** + * Hash(CurrentKey) per block, used to bind `key_hash` to the epoch at submit time. + */ + KeyHashByBlock: StorageDescriptor<[Key: number], FixedSizeBinary<32>, true, never>; + }; +}; +type ICalls = { + System: { + /** + * Make some on-chain remark. + * + * Can be executed by every `origin`. + */ + remark: TxDescriptor>; + /** + * Set the number of pages in the WebAssembly environment's heap. + */ + set_heap_pages: TxDescriptor>; + /** + * Set the new runtime code. + */ + set_code: TxDescriptor>; + /** + * Set the new runtime code without doing any checks of the given `code`. + * + * Note that runtime upgrades will not run if this is called with a not-increasing spec + * version! + */ + set_code_without_checks: TxDescriptor>; + /** + * Set some items of storage. + */ + set_storage: TxDescriptor>; + /** + * Kill some items from storage. + */ + kill_storage: TxDescriptor>; + /** + * Kill all storage items with a key that starts with the given prefix. + * + * **NOTE:** We rely on the Root origin to provide us the number of subkeys under + * the prefix we are removing to accurately calculate the weight of this function. + */ + kill_prefix: TxDescriptor>; + /** + * Make some on-chain remark and emit event. + */ + remark_with_event: TxDescriptor>; + /** + * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied + * later. + * + * This call requires Root origin. + */ + authorize_upgrade: TxDescriptor>; + /** + * Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied + * later. + * + * WARNING: This authorizes an upgrade that will take place without any safety checks, for + * example that the spec name remains the same and that the version number increases. Not + * recommended for normal use. Use `authorize_upgrade` instead. + * + * This call requires Root origin. + */ + authorize_upgrade_without_checks: TxDescriptor>; + /** + * Provide the preimage (runtime binary) `code` for an upgrade that has been authorized. + * + * If the authorization required a version check, this call will ensure the spec name + * remains unchanged and that the spec version has increased. + * + * Depending on the runtime's `OnSetCode` configuration, this function may directly apply + * the new `code` in the same block or attempt to schedule the upgrade. + * + * All origins are allowed. + */ + apply_authorized_upgrade: TxDescriptor>; + }; + Timestamp: { + /** + * Set the current time. + * + * This call should be invoked exactly once per block. It will panic at the finalization + * phase, if this call hasn't been invoked by that time. + * + * The timestamp should be greater than the previous one by the amount specified by + * [`Config::MinimumPeriod`]. + * + * The dispatch origin for this call must be _None_. + * + * This dispatch class is _Mandatory_ to ensure it gets executed in the block. Be aware + * that changing the complexity of this call could result exhausting the resources in a + * block to execute any other calls. + * + * ## Complexity + * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`) + * - 1 storage read and 1 storage mutation (codec `O(1)` because of `DidUpdate::take` in + * `on_finalize`) + * - 1 event handler `on_timestamp_set`. Must be `O(1)`. + */ + set: TxDescriptor>; + }; + Grandpa: { + /** + * Report voter equivocation/misbehavior. This method will verify the + * equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence + * will be reported. + */ + report_equivocation: TxDescriptor>; + /** + * Report voter equivocation/misbehavior. This method will verify the + * equivocation proof and validate the given key ownership proof + * against the extracted offender. If both are valid, the offence + * will be reported. + * + * This extrinsic must be called unsigned and it is expected that only + * block authors will call it (validated in `ValidateUnsigned`), as such + * if the block author is defined it will be defined as the equivocation + * reporter. + */ + report_equivocation_unsigned: TxDescriptor>; + /** + * Note that the current authority set of the GRANDPA finality gadget has stalled. + * + * This will trigger a forced authority set change at the beginning of the next session, to + * be enacted `delay` blocks after that. The `delay` should be high enough to safely assume + * that the block signalling the forced change will not be re-orged e.g. 1000 blocks. + * The block production rate (which may be slowed down because of finality lagging) should + * be taken into account when choosing the `delay`. The GRANDPA voters based on the new + * authority will start voting on top of `best_finalized_block_number` for new finalized + * blocks. `best_finalized_block_number` should be the highest of the latest finalized + * block of all validators of the new authority set. + * + * Only callable by root. + */ + note_stalled: TxDescriptor>; + }; + Balances: { + /** + * Transfer some liquid free balance to another account. + * + * `transfer_allow_death` will set the `FreeBalance` of the sender and receiver. + * If the sender's account is below the existential deposit as a result + * of the transfer, the account will be reaped. + * + * The dispatch origin for this call must be `Signed` by the transactor. + */ + transfer_allow_death: TxDescriptor>; + /** + * Exactly as `transfer_allow_death`, except the origin must be root and the source account + * may be specified. + */ + force_transfer: TxDescriptor>; + /** + * Same as the [`transfer_allow_death`] call, but with a check that the transfer will not + * kill the origin account. + * + * 99% of the time you want [`transfer_allow_death`] instead. + * + * [`transfer_allow_death`]: struct.Pallet.html#method.transfer + */ + transfer_keep_alive: TxDescriptor>; + /** + * Transfer the entire transferable balance from the caller account. + * + * NOTE: This function only attempts to transfer _transferable_ balances. This means that + * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be + * transferred by this function. To ensure that this function results in a killed account, + * you might need to prepare the account by removing any reference counters, storage + * deposits, etc... + * + * The dispatch origin of this call must be Signed. + * + * - `dest`: The recipient of the transfer. + * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all + * of the funds the account has, causing the sender account to be killed (false), or + * transfer everything except at least the existential deposit, which will guarantee to + * keep the sender account alive (true). + */ + transfer_all: TxDescriptor>; + /** + * Unreserve some balance from a user by force. + * + * Can only be called by ROOT. + */ + force_unreserve: TxDescriptor>; + /** + * Upgrade a specified account. + * + * - `origin`: Must be `Signed`. + * - `who`: The account to be upgraded. + * + * This will waive the transaction fee if at least all but 10% of the accounts needed to + * be upgraded. (We let some not have to be upgraded just in order to allow for the + * possibility of churn). + */ + upgrade_accounts: TxDescriptor>; + /** + * Set the regular balance of a given account. + * + * The dispatch origin for this call is `root`. + */ + force_set_balance: TxDescriptor>; + /** + * Adjust the total issuance in a saturating way. + * + * Can only be called by root and always needs a positive `delta`. + * + * # Example + */ + force_adjust_total_issuance: TxDescriptor>; + /** + * Burn the specified liquid free balance from the origin account. + * + * If the origin's account ends up below the existential deposit as a result + * of the burn and `keep_alive` is false, the account will be reaped. + * + * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible, + * this `burn` operation will reduce total issuance by the amount _burned_. + */ + burn: TxDescriptor>; + }; + SubtensorModule: { + /** + * --- Sets the caller weights for the incentive mechanism. The call can be + * made from the hotkey account so is potentially insecure, however, the damage + * of changing weights is minimal if caught early. This function includes all the + * checks that the passed weights meet the requirements. Stored as u16s they represent + * rational values in the range [0,1] which sum to 1 and can be interpreted as + * probabilities. The specific weights determine how inflation propagates outward + * from this peer. + * + * Note: The 16 bit integers weights should represent 1.0 as the max u16. + * However, the function normalizes all integers to u16_max anyway. This means that if the sum of all + * elements is larger or smaller than the amount of elements * u16_max, all elements + * will be corrected for this deviation. + * + * # Args: + * * `origin`: (Origin): + * - The caller, a hotkey who wishes to set their weights. + * + * * `netuid` (u16): + * - The network uid we are setting these weights on. + * + * * `dests` (Vec): + * - The edge endpoint for the weight, i.e. j for w_ij. + * + * * 'weights' (Vec): + * - The u16 integer encoded weights. Interpreted as rational + * values in the range [0,1]. They must sum to in32::MAX. + * + * * 'version_key' ( u64 ): + * - The network version key to check if the validator is up to date. + * + * # Event: + * * WeightsSet; + * - On successfully setting the weights on chain. + * + * # Raises: + * * 'MechanismDoesNotExist': + * - Attempting to set weights on a non-existent network. + * + * * 'NotRegistered': + * - Attempting to set weights from a non registered account. + * + * * 'WeightVecNotEqualSize': + * - Attempting to set weights with uids not of same length. + * + * * 'DuplicateUids': + * - Attempting to set weights with duplicate uids. + * + * * 'UidsLengthExceedUidsInSubNet': + * - Attempting to set weights above the max allowed uids. + * + * * 'UidVecContainInvalidOne': + * - Attempting to set weights with invalid uids. + * + * * 'WeightVecLengthIsLow': + * - Attempting to set weights with fewer weights than min. + * + * * 'MaxWeightExceeded': + * - Attempting to set weights with max value exceeding limit. + */ + set_weights: TxDescriptor>; + /** + * --- Sets the caller weights for the incentive mechanism for mechanisms. The call + * can be made from the hotkey account so is potentially insecure, however, the damage + * of changing weights is minimal if caught early. This function includes all the + * checks that the passed weights meet the requirements. Stored as u16s they represent + * rational values in the range [0,1] which sum to 1 and can be interpreted as + * probabilities. The specific weights determine how inflation propagates outward + * from this peer. + * + * Note: The 16 bit integers weights should represent 1.0 as the max u16. + * However, the function normalizes all integers to u16_max anyway. This means that if the sum of all + * elements is larger or smaller than the amount of elements * u16_max, all elements + * will be corrected for this deviation. + * + * # Args: + * * `origin`: (Origin): + * - The caller, a hotkey who wishes to set their weights. + * + * * `netuid` (u16): + * - The network uid we are setting these weights on. + * + * * `mecid` (`u8`): + * - The u8 mechnism identifier. + * + * * `dests` (Vec): + * - The edge endpoint for the weight, i.e. j for w_ij. + * + * * 'weights' (Vec): + * - The u16 integer encoded weights. Interpreted as rational + * values in the range [0,1]. They must sum to in32::MAX. + * + * * 'version_key' ( u64 ): + * - The network version key to check if the validator is up to date. + * + * # Event: + * * WeightsSet; + * - On successfully setting the weights on chain. + * + * # Raises: + * * 'MechanismDoesNotExist': + * - Attempting to set weights on a non-existent network. + * + * * 'NotRegistered': + * - Attempting to set weights from a non registered account. + * + * * 'WeightVecNotEqualSize': + * - Attempting to set weights with uids not of same length. + * + * * 'DuplicateUids': + * - Attempting to set weights with duplicate uids. + * + * * 'UidsLengthExceedUidsInSubNet': + * - Attempting to set weights above the max allowed uids. + * + * * 'UidVecContainInvalidOne': + * - Attempting to set weights with invalid uids. + * + * * 'WeightVecLengthIsLow': + * - Attempting to set weights with fewer weights than min. + * + * * 'MaxWeightExceeded': + * - Attempting to set weights with max value exceeding limit. + */ + set_mechanism_weights: TxDescriptor>; + /** + * --- Allows a hotkey to set weights for multiple netuids as a batch. + * + * # Args: + * * `origin`: (Origin): + * - The caller, a hotkey who wishes to set their weights. + * + * * `netuids` (Vec>): + * - The network uids we are setting these weights on. + * + * * `weights` (Vec, Compact)>): + * - The weights to set for each network. [(uid, weight), ...] + * + * * `version_keys` (Vec>): + * - The network version keys to check if the validator is up to date. + * + * # Event: + * * WeightsSet; + * - On successfully setting the weights on chain. + * * BatchWeightsCompleted; + * - On success of the batch. + * * BatchCompletedWithErrors; + * - On failure of any of the weights in the batch. + * * BatchWeightItemFailed; + * - On failure for each failed item in the batch. + * + */ + batch_set_weights: TxDescriptor>; + /** + * ---- Used to commit a hash of your weight values to later be revealed. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The signature of the committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `commit_hash` (`H256`): + * - The hash representing the committed weights. + * + * # Raises: + * * `CommitRevealDisabled`: + * - Attempting to commit when the commit-reveal mechanism is disabled. + * + * * `TooManyUnrevealedCommits`: + * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. + * + */ + commit_weights: TxDescriptor>; + /** + * ---- Used to commit a hash of your weight values to later be revealed for mechanisms. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The signature of the committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `mecid` (`u8`): + * - The u8 mechanism identifier. + * + * * `commit_hash` (`H256`): + * - The hash representing the committed weights. + * + * # Raises: + * * `CommitRevealDisabled`: + * - Attempting to commit when the commit-reveal mechanism is disabled. + * + * * `TooManyUnrevealedCommits`: + * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. + * + */ + commit_mechanism_weights: TxDescriptor>; + /** + * --- Allows a hotkey to commit weight hashes for multiple netuids as a batch. + * + * # Args: + * * `origin`: (Origin): + * - The caller, a hotkey who wishes to set their weights. + * + * * `netuids` (Vec>): + * - The network uids we are setting these weights on. + * + * * `commit_hashes` (Vec): + * - The commit hashes to commit. + * + * # Event: + * * WeightsSet; + * - On successfully setting the weights on chain. + * * BatchWeightsCompleted; + * - On success of the batch. + * * BatchCompletedWithErrors; + * - On failure of any of the weights in the batch. + * * BatchWeightItemFailed; + * - On failure for each failed item in the batch. + * + */ + batch_commit_weights: TxDescriptor>; + /** + * ---- Used to reveal the weights for a previously committed hash. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The signature of the revealing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `uids` (`Vec`): + * - The uids for the weights being revealed. + * + * * `values` (`Vec`): + * - The values of the weights being revealed. + * + * * `salt` (`Vec`): + * - The salt used to generate the commit hash. + * + * * `version_key` (`u64`): + * - The network version key. + * + * # Raises: + * * `CommitRevealDisabled`: + * - Attempting to reveal weights when the commit-reveal mechanism is disabled. + * + * * `NoWeightsCommitFound`: + * - Attempting to reveal weights without an existing commit. + * + * * `ExpiredWeightCommit`: + * - Attempting to reveal a weight commit that has expired. + * + * * `RevealTooEarly`: + * - Attempting to reveal weights outside the valid reveal period. + * + * * `InvalidRevealCommitHashNotMatch`: + * - The revealed hash does not match any committed hash. + * + */ + reveal_weights: TxDescriptor>; + /** + * ---- Used to reveal the weights for a previously committed hash for mechanisms. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The signature of the revealing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `mecid` (`u8`): + * - The u8 mechanism identifier. + * + * * `uids` (`Vec`): + * - The uids for the weights being revealed. + * + * * `values` (`Vec`): + * - The values of the weights being revealed. + * + * * `salt` (`Vec`): + * - The salt used to generate the commit hash. + * + * * `version_key` (`u64`): + * - The network version key. + * + * # Raises: + * * `CommitRevealDisabled`: + * - Attempting to reveal weights when the commit-reveal mechanism is disabled. + * + * * `NoWeightsCommitFound`: + * - Attempting to reveal weights without an existing commit. + * + * * `ExpiredWeightCommit`: + * - Attempting to reveal a weight commit that has expired. + * + * * `RevealTooEarly`: + * - Attempting to reveal weights outside the valid reveal period. + * + * * `InvalidRevealCommitHashNotMatch`: + * - The revealed hash does not match any committed hash. + * + */ + reveal_mechanism_weights: TxDescriptor>; + /** + * ---- Used to commit encrypted commit-reveal v3 weight values to later be revealed. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `commit` (`Vec`): + * - The encrypted compressed commit. + * The steps for this are: + * 1. Instantiate [`WeightsTlockPayload`] + * 2. Serialize it using the `parity_scale_codec::Encode` trait + * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] + * to produce a [`TLECiphertext`] type. + * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. + * + * * reveal_round (`u64`): + * - The drand reveal round which will be avaliable during epoch `n+1` from the current + * epoch. + * + * # Raises: + * * `CommitRevealV3Disabled`: + * - Attempting to commit when the commit-reveal mechanism is disabled. + * + * * `TooManyUnrevealedCommits`: + * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. + * + * ---- Used to commit encrypted commit-reveal v3 weight values to later be revealed for mechanisms. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `mecid` (`u8`): + * - The u8 mechanism identifier. + * + * * `commit` (`Vec`): + * - The encrypted compressed commit. + * The steps for this are: + * 1. Instantiate [`WeightsTlockPayload`] + * 2. Serialize it using the `parity_scale_codec::Encode` trait + * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] + * to produce a [`TLECiphertext`] type. + * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. + * + * * reveal_round (`u64`): + * - The drand reveal round which will be avaliable during epoch `n+1` from the current + * epoch. + * + * # Raises: + * * `CommitRevealV3Disabled`: + * - Attempting to commit when the commit-reveal mechanism is disabled. + * + * * `TooManyUnrevealedCommits`: + * - Attempting to commit when the user has more than the allowed limit of unrevealed commits. + * + */ + commit_crv3_mechanism_weights: TxDescriptor>; + /** + * ---- The implementation for batch revealing committed weights. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The signature of the revealing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `uids_list` (`Vec>`): + * - A list of uids for each set of weights being revealed. + * + * * `values_list` (`Vec>`): + * - A list of values for each set of weights being revealed. + * + * * `salts_list` (`Vec>`): + * - A list of salts used to generate the commit hashes. + * + * * `version_keys` (`Vec`): + * - A list of network version keys. + * + * # Raises: + * * `CommitRevealDisabled`: + * - Attempting to reveal weights when the commit-reveal mechanism is disabled. + * + * * `NoWeightsCommitFound`: + * - Attempting to reveal weights without an existing commit. + * + * * `ExpiredWeightCommit`: + * - Attempting to reveal a weight commit that has expired. + * + * * `RevealTooEarly`: + * - Attempting to reveal weights outside the valid reveal period. + * + * * `InvalidRevealCommitHashNotMatch`: + * - The revealed hash does not match any committed hash. + * + * * `InvalidInputLengths`: + * - The input vectors are of mismatched lengths. + */ + batch_reveal_weights: TxDescriptor>; + /** + * --- Allows delegates to decrease its take value. + * + * # Args: + * * 'origin': (::Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The hotkey we are delegating (must be owned by the coldkey.) + * + * * 'netuid' (u16): + * - Subnet ID to decrease take for + * + * * 'take' (u16): + * - The new stake proportion that this hotkey takes from delegations. + * The new value can be between 0 and 11_796 and should be strictly + * lower than the previous value. It T is the new value (rational number), + * the the parameter is calculated as [65535 * T]. For example, 1% would be + * [0.01 * 65535] = [655.35] = 655 + * + * # Event: + * * TakeDecreased; + * - On successfully setting a decreased take for this hotkey. + * + * # Raises: + * * 'NotRegistered': + * - The hotkey we are delegating is not registered on the network. + * + * * 'NonAssociatedColdKey': + * - The hotkey we are delegating is not owned by the calling coldkey. + * + * * 'DelegateTakeTooLow': + * - The delegate is setting a take which is not lower than the previous. + * + */ + decrease_take: TxDescriptor>; + /** + * --- Allows delegates to increase its take value. This call is rate-limited. + * + * # Args: + * * 'origin': (::Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The hotkey we are delegating (must be owned by the coldkey.) + * + * * 'take' (u16): + * - The new stake proportion that this hotkey takes from delegations. + * The new value can be between 0 and 11_796 and should be strictly + * greater than the previous value. T is the new value (rational number), + * the the parameter is calculated as [65535 * T]. For example, 1% would be + * [0.01 * 65535] = [655.35] = 655 + * + * # Event: + * * TakeIncreased; + * - On successfully setting a increased take for this hotkey. + * + * # Raises: + * * 'NotRegistered': + * - The hotkey we are delegating is not registered on the network. + * + * * 'NonAssociatedColdKey': + * - The hotkey we are delegating is not owned by the calling coldkey. + * + * * 'DelegateTakeTooHigh': + * - The delegate is setting a take which is not greater than the previous. + * + */ + increase_take: TxDescriptor>; + /** + * --- Adds stake to a hotkey. The call is made from a coldkey account. + * This delegates stake to the hotkey. + * + * Note: the coldkey account may own the hotkey, in which case they are + * delegating to themselves. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The associated hotkey account. + * + * * 'netuid' (u16): + * - Subnetwork UID + * + * * 'amount_staked' (u64): + * - The amount of stake to be added to the hotkey staking account. + * + * # Event: + * * StakeAdded; + * - On the successfully adding stake to a global account. + * + * # Raises: + * * 'NotEnoughBalanceToStake': + * - Not enough balance on the coldkey to add onto the global account. + * + * * 'NonAssociatedColdKey': + * - The calling coldkey is not associated with this hotkey. + * + * * 'BalanceWithdrawalError': + * - Errors stemming from transaction pallet. + * + */ + add_stake: TxDescriptor>; + /** + * Remove stake from the staking account. The call must be made + * from the coldkey account attached to the neuron metadata. Only this key + * has permission to make staking and unstaking requests. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The associated hotkey account. + * + * * 'netuid' (u16): + * - Subnetwork UID + * + * * 'amount_unstaked' (u64): + * - The amount of stake to be added to the hotkey staking account. + * + * # Event: + * * StakeRemoved; + * - On the successfully removing stake from the hotkey account. + * + * # Raises: + * * 'NotRegistered': + * - Thrown if the account we are attempting to unstake from is non existent. + * + * * 'NonAssociatedColdKey': + * - Thrown if the coldkey does not own the hotkey we are unstaking from. + * + * * 'NotEnoughStakeToWithdraw': + * - Thrown if there is not enough stake on the hotkey to withdwraw this amount. + * + */ + remove_stake: TxDescriptor>; + /** + * Serves or updates axon /prometheus information for the neuron associated with the caller. If the caller is + * already registered the metadata is updated. If the caller is not registered this call throws NotRegistered. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller. + * + * * 'netuid' (u16): + * - The u16 network identifier. + * + * * 'version' (u64): + * - The bittensor version identifier. + * + * * 'ip' (u64): + * - The endpoint ip information as a u128 encoded integer. + * + * * 'port' (u16): + * - The endpoint port information as a u16 encoded integer. + * + * * 'ip_type' (u8): + * - The endpoint ip version as a u8, 4 or 6. + * + * * 'protocol' (u8): + * - UDP:1 or TCP:0 + * + * * 'placeholder1' (u8): + * - Placeholder for further extra params. + * + * * 'placeholder2' (u8): + * - Placeholder for further extra params. + * + * # Event: + * * AxonServed; + * - On successfully serving the axon info. + * + * # Raises: + * * 'MechanismDoesNotExist': + * - Attempting to set weights on a non-existent network. + * + * * 'NotRegistered': + * - Attempting to set weights from a non registered account. + * + * * 'InvalidIpType': + * - The ip type is not 4 or 6. + * + * * 'InvalidIpAddress': + * - The numerically encoded ip address does not resolve to a proper ip. + * + * * 'ServingRateLimitExceeded': + * - Attempting to set prometheus information withing the rate limit min. + * + */ + serve_axon: TxDescriptor>; + /** + * Same as `serve_axon` but takes a certificate as an extra optional argument. + * Serves or updates axon /prometheus information for the neuron associated with the caller. If the caller is + * already registered the metadata is updated. If the caller is not registered this call throws NotRegistered. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller. + * + * * 'netuid' (u16): + * - The u16 network identifier. + * + * * 'version' (u64): + * - The bittensor version identifier. + * + * * 'ip' (u64): + * - The endpoint ip information as a u128 encoded integer. + * + * * 'port' (u16): + * - The endpoint port information as a u16 encoded integer. + * + * * 'ip_type' (u8): + * - The endpoint ip version as a u8, 4 or 6. + * + * * 'protocol' (u8): + * - UDP:1 or TCP:0 + * + * * 'placeholder1' (u8): + * - Placeholder for further extra params. + * + * * 'placeholder2' (u8): + * - Placeholder for further extra params. + * + * * 'certificate' (Vec): + * - TLS certificate for inter neuron communitation. + * + * # Event: + * * AxonServed; + * - On successfully serving the axon info. + * + * # Raises: + * * 'MechanismDoesNotExist': + * - Attempting to set weights on a non-existent network. + * + * * 'NotRegistered': + * - Attempting to set weights from a non registered account. + * + * * 'InvalidIpType': + * - The ip type is not 4 or 6. + * + * * 'InvalidIpAddress': + * - The numerically encoded ip address does not resolve to a proper ip. + * + * * 'ServingRateLimitExceeded': + * - Attempting to set prometheus information withing the rate limit min. + * + */ + serve_axon_tls: TxDescriptor>; + /** + * ---- Set prometheus information for the neuron. + * # Args: + * * 'origin': (Origin): + * - The signature of the calling hotkey. + * + * * 'netuid' (u16): + * - The u16 network identifier. + * + * * 'version' (u16): + * - The bittensor version identifier. + * + * * 'ip' (u128): + * - The prometheus ip information as a u128 encoded integer. + * + * * 'port' (u16): + * - The prometheus port information as a u16 encoded integer. + * + * * 'ip_type' (u8): + * - The ip type v4 or v6. + * + */ + serve_prometheus: TxDescriptor>; + /** + * ---- Registers a new neuron to the subnetwork. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the calling hotkey. + * + * * 'netuid' (u16): + * - The u16 network identifier. + * + * * 'block_number' ( u64 ): + * - Block hash used to prove work done. + * + * * 'nonce' ( u64 ): + * - Positive integer nonce used in POW. + * + * * 'work' ( Vec ): + * - Vector encoded bytes representing work done. + * + * * 'hotkey' ( T::AccountId ): + * - Hotkey to be registered to the network. + * + * * 'coldkey' ( T::AccountId ): + * - Associated coldkey account. + * + * # Event: + * * NeuronRegistered; + * - On successfully registering a uid to a neuron slot on a subnetwork. + * + * # Raises: + * * 'MechanismDoesNotExist': + * - Attempting to register to a non existent network. + * + * * 'TooManyRegistrationsThisBlock': + * - This registration exceeds the total allowed on this network this block. + * + * * 'HotKeyAlreadyRegisteredInSubNet': + * - The hotkey is already registered on this network. + * + * * 'InvalidWorkBlock': + * - The work has been performed on a stale, future, or non existent block. + * + * * 'InvalidDifficulty': + * - The work does not match the difficulty. + * + * * 'InvalidSeal': + * - The seal is incorrect. + * + */ + register: TxDescriptor>; + /** + * Register the hotkey to root network + */ + root_register: TxDescriptor>; + /** + * User register a new subnetwork via burning token + */ + burned_register: TxDescriptor>; + /** + * The extrinsic for user to change its hotkey in subnet or all subnets. + */ + swap_hotkey: TxDescriptor>; + /** + * Performs an arbitrary coldkey swap for any coldkey. + * + * Only callable by root as it doesn't require an announcement and can be used to swap any coldkey. + */ + swap_coldkey: TxDescriptor>; + /** + * Sets the childkey take for a given hotkey. + * + * This function allows a coldkey to set the childkey take for a given hotkey. + * The childkey take determines the proportion of stake that the hotkey keeps for itself + * when distributing stake to its children. + * + * # Arguments: + * * `origin` (::RuntimeOrigin): + * - The signature of the calling coldkey. Setting childkey take can only be done by the coldkey. + * + * * `hotkey` (T::AccountId): + * - The hotkey for which the childkey take will be set. + * + * * `take` (u16): + * - The new childkey take value. This is a percentage represented as a value between 0 and 10000, + * where 10000 represents 100%. + * + * # Events: + * * `ChildkeyTakeSet`: + * - On successfully setting the childkey take for a hotkey. + * + * # Errors: + * * `NonAssociatedColdKey`: + * - The coldkey does not own the hotkey. + * * `InvalidChildkeyTake`: + * - The provided take value is invalid (greater than the maximum allowed take). + * * `TxChildkeyTakeRateLimitExceeded`: + * - The rate limit for changing childkey take has been exceeded. + * + */ + set_childkey_take: TxDescriptor>; + /** + * Sets the transaction rate limit for changing childkey take. + * + * This function can only be called by the root origin. + * + * # Arguments: + * * `origin` - The origin of the call, must be root. + * * `tx_rate_limit` - The new rate limit in blocks. + * + * # Errors: + * * `BadOrigin` - If the origin is not root. + * + */ + sudo_set_tx_childkey_take_rate_limit: TxDescriptor>; + /** + * Sets the minimum allowed childkey take. + * + * This function can only be called by the root origin. + * + * # Arguments: + * * `origin` - The origin of the call, must be root. + * * `take` - The new minimum childkey take value. + * + * # Errors: + * * `BadOrigin` - If the origin is not root. + * + */ + sudo_set_min_childkey_take: TxDescriptor>; + /** + * Sets the maximum allowed childkey take. + * + * This function can only be called by the root origin. + * + * # Arguments: + * * `origin` - The origin of the call, must be root. + * * `take` - The new maximum childkey take value. + * + * # Errors: + * * `BadOrigin` - If the origin is not root. + * + */ + sudo_set_max_childkey_take: TxDescriptor>; + /** + * User register a new subnetwork + */ + register_network: TxDescriptor>; + /** + * Facility extrinsic for user to get taken from faucet + * It is only available when pow-faucet feature enabled + * Just deployed in testnet and devnet for testing purpose + */ + faucet: TxDescriptor>; + /** + * Remove a user's subnetwork + * The caller must be the owner of the network + */ + dissolve_network: TxDescriptor>; + /** + * Set a single child for a given hotkey on a specified network. + * + * This function allows a coldkey to set a single child for a given hotkey on a specified network. + * The proportion of the hotkey's stake to be allocated to the child is also specified. + * + * # Arguments: + * * `origin` (::RuntimeOrigin): + * - The signature of the calling coldkey. Setting a hotkey child can only be done by the coldkey. + * + * * `hotkey` (T::AccountId): + * - The hotkey which will be assigned the child. + * + * * `child` (T::AccountId): + * - The child which will be assigned to the hotkey. + * + * * `netuid` (u16): + * - The u16 network identifier where the childkey will exist. + * + * * `proportion` (u64): + * - Proportion of the hotkey's stake to be given to the child, the value must be u64 normalized. + * + * # Events: + * * `ChildAddedSingular`: + * - On successfully registering a child to a hotkey. + * + * # Errors: + * * `MechanismDoesNotExist`: + * - Attempting to register to a non-existent network. + * * `RegistrationNotPermittedOnRootSubnet`: + * - Attempting to register a child on the root network. + * * `NonAssociatedColdKey`: + * - The coldkey does not own the hotkey or the child is the same as the hotkey. + * * `HotKeyAccountNotExists`: + * - The hotkey account does not exist. + * + * # Detailed Explanation of Checks: + * 1. **Signature Verification**: Ensures that the caller has signed the transaction, verifying the coldkey. + * 2. **Root Network Check**: Ensures that the delegation is not on the root network, as child hotkeys are not valid on the root. + * 3. **Network Existence Check**: Ensures that the specified network exists. + * 4. **Ownership Verification**: Ensures that the coldkey owns the hotkey. + * 5. **Hotkey Account Existence Check**: Ensures that the hotkey account already exists. + * 6. **Child-Hotkey Distinction**: Ensures that the child is not the same as the hotkey. + * 7. **Old Children Cleanup**: Removes the hotkey from the parent list of its old children. + * 8. **New Children Assignment**: Assigns the new child to the hotkey and updates the parent list for the new child. + */ + set_children: TxDescriptor>; + /** + * Schedules a coldkey swap operation to be executed at a future block. + * + * WARNING: This function is deprecated, please migrate to `announce_coldkey_swap`/`coldkey_swap` + */ + schedule_swap_coldkey: TxDescriptor>; + /** + * ---- Set prometheus information for the neuron. + * # Args: + * * 'origin': (Origin): + * - The signature of the calling hotkey. + * + * * 'netuid' (u16): + * - The u16 network identifier. + * + * * 'version' (u16): + * - The bittensor version identifier. + * + * * 'ip' (u128): + * - The prometheus ip information as a u128 encoded integer. + * + * * 'port' (u16): + * - The prometheus port information as a u16 encoded integer. + * + * * 'ip_type' (u8): + * - The ip type v4 or v6. + * + */ + set_identity: TxDescriptor>; + /** + * ---- Set the identity information for a subnet. + * # Args: + * * `origin` - (::Origin): + * - The signature of the calling coldkey, which must be the owner of the subnet. + * + * * `netuid` (u16): + * - The unique network identifier of the subnet. + * + * * `subnet_name` (Vec): + * - The name of the subnet. + * + * * `github_repo` (Vec): + * - The GitHub repository associated with the subnet identity. + * + * * `subnet_contact` (Vec): + * - The contact information for the subnet. + */ + set_subnet_identity: TxDescriptor>; + /** + * User register a new subnetwork + */ + register_network_with_identity: TxDescriptor>; + /** + * ---- The implementation for the extrinsic unstake_all: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey. + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `hotkey` (T::AccountId): + * - The associated hotkey account. + * + * # Event: + * * StakeRemoved; + * - On the successfully removing stake from the hotkey account. + * + * # Raises: + * * `NotRegistered`: + * - Thrown if the account we are attempting to unstake from is non existent. + * + * * `NonAssociatedColdKey`: + * - Thrown if the coldkey does not own the hotkey we are unstaking from. + * + * * `NotEnoughStakeToWithdraw`: + * - Thrown if there is not enough stake on the hotkey to withdraw this amount. + * + * * `TxRateLimitExceeded`: + * - Thrown if key has hit transaction rate limit + */ + unstake_all: TxDescriptor>; + /** + * ---- The implementation for the extrinsic unstake_all: Removes all stake from a hotkey account across all subnets and adds it onto a coldkey. + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `hotkey` (T::AccountId): + * - The associated hotkey account. + * + * # Event: + * * StakeRemoved; + * - On the successfully removing stake from the hotkey account. + * + * # Raises: + * * `NotRegistered`: + * - Thrown if the account we are attempting to unstake from is non existent. + * + * * `NonAssociatedColdKey`: + * - Thrown if the coldkey does not own the hotkey we are unstaking from. + * + * * `NotEnoughStakeToWithdraw`: + * - Thrown if there is not enough stake on the hotkey to withdraw this amount. + * + * * `TxRateLimitExceeded`: + * - Thrown if key has hit transaction rate limit + */ + unstake_all_alpha: TxDescriptor>; + /** + * ---- The implementation for the extrinsic move_stake: Moves specified amount of stake from a hotkey to another across subnets. + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `origin_hotkey` (T::AccountId): + * - The hotkey account to move stake from. + * + * * `destination_hotkey` (T::AccountId): + * - The hotkey account to move stake to. + * + * * `origin_netuid` (T::AccountId): + * - The subnet ID to move stake from. + * + * * `destination_netuid` (T::AccountId): + * - The subnet ID to move stake to. + * + * * `alpha_amount` (T::AccountId): + * - The alpha stake amount to move. + * + */ + move_stake: TxDescriptor>; + /** + * Transfers a specified amount of stake from one coldkey to another, optionally across subnets, + * while keeping the same hotkey. + * + * # Arguments + * * `origin` - The origin of the transaction, which must be signed by the `origin_coldkey`. + * * `destination_coldkey` - The coldkey to which the stake is transferred. + * * `hotkey` - The hotkey associated with the stake. + * * `origin_netuid` - The network/subnet ID to move stake from. + * * `destination_netuid` - The network/subnet ID to move stake to (for cross-subnet transfer). + * * `alpha_amount` - The amount of stake to transfer. + * + * # Errors + * Returns an error if: + * * The origin is not signed by the correct coldkey. + * * Either subnet does not exist. + * * The hotkey does not exist. + * * There is insufficient stake on `(origin_coldkey, hotkey, origin_netuid)`. + * * The transfer amount is below the minimum stake requirement. + * + * # Events + * May emit a `StakeTransferred` event on success. + */ + transfer_stake: TxDescriptor>; + /** + * Swaps a specified amount of stake from one subnet to another, while keeping the same coldkey and hotkey. + * + * # Arguments + * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. + * * `hotkey` - The hotkey whose stake is being swapped. + * * `origin_netuid` - The network/subnet ID from which stake is removed. + * * `destination_netuid` - The network/subnet ID to which stake is added. + * * `alpha_amount` - The amount of stake to swap. + * + * # Errors + * Returns an error if: + * * The transaction is not signed by the correct coldkey (i.e., `coldkey_owns_hotkey` fails). + * * Either `origin_netuid` or `destination_netuid` does not exist. + * * The hotkey does not exist. + * * There is insufficient stake on `(coldkey, hotkey, origin_netuid)`. + * * The swap amount is below the minimum stake requirement. + * + * # Events + * May emit a `StakeSwapped` event on success. + */ + swap_stake: TxDescriptor>; + /** + * --- Adds stake to a hotkey on a subnet with a price limit. + * This extrinsic allows to specify the limit price for alpha token + * at which or better (lower) the staking should execute. + * + * In case if slippage occurs and the price shall move beyond the limit + * price, the staking order may execute only partially or not execute + * at all. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The associated hotkey account. + * + * * 'netuid' (u16): + * - Subnetwork UID + * + * * 'amount_staked' (u64): + * - The amount of stake to be added to the hotkey staking account. + * + * * 'limit_price' (u64): + * - The limit price expressed in units of RAO per one Alpha. + * + * * 'allow_partial' (bool): + * - Allows partial execution of the amount. If set to false, this becomes + * fill or kill type or order. + * + * # Event: + * * StakeAdded; + * - On the successfully adding stake to a global account. + * + * # Raises: + * * 'NotEnoughBalanceToStake': + * - Not enough balance on the coldkey to add onto the global account. + * + * * 'NonAssociatedColdKey': + * - The calling coldkey is not associated with this hotkey. + * + * * 'BalanceWithdrawalError': + * - Errors stemming from transaction pallet. + * + */ + add_stake_limit: TxDescriptor>; + /** + * --- Removes stake from a hotkey on a subnet with a price limit. + * This extrinsic allows to specify the limit price for alpha token + * at which or better (higher) the staking should execute. + * + * In case if slippage occurs and the price shall move beyond the limit + * price, the staking order may execute only partially or not execute + * at all. + * + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * * 'hotkey' (T::AccountId): + * - The associated hotkey account. + * + * * 'netuid' (u16): + * - Subnetwork UID + * + * * 'amount_unstaked' (u64): + * - The amount of stake to be added to the hotkey staking account. + * + * * 'limit_price' (u64): + * - The limit price expressed in units of RAO per one Alpha. + * + * * 'allow_partial' (bool): + * - Allows partial execution of the amount. If set to false, this becomes + * fill or kill type or order. + * + * # Event: + * * StakeRemoved; + * - On the successfully removing stake from the hotkey account. + * + * # Raises: + * * 'NotRegistered': + * - Thrown if the account we are attempting to unstake from is non existent. + * + * * 'NonAssociatedColdKey': + * - Thrown if the coldkey does not own the hotkey we are unstaking from. + * + * * 'NotEnoughStakeToWithdraw': + * - Thrown if there is not enough stake on the hotkey to withdwraw this amount. + * + */ + remove_stake_limit: TxDescriptor>; + /** + * Swaps a specified amount of stake from one subnet to another, while keeping the same coldkey and hotkey. + * + * # Arguments + * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. + * * `hotkey` - The hotkey whose stake is being swapped. + * * `origin_netuid` - The network/subnet ID from which stake is removed. + * * `destination_netuid` - The network/subnet ID to which stake is added. + * * `alpha_amount` - The amount of stake to swap. + * * `limit_price` - The limit price expressed in units of RAO per one Alpha. + * * `allow_partial` - Allows partial execution of the amount. If set to false, this becomes fill or kill type or order. + * + * # Errors + * Returns an error if: + * * The transaction is not signed by the correct coldkey (i.e., `coldkey_owns_hotkey` fails). + * * Either `origin_netuid` or `destination_netuid` does not exist. + * * The hotkey does not exist. + * * There is insufficient stake on `(coldkey, hotkey, origin_netuid)`. + * * The swap amount is below the minimum stake requirement. + * + * # Events + * May emit a `StakeSwapped` event on success. + */ + swap_stake_limit: TxDescriptor>; + /** + * Attempts to associate a hotkey with a coldkey. + * + * # Arguments + * * `origin` - The origin of the transaction, which must be signed by the coldkey that owns the `hotkey`. + * * `hotkey` - The hotkey to associate with the coldkey. + * + * # Note + * Will charge based on the weight even if the hotkey is already associated with a coldkey. + */ + try_associate_hotkey: TxDescriptor>; + /** + * Initiates a call on a subnet. + * + * # Arguments + * * `origin` - The origin of the call, which must be signed by the subnet owner. + * * `netuid` - The unique identifier of the subnet on which the call is being initiated. + * + * # Events + * Emits a `FirstEmissionBlockNumberSet` event on success. + */ + start_call: TxDescriptor>; + /** + * Attempts to associate a hotkey with an EVM key. + * + * The signature will be checked to see if the recovered public key matches the `evm_key` provided. + * + * The EVM key is expected to sign the message according to this formula to produce the signature: + * ```text + * keccak_256(hotkey ++ keccak_256(block_number)) + * ``` + * + * # Arguments + * * `origin` - The origin of the transaction, which must be signed by the `hotkey`. + * * `netuid` - The netuid that the `hotkey` belongs to. + * * `evm_key` - The EVM key to associate with the `hotkey`. + * * `block_number` - The block number used in the `signature`. + * * `signature` - A signed message by the `evm_key` containing the `hotkey` and the hashed `block_number`. + * + * # Errors + * Returns an error if: + * * The transaction is not signed. + * * The hotkey does not belong to the subnet identified by the netuid. + * * The EVM key cannot be recovered from the signature. + * * The EVM key recovered from the signature does not match the given EVM key. + * + * # Events + * May emit a `EvmKeyAssociated` event on success + */ + associate_evm_key: TxDescriptor>; + /** + * Recycles alpha from a cold/hot key pair, reducing AlphaOut on a subnet + * + * # Arguments + * * `origin` - The origin of the call (must be signed by the coldkey) + * * `hotkey` - The hotkey account + * * `amount` - The amount of alpha to recycle + * * `netuid` - The subnet ID + * + * # Events + * Emits a `TokensRecycled` event on success. + */ + recycle_alpha: TxDescriptor>; + /** + * Burns alpha from a cold/hot key pair without reducing `AlphaOut` + * + * # Arguments + * * `origin` - The origin of the call (must be signed by the coldkey) + * * `hotkey` - The hotkey account + * * `amount` - The amount of alpha to burn + * * `netuid` - The subnet ID + * + * # Events + * Emits a `TokensBurned` event on success. + */ + burn_alpha: TxDescriptor>; + /** + * Sets the pending childkey cooldown (in blocks). Root only. + */ + set_pending_childkey_cooldown: TxDescriptor>; + /** + * Removes all stake from a hotkey on a subnet with a price limit. + * This extrinsic allows to specify the limit price for alpha token + * at which or better (higher) the staking should execute. + * Without limit_price it remove all the stake similar to `remove_stake` extrinsic + */ + remove_stake_full_limit: TxDescriptor>; + /** + * Register a new leased network. + * + * The crowdloan's contributions are used to compute the share of the emissions that the contributors + * will receive as dividends. + * + * The leftover cap is refunded to the contributors and the beneficiary. + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `emissions_share` (Percent): + * - The share of the emissions that the contributors will receive as dividends. + * + * * `end_block` (Option>): + * - The block at which the lease will end. If not defined, the lease is perpetual. + */ + register_leased_network: TxDescriptor>; + /** + * Terminate a lease. + * + * The beneficiary can terminate the lease after the end block has passed and get the subnet ownership. + * The subnet is transferred to the beneficiary and the lease is removed from storage. + * + * **The hotkey must be owned by the beneficiary coldkey.** + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `lease_id` (LeaseId): + * - The ID of the lease to terminate. + * + * * `hotkey` (T::AccountId): + * - The hotkey of the beneficiary to mark as subnet owner hotkey. + */ + terminate_lease: TxDescriptor>; + /** + * Updates the symbol for a subnet. + * + * # Arguments + * * `origin` - The origin of the call, which must be the subnet owner or root. + * * `netuid` - The unique identifier of the subnet on which the symbol is being set. + * * `symbol` - The symbol to set for the subnet. + * + * # Errors + * Returns an error if: + * * The transaction is not signed by the subnet owner. + * * The symbol does not exist. + * * The symbol is already in use by another subnet. + * + * # Events + * Emits a `SymbolUpdated` event on success. + */ + update_symbol: TxDescriptor>; + /** + * ---- Used to commit timelock encrypted commit-reveal weight values to later be revealed. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `commit` (`Vec`): + * - The encrypted compressed commit. + * The steps for this are: + * 1. Instantiate [`WeightsTlockPayload`] + * 2. Serialize it using the `parity_scale_codec::Encode` trait + * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] + * to produce a [`TLECiphertext`] type. + * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. + * + * * reveal_round (`u64`): + * - The drand reveal round which will be avaliable during epoch `n+1` from the current + * epoch. + * + * * commit_reveal_version (`u16`): + * - The client (bittensor-drand) version + */ + commit_timelocked_weights: TxDescriptor>; + /** + * Set the autostake destination hotkey for a coldkey. + * + * The caller selects a hotkey where all future rewards + * will be automatically staked. + * + * # Args: + * * `origin` - (::Origin): + * - The signature of the caller's coldkey. + * + * * `hotkey` (T::AccountId): + * - The hotkey account to designate as the autostake destination. + */ + set_coldkey_auto_stake_hotkey: TxDescriptor>; + /** + * ---- Used to commit timelock encrypted commit-reveal weight values to later be revealed for + * a mechanism. + * + * # Args: + * * `origin`: (`::RuntimeOrigin`): + * - The committing hotkey. + * + * * `netuid` (`u16`): + * - The u16 network identifier. + * + * * `mecid` (`u8`): + * - The u8 mechanism identifier. + * + * * `commit` (`Vec`): + * - The encrypted compressed commit. + * The steps for this are: + * 1. Instantiate [`WeightsTlockPayload`] + * 2. Serialize it using the `parity_scale_codec::Encode` trait + * 3. Encrypt it following the steps (here)[https://github.com/ideal-lab5/tle/blob/f8e6019f0fb02c380ebfa6b30efb61786dede07b/timelock/src/tlock.rs#L283-L336] + * to produce a [`TLECiphertext`] type. + * 4. Serialize and compress using the `ark-serialize` `CanonicalSerialize` trait. + * + * * reveal_round (`u64`): + * - The drand reveal round which will be avaliable during epoch `n+1` from the current + * epoch. + * + * * commit_reveal_version (`u16`): + * - The client (bittensor-drand) version + */ + commit_timelocked_mechanism_weights: TxDescriptor>; + /** + * Remove a subnetwork + * The caller must be root + */ + root_dissolve_network: TxDescriptor>; + /** + * --- Claims the root emissions for a coldkey. + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * # Event: + * * RootClaimed; + * - On the successfully claiming the root emissions for a coldkey. + * + * # Raises: + * + */ + claim_root: TxDescriptor>; + /** + * --- Sets the root claim type for the coldkey. + * # Args: + * * 'origin': (Origin): + * - The signature of the caller's coldkey. + * + * # Event: + * * RootClaimTypeSet; + * - On the successfully setting the root claim type for the coldkey. + * + */ + set_root_claim_type: TxDescriptor>; + /** + * --- Sets root claim number (sudo extrinsic). Zero disables auto-claim. + */ + sudo_set_num_root_claims: TxDescriptor>; + /** + * --- Sets root claim threshold for subnet (sudo or owner origin). + */ + sudo_set_root_claim_threshold: TxDescriptor>; + /** + * Announces a coldkey swap using BlakeTwo256 hash of the new coldkey. + * + * This is required before the coldkey swap can be performed + * after the delay period. + * + * It can be reannounced after a delay of `ColdkeySwapReannouncementDelay` following + * the first valid execution block of the original announcement. + * + * The dispatch origin of this call must be the original coldkey that made the announcement. + * + * - `new_coldkey_hash`: The hash of the new coldkey using BlakeTwo256. + * + * The `ColdkeySwapAnnounced` event is emitted on successful announcement. + * + */ + announce_coldkey_swap: TxDescriptor>; + /** + * Performs a coldkey swap if an announcement has been made. + * + * The dispatch origin of this call must be the original coldkey that made the announcement. + * + * - `new_coldkey`: The new coldkey to swap to. The BlakeTwo256 hash of the new coldkey must be + * the same as the announced coldkey hash. + * + * The `ColdkeySwapped` event is emitted on successful swap. + */ + swap_coldkey_announced: TxDescriptor>; + /** + * Dispute a coldkey swap. + * + * This will prevent any further actions on the coldkey swap + * until triumvirate step in to resolve the issue. + * + * - `coldkey`: The coldkey to dispute the swap for. + * + */ + dispute_coldkey_swap: TxDescriptor; + /** + * Reset a coldkey swap by clearing the announcement and dispute status. + * + * The dispatch origin of this call must be root. + * + * - `coldkey`: The coldkey to reset the swap for. + * + */ + reset_coldkey_swap: TxDescriptor>; + /** + * Enables voting power tracking for a subnet. + * + * This function can be called by the subnet owner or root. + * When enabled, voting power EMA is updated every epoch for all validators. + * Voting power starts at 0 and increases over epochs. + * + * # Arguments: + * * `origin` - The origin of the call, must be subnet owner or root. + * * `netuid` - The subnet to enable voting power tracking for. + * + * # Errors: + * * `SubnetNotExist` - If the subnet does not exist. + * * `NotSubnetOwner` - If the caller is not the subnet owner or root. + */ + enable_voting_power_tracking: TxDescriptor>; + /** + * Schedules disabling of voting power tracking for a subnet. + * + * This function can be called by the subnet owner or root. + * Voting power tracking will continue for 14 days (grace period) after this call, + * then automatically disable and clear all VotingPower entries for the subnet. + * + * # Arguments: + * * `origin` - The origin of the call, must be subnet owner or root. + * * `netuid` - The subnet to schedule disabling voting power tracking for. + * + * # Errors: + * * `SubnetNotExist` - If the subnet does not exist. + * * `NotSubnetOwner` - If the caller is not the subnet owner or root. + * * `VotingPowerTrackingNotEnabled` - If voting power tracking is not enabled. + */ + disable_voting_power_tracking: TxDescriptor>; + /** + * Sets the EMA alpha value for voting power calculation on a subnet. + * + * This function can only be called by root (sudo). + * Higher alpha = faster response to stake changes. + * Alpha is stored as u64 with 18 decimal precision (1.0 = 10^18). + * + * # Arguments: + * * `origin` - The origin of the call, must be root. + * * `netuid` - The subnet to set the alpha for. + * * `alpha` - The new alpha value (u64 with 18 decimal precision). + * + * # Errors: + * * `BadOrigin` - If the origin is not root. + * * `SubnetNotExist` - If the subnet does not exist. + * * `InvalidVotingPowerEmaAlpha` - If alpha is greater than 10^18 (1.0). + */ + sudo_set_voting_power_ema_alpha: TxDescriptor>; + /** + * --- The extrinsic is a combination of add_stake(add_stake_limit) and burn_alpha. We buy + * alpha token first and immediately burn the acquired amount of alpha (aka Subnet buyback). + */ + add_stake_burn: TxDescriptor>; + }; + Utility: { + /** + * Send a batch of dispatch calls. + * + * May be called from any origin except `None`. + * + * - `calls`: The calls to be dispatched from the same origin. The number of call must not + * exceed the constant: `batched_calls_limit` (available in constant metadata). + * + * If origin is root then the calls are dispatched without checking origin filter. (This + * includes bypassing `frame_system::Config::BaseCallFilter`). + * + * ## Complexity + * - O(C) where C is the number of calls to be batched. + * + * This will return `Ok` in all circumstances. To determine the success of the batch, an + * event is deposited. If a call failed and the batch was interrupted, then the + * `BatchInterrupted` event is deposited, along with the number of successful calls made + * and the error of the failed call. If all were successful, then the `BatchCompleted` + * event is deposited. + */ + batch: TxDescriptor>; + /** + * Send a call through an indexed pseudonym of the sender. + * + * Filter from origin are passed along. The call will be dispatched with an origin which + * use the same filter as the origin of this call. + * + * NOTE: If you need to ensure that any account-based filtering is not honored (i.e. + * because you expect `proxy` to have been used prior in the call stack and you do not want + * the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1` + * in the Multisig pallet instead. + * + * NOTE: Prior to version *12, this was called `as_limited_sub`. + * + * The dispatch origin for this call must be _Signed_. + */ + as_derivative: TxDescriptor>; + /** + * Send a batch of dispatch calls and atomically execute them. + * The whole transaction will rollback and fail if any of the calls failed. + * + * May be called from any origin except `None`. + * + * - `calls`: The calls to be dispatched from the same origin. The number of call must not + * exceed the constant: `batched_calls_limit` (available in constant metadata). + * + * If origin is root then the calls are dispatched without checking origin filter. (This + * includes bypassing `frame_system::Config::BaseCallFilter`). + * + * ## Complexity + * - O(C) where C is the number of calls to be batched. + */ + batch_all: TxDescriptor>; + /** + * Dispatches a function call with a provided origin. + * + * The dispatch origin for this call must be _Root_. + * + * ## Complexity + * - O(1). + */ + dispatch_as: TxDescriptor>; + /** + * Send a batch of dispatch calls. + * Unlike `batch`, it allows errors and won't interrupt. + * + * May be called from any origin except `None`. + * + * - `calls`: The calls to be dispatched from the same origin. The number of call must not + * exceed the constant: `batched_calls_limit` (available in constant metadata). + * + * If origin is root then the calls are dispatch without checking origin filter. (This + * includes bypassing `frame_system::Config::BaseCallFilter`). + * + * ## Complexity + * - O(C) where C is the number of calls to be batched. + */ + force_batch: TxDescriptor>; + /** + * Dispatch a function call with a specified weight. + * + * This function does not check the weight of the call, and instead allows the + * Root origin to specify the weight of the call. + * + * The dispatch origin for this call must be _Root_. + */ + with_weight: TxDescriptor>; + /** + * Dispatch a fallback call in the event the main call fails to execute. + * May be called from any origin except `None`. + * + * This function first attempts to dispatch the `main` call. + * If the `main` call fails, the `fallback` is attemted. + * if the fallback is successfully dispatched, the weights of both calls + * are accumulated and an event containing the main call error is deposited. + * + * In the event of a fallback failure the whole call fails + * with the weights returned. + * + * - `main`: The main call to be dispatched. This is the primary action to execute. + * - `fallback`: The fallback call to be dispatched in case the `main` call fails. + * + * ## Dispatch Logic + * - If the origin is `root`, both the main and fallback calls are executed without + * applying any origin filters. + * - If the origin is not `root`, the origin filter is applied to both the `main` and + * `fallback` calls. + * + * ## Use Case + * - Some use cases might involve submitting a `batch` type call in either main, fallback + * or both. + */ + if_else: TxDescriptor>; + /** + * Dispatches a function call with a provided origin. + * + * Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call. + * + * The dispatch origin for this call must be _Root_. + */ + dispatch_as_fallible: TxDescriptor>; + }; + Sudo: { + /** + * Authenticates the sudo key and dispatches a function call with `Root` origin. + */ + sudo: TxDescriptor>; + /** + * Authenticates the sudo key and dispatches a function call with `Root` origin. + * This function does not check the weight of the call, and instead allows the + * Sudo user to specify the weight of the call. + * + * The dispatch origin for this call must be _Signed_. + */ + sudo_unchecked_weight: TxDescriptor>; + /** + * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo + * key. + */ + set_key: TxDescriptor>; + /** + * Authenticates the sudo key and dispatches a function call with `Signed` origin from + * a given account. + * + * The dispatch origin for this call must be _Signed_. + */ + sudo_as: TxDescriptor>; + /** + * Permanently removes the sudo key. + * + * **This cannot be un-done.** + */ + remove_key: TxDescriptor; + }; + Multisig: { + /** + * Immediately dispatch a multi-signature call using a single approval from the caller. + * + * The dispatch origin for this call must be _Signed_. + * + * - `other_signatories`: The accounts (other than the sender) who are part of the + * multi-signature, but do not participate in the approval process. + * - `call`: The call to be executed. + * + * Result is equivalent to the dispatched result. + * + * ## Complexity + * O(Z + C) where Z is the length of the call and C its execution weight. + */ + as_multi_threshold_1: TxDescriptor>; + /** + * Register approval for a dispatch to be made from a deterministic composite account if + * approved by a total of `threshold - 1` of `other_signatories`. + * + * If there are enough, then dispatch the call. + * + * Payment: `DepositBase` will be reserved if this is the first approval, plus + * `threshold` times `DepositFactor`. It is returned once this dispatch happens or + * is cancelled. + * + * The dispatch origin for this call must be _Signed_. + * + * - `threshold`: The total number of approvals for this dispatch before it is executed. + * - `other_signatories`: The accounts (other than the sender) who can approve this + * dispatch. May not be empty. + * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is + * not the first approval, then it must be `Some`, with the timepoint (block number and + * transaction index) of the first approval transaction. + * - `call`: The call to be executed. + * + * NOTE: Unless this is the final approval, you will generally want to use + * `approve_as_multi` instead, since it only requires a hash of the call. + * + * Result is equivalent to the dispatched result if `threshold` is exactly `1`. Otherwise + * on success, result is `Ok` and the result from the interior call, if it was executed, + * may be found in the deposited `MultisigExecuted` event. + * + * ## Complexity + * - `O(S + Z + Call)`. + * - Up to one balance-reserve or unreserve operation. + * - One passthrough operation, one insert, both `O(S)` where `S` is the number of + * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. + * - One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len. + * - One encode & hash, both of complexity `O(S)`. + * - Up to one binary search and insert (`O(logS + S)`). + * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. + * - One event. + * - The weight of the `call`. + * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit + * taken for its lifetime of `DepositBase + threshold * DepositFactor`. + */ + as_multi: TxDescriptor>; + /** + * Register approval for a dispatch to be made from a deterministic composite account if + * approved by a total of `threshold - 1` of `other_signatories`. + * + * Payment: `DepositBase` will be reserved if this is the first approval, plus + * `threshold` times `DepositFactor`. It is returned once this dispatch happens or + * is cancelled. + * + * The dispatch origin for this call must be _Signed_. + * + * - `threshold`: The total number of approvals for this dispatch before it is executed. + * - `other_signatories`: The accounts (other than the sender) who can approve this + * dispatch. May not be empty. + * - `maybe_timepoint`: If this is the first approval, then this must be `None`. If it is + * not the first approval, then it must be `Some`, with the timepoint (block number and + * transaction index) of the first approval transaction. + * - `call_hash`: The hash of the call to be executed. + * + * NOTE: If this is the final approval, you will want to use `as_multi` instead. + * + * ## Complexity + * - `O(S)`. + * - Up to one balance-reserve or unreserve operation. + * - One passthrough operation, one insert, both `O(S)` where `S` is the number of + * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. + * - One encode & hash, both of complexity `O(S)`. + * - Up to one binary search and insert (`O(logS + S)`). + * - I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove. + * - One event. + * - Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit + * taken for its lifetime of `DepositBase + threshold * DepositFactor`. + */ + approve_as_multi: TxDescriptor>; + /** + * Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously + * for this operation will be unreserved on success. + * + * The dispatch origin for this call must be _Signed_. + * + * - `threshold`: The total number of approvals for this dispatch before it is executed. + * - `other_signatories`: The accounts (other than the sender) who can approve this + * dispatch. May not be empty. + * - `timepoint`: The timepoint (block number and transaction index) of the first approval + * transaction for this dispatch. + * - `call_hash`: The hash of the call to be executed. + * + * ## Complexity + * - `O(S)`. + * - Up to one balance-reserve or unreserve operation. + * - One passthrough operation, one insert, both `O(S)` where `S` is the number of + * signatories. `S` is capped by `MaxSignatories`, with weight being proportional. + * - One encode & hash, both of complexity `O(S)`. + * - One event. + * - I/O: 1 read `O(S)`, one remove. + * - Storage: removes one item. + */ + cancel_as_multi: TxDescriptor>; + /** + * Poke the deposit reserved for an existing multisig operation. + * + * The dispatch origin for this call must be _Signed_ and must be the original depositor of + * the multisig operation. + * + * The transaction fee is waived if the deposit amount has changed. + * + * - `threshold`: The total number of approvals needed for this multisig. + * - `other_signatories`: The accounts (other than the sender) who are part of the + * multisig. + * - `call_hash`: The hash of the call this deposit is reserved for. + * + * Emits `DepositPoked` if successful. + */ + poke_deposit: TxDescriptor>; + }; + Preimage: { + /** + * Register a preimage on-chain. + * + * If the preimage was previously requested, no fees or deposits are taken for providing + * the preimage. Otherwise, a deposit is taken proportional to the size of the preimage. + */ + note_preimage: TxDescriptor>; + /** + * Clear an unrequested preimage from the runtime storage. + * + * If `len` is provided, then it will be a much cheaper operation. + * + * - `hash`: The hash of the preimage to be removed from the store. + * - `len`: The length of the preimage of `hash`. + */ + unnote_preimage: TxDescriptor>; + /** + * Request a preimage be uploaded to the chain without paying any fees or deposits. + * + * If the preimage requests has already been provided on-chain, we unreserve any deposit + * a user may have paid, and take the control of the preimage out of their hands. + */ + request_preimage: TxDescriptor>; + /** + * Clear a previously made request for a preimage. + * + * NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`. + */ + unrequest_preimage: TxDescriptor>; + /** + * Ensure that the bulk of pre-images is upgraded. + * + * The caller pays no fee if at least 90% of pre-images were successfully updated. + */ + ensure_updated: TxDescriptor>; + }; + Scheduler: { + /** + * Anonymously schedule a task. + */ + schedule: TxDescriptor>; + /** + * Cancel an anonymously scheduled task. + */ + cancel: TxDescriptor>; + /** + * Schedule a named task. + */ + schedule_named: TxDescriptor>; + /** + * Cancel a named scheduled task. + */ + cancel_named: TxDescriptor>; + /** + * Anonymously schedule a task after a delay. + */ + schedule_after: TxDescriptor>; + /** + * Schedule a named task after a delay. + */ + schedule_named_after: TxDescriptor>; + /** + * Set a retry configuration for a task so that, in case its scheduled run fails, it will + * be retried after `period` blocks, for a total amount of `retries` retries or until it + * succeeds. + * + * Tasks which need to be scheduled for a retry are still subject to weight metering and + * agenda space, same as a regular task. If a periodic task fails, it will be scheduled + * normally while the task is retrying. + * + * Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic + * clones of the original task. Their retry configuration will be derived from the + * original task's configuration, but will have a lower value for `remaining` than the + * original `total_retries`. + */ + set_retry: TxDescriptor>; + /** + * Set a retry configuration for a named task so that, in case its scheduled run fails, it + * will be retried after `period` blocks, for a total amount of `retries` retries or until + * it succeeds. + * + * Tasks which need to be scheduled for a retry are still subject to weight metering and + * agenda space, same as a regular task. If a periodic task fails, it will be scheduled + * normally while the task is retrying. + * + * Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic + * clones of the original task. Their retry configuration will be derived from the + * original task's configuration, but will have a lower value for `remaining` than the + * original `total_retries`. + */ + set_retry_named: TxDescriptor>; + /** + * Removes the retry configuration of a task. + */ + cancel_retry: TxDescriptor>; + /** + * Cancel the retry configuration of a named task. + */ + cancel_retry_named: TxDescriptor>; + }; + Proxy: { + /** + * Dispatch the given `call` from an account that the sender is authorised for through + * `add_proxy`. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `real`: The account that the proxy will make a call on behalf of. + * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call. + * - `call`: The call to be made by the `real` account. + */ + proxy: TxDescriptor>; + /** + * Register a proxy account for the sender that is able to make calls on its behalf. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `proxy`: The account that the `caller` would like to make a proxy. + * - `proxy_type`: The permissions allowed for this proxy account. + * - `delay`: The announcement period required of the initial proxy. Will generally be + * zero. + */ + add_proxy: TxDescriptor>; + /** + * Unregister a proxy account for the sender. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `proxy`: The account that the `caller` would like to remove as a proxy. + * - `proxy_type`: The permissions currently enabled for the removed proxy account. + */ + remove_proxy: TxDescriptor>; + /** + * Unregister all proxy accounts for the sender. + * + * The dispatch origin for this call must be _Signed_. + * + * WARNING: This may be called on accounts created by `create_pure`, however if done, then + * the unreserved fees will be inaccessible. **All access to this account will be lost.** + */ + remove_proxies: TxDescriptor; + /** + * Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and + * initialize it with a proxy of `proxy_type` for `origin` sender. + * + * Requires a `Signed` origin. + * + * - `proxy_type`: The type of the proxy that the sender will be registered as over the + * new account. This will almost always be the most permissive `ProxyType` possible to + * allow for maximum flexibility. + * - `index`: A disambiguation index, in case this is called multiple times in the same + * transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just + * want to use `0`. + * - `delay`: The announcement period required of the initial proxy. Will generally be + * zero. + * + * Fails with `Duplicate` if this has already been called in this transaction, from the + * same sender, with the same parameters. + * + * Fails if there are insufficient funds to pay for deposit. + */ + create_pure: TxDescriptor>; + /** + * Removes a previously spawned pure proxy. + * + * WARNING: **All access to this account will be lost.** Any funds held in it will be + * inaccessible. + * + * Requires a `Signed` origin, and the sender account must have been created by a call to + * `create_pure` with corresponding parameters. + * + * - `spawner`: The account that originally called `create_pure` to create this account. + * - `index`: The disambiguation index originally passed to `create_pure`. Probably `0`. + * - `proxy_type`: The proxy type originally passed to `create_pure`. + * - `height`: The height of the chain when the call to `create_pure` was processed. + * - `ext_index`: The extrinsic index in which the call to `create_pure` was processed. + * + * Fails with `NoPermission` in case the caller is not a previously created pure + * account whose `create_pure` call has corresponding parameters. + */ + kill_pure: TxDescriptor>; + /** + * Publish the hash of a proxy-call that will be made in the future. + * + * This must be called some number of blocks before the corresponding `proxy` is attempted + * if the delay associated with the proxy relationship is greater than zero. + * + * No more than `MaxPending` announcements may be made at any one time. + * + * This will take a deposit of `AnnouncementDepositFactor` as well as + * `AnnouncementDepositBase` if there are no other pending announcements. + * + * The dispatch origin for this call must be _Signed_ and a proxy of `real`. + * + * Parameters: + * - `real`: The account that the proxy will make a call on behalf of. + * - `call_hash`: The hash of the call to be made by the `real` account. + */ + announce: TxDescriptor>; + /** + * Remove a given announcement. + * + * May be called by a proxy account to remove a call they previously announced and return + * the deposit. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `real`: The account that the proxy will make a call on behalf of. + * - `call_hash`: The hash of the call to be made by the `real` account. + */ + remove_announcement: TxDescriptor>; + /** + * Remove the given announcement of a delegate. + * + * May be called by a target (proxied) account to remove a call that one of their delegates + * (`delegate`) has announced they want to execute. The deposit is returned. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `delegate`: The account that previously announced the call. + * - `call_hash`: The hash of the call to be made. + */ + reject_announcement: TxDescriptor>; + /** + * Dispatch the given `call` from an account that the sender is authorized for through + * `add_proxy`. + * + * Removes any corresponding announcement(s). + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `real`: The account that the proxy will make a call on behalf of. + * - `force_proxy_type`: Specify the exact proxy type to be used and checked for this call. + * - `call`: The call to be made by the `real` account. + */ + proxy_announced: TxDescriptor>; + /** + * Poke / Adjust deposits made for proxies and announcements based on current values. + * This can be used by accounts to possibly lower their locked amount. + * + * The dispatch origin for this call must be _Signed_. + * + * The transaction fee is waived if the deposit amount has changed. + * + * Emits `DepositPoked` if successful. + */ + poke_deposit: TxDescriptor; + }; + Registry: { + /** + * Register an identity for an account. This will overwrite any existing identity. + */ + set_identity: TxDescriptor>; + /** + * Clear the identity of an account. + */ + clear_identity: TxDescriptor>; + }; + Commitments: { + /** + * Set the commitment for a given netuid + */ + set_commitment: TxDescriptor>; + /** + * Sudo-set MaxSpace + */ + set_max_space: TxDescriptor>; + }; + AdminUtils: { + /** + * The extrinsic sets the new authorities for Aura consensus. + * It is only callable by the root account. + * The extrinsic will call the Aura pallet to change the authorities. + */ + swap_authorities: TxDescriptor>; + /** + * The extrinsic sets the default take for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the default take. + */ + sudo_set_default_take: TxDescriptor>; + /** + * The extrinsic sets the transaction rate limit for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the transaction rate limit. + */ + sudo_set_tx_rate_limit: TxDescriptor>; + /** + * The extrinsic sets the serving rate limit for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the serving rate limit. + */ + sudo_set_serving_rate_limit: TxDescriptor>; + /** + * The extrinsic sets the minimum difficulty for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the minimum difficulty. + */ + sudo_set_min_difficulty: TxDescriptor>; + /** + * The extrinsic sets the maximum difficulty for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the maximum difficulty. + */ + sudo_set_max_difficulty: TxDescriptor>; + /** + * The extrinsic sets the weights version key for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the weights version key. + */ + sudo_set_weights_version_key: TxDescriptor>; + /** + * The extrinsic sets the weights set rate limit for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the weights set rate limit. + */ + sudo_set_weights_set_rate_limit: TxDescriptor>; + /** + * The extrinsic sets the adjustment interval for a subnet. + * It is only callable by the root account, not changeable by the subnet owner. + * The extrinsic will call the Subtensor pallet to set the adjustment interval. + */ + sudo_set_adjustment_interval: TxDescriptor>; + /** + * The extrinsic sets the adjustment alpha for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the adjustment alpha. + */ + sudo_set_adjustment_alpha: TxDescriptor>; + /** + * The extrinsic sets the immunity period for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the immunity period. + */ + sudo_set_immunity_period: TxDescriptor>; + /** + * The extrinsic sets the minimum allowed weights for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the minimum allowed weights. + */ + sudo_set_min_allowed_weights: TxDescriptor>; + /** + * The extrinsic sets the maximum allowed UIDs for a subnet. + * It is only callable by the root account and subnet owner. + * The extrinsic will call the Subtensor pallet to set the maximum allowed UIDs for a subnet. + */ + sudo_set_max_allowed_uids: TxDescriptor>; + /** + * The extrinsic sets the kappa for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the kappa. + */ + sudo_set_kappa: TxDescriptor>; + /** + * The extrinsic sets the rho for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the rho. + */ + sudo_set_rho: TxDescriptor>; + /** + * The extrinsic sets the activity cutoff for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the activity cutoff. + */ + sudo_set_activity_cutoff: TxDescriptor>; + /** + * The extrinsic sets the network registration allowed for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the network registration allowed. + */ + sudo_set_network_registration_allowed: TxDescriptor>; + /** + * The extrinsic sets the network PoW registration allowed for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the network PoW registration allowed. + */ + sudo_set_network_pow_registration_allowed: TxDescriptor>; + /** + * The extrinsic sets the target registrations per interval for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the target registrations per interval. + */ + sudo_set_target_registrations_per_interval: TxDescriptor>; + /** + * The extrinsic sets the minimum burn for a subnet. + * It is only callable by root and subnet owner. + * The extrinsic will call the Subtensor pallet to set the minimum burn. + */ + sudo_set_min_burn: TxDescriptor>; + /** + * The extrinsic sets the maximum burn for a subnet. + * It is only callable by root and subnet owner. + * The extrinsic will call the Subtensor pallet to set the maximum burn. + */ + sudo_set_max_burn: TxDescriptor>; + /** + * The extrinsic sets the difficulty for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the difficulty. + */ + sudo_set_difficulty: TxDescriptor>; + /** + * The extrinsic sets the maximum allowed validators for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the maximum allowed validators. + */ + sudo_set_max_allowed_validators: TxDescriptor>; + /** + * The extrinsic sets the bonds moving average for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the bonds moving average. + */ + sudo_set_bonds_moving_average: TxDescriptor>; + /** + * The extrinsic sets the bonds penalty for a subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the bonds penalty. + */ + sudo_set_bonds_penalty: TxDescriptor>; + /** + * The extrinsic sets the maximum registrations per block for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the maximum registrations per block. + */ + sudo_set_max_registrations_per_block: TxDescriptor>; + /** + * The extrinsic sets the subnet owner cut for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the subnet owner cut. + */ + sudo_set_subnet_owner_cut: TxDescriptor>; + /** + * The extrinsic sets the network rate limit for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the network rate limit. + */ + sudo_set_network_rate_limit: TxDescriptor>; + /** + * The extrinsic sets the tempo for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the tempo. + */ + sudo_set_tempo: TxDescriptor>; + /** + * The extrinsic sets the total issuance for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the issuance for the network. + */ + sudo_set_total_issuance: TxDescriptor>; + /** + * The extrinsic sets the immunity period for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the immunity period for the network. + */ + sudo_set_network_immunity_period: TxDescriptor>; + /** + * The extrinsic sets the min lock cost for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the min lock cost for the network. + */ + sudo_set_network_min_lock_cost: TxDescriptor>; + /** + * The extrinsic sets the subnet limit for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the subnet limit. + */ + sudo_set_subnet_limit: TxDescriptor>; + /** + * The extrinsic sets the lock reduction interval for the network. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the lock reduction interval. + */ + sudo_set_lock_reduction_interval: TxDescriptor>; + /** + * The extrinsic sets the recycled RAO for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the recycled RAO. + */ + sudo_set_rao_recycled: TxDescriptor>; + /** + * The extrinsic sets the weights min stake. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the weights min stake. + */ + sudo_set_stake_threshold: TxDescriptor>; + /** + * The extrinsic sets the minimum stake required for nominators. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the minimum stake required for nominators. + */ + sudo_set_nominator_min_required_stake: TxDescriptor>; + /** + * The extrinsic sets the rate limit for delegate take transactions. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the rate limit for delegate take transactions. + */ + sudo_set_tx_delegate_take_rate_limit: TxDescriptor>; + /** + * The extrinsic sets the minimum delegate take. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the minimum delegate take. + */ + sudo_set_min_delegate_take: TxDescriptor>; + /** + * The extrinsic enabled/disables commit/reaveal for a given subnet. + * It is only callable by the root account or subnet owner. + * The extrinsic will call the Subtensor pallet to set the value. + */ + sudo_set_commit_reveal_weights_enabled: TxDescriptor>; + /** + * Enables or disables Liquid Alpha for a given subnet. + * + * # Parameters + * - `origin`: The origin of the call, which must be the root account or subnet owner. + * - `netuid`: The unique identifier for the subnet. + * - `enabled`: A boolean flag to enable or disable Liquid Alpha. + * + * # Weight + * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. + */ + sudo_set_liquid_alpha_enabled: TxDescriptor>; + /** + * Sets values for liquid alpha + */ + sudo_set_alpha_values: TxDescriptor>; + /** + * Sets the duration of the dissolve network schedule. + * + * This extrinsic allows the root account to set the duration for the dissolve network schedule. + * The dissolve network schedule determines how long it takes for a network dissolution operation to complete. + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `duration` - The new duration for the dissolve network schedule, in number of blocks. + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + sudo_set_dissolve_network_schedule_duration: TxDescriptor>; + /** + * Sets the commit-reveal weights periods for a specific subnet. + * + * This extrinsic allows the subnet owner or root account to set the duration (in epochs) during which committed weights must be revealed. + * The commit-reveal mechanism ensures that users commit weights in advance and reveal them only within a specified period. + * + * # Arguments + * * `origin` - The origin of the call, which must be the subnet owner or the root account. + * * `netuid` - The unique identifier of the subnet for which the periods are being set. + * * `periods` - The number of epochs that define the commit-reveal period. + * + * # Errors + * * `BadOrigin` - If the caller is neither the subnet owner nor the root account. + * * `SubnetDoesNotExist` - If the specified subnet does not exist. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + sudo_set_commit_reveal_weights_interval: TxDescriptor>; + /** + * Sets the EVM ChainID. + * + * # Arguments + * * `origin` - The origin of the call, which must be the subnet owner or the root account. + * * `chainId` - The u64 chain ID + * + * # Errors + * * `BadOrigin` - If the caller is neither the subnet owner nor the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + sudo_set_evm_chain_id: TxDescriptor>; + /** + * A public interface for `pallet_grandpa::Pallet::schedule_grandpa_change`. + * + * Schedule a change in the authorities. + * + * The change will be applied at the end of execution of the block `in_blocks` after the + * current block. This value may be 0, in which case the change is applied at the end of + * the current block. + * + * If the `forced` parameter is defined, this indicates that the current set has been + * synchronously determined to be offline and that after `in_blocks` the given change + * should be applied. The given block number indicates the median last finalized block + * number and it should be used as the canon block when starting the new grandpa voter. + * + * No change should be signaled while any change is pending. Returns an error if a change + * is already pending. + */ + schedule_grandpa_change: TxDescriptor>; + /** + * Enable or disable atomic alpha transfers for a given subnet. + * + * # Parameters + * - `origin`: The origin of the call, which must be the root account or subnet owner. + * - `netuid`: The unique identifier for the subnet. + * - `enabled`: A boolean flag to enable or disable Liquid Alpha. + * + * # Weight + * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. + */ + sudo_set_toggle_transfer: TxDescriptor>; + /** + * Set the behaviour of the "burn" UID(s) for a given subnet. + * If set to `Burn`, the miner emission sent to the burn UID(s) will be burned. + * If set to `Recycle`, the miner emission sent to the burn UID(s) will be recycled. + * + * # Parameters + * - `origin`: The origin of the call, which must be the root account or subnet owner. + * - `netuid`: The unique identifier for the subnet. + * - `recycle_or_burn`: The desired behaviour of the "burn" UID(s) for the subnet. + * + */ + sudo_set_recycle_or_burn: TxDescriptor>; + /** + * Toggles the enablement of an EVM precompile. + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `precompile_id` - The identifier of the EVM precompile to toggle. + * * `enabled` - The new enablement state of the precompile. + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + sudo_toggle_evm_precompile: TxDescriptor>; + /** + * + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `alpha` - The new moving alpha value for the SubnetMovingAlpha. + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + sudo_set_subnet_moving_alpha: TxDescriptor>; + /** + * Change the SubnetOwnerHotkey for a given subnet. + * + * # Arguments + * * `origin` - The origin of the call, which must be the subnet owner. + * * `netuid` - The unique identifier for the subnet. + * * `hotkey` - The new hotkey for the subnet owner. + * + * # Errors + * * `BadOrigin` - If the caller is not the subnet owner or root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + sudo_set_subnet_owner_hotkey: TxDescriptor>; + /** + * + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `ema_alpha_period` - Number of blocks for EMA price to halve + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + sudo_set_ema_price_halving_period: TxDescriptor>; + /** + * + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `netuid` - The unique identifier for the subnet. + * * `steepness` - The Steepness for the alpha sigmoid function. (range is 0-int16::MAX, + * negative values are reserved for future use) + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * * `SubnetDoesNotExist` - If the specified subnet does not exist. + * * `NegativeSigmoidSteepness` - If the steepness is negative and the caller is + * root. + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + sudo_set_alpha_sigmoid_steepness: TxDescriptor>; + /** + * Enables or disables Yuma3 for a given subnet. + * + * # Parameters + * - `origin`: The origin of the call, which must be the root account or subnet owner. + * - `netuid`: The unique identifier for the subnet. + * - `enabled`: A boolean flag to enable or disable Yuma3. + * + * # Weight + * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. + */ + sudo_set_yuma3_enabled: TxDescriptor>; + /** + * Enables or disables Bonds Reset for a given subnet. + * + * # Parameters + * - `origin`: The origin of the call, which must be the root account or subnet owner. + * - `netuid`: The unique identifier for the subnet. + * - `enabled`: A boolean flag to enable or disable Bonds Reset. + * + * # Weight + * This function has a fixed weight of 0 and is classified as an operational transaction that does not incur any fees. + */ + sudo_set_bonds_reset_enabled: TxDescriptor>; + /** + * Sets or updates the hotkey account associated with the owner of a specific subnet. + * + * This function allows either the root origin or the current subnet owner to set or update + * the hotkey for a given subnet. The subnet must already exist. To prevent abuse, the call is + * rate-limited to once per configured interval (default: one week) per subnet. + * + * # Parameters + * - `origin`: The dispatch origin of the call. Must be either root or the current owner of the subnet. + * - `netuid`: The unique identifier of the subnet whose owner hotkey is being set. + * - `hotkey`: The new hotkey account to associate with the subnet owner. + * + * # Returns + * - `DispatchResult`: Returns `Ok(())` if the hotkey was successfully set, or an appropriate error otherwise. + * + * # Errors + * - `Error::SubnetNotExists`: If the specified subnet does not exist. + * - `Error::TxRateLimitExceeded`: If the function is called more frequently than the allowed rate limit. + * + * # Access Control + * Only callable by: + * - Root origin, or + * - The coldkey account that owns the subnet. + * + * # Storage + * - Updates [`SubnetOwnerHotkey`] for the given `netuid`. + * - Reads and updates [`LastRateLimitedBlock`] for rate-limiting. + * - Reads [`DefaultSetSNOwnerHotkeyRateLimit`] to determine the interval between allowed updates. + * + * # Rate Limiting + * This function is rate-limited to one call per subnet per interval (e.g., one week). + */ + sudo_set_sn_owner_hotkey: TxDescriptor>; + /** + * Enables or disables subtoken trading for a given subnet. + * + * # Arguments + * * `origin` - The origin of the call, which must be the root account. + * * `netuid` - The unique identifier of the subnet. + * * `subtoken_enabled` - A boolean indicating whether subtoken trading should be enabled or disabled. + * + * # Errors + * * `BadOrigin` - If the caller is not the root account. + * + * # Weight + * Weight is handled by the `#[pallet::weight]` attribute. + */ + sudo_set_subtoken_enabled: TxDescriptor>; + /** + * Sets the commit-reveal weights version for all subnets + */ + sudo_set_commit_reveal_version: TxDescriptor>; + /** + * Sets the number of immune owner neurons + */ + sudo_set_owner_immune_neuron_limit: TxDescriptor>; + /** + * Sets the childkey burn for a subnet. + * It is only callable by the root account. + * The extrinsic will call the Subtensor pallet to set the childkey burn. + */ + sudo_set_ck_burn: TxDescriptor>; + /** + * Sets the admin freeze window length (in blocks) at the end of a tempo. + * Only callable by root. + */ + sudo_set_admin_freeze_window: TxDescriptor>; + /** + * Sets the owner hyperparameter rate limit in epochs (global multiplier). + * Only callable by root. + */ + sudo_set_owner_hparam_rate_limit: TxDescriptor>; + /** + * Sets the desired number of mechanisms in a subnet + */ + sudo_set_mechanism_count: TxDescriptor>; + /** + * Sets the emission split between mechanisms in a subnet + */ + sudo_set_mechanism_emission_split: TxDescriptor>; + /** + * Trims the maximum number of UIDs for a subnet. + * + * The trimming is done by sorting the UIDs by emission descending and then trimming + * the lowest emitters while preserving temporally and owner immune UIDs. The UIDs are + * then compressed to the left and storage is migrated to the new compressed UIDs. + */ + sudo_trim_to_max_allowed_uids: TxDescriptor>; + /** + * The extrinsic sets the minimum allowed UIDs for a subnet. + * It is only callable by the root account. + */ + sudo_set_min_allowed_uids: TxDescriptor>; + /** + * Sets TAO flow cutoff value (A) + */ + sudo_set_tao_flow_cutoff: TxDescriptor>; + /** + * Sets TAO flow normalization exponent (p) + */ + sudo_set_tao_flow_normalization_exponent: TxDescriptor>; + /** + * Sets TAO flow smoothing factor (alpha) + */ + sudo_set_tao_flow_smoothing_factor: TxDescriptor>; + /** + * Sets the global maximum number of mechanisms in a subnet + */ + sudo_set_max_mechanism_count: TxDescriptor>; + /** + * Sets the minimum number of non-immortal & non-immune UIDs that must remain in a subnet + */ + sudo_set_min_non_immune_uids: TxDescriptor>; + /** + * Sets the delay before a subnet can call start + */ + sudo_set_start_call_delay: TxDescriptor>; + /** + * Sets the announcement delay for coldkey swap. + */ + sudo_set_coldkey_swap_announcement_delay: TxDescriptor>; + /** + * Sets the coldkey swap reannouncement delay. + */ + sudo_set_coldkey_swap_reannouncement_delay: TxDescriptor>; + }; + SafeMode: { + /** + * Enter safe-mode permissionlessly for [`Config::EnterDuration`] blocks. + * + * Reserves [`Config::EnterDepositAmount`] from the caller's account. + * Emits an [`Event::Entered`] event on success. + * Errors with [`Error::Entered`] if the safe-mode is already entered. + * Errors with [`Error::NotConfigured`] if the deposit amount is `None`. + */ + enter: TxDescriptor; + /** + * Enter safe-mode by force for a per-origin configured number of blocks. + * + * Emits an [`Event::Entered`] event on success. + * Errors with [`Error::Entered`] if the safe-mode is already entered. + * + * Can only be called by the [`Config::ForceEnterOrigin`] origin. + */ + force_enter: TxDescriptor; + /** + * Extend the safe-mode permissionlessly for [`Config::ExtendDuration`] blocks. + * + * This accumulates on top of the current remaining duration. + * Reserves [`Config::ExtendDepositAmount`] from the caller's account. + * Emits an [`Event::Extended`] event on success. + * Errors with [`Error::Exited`] if the safe-mode is entered. + * Errors with [`Error::NotConfigured`] if the deposit amount is `None`. + * + * This may be called by any signed origin with [`Config::ExtendDepositAmount`] free + * currency to reserve. This call can be disabled for all origins by configuring + * [`Config::ExtendDepositAmount`] to `None`. + */ + extend: TxDescriptor; + /** + * Extend the safe-mode by force for a per-origin configured number of blocks. + * + * Emits an [`Event::Extended`] event on success. + * Errors with [`Error::Exited`] if the safe-mode is inactive. + * + * Can only be called by the [`Config::ForceExtendOrigin`] origin. + */ + force_extend: TxDescriptor; + /** + * Exit safe-mode by force. + * + * Emits an [`Event::Exited`] with [`ExitReason::Force`] event on success. + * Errors with [`Error::Exited`] if the safe-mode is inactive. + * + * Note: `safe-mode` will be automatically deactivated by [`Pallet::on_initialize`] hook + * after the block height is greater than the [`EnteredUntil`] storage item. + * Emits an [`Event::Exited`] with [`ExitReason::Timeout`] event when deactivated in the + * hook. + */ + force_exit: TxDescriptor; + /** + * Slash a deposit for an account that entered or extended safe-mode at a given + * historical block. + * + * This can only be called while safe-mode is entered. + * + * Emits a [`Event::DepositSlashed`] event on success. + * Errors with [`Error::Entered`] if safe-mode is entered. + * + * Can only be called by the [`Config::ForceDepositOrigin`] origin. + */ + force_slash_deposit: TxDescriptor>; + /** + * Permissionlessly release a deposit for an account that entered safe-mode at a + * given historical block. + * + * The call can be completely disabled by setting [`Config::ReleaseDelay`] to `None`. + * This cannot be called while safe-mode is entered and not until + * [`Config::ReleaseDelay`] blocks have passed since safe-mode was entered. + * + * Emits a [`Event::DepositReleased`] event on success. + * Errors with [`Error::Entered`] if the safe-mode is entered. + * Errors with [`Error::CannotReleaseYet`] if [`Config::ReleaseDelay`] block have not + * passed since safe-mode was entered. Errors with [`Error::NoDeposit`] if the payee has no + * reserved currency at the block specified. + */ + release_deposit: TxDescriptor>; + /** + * Force to release a deposit for an account that entered safe-mode at a given + * historical block. + * + * This can be called while safe-mode is still entered. + * + * Emits a [`Event::DepositReleased`] event on success. + * Errors with [`Error::Entered`] if safe-mode is entered. + * Errors with [`Error::NoDeposit`] if the payee has no reserved currency at the + * specified block. + * + * Can only be called by the [`Config::ForceDepositOrigin`] origin. + */ + force_release_deposit: TxDescriptor>; + }; + Ethereum: { + /** + * Transact an Ethereum transaction. + */ + transact: TxDescriptor>; + }; + EVM: { + /** + * Withdraw balance from EVM into currency/balances pallet. + */ + withdraw: TxDescriptor>; + /** + * Issue an EVM call operation. This is similar to a message call transaction in Ethereum. + */ + call: TxDescriptor>; + /** + * Issue an EVM create operation. This is similar to a contract creation transaction in + * Ethereum. + */ + create: TxDescriptor>; + /** + * Issue an EVM create2 operation. + */ + create2: TxDescriptor>; + /** + + */ + set_whitelist: TxDescriptor>; + /** + + */ + disable_whitelist: TxDescriptor>; + }; + BaseFee: { + /** + + */ + set_base_fee_per_gas: TxDescriptor>; + /** + + */ + set_elasticity: TxDescriptor>; + }; + Drand: { + /** + * Verify and write a pulse from the beacon into the runtime + */ + write_pulse: TxDescriptor>; + /** + * allows the root user to set the beacon configuration + * generally this would be called from an offchain worker context. + * there is no verification of configurations, so be careful with this. + * + * * `origin`: the root user + * * `config`: the beacon configuration + */ + set_beacon_config: TxDescriptor>; + /** + * allows the root user to set the oldest stored round + */ + set_oldest_stored_round: TxDescriptor>; + }; + Crowdloan: { + /** + * Create a crowdloan that will raise funds up to a maximum cap and if successful, + * will transfer funds to the target address if provided and dispatch the call + * (using creator origin). + * + * The initial deposit will be transfered to the crowdloan account and will be refunded + * in case the crowdloan fails to raise the cap. Additionally, the creator will pay for + * the execution of the call. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `deposit`: The initial deposit from the creator. + * - `min_contribution`: The minimum contribution required to contribute to the crowdloan. + * - `cap`: The maximum amount of funds that can be raised. + * - `end`: The block number at which the crowdloan will end. + * - `call`: The call to dispatch when the crowdloan is finalized. + * - `target_address`: The address to transfer the raised funds to if provided. + */ + create: TxDescriptor>; + /** + * Contribute to an active crowdloan. + * + * The contribution will be transfered to the crowdloan account and will be refunded + * if the crowdloan fails to raise the cap. If the contribution would raise the amount above the cap, + * the contribution will be set to the amount that is left to be raised. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to contribute to. + * - `amount`: The amount to contribute. + */ + contribute: TxDescriptor>; + /** + * Withdraw a contribution from an active (not yet finalized or dissolved) crowdloan. + * + * Only contributions over the deposit can be withdrawn by the creator. + * + * The dispatch origin for this call must be _Signed_. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to withdraw from. + */ + withdraw: TxDescriptor>; + /** + * Finalize crowdloan that has reached the cap. + * + * The call will transfer the raised amount to the target address if it was provided when the crowdloan was created + * and dispatch the call that was provided using the creator origin. The CurrentCrowdloanId will be set to the + * crowdloan id being finalized so the dispatched call can access it temporarily by accessing + * the `CurrentCrowdloanId` storage item. + * + * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to finalize. + */ + finalize: TxDescriptor>; + /** + * Refund contributors of a non-finalized crowdloan. + * + * The call will try to refund all contributors (excluding the creator) up to the limit defined by the `RefundContributorsLimit`. + * If the limit is reached, the call will stop and the crowdloan will be marked as partially refunded. + * It may be needed to dispatch this call multiple times to refund all contributors. + * + * The dispatch origin for this call must be _Signed_ and doesn't need to be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to refund. + */ + refund: TxDescriptor>; + /** + * Dissolve a crowdloan. + * + * The crowdloan will be removed from the storage. + * All contributions must have been refunded before the crowdloan can be dissolved (except the creator's one). + * + * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to dissolve. + */ + dissolve: TxDescriptor>; + /** + * Update the minimum contribution of a non-finalized crowdloan. + * + * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to update the minimum contribution of. + * - `new_min_contribution`: The new minimum contribution. + */ + update_min_contribution: TxDescriptor>; + /** + * Update the end block of a non-finalized crowdloan. + * + * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to update the end block of. + * - `new_end`: The new end block. + */ + update_end: TxDescriptor>; + /** + * Update the cap of a non-finalized crowdloan. + * + * The dispatch origin for this call must be _Signed_ and must be the creator of the crowdloan. + * + * Parameters: + * - `crowdloan_id`: The id of the crowdloan to update the cap of. + * - `new_cap`: The new cap. + */ + update_cap: TxDescriptor>; + }; + Swap: { + /** + * Set the fee rate for swaps on a specific subnet (normalized value). + * For example, 0.3% is approximately 196. + * + * Only callable by the admin origin + */ + set_fee_rate: TxDescriptor>; + /** + * Enable user liquidity operations for a specific subnet. This switches the + * subnet from V2 to V3 swap mode. Thereafter, adding new user liquidity can be disabled + * by toggling this flag to false, but the swap mode will remain V3 because of existing + * user liquidity until all users withdraw their liquidity. + * + * Only sudo or subnet owner can enable user liquidity. + * Only sudo can disable user liquidity. + */ + toggle_user_liquidity: TxDescriptor>; + /** + * Add liquidity to a specific price range for a subnet. + * + * Parameters: + * - origin: The origin of the transaction + * - netuid: Subnet ID + * - tick_low: Lower bound of the price range + * - tick_high: Upper bound of the price range + * - liquidity: Amount of liquidity to add + * + * Emits `Event::LiquidityAdded` on success + */ + add_liquidity: TxDescriptor>; + /** + * Remove liquidity from a specific position. + * + * Parameters: + * - origin: The origin of the transaction + * - netuid: Subnet ID + * - position_id: ID of the position to remove + * + * Emits `Event::LiquidityRemoved` on success + */ + remove_liquidity: TxDescriptor>; + /** + * Modify a liquidity position. + * + * Parameters: + * - origin: The origin of the transaction + * - netuid: Subnet ID + * - position_id: ID of the position to remove + * - liquidity_delta: Liquidity to add (if positive) or remove (if negative) + * + * Emits `Event::LiquidityRemoved` on success + */ + modify_position: TxDescriptor>; + /** + * Disable user liquidity in all subnets. + * + * Emits `Event::UserLiquidityToggled` on success + */ + disable_lp: TxDescriptor; + }; + Contracts: { + /** + * Deprecated version if [`Self::call`] for use in an in-storage `Call`. + */ + call_old_weight: TxDescriptor>; + /** + * Deprecated version if [`Self::instantiate_with_code`] for use in an in-storage `Call`. + */ + instantiate_with_code_old_weight: TxDescriptor>; + /** + * Deprecated version if [`Self::instantiate`] for use in an in-storage `Call`. + */ + instantiate_old_weight: TxDescriptor>; + /** + * Upload new `code` without instantiating a contract from it. + * + * If the code does not already exist a deposit is reserved from the caller + * and unreserved only when [`Self::remove_code`] is called. The size of the reserve + * depends on the size of the supplied `code`. + * + * If the code already exists in storage it will still return `Ok` and upgrades + * the in storage version to the current + * [`InstructionWeights::version`](InstructionWeights). + * + * - `determinism`: If this is set to any other value but [`Determinism::Enforced`] then + * the only way to use this code is to delegate call into it from an offchain execution. + * Set to [`Determinism::Enforced`] if in doubt. + * + * # Note + * + * Anyone can instantiate a contract from any uploaded code and thus prevent its removal. + * To avoid this situation a constructor could employ access control so that it can + * only be instantiated by permissioned entities. The same is true when uploading + * through [`Self::instantiate_with_code`]. + * + * Use [`Determinism::Relaxed`] exclusively for non-deterministic code. If the uploaded + * code is deterministic, specifying [`Determinism::Relaxed`] will be disregarded and + * result in higher gas costs. + */ + upload_code: TxDescriptor>; + /** + * Remove the code stored under `code_hash` and refund the deposit to its owner. + * + * A code can only be removed by its original uploader (its owner) and only if it is + * not used by any contract. + */ + remove_code: TxDescriptor>; + /** + * Privileged function that changes the code of an existing contract. + * + * This takes care of updating refcounts and all other necessary operations. Returns + * an error if either the `code_hash` or `dest` do not exist. + * + * # Note + * + * This does **not** change the address of the contract in question. This means + * that the contract address is no longer derived from its code hash after calling + * this dispatchable. + */ + set_code: TxDescriptor>; + /** + * Makes a call to an account, optionally transferring some balance. + * + * # Parameters + * + * * `dest`: Address of the contract to call. + * * `value`: The balance to transfer from the `origin` to `dest`. + * * `gas_limit`: The gas limit enforced when executing the constructor. + * * `storage_deposit_limit`: The maximum amount of balance that can be charged from the + * caller to pay for the storage consumed. + * * `data`: The input data to pass to the contract. + * + * * If the account is a smart-contract account, the associated code will be + * executed and any value will be transferred. + * * If the account is a regular account, any value will be transferred. + * * If no account exists and the call value is not less than `existential_deposit`, + * a regular account will be created and any value will be transferred. + */ + call: TxDescriptor>; + /** + * Instantiates a new contract from the supplied `code` optionally transferring + * some balance. + * + * This dispatchable has the same effect as calling [`Self::upload_code`] + + * [`Self::instantiate`]. Bundling them together provides efficiency gains. Please + * also check the documentation of [`Self::upload_code`]. + * + * # Parameters + * + * * `value`: The balance to transfer from the `origin` to the newly created contract. + * * `gas_limit`: The gas limit enforced when executing the constructor. + * * `storage_deposit_limit`: The maximum amount of balance that can be charged/reserved + * from the caller to pay for the storage consumed. + * * `code`: The contract code to deploy in raw bytes. + * * `data`: The input data to pass to the contract constructor. + * * `salt`: Used for the address derivation. See [`Pallet::contract_address`]. + * + * Instantiation is executed as follows: + * + * - The supplied `code` is deployed, and a `code_hash` is created for that code. + * - If the `code_hash` already exists on the chain the underlying `code` will be shared. + * - The destination address is computed based on the sender, code_hash and the salt. + * - The smart-contract account is created at the computed address. + * - The `value` is transferred to the new account. + * - The `deploy` function is executed in the context of the newly-created account. + */ + instantiate_with_code: TxDescriptor>; + /** + * Instantiates a contract from a previously deployed wasm binary. + * + * This function is identical to [`Self::instantiate_with_code`] but without the + * code deployment step. Instead, the `code_hash` of an on-chain deployed wasm binary + * must be supplied. + */ + instantiate: TxDescriptor>; + /** + * When a migration is in progress, this dispatchable can be used to run migration steps. + * Calls that contribute to advancing the migration have their fees waived, as it's helpful + * for the chain. Note that while the migration is in progress, the pallet will also + * leverage the `on_idle` hooks to run migration steps. + */ + migrate: TxDescriptor>; + }; + MevShield: { + /** + * Announce the ML‑KEM public key that will become `CurrentKey` in + * the following block. + */ + announce_next_key: TxDescriptor>; + /** + * Users submit an encrypted wrapper. + * + * Client‑side: + * + * 1. Read `NextKey` (ML‑KEM public key bytes) from storage. + * 2. Sign your extrinsic so that it can be executed when added to the pool, + * i.e. you may need to increment the nonce if you submit using the same account. + * 3. `commitment = Hashing::hash(signed_extrinsic)`. + * 4. Encrypt: + * + * plaintext = signed_extrinsic + * + * with ML‑KEM‑768 + XChaCha20‑Poly1305, producing + * + * ciphertext = [u16 kem_len] || kem_ct || nonce24 || aead_ct + * + */ + submit_encrypted: TxDescriptor>; + /** + * Marks a submission as failed to decrypt and removes it from storage. + * + * Called by the block author when decryption fails at any stage (e.g., ML-KEM decapsulate + * failed, AEAD decrypt failed, invalid ciphertext format, etc.). This allows clients to be + * notified of decryption failures through on-chain events. + * + * # Arguments + * + * * `id` - The wrapper id (hash of (author, commitment, ciphertext)) + * * `reason` - Human-readable reason for the decryption failure (e.g., "ML-KEM decapsulate failed") + */ + mark_decryption_failed: TxDescriptor>; + }; +}; +type IEvent = { + System: { + /** + * An extrinsic completed successfully. + */ + ExtrinsicSuccess: PlainDescriptor>; + /** + * An extrinsic failed. + */ + ExtrinsicFailed: PlainDescriptor>; + /** + * `:code` was updated. + */ + CodeUpdated: PlainDescriptor; + /** + * A new account was created. + */ + NewAccount: PlainDescriptor>; + /** + * An account was reaped. + */ + KilledAccount: PlainDescriptor>; + /** + * On on-chain remark happened. + */ + Remarked: PlainDescriptor>; + /** + * An upgrade was authorized. + */ + UpgradeAuthorized: PlainDescriptor>; + /** + * An invalid authorized upgrade was rejected while trying to apply it. + */ + RejectedInvalidAuthorizedUpgrade: PlainDescriptor>; + }; + Grandpa: { + /** + * New authority set has been applied. + */ + NewAuthorities: PlainDescriptor>; + /** + * Current authority set has been paused. + */ + Paused: PlainDescriptor; + /** + * Current authority set has been resumed. + */ + Resumed: PlainDescriptor; + }; + Balances: { + /** + * An account was created with some free balance. + */ + Endowed: PlainDescriptor>; + /** + * An account was removed whose balance was non-zero but below ExistentialDeposit, + * resulting in an outright loss. + */ + DustLost: PlainDescriptor>; + /** + * Transfer succeeded. + */ + Transfer: PlainDescriptor>; + /** + * A balance was set by root. + */ + BalanceSet: PlainDescriptor>; + /** + * Some balance was reserved (moved from free to reserved). + */ + Reserved: PlainDescriptor>; + /** + * Some balance was unreserved (moved from reserved to free). + */ + Unreserved: PlainDescriptor>; + /** + * Some balance was moved from the reserve of the first account to the second account. + * Final argument indicates the destination balance type. + */ + ReserveRepatriated: PlainDescriptor>; + /** + * Some amount was deposited (e.g. for transaction fees). + */ + Deposit: PlainDescriptor>; + /** + * Some amount was withdrawn from the account (e.g. for transaction fees). + */ + Withdraw: PlainDescriptor>; + /** + * Some amount was removed from the account (e.g. for misbehavior). + */ + Slashed: PlainDescriptor>; + /** + * Some amount was minted into an account. + */ + Minted: PlainDescriptor>; + /** + * Some amount was burned from an account. + */ + Burned: PlainDescriptor>; + /** + * Some amount was suspended from an account (it can be restored later). + */ + Suspended: PlainDescriptor>; + /** + * Some amount was restored into an account. + */ + Restored: PlainDescriptor>; + /** + * An account was upgraded. + */ + Upgraded: PlainDescriptor>; + /** + * Total issuance was increased by `amount`, creating a credit to be balanced. + */ + Issued: PlainDescriptor>; + /** + * Total issuance was decreased by `amount`, creating a debt to be balanced. + */ + Rescinded: PlainDescriptor>; + /** + * Some balance was locked. + */ + Locked: PlainDescriptor>; + /** + * Some balance was unlocked. + */ + Unlocked: PlainDescriptor>; + /** + * Some balance was frozen. + */ + Frozen: PlainDescriptor>; + /** + * Some balance was thawed. + */ + Thawed: PlainDescriptor>; + /** + * The `TotalIssuance` was forcefully changed. + */ + TotalIssuanceForced: PlainDescriptor>; + }; + TransactionPayment: { + /** + * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee, + * has been paid by `who`. + */ + TransactionFeePaid: PlainDescriptor>; + }; + SubtensorModule: { + /** + * a new network is added. + */ + NetworkAdded: PlainDescriptor>; + /** + * a network is removed. + */ + NetworkRemoved: PlainDescriptor; + /** + * stake has been transferred from the a coldkey account onto the hotkey staking account. + */ + StakeAdded: PlainDescriptor>; + /** + * stake has been removed from the hotkey staking account onto the coldkey account. + */ + StakeRemoved: PlainDescriptor>; + /** + * stake has been moved from origin (hotkey, subnet ID) to destination (hotkey, subnet ID) of this amount (in TAO). + */ + StakeMoved: PlainDescriptor>; + /** + * a caller successfully sets their weights on a subnetwork. + */ + WeightsSet: PlainDescriptor>; + /** + * a new neuron account has been registered to the chain. + */ + NeuronRegistered: PlainDescriptor>; + /** + * multiple uids have been concurrently registered. + */ + BulkNeuronsRegistered: PlainDescriptor>; + /** + * FIXME: Not used yet + */ + BulkBalancesSet: PlainDescriptor>; + /** + * max allowed uids has been set for a subnetwork. + */ + MaxAllowedUidsSet: PlainDescriptor>; + /** + * DEPRECATED: max weight limit updates are no longer supported. + */ + MaxWeightLimitSet: PlainDescriptor>; + /** + * the difficulty has been set for a subnet. + */ + DifficultySet: PlainDescriptor>; + /** + * the adjustment interval is set for a subnet. + */ + AdjustmentIntervalSet: PlainDescriptor>; + /** + * registration per interval is set for a subnet. + */ + RegistrationPerIntervalSet: PlainDescriptor>; + /** + * we set max registrations per block. + */ + MaxRegistrationsPerBlockSet: PlainDescriptor>; + /** + * an activity cutoff is set for a subnet. + */ + ActivityCutoffSet: PlainDescriptor>; + /** + * Rho value is set. + */ + RhoSet: PlainDescriptor>; + /** + * steepness of the sigmoid used to compute alpha values. + */ + AlphaSigmoidSteepnessSet: PlainDescriptor>; + /** + * Kappa is set for a subnet. + */ + KappaSet: PlainDescriptor>; + /** + * minimum allowed weight is set for a subnet. + */ + MinAllowedWeightSet: PlainDescriptor>; + /** + * the validator pruning length has been set. + */ + ValidatorPruneLenSet: PlainDescriptor>; + /** + * the scaling law power has been set for a subnet. + */ + ScalingLawPowerSet: PlainDescriptor>; + /** + * weights set rate limit has been set for a subnet. + */ + WeightsSetRateLimitSet: PlainDescriptor>; + /** + * immunity period is set for a subnet. + */ + ImmunityPeriodSet: PlainDescriptor>; + /** + * bonds moving average is set for a subnet. + */ + BondsMovingAverageSet: PlainDescriptor>; + /** + * bonds penalty is set for a subnet. + */ + BondsPenaltySet: PlainDescriptor>; + /** + * bonds reset is set for a subnet. + */ + BondsResetOnSet: PlainDescriptor>; + /** + * setting the max number of allowed validators on a subnet. + */ + MaxAllowedValidatorsSet: PlainDescriptor>; + /** + * the axon server information is added to the network. + */ + AxonServed: PlainDescriptor>; + /** + * the prometheus server information is added to the network. + */ + PrometheusServed: PlainDescriptor>; + /** + * a hotkey has become a delegate. + */ + DelegateAdded: PlainDescriptor>; + /** + * the default take is set. + */ + DefaultTakeSet: PlainDescriptor; + /** + * weights version key is set for a network. + */ + WeightsVersionKeySet: PlainDescriptor>; + /** + * setting min difficulty on a network. + */ + MinDifficultySet: PlainDescriptor>; + /** + * setting max difficulty on a network. + */ + MaxDifficultySet: PlainDescriptor>; + /** + * setting the prometheus serving rate limit. + */ + ServingRateLimitSet: PlainDescriptor>; + /** + * setting burn on a network. + */ + BurnSet: PlainDescriptor>; + /** + * setting max burn on a network. + */ + MaxBurnSet: PlainDescriptor>; + /** + * setting min burn on a network. + */ + MinBurnSet: PlainDescriptor>; + /** + * setting the transaction rate limit. + */ + TxRateLimitSet: PlainDescriptor; + /** + * setting the delegate take transaction rate limit. + */ + TxDelegateTakeRateLimitSet: PlainDescriptor; + /** + * setting the childkey take transaction rate limit. + */ + TxChildKeyTakeRateLimitSet: PlainDescriptor; + /** + * setting the admin freeze window length (last N blocks of tempo) + */ + AdminFreezeWindowSet: PlainDescriptor; + /** + * setting the owner hyperparameter rate limit in epochs + */ + OwnerHyperparamRateLimitSet: PlainDescriptor; + /** + * minimum childkey take set + */ + MinChildKeyTakeSet: PlainDescriptor; + /** + * maximum childkey take set + */ + MaxChildKeyTakeSet: PlainDescriptor; + /** + * childkey take set + */ + ChildKeyTakeSet: PlainDescriptor>; + /** + * a sudo call is done. + */ + Sudid: PlainDescriptor>; + /** + * registration is allowed/disallowed for a subnet. + */ + RegistrationAllowed: PlainDescriptor>; + /** + * POW registration is allowed/disallowed for a subnet. + */ + PowRegistrationAllowed: PlainDescriptor>; + /** + * setting tempo on a network + */ + TempoSet: PlainDescriptor>; + /** + * setting the RAO recycled for registration. + */ + RAORecycledForRegistrationSet: PlainDescriptor>; + /** + * min stake is set for validators to set weights. + */ + StakeThresholdSet: PlainDescriptor; + /** + * setting the adjustment alpha on a subnet. + */ + AdjustmentAlphaSet: PlainDescriptor>; + /** + * the faucet it called on the test net. + */ + Faucet: PlainDescriptor>; + /** + * the subnet owner cut is set. + */ + SubnetOwnerCutSet: PlainDescriptor; + /** + * the network creation rate limit is set. + */ + NetworkRateLimitSet: PlainDescriptor; + /** + * the network immunity period is set. + */ + NetworkImmunityPeriodSet: PlainDescriptor; + /** + * the start call delay is set. + */ + StartCallDelaySet: PlainDescriptor; + /** + * the network minimum locking cost is set. + */ + NetworkMinLockCostSet: PlainDescriptor; + /** + * the maximum number of subnets is set + */ + SubnetLimitSet: PlainDescriptor; + /** + * the lock cost reduction is set + */ + NetworkLockCostReductionIntervalSet: PlainDescriptor; + /** + * the take for a delegate is decreased. + */ + TakeDecreased: PlainDescriptor>; + /** + * the take for a delegate is increased. + */ + TakeIncreased: PlainDescriptor>; + /** + * the hotkey is swapped + */ + HotkeySwapped: PlainDescriptor>; + /** + * maximum delegate take is set by sudo/admin transaction + */ + MaxDelegateTakeSet: PlainDescriptor; + /** + * minimum delegate take is set by sudo/admin transaction + */ + MinDelegateTakeSet: PlainDescriptor; + /** + * A coldkey swap announcement has been made. + */ + ColdkeySwapAnnounced: PlainDescriptor>; + /** + * A coldkey swap has been reset. + */ + ColdkeySwapReset: PlainDescriptor>; + /** + * A coldkey has been swapped. + */ + ColdkeySwapped: PlainDescriptor>; + /** + * A coldkey swap has been disputed. + */ + ColdkeySwapDisputed: PlainDescriptor>; + /** + * All balance of a hotkey has been unstaked and transferred to a new coldkey + */ + AllBalanceUnstakedAndTransferredToNewColdkey: PlainDescriptor>; + /** + * The arbitration period has been extended + */ + ArbitrationPeriodExtended: PlainDescriptor>; + /** + * Setting of children of a hotkey have been scheduled + */ + SetChildrenScheduled: PlainDescriptor>; + /** + * The children of a hotkey have been set + */ + SetChildren: PlainDescriptor>; + /** + * The identity of a coldkey has been set + */ + ChainIdentitySet: PlainDescriptor; + /** + * The identity of a subnet has been set + */ + SubnetIdentitySet: PlainDescriptor; + /** + * The identity of a subnet has been removed + */ + SubnetIdentityRemoved: PlainDescriptor; + /** + * A dissolve network extrinsic scheduled. + */ + DissolveNetworkScheduled: PlainDescriptor>; + /** + * The coldkey swap announcement delay has been set. + */ + ColdkeySwapAnnouncementDelaySet: PlainDescriptor; + /** + * The coldkey swap reannouncement delay has been set. + */ + ColdkeySwapReannouncementDelaySet: PlainDescriptor; + /** + * The duration of dissolve network has been set + */ + DissolveNetworkScheduleDurationSet: PlainDescriptor; + /** + * Commit-reveal v3 weights have been successfully committed. + * + * - **who**: The account ID of the user committing the weights. + * - **netuid**: The network identifier. + * - **commit_hash**: The hash representing the committed weights. + */ + CRV3WeightsCommitted: PlainDescriptor>; + /** + * Weights have been successfully committed. + * + * - **who**: The account ID of the user committing the weights. + * - **netuid**: The network identifier. + * - **commit_hash**: The hash representing the committed weights. + */ + WeightsCommitted: PlainDescriptor>; + /** + * Weights have been successfully revealed. + * + * - **who**: The account ID of the user revealing the weights. + * - **netuid**: The network identifier. + * - **commit_hash**: The hash of the revealed weights. + */ + WeightsRevealed: PlainDescriptor>; + /** + * Weights have been successfully batch revealed. + * + * - **who**: The account ID of the user revealing the weights. + * - **netuid**: The network identifier. + * - **revealed_hashes**: A vector of hashes representing each revealed weight set. + */ + WeightsBatchRevealed: PlainDescriptor>; + /** + * A batch of weights (or commits) have been force-set. + * + * - **netuids**: The netuids these weights were successfully set/committed for. + * - **who**: The hotkey that set this batch. + */ + BatchWeightsCompleted: PlainDescriptor>; + /** + * A batch extrinsic completed but with some errors. + */ + BatchCompletedWithErrors: PlainDescriptor; + /** + * A weight set among a batch of weights failed. + * + * - **error**: The dispatch error emitted by the failed item. + */ + BatchWeightItemFailed: PlainDescriptor>; + /** + * Stake has been transferred from one coldkey to another on the same subnet. + * Parameters: + * (origin_coldkey, destination_coldkey, hotkey, origin_netuid, destination_netuid, amount) + */ + StakeTransferred: PlainDescriptor>; + /** + * Stake has been swapped from one subnet to another for the same coldkey-hotkey pair. + * + * Parameters: + * (coldkey, hotkey, origin_netuid, destination_netuid, amount) + */ + StakeSwapped: PlainDescriptor>; + /** + * Event called when transfer is toggled on a subnet. + * + * Parameters: + * (netuid, bool) + */ + TransferToggle: PlainDescriptor>; + /** + * The owner hotkey for a subnet has been set. + * + * Parameters: + * (netuid, new_hotkey) + */ + SubnetOwnerHotkeySet: PlainDescriptor>; + /** + * FirstEmissionBlockNumber is set via start call extrinsic + * + * Parameters: + * netuid + * block number + */ + FirstEmissionBlockNumberSet: PlainDescriptor>; + /** + * Alpha has been recycled, reducing AlphaOut on a subnet. + * + * Parameters: + * (coldkey, hotkey, amount, subnet_id) + */ + AlphaRecycled: PlainDescriptor>; + /** + * Alpha have been burned without reducing AlphaOut. + * + * Parameters: + * (coldkey, hotkey, amount, subnet_id) + */ + AlphaBurned: PlainDescriptor>; + /** + * An EVM key has been associated with a hotkey. + */ + EvmKeyAssociated: PlainDescriptor>; + /** + * CRV3 Weights have been successfully revealed. + * + * - **netuid**: The network identifier. + * - **who**: The account ID of the user revealing the weights. + */ + CRV3WeightsRevealed: PlainDescriptor>; + /** + * Commit-Reveal periods has been successfully set. + * + * - **netuid**: The network identifier. + * - **periods**: The number of epochs before the reveal. + */ + CommitRevealPeriodsSet: PlainDescriptor>; + /** + * Commit-Reveal has been successfully toggled. + * + * - **netuid**: The network identifier. + * - **Enabled**: Is Commit-Reveal enabled. + */ + CommitRevealEnabled: PlainDescriptor>; + /** + * the hotkey is swapped + */ + HotkeySwappedOnSubnet: PlainDescriptor>; + /** + * A subnet lease has been created. + */ + SubnetLeaseCreated: PlainDescriptor>; + /** + * A subnet lease has been terminated. + */ + SubnetLeaseTerminated: PlainDescriptor>; + /** + * The symbol for a subnet has been updated. + */ + SymbolUpdated: PlainDescriptor>; + /** + * Commit Reveal Weights version has been updated. + * + * - **version**: The required version. + */ + CommitRevealVersionSet: PlainDescriptor; + /** + * Timelocked weights have been successfully committed. + * + * - **who**: The account ID of the user committing the weights. + * - **netuid**: The network identifier. + * - **commit_hash**: The hash representing the committed weights. + * - **reveal_round**: The round at which weights can be revealed. + */ + TimelockedWeightsCommitted: PlainDescriptor>; + /** + * Timelocked Weights have been successfully revealed. + * + * - **netuid**: The network identifier. + * - **who**: The account ID of the user revealing the weights. + */ + TimelockedWeightsRevealed: PlainDescriptor>; + /** + * Auto-staking hotkey received stake + */ + AutoStakeAdded: PlainDescriptor>; + /** + * End-of-epoch miner incentive alpha by UID + */ + IncentiveAlphaEmittedToMiners: PlainDescriptor>; + /** + * The minimum allowed UIDs for a subnet have been set. + */ + MinAllowedUidsSet: PlainDescriptor>; + /** + * The auto stake destination has been set. + * + * - **coldkey**: The account ID of the coldkey. + * - **netuid**: The network identifier. + * - **hotkey**: The account ID of the hotkey. + */ + AutoStakeDestinationSet: PlainDescriptor>; + /** + * The minimum allowed non-Immune UIDs has been set. + */ + MinNonImmuneUidsSet: PlainDescriptor>; + /** + * Root emissions have been claimed for a coldkey on all subnets and hotkeys. + * Parameters: + * (coldkey) + */ + RootClaimed: PlainDescriptor>; + /** + * Root claim type for a coldkey has been set. + * Parameters: + * (coldkey, u8) + */ + RootClaimTypeSet: PlainDescriptor>; + /** + * Voting power tracking has been enabled for a subnet. + */ + VotingPowerTrackingEnabled: PlainDescriptor>; + /** + * Voting power tracking has been scheduled for disabling. + * Tracking will continue until disable_at_block, then stop and clear entries. + */ + VotingPowerTrackingDisableScheduled: PlainDescriptor>; + /** + * Voting power tracking has been fully disabled and entries cleared. + */ + VotingPowerTrackingDisabled: PlainDescriptor>; + /** + * Voting power EMA alpha has been set for a subnet. + */ + VotingPowerEmaAlphaSet: PlainDescriptor>; + /** + * Subnet lease dividends have been distributed. + */ + SubnetLeaseDividendsDistributed: PlainDescriptor>; + /** + * "Add stake and burn" event: alpha token was purchased and burned. + */ + AddStakeBurn: PlainDescriptor>; + }; + Utility: { + /** + * Batch of dispatches did not complete fully. Index of first failing dispatch given, as + * well as the error. + */ + BatchInterrupted: PlainDescriptor>; + /** + * Batch of dispatches completed fully with no error. + */ + BatchCompleted: PlainDescriptor; + /** + * Batch of dispatches completed but has errors. + */ + BatchCompletedWithErrors: PlainDescriptor; + /** + * A single item within a Batch of dispatches has completed with no error. + */ + ItemCompleted: PlainDescriptor; + /** + * A single item within a Batch of dispatches has completed with error. + */ + ItemFailed: PlainDescriptor>; + /** + * A call was dispatched. + */ + DispatchedAs: PlainDescriptor>; + /** + * Main call was dispatched. + */ + IfElseMainSuccess: PlainDescriptor; + /** + * The fallback call was dispatched. + */ + IfElseFallbackCalled: PlainDescriptor>; + }; + Sudo: { + /** + * A sudo call just took place. + */ + Sudid: PlainDescriptor>; + /** + * The sudo key has been updated. + */ + KeyChanged: PlainDescriptor>; + /** + * The key was permanently removed. + */ + KeyRemoved: PlainDescriptor; + /** + * A [sudo_as](Pallet::sudo_as) call just took place. + */ + SudoAsDone: PlainDescriptor>; + }; + Multisig: { + /** + * A new multisig operation has begun. + */ + NewMultisig: PlainDescriptor>; + /** + * A multisig operation has been approved by someone. + */ + MultisigApproval: PlainDescriptor>; + /** + * A multisig operation has been executed. + */ + MultisigExecuted: PlainDescriptor>; + /** + * A multisig operation has been cancelled. + */ + MultisigCancelled: PlainDescriptor>; + /** + * The deposit for a multisig operation has been updated/poked. + */ + DepositPoked: PlainDescriptor>; + }; + Preimage: { + /** + * A preimage has been noted. + */ + Noted: PlainDescriptor>; + /** + * A preimage has been requested. + */ + Requested: PlainDescriptor>; + /** + * A preimage has ben cleared. + */ + Cleared: PlainDescriptor>; + }; + Scheduler: { + /** + * Scheduled some task. + */ + Scheduled: PlainDescriptor>; + /** + * Canceled some task. + */ + Canceled: PlainDescriptor>; + /** + * Dispatched some task. + */ + Dispatched: PlainDescriptor>; + /** + * Set a retry configuration for some task. + */ + RetrySet: PlainDescriptor>; + /** + * Cancel a retry configuration for some task. + */ + RetryCancelled: PlainDescriptor>; + /** + * The call for the provided hash was not found so the task has been aborted. + */ + CallUnavailable: PlainDescriptor>; + /** + * The given task was unable to be renewed since the agenda is full at that block. + */ + PeriodicFailed: PlainDescriptor>; + /** + * The given task was unable to be retried since the agenda is full at that block or there + * was not enough weight to reschedule it. + */ + RetryFailed: PlainDescriptor>; + /** + * The given task can never be executed since it is overweight. + */ + PermanentlyOverweight: PlainDescriptor>; + /** + * Agenda is incomplete from `when`. + */ + AgendaIncomplete: PlainDescriptor>; + }; + Proxy: { + /** + * A proxy was executed correctly, with the given. + */ + ProxyExecuted: PlainDescriptor>; + /** + * A pure account has been created by new proxy with given + * disambiguation index and proxy type. + */ + PureCreated: PlainDescriptor>; + /** + * A pure proxy was killed by its spawner. + */ + PureKilled: PlainDescriptor>; + /** + * An announcement was placed to make a call in the future. + */ + Announced: PlainDescriptor>; + /** + * A proxy was added. + */ + ProxyAdded: PlainDescriptor>; + /** + * A proxy was removed. + */ + ProxyRemoved: PlainDescriptor>; + /** + * A deposit stored for proxies or announcements was poked / updated. + */ + DepositPoked: PlainDescriptor>; + }; + Registry: { + /** + * Emitted when a user registers an identity + */ + IdentitySet: PlainDescriptor>; + /** + * Emitted when a user dissolves an identity + */ + IdentityDissolved: PlainDescriptor>; + }; + Commitments: { + /** + * A commitment was set + */ + Commitment: PlainDescriptor>; + /** + * A timelock-encrypted commitment was set + */ + TimelockCommitment: PlainDescriptor>; + /** + * A timelock-encrypted commitment was auto-revealed + */ + CommitmentRevealed: PlainDescriptor>; + }; + AdminUtils: { + /** + * Event emitted when a precompile operation is updated. + */ + PrecompileUpdated: PlainDescriptor>; + /** + * Event emitted when the Yuma3 enable is toggled. + */ + Yuma3EnableToggled: PlainDescriptor>; + /** + * Event emitted when Bonds Reset is toggled. + */ + BondsResetToggled: PlainDescriptor>; + }; + SafeMode: { + /** + * The safe-mode was entered until inclusively this block. + */ + Entered: PlainDescriptor>; + /** + * The safe-mode was extended until inclusively this block. + */ + Extended: PlainDescriptor>; + /** + * Exited the safe-mode for a specific reason. + */ + Exited: PlainDescriptor>; + /** + * An account reserved funds for either entering or extending the safe-mode. + */ + DepositPlaced: PlainDescriptor>; + /** + * An account had a reserve released that was reserved. + */ + DepositReleased: PlainDescriptor>; + /** + * An account had reserve slashed that was reserved. + */ + DepositSlashed: PlainDescriptor>; + /** + * Could not hold funds for entering or extending the safe-mode. + * + * This error comes from the underlying `Currency`. + */ + CannotDeposit: PlainDescriptor; + /** + * Could not release funds for entering or extending the safe-mode. + * + * This error comes from the underlying `Currency`. + */ + CannotRelease: PlainDescriptor; + }; + Ethereum: { + /** + * An ethereum transaction was successfully executed. + */ + Executed: PlainDescriptor>; + }; + EVM: { + /** + * Ethereum events from contracts. + */ + Log: PlainDescriptor>; + /** + * A contract has been created at given address. + */ + Created: PlainDescriptor>; + /** + * A contract was attempted to be created, but the execution failed. + */ + CreatedFailed: PlainDescriptor>; + /** + * A contract has been executed successfully with states applied. + */ + Executed: PlainDescriptor>; + /** + * A contract has been executed with errors. States are reverted with only gas fees applied. + */ + ExecutedFailed: PlainDescriptor>; + }; + BaseFee: { + /** + + */ + NewBaseFeePerGas: PlainDescriptor>; + /** + + */ + BaseFeeOverflow: PlainDescriptor; + /** + + */ + NewElasticity: PlainDescriptor>; + }; + Drand: { + /** + * Beacon Configuration has changed. + */ + BeaconConfigChanged: PlainDescriptor; + /** + * Successfully set a new pulse(s). + */ + NewPulse: PlainDescriptor>; + /** + * Oldest Stored Round has been set. + */ + SetOldestStoredRound: PlainDescriptor; + }; + Crowdloan: { + /** + * A crowdloan was created. + */ + Created: PlainDescriptor>; + /** + * A contribution was made to an active crowdloan. + */ + Contributed: PlainDescriptor>; + /** + * A contribution was withdrawn from a failed crowdloan. + */ + Withdrew: PlainDescriptor>; + /** + * A refund was partially processed for a failed crowdloan. + */ + PartiallyRefunded: PlainDescriptor>; + /** + * A refund was fully processed for a failed crowdloan. + */ + AllRefunded: PlainDescriptor>; + /** + * A crowdloan was finalized, funds were transferred and the call was dispatched. + */ + Finalized: PlainDescriptor>; + /** + * A crowdloan was dissolved. + */ + Dissolved: PlainDescriptor>; + /** + * The minimum contribution was updated. + */ + MinContributionUpdated: PlainDescriptor>; + /** + * The end was updated. + */ + EndUpdated: PlainDescriptor>; + /** + * The cap was updated. + */ + CapUpdated: PlainDescriptor>; + }; + Swap: { + /** + * Event emitted when the fee rate has been updated for a subnet + */ + FeeRateSet: PlainDescriptor>; + /** + * Event emitted when user liquidity operations are enabled for a subnet. + * First enable even indicates a switch from V2 to V3 swap. + */ + UserLiquidityToggled: PlainDescriptor>; + /** + * Event emitted when a liquidity position is added to a subnet's liquidity pool. + */ + LiquidityAdded: PlainDescriptor>; + /** + * Event emitted when a liquidity position is removed from a subnet's liquidity pool. + */ + LiquidityRemoved: PlainDescriptor>; + /** + * Event emitted when a liquidity position is modified in a subnet's liquidity pool. + * Modifying causes the fees to be claimed. + */ + LiquidityModified: PlainDescriptor>; + }; + Contracts: { + /** + * Contract deployed by address at the specified address. + */ + Instantiated: PlainDescriptor>; + /** + * Contract has been removed. + * + * # Note + * + * The only way for a contract to be removed and emitting this event is by calling + * `seal_terminate`. + */ + Terminated: PlainDescriptor>; + /** + * Code with the specified hash has been stored. + */ + CodeStored: PlainDescriptor>; + /** + * A custom event emitted by the contract. + */ + ContractEmitted: PlainDescriptor>; + /** + * A code with the specified hash was removed. + */ + CodeRemoved: PlainDescriptor>; + /** + * A contract's code was updated. + */ + ContractCodeUpdated: PlainDescriptor>; + /** + * A contract was called either by a plain account or another contract. + * + * # Note + * + * Please keep in mind that like all events this is only emitted for successful + * calls. This is because on failure all storage changes including events are + * rolled back. + */ + Called: PlainDescriptor>; + /** + * A contract delegate called a code hash. + * + * # Note + * + * Please keep in mind that like all events this is only emitted for successful + * calls. This is because on failure all storage changes including events are + * rolled back. + */ + DelegateCalled: PlainDescriptor>; + /** + * Some funds have been transferred and held as storage deposit. + */ + StorageDepositTransferredAndHeld: PlainDescriptor>; + /** + * Some storage deposit funds have been transferred and released. + */ + StorageDepositTransferredAndReleased: PlainDescriptor>; + }; + MevShield: { + /** + * Encrypted wrapper accepted. + */ + EncryptedSubmitted: PlainDescriptor>; + /** + * Decrypted call executed. + */ + DecryptedExecuted: PlainDescriptor>; + /** + * Decrypted execution rejected. + */ + DecryptedRejected: PlainDescriptor>; + /** + * Decryption failed - validator could not decrypt the submission. + */ + DecryptionFailed: PlainDescriptor>; + }; +}; +type IError = { + System: { + /** + * The name of specification does not match between the current runtime + * and the new runtime. + */ + InvalidSpecName: PlainDescriptor; + /** + * The specification version is not allowed to decrease between the current runtime + * and the new runtime. + */ + SpecVersionNeedsToIncrease: PlainDescriptor; + /** + * Failed to extract the runtime version from the new runtime. + * + * Either calling `Core_version` or decoding `RuntimeVersion` failed. + */ + FailedToExtractRuntimeVersion: PlainDescriptor; + /** + * Suicide called when the account has non-default composite data. + */ + NonDefaultComposite: PlainDescriptor; + /** + * There is a non-zero reference count preventing the account from being purged. + */ + NonZeroRefCount: PlainDescriptor; + /** + * The origin filter prevent the call to be dispatched. + */ + CallFiltered: PlainDescriptor; + /** + * A multi-block migration is ongoing and prevents the current code from being replaced. + */ + MultiBlockMigrationsOngoing: PlainDescriptor; + /** + * No upgrade authorized. + */ + NothingAuthorized: PlainDescriptor; + /** + * The submitted code is not authorized. + */ + Unauthorized: PlainDescriptor; + }; + Grandpa: { + /** + * Attempt to signal GRANDPA pause when the authority set isn't live + * (either paused or already pending pause). + */ + PauseFailed: PlainDescriptor; + /** + * Attempt to signal GRANDPA resume when the authority set isn't paused + * (either live or already pending resume). + */ + ResumeFailed: PlainDescriptor; + /** + * Attempt to signal GRANDPA change with one already pending. + */ + ChangePending: PlainDescriptor; + /** + * Cannot signal forced change so soon after last. + */ + TooSoon: PlainDescriptor; + /** + * A key ownership proof provided as part of an equivocation report is invalid. + */ + InvalidKeyOwnershipProof: PlainDescriptor; + /** + * An equivocation proof provided as part of an equivocation report is invalid. + */ + InvalidEquivocationProof: PlainDescriptor; + /** + * A given equivocation report is valid but already previously reported. + */ + DuplicateOffenceReport: PlainDescriptor; + }; + Balances: { + /** + * Vesting balance too high to send value. + */ + VestingBalance: PlainDescriptor; + /** + * Account liquidity restrictions prevent withdrawal. + */ + LiquidityRestrictions: PlainDescriptor; + /** + * Balance too low to send value. + */ + InsufficientBalance: PlainDescriptor; + /** + * Value too low to create account due to existential deposit. + */ + ExistentialDeposit: PlainDescriptor; + /** + * Transfer/payment would kill account. + */ + Expendability: PlainDescriptor; + /** + * A vesting schedule already exists for this account. + */ + ExistingVestingSchedule: PlainDescriptor; + /** + * Beneficiary account must pre-exist. + */ + DeadAccount: PlainDescriptor; + /** + * Number of named reserves exceed `MaxReserves`. + */ + TooManyReserves: PlainDescriptor; + /** + * Number of holds exceed `VariantCountOf`. + */ + TooManyHolds: PlainDescriptor; + /** + * Number of freezes exceed `MaxFreezes`. + */ + TooManyFreezes: PlainDescriptor; + /** + * The issuance cannot be modified since it is already deactivated. + */ + IssuanceDeactivated: PlainDescriptor; + /** + * The delta cannot be zero. + */ + DeltaZero: PlainDescriptor; + }; + SubtensorModule: { + /** + * The root network does not exist. + */ + RootNetworkDoesNotExist: PlainDescriptor; + /** + * The user is trying to serve an axon which is not of type 4 (IPv4) or 6 (IPv6). + */ + InvalidIpType: PlainDescriptor; + /** + * An invalid IP address is passed to the serve function. + */ + InvalidIpAddress: PlainDescriptor; + /** + * An invalid port is passed to the serve function. + */ + InvalidPort: PlainDescriptor; + /** + * The hotkey is not registered in subnet + */ + HotKeyNotRegisteredInSubNet: PlainDescriptor; + /** + * The hotkey does not exists + */ + HotKeyAccountNotExists: PlainDescriptor; + /** + * The hotkey is not registered in any subnet. + */ + HotKeyNotRegisteredInNetwork: PlainDescriptor; + /** + * Request to stake, unstake or subscribe is made by a coldkey that is not associated with + * the hotkey account. + */ + NonAssociatedColdKey: PlainDescriptor; + /** + * DEPRECATED: Stake amount to withdraw is zero. + * The caller does not have enought stake to perform this action. + */ + NotEnoughStake: PlainDescriptor; + /** + * The caller is requesting removing more stake than there exists in the staking account. + * See: "[remove_stake()]". + */ + NotEnoughStakeToWithdraw: PlainDescriptor; + /** + * The caller is requesting to set weights but the caller has less than minimum stake + * required to set weights (less than WeightsMinStake). + */ + NotEnoughStakeToSetWeights: PlainDescriptor; + /** + * The parent hotkey doesn't have enough own stake to set childkeys. + */ + NotEnoughStakeToSetChildkeys: PlainDescriptor; + /** + * The caller is requesting adding more stake than there exists in the coldkey account. + * See: "[add_stake()]" + */ + NotEnoughBalanceToStake: PlainDescriptor; + /** + * The caller is trying to add stake, but for some reason the requested amount could not be + * withdrawn from the coldkey account. + */ + BalanceWithdrawalError: PlainDescriptor; + /** + * Unsuccessfully withdraw, balance could be zero (can not make account exist) after + * withdrawal. + */ + ZeroBalanceAfterWithdrawn: PlainDescriptor; + /** + * The caller is attempting to set non-self weights without being a permitted validator. + */ + NeuronNoValidatorPermit: PlainDescriptor; + /** + * The caller is attempting to set the weight keys and values but these vectors have + * different size. + */ + WeightVecNotEqualSize: PlainDescriptor; + /** + * The caller is attempting to set weights with duplicate UIDs in the weight matrix. + */ + DuplicateUids: PlainDescriptor; + /** + * The caller is attempting to set weight to at least one UID that does not exist in the + * metagraph. + */ + UidVecContainInvalidOne: PlainDescriptor; + /** + * The dispatch is attempting to set weights on chain with fewer elements than are allowed. + */ + WeightVecLengthIsLow: PlainDescriptor; + /** + * Number of registrations in this block exceeds the allowed number (i.e., exceeds the + * subnet hyperparameter "max_regs_per_block"). + */ + TooManyRegistrationsThisBlock: PlainDescriptor; + /** + * The caller is requesting registering a neuron which already exists in the active set. + */ + HotKeyAlreadyRegisteredInSubNet: PlainDescriptor; + /** + * The new hotkey is the same as old one + */ + NewHotKeyIsSameWithOld: PlainDescriptor; + /** + * The supplied PoW hash block is in the future or negative. + */ + InvalidWorkBlock: PlainDescriptor; + /** + * The supplied PoW hash block does not meet the network difficulty. + */ + InvalidDifficulty: PlainDescriptor; + /** + * The supplied PoW hash seal does not match the supplied work. + */ + InvalidSeal: PlainDescriptor; + /** + * The dispatch is attempting to set weights on chain with weight value exceeding the + * configured max weight limit (currently `u16::MAX`). + */ + MaxWeightExceeded: PlainDescriptor; + /** + * The hotkey is attempting to become a delegate when the hotkey is already a delegate. + */ + HotKeyAlreadyDelegate: PlainDescriptor; + /** + * A transactor exceeded the rate limit for setting weights. + */ + SettingWeightsTooFast: PlainDescriptor; + /** + * A validator is attempting to set weights from a validator with incorrect weight version. + */ + IncorrectWeightVersionKey: PlainDescriptor; + /** + * An axon or prometheus serving exceeded the rate limit for a registered neuron. + */ + ServingRateLimitExceeded: PlainDescriptor; + /** + * The caller is attempting to set weights with more UIDs than allowed. + */ + UidsLengthExceedUidsInSubNet: PlainDescriptor; + /** + * A transactor exceeded the rate limit for add network transaction. + */ + NetworkTxRateLimitExceeded: PlainDescriptor; + /** + * A transactor exceeded the rate limit for delegate transaction. + */ + DelegateTxRateLimitExceeded: PlainDescriptor; + /** + * A transactor exceeded the rate limit for setting or swapping hotkey. + */ + HotKeySetTxRateLimitExceeded: PlainDescriptor; + /** + * A transactor exceeded the rate limit for staking. + */ + StakingRateLimitExceeded: PlainDescriptor; + /** + * Registration is disabled. + */ + SubNetRegistrationDisabled: PlainDescriptor; + /** + * The number of registration attempts exceeded the allowed number in the interval. + */ + TooManyRegistrationsThisInterval: PlainDescriptor; + /** + * The hotkey is required to be the origin. + */ + TransactorAccountShouldBeHotKey: PlainDescriptor; + /** + * Faucet is disabled. + */ + FaucetDisabled: PlainDescriptor; + /** + * Not a subnet owner. + */ + NotSubnetOwner: PlainDescriptor; + /** + * Operation is not permitted on the root subnet. + */ + RegistrationNotPermittedOnRootSubnet: PlainDescriptor; + /** + * A hotkey with too little stake is attempting to join the root subnet. + */ + StakeTooLowForRoot: PlainDescriptor; + /** + * All subnets are in the immunity period. + */ + AllNetworksInImmunity: PlainDescriptor; + /** + * Not enough balance to pay swapping hotkey. + */ + NotEnoughBalanceToPaySwapHotKey: PlainDescriptor; + /** + * Netuid does not match for setting root network weights. + */ + NotRootSubnet: PlainDescriptor; + /** + * Can not set weights for the root network. + */ + CanNotSetRootNetworkWeights: PlainDescriptor; + /** + * No neuron ID is available. + */ + NoNeuronIdAvailable: PlainDescriptor; + /** + * Delegate take is too low. + */ + DelegateTakeTooLow: PlainDescriptor; + /** + * Delegate take is too high. + */ + DelegateTakeTooHigh: PlainDescriptor; + /** + * No commit found for the provided hotkey+netuid combination when attempting to reveal the + * weights. + */ + NoWeightsCommitFound: PlainDescriptor; + /** + * Committed hash does not equal the hashed reveal data. + */ + InvalidRevealCommitHashNotMatch: PlainDescriptor; + /** + * Attempting to call set_weights when commit/reveal is enabled + */ + CommitRevealEnabled: PlainDescriptor; + /** + * Attemtping to commit/reveal weights when disabled. + */ + CommitRevealDisabled: PlainDescriptor; + /** + * Attempting to set alpha high/low while disabled + */ + LiquidAlphaDisabled: PlainDescriptor; + /** + * Alpha high is too low: alpha_high > 0.8 + */ + AlphaHighTooLow: PlainDescriptor; + /** + * Alpha low is out of range: alpha_low > 0 && alpha_low < 0.8 + */ + AlphaLowOutOfRange: PlainDescriptor; + /** + * The coldkey has already been swapped + */ + ColdKeyAlreadyAssociated: PlainDescriptor; + /** + * The coldkey balance is not enough to pay for the swap + */ + NotEnoughBalanceToPaySwapColdKey: PlainDescriptor; + /** + * Attempting to set an invalid child for a hotkey on a network. + */ + InvalidChild: PlainDescriptor; + /** + * Duplicate child when setting children. + */ + DuplicateChild: PlainDescriptor; + /** + * Proportion overflow when setting children. + */ + ProportionOverflow: PlainDescriptor; + /** + * Too many children MAX 5. + */ + TooManyChildren: PlainDescriptor; + /** + * Default transaction rate limit exceeded. + */ + TxRateLimitExceeded: PlainDescriptor; + /** + * Coldkey swap announcement not found + */ + ColdkeySwapAnnouncementNotFound: PlainDescriptor; + /** + * Coldkey swap too early. + */ + ColdkeySwapTooEarly: PlainDescriptor; + /** + * Coldkey swap reannounced too early. + */ + ColdkeySwapReannouncedTooEarly: PlainDescriptor; + /** + * The announced coldkey hash does not match the new coldkey hash. + */ + AnnouncedColdkeyHashDoesNotMatch: PlainDescriptor; + /** + * Coldkey swap already disputed + */ + ColdkeySwapAlreadyDisputed: PlainDescriptor; + /** + * New coldkey is hotkey + */ + NewColdKeyIsHotkey: PlainDescriptor; + /** + * Childkey take is invalid. + */ + InvalidChildkeyTake: PlainDescriptor; + /** + * Childkey take rate limit exceeded. + */ + TxChildkeyTakeRateLimitExceeded: PlainDescriptor; + /** + * Invalid identity. + */ + InvalidIdentity: PlainDescriptor; + /** + * Subnet mechanism does not exist. + */ + MechanismDoesNotExist: PlainDescriptor; + /** + * Trying to unstake your lock amount. + */ + CannotUnstakeLock: PlainDescriptor; + /** + * Trying to perform action on non-existent subnet. + */ + SubnetNotExists: PlainDescriptor; + /** + * Maximum commit limit reached + */ + TooManyUnrevealedCommits: PlainDescriptor; + /** + * Attempted to reveal weights that are expired. + */ + ExpiredWeightCommit: PlainDescriptor; + /** + * Attempted to reveal weights too early. + */ + RevealTooEarly: PlainDescriptor; + /** + * Attempted to batch reveal weights with mismatched vector input lenghts. + */ + InputLengthsUnequal: PlainDescriptor; + /** + * A transactor exceeded the rate limit for setting weights. + */ + CommittingWeightsTooFast: PlainDescriptor; + /** + * Stake amount is too low. + */ + AmountTooLow: PlainDescriptor; + /** + * Not enough liquidity. + */ + InsufficientLiquidity: PlainDescriptor; + /** + * Slippage is too high for the transaction. + */ + SlippageTooHigh: PlainDescriptor; + /** + * Subnet disallows transfer. + */ + TransferDisallowed: PlainDescriptor; + /** + * Activity cutoff is being set too low. + */ + ActivityCutoffTooLow: PlainDescriptor; + /** + * Call is disabled + */ + CallDisabled: PlainDescriptor; + /** + * FirstEmissionBlockNumber is already set. + */ + FirstEmissionBlockNumberAlreadySet: PlainDescriptor; + /** + * need wait for more blocks to accept the start call extrinsic. + */ + NeedWaitingMoreBlocksToStarCall: PlainDescriptor; + /** + * Not enough AlphaOut on the subnet to recycle + */ + NotEnoughAlphaOutToRecycle: PlainDescriptor; + /** + * Cannot burn or recycle TAO from root subnet + */ + CannotBurnOrRecycleOnRootSubnet: PlainDescriptor; + /** + * Public key cannot be recovered. + */ + UnableToRecoverPublicKey: PlainDescriptor; + /** + * Recovered public key is invalid. + */ + InvalidRecoveredPublicKey: PlainDescriptor; + /** + * SubToken disabled now + */ + SubtokenDisabled: PlainDescriptor; + /** + * Too frequent hotkey swap on subnet + */ + HotKeySwapOnSubnetIntervalNotPassed: PlainDescriptor; + /** + * Zero max stake amount + */ + ZeroMaxStakeAmount: PlainDescriptor; + /** + * Invalid netuid duplication + */ + SameNetuid: PlainDescriptor; + /** + * The caller does not have enough balance for the operation. + */ + InsufficientBalance: PlainDescriptor; + /** + * Too frequent staking operations + */ + StakingOperationRateLimitExceeded: PlainDescriptor; + /** + * Invalid lease beneficiary to register the leased network. + */ + InvalidLeaseBeneficiary: PlainDescriptor; + /** + * Lease cannot end in the past. + */ + LeaseCannotEndInThePast: PlainDescriptor; + /** + * Couldn't find the lease netuid. + */ + LeaseNetuidNotFound: PlainDescriptor; + /** + * Lease does not exist. + */ + LeaseDoesNotExist: PlainDescriptor; + /** + * Lease has no end block. + */ + LeaseHasNoEndBlock: PlainDescriptor; + /** + * Lease has not ended. + */ + LeaseHasNotEnded: PlainDescriptor; + /** + * An overflow occurred. + */ + Overflow: PlainDescriptor; + /** + * Beneficiary does not own hotkey. + */ + BeneficiaryDoesNotOwnHotkey: PlainDescriptor; + /** + * Expected beneficiary origin. + */ + ExpectedBeneficiaryOrigin: PlainDescriptor; + /** + * Admin operation is prohibited during the protected weights window + */ + AdminActionProhibitedDuringWeightsWindow: PlainDescriptor; + /** + * Symbol does not exist. + */ + SymbolDoesNotExist: PlainDescriptor; + /** + * Symbol already in use. + */ + SymbolAlreadyInUse: PlainDescriptor; + /** + * Incorrect commit-reveal version. + */ + IncorrectCommitRevealVersion: PlainDescriptor; + /** + * Reveal period is too large. + */ + RevealPeriodTooLarge: PlainDescriptor; + /** + * Reveal period is too small. + */ + RevealPeriodTooSmall: PlainDescriptor; + /** + * Generic error for out-of-range parameter value + */ + InvalidValue: PlainDescriptor; + /** + * Subnet limit reached & there is no eligible subnet to prune + */ + SubnetLimitReached: PlainDescriptor; + /** + * Insufficient funds to meet the subnet lock cost + */ + CannotAffordLockCost: PlainDescriptor; + /** + * exceeded the rate limit for associating an EVM key. + */ + EvmKeyAssociateRateLimitExceeded: PlainDescriptor; + /** + * Same auto stake hotkey already set + */ + SameAutoStakeHotkeyAlreadySet: PlainDescriptor; + /** + * The UID map for the subnet could not be cleared + */ + UidMapCouldNotBeCleared: PlainDescriptor; + /** + * Trimming would exceed the max immune neurons percentage + */ + TrimmingWouldExceedMaxImmunePercentage: PlainDescriptor; + /** + * Violating the rules of Childkey-Parentkey consistency + */ + ChildParentInconsistency: PlainDescriptor; + /** + * Invalid number of root claims + */ + InvalidNumRootClaim: PlainDescriptor; + /** + * Invalid value of root claim threshold + */ + InvalidRootClaimThreshold: PlainDescriptor; + /** + * Exceeded subnet limit number or zero. + */ + InvalidSubnetNumber: PlainDescriptor; + /** + * The maximum allowed UIDs times mechanism count should not exceed 256. + */ + TooManyUIDsPerMechanism: PlainDescriptor; + /** + * Voting power tracking is not enabled for this subnet. + */ + VotingPowerTrackingNotEnabled: PlainDescriptor; + /** + * Invalid voting power EMA alpha value (must be <= 10^18). + */ + InvalidVotingPowerEmaAlpha: PlainDescriptor; + /** + * Unintended precision loss when unstaking alpha + */ + PrecisionLoss: PlainDescriptor; + /** + * Deprecated call. + */ + Deprecated: PlainDescriptor; + /** + * "Add stake and burn" exceeded the operation rate limit + */ + AddStakeBurnRateLimitExceeded: PlainDescriptor; + }; + Utility: { + /** + * Too many calls batched. + */ + TooManyCalls: PlainDescriptor; + /** + * Bad input data for derived account ID + */ + InvalidDerivedAccount: PlainDescriptor; + }; + Sudo: { + /** + * Sender must be the Sudo account. + */ + RequireSudo: PlainDescriptor; + }; + Multisig: { + /** + * Threshold must be 2 or greater. + */ + MinimumThreshold: PlainDescriptor; + /** + * Call is already approved by this signatory. + */ + AlreadyApproved: PlainDescriptor; + /** + * Call doesn't need any (more) approvals. + */ + NoApprovalsNeeded: PlainDescriptor; + /** + * There are too few signatories in the list. + */ + TooFewSignatories: PlainDescriptor; + /** + * There are too many signatories in the list. + */ + TooManySignatories: PlainDescriptor; + /** + * The signatories were provided out of order; they should be ordered. + */ + SignatoriesOutOfOrder: PlainDescriptor; + /** + * The sender was contained in the other signatories; it shouldn't be. + */ + SenderInSignatories: PlainDescriptor; + /** + * Multisig operation not found in storage. + */ + NotFound: PlainDescriptor; + /** + * Only the account that originally created the multisig is able to cancel it or update + * its deposits. + */ + NotOwner: PlainDescriptor; + /** + * No timepoint was given, yet the multisig operation is already underway. + */ + NoTimepoint: PlainDescriptor; + /** + * A different timepoint was given to the multisig operation that is underway. + */ + WrongTimepoint: PlainDescriptor; + /** + * A timepoint was given, yet no multisig operation is underway. + */ + UnexpectedTimepoint: PlainDescriptor; + /** + * The maximum weight information provided was too low. + */ + MaxWeightTooLow: PlainDescriptor; + /** + * The data to be stored is already stored. + */ + AlreadyStored: PlainDescriptor; + }; + Preimage: { + /** + * Preimage is too large to store on-chain. + */ + TooBig: PlainDescriptor; + /** + * Preimage has already been noted on-chain. + */ + AlreadyNoted: PlainDescriptor; + /** + * The user is not authorized to perform this action. + */ + NotAuthorized: PlainDescriptor; + /** + * The preimage cannot be removed since it has not yet been noted. + */ + NotNoted: PlainDescriptor; + /** + * A preimage may not be removed when there are outstanding requests. + */ + Requested: PlainDescriptor; + /** + * The preimage request cannot be removed since no outstanding requests exist. + */ + NotRequested: PlainDescriptor; + /** + * More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once. + */ + TooMany: PlainDescriptor; + /** + * Too few hashes were requested to be upgraded (i.e. zero). + */ + TooFew: PlainDescriptor; + }; + Scheduler: { + /** + * Failed to schedule a call + */ + FailedToSchedule: PlainDescriptor; + /** + * Cannot find the scheduled call. + */ + NotFound: PlainDescriptor; + /** + * Given target block number is in the past. + */ + TargetBlockNumberInPast: PlainDescriptor; + /** + * Reschedule failed because it does not change scheduled time. + */ + RescheduleNoChange: PlainDescriptor; + /** + * Attempt to use a non-named function on a named task. + */ + Named: PlainDescriptor; + }; + Proxy: { + /** + * There are too many proxies registered or too many announcements pending. + */ + TooMany: PlainDescriptor; + /** + * Proxy registration not found. + */ + NotFound: PlainDescriptor; + /** + * Sender is not a proxy of the account to be proxied. + */ + NotProxy: PlainDescriptor; + /** + * A call which is incompatible with the proxy type's filter was attempted. + */ + Unproxyable: PlainDescriptor; + /** + * Account is already a proxy. + */ + Duplicate: PlainDescriptor; + /** + * Call may not be made by proxy because it may escalate its privileges. + */ + NoPermission: PlainDescriptor; + /** + * Announcement, if made at all, was made too recently. + */ + Unannounced: PlainDescriptor; + /** + * Cannot add self as proxy. + */ + NoSelfProxy: PlainDescriptor; + /** + * Invariant violated: deposit recomputation returned None after updating announcements. + */ + AnnouncementDepositInvariantViolated: PlainDescriptor; + /** + * Failed to derive a valid account id from the provided entropy. + */ + InvalidDerivedAccountId: PlainDescriptor; + }; + Registry: { + /** + * Account attempted to register an identity but does not meet the requirements. + */ + CannotRegister: PlainDescriptor; + /** + * Account passed too many additional fields to their identity + */ + TooManyFieldsInIdentityInfo: PlainDescriptor; + /** + * Account doesn't have a registered identity + */ + NotRegistered: PlainDescriptor; + }; + Commitments: { + /** + * Account passed too many additional fields to their commitment + */ + TooManyFieldsInCommitmentInfo: PlainDescriptor; + /** + * Account is not allowed to make commitments to the chain + */ + AccountNotAllowedCommit: PlainDescriptor; + /** + * Space Limit Exceeded for the current interval + */ + SpaceLimitExceeded: PlainDescriptor; + /** + * Indicates that unreserve returned a leftover, which is unexpected. + */ + UnexpectedUnreserveLeftover: PlainDescriptor; + }; + AdminUtils: { + /** + * The subnet does not exist, check the netuid parameter + */ + SubnetDoesNotExist: PlainDescriptor; + /** + * The maximum number of subnet validators must be less than the maximum number of allowed UIDs in the subnet. + */ + MaxValidatorsLargerThanMaxUIds: PlainDescriptor; + /** + * The maximum number of subnet validators must be more than the current number of UIDs already in the subnet. + */ + MaxAllowedUIdsLessThanCurrentUIds: PlainDescriptor; + /** + * The maximum value for bonds moving average is reached + */ + BondsMovingAverageMaxReached: PlainDescriptor; + /** + * Only root can set negative sigmoid steepness values + */ + NegativeSigmoidSteepness: PlainDescriptor; + /** + * Value not in allowed bounds. + */ + ValueNotInBounds: PlainDescriptor; + /** + * The minimum allowed UIDs must be less than the current number of UIDs in the subnet. + */ + MinAllowedUidsGreaterThanCurrentUids: PlainDescriptor; + /** + * The minimum allowed UIDs must be less than the maximum allowed UIDs. + */ + MinAllowedUidsGreaterThanMaxAllowedUids: PlainDescriptor; + /** + * The maximum allowed UIDs must be greater than the minimum allowed UIDs. + */ + MaxAllowedUidsLessThanMinAllowedUids: PlainDescriptor; + /** + * The maximum allowed UIDs must be less than the default maximum allowed UIDs. + */ + MaxAllowedUidsGreaterThanDefaultMaxAllowedUids: PlainDescriptor; + /** + * Bad parameter value + */ + InvalidValue: PlainDescriptor; + }; + SafeMode: { + /** + * The safe-mode is (already or still) entered. + */ + Entered: PlainDescriptor; + /** + * The safe-mode is (already or still) exited. + */ + Exited: PlainDescriptor; + /** + * This functionality of the pallet is disabled by the configuration. + */ + NotConfigured: PlainDescriptor; + /** + * There is no balance reserved. + */ + NoDeposit: PlainDescriptor; + /** + * The account already has a deposit reserved and can therefore not enter or extend again. + */ + AlreadyDeposited: PlainDescriptor; + /** + * This deposit cannot be released yet. + */ + CannotReleaseYet: PlainDescriptor; + /** + * An error from the underlying `Currency`. + */ + CurrencyError: PlainDescriptor; + }; + Ethereum: { + /** + * Signature is invalid. + */ + InvalidSignature: PlainDescriptor; + /** + * Pre-log is present, therefore transact is not allowed. + */ + PreLogExists: PlainDescriptor; + }; + EVM: { + /** + * Not enough balance to perform action + */ + BalanceLow: PlainDescriptor; + /** + * Calculating total fee overflowed + */ + FeeOverflow: PlainDescriptor; + /** + * Calculating total payment overflowed + */ + PaymentOverflow: PlainDescriptor; + /** + * Withdraw fee failed + */ + WithdrawFailed: PlainDescriptor; + /** + * Gas price is too low. + */ + GasPriceTooLow: PlainDescriptor; + /** + * Nonce is invalid + */ + InvalidNonce: PlainDescriptor; + /** + * Gas limit is too low. + */ + GasLimitTooLow: PlainDescriptor; + /** + * Gas limit is too high. + */ + GasLimitTooHigh: PlainDescriptor; + /** + * The chain id is invalid. + */ + InvalidChainId: PlainDescriptor; + /** + * the signature is invalid. + */ + InvalidSignature: PlainDescriptor; + /** + * EVM reentrancy + */ + Reentrancy: PlainDescriptor; + /** + * EIP-3607, + */ + TransactionMustComeFromEOA: PlainDescriptor; + /** + * Undefined error. + */ + Undefined: PlainDescriptor; + /** + * Origin is not allowed to perform the operation. + */ + NotAllowed: PlainDescriptor; + /** + * Address not allowed to deploy contracts either via CREATE or CALL(CREATE). + */ + CreateOriginNotAllowed: PlainDescriptor; + }; + Drand: { + /** + * The value retrieved was `None` as no value was previously set. + */ + NoneValue: PlainDescriptor; + /** + * There was an attempt to increment the value in storage over `u32::MAX`. + */ + StorageOverflow: PlainDescriptor; + /** + * failed to connect to the + */ + DrandConnectionFailure: PlainDescriptor; + /** + * the pulse is invalid + */ + UnverifiedPulse: PlainDescriptor; + /** + * the round number did not increment + */ + InvalidRoundNumber: PlainDescriptor; + /** + * the pulse could not be verified + */ + PulseVerificationError: PlainDescriptor; + }; + Crowdloan: { + /** + * The crowdloan initial deposit is too low. + */ + DepositTooLow: PlainDescriptor; + /** + * The crowdloan cap is too low. + */ + CapTooLow: PlainDescriptor; + /** + * The minimum contribution is too low. + */ + MinimumContributionTooLow: PlainDescriptor; + /** + * The crowdloan cannot end in the past. + */ + CannotEndInPast: PlainDescriptor; + /** + * The crowdloan block duration is too short. + */ + BlockDurationTooShort: PlainDescriptor; + /** + * The block duration is too long. + */ + BlockDurationTooLong: PlainDescriptor; + /** + * The account does not have enough balance to pay for the initial deposit/contribution. + */ + InsufficientBalance: PlainDescriptor; + /** + * An overflow occurred. + */ + Overflow: PlainDescriptor; + /** + * The crowdloan id is invalid. + */ + InvalidCrowdloanId: PlainDescriptor; + /** + * The crowdloan cap has been fully raised. + */ + CapRaised: PlainDescriptor; + /** + * The contribution period has ended. + */ + ContributionPeriodEnded: PlainDescriptor; + /** + * The contribution is too low. + */ + ContributionTooLow: PlainDescriptor; + /** + * The origin of this call is invalid. + */ + InvalidOrigin: PlainDescriptor; + /** + * The crowdloan has already been finalized. + */ + AlreadyFinalized: PlainDescriptor; + /** + * The crowdloan contribution period has not ended yet. + */ + ContributionPeriodNotEnded: PlainDescriptor; + /** + * The contributor has no contribution for this crowdloan. + */ + NoContribution: PlainDescriptor; + /** + * The crowdloan cap has not been raised. + */ + CapNotRaised: PlainDescriptor; + /** + * An underflow occurred. + */ + Underflow: PlainDescriptor; + /** + * Call to dispatch was not found in the preimage storage. + */ + CallUnavailable: PlainDescriptor; + /** + * The crowdloan is not ready to be dissolved, it still has contributions. + */ + NotReadyToDissolve: PlainDescriptor; + /** + * The deposit cannot be withdrawn from the crowdloan. + */ + DepositCannotBeWithdrawn: PlainDescriptor; + /** + * The maximum number of contributors has been reached. + */ + MaxContributorsReached: PlainDescriptor; + }; + Swap: { + /** + * The fee rate is too high + */ + FeeRateTooHigh: PlainDescriptor; + /** + * The provided amount is insufficient for the swap. + */ + InsufficientInputAmount: PlainDescriptor; + /** + * The provided liquidity is insufficient for the operation. + */ + InsufficientLiquidity: PlainDescriptor; + /** + * The operation would exceed the price limit. + */ + PriceLimitExceeded: PlainDescriptor; + /** + * The caller does not have enough balance for the operation. + */ + InsufficientBalance: PlainDescriptor; + /** + * Attempted to remove liquidity that does not exist. + */ + LiquidityNotFound: PlainDescriptor; + /** + * The provided tick range is invalid. + */ + InvalidTickRange: PlainDescriptor; + /** + * Maximum user positions exceeded + */ + MaxPositionsExceeded: PlainDescriptor; + /** + * Too many swap steps + */ + TooManySwapSteps: PlainDescriptor; + /** + * Provided liquidity parameter is invalid (likely too small) + */ + InvalidLiquidityValue: PlainDescriptor; + /** + * Reserves too low for operation. + */ + ReservesTooLow: PlainDescriptor; + /** + * The subnet does not exist. + */ + MechanismDoesNotExist: PlainDescriptor; + /** + * User liquidity operations are disabled for this subnet + */ + UserLiquidityDisabled: PlainDescriptor; + /** + * The subnet does not have subtoken enabled + */ + SubtokenDisabled: PlainDescriptor; + }; + Contracts: { + /** + * Invalid schedule supplied, e.g. with zero weight of a basic operation. + */ + InvalidSchedule: PlainDescriptor; + /** + * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`. + */ + InvalidCallFlags: PlainDescriptor; + /** + * The executed contract exhausted its gas limit. + */ + OutOfGas: PlainDescriptor; + /** + * The output buffer supplied to a contract API call was too small. + */ + OutputBufferTooSmall: PlainDescriptor; + /** + * Performing the requested transfer failed. Probably because there isn't enough + * free balance in the sender's account. + */ + TransferFailed: PlainDescriptor; + /** + * Performing a call was denied because the calling depth reached the limit + * of what is specified in the schedule. + */ + MaxCallDepthReached: PlainDescriptor; + /** + * No contract was found at the specified address. + */ + ContractNotFound: PlainDescriptor; + /** + * The code supplied to `instantiate_with_code` exceeds the limit specified in the + * current schedule. + */ + CodeTooLarge: PlainDescriptor; + /** + * No code could be found at the supplied code hash. + */ + CodeNotFound: PlainDescriptor; + /** + * No code info could be found at the supplied code hash. + */ + CodeInfoNotFound: PlainDescriptor; + /** + * A buffer outside of sandbox memory was passed to a contract API function. + */ + OutOfBounds: PlainDescriptor; + /** + * Input passed to a contract API function failed to decode as expected type. + */ + DecodingFailed: PlainDescriptor; + /** + * Contract trapped during execution. + */ + ContractTrapped: PlainDescriptor; + /** + * The size defined in `T::MaxValueSize` was exceeded. + */ + ValueTooLarge: PlainDescriptor; + /** + * Termination of a contract is not allowed while the contract is already + * on the call stack. Can be triggered by `seal_terminate`. + */ + TerminatedWhileReentrant: PlainDescriptor; + /** + * `seal_call` forwarded this contracts input. It therefore is no longer available. + */ + InputForwarded: PlainDescriptor; + /** + * The subject passed to `seal_random` exceeds the limit. + */ + RandomSubjectTooLong: PlainDescriptor; + /** + * The amount of topics passed to `seal_deposit_events` exceeds the limit. + */ + TooManyTopics: PlainDescriptor; + /** + * The chain does not provide a chain extension. Calling the chain extension results + * in this error. Note that this usually shouldn't happen as deploying such contracts + * is rejected. + */ + NoChainExtension: PlainDescriptor; + /** + * Failed to decode the XCM program. + */ + XCMDecodeFailed: PlainDescriptor; + /** + * A contract with the same AccountId already exists. + */ + DuplicateContract: PlainDescriptor; + /** + * A contract self destructed in its constructor. + * + * This can be triggered by a call to `seal_terminate`. + */ + TerminatedInConstructor: PlainDescriptor; + /** + * A call tried to invoke a contract that is flagged as non-reentrant. + * The only other cause is that a call from a contract into the runtime tried to call back + * into `pallet-contracts`. This would make the whole pallet reentrant with regard to + * contract code execution which is not supported. + */ + ReentranceDenied: PlainDescriptor; + /** + * A contract attempted to invoke a state modifying API while being in read-only mode. + */ + StateChangeDenied: PlainDescriptor; + /** + * Origin doesn't have enough balance to pay the required storage deposits. + */ + StorageDepositNotEnoughFunds: PlainDescriptor; + /** + * More storage was created than allowed by the storage deposit limit. + */ + StorageDepositLimitExhausted: PlainDescriptor; + /** + * Code removal was denied because the code is still in use by at least one contract. + */ + CodeInUse: PlainDescriptor; + /** + * The contract ran to completion but decided to revert its storage changes. + * Please note that this error is only returned from extrinsics. When called directly + * or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags + * to determine whether a reversion has taken place. + */ + ContractReverted: PlainDescriptor; + /** + * The contract's code was found to be invalid during validation. + * + * The most likely cause of this is that an API was used which is not supported by the + * node. This happens if an older node is used with a new version of ink!. Try updating + * your node to the newest available version. + * + * A more detailed error can be found on the node console if debug messages are enabled + * by supplying `-lruntime::contracts=debug`. + */ + CodeRejected: PlainDescriptor; + /** + * An indeterministic code was used in a context where this is not permitted. + */ + Indeterministic: PlainDescriptor; + /** + * A pending migration needs to complete before the extrinsic can be called. + */ + MigrationInProgress: PlainDescriptor; + /** + * Migrate dispatch call was attempted but no migration was performed. + */ + NoMigrationPerformed: PlainDescriptor; + /** + * The contract has reached its maximum number of delegate dependencies. + */ + MaxDelegateDependenciesReached: PlainDescriptor; + /** + * The dependency was not found in the contract's delegate dependencies. + */ + DelegateDependencyNotFound: PlainDescriptor; + /** + * The contract already depends on the given delegate dependency. + */ + DelegateDependencyAlreadyExists: PlainDescriptor; + /** + * Can not add a delegate dependency to the code hash of the contract itself. + */ + CannotAddSelfAsDelegateDependency: PlainDescriptor; + /** + * Can not add more data to transient storage. + */ + OutOfTransientStorage: PlainDescriptor; + }; + MevShield: { + /** + * A submission with the same id already exists in `Submissions`. + */ + SubmissionAlreadyExists: PlainDescriptor; + /** + * The referenced submission id does not exist in `Submissions`. + */ + MissingSubmission: PlainDescriptor; + /** + * The recomputed commitment does not match the stored commitment. + */ + CommitmentMismatch: PlainDescriptor; + /** + * The provided signature over the payload is invalid. + */ + SignatureInvalid: PlainDescriptor; + /** + * The announced ML‑KEM public key length is invalid. + */ + BadPublicKeyLen: PlainDescriptor; + /** + * The MEV‑Shield key epoch for this submission has expired and is no longer accepted. + */ + KeyExpired: PlainDescriptor; + /** + * The provided `key_hash` does not match the expected epoch key hash. + */ + KeyHashMismatch: PlainDescriptor; + }; +}; +type IConstants = { + System: { + /** + * Block & extrinsics weights: base values and limits. + */ + BlockWeights: PlainDescriptor>; + /** + * The maximum length of a block (in bytes). + */ + BlockLength: PlainDescriptor>; + /** + * Maximum number of block number to block hash mappings to keep (oldest pruned first). + */ + BlockHashCount: PlainDescriptor; + /** + * The weight of runtime database operations the runtime can invoke. + */ + DbWeight: PlainDescriptor>; + /** + * Get the chain's in-code version. + */ + Version: PlainDescriptor>; + /** + * The designated SS58 prefix of this chain. + * + * This replaces the "ss58Format" property declared in the chain spec. Reason is + * that the runtime should know about the prefix in order to make use of it as + * an identifier of the chain. + */ + SS58Prefix: PlainDescriptor; + }; + Timestamp: { + /** + * The minimum period between blocks. + * + * Be aware that this is different to the *expected* period that the block production + * apparatus provides. Your chosen consensus system will generally work with this to + * determine a sensible block time. For example, in the Aura pallet it will be double this + * period on default settings. + */ + MinimumPeriod: PlainDescriptor; + }; + Aura: { + /** + * The slot duration Aura should run with, expressed in milliseconds. + * The effective value of this type should not change while the chain is running. + * + * For backwards compatibility either use [`MinimumPeriodTimesTwo`] or a const. + */ + SlotDuration: PlainDescriptor; + }; + Grandpa: { + /** + * Max Authorities in use + */ + MaxAuthorities: PlainDescriptor; + /** + * The maximum number of nominators for each validator. + */ + MaxNominators: PlainDescriptor; + /** + * The maximum number of entries to keep in the set id to session index mapping. + * + * Since the `SetIdSession` map is only used for validating equivocations this + * value should relate to the bonding duration of whatever staking system is + * being used (if any). If equivocation handling is not enabled then this value + * can be zero. + */ + MaxSetIdSessionEntries: PlainDescriptor; + }; + Balances: { + /** + * The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO! + * + * If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` for + * this pallet. However, you do so at your own risk: this will open up a major DoS vector. + * In case you have multiple sources of provider references, you may also get unexpected + * behaviour if you set this to zero. + * + * Bottom line: Do yourself a favour and make it at least one! + */ + ExistentialDeposit: PlainDescriptor; + /** + * The maximum number of locks that should exist on an account. + * Not strictly enforced, but used for weight estimation. + * + * Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/` + */ + MaxLocks: PlainDescriptor; + /** + * The maximum number of named reserves that can exist on an account. + * + * Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/` + */ + MaxReserves: PlainDescriptor; + /** + * The maximum number of individual freeze locks that can exist on an account at any time. + */ + MaxFreezes: PlainDescriptor; + }; + TransactionPayment: { + /** + * A fee multiplier for `Operational` extrinsics to compute "virtual tip" to boost their + * `priority` + * + * This value is multiplied by the `final_fee` to obtain a "virtual tip" that is later + * added to a tip component in regular `priority` calculations. + * It means that a `Normal` transaction can front-run a similarly-sized `Operational` + * extrinsic (with no tip), by including a tip value greater than the virtual tip. + * + * ```rust,ignore + * // For `Normal` + * let priority = priority_calc(tip); + * + * // For `Operational` + * let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier; + * let priority = priority_calc(tip + virtual_tip); + * ``` + * + * Note that since we use `final_fee` the multiplier applies also to the regular `tip` + * sent with the transaction. So, not only does the transaction get a priority bump based + * on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational` + * transactions. + */ + OperationalFeeMultiplier: PlainDescriptor; + }; + SubtensorModule: { + /** + * ================================= + * ==== Initial Value Constants ==== + * ================================= + * Initial currency issuance. + */ + InitialIssuance: PlainDescriptor; + /** + * Initial min allowed weights setting. + */ + InitialMinAllowedWeights: PlainDescriptor; + /** + * Initial Emission Ratio. + */ + InitialEmissionValue: PlainDescriptor; + /** + * Tempo for each network. + */ + InitialTempo: PlainDescriptor; + /** + * Initial Difficulty. + */ + InitialDifficulty: PlainDescriptor; + /** + * Initial Max Difficulty. + */ + InitialMaxDifficulty: PlainDescriptor; + /** + * Initial Min Difficulty. + */ + InitialMinDifficulty: PlainDescriptor; + /** + * Initial RAO Recycled. + */ + InitialRAORecycledForRegistration: PlainDescriptor; + /** + * Initial Burn. + */ + InitialBurn: PlainDescriptor; + /** + * Initial Max Burn. + */ + InitialMaxBurn: PlainDescriptor; + /** + * Initial Min Burn. + */ + InitialMinBurn: PlainDescriptor; + /** + * Min burn upper bound. + */ + MinBurnUpperBound: PlainDescriptor; + /** + * Max burn lower bound. + */ + MaxBurnLowerBound: PlainDescriptor; + /** + * Initial adjustment interval. + */ + InitialAdjustmentInterval: PlainDescriptor; + /** + * Initial bonds moving average. + */ + InitialBondsMovingAverage: PlainDescriptor; + /** + * Initial bonds penalty. + */ + InitialBondsPenalty: PlainDescriptor; + /** + * Initial bonds reset. + */ + InitialBondsResetOn: PlainDescriptor; + /** + * Initial target registrations per interval. + */ + InitialTargetRegistrationsPerInterval: PlainDescriptor; + /** + * Rho constant. + */ + InitialRho: PlainDescriptor; + /** + * AlphaSigmoidSteepness constant. + */ + InitialAlphaSigmoidSteepness: PlainDescriptor; + /** + * Kappa constant. + */ + InitialKappa: PlainDescriptor; + /** + * Initial minimum allowed network UIDs + */ + InitialMinAllowedUids: PlainDescriptor; + /** + * Initial maximum allowed network UIDs + */ + InitialMaxAllowedUids: PlainDescriptor; + /** + * Initial validator context pruning length. + */ + InitialValidatorPruneLen: PlainDescriptor; + /** + * Initial scaling law power. + */ + InitialScalingLawPower: PlainDescriptor; + /** + * Immunity Period Constant. + */ + InitialImmunityPeriod: PlainDescriptor; + /** + * Activity constant. + */ + InitialActivityCutoff: PlainDescriptor; + /** + * Initial max registrations per block. + */ + InitialMaxRegistrationsPerBlock: PlainDescriptor; + /** + * Initial pruning score for each neuron. + */ + InitialPruningScore: PlainDescriptor; + /** + * Initial maximum allowed validators per network. + */ + InitialMaxAllowedValidators: PlainDescriptor; + /** + * Initial default delegation take. + */ + InitialDefaultDelegateTake: PlainDescriptor; + /** + * Initial minimum delegation take. + */ + InitialMinDelegateTake: PlainDescriptor; + /** + * Initial default childkey take. + */ + InitialDefaultChildKeyTake: PlainDescriptor; + /** + * Initial minimum childkey take. + */ + InitialMinChildKeyTake: PlainDescriptor; + /** + * Initial maximum childkey take. + */ + InitialMaxChildKeyTake: PlainDescriptor; + /** + * Initial weights version key. + */ + InitialWeightsVersionKey: PlainDescriptor; + /** + * Initial serving rate limit. + */ + InitialServingRateLimit: PlainDescriptor; + /** + * Initial transaction rate limit. + */ + InitialTxRateLimit: PlainDescriptor; + /** + * Initial delegate take transaction rate limit. + */ + InitialTxDelegateTakeRateLimit: PlainDescriptor; + /** + * Initial childkey take transaction rate limit. + */ + InitialTxChildKeyTakeRateLimit: PlainDescriptor; + /** + * Initial adjustment alpha on burn and pow. + */ + InitialAdjustmentAlpha: PlainDescriptor; + /** + * Initial network immunity period + */ + InitialNetworkImmunityPeriod: PlainDescriptor; + /** + * Initial network minimum burn cost + */ + InitialNetworkMinLockCost: PlainDescriptor; + /** + * Initial network subnet cut. + */ + InitialSubnetOwnerCut: PlainDescriptor; + /** + * Initial lock reduction interval. + */ + InitialNetworkLockReductionInterval: PlainDescriptor; + /** + * Initial network creation rate limit + */ + InitialNetworkRateLimit: PlainDescriptor; + /** + * Cost of swapping a hotkey. + */ + KeySwapCost: PlainDescriptor; + /** + * The upper bound for the alpha parameter. Used for Liquid Alpha. + */ + AlphaHigh: PlainDescriptor; + /** + * The lower bound for the alpha parameter. Used for Liquid Alpha. + */ + AlphaLow: PlainDescriptor; + /** + * A flag to indicate if Liquid Alpha is enabled. + */ + LiquidAlphaOn: PlainDescriptor; + /** + * A flag to indicate if Yuma3 is enabled. + */ + Yuma3On: PlainDescriptor; + /** + * Coldkey swap announcement delay. + */ + InitialColdkeySwapAnnouncementDelay: PlainDescriptor; + /** + * Coldkey swap reannouncement delay. + */ + InitialColdkeySwapReannouncementDelay: PlainDescriptor; + /** + * Dissolve network schedule duration + */ + InitialDissolveNetworkScheduleDuration: PlainDescriptor; + /** + * Initial TAO weight. + */ + InitialTaoWeight: PlainDescriptor; + /** + * Initial EMA price halving period + */ + InitialEmaPriceHalvingPeriod: PlainDescriptor; + /** + * Delay after which a new subnet can dispatch start call extrinsic. + */ + InitialStartCallDelay: PlainDescriptor; + /** + * Cost of swapping a hotkey in a subnet. + */ + KeySwapOnSubnetCost: PlainDescriptor; + /** + * Block number for a coldkey swap the hotkey in specific subnet. + */ + HotkeySwapOnSubnetInterval: PlainDescriptor; + /** + * Number of blocks between dividends distribution. + */ + LeaseDividendsDistributionInterval: PlainDescriptor; + /** + * Maximum percentage of immune UIDs. + */ + MaxImmuneUidsPercentage: PlainDescriptor; + }; + Utility: { + /** + * The limit on the number of batched calls. + */ + batched_calls_limit: PlainDescriptor; + }; + Multisig: { + /** + * The base amount of currency needed to reserve for creating a multisig execution or to + * store a dispatch call for later. + * + * This is held for an additional storage item whose value size is + * `4 + sizeof((BlockNumber, Balance, AccountId))` bytes and whose key size is + * `32 + sizeof(AccountId)` bytes. + */ + DepositBase: PlainDescriptor; + /** + * The amount of currency needed per unit threshold when creating a multisig execution. + * + * This is held for adding 32 bytes more into a pre-existing storage value. + */ + DepositFactor: PlainDescriptor; + /** + * The maximum amount of signatories allowed in the multisig. + */ + MaxSignatories: PlainDescriptor; + }; + Scheduler: { + /** + * The maximum weight that may be scheduled per block for any dispatchables. + */ + MaximumWeight: PlainDescriptor>; + /** + * The maximum number of scheduled calls in the queue for a single block. + * + * NOTE: + * + Dependent pallets' benchmarks might require a higher limit for the setting. Set a + * higher limit under `runtime-benchmarks` feature. + */ + MaxScheduledPerBlock: PlainDescriptor; + }; + Proxy: { + /** + * The base amount of currency needed to reserve for creating a proxy. + * + * This is held for an additional storage item whose value size is + * `sizeof(Balance)` bytes and whose key size is `sizeof(AccountId)` bytes. + */ + ProxyDepositBase: PlainDescriptor; + /** + * The amount of currency needed per proxy added. + * + * This is held for adding 32 bytes plus an instance of `ProxyType` more into a + * pre-existing storage value. Thus, when configuring `ProxyDepositFactor` one should take + * into account `32 + proxy_type.encode().len()` bytes of data. + */ + ProxyDepositFactor: PlainDescriptor; + /** + * The maximum amount of proxies allowed for a single account. + */ + MaxProxies: PlainDescriptor; + /** + * The maximum amount of time-delayed announcements that are allowed to be pending. + */ + MaxPending: PlainDescriptor; + /** + * The base amount of currency needed to reserve for creating an announcement. + * + * This is held when a new storage item holding a `Balance` is created (typically 16 + * bytes). + */ + AnnouncementDepositBase: PlainDescriptor; + /** + * The amount of currency needed per announcement made. + * + * This is held for adding an `AccountId`, `Hash` and `BlockNumber` (typically 68 bytes) + * into a pre-existing storage value. + */ + AnnouncementDepositFactor: PlainDescriptor; + }; + Registry: { + /** + * Configuration fields + * Maximum user-configured additional fields + */ + MaxAdditionalFields: PlainDescriptor; + /** + * The amount held on deposit for a registered identity + */ + InitialDeposit: PlainDescriptor; + /** + * The amount held on deposit per additional field for a registered identity. + */ + FieldDeposit: PlainDescriptor; + }; + Commitments: { + /** + * The maximum number of additional fields that can be added to a commitment + */ + MaxFields: PlainDescriptor; + /** + * The amount held on deposit for a registered identity + */ + InitialDeposit: PlainDescriptor; + /** + * The amount held on deposit per additional field for a registered identity. + */ + FieldDeposit: PlainDescriptor; + }; + SafeMode: { + /** + * For how many blocks the safe-mode will be entered by [`Pallet::enter`]. + */ + EnterDuration: PlainDescriptor; + /** + * For how many blocks the safe-mode can be extended by each [`Pallet::extend`] call. + * + * This does not impose a hard limit as the safe-mode can be extended multiple times. + */ + ExtendDuration: PlainDescriptor; + /** + * The amount that will be reserved upon calling [`Pallet::enter`]. + * + * `None` disallows permissionlessly enabling the safe-mode and is a sane default. + */ + EnterDepositAmount: PlainDescriptor>; + /** + * The amount that will be reserved upon calling [`Pallet::extend`]. + * + * `None` disallows permissionlessly extending the safe-mode and is a sane default. + */ + ExtendDepositAmount: PlainDescriptor>; + /** + * The minimal duration a deposit will remain reserved after safe-mode is entered or + * extended, unless [`Pallet::force_release_deposit`] is successfully called sooner. + * + * Every deposit is tied to a specific activation or extension, thus each deposit can be + * released independently after the delay for it has passed. + * + * `None` disallows permissionlessly releasing the safe-mode deposits and is a sane + * default. + */ + ReleaseDelay: PlainDescriptor>; + }; + Drand: { + /** + * A configuration for base priority of unsigned transactions. + * + * This is exposed so that it can be tuned for particular runtime, when + * multiple pallets send unsigned transactions. + */ + UnsignedPriority: PlainDescriptor; + /** + * The maximum number of milliseconds we are willing to wait for the HTTP request to + * complete. + */ + HttpFetchTimeout: PlainDescriptor; + }; + Crowdloan: { + /** + * The pallet id that will be used to derive crowdloan account ids. + */ + PalletId: PlainDescriptor>; + /** + * The minimum deposit required to create a crowdloan. + */ + MinimumDeposit: PlainDescriptor; + /** + * The absolute minimum contribution required to contribute to a crowdloan. + */ + AbsoluteMinimumContribution: PlainDescriptor; + /** + * The minimum block duration for a crowdloan. + */ + MinimumBlockDuration: PlainDescriptor; + /** + * The maximum block duration for a crowdloan. + */ + MaximumBlockDuration: PlainDescriptor; + /** + * The maximum number of contributors that can be refunded in a single refund. + */ + RefundContributorsLimit: PlainDescriptor; + /** + + */ + MaxContributors: PlainDescriptor; + }; + Swap: { + /** + * This type is used to derive protocol accoun ID. + */ + ProtocolId: PlainDescriptor>; + /** + * The maximum fee rate that can be set + */ + MaxFeeRate: PlainDescriptor; + /** + * The maximum number of positions a user can have + */ + MaxPositions: PlainDescriptor; + /** + * Minimum liquidity that is safe for rounding and integer math. + */ + MinimumLiquidity: PlainDescriptor; + /** + * Minimum reserve for tao and alpha + */ + MinimumReserve: PlainDescriptor; + }; + Contracts: { + /** + * Cost schedule and limits. + */ + Schedule: PlainDescriptor>; + /** + * The amount of balance a caller has to pay for each byte of storage. + * + * # Note + * + * Changing this value for an existing chain might need a storage migration. + */ + DepositPerByte: PlainDescriptor; + /** + * Fallback value to limit the storage deposit if it's not being set by the caller. + */ + DefaultDepositLimit: PlainDescriptor; + /** + * The amount of balance a caller has to pay for each storage item. + * + * # Note + * + * Changing this value for an existing chain might need a storage migration. + */ + DepositPerItem: PlainDescriptor; + /** + * The percentage of the storage deposit that should be held for using a code hash. + * Instantiating a contract, or calling [`chain_extension::Ext::lock_delegate_dependency`] + * protects the code from being removed. In order to prevent abuse these actions are + * protected with a percentage of the code deposit. + */ + CodeHashLockupDepositPercent: PlainDescriptor; + /** + * The maximum length of a contract code in bytes. + * + * The value should be chosen carefully taking into the account the overall memory limit + * your runtime has, as well as the [maximum allowed callstack + * depth](#associatedtype.CallStack). Look into the `integrity_test()` for some insights. + */ + MaxCodeLen: PlainDescriptor; + /** + * The maximum allowable length in bytes for storage keys. + */ + MaxStorageKeyLen: PlainDescriptor; + /** + * The maximum size of the transient storage in bytes. + * This includes keys, values, and previous entries used for storage rollback. + */ + MaxTransientStorageSize: PlainDescriptor; + /** + * The maximum number of delegate_dependencies that a contract can lock with + * [`chain_extension::Ext::lock_delegate_dependency`]. + */ + MaxDelegateDependencies: PlainDescriptor; + /** + * Make contract callable functions marked as `#[unstable]` available. + * + * Contracts that use `#[unstable]` functions won't be able to be uploaded unless + * this is set to `true`. This is only meant for testnets and dev nodes in order to + * experiment with new features. + * + * # Warning + * + * Do **not** set to `true` on productions chains. + */ + UnsafeUnstableInterface: PlainDescriptor; + /** + * The maximum length of the debug buffer in bytes. + */ + MaxDebugBufferLen: PlainDescriptor; + /** + * Type that bundles together all the runtime configurable interface types. + * + * This is not a real config. We just mention the type here as constant so that + * its type appears in the metadata. Only valid value is `()`. + */ + Environment: PlainDescriptor>; + /** + * The version of the HostFn APIs that are available in the runtime. + * + * Only valid value is `()`. + */ + ApiVersion: PlainDescriptor; + }; +}; +type IViewFns = { + Proxy: { + /** + * Check if a `RuntimeCall` is allowed for a given `ProxyType`. + */ + check_permissions: RuntimeDescriptor<[call: Anonymize, proxy_type: Anonymize], boolean>; + /** + * Check if one `ProxyType` is a subset of another `ProxyType`. + */ + is_superset: RuntimeDescriptor<[to_check: Anonymize, against: Anonymize], boolean>; + }; +}; +type IRuntimeCalls = { + /** + * The `Core` runtime api that every Substrate runtime needs to implement. + */ + Core: { + /** + * Returns the version of the runtime. + */ + version: RuntimeDescriptor<[], Anonymize>; + /** + * Execute the given block. + */ + execute_block: RuntimeDescriptor<[block: Anonymize], undefined>; + /** + * Initialize a block with the given header and return the runtime executive mode. + */ + initialize_block: RuntimeDescriptor<[header: Anonymize], Anonymize>; + }; + /** + * The `Metadata` api trait that returns metadata for the runtime. + */ + Metadata: { + /** + * Returns the metadata of a runtime. + */ + metadata: RuntimeDescriptor<[], Binary>; + /** + * Returns the metadata at a given version. + * + * If the given `version` isn't supported, this will return `None`. + * Use [`Self::metadata_versions`] to find out about supported metadata version of the runtime. + */ + metadata_at_version: RuntimeDescriptor<[version: number], Anonymize>; + /** + * Returns the supported metadata versions. + * + * This can be used to call `metadata_at_version`. + */ + metadata_versions: RuntimeDescriptor<[], Anonymize>; + }; + /** + * The `BlockBuilder` api trait that provides the required functionality for building a block. + */ + BlockBuilder: { + /** + * Apply the given extrinsic. + * + * Returns an inclusion outcome which specifies if this extrinsic is included in + * this block or not. + */ + apply_extrinsic: RuntimeDescriptor<[extrinsic: Binary], Anonymize>; + /** + * Finish the current block. + */ + finalize_block: RuntimeDescriptor<[], Anonymize>; + /** + * Generate inherent extrinsics. The inherent data will vary from chain to chain. + */ + inherent_extrinsics: RuntimeDescriptor<[inherent: Anonymize], Anonymize>; + /** + * Check that the inherents are valid. The inherent data will vary from chain to chain. + */ + check_inherents: RuntimeDescriptor<[block: Anonymize, data: Anonymize], Anonymize>; + }; + /** + * API to interact with `RuntimeGenesisConfig` for the runtime + */ + GenesisBuilder: { + /** + * Build `RuntimeGenesisConfig` from a JSON blob not using any defaults and store it in the + * storage. + * + * In the case of a FRAME-based runtime, this function deserializes the full + * `RuntimeGenesisConfig` from the given JSON blob and puts it into the storage. If the + * provided JSON blob is incorrect or incomplete or the deserialization fails, an error + * is returned. + * + * Please note that provided JSON blob must contain all `RuntimeGenesisConfig` fields, no + * defaults will be used. + */ + build_state: RuntimeDescriptor<[json: Binary], Anonymize>; + /** + * Returns a JSON blob representation of the built-in `RuntimeGenesisConfig` identified by + * `id`. + * + * If `id` is `None` the function should return JSON blob representation of the default + * `RuntimeGenesisConfig` struct of the runtime. Implementation must provide default + * `RuntimeGenesisConfig`. + * + * Otherwise function returns a JSON representation of the built-in, named + * `RuntimeGenesisConfig` preset identified by `id`, or `None` if such preset does not + * exist. Returned `Vec` contains bytes of JSON blob (patch) which comprises a list of + * (potentially nested) key-value pairs that are intended for customizing the default + * runtime genesis config. The patch shall be merged (rfc7386) with the JSON representation + * of the default `RuntimeGenesisConfig` to create a comprehensive genesis config that can + * be used in `build_state` method. + */ + get_preset: RuntimeDescriptor<[id: Anonymize], Anonymize>; + /** + * Returns a list of identifiers for available builtin `RuntimeGenesisConfig` presets. + * + * The presets from the list can be queried with [`GenesisBuilder::get_preset`] method. If + * no named presets are provided by the runtime the list is empty. + */ + preset_names: RuntimeDescriptor<[], Anonymize>; + }; + /** + * The `TaggedTransactionQueue` api trait for interfering with the transaction queue. + */ + TaggedTransactionQueue: { + /** + * Validate the transaction. + * + * This method is invoked by the transaction pool to learn details about given transaction. + * The implementation should make sure to verify the correctness of the transaction + * against current state. The given `block_hash` corresponds to the hash of the block + * that is used as current state. + * + * Note that this call may be performed by the pool multiple times and transactions + * might be verified in any possible order. + */ + validate_transaction: RuntimeDescriptor<[source: TransactionValidityTransactionSource, tx: Binary, block_hash: FixedSizeBinary<32>], Anonymize>; + }; + /** + * The offchain worker api. + */ + OffchainWorkerApi: { + /** + * Starts the off-chain task for given block header. + */ + offchain_worker: RuntimeDescriptor<[header: Anonymize], undefined>; + }; + /** + * API necessary for block authorship with aura. + */ + AuraApi: { + /** + * Returns the slot duration for Aura. + * + * Currently, only the value provided by this type at genesis will be used. + */ + slot_duration: RuntimeDescriptor<[], bigint>; + /** + * Return the current set of authorities. + */ + authorities: RuntimeDescriptor<[], Anonymize>; + }; + /** + * Session keys runtime api. + */ + SessionKeys: { + /** + * Generate a set of session keys with optionally using the given seed. + * The keys should be stored within the keystore exposed via runtime + * externalities. + * + * The seed needs to be a valid `utf8` string. + * + * Returns the concatenated SCALE encoded public keys. + */ + generate_session_keys: RuntimeDescriptor<[seed: Anonymize], Binary>; + /** + * Decode the given public session keys. + * + * Returns the list of public raw public keys + key type. + */ + decode_session_keys: RuntimeDescriptor<[encoded: Binary], Anonymize>; + }; + /** + * APIs for integrating the GRANDPA finality gadget into runtimes. + * This should be implemented on the runtime side. + * + * This is primarily used for negotiating authority-set changes for the + * gadget. GRANDPA uses a signaling model of changing authority sets: + * changes should be signaled with a delay of N blocks, and then automatically + * applied in the runtime after those N blocks have passed. + * + * The consensus protocol will coordinate the handoff externally. + */ + GrandpaApi: { + /** + * Get the current GRANDPA authorities and weights. This should not change except + * for when changes are scheduled and the corresponding delay has passed. + * + * When called at block B, it will return the set of authorities that should be + * used to finalize descendants of this block (B+1, B+2, ...). The block B itself + * is finalized by the authorities from block B-1. + */ + grandpa_authorities: RuntimeDescriptor<[], Anonymize>; + /** + * Submits an unsigned extrinsic to report an equivocation. The caller + * must provide the equivocation proof and a key ownership proof + * (should be obtained using `generate_key_ownership_proof`). The + * extrinsic will be unsigned and should only be accepted for local + * authorship (not to be broadcast to the network). This method returns + * `None` when creation of the extrinsic fails, e.g. if equivocation + * reporting is disabled for the given runtime (i.e. this method is + * hardcoded to return `None`). Only useful in an offchain context. + */ + submit_report_equivocation_unsigned_extrinsic: RuntimeDescriptor<[equivocation_proof: Anonymize, key_owner_proof: Binary], boolean>; + /** + * Generates a proof of key ownership for the given authority in the + * given set. An example usage of this module is coupled with the + * session historical module to prove that a given authority key is + * tied to a given staking identity during a specific session. Proofs + * of key ownership are necessary for submitting equivocation reports. + * NOTE: even though the API takes a `set_id` as parameter the current + * implementations ignore this parameter and instead rely on this + * method being called at the correct block height, i.e. any point at + * which the given set id is live on-chain. Future implementations will + * instead use indexed data through an offchain worker, not requiring + * older states to be available. + */ + generate_key_ownership_proof: RuntimeDescriptor<[set_id: bigint, authority_id: FixedSizeBinary<32>], Anonymize>; + /** + * Get current GRANDPA authority set id. + */ + current_set_id: RuntimeDescriptor<[], bigint>; + }; + /** + * The API to query account nonce. + */ + AccountNonceApi: { + /** + * Get current account nonce of given `AccountId`. + */ + account_nonce: RuntimeDescriptor<[account: SS58String], number>; + }; + /** + + */ + TransactionPaymentApi: { + /** + + */ + query_info: RuntimeDescriptor<[uxt: Binary, len: number], Anonymize>; + /** + + */ + query_fee_details: RuntimeDescriptor<[uxt: Binary, len: number], Anonymize>; + /** + + */ + query_weight_to_fee: RuntimeDescriptor<[weight: Anonymize], bigint>; + /** + + */ + query_length_to_fee: RuntimeDescriptor<[length: number], bigint>; + }; + /** + + */ + TransactionPaymentCallApi: { + /** + * Query information of a dispatch class, weight, and fee of a given encoded `Call`. + */ + query_call_info: RuntimeDescriptor<[call: Anonymize, len: number], Anonymize>; + /** + * Query fee details of a given encoded `Call`. + */ + query_call_fee_details: RuntimeDescriptor<[call: Anonymize, len: number], Anonymize>; + /** + * Query the output of the current `WeightToFee` given some input. + */ + query_weight_to_fee: RuntimeDescriptor<[weight: Anonymize], bigint>; + /** + * Query the output of the current `LengthToFee` given some input. + */ + query_length_to_fee: RuntimeDescriptor<[length: number], bigint>; + }; + /** + * API necessary for Ethereum-compatibility layer. + */ + EthereumRuntimeRPCApi: { + /** + * Returns runtime defined pallet_evm::ChainId. + */ + chain_id: RuntimeDescriptor<[], bigint>; + /** + * Returns pallet_evm::Accounts by address. + */ + account_basic: RuntimeDescriptor<[address: FixedSizeBinary<20>], Anonymize>; + /** + * Returns FixedGasPrice::min_gas_price + */ + gas_price: RuntimeDescriptor<[], Anonymize>; + /** + * For a given account address, returns pallet_evm::AccountCodes. + */ + account_code_at: RuntimeDescriptor<[address: FixedSizeBinary<20>], Binary>; + /** + * Returns the converted FindAuthor::find_author authority id. + */ + author: RuntimeDescriptor<[], FixedSizeBinary<20>>; + /** + * For a given account address and index, returns pallet_evm::AccountStorages. + */ + storage_at: RuntimeDescriptor<[address: FixedSizeBinary<20>, index: Anonymize], FixedSizeBinary<32>>; + /** + + */ + call: RuntimeDescriptor<[from: FixedSizeBinary<20>, to: FixedSizeBinary<20>, data: Binary, value: Anonymize, gas_limit: Anonymize, max_fee_per_gas: Anonymize, max_priority_fee_per_gas: Anonymize, nonce: Anonymize, estimate: boolean, access_list: Anonymize, authorization_list: Anonymize], Anonymize>; + /** + + */ + create: RuntimeDescriptor<[from: FixedSizeBinary<20>, data: Binary, value: Anonymize, gas_limit: Anonymize, max_fee_per_gas: Anonymize, max_priority_fee_per_gas: Anonymize, nonce: Anonymize, estimate: boolean, access_list: Anonymize, authorization_list: Anonymize], Anonymize>; + /** + * Return the current block. + */ + current_block: RuntimeDescriptor<[], Anonymize>; + /** + * Return the current receipt. + */ + current_receipts: RuntimeDescriptor<[], Anonymize>; + /** + * Return the current transaction status. + */ + current_transaction_statuses: RuntimeDescriptor<[], Anonymize>; + /** + + */ + current_all: RuntimeDescriptor<[], Anonymize>; + /** + * Receives a `Vec` and filters all the ethereum transactions. + */ + extrinsic_filter: RuntimeDescriptor<[xts: Anonymize], Anonymize>; + /** + * Return the elasticity multiplier. + */ + elasticity: RuntimeDescriptor<[], Anonymize>; + /** + * Used to determine if gas limit multiplier for non-transactional calls (eth_call/estimateGas) + * is supported. + */ + gas_limit_multiplier_support: RuntimeDescriptor<[], undefined>; + /** + * Return the pending block. + */ + pending_block: RuntimeDescriptor<[xts: Anonymize], Anonymize>; + /** + * Initialize the pending block. + * The behavior should be the same as the runtime api Core_initialize_block but + * for a "pending" block. + * If your project don't need to have a different behavior to initialize "pending" blocks, + * you can copy your Core_initialize_block implementation. + */ + initialize_pending_block: RuntimeDescriptor<[header: Anonymize], undefined>; + }; + /** + + */ + ConvertTransactionRuntimeApi: { + /** + + */ + convert_transaction: RuntimeDescriptor<[transaction: Anonymize], Binary>; + }; + /** + * The API used to dry-run contract interactions. + */ + ContractsApi: { + /** + * Perform a call from a specified account to a given contract. + * + * See [`crate::Pallet::bare_call`]. + */ + call: RuntimeDescriptor<[origin: SS58String, dest: SS58String, value: bigint, gas_limit: Anonymize, storage_deposit_limit: Anonymize, input_data: Binary], Anonymize>; + /** + * Instantiate a new contract. + * + * See `[crate::Pallet::bare_instantiate]`. + */ + instantiate: RuntimeDescriptor<[origin: SS58String, value: bigint, gas_limit: Anonymize, storage_deposit_limit: Anonymize, code: Anonymize, data: Binary, salt: Binary], Anonymize>; + /** + * Upload new code without instantiating a contract from it. + * + * See [`crate::Pallet::bare_upload_code`]. + */ + upload_code: RuntimeDescriptor<[origin: SS58String, code: Binary, storage_deposit_limit: Anonymize, determinism: Anonymize], Anonymize>; + /** + * Query a given storage key in a given contract. + * + * Returns `Ok(Some(Vec))` if the storage value exists under the given key in the + * specified account and `Ok(None)` if it doesn't. If the account specified by the address + * doesn't exist, or doesn't have a contract then `Err` is returned. + */ + get_storage: RuntimeDescriptor<[address: SS58String, key: Binary], Anonymize>; + }; + /** + + */ + DelegateInfoRuntimeApi: { + /** + + */ + get_delegates: RuntimeDescriptor<[], Anonymize>; + /** + + */ + get_delegate: RuntimeDescriptor<[delegate_account: SS58String], Anonymize>; + /** + + */ + get_delegated: RuntimeDescriptor<[delegatee_account: SS58String], Anonymize>; + }; + /** + + */ + NeuronInfoRuntimeApi: { + /** + + */ + get_neurons: RuntimeDescriptor<[netuid: number], Anonymize>; + /** + + */ + get_neuron: RuntimeDescriptor<[netuid: number, uid: number], Anonymize>; + /** + + */ + get_neurons_lite: RuntimeDescriptor<[netuid: number], Anonymize>; + /** + + */ + get_neuron_lite: RuntimeDescriptor<[netuid: number, uid: number], Anonymize>; + }; + /** + + */ + SubnetInfoRuntimeApi: { + /** + + */ + get_subnet_info: RuntimeDescriptor<[netuid: number], Anonymize>; + /** + + */ + get_subnets_info: RuntimeDescriptor<[], Anonymize>; + /** + + */ + get_subnet_info_v2: RuntimeDescriptor<[netuid: number], Anonymize>; + /** + + */ + get_subnets_info_v2: RuntimeDescriptor<[], Anonymize>; + /** + + */ + get_subnet_hyperparams: RuntimeDescriptor<[netuid: number], Anonymize>; + /** + + */ + get_subnet_hyperparams_v2: RuntimeDescriptor<[netuid: number], Anonymize>; + /** + + */ + get_all_dynamic_info: RuntimeDescriptor<[], Anonymize>; + /** + + */ + get_all_metagraphs: RuntimeDescriptor<[], Anonymize>; + /** + + */ + get_metagraph: RuntimeDescriptor<[netuid: number], Anonymize>; + /** + + */ + get_all_mechagraphs: RuntimeDescriptor<[], Anonymize>; + /** + + */ + get_mechagraph: RuntimeDescriptor<[netuid: number, mecid: number], Anonymize>; + /** + + */ + get_dynamic_info: RuntimeDescriptor<[netuid: number], Anonymize>; + /** + + */ + get_subnet_state: RuntimeDescriptor<[netuid: number], Anonymize>; + /** + + */ + get_selective_metagraph: RuntimeDescriptor<[netuid: number, metagraph_indexes: Anonymize], Anonymize>; + /** + + */ + get_coldkey_auto_stake_hotkey: RuntimeDescriptor<[coldkey: SS58String, netuid: number], Anonymize>; + /** + + */ + get_selective_mechagraph: RuntimeDescriptor<[netuid: number, subid: number, metagraph_indexes: Anonymize], Anonymize>; + /** + + */ + get_subnet_to_prune: RuntimeDescriptor<[], Anonymize>; + }; + /** + + */ + StakeInfoRuntimeApi: { + /** + + */ + get_stake_info_for_coldkey: RuntimeDescriptor<[coldkey_account: SS58String], Anonymize>; + /** + + */ + get_stake_info_for_coldkeys: RuntimeDescriptor<[coldkey_accounts: Anonymize], Anonymize>; + /** + + */ + get_stake_info_for_hotkey_coldkey_netuid: RuntimeDescriptor<[hotkey_account: SS58String, coldkey_account: SS58String, netuid: number], Anonymize>; + /** + + */ + get_stake_fee: RuntimeDescriptor<[origin: Anonymize, origin_coldkey_account: SS58String, destination: Anonymize, destination_coldkey_account: SS58String, amount: bigint], bigint>; + }; + /** + + */ + SubnetRegistrationRuntimeApi: { + /** + + */ + get_network_registration_cost: RuntimeDescriptor<[], bigint>; + }; + /** + * API necessary for block authorship with BABE. + */ + BabeApi: { + /** + * Return the configuration for BABE. + */ + configuration: RuntimeDescriptor<[], Anonymize>; + /** + * Returns the slot that started the current epoch. + */ + current_epoch_start: RuntimeDescriptor<[], bigint>; + /** + * Returns information regarding the current epoch. + */ + current_epoch: RuntimeDescriptor<[], Anonymize>; + /** + * Returns information regarding the next epoch (which was already + * previously announced). + */ + next_epoch: RuntimeDescriptor<[], Anonymize>; + /** + * Generates a proof of key ownership for the given authority in the + * current epoch. An example usage of this module is coupled with the + * session historical module to prove that a given authority key is + * tied to a given staking identity during a specific session. Proofs + * of key ownership are necessary for submitting equivocation reports. + * NOTE: even though the API takes a `slot` as parameter the current + * implementations ignores this parameter and instead relies on this + * method being called at the correct block height, i.e. any point at + * which the epoch for the given slot is live on-chain. Future + * implementations will instead use indexed data through an offchain + * worker, not requiring older states to be available. + */ + generate_key_ownership_proof: RuntimeDescriptor<[slot: bigint, authority_id: FixedSizeBinary<32>], Anonymize>; + /** + * Submits an unsigned extrinsic to report an equivocation. The caller + * must provide the equivocation proof and a key ownership proof + * (should be obtained using `generate_key_ownership_proof`). The + * extrinsic will be unsigned and should only be accepted for local + * authorship (not to be broadcast to the network). This method returns + * `None` when creation of the extrinsic fails, e.g. if equivocation + * reporting is disabled for the given runtime (i.e. this method is + * hardcoded to return `None`). Only useful in an offchain context. + */ + submit_report_equivocation_unsigned_extrinsic: RuntimeDescriptor<[equivocation_proof: Anonymize, key_owner_proof: Binary], boolean>; + }; + /** + + */ + SwapRuntimeApi: { + /** + + */ + current_alpha_price: RuntimeDescriptor<[netuid: number], bigint>; + /** + + */ + current_alpha_price_all: RuntimeDescriptor<[], Anonymize>; + /** + + */ + sim_swap_tao_for_alpha: RuntimeDescriptor<[netuid: number, tao: bigint], Anonymize>; + /** + + */ + sim_swap_alpha_for_tao: RuntimeDescriptor<[netuid: number, alpha: bigint], Anonymize>; + }; +}; +export type DevnetDispatchError = Anonymize; +type IAsset = PlainDescriptor; +export type DevnetExtensions = {}; +type PalletsTypedef = { + __storage: IStorage; + __tx: ICalls; + __event: IEvent; + __error: IError; + __const: IConstants; + __view: IViewFns; +}; +export type Devnet = { + descriptors: { + pallets: PalletsTypedef; + apis: IRuntimeCalls; + } & Promise; + metadataTypes: Promise; + asset: IAsset; + extensions: DevnetExtensions; + getMetadata: () => Promise; + genesis: string | undefined; +}; +declare const _allDescriptors: Devnet; +export default _allDescriptors; +export type DevnetApis = ApisFromDef; +export type DevnetQueries = QueryFromPalletsDef; +export type DevnetCalls = TxFromPalletsDef; +export type DevnetEvents = EventsFromPalletsDef; +export type DevnetErrors = ErrorsFromPalletsDef; +export type DevnetConstants = ConstFromPalletsDef; +export type DevnetViewFns = ViewFnsFromPalletsDef; +export type DevnetCallData = Anonymize & { + value: { + type: string; + }; +}; +export type DevnetWhitelistEntry = PalletKey | ApiKey | `query.${NestedKey}` | `tx.${NestedKey}` | `event.${NestedKey}` | `error.${NestedKey}` | `const.${NestedKey}` | `view.${NestedKey}`; +type PalletKey = `*.${keyof (IStorage & ICalls & IEvent & IError & IConstants & IRuntimeCalls & IViewFns)}`; +type NestedKey>> = "*" | { + [P in keyof D & string]: `${P}.*` | { + [N in keyof D[P] & string]: `${P}.${N}`; + }[keyof D[P] & string]; +}[keyof D & string]; +type ApiKey>> = "api.*" | { + [P in keyof D & string]: `api.${P}.*` | { + [N in keyof D[P] & string]: `api.${P}.${N}`; + }[keyof D[P] & string]; +}[keyof D & string]; diff --git a/contract-tests/.papi/descriptors/dist/devnet_metadata-NGDS3DPZ.mjs b/contract-tests/.papi/descriptors/dist/devnet_metadata-NGDS3DPZ.mjs new file mode 100644 index 0000000000..22a3f78b0e --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/devnet_metadata-NGDS3DPZ.mjs @@ -0,0 +1,8 @@ +import "./chunk-7P6ASYW6.mjs"; + +// .papi/descriptors/src/devnet_metadata.ts +var binMeta = "bWV0YRBRCwAMHHNwX2NvcmUYY3J5cHRvLEFjY291bnRJZDMyAAAEAAQBIFt1ODsgMzJdAAAEAAADIAAAAAgACAAABQMADAgwZnJhbWVfc3lzdGVtLEFjY291bnRJbmZvCBROb25jZQEQLEFjY291bnREYXRhARQAFAEUbm9uY2UQARROb25jZQABJGNvbnN1bWVycxABIFJlZkNvdW50AAEkcHJvdmlkZXJzEAEgUmVmQ291bnQAASxzdWZmaWNpZW50cxABIFJlZkNvdW50AAEQZGF0YRQBLEFjY291bnREYXRhAAAQAAAFBQAUDDxwYWxsZXRfYmFsYW5jZXMUdHlwZXMsQWNjb3VudERhdGEEHEJhbGFuY2UBGAAQARBmcmVlGAEcQmFsYW5jZQABIHJlc2VydmVkGAEcQmFsYW5jZQABGGZyb3plbhgBHEJhbGFuY2UAARRmbGFncxwBKEV4dHJhRmxhZ3MAABgAAAUGABwMPHBhbGxldF9iYWxhbmNlcxR0eXBlcyhFeHRyYUZsYWdzAAAEACABEHUxMjgAACAAAAUHACQAAAUAACgMNGZyYW1lX3N1cHBvcnQgZGlzcGF0Y2hAUGVyRGlzcGF0Y2hDbGFzcwQEVAEsAAwBGG5vcm1hbCwBBFQAASxvcGVyYXRpb25hbCwBBFQAASRtYW5kYXRvcnksAQRUAAAsDChzcF93ZWlnaHRzJHdlaWdodF92MhhXZWlnaHQAAAgBIHJlZl90aW1lMAEMdTY0AAEocHJvb2Zfc2l6ZTABDHU2NAAAMAAABhgANAg8cHJpbWl0aXZlX3R5cGVzEEgyNTYAAAQABAEgW3U4OyAzMl0AADgAAAIIADwQKHNwX3J1bnRpbWUcZ2VuZXJpYxhkaWdlc3QYRGlnZXN0AAAEARBsb2dzQAE8VmVjPERpZ2VzdEl0ZW0+AABAAAACRABEEChzcF9ydW50aW1lHGdlbmVyaWMYZGlnZXN0KERpZ2VzdEl0ZW0AARQoUHJlUnVudGltZQgASAFEQ29uc2Vuc3VzRW5naW5lSWQAADgBHFZlYzx1OD4ABgAkQ29uc2Vuc3VzCABIAURDb25zZW5zdXNFbmdpbmVJZAAAOAEcVmVjPHU4PgAEABBTZWFsCABIAURDb25zZW5zdXNFbmdpbmVJZAAAOAEcVmVjPHU4PgAFABRPdGhlcgQAOAEcVmVjPHU4PgAAAGRSdW50aW1lRW52aXJvbm1lbnRVcGRhdGVkAAgAAEgAAAMEAAAACABMAAACUABQCDBmcmFtZV9zeXN0ZW0sRXZlbnRSZWNvcmQIBEUBVARUATQADAEUcGhhc2WlAQEUUGhhc2UAARRldmVudFQBBEUAARh0b3BpY3O4ARhWZWM8VD4AAFQIWG5vZGVfc3VidGVuc29yX3J1bnRpbWUwUnVudGltZUV2ZW50AAFcGFN5c3RlbQQAWAFwZnJhbWVfc3lzdGVtOjpFdmVudDxSdW50aW1lPgAAABxHcmFuZHBhBACAAVRwYWxsZXRfZ3JhbmRwYTo6RXZlbnQABAAgQmFsYW5jZXMEAJABfHBhbGxldF9iYWxhbmNlczo6RXZlbnQ8UnVudGltZT4ABQBIVHJhbnNhY3Rpb25QYXltZW50BACYAahwYWxsZXRfdHJhbnNhY3Rpb25fcGF5bWVudDo6RXZlbnQ8UnVudGltZT4ABgA8U3VidGVuc29yTW9kdWxlBACcAYBwYWxsZXRfc3VidGVuc29yOjpFdmVudDxSdW50aW1lPgAHABxVdGlsaXR5BADgAVRwYWxsZXRfdXRpbGl0eTo6RXZlbnQACwAQU3VkbwQA5AFscGFsbGV0X3N1ZG86OkV2ZW50PFJ1bnRpbWU+AAwAIE11bHRpc2lnBADsAXxwYWxsZXRfbXVsdGlzaWc6OkV2ZW50PFJ1bnRpbWU+AA0AIFByZWltYWdlBAD0AXxwYWxsZXRfcHJlaW1hZ2U6OkV2ZW50PFJ1bnRpbWU+AA4AJFNjaGVkdWxlcgQA+AGAcGFsbGV0X3NjaGVkdWxlcjo6RXZlbnQ8UnVudGltZT4ADwAUUHJveHkEAAUBAXBwYWxsZXRfcHJveHk6OkV2ZW50PFJ1bnRpbWU+ABAAIFJlZ2lzdHJ5BAARAQF8cGFsbGV0X3JlZ2lzdHJ5OjpFdmVudDxSdW50aW1lPgARACxDb21taXRtZW50cwQAFQEBiHBhbGxldF9jb21taXRtZW50czo6RXZlbnQ8UnVudGltZT4AEgAoQWRtaW5VdGlscwQAGQEBiHBhbGxldF9hZG1pbl91dGlsczo6RXZlbnQ8UnVudGltZT4AEwAgU2FmZU1vZGUEACEBAYBwYWxsZXRfc2FmZV9tb2RlOjpFdmVudDxSdW50aW1lPgAUACBFdGhlcmV1bQQAKQEBWHBhbGxldF9ldGhlcmV1bTo6RXZlbnQAFQAMRVZNBABNAQFocGFsbGV0X2V2bTo6RXZlbnQ8UnVudGltZT4AFgAcQmFzZUZlZQQAVQEBWHBhbGxldF9iYXNlX2ZlZTo6RXZlbnQAGQAURHJhbmQEAGUBAXBwYWxsZXRfZHJhbmQ6OkV2ZW50PFJ1bnRpbWU+ABoAJENyb3dkbG9hbgQAbQEBgHBhbGxldF9jcm93ZGxvYW46OkV2ZW50PFJ1bnRpbWU+ABsAEFN3YXAEAHEBAZRwYWxsZXRfc3VidGVuc29yX3N3YXA6OkV2ZW50PFJ1bnRpbWU+ABwAJENvbnRyYWN0cwQAhQEBgHBhbGxldF9jb250cmFjdHM6OkV2ZW50PFJ1bnRpbWU+AB0AJE1ldlNoaWVsZAQAkQEBdHBhbGxldF9zaGllbGQ6OkV2ZW50PFJ1bnRpbWU+AB4AAFgMMGZyYW1lX3N5c3RlbRhwYWxsZXQURXZlbnQEBFQAASBARXh0cmluc2ljU3VjY2VzcwQBNGRpc3BhdGNoX2luZm9cAUREaXNwYXRjaEV2ZW50SW5mbwAABJBBbiBleHRyaW5zaWMgY29tcGxldGVkIHN1Y2Nlc3NmdWxseS48RXh0cmluc2ljRmFpbGVkCAE4ZGlzcGF0Y2hfZXJyb3JoATREaXNwYXRjaEVycm9yAAE0ZGlzcGF0Y2hfaW5mb1wBRERpc3BhdGNoRXZlbnRJbmZvAAEEUEFuIGV4dHJpbnNpYyBmYWlsZWQuLENvZGVVcGRhdGVkAAIEUGA6Y29kZWAgd2FzIHVwZGF0ZWQuKE5ld0FjY291bnQEARxhY2NvdW50AAEwVDo6QWNjb3VudElkAAMEaEEgbmV3IGFjY291bnQgd2FzIGNyZWF0ZWQuNEtpbGxlZEFjY291bnQEARxhY2NvdW50AAEwVDo6QWNjb3VudElkAAQEWEFuIGFjY291bnQgd2FzIHJlYXBlZC4gUmVtYXJrZWQIARhzZW5kZXIAATBUOjpBY2NvdW50SWQAARBoYXNoNAEcVDo6SGFzaAAFBHBPbiBvbi1jaGFpbiByZW1hcmsgaGFwcGVuZWQuRFVwZ3JhZGVBdXRob3JpemVkCAEkY29kZV9oYXNoNAEcVDo6SGFzaAABNGNoZWNrX3ZlcnNpb24kARBib29sAAYEaEFuIHVwZ3JhZGUgd2FzIGF1dGhvcml6ZWQugFJlamVjdGVkSW52YWxpZEF1dGhvcml6ZWRVcGdyYWRlCAEkY29kZV9oYXNoNAEcVDo6SGFzaAABFGVycm9yaAE0RGlzcGF0Y2hFcnJvcgAHBBEBQW4gaW52YWxpZCBhdXRob3JpemVkIHVwZ3JhZGUgd2FzIHJlamVjdGVkIHdoaWxlIHRyeWluZyB0byBhcHBseSBpdC4EcEV2ZW50IGZvciB0aGUgU3lzdGVtIHBhbGxldC5cCDBmcmFtZV9zeXN0ZW1ERGlzcGF0Y2hFdmVudEluZm8AAAwBGHdlaWdodCwBGFdlaWdodAABFGNsYXNzYAE0RGlzcGF0Y2hDbGFzcwABIHBheXNfZmVlZAEQUGF5cwAAYAw0ZnJhbWVfc3VwcG9ydCBkaXNwYXRjaDREaXNwYXRjaENsYXNzAAEMGE5vcm1hbAAAACxPcGVyYXRpb25hbAABACRNYW5kYXRvcnkAAgAAZAw0ZnJhbWVfc3VwcG9ydCBkaXNwYXRjaBBQYXlzAAEIDFllcwAAAAhObwABAABoCChzcF9ydW50aW1lNERpc3BhdGNoRXJyb3IAATwUT3RoZXIAAAAwQ2Fubm90TG9va3VwAAEAJEJhZE9yaWdpbgACABhNb2R1bGUEAGwBLE1vZHVsZUVycm9yAAMARENvbnN1bWVyUmVtYWluaW5nAAQALE5vUHJvdmlkZXJzAAUAQFRvb01hbnlDb25zdW1lcnMABgAUVG9rZW4EAHABKFRva2VuRXJyb3IABwAoQXJpdGhtZXRpYwQAdAE8QXJpdGhtZXRpY0Vycm9yAAgANFRyYW5zYWN0aW9uYWwEAHgBSFRyYW5zYWN0aW9uYWxFcnJvcgAJACRFeGhhdXN0ZWQACgAoQ29ycnVwdGlvbgALACxVbmF2YWlsYWJsZQAMADhSb290Tm90QWxsb3dlZAANABBUcmllBAB8ASRUcmllRXJyb3IADgAAbAgoc3BfcnVudGltZSxNb2R1bGVFcnJvcgAACAEUaW5kZXgIAQh1OAABFGVycm9ySAGMW3U4OyBNQVhfTU9EVUxFX0VSUk9SX0VOQ09ERURfU0laRV0AAHAIKHNwX3J1bnRpbWUoVG9rZW5FcnJvcgABKEBGdW5kc1VuYXZhaWxhYmxlAAAAME9ubHlQcm92aWRlcgABADBCZWxvd01pbmltdW0AAgAwQ2Fubm90Q3JlYXRlAAMAMFVua25vd25Bc3NldAAEABhGcm96ZW4ABQAsVW5zdXBwb3J0ZWQABgBAQ2Fubm90Q3JlYXRlSG9sZAAHADROb3RFeHBlbmRhYmxlAAgAHEJsb2NrZWQACQAAdAg0c3BfYXJpdGhtZXRpYzxBcml0aG1ldGljRXJyb3IAAQwkVW5kZXJmbG93AAAAIE92ZXJmbG93AAEAOERpdmlzaW9uQnlaZXJvAAIAAHgIKHNwX3J1bnRpbWVIVHJhbnNhY3Rpb25hbEVycm9yAAEIMExpbWl0UmVhY2hlZAAAABxOb0xheWVyAAEAAHwMKHNwX3J1bnRpbWUwcHJvdmluZ190cmllJFRyaWVFcnJvcgABOEBJbnZhbGlkU3RhdGVSb290AAAASEluY29tcGxldGVEYXRhYmFzZQABAFBWYWx1ZUF0SW5jb21wbGV0ZUtleQACADBEZWNvZGVyRXJyb3IAAwAsSW52YWxpZEhhc2gABAAwRHVwbGljYXRlS2V5AAUAOEV4dHJhbmVvdXNOb2RlAAYAPEV4dHJhbmVvdXNWYWx1ZQAHAFxFeHRyYW5lb3VzSGFzaFJlZmVyZW5jZQAIAFRJbnZhbGlkQ2hpbGRSZWZlcmVuY2UACQA0VmFsdWVNaXNtYXRjaAAKADxJbmNvbXBsZXRlUHJvb2YACwAwUm9vdE1pc21hdGNoAAwALERlY29kZUVycm9yAA0AAIAMOHBhbGxldF9ncmFuZHBhGHBhbGxldBRFdmVudAABDDhOZXdBdXRob3JpdGllcwQBNGF1dGhvcml0eV9zZXSEATRBdXRob3JpdHlMaXN0AAAEjE5ldyBhdXRob3JpdHkgc2V0IGhhcyBiZWVuIGFwcGxpZWQuGFBhdXNlZAABBJhDdXJyZW50IGF1dGhvcml0eSBzZXQgaGFzIGJlZW4gcGF1c2VkLhxSZXN1bWVkAAIEnEN1cnJlbnQgYXV0aG9yaXR5IHNldCBoYXMgYmVlbiByZXN1bWVkLgR8VGhlIGBFdmVudGAgZW51bSBvZiB0aGlzIHBhbGxldIQAAAKIAIgAAAQIjBgAjAxQc3BfY29uc2Vuc3VzX2dyYW5kcGEMYXBwGFB1YmxpYwAABAAEATxlZDI1NTE5OjpQdWJsaWMAAJAMPHBhbGxldF9iYWxhbmNlcxhwYWxsZXQURXZlbnQIBFQABEkAAVgcRW5kb3dlZAgBHGFjY291bnQAATBUOjpBY2NvdW50SWQAATBmcmVlX2JhbGFuY2UYAShUOjpCYWxhbmNlAAAEuEFuIGFjY291bnQgd2FzIGNyZWF0ZWQgd2l0aCBzb21lIGZyZWUgYmFsYW5jZS4gRHVzdExvc3QIARxhY2NvdW50AAEwVDo6QWNjb3VudElkAAEYYW1vdW50GAEoVDo6QmFsYW5jZQABCD0BQW4gYWNjb3VudCB3YXMgcmVtb3ZlZCB3aG9zZSBiYWxhbmNlIHdhcyBub24temVybyBidXQgYmVsb3cgRXhpc3RlbnRpYWxEZXBvc2l0LHhyZXN1bHRpbmcgaW4gYW4gb3V0cmlnaHQgbG9zcy4gVHJhbnNmZXIMARBmcm9tAAEwVDo6QWNjb3VudElkAAEIdG8AATBUOjpBY2NvdW50SWQAARhhbW91bnQYAShUOjpCYWxhbmNlAAIETFRyYW5zZmVyIHN1Y2NlZWRlZC4oQmFsYW5jZVNldAgBDHdobwABMFQ6OkFjY291bnRJZAABEGZyZWUYAShUOjpCYWxhbmNlAAMEaEEgYmFsYW5jZSB3YXMgc2V0IGJ5IHJvb3QuIFJlc2VydmVkCAEMd2hvAAEwVDo6QWNjb3VudElkAAEYYW1vdW50GAEoVDo6QmFsYW5jZQAEBOBTb21lIGJhbGFuY2Ugd2FzIHJlc2VydmVkIChtb3ZlZCBmcm9tIGZyZWUgdG8gcmVzZXJ2ZWQpLihVbnJlc2VydmVkCAEMd2hvAAEwVDo6QWNjb3VudElkAAEYYW1vdW50GAEoVDo6QmFsYW5jZQAFBOhTb21lIGJhbGFuY2Ugd2FzIHVucmVzZXJ2ZWQgKG1vdmVkIGZyb20gcmVzZXJ2ZWQgdG8gZnJlZSkuSFJlc2VydmVSZXBhdHJpYXRlZBABEGZyb20AATBUOjpBY2NvdW50SWQAAQh0bwABMFQ6OkFjY291bnRJZAABGGFtb3VudBgBKFQ6OkJhbGFuY2UAAUhkZXN0aW5hdGlvbl9zdGF0dXOUARhTdGF0dXMABghNAVNvbWUgYmFsYW5jZSB3YXMgbW92ZWQgZnJvbSB0aGUgcmVzZXJ2ZSBvZiB0aGUgZmlyc3QgYWNjb3VudCB0byB0aGUgc2Vjb25kIGFjY291bnQu2EZpbmFsIGFyZ3VtZW50IGluZGljYXRlcyB0aGUgZGVzdGluYXRpb24gYmFsYW5jZSB0eXBlLhxEZXBvc2l0CAEMd2hvAAEwVDo6QWNjb3VudElkAAEYYW1vdW50GAEoVDo6QmFsYW5jZQAHBNhTb21lIGFtb3VudCB3YXMgZGVwb3NpdGVkIChlLmcuIGZvciB0cmFuc2FjdGlvbiBmZWVzKS4gV2l0aGRyYXcIAQx3aG8AATBUOjpBY2NvdW50SWQAARhhbW91bnQYAShUOjpCYWxhbmNlAAgEHQFTb21lIGFtb3VudCB3YXMgd2l0aGRyYXduIGZyb20gdGhlIGFjY291bnQgKGUuZy4gZm9yIHRyYW5zYWN0aW9uIGZlZXMpLhxTbGFzaGVkCAEMd2hvAAEwVDo6QWNjb3VudElkAAEYYW1vdW50GAEoVDo6QmFsYW5jZQAJBAEBU29tZSBhbW91bnQgd2FzIHJlbW92ZWQgZnJvbSB0aGUgYWNjb3VudCAoZS5nLiBmb3IgbWlzYmVoYXZpb3IpLhhNaW50ZWQIAQx3aG8AATBUOjpBY2NvdW50SWQAARhhbW91bnQYAShUOjpCYWxhbmNlAAoEnFNvbWUgYW1vdW50IHdhcyBtaW50ZWQgaW50byBhbiBhY2NvdW50LhhCdXJuZWQIAQx3aG8AATBUOjpBY2NvdW50SWQAARhhbW91bnQYAShUOjpCYWxhbmNlAAsEnFNvbWUgYW1vdW50IHdhcyBidXJuZWQgZnJvbSBhbiBhY2NvdW50LiRTdXNwZW5kZWQIAQx3aG8AATBUOjpBY2NvdW50SWQAARhhbW91bnQYAShUOjpCYWxhbmNlAAwEFQFTb21lIGFtb3VudCB3YXMgc3VzcGVuZGVkIGZyb20gYW4gYWNjb3VudCAoaXQgY2FuIGJlIHJlc3RvcmVkIGxhdGVyKS4gUmVzdG9yZWQIAQx3aG8AATBUOjpBY2NvdW50SWQAARhhbW91bnQYAShUOjpCYWxhbmNlAA0EpFNvbWUgYW1vdW50IHdhcyByZXN0b3JlZCBpbnRvIGFuIGFjY291bnQuIFVwZ3JhZGVkBAEMd2hvAAEwVDo6QWNjb3VudElkAA4EYEFuIGFjY291bnQgd2FzIHVwZ3JhZGVkLhhJc3N1ZWQEARhhbW91bnQYAShUOjpCYWxhbmNlAA8ELQFUb3RhbCBpc3N1YW5jZSB3YXMgaW5jcmVhc2VkIGJ5IGBhbW91bnRgLCBjcmVhdGluZyBhIGNyZWRpdCB0byBiZSBiYWxhbmNlZC4kUmVzY2luZGVkBAEYYW1vdW50GAEoVDo6QmFsYW5jZQAQBCUBVG90YWwgaXNzdWFuY2Ugd2FzIGRlY3JlYXNlZCBieSBgYW1vdW50YCwgY3JlYXRpbmcgYSBkZWJ0IHRvIGJlIGJhbGFuY2VkLhhMb2NrZWQIAQx3aG8AATBUOjpBY2NvdW50SWQAARhhbW91bnQYAShUOjpCYWxhbmNlABEEYFNvbWUgYmFsYW5jZSB3YXMgbG9ja2VkLiBVbmxvY2tlZAgBDHdobwABMFQ6OkFjY291bnRJZAABGGFtb3VudBgBKFQ6OkJhbGFuY2UAEgRoU29tZSBiYWxhbmNlIHdhcyB1bmxvY2tlZC4YRnJvemVuCAEMd2hvAAEwVDo6QWNjb3VudElkAAEYYW1vdW50GAEoVDo6QmFsYW5jZQATBGBTb21lIGJhbGFuY2Ugd2FzIGZyb3plbi4YVGhhd2VkCAEMd2hvAAEwVDo6QWNjb3VudElkAAEYYW1vdW50GAEoVDo6QmFsYW5jZQAUBGBTb21lIGJhbGFuY2Ugd2FzIHRoYXdlZC5MVG90YWxJc3N1YW5jZUZvcmNlZAgBDG9sZBgBKFQ6OkJhbGFuY2UAAQxuZXcYAShUOjpCYWxhbmNlABUErFRoZSBgVG90YWxJc3N1YW5jZWAgd2FzIGZvcmNlZnVsbHkgY2hhbmdlZC4EfFRoZSBgRXZlbnRgIGVudW0gb2YgdGhpcyBwYWxsZXSUFDRmcmFtZV9zdXBwb3J0GHRyYWl0cxh0b2tlbnMQbWlzYzRCYWxhbmNlU3RhdHVzAAEIEEZyZWUAAAAgUmVzZXJ2ZWQAAQAAmAxocGFsbGV0X3RyYW5zYWN0aW9uX3BheW1lbnQYcGFsbGV0FEV2ZW50BARUAAEESFRyYW5zYWN0aW9uRmVlUGFpZAwBDHdobwABMFQ6OkFjY291bnRJZAABKGFjdHVhbF9mZWUYATBCYWxhbmNlT2Y8VD4AAQx0aXAYATBCYWxhbmNlT2Y8VD4AAAhZAUEgdHJhbnNhY3Rpb24gZmVlIGBhY3R1YWxfZmVlYCwgb2Ygd2hpY2ggYHRpcGAgd2FzIGFkZGVkIHRvIHRoZSBtaW5pbXVtIGluY2x1c2lvbiBmZWUsXGhhcyBiZWVuIHBhaWQgYnkgYHdob2AuBHxUaGUgYEV2ZW50YCBlbnVtIG9mIHRoaXMgcGFsbGV0nAxAcGFsbGV0X3N1YnRlbnNvchhwYWxsZXQURXZlbnQEBFQAAeEBME5ldHdvcmtBZGRlZAgAoAEYTmV0VWlkAACgAQx1MTYAAARcYSBuZXcgbmV0d29yayBpcyBhZGRlZC44TmV0d29ya1JlbW92ZWQEAKABGE5ldFVpZAABBFRhIG5ldHdvcmsgaXMgcmVtb3ZlZC4oU3Rha2VBZGRlZBgAAAEwVDo6QWNjb3VudElkAAAAATBUOjpBY2NvdW50SWQAABgBKFRhb0JhbGFuY2UAABgBMEFscGhhQmFsYW5jZQAAoAEYTmV0VWlkAAAYAQx1NjQAAgRZAXN0YWtlIGhhcyBiZWVuIHRyYW5zZmVycmVkIGZyb20gdGhlIGEgY29sZGtleSBhY2NvdW50IG9udG8gdGhlIGhvdGtleSBzdGFraW5nIGFjY291bnQuMFN0YWtlUmVtb3ZlZBgAAAEwVDo6QWNjb3VudElkAAAAATBUOjpBY2NvdW50SWQAABgBKFRhb0JhbGFuY2UAABgBMEFscGhhQmFsYW5jZQAAoAEYTmV0VWlkAAAYAQx1NjQAAwRBAXN0YWtlIGhhcyBiZWVuIHJlbW92ZWQgZnJvbSB0aGUgaG90a2V5IHN0YWtpbmcgYWNjb3VudCBvbnRvIHRoZSBjb2xka2V5IGFjY291bnQuKFN0YWtlTW92ZWQYAAABMFQ6OkFjY291bnRJZAAAAAEwVDo6QWNjb3VudElkAACgARhOZXRVaWQAAAABMFQ6OkFjY291bnRJZAAAoAEYTmV0VWlkAAAYAShUYW9CYWxhbmNlAAQEwQFzdGFrZSBoYXMgYmVlbiBtb3ZlZCBmcm9tIG9yaWdpbiAoaG90a2V5LCBzdWJuZXQgSUQpIHRvIGRlc3RpbmF0aW9uIChob3RrZXksIHN1Ym5ldCBJRCkgb2YgdGhpcyBhbW91bnQgKGluIFRBTykuKFdlaWdodHNTZXQIAKABSE5ldFVpZFN0b3JhZ2VJbmRleAAAoAEMdTE2AAUE5GEgY2FsbGVyIHN1Y2Nlc3NmdWxseSBzZXRzIHRoZWlyIHdlaWdodHMgb24gYSBzdWJuZXR3b3JrLkBOZXVyb25SZWdpc3RlcmVkDACgARhOZXRVaWQAAKABDHUxNgAAAAEwVDo6QWNjb3VudElkAAYE2GEgbmV3IG5ldXJvbiBhY2NvdW50IGhhcyBiZWVuIHJlZ2lzdGVyZWQgdG8gdGhlIGNoYWluLlRCdWxrTmV1cm9uc1JlZ2lzdGVyZWQIAKABDHUxNgAAoAEMdTE2AAcEwG11bHRpcGxlIHVpZHMgaGF2ZSBiZWVuIGNvbmN1cnJlbnRseSByZWdpc3RlcmVkLjxCdWxrQmFsYW5jZXNTZXQIAKABDHUxNgAAoAEMdTE2AAgETEZJWE1FOiBOb3QgdXNlZCB5ZXRETWF4QWxsb3dlZFVpZHNTZXQIAKABGE5ldFVpZAAAoAEMdTE2AAkEvG1heCBhbGxvd2VkIHVpZHMgaGFzIGJlZW4gc2V0IGZvciBhIHN1Ym5ldHdvcmsuRE1heFdlaWdodExpbWl0U2V0CACgARhOZXRVaWQAAKABDHUxNgAKBPRERVBSRUNBVEVEOiBtYXggd2VpZ2h0IGxpbWl0IHVwZGF0ZXMgYXJlIG5vIGxvbmdlciBzdXBwb3J0ZWQuNERpZmZpY3VsdHlTZXQIAKABGE5ldFVpZAAAGAEMdTY0AAsEpHRoZSBkaWZmaWN1bHR5IGhhcyBiZWVuIHNldCBmb3IgYSBzdWJuZXQuVEFkanVzdG1lbnRJbnRlcnZhbFNldAgAoAEYTmV0VWlkAACgAQx1MTYADASwdGhlIGFkanVzdG1lbnQgaW50ZXJ2YWwgaXMgc2V0IGZvciBhIHN1Ym5ldC5oUmVnaXN0cmF0aW9uUGVySW50ZXJ2YWxTZXQIAKABGE5ldFVpZAAAoAEMdTE2AA0EuHJlZ2lzdHJhdGlvbiBwZXIgaW50ZXJ2YWwgaXMgc2V0IGZvciBhIHN1Ym5ldC5sTWF4UmVnaXN0cmF0aW9uc1BlckJsb2NrU2V0CACgARhOZXRVaWQAAKABDHUxNgAOBIx3ZSBzZXQgbWF4IHJlZ2lzdHJhdGlvbnMgcGVyIGJsb2NrLkRBY3Rpdml0eUN1dG9mZlNldAgAoAEYTmV0VWlkAACgAQx1MTYADwScYW4gYWN0aXZpdHkgY3V0b2ZmIGlzIHNldCBmb3IgYSBzdWJuZXQuGFJob1NldAgAoAEYTmV0VWlkAACgAQx1MTYAEAREUmhvIHZhbHVlIGlzIHNldC5gQWxwaGFTaWdtb2lkU3RlZXBuZXNzU2V0CACgARhOZXRVaWQAAKQBDGkxNgARBNhzdGVlcG5lc3Mgb2YgdGhlIHNpZ21vaWQgdXNlZCB0byBjb21wdXRlIGFscGhhIHZhbHVlcy4gS2FwcGFTZXQIAKABGE5ldFVpZAAAoAEMdTE2ABIEaEthcHBhIGlzIHNldCBmb3IgYSBzdWJuZXQuTE1pbkFsbG93ZWRXZWlnaHRTZXQIAKABGE5ldFVpZAAAoAEMdTE2ABMErG1pbmltdW0gYWxsb3dlZCB3ZWlnaHQgaXMgc2V0IGZvciBhIHN1Ym5ldC5QVmFsaWRhdG9yUHJ1bmVMZW5TZXQIAKABGE5ldFVpZAAAGAEMdTY0ABQEqHRoZSB2YWxpZGF0b3IgcHJ1bmluZyBsZW5ndGggaGFzIGJlZW4gc2V0LkhTY2FsaW5nTGF3UG93ZXJTZXQIAKABGE5ldFVpZAAAoAEMdTE2ABUEwHRoZSBzY2FsaW5nIGxhdyBwb3dlciBoYXMgYmVlbiBzZXQgZm9yIGEgc3VibmV0LlhXZWlnaHRzU2V0UmF0ZUxpbWl0U2V0CACgARhOZXRVaWQAABgBDHU2NAAWBMR3ZWlnaHRzIHNldCByYXRlIGxpbWl0IGhhcyBiZWVuIHNldCBmb3IgYSBzdWJuZXQuREltbXVuaXR5UGVyaW9kU2V0CACgARhOZXRVaWQAAKABDHUxNgAXBJBpbW11bml0eSBwZXJpb2QgaXMgc2V0IGZvciBhIHN1Ym5ldC5UQm9uZHNNb3ZpbmdBdmVyYWdlU2V0CACgARhOZXRVaWQAABgBDHU2NAAYBKRib25kcyBtb3ZpbmcgYXZlcmFnZSBpcyBzZXQgZm9yIGEgc3VibmV0LjxCb25kc1BlbmFsdHlTZXQIAKABGE5ldFVpZAAAoAEMdTE2ABkEiGJvbmRzIHBlbmFsdHkgaXMgc2V0IGZvciBhIHN1Ym5ldC48Qm9uZHNSZXNldE9uU2V0CACgARhOZXRVaWQAACQBEGJvb2wAGgSAYm9uZHMgcmVzZXQgaXMgc2V0IGZvciBhIHN1Ym5ldC5cTWF4QWxsb3dlZFZhbGlkYXRvcnNTZXQIAKABGE5ldFVpZAAAoAEMdTE2ABsE5HNldHRpbmcgdGhlIG1heCBudW1iZXIgb2YgYWxsb3dlZCB2YWxpZGF0b3JzIG9uIGEgc3VibmV0LihBeG9uU2VydmVkCACgARhOZXRVaWQAAAABMFQ6OkFjY291bnRJZAAcBNB0aGUgYXhvbiBzZXJ2ZXIgaW5mb3JtYXRpb24gaXMgYWRkZWQgdG8gdGhlIG5ldHdvcmsuQFByb21ldGhldXNTZXJ2ZWQIAKABGE5ldFVpZAAAAAEwVDo6QWNjb3VudElkAB0E6HRoZSBwcm9tZXRoZXVzIHNlcnZlciBpbmZvcm1hdGlvbiBpcyBhZGRlZCB0byB0aGUgbmV0d29yay40RGVsZWdhdGVBZGRlZAwAAAEwVDo6QWNjb3VudElkAAAAATBUOjpBY2NvdW50SWQAAKABDHUxNgAeBHxhIGhvdGtleSBoYXMgYmVjb21lIGEgZGVsZWdhdGUuOERlZmF1bHRUYWtlU2V0BACgAQx1MTYAHwRgdGhlIGRlZmF1bHQgdGFrZSBpcyBzZXQuUFdlaWdodHNWZXJzaW9uS2V5U2V0CACgARhOZXRVaWQAABgBDHU2NAAgBKR3ZWlnaHRzIHZlcnNpb24ga2V5IGlzIHNldCBmb3IgYSBuZXR3b3JrLkBNaW5EaWZmaWN1bHR5U2V0CACgARhOZXRVaWQAABgBDHU2NAAhBJBzZXR0aW5nIG1pbiBkaWZmaWN1bHR5IG9uIGEgbmV0d29yay5ATWF4RGlmZmljdWx0eVNldAgAoAEYTmV0VWlkAAAYAQx1NjQAIgSQc2V0dGluZyBtYXggZGlmZmljdWx0eSBvbiBhIG5ldHdvcmsuTFNlcnZpbmdSYXRlTGltaXRTZXQIAKABGE5ldFVpZAAAGAEMdTY0ACMEqHNldHRpbmcgdGhlIHByb21ldGhldXMgc2VydmluZyByYXRlIGxpbWl0LhxCdXJuU2V0CACgARhOZXRVaWQAABgBKFRhb0JhbGFuY2UAJARoc2V0dGluZyBidXJuIG9uIGEgbmV0d29yay4oTWF4QnVyblNldAgAoAEYTmV0VWlkAAAYAShUYW9CYWxhbmNlACUEeHNldHRpbmcgbWF4IGJ1cm4gb24gYSBuZXR3b3JrLihNaW5CdXJuU2V0CACgARhOZXRVaWQAABgBKFRhb0JhbGFuY2UAJgR4c2V0dGluZyBtaW4gYnVybiBvbiBhIG5ldHdvcmsuOFR4UmF0ZUxpbWl0U2V0BAAYAQx1NjQAJwSMc2V0dGluZyB0aGUgdHJhbnNhY3Rpb24gcmF0ZSBsaW1pdC5oVHhEZWxlZ2F0ZVRha2VSYXRlTGltaXRTZXQEABgBDHU2NAAoBMRzZXR0aW5nIHRoZSBkZWxlZ2F0ZSB0YWtlIHRyYW5zYWN0aW9uIHJhdGUgbGltaXQuaFR4Q2hpbGRLZXlUYWtlUmF0ZUxpbWl0U2V0BAAYAQx1NjQAKQTEc2V0dGluZyB0aGUgY2hpbGRrZXkgdGFrZSB0cmFuc2FjdGlvbiByYXRlIGxpbWl0LlBBZG1pbkZyZWV6ZVdpbmRvd1NldAQAoAEMdTE2ACoE/HNldHRpbmcgdGhlIGFkbWluIGZyZWV6ZSB3aW5kb3cgbGVuZ3RoIChsYXN0IE4gYmxvY2tzIG9mIHRlbXBvKWxPd25lckh5cGVycGFyYW1SYXRlTGltaXRTZXQEAKABDHUxNgArBNRzZXR0aW5nIHRoZSBvd25lciBoeXBlcnBhcmFtZXRlciByYXRlIGxpbWl0IGluIGVwb2Noc0hNaW5DaGlsZEtleVRha2VTZXQEAKABDHUxNgAsBGRtaW5pbXVtIGNoaWxka2V5IHRha2Ugc2V0SE1heENoaWxkS2V5VGFrZVNldAQAoAEMdTE2AC0EZG1heGltdW0gY2hpbGRrZXkgdGFrZSBzZXQ8Q2hpbGRLZXlUYWtlU2V0CAAAATBUOjpBY2NvdW50SWQAAKABDHUxNgAuBERjaGlsZGtleSB0YWtlIHNldBRTdWRpZAQAqAE4RGlzcGF0Y2hSZXN1bHQALwRQYSBzdWRvIGNhbGwgaXMgZG9uZS5MUmVnaXN0cmF0aW9uQWxsb3dlZAgAoAEYTmV0VWlkAAAkARBib29sADAEwHJlZ2lzdHJhdGlvbiBpcyBhbGxvd2VkL2Rpc2FsbG93ZWQgZm9yIGEgc3VibmV0LlhQb3dSZWdpc3RyYXRpb25BbGxvd2VkCACgARhOZXRVaWQAACQBEGJvb2wAMQTQUE9XIHJlZ2lzdHJhdGlvbiBpcyBhbGxvd2VkL2Rpc2FsbG93ZWQgZm9yIGEgc3VibmV0LiBUZW1wb1NldAgAoAEYTmV0VWlkAACgAQx1MTYAMgRoc2V0dGluZyB0ZW1wbyBvbiBhIG5ldHdvcmt0UkFPUmVjeWNsZWRGb3JSZWdpc3RyYXRpb25TZXQIAKABGE5ldFVpZAAAGAEoVGFvQmFsYW5jZQAzBKhzZXR0aW5nIHRoZSBSQU8gcmVjeWNsZWQgZm9yIHJlZ2lzdHJhdGlvbi5EU3Rha2VUaHJlc2hvbGRTZXQEABgBDHU2NAA0BLxtaW4gc3Rha2UgaXMgc2V0IGZvciB2YWxpZGF0b3JzIHRvIHNldCB3ZWlnaHRzLkhBZGp1c3RtZW50QWxwaGFTZXQIAKABGE5ldFVpZAAAGAEMdTY0ADUEpHNldHRpbmcgdGhlIGFkanVzdG1lbnQgYWxwaGEgb24gYSBzdWJuZXQuGEZhdWNldAgAAAEwVDo6QWNjb3VudElkAAAYAQx1NjQANgSUdGhlIGZhdWNldCBpdCBjYWxsZWQgb24gdGhlIHRlc3QgbmV0LkRTdWJuZXRPd25lckN1dFNldAQAoAEMdTE2ADcEcHRoZSBzdWJuZXQgb3duZXIgY3V0IGlzIHNldC5MTmV0d29ya1JhdGVMaW1pdFNldAQAGAEMdTY0ADgEnHRoZSBuZXR3b3JrIGNyZWF0aW9uIHJhdGUgbGltaXQgaXMgc2V0LmBOZXR3b3JrSW1tdW5pdHlQZXJpb2RTZXQEABgBDHU2NAA5BIx0aGUgbmV0d29yayBpbW11bml0eSBwZXJpb2QgaXMgc2V0LkRTdGFydENhbGxEZWxheVNldAQAGAEMdTY0ADoEcHRoZSBzdGFydCBjYWxsIGRlbGF5IGlzIHNldC5UTmV0d29ya01pbkxvY2tDb3N0U2V0BAAYAShUYW9CYWxhbmNlADsEoHRoZSBuZXR3b3JrIG1pbmltdW0gbG9ja2luZyBjb3N0IGlzIHNldC44U3VibmV0TGltaXRTZXQEAKABDHUxNgA8BJB0aGUgbWF4aW11bSBudW1iZXIgb2Ygc3VibmV0cyBpcyBzZXSMTmV0d29ya0xvY2tDb3N0UmVkdWN0aW9uSW50ZXJ2YWxTZXQEABgBDHU2NAA9BHh0aGUgbG9jayBjb3N0IHJlZHVjdGlvbiBpcyBzZXQ0VGFrZURlY3JlYXNlZAwAAAEwVDo6QWNjb3VudElkAAAAATBUOjpBY2NvdW50SWQAAKABDHUxNgA+BJR0aGUgdGFrZSBmb3IgYSBkZWxlZ2F0ZSBpcyBkZWNyZWFzZWQuNFRha2VJbmNyZWFzZWQMAAABMFQ6OkFjY291bnRJZAAAAAEwVDo6QWNjb3VudElkAACgAQx1MTYAPwSUdGhlIHRha2UgZm9yIGEgZGVsZWdhdGUgaXMgaW5jcmVhc2VkLjRIb3RrZXlTd2FwcGVkDAEcY29sZGtleQABMFQ6OkFjY291bnRJZARkdGhlIGFjY291bnQgSUQgb2YgY29sZGtleQEob2xkX2hvdGtleQABMFQ6OkFjY291bnRJZARwdGhlIGFjY291bnQgSUQgb2Ygb2xkIGhvdGtleQEobmV3X2hvdGtleQABMFQ6OkFjY291bnRJZARwdGhlIGFjY291bnQgSUQgb2YgbmV3IGhvdGtleUAEVHRoZSBob3RrZXkgaXMgc3dhcHBlZEhNYXhEZWxlZ2F0ZVRha2VTZXQEAKABDHUxNgBBBNhtYXhpbXVtIGRlbGVnYXRlIHRha2UgaXMgc2V0IGJ5IHN1ZG8vYWRtaW4gdHJhbnNhY3Rpb25ITWluRGVsZWdhdGVUYWtlU2V0BACgAQx1MTYAQgTYbWluaW11bSBkZWxlZ2F0ZSB0YWtlIGlzIHNldCBieSBzdWRvL2FkbWluIHRyYW5zYWN0aW9uUENvbGRrZXlTd2FwQW5ub3VuY2VkCAEMd2hvAAEwVDo6QWNjb3VudElkBORUaGUgYWNjb3VudCBJRCBvZiB0aGUgY29sZGtleSB0aGF0IG1hZGUgdGhlIGFubm91bmNlbWVudC4BQG5ld19jb2xka2V5X2hhc2g0ARxUOjpIYXNoBHBUaGUgaGFzaCBvZiB0aGUgbmV3IGNvbGRrZXkuQwSoQSBjb2xka2V5IHN3YXAgYW5ub3VuY2VtZW50IGhhcyBiZWVuIG1hZGUuQENvbGRrZXlTd2FwUmVzZXQEAQx3aG8AATBUOjpBY2NvdW50SWQEAQFUaGUgYWNjb3VudCBJRCBvZiB0aGUgY29sZGtleSBmb3Igd2hpY2ggdGhlIHN3YXAgaGFzIGJlZW4gcmVzZXQuRAR4QSBjb2xka2V5IHN3YXAgaGFzIGJlZW4gcmVzZXQuOENvbGRrZXlTd2FwcGVkCAEsb2xkX2NvbGRrZXkAATBUOjpBY2NvdW50SWQEeFRoZSBhY2NvdW50IElEIG9mIG9sZCBjb2xka2V5LgEsbmV3X2NvbGRrZXkAATBUOjpBY2NvdW50SWQEeFRoZSBhY2NvdW50IElEIG9mIG5ldyBjb2xka2V5LkUEbEEgY29sZGtleSBoYXMgYmVlbiBzd2FwcGVkLkxDb2xka2V5U3dhcERpc3B1dGVkBAEcY29sZGtleQABMFQ6OkFjY291bnRJZATAVGhlIGFjY291bnQgSUQgb2YgdGhlIGNvbGRrZXkgdGhhdCB3YXMgZGlzcHV0ZWQuRgSEQSBjb2xka2V5IHN3YXAgaGFzIGJlZW4gZGlzcHV0ZWQusEFsbEJhbGFuY2VVbnN0YWtlZEFuZFRyYW5zZmVycmVkVG9OZXdDb2xka2V5DAE8Y3VycmVudF9jb2xka2V5AAEwVDo6QWNjb3VudElkBJRUaGUgYWNjb3VudCBJRCBvZiB0aGUgY3VycmVudCBjb2xka2V5ASxuZXdfY29sZGtleQABMFQ6OkFjY291bnRJZASEVGhlIGFjY291bnQgSUQgb2YgdGhlIG5ldyBjb2xka2V5ATR0b3RhbF9iYWxhbmNlGAGFATw8VCBhcyBDb25maWc+OjpDdXJyZW5jeSBhcyBmdW5naWJsZTo6SW5zcGVjdDw8VCBhcyBmcmFtZV9zeXN0ZW06OgpDb25maWc+OjpBY2NvdW50SWQsPj46OkJhbGFuY2UEfFRoZSB0b3RhbCBiYWxhbmNlIG9mIHRoZSBob3RrZXlHBCkBQWxsIGJhbGFuY2Ugb2YgYSBob3RrZXkgaGFzIGJlZW4gdW5zdGFrZWQgYW5kIHRyYW5zZmVycmVkIHRvIGEgbmV3IGNvbGRrZXlkQXJiaXRyYXRpb25QZXJpb2RFeHRlbmRlZAQBHGNvbGRrZXkAATBUOjpBY2NvdW50SWQEdFRoZSBhY2NvdW50IElEIG9mIHRoZSBjb2xka2V5SASgVGhlIGFyYml0cmF0aW9uIHBlcmlvZCBoYXMgYmVlbiBleHRlbmRlZFBTZXRDaGlsZHJlblNjaGVkdWxlZBAAAAEwVDo6QWNjb3VudElkAACgARhOZXRVaWQAABgBDHU2NAAAsAFgVmVjPCh1NjQsIFQ6OkFjY291bnRJZCk+AEkEzFNldHRpbmcgb2YgY2hpbGRyZW4gb2YgYSBob3RrZXkgaGF2ZSBiZWVuIHNjaGVkdWxlZCxTZXRDaGlsZHJlbgwAAAEwVDo6QWNjb3VudElkAACgARhOZXRVaWQAALABYFZlYzwodTY0LCBUOjpBY2NvdW50SWQpPgBKBJhUaGUgY2hpbGRyZW4gb2YgYSBob3RrZXkgaGF2ZSBiZWVuIHNldEBDaGFpbklkZW50aXR5U2V0BAAAATBUOjpBY2NvdW50SWQASwSYVGhlIGlkZW50aXR5IG9mIGEgY29sZGtleSBoYXMgYmVlbiBzZXREU3VibmV0SWRlbnRpdHlTZXQEAKABGE5ldFVpZABMBJRUaGUgaWRlbnRpdHkgb2YgYSBzdWJuZXQgaGFzIGJlZW4gc2V0VFN1Ym5ldElkZW50aXR5UmVtb3ZlZAQAoAEYTmV0VWlkAE0EpFRoZSBpZGVudGl0eSBvZiBhIHN1Ym5ldCBoYXMgYmVlbiByZW1vdmVkYERpc3NvbHZlTmV0d29ya1NjaGVkdWxlZAwBHGFjY291bnQAATBUOjpBY2NvdW50SWQE2FRoZSBhY2NvdW50IElEIHNjaGVkdWxlIHRoZSBkaXNzb2x2ZSBuZXR3b3JrIGV4dHJpbnNpYwEYbmV0dWlkoAEYTmV0VWlkBHBuZXR3b3JrIElEIHdpbGwgYmUgZGlzc29sdmVkATxleGVjdXRpb25fYmxvY2sQAURCbG9ja051bWJlckZvcjxUPgSAZXh0cmluc2ljIGV4ZWN1dGlvbiBibG9jayBudW1iZXJOBJxBIGRpc3NvbHZlIG5ldHdvcmsgZXh0cmluc2ljIHNjaGVkdWxlZC58Q29sZGtleVN3YXBBbm5vdW5jZW1lbnREZWxheVNldAQAEAFEQmxvY2tOdW1iZXJGb3I8VD4ATwTEVGhlIGNvbGRrZXkgc3dhcCBhbm5vdW5jZW1lbnQgZGVsYXkgaGFzIGJlZW4gc2V0LoRDb2xka2V5U3dhcFJlYW5ub3VuY2VtZW50RGVsYXlTZXQEABABREJsb2NrTnVtYmVyRm9yPFQ+AFAEzFRoZSBjb2xka2V5IHN3YXAgcmVhbm5vdW5jZW1lbnQgZGVsYXkgaGFzIGJlZW4gc2V0LohEaXNzb2x2ZU5ldHdvcmtTY2hlZHVsZUR1cmF0aW9uU2V0BAAQAURCbG9ja051bWJlckZvcjxUPgBRBLRUaGUgZHVyYXRpb24gb2YgZGlzc29sdmUgbmV0d29yayBoYXMgYmVlbiBzZXRQQ1JWM1dlaWdodHNDb21taXR0ZWQMAAABMFQ6OkFjY291bnRJZAAAoAFITmV0VWlkU3RvcmFnZUluZGV4AAA0ARBIMjU2AFIU6ENvbW1pdC1yZXZlYWwgdjMgd2VpZ2h0cyBoYXZlIGJlZW4gc3VjY2Vzc2Z1bGx5IGNvbW1pdHRlZC4A9C0gKip3aG8qKjogVGhlIGFjY291bnQgSUQgb2YgdGhlIHVzZXIgY29tbWl0dGluZyB0aGUgd2VpZ2h0cy6ULSAqKm5ldHVpZCoqOiBUaGUgbmV0d29yayBpZGVudGlmaWVyLvwtICoqY29tbWl0X2hhc2gqKjogVGhlIGhhc2ggcmVwcmVzZW50aW5nIHRoZSBjb21taXR0ZWQgd2VpZ2h0cy5AV2VpZ2h0c0NvbW1pdHRlZAwAAAEwVDo6QWNjb3VudElkAACgAUhOZXRVaWRTdG9yYWdlSW5kZXgAADQBEEgyNTYAUxSkV2VpZ2h0cyBoYXZlIGJlZW4gc3VjY2Vzc2Z1bGx5IGNvbW1pdHRlZC4A9C0gKip3aG8qKjogVGhlIGFjY291bnQgSUQgb2YgdGhlIHVzZXIgY29tbWl0dGluZyB0aGUgd2VpZ2h0cy6ULSAqKm5ldHVpZCoqOiBUaGUgbmV0d29yayBpZGVudGlmaWVyLvwtICoqY29tbWl0X2hhc2gqKjogVGhlIGhhc2ggcmVwcmVzZW50aW5nIHRoZSBjb21taXR0ZWQgd2VpZ2h0cy48V2VpZ2h0c1JldmVhbGVkDAAAATBUOjpBY2NvdW50SWQAAKABSE5ldFVpZFN0b3JhZ2VJbmRleAAANAEQSDI1NgBUFKBXZWlnaHRzIGhhdmUgYmVlbiBzdWNjZXNzZnVsbHkgcmV2ZWFsZWQuAPAtICoqd2hvKio6IFRoZSBhY2NvdW50IElEIG9mIHRoZSB1c2VyIHJldmVhbGluZyB0aGUgd2VpZ2h0cy6ULSAqKm5ldHVpZCoqOiBUaGUgbmV0d29yayBpZGVudGlmaWVyLtAtICoqY29tbWl0X2hhc2gqKjogVGhlIGhhc2ggb2YgdGhlIHJldmVhbGVkIHdlaWdodHMuUFdlaWdodHNCYXRjaFJldmVhbGVkDAAAATBUOjpBY2NvdW50SWQAAKABGE5ldFVpZAAAuAEkVmVjPEgyNTY+AFUUuFdlaWdodHMgaGF2ZSBiZWVuIHN1Y2Nlc3NmdWxseSBiYXRjaCByZXZlYWxlZC4A8C0gKip3aG8qKjogVGhlIGFjY291bnQgSUQgb2YgdGhlIHVzZXIgcmV2ZWFsaW5nIHRoZSB3ZWlnaHRzLpQtICoqbmV0dWlkKio6IFRoZSBuZXR3b3JrIGlkZW50aWZpZXIuQQEtICoqcmV2ZWFsZWRfaGFzaGVzKio6IEEgdmVjdG9yIG9mIGhhc2hlcyByZXByZXNlbnRpbmcgZWFjaCByZXZlYWxlZCB3ZWlnaHQgc2V0LlRCYXRjaFdlaWdodHNDb21wbGV0ZWQIALwBUFZlYzxDb21wYWN0PE5ldFVpZD4+AAAAATBUOjpBY2NvdW50SWQAVhDQQSBiYXRjaCBvZiB3ZWlnaHRzIChvciBjb21taXRzKSBoYXZlIGJlZW4gZm9yY2Utc2V0LgA1AS0gKipuZXR1aWRzKio6IFRoZSBuZXR1aWRzIHRoZXNlIHdlaWdodHMgd2VyZSBzdWNjZXNzZnVsbHkgc2V0L2NvbW1pdHRlZCBmb3IuqC0gKip3aG8qKjogVGhlIGhvdGtleSB0aGF0IHNldCB0aGlzIGJhdGNoLmBCYXRjaENvbXBsZXRlZFdpdGhFcnJvcnMAVwTEQSBiYXRjaCBleHRyaW5zaWMgY29tcGxldGVkIGJ1dCB3aXRoIHNvbWUgZXJyb3JzLlRCYXRjaFdlaWdodEl0ZW1GYWlsZWQEAGgBZHNwX3J1bnRpbWU6OkRpc3BhdGNoRXJyb3IAWAy0QSB3ZWlnaHQgc2V0IGFtb25nIGEgYmF0Y2ggb2Ygd2VpZ2h0cyBmYWlsZWQuAOwtICoqZXJyb3IqKjogVGhlIGRpc3BhdGNoIGVycm9yIGVtaXR0ZWQgYnkgdGhlIGZhaWxlZCBpdGVtLkBTdGFrZVRyYW5zZmVycmVkGAAAATBUOjpBY2NvdW50SWQAAAABMFQ6OkFjY291bnRJZAAAAAEwVDo6QWNjb3VudElkAACgARhOZXRVaWQAAKABGE5ldFVpZAAAGAEoVGFvQmFsYW5jZQBZDCkBU3Rha2UgaGFzIGJlZW4gdHJhbnNmZXJyZWQgZnJvbSBvbmUgY29sZGtleSB0byBhbm90aGVyIG9uIHRoZSBzYW1lIHN1Ym5ldC4sUGFyYW1ldGVyczphAShvcmlnaW5fY29sZGtleSwgZGVzdGluYXRpb25fY29sZGtleSwgaG90a2V5LCBvcmlnaW5fbmV0dWlkLCBkZXN0aW5hdGlvbl9uZXR1aWQsIGFtb3VudCkwU3Rha2VTd2FwcGVkFAAAATBUOjpBY2NvdW50SWQAAAABMFQ6OkFjY291bnRJZAAAoAEYTmV0VWlkAACgARhOZXRVaWQAABgBKFRhb0JhbGFuY2UAWhBNAVN0YWtlIGhhcyBiZWVuIHN3YXBwZWQgZnJvbSBvbmUgc3VibmV0IHRvIGFub3RoZXIgZm9yIHRoZSBzYW1lIGNvbGRrZXktaG90a2V5IHBhaXIuACxQYXJhbWV0ZXJzOvAoY29sZGtleSwgaG90a2V5LCBvcmlnaW5fbmV0dWlkLCBkZXN0aW5hdGlvbl9uZXR1aWQsIGFtb3VudCk4VHJhbnNmZXJUb2dnbGUIAKABGE5ldFVpZAAAJAEQYm9vbABbEMhFdmVudCBjYWxsZWQgd2hlbiB0cmFuc2ZlciBpcyB0b2dnbGVkIG9uIGEgc3VibmV0LgAsUGFyYW1ldGVyczo4KG5ldHVpZCwgYm9vbClQU3VibmV0T3duZXJIb3RrZXlTZXQIAKABGE5ldFVpZAAAAAEwVDo6QWNjb3VudElkAFwQrFRoZSBvd25lciBob3RrZXkgZm9yIGEgc3VibmV0IGhhcyBiZWVuIHNldC4ALFBhcmFtZXRlcnM6UChuZXR1aWQsIG5ld19ob3RrZXkpbEZpcnN0RW1pc3Npb25CbG9ja051bWJlclNldAgAoAEYTmV0VWlkAAAYAQx1NjQAXRTgRmlyc3RFbWlzc2lvbkJsb2NrTnVtYmVyIGlzIHNldCB2aWEgc3RhcnQgY2FsbCBleHRyaW5zaWMALFBhcmFtZXRlcnM6GG5ldHVpZDBibG9jayBudW1iZXI0QWxwaGFSZWN5Y2xlZBAAAAEwVDo6QWNjb3VudElkAAAAATBUOjpBY2NvdW50SWQAABgBMEFscGhhQmFsYW5jZQAAoAEYTmV0VWlkAF4Q3EFscGhhIGhhcyBiZWVuIHJlY3ljbGVkLCByZWR1Y2luZyBBbHBoYU91dCBvbiBhIHN1Ym5ldC4ALFBhcmFtZXRlcnM6kChjb2xka2V5LCBob3RrZXksIGFtb3VudCwgc3VibmV0X2lkKSxBbHBoYUJ1cm5lZBAAAAEwVDo6QWNjb3VudElkAAAAATBUOjpBY2NvdW50SWQAABgBMEFscGhhQmFsYW5jZQAAoAEYTmV0VWlkAF8QxEFscGhhIGhhdmUgYmVlbiBidXJuZWQgd2l0aG91dCByZWR1Y2luZyBBbHBoYU91dC4ALFBhcmFtZXRlcnM6kChjb2xka2V5LCBob3RrZXksIGFtb3VudCwgc3VibmV0X2lkKUBFdm1LZXlBc3NvY2lhdGVkEAEYbmV0dWlkoAEYTmV0VWlkBJhUaGUgc3VibmV0IHRoYXQgdGhlIGhvdGtleSBiZWxvbmdzIHRvLgEYaG90a2V5AAEwVDo6QWNjb3VudElkBJxUaGUgaG90a2V5IGFzc29jaWF0ZWQgd2l0aCB0aGUgRVZNIGtleS4BHGV2bV9rZXnEARBIMTYwBLRUaGUgRVZNIGtleSBiZWluZyBhc3NvY2lhdGVkIHdpdGggdGhlIGhvdGtleS4BQGJsb2NrX2Fzc29jaWF0ZWQYAQx1NjQEpFRoZSBibG9jayB3aGVyZSB0aGUgYXNzb2NpYXRpb24gaGFwcGVuZWQuYAS0QW4gRVZNIGtleSBoYXMgYmVlbiBhc3NvY2lhdGVkIHdpdGggYSBob3RrZXkuTENSVjNXZWlnaHRzUmV2ZWFsZWQIAKABGE5ldFVpZAAAAAEwVDo6QWNjb3VudElkAGEQtENSVjMgV2VpZ2h0cyBoYXZlIGJlZW4gc3VjY2Vzc2Z1bGx5IHJldmVhbGVkLgCULSAqKm5ldHVpZCoqOiBUaGUgbmV0d29yayBpZGVudGlmaWVyLvAtICoqd2hvKio6IFRoZSBhY2NvdW50IElEIG9mIHRoZSB1c2VyIHJldmVhbGluZyB0aGUgd2VpZ2h0cy5YQ29tbWl0UmV2ZWFsUGVyaW9kc1NldAgAoAEYTmV0VWlkAAAYAQx1NjQAYhDAQ29tbWl0LVJldmVhbCBwZXJpb2RzIGhhcyBiZWVuIHN1Y2Nlc3NmdWxseSBzZXQuAJQtICoqbmV0dWlkKio6IFRoZSBuZXR3b3JrIGlkZW50aWZpZXIu2C0gKipwZXJpb2RzKio6IFRoZSBudW1iZXIgb2YgZXBvY2hzIGJlZm9yZSB0aGUgcmV2ZWFsLkxDb21taXRSZXZlYWxFbmFibGVkCACgARhOZXRVaWQAACQBEGJvb2wAYxCwQ29tbWl0LVJldmVhbCBoYXMgYmVlbiBzdWNjZXNzZnVsbHkgdG9nZ2xlZC4AlC0gKipuZXR1aWQqKjogVGhlIG5ldHdvcmsgaWRlbnRpZmllci6gLSAqKkVuYWJsZWQqKjogSXMgQ29tbWl0LVJldmVhbCBlbmFibGVkLlRIb3RrZXlTd2FwcGVkT25TdWJuZXQQARxjb2xka2V5AAEwVDo6QWNjb3VudElkBGR0aGUgYWNjb3VudCBJRCBvZiBjb2xka2V5AShvbGRfaG90a2V5AAEwVDo6QWNjb3VudElkBHB0aGUgYWNjb3VudCBJRCBvZiBvbGQgaG90a2V5AShuZXdfaG90a2V5AAEwVDo6QWNjb3VudElkBHB0aGUgYWNjb3VudCBJRCBvZiBuZXcgaG90a2V5ARhuZXR1aWSgARhOZXRVaWQENHRoZSBzdWJuZXQgSURkBFR0aGUgaG90a2V5IGlzIHN3YXBwZWRIU3VibmV0TGVhc2VDcmVhdGVkEAEsYmVuZWZpY2lhcnkAATBUOjpBY2NvdW50SWQEdFRoZSBiZW5lZmljaWFyeSBvZiB0aGUgbGVhc2UuASBsZWFzZV9pZBABHExlYXNlSWQEMFRoZSBsZWFzZSBJRAEYbmV0dWlkoAEYTmV0VWlkBDRUaGUgc3VibmV0IElEASRlbmRfYmxvY2vMAWRPcHRpb248QmxvY2tOdW1iZXJGb3I8VD4+BGhUaGUgZW5kIGJsb2NrIG9mIHRoZSBsZWFzZWUEgEEgc3VibmV0IGxlYXNlIGhhcyBiZWVuIGNyZWF0ZWQuVFN1Ym5ldExlYXNlVGVybWluYXRlZAgBLGJlbmVmaWNpYXJ5AAEwVDo6QWNjb3VudElkBHRUaGUgYmVuZWZpY2lhcnkgb2YgdGhlIGxlYXNlLgEYbmV0dWlkoAEYTmV0VWlkBDRUaGUgc3VibmV0IElEZgSMQSBzdWJuZXQgbGVhc2UgaGFzIGJlZW4gdGVybWluYXRlZC40U3ltYm9sVXBkYXRlZAgBGG5ldHVpZKABGE5ldFVpZAQ0VGhlIHN1Ym5ldCBJRAEYc3ltYm9sOAEcVmVjPHU4PgSEVGhlIHN5bWJvbCB0aGF0IGhhcyBiZWVuIHVwZGF0ZWQuZwSkVGhlIHN5bWJvbCBmb3IgYSBzdWJuZXQgaGFzIGJlZW4gdXBkYXRlZC5YQ29tbWl0UmV2ZWFsVmVyc2lvblNldAQAoAEMdTE2AGgMvENvbW1pdCBSZXZlYWwgV2VpZ2h0cyB2ZXJzaW9uIGhhcyBiZWVuIHVwZGF0ZWQuAJAtICoqdmVyc2lvbioqOiBUaGUgcmVxdWlyZWQgdmVyc2lvbi5oVGltZWxvY2tlZFdlaWdodHNDb21taXR0ZWQQAAABMFQ6OkFjY291bnRJZAAAoAFITmV0VWlkU3RvcmFnZUluZGV4AAA0ARBIMjU2AAAYAQx1NjQAaRjQVGltZWxvY2tlZCB3ZWlnaHRzIGhhdmUgYmVlbiBzdWNjZXNzZnVsbHkgY29tbWl0dGVkLgD0LSAqKndobyoqOiBUaGUgYWNjb3VudCBJRCBvZiB0aGUgdXNlciBjb21taXR0aW5nIHRoZSB3ZWlnaHRzLpQtICoqbmV0dWlkKio6IFRoZSBuZXR3b3JrIGlkZW50aWZpZXIu/C0gKipjb21taXRfaGFzaCoqOiBUaGUgaGFzaCByZXByZXNlbnRpbmcgdGhlIGNvbW1pdHRlZCB3ZWlnaHRzLvwtICoqcmV2ZWFsX3JvdW5kKio6IFRoZSByb3VuZCBhdCB3aGljaCB3ZWlnaHRzIGNhbiBiZSByZXZlYWxlZC5kVGltZWxvY2tlZFdlaWdodHNSZXZlYWxlZAgAoAFITmV0VWlkU3RvcmFnZUluZGV4AAAAATBUOjpBY2NvdW50SWQAahDMVGltZWxvY2tlZCBXZWlnaHRzIGhhdmUgYmVlbiBzdWNjZXNzZnVsbHkgcmV2ZWFsZWQuAJQtICoqbmV0dWlkKio6IFRoZSBuZXR3b3JrIGlkZW50aWZpZXIu8C0gKip3aG8qKjogVGhlIGFjY291bnQgSUQgb2YgdGhlIHVzZXIgcmV2ZWFsaW5nIHRoZSB3ZWlnaHRzLjhBdXRvU3Rha2VBZGRlZBQBGG5ldHVpZKABGE5ldFVpZARIU3VibmV0IGlkZW50aWZpZXIuASxkZXN0aW5hdGlvbgABMFQ6OkFjY291bnRJZATgRGVzdGluYXRpb24gYWNjb3VudCB0aGF0IHJlY2VpdmVkIHRoZSBhdXRvLXN0YWtlZCBmdW5kcy4BGGhvdGtleQABMFQ6OkFjY291bnRJZASsSG90a2V5IGFjY291bnQgd2hvc2Ugc3Rha2Ugd2FzIGF1dG8tc3Rha2VkLgEUb3duZXIAATBUOjpBY2NvdW50SWQEzE93bmVyIChjb2xka2V5KSBhY2NvdW50IGFzc29jaWF0ZWQgd2l0aCB0aGUgaG90a2V5LgEkaW5jZW50aXZlGAEwQWxwaGFCYWxhbmNlBHBBbW91bnQgb2YgYWxwaGEgYXV0by1zdGFrZWQuawSIQXV0by1zdGFraW5nIGhvdGtleSByZWNlaXZlZCBzdGFrZXRJbmNlbnRpdmVBbHBoYUVtaXR0ZWRUb01pbmVycwgBGG5ldHVpZKABSE5ldFVpZFN0b3JhZ2VJbmRleARIU3VibmV0IGlkZW50aWZpZXIuASRlbWlzc2lvbnPQAURWZWM8QWxwaGFCYWxhbmNlPgT0VUlELWluZGV4ZWQgYXJyYXkgb2YgbWluZXIgaW5jZW50aXZlIGFscGhhOyBpbmRleCBlcXVhbHMgVUlELmwEpEVuZC1vZi1lcG9jaCBtaW5lciBpbmNlbnRpdmUgYWxwaGEgYnkgVUlERE1pbkFsbG93ZWRVaWRzU2V0CACgARhOZXRVaWQAAKABDHUxNgBtBNBUaGUgbWluaW11bSBhbGxvd2VkIFVJRHMgZm9yIGEgc3VibmV0IGhhdmUgYmVlbiBzZXQuXEF1dG9TdGFrZURlc3RpbmF0aW9uU2V0DAEcY29sZGtleQABMFQ6OkFjY291bnRJZAR4VGhlIGFjY291bnQgSUQgb2YgdGhlIGNvbGRrZXkuARhuZXR1aWSgARhOZXRVaWQEXFRoZSBuZXR3b3JrIGlkZW50aWZpZXIuARhob3RrZXkAATBUOjpBY2NvdW50SWQEdFRoZSBhY2NvdW50IElEIG9mIHRoZSBob3RrZXkubhSgVGhlIGF1dG8gc3Rha2UgZGVzdGluYXRpb24gaGFzIGJlZW4gc2V0LgC0LSAqKmNvbGRrZXkqKjogVGhlIGFjY291bnQgSUQgb2YgdGhlIGNvbGRrZXkulC0gKipuZXR1aWQqKjogVGhlIG5ldHdvcmsgaWRlbnRpZmllci6sLSAqKmhvdGtleSoqOiBUaGUgYWNjb3VudCBJRCBvZiB0aGUgaG90a2V5LkxNaW5Ob25JbW11bmVVaWRzU2V0CACgARhOZXRVaWQAAKABDHUxNgBvBMRUaGUgbWluaW11bSBhbGxvd2VkIG5vbi1JbW11bmUgVUlEcyBoYXMgYmVlbiBzZXQuLFJvb3RDbGFpbWVkBAEcY29sZGtleQABMFQ6OkFjY291bnRJZAQ0Q2xhaW0gY29sZGtleXAMKQFSb290IGVtaXNzaW9ucyBoYXZlIGJlZW4gY2xhaW1lZCBmb3IgYSBjb2xka2V5IG9uIGFsbCBzdWJuZXRzIGFuZCBob3RrZXlzLixQYXJhbWV0ZXJzOiQoY29sZGtleSlAUm9vdENsYWltVHlwZVNldAgBHGNvbGRrZXkAATBUOjpBY2NvdW50SWQENENsYWltIGNvbGRrZXkBPHJvb3RfY2xhaW1fdHlwZdQBRFJvb3RDbGFpbVR5cGVFbnVtBChDbGFpbSB0eXBlcQysUm9vdCBjbGFpbSB0eXBlIGZvciBhIGNvbGRrZXkgaGFzIGJlZW4gc2V0LixQYXJhbWV0ZXJzOjQoY29sZGtleSwgdTgpaFZvdGluZ1Bvd2VyVHJhY2tpbmdFbmFibGVkBAEYbmV0dWlkoAEYTmV0VWlkBDRUaGUgc3VibmV0IElEcgTQVm90aW5nIHBvd2VyIHRyYWNraW5nIGhhcyBiZWVuIGVuYWJsZWQgZm9yIGEgc3VibmV0LoxWb3RpbmdQb3dlclRyYWNraW5nRGlzYWJsZVNjaGVkdWxlZAgBGG5ldHVpZKABGE5ldFVpZAQ0VGhlIHN1Ym5ldCBJRAFAZGlzYWJsZV9hdF9ibG9jaxgBDHU2NASgQmxvY2sgYXQgd2hpY2ggdHJhY2tpbmcgd2lsbCBiZSBkaXNhYmxlZHMI3FZvdGluZyBwb3dlciB0cmFja2luZyBoYXMgYmVlbiBzY2hlZHVsZWQgZm9yIGRpc2FibGluZy4tAVRyYWNraW5nIHdpbGwgY29udGludWUgdW50aWwgZGlzYWJsZV9hdF9ibG9jaywgdGhlbiBzdG9wIGFuZCBjbGVhciBlbnRyaWVzLmxWb3RpbmdQb3dlclRyYWNraW5nRGlzYWJsZWQEARhuZXR1aWSgARhOZXRVaWQENFRoZSBzdWJuZXQgSUR0BAkBVm90aW5nIHBvd2VyIHRyYWNraW5nIGhhcyBiZWVuIGZ1bGx5IGRpc2FibGVkIGFuZCBlbnRyaWVzIGNsZWFyZWQuWFZvdGluZ1Bvd2VyRW1hQWxwaGFTZXQIARhuZXR1aWSgARhOZXRVaWQENFRoZSBzdWJuZXQgSUQBFGFscGhhGAEMdTY0BMxUaGUgbmV3IGFscGhhIHZhbHVlICh1NjQgd2l0aCAxOCBkZWNpbWFsIHByZWNpc2lvbil1BMRWb3RpbmcgcG93ZXIgRU1BIGFscGhhIGhhcyBiZWVuIHNldCBmb3IgYSBzdWJuZXQufFN1Ym5ldExlYXNlRGl2aWRlbmRzRGlzdHJpYnV0ZWQMASBsZWFzZV9pZBABHExlYXNlSWQEMFRoZSBsZWFzZSBJRAEsY29udHJpYnV0b3IAATBUOjpBY2NvdW50SWQEPFRoZSBjb250cmlidXRvcgEUYWxwaGEYATBBbHBoYUJhbGFuY2UEfFRoZSBhbW91bnQgb2YgYWxwaGEgZGlzdHJpYnV0ZWR2BLRTdWJuZXQgbGVhc2UgZGl2aWRlbmRzIGhhdmUgYmVlbiBkaXN0cmlidXRlZC4wQWRkU3Rha2VCdXJuEAEYbmV0dWlkoAEYTmV0VWlkBDRUaGUgc3VibmV0IElEARhob3RrZXkAATBUOjpBY2NvdW50SWQEQGhvdGt5IGFjY291bnQgSUQBGGFtb3VudBgBKFRhb0JhbGFuY2UEMFRhbyBwcm92aWRlZAEUYWxwaGEYATBBbHBoYUJhbGFuY2UEMEFscGhhIGJ1cm5lZHcEBQEiQWRkIHN0YWtlIGFuZCBidXJuIiBldmVudDogYWxwaGEgdG9rZW4gd2FzIHB1cmNoYXNlZCBhbmQgYnVybmVkLgR8VGhlIGBFdmVudGAgZW51bSBvZiB0aGlzIHBhbGxldKAAAAUEAKQAAAUKAKgEGFJlc3VsdAgEVAGsBEUBaAEICE9rBACsAAAAAAxFcnIEAGgAAAEAAKwAAAQAALAAAAK0ALQAAAQIGAAAuAAAAjQAvAAAAsAAwAAABqAAxAg8cHJpbWl0aXZlX3R5cGVzEEgxNjAAAAQAyAEgW3U4OyAyMF0AAMgAAAMUAAAACADMBBhPcHRpb24EBFQBEAEIEE5vbmUAAAAQU29tZQQAEAAAAQAA0AAAAhgA1AxAcGFsbGV0X3N1YnRlbnNvchhwYWxsZXREUm9vdENsYWltVHlwZUVudW0AAQwQU3dhcAAAABBLZWVwAAEALEtlZXBTdWJuZXRzBAEcc3VibmV0c9gBQEJUcmVlU2V0PE5ldFVpZD4AAgAA2AQgQlRyZWVTZXQEBFQBoAAEANwAAADcAAACoADgDGBwYWxsZXRfc3VidGVuc29yX3V0aWxpdHkYcGFsbGV0FEV2ZW50AAEgQEJhdGNoSW50ZXJydXB0ZWQIARRpbmRleBABDHUzMgABFGVycm9yaAE0RGlzcGF0Y2hFcnJvcgAACFUBQmF0Y2ggb2YgZGlzcGF0Y2hlcyBkaWQgbm90IGNvbXBsZXRlIGZ1bGx5LiBJbmRleCBvZiBmaXJzdCBmYWlsaW5nIGRpc3BhdGNoIGdpdmVuLCBhc0h3ZWxsIGFzIHRoZSBlcnJvci44QmF0Y2hDb21wbGV0ZWQAAQTIQmF0Y2ggb2YgZGlzcGF0Y2hlcyBjb21wbGV0ZWQgZnVsbHkgd2l0aCBubyBlcnJvci5gQmF0Y2hDb21wbGV0ZWRXaXRoRXJyb3JzAAIEtEJhdGNoIG9mIGRpc3BhdGNoZXMgY29tcGxldGVkIGJ1dCBoYXMgZXJyb3JzLjRJdGVtQ29tcGxldGVkAAMEHQFBIHNpbmdsZSBpdGVtIHdpdGhpbiBhIEJhdGNoIG9mIGRpc3BhdGNoZXMgaGFzIGNvbXBsZXRlZCB3aXRoIG5vIGVycm9yLihJdGVtRmFpbGVkBAEUZXJyb3JoATREaXNwYXRjaEVycm9yAAQEEQFBIHNpbmdsZSBpdGVtIHdpdGhpbiBhIEJhdGNoIG9mIGRpc3BhdGNoZXMgaGFzIGNvbXBsZXRlZCB3aXRoIGVycm9yLjBEaXNwYXRjaGVkQXMEARhyZXN1bHSoAThEaXNwYXRjaFJlc3VsdAAFBFhBIGNhbGwgd2FzIGRpc3BhdGNoZWQuRElmRWxzZU1haW5TdWNjZXNzAAYEZE1haW4gY2FsbCB3YXMgZGlzcGF0Y2hlZC5QSWZFbHNlRmFsbGJhY2tDYWxsZWQEAShtYWluX2Vycm9yaAE0RGlzcGF0Y2hFcnJvcgAHBIRUaGUgZmFsbGJhY2sgY2FsbCB3YXMgZGlzcGF0Y2hlZC4EfFRoZSBgRXZlbnRgIGVudW0gb2YgdGhpcyBwYWxsZXTkDCxwYWxsZXRfc3VkbxhwYWxsZXQURXZlbnQEBFQAARAUU3VkaWQEASxzdWRvX3Jlc3VsdKgBOERpc3BhdGNoUmVzdWx0BLRUaGUgcmVzdWx0IG9mIHRoZSBjYWxsIG1hZGUgYnkgdGhlIHN1ZG8gdXNlci4ABHBBIHN1ZG8gY2FsbCBqdXN0IHRvb2sgcGxhY2UuKEtleUNoYW5nZWQIAQxvbGToAVBPcHRpb248VDo6QWNjb3VudElkPgS0VGhlIG9sZCBzdWRvIGtleSAoaWYgb25lIHdhcyBwcmV2aW91c2x5IHNldCkuAQxuZXcAATBUOjpBY2NvdW50SWQEiFRoZSBuZXcgc3VkbyBrZXkgKGlmIG9uZSB3YXMgc2V0KS4BBHhUaGUgc3VkbyBrZXkgaGFzIGJlZW4gdXBkYXRlZC4oS2V5UmVtb3ZlZAACBIBUaGUga2V5IHdhcyBwZXJtYW5lbnRseSByZW1vdmVkLihTdWRvQXNEb25lBAEsc3Vkb19yZXN1bHSoAThEaXNwYXRjaFJlc3VsdAS0VGhlIHJlc3VsdCBvZiB0aGUgY2FsbCBtYWRlIGJ5IHRoZSBzdWRvIHVzZXIuAwTIQSBbc3Vkb19hc10oUGFsbGV0OjpzdWRvX2FzKSBjYWxsIGp1c3QgdG9vayBwbGFjZS4EfFRoZSBgRXZlbnRgIGVudW0gb2YgdGhpcyBwYWxsZXToBBhPcHRpb24EBFQBAAEIEE5vbmUAAAAQU29tZQQAAAAAAQAA7Aw8cGFsbGV0X211bHRpc2lnGHBhbGxldBRFdmVudAQEVAABFCxOZXdNdWx0aXNpZwwBJGFwcHJvdmluZwABMFQ6OkFjY291bnRJZAABIG11bHRpc2lnAAEwVDo6QWNjb3VudElkAAEkY2FsbF9oYXNoBAEgQ2FsbEhhc2gAAASMQSBuZXcgbXVsdGlzaWcgb3BlcmF0aW9uIGhhcyBiZWd1bi5ATXVsdGlzaWdBcHByb3ZhbBABJGFwcHJvdmluZwABMFQ6OkFjY291bnRJZAABJHRpbWVwb2ludPABcFRpbWVwb2ludDxCbG9ja051bWJlckZvcjxUPj4AASBtdWx0aXNpZwABMFQ6OkFjY291bnRJZAABJGNhbGxfaGFzaAQBIENhbGxIYXNoAAEEyEEgbXVsdGlzaWcgb3BlcmF0aW9uIGhhcyBiZWVuIGFwcHJvdmVkIGJ5IHNvbWVvbmUuQE11bHRpc2lnRXhlY3V0ZWQUASRhcHByb3ZpbmcAATBUOjpBY2NvdW50SWQAASR0aW1lcG9pbnTwAXBUaW1lcG9pbnQ8QmxvY2tOdW1iZXJGb3I8VD4+AAEgbXVsdGlzaWcAATBUOjpBY2NvdW50SWQAASRjYWxsX2hhc2gEASBDYWxsSGFzaAABGHJlc3VsdKgBOERpc3BhdGNoUmVzdWx0AAIEnEEgbXVsdGlzaWcgb3BlcmF0aW9uIGhhcyBiZWVuIGV4ZWN1dGVkLkRNdWx0aXNpZ0NhbmNlbGxlZBABKGNhbmNlbGxpbmcAATBUOjpBY2NvdW50SWQAASR0aW1lcG9pbnTwAXBUaW1lcG9pbnQ8QmxvY2tOdW1iZXJGb3I8VD4+AAEgbXVsdGlzaWcAATBUOjpBY2NvdW50SWQAASRjYWxsX2hhc2gEASBDYWxsSGFzaAADBKBBIG11bHRpc2lnIG9wZXJhdGlvbiBoYXMgYmVlbiBjYW5jZWxsZWQuMERlcG9zaXRQb2tlZBABDHdobwABMFQ6OkFjY291bnRJZAABJGNhbGxfaGFzaAQBIENhbGxIYXNoAAEsb2xkX2RlcG9zaXQYATBCYWxhbmNlT2Y8VD4AASxuZXdfZGVwb3NpdBgBMEJhbGFuY2VPZjxUPgAEBPBUaGUgZGVwb3NpdCBmb3IgYSBtdWx0aXNpZyBvcGVyYXRpb24gaGFzIGJlZW4gdXBkYXRlZC9wb2tlZC4EfFRoZSBgRXZlbnRgIGVudW0gb2YgdGhpcyBwYWxsZXTwCDxwYWxsZXRfbXVsdGlzaWckVGltZXBvaW50BCxCbG9ja051bWJlcgEQAAgBGGhlaWdodBABLEJsb2NrTnVtYmVyAAEUaW5kZXgQAQx1MzIAAPQMPHBhbGxldF9wcmVpbWFnZRhwYWxsZXQURXZlbnQEBFQAAQwUTm90ZWQEARBoYXNoNAEcVDo6SGFzaAAABGhBIHByZWltYWdlIGhhcyBiZWVuIG5vdGVkLiRSZXF1ZXN0ZWQEARBoYXNoNAEcVDo6SGFzaAABBHhBIHByZWltYWdlIGhhcyBiZWVuIHJlcXVlc3RlZC4cQ2xlYXJlZAQBEGhhc2g0ARxUOjpIYXNoAAIEbEEgcHJlaW1hZ2UgaGFzIGJlbiBjbGVhcmVkLgR8VGhlIGBFdmVudGAgZW51bSBvZiB0aGlzIHBhbGxldPgMQHBhbGxldF9zY2hlZHVsZXIYcGFsbGV0FEV2ZW50BARUAAEoJFNjaGVkdWxlZAgBEHdoZW4QAURCbG9ja051bWJlckZvcjxUPgABFGluZGV4EAEMdTMyAAAEUFNjaGVkdWxlZCBzb21lIHRhc2suIENhbmNlbGVkCAEQd2hlbhABREJsb2NrTnVtYmVyRm9yPFQ+AAEUaW5kZXgQAQx1MzIAAQRMQ2FuY2VsZWQgc29tZSB0YXNrLihEaXNwYXRjaGVkDAEQdGFza/wBeFRhc2tBZGRyZXNzPEJsb2NrTnVtYmVyRm9yPFQ+PgABCGlkAQEBQE9wdGlvbjxUYXNrTmFtZT4AARhyZXN1bHSoAThEaXNwYXRjaFJlc3VsdAACBFREaXNwYXRjaGVkIHNvbWUgdGFzay4gUmV0cnlTZXQQARB0YXNr/AF4VGFza0FkZHJlc3M8QmxvY2tOdW1iZXJGb3I8VD4+AAEIaWQBAQFAT3B0aW9uPFRhc2tOYW1lPgABGHBlcmlvZBABREJsb2NrTnVtYmVyRm9yPFQ+AAEccmV0cmllcwgBCHU4AAMEoFNldCBhIHJldHJ5IGNvbmZpZ3VyYXRpb24gZm9yIHNvbWUgdGFzay44UmV0cnlDYW5jZWxsZWQIARB0YXNr/AF4VGFza0FkZHJlc3M8QmxvY2tOdW1iZXJGb3I8VD4+AAEIaWQBAQFAT3B0aW9uPFRhc2tOYW1lPgAEBKxDYW5jZWwgYSByZXRyeSBjb25maWd1cmF0aW9uIGZvciBzb21lIHRhc2suPENhbGxVbmF2YWlsYWJsZQgBEHRhc2v8AXhUYXNrQWRkcmVzczxCbG9ja051bWJlckZvcjxUPj4AAQhpZAEBAUBPcHRpb248VGFza05hbWU+AAUEKQFUaGUgY2FsbCBmb3IgdGhlIHByb3ZpZGVkIGhhc2ggd2FzIG5vdCBmb3VuZCBzbyB0aGUgdGFzayBoYXMgYmVlbiBhYm9ydGVkLjhQZXJpb2RpY0ZhaWxlZAgBEHRhc2v8AXhUYXNrQWRkcmVzczxCbG9ja051bWJlckZvcjxUPj4AAQhpZAEBAUBPcHRpb248VGFza05hbWU+AAYEPQFUaGUgZ2l2ZW4gdGFzayB3YXMgdW5hYmxlIHRvIGJlIHJlbmV3ZWQgc2luY2UgdGhlIGFnZW5kYSBpcyBmdWxsIGF0IHRoYXQgYmxvY2suLFJldHJ5RmFpbGVkCAEQdGFza/wBeFRhc2tBZGRyZXNzPEJsb2NrTnVtYmVyRm9yPFQ+PgABCGlkAQEBQE9wdGlvbjxUYXNrTmFtZT4ABwhdAVRoZSBnaXZlbiB0YXNrIHdhcyB1bmFibGUgdG8gYmUgcmV0cmllZCBzaW5jZSB0aGUgYWdlbmRhIGlzIGZ1bGwgYXQgdGhhdCBibG9jayBvciB0aGVyZZx3YXMgbm90IGVub3VnaCB3ZWlnaHQgdG8gcmVzY2hlZHVsZSBpdC5UUGVybWFuZW50bHlPdmVyd2VpZ2h0CAEQdGFza/wBeFRhc2tBZGRyZXNzPEJsb2NrTnVtYmVyRm9yPFQ+PgABCGlkAQEBQE9wdGlvbjxUYXNrTmFtZT4ACATwVGhlIGdpdmVuIHRhc2sgY2FuIG5ldmVyIGJlIGV4ZWN1dGVkIHNpbmNlIGl0IGlzIG92ZXJ3ZWlnaHQuQEFnZW5kYUluY29tcGxldGUEARB3aGVuEAFEQmxvY2tOdW1iZXJGb3I8VD4ACQSEQWdlbmRhIGlzIGluY29tcGxldGUgZnJvbSBgd2hlbmAuBDBFdmVudHMgdHlwZS78AAAECBAQAAEBBBhPcHRpb24EBFQBBAEIEE5vbmUAAAAQU29tZQQABAAAAQAABQEMWHBhbGxldF9zdWJ0ZW5zb3JfcHJveHkYcGFsbGV0FEV2ZW50BARUAAEcNFByb3h5RXhlY3V0ZWQEARhyZXN1bHSoAThEaXNwYXRjaFJlc3VsdAAABLxBIHByb3h5IHdhcyBleGVjdXRlZCBjb3JyZWN0bHksIHdpdGggdGhlIGdpdmVuLixQdXJlQ3JlYXRlZBABEHB1cmUAATBUOjpBY2NvdW50SWQAAQx3aG8AATBUOjpBY2NvdW50SWQAAShwcm94eV90eXBlCQEBMFQ6OlByb3h5VHlwZQABUGRpc2FtYmlndWF0aW9uX2luZGV4oAEMdTE2AAEI3EEgcHVyZSBhY2NvdW50IGhhcyBiZWVuIGNyZWF0ZWQgYnkgbmV3IHByb3h5IHdpdGggZ2l2ZW6QZGlzYW1iaWd1YXRpb24gaW5kZXggYW5kIHByb3h5IHR5cGUuKFB1cmVLaWxsZWQQARBwdXJlAAEwVDo6QWNjb3VudElkAAEcc3Bhd25lcgABMFQ6OkFjY291bnRJZAABKHByb3h5X3R5cGUJAQEwVDo6UHJveHlUeXBlAAFQZGlzYW1iaWd1YXRpb25faW5kZXigAQx1MTYAAgScQSBwdXJlIHByb3h5IHdhcyBraWxsZWQgYnkgaXRzIHNwYXduZXIuJEFubm91bmNlZAwBEHJlYWwAATBUOjpBY2NvdW50SWQAARRwcm94eQABMFQ6OkFjY291bnRJZAABJGNhbGxfaGFzaDQBNENhbGxIYXNoT2Y8VD4AAwTgQW4gYW5ub3VuY2VtZW50IHdhcyBwbGFjZWQgdG8gbWFrZSBhIGNhbGwgaW4gdGhlIGZ1dHVyZS4oUHJveHlBZGRlZBABJGRlbGVnYXRvcgABMFQ6OkFjY291bnRJZAABJGRlbGVnYXRlZQABMFQ6OkFjY291bnRJZAABKHByb3h5X3R5cGUJAQEwVDo6UHJveHlUeXBlAAEUZGVsYXkQAURCbG9ja051bWJlckZvcjxUPgAEBEhBIHByb3h5IHdhcyBhZGRlZC4wUHJveHlSZW1vdmVkEAEkZGVsZWdhdG9yAAEwVDo6QWNjb3VudElkAAEkZGVsZWdhdGVlAAEwVDo6QWNjb3VudElkAAEocHJveHlfdHlwZQkBATBUOjpQcm94eVR5cGUAARRkZWxheRABREJsb2NrTnVtYmVyRm9yPFQ+AAUEUEEgcHJveHkgd2FzIHJlbW92ZWQuMERlcG9zaXRQb2tlZBABDHdobwABMFQ6OkFjY291bnRJZAABEGtpbmQNAQEsRGVwb3NpdEtpbmQAASxvbGRfZGVwb3NpdBgBMEJhbGFuY2VPZjxUPgABLG5ld19kZXBvc2l0GAEwQmFsYW5jZU9mPFQ+AAYECQFBIGRlcG9zaXQgc3RvcmVkIGZvciBwcm94aWVzIG9yIGFubm91bmNlbWVudHMgd2FzIHBva2VkIC8gdXBkYXRlZC4EfFRoZSBgRXZlbnRgIGVudW0gb2YgdGhpcyBwYWxsZXQJAQhgc3VidGVuc29yX3J1bnRpbWVfY29tbW9uJFByb3h5VHlwZQABSAxBbnkAAAAUT3duZXIAAQAsTm9uQ3JpdGljYWwAAgAsTm9uVHJhbnNmZXIAAwAYU2VuYXRlAAQALE5vbkZ1bmdpYmxlAAUALFRyaXVtdmlyYXRlAAYAKEdvdmVybmFuY2UABwAcU3Rha2luZwAIADBSZWdpc3RyYXRpb24ACQAgVHJhbnNmZXIACgA0U21hbGxUcmFuc2ZlcgALACxSb290V2VpZ2h0cwAMACRDaGlsZEtleXMADQBQU3Vkb1VuY2hlY2tlZFNldENvZGUADgAoU3dhcEhvdGtleQAPAFhTdWJuZXRMZWFzZUJlbmVmaWNpYXJ5ABAAJFJvb3RDbGFpbQARAAANAQhYcGFsbGV0X3N1YnRlbnNvcl9wcm94eSxEZXBvc2l0S2luZAABCBxQcm94aWVzAAAANEFubm91bmNlbWVudHMAAQAAEQEMPHBhbGxldF9yZWdpc3RyeRhwYWxsZXQURXZlbnQEBFQAAQgsSWRlbnRpdHlTZXQEAQx3aG8AATBUOjpBY2NvdW50SWQEoFRoZSBhY2NvdW50IHRoYXQgcmVnaXN0ZXJlZCB0aGUgaWRlbnRpdHkABKRFbWl0dGVkIHdoZW4gYSB1c2VyIHJlZ2lzdGVycyBhbiBpZGVudGl0eURJZGVudGl0eURpc3NvbHZlZAQBDHdobwABMFQ6OkFjY291bnRJZAScVGhlIGFjY291bnQgdGhhdCBkaXNzb2x2ZWQgdGhlIGlkZW50aXR5AQSkRW1pdHRlZCB3aGVuIGEgdXNlciBkaXNzb2x2ZXMgYW4gaWRlbnRpdHkEfFRoZSBgRXZlbnRgIGVudW0gb2YgdGhpcyBwYWxsZXQVAQxIcGFsbGV0X2NvbW1pdG1lbnRzGHBhbGxldBRFdmVudAQEVAABDChDb21taXRtZW50CAEYbmV0dWlkoAEYTmV0VWlkBHBUaGUgbmV0dWlkIG9mIHRoZSBjb21taXRtZW50AQx3aG8AATBUOjpBY2NvdW50SWQELFRoZSBhY2NvdW50AARQQSBjb21taXRtZW50IHdhcyBzZXRIVGltZWxvY2tDb21taXRtZW50DAEYbmV0dWlkoAEYTmV0VWlkBHBUaGUgbmV0dWlkIG9mIHRoZSBjb21taXRtZW50AQx3aG8AATBUOjpBY2NvdW50SWQELFRoZSBhY2NvdW50ATByZXZlYWxfcm91bmQYAQx1NjQEZFRoZSBkcmFuZCByb3VuZCB0byByZXZlYWwBBJxBIHRpbWVsb2NrLWVuY3J5cHRlZCBjb21taXRtZW50IHdhcyBzZXRIQ29tbWl0bWVudFJldmVhbGVkCAEYbmV0dWlkoAEYTmV0VWlkBHBUaGUgbmV0dWlkIG9mIHRoZSBjb21taXRtZW50AQx3aG8AATBUOjpBY2NvdW50SWQELFRoZSBhY2NvdW50AgTEQSB0aW1lbG9jay1lbmNyeXB0ZWQgY29tbWl0bWVudCB3YXMgYXV0by1yZXZlYWxlZAR8VGhlIGBFdmVudGAgZW51bSBvZiB0aGlzIHBhbGxldBkBDEhwYWxsZXRfYWRtaW5fdXRpbHMYcGFsbGV0FEV2ZW50BARUAAEMRFByZWNvbXBpbGVVcGRhdGVkCAE0cHJlY29tcGlsZV9pZB0BAThQcmVjb21waWxlRW51bQS8VGhlIHR5cGUgb2YgcHJlY29tcGlsZSBvcGVyYXRpb24gYmVpbmcgdXBkYXRlZC4BHGVuYWJsZWQkARBib29sBOBJbmRpY2F0ZXMgaWYgdGhlIHByZWNvbXBpbGUgb3BlcmF0aW9uIGlzIGVuYWJsZWQgb3Igbm90LgAE1EV2ZW50IGVtaXR0ZWQgd2hlbiBhIHByZWNvbXBpbGUgb3BlcmF0aW9uIGlzIHVwZGF0ZWQuSFl1bWEzRW5hYmxlVG9nZ2xlZAgBGG5ldHVpZKABGE5ldFVpZARcVGhlIG5ldHdvcmsgaWRlbnRpZmllci4BHGVuYWJsZWQkARBib29sBNhJbmRpY2F0ZXMgaWYgdGhlIFl1bWEzIGVuYWJsZSB3YXMgZW5hYmxlZCBvciBkaXNhYmxlZC4BBLxFdmVudCBlbWl0dGVkIHdoZW4gdGhlIFl1bWEzIGVuYWJsZSBpcyB0b2dnbGVkLkRCb25kc1Jlc2V0VG9nZ2xlZAgBGG5ldHVpZKABGE5ldFVpZARcVGhlIG5ldHdvcmsgaWRlbnRpZmllci4BHGVuYWJsZWQkARBib29sBNRJbmRpY2F0ZXMgaWYgdGhlIEJvbmRzIFJlc2V0IHdhcyBlbmFibGVkIG9yIGRpc2FibGVkLgIEqEV2ZW50IGVtaXR0ZWQgd2hlbiBCb25kcyBSZXNldCBpcyB0b2dnbGVkLgR8VGhlIGBFdmVudGAgZW51bSBvZiB0aGlzIHBhbGxldB0BDEhwYWxsZXRfYWRtaW5fdXRpbHMYcGFsbGV0OFByZWNvbXBpbGVFbnVtAAEwPEJhbGFuY2VUcmFuc2ZlcgAAABxTdGFraW5nAAEAGFN1Ym5ldAACACRNZXRhZ3JhcGgAAwAYTmV1cm9uAAQAJFVpZExvb2t1cAAFABRBbHBoYQAGACRDcm93ZGxvYW4ABwAUUHJveHkACAAcTGVhc2luZwAJADhBZGRyZXNzTWFwcGluZwAKACxWb3RpbmdQb3dlcgALAAAhAQxAcGFsbGV0X3NhZmVfbW9kZRhwYWxsZXQURXZlbnQEBFQAASAcRW50ZXJlZAQBFHVudGlsEAFEQmxvY2tOdW1iZXJGb3I8VD4AAATcVGhlIHNhZmUtbW9kZSB3YXMgZW50ZXJlZCB1bnRpbCBpbmNsdXNpdmVseSB0aGlzIGJsb2NrLiBFeHRlbmRlZAQBFHVudGlsEAFEQmxvY2tOdW1iZXJGb3I8VD4AAQTgVGhlIHNhZmUtbW9kZSB3YXMgZXh0ZW5kZWQgdW50aWwgaW5jbHVzaXZlbHkgdGhpcyBibG9jay4YRXhpdGVkBAEYcmVhc29uJQEBKEV4aXRSZWFzb24AAgSsRXhpdGVkIHRoZSBzYWZlLW1vZGUgZm9yIGEgc3BlY2lmaWMgcmVhc29uLjREZXBvc2l0UGxhY2VkCAEcYWNjb3VudAABMFQ6OkFjY291bnRJZAABGGFtb3VudBgBMEJhbGFuY2VPZjxUPgADBCUBQW4gYWNjb3VudCByZXNlcnZlZCBmdW5kcyBmb3IgZWl0aGVyIGVudGVyaW5nIG9yIGV4dGVuZGluZyB0aGUgc2FmZS1tb2RlLjxEZXBvc2l0UmVsZWFzZWQIARxhY2NvdW50AAEwVDo6QWNjb3VudElkAAEYYW1vdW50GAEwQmFsYW5jZU9mPFQ+AAQE0EFuIGFjY291bnQgaGFkIGEgcmVzZXJ2ZSByZWxlYXNlZCB0aGF0IHdhcyByZXNlcnZlZC44RGVwb3NpdFNsYXNoZWQIARxhY2NvdW50AAEwVDo6QWNjb3VudElkAAEYYW1vdW50GAEwQmFsYW5jZU9mPFQ+AAUExEFuIGFjY291bnQgaGFkIHJlc2VydmUgc2xhc2hlZCB0aGF0IHdhcyByZXNlcnZlZC40Q2Fubm90RGVwb3NpdAAGDPRDb3VsZCBub3QgaG9sZCBmdW5kcyBmb3IgZW50ZXJpbmcgb3IgZXh0ZW5kaW5nIHRoZSBzYWZlLW1vZGUuAMBUaGlzIGVycm9yIGNvbWVzIGZyb20gdGhlIHVuZGVybHlpbmcgYEN1cnJlbmN5YC40Q2Fubm90UmVsZWFzZQAHDAEBQ291bGQgbm90IHJlbGVhc2UgZnVuZHMgZm9yIGVudGVyaW5nIG9yIGV4dGVuZGluZyB0aGUgc2FmZS1tb2RlLgDAVGhpcyBlcnJvciBjb21lcyBmcm9tIHRoZSB1bmRlcmx5aW5nIGBDdXJyZW5jeWAuBHxUaGUgYEV2ZW50YCBlbnVtIG9mIHRoaXMgcGFsbGV0JQEMQHBhbGxldF9zYWZlX21vZGUYcGFsbGV0KEV4aXRSZWFzb24AAQgcVGltZW91dAAAABRGb3JjZQABAAApAQw8cGFsbGV0X2V0aGVyZXVtGHBhbGxldBRFdmVudAABBCBFeGVjdXRlZBQBEGZyb23EARBIMTYwAAEIdG/EARBIMTYwAAFAdHJhbnNhY3Rpb25faGFzaDQBEEgyNTYAASxleGl0X3JlYXNvbi0BAShFeGl0UmVhc29uAAEoZXh0cmFfZGF0YTgBHFZlYzx1OD4AAATIQW4gZXRoZXJldW0gdHJhbnNhY3Rpb24gd2FzIHN1Y2Nlc3NmdWxseSBleGVjdXRlZC4EfFRoZSBgRXZlbnRgIGVudW0gb2YgdGhpcyBwYWxsZXQtAQwgZXZtX2NvcmUUZXJyb3IoRXhpdFJlYXNvbgABEBxTdWNjZWVkBAAxAQEsRXhpdFN1Y2NlZWQAAAAURXJyb3IEADUBASRFeGl0RXJyb3IAAQAYUmV2ZXJ0BABFAQEoRXhpdFJldmVydAACABRGYXRhbAQASQEBJEV4aXRGYXRhbAADAAAxAQwgZXZtX2NvcmUUZXJyb3IsRXhpdFN1Y2NlZWQAAQwcU3RvcHBlZAAAACBSZXR1cm5lZAABACBTdWljaWRlZAACAAA1AQwgZXZtX2NvcmUUZXJyb3IkRXhpdEVycm9yAAFAOFN0YWNrVW5kZXJmbG93AAAANFN0YWNrT3ZlcmZsb3cAAQAsSW52YWxpZEp1bXAAAgAwSW52YWxpZFJhbmdlAAMARERlc2lnbmF0ZWRJbnZhbGlkAAQALENhbGxUb29EZWVwAAUAPENyZWF0ZUNvbGxpc2lvbgAGAExDcmVhdGVDb250cmFjdExpbWl0AAcALEludmFsaWRDb2RlBAA5AQEYT3Bjb2RlAA8ALE91dE9mT2Zmc2V0AAgAIE91dE9mR2FzAAkAJE91dE9mRnVuZAAKACxQQ1VuZGVyZmxvdwALACxDcmVhdGVFbXB0eQAMABRPdGhlcgQAPQEBRENvdzwnc3RhdGljLCBzdHI+AA0AIE1heE5vbmNlAA4AADkBDCBldm1fY29yZRhvcGNvZGUYT3Bjb2RlAAAEAAgBCHU4AAA9AQQMQ293BARUAUEBAAQAQQEAAABBAQAABQIARQEMIGV2bV9jb3JlFGVycm9yKEV4aXRSZXZlcnQAAQQgUmV2ZXJ0ZWQAAAAASQEMIGV2bV9jb3JlFGVycm9yJEV4aXRGYXRhbAABEDBOb3RTdXBwb3J0ZWQAAABIVW5oYW5kbGVkSW50ZXJydXB0AAEAQENhbGxFcnJvckFzRmF0YWwEADUBASRFeGl0RXJyb3IAAgAUT3RoZXIEAD0BAURDb3c8J3N0YXRpYywgc3RyPgADAABNAQwocGFsbGV0X2V2bRhwYWxsZXQURXZlbnQEBFQAARQMTG9nBAEMbG9nUQEBDExvZwAABHxFdGhlcmV1bSBldmVudHMgZnJvbSBjb250cmFjdHMuHENyZWF0ZWQEARxhZGRyZXNzxAEQSDE2MAABBLRBIGNvbnRyYWN0IGhhcyBiZWVuIGNyZWF0ZWQgYXQgZ2l2ZW4gYWRkcmVzcy40Q3JlYXRlZEZhaWxlZAQBHGFkZHJlc3PEARBIMTYwAAIEBQFBIGNvbnRyYWN0IHdhcyBhdHRlbXB0ZWQgdG8gYmUgY3JlYXRlZCwgYnV0IHRoZSBleGVjdXRpb24gZmFpbGVkLiBFeGVjdXRlZAQBHGFkZHJlc3PEARBIMTYwAAME+EEgY29udHJhY3QgaGFzIGJlZW4gZXhlY3V0ZWQgc3VjY2Vzc2Z1bGx5IHdpdGggc3RhdGVzIGFwcGxpZWQuOEV4ZWN1dGVkRmFpbGVkBAEcYWRkcmVzc8QBEEgxNjAABARlAUEgY29udHJhY3QgaGFzIGJlZW4gZXhlY3V0ZWQgd2l0aCBlcnJvcnMuIFN0YXRlcyBhcmUgcmV2ZXJ0ZWQgd2l0aCBvbmx5IGdhcyBmZWVzIGFwcGxpZWQuBHxUaGUgYEV2ZW50YCBlbnVtIG9mIHRoaXMgcGFsbGV0UQEMIGV0aGVyZXVtDGxvZwxMb2cAAAwBHGFkZHJlc3PEARBIMTYwAAEYdG9waWNzuAEkVmVjPEgyNTY+AAEQZGF0YTgBFEJ5dGVzAABVAQw8cGFsbGV0X2Jhc2VfZmVlGHBhbGxldBRFdmVudAABDEBOZXdCYXNlRmVlUGVyR2FzBAEMZmVlWQEBEFUyNTYAAAA8QmFzZUZlZU92ZXJmbG93AAEANE5ld0VsYXN0aWNpdHkEAShlbGFzdGljaXR5YQEBHFBlcm1pbGwAAgAEfFRoZSBgRXZlbnRgIGVudW0gb2YgdGhpcyBwYWxsZXRZAQg8cHJpbWl0aXZlX3R5cGVzEFUyNTYAAAQAXQEBIFt1NjQ7IDRdAABdAQAAAwQAAAAYAGEBDDRzcF9hcml0aG1ldGljKHBlcl90aGluZ3McUGVybWlsbAAABAAQAQx1MzIAAGUBDDBwYWxsZXRfZHJhbmQYcGFsbGV0FEV2ZW50BARUAAEMTEJlYWNvbkNvbmZpZ0NoYW5nZWQAAASEQmVhY29uIENvbmZpZ3VyYXRpb24gaGFzIGNoYW5nZWQuIE5ld1B1bHNlBAEYcm91bmRzaQEBQFZlYzxSb3VuZE51bWJlcj4AAQSAU3VjY2Vzc2Z1bGx5IHNldCBhIG5ldyBwdWxzZShzKS5QU2V0T2xkZXN0U3RvcmVkUm91bmQEABgBDHU2NAACBIRPbGRlc3QgU3RvcmVkIFJvdW5kIGhhcyBiZWVuIHNldC4EfFRoZSBgRXZlbnRgIGVudW0gb2YgdGhpcyBwYWxsZXRpAQAAAhgAbQEMQHBhbGxldF9jcm93ZGxvYW4YcGFsbGV0FEV2ZW50BARUAAEoHENyZWF0ZWQQATBjcm93ZGxvYW5faWQQASxDcm93ZGxvYW5JZAABHGNyZWF0b3IAATBUOjpBY2NvdW50SWQAAQxlbmQQAURCbG9ja051bWJlckZvcjxUPgABDGNhcBgBMEJhbGFuY2VPZjxUPgAABGBBIGNyb3dkbG9hbiB3YXMgY3JlYXRlZC4sQ29udHJpYnV0ZWQMATBjcm93ZGxvYW5faWQQASxDcm93ZGxvYW5JZAABLGNvbnRyaWJ1dG9yAAEwVDo6QWNjb3VudElkAAEYYW1vdW50GAEwQmFsYW5jZU9mPFQ+AAEEvEEgY29udHJpYnV0aW9uIHdhcyBtYWRlIHRvIGFuIGFjdGl2ZSBjcm93ZGxvYW4uIFdpdGhkcmV3DAEwY3Jvd2Rsb2FuX2lkEAEsQ3Jvd2Rsb2FuSWQAASxjb250cmlidXRvcgABMFQ6OkFjY291bnRJZAABGGFtb3VudBgBMEJhbGFuY2VPZjxUPgACBNRBIGNvbnRyaWJ1dGlvbiB3YXMgd2l0aGRyYXduIGZyb20gYSBmYWlsZWQgY3Jvd2Rsb2FuLkRQYXJ0aWFsbHlSZWZ1bmRlZAQBMGNyb3dkbG9hbl9pZBABLENyb3dkbG9hbklkAAME4EEgcmVmdW5kIHdhcyBwYXJ0aWFsbHkgcHJvY2Vzc2VkIGZvciBhIGZhaWxlZCBjcm93ZGxvYW4uLEFsbFJlZnVuZGVkBAEwY3Jvd2Rsb2FuX2lkEAEsQ3Jvd2Rsb2FuSWQABATQQSByZWZ1bmQgd2FzIGZ1bGx5IHByb2Nlc3NlZCBmb3IgYSBmYWlsZWQgY3Jvd2Rsb2FuLiRGaW5hbGl6ZWQEATBjcm93ZGxvYW5faWQQASxDcm93ZGxvYW5JZAAFBDkBQSBjcm93ZGxvYW4gd2FzIGZpbmFsaXplZCwgZnVuZHMgd2VyZSB0cmFuc2ZlcnJlZCBhbmQgdGhlIGNhbGwgd2FzIGRpc3BhdGNoZWQuJERpc3NvbHZlZAQBMGNyb3dkbG9hbl9pZBABLENyb3dkbG9hbklkAAYEaEEgY3Jvd2Rsb2FuIHdhcyBkaXNzb2x2ZWQuWE1pbkNvbnRyaWJ1dGlvblVwZGF0ZWQIATBjcm93ZGxvYW5faWQQASxDcm93ZGxvYW5JZAABUG5ld19taW5fY29udHJpYnV0aW9uGAEwQmFsYW5jZU9mPFQ+AAcElFRoZSBtaW5pbXVtIGNvbnRyaWJ1dGlvbiB3YXMgdXBkYXRlZC4oRW5kVXBkYXRlZAgBMGNyb3dkbG9hbl9pZBABLENyb3dkbG9hbklkAAEcbmV3X2VuZBABREJsb2NrTnVtYmVyRm9yPFQ+AAgEUFRoZSBlbmQgd2FzIHVwZGF0ZWQuKENhcFVwZGF0ZWQIATBjcm93ZGxvYW5faWQQASxDcm93ZGxvYW5JZAABHG5ld19jYXAYATBCYWxhbmNlT2Y8VD4ACQRQVGhlIGNhcCB3YXMgdXBkYXRlZC4EfFRoZSBgRXZlbnRgIGVudW0gb2YgdGhpcyBwYWxsZXRxARBUcGFsbGV0X3N1YnRlbnNvcl9zd2FwGHBhbGxldBhwYWxsZXQURXZlbnQEBFQAARQoRmVlUmF0ZVNldAgBGG5ldHVpZKABGE5ldFVpZAABEHJhdGWgAQx1MTYAAAT0RXZlbnQgZW1pdHRlZCB3aGVuIHRoZSBmZWUgcmF0ZSBoYXMgYmVlbiB1cGRhdGVkIGZvciBhIHN1Ym5ldFBVc2VyTGlxdWlkaXR5VG9nZ2xlZAgBGG5ldHVpZKABGE5ldFVpZAABGGVuYWJsZSQBEGJvb2wAAQgZAUV2ZW50IGVtaXR0ZWQgd2hlbiB1c2VyIGxpcXVpZGl0eSBvcGVyYXRpb25zIGFyZSBlbmFibGVkIGZvciBhIHN1Ym5ldC7gRmlyc3QgZW5hYmxlIGV2ZW4gaW5kaWNhdGVzIGEgc3dpdGNoIGZyb20gVjIgdG8gVjMgc3dhcC44TGlxdWlkaXR5QWRkZWQkARxjb2xka2V5AAEwVDo6QWNjb3VudElkBKhUaGUgY29sZGtleSBhY2NvdW50IHRoYXQgb3ducyB0aGUgcG9zaXRpb24BGGhvdGtleQABMFQ6OkFjY291bnRJZASkVGhlIGhvdGtleSBhY2NvdW50IHdoZXJlIEFscGhhIGNvbWVzIGZyb20BGG5ldHVpZKABGE5ldFVpZARUVGhlIHN1Ym5ldCBpZGVudGlmaWVyASxwb3NpdGlvbl9pZHUBAShQb3NpdGlvbklkBLBVbmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIGxpcXVpZGl0eSBwb3NpdGlvbgEkbGlxdWlkaXR5GAEMdTY0BLRUaGUgYW1vdW50IG9mIGxpcXVpZGl0eSBhZGRlZCB0byB0aGUgcG9zaXRpb24BDHRhbxgBKFRhb0JhbGFuY2UEyFRoZSBhbW91bnQgb2YgVEFPIHRva2VucyBjb21taXR0ZWQgdG8gdGhlIHBvc2l0aW9uARRhbHBoYRgBMEFscGhhQmFsYW5jZQTQVGhlIGFtb3VudCBvZiBBbHBoYSB0b2tlbnMgY29tbWl0dGVkIHRvIHRoZSBwb3NpdGlvbgEgdGlja19sb3d5AQEkVGlja0luZGV4BDh0aGUgbG93ZXIgdGljawEkdGlja19oaWdoeQEBJFRpY2tJbmRleAQ4dGhlIHVwcGVyIHRpY2sCBDkBRXZlbnQgZW1pdHRlZCB3aGVuIGEgbGlxdWlkaXR5IHBvc2l0aW9uIGlzIGFkZGVkIHRvIGEgc3VibmV0J3MgbGlxdWlkaXR5IHBvb2wuQExpcXVpZGl0eVJlbW92ZWQsARxjb2xka2V5AAEwVDo6QWNjb3VudElkBKhUaGUgY29sZGtleSBhY2NvdW50IHRoYXQgb3ducyB0aGUgcG9zaXRpb24BGGhvdGtleQABMFQ6OkFjY291bnRJZASYVGhlIGhvdGtleSBhY2NvdW50IHdoZXJlIEFscGhhIGdvZXMgdG8BGG5ldHVpZKABGE5ldFVpZARUVGhlIHN1Ym5ldCBpZGVudGlmaWVyASxwb3NpdGlvbl9pZHUBAShQb3NpdGlvbklkBLBVbmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIGxpcXVpZGl0eSBwb3NpdGlvbgEkbGlxdWlkaXR5GAEMdTY0BMRUaGUgYW1vdW50IG9mIGxpcXVpZGl0eSByZW1vdmVkIGZyb20gdGhlIHBvc2l0aW9uAQx0YW8YAShUYW9CYWxhbmNlBLRUaGUgYW1vdW50IG9mIFRBTyB0b2tlbnMgcmV0dXJuZWQgdG8gdGhlIHVzZXIBFGFscGhhGAEwQWxwaGFCYWxhbmNlBLxUaGUgYW1vdW50IG9mIEFscGhhIHRva2VucyByZXR1cm5lZCB0byB0aGUgdXNlcgEcZmVlX3RhbxgBKFRhb0JhbGFuY2UEvFRoZSBhbW91bnQgb2YgVEFPIGZlZXMgZWFybmVkIGZyb20gdGhlIHBvc2l0aW9uASRmZWVfYWxwaGEYATBBbHBoYUJhbGFuY2UExFRoZSBhbW91bnQgb2YgQWxwaGEgZmVlcyBlYXJuZWQgZnJvbSB0aGUgcG9zaXRpb24BIHRpY2tfbG93eQEBJFRpY2tJbmRleAQ4dGhlIGxvd2VyIHRpY2sBJHRpY2tfaGlnaHkBASRUaWNrSW5kZXgEOHRoZSB1cHBlciB0aWNrAwRJAUV2ZW50IGVtaXR0ZWQgd2hlbiBhIGxpcXVpZGl0eSBwb3NpdGlvbiBpcyByZW1vdmVkIGZyb20gYSBzdWJuZXQncyBsaXF1aWRpdHkgcG9vbC5ETGlxdWlkaXR5TW9kaWZpZWQsARxjb2xka2V5AAEwVDo6QWNjb3VudElkBKhUaGUgY29sZGtleSBhY2NvdW50IHRoYXQgb3ducyB0aGUgcG9zaXRpb24BGGhvdGtleQABMFQ6OkFjY291bnRJZATQVGhlIGhvdGtleSBhY2NvdW50IHdoZXJlIEFscGhhIGNvbWVzIGZyb20gb3IgZ29lcyB0bwEYbmV0dWlkoAEYTmV0VWlkBFRUaGUgc3VibmV0IGlkZW50aWZpZXIBLHBvc2l0aW9uX2lkdQEBKFBvc2l0aW9uSWQEsFVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgbGlxdWlkaXR5IHBvc2l0aW9uASRsaXF1aWRpdHmBAQEMaTY0BPRUaGUgYW1vdW50IG9mIGxpcXVpZGl0eSBhZGRlZCB0byBvciByZW1vdmVkIGZyb20gdGhlIHBvc2l0aW9uAQx0YW+BAQEMaTY0BLRUaGUgYW1vdW50IG9mIFRBTyB0b2tlbnMgcmV0dXJuZWQgdG8gdGhlIHVzZXIBFGFscGhhgQEBDGk2NAS8VGhlIGFtb3VudCBvZiBBbHBoYSB0b2tlbnMgcmV0dXJuZWQgdG8gdGhlIHVzZXIBHGZlZV90YW8YAShUYW9CYWxhbmNlBLxUaGUgYW1vdW50IG9mIFRBTyBmZWVzIGVhcm5lZCBmcm9tIHRoZSBwb3NpdGlvbgEkZmVlX2FscGhhGAEwQWxwaGFCYWxhbmNlBMRUaGUgYW1vdW50IG9mIEFscGhhIGZlZXMgZWFybmVkIGZyb20gdGhlIHBvc2l0aW9uASB0aWNrX2xvd3kBASRUaWNrSW5kZXgEOHRoZSBsb3dlciB0aWNrASR0aWNrX2hpZ2h5AQEkVGlja0luZGV4BDh0aGUgdXBwZXIgdGljawQIRQFFdmVudCBlbWl0dGVkIHdoZW4gYSBsaXF1aWRpdHkgcG9zaXRpb24gaXMgbW9kaWZpZWQgaW4gYSBzdWJuZXQncyBsaXF1aWRpdHkgcG9vbC6gTW9kaWZ5aW5nIGNhdXNlcyB0aGUgZmVlcyB0byBiZSBjbGFpbWVkLgR8VGhlIGBFdmVudGAgZW51bSBvZiB0aGlzIHBhbGxldHUBDFRwYWxsZXRfc3VidGVuc29yX3N3YXAgcG9zaXRpb24oUG9zaXRpb25JZAAABAAgARB1MTI4AAB5AQxUcGFsbGV0X3N1YnRlbnNvcl9zd2FwEHRpY2skVGlja0luZGV4AAAEAH0BAQxpMzIAAH0BAAAFCwCBAQAABQwAhQEMQHBhbGxldF9jb250cmFjdHMYcGFsbGV0FEV2ZW50BARUAAEoMEluc3RhbnRpYXRlZAgBIGRlcGxveWVyAAEwVDo6QWNjb3VudElkAAEgY29udHJhY3QAATBUOjpBY2NvdW50SWQAAATYQ29udHJhY3QgZGVwbG95ZWQgYnkgYWRkcmVzcyBhdCB0aGUgc3BlY2lmaWVkIGFkZHJlc3MuKFRlcm1pbmF0ZWQIASBjb250cmFjdAABMFQ6OkFjY291bnRJZASEVGhlIGNvbnRyYWN0IHRoYXQgd2FzIHRlcm1pbmF0ZWQuASxiZW5lZmljaWFyeQABMFQ6OkFjY291bnRJZATkVGhlIGFjY291bnQgdGhhdCByZWNlaXZlZCB0aGUgY29udHJhY3RzIHJlbWFpbmluZyBiYWxhbmNlARhoQ29udHJhY3QgaGFzIGJlZW4gcmVtb3ZlZC4AGCMgTm90ZQA9AVRoZSBvbmx5IHdheSBmb3IgYSBjb250cmFjdCB0byBiZSByZW1vdmVkIGFuZCBlbWl0dGluZyB0aGlzIGV2ZW50IGlzIGJ5IGNhbGxpbmdEYHNlYWxfdGVybWluYXRlYC4oQ29kZVN0b3JlZAwBJGNvZGVfaGFzaDQBHFQ6Okhhc2gAATBkZXBvc2l0X2hlbGQYATBCYWxhbmNlT2Y8VD4AASB1cGxvYWRlcgABMFQ6OkFjY291bnRJZAACBLRDb2RlIHdpdGggdGhlIHNwZWNpZmllZCBoYXNoIGhhcyBiZWVuIHN0b3JlZC48Q29udHJhY3RFbWl0dGVkCAEgY29udHJhY3QAATBUOjpBY2NvdW50SWQEkFRoZSBjb250cmFjdCB0aGF0IGVtaXR0ZWQgdGhlIGV2ZW50LgEQZGF0YTgBHFZlYzx1OD4INQFEYXRhIHN1cHBsaWVkIGJ5IHRoZSBjb250cmFjdC4gTWV0YWRhdGEgZ2VuZXJhdGVkIGR1cmluZyBjb250cmFjdCBjb21waWxhdGlvblxpcyBuZWVkZWQgdG8gZGVjb2RlIGl0LgMEnEEgY3VzdG9tIGV2ZW50IGVtaXR0ZWQgYnkgdGhlIGNvbnRyYWN0LixDb2RlUmVtb3ZlZAwBJGNvZGVfaGFzaDQBHFQ6Okhhc2gAAUBkZXBvc2l0X3JlbGVhc2VkGAEwQmFsYW5jZU9mPFQ+AAEccmVtb3ZlcgABMFQ6OkFjY291bnRJZAAEBKxBIGNvZGUgd2l0aCB0aGUgc3BlY2lmaWVkIGhhc2ggd2FzIHJlbW92ZWQuTENvbnRyYWN0Q29kZVVwZGF0ZWQMASBjb250cmFjdAABMFQ6OkFjY291bnRJZASMVGhlIGNvbnRyYWN0IHRoYXQgaGFzIGJlZW4gdXBkYXRlZC4BNG5ld19jb2RlX2hhc2g0ARxUOjpIYXNoBLBOZXcgY29kZSBoYXNoIHRoYXQgd2FzIHNldCBmb3IgdGhlIGNvbnRyYWN0LgE0b2xkX2NvZGVfaGFzaDQBHFQ6Okhhc2gEjFByZXZpb3VzIGNvZGUgaGFzaCBvZiB0aGUgY29udHJhY3QuBQR4QSBjb250cmFjdCdzIGNvZGUgd2FzIHVwZGF0ZWQuGENhbGxlZAgBGGNhbGxlcokBASRPcmlnaW48VD4EdFRoZSBjYWxsZXIgb2YgdGhlIGBjb250cmFjdGAuASBjb250cmFjdAABMFQ6OkFjY291bnRJZAR0VGhlIGNvbnRyYWN0IHRoYXQgd2FzIGNhbGxlZC4GHBEBQSBjb250cmFjdCB3YXMgY2FsbGVkIGVpdGhlciBieSBhIHBsYWluIGFjY291bnQgb3IgYW5vdGhlciBjb250cmFjdC4AGCMgTm90ZQAxAVBsZWFzZSBrZWVwIGluIG1pbmQgdGhhdCBsaWtlIGFsbCBldmVudHMgdGhpcyBpcyBvbmx5IGVtaXR0ZWQgZm9yIHN1Y2Nlc3NmdWwpAWNhbGxzLiBUaGlzIGlzIGJlY2F1c2Ugb24gZmFpbHVyZSBhbGwgc3RvcmFnZSBjaGFuZ2VzIGluY2x1ZGluZyBldmVudHMgYXJlMHJvbGxlZCBiYWNrLjhEZWxlZ2F0ZUNhbGxlZAgBIGNvbnRyYWN0AAEwVDo6QWNjb3VudElkCCEBVGhlIGNvbnRyYWN0IHRoYXQgcGVyZm9ybWVkIHRoZSBkZWxlZ2F0ZSBjYWxsIGFuZCBoZW5jZSBpbiB3aG9zZSBjb250ZXh0cHRoZSBgY29kZV9oYXNoYCBpcyBleGVjdXRlZC4BJGNvZGVfaGFzaDQBLENvZGVIYXNoPFQ+BJxUaGUgY29kZSBoYXNoIHRoYXQgd2FzIGRlbGVnYXRlIGNhbGxlZC4HHJxBIGNvbnRyYWN0IGRlbGVnYXRlIGNhbGxlZCBhIGNvZGUgaGFzaC4AGCMgTm90ZQAxAVBsZWFzZSBrZWVwIGluIG1pbmQgdGhhdCBsaWtlIGFsbCBldmVudHMgdGhpcyBpcyBvbmx5IGVtaXR0ZWQgZm9yIHN1Y2Nlc3NmdWwpAWNhbGxzLiBUaGlzIGlzIGJlY2F1c2Ugb24gZmFpbHVyZSBhbGwgc3RvcmFnZSBjaGFuZ2VzIGluY2x1ZGluZyBldmVudHMgYXJlMHJvbGxlZCBiYWNrLoBTdG9yYWdlRGVwb3NpdFRyYW5zZmVycmVkQW5kSGVsZAwBEGZyb20AATBUOjpBY2NvdW50SWQAAQh0bwABMFQ6OkFjY291bnRJZAABGGFtb3VudBgBMEJhbGFuY2VPZjxUPgAIBPRTb21lIGZ1bmRzIGhhdmUgYmVlbiB0cmFuc2ZlcnJlZCBhbmQgaGVsZCBhcyBzdG9yYWdlIGRlcG9zaXQukFN0b3JhZ2VEZXBvc2l0VHJhbnNmZXJyZWRBbmRSZWxlYXNlZAwBEGZyb20AATBUOjpBY2NvdW50SWQAAQh0bwABMFQ6OkFjY291bnRJZAABGGFtb3VudBgBMEJhbGFuY2VPZjxUPgAJBPhTb21lIHN0b3JhZ2UgZGVwb3NpdCBmdW5kcyBoYXZlIGJlZW4gdHJhbnNmZXJyZWQgYW5kIHJlbGVhc2VkLgR8VGhlIGBFdmVudGAgZW51bSBvZiB0aGlzIHBhbGxldIkBCEBwYWxsZXRfY29udHJhY3RzGE9yaWdpbgQEVAGNAQEIEFJvb3QAAAAYU2lnbmVkBAAAATBUOjpBY2NvdW50SWQAAQAAjQEIWG5vZGVfc3VidGVuc29yX3J1bnRpbWUcUnVudGltZQAAAACRAQw0cGFsbGV0X3NoaWVsZBhwYWxsZXQURXZlbnQEBFQAARBIRW5jcnlwdGVkU3VibWl0dGVkCAEIaWQ0ARxUOjpIYXNoAAEMd2hvAAEwVDo6QWNjb3VudElkAAAEbEVuY3J5cHRlZCB3cmFwcGVyIGFjY2VwdGVkLkREZWNyeXB0ZWRFeGVjdXRlZAgBCGlkNAEcVDo6SGFzaAABGHNpZ25lcgABMFQ6OkFjY291bnRJZAABBGBEZWNyeXB0ZWQgY2FsbCBleGVjdXRlZC5ERGVjcnlwdGVkUmVqZWN0ZWQIAQhpZDQBHFQ6Okhhc2gAARhyZWFzb26VAQGsRGlzcGF0Y2hFcnJvcldpdGhQb3N0SW5mbzxQb3N0RGlzcGF0Y2hJbmZvPgACBHREZWNyeXB0ZWQgZXhlY3V0aW9uIHJlamVjdGVkLkBEZWNyeXB0aW9uRmFpbGVkCAEIaWQ0ARxUOjpIYXNoAAEYcmVhc29uoQEBdEJvdW5kZWRWZWM8dTgsIENvbnN0VTMyPDI1Nj4+AAME/ERlY3J5cHRpb24gZmFpbGVkIC0gdmFsaWRhdG9yIGNvdWxkIG5vdCBkZWNyeXB0IHRoZSBzdWJtaXNzaW9uLgR8VGhlIGBFdmVudGAgZW51bSBvZiB0aGlzIHBhbGxldJUBCChzcF9ydW50aW1lZERpc3BhdGNoRXJyb3JXaXRoUG9zdEluZm8EEEluZm8BmQEACAEkcG9zdF9pbmZvmQEBEEluZm8AARRlcnJvcmgBNERpc3BhdGNoRXJyb3IAAJkBDDRmcmFtZV9zdXBwb3J0IGRpc3BhdGNoQFBvc3REaXNwYXRjaEluZm8AAAgBNGFjdHVhbF93ZWlnaHSdAQE4T3B0aW9uPFdlaWdodD4AASBwYXlzX2ZlZWQBEFBheXMAAJ0BBBhPcHRpb24EBFQBLAEIEE5vbmUAAAAQU29tZQQALAAAAQAAoQEMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAEIBFMAAAQAOAEYVmVjPFQ+AAClAQgwZnJhbWVfc3lzdGVtFFBoYXNlAAEMOEFwcGx5RXh0cmluc2ljBAAQAQx1MzIAAAAwRmluYWxpemF0aW9uAAEAOEluaXRpYWxpemF0aW9uAAIAAKkBAAAC/ACtAQgwZnJhbWVfc3lzdGVtWExhc3RSdW50aW1lVXBncmFkZUluZm8AAAgBMHNwZWNfdmVyc2lvbrEBAUxjb2RlYzo6Q29tcGFjdDx1MzI+AAEkc3BlY19uYW1lPQEBRENvdzwnc3RhdGljLCBzdHI+AACxAQAABhAAtQEIMGZyYW1lX3N5c3RlbWBDb2RlVXBncmFkZUF1dGhvcml6YXRpb24EBFQAAAgBJGNvZGVfaGFzaDQBHFQ6Okhhc2gAATRjaGVja192ZXJzaW9uJAEQYm9vbAAAuQEMMGZyYW1lX3N5c3RlbRhwYWxsZXQQQ2FsbAQEVAABLBhyZW1hcmsEARhyZW1hcms4ARxWZWM8dTg+AAAMaE1ha2Ugc29tZSBvbi1jaGFpbiByZW1hcmsuAIhDYW4gYmUgZXhlY3V0ZWQgYnkgZXZlcnkgYG9yaWdpbmAuOHNldF9oZWFwX3BhZ2VzBAEUcGFnZXMYAQx1NjQAAQT4U2V0IHRoZSBudW1iZXIgb2YgcGFnZXMgaW4gdGhlIFdlYkFzc2VtYmx5IGVudmlyb25tZW50J3MgaGVhcC4gc2V0X2NvZGUEARBjb2RlOAEcVmVjPHU4PgACBGRTZXQgdGhlIG5ldyBydW50aW1lIGNvZGUuXHNldF9jb2RlX3dpdGhvdXRfY2hlY2tzBAEQY29kZTgBHFZlYzx1OD4AAxAZAVNldCB0aGUgbmV3IHJ1bnRpbWUgY29kZSB3aXRob3V0IGRvaW5nIGFueSBjaGVja3Mgb2YgdGhlIGdpdmVuIGBjb2RlYC4AUQFOb3RlIHRoYXQgcnVudGltZSB1cGdyYWRlcyB3aWxsIG5vdCBydW4gaWYgdGhpcyBpcyBjYWxsZWQgd2l0aCBhIG5vdC1pbmNyZWFzaW5nIHNwZWMgdmVyc2lvbiEsc2V0X3N0b3JhZ2UEARRpdGVtc70BATRWZWM8S2V5VmFsdWU+AAQEaFNldCBzb21lIGl0ZW1zIG9mIHN0b3JhZ2UuMGtpbGxfc3RvcmFnZQQBEGtleXPFAQEgVmVjPEtleT4ABQR0S2lsbCBzb21lIGl0ZW1zIGZyb20gc3RvcmFnZS4sa2lsbF9wcmVmaXgIARhwcmVmaXg4AQxLZXkAARxzdWJrZXlzEAEMdTMyAAYQEQFLaWxsIGFsbCBzdG9yYWdlIGl0ZW1zIHdpdGggYSBrZXkgdGhhdCBzdGFydHMgd2l0aCB0aGUgZ2l2ZW4gcHJlZml4LgA5ASoqTk9URToqKiBXZSByZWx5IG9uIHRoZSBSb290IG9yaWdpbiB0byBwcm92aWRlIHVzIHRoZSBudW1iZXIgb2Ygc3Via2V5cyB1bmRlcj0BdGhlIHByZWZpeCB3ZSBhcmUgcmVtb3ZpbmcgdG8gYWNjdXJhdGVseSBjYWxjdWxhdGUgdGhlIHdlaWdodCBvZiB0aGlzIGZ1bmN0aW9uLkRyZW1hcmtfd2l0aF9ldmVudAQBGHJlbWFyazgBHFZlYzx1OD4ABwSkTWFrZSBzb21lIG9uLWNoYWluIHJlbWFyayBhbmQgZW1pdCBldmVudC5EYXV0aG9yaXplX3VwZ3JhZGUEASRjb2RlX2hhc2g0ARxUOjpIYXNoAAkQYQFBdXRob3JpemUgYW4gdXBncmFkZSB0byBhIGdpdmVuIGBjb2RlX2hhc2hgIGZvciB0aGUgcnVudGltZS4gVGhlIHJ1bnRpbWUgY2FuIGJlIHN1cHBsaWVkGGxhdGVyLgB8VGhpcyBjYWxsIHJlcXVpcmVzIFJvb3Qgb3JpZ2luLoBhdXRob3JpemVfdXBncmFkZV93aXRob3V0X2NoZWNrcwQBJGNvZGVfaGFzaDQBHFQ6Okhhc2gACiBhAUF1dGhvcml6ZSBhbiB1cGdyYWRlIHRvIGEgZ2l2ZW4gYGNvZGVfaGFzaGAgZm9yIHRoZSBydW50aW1lLiBUaGUgcnVudGltZSBjYW4gYmUgc3VwcGxpZWQYbGF0ZXIuAF0BV0FSTklORzogVGhpcyBhdXRob3JpemVzIGFuIHVwZ3JhZGUgdGhhdCB3aWxsIHRha2UgcGxhY2Ugd2l0aG91dCBhbnkgc2FmZXR5IGNoZWNrcywgZm9yWQFleGFtcGxlIHRoYXQgdGhlIHNwZWMgbmFtZSByZW1haW5zIHRoZSBzYW1lIGFuZCB0aGF0IHRoZSB2ZXJzaW9uIG51bWJlciBpbmNyZWFzZXMuIE5vdPByZWNvbW1lbmRlZCBmb3Igbm9ybWFsIHVzZS4gVXNlIGBhdXRob3JpemVfdXBncmFkZWAgaW5zdGVhZC4AfFRoaXMgY2FsbCByZXF1aXJlcyBSb290IG9yaWdpbi5gYXBwbHlfYXV0aG9yaXplZF91cGdyYWRlBAEQY29kZTgBHFZlYzx1OD4ACyRVAVByb3ZpZGUgdGhlIHByZWltYWdlIChydW50aW1lIGJpbmFyeSkgYGNvZGVgIGZvciBhbiB1cGdyYWRlIHRoYXQgaGFzIGJlZW4gYXV0aG9yaXplZC4ASQFJZiB0aGUgYXV0aG9yaXphdGlvbiByZXF1aXJlZCBhIHZlcnNpb24gY2hlY2ssIHRoaXMgY2FsbCB3aWxsIGVuc3VyZSB0aGUgc3BlYyBuYW1l6HJlbWFpbnMgdW5jaGFuZ2VkIGFuZCB0aGF0IHRoZSBzcGVjIHZlcnNpb24gaGFzIGluY3JlYXNlZC4AWQFEZXBlbmRpbmcgb24gdGhlIHJ1bnRpbWUncyBgT25TZXRDb2RlYCBjb25maWd1cmF0aW9uLCB0aGlzIGZ1bmN0aW9uIG1heSBkaXJlY3RseSBhcHBseREBdGhlIG5ldyBgY29kZWAgaW4gdGhlIHNhbWUgYmxvY2sgb3IgYXR0ZW1wdCB0byBzY2hlZHVsZSB0aGUgdXBncmFkZS4AYEFsbCBvcmlnaW5zIGFyZSBhbGxvd2VkLgQNAUNvbnRhaW5zIGEgdmFyaWFudCBwZXIgZGlzcGF0Y2hhYmxlIGV4dHJpbnNpYyB0aGF0IHRoaXMgcGFsbGV0IGhhcy69AQAAAsEBAMEBAAAECDg4AMUBAAACOADJAQwwZnJhbWVfc3lzdGVtGGxpbWl0czBCbG9ja1dlaWdodHMAAAwBKGJhc2VfYmxvY2ssARhXZWlnaHQAASRtYXhfYmxvY2ssARhXZWlnaHQAASRwZXJfY2xhc3PNAQGEUGVyRGlzcGF0Y2hDbGFzczxXZWlnaHRzUGVyQ2xhc3M+AADNAQw0ZnJhbWVfc3VwcG9ydCBkaXNwYXRjaEBQZXJEaXNwYXRjaENsYXNzBARUAdEBAAwBGG5vcm1hbNEBAQRUAAEsb3BlcmF0aW9uYWzRAQEEVAABJG1hbmRhdG9yedEBAQRUAADRAQwwZnJhbWVfc3lzdGVtGGxpbWl0czxXZWlnaHRzUGVyQ2xhc3MAABABOGJhc2VfZXh0cmluc2ljLAEYV2VpZ2h0AAE0bWF4X2V4dHJpbnNpY50BAThPcHRpb248V2VpZ2h0PgABJG1heF90b3RhbJ0BAThPcHRpb248V2VpZ2h0PgABIHJlc2VydmVknQEBOE9wdGlvbjxXZWlnaHQ+AADVAQwwZnJhbWVfc3lzdGVtGGxpbWl0cyxCbG9ja0xlbmd0aAAABAEMbWF42QEBVFBlckRpc3BhdGNoQ2xhc3M8dTMyPgAA2QEMNGZyYW1lX3N1cHBvcnQgZGlzcGF0Y2hAUGVyRGlzcGF0Y2hDbGFzcwQEVAEQAAwBGG5vcm1hbBABBFQAASxvcGVyYXRpb25hbBABBFQAASRtYW5kYXRvcnkQAQRUAADdAQgoc3Bfd2VpZ2h0czxSdW50aW1lRGJXZWlnaHQAAAgBEHJlYWQYAQx1NjQAARR3cml0ZRgBDHU2NAAA4QEIKHNwX3ZlcnNpb244UnVudGltZVZlcnNpb24AACABJHNwZWNfbmFtZT0BAURDb3c8J3N0YXRpYywgc3RyPgABJGltcGxfbmFtZT0BAURDb3c8J3N0YXRpYywgc3RyPgABRGF1dGhvcmluZ192ZXJzaW9uEAEMdTMyAAEwc3BlY192ZXJzaW9uEAEMdTMyAAEwaW1wbF92ZXJzaW9uEAEMdTMyAAEQYXBpc+UBARxBcGlzVmVjAAFMdHJhbnNhY3Rpb25fdmVyc2lvbhABDHUzMgABOHN5c3RlbV92ZXJzaW9uCAEIdTgAAOUBBAxDb3cEBFQB6QEABADpAQAAAOkBAAAC7QEA7QEAAAQI8QEQAPEBAAADCAAAAAgA9QEMMGZyYW1lX3N5c3RlbRhwYWxsZXQURXJyb3IEBFQAASQ8SW52YWxpZFNwZWNOYW1lAAAIEQFUaGUgbmFtZSBvZiBzcGVjaWZpY2F0aW9uIGRvZXMgbm90IG1hdGNoIGJldHdlZW4gdGhlIGN1cnJlbnQgcnVudGltZVBhbmQgdGhlIG5ldyBydW50aW1lLmhTcGVjVmVyc2lvbk5lZWRzVG9JbmNyZWFzZQABCEEBVGhlIHNwZWNpZmljYXRpb24gdmVyc2lvbiBpcyBub3QgYWxsb3dlZCB0byBkZWNyZWFzZSBiZXR3ZWVuIHRoZSBjdXJyZW50IHJ1bnRpbWVQYW5kIHRoZSBuZXcgcnVudGltZS50RmFpbGVkVG9FeHRyYWN0UnVudGltZVZlcnNpb24AAgzsRmFpbGVkIHRvIGV4dHJhY3QgdGhlIHJ1bnRpbWUgdmVyc2lvbiBmcm9tIHRoZSBuZXcgcnVudGltZS4ACQFFaXRoZXIgY2FsbGluZyBgQ29yZV92ZXJzaW9uYCBvciBkZWNvZGluZyBgUnVudGltZVZlcnNpb25gIGZhaWxlZC5MTm9uRGVmYXVsdENvbXBvc2l0ZQADBPxTdWljaWRlIGNhbGxlZCB3aGVuIHRoZSBhY2NvdW50IGhhcyBub24tZGVmYXVsdCBjb21wb3NpdGUgZGF0YS48Tm9uWmVyb1JlZkNvdW50AAQENQFUaGVyZSBpcyBhIG5vbi16ZXJvIHJlZmVyZW5jZSBjb3VudCBwcmV2ZW50aW5nIHRoZSBhY2NvdW50IGZyb20gYmVpbmcgcHVyZ2VkLjBDYWxsRmlsdGVyZWQABQTQVGhlIG9yaWdpbiBmaWx0ZXIgcHJldmVudCB0aGUgY2FsbCB0byBiZSBkaXNwYXRjaGVkLmxNdWx0aUJsb2NrTWlncmF0aW9uc09uZ29pbmcABgRVAUEgbXVsdGktYmxvY2sgbWlncmF0aW9uIGlzIG9uZ29pbmcgYW5kIHByZXZlbnRzIHRoZSBjdXJyZW50IGNvZGUgZnJvbSBiZWluZyByZXBsYWNlZC5ETm90aGluZ0F1dGhvcml6ZWQABwRYTm8gdXBncmFkZSBhdXRob3JpemVkLjBVbmF1dGhvcml6ZWQACASUVGhlIHN1Ym1pdHRlZCBjb2RlIGlzIG5vdCBhdXRob3JpemVkLgRsRXJyb3IgZm9yIHRoZSBTeXN0ZW0gcGFsbGV0+QEIWG5vZGVfc3VidGVuc29yX3J1bnRpbWUsUnVudGltZUNhbGwAAVwYU3lzdGVtBAC5AQGtAXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxTeXN0ZW0sIFJ1bnRpbWU+AAAAJFRpbWVzdGFtcAQA/QEBuQFzZWxmOjpzcF9hcGlfaGlkZGVuX2luY2x1ZGVzX2NvbnN0cnVjdF9ydW50aW1lOjpoaWRkZW5faW5jbHVkZTo6ZGlzcGF0Y2gKOjpDYWxsYWJsZUNhbGxGb3I8VGltZXN0YW1wLCBSdW50aW1lPgACABxHcmFuZHBhBAABAgGxAXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxHcmFuZHBhLCBSdW50aW1lPgAEACBCYWxhbmNlcwQAMQIBtQFzZWxmOjpzcF9hcGlfaGlkZGVuX2luY2x1ZGVzX2NvbnN0cnVjdF9ydW50aW1lOjpoaWRkZW5faW5jbHVkZTo6ZGlzcGF0Y2gKOjpDYWxsYWJsZUNhbGxGb3I8QmFsYW5jZXMsIFJ1bnRpbWU+AAUAPFN1YnRlbnNvck1vZHVsZQQASQIB0QFzZWxmOjpzcF9hcGlfaGlkZGVuX2luY2x1ZGVzX2NvbnN0cnVjdF9ydW50aW1lOjpoaWRkZW5faW5jbHVkZTo6ZGlzcGF0Y2gKOjpDYWxsYWJsZUNhbGxGb3I8U3VidGVuc29yTW9kdWxlLCBSdW50aW1lPgAHABxVdGlsaXR5BACFAgGxAXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxVdGlsaXR5LCBSdW50aW1lPgALABBTdWRvBACZAgGlAXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxTdWRvLCBSdW50aW1lPgAMACBNdWx0aXNpZwQAnQIBtQFzZWxmOjpzcF9hcGlfaGlkZGVuX2luY2x1ZGVzX2NvbnN0cnVjdF9ydW50aW1lOjpoaWRkZW5faW5jbHVkZTo6ZGlzcGF0Y2gKOjpDYWxsYWJsZUNhbGxGb3I8TXVsdGlzaWcsIFJ1bnRpbWU+AA0AIFByZWltYWdlBAClAgG1AXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxQcmVpbWFnZSwgUnVudGltZT4ADgAkU2NoZWR1bGVyBACpAgG5AXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxTY2hlZHVsZXIsIFJ1bnRpbWU+AA8AFFByb3h5BACxAgGpAXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxQcm94eSwgUnVudGltZT4AEAAgUmVnaXN0cnkEALkCAbUBc2VsZjo6c3BfYXBpX2hpZGRlbl9pbmNsdWRlc19jb25zdHJ1Y3RfcnVudGltZTo6aGlkZGVuX2luY2x1ZGU6OmRpc3BhdGNoCjo6Q2FsbGFibGVDYWxsRm9yPFJlZ2lzdHJ5LCBSdW50aW1lPgARACxDb21taXRtZW50cwQAxQMBwQFzZWxmOjpzcF9hcGlfaGlkZGVuX2luY2x1ZGVzX2NvbnN0cnVjdF9ydW50aW1lOjpoaWRkZW5faW5jbHVkZTo6ZGlzcGF0Y2gKOjpDYWxsYWJsZUNhbGxGb3I8Q29tbWl0bWVudHMsIFJ1bnRpbWU+ABIAKEFkbWluVXRpbHMEAN0EAb0Bc2VsZjo6c3BfYXBpX2hpZGRlbl9pbmNsdWRlc19jb25zdHJ1Y3RfcnVudGltZTo6aGlkZGVuX2luY2x1ZGU6OmRpc3BhdGNoCjo6Q2FsbGFibGVDYWxsRm9yPEFkbWluVXRpbHMsIFJ1bnRpbWU+ABMAIFNhZmVNb2RlBAAtBQG1AXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxTYWZlTW9kZSwgUnVudGltZT4AFAAgRXRoZXJldW0EADEFAbUBc2VsZjo6c3BfYXBpX2hpZGRlbl9pbmNsdWRlc19jb25zdHJ1Y3RfcnVudGltZTo6aGlkZGVuX2luY2x1ZGU6OmRpc3BhdGNoCjo6Q2FsbGFibGVDYWxsRm9yPEV0aGVyZXVtLCBSdW50aW1lPgAVAAxFVk0EAG0FAaEBc2VsZjo6c3BfYXBpX2hpZGRlbl9pbmNsdWRlc19jb25zdHJ1Y3RfcnVudGltZTo6aGlkZGVuX2luY2x1ZGU6OmRpc3BhdGNoCjo6Q2FsbGFibGVDYWxsRm9yPEVWTSwgUnVudGltZT4AFgAcQmFzZUZlZQQAgQUBsQFzZWxmOjpzcF9hcGlfaGlkZGVuX2luY2x1ZGVzX2NvbnN0cnVjdF9ydW50aW1lOjpoaWRkZW5faW5jbHVkZTo6ZGlzcGF0Y2gKOjpDYWxsYWJsZUNhbGxGb3I8QmFzZUZlZSwgUnVudGltZT4AGQAURHJhbmQEAIUFAakBc2VsZjo6c3BfYXBpX2hpZGRlbl9pbmNsdWRlc19jb25zdHJ1Y3RfcnVudGltZTo6aGlkZGVuX2luY2x1ZGU6OmRpc3BhdGNoCjo6Q2FsbGFibGVDYWxsRm9yPERyYW5kLCBSdW50aW1lPgAaACRDcm93ZGxvYW4EALkFAbkBc2VsZjo6c3BfYXBpX2hpZGRlbl9pbmNsdWRlc19jb25zdHJ1Y3RfcnVudGltZTo6aGlkZGVuX2luY2x1ZGU6OmRpc3BhdGNoCjo6Q2FsbGFibGVDYWxsRm9yPENyb3dkbG9hbiwgUnVudGltZT4AGwAQU3dhcAQAwQUBpQFzZWxmOjpzcF9hcGlfaGlkZGVuX2luY2x1ZGVzX2NvbnN0cnVjdF9ydW50aW1lOjpoaWRkZW5faW5jbHVkZTo6ZGlzcGF0Y2gKOjpDYWxsYWJsZUNhbGxGb3I8U3dhcCwgUnVudGltZT4AHAAkQ29udHJhY3RzBADFBQG5AXNlbGY6OnNwX2FwaV9oaWRkZW5faW5jbHVkZXNfY29uc3RydWN0X3J1bnRpbWU6OmhpZGRlbl9pbmNsdWRlOjpkaXNwYXRjaAo6OkNhbGxhYmxlQ2FsbEZvcjxDb250cmFjdHMsIFJ1bnRpbWU+AB0AJE1ldlNoaWVsZAQA0QUBuQFzZWxmOjpzcF9hcGlfaGlkZGVuX2luY2x1ZGVzX2NvbnN0cnVjdF9ydW50aW1lOjpoaWRkZW5faW5jbHVkZTo6ZGlzcGF0Y2gKOjpDYWxsYWJsZUNhbGxGb3I8TWV2U2hpZWxkLCBSdW50aW1lPgAeAAD9AQxAcGFsbGV0X3RpbWVzdGFtcBhwYWxsZXQQQ2FsbAQEVAABBAxzZXQEAQxub3cwASRUOjpNb21lbnQAAExUU2V0IHRoZSBjdXJyZW50IHRpbWUuAFUBVGhpcyBjYWxsIHNob3VsZCBiZSBpbnZva2VkIGV4YWN0bHkgb25jZSBwZXIgYmxvY2suIEl0IHdpbGwgcGFuaWMgYXQgdGhlIGZpbmFsaXphdGlvbtRwaGFzZSwgaWYgdGhpcyBjYWxsIGhhc24ndCBiZWVuIGludm9rZWQgYnkgdGhhdCB0aW1lLgBBAVRoZSB0aW1lc3RhbXAgc2hvdWxkIGJlIGdyZWF0ZXIgdGhhbiB0aGUgcHJldmlvdXMgb25lIGJ5IHRoZSBhbW91bnQgc3BlY2lmaWVkIGJ5aFtgQ29uZmlnOjpNaW5pbXVtUGVyaW9kYF0uAMRUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfTm9uZV8uAFEBVGhpcyBkaXNwYXRjaCBjbGFzcyBpcyBfTWFuZGF0b3J5XyB0byBlbnN1cmUgaXQgZ2V0cyBleGVjdXRlZCBpbiB0aGUgYmxvY2suIEJlIGF3YXJlUQF0aGF0IGNoYW5naW5nIHRoZSBjb21wbGV4aXR5IG9mIHRoaXMgY2FsbCBjb3VsZCByZXN1bHQgZXhoYXVzdGluZyB0aGUgcmVzb3VyY2VzIGluIGGEYmxvY2sgdG8gZXhlY3V0ZSBhbnkgb3RoZXIgY2FsbHMuADQjIyBDb21wbGV4aXR5MQEtIGBPKDEpYCAoTm90ZSB0aGF0IGltcGxlbWVudGF0aW9ucyBvZiBgT25UaW1lc3RhbXBTZXRgIG11c3QgYWxzbyBiZSBgTygxKWApVQEtIDEgc3RvcmFnZSByZWFkIGFuZCAxIHN0b3JhZ2UgbXV0YXRpb24gKGNvZGVjIGBPKDEpYCBiZWNhdXNlIG9mIGBEaWRVcGRhdGU6OnRha2VgIGluQCAgYG9uX2ZpbmFsaXplYCnULSAxIGV2ZW50IGhhbmRsZXIgYG9uX3RpbWVzdGFtcF9zZXRgLiBNdXN0IGJlIGBPKDEpYC4EDQFDb250YWlucyBhIHZhcmlhbnQgcGVyIGRpc3BhdGNoYWJsZSBleHRyaW5zaWMgdGhhdCB0aGlzIHBhbGxldCBoYXMuAQIMOHBhbGxldF9ncmFuZHBhGHBhbGxldBBDYWxsBARUAAEMTHJlcG9ydF9lcXVpdm9jYXRpb24IAUhlcXVpdm9jYXRpb25fcHJvb2YFAgHIQm94PEVxdWl2b2NhdGlvblByb29mPFQ6Okhhc2gsIEJsb2NrTnVtYmVyRm9yPFQ+Pj4AATxrZXlfb3duZXJfcHJvb2YtAgFAVDo6S2V5T3duZXJQcm9vZgAAEAkBUmVwb3J0IHZvdGVyIGVxdWl2b2NhdGlvbi9taXNiZWhhdmlvci4gVGhpcyBtZXRob2Qgd2lsbCB2ZXJpZnkgdGhl9GVxdWl2b2NhdGlvbiBwcm9vZiBhbmQgdmFsaWRhdGUgdGhlIGdpdmVuIGtleSBvd25lcnNoaXAgcHJvb2b4YWdhaW5zdCB0aGUgZXh0cmFjdGVkIG9mZmVuZGVyLiBJZiBib3RoIGFyZSB2YWxpZCwgdGhlIG9mZmVuY2VEd2lsbCBiZSByZXBvcnRlZC5wcmVwb3J0X2VxdWl2b2NhdGlvbl91bnNpZ25lZAgBSGVxdWl2b2NhdGlvbl9wcm9vZgUCAchCb3g8RXF1aXZvY2F0aW9uUHJvb2Y8VDo6SGFzaCwgQmxvY2tOdW1iZXJGb3I8VD4+PgABPGtleV9vd25lcl9wcm9vZi0CAUBUOjpLZXlPd25lclByb29mAAEkCQFSZXBvcnQgdm90ZXIgZXF1aXZvY2F0aW9uL21pc2JlaGF2aW9yLiBUaGlzIG1ldGhvZCB3aWxsIHZlcmlmeSB0aGX0ZXF1aXZvY2F0aW9uIHByb29mIGFuZCB2YWxpZGF0ZSB0aGUgZ2l2ZW4ga2V5IG93bmVyc2hpcCBwcm9vZvhhZ2FpbnN0IHRoZSBleHRyYWN0ZWQgb2ZmZW5kZXIuIElmIGJvdGggYXJlIHZhbGlkLCB0aGUgb2ZmZW5jZUR3aWxsIGJlIHJlcG9ydGVkLgANAVRoaXMgZXh0cmluc2ljIG11c3QgYmUgY2FsbGVkIHVuc2lnbmVkIGFuZCBpdCBpcyBleHBlY3RlZCB0aGF0IG9ubHkVAWJsb2NrIGF1dGhvcnMgd2lsbCBjYWxsIGl0ICh2YWxpZGF0ZWQgaW4gYFZhbGlkYXRlVW5zaWduZWRgKSwgYXMgc3VjaBUBaWYgdGhlIGJsb2NrIGF1dGhvciBpcyBkZWZpbmVkIGl0IHdpbGwgYmUgZGVmaW5lZCBhcyB0aGUgZXF1aXZvY2F0aW9uJHJlcG9ydGVyLjBub3RlX3N0YWxsZWQIARRkZWxheRABREJsb2NrTnVtYmVyRm9yPFQ+AAFsYmVzdF9maW5hbGl6ZWRfYmxvY2tfbnVtYmVyEAFEQmxvY2tOdW1iZXJGb3I8VD4AAjA9AU5vdGUgdGhhdCB0aGUgY3VycmVudCBhdXRob3JpdHkgc2V0IG9mIHRoZSBHUkFORFBBIGZpbmFsaXR5IGdhZGdldCBoYXMgc3RhbGxlZC4AYQFUaGlzIHdpbGwgdHJpZ2dlciBhIGZvcmNlZCBhdXRob3JpdHkgc2V0IGNoYW5nZSBhdCB0aGUgYmVnaW5uaW5nIG9mIHRoZSBuZXh0IHNlc3Npb24sIHRvYQFiZSBlbmFjdGVkIGBkZWxheWAgYmxvY2tzIGFmdGVyIHRoYXQuIFRoZSBgZGVsYXlgIHNob3VsZCBiZSBoaWdoIGVub3VnaCB0byBzYWZlbHkgYXNzdW1lSQF0aGF0IHRoZSBibG9jayBzaWduYWxsaW5nIHRoZSBmb3JjZWQgY2hhbmdlIHdpbGwgbm90IGJlIHJlLW9yZ2VkIGUuZy4gMTAwMCBibG9ja3MuXQFUaGUgYmxvY2sgcHJvZHVjdGlvbiByYXRlICh3aGljaCBtYXkgYmUgc2xvd2VkIGRvd24gYmVjYXVzZSBvZiBmaW5hbGl0eSBsYWdnaW5nKSBzaG91bGRRAWJlIHRha2VuIGludG8gYWNjb3VudCB3aGVuIGNob29zaW5nIHRoZSBgZGVsYXlgLiBUaGUgR1JBTkRQQSB2b3RlcnMgYmFzZWQgb24gdGhlIG5ld1UBYXV0aG9yaXR5IHdpbGwgc3RhcnQgdm90aW5nIG9uIHRvcCBvZiBgYmVzdF9maW5hbGl6ZWRfYmxvY2tfbnVtYmVyYCBmb3IgbmV3IGZpbmFsaXplZE0BYmxvY2tzLiBgYmVzdF9maW5hbGl6ZWRfYmxvY2tfbnVtYmVyYCBzaG91bGQgYmUgdGhlIGhpZ2hlc3Qgb2YgdGhlIGxhdGVzdCBmaW5hbGl6ZWTEYmxvY2sgb2YgYWxsIHZhbGlkYXRvcnMgb2YgdGhlIG5ldyBhdXRob3JpdHkgc2V0LgBYT25seSBjYWxsYWJsZSBieSByb290LgQNAUNvbnRhaW5zIGEgdmFyaWFudCBwZXIgZGlzcGF0Y2hhYmxlIGV4dHJpbnNpYyB0aGF0IHRoaXMgcGFsbGV0IGhhcy4FAghQc3BfY29uc2Vuc3VzX2dyYW5kcGFERXF1aXZvY2F0aW9uUHJvb2YIBEgBNAROARAACAEYc2V0X2lkGAEUU2V0SWQAATBlcXVpdm9jYXRpb24JAgFIRXF1aXZvY2F0aW9uPEgsIE4+AAAJAghQc3BfY29uc2Vuc3VzX2dyYW5kcGEwRXF1aXZvY2F0aW9uCARIATQETgEQAQgcUHJldm90ZQQADQIBiQFmaW5hbGl0eV9ncmFuZHBhOjpFcXVpdm9jYXRpb248QXV0aG9yaXR5SWQsIGZpbmFsaXR5X2dyYW5kcGE6OlByZXZvdGU8CkgsIE4+LCBBdXRob3JpdHlTaWduYXR1cmUsPgAAACRQcmVjb21taXQEACECAZEBZmluYWxpdHlfZ3JhbmRwYTo6RXF1aXZvY2F0aW9uPEF1dGhvcml0eUlkLCBmaW5hbGl0eV9ncmFuZHBhOjpQcmVjb21taXQKPEgsIE4+LCBBdXRob3JpdHlTaWduYXR1cmUsPgABAAANAghAZmluYWxpdHlfZ3JhbmRwYTBFcXVpdm9jYXRpb24MCElkAYwEVgERAgRTARUCABABMHJvdW5kX251bWJlchgBDHU2NAABIGlkZW50aXR5jAEISWQAARRmaXJzdB0CARgoViwgUykAARhzZWNvbmQdAgEYKFYsIFMpAAARAghAZmluYWxpdHlfZ3JhbmRwYRxQcmV2b3RlCARIATQETgEQAAgBLHRhcmdldF9oYXNoNAEESAABNHRhcmdldF9udW1iZXIQAQROAAAVAgxQc3BfY29uc2Vuc3VzX2dyYW5kcGEMYXBwJFNpZ25hdHVyZQAABAAZAgFIZWQyNTUxOTo6U2lnbmF0dXJlAAAZAgAAA0AAAAAIAB0CAAAECBECFQIAIQIIQGZpbmFsaXR5X2dyYW5kcGEwRXF1aXZvY2F0aW9uDAhJZAGMBFYBJQIEUwEVAgAQATByb3VuZF9udW1iZXIYAQx1NjQAASBpZGVudGl0eYwBCElkAAEUZmlyc3QpAgEYKFYsIFMpAAEYc2Vjb25kKQIBGChWLCBTKQAAJQIIQGZpbmFsaXR5X2dyYW5kcGEkUHJlY29tbWl0CARIATQETgEQAAgBLHRhcmdldF9oYXNoNAEESAABNHRhcmdldF9udW1iZXIQAQROAAApAgAABAglAhUCAC0CCBxzcF9jb3JlEFZvaWQAAQAAMQIMPHBhbGxldF9iYWxhbmNlcxhwYWxsZXQQQ2FsbAgEVAAESQABJFB0cmFuc2Zlcl9hbGxvd19kZWF0aAgBEGRlc3Q1AgFQQWNjb3VudElkTG9va3VwT2Y8VD4AARR2YWx1ZT0CAShUOjpCYWxhbmNlAAAc1FRyYW5zZmVyIHNvbWUgbGlxdWlkIGZyZWUgYmFsYW5jZSB0byBhbm90aGVyIGFjY291bnQuADUBYHRyYW5zZmVyX2FsbG93X2RlYXRoYCB3aWxsIHNldCB0aGUgYEZyZWVCYWxhbmNlYCBvZiB0aGUgc2VuZGVyIGFuZCByZWNlaXZlci4RAUlmIHRoZSBzZW5kZXIncyBhY2NvdW50IGlzIGJlbG93IHRoZSBleGlzdGVudGlhbCBkZXBvc2l0IGFzIGEgcmVzdWx0sG9mIHRoZSB0cmFuc2ZlciwgdGhlIGFjY291bnQgd2lsbCBiZSByZWFwZWQuABUBVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgYFNpZ25lZGAgYnkgdGhlIHRyYW5zYWN0b3IuOGZvcmNlX3RyYW5zZmVyDAEYc291cmNlNQIBUEFjY291bnRJZExvb2t1cE9mPFQ+AAEQZGVzdDUCAVBBY2NvdW50SWRMb29rdXBPZjxUPgABFHZhbHVlPQIBKFQ6OkJhbGFuY2UAAghhAUV4YWN0bHkgYXMgYHRyYW5zZmVyX2FsbG93X2RlYXRoYCwgZXhjZXB0IHRoZSBvcmlnaW4gbXVzdCBiZSByb290IGFuZCB0aGUgc291cmNlIGFjY291bnREbWF5IGJlIHNwZWNpZmllZC5MdHJhbnNmZXJfa2VlcF9hbGl2ZQgBEGRlc3Q1AgFQQWNjb3VudElkTG9va3VwT2Y8VD4AARR2YWx1ZT0CAShUOjpCYWxhbmNlAAMYWQFTYW1lIGFzIHRoZSBbYHRyYW5zZmVyX2FsbG93X2RlYXRoYF0gY2FsbCwgYnV0IHdpdGggYSBjaGVjayB0aGF0IHRoZSB0cmFuc2ZlciB3aWxsIG5vdGBraWxsIHRoZSBvcmlnaW4gYWNjb3VudC4A6Dk5JSBvZiB0aGUgdGltZSB5b3Ugd2FudCBbYHRyYW5zZmVyX2FsbG93X2RlYXRoYF0gaW5zdGVhZC4A8FtgdHJhbnNmZXJfYWxsb3dfZGVhdGhgXTogc3RydWN0LlBhbGxldC5odG1sI21ldGhvZC50cmFuc2ZlcjB0cmFuc2Zlcl9hbGwIARBkZXN0NQIBUEFjY291bnRJZExvb2t1cE9mPFQ+AAEoa2VlcF9hbGl2ZSQBEGJvb2wABDwFAVRyYW5zZmVyIHRoZSBlbnRpcmUgdHJhbnNmZXJhYmxlIGJhbGFuY2UgZnJvbSB0aGUgY2FsbGVyIGFjY291bnQuAFkBTk9URTogVGhpcyBmdW5jdGlvbiBvbmx5IGF0dGVtcHRzIHRvIHRyYW5zZmVyIF90cmFuc2ZlcmFibGVfIGJhbGFuY2VzLiBUaGlzIG1lYW5zIHRoYXRhAWFueSBsb2NrZWQsIHJlc2VydmVkLCBvciBleGlzdGVudGlhbCBkZXBvc2l0cyAod2hlbiBga2VlcF9hbGl2ZWAgaXMgYHRydWVgKSwgd2lsbCBub3QgYmVdAXRyYW5zZmVycmVkIGJ5IHRoaXMgZnVuY3Rpb24uIFRvIGVuc3VyZSB0aGF0IHRoaXMgZnVuY3Rpb24gcmVzdWx0cyBpbiBhIGtpbGxlZCBhY2NvdW50LEUBeW91IG1pZ2h0IG5lZWQgdG8gcHJlcGFyZSB0aGUgYWNjb3VudCBieSByZW1vdmluZyBhbnkgcmVmZXJlbmNlIGNvdW50ZXJzLCBzdG9yYWdlQGRlcG9zaXRzLCBldGMuLi4AwFRoZSBkaXNwYXRjaCBvcmlnaW4gb2YgdGhpcyBjYWxsIG11c3QgYmUgU2lnbmVkLgCgLSBgZGVzdGA6IFRoZSByZWNpcGllbnQgb2YgdGhlIHRyYW5zZmVyLlkBLSBga2VlcF9hbGl2ZWA6IEEgYm9vbGVhbiB0byBkZXRlcm1pbmUgaWYgdGhlIGB0cmFuc2Zlcl9hbGxgIG9wZXJhdGlvbiBzaG91bGQgc2VuZCBhbGxNASAgb2YgdGhlIGZ1bmRzIHRoZSBhY2NvdW50IGhhcywgY2F1c2luZyB0aGUgc2VuZGVyIGFjY291bnQgdG8gYmUga2lsbGVkIChmYWxzZSksIG9yWQEgIHRyYW5zZmVyIGV2ZXJ5dGhpbmcgZXhjZXB0IGF0IGxlYXN0IHRoZSBleGlzdGVudGlhbCBkZXBvc2l0LCB3aGljaCB3aWxsIGd1YXJhbnRlZSB0b5wgIGtlZXAgdGhlIHNlbmRlciBhY2NvdW50IGFsaXZlICh0cnVlKS48Zm9yY2VfdW5yZXNlcnZlCAEMd2hvNQIBUEFjY291bnRJZExvb2t1cE9mPFQ+AAEYYW1vdW50GAEoVDo6QmFsYW5jZQAFDLBVbnJlc2VydmUgc29tZSBiYWxhbmNlIGZyb20gYSB1c2VyIGJ5IGZvcmNlLgBsQ2FuIG9ubHkgYmUgY2FsbGVkIGJ5IFJPT1QuQHVwZ3JhZGVfYWNjb3VudHMEAQx3aG9BAgFEVmVjPFQ6OkFjY291bnRJZD4ABiBwVXBncmFkZSBhIHNwZWNpZmllZCBhY2NvdW50LgB0LSBgb3JpZ2luYDogTXVzdCBiZSBgU2lnbmVkYC6QLSBgd2hvYDogVGhlIGFjY291bnQgdG8gYmUgdXBncmFkZWQuAFUBVGhpcyB3aWxsIHdhaXZlIHRoZSB0cmFuc2FjdGlvbiBmZWUgaWYgYXQgbGVhc3QgYWxsIGJ1dCAxMCUgb2YgdGhlIGFjY291bnRzIG5lZWRlZCB0b0EBYmUgdXBncmFkZWQuIChXZSBsZXQgc29tZSBub3QgaGF2ZSB0byBiZSB1cGdyYWRlZCBqdXN0IGluIG9yZGVyIHRvIGFsbG93IGZvciB0aGVYcG9zc2liaWxpdHkgb2YgY2h1cm4pLkRmb3JjZV9zZXRfYmFsYW5jZQgBDHdobzUCAVBBY2NvdW50SWRMb29rdXBPZjxUPgABIG5ld19mcmVlPQIBKFQ6OkJhbGFuY2UACAysU2V0IHRoZSByZWd1bGFyIGJhbGFuY2Ugb2YgYSBnaXZlbiBhY2NvdW50LgCwVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIGlzIGByb290YC5sZm9yY2VfYWRqdXN0X3RvdGFsX2lzc3VhbmNlCAEkZGlyZWN0aW9uRQIBTEFkanVzdG1lbnREaXJlY3Rpb24AARRkZWx0YT0CAShUOjpCYWxhbmNlAAkUuEFkanVzdCB0aGUgdG90YWwgaXNzdWFuY2UgaW4gYSBzYXR1cmF0aW5nIHdheS4A/ENhbiBvbmx5IGJlIGNhbGxlZCBieSByb290IGFuZCBhbHdheXMgbmVlZHMgYSBwb3NpdGl2ZSBgZGVsdGFgLgAkIyBFeGFtcGxlEGJ1cm4IARR2YWx1ZT0CAShUOjpCYWxhbmNlAAEoa2VlcF9hbGl2ZSQBEGJvb2wAChz8QnVybiB0aGUgc3BlY2lmaWVkIGxpcXVpZCBmcmVlIGJhbGFuY2UgZnJvbSB0aGUgb3JpZ2luIGFjY291bnQuACUBSWYgdGhlIG9yaWdpbidzIGFjY291bnQgZW5kcyB1cCBiZWxvdyB0aGUgZXhpc3RlbnRpYWwgZGVwb3NpdCBhcyBhIHJlc3VsdAkBb2YgdGhlIGJ1cm4gYW5kIGBrZWVwX2FsaXZlYCBpcyBmYWxzZSwgdGhlIGFjY291bnQgd2lsbCBiZSByZWFwZWQuAFEBVW5saWtlIHNlbmRpbmcgZnVuZHMgdG8gYSBfYnVybl8gYWRkcmVzcywgd2hpY2ggbWVyZWx5IG1ha2VzIHRoZSBmdW5kcyBpbmFjY2Vzc2libGUsIQF0aGlzIGBidXJuYCBvcGVyYXRpb24gd2lsbCByZWR1Y2UgdG90YWwgaXNzdWFuY2UgYnkgdGhlIGFtb3VudCBfYnVybmVkXy4EDQFDb250YWlucyBhIHZhcmlhbnQgcGVyIGRpc3BhdGNoYWJsZSBleHRyaW5zaWMgdGhhdCB0aGlzIHBhbGxldCBoYXMuNQIMKHNwX3J1bnRpbWUwbXVsdGlhZGRyZXNzME11bHRpQWRkcmVzcwgkQWNjb3VudElkAQAwQWNjb3VudEluZGV4AawBFAhJZAQAAAEkQWNjb3VudElkAAAAFEluZGV4BAA5AgEwQWNjb3VudEluZGV4AAEADFJhdwQAOAEcVmVjPHU4PgACACRBZGRyZXNzMzIEAAQBIFt1ODsgMzJdAAMAJEFkZHJlc3MyMAQAyAEgW3U4OyAyMF0ABAAAOQIAAAasAD0CAAAGGABBAgAAAgAARQIMPHBhbGxldF9iYWxhbmNlcxR0eXBlc0xBZGp1c3RtZW50RGlyZWN0aW9uAAEIIEluY3JlYXNlAAAAIERlY3JlYXNlAAEAAEkCDEBwYWxsZXRfc3VidGVuc29yGHBhbGxldBBDYWxsBARUAAERASxzZXRfd2VpZ2h0cxABGG5ldHVpZKABGE5ldFVpZAABFGRlc3RzTQIBIFZlYzx1MTY+AAEcd2VpZ2h0c00CASBWZWM8dTE2PgABLHZlcnNpb25fa2V5GAEMdTY0AADoIQEtLS0gU2V0cyB0aGUgY2FsbGVyIHdlaWdodHMgZm9yIHRoZSBpbmNlbnRpdmUgbWVjaGFuaXNtLiBUaGUgY2FsbCBjYW4gYmUxAW1hZGUgZnJvbSB0aGUgaG90a2V5IGFjY291bnQgc28gaXMgcG90ZW50aWFsbHkgaW5zZWN1cmUsIGhvd2V2ZXIsIHRoZSBkYW1hZ2U5AW9mIGNoYW5naW5nIHdlaWdodHMgaXMgbWluaW1hbCBpZiBjYXVnaHQgZWFybHkuIFRoaXMgZnVuY3Rpb24gaW5jbHVkZXMgYWxsIHRoZU0BY2hlY2tzIHRoYXQgdGhlIHBhc3NlZCB3ZWlnaHRzIG1lZXQgdGhlIHJlcXVpcmVtZW50cy4gU3RvcmVkIGFzIHUxNnMgdGhleSByZXByZXNlbnQtAXJhdGlvbmFsIHZhbHVlcyBpbiB0aGUgcmFuZ2UgWzAsMV0gd2hpY2ggc3VtIHRvIDEgYW5kIGNhbiBiZSBpbnRlcnByZXRlZCBhczkBcHJvYmFiaWxpdGllcy4gVGhlIHNwZWNpZmljIHdlaWdodHMgZGV0ZXJtaW5lIGhvdyBpbmZsYXRpb24gcHJvcGFnYXRlcyBvdXR3YXJkPGZyb20gdGhpcyBwZWVyLgAZAU5vdGU6IFRoZSAxNiBiaXQgaW50ZWdlcnMgd2VpZ2h0cyBzaG91bGQgcmVwcmVzZW50IDEuMCBhcyB0aGUgbWF4IHUxNi6JAUhvd2V2ZXIsIHRoZSBmdW5jdGlvbiBub3JtYWxpemVzIGFsbCBpbnRlZ2VycyB0byB1MTZfbWF4IGFueXdheS4gVGhpcyBtZWFucyB0aGF0IGlmIHRoZSBzdW0gb2YgYWxsRQFlbGVtZW50cyBpcyBsYXJnZXIgb3Igc21hbGxlciB0aGFuIHRoZSBhbW91bnQgb2YgZWxlbWVudHMgKiB1MTZfbWF4LCBhbGwgZWxlbWVudHOUd2lsbCBiZSBjb3JyZWN0ZWQgZm9yIHRoaXMgZGV2aWF0aW9uLgAcIyBBcmdzOsAqIGBvcmlnaW5gOiAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+T3JpZ2luKTrsICAgIC0gVGhlIGNhbGxlciwgYSBob3RrZXkgd2hvIHdpc2hlcyB0byBzZXQgdGhlaXIgd2VpZ2h0cy4ARCogYG5ldHVpZGAgKHUxNik6zAktIFRoZSBuZXR3b3JrIHVpZCB3ZSBhcmUgc2V0dGluZyB0aGVzZSB3ZWlnaHRzIG9uLgBUKiBgZGVzdHNgIChWZWM8dTE2Pik61AktIFRoZSBlZGdlIGVuZHBvaW50IGZvciB0aGUgd2VpZ2h0LCBpLmUuIGogZm9yIHdfaWouAFwqICd3ZWlnaHRzJyAoVmVjPHUxNj4pOuwJLSBUaGUgdTE2IGludGVnZXIgZW5jb2RlZCB3ZWlnaHRzLiBJbnRlcnByZXRlZCBhcyByYXRpb25hbOggICAgdmFsdWVzIGluIHRoZSByYW5nZSBbMCwxXS4gVGhleSBtdXN0IHN1bSB0byBpbjMyOjpNQVguAGAqICd2ZXJzaW9uX2tleScgKCB1NjQgKToNAQktIFRoZSBuZXR3b3JrIHZlcnNpb24ga2V5IHRvIGNoZWNrIGlmIHRoZSB2YWxpZGF0b3IgaXMgdXAgdG8gZGF0ZS4AICMgRXZlbnQ6NCogV2VpZ2h0c1NldDvACS0gT24gc3VjY2Vzc2Z1bGx5IHNldHRpbmcgdGhlIHdlaWdodHMgb24gY2hhaW4uACQjIFJhaXNlczpoKiAnTWVjaGFuaXNtRG9lc05vdEV4aXN0JzrcCS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyBvbiBhIG5vbi1leGlzdGVudCBuZXR3b3JrLgBIKiAnTm90UmVnaXN0ZXJlZCc67AktIEF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgZnJvbSBhIG5vbiByZWdpc3RlcmVkIGFjY291bnQuAGgqICdXZWlnaHRWZWNOb3RFcXVhbFNpemUnOugJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIHdpdGggdWlkcyBub3Qgb2Ygc2FtZSBsZW5ndGguAEgqICdEdXBsaWNhdGVVaWRzJzrECS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyB3aXRoIGR1cGxpY2F0ZSB1aWRzLgCUICAgICogJ1VpZHNMZW5ndGhFeGNlZWRVaWRzSW5TdWJOZXQnOuAJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIGFib3ZlIHRoZSBtYXggYWxsb3dlZCB1aWRzLgBwKiAnVWlkVmVjQ29udGFpbkludmFsaWRPbmUnOrwJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIHdpdGggaW52YWxpZCB1aWRzLgBkKiAnV2VpZ2h0VmVjTGVuZ3RoSXNMb3cnOuQJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIHdpdGggZmV3ZXIgd2VpZ2h0cyB0aGFuIG1pbi4AWCogJ01heFdlaWdodEV4Y2VlZGVkJzrwCS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyB3aXRoIG1heCB2YWx1ZSBleGNlZWRpbmcgbGltaXQuVHNldF9tZWNoYW5pc21fd2VpZ2h0cxQBGG5ldHVpZKABGE5ldFVpZAABFG1lY2lkCAEYTWVjaElkAAEUZGVzdHNNAgEgVmVjPHUxNj4AARx3ZWlnaHRzTQIBIFZlYzx1MTY+AAEsdmVyc2lvbl9rZXkYAQx1NjQAd/RBAS0tLSBTZXRzIHRoZSBjYWxsZXIgd2VpZ2h0cyBmb3IgdGhlIGluY2VudGl2ZSBtZWNoYW5pc20gZm9yIG1lY2hhbmlzbXMuIFRoZSBjYWxsTQFjYW4gYmUgbWFkZSBmcm9tIHRoZSBob3RrZXkgYWNjb3VudCBzbyBpcyBwb3RlbnRpYWxseSBpbnNlY3VyZSwgaG93ZXZlciwgdGhlIGRhbWFnZTkBb2YgY2hhbmdpbmcgd2VpZ2h0cyBpcyBtaW5pbWFsIGlmIGNhdWdodCBlYXJseS4gVGhpcyBmdW5jdGlvbiBpbmNsdWRlcyBhbGwgdGhlTQFjaGVja3MgdGhhdCB0aGUgcGFzc2VkIHdlaWdodHMgbWVldCB0aGUgcmVxdWlyZW1lbnRzLiBTdG9yZWQgYXMgdTE2cyB0aGV5IHJlcHJlc2VudC0BcmF0aW9uYWwgdmFsdWVzIGluIHRoZSByYW5nZSBbMCwxXSB3aGljaCBzdW0gdG8gMSBhbmQgY2FuIGJlIGludGVycHJldGVkIGFzOQFwcm9iYWJpbGl0aWVzLiBUaGUgc3BlY2lmaWMgd2VpZ2h0cyBkZXRlcm1pbmUgaG93IGluZmxhdGlvbiBwcm9wYWdhdGVzIG91dHdhcmQ8ZnJvbSB0aGlzIHBlZXIuABkBTm90ZTogVGhlIDE2IGJpdCBpbnRlZ2VycyB3ZWlnaHRzIHNob3VsZCByZXByZXNlbnQgMS4wIGFzIHRoZSBtYXggdTE2LokBSG93ZXZlciwgdGhlIGZ1bmN0aW9uIG5vcm1hbGl6ZXMgYWxsIGludGVnZXJzIHRvIHUxNl9tYXggYW55d2F5LiBUaGlzIG1lYW5zIHRoYXQgaWYgdGhlIHN1bSBvZiBhbGxFAWVsZW1lbnRzIGlzIGxhcmdlciBvciBzbWFsbGVyIHRoYW4gdGhlIGFtb3VudCBvZiBlbGVtZW50cyAqIHUxNl9tYXgsIGFsbCBlbGVtZW50c5R3aWxsIGJlIGNvcnJlY3RlZCBmb3IgdGhpcyBkZXZpYXRpb24uABwjIEFyZ3M6wCogYG9yaWdpbmA6ICg8VCBhcyBmcmFtZV9zeXN0ZW06OkNvbmZpZz5PcmlnaW4pOuwgICAgLSBUaGUgY2FsbGVyLCBhIGhvdGtleSB3aG8gd2lzaGVzIHRvIHNldCB0aGVpciB3ZWlnaHRzLgBEKiBgbmV0dWlkYCAodTE2KTrMCS0gVGhlIG5ldHdvcmsgdWlkIHdlIGFyZSBzZXR0aW5nIHRoZXNlIHdlaWdodHMgb24uAEQqIGBtZWNpZGAgKGB1OGApOnwgIC0gVGhlIHU4IG1lY2huaXNtIGlkZW50aWZpZXIuAFQqIGBkZXN0c2AgKFZlYzx1MTY+KTrUCS0gVGhlIGVkZ2UgZW5kcG9pbnQgZm9yIHRoZSB3ZWlnaHQsIGkuZS4gaiBmb3Igd19pai4AXCogJ3dlaWdodHMnIChWZWM8dTE2Pik67AktIFRoZSB1MTYgaW50ZWdlciBlbmNvZGVkIHdlaWdodHMuIEludGVycHJldGVkIGFzIHJhdGlvbmFs6CAgICB2YWx1ZXMgaW4gdGhlIHJhbmdlIFswLDFdLiBUaGV5IG11c3Qgc3VtIHRvIGluMzI6Ok1BWC4AYCogJ3ZlcnNpb25fa2V5JyAoIHU2NCApOg0BCS0gVGhlIG5ldHdvcmsgdmVyc2lvbiBrZXkgdG8gY2hlY2sgaWYgdGhlIHZhbGlkYXRvciBpcyB1cCB0byBkYXRlLgAgIyBFdmVudDo0KiBXZWlnaHRzU2V0O8AJLSBPbiBzdWNjZXNzZnVsbHkgc2V0dGluZyB0aGUgd2VpZ2h0cyBvbiBjaGFpbi4AJCMgUmFpc2VzOmgqICdNZWNoYW5pc21Eb2VzTm90RXhpc3QnOtwJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIG9uIGEgbm9uLWV4aXN0ZW50IG5ldHdvcmsuAEgqICdOb3RSZWdpc3RlcmVkJzrsCS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyBmcm9tIGEgbm9uIHJlZ2lzdGVyZWQgYWNjb3VudC4AaCogJ1dlaWdodFZlY05vdEVxdWFsU2l6ZSc66AktIEF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgd2l0aCB1aWRzIG5vdCBvZiBzYW1lIGxlbmd0aC4ASCogJ0R1cGxpY2F0ZVVpZHMnOsQJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIHdpdGggZHVwbGljYXRlIHVpZHMuAJQgICAgKiAnVWlkc0xlbmd0aEV4Y2VlZFVpZHNJblN1Yk5ldCc64AktIEF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgYWJvdmUgdGhlIG1heCBhbGxvd2VkIHVpZHMuAHAqICdVaWRWZWNDb250YWluSW52YWxpZE9uZSc6vAktIEF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgd2l0aCBpbnZhbGlkIHVpZHMuAGQqICdXZWlnaHRWZWNMZW5ndGhJc0xvdyc65AktIEF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgd2l0aCBmZXdlciB3ZWlnaHRzIHRoYW4gbWluLgBYKiAnTWF4V2VpZ2h0RXhjZWVkZWQnOvAJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIHdpdGggbWF4IHZhbHVlIGV4Y2VlZGluZyBsaW1pdC5EYmF0Y2hfc2V0X3dlaWdodHMMARxuZXR1aWRzvAFQVmVjPENvbXBhY3Q8TmV0VWlkPj4AARx3ZWlnaHRzUQIBmFZlYzxWZWM8KENvbXBhY3Q8dTE2PiwgQ29tcGFjdDx1MTY+KT4+AAEwdmVyc2lvbl9rZXlzYQIBRFZlYzxDb21wYWN0PHU2ND4+AFBkDQEtLS0gQWxsb3dzIGEgaG90a2V5IHRvIHNldCB3ZWlnaHRzIGZvciBtdWx0aXBsZSBuZXR1aWRzIGFzIGEgYmF0Y2guABwjIEFyZ3M6wCogYG9yaWdpbmA6ICg8VCBhcyBmcmFtZV9zeXN0ZW06OkNvbmZpZz5PcmlnaW4pOuwgICAgLSBUaGUgY2FsbGVyLCBhIGhvdGtleSB3aG8gd2lzaGVzIHRvIHNldCB0aGVpciB3ZWlnaHRzLgCAKiBgbmV0dWlkc2AgKFZlYzxDb21wYWN0PHUxNj4+KTrQCS0gVGhlIG5ldHdvcmsgdWlkcyB3ZSBhcmUgc2V0dGluZyB0aGVzZSB3ZWlnaHRzIG9uLgDQKiBgd2VpZ2h0c2AgKFZlYzxWZWM8KENvbXBhY3Q8dTE2PiwgQ29tcGFjdDx1MTY+KT4pOvAJLSBUaGUgd2VpZ2h0cyB0byBzZXQgZm9yIGVhY2ggbmV0d29yay4gWyh1aWQsIHdlaWdodCksIC4uLl0AlCogYHZlcnNpb25fa2V5c2AgKFZlYzxDb21wYWN0PHU2ND4+KToRAQktIFRoZSBuZXR3b3JrIHZlcnNpb24ga2V5cyB0byBjaGVjayBpZiB0aGUgdmFsaWRhdG9yIGlzIHVwIHRvIGRhdGUuACAjIEV2ZW50OjQqIFdlaWdodHNTZXQ7wAktIE9uIHN1Y2Nlc3NmdWxseSBzZXR0aW5nIHRoZSB3ZWlnaHRzIG9uIGNoYWluLmAqIEJhdGNoV2VpZ2h0c0NvbXBsZXRlZDtsCS0gT24gc3VjY2VzcyBvZiB0aGUgYmF0Y2gubCogQmF0Y2hDb21wbGV0ZWRXaXRoRXJyb3JzO8QJLSBPbiBmYWlsdXJlIG9mIGFueSBvZiB0aGUgd2VpZ2h0cyBpbiB0aGUgYmF0Y2guYCogQmF0Y2hXZWlnaHRJdGVtRmFpbGVkO8AJLSBPbiBmYWlsdXJlIGZvciBlYWNoIGZhaWxlZCBpdGVtIGluIHRoZSBiYXRjaC4AOGNvbW1pdF93ZWlnaHRzCAEYbmV0dWlkoAEYTmV0VWlkAAEsY29tbWl0X2hhc2g0ARBIMjU2AGBMGQEtLS0tIFVzZWQgdG8gY29tbWl0IGEgaGFzaCBvZiB5b3VyIHdlaWdodCB2YWx1ZXMgdG8gbGF0ZXIgYmUgcmV2ZWFsZWQuABwjIEFyZ3M67CogYG9yaWdpbmA6IChgPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+OjpSdW50aW1lT3JpZ2luYCk6rCAgLSBUaGUgc2lnbmF0dXJlIG9mIHRoZSBjb21taXR0aW5nIGhvdGtleS4ATCogYG5ldHVpZGAgKGB1MTZgKTp8ICAtIFRoZSB1MTYgbmV0d29yayBpZGVudGlmaWVyLgBkKiBgY29tbWl0X2hhc2hgIChgSDI1NmApOsAgIC0gVGhlIGhhc2ggcmVwcmVzZW50aW5nIHRoZSBjb21taXR0ZWQgd2VpZ2h0cy4AJCMgUmFpc2VzOmQqIGBDb21taXRSZXZlYWxEaXNhYmxlZGA6GQEgIC0gQXR0ZW1wdGluZyB0byBjb21taXQgd2hlbiB0aGUgY29tbWl0LXJldmVhbCBtZWNoYW5pc20gaXMgZGlzYWJsZWQuAHQqIGBUb29NYW55VW5yZXZlYWxlZENvbW1pdHNgOnUBICAtIEF0dGVtcHRpbmcgdG8gY29tbWl0IHdoZW4gdGhlIHVzZXIgaGFzIG1vcmUgdGhhbiB0aGUgYWxsb3dlZCBsaW1pdCBvZiB1bnJldmVhbGVkIGNvbW1pdHMuAGBjb21taXRfbWVjaGFuaXNtX3dlaWdodHMMARhuZXR1aWSgARhOZXRVaWQAARRtZWNpZAgBGE1lY2hJZAABLGNvbW1pdF9oYXNoNAEQSDI1NgBzWFUBLS0tLSBVc2VkIHRvIGNvbW1pdCBhIGhhc2ggb2YgeW91ciB3ZWlnaHQgdmFsdWVzIHRvIGxhdGVyIGJlIHJldmVhbGVkIGZvciBtZWNoYW5pc21zLgAcIyBBcmdzOuwqIGBvcmlnaW5gOiAoYDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6UnVudGltZU9yaWdpbmApOqwgIC0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY29tbWl0dGluZyBob3RrZXkuAEwqIGBuZXR1aWRgIChgdTE2YCk6fCAgLSBUaGUgdTE2IG5ldHdvcmsgaWRlbnRpZmllci4ARCogYG1lY2lkYCAoYHU4YCk6gCAgLSBUaGUgdTggbWVjaGFuaXNtIGlkZW50aWZpZXIuAGQqIGBjb21taXRfaGFzaGAgKGBIMjU2YCk6wCAgLSBUaGUgaGFzaCByZXByZXNlbnRpbmcgdGhlIGNvbW1pdHRlZCB3ZWlnaHRzLgAkIyBSYWlzZXM6ZCogYENvbW1pdFJldmVhbERpc2FibGVkYDoZASAgLSBBdHRlbXB0aW5nIHRvIGNvbW1pdCB3aGVuIHRoZSBjb21taXQtcmV2ZWFsIG1lY2hhbmlzbSBpcyBkaXNhYmxlZC4AdCogYFRvb01hbnlVbnJldmVhbGVkQ29tbWl0c2A6dQEgIC0gQXR0ZW1wdGluZyB0byBjb21taXQgd2hlbiB0aGUgdXNlciBoYXMgbW9yZSB0aGFuIHRoZSBhbGxvd2VkIGxpbWl0IG9mIHVucmV2ZWFsZWQgY29tbWl0cy4AUGJhdGNoX2NvbW1pdF93ZWlnaHRzCAEcbmV0dWlkc7wBUFZlYzxDb21wYWN0PE5ldFVpZD4+AAE0Y29tbWl0X2hhc2hlc7gBJFZlYzxIMjU2PgBkWDEBLS0tIEFsbG93cyBhIGhvdGtleSB0byBjb21taXQgd2VpZ2h0IGhhc2hlcyBmb3IgbXVsdGlwbGUgbmV0dWlkcyBhcyBhIGJhdGNoLgAcIyBBcmdzOsAqIGBvcmlnaW5gOiAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+T3JpZ2luKTrsICAgIC0gVGhlIGNhbGxlciwgYSBob3RrZXkgd2hvIHdpc2hlcyB0byBzZXQgdGhlaXIgd2VpZ2h0cy4AgCogYG5ldHVpZHNgIChWZWM8Q29tcGFjdDx1MTY+Pik60AktIFRoZSBuZXR3b3JrIHVpZHMgd2UgYXJlIHNldHRpbmcgdGhlc2Ugd2VpZ2h0cyBvbi4AeCogYGNvbW1pdF9oYXNoZXNgIChWZWM8SDI1Nj4pOnwJLSBUaGUgY29tbWl0IGhhc2hlcyB0byBjb21taXQuACAjIEV2ZW50OjQqIFdlaWdodHNTZXQ7wAktIE9uIHN1Y2Nlc3NmdWxseSBzZXR0aW5nIHRoZSB3ZWlnaHRzIG9uIGNoYWluLmAqIEJhdGNoV2VpZ2h0c0NvbXBsZXRlZDtsCS0gT24gc3VjY2VzcyBvZiB0aGUgYmF0Y2gubCogQmF0Y2hDb21wbGV0ZWRXaXRoRXJyb3JzO8QJLSBPbiBmYWlsdXJlIG9mIGFueSBvZiB0aGUgd2VpZ2h0cyBpbiB0aGUgYmF0Y2guYCogQmF0Y2hXZWlnaHRJdGVtRmFpbGVkO8AJLSBPbiBmYWlsdXJlIGZvciBlYWNoIGZhaWxlZCBpdGVtIGluIHRoZSBiYXRjaC4AOHJldmVhbF93ZWlnaHRzFAEYbmV0dWlkoAEYTmV0VWlkAAEQdWlkc00CASBWZWM8dTE2PgABGHZhbHVlc00CASBWZWM8dTE2PgABEHNhbHRNAgEgVmVjPHUxNj4AASx2ZXJzaW9uX2tleRgBDHU2NABhlAEBLS0tLSBVc2VkIHRvIHJldmVhbCB0aGUgd2VpZ2h0cyBmb3IgYSBwcmV2aW91c2x5IGNvbW1pdHRlZCBoYXNoLgAcIyBBcmdzOuwqIGBvcmlnaW5gOiAoYDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6UnVudGltZU9yaWdpbmApOqggIC0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgcmV2ZWFsaW5nIGhvdGtleS4ATCogYG5ldHVpZGAgKGB1MTZgKTp8ICAtIFRoZSB1MTYgbmV0d29yayBpZGVudGlmaWVyLgBYKiBgdWlkc2AgKGBWZWM8dTE2PmApOrAgIC0gVGhlIHVpZHMgZm9yIHRoZSB3ZWlnaHRzIGJlaW5nIHJldmVhbGVkLgBgKiBgdmFsdWVzYCAoYFZlYzx1MTY+YCk6tCAgLSBUaGUgdmFsdWVzIG9mIHRoZSB3ZWlnaHRzIGJlaW5nIHJldmVhbGVkLgBYKiBgc2FsdGAgKGBWZWM8dTE2PmApOrggIC0gVGhlIHNhbHQgdXNlZCB0byBnZW5lcmF0ZSB0aGUgY29tbWl0IGhhc2guAGAqIGB2ZXJzaW9uX2tleWAgKGB1NjRgKTpwICAtIFRoZSBuZXR3b3JrIHZlcnNpb24ga2V5LgAkIyBSYWlzZXM6ZCogYENvbW1pdFJldmVhbERpc2FibGVkYDo5ASAgLSBBdHRlbXB0aW5nIHRvIHJldmVhbCB3ZWlnaHRzIHdoZW4gdGhlIGNvbW1pdC1yZXZlYWwgbWVjaGFuaXNtIGlzIGRpc2FibGVkLgBkKiBgTm9XZWlnaHRzQ29tbWl0Rm91bmRgOvAgIC0gQXR0ZW1wdGluZyB0byByZXZlYWwgd2VpZ2h0cyB3aXRob3V0IGFuIGV4aXN0aW5nIGNvbW1pdC4AYCogYEV4cGlyZWRXZWlnaHRDb21taXRgOuggIC0gQXR0ZW1wdGluZyB0byByZXZlYWwgYSB3ZWlnaHQgY29tbWl0IHRoYXQgaGFzIGV4cGlyZWQuAEwqIGBSZXZlYWxUb29FYXJseWA6BQEgIC0gQXR0ZW1wdGluZyB0byByZXZlYWwgd2VpZ2h0cyBvdXRzaWRlIHRoZSB2YWxpZCByZXZlYWwgcGVyaW9kLgCQKiBgSW52YWxpZFJldmVhbENvbW1pdEhhc2hOb3RNYXRjaGA64CAgLSBUaGUgcmV2ZWFsZWQgaGFzaCBkb2VzIG5vdCBtYXRjaCBhbnkgY29tbWl0dGVkIGhhc2guAGByZXZlYWxfbWVjaGFuaXNtX3dlaWdodHMYARhuZXR1aWSgARhOZXRVaWQAARRtZWNpZAgBGE1lY2hJZAABEHVpZHNNAgEgVmVjPHUxNj4AARh2YWx1ZXNNAgEgVmVjPHUxNj4AARBzYWx0TQIBIFZlYzx1MTY+AAEsdmVyc2lvbl9rZXkYAQx1NjQAdKA9AS0tLS0gVXNlZCB0byByZXZlYWwgdGhlIHdlaWdodHMgZm9yIGEgcHJldmlvdXNseSBjb21taXR0ZWQgaGFzaCBmb3IgbWVjaGFuaXNtcy4AHCMgQXJnczrsKiBgb3JpZ2luYDogKGA8VCBhcyBmcmFtZV9zeXN0ZW06OkNvbmZpZz46OlJ1bnRpbWVPcmlnaW5gKTqoICAtIFRoZSBzaWduYXR1cmUgb2YgdGhlIHJldmVhbGluZyBob3RrZXkuAEwqIGBuZXR1aWRgIChgdTE2YCk6fCAgLSBUaGUgdTE2IG5ldHdvcmsgaWRlbnRpZmllci4ARCogYG1lY2lkYCAoYHU4YCk6gCAgLSBUaGUgdTggbWVjaGFuaXNtIGlkZW50aWZpZXIuAFgqIGB1aWRzYCAoYFZlYzx1MTY+YCk6sCAgLSBUaGUgdWlkcyBmb3IgdGhlIHdlaWdodHMgYmVpbmcgcmV2ZWFsZWQuAGAqIGB2YWx1ZXNgIChgVmVjPHUxNj5gKTq0ICAtIFRoZSB2YWx1ZXMgb2YgdGhlIHdlaWdodHMgYmVpbmcgcmV2ZWFsZWQuAFgqIGBzYWx0YCAoYFZlYzx1MTY+YCk6uCAgLSBUaGUgc2FsdCB1c2VkIHRvIGdlbmVyYXRlIHRoZSBjb21taXQgaGFzaC4AYCogYHZlcnNpb25fa2V5YCAoYHU2NGApOnAgIC0gVGhlIG5ldHdvcmsgdmVyc2lvbiBrZXkuACQjIFJhaXNlczpkKiBgQ29tbWl0UmV2ZWFsRGlzYWJsZWRgOjkBICAtIEF0dGVtcHRpbmcgdG8gcmV2ZWFsIHdlaWdodHMgd2hlbiB0aGUgY29tbWl0LXJldmVhbCBtZWNoYW5pc20gaXMgZGlzYWJsZWQuAGQqIGBOb1dlaWdodHNDb21taXRGb3VuZGA68CAgLSBBdHRlbXB0aW5nIHRvIHJldmVhbCB3ZWlnaHRzIHdpdGhvdXQgYW4gZXhpc3RpbmcgY29tbWl0LgBgKiBgRXhwaXJlZFdlaWdodENvbW1pdGA66CAgLSBBdHRlbXB0aW5nIHRvIHJldmVhbCBhIHdlaWdodCBjb21taXQgdGhhdCBoYXMgZXhwaXJlZC4ATCogYFJldmVhbFRvb0Vhcmx5YDoFASAgLSBBdHRlbXB0aW5nIHRvIHJldmVhbCB3ZWlnaHRzIG91dHNpZGUgdGhlIHZhbGlkIHJldmVhbCBwZXJpb2QuAJAqIGBJbnZhbGlkUmV2ZWFsQ29tbWl0SGFzaE5vdE1hdGNoYDrgICAtIFRoZSByZXZlYWxlZCBoYXNoIGRvZXMgbm90IG1hdGNoIGFueSBjb21taXR0ZWQgaGFzaC4AdGNvbW1pdF9jcnYzX21lY2hhbmlzbV93ZWlnaHRzEAEYbmV0dWlkoAEYTmV0VWlkAAEUbWVjaWQIARhNZWNoSWQAARhjb21taXRlAgHQQm91bmRlZFZlYzx1OCwgQ29uc3RVMzI8TUFYX0NSVjNfQ09NTUlUX1NJWkVfQllURVM+PgABMHJldmVhbF9yb3VuZBgBDHU2NAB19EkBLS0tLSBVc2VkIHRvIGNvbW1pdCBlbmNyeXB0ZWQgY29tbWl0LXJldmVhbCB2MyB3ZWlnaHQgdmFsdWVzIHRvIGxhdGVyIGJlIHJldmVhbGVkLgAcIyBBcmdzOuwqIGBvcmlnaW5gOiAoYDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6UnVudGltZU9yaWdpbmApOmggIC0gVGhlIGNvbW1pdHRpbmcgaG90a2V5LgBMKiBgbmV0dWlkYCAoYHUxNmApOnwgIC0gVGhlIHUxNiBuZXR3b3JrIGlkZW50aWZpZXIuAFwqIGBjb21taXRgIChgVmVjPHU4PmApOpAgIC0gVGhlIGVuY3J5cHRlZCBjb21wcmVzc2VkIGNvbW1pdC5sICAgIFRoZSBzdGVwcyBmb3IgdGhpcyBhcmU6qCAgICAxLiBJbnN0YW50aWF0ZSBbYFdlaWdodHNUbG9ja1BheWxvYWRgXQEBICAgIDIuIFNlcmlhbGl6ZSBpdCB1c2luZyB0aGUgYHBhcml0eV9zY2FsZV9jb2RlYzo6RW5jb2RlYCB0cmFpdHUCICAgIDMuIEVuY3J5cHQgaXQgZm9sbG93aW5nIHRoZSBzdGVwcyAoaGVyZSlbaHR0cHM6Ly9naXRodWIuY29tL2lkZWFsLWxhYjUvdGxlL2Jsb2IvZjhlNjAxOWYwZmIwMmMzODBlYmZhNmIzMGVmYjYxNzg2ZGVkZTA3Yi90aW1lbG9jay9zcmMvdGxvY2sucnMjTDI4My1MMzM2XdwgICAgICAgdG8gcHJvZHVjZSBhIFtgVExFQ2lwaGVydGV4dDxUaW55QkxTMzgxPmBdIHR5cGUuTQEgICAgNC4gU2VyaWFsaXplIGFuZCBjb21wcmVzcyB1c2luZyB0aGUgYGFyay1zZXJpYWxpemVgIGBDYW5vbmljYWxTZXJpYWxpemVgIHRyYWl0LgBcKiByZXZlYWxfcm91bmQgKGB1NjRgKTpdASAgIC0gVGhlIGRyYW5kIHJldmVhbCByb3VuZCB3aGljaCB3aWxsIGJlIGF2YWxpYWJsZSBkdXJpbmcgZXBvY2ggYG4rMWAgZnJvbSB0aGUgY3VycmVudCwgICAgIGVwb2NoLgAkIyBSYWlzZXM6bCogYENvbW1pdFJldmVhbFYzRGlzYWJsZWRgOhkBICAtIEF0dGVtcHRpbmcgdG8gY29tbWl0IHdoZW4gdGhlIGNvbW1pdC1yZXZlYWwgbWVjaGFuaXNtIGlzIGRpc2FibGVkLgB0KiBgVG9vTWFueVVucmV2ZWFsZWRDb21taXRzYDp1ASAgLSBBdHRlbXB0aW5nIHRvIGNvbW1pdCB3aGVuIHRoZSB1c2VyIGhhcyBtb3JlIHRoYW4gdGhlIGFsbG93ZWQgbGltaXQgb2YgdW5yZXZlYWxlZCBjb21taXRzLgCFAS0tLS0gVXNlZCB0byBjb21taXQgZW5jcnlwdGVkIGNvbW1pdC1yZXZlYWwgdjMgd2VpZ2h0IHZhbHVlcyB0byBsYXRlciBiZSByZXZlYWxlZCBmb3IgbWVjaGFuaXNtcy4AHCMgQXJnczrsKiBgb3JpZ2luYDogKGA8VCBhcyBmcmFtZV9zeXN0ZW06OkNvbmZpZz46OlJ1bnRpbWVPcmlnaW5gKTpoICAtIFRoZSBjb21taXR0aW5nIGhvdGtleS4ATCogYG5ldHVpZGAgKGB1MTZgKTp8ICAtIFRoZSB1MTYgbmV0d29yayBpZGVudGlmaWVyLgBEKiBgbWVjaWRgIChgdThgKTqAICAtIFRoZSB1OCBtZWNoYW5pc20gaWRlbnRpZmllci4AXCogYGNvbW1pdGAgKGBWZWM8dTg+YCk6kCAgLSBUaGUgZW5jcnlwdGVkIGNvbXByZXNzZWQgY29tbWl0LmwgICAgVGhlIHN0ZXBzIGZvciB0aGlzIGFyZTqoICAgIDEuIEluc3RhbnRpYXRlIFtgV2VpZ2h0c1Rsb2NrUGF5bG9hZGBdAQEgICAgMi4gU2VyaWFsaXplIGl0IHVzaW5nIHRoZSBgcGFyaXR5X3NjYWxlX2NvZGVjOjpFbmNvZGVgIHRyYWl0dQIgICAgMy4gRW5jcnlwdCBpdCBmb2xsb3dpbmcgdGhlIHN0ZXBzIChoZXJlKVtodHRwczovL2dpdGh1Yi5jb20vaWRlYWwtbGFiNS90bGUvYmxvYi9mOGU2MDE5ZjBmYjAyYzM4MGViZmE2YjMwZWZiNjE3ODZkZWRlMDdiL3RpbWVsb2NrL3NyYy90bG9jay5ycyNMMjgzLUwzMzZd3CAgICAgICB0byBwcm9kdWNlIGEgW2BUTEVDaXBoZXJ0ZXh0PFRpbnlCTFMzODE+YF0gdHlwZS5NASAgICA0LiBTZXJpYWxpemUgYW5kIGNvbXByZXNzIHVzaW5nIHRoZSBgYXJrLXNlcmlhbGl6ZWAgYENhbm9uaWNhbFNlcmlhbGl6ZWAgdHJhaXQuAFwqIHJldmVhbF9yb3VuZCAoYHU2NGApOl0BICAgLSBUaGUgZHJhbmQgcmV2ZWFsIHJvdW5kIHdoaWNoIHdpbGwgYmUgYXZhbGlhYmxlIGR1cmluZyBlcG9jaCBgbisxYCBmcm9tIHRoZSBjdXJyZW50LCAgICAgZXBvY2guACQjIFJhaXNlczpsKiBgQ29tbWl0UmV2ZWFsVjNEaXNhYmxlZGA6GQEgIC0gQXR0ZW1wdGluZyB0byBjb21taXQgd2hlbiB0aGUgY29tbWl0LXJldmVhbCBtZWNoYW5pc20gaXMgZGlzYWJsZWQuAHQqIGBUb29NYW55VW5yZXZlYWxlZENvbW1pdHNgOnUBICAtIEF0dGVtcHRpbmcgdG8gY29tbWl0IHdoZW4gdGhlIHVzZXIgaGFzIG1vcmUgdGhhbiB0aGUgYWxsb3dlZCBsaW1pdCBvZiB1bnJldmVhbGVkIGNvbW1pdHMuAFBiYXRjaF9yZXZlYWxfd2VpZ2h0cxQBGG5ldHVpZKABGE5ldFVpZAABJHVpZHNfbGlzdGkCATRWZWM8VmVjPHUxNj4+AAEsdmFsdWVzX2xpc3RpAgE0VmVjPFZlYzx1MTY+PgABKHNhbHRzX2xpc3RpAgE0VmVjPFZlYzx1MTY+PgABMHZlcnNpb25fa2V5c2kBASBWZWM8dTY0PgBinPgtLS0tIFRoZSBpbXBsZW1lbnRhdGlvbiBmb3IgYmF0Y2ggcmV2ZWFsaW5nIGNvbW1pdHRlZCB3ZWlnaHRzLgAcIyBBcmdzOuwqIGBvcmlnaW5gOiAoYDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6UnVudGltZU9yaWdpbmApOqggIC0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgcmV2ZWFsaW5nIGhvdGtleS4ATCogYG5ldHVpZGAgKGB1MTZgKTp8ICAtIFRoZSB1MTYgbmV0d29yayBpZGVudGlmaWVyLgCAKiBgdWlkc19saXN0YCAoYFZlYzxWZWM8dTE2Pj5gKTroICAtIEEgbGlzdCBvZiB1aWRzIGZvciBlYWNoIHNldCBvZiB3ZWlnaHRzIGJlaW5nIHJldmVhbGVkLgCIKiBgdmFsdWVzX2xpc3RgIChgVmVjPFZlYzx1MTY+PmApOvAgIC0gQSBsaXN0IG9mIHZhbHVlcyBmb3IgZWFjaCBzZXQgb2Ygd2VpZ2h0cyBiZWluZyByZXZlYWxlZC4AhCogYHNhbHRzX2xpc3RgIChgVmVjPFZlYzx1MTY+PmApOtwgIC0gQSBsaXN0IG9mIHNhbHRzIHVzZWQgdG8gZ2VuZXJhdGUgdGhlIGNvbW1pdCBoYXNoZXMuAHgqIGB2ZXJzaW9uX2tleXNgIChgVmVjPHU2ND5gKTqMICAtIEEgbGlzdCBvZiBuZXR3b3JrIHZlcnNpb24ga2V5cy4AJCMgUmFpc2VzOmQqIGBDb21taXRSZXZlYWxEaXNhYmxlZGA6OQEgIC0gQXR0ZW1wdGluZyB0byByZXZlYWwgd2VpZ2h0cyB3aGVuIHRoZSBjb21taXQtcmV2ZWFsIG1lY2hhbmlzbSBpcyBkaXNhYmxlZC4AZCogYE5vV2VpZ2h0c0NvbW1pdEZvdW5kYDrwICAtIEF0dGVtcHRpbmcgdG8gcmV2ZWFsIHdlaWdodHMgd2l0aG91dCBhbiBleGlzdGluZyBjb21taXQuAGAqIGBFeHBpcmVkV2VpZ2h0Q29tbWl0YDroICAtIEF0dGVtcHRpbmcgdG8gcmV2ZWFsIGEgd2VpZ2h0IGNvbW1pdCB0aGF0IGhhcyBleHBpcmVkLgBMKiBgUmV2ZWFsVG9vRWFybHlgOgUBICAtIEF0dGVtcHRpbmcgdG8gcmV2ZWFsIHdlaWdodHMgb3V0c2lkZSB0aGUgdmFsaWQgcmV2ZWFsIHBlcmlvZC4AkCogYEludmFsaWRSZXZlYWxDb21taXRIYXNoTm90TWF0Y2hgOuAgIC0gVGhlIHJldmVhbGVkIGhhc2ggZG9lcyBub3QgbWF0Y2ggYW55IGNvbW1pdHRlZCBoYXNoLgBgKiBgSW52YWxpZElucHV0TGVuZ3Roc2A6wCAgLSBUaGUgaW5wdXQgdmVjdG9ycyBhcmUgb2YgbWlzbWF0Y2hlZCBsZW5ndGhzLjRkZWNyZWFzZV90YWtlCAEYaG90a2V5AAEwVDo6QWNjb3VudElkAAEQdGFrZaABDHUxNgBBhMAtLS0gQWxsb3dzIGRlbGVnYXRlcyB0byBkZWNyZWFzZSBpdHMgdGFrZSB2YWx1ZS4AHCMgQXJnczrIKiAnb3JpZ2luJzogKDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6T3JpZ2luKTqkCS0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY2FsbGVyJ3MgY29sZGtleS4AaCogJ2hvdGtleScgKFQ6OkFjY291bnRJZCk6/AktIFRoZSBob3RrZXkgd2UgYXJlIGRlbGVnYXRpbmcgKG11c3QgYmUgb3duZWQgYnkgdGhlIGNvbGRrZXkuKQBEKiAnbmV0dWlkJyAodTE2KTqECS0gU3VibmV0IElEIHRvIGRlY3JlYXNlIHRha2UgZm9yADwqICd0YWtlJyAodTE2KToRAQktIFRoZSBuZXcgc3Rha2UgcHJvcG9ydGlvbiB0aGF0IHRoaXMgaG90a2V5IHRha2VzIGZyb20gZGVsZWdhdGlvbnMuHQEgICAgICAgVGhlIG5ldyB2YWx1ZSBjYW4gYmUgYmV0d2VlbiAwIGFuZCAxMV83OTYgYW5kIHNob3VsZCBiZSBzdHJpY3RseTkBICAgICAgIGxvd2VyIHRoYW4gdGhlIHByZXZpb3VzIHZhbHVlLiBJdCBUIGlzIHRoZSBuZXcgdmFsdWUgKHJhdGlvbmFsIG51bWJlciksPQEgICAgICAgdGhlIHRoZSBwYXJhbWV0ZXIgaXMgY2FsY3VsYXRlZCBhcyBbNjU1MzUgKiBUXS4gRm9yIGV4YW1wbGUsIDElIHdvdWxkIGJlmCAgICAgICBbMC4wMSAqIDY1NTM1XSA9IFs2NTUuMzVdID0gNjU1ACAjIEV2ZW50OkAqIFRha2VEZWNyZWFzZWQ78AktIE9uIHN1Y2Nlc3NmdWxseSBzZXR0aW5nIGEgZGVjcmVhc2VkIHRha2UgZm9yIHRoaXMgaG90a2V5LgAkIyBSYWlzZXM6SCogJ05vdFJlZ2lzdGVyZWQnOgUBCS0gVGhlIGhvdGtleSB3ZSBhcmUgZGVsZWdhdGluZyBpcyBub3QgcmVnaXN0ZXJlZCBvbiB0aGUgbmV0d29yay4AZCogJ05vbkFzc29jaWF0ZWRDb2xkS2V5JzoRAQktIFRoZSBob3RrZXkgd2UgYXJlIGRlbGVnYXRpbmcgaXMgbm90IG93bmVkIGJ5IHRoZSBjYWxsaW5nIGNvbGRrZXkuAFwqICdEZWxlZ2F0ZVRha2VUb29Mb3cnOh0BCS0gVGhlIGRlbGVnYXRlIGlzIHNldHRpbmcgYSB0YWtlIHdoaWNoIGlzIG5vdCBsb3dlciB0aGFuIHRoZSBwcmV2aW91cy4ANGluY3JlYXNlX3Rha2UIARhob3RrZXkAATBUOjpBY2NvdW50SWQAARB0YWtloAEMdTE2AEJ4LQEtLS0gQWxsb3dzIGRlbGVnYXRlcyB0byBpbmNyZWFzZSBpdHMgdGFrZSB2YWx1ZS4gVGhpcyBjYWxsIGlzIHJhdGUtbGltaXRlZC4AHCMgQXJnczrIKiAnb3JpZ2luJzogKDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6T3JpZ2luKTqkCS0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY2FsbGVyJ3MgY29sZGtleS4AaCogJ2hvdGtleScgKFQ6OkFjY291bnRJZCk6/AktIFRoZSBob3RrZXkgd2UgYXJlIGRlbGVnYXRpbmcgKG11c3QgYmUgb3duZWQgYnkgdGhlIGNvbGRrZXkuKQA8KiAndGFrZScgKHUxNik6EQEJLSBUaGUgbmV3IHN0YWtlIHByb3BvcnRpb24gdGhhdCB0aGlzIGhvdGtleSB0YWtlcyBmcm9tIGRlbGVnYXRpb25zLh0BICAgICAgIFRoZSBuZXcgdmFsdWUgY2FuIGJlIGJldHdlZW4gMCBhbmQgMTFfNzk2IGFuZCBzaG91bGQgYmUgc3RyaWN0bHk1ASAgICAgICBncmVhdGVyIHRoYW4gdGhlIHByZXZpb3VzIHZhbHVlLiBUIGlzIHRoZSBuZXcgdmFsdWUgKHJhdGlvbmFsIG51bWJlciksPQEgICAgICAgdGhlIHRoZSBwYXJhbWV0ZXIgaXMgY2FsY3VsYXRlZCBhcyBbNjU1MzUgKiBUXS4gRm9yIGV4YW1wbGUsIDElIHdvdWxkIGJlmCAgICAgICBbMC4wMSAqIDY1NTM1XSA9IFs2NTUuMzVdID0gNjU1ACAjIEV2ZW50OkAqIFRha2VJbmNyZWFzZWQ78AktIE9uIHN1Y2Nlc3NmdWxseSBzZXR0aW5nIGEgaW5jcmVhc2VkIHRha2UgZm9yIHRoaXMgaG90a2V5LgAkIyBSYWlzZXM6SCogJ05vdFJlZ2lzdGVyZWQnOgUBCS0gVGhlIGhvdGtleSB3ZSBhcmUgZGVsZWdhdGluZyBpcyBub3QgcmVnaXN0ZXJlZCBvbiB0aGUgbmV0d29yay4AZCogJ05vbkFzc29jaWF0ZWRDb2xkS2V5JzoRAQktIFRoZSBob3RrZXkgd2UgYXJlIGRlbGVnYXRpbmcgaXMgbm90IG93bmVkIGJ5IHRoZSBjYWxsaW5nIGNvbGRrZXkuAGAqICdEZWxlZ2F0ZVRha2VUb29IaWdoJzolAQktIFRoZSBkZWxlZ2F0ZSBpcyBzZXR0aW5nIGEgdGFrZSB3aGljaCBpcyBub3QgZ3JlYXRlciB0aGFuIHRoZSBwcmV2aW91cy4AJGFkZF9zdGFrZQwBGGhvdGtleQABMFQ6OkFjY291bnRJZAABGG5ldHVpZKABGE5ldFVpZAABNGFtb3VudF9zdGFrZWQYAShUYW9CYWxhbmNlAAKEEQEtLS0gQWRkcyBzdGFrZSB0byBhIGhvdGtleS4gVGhlIGNhbGwgaXMgbWFkZSBmcm9tIGEgY29sZGtleSBhY2NvdW50LoxUaGlzIGRlbGVnYXRlcyBzdGFrZSB0byB0aGUgaG90a2V5LgARAU5vdGU6IHRoZSBjb2xka2V5IGFjY291bnQgbWF5IG93biB0aGUgaG90a2V5LCBpbiB3aGljaCBjYXNlIHRoZXkgYXJlZGRlbGVnYXRpbmcgdG8gdGhlbXNlbHZlcy4AHCMgQXJnczrEICogJ29yaWdpbic6ICg8VCBhcyBmcmFtZV9zeXN0ZW06OkNvbmZpZz5PcmlnaW4pOqQJLSBUaGUgc2lnbmF0dXJlIG9mIHRoZSBjYWxsZXIncyBjb2xka2V5LgBsICogJ2hvdGtleScgKFQ6OkFjY291bnRJZCk6hAktIFRoZSBhc3NvY2lhdGVkIGhvdGtleSBhY2NvdW50LgBEKiAnbmV0dWlkJyAodTE2KTpQICAgIC0gU3VibmV0d29yayBVSUQAZCAqICdhbW91bnRfc3Rha2VkJyAodTY0KToFAQktIFRoZSBhbW91bnQgb2Ygc3Rha2UgdG8gYmUgYWRkZWQgdG8gdGhlIGhvdGtleSBzdGFraW5nIGFjY291bnQuACAjIEV2ZW50OjggKiBTdGFrZUFkZGVkO+AJLSBPbiB0aGUgc3VjY2Vzc2Z1bGx5IGFkZGluZyBzdGFrZSB0byBhIGdsb2JhbCBhY2NvdW50LgAkIyBSYWlzZXM6dCAqICdOb3RFbm91Z2hCYWxhbmNlVG9TdGFrZSc6EQEJLSBOb3QgZW5vdWdoIGJhbGFuY2Ugb24gdGhlIGNvbGRrZXkgdG8gYWRkIG9udG8gdGhlIGdsb2JhbCBhY2NvdW50LgBoICogJ05vbkFzc29jaWF0ZWRDb2xkS2V5JzroCS0gVGhlIGNhbGxpbmcgY29sZGtleSBpcyBub3QgYXNzb2NpYXRlZCB3aXRoIHRoaXMgaG90a2V5LgBwICogJ0JhbGFuY2VXaXRoZHJhd2FsRXJyb3InOrAgCS0gRXJyb3JzIHN0ZW1taW5nIGZyb20gdHJhbnNhY3Rpb24gcGFsbGV0LgAwcmVtb3ZlX3N0YWtlDAEYaG90a2V5AAEwVDo6QWNjb3VudElkAAEYbmV0dWlkoAEYTmV0VWlkAAE8YW1vdW50X3Vuc3Rha2VkGAEwQWxwaGFCYWxhbmNlAAN88FJlbW92ZSBzdGFrZSBmcm9tIHRoZSBzdGFraW5nIGFjY291bnQuIFRoZSBjYWxsIG11c3QgYmUgbWFkZR0BZnJvbSB0aGUgY29sZGtleSBhY2NvdW50IGF0dGFjaGVkIHRvIHRoZSBuZXVyb24gbWV0YWRhdGEuIE9ubHkgdGhpcyBrZXnYaGFzIHBlcm1pc3Npb24gdG8gbWFrZSBzdGFraW5nIGFuZCB1bnN0YWtpbmcgcmVxdWVzdHMuABwjIEFyZ3M6wCogJ29yaWdpbic6ICg8VCBhcyBmcmFtZV9zeXN0ZW06OkNvbmZpZz5PcmlnaW4pOqQJLSBUaGUgc2lnbmF0dXJlIG9mIHRoZSBjYWxsZXIncyBjb2xka2V5LgBoKiAnaG90a2V5JyAoVDo6QWNjb3VudElkKTqECS0gVGhlIGFzc29jaWF0ZWQgaG90a2V5IGFjY291bnQuAEQqICduZXR1aWQnICh1MTYpOlAgICAgLSBTdWJuZXR3b3JrIFVJRABoKiAnYW1vdW50X3Vuc3Rha2VkJyAodTY0KToFAQktIFRoZSBhbW91bnQgb2Ygc3Rha2UgdG8gYmUgYWRkZWQgdG8gdGhlIGhvdGtleSBzdGFraW5nIGFjY291bnQuACAjIEV2ZW50OjwqIFN0YWtlUmVtb3ZlZDv4CS0gT24gdGhlIHN1Y2Nlc3NmdWxseSByZW1vdmluZyBzdGFrZSBmcm9tIHRoZSBob3RrZXkgYWNjb3VudC4AJCMgUmFpc2VzOkgqICdOb3RSZWdpc3RlcmVkJzotAQktIFRocm93biBpZiB0aGUgYWNjb3VudCB3ZSBhcmUgYXR0ZW1wdGluZyB0byB1bnN0YWtlIGZyb20gaXMgbm9uIGV4aXN0ZW50LgBkKiAnTm9uQXNzb2NpYXRlZENvbGRLZXknOh0BCS0gVGhyb3duIGlmIHRoZSBjb2xka2V5IGRvZXMgbm90IG93biB0aGUgaG90a2V5IHdlIGFyZSB1bnN0YWtpbmcgZnJvbS4AdCogJ05vdEVub3VnaFN0YWtlVG9XaXRoZHJhdyc6OQEJLSBUaHJvd24gaWYgdGhlcmUgaXMgbm90IGVub3VnaCBzdGFrZSBvbiB0aGUgaG90a2V5IHRvIHdpdGhkd3JhdyB0aGlzIGFtb3VudC4AKHNlcnZlX2F4b24gARhuZXR1aWSgARhOZXRVaWQAARx2ZXJzaW9uEAEMdTMyAAEIaXAgARB1MTI4AAEQcG9ydKABDHUxNgABHGlwX3R5cGUIAQh1OAABIHByb3RvY29sCAEIdTgAATBwbGFjZWhvbGRlcjEIAQh1OAABMHBsYWNlaG9sZGVyMggBCHU4AATMqQFTZXJ2ZXMgb3IgdXBkYXRlcyBheG9uIC9wcm9tZXRoZXVzIGluZm9ybWF0aW9uIGZvciB0aGUgbmV1cm9uIGFzc29jaWF0ZWQgd2l0aCB0aGUgY2FsbGVyLiBJZiB0aGUgY2FsbGVyIGlzrQFhbHJlYWR5IHJlZ2lzdGVyZWQgdGhlIG1ldGFkYXRhIGlzIHVwZGF0ZWQuIElmIHRoZSBjYWxsZXIgaXMgbm90IHJlZ2lzdGVyZWQgdGhpcyBjYWxsIHRocm93cyBOb3RSZWdpc3RlcmVkLgAcIyBBcmdzOsAqICdvcmlnaW4nOiAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+T3JpZ2luKTp8CS0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY2FsbGVyLgBEKiAnbmV0dWlkJyAodTE2KTp4CS0gVGhlIHUxNiBuZXR3b3JrIGlkZW50aWZpZXIuAEgqICd2ZXJzaW9uJyAodTY0KTqQCS0gVGhlIGJpdHRlbnNvciB2ZXJzaW9uIGlkZW50aWZpZXIuADQqICdpcCcgKHU2NCk65AktIFRoZSBlbmRwb2ludCBpcCBpbmZvcm1hdGlvbiBhcyBhIHUxMjggZW5jb2RlZCBpbnRlZ2VyLgA8KiAncG9ydCcgKHUxNik66AktIFRoZSBlbmRwb2ludCBwb3J0IGluZm9ybWF0aW9uIGFzIGEgdTE2IGVuY29kZWQgaW50ZWdlci4ARCogJ2lwX3R5cGUnICh1OCk6rAktIFRoZSBlbmRwb2ludCBpcCB2ZXJzaW9uIGFzIGEgdTgsIDQgb3IgNi4ASCogJ3Byb3RvY29sJyAodTgpOkQJLSBVRFA6MSBvciBUQ1A6MABYKiAncGxhY2Vob2xkZXIxJyAodTgpOqAJLSBQbGFjZWhvbGRlciBmb3IgZnVydGhlciBleHRyYSBwYXJhbXMuAFgqICdwbGFjZWhvbGRlcjInICh1OCk6oAktIFBsYWNlaG9sZGVyIGZvciBmdXJ0aGVyIGV4dHJhIHBhcmFtcy4AICMgRXZlbnQ6NCogQXhvblNlcnZlZDukCS0gT24gc3VjY2Vzc2Z1bGx5IHNlcnZpbmcgdGhlIGF4b24gaW5mby4AJCMgUmFpc2VzOmgqICdNZWNoYW5pc21Eb2VzTm90RXhpc3QnOtwJLSBBdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIG9uIGEgbm9uLWV4aXN0ZW50IG5ldHdvcmsuAEgqICdOb3RSZWdpc3RlcmVkJzrsCS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyBmcm9tIGEgbm9uIHJlZ2lzdGVyZWQgYWNjb3VudC4ASCogJ0ludmFsaWRJcFR5cGUnOnQJLSBUaGUgaXAgdHlwZSBpcyBub3QgNCBvciA2LgBUKiAnSW52YWxpZElwQWRkcmVzcyc6GQEJLSBUaGUgbnVtZXJpY2FsbHkgZW5jb2RlZCBpcCBhZGRyZXNzIGRvZXMgbm90IHJlc29sdmUgdG8gYSBwcm9wZXIgaXAuAHQqICdTZXJ2aW5nUmF0ZUxpbWl0RXhjZWVkZWQnOh0BCS0gQXR0ZW1wdGluZyB0byBzZXQgcHJvbWV0aGV1cyBpbmZvcm1hdGlvbiB3aXRoaW5nIHRoZSByYXRlIGxpbWl0IG1pbi4AOHNlcnZlX2F4b25fdGxzJAEYbmV0dWlkoAEYTmV0VWlkAAEcdmVyc2lvbhABDHUzMgABCGlwIAEQdTEyOAABEHBvcnSgAQx1MTYAARxpcF90eXBlCAEIdTgAASBwcm90b2NvbAgBCHU4AAEwcGxhY2Vob2xkZXIxCAEIdTgAATBwbGFjZWhvbGRlcjIIAQh1OAABLGNlcnRpZmljYXRlOAEcVmVjPHU4PgAo3C0BU2FtZSBhcyBgc2VydmVfYXhvbmAgYnV0IHRha2VzIGEgY2VydGlmaWNhdGUgYXMgYW4gZXh0cmEgb3B0aW9uYWwgYXJndW1lbnQuqQFTZXJ2ZXMgb3IgdXBkYXRlcyBheG9uIC9wcm9tZXRoZXVzIGluZm9ybWF0aW9uIGZvciB0aGUgbmV1cm9uIGFzc29jaWF0ZWQgd2l0aCB0aGUgY2FsbGVyLiBJZiB0aGUgY2FsbGVyIGlzrQFhbHJlYWR5IHJlZ2lzdGVyZWQgdGhlIG1ldGFkYXRhIGlzIHVwZGF0ZWQuIElmIHRoZSBjYWxsZXIgaXMgbm90IHJlZ2lzdGVyZWQgdGhpcyBjYWxsIHRocm93cyBOb3RSZWdpc3RlcmVkLgAcIyBBcmdzOsAqICdvcmlnaW4nOiAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+T3JpZ2luKTp8CS0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY2FsbGVyLgBEKiAnbmV0dWlkJyAodTE2KTp4CS0gVGhlIHUxNiBuZXR3b3JrIGlkZW50aWZpZXIuAEgqICd2ZXJzaW9uJyAodTY0KTqQCS0gVGhlIGJpdHRlbnNvciB2ZXJzaW9uIGlkZW50aWZpZXIuADQqICdpcCcgKHU2NCk65AktIFRoZSBlbmRwb2ludCBpcCBpbmZvcm1hdGlvbiBhcyBhIHUxMjggZW5jb2RlZCBpbnRlZ2VyLgA8KiAncG9ydCcgKHUxNik66AktIFRoZSBlbmRwb2ludCBwb3J0IGluZm9ybWF0aW9uIGFzIGEgdTE2IGVuY29kZWQgaW50ZWdlci4ARCogJ2lwX3R5cGUnICh1OCk6rAktIFRoZSBlbmRwb2ludCBpcCB2ZXJzaW9uIGFzIGEgdTgsIDQgb3IgNi4ASCogJ3Byb3RvY29sJyAodTgpOkQJLSBVRFA6MSBvciBUQ1A6MABYKiAncGxhY2Vob2xkZXIxJyAodTgpOqAJLSBQbGFjZWhvbGRlciBmb3IgZnVydGhlciBleHRyYSBwYXJhbXMuAFgqICdwbGFjZWhvbGRlcjInICh1OCk6oAktIFBsYWNlaG9sZGVyIGZvciBmdXJ0aGVyIGV4dHJhIHBhcmFtcy4AaCogJ2NlcnRpZmljYXRlJyAoVmVjPHU4Pik61CAgICAtIFRMUyBjZXJ0aWZpY2F0ZSBmb3IgaW50ZXIgbmV1cm9uIGNvbW11bml0YXRpb24uACAjIEV2ZW50OjQqIEF4b25TZXJ2ZWQ7pAktIE9uIHN1Y2Nlc3NmdWxseSBzZXJ2aW5nIHRoZSBheG9uIGluZm8uACQjIFJhaXNlczpoKiAnTWVjaGFuaXNtRG9lc05vdEV4aXN0JzrcCS0gQXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyBvbiBhIG5vbi1leGlzdGVudCBuZXR3b3JrLgBIKiAnTm90UmVnaXN0ZXJlZCc67AktIEF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgZnJvbSBhIG5vbiByZWdpc3RlcmVkIGFjY291bnQuAEgqICdJbnZhbGlkSXBUeXBlJzp0CS0gVGhlIGlwIHR5cGUgaXMgbm90IDQgb3IgNi4AVCogJ0ludmFsaWRJcEFkZHJlc3MnOhkBCS0gVGhlIG51bWVyaWNhbGx5IGVuY29kZWQgaXAgYWRkcmVzcyBkb2VzIG5vdCByZXNvbHZlIHRvIGEgcHJvcGVyIGlwLgB0KiAnU2VydmluZ1JhdGVMaW1pdEV4Y2VlZGVkJzodAQktIEF0dGVtcHRpbmcgdG8gc2V0IHByb21ldGhldXMgaW5mb3JtYXRpb24gd2l0aGluZyB0aGUgcmF0ZSBsaW1pdCBtaW4uAEBzZXJ2ZV9wcm9tZXRoZXVzFAEYbmV0dWlkoAEYTmV0VWlkAAEcdmVyc2lvbhABDHUzMgABCGlwIAEQdTEyOAABEHBvcnSgAQx1MTYAARxpcF90eXBlCAEIdTgABVC8LS0tLSBTZXQgcHJvbWV0aGV1cyBpbmZvcm1hdGlvbiBmb3IgdGhlIG5ldXJvbi4cIyBBcmdzOsAqICdvcmlnaW4nOiAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+T3JpZ2luKTqcCS0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY2FsbGluZyBob3RrZXkuAEQqICduZXR1aWQnICh1MTYpOngJLSBUaGUgdTE2IG5ldHdvcmsgaWRlbnRpZmllci4ASCogJ3ZlcnNpb24nICh1MTYpOpQJLSAgVGhlIGJpdHRlbnNvciB2ZXJzaW9uIGlkZW50aWZpZXIuADgqICdpcCcgKHUxMjgpOuwJLSBUaGUgcHJvbWV0aGV1cyBpcCBpbmZvcm1hdGlvbiBhcyBhIHUxMjggZW5jb2RlZCBpbnRlZ2VyLgA8KiAncG9ydCcgKHUxNik68AktIFRoZSBwcm9tZXRoZXVzIHBvcnQgaW5mb3JtYXRpb24gYXMgYSB1MTYgZW5jb2RlZCBpbnRlZ2VyLgBEKiAnaXBfdHlwZScgKHU4KTpgCS0gVGhlIGlwIHR5cGUgdjQgb3IgdjYuACByZWdpc3RlchgBGG5ldHVpZKABGE5ldFVpZAABMGJsb2NrX251bWJlchgBDHU2NAABFG5vbmNlGAEMdTY0AAEQd29yazgBHFZlYzx1OD4AARhob3RrZXkAATBUOjpBY2NvdW50SWQAARxjb2xka2V5AAEwVDo6QWNjb3VudElkAAa8uC0tLS0gUmVnaXN0ZXJzIGEgbmV3IG5ldXJvbiB0byB0aGUgc3VibmV0d29yay4AHCMgQXJnczrAKiAnb3JpZ2luJzogKDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPk9yaWdpbik6nAktIFRoZSBzaWduYXR1cmUgb2YgdGhlIGNhbGxpbmcgaG90a2V5LgBEKiAnbmV0dWlkJyAodTE2KTp4CS0gVGhlIHUxNiBuZXR3b3JrIGlkZW50aWZpZXIuAGQqICdibG9ja19udW1iZXInICggdTY0ICk6mAktIEJsb2NrIGhhc2ggdXNlZCB0byBwcm92ZSB3b3JrIGRvbmUuAEgqICdub25jZScgKCB1NjQgKTqYCS0gUG9zaXRpdmUgaW50ZWdlciBub25jZSB1c2VkIGluIFBPVy4AVCogJ3dvcmsnICggVmVjPHU4PiApOrwJLSBWZWN0b3IgZW5jb2RlZCBieXRlcyByZXByZXNlbnRpbmcgd29yayBkb25lLgBwKiAnaG90a2V5JyAoIFQ6OkFjY291bnRJZCApOqgJLSBIb3RrZXkgdG8gYmUgcmVnaXN0ZXJlZCB0byB0aGUgbmV0d29yay4AdCogJ2NvbGRrZXknICggVDo6QWNjb3VudElkICk6eAktIEFzc29jaWF0ZWQgY29sZGtleSBhY2NvdW50LgAgIyBFdmVudDpMKiBOZXVyb25SZWdpc3RlcmVkOxkBCS0gT24gc3VjY2Vzc2Z1bGx5IHJlZ2lzdGVyaW5nIGEgdWlkIHRvIGEgbmV1cm9uIHNsb3Qgb24gYSBzdWJuZXR3b3JrLgAkIyBSYWlzZXM6aCogJ01lY2hhbmlzbURvZXNOb3RFeGlzdCc60AktIEF0dGVtcHRpbmcgdG8gcmVnaXN0ZXIgdG8gYSBub24gZXhpc3RlbnQgbmV0d29yay4AiCogJ1Rvb01hbnlSZWdpc3RyYXRpb25zVGhpc0Jsb2NrJzopAQktIFRoaXMgcmVnaXN0cmF0aW9uIGV4Y2VlZHMgdGhlIHRvdGFsIGFsbG93ZWQgb24gdGhpcyBuZXR3b3JrIHRoaXMgYmxvY2suAJAqICdIb3RLZXlBbHJlYWR5UmVnaXN0ZXJlZEluU3ViTmV0JzrQCS0gVGhlIGhvdGtleSBpcyBhbHJlYWR5IHJlZ2lzdGVyZWQgb24gdGhpcyBuZXR3b3JrLgBUKiAnSW52YWxpZFdvcmtCbG9jayc6JQEJLSBUaGUgd29yayBoYXMgYmVlbiBwZXJmb3JtZWQgb24gYSBzdGFsZSwgZnV0dXJlLCBvciBub24gZXhpc3RlbnQgYmxvY2suAFgqICdJbnZhbGlkRGlmZmljdWx0eSc6qAktIFRoZSB3b3JrIGRvZXMgbm90IG1hdGNoIHRoZSBkaWZmaWN1bHR5LgBAKiAnSW52YWxpZFNlYWwnOmQJLSBUaGUgc2VhbCBpcyBpbmNvcnJlY3QuADRyb290X3JlZ2lzdGVyBAEYaG90a2V5AAEwVDo6QWNjb3VudElkAD4EjFJlZ2lzdGVyIHRoZSBob3RrZXkgdG8gcm9vdCBuZXR3b3JrPGJ1cm5lZF9yZWdpc3RlcggBGG5ldHVpZKABGE5ldFVpZAABGGhvdGtleQABMFQ6OkFjY291bnRJZAAHBMBVc2VyIHJlZ2lzdGVyIGEgbmV3IHN1Ym5ldHdvcmsgdmlhIGJ1cm5pbmcgdG9rZW4sc3dhcF9ob3RrZXkMARhob3RrZXkAATBUOjpBY2NvdW50SWQAAShuZXdfaG90a2V5AAEwVDo6QWNjb3VudElkAAEYbmV0dWlkbQIBOE9wdGlvbjxOZXRVaWQ+AEYEFQFUaGUgZXh0cmluc2ljIGZvciB1c2VyIHRvIGNoYW5nZSBpdHMgaG90a2V5IGluIHN1Ym5ldCBvciBhbGwgc3VibmV0cy4wc3dhcF9jb2xka2V5DAEsb2xkX2NvbGRrZXkAATBUOjpBY2NvdW50SWQAASxuZXdfY29sZGtleQABMFQ6OkFjY291bnRJZAABJHN3YXBfY29zdBgBKFRhb0JhbGFuY2UARwzMUGVyZm9ybXMgYW4gYXJiaXRyYXJ5IGNvbGRrZXkgc3dhcCBmb3IgYW55IGNvbGRrZXkuAIEBT25seSBjYWxsYWJsZSBieSByb290IGFzIGl0IGRvZXNuJ3QgcmVxdWlyZSBhbiBhbm5vdW5jZW1lbnQgYW5kIGNhbiBiZSB1c2VkIHRvIHN3YXAgYW55IGNvbGRrZXkuRHNldF9jaGlsZGtleV90YWtlDAEYaG90a2V5AAEwVDo6QWNjb3VudElkAAEYbmV0dWlkoAEYTmV0VWlkAAEQdGFrZaABDHUxNgBLdKhTZXRzIHRoZSBjaGlsZGtleSB0YWtlIGZvciBhIGdpdmVuIGhvdGtleS4ALQFUaGlzIGZ1bmN0aW9uIGFsbG93cyBhIGNvbGRrZXkgdG8gc2V0IHRoZSBjaGlsZGtleSB0YWtlIGZvciBhIGdpdmVuIGhvdGtleS5VAVRoZSBjaGlsZGtleSB0YWtlIGRldGVybWluZXMgdGhlIHByb3BvcnRpb24gb2Ygc3Rha2UgdGhhdCB0aGUgaG90a2V5IGtlZXBzIGZvciBpdHNlbGagd2hlbiBkaXN0cmlidXRpbmcgc3Rha2UgdG8gaXRzIGNoaWxkcmVuLgAwIyBBcmd1bWVudHM64CogYG9yaWdpbmAgKDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6UnVudGltZU9yaWdpbik6iQEgICAgLSBUaGUgc2lnbmF0dXJlIG9mIHRoZSBjYWxsaW5nIGNvbGRrZXkuIFNldHRpbmcgY2hpbGRrZXkgdGFrZSBjYW4gb25seSBiZSBkb25lIGJ5IHRoZSBjb2xka2V5LgBoKiBgaG90a2V5YCAoVDo6QWNjb3VudElkKTrkICAgIC0gVGhlIGhvdGtleSBmb3Igd2hpY2ggdGhlIGNoaWxka2V5IHRha2Ugd2lsbCBiZSBzZXQuADwqIGB0YWtlYCAodTE2KTqNASAgICAtIFRoZSBuZXcgY2hpbGRrZXkgdGFrZSB2YWx1ZS4gVGhpcyBpcyBhIHBlcmNlbnRhZ2UgcmVwcmVzZW50ZWQgYXMgYSB2YWx1ZSBiZXR3ZWVuIDAgYW5kIDEwMDAwLIggICAgICB3aGVyZSAxMDAwMCByZXByZXNlbnRzIDEwMCUuACQjIEV2ZW50czpQKiBgQ2hpbGRrZXlUYWtlU2V0YDr0ICAgIC0gT24gc3VjY2Vzc2Z1bGx5IHNldHRpbmcgdGhlIGNoaWxka2V5IHRha2UgZm9yIGEgaG90a2V5LgAkIyBFcnJvcnM6ZCogYE5vbkFzc29jaWF0ZWRDb2xkS2V5YDqoICAgIC0gVGhlIGNvbGRrZXkgZG9lcyBub3Qgb3duIHRoZSBob3RrZXkuYCogYEludmFsaWRDaGlsZGtleVRha2VgOkUBICAgIC0gVGhlIHByb3ZpZGVkIHRha2UgdmFsdWUgaXMgaW52YWxpZCAoZ3JlYXRlciB0aGFuIHRoZSBtYXhpbXVtIGFsbG93ZWQgdGFrZSkukCogYFR4Q2hpbGRrZXlUYWtlUmF0ZUxpbWl0RXhjZWVkZWRgOgkBICAgIC0gVGhlIHJhdGUgbGltaXQgZm9yIGNoYW5naW5nIGNoaWxka2V5IHRha2UgaGFzIGJlZW4gZXhjZWVkZWQuAJBzdWRvX3NldF90eF9jaGlsZGtleV90YWtlX3JhdGVfbGltaXQEATR0eF9yYXRlX2xpbWl0GAEMdTY0AEUs7FNldHMgdGhlIHRyYW5zYWN0aW9uIHJhdGUgbGltaXQgZm9yIGNoYW5naW5nIGNoaWxka2V5IHRha2UuANBUaGlzIGZ1bmN0aW9uIGNhbiBvbmx5IGJlIGNhbGxlZCBieSB0aGUgcm9vdCBvcmlnaW4uADAjIEFyZ3VtZW50czrIKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIG11c3QgYmUgcm9vdC7EKiBgdHhfcmF0ZV9saW1pdGAgLSBUaGUgbmV3IHJhdGUgbGltaXQgaW4gYmxvY2tzLgAkIyBFcnJvcnM6qCogYEJhZE9yaWdpbmAgLSBJZiB0aGUgb3JpZ2luIGlzIG5vdCByb290LgBoc3Vkb19zZXRfbWluX2NoaWxka2V5X3Rha2UEARB0YWtloAEMdTE2AEwsnFNldHMgdGhlIG1pbmltdW0gYWxsb3dlZCBjaGlsZGtleSB0YWtlLgDQVGhpcyBmdW5jdGlvbiBjYW4gb25seSBiZSBjYWxsZWQgYnkgdGhlIHJvb3Qgb3JpZ2luLgAwIyBBcmd1bWVudHM6yCogYG9yaWdpbmAgLSBUaGUgb3JpZ2luIG9mIHRoZSBjYWxsLCBtdXN0IGJlIHJvb3QuvCogYHRha2VgIC0gVGhlIG5ldyBtaW5pbXVtIGNoaWxka2V5IHRha2UgdmFsdWUuACQjIEVycm9yczqoKiBgQmFkT3JpZ2luYCAtIElmIHRoZSBvcmlnaW4gaXMgbm90IHJvb3QuAGhzdWRvX3NldF9tYXhfY2hpbGRrZXlfdGFrZQQBEHRha2WgAQx1MTYATSycU2V0cyB0aGUgbWF4aW11bSBhbGxvd2VkIGNoaWxka2V5IHRha2UuANBUaGlzIGZ1bmN0aW9uIGNhbiBvbmx5IGJlIGNhbGxlZCBieSB0aGUgcm9vdCBvcmlnaW4uADAjIEFyZ3VtZW50czrIKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIG11c3QgYmUgcm9vdC68KiBgdGFrZWAgLSBUaGUgbmV3IG1heGltdW0gY2hpbGRrZXkgdGFrZSB2YWx1ZS4AJCMgRXJyb3JzOqgqIGBCYWRPcmlnaW5gIC0gSWYgdGhlIG9yaWdpbiBpcyBub3Qgcm9vdC4AQHJlZ2lzdGVyX25ldHdvcmsEARhob3RrZXkAATBUOjpBY2NvdW50SWQAOwR4VXNlciByZWdpc3RlciBhIG5ldyBzdWJuZXR3b3JrGGZhdWNldAwBMGJsb2NrX251bWJlchgBDHU2NAABFG5vbmNlGAEMdTY0AAEQd29yazgBHFZlYzx1OD4APAzQRmFjaWxpdHkgZXh0cmluc2ljIGZvciB1c2VyIHRvIGdldCB0YWtlbiBmcm9tIGZhdWNldNBJdCBpcyBvbmx5IGF2YWlsYWJsZSB3aGVuIHBvdy1mYXVjZXQgZmVhdHVyZSBlbmFibGVk3Ep1c3QgZGVwbG95ZWQgaW4gdGVzdG5ldCBhbmQgZGV2bmV0IGZvciB0ZXN0aW5nIHB1cnBvc2VAZGlzc29sdmVfbmV0d29yawgBHGNvbGRrZXkAATBUOjpBY2NvdW50SWQAARhuZXR1aWSgARhOZXRVaWQAPQhoUmVtb3ZlIGEgdXNlcidzIHN1Ym5ldHdvcmusVGhlIGNhbGxlciBtdXN0IGJlIHRoZSBvd25lciBvZiB0aGUgbmV0d29yazBzZXRfY2hpbGRyZW4MARhob3RrZXkAATBUOjpBY2NvdW50SWQAARhuZXR1aWSgARhOZXRVaWQAASBjaGlsZHJlbrABYFZlYzwodTY0LCBUOjpBY2NvdW50SWQpPgBDsPRTZXQgYSBzaW5nbGUgY2hpbGQgZm9yIGEgZ2l2ZW4gaG90a2V5IG9uIGEgc3BlY2lmaWVkIG5ldHdvcmsuAH0BVGhpcyBmdW5jdGlvbiBhbGxvd3MgYSBjb2xka2V5IHRvIHNldCBhIHNpbmdsZSBjaGlsZCBmb3IgYSBnaXZlbiBob3RrZXkgb24gYSBzcGVjaWZpZWQgbmV0d29yay5RAVRoZSBwcm9wb3J0aW9uIG9mIHRoZSBob3RrZXkncyBzdGFrZSB0byBiZSBhbGxvY2F0ZWQgdG8gdGhlIGNoaWxkIGlzIGFsc28gc3BlY2lmaWVkLgAwIyBBcmd1bWVudHM64CogYG9yaWdpbmAgKDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6UnVudGltZU9yaWdpbik6jQEgICAgLSBUaGUgc2lnbmF0dXJlIG9mIHRoZSBjYWxsaW5nIGNvbGRrZXkuIFNldHRpbmcgYSBob3RrZXkgY2hpbGQgY2FuIG9ubHkgYmUgZG9uZSBieSB0aGUgY29sZGtleS4AaCogYGhvdGtleWAgKFQ6OkFjY291bnRJZCk6yCAgICAtIFRoZSBob3RrZXkgd2hpY2ggd2lsbCBiZSBhc3NpZ25lZCB0aGUgY2hpbGQuAGQqIGBjaGlsZGAgKFQ6OkFjY291bnRJZCk61CAgICAtIFRoZSBjaGlsZCB3aGljaCB3aWxsIGJlIGFzc2lnbmVkIHRvIHRoZSBob3RrZXkuAEQqIGBuZXR1aWRgICh1MTYpOvwgICAgLSBUaGUgdTE2IG5ldHdvcmsgaWRlbnRpZmllciB3aGVyZSB0aGUgY2hpbGRrZXkgd2lsbCBleGlzdC4AVCogYHByb3BvcnRpb25gICh1NjQpOokBICAgIC0gUHJvcG9ydGlvbiBvZiB0aGUgaG90a2V5J3Mgc3Rha2UgdG8gYmUgZ2l2ZW4gdG8gdGhlIGNoaWxkLCB0aGUgdmFsdWUgbXVzdCBiZSB1NjQgbm9ybWFsaXplZC4AJCMgRXZlbnRzOlwqIGBDaGlsZEFkZGVkU2luZ3VsYXJgOtggICAgLSBPbiBzdWNjZXNzZnVsbHkgcmVnaXN0ZXJpbmcgYSBjaGlsZCB0byBhIGhvdGtleS4AJCMgRXJyb3JzOmgqIGBNZWNoYW5pc21Eb2VzTm90RXhpc3RgOtwgICAgLSBBdHRlbXB0aW5nIHRvIHJlZ2lzdGVyIHRvIGEgbm9uLWV4aXN0ZW50IG5ldHdvcmsupCogYFJlZ2lzdHJhdGlvbk5vdFBlcm1pdHRlZE9uUm9vdFN1Ym5ldGA65CAgICAtIEF0dGVtcHRpbmcgdG8gcmVnaXN0ZXIgYSBjaGlsZCBvbiB0aGUgcm9vdCBuZXR3b3JrLmQqIGBOb25Bc3NvY2lhdGVkQ29sZEtleWA6RQEgICAgLSBUaGUgY29sZGtleSBkb2VzIG5vdCBvd24gdGhlIGhvdGtleSBvciB0aGUgY2hpbGQgaXMgdGhlIHNhbWUgYXMgdGhlIGhvdGtleS5sKiBgSG90S2V5QWNjb3VudE5vdEV4aXN0c2A6oCAgICAtIFRoZSBob3RrZXkgYWNjb3VudCBkb2VzIG5vdCBleGlzdC4AhCMgRGV0YWlsZWQgRXhwbGFuYXRpb24gb2YgQ2hlY2tzOqUBMS4gKipTaWduYXR1cmUgVmVyaWZpY2F0aW9uKio6IEVuc3VyZXMgdGhhdCB0aGUgY2FsbGVyIGhhcyBzaWduZWQgdGhlIHRyYW5zYWN0aW9uLCB2ZXJpZnlpbmcgdGhlIGNvbGRrZXku+QEyLiAqKlJvb3QgTmV0d29yayBDaGVjayoqOiBFbnN1cmVzIHRoYXQgdGhlIGRlbGVnYXRpb24gaXMgbm90IG9uIHRoZSByb290IG5ldHdvcmssIGFzIGNoaWxkIGhvdGtleXMgYXJlIG5vdCB2YWxpZCBvbiB0aGUgcm9vdC4pATMuICoqTmV0d29yayBFeGlzdGVuY2UgQ2hlY2sqKjogRW5zdXJlcyB0aGF0IHRoZSBzcGVjaWZpZWQgbmV0d29yayBleGlzdHMuIQE0LiAqKk93bmVyc2hpcCBWZXJpZmljYXRpb24qKjogRW5zdXJlcyB0aGF0IHRoZSBjb2xka2V5IG93bnMgdGhlIGhvdGtleS5ZATUuICoqSG90a2V5IEFjY291bnQgRXhpc3RlbmNlIENoZWNrKio6IEVuc3VyZXMgdGhhdCB0aGUgaG90a2V5IGFjY291bnQgYWxyZWFkeSBleGlzdHMuWQE2LiAqKkNoaWxkLUhvdGtleSBEaXN0aW5jdGlvbioqOiBFbnN1cmVzIHRoYXQgdGhlIGNoaWxkIGlzIG5vdCB0aGUgc2FtZSBhcyB0aGUgaG90a2V5LmUBNy4gKipPbGQgQ2hpbGRyZW4gQ2xlYW51cCoqOiBSZW1vdmVzIHRoZSBob3RrZXkgZnJvbSB0aGUgcGFyZW50IGxpc3Qgb2YgaXRzIG9sZCBjaGlsZHJlbi7JATguICoqTmV3IENoaWxkcmVuIEFzc2lnbm1lbnQqKjogQXNzaWducyB0aGUgbmV3IGNoaWxkIHRvIHRoZSBob3RrZXkgYW5kIHVwZGF0ZXMgdGhlIHBhcmVudCBsaXN0IGZvciB0aGUgbmV3IGNoaWxkLlRzY2hlZHVsZV9zd2FwX2NvbGRrZXkEASxuZXdfY29sZGtleQABMFQ6OkFjY291bnRJZABJDBEBU2NoZWR1bGVzIGEgY29sZGtleSBzd2FwIG9wZXJhdGlvbiB0byBiZSBleGVjdXRlZCBhdCBhIGZ1dHVyZSBibG9jay4AeQFXQVJOSU5HOiBUaGlzIGZ1bmN0aW9uIGlzIGRlcHJlY2F0ZWQsIHBsZWFzZSBtaWdyYXRlIHRvIGBhbm5vdW5jZV9jb2xka2V5X3N3YXBgL2Bjb2xka2V5X3N3YXBgMHNldF9pZGVudGl0eRwBEG5hbWU4ARxWZWM8dTg+AAEMdXJsOAEcVmVjPHU4PgABLGdpdGh1Yl9yZXBvOAEcVmVjPHU4PgABFGltYWdlOAEcVmVjPHU4PgABHGRpc2NvcmQ4ARxWZWM8dTg+AAEsZGVzY3JpcHRpb244ARxWZWM8dTg+AAEoYWRkaXRpb25hbDgBHFZlYzx1OD4ARFC8LS0tLSBTZXQgcHJvbWV0aGV1cyBpbmZvcm1hdGlvbiBmb3IgdGhlIG5ldXJvbi4cIyBBcmdzOsAqICdvcmlnaW4nOiAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+T3JpZ2luKTqcCS0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY2FsbGluZyBob3RrZXkuAEQqICduZXR1aWQnICh1MTYpOngJLSBUaGUgdTE2IG5ldHdvcmsgaWRlbnRpZmllci4ASCogJ3ZlcnNpb24nICh1MTYpOpQJLSAgVGhlIGJpdHRlbnNvciB2ZXJzaW9uIGlkZW50aWZpZXIuADgqICdpcCcgKHUxMjgpOuwJLSBUaGUgcHJvbWV0aGV1cyBpcCBpbmZvcm1hdGlvbiBhcyBhIHUxMjggZW5jb2RlZCBpbnRlZ2VyLgA8KiAncG9ydCcgKHUxNik68AktIFRoZSBwcm9tZXRoZXVzIHBvcnQgaW5mb3JtYXRpb24gYXMgYSB1MTYgZW5jb2RlZCBpbnRlZ2VyLgBEKiAnaXBfdHlwZScgKHU4KTpgCS0gVGhlIGlwIHR5cGUgdjQgb3IgdjYuAExzZXRfc3VibmV0X2lkZW50aXR5JAEYbmV0dWlkoAEYTmV0VWlkAAEsc3VibmV0X25hbWU4ARxWZWM8dTg+AAEsZ2l0aHViX3JlcG84ARxWZWM8dTg+AAE4c3VibmV0X2NvbnRhY3Q4ARxWZWM8dTg+AAEoc3VibmV0X3VybDgBHFZlYzx1OD4AARxkaXNjb3JkOAEcVmVjPHU4PgABLGRlc2NyaXB0aW9uOAEcVmVjPHU4PgABIGxvZ29fdXJsOAEcVmVjPHU4PgABKGFkZGl0aW9uYWw4ARxWZWM8dTg+AE5AvC0tLS0gU2V0IHRoZSBpZGVudGl0eSBpbmZvcm1hdGlvbiBmb3IgYSBzdWJuZXQuHCMgQXJnczrMKiBgb3JpZ2luYCAtICg8VCBhcyBmcmFtZV9zeXN0ZW06OkNvbmZpZz46Ok9yaWdpbik6SQEgICAgLSBUaGUgc2lnbmF0dXJlIG9mIHRoZSBjYWxsaW5nIGNvbGRrZXksIHdoaWNoIG11c3QgYmUgdGhlIG93bmVyIG9mIHRoZSBzdWJuZXQuAEQqIGBuZXR1aWRgICh1MTYpOsggICAgLSBUaGUgdW5pcXVlIG5ldHdvcmsgaWRlbnRpZmllciBvZiB0aGUgc3VibmV0LgBoKiBgc3VibmV0X25hbWVgIChWZWM8dTg+KTp0ICAgIC0gVGhlIG5hbWUgb2YgdGhlIHN1Ym5ldC4AaCogYGdpdGh1Yl9yZXBvYCAoVmVjPHU4Pik6AQEgICAgLSBUaGUgR2l0SHViIHJlcG9zaXRvcnkgYXNzb2NpYXRlZCB3aXRoIHRoZSBzdWJuZXQgaWRlbnRpdHkuAHQqIGBzdWJuZXRfY29udGFjdGAgKFZlYzx1OD4pOrQgICAgLSBUaGUgY29udGFjdCBpbmZvcm1hdGlvbiBmb3IgdGhlIHN1Ym5ldC54cmVnaXN0ZXJfbmV0d29ya193aXRoX2lkZW50aXR5CAEYaG90a2V5AAEwVDo6QWNjb3VudElkAAEgaWRlbnRpdHlxAgFoT3B0aW9uPFN1Ym5ldElkZW50aXR5T2ZWMz4ATwR4VXNlciByZWdpc3RlciBhIG5ldyBzdWJuZXR3b3JrLHVuc3Rha2VfYWxsBAEYaG90a2V5AAEwVDo6QWNjb3VudElkAFNkNQItLS0tIFRoZSBpbXBsZW1lbnRhdGlvbiBmb3IgdGhlIGV4dHJpbnNpYyB1bnN0YWtlX2FsbDogUmVtb3ZlcyBhbGwgc3Rha2UgZnJvbSBhIGhvdGtleSBhY2NvdW50IGFjcm9zcyBhbGwgc3VibmV0cyBhbmQgYWRkcyBpdCBvbnRvIGEgY29sZGtleS4AHCMgQXJnczrMKiBgb3JpZ2luYCAtICg8VCBhcyBmcmFtZV9zeXN0ZW06OkNvbmZpZz46Ok9yaWdpbik6sCAgICAtIFRoZSBzaWduYXR1cmUgb2YgdGhlIGNhbGxlcidzIGNvbGRrZXkuAGgqIGBob3RrZXlgIChUOjpBY2NvdW50SWQpOpAgICAgLSBUaGUgYXNzb2NpYXRlZCBob3RrZXkgYWNjb3VudC4AICMgRXZlbnQ6PCogU3Rha2VSZW1vdmVkOwUBICAgIC0gT24gdGhlIHN1Y2Nlc3NmdWxseSByZW1vdmluZyBzdGFrZSBmcm9tIHRoZSBob3RrZXkgYWNjb3VudC4AJCMgUmFpc2VzOkgqIGBOb3RSZWdpc3RlcmVkYDo5ASAgICAtIFRocm93biBpZiB0aGUgYWNjb3VudCB3ZSBhcmUgYXR0ZW1wdGluZyB0byB1bnN0YWtlIGZyb20gaXMgbm9uIGV4aXN0ZW50LgBkKiBgTm9uQXNzb2NpYXRlZENvbGRLZXlgOikBICAgIC0gVGhyb3duIGlmIHRoZSBjb2xka2V5IGRvZXMgbm90IG93biB0aGUgaG90a2V5IHdlIGFyZSB1bnN0YWtpbmcgZnJvbS4AdCogYE5vdEVub3VnaFN0YWtlVG9XaXRoZHJhd2A6QQEgICAgLSBUaHJvd24gaWYgdGhlcmUgaXMgbm90IGVub3VnaCBzdGFrZSBvbiB0aGUgaG90a2V5IHRvIHdpdGhkcmF3IHRoaXMgYW1vdW50LgBgKiBgVHhSYXRlTGltaXRFeGNlZWRlZGA6yCAgICAtIFRocm93biBpZiBrZXkgaGFzIGhpdCB0cmFuc2FjdGlvbiByYXRlIGxpbWl0RHVuc3Rha2VfYWxsX2FscGhhBAEYaG90a2V5AAEwVDo6QWNjb3VudElkAFRkNQItLS0tIFRoZSBpbXBsZW1lbnRhdGlvbiBmb3IgdGhlIGV4dHJpbnNpYyB1bnN0YWtlX2FsbDogUmVtb3ZlcyBhbGwgc3Rha2UgZnJvbSBhIGhvdGtleSBhY2NvdW50IGFjcm9zcyBhbGwgc3VibmV0cyBhbmQgYWRkcyBpdCBvbnRvIGEgY29sZGtleS4AHCMgQXJnczrMKiBgb3JpZ2luYCAtICg8VCBhcyBmcmFtZV9zeXN0ZW06OkNvbmZpZz46Ok9yaWdpbik6sCAgICAtIFRoZSBzaWduYXR1cmUgb2YgdGhlIGNhbGxlcidzIGNvbGRrZXkuAGgqIGBob3RrZXlgIChUOjpBY2NvdW50SWQpOpAgICAgLSBUaGUgYXNzb2NpYXRlZCBob3RrZXkgYWNjb3VudC4AICMgRXZlbnQ6PCogU3Rha2VSZW1vdmVkOwUBICAgIC0gT24gdGhlIHN1Y2Nlc3NmdWxseSByZW1vdmluZyBzdGFrZSBmcm9tIHRoZSBob3RrZXkgYWNjb3VudC4AJCMgUmFpc2VzOkgqIGBOb3RSZWdpc3RlcmVkYDo5ASAgICAtIFRocm93biBpZiB0aGUgYWNjb3VudCB3ZSBhcmUgYXR0ZW1wdGluZyB0byB1bnN0YWtlIGZyb20gaXMgbm9uIGV4aXN0ZW50LgBkKiBgTm9uQXNzb2NpYXRlZENvbGRLZXlgOikBICAgIC0gVGhyb3duIGlmIHRoZSBjb2xka2V5IGRvZXMgbm90IG93biB0aGUgaG90a2V5IHdlIGFyZSB1bnN0YWtpbmcgZnJvbS4AdCogYE5vdEVub3VnaFN0YWtlVG9XaXRoZHJhd2A6QQEgICAgLSBUaHJvd24gaWYgdGhlcmUgaXMgbm90IGVub3VnaCBzdGFrZSBvbiB0aGUgaG90a2V5IHRvIHdpdGhkcmF3IHRoaXMgYW1vdW50LgBgKiBgVHhSYXRlTGltaXRFeGNlZWRlZGA6yCAgICAtIFRocm93biBpZiBrZXkgaGFzIGhpdCB0cmFuc2FjdGlvbiByYXRlIGxpbWl0KG1vdmVfc3Rha2UUATRvcmlnaW5faG90a2V5AAEwVDo6QWNjb3VudElkAAFIZGVzdGluYXRpb25faG90a2V5AAEwVDo6QWNjb3VudElkAAE0b3JpZ2luX25ldHVpZKABGE5ldFVpZAABSGRlc3RpbmF0aW9uX25ldHVpZKABGE5ldFVpZAABMGFscGhhX2Ftb3VudBgBMEFscGhhQmFsYW5jZQBVVPkBLS0tLSBUaGUgaW1wbGVtZW50YXRpb24gZm9yIHRoZSBleHRyaW5zaWMgbW92ZV9zdGFrZTogTW92ZXMgc3BlY2lmaWVkIGFtb3VudCBvZiBzdGFrZSBmcm9tIGEgaG90a2V5IHRvIGFub3RoZXIgYWNyb3NzIHN1Ym5ldHMuABwjIEFyZ3M6zCogYG9yaWdpbmAgLSAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+OjpPcmlnaW4pOrAgICAgLSBUaGUgc2lnbmF0dXJlIG9mIHRoZSBjYWxsZXIncyBjb2xka2V5LgCEKiBgb3JpZ2luX2hvdGtleWAgKFQ6OkFjY291bnRJZCk6sCAgICAtIFRoZSBob3RrZXkgYWNjb3VudCB0byBtb3ZlIHN0YWtlIGZyb20uAJgqIGBkZXN0aW5hdGlvbl9ob3RrZXlgIChUOjpBY2NvdW50SWQpOqggICAgLSBUaGUgaG90a2V5IGFjY291bnQgdG8gbW92ZSBzdGFrZSB0by4AhCogYG9yaWdpbl9uZXR1aWRgIChUOjpBY2NvdW50SWQpOpwgICAgLSBUaGUgc3VibmV0IElEIHRvIG1vdmUgc3Rha2UgZnJvbS4AmCogYGRlc3RpbmF0aW9uX25ldHVpZGAgKFQ6OkFjY291bnRJZCk6lCAgICAtIFRoZSBzdWJuZXQgSUQgdG8gbW92ZSBzdGFrZSB0by4AgCogYGFscGhhX2Ftb3VudGAgKFQ6OkFjY291bnRJZCk6lCAgICAtIFRoZSBhbHBoYSBzdGFrZSBhbW91bnQgdG8gbW92ZS4AOHRyYW5zZmVyX3N0YWtlFAFMZGVzdGluYXRpb25fY29sZGtleQABMFQ6OkFjY291bnRJZAABGGhvdGtleQABMFQ6OkFjY291bnRJZAABNG9yaWdpbl9uZXR1aWSgARhOZXRVaWQAAUhkZXN0aW5hdGlvbl9uZXR1aWSgARhOZXRVaWQAATBhbHBoYV9hbW91bnQYATBBbHBoYUJhbGFuY2UAVlR1AVRyYW5zZmVycyBhIHNwZWNpZmllZCBhbW91bnQgb2Ygc3Rha2UgZnJvbSBvbmUgY29sZGtleSB0byBhbm90aGVyLCBvcHRpb25hbGx5IGFjcm9zcyBzdWJuZXRzLHh3aGlsZSBrZWVwaW5nIHRoZSBzYW1lIGhvdGtleS4ALCMgQXJndW1lbnRzZQEqIGBvcmlnaW5gIC0gVGhlIG9yaWdpbiBvZiB0aGUgdHJhbnNhY3Rpb24sIHdoaWNoIG11c3QgYmUgc2lnbmVkIGJ5IHRoZSBgb3JpZ2luX2NvbGRrZXlgLiEBKiBgZGVzdGluYXRpb25fY29sZGtleWAgLSBUaGUgY29sZGtleSB0byB3aGljaCB0aGUgc3Rha2UgaXMgdHJhbnNmZXJyZWQuyCogYGhvdGtleWAgLSBUaGUgaG90a2V5IGFzc29jaWF0ZWQgd2l0aCB0aGUgc3Rha2Uu9CogYG9yaWdpbl9uZXR1aWRgIC0gVGhlIG5ldHdvcmsvc3VibmV0IElEIHRvIG1vdmUgc3Rha2UgZnJvbS5xASogYGRlc3RpbmF0aW9uX25ldHVpZGAgLSBUaGUgbmV0d29yay9zdWJuZXQgSUQgdG8gbW92ZSBzdGFrZSB0byAoZm9yIGNyb3NzLXN1Ym5ldCB0cmFuc2ZlcikuzCogYGFscGhhX2Ftb3VudGAgLSBUaGUgYW1vdW50IG9mIHN0YWtlIHRvIHRyYW5zZmVyLgAgIyBFcnJvcnNQUmV0dXJucyBhbiBlcnJvciBpZjrIKiBUaGUgb3JpZ2luIGlzIG5vdCBzaWduZWQgYnkgdGhlIGNvcnJlY3QgY29sZGtleS58KiBFaXRoZXIgc3VibmV0IGRvZXMgbm90IGV4aXN0LnAqIFRoZSBob3RrZXkgZG9lcyBub3QgZXhpc3QuLQEqIFRoZXJlIGlzIGluc3VmZmljaWVudCBzdGFrZSBvbiBgKG9yaWdpbl9jb2xka2V5LCBob3RrZXksIG9yaWdpbl9uZXR1aWQpYC70KiBUaGUgdHJhbnNmZXIgYW1vdW50IGlzIGJlbG93IHRoZSBtaW5pbXVtIHN0YWtlIHJlcXVpcmVtZW50LgAgIyBFdmVudHO8TWF5IGVtaXQgYSBgU3Rha2VUcmFuc2ZlcnJlZGAgZXZlbnQgb24gc3VjY2Vzcy4oc3dhcF9zdGFrZRABGGhvdGtleQABMFQ6OkFjY291bnRJZAABNG9yaWdpbl9uZXR1aWSgARhOZXRVaWQAAUhkZXN0aW5hdGlvbl9uZXR1aWSgARhOZXRVaWQAATBhbHBoYV9hbW91bnQYATBBbHBoYUJhbGFuY2UAV0yhAVN3YXBzIGEgc3BlY2lmaWVkIGFtb3VudCBvZiBzdGFrZSBmcm9tIG9uZSBzdWJuZXQgdG8gYW5vdGhlciwgd2hpbGUga2VlcGluZyB0aGUgc2FtZSBjb2xka2V5IGFuZCBob3RrZXkuACwjIEFyZ3VtZW50c50BKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIHRyYW5zYWN0aW9uLCB3aGljaCBtdXN0IGJlIHNpZ25lZCBieSB0aGUgY29sZGtleSB0aGF0IG93bnMgdGhlIGBob3RrZXlgLtQqIGBob3RrZXlgIC0gVGhlIGhvdGtleSB3aG9zZSBzdGFrZSBpcyBiZWluZyBzd2FwcGVkLhkBKiBgb3JpZ2luX25ldHVpZGAgLSBUaGUgbmV0d29yay9zdWJuZXQgSUQgZnJvbSB3aGljaCBzdGFrZSBpcyByZW1vdmVkLh0BKiBgZGVzdGluYXRpb25fbmV0dWlkYCAtIFRoZSBuZXR3b3JrL3N1Ym5ldCBJRCB0byB3aGljaCBzdGFrZSBpcyBhZGRlZC68KiBgYWxwaGFfYW1vdW50YCAtIFRoZSBhbW91bnQgb2Ygc3Rha2UgdG8gc3dhcC4AICMgRXJyb3JzUFJldHVybnMgYW4gZXJyb3IgaWY6bQEqIFRoZSB0cmFuc2FjdGlvbiBpcyBub3Qgc2lnbmVkIGJ5IHRoZSBjb3JyZWN0IGNvbGRrZXkgKGkuZS4sIGBjb2xka2V5X293bnNfaG90a2V5YCBmYWlscykuAQEqIEVpdGhlciBgb3JpZ2luX25ldHVpZGAgb3IgYGRlc3RpbmF0aW9uX25ldHVpZGAgZG9lcyBub3QgZXhpc3QucCogVGhlIGhvdGtleSBkb2VzIG5vdCBleGlzdC4RASogVGhlcmUgaXMgaW5zdWZmaWNpZW50IHN0YWtlIG9uIGAoY29sZGtleSwgaG90a2V5LCBvcmlnaW5fbmV0dWlkKWAu5CogVGhlIHN3YXAgYW1vdW50IGlzIGJlbG93IHRoZSBtaW5pbXVtIHN0YWtlIHJlcXVpcmVtZW50LgAgIyBFdmVudHOsTWF5IGVtaXQgYSBgU3Rha2VTd2FwcGVkYCBldmVudCBvbiBzdWNjZXNzLjxhZGRfc3Rha2VfbGltaXQUARhob3RrZXkAATBUOjpBY2NvdW50SWQAARhuZXR1aWSgARhOZXRVaWQAATRhbW91bnRfc3Rha2VkGAEoVGFvQmFsYW5jZQABLGxpbWl0X3ByaWNlGAEoVGFvQmFsYW5jZQABNGFsbG93X3BhcnRpYWwkARBib29sAFio6C0tLSBBZGRzIHN0YWtlIHRvIGEgaG90a2V5IG9uIGEgc3VibmV0IHdpdGggYSBwcmljZSBsaW1pdC4BAVRoaXMgZXh0cmluc2ljIGFsbG93cyB0byBzcGVjaWZ5IHRoZSBsaW1pdCBwcmljZSBmb3IgYWxwaGEgdG9rZW7YYXQgd2hpY2ggb3IgYmV0dGVyIChsb3dlcikgdGhlIHN0YWtpbmcgc2hvdWxkIGV4ZWN1dGUuABEBSW4gY2FzZSBpZiBzbGlwcGFnZSBvY2N1cnMgYW5kIHRoZSBwcmljZSBzaGFsbCBtb3ZlIGJleW9uZCB0aGUgbGltaXQJAXByaWNlLCB0aGUgc3Rha2luZyBvcmRlciBtYXkgZXhlY3V0ZSBvbmx5IHBhcnRpYWxseSBvciBub3QgZXhlY3V0ZRxhdCBhbGwuABwjIEFyZ3M6xCAqICdvcmlnaW4nOiAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+T3JpZ2luKTqkCS0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY2FsbGVyJ3MgY29sZGtleS4AbCAqICdob3RrZXknIChUOjpBY2NvdW50SWQpOoQJLSBUaGUgYXNzb2NpYXRlZCBob3RrZXkgYWNjb3VudC4ARCogJ25ldHVpZCcgKHUxNik6UCAgICAtIFN1Ym5ldHdvcmsgVUlEAGQgKiAnYW1vdW50X3N0YWtlZCcgKHU2NCk6BQEJLSBUaGUgYW1vdW50IG9mIHN0YWtlIHRvIGJlIGFkZGVkIHRvIHRoZSBob3RrZXkgc3Rha2luZyBhY2NvdW50LgBcICogJ2xpbWl0X3ByaWNlJyAodTY0KTrsCS0gVGhlIGxpbWl0IHByaWNlIGV4cHJlc3NlZCBpbiB1bml0cyBvZiBSQU8gcGVyIG9uZSBBbHBoYS4AaCAqICdhbGxvd19wYXJ0aWFsJyAoYm9vbCk6IQEJLSBBbGxvd3MgcGFydGlhbCBleGVjdXRpb24gb2YgdGhlIGFtb3VudC4gSWYgc2V0IHRvIGZhbHNlLCB0aGlzIGJlY29tZXOEICAgICAgZmlsbCBvciBraWxsIHR5cGUgb3Igb3JkZXIuACAjIEV2ZW50OjggKiBTdGFrZUFkZGVkO+AJLSBPbiB0aGUgc3VjY2Vzc2Z1bGx5IGFkZGluZyBzdGFrZSB0byBhIGdsb2JhbCBhY2NvdW50LgAkIyBSYWlzZXM6dCAqICdOb3RFbm91Z2hCYWxhbmNlVG9TdGFrZSc6EQEJLSBOb3QgZW5vdWdoIGJhbGFuY2Ugb24gdGhlIGNvbGRrZXkgdG8gYWRkIG9udG8gdGhlIGdsb2JhbCBhY2NvdW50LgBoICogJ05vbkFzc29jaWF0ZWRDb2xkS2V5JzroCS0gVGhlIGNhbGxpbmcgY29sZGtleSBpcyBub3QgYXNzb2NpYXRlZCB3aXRoIHRoaXMgaG90a2V5LgBwICogJ0JhbGFuY2VXaXRoZHJhd2FsRXJyb3InOrAgCS0gRXJyb3JzIHN0ZW1taW5nIGZyb20gdHJhbnNhY3Rpb24gcGFsbGV0LgBIcmVtb3ZlX3N0YWtlX2xpbWl0FAEYaG90a2V5AAEwVDo6QWNjb3VudElkAAEYbmV0dWlkoAEYTmV0VWlkAAE8YW1vdW50X3Vuc3Rha2VkGAEwQWxwaGFCYWxhbmNlAAEsbGltaXRfcHJpY2UYAShUYW9CYWxhbmNlAAE0YWxsb3dfcGFydGlhbCQBEGJvb2wAWaj8LS0tIFJlbW92ZXMgc3Rha2UgZnJvbSBhIGhvdGtleSBvbiBhIHN1Ym5ldCB3aXRoIGEgcHJpY2UgbGltaXQuAQFUaGlzIGV4dHJpbnNpYyBhbGxvd3MgdG8gc3BlY2lmeSB0aGUgbGltaXQgcHJpY2UgZm9yIGFscGhhIHRva2Vu3GF0IHdoaWNoIG9yIGJldHRlciAoaGlnaGVyKSB0aGUgc3Rha2luZyBzaG91bGQgZXhlY3V0ZS4AEQFJbiBjYXNlIGlmIHNsaXBwYWdlIG9jY3VycyBhbmQgdGhlIHByaWNlIHNoYWxsIG1vdmUgYmV5b25kIHRoZSBsaW1pdAkBcHJpY2UsIHRoZSBzdGFraW5nIG9yZGVyIG1heSBleGVjdXRlIG9ubHkgcGFydGlhbGx5IG9yIG5vdCBleGVjdXRlHGF0IGFsbC4AHCMgQXJnczrAKiAnb3JpZ2luJzogKDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPk9yaWdpbik6pAktIFRoZSBzaWduYXR1cmUgb2YgdGhlIGNhbGxlcidzIGNvbGRrZXkuAGgqICdob3RrZXknIChUOjpBY2NvdW50SWQpOoQJLSBUaGUgYXNzb2NpYXRlZCBob3RrZXkgYWNjb3VudC4ARCogJ25ldHVpZCcgKHUxNik6UCAgICAtIFN1Ym5ldHdvcmsgVUlEAGgqICdhbW91bnRfdW5zdGFrZWQnICh1NjQpOgUBCS0gVGhlIGFtb3VudCBvZiBzdGFrZSB0byBiZSBhZGRlZCB0byB0aGUgaG90a2V5IHN0YWtpbmcgYWNjb3VudC4AXCAqICdsaW1pdF9wcmljZScgKHU2NCk6+CAgICAtIFRoZSBsaW1pdCBwcmljZSBleHByZXNzZWQgaW4gdW5pdHMgb2YgUkFPIHBlciBvbmUgQWxwaGEuAGggKiAnYWxsb3dfcGFydGlhbCcgKGJvb2wpOi0BICAgIC0gQWxsb3dzIHBhcnRpYWwgZXhlY3V0aW9uIG9mIHRoZSBhbW91bnQuIElmIHNldCB0byBmYWxzZSwgdGhpcyBiZWNvbWVzhCAgICAgIGZpbGwgb3Iga2lsbCB0eXBlIG9yIG9yZGVyLgAgIyBFdmVudDo8KiBTdGFrZVJlbW92ZWQ7+AktIE9uIHRoZSBzdWNjZXNzZnVsbHkgcmVtb3Zpbmcgc3Rha2UgZnJvbSB0aGUgaG90a2V5IGFjY291bnQuACQjIFJhaXNlczpIKiAnTm90UmVnaXN0ZXJlZCc6LQEJLSBUaHJvd24gaWYgdGhlIGFjY291bnQgd2UgYXJlIGF0dGVtcHRpbmcgdG8gdW5zdGFrZSBmcm9tIGlzIG5vbiBleGlzdGVudC4AZCogJ05vbkFzc29jaWF0ZWRDb2xkS2V5JzodAQktIFRocm93biBpZiB0aGUgY29sZGtleSBkb2VzIG5vdCBvd24gdGhlIGhvdGtleSB3ZSBhcmUgdW5zdGFraW5nIGZyb20uAHQqICdOb3RFbm91Z2hTdGFrZVRvV2l0aGRyYXcnOjkBCS0gVGhyb3duIGlmIHRoZXJlIGlzIG5vdCBlbm91Z2ggc3Rha2Ugb24gdGhlIGhvdGtleSB0byB3aXRoZHdyYXcgdGhpcyBhbW91bnQuAEBzd2FwX3N0YWtlX2xpbWl0GAEYaG90a2V5AAEwVDo6QWNjb3VudElkAAE0b3JpZ2luX25ldHVpZKABGE5ldFVpZAABSGRlc3RpbmF0aW9uX25ldHVpZKABGE5ldFVpZAABMGFscGhhX2Ftb3VudBgBMEFscGhhQmFsYW5jZQABLGxpbWl0X3ByaWNlGAEoVGFvQmFsYW5jZQABNGFsbG93X3BhcnRpYWwkARBib29sAFpUoQFTd2FwcyBhIHNwZWNpZmllZCBhbW91bnQgb2Ygc3Rha2UgZnJvbSBvbmUgc3VibmV0IHRvIGFub3RoZXIsIHdoaWxlIGtlZXBpbmcgdGhlIHNhbWUgY29sZGtleSBhbmQgaG90a2V5LgAsIyBBcmd1bWVudHOdASogYG9yaWdpbmAgLSBUaGUgb3JpZ2luIG9mIHRoZSB0cmFuc2FjdGlvbiwgd2hpY2ggbXVzdCBiZSBzaWduZWQgYnkgdGhlIGNvbGRrZXkgdGhhdCBvd25zIHRoZSBgaG90a2V5YC7UKiBgaG90a2V5YCAtIFRoZSBob3RrZXkgd2hvc2Ugc3Rha2UgaXMgYmVpbmcgc3dhcHBlZC4ZASogYG9yaWdpbl9uZXR1aWRgIC0gVGhlIG5ldHdvcmsvc3VibmV0IElEIGZyb20gd2hpY2ggc3Rha2UgaXMgcmVtb3ZlZC4dASogYGRlc3RpbmF0aW9uX25ldHVpZGAgLSBUaGUgbmV0d29yay9zdWJuZXQgSUQgdG8gd2hpY2ggc3Rha2UgaXMgYWRkZWQuvCogYGFscGhhX2Ftb3VudGAgLSBUaGUgYW1vdW50IG9mIHN0YWtlIHRvIHN3YXAuKQEqIGBsaW1pdF9wcmljZWAgLSBUaGUgbGltaXQgcHJpY2UgZXhwcmVzc2VkIGluIHVuaXRzIG9mIFJBTyBwZXIgb25lIEFscGhhLtUBKiBgYWxsb3dfcGFydGlhbGAgLSBBbGxvd3MgcGFydGlhbCBleGVjdXRpb24gb2YgdGhlIGFtb3VudC4gSWYgc2V0IHRvIGZhbHNlLCB0aGlzIGJlY29tZXMgZmlsbCBvciBraWxsIHR5cGUgb3Igb3JkZXIuACAjIEVycm9yc1BSZXR1cm5zIGFuIGVycm9yIGlmOm0BKiBUaGUgdHJhbnNhY3Rpb24gaXMgbm90IHNpZ25lZCBieSB0aGUgY29ycmVjdCBjb2xka2V5IChpLmUuLCBgY29sZGtleV9vd25zX2hvdGtleWAgZmFpbHMpLgEBKiBFaXRoZXIgYG9yaWdpbl9uZXR1aWRgIG9yIGBkZXN0aW5hdGlvbl9uZXR1aWRgIGRvZXMgbm90IGV4aXN0LnAqIFRoZSBob3RrZXkgZG9lcyBub3QgZXhpc3QuEQEqIFRoZXJlIGlzIGluc3VmZmljaWVudCBzdGFrZSBvbiBgKGNvbGRrZXksIGhvdGtleSwgb3JpZ2luX25ldHVpZClgLuQqIFRoZSBzd2FwIGFtb3VudCBpcyBiZWxvdyB0aGUgbWluaW11bSBzdGFrZSByZXF1aXJlbWVudC4AICMgRXZlbnRzrE1heSBlbWl0IGEgYFN0YWtlU3dhcHBlZGAgZXZlbnQgb24gc3VjY2Vzcy5QdHJ5X2Fzc29jaWF0ZV9ob3RrZXkEARhob3RrZXkAATBUOjpBY2NvdW50SWQAWyC4QXR0ZW1wdHMgdG8gYXNzb2NpYXRlIGEgaG90a2V5IHdpdGggYSBjb2xka2V5LgAsIyBBcmd1bWVudHOdASogYG9yaWdpbmAgLSBUaGUgb3JpZ2luIG9mIHRoZSB0cmFuc2FjdGlvbiwgd2hpY2ggbXVzdCBiZSBzaWduZWQgYnkgdGhlIGNvbGRrZXkgdGhhdCBvd25zIHRoZSBgaG90a2V5YC7YKiBgaG90a2V5YCAtIFRoZSBob3RrZXkgdG8gYXNzb2NpYXRlIHdpdGggdGhlIGNvbGRrZXkuABgjIE5vdGVhAVdpbGwgY2hhcmdlIGJhc2VkIG9uIHRoZSB3ZWlnaHQgZXZlbiBpZiB0aGUgaG90a2V5IGlzIGFscmVhZHkgYXNzb2NpYXRlZCB3aXRoIGEgY29sZGtleS4oc3RhcnRfY2FsbAQBGG5ldHVpZKABGE5ldFVpZABcIHRJbml0aWF0ZXMgYSBjYWxsIG9uIGEgc3VibmV0LgAsIyBBcmd1bWVudHM5ASogYG9yaWdpbmAgLSBUaGUgb3JpZ2luIG9mIHRoZSBjYWxsLCB3aGljaCBtdXN0IGJlIHNpZ25lZCBieSB0aGUgc3VibmV0IG93bmVyLlkBKiBgbmV0dWlkYCAtIFRoZSB1bmlxdWUgaWRlbnRpZmllciBvZiB0aGUgc3VibmV0IG9uIHdoaWNoIHRoZSBjYWxsIGlzIGJlaW5nIGluaXRpYXRlZC4AICMgRXZlbnRz3EVtaXRzIGEgYEZpcnN0RW1pc3Npb25CbG9ja051bWJlclNldGAgZXZlbnQgb24gc3VjY2Vzcy5EYXNzb2NpYXRlX2V2bV9rZXkQARhuZXR1aWSgARhOZXRVaWQAARxldm1fa2V5xAEQSDE2MAABMGJsb2NrX251bWJlchgBDHU2NAABJHNpZ25hdHVyZXkCASRTaWduYXR1cmUAXWS8QXR0ZW1wdHMgdG8gYXNzb2NpYXRlIGEgaG90a2V5IHdpdGggYW4gRVZNIGtleS4AgQFUaGUgc2lnbmF0dXJlIHdpbGwgYmUgY2hlY2tlZCB0byBzZWUgaWYgdGhlIHJlY292ZXJlZCBwdWJsaWMga2V5IG1hdGNoZXMgdGhlIGBldm1fa2V5YCBwcm92aWRlZC4AfQFUaGUgRVZNIGtleSBpcyBleHBlY3RlZCB0byBzaWduIHRoZSBtZXNzYWdlIGFjY29yZGluZyB0byB0aGlzIGZvcm11bGEgdG8gcHJvZHVjZSB0aGUgc2lnbmF0dXJlOhxgYGB0ZXh0uGtlY2Nha18yNTYoaG90a2V5ICsrIGtlY2Nha18yNTYoYmxvY2tfbnVtYmVyKSkMYGBgACwjIEFyZ3VtZW50c0UBKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIHRyYW5zYWN0aW9uLCB3aGljaCBtdXN0IGJlIHNpZ25lZCBieSB0aGUgYGhvdGtleWAu1CogYG5ldHVpZGAgLSBUaGUgbmV0dWlkIHRoYXQgdGhlIGBob3RrZXlgIGJlbG9uZ3MgdG8u5CogYGV2bV9rZXlgIC0gVGhlIEVWTSBrZXkgdG8gYXNzb2NpYXRlIHdpdGggdGhlIGBob3RrZXlgLvAqIGBibG9ja19udW1iZXJgIC0gVGhlIGJsb2NrIG51bWJlciB1c2VkIGluIHRoZSBgc2lnbmF0dXJlYC6hASogYHNpZ25hdHVyZWAgLSBBIHNpZ25lZCBtZXNzYWdlIGJ5IHRoZSBgZXZtX2tleWAgY29udGFpbmluZyB0aGUgYGhvdGtleWAgYW5kIHRoZSBoYXNoZWQgYGJsb2NrX251bWJlcmAuACAjIEVycm9yc1BSZXR1cm5zIGFuIGVycm9yIGlmOoAqIFRoZSB0cmFuc2FjdGlvbiBpcyBub3Qgc2lnbmVkLhEBKiBUaGUgaG90a2V5IGRvZXMgbm90IGJlbG9uZyB0byB0aGUgc3VibmV0IGlkZW50aWZpZWQgYnkgdGhlIG5ldHVpZC7UKiBUaGUgRVZNIGtleSBjYW5ub3QgYmUgcmVjb3ZlcmVkIGZyb20gdGhlIHNpZ25hdHVyZS4xASogVGhlIEVWTSBrZXkgcmVjb3ZlcmVkIGZyb20gdGhlIHNpZ25hdHVyZSBkb2VzIG5vdCBtYXRjaCB0aGUgZ2l2ZW4gRVZNIGtleS4AICMgRXZlbnRzuE1heSBlbWl0IGEgYEV2bUtleUFzc29jaWF0ZWRgIGV2ZW50IG9uIHN1Y2Nlc3M0cmVjeWNsZV9hbHBoYQwBGGhvdGtleQABMFQ6OkFjY291bnRJZAABGGFtb3VudBgBMEFscGhhQmFsYW5jZQABGG5ldHVpZKABGE5ldFVpZABlKBkBUmVjeWNsZXMgYWxwaGEgZnJvbSBhIGNvbGQvaG90IGtleSBwYWlyLCByZWR1Y2luZyBBbHBoYU91dCBvbiBhIHN1Ym5ldAAsIyBBcmd1bWVudHMNASogYG9yaWdpbmAgLSBUaGUgb3JpZ2luIG9mIHRoZSBjYWxsIChtdXN0IGJlIHNpZ25lZCBieSB0aGUgY29sZGtleSl8KiBgaG90a2V5YCAtIFRoZSBob3RrZXkgYWNjb3VudKwqIGBhbW91bnRgIC0gVGhlIGFtb3VudCBvZiBhbHBoYSB0byByZWN5Y2xlaCogYG5ldHVpZGAgLSBUaGUgc3VibmV0IElEACAjIEV2ZW50c6hFbWl0cyBhIGBUb2tlbnNSZWN5Y2xlZGAgZXZlbnQgb24gc3VjY2Vzcy4oYnVybl9hbHBoYQwBGGhvdGtleQABMFQ6OkFjY291bnRJZAABGGFtb3VudBgBMEFscGhhQmFsYW5jZQABGG5ldHVpZKABGE5ldFVpZABmKAEBQnVybnMgYWxwaGEgZnJvbSBhIGNvbGQvaG90IGtleSBwYWlyIHdpdGhvdXQgcmVkdWNpbmcgYEFscGhhT3V0YAAsIyBBcmd1bWVudHMNASogYG9yaWdpbmAgLSBUaGUgb3JpZ2luIG9mIHRoZSBjYWxsIChtdXN0IGJlIHNpZ25lZCBieSB0aGUgY29sZGtleSl8KiBgaG90a2V5YCAtIFRoZSBob3RrZXkgYWNjb3VudKAqIGBhbW91bnRgIC0gVGhlIGFtb3VudCBvZiBhbHBoYSB0byBidXJuaCogYG5ldHVpZGAgLSBUaGUgc3VibmV0IElEACAjIEV2ZW50c6BFbWl0cyBhIGBUb2tlbnNCdXJuZWRgIGV2ZW50IG9uIHN1Y2Nlc3MudHNldF9wZW5kaW5nX2NoaWxka2V5X2Nvb2xkb3duBAEgY29vbGRvd24YAQx1NjQAbQToU2V0cyB0aGUgcGVuZGluZyBjaGlsZGtleSBjb29sZG93biAoaW4gYmxvY2tzKS4gUm9vdCBvbmx5LlxyZW1vdmVfc3Rha2VfZnVsbF9saW1pdAwBGGhvdGtleQABMFQ6OkFjY291bnRJZAABGG5ldHVpZKABGE5ldFVpZAABLGxpbWl0X3ByaWNlfQIBSE9wdGlvbjxUYW9CYWxhbmNlPgBnEPxSZW1vdmVzIGFsbCBzdGFrZSBmcm9tIGEgaG90a2V5IG9uIGEgc3VibmV0IHdpdGggYSBwcmljZSBsaW1pdC4BAVRoaXMgZXh0cmluc2ljIGFsbG93cyB0byBzcGVjaWZ5IHRoZSBsaW1pdCBwcmljZSBmb3IgYWxwaGEgdG9rZW7cYXQgd2hpY2ggb3IgYmV0dGVyIChoaWdoZXIpIHRoZSBzdGFraW5nIHNob3VsZCBleGVjdXRlLj0BV2l0aG91dCBsaW1pdF9wcmljZSBpdCByZW1vdmUgYWxsIHRoZSBzdGFrZSBzaW1pbGFyIHRvIGByZW1vdmVfc3Rha2VgIGV4dHJpbnNpY1xyZWdpc3Rlcl9sZWFzZWRfbmV0d29yawgBPGVtaXNzaW9uc19zaGFyZYECARxQZXJjZW50AAEkZW5kX2Jsb2NrzAFkT3B0aW9uPEJsb2NrTnVtYmVyRm9yPFQ+PgBuQHhSZWdpc3RlciBhIG5ldyBsZWFzZWQgbmV0d29yay4AiQFUaGUgY3Jvd2Rsb2FuJ3MgY29udHJpYnV0aW9ucyBhcmUgdXNlZCB0byBjb21wdXRlIHRoZSBzaGFyZSBvZiB0aGUgZW1pc3Npb25zIHRoYXQgdGhlIGNvbnRyaWJ1dG9yc2h3aWxsIHJlY2VpdmUgYXMgZGl2aWRlbmRzLgAVAVRoZSBsZWZ0b3ZlciBjYXAgaXMgcmVmdW5kZWQgdG8gdGhlIGNvbnRyaWJ1dG9ycyBhbmQgdGhlIGJlbmVmaWNpYXJ5LgAcIyBBcmdzOswqIGBvcmlnaW5gIC0gKDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6T3JpZ2luKTqwICAgIC0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY2FsbGVyJ3MgY29sZGtleS4AeCogYGVtaXNzaW9uc19zaGFyZWAgKFBlcmNlbnQpOkUBICAgIC0gVGhlIHNoYXJlIG9mIHRoZSBlbWlzc2lvbnMgdGhhdCB0aGUgY29udHJpYnV0b3JzIHdpbGwgcmVjZWl2ZSBhcyBkaXZpZGVuZHMuAKgqIGBlbmRfYmxvY2tgIChPcHRpb248QmxvY2tOdW1iZXJGb3I8VD4+KTpRASAgICAtIFRoZSBibG9jayBhdCB3aGljaCB0aGUgbGVhc2Ugd2lsbCBlbmQuIElmIG5vdCBkZWZpbmVkLCB0aGUgbGVhc2UgaXMgcGVycGV0dWFsLjx0ZXJtaW5hdGVfbGVhc2UIASBsZWFzZV9pZBABHExlYXNlSWQAARhob3RrZXkAATBUOjpBY2NvdW50SWQAb0BIVGVybWluYXRlIGEgbGVhc2UuAJEBVGhlIGJlbmVmaWNpYXJ5IGNhbiB0ZXJtaW5hdGUgdGhlIGxlYXNlIGFmdGVyIHRoZSBlbmQgYmxvY2sgaGFzIHBhc3NlZCBhbmQgZ2V0IHRoZSBzdWJuZXQgb3duZXJzaGlwLk0BVGhlIHN1Ym5ldCBpcyB0cmFuc2ZlcnJlZCB0byB0aGUgYmVuZWZpY2lhcnkgYW5kIHRoZSBsZWFzZSBpcyByZW1vdmVkIGZyb20gc3RvcmFnZS4A4CoqVGhlIGhvdGtleSBtdXN0IGJlIG93bmVkIGJ5IHRoZSBiZW5lZmljaWFyeSBjb2xka2V5LioqABwjIEFyZ3M6zCogYG9yaWdpbmAgLSAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+OjpPcmlnaW4pOrAgICAgLSBUaGUgc2lnbmF0dXJlIG9mIHRoZSBjYWxsZXIncyBjb2xka2V5LgBcKiBgbGVhc2VfaWRgIChMZWFzZUlkKTqcICAgIC0gVGhlIElEIG9mIHRoZSBsZWFzZSB0byB0ZXJtaW5hdGUuAGgqIGBob3RrZXlgIChUOjpBY2NvdW50SWQpOg0BICAgIC0gVGhlIGhvdGtleSBvZiB0aGUgYmVuZWZpY2lhcnkgdG8gbWFyayBhcyBzdWJuZXQgb3duZXIgaG90a2V5LjR1cGRhdGVfc3ltYm9sCAEYbmV0dWlkoAEYTmV0VWlkAAEYc3ltYm9sOAEcVmVjPHU4PgBwPIBVcGRhdGVzIHRoZSBzeW1ib2wgZm9yIGEgc3VibmV0LgAsIyBBcmd1bWVudHMxASogYG9yaWdpbmAgLSBUaGUgb3JpZ2luIG9mIHRoZSBjYWxsLCB3aGljaCBtdXN0IGJlIHRoZSBzdWJuZXQgb3duZXIgb3Igcm9vdC5JASogYG5ldHVpZGAgLSBUaGUgdW5pcXVlIGlkZW50aWZpZXIgb2YgdGhlIHN1Ym5ldCBvbiB3aGljaCB0aGUgc3ltYm9sIGlzIGJlaW5nIHNldC64KiBgc3ltYm9sYCAtIFRoZSBzeW1ib2wgdG8gc2V0IGZvciB0aGUgc3VibmV0LgAgIyBFcnJvcnNQUmV0dXJucyBhbiBlcnJvciBpZjrQKiBUaGUgdHJhbnNhY3Rpb24gaXMgbm90IHNpZ25lZCBieSB0aGUgc3VibmV0IG93bmVyLnAqIFRoZSBzeW1ib2wgZG9lcyBub3QgZXhpc3QuxCogVGhlIHN5bWJvbCBpcyBhbHJlYWR5IGluIHVzZSBieSBhbm90aGVyIHN1Ym5ldC4AICMgRXZlbnRzpEVtaXRzIGEgYFN5bWJvbFVwZGF0ZWRgIGV2ZW50IG9uIHN1Y2Nlc3MuZGNvbW1pdF90aW1lbG9ja2VkX3dlaWdodHMQARhuZXR1aWSgARhOZXRVaWQAARhjb21taXRlAgHQQm91bmRlZFZlYzx1OCwgQ29uc3RVMzI8TUFYX0NSVjNfQ09NTUlUX1NJWkVfQllURVM+PgABMHJldmVhbF9yb3VuZBgBDHU2NAABVGNvbW1pdF9yZXZlYWxfdmVyc2lvbqABDHUxNgBxYGEBLS0tLSBVc2VkIHRvIGNvbW1pdCB0aW1lbG9jayBlbmNyeXB0ZWQgY29tbWl0LXJldmVhbCB3ZWlnaHQgdmFsdWVzIHRvIGxhdGVyIGJlIHJldmVhbGVkLgAcIyBBcmdzOuwqIGBvcmlnaW5gOiAoYDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6UnVudGltZU9yaWdpbmApOmggIC0gVGhlIGNvbW1pdHRpbmcgaG90a2V5LgBMKiBgbmV0dWlkYCAoYHUxNmApOnwgIC0gVGhlIHUxNiBuZXR3b3JrIGlkZW50aWZpZXIuAFwqIGBjb21taXRgIChgVmVjPHU4PmApOpAgIC0gVGhlIGVuY3J5cHRlZCBjb21wcmVzc2VkIGNvbW1pdC5sICAgIFRoZSBzdGVwcyBmb3IgdGhpcyBhcmU6qCAgICAxLiBJbnN0YW50aWF0ZSBbYFdlaWdodHNUbG9ja1BheWxvYWRgXQEBICAgIDIuIFNlcmlhbGl6ZSBpdCB1c2luZyB0aGUgYHBhcml0eV9zY2FsZV9jb2RlYzo6RW5jb2RlYCB0cmFpdHUCICAgIDMuIEVuY3J5cHQgaXQgZm9sbG93aW5nIHRoZSBzdGVwcyAoaGVyZSlbaHR0cHM6Ly9naXRodWIuY29tL2lkZWFsLWxhYjUvdGxlL2Jsb2IvZjhlNjAxOWYwZmIwMmMzODBlYmZhNmIzMGVmYjYxNzg2ZGVkZTA3Yi90aW1lbG9jay9zcmMvdGxvY2sucnMjTDI4My1MMzM2XdwgICAgICAgdG8gcHJvZHVjZSBhIFtgVExFQ2lwaGVydGV4dDxUaW55QkxTMzgxPmBdIHR5cGUuTQEgICAgNC4gU2VyaWFsaXplIGFuZCBjb21wcmVzcyB1c2luZyB0aGUgYGFyay1zZXJpYWxpemVgIGBDYW5vbmljYWxTZXJpYWxpemVgIHRyYWl0LgBcKiByZXZlYWxfcm91bmQgKGB1NjRgKTpdASAgIC0gVGhlIGRyYW5kIHJldmVhbCByb3VuZCB3aGljaCB3aWxsIGJlIGF2YWxpYWJsZSBkdXJpbmcgZXBvY2ggYG4rMWAgZnJvbSB0aGUgY3VycmVudCwgICAgIGVwb2NoLgCAKiBjb21taXRfcmV2ZWFsX3ZlcnNpb24gKGB1MTZgKTqoICAgIC0gVGhlIGNsaWVudCAoYml0dGVuc29yLWRyYW5kKSB2ZXJzaW9udHNldF9jb2xka2V5X2F1dG9fc3Rha2VfaG90a2V5CAEYbmV0dWlkoAEYTmV0VWlkAAEYaG90a2V5AAEwVDo6QWNjb3VudElkAHIszFNldCB0aGUgYXV0b3N0YWtlIGRlc3RpbmF0aW9uIGhvdGtleSBmb3IgYSBjb2xka2V5LgDQVGhlIGNhbGxlciBzZWxlY3RzIGEgaG90a2V5IHdoZXJlIGFsbCBmdXR1cmUgcmV3YXJkc3R3aWxsIGJlIGF1dG9tYXRpY2FsbHkgc3Rha2VkLgAcIyBBcmdzOswqIGBvcmlnaW5gIC0gKDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPjo6T3JpZ2luKTqwICAgIC0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY2FsbGVyJ3MgY29sZGtleS4AaCogYGhvdGtleWAgKFQ6OkFjY291bnRJZCk6DQEgICAgLSBUaGUgaG90a2V5IGFjY291bnQgdG8gZGVzaWduYXRlIGFzIHRoZSBhdXRvc3Rha2UgZGVzdGluYXRpb24ujGNvbW1pdF90aW1lbG9ja2VkX21lY2hhbmlzbV93ZWlnaHRzFAEYbmV0dWlkoAEYTmV0VWlkAAEUbWVjaWQIARhNZWNoSWQAARhjb21taXRlAgHQQm91bmRlZFZlYzx1OCwgQ29uc3RVMzI8TUFYX0NSVjNfQ09NTUlUX1NJWkVfQllURVM+PgABMHJldmVhbF9yb3VuZBgBDHU2NAABVGNvbW1pdF9yZXZlYWxfdmVyc2lvbqABDHUxNgB2cG0BLS0tLSBVc2VkIHRvIGNvbW1pdCB0aW1lbG9jayBlbmNyeXB0ZWQgY29tbWl0LXJldmVhbCB3ZWlnaHQgdmFsdWVzIHRvIGxhdGVyIGJlIHJldmVhbGVkIGZvcjBhIG1lY2hhbmlzbS4AHCMgQXJnczrsKiBgb3JpZ2luYDogKGA8VCBhcyBmcmFtZV9zeXN0ZW06OkNvbmZpZz46OlJ1bnRpbWVPcmlnaW5gKTpoICAtIFRoZSBjb21taXR0aW5nIGhvdGtleS4ATCogYG5ldHVpZGAgKGB1MTZgKTp8ICAtIFRoZSB1MTYgbmV0d29yayBpZGVudGlmaWVyLgBEKiBgbWVjaWRgIChgdThgKTqAICAtIFRoZSB1OCBtZWNoYW5pc20gaWRlbnRpZmllci4AXCogYGNvbW1pdGAgKGBWZWM8dTg+YCk6kCAgLSBUaGUgZW5jcnlwdGVkIGNvbXByZXNzZWQgY29tbWl0LmwgICAgVGhlIHN0ZXBzIGZvciB0aGlzIGFyZTqoICAgIDEuIEluc3RhbnRpYXRlIFtgV2VpZ2h0c1Rsb2NrUGF5bG9hZGBdAQEgICAgMi4gU2VyaWFsaXplIGl0IHVzaW5nIHRoZSBgcGFyaXR5X3NjYWxlX2NvZGVjOjpFbmNvZGVgIHRyYWl0dQIgICAgMy4gRW5jcnlwdCBpdCBmb2xsb3dpbmcgdGhlIHN0ZXBzIChoZXJlKVtodHRwczovL2dpdGh1Yi5jb20vaWRlYWwtbGFiNS90bGUvYmxvYi9mOGU2MDE5ZjBmYjAyYzM4MGViZmE2YjMwZWZiNjE3ODZkZWRlMDdiL3RpbWVsb2NrL3NyYy90bG9jay5ycyNMMjgzLUwzMzZd3CAgICAgICB0byBwcm9kdWNlIGEgW2BUTEVDaXBoZXJ0ZXh0PFRpbnlCTFMzODE+YF0gdHlwZS5NASAgICA0LiBTZXJpYWxpemUgYW5kIGNvbXByZXNzIHVzaW5nIHRoZSBgYXJrLXNlcmlhbGl6ZWAgYENhbm9uaWNhbFNlcmlhbGl6ZWAgdHJhaXQuAFwqIHJldmVhbF9yb3VuZCAoYHU2NGApOl0BICAgLSBUaGUgZHJhbmQgcmV2ZWFsIHJvdW5kIHdoaWNoIHdpbGwgYmUgYXZhbGlhYmxlIGR1cmluZyBlcG9jaCBgbisxYCBmcm9tIHRoZSBjdXJyZW50LCAgICAgZXBvY2guAIAqIGNvbW1pdF9yZXZlYWxfdmVyc2lvbiAoYHUxNmApOqggICAgLSBUaGUgY2xpZW50IChiaXR0ZW5zb3ItZHJhbmQpIHZlcnNpb25Ucm9vdF9kaXNzb2x2ZV9uZXR3b3JrBAEYbmV0dWlkoAEYTmV0VWlkAHgITFJlbW92ZSBhIHN1Ym5ldHdvcmtcVGhlIGNhbGxlciBtdXN0IGJlIHJvb3QoY2xhaW1fcm9vdAQBHHN1Ym5ldHPYAUBCVHJlZVNldDxOZXRVaWQ+AHkssC0tLSBDbGFpbXMgdGhlIHJvb3QgZW1pc3Npb25zIGZvciBhIGNvbGRrZXkuHCMgQXJnczrAKiAnb3JpZ2luJzogKDxUIGFzIGZyYW1lX3N5c3RlbTo6Q29uZmlnPk9yaWdpbik6pAktIFRoZSBzaWduYXR1cmUgb2YgdGhlIGNhbGxlcidzIGNvbGRrZXkuACAjIEV2ZW50OjgqIFJvb3RDbGFpbWVkOwUBCS0gT24gdGhlIHN1Y2Nlc3NmdWxseSBjbGFpbWluZyB0aGUgcm9vdCBlbWlzc2lvbnMgZm9yIGEgY29sZGtleS4AJCMgUmFpc2VzOgBMc2V0X3Jvb3RfY2xhaW1fdHlwZQQBTG5ld19yb290X2NsYWltX3R5cGXUAURSb290Q2xhaW1UeXBlRW51bQB6JLQtLS0gU2V0cyB0aGUgcm9vdCBjbGFpbSB0eXBlIGZvciB0aGUgY29sZGtleS4cIyBBcmdzOsAqICdvcmlnaW4nOiAoPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+T3JpZ2luKTqkCS0gVGhlIHNpZ25hdHVyZSBvZiB0aGUgY2FsbGVyJ3MgY29sZGtleS4AICMgRXZlbnQ6TCogUm9vdENsYWltVHlwZVNldDsNAQktIE9uIHRoZSBzdWNjZXNzZnVsbHkgc2V0dGluZyB0aGUgcm9vdCBjbGFpbSB0eXBlIGZvciB0aGUgY29sZGtleS4AYHN1ZG9fc2V0X251bV9yb290X2NsYWltcwQBJG5ld192YWx1ZRgBDHU2NAB7BBkBLS0tIFNldHMgcm9vdCBjbGFpbSBudW1iZXIgKHN1ZG8gZXh0cmluc2ljKS4gWmVybyBkaXNhYmxlcyBhdXRvLWNsYWltLnRzdWRvX3NldF9yb290X2NsYWltX3RocmVzaG9sZAgBGG5ldHVpZKABGE5ldFVpZAABJG5ld192YWx1ZRgBDHU2NAB8BAEBLS0tIFNldHMgcm9vdCBjbGFpbSB0aHJlc2hvbGQgZm9yIHN1Ym5ldCAoc3VkbyBvciBvd25lciBvcmlnaW4pLlRhbm5vdW5jZV9jb2xka2V5X3N3YXAEAUBuZXdfY29sZGtleV9oYXNoNAEcVDo6SGFzaAB9OA0BQW5ub3VuY2VzIGEgY29sZGtleSBzd2FwIHVzaW5nIEJsYWtlVHdvMjU2IGhhc2ggb2YgdGhlIG5ldyBjb2xka2V5LgDkVGhpcyBpcyByZXF1aXJlZCBiZWZvcmUgdGhlIGNvbGRrZXkgc3dhcCBjYW4gYmUgcGVyZm9ybWVkXGFmdGVyIHRoZSBkZWxheSBwZXJpb2QuAEUBSXQgY2FuIGJlIHJlYW5ub3VuY2VkIGFmdGVyIGEgZGVsYXkgb2YgYENvbGRrZXlTd2FwUmVhbm5vdW5jZW1lbnREZWxheWAgZm9sbG93aW5n9HRoZSBmaXJzdCB2YWxpZCBleGVjdXRpb24gYmxvY2sgb2YgdGhlIG9yaWdpbmFsIGFubm91bmNlbWVudC4AZQFUaGUgZGlzcGF0Y2ggb3JpZ2luIG9mIHRoaXMgY2FsbCBtdXN0IGJlIHRoZSBvcmlnaW5hbCBjb2xka2V5IHRoYXQgbWFkZSB0aGUgYW5ub3VuY2VtZW50LgARAS0gYG5ld19jb2xka2V5X2hhc2hgOiBUaGUgaGFzaCBvZiB0aGUgbmV3IGNvbGRrZXkgdXNpbmcgQmxha2VUd28yNTYuAB0BVGhlIGBDb2xka2V5U3dhcEFubm91bmNlZGAgZXZlbnQgaXMgZW1pdHRlZCBvbiBzdWNjZXNzZnVsIGFubm91bmNlbWVudC4AWHN3YXBfY29sZGtleV9hbm5vdW5jZWQEASxuZXdfY29sZGtleQABMFQ6OkFjY291bnRJZAB+IORQZXJmb3JtcyBhIGNvbGRrZXkgc3dhcCBpZiBhbiBhbm5vdW5jZW1lbnQgaGFzIGJlZW4gbWFkZS4AZQFUaGUgZGlzcGF0Y2ggb3JpZ2luIG9mIHRoaXMgY2FsbCBtdXN0IGJlIHRoZSBvcmlnaW5hbCBjb2xka2V5IHRoYXQgbWFkZSB0aGUgYW5ub3VuY2VtZW50LgBxAS0gYG5ld19jb2xka2V5YDogVGhlIG5ldyBjb2xka2V5IHRvIHN3YXAgdG8uIFRoZSBCbGFrZVR3bzI1NiBoYXNoIG9mIHRoZSBuZXcgY29sZGtleSBtdXN0IGJlpCAgdGhlIHNhbWUgYXMgdGhlIGFubm91bmNlZCBjb2xka2V5IGhhc2guAORUaGUgYENvbGRrZXlTd2FwcGVkYCBldmVudCBpcyBlbWl0dGVkIG9uIHN1Y2Nlc3NmdWwgc3dhcC5QZGlzcHV0ZV9jb2xka2V5X3N3YXAAfxxcRGlzcHV0ZSBhIGNvbGRrZXkgc3dhcC4A5FRoaXMgd2lsbCBwcmV2ZW50IGFueSBmdXJ0aGVyIGFjdGlvbnMgb24gdGhlIGNvbGRrZXkgc3dhcLx1bnRpbCB0cml1bXZpcmF0ZSBzdGVwIGluIHRvIHJlc29sdmUgdGhlIGlzc3VlLgDELSBgY29sZGtleWA6IFRoZSBjb2xka2V5IHRvIGRpc3B1dGUgdGhlIHN3YXAgZm9yLgBIcmVzZXRfY29sZGtleV9zd2FwBAEcY29sZGtleQABMFQ6OkFjY291bnRJZACAGBUBUmVzZXQgYSBjb2xka2V5IHN3YXAgYnkgY2xlYXJpbmcgdGhlIGFubm91bmNlbWVudCBhbmQgZGlzcHV0ZSBzdGF0dXMuALhUaGUgZGlzcGF0Y2ggb3JpZ2luIG9mIHRoaXMgY2FsbCBtdXN0IGJlIHJvb3QuALwtIGBjb2xka2V5YDogVGhlIGNvbGRrZXkgdG8gcmVzZXQgdGhlIHN3YXAgZm9yLgBwZW5hYmxlX3ZvdGluZ19wb3dlcl90cmFja2luZwQBGG5ldHVpZKABGE5ldFVpZACBNKxFbmFibGVzIHZvdGluZyBwb3dlciB0cmFja2luZyBmb3IgYSBzdWJuZXQuAOBUaGlzIGZ1bmN0aW9uIGNhbiBiZSBjYWxsZWQgYnkgdGhlIHN1Ym5ldCBvd25lciBvciByb290LiUBV2hlbiBlbmFibGVkLCB2b3RpbmcgcG93ZXIgRU1BIGlzIHVwZGF0ZWQgZXZlcnkgZXBvY2ggZm9yIGFsbCB2YWxpZGF0b3JzLsxWb3RpbmcgcG93ZXIgc3RhcnRzIGF0IDAgYW5kIGluY3JlYXNlcyBvdmVyIGVwb2Nocy4AMCMgQXJndW1lbnRzOgkBKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIG11c3QgYmUgc3VibmV0IG93bmVyIG9yIHJvb3Qu8CogYG5ldHVpZGAgLSBUaGUgc3VibmV0IHRvIGVuYWJsZSB2b3RpbmcgcG93ZXIgdHJhY2tpbmcgZm9yLgAkIyBFcnJvcnM6yCogYFN1Ym5ldE5vdEV4aXN0YCAtIElmIHRoZSBzdWJuZXQgZG9lcyBub3QgZXhpc3QuDQEqIGBOb3RTdWJuZXRPd25lcmAgLSBJZiB0aGUgY2FsbGVyIGlzIG5vdCB0aGUgc3VibmV0IG93bmVyIG9yIHJvb3QudGRpc2FibGVfdm90aW5nX3Bvd2VyX3RyYWNraW5nBAEYbmV0dWlkoAEYTmV0VWlkAII46FNjaGVkdWxlcyBkaXNhYmxpbmcgb2Ygdm90aW5nIHBvd2VyIHRyYWNraW5nIGZvciBhIHN1Ym5ldC4A4FRoaXMgZnVuY3Rpb24gY2FuIGJlIGNhbGxlZCBieSB0aGUgc3VibmV0IG93bmVyIG9yIHJvb3QuPQFWb3RpbmcgcG93ZXIgdHJhY2tpbmcgd2lsbCBjb250aW51ZSBmb3IgMTQgZGF5cyAoZ3JhY2UgcGVyaW9kKSBhZnRlciB0aGlzIGNhbGwsMQF0aGVuIGF1dG9tYXRpY2FsbHkgZGlzYWJsZSBhbmQgY2xlYXIgYWxsIFZvdGluZ1Bvd2VyIGVudHJpZXMgZm9yIHRoZSBzdWJuZXQuADAjIEFyZ3VtZW50czoJASogYG9yaWdpbmAgLSBUaGUgb3JpZ2luIG9mIHRoZSBjYWxsLCBtdXN0IGJlIHN1Ym5ldCBvd25lciBvciByb290LiEBKiBgbmV0dWlkYCAtIFRoZSBzdWJuZXQgdG8gc2NoZWR1bGUgZGlzYWJsaW5nIHZvdGluZyBwb3dlciB0cmFja2luZyBmb3IuACQjIEVycm9yczrIKiBgU3VibmV0Tm90RXhpc3RgIC0gSWYgdGhlIHN1Ym5ldCBkb2VzIG5vdCBleGlzdC4NASogYE5vdFN1Ym5ldE93bmVyYCAtIElmIHRoZSBjYWxsZXIgaXMgbm90IHRoZSBzdWJuZXQgb3duZXIgb3Igcm9vdC4xASogYFZvdGluZ1Bvd2VyVHJhY2tpbmdOb3RFbmFibGVkYCAtIElmIHZvdGluZyBwb3dlciB0cmFja2luZyBpcyBub3QgZW5hYmxlZC58c3Vkb19zZXRfdm90aW5nX3Bvd2VyX2VtYV9hbHBoYQgBGG5ldHVpZKABGE5ldFVpZAABFGFscGhhGAEMdTY0AIM8CQFTZXRzIHRoZSBFTUEgYWxwaGEgdmFsdWUgZm9yIHZvdGluZyBwb3dlciBjYWxjdWxhdGlvbiBvbiBhIHN1Ym5ldC4AwFRoaXMgZnVuY3Rpb24gY2FuIG9ubHkgYmUgY2FsbGVkIGJ5IHJvb3QgKHN1ZG8pLsBIaWdoZXIgYWxwaGEgPSBmYXN0ZXIgcmVzcG9uc2UgdG8gc3Rha2UgY2hhbmdlcy78QWxwaGEgaXMgc3RvcmVkIGFzIHU2NCB3aXRoIDE4IGRlY2ltYWwgcHJlY2lzaW9uICgxLjAgPSAxMF4xOCkuADAjIEFyZ3VtZW50czrIKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIG11c3QgYmUgcm9vdC60KiBgbmV0dWlkYCAtIFRoZSBzdWJuZXQgdG8gc2V0IHRoZSBhbHBoYSBmb3IuAQEqIGBhbHBoYWAgLSBUaGUgbmV3IGFscGhhIHZhbHVlICh1NjQgd2l0aCAxOCBkZWNpbWFsIHByZWNpc2lvbikuACQjIEVycm9yczqoKiBgQmFkT3JpZ2luYCAtIElmIHRoZSBvcmlnaW4gaXMgbm90IHJvb3QuyCogYFN1Ym5ldE5vdEV4aXN0YCAtIElmIHRoZSBzdWJuZXQgZG9lcyBub3QgZXhpc3QuGQEqIGBJbnZhbGlkVm90aW5nUG93ZXJFbWFBbHBoYWAgLSBJZiBhbHBoYSBpcyBncmVhdGVyIHRoYW4gMTBeMTggKDEuMCkuOGFkZF9zdGFrZV9idXJuEAEYaG90a2V5AAEwVDo6QWNjb3VudElkAAEYbmV0dWlkoAEYTmV0VWlkAAEYYW1vdW50GAEoVGFvQmFsYW5jZQABFGxpbWl0fQIBSE9wdGlvbjxUYW9CYWxhbmNlPgCECF0BLS0tIFRoZSBleHRyaW5zaWMgaXMgYSBjb21iaW5hdGlvbiBvZiBhZGRfc3Rha2UoYWRkX3N0YWtlX2xpbWl0KSBhbmQgYnVybl9hbHBoYS4gV2UgYnV5ZQFhbHBoYSB0b2tlbiBmaXJzdCBhbmQgaW1tZWRpYXRlbHkgYnVybiB0aGUgYWNxdWlyZWQgYW1vdW50IG9mIGFscGhhIChha2EgU3VibmV0IGJ1eWJhY2spLgxhAURpc3BhdGNoYWJsZSBmdW5jdGlvbnMgYWxsb3cgdXNlcnMgdG8gaW50ZXJhY3Qgd2l0aCB0aGUgcGFsbGV0IGFuZCBpbnZva2Ugc3RhdGUgY2hhbmdlcy5ZAVRoZXNlIGZ1bmN0aW9ucyBtYXRlcmlhbGl6ZSBhcyAiZXh0cmluc2ljcyIsIHdoaWNoIGFyZSBvZnRlbiBjb21wYXJlZCB0byB0cmFuc2FjdGlvbnMuYQFEaXNwYXRjaGFibGUgZnVuY3Rpb25zIG11c3QgYmUgYW5ub3RhdGVkIHdpdGggYSB3ZWlnaHQgYW5kIG11c3QgcmV0dXJuIGEgRGlzcGF0Y2hSZXN1bHQuTQIAAAKgAFECAAACVQIAVQIAAAJZAgBZAgAABAhdAl0CAF0CAAAGoABhAgAAAjAAZQIMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAEIBFMAAAQAOAEYVmVjPFQ+AABpAgAAAk0CAG0CBBhPcHRpb24EBFQBoAEIEE5vbmUAAAAQU29tZQQAoAAAAQAAcQIEGE9wdGlvbgQEVAF1AgEIEE5vbmUAAAAQU29tZQQAdQIAAAEAAHUCDEBwYWxsZXRfc3VidGVuc29yGHBhbGxldEBTdWJuZXRJZGVudGl0eVYzAAAgASxzdWJuZXRfbmFtZTgBHFZlYzx1OD4AASxnaXRodWJfcmVwbzgBHFZlYzx1OD4AAThzdWJuZXRfY29udGFjdDgBHFZlYzx1OD4AAShzdWJuZXRfdXJsOAEcVmVjPHU4PgABHGRpc2NvcmQ4ARxWZWM8dTg+AAEsZGVzY3JpcHRpb244ARxWZWM8dTg+AAEgbG9nb191cmw4ARxWZWM8dTg+AAEoYWRkaXRpb25hbDgBHFZlYzx1OD4AAHkCAAADQQAAAAgAfQIEGE9wdGlvbgQEVAEYAQgQTm9uZQAAABBTb21lBAAYAAABAACBAgw0c3BfYXJpdGhtZXRpYyhwZXJfdGhpbmdzHFBlcmNlbnQAAAQACAEIdTgAAIUCDGBwYWxsZXRfc3VidGVuc29yX3V0aWxpdHkYcGFsbGV0EENhbGwEBFQAASAUYmF0Y2gEARRjYWxsc4kCAXxWZWM8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AABIfFNlbmQgYSBiYXRjaCBvZiBkaXNwYXRjaCBjYWxscy4AsE1heSBiZSBjYWxsZWQgZnJvbSBhbnkgb3JpZ2luIGV4Y2VwdCBgTm9uZWAuAF0BLSBgY2FsbHNgOiBUaGUgY2FsbHMgdG8gYmUgZGlzcGF0Y2hlZCBmcm9tIHRoZSBzYW1lIG9yaWdpbi4gVGhlIG51bWJlciBvZiBjYWxsIG11c3Qgbm90OQEgIGV4Y2VlZCB0aGUgY29uc3RhbnQ6IGBiYXRjaGVkX2NhbGxzX2xpbWl0YCAoYXZhaWxhYmxlIGluIGNvbnN0YW50IG1ldGFkYXRhKS4AVQFJZiBvcmlnaW4gaXMgcm9vdCB0aGVuIHRoZSBjYWxscyBhcmUgZGlzcGF0Y2hlZCB3aXRob3V0IGNoZWNraW5nIG9yaWdpbiBmaWx0ZXIuIChUaGlz7GluY2x1ZGVzIGJ5cGFzc2luZyBgZnJhbWVfc3lzdGVtOjpDb25maWc6OkJhc2VDYWxsRmlsdGVyYCkuADQjIyBDb21wbGV4aXR50C0gTyhDKSB3aGVyZSBDIGlzIHRoZSBudW1iZXIgb2YgY2FsbHMgdG8gYmUgYmF0Y2hlZC4AVQFUaGlzIHdpbGwgcmV0dXJuIGBPa2AgaW4gYWxsIGNpcmN1bXN0YW5jZXMuIFRvIGRldGVybWluZSB0aGUgc3VjY2VzcyBvZiB0aGUgYmF0Y2gsIGFuMQFldmVudCBpcyBkZXBvc2l0ZWQuIElmIGEgY2FsbCBmYWlsZWQgYW5kIHRoZSBiYXRjaCB3YXMgaW50ZXJydXB0ZWQsIHRoZW4gdGhlVQFgQmF0Y2hJbnRlcnJ1cHRlZGAgZXZlbnQgaXMgZGVwb3NpdGVkLCBhbG9uZyB3aXRoIHRoZSBudW1iZXIgb2Ygc3VjY2Vzc2Z1bCBjYWxscyBtYWRlTQFhbmQgdGhlIGVycm9yIG9mIHRoZSBmYWlsZWQgY2FsbC4gSWYgYWxsIHdlcmUgc3VjY2Vzc2Z1bCwgdGhlbiB0aGUgYEJhdGNoQ29tcGxldGVkYExldmVudCBpcyBkZXBvc2l0ZWQuNGFzX2Rlcml2YXRpdmUIARRpbmRleKABDHUxNgABEGNhbGz5AQF8Qm94PDxUIGFzIENvbmZpZz46OlJ1bnRpbWVDYWxsPgABNNxTZW5kIGEgY2FsbCB0aHJvdWdoIGFuIGluZGV4ZWQgcHNldWRvbnltIG9mIHRoZSBzZW5kZXIuAFUBRmlsdGVyIGZyb20gb3JpZ2luIGFyZSBwYXNzZWQgYWxvbmcuIFRoZSBjYWxsIHdpbGwgYmUgZGlzcGF0Y2hlZCB3aXRoIGFuIG9yaWdpbiB3aGljaLx1c2UgdGhlIHNhbWUgZmlsdGVyIGFzIHRoZSBvcmlnaW4gb2YgdGhpcyBjYWxsLgBFAU5PVEU6IElmIHlvdSBuZWVkIHRvIGVuc3VyZSB0aGF0IGFueSBhY2NvdW50LWJhc2VkIGZpbHRlcmluZyBpcyBub3QgaG9ub3JlZCAoaS5lLmEBYmVjYXVzZSB5b3UgZXhwZWN0IGBwcm94eWAgdG8gaGF2ZSBiZWVuIHVzZWQgcHJpb3IgaW4gdGhlIGNhbGwgc3RhY2sgYW5kIHlvdSBkbyBub3Qgd2FudFEBdGhlIGNhbGwgcmVzdHJpY3Rpb25zIHRvIGFwcGx5IHRvIGFueSBzdWItYWNjb3VudHMpLCB0aGVuIHVzZSBgYXNfbXVsdGlfdGhyZXNob2xkXzFgfGluIHRoZSBNdWx0aXNpZyBwYWxsZXQgaW5zdGVhZC4A9E5PVEU6IFByaW9yIHRvIHZlcnNpb24gKjEyLCB0aGlzIHdhcyBjYWxsZWQgYGFzX2xpbWl0ZWRfc3ViYC4AzFRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfLiRiYXRjaF9hbGwEARRjYWxsc4kCAXxWZWM8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAI07FNlbmQgYSBiYXRjaCBvZiBkaXNwYXRjaCBjYWxscyBhbmQgYXRvbWljYWxseSBleGVjdXRlIHRoZW0uIQFUaGUgd2hvbGUgdHJhbnNhY3Rpb24gd2lsbCByb2xsYmFjayBhbmQgZmFpbCBpZiBhbnkgb2YgdGhlIGNhbGxzIGZhaWxlZC4AsE1heSBiZSBjYWxsZWQgZnJvbSBhbnkgb3JpZ2luIGV4Y2VwdCBgTm9uZWAuAF0BLSBgY2FsbHNgOiBUaGUgY2FsbHMgdG8gYmUgZGlzcGF0Y2hlZCBmcm9tIHRoZSBzYW1lIG9yaWdpbi4gVGhlIG51bWJlciBvZiBjYWxsIG11c3Qgbm90OQEgIGV4Y2VlZCB0aGUgY29uc3RhbnQ6IGBiYXRjaGVkX2NhbGxzX2xpbWl0YCAoYXZhaWxhYmxlIGluIGNvbnN0YW50IG1ldGFkYXRhKS4AVQFJZiBvcmlnaW4gaXMgcm9vdCB0aGVuIHRoZSBjYWxscyBhcmUgZGlzcGF0Y2hlZCB3aXRob3V0IGNoZWNraW5nIG9yaWdpbiBmaWx0ZXIuIChUaGlz7GluY2x1ZGVzIGJ5cGFzc2luZyBgZnJhbWVfc3lzdGVtOjpDb25maWc6OkJhc2VDYWxsRmlsdGVyYCkuADQjIyBDb21wbGV4aXR50C0gTyhDKSB3aGVyZSBDIGlzIHRoZSBudW1iZXIgb2YgY2FsbHMgdG8gYmUgYmF0Y2hlZC4sZGlzcGF0Y2hfYXMIASRhc19vcmlnaW6NAgFUQm94PFQ6OlBhbGxldHNPcmlnaW4+AAEQY2FsbPkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAMYyERpc3BhdGNoZXMgYSBmdW5jdGlvbiBjYWxsIHdpdGggYSBwcm92aWRlZCBvcmlnaW4uAMRUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfUm9vdF8uADQjIyBDb21wbGV4aXR5HC0gTygxKS4sZm9yY2VfYmF0Y2gEARRjYWxsc4kCAXxWZWM8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAQ0fFNlbmQgYSBiYXRjaCBvZiBkaXNwYXRjaCBjYWxscy7UVW5saWtlIGBiYXRjaGAsIGl0IGFsbG93cyBlcnJvcnMgYW5kIHdvbid0IGludGVycnVwdC4AsE1heSBiZSBjYWxsZWQgZnJvbSBhbnkgb3JpZ2luIGV4Y2VwdCBgTm9uZWAuAF0BLSBgY2FsbHNgOiBUaGUgY2FsbHMgdG8gYmUgZGlzcGF0Y2hlZCBmcm9tIHRoZSBzYW1lIG9yaWdpbi4gVGhlIG51bWJlciBvZiBjYWxsIG11c3Qgbm90OQEgIGV4Y2VlZCB0aGUgY29uc3RhbnQ6IGBiYXRjaGVkX2NhbGxzX2xpbWl0YCAoYXZhaWxhYmxlIGluIGNvbnN0YW50IG1ldGFkYXRhKS4ATQFJZiBvcmlnaW4gaXMgcm9vdCB0aGVuIHRoZSBjYWxscyBhcmUgZGlzcGF0Y2ggd2l0aG91dCBjaGVja2luZyBvcmlnaW4gZmlsdGVyLiAoVGhpc+xpbmNsdWRlcyBieXBhc3NpbmcgYGZyYW1lX3N5c3RlbTo6Q29uZmlnOjpCYXNlQ2FsbEZpbHRlcmApLgA0IyMgQ29tcGxleGl0edAtIE8oQykgd2hlcmUgQyBpcyB0aGUgbnVtYmVyIG9mIGNhbGxzIHRvIGJlIGJhdGNoZWQuLHdpdGhfd2VpZ2h0CAEQY2FsbPkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAEYd2VpZ2h0LAEYV2VpZ2h0AAUYxERpc3BhdGNoIGEgZnVuY3Rpb24gY2FsbCB3aXRoIGEgc3BlY2lmaWVkIHdlaWdodC4ALQFUaGlzIGZ1bmN0aW9uIGRvZXMgbm90IGNoZWNrIHRoZSB3ZWlnaHQgb2YgdGhlIGNhbGwsIGFuZCBpbnN0ZWFkIGFsbG93cyB0aGW4Um9vdCBvcmlnaW4gdG8gc3BlY2lmeSB0aGUgd2VpZ2h0IG9mIHRoZSBjYWxsLgDEVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1Jvb3RfLhxpZl9lbHNlCAEQbWFpbvkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAEgZmFsbGJhY2v5AQF8Qm94PDxUIGFzIENvbmZpZz46OlJ1bnRpbWVDYWxsPgAGXBUBRGlzcGF0Y2ggYSBmYWxsYmFjayBjYWxsIGluIHRoZSBldmVudCB0aGUgbWFpbiBjYWxsIGZhaWxzIHRvIGV4ZWN1dGUusE1heSBiZSBjYWxsZWQgZnJvbSBhbnkgb3JpZ2luIGV4Y2VwdCBgTm9uZWAuAORUaGlzIGZ1bmN0aW9uIGZpcnN0IGF0dGVtcHRzIHRvIGRpc3BhdGNoIHRoZSBgbWFpbmAgY2FsbC7USWYgdGhlIGBtYWluYCBjYWxsIGZhaWxzLCB0aGUgYGZhbGxiYWNrYCBpcyBhdHRlbXRlZC4VAWlmIHRoZSBmYWxsYmFjayBpcyBzdWNjZXNzZnVsbHkgZGlzcGF0Y2hlZCwgdGhlIHdlaWdodHMgb2YgYm90aCBjYWxscyUBYXJlIGFjY3VtdWxhdGVkIGFuZCBhbiBldmVudCBjb250YWluaW5nIHRoZSBtYWluIGNhbGwgZXJyb3IgaXMgZGVwb3NpdGVkLgDcSW4gdGhlIGV2ZW50IG9mIGEgZmFsbGJhY2sgZmFpbHVyZSB0aGUgd2hvbGUgY2FsbCBmYWlsc2h3aXRoIHRoZSB3ZWlnaHRzIHJldHVybmVkLgBBAS0gYG1haW5gOiBUaGUgbWFpbiBjYWxsIHRvIGJlIGRpc3BhdGNoZWQuIFRoaXMgaXMgdGhlIHByaW1hcnkgYWN0aW9uIHRvIGV4ZWN1dGUuPQEtIGBmYWxsYmFja2A6IFRoZSBmYWxsYmFjayBjYWxsIHRvIGJlIGRpc3BhdGNoZWQgaW4gY2FzZSB0aGUgYG1haW5gIGNhbGwgZmFpbHMuAEQjIyBEaXNwYXRjaCBMb2dpY0EBLSBJZiB0aGUgb3JpZ2luIGlzIGByb290YCwgYm90aCB0aGUgbWFpbiBhbmQgZmFsbGJhY2sgY2FsbHMgYXJlIGV4ZWN1dGVkIHdpdGhvdXR4ICBhcHBseWluZyBhbnkgb3JpZ2luIGZpbHRlcnMuSQEtIElmIHRoZSBvcmlnaW4gaXMgbm90IGByb290YCwgdGhlIG9yaWdpbiBmaWx0ZXIgaXMgYXBwbGllZCB0byBib3RoIHRoZSBgbWFpbmAgYW5kTCAgYGZhbGxiYWNrYCBjYWxscy4ALCMjIFVzZSBDYXNlWQEtIFNvbWUgdXNlIGNhc2VzIG1pZ2h0IGludm9sdmUgc3VibWl0dGluZyBhIGBiYXRjaGAgdHlwZSBjYWxsIGluIGVpdGhlciBtYWluLCBmYWxsYmFjayggIG9yIGJvdGguUGRpc3BhdGNoX2FzX2ZhbGxpYmxlCAEkYXNfb3JpZ2lujQIBVEJveDxUOjpQYWxsZXRzT3JpZ2luPgABEGNhbGz5AQF8Qm94PDxUIGFzIENvbmZpZz46OlJ1bnRpbWVDYWxsPgAHFMhEaXNwYXRjaGVzIGEgZnVuY3Rpb24gY2FsbCB3aXRoIGEgcHJvdmlkZWQgb3JpZ2luLgBRAUFsbW9zdCB0aGUgc2FtZSBhcyBbYFBhbGxldDo6ZGlzcGF0Y2hfYXNgXSBidXQgZm9yd2FyZHMgYW55IGVycm9yIG9mIHRoZSBpbm5lciBjYWxsLgDEVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1Jvb3RfLgQNAUNvbnRhaW5zIGEgdmFyaWFudCBwZXIgZGlzcGF0Y2hhYmxlIGV4dHJpbnNpYyB0aGF0IHRoaXMgcGFsbGV0IGhhcy6JAgAAAvkBAI0CCFhub2RlX3N1YnRlbnNvcl9ydW50aW1lME9yaWdpbkNhbGxlcgABCBhzeXN0ZW0EAJECAXRmcmFtZV9zeXN0ZW06Ok9yaWdpbjxSdW50aW1lPgAAACBFdGhlcmV1bQQAlQIBXHBhbGxldF9ldGhlcmV1bTo6T3JpZ2luABUAAJECDDRmcmFtZV9zdXBwb3J0IGRpc3BhdGNoJFJhd09yaWdpbgQkQWNjb3VudElkAQABEBBSb290AAAAGFNpZ25lZAQAAAEkQWNjb3VudElkAAEAEE5vbmUAAgAoQXV0aG9yaXplZAADAACVAgg8cGFsbGV0X2V0aGVyZXVtJFJhd09yaWdpbgABBExFdGhlcmV1bVRyYW5zYWN0aW9uBADEARBIMTYwAAAAAJkCDCxwYWxsZXRfc3VkbxhwYWxsZXQQQ2FsbAQEVAABFBBzdWRvBAEQY2FsbPkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAAENQFBdXRoZW50aWNhdGVzIHRoZSBzdWRvIGtleSBhbmQgZGlzcGF0Y2hlcyBhIGZ1bmN0aW9uIGNhbGwgd2l0aCBgUm9vdGAgb3JpZ2luLlRzdWRvX3VuY2hlY2tlZF93ZWlnaHQIARBjYWxs+QEBfEJveDw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4AARh3ZWlnaHQsARhXZWlnaHQAARQ1AUF1dGhlbnRpY2F0ZXMgdGhlIHN1ZG8ga2V5IGFuZCBkaXNwYXRjaGVzIGEgZnVuY3Rpb24gY2FsbCB3aXRoIGBSb290YCBvcmlnaW4uLQFUaGlzIGZ1bmN0aW9uIGRvZXMgbm90IGNoZWNrIHRoZSB3ZWlnaHQgb2YgdGhlIGNhbGwsIGFuZCBpbnN0ZWFkIGFsbG93cyB0aGWwU3VkbyB1c2VyIHRvIHNwZWNpZnkgdGhlIHdlaWdodCBvZiB0aGUgY2FsbC4AzFRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfLhxzZXRfa2V5BAEMbmV3NQIBUEFjY291bnRJZExvb2t1cE9mPFQ+AAIIXQFBdXRoZW50aWNhdGVzIHRoZSBjdXJyZW50IHN1ZG8ga2V5IGFuZCBzZXRzIHRoZSBnaXZlbiBBY2NvdW50SWQgKGBuZXdgKSBhcyB0aGUgbmV3IHN1ZG8Qa2V5LhxzdWRvX2FzCAEMd2hvNQIBUEFjY291bnRJZExvb2t1cE9mPFQ+AAEQY2FsbPkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAMQTQFBdXRoZW50aWNhdGVzIHRoZSBzdWRvIGtleSBhbmQgZGlzcGF0Y2hlcyBhIGZ1bmN0aW9uIGNhbGwgd2l0aCBgU2lnbmVkYCBvcmlnaW4gZnJvbUBhIGdpdmVuIGFjY291bnQuAMxUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfU2lnbmVkXy4ocmVtb3ZlX2tleQAEDIRQZXJtYW5lbnRseSByZW1vdmVzIHRoZSBzdWRvIGtleS4AbCoqVGhpcyBjYW5ub3QgYmUgdW4tZG9uZS4qKgQNAUNvbnRhaW5zIGEgdmFyaWFudCBwZXIgZGlzcGF0Y2hhYmxlIGV4dHJpbnNpYyB0aGF0IHRoaXMgcGFsbGV0IGhhcy6dAgw8cGFsbGV0X211bHRpc2lnGHBhbGxldBBDYWxsBARUAAEUUGFzX211bHRpX3RocmVzaG9sZF8xCAFEb3RoZXJfc2lnbmF0b3JpZXNBAgFEVmVjPFQ6OkFjY291bnRJZD4AARBjYWxs+QEBfEJveDw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4AADBRAUltbWVkaWF0ZWx5IGRpc3BhdGNoIGEgbXVsdGktc2lnbmF0dXJlIGNhbGwgdXNpbmcgYSBzaW5nbGUgYXBwcm92YWwgZnJvbSB0aGUgY2FsbGVyLgDMVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8uAD0BLSBgb3RoZXJfc2lnbmF0b3JpZXNgOiBUaGUgYWNjb3VudHMgKG90aGVyIHRoYW4gdGhlIHNlbmRlcikgd2hvIGFyZSBwYXJ0IG9mIHRoZQEBbXVsdGktc2lnbmF0dXJlLCBidXQgZG8gbm90IHBhcnRpY2lwYXRlIGluIHRoZSBhcHByb3ZhbCBwcm9jZXNzLogtIGBjYWxsYDogVGhlIGNhbGwgdG8gYmUgZXhlY3V0ZWQuALhSZXN1bHQgaXMgZXF1aXZhbGVudCB0byB0aGUgZGlzcGF0Y2hlZCByZXN1bHQuADQjIyBDb21wbGV4aXR5GQFPKFogKyBDKSB3aGVyZSBaIGlzIHRoZSBsZW5ndGggb2YgdGhlIGNhbGwgYW5kIEMgaXRzIGV4ZWN1dGlvbiB3ZWlnaHQuIGFzX211bHRpFAEkdGhyZXNob2xkoAEMdTE2AAFEb3RoZXJfc2lnbmF0b3JpZXNBAgFEVmVjPFQ6OkFjY291bnRJZD4AATxtYXliZV90aW1lcG9pbnShAgGQT3B0aW9uPFRpbWVwb2ludDxCbG9ja051bWJlckZvcjxUPj4+AAEQY2FsbPkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAEobWF4X3dlaWdodCwBGFdlaWdodAABnFUBUmVnaXN0ZXIgYXBwcm92YWwgZm9yIGEgZGlzcGF0Y2ggdG8gYmUgbWFkZSBmcm9tIGEgZGV0ZXJtaW5pc3RpYyBjb21wb3NpdGUgYWNjb3VudCBpZvhhcHByb3ZlZCBieSBhIHRvdGFsIG9mIGB0aHJlc2hvbGQgLSAxYCBvZiBgb3RoZXJfc2lnbmF0b3JpZXNgLgCwSWYgdGhlcmUgYXJlIGVub3VnaCwgdGhlbiBkaXNwYXRjaCB0aGUgY2FsbC4ALQFQYXltZW50OiBgRGVwb3NpdEJhc2VgIHdpbGwgYmUgcmVzZXJ2ZWQgaWYgdGhpcyBpcyB0aGUgZmlyc3QgYXBwcm92YWwsIHBsdXM9AWB0aHJlc2hvbGRgIHRpbWVzIGBEZXBvc2l0RmFjdG9yYC4gSXQgaXMgcmV0dXJuZWQgb25jZSB0aGlzIGRpc3BhdGNoIGhhcHBlbnMgb3I0aXMgY2FuY2VsbGVkLgDMVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8uAFUBLSBgdGhyZXNob2xkYDogVGhlIHRvdGFsIG51bWJlciBvZiBhcHByb3ZhbHMgZm9yIHRoaXMgZGlzcGF0Y2ggYmVmb3JlIGl0IGlzIGV4ZWN1dGVkLkEBLSBgb3RoZXJfc2lnbmF0b3JpZXNgOiBUaGUgYWNjb3VudHMgKG90aGVyIHRoYW4gdGhlIHNlbmRlcikgd2hvIGNhbiBhcHByb3ZlIHRoaXNsZGlzcGF0Y2guIE1heSBub3QgYmUgZW1wdHkuWQEtIGBtYXliZV90aW1lcG9pbnRgOiBJZiB0aGlzIGlzIHRoZSBmaXJzdCBhcHByb3ZhbCwgdGhlbiB0aGlzIG11c3QgYmUgYE5vbmVgLiBJZiBpdCBpc1EBbm90IHRoZSBmaXJzdCBhcHByb3ZhbCwgdGhlbiBpdCBtdXN0IGJlIGBTb21lYCwgd2l0aCB0aGUgdGltZXBvaW50IChibG9jayBudW1iZXIgYW5k1HRyYW5zYWN0aW9uIGluZGV4KSBvZiB0aGUgZmlyc3QgYXBwcm92YWwgdHJhbnNhY3Rpb24uiC0gYGNhbGxgOiBUaGUgY2FsbCB0byBiZSBleGVjdXRlZC4AHQFOT1RFOiBVbmxlc3MgdGhpcyBpcyB0aGUgZmluYWwgYXBwcm92YWwsIHlvdSB3aWxsIGdlbmVyYWxseSB3YW50IHRvIHVzZRkBYGFwcHJvdmVfYXNfbXVsdGlgIGluc3RlYWQsIHNpbmNlIGl0IG9ubHkgcmVxdWlyZXMgYSBoYXNoIG9mIHRoZSBjYWxsLgBZAVJlc3VsdCBpcyBlcXVpdmFsZW50IHRvIHRoZSBkaXNwYXRjaGVkIHJlc3VsdCBpZiBgdGhyZXNob2xkYCBpcyBleGFjdGx5IGAxYC4gT3RoZXJ3aXNlVQFvbiBzdWNjZXNzLCByZXN1bHQgaXMgYE9rYCBhbmQgdGhlIHJlc3VsdCBmcm9tIHRoZSBpbnRlcmlvciBjYWxsLCBpZiBpdCB3YXMgZXhlY3V0ZWQs3G1heSBiZSBmb3VuZCBpbiB0aGUgZGVwb3NpdGVkIGBNdWx0aXNpZ0V4ZWN1dGVkYCBldmVudC4ANCMjIENvbXBsZXhpdHlQLSBgTyhTICsgWiArIENhbGwpYC7MLSBVcCB0byBvbmUgYmFsYW5jZS1yZXNlcnZlIG9yIHVucmVzZXJ2ZSBvcGVyYXRpb24uPQEtIE9uZSBwYXNzdGhyb3VnaCBvcGVyYXRpb24sIG9uZSBpbnNlcnQsIGJvdGggYE8oUylgIHdoZXJlIGBTYCBpcyB0aGUgbnVtYmVyIG9mRQEgIHNpZ25hdG9yaWVzLiBgU2AgaXMgY2FwcGVkIGJ5IGBNYXhTaWduYXRvcmllc2AsIHdpdGggd2VpZ2h0IGJlaW5nIHByb3BvcnRpb25hbC4hAS0gT25lIGNhbGwgZW5jb2RlICYgaGFzaCwgYm90aCBvZiBjb21wbGV4aXR5IGBPKFopYCB3aGVyZSBgWmAgaXMgdHgtbGVuLrwtIE9uZSBlbmNvZGUgJiBoYXNoLCBib3RoIG9mIGNvbXBsZXhpdHkgYE8oUylgLtQtIFVwIHRvIG9uZSBiaW5hcnkgc2VhcmNoIGFuZCBpbnNlcnQgKGBPKGxvZ1MgKyBTKWApLvgtIEkvTzogMSByZWFkIGBPKFMpYCwgdXAgdG8gMSBtdXRhdGUgYE8oUylgLiBVcCB0byBvbmUgcmVtb3ZlLjAtIE9uZSBldmVudC5sLSBUaGUgd2VpZ2h0IG9mIHRoZSBgY2FsbGAuTQEtIFN0b3JhZ2U6IGluc2VydHMgb25lIGl0ZW0sIHZhbHVlIHNpemUgYm91bmRlZCBieSBgTWF4U2lnbmF0b3JpZXNgLCB3aXRoIGEgZGVwb3NpdBkBICB0YWtlbiBmb3IgaXRzIGxpZmV0aW1lIG9mIGBEZXBvc2l0QmFzZSArIHRocmVzaG9sZCAqIERlcG9zaXRGYWN0b3JgLkBhcHByb3ZlX2FzX211bHRpFAEkdGhyZXNob2xkoAEMdTE2AAFEb3RoZXJfc2lnbmF0b3JpZXNBAgFEVmVjPFQ6OkFjY291bnRJZD4AATxtYXliZV90aW1lcG9pbnShAgGQT3B0aW9uPFRpbWVwb2ludDxCbG9ja051bWJlckZvcjxUPj4+AAEkY2FsbF9oYXNoBAEgW3U4OyAzMl0AAShtYXhfd2VpZ2h0LAEYV2VpZ2h0AAJ4VQFSZWdpc3RlciBhcHByb3ZhbCBmb3IgYSBkaXNwYXRjaCB0byBiZSBtYWRlIGZyb20gYSBkZXRlcm1pbmlzdGljIGNvbXBvc2l0ZSBhY2NvdW50IGlm+GFwcHJvdmVkIGJ5IGEgdG90YWwgb2YgYHRocmVzaG9sZCAtIDFgIG9mIGBvdGhlcl9zaWduYXRvcmllc2AuAC0BUGF5bWVudDogYERlcG9zaXRCYXNlYCB3aWxsIGJlIHJlc2VydmVkIGlmIHRoaXMgaXMgdGhlIGZpcnN0IGFwcHJvdmFsLCBwbHVzPQFgdGhyZXNob2xkYCB0aW1lcyBgRGVwb3NpdEZhY3RvcmAuIEl0IGlzIHJldHVybmVkIG9uY2UgdGhpcyBkaXNwYXRjaCBoYXBwZW5zIG9yNGlzIGNhbmNlbGxlZC4AzFRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfLgBVAS0gYHRocmVzaG9sZGA6IFRoZSB0b3RhbCBudW1iZXIgb2YgYXBwcm92YWxzIGZvciB0aGlzIGRpc3BhdGNoIGJlZm9yZSBpdCBpcyBleGVjdXRlZC5BAS0gYG90aGVyX3NpZ25hdG9yaWVzYDogVGhlIGFjY291bnRzIChvdGhlciB0aGFuIHRoZSBzZW5kZXIpIHdobyBjYW4gYXBwcm92ZSB0aGlzbGRpc3BhdGNoLiBNYXkgbm90IGJlIGVtcHR5LlkBLSBgbWF5YmVfdGltZXBvaW50YDogSWYgdGhpcyBpcyB0aGUgZmlyc3QgYXBwcm92YWwsIHRoZW4gdGhpcyBtdXN0IGJlIGBOb25lYC4gSWYgaXQgaXNRAW5vdCB0aGUgZmlyc3QgYXBwcm92YWwsIHRoZW4gaXQgbXVzdCBiZSBgU29tZWAsIHdpdGggdGhlIHRpbWVwb2ludCAoYmxvY2sgbnVtYmVyIGFuZNR0cmFuc2FjdGlvbiBpbmRleCkgb2YgdGhlIGZpcnN0IGFwcHJvdmFsIHRyYW5zYWN0aW9uLswtIGBjYWxsX2hhc2hgOiBUaGUgaGFzaCBvZiB0aGUgY2FsbCB0byBiZSBleGVjdXRlZC4ANQFOT1RFOiBJZiB0aGlzIGlzIHRoZSBmaW5hbCBhcHByb3ZhbCwgeW91IHdpbGwgd2FudCB0byB1c2UgYGFzX211bHRpYCBpbnN0ZWFkLgA0IyMgQ29tcGxleGl0eSQtIGBPKFMpYC7MLSBVcCB0byBvbmUgYmFsYW5jZS1yZXNlcnZlIG9yIHVucmVzZXJ2ZSBvcGVyYXRpb24uPQEtIE9uZSBwYXNzdGhyb3VnaCBvcGVyYXRpb24sIG9uZSBpbnNlcnQsIGJvdGggYE8oUylgIHdoZXJlIGBTYCBpcyB0aGUgbnVtYmVyIG9mRQEgIHNpZ25hdG9yaWVzLiBgU2AgaXMgY2FwcGVkIGJ5IGBNYXhTaWduYXRvcmllc2AsIHdpdGggd2VpZ2h0IGJlaW5nIHByb3BvcnRpb25hbC68LSBPbmUgZW5jb2RlICYgaGFzaCwgYm90aCBvZiBjb21wbGV4aXR5IGBPKFMpYC7ULSBVcCB0byBvbmUgYmluYXJ5IHNlYXJjaCBhbmQgaW5zZXJ0IChgTyhsb2dTICsgUylgKS74LSBJL086IDEgcmVhZCBgTyhTKWAsIHVwIHRvIDEgbXV0YXRlIGBPKFMpYC4gVXAgdG8gb25lIHJlbW92ZS4wLSBPbmUgZXZlbnQuTQEtIFN0b3JhZ2U6IGluc2VydHMgb25lIGl0ZW0sIHZhbHVlIHNpemUgYm91bmRlZCBieSBgTWF4U2lnbmF0b3JpZXNgLCB3aXRoIGEgZGVwb3NpdBkBICB0YWtlbiBmb3IgaXRzIGxpZmV0aW1lIG9mIGBEZXBvc2l0QmFzZSArIHRocmVzaG9sZCAqIERlcG9zaXRGYWN0b3JgLjxjYW5jZWxfYXNfbXVsdGkQASR0aHJlc2hvbGSgAQx1MTYAAURvdGhlcl9zaWduYXRvcmllc0ECAURWZWM8VDo6QWNjb3VudElkPgABJHRpbWVwb2ludPABcFRpbWVwb2ludDxCbG9ja051bWJlckZvcjxUPj4AASRjYWxsX2hhc2gEASBbdTg7IDMyXQADVFUBQ2FuY2VsIGEgcHJlLWV4aXN0aW5nLCBvbi1nb2luZyBtdWx0aXNpZyB0cmFuc2FjdGlvbi4gQW55IGRlcG9zaXQgcmVzZXJ2ZWQgcHJldmlvdXNsecRmb3IgdGhpcyBvcGVyYXRpb24gd2lsbCBiZSB1bnJlc2VydmVkIG9uIHN1Y2Nlc3MuAMxUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfU2lnbmVkXy4AVQEtIGB0aHJlc2hvbGRgOiBUaGUgdG90YWwgbnVtYmVyIG9mIGFwcHJvdmFscyBmb3IgdGhpcyBkaXNwYXRjaCBiZWZvcmUgaXQgaXMgZXhlY3V0ZWQuQQEtIGBvdGhlcl9zaWduYXRvcmllc2A6IFRoZSBhY2NvdW50cyAob3RoZXIgdGhhbiB0aGUgc2VuZGVyKSB3aG8gY2FuIGFwcHJvdmUgdGhpc2xkaXNwYXRjaC4gTWF5IG5vdCBiZSBlbXB0eS5dAS0gYHRpbWVwb2ludGA6IFRoZSB0aW1lcG9pbnQgKGJsb2NrIG51bWJlciBhbmQgdHJhbnNhY3Rpb24gaW5kZXgpIG9mIHRoZSBmaXJzdCBhcHByb3ZhbHh0cmFuc2FjdGlvbiBmb3IgdGhpcyBkaXNwYXRjaC7MLSBgY2FsbF9oYXNoYDogVGhlIGhhc2ggb2YgdGhlIGNhbGwgdG8gYmUgZXhlY3V0ZWQuADQjIyBDb21wbGV4aXR5JC0gYE8oUylgLswtIFVwIHRvIG9uZSBiYWxhbmNlLXJlc2VydmUgb3IgdW5yZXNlcnZlIG9wZXJhdGlvbi49AS0gT25lIHBhc3N0aHJvdWdoIG9wZXJhdGlvbiwgb25lIGluc2VydCwgYm90aCBgTyhTKWAgd2hlcmUgYFNgIGlzIHRoZSBudW1iZXIgb2ZFASAgc2lnbmF0b3JpZXMuIGBTYCBpcyBjYXBwZWQgYnkgYE1heFNpZ25hdG9yaWVzYCwgd2l0aCB3ZWlnaHQgYmVpbmcgcHJvcG9ydGlvbmFsLrwtIE9uZSBlbmNvZGUgJiBoYXNoLCBib3RoIG9mIGNvbXBsZXhpdHkgYE8oUylgLjAtIE9uZSBldmVudC6ELSBJL086IDEgcmVhZCBgTyhTKWAsIG9uZSByZW1vdmUucC0gU3RvcmFnZTogcmVtb3ZlcyBvbmUgaXRlbS4wcG9rZV9kZXBvc2l0DAEkdGhyZXNob2xkoAEMdTE2AAFEb3RoZXJfc2lnbmF0b3JpZXNBAgFEVmVjPFQ6OkFjY291bnRJZD4AASRjYWxsX2hhc2gEASBbdTg7IDMyXQAENPRQb2tlIHRoZSBkZXBvc2l0IHJlc2VydmVkIGZvciBhbiBleGlzdGluZyBtdWx0aXNpZyBvcGVyYXRpb24uAGEBVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8gYW5kIG11c3QgYmUgdGhlIG9yaWdpbmFsIGRlcG9zaXRvciBvZlx0aGUgbXVsdGlzaWcgb3BlcmF0aW9uLgABAVRoZSB0cmFuc2FjdGlvbiBmZWUgaXMgd2FpdmVkIGlmIHRoZSBkZXBvc2l0IGFtb3VudCBoYXMgY2hhbmdlZC4AGQEtIGB0aHJlc2hvbGRgOiBUaGUgdG90YWwgbnVtYmVyIG9mIGFwcHJvdmFscyBuZWVkZWQgZm9yIHRoaXMgbXVsdGlzaWcuPQEtIGBvdGhlcl9zaWduYXRvcmllc2A6IFRoZSBhY2NvdW50cyAob3RoZXIgdGhhbiB0aGUgc2VuZGVyKSB3aG8gYXJlIHBhcnQgb2YgdGhlLCAgbXVsdGlzaWcuBQEtIGBjYWxsX2hhc2hgOiBUaGUgaGFzaCBvZiB0aGUgY2FsbCB0aGlzIGRlcG9zaXQgaXMgcmVzZXJ2ZWQgZm9yLgCMRW1pdHMgYERlcG9zaXRQb2tlZGAgaWYgc3VjY2Vzc2Z1bC4EDQFDb250YWlucyBhIHZhcmlhbnQgcGVyIGRpc3BhdGNoYWJsZSBleHRyaW5zaWMgdGhhdCB0aGlzIHBhbGxldCBoYXMuoQIEGE9wdGlvbgQEVAHwAQgQTm9uZQAAABBTb21lBADwAAABAAClAgw8cGFsbGV0X3ByZWltYWdlGHBhbGxldBBDYWxsBARUAAEUNG5vdGVfcHJlaW1hZ2UEARRieXRlczgBHFZlYzx1OD4AABB0UmVnaXN0ZXIgYSBwcmVpbWFnZSBvbi1jaGFpbi4AVQFJZiB0aGUgcHJlaW1hZ2Ugd2FzIHByZXZpb3VzbHkgcmVxdWVzdGVkLCBubyBmZWVzIG9yIGRlcG9zaXRzIGFyZSB0YWtlbiBmb3IgcHJvdmlkaW5nVQF0aGUgcHJlaW1hZ2UuIE90aGVyd2lzZSwgYSBkZXBvc2l0IGlzIHRha2VuIHByb3BvcnRpb25hbCB0byB0aGUgc2l6ZSBvZiB0aGUgcHJlaW1hZ2UuPHVubm90ZV9wcmVpbWFnZQQBEGhhc2g0ARxUOjpIYXNoAAEY3ENsZWFyIGFuIHVucmVxdWVzdGVkIHByZWltYWdlIGZyb20gdGhlIHJ1bnRpbWUgc3RvcmFnZS4A/ElmIGBsZW5gIGlzIHByb3ZpZGVkLCB0aGVuIGl0IHdpbGwgYmUgYSBtdWNoIGNoZWFwZXIgb3BlcmF0aW9uLgABAS0gYGhhc2hgOiBUaGUgaGFzaCBvZiB0aGUgcHJlaW1hZ2UgdG8gYmUgcmVtb3ZlZCBmcm9tIHRoZSBzdG9yZS64LSBgbGVuYDogVGhlIGxlbmd0aCBvZiB0aGUgcHJlaW1hZ2Ugb2YgYGhhc2hgLkByZXF1ZXN0X3ByZWltYWdlBAEQaGFzaDQBHFQ6Okhhc2gAAhBBAVJlcXVlc3QgYSBwcmVpbWFnZSBiZSB1cGxvYWRlZCB0byB0aGUgY2hhaW4gd2l0aG91dCBwYXlpbmcgYW55IGZlZXMgb3IgZGVwb3NpdHMuAFUBSWYgdGhlIHByZWltYWdlIHJlcXVlc3RzIGhhcyBhbHJlYWR5IGJlZW4gcHJvdmlkZWQgb24tY2hhaW4sIHdlIHVucmVzZXJ2ZSBhbnkgZGVwb3NpdDkBYSB1c2VyIG1heSBoYXZlIHBhaWQsIGFuZCB0YWtlIHRoZSBjb250cm9sIG9mIHRoZSBwcmVpbWFnZSBvdXQgb2YgdGhlaXIgaGFuZHMuSHVucmVxdWVzdF9wcmVpbWFnZQQBEGhhc2g0ARxUOjpIYXNoAAMMvENsZWFyIGEgcHJldmlvdXNseSBtYWRlIHJlcXVlc3QgZm9yIGEgcHJlaW1hZ2UuAC0BTk9URTogVEhJUyBNVVNUIE5PVCBCRSBDQUxMRUQgT04gYGhhc2hgIE1PUkUgVElNRVMgVEhBTiBgcmVxdWVzdF9wcmVpbWFnZWAuOGVuc3VyZV91cGRhdGVkBAEYaGFzaGVzuAEwVmVjPFQ6Okhhc2g+AAQMvEVuc3VyZSB0aGF0IHRoZSBidWxrIG9mIHByZS1pbWFnZXMgaXMgdXBncmFkZWQuAD0BVGhlIGNhbGxlciBwYXlzIG5vIGZlZSBpZiBhdCBsZWFzdCA5MCUgb2YgcHJlLWltYWdlcyB3ZXJlIHN1Y2Nlc3NmdWxseSB1cGRhdGVkLgQNAUNvbnRhaW5zIGEgdmFyaWFudCBwZXIgZGlzcGF0Y2hhYmxlIGV4dHJpbnNpYyB0aGF0IHRoaXMgcGFsbGV0IGhhcy6pAgxAcGFsbGV0X3NjaGVkdWxlchhwYWxsZXQQQ2FsbAQEVAABKCBzY2hlZHVsZRABEHdoZW4QAURCbG9ja051bWJlckZvcjxUPgABOG1heWJlX3BlcmlvZGljrQIBrE9wdGlvbjxzY2hlZHVsZTo6UGVyaW9kPEJsb2NrTnVtYmVyRm9yPFQ+Pj4AASBwcmlvcml0eQgBSHNjaGVkdWxlOjpQcmlvcml0eQABEGNhbGz5AQF8Qm94PDxUIGFzIENvbmZpZz46OlJ1bnRpbWVDYWxsPgAABHBBbm9ueW1vdXNseSBzY2hlZHVsZSBhIHRhc2suGGNhbmNlbAgBEHdoZW4QAURCbG9ja051bWJlckZvcjxUPgABFGluZGV4EAEMdTMyAAEElENhbmNlbCBhbiBhbm9ueW1vdXNseSBzY2hlZHVsZWQgdGFzay44c2NoZWR1bGVfbmFtZWQUAQhpZAQBIFRhc2tOYW1lAAEQd2hlbhABREJsb2NrTnVtYmVyRm9yPFQ+AAE4bWF5YmVfcGVyaW9kaWOtAgGsT3B0aW9uPHNjaGVkdWxlOjpQZXJpb2Q8QmxvY2tOdW1iZXJGb3I8VD4+PgABIHByaW9yaXR5CAFIc2NoZWR1bGU6OlByaW9yaXR5AAEQY2FsbPkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAIEWFNjaGVkdWxlIGEgbmFtZWQgdGFzay4wY2FuY2VsX25hbWVkBAEIaWQEASBUYXNrTmFtZQADBHhDYW5jZWwgYSBuYW1lZCBzY2hlZHVsZWQgdGFzay44c2NoZWR1bGVfYWZ0ZXIQARRhZnRlchABREJsb2NrTnVtYmVyRm9yPFQ+AAE4bWF5YmVfcGVyaW9kaWOtAgGsT3B0aW9uPHNjaGVkdWxlOjpQZXJpb2Q8QmxvY2tOdW1iZXJGb3I8VD4+PgABIHByaW9yaXR5CAFIc2NoZWR1bGU6OlByaW9yaXR5AAEQY2FsbPkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAQEqEFub255bW91c2x5IHNjaGVkdWxlIGEgdGFzayBhZnRlciBhIGRlbGF5LlBzY2hlZHVsZV9uYW1lZF9hZnRlchQBCGlkBAEgVGFza05hbWUAARRhZnRlchABREJsb2NrTnVtYmVyRm9yPFQ+AAE4bWF5YmVfcGVyaW9kaWOtAgGsT3B0aW9uPHNjaGVkdWxlOjpQZXJpb2Q8QmxvY2tOdW1iZXJGb3I8VD4+PgABIHByaW9yaXR5CAFIc2NoZWR1bGU6OlByaW9yaXR5AAEQY2FsbPkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAUEkFNjaGVkdWxlIGEgbmFtZWQgdGFzayBhZnRlciBhIGRlbGF5LiRzZXRfcmV0cnkMARB0YXNr/AF4VGFza0FkZHJlc3M8QmxvY2tOdW1iZXJGb3I8VD4+AAEccmV0cmllcwgBCHU4AAEYcGVyaW9kEAFEQmxvY2tOdW1iZXJGb3I8VD4ABjBZAVNldCBhIHJldHJ5IGNvbmZpZ3VyYXRpb24gZm9yIGEgdGFzayBzbyB0aGF0LCBpbiBjYXNlIGl0cyBzY2hlZHVsZWQgcnVuIGZhaWxzLCBpdCB3aWxsVQFiZSByZXRyaWVkIGFmdGVyIGBwZXJpb2RgIGJsb2NrcywgZm9yIGEgdG90YWwgYW1vdW50IG9mIGByZXRyaWVzYCByZXRyaWVzIG9yIHVudGlsIGl0JHN1Y2NlZWRzLgBVAVRhc2tzIHdoaWNoIG5lZWQgdG8gYmUgc2NoZWR1bGVkIGZvciBhIHJldHJ5IGFyZSBzdGlsbCBzdWJqZWN0IHRvIHdlaWdodCBtZXRlcmluZyBhbmRRAWFnZW5kYSBzcGFjZSwgc2FtZSBhcyBhIHJlZ3VsYXIgdGFzay4gSWYgYSBwZXJpb2RpYyB0YXNrIGZhaWxzLCBpdCB3aWxsIGJlIHNjaGVkdWxlZJBub3JtYWxseSB3aGlsZSB0aGUgdGFzayBpcyByZXRyeWluZy4AUQFUYXNrcyBzY2hlZHVsZWQgYXMgYSByZXN1bHQgb2YgYSByZXRyeSBmb3IgYSBwZXJpb2RpYyB0YXNrIGFyZSB1bm5hbWVkLCBub24tcGVyaW9kaWM9AWNsb25lcyBvZiB0aGUgb3JpZ2luYWwgdGFzay4gVGhlaXIgcmV0cnkgY29uZmlndXJhdGlvbiB3aWxsIGJlIGRlcml2ZWQgZnJvbSB0aGVNAW9yaWdpbmFsIHRhc2sncyBjb25maWd1cmF0aW9uLCBidXQgd2lsbCBoYXZlIGEgbG93ZXIgdmFsdWUgZm9yIGByZW1haW5pbmdgIHRoYW4gdGhlZG9yaWdpbmFsIGB0b3RhbF9yZXRyaWVzYC48c2V0X3JldHJ5X25hbWVkDAEIaWQEASBUYXNrTmFtZQABHHJldHJpZXMIAQh1OAABGHBlcmlvZBABREJsb2NrTnVtYmVyRm9yPFQ+AAcwXQFTZXQgYSByZXRyeSBjb25maWd1cmF0aW9uIGZvciBhIG5hbWVkIHRhc2sgc28gdGhhdCwgaW4gY2FzZSBpdHMgc2NoZWR1bGVkIHJ1biBmYWlscywgaXRdAXdpbGwgYmUgcmV0cmllZCBhZnRlciBgcGVyaW9kYCBibG9ja3MsIGZvciBhIHRvdGFsIGFtb3VudCBvZiBgcmV0cmllc2AgcmV0cmllcyBvciB1bnRpbDBpdCBzdWNjZWVkcy4AVQFUYXNrcyB3aGljaCBuZWVkIHRvIGJlIHNjaGVkdWxlZCBmb3IgYSByZXRyeSBhcmUgc3RpbGwgc3ViamVjdCB0byB3ZWlnaHQgbWV0ZXJpbmcgYW5kUQFhZ2VuZGEgc3BhY2UsIHNhbWUgYXMgYSByZWd1bGFyIHRhc2suIElmIGEgcGVyaW9kaWMgdGFzayBmYWlscywgaXQgd2lsbCBiZSBzY2hlZHVsZWSQbm9ybWFsbHkgd2hpbGUgdGhlIHRhc2sgaXMgcmV0cnlpbmcuAFEBVGFza3Mgc2NoZWR1bGVkIGFzIGEgcmVzdWx0IG9mIGEgcmV0cnkgZm9yIGEgcGVyaW9kaWMgdGFzayBhcmUgdW5uYW1lZCwgbm9uLXBlcmlvZGljPQFjbG9uZXMgb2YgdGhlIG9yaWdpbmFsIHRhc2suIFRoZWlyIHJldHJ5IGNvbmZpZ3VyYXRpb24gd2lsbCBiZSBkZXJpdmVkIGZyb20gdGhlTQFvcmlnaW5hbCB0YXNrJ3MgY29uZmlndXJhdGlvbiwgYnV0IHdpbGwgaGF2ZSBhIGxvd2VyIHZhbHVlIGZvciBgcmVtYWluaW5nYCB0aGFuIHRoZWRvcmlnaW5hbCBgdG90YWxfcmV0cmllc2AuMGNhbmNlbF9yZXRyeQQBEHRhc2v8AXhUYXNrQWRkcmVzczxCbG9ja051bWJlckZvcjxUPj4ACASoUmVtb3ZlcyB0aGUgcmV0cnkgY29uZmlndXJhdGlvbiBvZiBhIHRhc2suSGNhbmNlbF9yZXRyeV9uYW1lZAQBCGlkBAEgVGFza05hbWUACQS8Q2FuY2VsIHRoZSByZXRyeSBjb25maWd1cmF0aW9uIG9mIGEgbmFtZWQgdGFzay4EDQFDb250YWlucyBhIHZhcmlhbnQgcGVyIGRpc3BhdGNoYWJsZSBleHRyaW5zaWMgdGhhdCB0aGlzIHBhbGxldCBoYXMurQIEGE9wdGlvbgQEVAH8AQgQTm9uZQAAABBTb21lBAD8AAABAACxAgxYcGFsbGV0X3N1YnRlbnNvcl9wcm94eRhwYWxsZXQQQ2FsbAQEVAABLBRwcm94eQwBEHJlYWw1AgFQQWNjb3VudElkTG9va3VwT2Y8VD4AAUBmb3JjZV9wcm94eV90eXBltQIBUE9wdGlvbjxUOjpQcm94eVR5cGU+AAEQY2FsbPkBAXxCb3g8PFQgYXMgQ29uZmlnPjo6UnVudGltZUNhbGw+AAAkTQFEaXNwYXRjaCB0aGUgZ2l2ZW4gYGNhbGxgIGZyb20gYW4gYWNjb3VudCB0aGF0IHRoZSBzZW5kZXIgaXMgYXV0aG9yaXNlZCBmb3IgdGhyb3VnaDBgYWRkX3Byb3h5YC4AzFRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfLgAsUGFyYW1ldGVyczoNAS0gYHJlYWxgOiBUaGUgYWNjb3VudCB0aGF0IHRoZSBwcm94eSB3aWxsIG1ha2UgYSBjYWxsIG9uIGJlaGFsZiBvZi5hAS0gYGZvcmNlX3Byb3h5X3R5cGVgOiBTcGVjaWZ5IHRoZSBleGFjdCBwcm94eSB0eXBlIHRvIGJlIHVzZWQgYW5kIGNoZWNrZWQgZm9yIHRoaXMgY2FsbC7QLSBgY2FsbGA6IFRoZSBjYWxsIHRvIGJlIG1hZGUgYnkgdGhlIGByZWFsYCBhY2NvdW50LiRhZGRfcHJveHkMASBkZWxlZ2F0ZTUCAVBBY2NvdW50SWRMb29rdXBPZjxUPgABKHByb3h5X3R5cGUJAQEwVDo6UHJveHlUeXBlAAEUZGVsYXkQAURCbG9ja051bWJlckZvcjxUPgABJEUBUmVnaXN0ZXIgYSBwcm94eSBhY2NvdW50IGZvciB0aGUgc2VuZGVyIHRoYXQgaXMgYWJsZSB0byBtYWtlIGNhbGxzIG9uIGl0cyBiZWhhbGYuAMxUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfU2lnbmVkXy4ALFBhcmFtZXRlcnM6EQEtIGBwcm94eWA6IFRoZSBhY2NvdW50IHRoYXQgdGhlIGBjYWxsZXJgIHdvdWxkIGxpa2UgdG8gbWFrZSBhIHByb3h5LvwtIGBwcm94eV90eXBlYDogVGhlIHBlcm1pc3Npb25zIGFsbG93ZWQgZm9yIHRoaXMgcHJveHkgYWNjb3VudC5NAS0gYGRlbGF5YDogVGhlIGFubm91bmNlbWVudCBwZXJpb2QgcmVxdWlyZWQgb2YgdGhlIGluaXRpYWwgcHJveHkuIFdpbGwgZ2VuZXJhbGx5IGJlFHplcm8uMHJlbW92ZV9wcm94eQwBIGRlbGVnYXRlNQIBUEFjY291bnRJZExvb2t1cE9mPFQ+AAEocHJveHlfdHlwZQkBATBUOjpQcm94eVR5cGUAARRkZWxheRABREJsb2NrTnVtYmVyRm9yPFQ+AAIcqFVucmVnaXN0ZXIgYSBwcm94eSBhY2NvdW50IGZvciB0aGUgc2VuZGVyLgDMVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8uACxQYXJhbWV0ZXJzOiUBLSBgcHJveHlgOiBUaGUgYWNjb3VudCB0aGF0IHRoZSBgY2FsbGVyYCB3b3VsZCBsaWtlIHRvIHJlbW92ZSBhcyBhIHByb3h5LkEBLSBgcHJveHlfdHlwZWA6IFRoZSBwZXJtaXNzaW9ucyBjdXJyZW50bHkgZW5hYmxlZCBmb3IgdGhlIHJlbW92ZWQgcHJveHkgYWNjb3VudC44cmVtb3ZlX3Byb3hpZXMAAxi0VW5yZWdpc3RlciBhbGwgcHJveHkgYWNjb3VudHMgZm9yIHRoZSBzZW5kZXIuAMxUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfU2lnbmVkXy4AXQFXQVJOSU5HOiBUaGlzIG1heSBiZSBjYWxsZWQgb24gYWNjb3VudHMgY3JlYXRlZCBieSBgY3JlYXRlX3B1cmVgLCBob3dldmVyIGlmIGRvbmUsIHRoZW5ZAXRoZSB1bnJlc2VydmVkIGZlZXMgd2lsbCBiZSBpbmFjY2Vzc2libGUuICoqQWxsIGFjY2VzcyB0byB0aGlzIGFjY291bnQgd2lsbCBiZSBsb3N0LioqLGNyZWF0ZV9wdXJlDAEocHJveHlfdHlwZQkBATBUOjpQcm94eVR5cGUAARRkZWxheRABREJsb2NrTnVtYmVyRm9yPFQ+AAEUaW5kZXigAQx1MTYABEg5AVNwYXduIGEgZnJlc2ggbmV3IGFjY291bnQgdGhhdCBpcyBndWFyYW50ZWVkIHRvIGJlIG90aGVyd2lzZSBpbmFjY2Vzc2libGUsIGFuZPxpbml0aWFsaXplIGl0IHdpdGggYSBwcm94eSBvZiBgcHJveHlfdHlwZWAgZm9yIGBvcmlnaW5gIHNlbmRlci4AbFJlcXVpcmVzIGEgYFNpZ25lZGAgb3JpZ2luLgBRAS0gYHByb3h5X3R5cGVgOiBUaGUgdHlwZSBvZiB0aGUgcHJveHkgdGhhdCB0aGUgc2VuZGVyIHdpbGwgYmUgcmVnaXN0ZXJlZCBhcyBvdmVyIHRoZU0BbmV3IGFjY291bnQuIFRoaXMgd2lsbCBhbG1vc3QgYWx3YXlzIGJlIHRoZSBtb3N0IHBlcm1pc3NpdmUgYFByb3h5VHlwZWAgcG9zc2libGUgdG94YWxsb3cgZm9yIG1heGltdW0gZmxleGliaWxpdHkuUQEtIGBpbmRleGA6IEEgZGlzYW1iaWd1YXRpb24gaW5kZXgsIGluIGNhc2UgdGhpcyBpcyBjYWxsZWQgbXVsdGlwbGUgdGltZXMgaW4gdGhlIHNhbWVdAXRyYW5zYWN0aW9uIChlLmcuIHdpdGggYHV0aWxpdHk6OmJhdGNoYCkuIFVubGVzcyB5b3UncmUgdXNpbmcgYGJhdGNoYCB5b3UgcHJvYmFibHkganVzdEB3YW50IHRvIHVzZSBgMGAuTQEtIGBkZWxheWA6IFRoZSBhbm5vdW5jZW1lbnQgcGVyaW9kIHJlcXVpcmVkIG9mIHRoZSBpbml0aWFsIHByb3h5LiBXaWxsIGdlbmVyYWxseSBiZRR6ZXJvLgBRAUZhaWxzIHdpdGggYER1cGxpY2F0ZWAgaWYgdGhpcyBoYXMgYWxyZWFkeSBiZWVuIGNhbGxlZCBpbiB0aGlzIHRyYW5zYWN0aW9uLCBmcm9tIHRoZZhzYW1lIHNlbmRlciwgd2l0aCB0aGUgc2FtZSBwYXJhbWV0ZXJzLgDkRmFpbHMgaWYgdGhlcmUgYXJlIGluc3VmZmljaWVudCBmdW5kcyB0byBwYXkgZm9yIGRlcG9zaXQuJGtpbGxfcHVyZRQBHHNwYXduZXI1AgFQQWNjb3VudElkTG9va3VwT2Y8VD4AAShwcm94eV90eXBlCQEBMFQ6OlByb3h5VHlwZQABFGluZGV4oAEMdTE2AAEYaGVpZ2h0sQEBREJsb2NrTnVtYmVyRm9yPFQ+AAEkZXh0X2luZGV4sQEBDHUzMgAFQKBSZW1vdmVzIGEgcHJldmlvdXNseSBzcGF3bmVkIHB1cmUgcHJveHkuAEkBV0FSTklORzogKipBbGwgYWNjZXNzIHRvIHRoaXMgYWNjb3VudCB3aWxsIGJlIGxvc3QuKiogQW55IGZ1bmRzIGhlbGQgaW4gaXQgd2lsbCBiZTRpbmFjY2Vzc2libGUuAFkBUmVxdWlyZXMgYSBgU2lnbmVkYCBvcmlnaW4sIGFuZCB0aGUgc2VuZGVyIGFjY291bnQgbXVzdCBoYXZlIGJlZW4gY3JlYXRlZCBieSBhIGNhbGwgdG+wYGNyZWF0ZV9wdXJlYCB3aXRoIGNvcnJlc3BvbmRpbmcgcGFyYW1ldGVycy4AVQEtIGBzcGF3bmVyYDogVGhlIGFjY291bnQgdGhhdCBvcmlnaW5hbGx5IGNhbGxlZCBgY3JlYXRlX3B1cmVgIHRvIGNyZWF0ZSB0aGlzIGFjY291bnQuVQEtIGBpbmRleGA6IFRoZSBkaXNhbWJpZ3VhdGlvbiBpbmRleCBvcmlnaW5hbGx5IHBhc3NlZCB0byBgY3JlYXRlX3B1cmVgLiBQcm9iYWJseSBgMGAuCQEtIGBwcm94eV90eXBlYDogVGhlIHByb3h5IHR5cGUgb3JpZ2luYWxseSBwYXNzZWQgdG8gYGNyZWF0ZV9wdXJlYC5FAS0gYGhlaWdodGA6IFRoZSBoZWlnaHQgb2YgdGhlIGNoYWluIHdoZW4gdGhlIGNhbGwgdG8gYGNyZWF0ZV9wdXJlYCB3YXMgcHJvY2Vzc2VkLlEBLSBgZXh0X2luZGV4YDogVGhlIGV4dHJpbnNpYyBpbmRleCBpbiB3aGljaCB0aGUgY2FsbCB0byBgY3JlYXRlX3B1cmVgIHdhcyBwcm9jZXNzZWQuADUBRmFpbHMgd2l0aCBgTm9QZXJtaXNzaW9uYCBpbiBjYXNlIHRoZSBjYWxsZXIgaXMgbm90IGEgcHJldmlvdXNseSBjcmVhdGVkIHB1cmX4YWNjb3VudCB3aG9zZSBgY3JlYXRlX3B1cmVgIGNhbGwgaGFzIGNvcnJlc3BvbmRpbmcgcGFyYW1ldGVycy4gYW5ub3VuY2UIARByZWFsNQIBUEFjY291bnRJZExvb2t1cE9mPFQ+AAEkY2FsbF9oYXNoNAE0Q2FsbEhhc2hPZjxUPgAGPAUBUHVibGlzaCB0aGUgaGFzaCBvZiBhIHByb3h5LWNhbGwgdGhhdCB3aWxsIGJlIG1hZGUgaW4gdGhlIGZ1dHVyZS4AXQFUaGlzIG11c3QgYmUgY2FsbGVkIHNvbWUgbnVtYmVyIG9mIGJsb2NrcyBiZWZvcmUgdGhlIGNvcnJlc3BvbmRpbmcgYHByb3h5YCBpcyBhdHRlbXB0ZWQlAWlmIHRoZSBkZWxheSBhc3NvY2lhdGVkIHdpdGggdGhlIHByb3h5IHJlbGF0aW9uc2hpcCBpcyBncmVhdGVyIHRoYW4gemVyby4AEQFObyBtb3JlIHRoYW4gYE1heFBlbmRpbmdgIGFubm91bmNlbWVudHMgbWF5IGJlIG1hZGUgYXQgYW55IG9uZSB0aW1lLgAJAVRoaXMgd2lsbCB0YWtlIGEgZGVwb3NpdCBvZiBgQW5ub3VuY2VtZW50RGVwb3NpdEZhY3RvcmAgYXMgd2VsbCBhcxkBYEFubm91bmNlbWVudERlcG9zaXRCYXNlYCBpZiB0aGVyZSBhcmUgbm8gb3RoZXIgcGVuZGluZyBhbm5vdW5jZW1lbnRzLgAlAVRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfIGFuZCBhIHByb3h5IG9mIGByZWFsYC4ALFBhcmFtZXRlcnM6DQEtIGByZWFsYDogVGhlIGFjY291bnQgdGhhdCB0aGUgcHJveHkgd2lsbCBtYWtlIGEgY2FsbCBvbiBiZWhhbGYgb2YuFQEtIGBjYWxsX2hhc2hgOiBUaGUgaGFzaCBvZiB0aGUgY2FsbCB0byBiZSBtYWRlIGJ5IHRoZSBgcmVhbGAgYWNjb3VudC5McmVtb3ZlX2Fubm91bmNlbWVudAgBEHJlYWw1AgFQQWNjb3VudElkTG9va3VwT2Y8VD4AASRjYWxsX2hhc2g0ATRDYWxsSGFzaE9mPFQ+AAcocFJlbW92ZSBhIGdpdmVuIGFubm91bmNlbWVudC4AWQFNYXkgYmUgY2FsbGVkIGJ5IGEgcHJveHkgYWNjb3VudCB0byByZW1vdmUgYSBjYWxsIHRoZXkgcHJldmlvdXNseSBhbm5vdW5jZWQgYW5kIHJldHVybjB0aGUgZGVwb3NpdC4AzFRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfLgAsUGFyYW1ldGVyczoNAS0gYHJlYWxgOiBUaGUgYWNjb3VudCB0aGF0IHRoZSBwcm94eSB3aWxsIG1ha2UgYSBjYWxsIG9uIGJlaGFsZiBvZi4VAS0gYGNhbGxfaGFzaGA6IFRoZSBoYXNoIG9mIHRoZSBjYWxsIHRvIGJlIG1hZGUgYnkgdGhlIGByZWFsYCBhY2NvdW50LkxyZWplY3RfYW5ub3VuY2VtZW50CAEgZGVsZWdhdGU1AgFQQWNjb3VudElkTG9va3VwT2Y8VD4AASRjYWxsX2hhc2g0ATRDYWxsSGFzaE9mPFQ+AAgosFJlbW92ZSB0aGUgZ2l2ZW4gYW5ub3VuY2VtZW50IG9mIGEgZGVsZWdhdGUuAGEBTWF5IGJlIGNhbGxlZCBieSBhIHRhcmdldCAocHJveGllZCkgYWNjb3VudCB0byByZW1vdmUgYSBjYWxsIHRoYXQgb25lIG9mIHRoZWlyIGRlbGVnYXRlcyUBKGBkZWxlZ2F0ZWApIGhhcyBhbm5vdW5jZWQgdGhleSB3YW50IHRvIGV4ZWN1dGUuIFRoZSBkZXBvc2l0IGlzIHJldHVybmVkLgDMVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8uACxQYXJhbWV0ZXJzOvQtIGBkZWxlZ2F0ZWA6IFRoZSBhY2NvdW50IHRoYXQgcHJldmlvdXNseSBhbm5vdW5jZWQgdGhlIGNhbGwuvC0gYGNhbGxfaGFzaGA6IFRoZSBoYXNoIG9mIHRoZSBjYWxsIHRvIGJlIG1hZGUuPHByb3h5X2Fubm91bmNlZBABIGRlbGVnYXRlNQIBUEFjY291bnRJZExvb2t1cE9mPFQ+AAEQcmVhbDUCAVBBY2NvdW50SWRMb29rdXBPZjxUPgABQGZvcmNlX3Byb3h5X3R5cGW1AgFQT3B0aW9uPFQ6OlByb3h5VHlwZT4AARBjYWxs+QEBfEJveDw8VCBhcyBDb25maWc+OjpSdW50aW1lQ2FsbD4ACSxNAURpc3BhdGNoIHRoZSBnaXZlbiBgY2FsbGAgZnJvbSBhbiBhY2NvdW50IHRoYXQgdGhlIHNlbmRlciBpcyBhdXRob3JpemVkIGZvciB0aHJvdWdoMGBhZGRfcHJveHlgLgCoUmVtb3ZlcyBhbnkgY29ycmVzcG9uZGluZyBhbm5vdW5jZW1lbnQocykuAMxUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfU2lnbmVkXy4ALFBhcmFtZXRlcnM6DQEtIGByZWFsYDogVGhlIGFjY291bnQgdGhhdCB0aGUgcHJveHkgd2lsbCBtYWtlIGEgY2FsbCBvbiBiZWhhbGYgb2YuYQEtIGBmb3JjZV9wcm94eV90eXBlYDogU3BlY2lmeSB0aGUgZXhhY3QgcHJveHkgdHlwZSB0byBiZSB1c2VkIGFuZCBjaGVja2VkIGZvciB0aGlzIGNhbGwu0C0gYGNhbGxgOiBUaGUgY2FsbCB0byBiZSBtYWRlIGJ5IHRoZSBgcmVhbGAgYWNjb3VudC4wcG9rZV9kZXBvc2l0AAogSQFQb2tlIC8gQWRqdXN0IGRlcG9zaXRzIG1hZGUgZm9yIHByb3hpZXMgYW5kIGFubm91bmNlbWVudHMgYmFzZWQgb24gY3VycmVudCB2YWx1ZXMuDQFUaGlzIGNhbiBiZSB1c2VkIGJ5IGFjY291bnRzIHRvIHBvc3NpYmx5IGxvd2VyIHRoZWlyIGxvY2tlZCBhbW91bnQuAMxUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfU2lnbmVkXy4AAQFUaGUgdHJhbnNhY3Rpb24gZmVlIGlzIHdhaXZlZCBpZiB0aGUgZGVwb3NpdCBhbW91bnQgaGFzIGNoYW5nZWQuAIxFbWl0cyBgRGVwb3NpdFBva2VkYCBpZiBzdWNjZXNzZnVsLgQNAUNvbnRhaW5zIGEgdmFyaWFudCBwZXIgZGlzcGF0Y2hhYmxlIGV4dHJpbnNpYyB0aGF0IHRoaXMgcGFsbGV0IGhhcy61AgQYT3B0aW9uBARUAQkBAQgQTm9uZQAAABBTb21lBAAJAQAAAQAAuQIMPHBhbGxldF9yZWdpc3RyeRhwYWxsZXQQQ2FsbAQEVAABCDBzZXRfaWRlbnRpdHkIAShpZGVudGlmaWVkAAEwVDo6QWNjb3VudElkAAEQaW5mb70CAaRCb3g8SWRlbnRpdHlJbmZvPFQ6Ok1heEFkZGl0aW9uYWxGaWVsZHM+PgAABD0BUmVnaXN0ZXIgYW4gaWRlbnRpdHkgZm9yIGFuIGFjY291bnQuIFRoaXMgd2lsbCBvdmVyd3JpdGUgYW55IGV4aXN0aW5nIGlkZW50aXR5LjhjbGVhcl9pZGVudGl0eQQBKGlkZW50aWZpZWQAATBUOjpBY2NvdW50SWQAAQSEQ2xlYXIgdGhlIGlkZW50aXR5IG9mIGFuIGFjY291bnQuBA0BQ29udGFpbnMgYSB2YXJpYW50IHBlciBkaXNwYXRjaGFibGUgZXh0cmluc2ljIHRoYXQgdGhpcyBwYWxsZXQgaGFzLr0CDDxwYWxsZXRfcmVnaXN0cnkUdHlwZXMwSWRlbnRpdHlJbmZvBChGaWVsZExpbWl0AAAkAShhZGRpdGlvbmFswQIBkEJvdW5kZWRWZWM8KERhdGEsIERhdGEpLCBGaWVsZExpbWl0PgABHGRpc3BsYXnJAgEQRGF0YQABFGxlZ2FsyQIBEERhdGEAAQx3ZWLJAgEQRGF0YQABEHJpb3TJAgEQRGF0YQABFGVtYWlsyQIBEERhdGEAATxwZ3BfZmluZ2VycHJpbnTBAwFAT3B0aW9uPFt1ODsgMjBdPgABFGltYWdlyQIBEERhdGEAARx0d2l0dGVyyQIBEERhdGEAAMECDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQBxQIEUwAABAC9AwEYVmVjPFQ+AADFAgAABAjJAskCAMkCDDxwYWxsZXRfcmVnaXN0cnkUdHlwZXMQRGF0YQABGQEQTm9uZQAAABBSYXcwBADNAgAAAQAQUmF3MQQA0QIAAAIAEFJhdzIEANUCAAADABBSYXczBADZAgAABAAQUmF3NAQASAAABQAQUmF3NQQA3QIAAAYAEFJhdzYEAOECAAAHABBSYXc3BADlAgAACAAQUmF3OAQA8QEAAAkAEFJhdzkEAOkCAAAKABRSYXcxMAQA7QIAAAsAFFJhdzExBADxAgAADAAUUmF3MTIEAPUCAAANABRSYXcxMwQA+QIAAA4AFFJhdzE0BAD9AgAADwAUUmF3MTUEAAEDAAAQABRSYXcxNgQABQMAABEAFFJhdzE3BAAJAwAAEgAUUmF3MTgEAA0DAAATABRSYXcxOQQAEQMAABQAFFJhdzIwBADIAAAVABRSYXcyMQQAFQMAABYAFFJhdzIyBAAZAwAAFwAUUmF3MjMEAB0DAAAYABRSYXcyNAQAIQMAABkAFFJhdzI1BAAlAwAAGgAUUmF3MjYEACkDAAAbABRSYXcyNwQALQMAABwAFFJhdzI4BAAxAwAAHQAUUmF3MjkEADUDAAAeABRSYXczMAQAOQMAAB8AFFJhdzMxBAA9AwAAIAAUUmF3MzIEAAQAACEAFFJhdzMzBABBAwAAIgAUUmF3MzQEAEUDAAAjABRSYXczNQQASQMAACQAFFJhdzM2BABNAwAAJQAUUmF3MzcEAFEDAAAmABRSYXczOAQAVQMAACcAFFJhdzM5BABZAwAAKAAUUmF3NDAEAF0DAAApABRSYXc0MQQAYQMAACoAFFJhdzQyBABlAwAAKwAUUmF3NDMEAGkDAAAsABRSYXc0NAQAbQMAAC0AFFJhdzQ1BABxAwAALgAUUmF3NDYEAHUDAAAvABRSYXc0NwQAeQMAADAAFFJhdzQ4BAB9AwAAMQAUUmF3NDkEAIEDAAAyABRSYXc1MAQAhQMAADMAFFJhdzUxBACJAwAANAAUUmF3NTIEAI0DAAA1ABRSYXc1MwQAkQMAADYAFFJhdzU0BACVAwAANwAUUmF3NTUEAJkDAAA4ABRSYXc1NgQAnQMAADkAFFJhdzU3BAChAwAAOgAUUmF3NTgEAKUDAAA7ABRSYXc1OQQAqQMAADwAFFJhdzYwBACtAwAAPQAUUmF3NjEEALEDAAA+ABRSYXc2MgQAtQMAAD8AFFJhdzYzBAC5AwAAQAAUUmF3NjQEABkCAABBACxCbGFrZVR3bzI1NgQABAAAQgAYU2hhMjU2BAAEAABDACRLZWNjYWsyNTYEAAQAAEQALFNoYVRocmVlMjU2BAAEAABFAADNAgAAAwAAAAAIANECAAADAQAAAAgA1QIAAAMCAAAACADZAgAAAwMAAAAIAN0CAAADBQAAAAgA4QIAAAMGAAAACADlAgAAAwcAAAAIAOkCAAADCQAAAAgA7QIAAAMKAAAACADxAgAAAwsAAAAIAPUCAAADDAAAAAgA+QIAAAMNAAAACAD9AgAAAw4AAAAIAAEDAAADDwAAAAgABQMAAAMQAAAACAAJAwAAAxEAAAAIAA0DAAADEgAAAAgAEQMAAAMTAAAACAAVAwAAAxUAAAAIABkDAAADFgAAAAgAHQMAAAMXAAAACAAhAwAAAxgAAAAIACUDAAADGQAAAAgAKQMAAAMaAAAACAAtAwAAAxsAAAAIADEDAAADHAAAAAgANQMAAAMdAAAACAA5AwAAAx4AAAAIAD0DAAADHwAAAAgAQQMAAAMhAAAACABFAwAAAyIAAAAIAEkDAAADIwAAAAgATQMAAAMkAAAACABRAwAAAyUAAAAIAFUDAAADJgAAAAgAWQMAAAMnAAAACABdAwAAAygAAAAIAGEDAAADKQAAAAgAZQMAAAMqAAAACABpAwAAAysAAAAIAG0DAAADLAAAAAgAcQMAAAMtAAAACAB1AwAAAy4AAAAIAHkDAAADLwAAAAgAfQMAAAMwAAAACACBAwAAAzEAAAAIAIUDAAADMgAAAAgAiQMAAAMzAAAACACNAwAAAzQAAAAIAJEDAAADNQAAAAgAlQMAAAM2AAAACACZAwAAAzcAAAAIAJ0DAAADOAAAAAgAoQMAAAM5AAAACAClAwAAAzoAAAAIAKkDAAADOwAAAAgArQMAAAM8AAAACACxAwAAAz0AAAAIALUDAAADPgAAAAgAuQMAAAM/AAAACAC9AwAAAsUCAMEDBBhPcHRpb24EBFQByAEIEE5vbmUAAAAQU29tZQQAyAAAAQAAxQMMSHBhbGxldF9jb21taXRtZW50cxhwYWxsZXQQQ2FsbAQEVAABCDhzZXRfY29tbWl0bWVudAgBGG5ldHVpZKABGE5ldFVpZAABEGluZm/JAwGEQm94PENvbW1pdG1lbnRJbmZvPFQ6Ok1heEZpZWxkcz4+AAAElFNldCB0aGUgY29tbWl0bWVudCBmb3IgYSBnaXZlbiBuZXR1aWQ0c2V0X21heF9zcGFjZQQBJG5ld19saW1pdBABDHUzMgACBERTdWRvLXNldCBNYXhTcGFjZQQNAUNvbnRhaW5zIGEgdmFyaWFudCBwZXIgZGlzcGF0Y2hhYmxlIGV4dHJpbnNpYyB0aGF0IHRoaXMgcGFsbGV0IGhhcy7JAwxIcGFsbGV0X2NvbW1pdG1lbnRzFHR5cGVzOENvbW1pdG1lbnRJbmZvBChGaWVsZExpbWl0AAAEARhmaWVsZHPNAwFwQm91bmRlZFZlYzxEYXRhLCBGaWVsZExpbWl0PgAAzQMMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAHRAwRTAAAEANkEARhWZWM8VD4AANEDDEhwYWxsZXRfY29tbWl0bWVudHMUdHlwZXMQRGF0YQABJQIQTm9uZQAAABBSYXcwBADNAgAAAQAQUmF3MQQA0QIAAAIAEFJhdzIEANUCAAADABBSYXczBADZAgAABAAQUmF3NAQASAAABQAQUmF3NQQA3QIAAAYAEFJhdzYEAOECAAAHABBSYXc3BADlAgAACAAQUmF3OAQA8QEAAAkAEFJhdzkEAOkCAAAKABRSYXcxMAQA7QIAAAsAFFJhdzExBADxAgAADAAUUmF3MTIEAPUCAAANABRSYXcxMwQA+QIAAA4AFFJhdzE0BAD9AgAADwAUUmF3MTUEAAEDAAAQABRSYXcxNgQABQMAABEAFFJhdzE3BAAJAwAAEgAUUmF3MTgEAA0DAAATABRSYXcxOQQAEQMAABQAFFJhdzIwBADIAAAVABRSYXcyMQQAFQMAABYAFFJhdzIyBAAZAwAAFwAUUmF3MjMEAB0DAAAYABRSYXcyNAQAIQMAABkAFFJhdzI1BAAlAwAAGgAUUmF3MjYEACkDAAAbABRSYXcyNwQALQMAABwAFFJhdzI4BAAxAwAAHQAUUmF3MjkEADUDAAAeABRSYXczMAQAOQMAAB8AFFJhdzMxBAA9AwAAIAAUUmF3MzIEAAQAACEAFFJhdzMzBABBAwAAIgAUUmF3MzQEAEUDAAAjABRSYXczNQQASQMAACQAFFJhdzM2BABNAwAAJQAUUmF3MzcEAFEDAAAmABRSYXczOAQAVQMAACcAFFJhdzM5BABZAwAAKAAUUmF3NDAEAF0DAAApABRSYXc0MQQAYQMAACoAFFJhdzQyBABlAwAAKwAUUmF3NDMEAGkDAAAsABRSYXc0NAQAbQMAAC0AFFJhdzQ1BABxAwAALgAUUmF3NDYEAHUDAAAvABRSYXc0NwQAeQMAADAAFFJhdzQ4BAB9AwAAMQAUUmF3NDkEAIEDAAAyABRSYXc1MAQAhQMAADMAFFJhdzUxBACJAwAANAAUUmF3NTIEAI0DAAA1ABRSYXc1MwQAkQMAADYAFFJhdzU0BACVAwAANwAUUmF3NTUEAJkDAAA4ABRSYXc1NgQAnQMAADkAFFJhdzU3BAChAwAAOgAUUmF3NTgEAKUDAAA7ABRSYXc1OQQAqQMAADwAFFJhdzYwBACtAwAAPQAUUmF3NjEEALEDAAA+ABRSYXc2MgQAtQMAAD8AFFJhdzYzBAC5AwAAQAAUUmF3NjQEABkCAABBABRSYXc2NQQAeQIAAEIAFFJhdzY2BADVAwAAQwAUUmF3NjcEANkDAABEABRSYXc2OAQA3QMAAEUAFFJhdzY5BADhAwAARgAUUmF3NzAEAOUDAABHABRSYXc3MQQA6QMAAEgAFFJhdzcyBADtAwAASQAUUmF3NzMEAPEDAABKABRSYXc3NAQA9QMAAEsAFFJhdzc1BAD5AwAATAAUUmF3NzYEAP0DAABNABRSYXc3NwQAAQQAAE4AFFJhdzc4BAAFBAAATwAUUmF3NzkEAAkEAABQABRSYXc4MAQADQQAAFEAFFJhdzgxBAARBAAAUgAUUmF3ODIEABUEAABTABRSYXc4MwQAGQQAAFQAFFJhdzg0BAAdBAAAVQAUUmF3ODUEACEEAABWABRSYXc4NgQAJQQAAFcAFFJhdzg3BAApBAAAWAAUUmF3ODgEAC0EAABZABRSYXc4OQQAMQQAAFoAFFJhdzkwBAA1BAAAWwAUUmF3OTEEADkEAABcABRSYXc5MgQAPQQAAF0AFFJhdzkzBABBBAAAXgAUUmF3OTQEAEUEAABfABRSYXc5NQQASQQAAGAAFFJhdzk2BABNBAAAYQAUUmF3OTcEAFEEAABiABRSYXc5OAQAVQQAAGMAFFJhdzk5BABZBAAAZAAYUmF3MTAwBABdBAAAZQAYUmF3MTAxBABhBAAAZgAYUmF3MTAyBABlBAAAZwAYUmF3MTAzBABpBAAAaAAYUmF3MTA0BABtBAAAaQAYUmF3MTA1BABxBAAAagAYUmF3MTA2BAB1BAAAawAYUmF3MTA3BAB5BAAAbAAYUmF3MTA4BAB9BAAAbQAYUmF3MTA5BACBBAAAbgAYUmF3MTEwBACFBAAAbwAYUmF3MTExBACJBAAAcAAYUmF3MTEyBACNBAAAcQAYUmF3MTEzBACRBAAAcgAYUmF3MTE0BACVBAAAcwAYUmF3MTE1BACZBAAAdAAYUmF3MTE2BACdBAAAdQAYUmF3MTE3BAChBAAAdgAYUmF3MTE4BAClBAAAdwAYUmF3MTE5BACpBAAAeAAYUmF3MTIwBACtBAAAeQAYUmF3MTIxBACxBAAAegAYUmF3MTIyBAC1BAAAewAYUmF3MTIzBAC5BAAAfAAYUmF3MTI0BAC9BAAAfQAYUmF3MTI1BADBBAAAfgAYUmF3MTI2BADFBAAAfwAYUmF3MTI3BADJBAAAgAAYUmF3MTI4BADNBAAAgQAsQmxha2VUd28yNTYEAAQAAIIAGFNoYTI1NgQABAAAgwAkS2VjY2FrMjU2BAAEAACEACxTaGFUaHJlZTI1NgQABAAAhQBEVGltZWxvY2tFbmNyeXB0ZWQIASRlbmNyeXB0ZWTRBAAAATByZXZlYWxfcm91bmQYAACGADhSZXNldEJvbmRzRmxhZwCHABhCaWdSYXcEANUEAACIAADVAwAAA0IAAAAIANkDAAADQwAAAAgA3QMAAANEAAAACADhAwAAA0UAAAAIAOUDAAADRgAAAAgA6QMAAANHAAAACADtAwAAA0gAAAAIAPEDAAADSQAAAAgA9QMAAANKAAAACAD5AwAAA0sAAAAIAP0DAAADTAAAAAgAAQQAAANNAAAACAAFBAAAA04AAAAIAAkEAAADTwAAAAgADQQAAANQAAAACAARBAAAA1EAAAAIABUEAAADUgAAAAgAGQQAAANTAAAACAAdBAAAA1QAAAAIACEEAAADVQAAAAgAJQQAAANWAAAACAApBAAAA1cAAAAIAC0EAAADWAAAAAgAMQQAAANZAAAACAA1BAAAA1oAAAAIADkEAAADWwAAAAgAPQQAAANcAAAACABBBAAAA10AAAAIAEUEAAADXgAAAAgASQQAAANfAAAACABNBAAAA2AAAAAIAFEEAAADYQAAAAgAVQQAAANiAAAACABZBAAAA2MAAAAIAF0EAAADZAAAAAgAYQQAAANlAAAACABlBAAAA2YAAAAIAGkEAAADZwAAAAgAbQQAAANoAAAACABxBAAAA2kAAAAIAHUEAAADagAAAAgAeQQAAANrAAAACAB9BAAAA2wAAAAIAIEEAAADbQAAAAgAhQQAAANuAAAACACJBAAAA28AAAAIAI0EAAADcAAAAAgAkQQAAANxAAAACACVBAAAA3IAAAAIAJkEAAADcwAAAAgAnQQAAAN0AAAACAChBAAAA3UAAAAIAKUEAAADdgAAAAgAqQQAAAN3AAAACACtBAAAA3gAAAAIALEEAAADeQAAAAgAtQQAAAN6AAAACAC5BAAAA3sAAAAIAL0EAAADfAAAAAgAwQQAAAN9AAAACADFBAAAA34AAAAIAMkEAAADfwAAAAgAzQQAAAOAAAAACADRBAxMYm91bmRlZF9jb2xsZWN0aW9ucyxib3VuZGVkX3ZlYyhCb3VuZGVkVmVjCARUAQgEUwAABAA4ARhWZWM8VD4AANUEDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQBCARTAAAEADgBGFZlYzxUPgAA2QQAAALRAwDdBAxIcGFsbGV0X2FkbWluX3V0aWxzGHBhbGxldBBDYWxsBARUAAEpAUBzd2FwX2F1dGhvcml0aWVzBAE8bmV3X2F1dGhvcml0aWVz4QQB5EJvdW5kZWRWZWM8PFQgYXMgQ29uZmlnPjo6QXV0aG9yaXR5SWQsIFQ6Ok1heEF1dGhvcml0aWVzPgAADOhUaGUgZXh0cmluc2ljIHNldHMgdGhlIG5ldyBhdXRob3JpdGllcyBmb3IgQXVyYSBjb25zZW5zdXMuoEl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudC4JAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBBdXJhIHBhbGxldCB0byBjaGFuZ2UgdGhlIGF1dGhvcml0aWVzLlRzdWRvX3NldF9kZWZhdWx0X3Rha2UEATBkZWZhdWx0X3Rha2WgAQx1MTYAAQzQVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBkZWZhdWx0IHRha2UgZm9yIHRoZSBuZXR3b3JrLqBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQuFQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIGRlZmF1bHQgdGFrZS5Yc3Vkb19zZXRfdHhfcmF0ZV9saW1pdAQBNHR4X3JhdGVfbGltaXQYAQx1NjQAAgz4VGhlIGV4dHJpbnNpYyBzZXRzIHRoZSB0cmFuc2FjdGlvbiByYXRlIGxpbWl0IGZvciB0aGUgbmV0d29yay6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50Lj0BVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSB0cmFuc2FjdGlvbiByYXRlIGxpbWl0LmxzdWRvX3NldF9zZXJ2aW5nX3JhdGVfbGltaXQIARhuZXR1aWSgARhOZXRVaWQAAUhzZXJ2aW5nX3JhdGVfbGltaXQYAQx1NjQAAwzcVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBzZXJ2aW5nIHJhdGUgbGltaXQgZm9yIGEgc3VibmV0LuBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLi0BVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBzZXJ2aW5nIHJhdGUgbGltaXQuXHN1ZG9fc2V0X21pbl9kaWZmaWN1bHR5CAEYbmV0dWlkoAEYTmV0VWlkAAE4bWluX2RpZmZpY3VsdHkYAQx1NjQABAzcVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBtaW5pbXVtIGRpZmZpY3VsdHkgZm9yIGEgc3VibmV0LuBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLi0BVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBtaW5pbXVtIGRpZmZpY3VsdHkuXHN1ZG9fc2V0X21heF9kaWZmaWN1bHR5CAEYbmV0dWlkoAEYTmV0VWlkAAE4bWF4X2RpZmZpY3VsdHkYAQx1NjQABQzcVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBtYXhpbXVtIGRpZmZpY3VsdHkgZm9yIGEgc3VibmV0LuBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLi0BVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBtYXhpbXVtIGRpZmZpY3VsdHkucHN1ZG9fc2V0X3dlaWdodHNfdmVyc2lvbl9rZXkIARhuZXR1aWSgARhOZXRVaWQAAUx3ZWlnaHRzX3ZlcnNpb25fa2V5GAEMdTY0AAYM4FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgd2VpZ2h0cyB2ZXJzaW9uIGtleSBmb3IgYSBzdWJuZXQu4El0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIuMQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIHdlaWdodHMgdmVyc2lvbiBrZXkufHN1ZG9fc2V0X3dlaWdodHNfc2V0X3JhdGVfbGltaXQIARhuZXR1aWSgARhOZXRVaWQAAVh3ZWlnaHRzX3NldF9yYXRlX2xpbWl0GAEMdTY0AAcM7FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgd2VpZ2h0cyBzZXQgcmF0ZSBsaW1pdCBmb3IgYSBzdWJuZXQuoEl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudC49AVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgd2VpZ2h0cyBzZXQgcmF0ZSBsaW1pdC5wc3Vkb19zZXRfYWRqdXN0bWVudF9pbnRlcnZhbAgBGG5ldHVpZKABGE5ldFVpZAABTGFkanVzdG1lbnRfaW50ZXJ2YWygAQx1MTYACAzgVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBhZGp1c3RtZW50IGludGVydmFsIGZvciBhIHN1Ym5ldC4xAUl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudCwgbm90IGNoYW5nZWFibGUgYnkgdGhlIHN1Ym5ldCBvd25lci4xAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgYWRqdXN0bWVudCBpbnRlcnZhbC5kc3Vkb19zZXRfYWRqdXN0bWVudF9hbHBoYQgBGG5ldHVpZKABGE5ldFVpZAABQGFkanVzdG1lbnRfYWxwaGEYAQx1NjQACQzUVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBhZGp1c3RtZW50IGFscGhhIGZvciBhIHN1Ym5ldC7gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50IG9yIHN1Ym5ldCBvd25lci4lAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgYWRqdXN0bWVudCBhbHBoYS5gc3Vkb19zZXRfaW1tdW5pdHlfcGVyaW9kCAEYbmV0dWlkoAEYTmV0VWlkAAE8aW1tdW5pdHlfcGVyaW9koAEMdTE2AA0M0FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgaW1tdW5pdHkgcGVyaW9kIGZvciBhIHN1Ym5ldC7gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50IG9yIHN1Ym5ldCBvd25lci4hAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgaW1tdW5pdHkgcGVyaW9kLnBzdWRvX3NldF9taW5fYWxsb3dlZF93ZWlnaHRzCAEYbmV0dWlkoAEYTmV0VWlkAAFMbWluX2FsbG93ZWRfd2VpZ2h0c6ABDHUxNgAODPBUaGUgZXh0cmluc2ljIHNldHMgdGhlIG1pbmltdW0gYWxsb3dlZCB3ZWlnaHRzIGZvciBhIHN1Ym5ldC7gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50IG9yIHN1Ym5ldCBvd25lci5BAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgbWluaW11bSBhbGxvd2VkIHdlaWdodHMuZHN1ZG9fc2V0X21heF9hbGxvd2VkX3VpZHMIARhuZXR1aWSgARhOZXRVaWQAAUBtYXhfYWxsb3dlZF91aWRzoAEMdTE2AA8M5FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgbWF4aW11bSBhbGxvd2VkIFVJRHMgZm9yIGEgc3VibmV0LuRJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQgYW5kIHN1Ym5ldCBvd25lci5pAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgbWF4aW11bSBhbGxvd2VkIFVJRHMgZm9yIGEgc3VibmV0LjhzdWRvX3NldF9rYXBwYQgBGG5ldHVpZKABGE5ldFVpZAABFGthcHBhoAEMdTE2ABAMqFRoZSBleHRyaW5zaWMgc2V0cyB0aGUga2FwcGEgZm9yIGEgc3VibmV0LuBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLvhUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIGthcHBhLjBzdWRvX3NldF9yaG8IARhuZXR1aWSgARhOZXRVaWQAAQxyaG+gAQx1MTYAEQygVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSByaG8gZm9yIGEgc3VibmV0LuBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLvBUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIHJoby5gc3Vkb19zZXRfYWN0aXZpdHlfY3V0b2ZmCAEYbmV0dWlkoAEYTmV0VWlkAAE8YWN0aXZpdHlfY3V0b2ZmoAEMdTE2ABIM0FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgYWN0aXZpdHkgY3V0b2ZmIGZvciBhIHN1Ym5ldC7gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50IG9yIHN1Ym5ldCBvd25lci4hAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgYWN0aXZpdHkgY3V0b2ZmLpRzdWRvX3NldF9uZXR3b3JrX3JlZ2lzdHJhdGlvbl9hbGxvd2VkCAEYbmV0dWlkoAEYTmV0VWlkAAFQcmVnaXN0cmF0aW9uX2FsbG93ZWQkARBib29sABMMBQFUaGUgZXh0cmluc2ljIHNldHMgdGhlIG5ldHdvcmsgcmVnaXN0cmF0aW9uIGFsbG93ZWQgZm9yIGEgc3VibmV0LuBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLlUBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBuZXR3b3JrIHJlZ2lzdHJhdGlvbiBhbGxvd2VkLqRzdWRvX3NldF9uZXR3b3JrX3Bvd19yZWdpc3RyYXRpb25fYWxsb3dlZAgBGG5ldHVpZKABGE5ldFVpZAABUHJlZ2lzdHJhdGlvbl9hbGxvd2VkJAEQYm9vbAAUDBUBVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBuZXR3b3JrIFBvVyByZWdpc3RyYXRpb24gYWxsb3dlZCBmb3IgYSBzdWJuZXQu4El0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIuZQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIG5ldHdvcmsgUG9XIHJlZ2lzdHJhdGlvbiBhbGxvd2VkLqhzdWRvX3NldF90YXJnZXRfcmVnaXN0cmF0aW9uc19wZXJfaW50ZXJ2YWwIARhuZXR1aWSgARhOZXRVaWQAAYR0YXJnZXRfcmVnaXN0cmF0aW9uc19wZXJfaW50ZXJ2YWygAQx1MTYAFQwZAVRoZSBleHRyaW5zaWMgc2V0cyB0aGUgdGFyZ2V0IHJlZ2lzdHJhdGlvbnMgcGVyIGludGVydmFsIGZvciBhIHN1Ym5ldC6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LmkBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSB0YXJnZXQgcmVnaXN0cmF0aW9ucyBwZXIgaW50ZXJ2YWwuRHN1ZG9fc2V0X21pbl9idXJuCAEYbmV0dWlkoAEYTmV0VWlkAAEgbWluX2J1cm4YAShUYW9CYWxhbmNlABYMxFRoZSBleHRyaW5zaWMgc2V0cyB0aGUgbWluaW11bSBidXJuIGZvciBhIHN1Ym5ldC60SXQgaXMgb25seSBjYWxsYWJsZSBieSByb290IGFuZCBzdWJuZXQgb3duZXIuFQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIG1pbmltdW0gYnVybi5Ec3Vkb19zZXRfbWF4X2J1cm4IARhuZXR1aWSgARhOZXRVaWQAASBtYXhfYnVybhgBKFRhb0JhbGFuY2UAFwzEVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBtYXhpbXVtIGJ1cm4gZm9yIGEgc3VibmV0LrRJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHJvb3QgYW5kIHN1Ym5ldCBvd25lci4VAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgbWF4aW11bSBidXJuLkxzdWRvX3NldF9kaWZmaWN1bHR5CAEYbmV0dWlkoAEYTmV0VWlkAAEoZGlmZmljdWx0eRgBDHU2NAAYDLxUaGUgZXh0cmluc2ljIHNldHMgdGhlIGRpZmZpY3VsdHkgZm9yIGEgc3VibmV0LuBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLg0BVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBkaWZmaWN1bHR5LnxzdWRvX3NldF9tYXhfYWxsb3dlZF92YWxpZGF0b3JzCAEYbmV0dWlkoAEYTmV0VWlkAAFYbWF4X2FsbG93ZWRfdmFsaWRhdG9yc6ABDHUxNgAZDPxUaGUgZXh0cmluc2ljIHNldHMgdGhlIG1heGltdW0gYWxsb3dlZCB2YWxpZGF0b3JzIGZvciBhIHN1Ym5ldC6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50Lk0BVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBtYXhpbXVtIGFsbG93ZWQgdmFsaWRhdG9ycy50c3Vkb19zZXRfYm9uZHNfbW92aW5nX2F2ZXJhZ2UIARhuZXR1aWSgARhOZXRVaWQAAVBib25kc19tb3ZpbmdfYXZlcmFnZRgBDHU2NAAaDORUaGUgZXh0cmluc2ljIHNldHMgdGhlIGJvbmRzIG1vdmluZyBhdmVyYWdlIGZvciBhIHN1Ym5ldC7gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50IG9yIHN1Ym5ldCBvd25lci41AVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgYm9uZHMgbW92aW5nIGF2ZXJhZ2UuWHN1ZG9fc2V0X2JvbmRzX3BlbmFsdHkIARhuZXR1aWSgARhOZXRVaWQAATRib25kc19wZW5hbHR5oAEMdTE2ADwMyFRoZSBleHRyaW5zaWMgc2V0cyB0aGUgYm9uZHMgcGVuYWx0eSBmb3IgYSBzdWJuZXQu4El0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIuGQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIGJvbmRzIHBlbmFsdHkukHN1ZG9fc2V0X21heF9yZWdpc3RyYXRpb25zX3Blcl9ibG9jawgBGG5ldHVpZKABGE5ldFVpZAABbG1heF9yZWdpc3RyYXRpb25zX3Blcl9ibG9ja6ABDHUxNgAbDBEBVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBtYXhpbXVtIHJlZ2lzdHJhdGlvbnMgcGVyIGJsb2NrIGZvciBhIHN1Ym5ldC6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LmEBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBtYXhpbXVtIHJlZ2lzdHJhdGlvbnMgcGVyIGJsb2NrLmRzdWRvX3NldF9zdWJuZXRfb3duZXJfY3V0BAFAc3VibmV0X293bmVyX2N1dKABDHUxNgAcDNRUaGUgZXh0cmluc2ljIHNldHMgdGhlIHN1Ym5ldCBvd25lciBjdXQgZm9yIGEgc3VibmV0LqBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQuJQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIHN1Ym5ldCBvd25lciBjdXQubHN1ZG9fc2V0X25ldHdvcmtfcmF0ZV9saW1pdAQBKHJhdGVfbGltaXQYAQx1NjQAHQzoVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBuZXR3b3JrIHJhdGUgbGltaXQgZm9yIHRoZSBuZXR3b3JrLqBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQuLQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIG5ldHdvcmsgcmF0ZSBsaW1pdC44c3Vkb19zZXRfdGVtcG8IARhuZXR1aWSgARhOZXRVaWQAARR0ZW1wb6ABDHUxNgAeDKhUaGUgZXh0cmluc2ljIHNldHMgdGhlIHRlbXBvIGZvciBhIHN1Ym5ldC6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LvhUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIHRlbXBvLlxzdWRvX3NldF90b3RhbF9pc3N1YW5jZQQBOHRvdGFsX2lzc3VhbmNlGAEoVGFvQmFsYW5jZQAhDNhUaGUgZXh0cmluc2ljIHNldHMgdGhlIHRvdGFsIGlzc3VhbmNlIGZvciB0aGUgbmV0d29yay6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LkUBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBpc3N1YW5jZSBmb3IgdGhlIG5ldHdvcmsugHN1ZG9fc2V0X25ldHdvcmtfaW1tdW5pdHlfcGVyaW9kBAE8aW1tdW5pdHlfcGVyaW9kGAEMdTY0ACMM3FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgaW1tdW5pdHkgcGVyaW9kIGZvciB0aGUgbmV0d29yay6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LmEBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBpbW11bml0eSBwZXJpb2QgZm9yIHRoZSBuZXR3b3JrLnhzdWRvX3NldF9uZXR3b3JrX21pbl9sb2NrX2Nvc3QEASRsb2NrX2Nvc3QYAShUYW9CYWxhbmNlACQM1FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgbWluIGxvY2sgY29zdCBmb3IgdGhlIG5ldHdvcmsuoEl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudC5ZAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgbWluIGxvY2sgY29zdCBmb3IgdGhlIG5ldHdvcmsuVHN1ZG9fc2V0X3N1Ym5ldF9saW1pdAQBLG1heF9zdWJuZXRzoAEMdTE2ACUM0FRoZSBleHRyaW5zaWMgc2V0cyB0aGUgc3VibmV0IGxpbWl0IGZvciB0aGUgbmV0d29yay6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LhUBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBzdWJuZXQgbGltaXQugHN1ZG9fc2V0X2xvY2tfcmVkdWN0aW9uX2ludGVydmFsBAEgaW50ZXJ2YWwYAQx1NjQAJgz8VGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBsb2NrIHJlZHVjdGlvbiBpbnRlcnZhbCBmb3IgdGhlIG5ldHdvcmsuoEl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudC5BAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgbG9jayByZWR1Y3Rpb24gaW50ZXJ2YWwuVHN1ZG9fc2V0X3Jhb19yZWN5Y2xlZAgBGG5ldHVpZKABGE5ldFVpZAABMHJhb19yZWN5Y2xlZBgBKFRhb0JhbGFuY2UAJwzEVGhlIGV4dHJpbnNpYyBzZXRzIHRoZSByZWN5Y2xlZCBSQU8gZm9yIGEgc3VibmV0LqBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQuFQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIHJlY3ljbGVkIFJBTy5gc3Vkb19zZXRfc3Rha2VfdGhyZXNob2xkBAEkbWluX3N0YWtlGAEMdTY0ACoMpFRoZSBleHRyaW5zaWMgc2V0cyB0aGUgd2VpZ2h0cyBtaW4gc3Rha2UuoEl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudC4pAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgd2VpZ2h0cyBtaW4gc3Rha2UulHN1ZG9fc2V0X25vbWluYXRvcl9taW5fcmVxdWlyZWRfc3Rha2UEASRtaW5fc3Rha2UYAQx1NjQAKwz0VGhlIGV4dHJpbnNpYyBzZXRzIHRoZSBtaW5pbXVtIHN0YWtlIHJlcXVpcmVkIGZvciBub21pbmF0b3JzLqBJdCBpcyBvbmx5IGNhbGxhYmxlIGJ5IHRoZSByb290IGFjY291bnQueQFUaGUgZXh0cmluc2ljIHdpbGwgY2FsbCB0aGUgU3VidGVuc29yIHBhbGxldCB0byBzZXQgdGhlIG1pbmltdW0gc3Rha2UgcmVxdWlyZWQgZm9yIG5vbWluYXRvcnMukHN1ZG9fc2V0X3R4X2RlbGVnYXRlX3Rha2VfcmF0ZV9saW1pdAQBNHR4X3JhdGVfbGltaXQYAQx1NjQALQwFAVRoZSBleHRyaW5zaWMgc2V0cyB0aGUgcmF0ZSBsaW1pdCBmb3IgZGVsZWdhdGUgdGFrZSB0cmFuc2FjdGlvbnMuoEl0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudC6JAVRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgcmF0ZSBsaW1pdCBmb3IgZGVsZWdhdGUgdGFrZSB0cmFuc2FjdGlvbnMuaHN1ZG9fc2V0X21pbl9kZWxlZ2F0ZV90YWtlBAEQdGFrZaABDHUxNgAuDLRUaGUgZXh0cmluc2ljIHNldHMgdGhlIG1pbmltdW0gZGVsZWdhdGUgdGFrZS6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LjkBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBtaW5pbXVtIGRlbGVnYXRlIHRha2UumHN1ZG9fc2V0X2NvbW1pdF9yZXZlYWxfd2VpZ2h0c19lbmFibGVkCAEYbmV0dWlkoAEYTmV0VWlkAAEcZW5hYmxlZCQBEGJvb2wAMQwFAVRoZSBleHRyaW5zaWMgZW5hYmxlZC9kaXNhYmxlcyBjb21taXQvcmVhdmVhbCBmb3IgYSBnaXZlbiBzdWJuZXQu4El0IGlzIG9ubHkgY2FsbGFibGUgYnkgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIu+FRoZSBleHRyaW5zaWMgd2lsbCBjYWxsIHRoZSBTdWJ0ZW5zb3IgcGFsbGV0IHRvIHNldCB0aGUgdmFsdWUudHN1ZG9fc2V0X2xpcXVpZF9hbHBoYV9lbmFibGVkCAEYbmV0dWlkoAEYTmV0VWlkAAEcZW5hYmxlZCQBEGJvb2wAMiTQRW5hYmxlcyBvciBkaXNhYmxlcyBMaXF1aWQgQWxwaGEgZm9yIGEgZ2l2ZW4gc3VibmV0LgAwIyBQYXJhbWV0ZXJzTQEtIGBvcmlnaW5gOiBUaGUgb3JpZ2luIG9mIHRoZSBjYWxsLCB3aGljaCBtdXN0IGJlIHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLsQtIGBuZXR1aWRgOiBUaGUgdW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBzdWJuZXQu+C0gYGVuYWJsZWRgOiBBIGJvb2xlYW4gZmxhZyB0byBlbmFibGUgb3IgZGlzYWJsZSBMaXF1aWQgQWxwaGEuACAjIFdlaWdodM0BVGhpcyBmdW5jdGlvbiBoYXMgYSBmaXhlZCB3ZWlnaHQgb2YgMCBhbmQgaXMgY2xhc3NpZmllZCBhcyBhbiBvcGVyYXRpb25hbCB0cmFuc2FjdGlvbiB0aGF0IGRvZXMgbm90IGluY3VyIGFueSBmZWVzLlRzdWRvX3NldF9hbHBoYV92YWx1ZXMMARhuZXR1aWSgARhOZXRVaWQAASRhbHBoYV9sb3egAQx1MTYAAShhbHBoYV9oaWdooAEMdTE2ADMEcFNldHMgdmFsdWVzIGZvciBsaXF1aWQgYWxwaGGsc3Vkb19zZXRfZGlzc29sdmVfbmV0d29ya19zY2hlZHVsZV9kdXJhdGlvbgQBIGR1cmF0aW9uEAFEQmxvY2tOdW1iZXJGb3I8VD4ANzjMU2V0cyB0aGUgZHVyYXRpb24gb2YgdGhlIGRpc3NvbHZlIG5ldHdvcmsgc2NoZWR1bGUuAHUBVGhpcyBleHRyaW5zaWMgYWxsb3dzIHRoZSByb290IGFjY291bnQgdG8gc2V0IHRoZSBkdXJhdGlvbiBmb3IgdGhlIGRpc3NvbHZlIG5ldHdvcmsgc2NoZWR1bGUurQFUaGUgZGlzc29sdmUgbmV0d29yayBzY2hlZHVsZSBkZXRlcm1pbmVzIGhvdyBsb25nIGl0IHRha2VzIGZvciBhIG5ldHdvcmsgZGlzc29sdXRpb24gb3BlcmF0aW9uIHRvIGNvbXBsZXRlLgAsIyBBcmd1bWVudHMRASogYG9yaWdpbmAgLSBUaGUgb3JpZ2luIG9mIHRoZSBjYWxsLCB3aGljaCBtdXN0IGJlIHRoZSByb290IGFjY291bnQuXQEqIGBkdXJhdGlvbmAgLSBUaGUgbmV3IGR1cmF0aW9uIGZvciB0aGUgZGlzc29sdmUgbmV0d29yayBzY2hlZHVsZSwgaW4gbnVtYmVyIG9mIGJsb2Nrcy4AICMgRXJyb3Jz2CogYEJhZE9yaWdpbmAgLSBJZiB0aGUgY2FsbGVyIGlzIG5vdCB0aGUgcm9vdCBhY2NvdW50LgAgIyBXZWlnaHTcV2VpZ2h0IGlzIGhhbmRsZWQgYnkgdGhlIGAjW3BhbGxldDo6d2VpZ2h0XWAgYXR0cmlidXRlLpxzdWRvX3NldF9jb21taXRfcmV2ZWFsX3dlaWdodHNfaW50ZXJ2YWwIARhuZXR1aWSgARhOZXRVaWQAASBpbnRlcnZhbBgBDHU2NAA5QPRTZXRzIHRoZSBjb21taXQtcmV2ZWFsIHdlaWdodHMgcGVyaW9kcyBmb3IgYSBzcGVjaWZpYyBzdWJuZXQuAB0CVGhpcyBleHRyaW5zaWMgYWxsb3dzIHRoZSBzdWJuZXQgb3duZXIgb3Igcm9vdCBhY2NvdW50IHRvIHNldCB0aGUgZHVyYXRpb24gKGluIGVwb2NocykgZHVyaW5nIHdoaWNoIGNvbW1pdHRlZCB3ZWlnaHRzIG11c3QgYmUgcmV2ZWFsZWQu4QFUaGUgY29tbWl0LXJldmVhbCBtZWNoYW5pc20gZW5zdXJlcyB0aGF0IHVzZXJzIGNvbW1pdCB3ZWlnaHRzIGluIGFkdmFuY2UgYW5kIHJldmVhbCB0aGVtIG9ubHkgd2l0aGluIGEgc3BlY2lmaWVkIHBlcmlvZC4ALCMgQXJndW1lbnRzYQEqIGBvcmlnaW5gIC0gVGhlIG9yaWdpbiBvZiB0aGUgY2FsbCwgd2hpY2ggbXVzdCBiZSB0aGUgc3VibmV0IG93bmVyIG9yIHRoZSByb290IGFjY291bnQuVQEqIGBuZXR1aWRgIC0gVGhlIHVuaXF1ZSBpZGVudGlmaWVyIG9mIHRoZSBzdWJuZXQgZm9yIHdoaWNoIHRoZSBwZXJpb2RzIGFyZSBiZWluZyBzZXQuIQEqIGBwZXJpb2RzYCAtIFRoZSBudW1iZXIgb2YgZXBvY2hzIHRoYXQgZGVmaW5lIHRoZSBjb21taXQtcmV2ZWFsIHBlcmlvZC4AICMgRXJyb3JzPQEqIGBCYWRPcmlnaW5gIC0gSWYgdGhlIGNhbGxlciBpcyBuZWl0aGVyIHRoZSBzdWJuZXQgb3duZXIgbm9yIHRoZSByb290IGFjY291bnQuAQEqIGBTdWJuZXREb2VzTm90RXhpc3RgIC0gSWYgdGhlIHNwZWNpZmllZCBzdWJuZXQgZG9lcyBub3QgZXhpc3QuACAjIFdlaWdodNxXZWlnaHQgaXMgaGFuZGxlZCBieSB0aGUgYCNbcGFsbGV0Ojp3ZWlnaHRdYCBhdHRyaWJ1dGUuVHN1ZG9fc2V0X2V2bV9jaGFpbl9pZAQBIGNoYWluX2lkGAEMdTY0ADosVFNldHMgdGhlIEVWTSBDaGFpbklELgAsIyBBcmd1bWVudHNhASogYG9yaWdpbmAgLSBUaGUgb3JpZ2luIG9mIHRoZSBjYWxsLCB3aGljaCBtdXN0IGJlIHRoZSBzdWJuZXQgb3duZXIgb3IgdGhlIHJvb3QgYWNjb3VudC54KiBgY2hhaW5JZGAgLSBUaGUgdTY0IGNoYWluIElEACAjIEVycm9ycz0BKiBgQmFkT3JpZ2luYCAtIElmIHRoZSBjYWxsZXIgaXMgbmVpdGhlciB0aGUgc3VibmV0IG93bmVyIG5vciB0aGUgcm9vdCBhY2NvdW50LgAgIyBXZWlnaHTcV2VpZ2h0IGlzIGhhbmRsZWQgYnkgdGhlIGAjW3BhbGxldDo6d2VpZ2h0XWAgYXR0cmlidXRlLlxzY2hlZHVsZV9ncmFuZHBhX2NoYW5nZQwBQG5leHRfYXV0aG9yaXRpZXOEATRBdXRob3JpdHlMaXN0AAEkaW5fYmxvY2tzEAFEQmxvY2tOdW1iZXJGb3I8VD4AARhmb3JjZWTMAWRPcHRpb248QmxvY2tOdW1iZXJGb3I8VD4+ADs8JQFBIHB1YmxpYyBpbnRlcmZhY2UgZm9yIGBwYWxsZXRfZ3JhbmRwYTo6UGFsbGV0OjpzY2hlZHVsZV9ncmFuZHBhX2NoYW5nZWAuAJRTY2hlZHVsZSBhIGNoYW5nZSBpbiB0aGUgYXV0aG9yaXRpZXMuAFUBVGhlIGNoYW5nZSB3aWxsIGJlIGFwcGxpZWQgYXQgdGhlIGVuZCBvZiBleGVjdXRpb24gb2YgdGhlIGJsb2NrIGBpbl9ibG9ja3NgIGFmdGVyIHRoZVUBY3VycmVudCBibG9jay4gVGhpcyB2YWx1ZSBtYXkgYmUgMCwgaW4gd2hpY2ggY2FzZSB0aGUgY2hhbmdlIGlzIGFwcGxpZWQgYXQgdGhlIGVuZCBvZkh0aGUgY3VycmVudCBibG9jay4ASQFJZiB0aGUgYGZvcmNlZGAgcGFyYW1ldGVyIGlzIGRlZmluZWQsIHRoaXMgaW5kaWNhdGVzIHRoYXQgdGhlIGN1cnJlbnQgc2V0IGhhcyBiZWVuSQFzeW5jaHJvbm91c2x5IGRldGVybWluZWQgdG8gYmUgb2ZmbGluZSBhbmQgdGhhdCBhZnRlciBgaW5fYmxvY2tzYCB0aGUgZ2l2ZW4gY2hhbmdlTQFzaG91bGQgYmUgYXBwbGllZC4gVGhlIGdpdmVuIGJsb2NrIG51bWJlciBpbmRpY2F0ZXMgdGhlIG1lZGlhbiBsYXN0IGZpbmFsaXplZCBibG9ja1EBbnVtYmVyIGFuZCBpdCBzaG91bGQgYmUgdXNlZCBhcyB0aGUgY2Fub24gYmxvY2sgd2hlbiBzdGFydGluZyB0aGUgbmV3IGdyYW5kcGEgdm90ZXIuAFkBTm8gY2hhbmdlIHNob3VsZCBiZSBzaWduYWxlZCB3aGlsZSBhbnkgY2hhbmdlIGlzIHBlbmRpbmcuIFJldHVybnMgYW4gZXJyb3IgaWYgYSBjaGFuZ2VMaXMgYWxyZWFkeSBwZW5kaW5nLmBzdWRvX3NldF90b2dnbGVfdHJhbnNmZXIIARhuZXR1aWSgARhOZXRVaWQAARh0b2dnbGUkARBib29sAD0k8EVuYWJsZSBvciBkaXNhYmxlIGF0b21pYyBhbHBoYSB0cmFuc2ZlcnMgZm9yIGEgZ2l2ZW4gc3VibmV0LgAwIyBQYXJhbWV0ZXJzTQEtIGBvcmlnaW5gOiBUaGUgb3JpZ2luIG9mIHRoZSBjYWxsLCB3aGljaCBtdXN0IGJlIHRoZSByb290IGFjY291bnQgb3Igc3VibmV0IG93bmVyLsQtIGBuZXR1aWRgOiBUaGUgdW5pcXVlIGlkZW50aWZpZXIgZm9yIHRoZSBzdWJuZXQu+C0gYGVuYWJsZWRgOiBBIGJvb2xlYW4gZmxhZyB0byBlbmFibGUgb3IgZGlzYWJsZSBMaXF1aWQgQWxwaGEuACAjIFdlaWdodM0BVGhpcyBmdW5jdGlvbiBoYXMgYSBmaXhlZCB3ZWlnaHQgb2YgMCBhbmQgaXMgY2xhc3NpZmllZCBhcyBhbiBvcGVyYXRpb25hbCB0cmFuc2FjdGlvbiB0aGF0IGRvZXMgbm90IGluY3VyIGFueSBmZWVzLmBzdWRvX3NldF9yZWN5Y2xlX29yX2J1cm4IARhuZXR1aWSgARhOZXRVaWQAATxyZWN5Y2xlX29yX2J1cm7tBAGMcGFsbGV0X3N1YnRlbnNvcjo6UmVjeWNsZU9yQnVybkVudW0AUCToU2V0IHRoZSBiZWhhdmlvdXIgb2YgdGhlICJidXJuIiBVSUQocykgZm9yIGEgZ2l2ZW4gc3VibmV0LjEBSWYgc2V0IHRvIGBCdXJuYCwgdGhlIG1pbmVyIGVtaXNzaW9uIHNlbnQgdG8gdGhlIGJ1cm4gVUlEKHMpIHdpbGwgYmUgYnVybmVkLkUBSWYgc2V0IHRvIGBSZWN5Y2xlYCwgdGhlIG1pbmVyIGVtaXNzaW9uIHNlbnQgdG8gdGhlIGJ1cm4gVUlEKHMpIHdpbGwgYmUgcmVjeWNsZWQuADAjIFBhcmFtZXRlcnNNAS0gYG9yaWdpbmA6IFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIHdoaWNoIG11c3QgYmUgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIuxC0gYG5ldHVpZGA6IFRoZSB1bmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIHN1Ym5ldC49AS0gYHJlY3ljbGVfb3JfYnVybmA6IFRoZSBkZXNpcmVkIGJlaGF2aW91ciBvZiB0aGUgImJ1cm4iIFVJRChzKSBmb3IgdGhlIHN1Ym5ldC4AaHN1ZG9fdG9nZ2xlX2V2bV9wcmVjb21waWxlCAE0cHJlY29tcGlsZV9pZB0BAThQcmVjb21waWxlRW51bQABHGVuYWJsZWQkARBib29sAD4wsFRvZ2dsZXMgdGhlIGVuYWJsZW1lbnQgb2YgYW4gRVZNIHByZWNvbXBpbGUuACwjIEFyZ3VtZW50cxEBKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIHdoaWNoIG11c3QgYmUgdGhlIHJvb3QgYWNjb3VudC4NASogYHByZWNvbXBpbGVfaWRgIC0gVGhlIGlkZW50aWZpZXIgb2YgdGhlIEVWTSBwcmVjb21waWxlIHRvIHRvZ2dsZS7kKiBgZW5hYmxlZGAgLSBUaGUgbmV3IGVuYWJsZW1lbnQgc3RhdGUgb2YgdGhlIHByZWNvbXBpbGUuACAjIEVycm9yc9gqIGBCYWRPcmlnaW5gIC0gSWYgdGhlIGNhbGxlciBpcyBub3QgdGhlIHJvb3QgYWNjb3VudC4AICMgV2VpZ2h03FdlaWdodCBpcyBoYW5kbGVkIGJ5IHRoZSBgI1twYWxsZXQ6OndlaWdodF1gIGF0dHJpYnV0ZS5wc3Vkb19zZXRfc3VibmV0X21vdmluZ19hbHBoYQQBFGFscGhh8QQBGEk5NkYzMgA/LAAALCMgQXJndW1lbnRzEQEqIGBvcmlnaW5gIC0gVGhlIG9yaWdpbiBvZiB0aGUgY2FsbCwgd2hpY2ggbXVzdCBiZSB0aGUgcm9vdCBhY2NvdW50LgUBKiBgYWxwaGFgIC0gVGhlIG5ldyBtb3ZpbmcgYWxwaGEgdmFsdWUgZm9yIHRoZSBTdWJuZXRNb3ZpbmdBbHBoYS4AICMgRXJyb3Jz2CogYEJhZE9yaWdpbmAgLSBJZiB0aGUgY2FsbGVyIGlzIG5vdCB0aGUgcm9vdCBhY2NvdW50LgAgIyBXZWlnaHTcV2VpZ2h0IGlzIGhhbmRsZWQgYnkgdGhlIGAjW3BhbGxldDo6d2VpZ2h0XWAgYXR0cmlidXRlLnBzdWRvX3NldF9zdWJuZXRfb3duZXJfaG90a2V5CAEYbmV0dWlkoAEYTmV0VWlkAAEYaG90a2V5AAGYPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+OjpBY2NvdW50SWQAQDDAQ2hhbmdlIHRoZSBTdWJuZXRPd25lckhvdGtleSBmb3IgYSBnaXZlbiBzdWJuZXQuACwjIEFyZ3VtZW50cxEBKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIHdoaWNoIG11c3QgYmUgdGhlIHN1Ym5ldCBvd25lci7IKiBgbmV0dWlkYCAtIFRoZSB1bmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIHN1Ym5ldC7EKiBgaG90a2V5YCAtIFRoZSBuZXcgaG90a2V5IGZvciB0aGUgc3VibmV0IG93bmVyLgAgIyBFcnJvcnMZASogYEJhZE9yaWdpbmAgLSBJZiB0aGUgY2FsbGVyIGlzIG5vdCB0aGUgc3VibmV0IG93bmVyIG9yIHJvb3QgYWNjb3VudC4AICMgV2VpZ2h03FdlaWdodCBpcyBoYW5kbGVkIGJ5IHRoZSBgI1twYWxsZXQ6OndlaWdodF1gIGF0dHJpYnV0ZS6Ec3Vkb19zZXRfZW1hX3ByaWNlX2hhbHZpbmdfcGVyaW9kCAEYbmV0dWlkoAEYTmV0VWlkAAEsZW1hX2hhbHZpbmcYAQx1NjQAQSwAACwjIEFyZ3VtZW50cxEBKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIHdoaWNoIG11c3QgYmUgdGhlIHJvb3QgYWNjb3VudC74KiBgZW1hX2FscGhhX3BlcmlvZGAgLSBOdW1iZXIgb2YgYmxvY2tzIGZvciBFTUEgcHJpY2UgdG8gaGFsdmUAICMgRXJyb3Jz2CogYEJhZE9yaWdpbmAgLSBJZiB0aGUgY2FsbGVyIGlzIG5vdCB0aGUgcm9vdCBhY2NvdW50LgAgIyBXZWlnaHTcV2VpZ2h0IGlzIGhhbmRsZWQgYnkgdGhlIGAjW3BhbGxldDo6d2VpZ2h0XWAgYXR0cmlidXRlLoBzdWRvX3NldF9hbHBoYV9zaWdtb2lkX3N0ZWVwbmVzcwgBGG5ldHVpZKABGE5ldFVpZAABJHN0ZWVwbmVzc6QBDGkxNgBEPAAALCMgQXJndW1lbnRzEQEqIGBvcmlnaW5gIC0gVGhlIG9yaWdpbiBvZiB0aGUgY2FsbCwgd2hpY2ggbXVzdCBiZSB0aGUgcm9vdCBhY2NvdW50LsgqIGBuZXR1aWRgIC0gVGhlIHVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgc3VibmV0LlUBKiBgc3RlZXBuZXNzYCAtIFRoZSBTdGVlcG5lc3MgZm9yIHRoZSBhbHBoYSBzaWdtb2lkIGZ1bmN0aW9uLiAocmFuZ2UgaXMgMC1pbnQxNjo6TUFYLLBuZWdhdGl2ZSB2YWx1ZXMgYXJlIHJlc2VydmVkIGZvciBmdXR1cmUgdXNlKQAgIyBFcnJvcnPYKiBgQmFkT3JpZ2luYCAtIElmIHRoZSBjYWxsZXIgaXMgbm90IHRoZSByb290IGFjY291bnQuAQEqIGBTdWJuZXREb2VzTm90RXhpc3RgIC0gSWYgdGhlIHNwZWNpZmllZCBzdWJuZXQgZG9lcyBub3QgZXhpc3QuNQEqIGBOZWdhdGl2ZVNpZ21vaWRTdGVlcG5lc3NgIC0gSWYgdGhlIHN0ZWVwbmVzcyBpcyBuZWdhdGl2ZSBhbmQgdGhlIGNhbGxlciBpcxRyb290LiAjIFdlaWdodNxXZWlnaHQgaXMgaGFuZGxlZCBieSB0aGUgYCNbcGFsbGV0Ojp3ZWlnaHRdYCBhdHRyaWJ1dGUuWHN1ZG9fc2V0X3l1bWEzX2VuYWJsZWQIARhuZXR1aWSgARhOZXRVaWQAARxlbmFibGVkJAEQYm9vbABFJLRFbmFibGVzIG9yIGRpc2FibGVzIFl1bWEzIGZvciBhIGdpdmVuIHN1Ym5ldC4AMCMgUGFyYW1ldGVyc00BLSBgb3JpZ2luYDogVGhlIG9yaWdpbiBvZiB0aGUgY2FsbCwgd2hpY2ggbXVzdCBiZSB0aGUgcm9vdCBhY2NvdW50IG9yIHN1Ym5ldCBvd25lci7ELSBgbmV0dWlkYDogVGhlIHVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgc3VibmV0LtwtIGBlbmFibGVkYDogQSBib29sZWFuIGZsYWcgdG8gZW5hYmxlIG9yIGRpc2FibGUgWXVtYTMuACAjIFdlaWdodM0BVGhpcyBmdW5jdGlvbiBoYXMgYSBmaXhlZCB3ZWlnaHQgb2YgMCBhbmQgaXMgY2xhc3NpZmllZCBhcyBhbiBvcGVyYXRpb25hbCB0cmFuc2FjdGlvbiB0aGF0IGRvZXMgbm90IGluY3VyIGFueSBmZWVzLnBzdWRvX3NldF9ib25kc19yZXNldF9lbmFibGVkCAEYbmV0dWlkoAEYTmV0VWlkAAEcZW5hYmxlZCQBEGJvb2wARiTMRW5hYmxlcyBvciBkaXNhYmxlcyBCb25kcyBSZXNldCBmb3IgYSBnaXZlbiBzdWJuZXQuADAjIFBhcmFtZXRlcnNNAS0gYG9yaWdpbmA6IFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIHdoaWNoIG11c3QgYmUgdGhlIHJvb3QgYWNjb3VudCBvciBzdWJuZXQgb3duZXIuxC0gYG5ldHVpZGA6IFRoZSB1bmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIHN1Ym5ldC70LSBgZW5hYmxlZGA6IEEgYm9vbGVhbiBmbGFnIHRvIGVuYWJsZSBvciBkaXNhYmxlIEJvbmRzIFJlc2V0LgAgIyBXZWlnaHTNAVRoaXMgZnVuY3Rpb24gaGFzIGEgZml4ZWQgd2VpZ2h0IG9mIDAgYW5kIGlzIGNsYXNzaWZpZWQgYXMgYW4gb3BlcmF0aW9uYWwgdHJhbnNhY3Rpb24gdGhhdCBkb2VzIG5vdCBpbmN1ciBhbnkgZmVlcy5gc3Vkb19zZXRfc25fb3duZXJfaG90a2V5CAEYbmV0dWlkoAEYTmV0VWlkAAEYaG90a2V5AAGYPFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+OjpBY2NvdW50SWQAQ3hJAVNldHMgb3IgdXBkYXRlcyB0aGUgaG90a2V5IGFjY291bnQgYXNzb2NpYXRlZCB3aXRoIHRoZSBvd25lciBvZiBhIHNwZWNpZmljIHN1Ym5ldC4AYQFUaGlzIGZ1bmN0aW9uIGFsbG93cyBlaXRoZXIgdGhlIHJvb3Qgb3JpZ2luIG9yIHRoZSBjdXJyZW50IHN1Ym5ldCBvd25lciB0byBzZXQgb3IgdXBkYXRlbQF0aGUgaG90a2V5IGZvciBhIGdpdmVuIHN1Ym5ldC4gVGhlIHN1Ym5ldCBtdXN0IGFscmVhZHkgZXhpc3QuIFRvIHByZXZlbnQgYWJ1c2UsIHRoZSBjYWxsIGlzMQFyYXRlLWxpbWl0ZWQgdG8gb25jZSBwZXIgY29uZmlndXJlZCBpbnRlcnZhbCAoZGVmYXVsdDogb25lIHdlZWspIHBlciBzdWJuZXQuADAjIFBhcmFtZXRlcnORAS0gYG9yaWdpbmA6IFRoZSBkaXNwYXRjaCBvcmlnaW4gb2YgdGhlIGNhbGwuIE11c3QgYmUgZWl0aGVyIHJvb3Qgb3IgdGhlIGN1cnJlbnQgb3duZXIgb2YgdGhlIHN1Ym5ldC5BAS0gYG5ldHVpZGA6IFRoZSB1bmlxdWUgaWRlbnRpZmllciBvZiB0aGUgc3VibmV0IHdob3NlIG93bmVyIGhvdGtleSBpcyBiZWluZyBzZXQuGQEtIGBob3RrZXlgOiBUaGUgbmV3IGhvdGtleSBhY2NvdW50IHRvIGFzc29jaWF0ZSB3aXRoIHRoZSBzdWJuZXQgb3duZXIuACQjIFJldHVybnOtAS0gYERpc3BhdGNoUmVzdWx0YDogUmV0dXJucyBgT2soKCkpYCBpZiB0aGUgaG90a2V5IHdhcyBzdWNjZXNzZnVsbHkgc2V0LCBvciBhbiBhcHByb3ByaWF0ZSBlcnJvciBvdGhlcndpc2UuACAjIEVycm9ycw0BLSBgRXJyb3I6OlN1Ym5ldE5vdEV4aXN0c2A6IElmIHRoZSBzcGVjaWZpZWQgc3VibmV0IGRvZXMgbm90IGV4aXN0LpkBLSBgRXJyb3I6OlR4UmF0ZUxpbWl0RXhjZWVkZWRgOiBJZiB0aGUgZnVuY3Rpb24gaXMgY2FsbGVkIG1vcmUgZnJlcXVlbnRseSB0aGFuIHRoZSBhbGxvd2VkIHJhdGUgbGltaXQuAEAjIEFjY2VzcyBDb250cm9sRE9ubHkgY2FsbGFibGUgYnk6RC0gUm9vdCBvcmlnaW4sIG9yrC0gVGhlIGNvbGRrZXkgYWNjb3VudCB0aGF0IG93bnMgdGhlIHN1Ym5ldC4AJCMgU3RvcmFnZdwtIFVwZGF0ZXMgW2BTdWJuZXRPd25lckhvdGtleWBdIGZvciB0aGUgZ2l2ZW4gYG5ldHVpZGAu/C0gUmVhZHMgYW5kIHVwZGF0ZXMgW2BMYXN0UmF0ZUxpbWl0ZWRCbG9ja2BdIGZvciByYXRlLWxpbWl0aW5nLn0BLSBSZWFkcyBbYERlZmF1bHRTZXRTTk93bmVySG90a2V5UmF0ZUxpbWl0YF0gdG8gZGV0ZXJtaW5lIHRoZSBpbnRlcnZhbCBiZXR3ZWVuIGFsbG93ZWQgdXBkYXRlcy4APCMgUmF0ZSBMaW1pdGluZ00BVGhpcyBmdW5jdGlvbiBpcyByYXRlLWxpbWl0ZWQgdG8gb25lIGNhbGwgcGVyIHN1Ym5ldCBwZXIgaW50ZXJ2YWwgKGUuZy4sIG9uZSB3ZWVrKS5kc3Vkb19zZXRfc3VidG9rZW5fZW5hYmxlZAgBGG5ldHVpZKABGE5ldFVpZAABQHN1YnRva2VuX2VuYWJsZWQkARBib29sAEIw4EVuYWJsZXMgb3IgZGlzYWJsZXMgc3VidG9rZW4gdHJhZGluZyBmb3IgYSBnaXZlbiBzdWJuZXQuACwjIEFyZ3VtZW50cxEBKiBgb3JpZ2luYCAtIFRoZSBvcmlnaW4gb2YgdGhlIGNhbGwsIHdoaWNoIG11c3QgYmUgdGhlIHJvb3QgYWNjb3VudC7EKiBgbmV0dWlkYCAtIFRoZSB1bmlxdWUgaWRlbnRpZmllciBvZiB0aGUgc3VibmV0Lo0BKiBgc3VidG9rZW5fZW5hYmxlZGAgLSBBIGJvb2xlYW4gaW5kaWNhdGluZyB3aGV0aGVyIHN1YnRva2VuIHRyYWRpbmcgc2hvdWxkIGJlIGVuYWJsZWQgb3IgZGlzYWJsZWQuACAjIEVycm9yc9gqIGBCYWRPcmlnaW5gIC0gSWYgdGhlIGNhbGxlciBpcyBub3QgdGhlIHJvb3QgYWNjb3VudC4AICMgV2VpZ2h03FdlaWdodCBpcyBoYW5kbGVkIGJ5IHRoZSBgI1twYWxsZXQ6OndlaWdodF1gIGF0dHJpYnV0ZS54c3Vkb19zZXRfY29tbWl0X3JldmVhbF92ZXJzaW9uBAEcdmVyc2lvbqABDHUxNgBHBNhTZXRzIHRoZSBjb21taXQtcmV2ZWFsIHdlaWdodHMgdmVyc2lvbiBmb3IgYWxsIHN1Ym5ldHOIc3Vkb19zZXRfb3duZXJfaW1tdW5lX25ldXJvbl9saW1pdAgBGG5ldHVpZKABGE5ldFVpZAABOGltbXVuZV9uZXVyb25zoAEMdTE2AEgEnFNldHMgdGhlIG51bWJlciBvZiBpbW11bmUgb3duZXIgbmV1cm9uc0BzdWRvX3NldF9ja19idXJuBAEQYnVybhgBDHU2NABJDJBTZXRzIHRoZSBjaGlsZGtleSBidXJuIGZvciBhIHN1Ym5ldC6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LhkBVGhlIGV4dHJpbnNpYyB3aWxsIGNhbGwgdGhlIFN1YnRlbnNvciBwYWxsZXQgdG8gc2V0IHRoZSBjaGlsZGtleSBidXJuLnBzdWRvX3NldF9hZG1pbl9mcmVlemVfd2luZG93BAEYd2luZG93oAEMdTE2AEoIGQFTZXRzIHRoZSBhZG1pbiBmcmVlemUgd2luZG93IGxlbmd0aCAoaW4gYmxvY2tzKSBhdCB0aGUgZW5kIG9mIGEgdGVtcG8uWE9ubHkgY2FsbGFibGUgYnkgcm9vdC6Ac3Vkb19zZXRfb3duZXJfaHBhcmFtX3JhdGVfbGltaXQEARhlcG9jaHOgAQx1MTYASwgdAVNldHMgdGhlIG93bmVyIGh5cGVycGFyYW1ldGVyIHJhdGUgbGltaXQgaW4gZXBvY2hzIChnbG9iYWwgbXVsdGlwbGllcikuWE9ubHkgY2FsbGFibGUgYnkgcm9vdC5gc3Vkb19zZXRfbWVjaGFuaXNtX2NvdW50CAEYbmV0dWlkoAEYTmV0VWlkAAE8bWVjaGFuaXNtX2NvdW50CAEYTWVjaElkAEwExFNldHMgdGhlIGRlc2lyZWQgbnVtYmVyIG9mIG1lY2hhbmlzbXMgaW4gYSBzdWJuZXSEc3Vkb19zZXRfbWVjaGFuaXNtX2VtaXNzaW9uX3NwbGl0CAEYbmV0dWlkoAEYTmV0VWlkAAEsbWF5YmVfc3BsaXQdBQFAT3B0aW9uPFZlYzx1MTY+PgBNBNhTZXRzIHRoZSBlbWlzc2lvbiBzcGxpdCBiZXR3ZWVuIG1lY2hhbmlzbXMgaW4gYSBzdWJuZXR0c3Vkb190cmltX3RvX21heF9hbGxvd2VkX3VpZHMIARhuZXR1aWSgARhOZXRVaWQAARRtYXhfbqABDHUxNgBOFLhUcmltcyB0aGUgbWF4aW11bSBudW1iZXIgb2YgVUlEcyBmb3IgYSBzdWJuZXQuAEUBVGhlIHRyaW1taW5nIGlzIGRvbmUgYnkgc29ydGluZyB0aGUgVUlEcyBieSBlbWlzc2lvbiBkZXNjZW5kaW5nIGFuZCB0aGVuIHRyaW1taW5nTQF0aGUgbG93ZXN0IGVtaXR0ZXJzIHdoaWxlIHByZXNlcnZpbmcgdGVtcG9yYWxseSBhbmQgb3duZXIgaW1tdW5lIFVJRHMuIFRoZSBVSURzIGFyZT0BdGhlbiBjb21wcmVzc2VkIHRvIHRoZSBsZWZ0IGFuZCBzdG9yYWdlIGlzIG1pZ3JhdGVkIHRvIHRoZSBuZXcgY29tcHJlc3NlZCBVSURzLmRzdWRvX3NldF9taW5fYWxsb3dlZF91aWRzCAEYbmV0dWlkoAEYTmV0VWlkAAFAbWluX2FsbG93ZWRfdWlkc6ABDHUxNgBPCORUaGUgZXh0cmluc2ljIHNldHMgdGhlIG1pbmltdW0gYWxsb3dlZCBVSURzIGZvciBhIHN1Ym5ldC6gSXQgaXMgb25seSBjYWxsYWJsZSBieSB0aGUgcm9vdCBhY2NvdW50LmBzdWRvX3NldF90YW9fZmxvd19jdXRvZmYEASxmbG93X2N1dG9mZiEFARhJNjRGNjQAUQR4U2V0cyBUQU8gZmxvdyBjdXRvZmYgdmFsdWUgKEEpoHN1ZG9fc2V0X3Rhb19mbG93X25vcm1hbGl6YXRpb25fZXhwb25lbnQEASBleHBvbmVudCkFARhVNjRGNjQAUgSgU2V0cyBUQU8gZmxvdyBub3JtYWxpemF0aW9uIGV4cG9uZW50IChwKYhzdWRvX3NldF90YW9fZmxvd19zbW9vdGhpbmdfZmFjdG9yBAFAc21vb3RoaW5nX2ZhY3RvchgBDHU2NABTBJhTZXRzIFRBTyBmbG93IHNtb290aGluZyBmYWN0b3IgKGFscGhhKXBzdWRvX3NldF9tYXhfbWVjaGFuaXNtX2NvdW50BAFMbWF4X21lY2hhbmlzbV9jb3VudAgBGE1lY2hJZABYBOBTZXRzIHRoZSBnbG9iYWwgbWF4aW11bSBudW1iZXIgb2YgbWVjaGFuaXNtcyBpbiBhIHN1Ym5ldHBzdWRvX3NldF9taW5fbm9uX2ltbXVuZV91aWRzCAEYbmV0dWlkoAEYTmV0VWlkAAEMbWluoAEMdTE2AFQEWQFTZXRzIHRoZSBtaW5pbXVtIG51bWJlciBvZiBub24taW1tb3J0YWwgJiBub24taW1tdW5lIFVJRHMgdGhhdCBtdXN0IHJlbWFpbiBpbiBhIHN1Ym5ldGRzdWRvX3NldF9zdGFydF9jYWxsX2RlbGF5BAEUZGVsYXkYAQx1NjQAVQS0U2V0cyB0aGUgZGVsYXkgYmVmb3JlIGEgc3VibmV0IGNhbiBjYWxsIHN0YXJ0oHN1ZG9fc2V0X2NvbGRrZXlfc3dhcF9hbm5vdW5jZW1lbnRfZGVsYXkEASBkdXJhdGlvbhABREJsb2NrTnVtYmVyRm9yPFQ+AFYEtFNldHMgdGhlIGFubm91bmNlbWVudCBkZWxheSBmb3IgY29sZGtleSBzd2FwLqhzdWRvX3NldF9jb2xka2V5X3N3YXBfcmVhbm5vdW5jZW1lbnRfZGVsYXkEASBkdXJhdGlvbhABREJsb2NrTnVtYmVyRm9yPFQ+AFcErFNldHMgdGhlIGNvbGRrZXkgc3dhcCByZWFubm91bmNlbWVudCBkZWxheS4EZQFEaXNwYXRjaGFibGUgZnVuY3Rpb25zIGFsbG93cyB1c2VycyB0byBpbnRlcmFjdCB3aXRoIHRoZSBwYWxsZXQgYW5kIGludm9rZSBzdGF0ZSBjaGFuZ2VzLuEEDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQB5QQEUwAABADpBAEYVmVjPFQ+AADlBBBEc3BfY29uc2Vuc3VzX2F1cmEcc3IyNTUxOSxhcHBfc3IyNTUxORhQdWJsaWMAAAQABAE8c3IyNTUxOTo6UHVibGljAADpBAAAAuUEAO0EDEBwYWxsZXRfc3VidGVuc29yGHBhbGxldERSZWN5Y2xlT3JCdXJuRW51bQABCBBCdXJuAAAAHFJlY3ljbGUAAQAA8QQIPHN1YnN0cmF0ZV9maXhlZCRGaXhlZEkxMjgEEEZyYWMB9QQABAEQYml0cxkFARBpMTI4AAD1BAxEc3Vic3RyYXRlX3R5cGVudW0QdWludBBVSW50CARVAfkEBEIBFQUACAEMbXNi+QQBBFUAAQxsc2IVBQEEQgAA+QQMRHN1YnN0cmF0ZV90eXBlbnVtEHVpbnQQVUludAgEVQH9BARCARUFAAgBDG1zYv0EAQRVAAEMbHNiFQUBBEIAAP0EDERzdWJzdHJhdGVfdHlwZW51bRB1aW50EFVJbnQIBFUBAQUEQgEVBQAIAQxtc2IBBQEEVQABDGxzYhUFAQRCAAABBQxEc3Vic3RyYXRlX3R5cGVudW0QdWludBBVSW50CARVAQUFBEIBFQUACAEMbXNiBQUBBFUAAQxsc2IVBQEEQgAABQUMRHN1YnN0cmF0ZV90eXBlbnVtEHVpbnQQVUludAgEVQEJBQRCARUFAAgBDG1zYgkFAQRVAAEMbHNiFQUBBEIAAAkFDERzdWJzdHJhdGVfdHlwZW51bRB1aW50EFVJbnQIBFUBDQUEQgERBQAIAQxtc2INBQEEVQABDGxzYhEFAQRCAAANBQxEc3Vic3RyYXRlX3R5cGVudW0QdWludBRVVGVybQAAAAARBQxEc3Vic3RyYXRlX3R5cGVudW0MYml0CEIxAAAAABUFDERzdWJzdHJhdGVfdHlwZW51bQxiaXQIQjAAAAAAGQUAAAUNAB0FBBhPcHRpb24EBFQBTQIBCBBOb25lAAAAEFNvbWUEAE0CAAABAAAhBQg8c3Vic3RyYXRlX2ZpeGVkJEZpeGVkSTEyOAQQRnJhYwElBQAEARBiaXRzGQUBEGkxMjgAACUFDERzdWJzdHJhdGVfdHlwZW51bRB1aW50EFVJbnQIBFUB9QQEQgEVBQAIAQxtc2L1BAEEVQABDGxzYhUFAQRCAAApBQg8c3Vic3RyYXRlX2ZpeGVkJEZpeGVkVTEyOAQQRnJhYwElBQAEARBiaXRzIAEQdTEyOAAALQUMQHBhbGxldF9zYWZlX21vZGUYcGFsbGV0EENhbGwEBFQAASAUZW50ZXIAABgZAUVudGVyIHNhZmUtbW9kZSBwZXJtaXNzaW9ubGVzc2x5IGZvciBbYENvbmZpZzo6RW50ZXJEdXJhdGlvbmBdIGJsb2Nrcy4ACQFSZXNlcnZlcyBbYENvbmZpZzo6RW50ZXJEZXBvc2l0QW1vdW50YF0gZnJvbSB0aGUgY2FsbGVyJ3MgYWNjb3VudC60RW1pdHMgYW4gW2BFdmVudDo6RW50ZXJlZGBdIGV2ZW50IG9uIHN1Y2Nlc3MuDQFFcnJvcnMgd2l0aCBbYEVycm9yOjpFbnRlcmVkYF0gaWYgdGhlIHNhZmUtbW9kZSBpcyBhbHJlYWR5IGVudGVyZWQuFQFFcnJvcnMgd2l0aCBbYEVycm9yOjpOb3RDb25maWd1cmVkYF0gaWYgdGhlIGRlcG9zaXQgYW1vdW50IGlzIGBOb25lYC4sZm9yY2VfZW50ZXIAARgZAUVudGVyIHNhZmUtbW9kZSBieSBmb3JjZSBmb3IgYSBwZXItb3JpZ2luIGNvbmZpZ3VyZWQgbnVtYmVyIG9mIGJsb2Nrcy4AtEVtaXRzIGFuIFtgRXZlbnQ6OkVudGVyZWRgXSBldmVudCBvbiBzdWNjZXNzLg0BRXJyb3JzIHdpdGggW2BFcnJvcjo6RW50ZXJlZGBdIGlmIHRoZSBzYWZlLW1vZGUgaXMgYWxyZWFkeSBlbnRlcmVkLgD4Q2FuIG9ubHkgYmUgY2FsbGVkIGJ5IHRoZSBbYENvbmZpZzo6Rm9yY2VFbnRlck9yaWdpbmBdIG9yaWdpbi4YZXh0ZW5kAAIsMQFFeHRlbmQgdGhlIHNhZmUtbW9kZSBwZXJtaXNzaW9ubGVzc2x5IGZvciBbYENvbmZpZzo6RXh0ZW5kRHVyYXRpb25gXSBibG9ja3MuAOhUaGlzIGFjY3VtdWxhdGVzIG9uIHRvcCBvZiB0aGUgY3VycmVudCByZW1haW5pbmcgZHVyYXRpb24uDQFSZXNlcnZlcyBbYENvbmZpZzo6RXh0ZW5kRGVwb3NpdEFtb3VudGBdIGZyb20gdGhlIGNhbGxlcidzIGFjY291bnQuuEVtaXRzIGFuIFtgRXZlbnQ6OkV4dGVuZGVkYF0gZXZlbnQgb24gc3VjY2Vzcy7oRXJyb3JzIHdpdGggW2BFcnJvcjo6RXhpdGVkYF0gaWYgdGhlIHNhZmUtbW9kZSBpcyBlbnRlcmVkLhUBRXJyb3JzIHdpdGggW2BFcnJvcjo6Tm90Q29uZmlndXJlZGBdIGlmIHRoZSBkZXBvc2l0IGFtb3VudCBpcyBgTm9uZWAuAEUBVGhpcyBtYXkgYmUgY2FsbGVkIGJ5IGFueSBzaWduZWQgb3JpZ2luIHdpdGggW2BDb25maWc6OkV4dGVuZERlcG9zaXRBbW91bnRgXSBmcmVlNQFjdXJyZW5jeSB0byByZXNlcnZlLiBUaGlzIGNhbGwgY2FuIGJlIGRpc2FibGVkIGZvciBhbGwgb3JpZ2lucyBieSBjb25maWd1cmluZ6hbYENvbmZpZzo6RXh0ZW5kRGVwb3NpdEFtb3VudGBdIHRvIGBOb25lYC4wZm9yY2VfZXh0ZW5kAAMYLQFFeHRlbmQgdGhlIHNhZmUtbW9kZSBieSBmb3JjZSBmb3IgYSBwZXItb3JpZ2luIGNvbmZpZ3VyZWQgbnVtYmVyIG9mIGJsb2Nrcy4AuEVtaXRzIGFuIFtgRXZlbnQ6OkV4dGVuZGVkYF0gZXZlbnQgb24gc3VjY2Vzcy7sRXJyb3JzIHdpdGggW2BFcnJvcjo6RXhpdGVkYF0gaWYgdGhlIHNhZmUtbW9kZSBpcyBpbmFjdGl2ZS4A/ENhbiBvbmx5IGJlIGNhbGxlZCBieSB0aGUgW2BDb25maWc6OkZvcmNlRXh0ZW5kT3JpZ2luYF0gb3JpZ2luLihmb3JjZV9leGl0AAQkYEV4aXQgc2FmZS1tb2RlIGJ5IGZvcmNlLgAdAUVtaXRzIGFuIFtgRXZlbnQ6OkV4aXRlZGBdIHdpdGggW2BFeGl0UmVhc29uOjpGb3JjZWBdIGV2ZW50IG9uIHN1Y2Nlc3Mu7EVycm9ycyB3aXRoIFtgRXJyb3I6OkV4aXRlZGBdIGlmIHRoZSBzYWZlLW1vZGUgaXMgaW5hY3RpdmUuAFUBTm90ZTogYHNhZmUtbW9kZWAgd2lsbCBiZSBhdXRvbWF0aWNhbGx5IGRlYWN0aXZhdGVkIGJ5IFtgUGFsbGV0Ojpvbl9pbml0aWFsaXplYF0gaG9vayUBYWZ0ZXIgdGhlIGJsb2NrIGhlaWdodCBpcyBncmVhdGVyIHRoYW4gdGhlIFtgRW50ZXJlZFVudGlsYF0gc3RvcmFnZSBpdGVtLlUBRW1pdHMgYW4gW2BFdmVudDo6RXhpdGVkYF0gd2l0aCBbYEV4aXRSZWFzb246OlRpbWVvdXRgXSBldmVudCB3aGVuIGRlYWN0aXZhdGVkIGluIHRoZRRob29rLkxmb3JjZV9zbGFzaF9kZXBvc2l0CAEcYWNjb3VudAABMFQ6OkFjY291bnRJZAABFGJsb2NrEAFEQmxvY2tOdW1iZXJGb3I8VD4ABSQxAVNsYXNoIGEgZGVwb3NpdCBmb3IgYW4gYWNjb3VudCB0aGF0IGVudGVyZWQgb3IgZXh0ZW5kZWQgc2FmZS1tb2RlIGF0IGEgZ2l2ZW5EaGlzdG9yaWNhbCBibG9jay4AzFRoaXMgY2FuIG9ubHkgYmUgY2FsbGVkIHdoaWxlIHNhZmUtbW9kZSBpcyBlbnRlcmVkLgDMRW1pdHMgYSBbYEV2ZW50OjpEZXBvc2l0U2xhc2hlZGBdIGV2ZW50IG9uIHN1Y2Nlc3Mu3EVycm9ycyB3aXRoIFtgRXJyb3I6OkVudGVyZWRgXSBpZiBzYWZlLW1vZGUgaXMgZW50ZXJlZC4AAQFDYW4gb25seSBiZSBjYWxsZWQgYnkgdGhlIFtgQ29uZmlnOjpGb3JjZURlcG9zaXRPcmlnaW5gXSBvcmlnaW4uPHJlbGVhc2VfZGVwb3NpdAgBHGFjY291bnQAATBUOjpBY2NvdW50SWQAARRibG9jaxABREJsb2NrTnVtYmVyRm9yPFQ+AAYwNQFQZXJtaXNzaW9ubGVzc2x5IHJlbGVhc2UgYSBkZXBvc2l0IGZvciBhbiBhY2NvdW50IHRoYXQgZW50ZXJlZCBzYWZlLW1vZGUgYXQgYVxnaXZlbiBoaXN0b3JpY2FsIGJsb2NrLgBJAVRoZSBjYWxsIGNhbiBiZSBjb21wbGV0ZWx5IGRpc2FibGVkIGJ5IHNldHRpbmcgW2BDb25maWc6OlJlbGVhc2VEZWxheWBdIHRvIGBOb25lYC74VGhpcyBjYW5ub3QgYmUgY2FsbGVkIHdoaWxlIHNhZmUtbW9kZSBpcyBlbnRlcmVkIGFuZCBub3QgdW50aWwhAVtgQ29uZmlnOjpSZWxlYXNlRGVsYXlgXSBibG9ja3MgaGF2ZSBwYXNzZWQgc2luY2Ugc2FmZS1tb2RlIHdhcyBlbnRlcmVkLgDQRW1pdHMgYSBbYEV2ZW50OjpEZXBvc2l0UmVsZWFzZWRgXSBldmVudCBvbiBzdWNjZXNzLuxFcnJvcnMgd2l0aCBbYEVycm9yOjpFbnRlcmVkYF0gaWYgdGhlIHNhZmUtbW9kZSBpcyBlbnRlcmVkLkkBRXJyb3JzIHdpdGggW2BFcnJvcjo6Q2Fubm90UmVsZWFzZVlldGBdIGlmIFtgQ29uZmlnOjpSZWxlYXNlRGVsYXlgXSBibG9jayBoYXZlIG5vdGEBcGFzc2VkIHNpbmNlIHNhZmUtbW9kZSB3YXMgZW50ZXJlZC4gRXJyb3JzIHdpdGggW2BFcnJvcjo6Tm9EZXBvc2l0YF0gaWYgdGhlIHBheWVlIGhhcyBub6RyZXNlcnZlZCBjdXJyZW5jeSBhdCB0aGUgYmxvY2sgc3BlY2lmaWVkLlRmb3JjZV9yZWxlYXNlX2RlcG9zaXQIARxhY2NvdW50AAEwVDo6QWNjb3VudElkAAEUYmxvY2sQAURCbG9ja051bWJlckZvcjxUPgAHLC0BRm9yY2UgdG8gcmVsZWFzZSBhIGRlcG9zaXQgZm9yIGFuIGFjY291bnQgdGhhdCBlbnRlcmVkIHNhZmUtbW9kZSBhdCBhIGdpdmVuRGhpc3RvcmljYWwgYmxvY2suANBUaGlzIGNhbiBiZSBjYWxsZWQgd2hpbGUgc2FmZS1tb2RlIGlzIHN0aWxsIGVudGVyZWQuANBFbWl0cyBhIFtgRXZlbnQ6OkRlcG9zaXRSZWxlYXNlZGBdIGV2ZW50IG9uIHN1Y2Nlc3Mu3EVycm9ycyB3aXRoIFtgRXJyb3I6OkVudGVyZWRgXSBpZiBzYWZlLW1vZGUgaXMgZW50ZXJlZC41AUVycm9ycyB3aXRoIFtgRXJyb3I6Ok5vRGVwb3NpdGBdIGlmIHRoZSBwYXllZSBoYXMgbm8gcmVzZXJ2ZWQgY3VycmVuY3kgYXQgdGhlQHNwZWNpZmllZCBibG9jay4AAQFDYW4gb25seSBiZSBjYWxsZWQgYnkgdGhlIFtgQ29uZmlnOjpGb3JjZURlcG9zaXRPcmlnaW5gXSBvcmlnaW4uBA0BQ29udGFpbnMgYSB2YXJpYW50IHBlciBkaXNwYXRjaGFibGUgZXh0cmluc2ljIHRoYXQgdGhpcyBwYWxsZXQgaGFzLjEFDDxwYWxsZXRfZXRoZXJldW0YcGFsbGV0EENhbGwEBFQAAQQgdHJhbnNhY3QEASx0cmFuc2FjdGlvbjUFASxUcmFuc2FjdGlvbgAABIRUcmFuc2FjdCBhbiBFdGhlcmV1bSB0cmFuc2FjdGlvbi4EDQFDb250YWlucyBhIHZhcmlhbnQgcGVyIGRpc3BhdGNoYWJsZSBleHRyaW5zaWMgdGhhdCB0aGlzIHBhbGxldCBoYXMuNQUMIGV0aGVyZXVtLHRyYW5zYWN0aW9uNFRyYW5zYWN0aW9uVjMAARAYTGVnYWN5BAA5BQFETGVnYWN5VHJhbnNhY3Rpb24AAAAcRUlQMjkzMAQASQUBSEVJUDI5MzBUcmFuc2FjdGlvbgABABxFSVAxNTU5BABZBQFIRUlQMTU1OVRyYW5zYWN0aW9uAAIAHEVJUDc3MDIEAF0FAUhFSVA3NzAyVHJhbnNhY3Rpb24AAwAAOQUQIGV0aGVyZXVtLHRyYW5zYWN0aW9uGGxlZ2FjeURMZWdhY3lUcmFuc2FjdGlvbgAAHAEUbm9uY2VZAQEQVTI1NgABJGdhc19wcmljZVkBARBVMjU2AAEkZ2FzX2xpbWl0WQEBEFUyNTYAARhhY3Rpb249BQFEVHJhbnNhY3Rpb25BY3Rpb24AARR2YWx1ZVkBARBVMjU2AAEUaW5wdXQ4ARRCeXRlcwABJHNpZ25hdHVyZUEFAVBUcmFuc2FjdGlvblNpZ25hdHVyZQAAPQUQIGV0aGVyZXVtLHRyYW5zYWN0aW9uGGxlZ2FjeURUcmFuc2FjdGlvbkFjdGlvbgABCBBDYWxsBADEARBIMTYwAAAAGENyZWF0ZQABAABBBRAgZXRoZXJldW0sdHJhbnNhY3Rpb24YbGVnYWN5UFRyYW5zYWN0aW9uU2lnbmF0dXJlAAAMAQR2RQUBVFRyYW5zYWN0aW9uUmVjb3ZlcnlJZAABBHI0ARBIMjU2AAEEczQBEEgyNTYAAEUFECBldGhlcmV1bSx0cmFuc2FjdGlvbhhsZWdhY3lUVHJhbnNhY3Rpb25SZWNvdmVyeUlkAAAEABgBDHU2NAAASQUQIGV0aGVyZXVtLHRyYW5zYWN0aW9uHGVpcDI5MzBIRUlQMjkzMFRyYW5zYWN0aW9uAAAkASBjaGFpbl9pZBgBDHU2NAABFG5vbmNlWQEBEFUyNTYAASRnYXNfcHJpY2VZAQEQVTI1NgABJGdhc19saW1pdFkBARBVMjU2AAEYYWN0aW9uPQUBRFRyYW5zYWN0aW9uQWN0aW9uAAEUdmFsdWVZAQEQVTI1NgABFGlucHV0OAEUQnl0ZXMAASxhY2Nlc3NfbGlzdE0FAShBY2Nlc3NMaXN0AAEkc2lnbmF0dXJlVQUBUFRyYW5zYWN0aW9uU2lnbmF0dXJlAABNBQAAAlEFAFEFECBldGhlcmV1bSx0cmFuc2FjdGlvbhxlaXAyOTMwOEFjY2Vzc0xpc3RJdGVtAAAIARxhZGRyZXNzxAEcQWRkcmVzcwABMHN0b3JhZ2Vfa2V5c7gBJFZlYzxIMjU2PgAAVQUQIGV0aGVyZXVtLHRyYW5zYWN0aW9uHGVpcDI5MzBQVHJhbnNhY3Rpb25TaWduYXR1cmUAAAwBMG9kZF95X3Bhcml0eSQBEGJvb2wAAQRyNAEQSDI1NgABBHM0ARBIMjU2AABZBRAgZXRoZXJldW0sdHJhbnNhY3Rpb24cZWlwMTU1OUhFSVAxNTU5VHJhbnNhY3Rpb24AACgBIGNoYWluX2lkGAEMdTY0AAEUbm9uY2VZAQEQVTI1NgABYG1heF9wcmlvcml0eV9mZWVfcGVyX2dhc1kBARBVMjU2AAE8bWF4X2ZlZV9wZXJfZ2FzWQEBEFUyNTYAASRnYXNfbGltaXRZAQEQVTI1NgABGGFjdGlvbj0FAURUcmFuc2FjdGlvbkFjdGlvbgABFHZhbHVlWQEBEFUyNTYAARRpbnB1dDgBFEJ5dGVzAAEsYWNjZXNzX2xpc3RNBQEoQWNjZXNzTGlzdAABJHNpZ25hdHVyZVUFAVBUcmFuc2FjdGlvblNpZ25hdHVyZQAAXQUQIGV0aGVyZXVtLHRyYW5zYWN0aW9uHGVpcDc3MDJIRUlQNzcwMlRyYW5zYWN0aW9uAAAsASBjaGFpbl9pZBgBDHU2NAABFG5vbmNlWQEBEFUyNTYAAWBtYXhfcHJpb3JpdHlfZmVlX3Blcl9nYXNZAQEQVTI1NgABPG1heF9mZWVfcGVyX2dhc1kBARBVMjU2AAEkZ2FzX2xpbWl0WQEBEFUyNTYAASxkZXN0aW5hdGlvbj0FAURUcmFuc2FjdGlvbkFjdGlvbgABFHZhbHVlWQEBEFUyNTYAARBkYXRhOAEUQnl0ZXMAASxhY2Nlc3NfbGlzdE0FAShBY2Nlc3NMaXN0AAFIYXV0aG9yaXphdGlvbl9saXN0YQUBREF1dGhvcml6YXRpb25MaXN0AAEkc2lnbmF0dXJlVQUBUFRyYW5zYWN0aW9uU2lnbmF0dXJlAABhBQAAAmUFAGUFECBldGhlcmV1bSx0cmFuc2FjdGlvbhxlaXA3NzAyVEF1dGhvcml6YXRpb25MaXN0SXRlbQAAEAEgY2hhaW5faWQYAQx1NjQAARxhZGRyZXNzxAEcQWRkcmVzcwABFG5vbmNlWQEBEFUyNTYAASRzaWduYXR1cmVpBQF0TWFsbGVhYmxlVHJhbnNhY3Rpb25TaWduYXR1cmUAAGkFECBldGhlcmV1bSx0cmFuc2FjdGlvbhxlaXAyOTMwdE1hbGxlYWJsZVRyYW5zYWN0aW9uU2lnbmF0dXJlAAAMATBvZGRfeV9wYXJpdHkkARBib29sAAEEcjQBEEgyNTYAAQRzNAEQSDI1NgAAbQUMKHBhbGxldF9ldm0YcGFsbGV0EENhbGwEBFQAARggd2l0aGRyYXcIARxhZGRyZXNzxAEQSDE2MAABFHZhbHVlGAEwQmFsYW5jZU9mPFQ+AAAE4FdpdGhkcmF3IGJhbGFuY2UgZnJvbSBFVk0gaW50byBjdXJyZW5jeS9iYWxhbmNlcyBwYWxsZXQuEGNhbGwoARhzb3VyY2XEARBIMTYwAAEYdGFyZ2V0xAEQSDE2MAABFGlucHV0OAEcVmVjPHU4PgABFHZhbHVlWQEBEFUyNTYAASRnYXNfbGltaXQYAQx1NjQAATxtYXhfZmVlX3Blcl9nYXNZAQEQVTI1NgABYG1heF9wcmlvcml0eV9mZWVfcGVyX2dhc3EFATBPcHRpb248VTI1Nj4AARRub25jZXEFATBPcHRpb248VTI1Nj4AASxhY2Nlc3NfbGlzdHUFAVhWZWM8KEgxNjAsIFZlYzxIMjU2Pik+AAFIYXV0aG9yaXphdGlvbl9saXN0YQUBREF1dGhvcml6YXRpb25MaXN0AAEEXQFJc3N1ZSBhbiBFVk0gY2FsbCBvcGVyYXRpb24uIFRoaXMgaXMgc2ltaWxhciB0byBhIG1lc3NhZ2UgY2FsbCB0cmFuc2FjdGlvbiBpbiBFdGhlcmV1bS4YY3JlYXRlJAEYc291cmNlxAEQSDE2MAABEGluaXQ4ARxWZWM8dTg+AAEUdmFsdWVZAQEQVTI1NgABJGdhc19saW1pdBgBDHU2NAABPG1heF9mZWVfcGVyX2dhc1kBARBVMjU2AAFgbWF4X3ByaW9yaXR5X2ZlZV9wZXJfZ2FzcQUBME9wdGlvbjxVMjU2PgABFG5vbmNlcQUBME9wdGlvbjxVMjU2PgABLGFjY2Vzc19saXN0dQUBWFZlYzwoSDE2MCwgVmVjPEgyNTY+KT4AAUhhdXRob3JpemF0aW9uX2xpc3RhBQFEQXV0aG9yaXphdGlvbkxpc3QAAghRAUlzc3VlIGFuIEVWTSBjcmVhdGUgb3BlcmF0aW9uLiBUaGlzIGlzIHNpbWlsYXIgdG8gYSBjb250cmFjdCBjcmVhdGlvbiB0cmFuc2FjdGlvbiBpbiRFdGhlcmV1bS4cY3JlYXRlMigBGHNvdXJjZcQBEEgxNjAAARBpbml0OAEcVmVjPHU4PgABEHNhbHQ0ARBIMjU2AAEUdmFsdWVZAQEQVTI1NgABJGdhc19saW1pdBgBDHU2NAABPG1heF9mZWVfcGVyX2dhc1kBARBVMjU2AAFgbWF4X3ByaW9yaXR5X2ZlZV9wZXJfZ2FzcQUBME9wdGlvbjxVMjU2PgABFG5vbmNlcQUBME9wdGlvbjxVMjU2PgABLGFjY2Vzc19saXN0dQUBWFZlYzwoSDE2MCwgVmVjPEgyNTY+KT4AAUhhdXRob3JpemF0aW9uX2xpc3RhBQFEQXV0aG9yaXphdGlvbkxpc3QAAwR8SXNzdWUgYW4gRVZNIGNyZWF0ZTIgb3BlcmF0aW9uLjRzZXRfd2hpdGVsaXN0BAEMbmV3fQUBJFZlYzxIMTYwPgAEAERkaXNhYmxlX3doaXRlbGlzdAQBIGRpc2FibGVkJAEQYm9vbAAFAAQNAUNvbnRhaW5zIGEgdmFyaWFudCBwZXIgZGlzcGF0Y2hhYmxlIGV4dHJpbnNpYyB0aGF0IHRoaXMgcGFsbGV0IGhhcy5xBQQYT3B0aW9uBARUAVkBAQgQTm9uZQAAABBTb21lBABZAQAAAQAAdQUAAAJ5BQB5BQAABAjEuAB9BQAAAsQAgQUMPHBhbGxldF9iYXNlX2ZlZRhwYWxsZXQQQ2FsbAQEVAABCFBzZXRfYmFzZV9mZWVfcGVyX2dhcwQBDGZlZVkBARBVMjU2AAAAOHNldF9lbGFzdGljaXR5BAEoZWxhc3RpY2l0eWEBARxQZXJtaWxsAAEABA0BQ29udGFpbnMgYSB2YXJpYW50IHBlciBkaXNwYXRjaGFibGUgZXh0cmluc2ljIHRoYXQgdGhpcyBwYWxsZXQgaGFzLoUFDDBwYWxsZXRfZHJhbmQYcGFsbGV0EENhbGwEBFQAAQwsd3JpdGVfcHVsc2UIAThwdWxzZXNfcGF5bG9hZIkFAaxQdWxzZXNQYXlsb2FkPFQ6OlB1YmxpYywgQmxvY2tOdW1iZXJGb3I8VD4+AAEkc2lnbmF0dXJloQUBUE9wdGlvbjxUOjpTaWduYXR1cmU+AAAE5FZlcmlmeSBhbmQgd3JpdGUgYSBwdWxzZSBmcm9tIHRoZSBiZWFjb24gaW50byB0aGUgcnVudGltZURzZXRfYmVhY29uX2NvbmZpZwgBOGNvbmZpZ19wYXlsb2FkqQUB4EJlYWNvbkNvbmZpZ3VyYXRpb25QYXlsb2FkPFQ6OlB1YmxpYywgQmxvY2tOdW1iZXJGb3I8VD4+AAEkc2lnbmF0dXJloQUBUE9wdGlvbjxUOjpTaWduYXR1cmU+AAEY0GFsbG93cyB0aGUgcm9vdCB1c2VyIHRvIHNldCB0aGUgYmVhY29uIGNvbmZpZ3VyYXRpb278Z2VuZXJhbGx5IHRoaXMgd291bGQgYmUgY2FsbGVkIGZyb20gYW4gb2ZmY2hhaW4gd29ya2VyIGNvbnRleHQuEQF0aGVyZSBpcyBubyB2ZXJpZmljYXRpb24gb2YgY29uZmlndXJhdGlvbnMsIHNvIGJlIGNhcmVmdWwgd2l0aCB0aGlzLgBkKiBgb3JpZ2luYDogdGhlIHJvb3QgdXNlcpAqIGBjb25maWdgOiB0aGUgYmVhY29uIGNvbmZpZ3VyYXRpb25cc2V0X29sZGVzdF9zdG9yZWRfcm91bmQEATBvbGRlc3Rfcm91bmQYAQx1NjQAAgTMYWxsb3dzIHRoZSByb290IHVzZXIgdG8gc2V0IHRoZSBvbGRlc3Qgc3RvcmVkIHJvdW5kBA0BQ29udGFpbnMgYSB2YXJpYW50IHBlciBkaXNwYXRjaGFibGUgZXh0cmluc2ljIHRoYXQgdGhpcyBwYWxsZXQgaGFzLokFDDBwYWxsZXRfZHJhbmQUdHlwZXM0UHVsc2VzUGF5bG9hZAgYUHVibGljAY0FLEJsb2NrTnVtYmVyARAADAEwYmxvY2tfbnVtYmVyEAEsQmxvY2tOdW1iZXIAARhwdWxzZXORBQEoVmVjPFB1bHNlPgABGHB1YmxpY40FARhQdWJsaWMAAI0FCChzcF9ydW50aW1lLE11bHRpU2lnbmVyAAEMHEVkMjU1MTkEAAQBPGVkMjU1MTk6OlB1YmxpYwAAABxTcjI1NTE5BAAEATxzcjI1NTE5OjpQdWJsaWMAAQAURWNkc2EEAEEDATRlY2RzYTo6UHVibGljAAIAAJEFAAAClQUAlQUMMHBhbGxldF9kcmFuZBR0eXBlcxRQdWxzZQAADAEUcm91bmQYASxSb3VuZE51bWJlcgABKHJhbmRvbW5lc3OZBQFwQm91bmRlZFZlYzx1OCwgQ29uc3RVMzI8MzI+PgABJHNpZ25hdHVyZZ0FAXRCb3VuZGVkVmVjPHU4LCBDb25zdFUzMjwxNDQ+PgAAmQUMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAEIBFMAAAQAOAEYVmVjPFQ+AACdBQxMYm91bmRlZF9jb2xsZWN0aW9ucyxib3VuZGVkX3ZlYyhCb3VuZGVkVmVjCARUAQgEUwAABAA4ARhWZWM8VD4AAKEFBBhPcHRpb24EBFQBpQUBCBBOb25lAAAAEFNvbWUEAKUFAAABAAClBQgoc3BfcnVudGltZThNdWx0aVNpZ25hdHVyZQABDBxFZDI1NTE5BAAZAgFIZWQyNTUxOTo6U2lnbmF0dXJlAAAAHFNyMjU1MTkEABkCAUhzcjI1NTE5OjpTaWduYXR1cmUAAQAURWNkc2EEAHkCAUBlY2RzYTo6U2lnbmF0dXJlAAIAAKkFDDBwYWxsZXRfZHJhbmQUdHlwZXNoQmVhY29uQ29uZmlndXJhdGlvblBheWxvYWQIGFB1YmxpYwGNBSxCbG9ja051bWJlcgEQAAwBMGJsb2NrX251bWJlchABLEJsb2NrTnVtYmVyAAEYY29uZmlnrQUBTEJlYWNvbkNvbmZpZ3VyYXRpb24AARhwdWJsaWONBQEYUHVibGljAACtBQwwcGFsbGV0X2RyYW5kFHR5cGVzTEJlYWNvbkNvbmZpZ3VyYXRpb24AABwBKHB1YmxpY19rZXmxBQE8T3BhcXVlUHVibGljS2V5AAEYcGVyaW9kEAEMdTMyAAEwZ2VuZXNpc190aW1lEAEMdTMyAAEQaGFzaJkFASxCb3VuZGVkSGFzaAABKGdyb3VwX2hhc2iZBQEsQm91bmRlZEhhc2gAASRzY2hlbWVfaWSZBQEsQm91bmRlZEhhc2gAASBtZXRhZGF0YbUFASBNZXRhZGF0YQAAsQUMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAEIBFMAAAQAOAEYVmVjPFQ+AAC1BQwwcGFsbGV0X2RyYW5kFHR5cGVzIE1ldGFkYXRhAAAEASRiZWFjb25faWSZBQEsQm91bmRlZEhhc2gAALkFDEBwYWxsZXRfY3Jvd2Rsb2FuGHBhbGxldBBDYWxsBARUAAEkGGNyZWF0ZRgBHGRlcG9zaXQ9AgEwQmFsYW5jZU9mPFQ+AAFAbWluX2NvbnRyaWJ1dGlvbj0CATBCYWxhbmNlT2Y8VD4AAQxjYXA9AgEwQmFsYW5jZU9mPFQ+AAEMZW5ksQEBREJsb2NrTnVtYmVyRm9yPFQ+AAEQY2FsbL0FAZxPcHRpb248Qm94PDxUIGFzIENvbmZpZz46OlJ1bnRpbWVDYWxsPj4AATh0YXJnZXRfYWRkcmVzc+gBUE9wdGlvbjxUOjpBY2NvdW50SWQ+AABEPQFDcmVhdGUgYSBjcm93ZGxvYW4gdGhhdCB3aWxsIHJhaXNlIGZ1bmRzIHVwIHRvIGEgbWF4aW11bSBjYXAgYW5kIGlmIHN1Y2Nlc3NmdWwsLQF3aWxsIHRyYW5zZmVyIGZ1bmRzIHRvIHRoZSB0YXJnZXQgYWRkcmVzcyBpZiBwcm92aWRlZCBhbmQgZGlzcGF0Y2ggdGhlIGNhbGxcKHVzaW5nIGNyZWF0b3Igb3JpZ2luKS4AUQFUaGUgaW5pdGlhbCBkZXBvc2l0IHdpbGwgYmUgdHJhbnNmZXJlZCB0byB0aGUgY3Jvd2Rsb2FuIGFjY291bnQgYW5kIHdpbGwgYmUgcmVmdW5kZWRRAWluIGNhc2UgdGhlIGNyb3dkbG9hbiBmYWlscyB0byByYWlzZSB0aGUgY2FwLiBBZGRpdGlvbmFsbHksIHRoZSBjcmVhdG9yIHdpbGwgcGF5IGZvcmh0aGUgZXhlY3V0aW9uIG9mIHRoZSBjYWxsLgDMVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8uACxQYXJhbWV0ZXJzOsgtIGBkZXBvc2l0YDogVGhlIGluaXRpYWwgZGVwb3NpdCBmcm9tIHRoZSBjcmVhdG9yLl0BLSBgbWluX2NvbnRyaWJ1dGlvbmA6IFRoZSBtaW5pbXVtIGNvbnRyaWJ1dGlvbiByZXF1aXJlZCB0byBjb250cmlidXRlIHRvIHRoZSBjcm93ZGxvYW4u4C0gYGNhcGA6IFRoZSBtYXhpbXVtIGFtb3VudCBvZiBmdW5kcyB0aGF0IGNhbiBiZSByYWlzZWQu6C0gYGVuZGA6IFRoZSBibG9jayBudW1iZXIgYXQgd2hpY2ggdGhlIGNyb3dkbG9hbiB3aWxsIGVuZC78LSBgY2FsbGA6IFRoZSBjYWxsIHRvIGRpc3BhdGNoIHdoZW4gdGhlIGNyb3dkbG9hbiBpcyBmaW5hbGl6ZWQuMQEtIGB0YXJnZXRfYWRkcmVzc2A6IFRoZSBhZGRyZXNzIHRvIHRyYW5zZmVyIHRoZSByYWlzZWQgZnVuZHMgdG8gaWYgcHJvdmlkZWQuKGNvbnRyaWJ1dGUIATBjcm93ZGxvYW5faWSxAQEsQ3Jvd2Rsb2FuSWQAARhhbW91bnQ9AgEwQmFsYW5jZU9mPFQ+AAEsiENvbnRyaWJ1dGUgdG8gYW4gYWN0aXZlIGNyb3dkbG9hbi4ARQFUaGUgY29udHJpYnV0aW9uIHdpbGwgYmUgdHJhbnNmZXJlZCB0byB0aGUgY3Jvd2Rsb2FuIGFjY291bnQgYW5kIHdpbGwgYmUgcmVmdW5kZWSJAWlmIHRoZSBjcm93ZGxvYW4gZmFpbHMgdG8gcmFpc2UgdGhlIGNhcC4gSWYgdGhlIGNvbnRyaWJ1dGlvbiB3b3VsZCByYWlzZSB0aGUgYW1vdW50IGFib3ZlIHRoZSBjYXAsFQF0aGUgY29udHJpYnV0aW9uIHdpbGwgYmUgc2V0IHRvIHRoZSBhbW91bnQgdGhhdCBpcyBsZWZ0IHRvIGJlIHJhaXNlZC4AzFRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfLgAsUGFyYW1ldGVyczrsLSBgY3Jvd2Rsb2FuX2lkYDogVGhlIGlkIG9mIHRoZSBjcm93ZGxvYW4gdG8gY29udHJpYnV0ZSB0by6ULSBgYW1vdW50YDogVGhlIGFtb3VudCB0byBjb250cmlidXRlLiB3aXRoZHJhdwQBMGNyb3dkbG9hbl9pZLEBASxDcm93ZGxvYW5JZAACIEkBV2l0aGRyYXcgYSBjb250cmlidXRpb24gZnJvbSBhbiBhY3RpdmUgKG5vdCB5ZXQgZmluYWxpemVkIG9yIGRpc3NvbHZlZCkgY3Jvd2Rsb2FuLgARAU9ubHkgY29udHJpYnV0aW9ucyBvdmVyIHRoZSBkZXBvc2l0IGNhbiBiZSB3aXRoZHJhd24gYnkgdGhlIGNyZWF0b3IuAMxUaGUgZGlzcGF0Y2ggb3JpZ2luIGZvciB0aGlzIGNhbGwgbXVzdCBiZSBfU2lnbmVkXy4ALFBhcmFtZXRlcnM67C0gYGNyb3dkbG9hbl9pZGA6IFRoZSBpZCBvZiB0aGUgY3Jvd2Rsb2FuIHRvIHdpdGhkcmF3IGZyb20uIGZpbmFsaXplBAEwY3Jvd2Rsb2FuX2lksQEBLENyb3dkbG9hbklkAAMssEZpbmFsaXplIGNyb3dkbG9hbiB0aGF0IGhhcyByZWFjaGVkIHRoZSBjYXAuAMEBVGhlIGNhbGwgd2lsbCB0cmFuc2ZlciB0aGUgcmFpc2VkIGFtb3VudCB0byB0aGUgdGFyZ2V0IGFkZHJlc3MgaWYgaXQgd2FzIHByb3ZpZGVkIHdoZW4gdGhlIGNyb3dkbG9hbiB3YXMgY3JlYXRlZK0BYW5kIGRpc3BhdGNoIHRoZSBjYWxsIHRoYXQgd2FzIHByb3ZpZGVkIHVzaW5nIHRoZSBjcmVhdG9yIG9yaWdpbi4gVGhlIEN1cnJlbnRDcm93ZGxvYW5JZCB3aWxsIGJlIHNldCB0byB0aGVpAWNyb3dkbG9hbiBpZCBiZWluZyBmaW5hbGl6ZWQgc28gdGhlIGRpc3BhdGNoZWQgY2FsbCBjYW4gYWNjZXNzIGl0IHRlbXBvcmFyaWx5IGJ5IGFjY2Vzc2luZ5h0aGUgYEN1cnJlbnRDcm93ZGxvYW5JZGAgc3RvcmFnZSBpdGVtLgBxAVRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfIGFuZCBtdXN0IGJlIHRoZSBjcmVhdG9yIG9mIHRoZSBjcm93ZGxvYW4uACxQYXJhbWV0ZXJzOtgtIGBjcm93ZGxvYW5faWRgOiBUaGUgaWQgb2YgdGhlIGNyb3dkbG9hbiB0byBmaW5hbGl6ZS4YcmVmdW5kBAEwY3Jvd2Rsb2FuX2lksQEBLENyb3dkbG9hbklkAAQoxFJlZnVuZCBjb250cmlidXRvcnMgb2YgYSBub24tZmluYWxpemVkIGNyb3dkbG9hbi4A+QFUaGUgY2FsbCB3aWxsIHRyeSB0byByZWZ1bmQgYWxsIGNvbnRyaWJ1dG9ycyAoZXhjbHVkaW5nIHRoZSBjcmVhdG9yKSB1cCB0byB0aGUgbGltaXQgZGVmaW5lZCBieSB0aGUgYFJlZnVuZENvbnRyaWJ1dG9yc0xpbWl0YC6NAUlmIHRoZSBsaW1pdCBpcyByZWFjaGVkLCB0aGUgY2FsbCB3aWxsIHN0b3AgYW5kIHRoZSBjcm93ZGxvYW4gd2lsbCBiZSBtYXJrZWQgYXMgcGFydGlhbGx5IHJlZnVuZGVkLkUBSXQgbWF5IGJlIG5lZWRlZCB0byBkaXNwYXRjaCB0aGlzIGNhbGwgbXVsdGlwbGUgdGltZXMgdG8gcmVmdW5kIGFsbCBjb250cmlidXRvcnMuAJ0BVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8gYW5kIGRvZXNuJ3QgbmVlZCB0byBiZSB0aGUgY3JlYXRvciBvZiB0aGUgY3Jvd2Rsb2FuLgAsUGFyYW1ldGVyczrQLSBgY3Jvd2Rsb2FuX2lkYDogVGhlIGlkIG9mIHRoZSBjcm93ZGxvYW4gdG8gcmVmdW5kLiBkaXNzb2x2ZQQBMGNyb3dkbG9hbl9pZLEBASxDcm93ZGxvYW5JZAAFJFREaXNzb2x2ZSBhIGNyb3dkbG9hbi4AvFRoZSBjcm93ZGxvYW4gd2lsbCBiZSByZW1vdmVkIGZyb20gdGhlIHN0b3JhZ2UurQFBbGwgY29udHJpYnV0aW9ucyBtdXN0IGhhdmUgYmVlbiByZWZ1bmRlZCBiZWZvcmUgdGhlIGNyb3dkbG9hbiBjYW4gYmUgZGlzc29sdmVkIChleGNlcHQgdGhlIGNyZWF0b3IncyBvbmUpLgBxAVRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfIGFuZCBtdXN0IGJlIHRoZSBjcmVhdG9yIG9mIHRoZSBjcm93ZGxvYW4uACxQYXJhbWV0ZXJzOtgtIGBjcm93ZGxvYW5faWRgOiBUaGUgaWQgb2YgdGhlIGNyb3dkbG9hbiB0byBkaXNzb2x2ZS5cdXBkYXRlX21pbl9jb250cmlidXRpb24IATBjcm93ZGxvYW5faWSxAQEsQ3Jvd2Rsb2FuSWQAAVBuZXdfbWluX2NvbnRyaWJ1dGlvbj0CATBCYWxhbmNlT2Y8VD4ABhz0VXBkYXRlIHRoZSBtaW5pbXVtIGNvbnRyaWJ1dGlvbiBvZiBhIG5vbi1maW5hbGl6ZWQgY3Jvd2Rsb2FuLgBxAVRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfIGFuZCBtdXN0IGJlIHRoZSBjcmVhdG9yIG9mIHRoZSBjcm93ZGxvYW4uACxQYXJhbWV0ZXJzOkEBLSBgY3Jvd2Rsb2FuX2lkYDogVGhlIGlkIG9mIHRoZSBjcm93ZGxvYW4gdG8gdXBkYXRlIHRoZSBtaW5pbXVtIGNvbnRyaWJ1dGlvbiBvZi7cLSBgbmV3X21pbl9jb250cmlidXRpb25gOiBUaGUgbmV3IG1pbmltdW0gY29udHJpYnV0aW9uLih1cGRhdGVfZW5kCAEwY3Jvd2Rsb2FuX2lksQEBLENyb3dkbG9hbklkAAEcbmV3X2VuZLEBAURCbG9ja051bWJlckZvcjxUPgAHHMhVcGRhdGUgdGhlIGVuZCBibG9jayBvZiBhIG5vbi1maW5hbGl6ZWQgY3Jvd2Rsb2FuLgBxAVRoZSBkaXNwYXRjaCBvcmlnaW4gZm9yIHRoaXMgY2FsbCBtdXN0IGJlIF9TaWduZWRfIGFuZCBtdXN0IGJlIHRoZSBjcmVhdG9yIG9mIHRoZSBjcm93ZGxvYW4uACxQYXJhbWV0ZXJzOhUBLSBgY3Jvd2Rsb2FuX2lkYDogVGhlIGlkIG9mIHRoZSBjcm93ZGxvYW4gdG8gdXBkYXRlIHRoZSBlbmQgYmxvY2sgb2YufC0gYG5ld19lbmRgOiBUaGUgbmV3IGVuZCBibG9jay4odXBkYXRlX2NhcAgBMGNyb3dkbG9hbl9pZLEBASxDcm93ZGxvYW5JZAABHG5ld19jYXA9AgEwQmFsYW5jZU9mPFQ+AAgcsFVwZGF0ZSB0aGUgY2FwIG9mIGEgbm9uLWZpbmFsaXplZCBjcm93ZGxvYW4uAHEBVGhlIGRpc3BhdGNoIG9yaWdpbiBmb3IgdGhpcyBjYWxsIG11c3QgYmUgX1NpZ25lZF8gYW5kIG11c3QgYmUgdGhlIGNyZWF0b3Igb2YgdGhlIGNyb3dkbG9hbi4ALFBhcmFtZXRlcnM6/C0gYGNyb3dkbG9hbl9pZGA6IFRoZSBpZCBvZiB0aGUgY3Jvd2Rsb2FuIHRvIHVwZGF0ZSB0aGUgY2FwIG9mLmQtIGBuZXdfY2FwYDogVGhlIG5ldyBjYXAuBA0BQ29udGFpbnMgYSB2YXJpYW50IHBlciBkaXNwYXRjaGFibGUgZXh0cmluc2ljIHRoYXQgdGhpcyBwYWxsZXQgaGFzLr0FBBhPcHRpb24EBFQB+QEBCBBOb25lAAAAEFNvbWUEAPkBAAABAADBBRBUcGFsbGV0X3N1YnRlbnNvcl9zd2FwGHBhbGxldBhwYWxsZXQQQ2FsbAQEVAABGDBzZXRfZmVlX3JhdGUIARhuZXR1aWSgARhOZXRVaWQAARByYXRloAEMdTE2AAAQDQFTZXQgdGhlIGZlZSByYXRlIGZvciBzd2FwcyBvbiBhIHNwZWNpZmljIHN1Ym5ldCAobm9ybWFsaXplZCB2YWx1ZSkunEZvciBleGFtcGxlLCAwLjMlIGlzIGFwcHJveGltYXRlbHkgMTk2LgCET25seSBjYWxsYWJsZSBieSB0aGUgYWRtaW4gb3JpZ2luVHRvZ2dsZV91c2VyX2xpcXVpZGl0eQgBGG5ldHVpZKABGE5ldFVpZAABGGVuYWJsZSQBEGJvb2wABBwlAUVuYWJsZSB1c2VyIGxpcXVpZGl0eSBvcGVyYXRpb25zIGZvciBhIHNwZWNpZmljIHN1Ym5ldC4gVGhpcyBzd2l0Y2hlcyB0aGVVAXN1Ym5ldCBmcm9tIFYyIHRvIFYzIHN3YXAgbW9kZS4gVGhlcmVhZnRlciwgYWRkaW5nIG5ldyB1c2VyIGxpcXVpZGl0eSBjYW4gYmUgZGlzYWJsZWRRAWJ5IHRvZ2dsaW5nIHRoaXMgZmxhZyB0byBmYWxzZSwgYnV0IHRoZSBzd2FwIG1vZGUgd2lsbCByZW1haW4gVjMgYmVjYXVzZSBvZiBleGlzdGluZ+B1c2VyIGxpcXVpZGl0eSB1bnRpbCBhbGwgdXNlcnMgd2l0aGRyYXcgdGhlaXIgbGlxdWlkaXR5LgDQT25seSBzdWRvIG9yIHN1Ym5ldCBvd25lciBjYW4gZW5hYmxlIHVzZXIgbGlxdWlkaXR5LpRPbmx5IHN1ZG8gY2FuIGRpc2FibGUgdXNlciBsaXF1aWRpdHkuNGFkZF9saXF1aWRpdHkUARhob3RrZXkAATBUOjpBY2NvdW50SWQAARhuZXR1aWSgARhOZXRVaWQAASB0aWNrX2xvd3kBASRUaWNrSW5kZXgAASR0aWNrX2hpZ2h5AQEkVGlja0luZGV4AAEkbGlxdWlkaXR5GAEMdTY0AAEo1EFkZCBsaXF1aWRpdHkgdG8gYSBzcGVjaWZpYyBwcmljZSByYW5nZSBmb3IgYSBzdWJuZXQuACxQYXJhbWV0ZXJzOpwtIG9yaWdpbjogVGhlIG9yaWdpbiBvZiB0aGUgdHJhbnNhY3Rpb25MLSBuZXR1aWQ6IFN1Ym5ldCBJRKgtIHRpY2tfbG93OiBMb3dlciBib3VuZCBvZiB0aGUgcHJpY2UgcmFuZ2WsLSB0aWNrX2hpZ2g6IFVwcGVyIGJvdW5kIG9mIHRoZSBwcmljZSByYW5nZZwtIGxpcXVpZGl0eTogQW1vdW50IG9mIGxpcXVpZGl0eSB0byBhZGQAoEVtaXRzIGBFdmVudDo6TGlxdWlkaXR5QWRkZWRgIG9uIHN1Y2Nlc3NAcmVtb3ZlX2xpcXVpZGl0eQwBGGhvdGtleQABMFQ6OkFjY291bnRJZAABGG5ldHVpZKABGE5ldFVpZAABLHBvc2l0aW9uX2lkdQEBKFBvc2l0aW9uSWQAAiCoUmVtb3ZlIGxpcXVpZGl0eSBmcm9tIGEgc3BlY2lmaWMgcG9zaXRpb24uACxQYXJhbWV0ZXJzOpwtIG9yaWdpbjogVGhlIG9yaWdpbiBvZiB0aGUgdHJhbnNhY3Rpb25MLSBuZXR1aWQ6IFN1Ym5ldCBJRKwtIHBvc2l0aW9uX2lkOiBJRCBvZiB0aGUgcG9zaXRpb24gdG8gcmVtb3ZlAKhFbWl0cyBgRXZlbnQ6OkxpcXVpZGl0eVJlbW92ZWRgIG9uIHN1Y2Nlc3M8bW9kaWZ5X3Bvc2l0aW9uEAEYaG90a2V5AAEwVDo6QWNjb3VudElkAAEYbmV0dWlkoAEYTmV0VWlkAAEscG9zaXRpb25faWR1AQEoUG9zaXRpb25JZAABPGxpcXVpZGl0eV9kZWx0YYEBAQxpNjQAAyRwTW9kaWZ5IGEgbGlxdWlkaXR5IHBvc2l0aW9uLgAsUGFyYW1ldGVyczqcLSBvcmlnaW46IFRoZSBvcmlnaW4gb2YgdGhlIHRyYW5zYWN0aW9uTC0gbmV0dWlkOiBTdWJuZXQgSUSsLSBwb3NpdGlvbl9pZDogSUQgb2YgdGhlIHBvc2l0aW9uIHRvIHJlbW92ZSUBLSBsaXF1aWRpdHlfZGVsdGE6IExpcXVpZGl0eSB0byBhZGQgKGlmIHBvc2l0aXZlKSBvciByZW1vdmUgKGlmIG5lZ2F0aXZlKQCoRW1pdHMgYEV2ZW50OjpMaXF1aWRpdHlSZW1vdmVkYCBvbiBzdWNjZXNzKGRpc2FibGVfbHAABQyYRGlzYWJsZSB1c2VyIGxpcXVpZGl0eSBpbiBhbGwgc3VibmV0cy4AuEVtaXRzIGBFdmVudDo6VXNlckxpcXVpZGl0eVRvZ2dsZWRgIG9uIHN1Y2Nlc3MEDQFDb250YWlucyBhIHZhcmlhbnQgcGVyIGRpc3BhdGNoYWJsZSBleHRyaW5zaWMgdGhhdCB0aGlzIHBhbGxldCBoYXMuxQUMQHBhbGxldF9jb250cmFjdHMYcGFsbGV0EENhbGwEBFQAASg8Y2FsbF9vbGRfd2VpZ2h0FAEQZGVzdDUCAVBBY2NvdW50SWRMb29rdXBPZjxUPgABFHZhbHVlPQIBMEJhbGFuY2VPZjxUPgABJGdhc19saW1pdDABJE9sZFdlaWdodAABVHN0b3JhZ2VfZGVwb3NpdF9saW1pdMkFAcRPcHRpb248PEJhbGFuY2VPZjxUPiBhcyBjb2RlYzo6SGFzQ29tcGFjdD46OlR5cGU+AAEQZGF0YTgBHFZlYzx1OD4AAAQVAURlcHJlY2F0ZWQgdmVyc2lvbiBpZiBbYFNlbGY6OmNhbGxgXSBmb3IgdXNlIGluIGFuIGluLXN0b3JhZ2UgYENhbGxgLoBpbnN0YW50aWF0ZV93aXRoX2NvZGVfb2xkX3dlaWdodBgBFHZhbHVlPQIBMEJhbGFuY2VPZjxUPgABJGdhc19saW1pdDABJE9sZFdlaWdodAABVHN0b3JhZ2VfZGVwb3NpdF9saW1pdMkFAcRPcHRpb248PEJhbGFuY2VPZjxUPiBhcyBjb2RlYzo6SGFzQ29tcGFjdD46OlR5cGU+AAEQY29kZTgBHFZlYzx1OD4AARBkYXRhOAEcVmVjPHU4PgABEHNhbHQ4ARxWZWM8dTg+AAEEWQFEZXByZWNhdGVkIHZlcnNpb24gaWYgW2BTZWxmOjppbnN0YW50aWF0ZV93aXRoX2NvZGVgXSBmb3IgdXNlIGluIGFuIGluLXN0b3JhZ2UgYENhbGxgLlhpbnN0YW50aWF0ZV9vbGRfd2VpZ2h0GAEUdmFsdWU9AgEwQmFsYW5jZU9mPFQ+AAEkZ2FzX2xpbWl0MAEkT2xkV2VpZ2h0AAFUc3RvcmFnZV9kZXBvc2l0X2xpbWl0yQUBxE9wdGlvbjw8QmFsYW5jZU9mPFQ+IGFzIGNvZGVjOjpIYXNDb21wYWN0Pjo6VHlwZT4AASRjb2RlX2hhc2g0ASxDb2RlSGFzaDxUPgABEGRhdGE4ARxWZWM8dTg+AAEQc2FsdDgBHFZlYzx1OD4AAgQxAURlcHJlY2F0ZWQgdmVyc2lvbiBpZiBbYFNlbGY6Omluc3RhbnRpYXRlYF0gZm9yIHVzZSBpbiBhbiBpbi1zdG9yYWdlIGBDYWxsYC4sdXBsb2FkX2NvZGUMARBjb2RlOAEcVmVjPHU4PgABVHN0b3JhZ2VfZGVwb3NpdF9saW1pdMkFAcRPcHRpb248PEJhbGFuY2VPZjxUPiBhcyBjb2RlYzo6SGFzQ29tcGFjdD46OlR5cGU+AAEsZGV0ZXJtaW5pc23NBQEsRGV0ZXJtaW5pc20AA2DsVXBsb2FkIG5ldyBgY29kZWAgd2l0aG91dCBpbnN0YW50aWF0aW5nIGEgY29udHJhY3QgZnJvbSBpdC4AIQFJZiB0aGUgY29kZSBkb2VzIG5vdCBhbHJlYWR5IGV4aXN0IGEgZGVwb3NpdCBpcyByZXNlcnZlZCBmcm9tIHRoZSBjYWxsZXJFAWFuZCB1bnJlc2VydmVkIG9ubHkgd2hlbiBbYFNlbGY6OnJlbW92ZV9jb2RlYF0gaXMgY2FsbGVkLiBUaGUgc2l6ZSBvZiB0aGUgcmVzZXJ2ZaxkZXBlbmRzIG9uIHRoZSBzaXplIG9mIHRoZSBzdXBwbGllZCBgY29kZWAuADEBSWYgdGhlIGNvZGUgYWxyZWFkeSBleGlzdHMgaW4gc3RvcmFnZSBpdCB3aWxsIHN0aWxsIHJldHVybiBgT2tgIGFuZCB1cGdyYWRlc5R0aGUgaW4gc3RvcmFnZSB2ZXJzaW9uIHRvIHRoZSBjdXJyZW500FtgSW5zdHJ1Y3Rpb25XZWlnaHRzOjp2ZXJzaW9uYF0oSW5zdHJ1Y3Rpb25XZWlnaHRzKS4AVQEtIGBkZXRlcm1pbmlzbWA6IElmIHRoaXMgaXMgc2V0IHRvIGFueSBvdGhlciB2YWx1ZSBidXQgW2BEZXRlcm1pbmlzbTo6RW5mb3JjZWRgXSB0aGVuXQEgIHRoZSBvbmx5IHdheSB0byB1c2UgdGhpcyBjb2RlIGlzIHRvIGRlbGVnYXRlIGNhbGwgaW50byBpdCBmcm9tIGFuIG9mZmNoYWluIGV4ZWN1dGlvbi68ICBTZXQgdG8gW2BEZXRlcm1pbmlzbTo6RW5mb3JjZWRgXSBpZiBpbiBkb3VidC4AGCMgTm90ZQBZAUFueW9uZSBjYW4gaW5zdGFudGlhdGUgYSBjb250cmFjdCBmcm9tIGFueSB1cGxvYWRlZCBjb2RlIGFuZCB0aHVzIHByZXZlbnQgaXRzIHJlbW92YWwuQQFUbyBhdm9pZCB0aGlzIHNpdHVhdGlvbiBhIGNvbnN0cnVjdG9yIGNvdWxkIGVtcGxveSBhY2Nlc3MgY29udHJvbCBzbyB0aGF0IGl0IGNhbjkBb25seSBiZSBpbnN0YW50aWF0ZWQgYnkgcGVybWlzc2lvbmVkIGVudGl0aWVzLiBUaGUgc2FtZSBpcyB0cnVlIHdoZW4gdXBsb2FkaW5noHRocm91Z2ggW2BTZWxmOjppbnN0YW50aWF0ZV93aXRoX2NvZGVgXS4AUQFVc2UgW2BEZXRlcm1pbmlzbTo6UmVsYXhlZGBdIGV4Y2x1c2l2ZWx5IGZvciBub24tZGV0ZXJtaW5pc3RpYyBjb2RlLiBJZiB0aGUgdXBsb2FkZWRJAWNvZGUgaXMgZGV0ZXJtaW5pc3RpYywgc3BlY2lmeWluZyBbYERldGVybWluaXNtOjpSZWxheGVkYF0gd2lsbCBiZSBkaXNyZWdhcmRlZCBhbmRscmVzdWx0IGluIGhpZ2hlciBnYXMgY29zdHMuLHJlbW92ZV9jb2RlBAEkY29kZV9oYXNoNAEsQ29kZUhhc2g8VD4ABBA1AVJlbW92ZSB0aGUgY29kZSBzdG9yZWQgdW5kZXIgYGNvZGVfaGFzaGAgYW5kIHJlZnVuZCB0aGUgZGVwb3NpdCB0byBpdHMgb3duZXIuAEUBQSBjb2RlIGNhbiBvbmx5IGJlIHJlbW92ZWQgYnkgaXRzIG9yaWdpbmFsIHVwbG9hZGVyIChpdHMgb3duZXIpIGFuZCBvbmx5IGlmIGl0IGlzZG5vdCB1c2VkIGJ5IGFueSBjb250cmFjdC4gc2V0X2NvZGUIARBkZXN0NQIBUEFjY291bnRJZExvb2t1cE9mPFQ+AAEkY29kZV9oYXNoNAEsQ29kZUhhc2g8VD4ABSgJAVByaXZpbGVnZWQgZnVuY3Rpb24gdGhhdCBjaGFuZ2VzIHRoZSBjb2RlIG9mIGFuIGV4aXN0aW5nIGNvbnRyYWN0LgBFAVRoaXMgdGFrZXMgY2FyZSBvZiB1cGRhdGluZyByZWZjb3VudHMgYW5kIGFsbCBvdGhlciBuZWNlc3Nhcnkgb3BlcmF0aW9ucy4gUmV0dXJuc+hhbiBlcnJvciBpZiBlaXRoZXIgdGhlIGBjb2RlX2hhc2hgIG9yIGBkZXN0YCBkbyBub3QgZXhpc3QuABgjIE5vdGUAMQFUaGlzIGRvZXMgKipub3QqKiBjaGFuZ2UgdGhlIGFkZHJlc3Mgb2YgdGhlIGNvbnRyYWN0IGluIHF1ZXN0aW9uLiBUaGlzIG1lYW5zPQF0aGF0IHRoZSBjb250cmFjdCBhZGRyZXNzIGlzIG5vIGxvbmdlciBkZXJpdmVkIGZyb20gaXRzIGNvZGUgaGFzaCBhZnRlciBjYWxsaW5nSHRoaXMgZGlzcGF0Y2hhYmxlLhBjYWxsFAEQZGVzdDUCAVBBY2NvdW50SWRMb29rdXBPZjxUPgABFHZhbHVlPQIBMEJhbGFuY2VPZjxUPgABJGdhc19saW1pdCwBGFdlaWdodAABVHN0b3JhZ2VfZGVwb3NpdF9saW1pdMkFAcRPcHRpb248PEJhbGFuY2VPZjxUPiBhcyBjb2RlYzo6SGFzQ29tcGFjdD46OlR5cGU+AAEQZGF0YTgBHFZlYzx1OD4ABkAFAU1ha2VzIGEgY2FsbCB0byBhbiBhY2NvdW50LCBvcHRpb25hbGx5IHRyYW5zZmVycmluZyBzb21lIGJhbGFuY2UuADAjIFBhcmFtZXRlcnMAqCogYGRlc3RgOiBBZGRyZXNzIG9mIHRoZSBjb250cmFjdCB0byBjYWxsLvwqIGB2YWx1ZWA6IFRoZSBiYWxhbmNlIHRvIHRyYW5zZmVyIGZyb20gdGhlIGBvcmlnaW5gIHRvIGBkZXN0YC4VASogYGdhc19saW1pdGA6IFRoZSBnYXMgbGltaXQgZW5mb3JjZWQgd2hlbiBleGVjdXRpbmcgdGhlIGNvbnN0cnVjdG9yLlUBKiBgc3RvcmFnZV9kZXBvc2l0X2xpbWl0YDogVGhlIG1heGltdW0gYW1vdW50IG9mIGJhbGFuY2UgdGhhdCBjYW4gYmUgY2hhcmdlZCBmcm9tIHRoZaQgIGNhbGxlciB0byBwYXkgZm9yIHRoZSBzdG9yYWdlIGNvbnN1bWVkLsQqIGBkYXRhYDogVGhlIGlucHV0IGRhdGEgdG8gcGFzcyB0byB0aGUgY29udHJhY3QuACUBKiBJZiB0aGUgYWNjb3VudCBpcyBhIHNtYXJ0LWNvbnRyYWN0IGFjY291bnQsIHRoZSBhc3NvY2lhdGVkIGNvZGUgd2lsbCBiZaxleGVjdXRlZCBhbmQgYW55IHZhbHVlIHdpbGwgYmUgdHJhbnNmZXJyZWQuFQEqIElmIHRoZSBhY2NvdW50IGlzIGEgcmVndWxhciBhY2NvdW50LCBhbnkgdmFsdWUgd2lsbCBiZSB0cmFuc2ZlcnJlZC5FASogSWYgbm8gYWNjb3VudCBleGlzdHMgYW5kIHRoZSBjYWxsIHZhbHVlIGlzIG5vdCBsZXNzIHRoYW4gYGV4aXN0ZW50aWFsX2RlcG9zaXRgLBEBYSByZWd1bGFyIGFjY291bnQgd2lsbCBiZSBjcmVhdGVkIGFuZCBhbnkgdmFsdWUgd2lsbCBiZSB0cmFuc2ZlcnJlZC5UaW5zdGFudGlhdGVfd2l0aF9jb2RlGAEUdmFsdWU9AgEwQmFsYW5jZU9mPFQ+AAEkZ2FzX2xpbWl0LAEYV2VpZ2h0AAFUc3RvcmFnZV9kZXBvc2l0X2xpbWl0yQUBxE9wdGlvbjw8QmFsYW5jZU9mPFQ+IGFzIGNvZGVjOjpIYXNDb21wYWN0Pjo6VHlwZT4AARBjb2RlOAEcVmVjPHU4PgABEGRhdGE4ARxWZWM8dTg+AAEQc2FsdDgBHFZlYzx1OD4AB2QxAUluc3RhbnRpYXRlcyBhIG5ldyBjb250cmFjdCBmcm9tIHRoZSBzdXBwbGllZCBgY29kZWAgb3B0aW9uYWxseSB0cmFuc2ZlcnJpbmc0c29tZSBiYWxhbmNlLgAhAVRoaXMgZGlzcGF0Y2hhYmxlIGhhcyB0aGUgc2FtZSBlZmZlY3QgYXMgY2FsbGluZyBbYFNlbGY6OnVwbG9hZF9jb2RlYF0gKz0BW2BTZWxmOjppbnN0YW50aWF0ZWBdLiBCdW5kbGluZyB0aGVtIHRvZ2V0aGVyIHByb3ZpZGVzIGVmZmljaWVuY3kgZ2FpbnMuIFBsZWFzZdhhbHNvIGNoZWNrIHRoZSBkb2N1bWVudGF0aW9uIG9mIFtgU2VsZjo6dXBsb2FkX2NvZGVgXS4AMCMgUGFyYW1ldGVycwBNASogYHZhbHVlYDogVGhlIGJhbGFuY2UgdG8gdHJhbnNmZXIgZnJvbSB0aGUgYG9yaWdpbmAgdG8gdGhlIG5ld2x5IGNyZWF0ZWQgY29udHJhY3QuFQEqIGBnYXNfbGltaXRgOiBUaGUgZ2FzIGxpbWl0IGVuZm9yY2VkIHdoZW4gZXhlY3V0aW5nIHRoZSBjb25zdHJ1Y3Rvci5VASogYHN0b3JhZ2VfZGVwb3NpdF9saW1pdGA6IFRoZSBtYXhpbXVtIGFtb3VudCBvZiBiYWxhbmNlIHRoYXQgY2FuIGJlIGNoYXJnZWQvcmVzZXJ2ZWTIICBmcm9tIHRoZSBjYWxsZXIgdG8gcGF5IGZvciB0aGUgc3RvcmFnZSBjb25zdW1lZC7MKiBgY29kZWA6IFRoZSBjb250cmFjdCBjb2RlIHRvIGRlcGxveSBpbiByYXcgYnl0ZXMu9CogYGRhdGFgOiBUaGUgaW5wdXQgZGF0YSB0byBwYXNzIHRvIHRoZSBjb250cmFjdCBjb25zdHJ1Y3Rvci4xASogYHNhbHRgOiBVc2VkIGZvciB0aGUgYWRkcmVzcyBkZXJpdmF0aW9uLiBTZWUgW2BQYWxsZXQ6OmNvbnRyYWN0X2FkZHJlc3NgXS4AlEluc3RhbnRpYXRpb24gaXMgZXhlY3V0ZWQgYXMgZm9sbG93czoAOQEtIFRoZSBzdXBwbGllZCBgY29kZWAgaXMgZGVwbG95ZWQsIGFuZCBhIGBjb2RlX2hhc2hgIGlzIGNyZWF0ZWQgZm9yIHRoYXQgY29kZS5ZAS0gSWYgdGhlIGBjb2RlX2hhc2hgIGFscmVhZHkgZXhpc3RzIG9uIHRoZSBjaGFpbiB0aGUgdW5kZXJseWluZyBgY29kZWAgd2lsbCBiZSBzaGFyZWQuSQEtIFRoZSBkZXN0aW5hdGlvbiBhZGRyZXNzIGlzIGNvbXB1dGVkIGJhc2VkIG9uIHRoZSBzZW5kZXIsIGNvZGVfaGFzaCBhbmQgdGhlIHNhbHQuAQEtIFRoZSBzbWFydC1jb250cmFjdCBhY2NvdW50IGlzIGNyZWF0ZWQgYXQgdGhlIGNvbXB1dGVkIGFkZHJlc3MuwC0gVGhlIGB2YWx1ZWAgaXMgdHJhbnNmZXJyZWQgdG8gdGhlIG5ldyBhY2NvdW50LkEBLSBUaGUgYGRlcGxveWAgZnVuY3Rpb24gaXMgZXhlY3V0ZWQgaW4gdGhlIGNvbnRleHQgb2YgdGhlIG5ld2x5LWNyZWF0ZWQgYWNjb3VudC4saW5zdGFudGlhdGUYARR2YWx1ZT0CATBCYWxhbmNlT2Y8VD4AASRnYXNfbGltaXQsARhXZWlnaHQAAVRzdG9yYWdlX2RlcG9zaXRfbGltaXTJBQHET3B0aW9uPDxCYWxhbmNlT2Y8VD4gYXMgY29kZWM6Okhhc0NvbXBhY3Q+OjpUeXBlPgABJGNvZGVfaGFzaDQBLENvZGVIYXNoPFQ+AAEQZGF0YTgBHFZlYzx1OD4AARBzYWx0OAEcVmVjPHU4PgAIFPxJbnN0YW50aWF0ZXMgYSBjb250cmFjdCBmcm9tIGEgcHJldmlvdXNseSBkZXBsb3llZCB3YXNtIGJpbmFyeS4ANQFUaGlzIGZ1bmN0aW9uIGlzIGlkZW50aWNhbCB0byBbYFNlbGY6Omluc3RhbnRpYXRlX3dpdGhfY29kZWBdIGJ1dCB3aXRob3V0IHRoZUkBY29kZSBkZXBsb3ltZW50IHN0ZXAuIEluc3RlYWQsIHRoZSBgY29kZV9oYXNoYCBvZiBhbiBvbi1jaGFpbiBkZXBsb3llZCB3YXNtIGJpbmFyeURtdXN0IGJlIHN1cHBsaWVkLhxtaWdyYXRlBAEwd2VpZ2h0X2xpbWl0LAEYV2VpZ2h0AAkQWQFXaGVuIGEgbWlncmF0aW9uIGlzIGluIHByb2dyZXNzLCB0aGlzIGRpc3BhdGNoYWJsZSBjYW4gYmUgdXNlZCB0byBydW4gbWlncmF0aW9uIHN0ZXBzLmEBQ2FsbHMgdGhhdCBjb250cmlidXRlIHRvIGFkdmFuY2luZyB0aGUgbWlncmF0aW9uIGhhdmUgdGhlaXIgZmVlcyB3YWl2ZWQsIGFzIGl0J3MgaGVscGZ1bEUBZm9yIHRoZSBjaGFpbi4gTm90ZSB0aGF0IHdoaWxlIHRoZSBtaWdyYXRpb24gaXMgaW4gcHJvZ3Jlc3MsIHRoZSBwYWxsZXQgd2lsbCBhbHNv0GxldmVyYWdlIHRoZSBgb25faWRsZWAgaG9va3MgdG8gcnVuIG1pZ3JhdGlvbiBzdGVwcy4EDQFDb250YWlucyBhIHZhcmlhbnQgcGVyIGRpc3BhdGNoYWJsZSBleHRyaW5zaWMgdGhhdCB0aGlzIHBhbGxldCBoYXMuyQUEGE9wdGlvbgQEVAE9AgEIEE5vbmUAAAAQU29tZQQAPQIAAAEAAM0FDEBwYWxsZXRfY29udHJhY3RzEHdhc20sRGV0ZXJtaW5pc20AAQggRW5mb3JjZWQAAAAcUmVsYXhlZAABAADRBQw0cGFsbGV0X3NoaWVsZBhwYWxsZXQQQ2FsbAQEVAABDERhbm5vdW5jZV9uZXh0X2tleQQBKHB1YmxpY19rZXnVBQF4Qm91bmRlZFZlYzx1OCwgQ29uc3RVMzI8MjA0OD4+AAAIBQFBbm5vdW5jZSB0aGUgTUzigJFLRU0gcHVibGljIGtleSB0aGF0IHdpbGwgYmVjb21lIGBDdXJyZW50S2V5YCBpblB0aGUgZm9sbG93aW5nIGJsb2NrLkBzdWJtaXRfZW5jcnlwdGVkCAEoY29tbWl0bWVudDQBHFQ6Okhhc2gAAShjaXBoZXJ0ZXh02QUBeEJvdW5kZWRWZWM8dTgsIENvbnN0VTMyPDgxOTI+PgABQIhVc2VycyBzdWJtaXQgYW4gZW5jcnlwdGVkIHdyYXBwZXIuADhDbGllbnTigJFzaWRlOgD0ICAxLiBSZWFkIGBOZXh0S2V5YCAoTUzigJFLRU0gcHVibGljIGtleSBieXRlcykgZnJvbSBzdG9yYWdlLi0BICAyLiBTaWduIHlvdXIgZXh0cmluc2ljIHNvIHRoYXQgaXQgY2FuIGJlIGV4ZWN1dGVkIHdoZW4gYWRkZWQgdG8gdGhlIHBvb2wsVQEgICAgICAgaS5lLiB5b3UgbWF5IG5lZWQgdG8gaW5jcmVtZW50IHRoZSBub25jZSBpZiB5b3Ugc3VibWl0IHVzaW5nIHRoZSBzYW1lIGFjY291bnQu0CAgMy4gYGNvbW1pdG1lbnQgPSBIYXNoaW5nOjpoYXNoKHNpZ25lZF9leHRyaW5zaWMpYC40ICA0LiBFbmNyeXB0OgCMICAgICAgIHBsYWludGV4dCA9IHNpZ25lZF9leHRyaW5zaWMA6CAgICAgd2l0aCBNTOKAkUtFTeKAkTc2OCArIFhDaGFDaGEyMOKAkVBvbHkxMzA1LCBwcm9kdWNpbmcABQEgICAgICAgY2lwaGVydGV4dCA9IFt1MTYga2VtX2xlbl0gfHwga2VtX2N0IHx8IG5vbmNlMjQgfHwgYWVhZF9jdABYbWFya19kZWNyeXB0aW9uX2ZhaWxlZAgBCGlkNAEcVDo6SGFzaAABGHJlYXNvbqEBAXRCb3VuZGVkVmVjPHU4LCBDb25zdFUzMjwyNTY+PgADKBEBTWFya3MgYSBzdWJtaXNzaW9uIGFzIGZhaWxlZCB0byBkZWNyeXB0IGFuZCByZW1vdmVzIGl0IGZyb20gc3RvcmFnZS4AXQFDYWxsZWQgYnkgdGhlIGJsb2NrIGF1dGhvciB3aGVuIGRlY3J5cHRpb24gZmFpbHMgYXQgYW55IHN0YWdlIChlLmcuLCBNTC1LRU0gZGVjYXBzdWxhdGVhAWZhaWxlZCwgQUVBRCBkZWNyeXB0IGZhaWxlZCwgaW52YWxpZCBjaXBoZXJ0ZXh0IGZvcm1hdCwgZXRjLikuIFRoaXMgYWxsb3dzIGNsaWVudHMgdG8gYmXgbm90aWZpZWQgb2YgZGVjcnlwdGlvbiBmYWlsdXJlcyB0aHJvdWdoIG9uLWNoYWluIGV2ZW50cy4ALCMgQXJndW1lbnRzAAkBKiBgaWRgIC0gVGhlIHdyYXBwZXIgaWQgKGhhc2ggb2YgKGF1dGhvciwgY29tbWl0bWVudCwgY2lwaGVydGV4dCkphQEqIGByZWFzb25gIC0gSHVtYW4tcmVhZGFibGUgcmVhc29uIGZvciB0aGUgZGVjcnlwdGlvbiBmYWlsdXJlIChlLmcuLCAiTUwtS0VNIGRlY2Fwc3VsYXRlIGZhaWxlZCIpBA0BQ29udGFpbnMgYSB2YXJpYW50IHBlciBkaXNwYXRjaGFibGUgZXh0cmluc2ljIHRoYXQgdGhpcyBwYWxsZXQgaGFzLtUFDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQBCARTAAAEADgBGFZlYzxUPgAA2QUMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAEIBFMAAAQAOAEYVmVjPFQ+AADdBQwoc3BfcnVudGltZRh0cmFpdHMsQmxha2VUd28yNTYAAAAA4QUQKHNwX3J1bnRpbWUcZ2VuZXJpYxRibG9jaxRCbG9jawgYSGVhZGVyAeUFJEV4dHJpbnNpYwHpBQAIARhoZWFkZXLlBQEYSGVhZGVyAAEoZXh0cmluc2ljczEGAThWZWM8RXh0cmluc2ljPgAA5QUQKHNwX3J1bnRpbWUcZ2VuZXJpYxhoZWFkZXIYSGVhZGVyCBhOdW1iZXIBEBBIYXNoAAAUASxwYXJlbnRfaGFzaDQBMEhhc2g6Ok91dHB1dAABGG51bWJlcrEBARhOdW1iZXIAAShzdGF0ZV9yb290NAEwSGFzaDo6T3V0cHV0AAE8ZXh0cmluc2ljc19yb290NAEwSGFzaDo6T3V0cHV0AAEYZGlnZXN0PAEYRGlnZXN0AADpBQxEZnBfc2VsZl9jb250YWluZWRMdW5jaGVja2VkX2V4dHJpbnNpY0hVbmNoZWNrZWRFeHRyaW5zaWMQHEFkZHJlc3MBNQIQQ2FsbAH5ASRTaWduYXR1cmUBpQUkRXh0ZW5zaW9uAe0FAAQALQYBAQFnZW5lcmljOjpVbmNoZWNrZWRFeHRyaW5zaWM8QWRkcmVzcywgQ2FsbCwgU2lnbmF0dXJlLCBFeHRlbnNpb24+AADtBQAABDDxBfUF+QX9BQEGCQYNBhEGGQYdBiEGJQYA8QUQMGZyYW1lX3N5c3RlbShleHRlbnNpb25zVGNoZWNrX25vbl96ZXJvX3NlbmRlckhDaGVja05vblplcm9TZW5kZXIEBFQAAAAA9QUQMGZyYW1lX3N5c3RlbShleHRlbnNpb25zSGNoZWNrX3NwZWNfdmVyc2lvbkBDaGVja1NwZWNWZXJzaW9uBARUAAAAAPkFEDBmcmFtZV9zeXN0ZW0oZXh0ZW5zaW9uc0BjaGVja190eF92ZXJzaW9uOENoZWNrVHhWZXJzaW9uBARUAAAAAP0FEDBmcmFtZV9zeXN0ZW0oZXh0ZW5zaW9uczRjaGVja19nZW5lc2lzMENoZWNrR2VuZXNpcwQEVAAAAAABBhAwZnJhbWVfc3lzdGVtKGV4dGVuc2lvbnM8Y2hlY2tfbW9ydGFsaXR5OENoZWNrTW9ydGFsaXR5BARUAAAEAAUGAQxFcmEAAAUGEChzcF9ydW50aW1lHGdlbmVyaWMMZXJhDEVyYQABAQQgSW1tb3J0YWwAAAAcTW9ydGFsMQQACAAAAQAcTW9ydGFsMgQACAAAAgAcTW9ydGFsMwQACAAAAwAcTW9ydGFsNAQACAAABAAcTW9ydGFsNQQACAAABQAcTW9ydGFsNgQACAAABgAcTW9ydGFsNwQACAAABwAcTW9ydGFsOAQACAAACAAcTW9ydGFsOQQACAAACQAgTW9ydGFsMTAEAAgAAAoAIE1vcnRhbDExBAAIAAALACBNb3J0YWwxMgQACAAADAAgTW9ydGFsMTMEAAgAAA0AIE1vcnRhbDE0BAAIAAAOACBNb3J0YWwxNQQACAAADwAgTW9ydGFsMTYEAAgAABAAIE1vcnRhbDE3BAAIAAARACBNb3J0YWwxOAQACAAAEgAgTW9ydGFsMTkEAAgAABMAIE1vcnRhbDIwBAAIAAAUACBNb3J0YWwyMQQACAAAFQAgTW9ydGFsMjIEAAgAABYAIE1vcnRhbDIzBAAIAAAXACBNb3J0YWwyNAQACAAAGAAgTW9ydGFsMjUEAAgAABkAIE1vcnRhbDI2BAAIAAAaACBNb3J0YWwyNwQACAAAGwAgTW9ydGFsMjgEAAgAABwAIE1vcnRhbDI5BAAIAAAdACBNb3J0YWwzMAQACAAAHgAgTW9ydGFsMzEEAAgAAB8AIE1vcnRhbDMyBAAIAAAgACBNb3J0YWwzMwQACAAAIQAgTW9ydGFsMzQEAAgAACIAIE1vcnRhbDM1BAAIAAAjACBNb3J0YWwzNgQACAAAJAAgTW9ydGFsMzcEAAgAACUAIE1vcnRhbDM4BAAIAAAmACBNb3J0YWwzOQQACAAAJwAgTW9ydGFsNDAEAAgAACgAIE1vcnRhbDQxBAAIAAApACBNb3J0YWw0MgQACAAAKgAgTW9ydGFsNDMEAAgAACsAIE1vcnRhbDQ0BAAIAAAsACBNb3J0YWw0NQQACAAALQAgTW9ydGFsNDYEAAgAAC4AIE1vcnRhbDQ3BAAIAAAvACBNb3J0YWw0OAQACAAAMAAgTW9ydGFsNDkEAAgAADEAIE1vcnRhbDUwBAAIAAAyACBNb3J0YWw1MQQACAAAMwAgTW9ydGFsNTIEAAgAADQAIE1vcnRhbDUzBAAIAAA1ACBNb3J0YWw1NAQACAAANgAgTW9ydGFsNTUEAAgAADcAIE1vcnRhbDU2BAAIAAA4ACBNb3J0YWw1NwQACAAAOQAgTW9ydGFsNTgEAAgAADoAIE1vcnRhbDU5BAAIAAA7ACBNb3J0YWw2MAQACAAAPAAgTW9ydGFsNjEEAAgAAD0AIE1vcnRhbDYyBAAIAAA+ACBNb3J0YWw2MwQACAAAPwAgTW9ydGFsNjQEAAgAAEAAIE1vcnRhbDY1BAAIAABBACBNb3J0YWw2NgQACAAAQgAgTW9ydGFsNjcEAAgAAEMAIE1vcnRhbDY4BAAIAABEACBNb3J0YWw2OQQACAAARQAgTW9ydGFsNzAEAAgAAEYAIE1vcnRhbDcxBAAIAABHACBNb3J0YWw3MgQACAAASAAgTW9ydGFsNzMEAAgAAEkAIE1vcnRhbDc0BAAIAABKACBNb3J0YWw3NQQACAAASwAgTW9ydGFsNzYEAAgAAEwAIE1vcnRhbDc3BAAIAABNACBNb3J0YWw3OAQACAAATgAgTW9ydGFsNzkEAAgAAE8AIE1vcnRhbDgwBAAIAABQACBNb3J0YWw4MQQACAAAUQAgTW9ydGFsODIEAAgAAFIAIE1vcnRhbDgzBAAIAABTACBNb3J0YWw4NAQACAAAVAAgTW9ydGFsODUEAAgAAFUAIE1vcnRhbDg2BAAIAABWACBNb3J0YWw4NwQACAAAVwAgTW9ydGFsODgEAAgAAFgAIE1vcnRhbDg5BAAIAABZACBNb3J0YWw5MAQACAAAWgAgTW9ydGFsOTEEAAgAAFsAIE1vcnRhbDkyBAAIAABcACBNb3J0YWw5MwQACAAAXQAgTW9ydGFsOTQEAAgAAF4AIE1vcnRhbDk1BAAIAABfACBNb3J0YWw5NgQACAAAYAAgTW9ydGFsOTcEAAgAAGEAIE1vcnRhbDk4BAAIAABiACBNb3J0YWw5OQQACAAAYwAkTW9ydGFsMTAwBAAIAABkACRNb3J0YWwxMDEEAAgAAGUAJE1vcnRhbDEwMgQACAAAZgAkTW9ydGFsMTAzBAAIAABnACRNb3J0YWwxMDQEAAgAAGgAJE1vcnRhbDEwNQQACAAAaQAkTW9ydGFsMTA2BAAIAABqACRNb3J0YWwxMDcEAAgAAGsAJE1vcnRhbDEwOAQACAAAbAAkTW9ydGFsMTA5BAAIAABtACRNb3J0YWwxMTAEAAgAAG4AJE1vcnRhbDExMQQACAAAbwAkTW9ydGFsMTEyBAAIAABwACRNb3J0YWwxMTMEAAgAAHEAJE1vcnRhbDExNAQACAAAcgAkTW9ydGFsMTE1BAAIAABzACRNb3J0YWwxMTYEAAgAAHQAJE1vcnRhbDExNwQACAAAdQAkTW9ydGFsMTE4BAAIAAB2ACRNb3J0YWwxMTkEAAgAAHcAJE1vcnRhbDEyMAQACAAAeAAkTW9ydGFsMTIxBAAIAAB5ACRNb3J0YWwxMjIEAAgAAHoAJE1vcnRhbDEyMwQACAAAewAkTW9ydGFsMTI0BAAIAAB8ACRNb3J0YWwxMjUEAAgAAH0AJE1vcnRhbDEyNgQACAAAfgAkTW9ydGFsMTI3BAAIAAB/ACRNb3J0YWwxMjgEAAgAAIAAJE1vcnRhbDEyOQQACAAAgQAkTW9ydGFsMTMwBAAIAACCACRNb3J0YWwxMzEEAAgAAIMAJE1vcnRhbDEzMgQACAAAhAAkTW9ydGFsMTMzBAAIAACFACRNb3J0YWwxMzQEAAgAAIYAJE1vcnRhbDEzNQQACAAAhwAkTW9ydGFsMTM2BAAIAACIACRNb3J0YWwxMzcEAAgAAIkAJE1vcnRhbDEzOAQACAAAigAkTW9ydGFsMTM5BAAIAACLACRNb3J0YWwxNDAEAAgAAIwAJE1vcnRhbDE0MQQACAAAjQAkTW9ydGFsMTQyBAAIAACOACRNb3J0YWwxNDMEAAgAAI8AJE1vcnRhbDE0NAQACAAAkAAkTW9ydGFsMTQ1BAAIAACRACRNb3J0YWwxNDYEAAgAAJIAJE1vcnRhbDE0NwQACAAAkwAkTW9ydGFsMTQ4BAAIAACUACRNb3J0YWwxNDkEAAgAAJUAJE1vcnRhbDE1MAQACAAAlgAkTW9ydGFsMTUxBAAIAACXACRNb3J0YWwxNTIEAAgAAJgAJE1vcnRhbDE1MwQACAAAmQAkTW9ydGFsMTU0BAAIAACaACRNb3J0YWwxNTUEAAgAAJsAJE1vcnRhbDE1NgQACAAAnAAkTW9ydGFsMTU3BAAIAACdACRNb3J0YWwxNTgEAAgAAJ4AJE1vcnRhbDE1OQQACAAAnwAkTW9ydGFsMTYwBAAIAACgACRNb3J0YWwxNjEEAAgAAKEAJE1vcnRhbDE2MgQACAAAogAkTW9ydGFsMTYzBAAIAACjACRNb3J0YWwxNjQEAAgAAKQAJE1vcnRhbDE2NQQACAAApQAkTW9ydGFsMTY2BAAIAACmACRNb3J0YWwxNjcEAAgAAKcAJE1vcnRhbDE2OAQACAAAqAAkTW9ydGFsMTY5BAAIAACpACRNb3J0YWwxNzAEAAgAAKoAJE1vcnRhbDE3MQQACAAAqwAkTW9ydGFsMTcyBAAIAACsACRNb3J0YWwxNzMEAAgAAK0AJE1vcnRhbDE3NAQACAAArgAkTW9ydGFsMTc1BAAIAACvACRNb3J0YWwxNzYEAAgAALAAJE1vcnRhbDE3NwQACAAAsQAkTW9ydGFsMTc4BAAIAACyACRNb3J0YWwxNzkEAAgAALMAJE1vcnRhbDE4MAQACAAAtAAkTW9ydGFsMTgxBAAIAAC1ACRNb3J0YWwxODIEAAgAALYAJE1vcnRhbDE4MwQACAAAtwAkTW9ydGFsMTg0BAAIAAC4ACRNb3J0YWwxODUEAAgAALkAJE1vcnRhbDE4NgQACAAAugAkTW9ydGFsMTg3BAAIAAC7ACRNb3J0YWwxODgEAAgAALwAJE1vcnRhbDE4OQQACAAAvQAkTW9ydGFsMTkwBAAIAAC+ACRNb3J0YWwxOTEEAAgAAL8AJE1vcnRhbDE5MgQACAAAwAAkTW9ydGFsMTkzBAAIAADBACRNb3J0YWwxOTQEAAgAAMIAJE1vcnRhbDE5NQQACAAAwwAkTW9ydGFsMTk2BAAIAADEACRNb3J0YWwxOTcEAAgAAMUAJE1vcnRhbDE5OAQACAAAxgAkTW9ydGFsMTk5BAAIAADHACRNb3J0YWwyMDAEAAgAAMgAJE1vcnRhbDIwMQQACAAAyQAkTW9ydGFsMjAyBAAIAADKACRNb3J0YWwyMDMEAAgAAMsAJE1vcnRhbDIwNAQACAAAzAAkTW9ydGFsMjA1BAAIAADNACRNb3J0YWwyMDYEAAgAAM4AJE1vcnRhbDIwNwQACAAAzwAkTW9ydGFsMjA4BAAIAADQACRNb3J0YWwyMDkEAAgAANEAJE1vcnRhbDIxMAQACAAA0gAkTW9ydGFsMjExBAAIAADTACRNb3J0YWwyMTIEAAgAANQAJE1vcnRhbDIxMwQACAAA1QAkTW9ydGFsMjE0BAAIAADWACRNb3J0YWwyMTUEAAgAANcAJE1vcnRhbDIxNgQACAAA2AAkTW9ydGFsMjE3BAAIAADZACRNb3J0YWwyMTgEAAgAANoAJE1vcnRhbDIxOQQACAAA2wAkTW9ydGFsMjIwBAAIAADcACRNb3J0YWwyMjEEAAgAAN0AJE1vcnRhbDIyMgQACAAA3gAkTW9ydGFsMjIzBAAIAADfACRNb3J0YWwyMjQEAAgAAOAAJE1vcnRhbDIyNQQACAAA4QAkTW9ydGFsMjI2BAAIAADiACRNb3J0YWwyMjcEAAgAAOMAJE1vcnRhbDIyOAQACAAA5AAkTW9ydGFsMjI5BAAIAADlACRNb3J0YWwyMzAEAAgAAOYAJE1vcnRhbDIzMQQACAAA5wAkTW9ydGFsMjMyBAAIAADoACRNb3J0YWwyMzMEAAgAAOkAJE1vcnRhbDIzNAQACAAA6gAkTW9ydGFsMjM1BAAIAADrACRNb3J0YWwyMzYEAAgAAOwAJE1vcnRhbDIzNwQACAAA7QAkTW9ydGFsMjM4BAAIAADuACRNb3J0YWwyMzkEAAgAAO8AJE1vcnRhbDI0MAQACAAA8AAkTW9ydGFsMjQxBAAIAADxACRNb3J0YWwyNDIEAAgAAPIAJE1vcnRhbDI0MwQACAAA8wAkTW9ydGFsMjQ0BAAIAAD0ACRNb3J0YWwyNDUEAAgAAPUAJE1vcnRhbDI0NgQACAAA9gAkTW9ydGFsMjQ3BAAIAAD3ACRNb3J0YWwyNDgEAAgAAPgAJE1vcnRhbDI0OQQACAAA+QAkTW9ydGFsMjUwBAAIAAD6ACRNb3J0YWwyNTEEAAgAAPsAJE1vcnRhbDI1MgQACAAA/AAkTW9ydGFsMjUzBAAIAAD9ACRNb3J0YWwyNTQEAAgAAP4AJE1vcnRhbDI1NQQACAAA/wAACQYMWG5vZGVfc3VidGVuc29yX3J1bnRpbWUsY2hlY2tfbm9uY2UoQ2hlY2tOb25jZQQEVAAABACxAQEgVDo6Tm9uY2UAAA0GEDBmcmFtZV9zeXN0ZW0oZXh0ZW5zaW9uczBjaGVja193ZWlnaHQsQ2hlY2tXZWlnaHQEBFQAAAAAEQYMWG5vZGVfc3VidGVuc29yX3J1bnRpbWVsdHJhbnNhY3Rpb25fcGF5bWVudF93cmFwcGVyfENoYXJnZVRyYW5zYWN0aW9uUGF5bWVudFdyYXBwZXIEBFQAAAQBaGNoYXJnZV90cmFuc2FjdGlvbl9wYXltZW50FQYBbENoYXJnZVRyYW5zYWN0aW9uUGF5bWVudDxUPgAAFQYIaHBhbGxldF90cmFuc2FjdGlvbl9wYXltZW50YENoYXJnZVRyYW5zYWN0aW9uUGF5bWVudAQEVAAABAA9AgEwQmFsYW5jZU9mPFQ+AAAZBgxYbm9kZV9zdWJ0ZW5zb3JfcnVudGltZTBzdWRvX3dyYXBwZXJgU3Vkb1RyYW5zYWN0aW9uRXh0ZW5zaW9uBARUAY0BAAAAHQYQQHBhbGxldF9zdWJ0ZW5zb3IoZXh0ZW5zaW9ucyRzdWJ0ZW5zb3J0U3VidGVuc29yVHJhbnNhY3Rpb25FeHRlbnNpb24EBFQBjQEAAAAhBgwwcGFsbGV0X2RyYW5kOGRyYW5kX3ByaW9yaXR5NERyYW5kUHJpb3JpdHkEBFQBjQEAAAAlBgh0ZnJhbWVfbWV0YWRhdGFfaGFzaF9leHRlbnNpb25EQ2hlY2tNZXRhZGF0YUhhc2gEBFQAAAQBEG1vZGUpBgEQTW9kZQAAKQYIdGZyYW1lX21ldGFkYXRhX2hhc2hfZXh0ZW5zaW9uEE1vZGUAAQggRGlzYWJsZWQAAAAcRW5hYmxlZAABAAAtBhAoc3BfcnVudGltZRxnZW5lcmljTHVuY2hlY2tlZF9leHRyaW5zaWNIVW5jaGVja2VkRXh0cmluc2ljEBxBZGRyZXNzATUCEENhbGwB+QEkU2lnbmF0dXJlAaUFFEV4dHJhAe0FAAQAOAAAADEGAAAC6QUANQYMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAE0BFMAAAQAuAEYVmVjPFQ+AAA5BghIc3BfY29uc2Vuc3VzX3Nsb3RzEFNsb3QAAAQAGAEMdTY0AAA9Bgg4cGFsbGV0X2dyYW5kcGEsU3RvcmVkU3RhdGUEBE4BEAEQEExpdmUAAAAwUGVuZGluZ1BhdXNlCAEwc2NoZWR1bGVkX2F0EAEETgABFGRlbGF5EAEETgABABhQYXVzZWQAAgA0UGVuZGluZ1Jlc3VtZQgBMHNjaGVkdWxlZF9hdBABBE4AARRkZWxheRABBE4AAwAAQQYIOHBhbGxldF9ncmFuZHBhTFN0b3JlZFBlbmRpbmdDaGFuZ2UIBE4BEBRMaW1pdAAAEAEwc2NoZWR1bGVkX2F0EAEETgABFGRlbGF5EAEETgABQG5leHRfYXV0aG9yaXRpZXNFBgFsQm91bmRlZEF1dGhvcml0eUxpc3Q8TGltaXQ+AAEYZm9yY2VkzAEkT3B0aW9uPE4+AABFBgxMYm91bmRlZF9jb2xsZWN0aW9uc0B3ZWFrX2JvdW5kZWRfdmVjOFdlYWtCb3VuZGVkVmVjCARUAYgEUwAABACEARhWZWM8VD4AAEkGDDhwYWxsZXRfZ3JhbmRwYRhwYWxsZXQURXJyb3IEBFQAARwsUGF1c2VGYWlsZWQAAAgFAUF0dGVtcHQgdG8gc2lnbmFsIEdSQU5EUEEgcGF1c2Ugd2hlbiB0aGUgYXV0aG9yaXR5IHNldCBpc24ndCBsaXZlpChlaXRoZXIgcGF1c2VkIG9yIGFscmVhZHkgcGVuZGluZyBwYXVzZSkuMFJlc3VtZUZhaWxlZAABCBEBQXR0ZW1wdCB0byBzaWduYWwgR1JBTkRQQSByZXN1bWUgd2hlbiB0aGUgYXV0aG9yaXR5IHNldCBpc24ndCBwYXVzZWSgKGVpdGhlciBsaXZlIG9yIGFscmVhZHkgcGVuZGluZyByZXN1bWUpLjRDaGFuZ2VQZW5kaW5nAAIE6EF0dGVtcHQgdG8gc2lnbmFsIEdSQU5EUEEgY2hhbmdlIHdpdGggb25lIGFscmVhZHkgcGVuZGluZy4cVG9vU29vbgADBLxDYW5ub3Qgc2lnbmFsIGZvcmNlZCBjaGFuZ2Ugc28gc29vbiBhZnRlciBsYXN0LmBJbnZhbGlkS2V5T3duZXJzaGlwUHJvb2YABAQxAUEga2V5IG93bmVyc2hpcCBwcm9vZiBwcm92aWRlZCBhcyBwYXJ0IG9mIGFuIGVxdWl2b2NhdGlvbiByZXBvcnQgaXMgaW52YWxpZC5gSW52YWxpZEVxdWl2b2NhdGlvblByb29mAAUEMQFBbiBlcXVpdm9jYXRpb24gcHJvb2YgcHJvdmlkZWQgYXMgcGFydCBvZiBhbiBlcXVpdm9jYXRpb24gcmVwb3J0IGlzIGludmFsaWQuWER1cGxpY2F0ZU9mZmVuY2VSZXBvcnQABgQVAUEgZ2l2ZW4gZXF1aXZvY2F0aW9uIHJlcG9ydCBpcyB2YWxpZCBidXQgYWxyZWFkeSBwcmV2aW91c2x5IHJlcG9ydGVkLgSAVGhlIGBFcnJvcmAgZW51bSBvZiB0aGlzIHBhbGxldC5NBgxMYm91bmRlZF9jb2xsZWN0aW9uc0B3ZWFrX2JvdW5kZWRfdmVjOFdlYWtCb3VuZGVkVmVjCARUAVEGBFMAAAQAWQYBGFZlYzxUPgAAUQYMPHBhbGxldF9iYWxhbmNlcxR0eXBlcyxCYWxhbmNlTG9jawQcQmFsYW5jZQEYAAwBCGlk8QEBOExvY2tJZGVudGlmaWVyAAEYYW1vdW50GAEcQmFsYW5jZQABHHJlYXNvbnNVBgEcUmVhc29ucwAAVQYMPHBhbGxldF9iYWxhbmNlcxR0eXBlcxxSZWFzb25zAAEMDEZlZQAAABBNaXNjAAEADEFsbAACAABZBgAAAlEGAF0GDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQBYQYEUwAABABlBgEYVmVjPFQ+AABhBgw8cGFsbGV0X2JhbGFuY2VzFHR5cGVzLFJlc2VydmVEYXRhCERSZXNlcnZlSWRlbnRpZmllcgHxARxCYWxhbmNlARgACAEIaWTxAQFEUmVzZXJ2ZUlkZW50aWZpZXIAARhhbW91bnQYARxCYWxhbmNlAABlBgAAAmEGAGkGDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQBbQYEUwAABACFBgEYVmVjPFQ+AABtBhQ0ZnJhbWVfc3VwcG9ydBh0cmFpdHMYdG9rZW5zEG1pc2MgSWRBbW91bnQICElkAXEGHEJhbGFuY2UBGAAIAQhpZHEGAQhJZAABGGFtb3VudBgBHEJhbGFuY2UAAHEGCFhub2RlX3N1YnRlbnNvcl9ydW50aW1lRFJ1bnRpbWVIb2xkUmVhc29uAAEQIFByZWltYWdlBAB1BgFscGFsbGV0X3ByZWltYWdlOjpIb2xkUmVhc29uAA4AIFJlZ2lzdHJ5BAB5BgFscGFsbGV0X3JlZ2lzdHJ5OjpIb2xkUmVhc29uABEAIFNhZmVNb2RlBAB9BgFwcGFsbGV0X3NhZmVfbW9kZTo6SG9sZFJlYXNvbgAUACRDb250cmFjdHMEAIEGAXBwYWxsZXRfY29udHJhY3RzOjpIb2xkUmVhc29uAB0AAHUGDDxwYWxsZXRfcHJlaW1hZ2UYcGFsbGV0KEhvbGRSZWFzb24AAQQgUHJlaW1hZ2UAAAAAeQYMPHBhbGxldF9yZWdpc3RyeRhwYWxsZXQoSG9sZFJlYXNvbgABBEBSZWdpc3RyeUlkZW50aXR5AAAAAH0GDEBwYWxsZXRfc2FmZV9tb2RlGHBhbGxldChIb2xkUmVhc29uAAEENEVudGVyT3JFeHRlbmQAAAAAgQYMQHBhbGxldF9jb250cmFjdHMYcGFsbGV0KEhvbGRSZWFzb24AAQhgQ29kZVVwbG9hZERlcG9zaXRSZXNlcnZlAAAAVFN0b3JhZ2VEZXBvc2l0UmVzZXJ2ZQABAACFBgAAAm0GAIkGDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQBjQYEUwAABACVBgEYVmVjPFQ+AACNBhQ0ZnJhbWVfc3VwcG9ydBh0cmFpdHMYdG9rZW5zEG1pc2MgSWRBbW91bnQICElkAZEGHEJhbGFuY2UBGAAIAQhpZJEGAQhJZAABGGFtb3VudBgBHEJhbGFuY2UAAJEGCFhub2RlX3N1YnRlbnNvcl9ydW50aW1lTFJ1bnRpbWVGcmVlemVSZWFzb24AAQAAlQYAAAKNBgCZBgw8cGFsbGV0X2JhbGFuY2VzGHBhbGxldBRFcnJvcggEVAAESQABMDhWZXN0aW5nQmFsYW5jZQAABJxWZXN0aW5nIGJhbGFuY2UgdG9vIGhpZ2ggdG8gc2VuZCB2YWx1ZS5UTGlxdWlkaXR5UmVzdHJpY3Rpb25zAAEEyEFjY291bnQgbGlxdWlkaXR5IHJlc3RyaWN0aW9ucyBwcmV2ZW50IHdpdGhkcmF3YWwuTEluc3VmZmljaWVudEJhbGFuY2UAAgR4QmFsYW5jZSB0b28gbG93IHRvIHNlbmQgdmFsdWUuSEV4aXN0ZW50aWFsRGVwb3NpdAADBOxWYWx1ZSB0b28gbG93IHRvIGNyZWF0ZSBhY2NvdW50IGR1ZSB0byBleGlzdGVudGlhbCBkZXBvc2l0LjRFeHBlbmRhYmlsaXR5AAQEkFRyYW5zZmVyL3BheW1lbnQgd291bGQga2lsbCBhY2NvdW50LlxFeGlzdGluZ1Zlc3RpbmdTY2hlZHVsZQAFBMxBIHZlc3Rpbmcgc2NoZWR1bGUgYWxyZWFkeSBleGlzdHMgZm9yIHRoaXMgYWNjb3VudC4sRGVhZEFjY291bnQABgSMQmVuZWZpY2lhcnkgYWNjb3VudCBtdXN0IHByZS1leGlzdC48VG9vTWFueVJlc2VydmVzAAcEuE51bWJlciBvZiBuYW1lZCByZXNlcnZlcyBleGNlZWQgYE1heFJlc2VydmVzYC4wVG9vTWFueUhvbGRzAAgE+E51bWJlciBvZiBob2xkcyBleGNlZWQgYFZhcmlhbnRDb3VudE9mPFQ6OlJ1bnRpbWVIb2xkUmVhc29uPmAuOFRvb01hbnlGcmVlemVzAAkEmE51bWJlciBvZiBmcmVlemVzIGV4Y2VlZCBgTWF4RnJlZXplc2AuTElzc3VhbmNlRGVhY3RpdmF0ZWQACgQBAVRoZSBpc3N1YW5jZSBjYW5ub3QgYmUgbW9kaWZpZWQgc2luY2UgaXQgaXMgYWxyZWFkeSBkZWFjdGl2YXRlZC4kRGVsdGFaZXJvAAsEZFRoZSBkZWx0YSBjYW5ub3QgYmUgemVyby4EgFRoZSBgRXJyb3JgIGVudW0gb2YgdGhpcyBwYWxsZXQunQYMNHNwX2FyaXRobWV0aWMsZml4ZWRfcG9pbnQkRml4ZWRVMTI4AAAEACABEHUxMjgAAKEGCGhwYWxsZXRfdHJhbnNhY3Rpb25fcGF5bWVudCBSZWxlYXNlcwABCCRWMUFuY2llbnQAAAAIVjIAAQAApQYAAAQIoAAAqQYAAAQIAKAArQYAAAQIsBgAsQYIPHN1YnN0cmF0ZV9maXhlZCRGaXhlZFUxMjgEEEZyYWMB9QQABAEQYml0cyABEHUxMjgAALUGAAAECBA0ALkGAAAEDAAAoAC9BgQYT3B0aW9uBARUATgBCBBOb25lAAAAEFNvbWUEADgAAAEAAMEGAAAECBghBQDFBghAcGFsbGV0X3N1YnRlbnNvcjBSYXRlTGltaXRLZXkEJEFjY291bnRJZAEAARxAU2V0U05Pd25lckhvdGtleQQAoAEYTmV0VWlkAAAAVE93bmVySHlwZXJwYXJhbVVwZGF0ZQgAoAEYTmV0VWlkAADJBgE4SHlwZXJwYXJhbWV0ZXIAAQBUTmV0d29ya0xhc3RSZWdpc3RlcmVkAAIALExhc3RUeEJsb2NrBAAAASRBY2NvdW50SWQAAwBcTGFzdFR4QmxvY2tDaGlsZEtleVRha2UEAAABJEFjY291bnRJZAAEAFxMYXN0VHhCbG9ja0RlbGVnYXRlVGFrZQQAAAEkQWNjb3VudElkAAUAMEFkZFN0YWtlQnVybgQAoAEYTmV0VWlkAAYAAMkGEEBwYWxsZXRfc3VidGVuc29yFHV0aWxzNHJhdGVfbGltaXRpbmc4SHlwZXJwYXJhbWV0ZXIAAWgcVW5rbm93bgAAAEBTZXJ2aW5nUmF0ZUxpbWl0AAEANE1heERpZmZpY3VsdHkAAgA8QWRqdXN0bWVudEFscGhhAAMAOE1heFdlaWdodExpbWl0AAQAOEltbXVuaXR5UGVyaW9kAAUARE1pbkFsbG93ZWRXZWlnaHRzAAYAFEthcHBhAAcADFJobwAIADhBY3Rpdml0eUN1dG9mZgAJAFhQb3dSZWdpc3RyYXRpb25BbGxvd2VkAAoAHE1pbkJ1cm4ACwAcTWF4QnVybgAMAEhCb25kc01vdmluZ0F2ZXJhZ2UADQAwQm9uZHNQZW5hbHR5AA4ATENvbW1pdFJldmVhbEVuYWJsZWQADwBITGlxdWlkQWxwaGFFbmFibGVkABAALEFscGhhVmFsdWVzABEAUFdlaWdodENvbW1pdEludGVydmFsABIAPFRyYW5zZmVyRW5hYmxlZAATAFRBbHBoYVNpZ21vaWRTdGVlcG5lc3MAFAAwWXVtYTNFbmFibGVkABUAREJvbmRzUmVzZXRFbmFibGVkABYAREltbXVuZU5ldXJvbkxpbWl0ABcANFJlY3ljbGVPckJ1cm4AGAA4TWF4QWxsb3dlZFVpZHMAGQAAzQYAAAQIoKAA0QYAAAQIoKAA1QYAAALZBgDZBgAABAwAGBgA3QYAAAIkAOEGAAAECKCgAOUGAAACzQYA6QYMQHBhbGxldF9zdWJ0ZW5zb3IYcGFsbGV0IEF4b25JbmZvAAAgARRibG9jaxgBDHU2NAABHHZlcnNpb24QAQx1MzIAAQhpcCABEHUxMjgAARBwb3J0oAEMdTE2AAEcaXBfdHlwZQgBCHU4AAEgcHJvdG9jb2wIAQh1OAABMHBsYWNlaG9sZGVyMQgBCHU4AAEwcGxhY2Vob2xkZXIyCAEIdTgAAO0GDEBwYWxsZXRfc3VidGVuc29yGHBhbGxldEROZXVyb25DZXJ0aWZpY2F0ZQAACAEocHVibGljX2tlefEGAXBCb3VuZGVkVmVjPHU4LCBDb25zdFUzMjw2ND4+AAEkYWxnb3JpdGhtCAEIdTgAAPEGDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQBCARTAAAEADgBGFZlYzxUPgAA9QYMQHBhbGxldF9zdWJ0ZW5zb3IYcGFsbGV0OFByb21ldGhldXNJbmZvAAAUARRibG9jaxgBDHU2NAABHHZlcnNpb24QAQx1MzIAAQhpcCABEHUxMjgAARBwb3J0oAEMdTE2AAEcaXBfdHlwZQgBCHU4AAD5BgxAcGFsbGV0X3N1YnRlbnNvchhwYWxsZXQ8Q2hhaW5JZGVudGl0eVYyAAAcARBuYW1lOAEcVmVjPHU4PgABDHVybDgBHFZlYzx1OD4AASxnaXRodWJfcmVwbzgBHFZlYzx1OD4AARRpbWFnZTgBHFZlYzx1OD4AARxkaXNjb3JkOAEcVmVjPHU4PgABLGRlc2NyaXB0aW9uOAEcVmVjPHU4PgABKGFkZGl0aW9uYWw4ARxWZWM8dTg+AAD9BgAABAwAoKAAAQcAAAQIoAAABQcAAAIJBwAJBwAABBA0GBgYAA0HAAAECKAYABEHAAACFQcAFQcAAAQQABhlAhgAGQcAAAIdBwAdBwAABAwAZQIYACEHAAAECAAAACUHBCBCVHJlZU1hcAgESwGgBFYB8QQABAApBwAAACkHAAACLQcALQcAAAQIoPEEADEHAAAEDKAAAAA1BwAABAjEGAA5BxBAcGFsbGV0X3N1YnRlbnNvchxzdWJuZXRzHGxlYXNpbmcsU3VibmV0TGVhc2UMJEFjY291bnRJZAEALEJsb2NrTnVtYmVyARAcQmFsYW5jZQEYABwBLGJlbmVmaWNpYXJ5AAEkQWNjb3VudElkAAEcY29sZGtleQABJEFjY291bnRJZAABGGhvdGtleQABJEFjY291bnRJZAABPGVtaXNzaW9uc19zaGFyZYECARxQZXJjZW50AAEkZW5kX2Jsb2NrzAFMT3B0aW9uPEJsb2NrTnVtYmVyPgABGG5ldHVpZKABGE5ldFVpZAABEGNvc3QYARxCYWxhbmNlAAA9BwAABAgQAABBBwxAcGFsbGV0X3N1YnRlbnNvchhwYWxsZXQURXJyb3IEBFQAAQ0CXFJvb3ROZXR3b3JrRG9lc05vdEV4aXN0AAAEgFRoZSByb290IG5ldHdvcmsgZG9lcyBub3QgZXhpc3QuNEludmFsaWRJcFR5cGUAAQQ5AVRoZSB1c2VyIGlzIHRyeWluZyB0byBzZXJ2ZSBhbiBheG9uIHdoaWNoIGlzIG5vdCBvZiB0eXBlIDQgKElQdjQpIG9yIDYgKElQdjYpLkBJbnZhbGlkSXBBZGRyZXNzAAIE2EFuIGludmFsaWQgSVAgYWRkcmVzcyBpcyBwYXNzZWQgdG8gdGhlIHNlcnZlIGZ1bmN0aW9uLixJbnZhbGlkUG9ydAADBMBBbiBpbnZhbGlkIHBvcnQgaXMgcGFzc2VkIHRvIHRoZSBzZXJ2ZSBmdW5jdGlvbi5sSG90S2V5Tm90UmVnaXN0ZXJlZEluU3ViTmV0AAQEmFRoZSBob3RrZXkgaXMgbm90IHJlZ2lzdGVyZWQgaW4gc3VibmV0WEhvdEtleUFjY291bnROb3RFeGlzdHMABQRoVGhlIGhvdGtleSBkb2VzIG5vdCBleGlzdHNwSG90S2V5Tm90UmVnaXN0ZXJlZEluTmV0d29yawAGBKxUaGUgaG90a2V5IGlzIG5vdCByZWdpc3RlcmVkIGluIGFueSBzdWJuZXQuUE5vbkFzc29jaWF0ZWRDb2xkS2V5AAcIXQFSZXF1ZXN0IHRvIHN0YWtlLCB1bnN0YWtlIG9yIHN1YnNjcmliZSBpcyBtYWRlIGJ5IGEgY29sZGtleSB0aGF0IGlzIG5vdCBhc3NvY2lhdGVkIHdpdGhMdGhlIGhvdGtleSBhY2NvdW50LjhOb3RFbm91Z2hTdGFrZQAICLRERVBSRUNBVEVEOiBTdGFrZSBhbW91bnQgdG8gd2l0aGRyYXcgaXMgemVyby74VGhlIGNhbGxlciBkb2VzIG5vdCBoYXZlIGVub3VnaHQgc3Rha2UgdG8gcGVyZm9ybSB0aGlzIGFjdGlvbi5gTm90RW5vdWdoU3Rha2VUb1dpdGhkcmF3AAkIWQFUaGUgY2FsbGVyIGlzIHJlcXVlc3RpbmcgcmVtb3ZpbmcgbW9yZSBzdGFrZSB0aGFuIHRoZXJlIGV4aXN0cyBpbiB0aGUgc3Rha2luZyBhY2NvdW50LmBTZWU6ICJbcmVtb3ZlX3N0YWtlKCldIi5oTm90RW5vdWdoU3Rha2VUb1NldFdlaWdodHMACghJAVRoZSBjYWxsZXIgaXMgcmVxdWVzdGluZyB0byBzZXQgd2VpZ2h0cyBidXQgdGhlIGNhbGxlciBoYXMgbGVzcyB0aGFuIG1pbmltdW0gc3Rha2XQcmVxdWlyZWQgdG8gc2V0IHdlaWdodHMgKGxlc3MgdGhhbiBXZWlnaHRzTWluU3Rha2UpLnBOb3RFbm91Z2hTdGFrZVRvU2V0Q2hpbGRrZXlzAAsEBQFUaGUgcGFyZW50IGhvdGtleSBkb2Vzbid0IGhhdmUgZW5vdWdoIG93biBzdGFrZSB0byBzZXQgY2hpbGRrZXlzLlxOb3RFbm91Z2hCYWxhbmNlVG9TdGFrZQAMCFEBVGhlIGNhbGxlciBpcyByZXF1ZXN0aW5nIGFkZGluZyBtb3JlIHN0YWtlIHRoYW4gdGhlcmUgZXhpc3RzIGluIHRoZSBjb2xka2V5IGFjY291bnQuUFNlZTogIlthZGRfc3Rha2UoKV0iWEJhbGFuY2VXaXRoZHJhd2FsRXJyb3IADQhhAVRoZSBjYWxsZXIgaXMgdHJ5aW5nIHRvIGFkZCBzdGFrZSwgYnV0IGZvciBzb21lIHJlYXNvbiB0aGUgcmVxdWVzdGVkIGFtb3VudCBjb3VsZCBub3QgYmWMd2l0aGRyYXduIGZyb20gdGhlIGNvbGRrZXkgYWNjb3VudC5kWmVyb0JhbGFuY2VBZnRlcldpdGhkcmF3bgAOCEUBVW5zdWNjZXNzZnVsbHkgd2l0aGRyYXcsIGJhbGFuY2UgY291bGQgYmUgemVybyAoY2FuIG5vdCBtYWtlIGFjY291bnQgZXhpc3QpIGFmdGVyLHdpdGhkcmF3YWwuXE5ldXJvbk5vVmFsaWRhdG9yUGVybWl0AA8EVQFUaGUgY2FsbGVyIGlzIGF0dGVtcHRpbmcgdG8gc2V0IG5vbi1zZWxmIHdlaWdodHMgd2l0aG91dCBiZWluZyBhIHBlcm1pdHRlZCB2YWxpZGF0b3IuVFdlaWdodFZlY05vdEVxdWFsU2l6ZQAQCEUBVGhlIGNhbGxlciBpcyBhdHRlbXB0aW5nIHRvIHNldCB0aGUgd2VpZ2h0IGtleXMgYW5kIHZhbHVlcyBidXQgdGhlc2UgdmVjdG9ycyBoYXZlPGRpZmZlcmVudCBzaXplLjREdXBsaWNhdGVVaWRzABEERQFUaGUgY2FsbGVyIGlzIGF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgd2l0aCBkdXBsaWNhdGUgVUlEcyBpbiB0aGUgd2VpZ2h0IG1hdHJpeC5cVWlkVmVjQ29udGFpbkludmFsaWRPbmUAEghVAVRoZSBjYWxsZXIgaXMgYXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0IHRvIGF0IGxlYXN0IG9uZSBVSUQgdGhhdCBkb2VzIG5vdCBleGlzdCBpbiB0aGUobWV0YWdyYXBoLlBXZWlnaHRWZWNMZW5ndGhJc0xvdwATBGEBVGhlIGRpc3BhdGNoIGlzIGF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgb24gY2hhaW4gd2l0aCBmZXdlciBlbGVtZW50cyB0aGFuIGFyZSBhbGxvd2VkLnRUb29NYW55UmVnaXN0cmF0aW9uc1RoaXNCbG9jawAUCE0BTnVtYmVyIG9mIHJlZ2lzdHJhdGlvbnMgaW4gdGhpcyBibG9jayBleGNlZWRzIHRoZSBhbGxvd2VkIG51bWJlciAoaS5lLiwgZXhjZWVkcyB0aGWwc3VibmV0IGh5cGVycGFyYW1ldGVyICJtYXhfcmVnc19wZXJfYmxvY2siKS58SG90S2V5QWxyZWFkeVJlZ2lzdGVyZWRJblN1Yk5ldAAVBFUBVGhlIGNhbGxlciBpcyByZXF1ZXN0aW5nIHJlZ2lzdGVyaW5nIGEgbmV1cm9uIHdoaWNoIGFscmVhZHkgZXhpc3RzIGluIHRoZSBhY3RpdmUgc2V0LlhOZXdIb3RLZXlJc1NhbWVXaXRoT2xkABYElFRoZSBuZXcgaG90a2V5IGlzIHRoZSBzYW1lIGFzIG9sZCBvbmVASW52YWxpZFdvcmtCbG9jawAXBORUaGUgc3VwcGxpZWQgUG9XIGhhc2ggYmxvY2sgaXMgaW4gdGhlIGZ1dHVyZSBvciBuZWdhdGl2ZS5ESW52YWxpZERpZmZpY3VsdHkAGAQFAVRoZSBzdXBwbGllZCBQb1cgaGFzaCBibG9jayBkb2VzIG5vdCBtZWV0IHRoZSBuZXR3b3JrIGRpZmZpY3VsdHkuLEludmFsaWRTZWFsABkE8FRoZSBzdXBwbGllZCBQb1cgaGFzaCBzZWFsIGRvZXMgbm90IG1hdGNoIHRoZSBzdXBwbGllZCB3b3JrLkRNYXhXZWlnaHRFeGNlZWRlZAAaCEkBVGhlIGRpc3BhdGNoIGlzIGF0dGVtcHRpbmcgdG8gc2V0IHdlaWdodHMgb24gY2hhaW4gd2l0aCB3ZWlnaHQgdmFsdWUgZXhjZWVkaW5nIHRoZcxjb25maWd1cmVkIG1heCB3ZWlnaHQgbGltaXQgKGN1cnJlbnRseSBgdTE2OjpNQVhgKS5USG90S2V5QWxyZWFkeURlbGVnYXRlABsEUQFUaGUgaG90a2V5IGlzIGF0dGVtcHRpbmcgdG8gYmVjb21lIGEgZGVsZWdhdGUgd2hlbiB0aGUgaG90a2V5IGlzIGFscmVhZHkgYSBkZWxlZ2F0ZS5UU2V0dGluZ1dlaWdodHNUb29GYXN0ABwE5EEgdHJhbnNhY3RvciBleGNlZWRlZCB0aGUgcmF0ZSBsaW1pdCBmb3Igc2V0dGluZyB3ZWlnaHRzLmRJbmNvcnJlY3RXZWlnaHRWZXJzaW9uS2V5AB0EYQFBIHZhbGlkYXRvciBpcyBhdHRlbXB0aW5nIHRvIHNldCB3ZWlnaHRzIGZyb20gYSB2YWxpZGF0b3Igd2l0aCBpbmNvcnJlY3Qgd2VpZ2h0IHZlcnNpb24uYFNlcnZpbmdSYXRlTGltaXRFeGNlZWRlZAAeBDkBQW4gYXhvbiBvciBwcm9tZXRoZXVzIHNlcnZpbmcgZXhjZWVkZWQgdGhlIHJhdGUgbGltaXQgZm9yIGEgcmVnaXN0ZXJlZCBuZXVyb24ucFVpZHNMZW5ndGhFeGNlZWRVaWRzSW5TdWJOZXQAHwQRAVRoZSBjYWxsZXIgaXMgYXR0ZW1wdGluZyB0byBzZXQgd2VpZ2h0cyB3aXRoIG1vcmUgVUlEcyB0aGFuIGFsbG93ZWQuaE5ldHdvcmtUeFJhdGVMaW1pdEV4Y2VlZGVkACAEBQFBIHRyYW5zYWN0b3IgZXhjZWVkZWQgdGhlIHJhdGUgbGltaXQgZm9yIGFkZCBuZXR3b3JrIHRyYW5zYWN0aW9uLmxEZWxlZ2F0ZVR4UmF0ZUxpbWl0RXhjZWVkZWQAIQT4QSB0cmFuc2FjdG9yIGV4Y2VlZGVkIHRoZSByYXRlIGxpbWl0IGZvciBkZWxlZ2F0ZSB0cmFuc2FjdGlvbi5wSG90S2V5U2V0VHhSYXRlTGltaXRFeGNlZWRlZAAiBBEBQSB0cmFuc2FjdG9yIGV4Y2VlZGVkIHRoZSByYXRlIGxpbWl0IGZvciBzZXR0aW5nIG9yIHN3YXBwaW5nIGhvdGtleS5gU3Rha2luZ1JhdGVMaW1pdEV4Y2VlZGVkACMExEEgdHJhbnNhY3RvciBleGNlZWRlZCB0aGUgcmF0ZSBsaW1pdCBmb3Igc3Rha2luZy5oU3ViTmV0UmVnaXN0cmF0aW9uRGlzYWJsZWQAJARkUmVnaXN0cmF0aW9uIGlzIGRpc2FibGVkLoBUb29NYW55UmVnaXN0cmF0aW9uc1RoaXNJbnRlcnZhbAAlBEEBVGhlIG51bWJlciBvZiByZWdpc3RyYXRpb24gYXR0ZW1wdHMgZXhjZWVkZWQgdGhlIGFsbG93ZWQgbnVtYmVyIGluIHRoZSBpbnRlcnZhbC58VHJhbnNhY3RvckFjY291bnRTaG91bGRCZUhvdEtleQAmBKBUaGUgaG90a2V5IGlzIHJlcXVpcmVkIHRvIGJlIHRoZSBvcmlnaW4uOEZhdWNldERpc2FibGVkACcETEZhdWNldCBpcyBkaXNhYmxlZC44Tm90U3VibmV0T3duZXIAKARMTm90IGEgc3VibmV0IG93bmVyLpBSZWdpc3RyYXRpb25Ob3RQZXJtaXR0ZWRPblJvb3RTdWJuZXQAKQS4T3BlcmF0aW9uIGlzIG5vdCBwZXJtaXR0ZWQgb24gdGhlIHJvb3Qgc3VibmV0LkhTdGFrZVRvb0xvd0ZvclJvb3QAKgQVAUEgaG90a2V5IHdpdGggdG9vIGxpdHRsZSBzdGFrZSBpcyBhdHRlbXB0aW5nIHRvIGpvaW4gdGhlIHJvb3Qgc3VibmV0LlRBbGxOZXR3b3Jrc0luSW1tdW5pdHkAKwScQWxsIHN1Ym5ldHMgYXJlIGluIHRoZSBpbW11bml0eSBwZXJpb2QufE5vdEVub3VnaEJhbGFuY2VUb1BheVN3YXBIb3RLZXkALASoTm90IGVub3VnaCBiYWxhbmNlIHRvIHBheSBzd2FwcGluZyBob3RrZXkuNE5vdFJvb3RTdWJuZXQALQTcTmV0dWlkIGRvZXMgbm90IG1hdGNoIGZvciBzZXR0aW5nIHJvb3QgbmV0d29yayB3ZWlnaHRzLmxDYW5Ob3RTZXRSb290TmV0d29ya1dlaWdodHMALgSkQ2FuIG5vdCBzZXQgd2VpZ2h0cyBmb3IgdGhlIHJvb3QgbmV0d29yay5MTm9OZXVyb25JZEF2YWlsYWJsZQAvBGhObyBuZXVyb24gSUQgaXMgYXZhaWxhYmxlLkhEZWxlZ2F0ZVRha2VUb29Mb3cAMARkRGVsZWdhdGUgdGFrZSBpcyB0b28gbG93LkxEZWxlZ2F0ZVRha2VUb29IaWdoADEEaERlbGVnYXRlIHRha2UgaXMgdG9vIGhpZ2guUE5vV2VpZ2h0c0NvbW1pdEZvdW5kADIIYQFObyBjb21taXQgZm91bmQgZm9yIHRoZSBwcm92aWRlZCBob3RrZXkrbmV0dWlkIGNvbWJpbmF0aW9uIHdoZW4gYXR0ZW1wdGluZyB0byByZXZlYWwgdGhlIHdlaWdodHMufEludmFsaWRSZXZlYWxDb21taXRIYXNoTm90TWF0Y2gAMwTUQ29tbWl0dGVkIGhhc2ggZG9lcyBub3QgZXF1YWwgdGhlIGhhc2hlZCByZXZlYWwgZGF0YS5MQ29tbWl0UmV2ZWFsRW5hYmxlZAA0BPBBdHRlbXB0aW5nIHRvIGNhbGwgc2V0X3dlaWdodHMgd2hlbiBjb21taXQvcmV2ZWFsIGlzIGVuYWJsZWRQQ29tbWl0UmV2ZWFsRGlzYWJsZWQANQTIQXR0ZW10cGluZyB0byBjb21taXQvcmV2ZWFsIHdlaWdodHMgd2hlbiBkaXNhYmxlZC5MTGlxdWlkQWxwaGFEaXNhYmxlZAA2BLxBdHRlbXB0aW5nIHRvIHNldCBhbHBoYSBoaWdoL2xvdyB3aGlsZSBkaXNhYmxlZDxBbHBoYUhpZ2hUb29Mb3cANwScQWxwaGEgaGlnaCBpcyB0b28gbG93OiBhbHBoYV9oaWdoID4gMC44SEFscGhhTG93T3V0T2ZSYW5nZQA4BOxBbHBoYSBsb3cgaXMgb3V0IG9mIHJhbmdlOiBhbHBoYV9sb3cgPiAwICYmIGFscGhhX2xvdyA8IDAuOGBDb2xkS2V5QWxyZWFkeUFzc29jaWF0ZWQAOQSQVGhlIGNvbGRrZXkgaGFzIGFscmVhZHkgYmVlbiBzd2FwcGVkgE5vdEVub3VnaEJhbGFuY2VUb1BheVN3YXBDb2xkS2V5ADoE1FRoZSBjb2xka2V5IGJhbGFuY2UgaXMgbm90IGVub3VnaCB0byBwYXkgZm9yIHRoZSBzd2FwMEludmFsaWRDaGlsZAA7BPRBdHRlbXB0aW5nIHRvIHNldCBhbiBpbnZhbGlkIGNoaWxkIGZvciBhIGhvdGtleSBvbiBhIG5ldHdvcmsuOER1cGxpY2F0ZUNoaWxkADwEmER1cGxpY2F0ZSBjaGlsZCB3aGVuIHNldHRpbmcgY2hpbGRyZW4uSFByb3BvcnRpb25PdmVyZmxvdwA9BKhQcm9wb3J0aW9uIG92ZXJmbG93IHdoZW4gc2V0dGluZyBjaGlsZHJlbi48VG9vTWFueUNoaWxkcmVuAD4EYFRvbyBtYW55IGNoaWxkcmVuIE1BWCA1LkxUeFJhdGVMaW1pdEV4Y2VlZGVkAD8EoERlZmF1bHQgdHJhbnNhY3Rpb24gcmF0ZSBsaW1pdCBleGNlZWRlZC58Q29sZGtleVN3YXBBbm5vdW5jZW1lbnROb3RGb3VuZABABIxDb2xka2V5IHN3YXAgYW5ub3VuY2VtZW50IG5vdCBmb3VuZExDb2xka2V5U3dhcFRvb0Vhcmx5AEEEXENvbGRrZXkgc3dhcCB0b28gZWFybHkueENvbGRrZXlTd2FwUmVhbm5vdW5jZWRUb29FYXJseQBCBIxDb2xka2V5IHN3YXAgcmVhbm5vdW5jZWQgdG9vIGVhcmx5LoBBbm5vdW5jZWRDb2xka2V5SGFzaERvZXNOb3RNYXRjaABDBPxUaGUgYW5ub3VuY2VkIGNvbGRrZXkgaGFzaCBkb2VzIG5vdCBtYXRjaCB0aGUgbmV3IGNvbGRrZXkgaGFzaC5oQ29sZGtleVN3YXBBbHJlYWR5RGlzcHV0ZWQARAR0Q29sZGtleSBzd2FwIGFscmVhZHkgZGlzcHV0ZWRITmV3Q29sZEtleUlzSG90a2V5AEUEVE5ldyBjb2xka2V5IGlzIGhvdGtleUxJbnZhbGlkQ2hpbGRrZXlUYWtlAEYEZENoaWxka2V5IHRha2UgaXMgaW52YWxpZC58VHhDaGlsZGtleVRha2VSYXRlTGltaXRFeGNlZWRlZABHBIhDaGlsZGtleSB0YWtlIHJhdGUgbGltaXQgZXhjZWVkZWQuPEludmFsaWRJZGVudGl0eQBIBERJbnZhbGlkIGlkZW50aXR5LlRNZWNoYW5pc21Eb2VzTm90RXhpc3QASQSAU3VibmV0IG1lY2hhbmlzbSBkb2VzIG5vdCBleGlzdC5EQ2Fubm90VW5zdGFrZUxvY2sASgSMVHJ5aW5nIHRvIHVuc3Rha2UgeW91ciBsb2NrIGFtb3VudC48U3VibmV0Tm90RXhpc3RzAEsEwFRyeWluZyB0byBwZXJmb3JtIGFjdGlvbiBvbiBub24tZXhpc3RlbnQgc3VibmV0LmBUb29NYW55VW5yZXZlYWxlZENvbW1pdHMATARwTWF4aW11bSBjb21taXQgbGltaXQgcmVhY2hlZExFeHBpcmVkV2VpZ2h0Q29tbWl0AE0EtEF0dGVtcHRlZCB0byByZXZlYWwgd2VpZ2h0cyB0aGF0IGFyZSBleHBpcmVkLjhSZXZlYWxUb29FYXJseQBOBJhBdHRlbXB0ZWQgdG8gcmV2ZWFsIHdlaWdodHMgdG9vIGVhcmx5LkxJbnB1dExlbmd0aHNVbmVxdWFsAE8EHQFBdHRlbXB0ZWQgdG8gYmF0Y2ggcmV2ZWFsIHdlaWdodHMgd2l0aCBtaXNtYXRjaGVkIHZlY3RvciBpbnB1dCBsZW5naHRzLmBDb21taXR0aW5nV2VpZ2h0c1Rvb0Zhc3QAUATkQSB0cmFuc2FjdG9yIGV4Y2VlZGVkIHRoZSByYXRlIGxpbWl0IGZvciBzZXR0aW5nIHdlaWdodHMuMEFtb3VudFRvb0xvdwBRBGBTdGFrZSBhbW91bnQgaXMgdG9vIGxvdy5USW5zdWZmaWNpZW50TGlxdWlkaXR5AFIEVE5vdCBlbm91Z2ggbGlxdWlkaXR5LjxTbGlwcGFnZVRvb0hpZ2gAUwSkU2xpcHBhZ2UgaXMgdG9vIGhpZ2ggZm9yIHRoZSB0cmFuc2FjdGlvbi5IVHJhbnNmZXJEaXNhbGxvd2VkAFQEaFN1Ym5ldCBkaXNhbGxvd3MgdHJhbnNmZXIuUEFjdGl2aXR5Q3V0b2ZmVG9vTG93AFUElEFjdGl2aXR5IGN1dG9mZiBpcyBiZWluZyBzZXQgdG9vIGxvdy4wQ2FsbERpc2FibGVkAFYEQENhbGwgaXMgZGlzYWJsZWSIRmlyc3RFbWlzc2lvbkJsb2NrTnVtYmVyQWxyZWFkeVNldABXBKBGaXJzdEVtaXNzaW9uQmxvY2tOdW1iZXIgaXMgYWxyZWFkeSBzZXQufE5lZWRXYWl0aW5nTW9yZUJsb2Nrc1RvU3RhckNhbGwAWAT0bmVlZCB3YWl0IGZvciBtb3JlIGJsb2NrcyB0byBhY2NlcHQgdGhlIHN0YXJ0IGNhbGwgZXh0cmluc2ljLmhOb3RFbm91Z2hBbHBoYU91dFRvUmVjeWNsZQBZBLBOb3QgZW5vdWdoIEFscGhhT3V0IG9uIHRoZSBzdWJuZXQgdG8gcmVjeWNsZXxDYW5ub3RCdXJuT3JSZWN5Y2xlT25Sb290U3VibmV0AFoErENhbm5vdCBidXJuIG9yIHJlY3ljbGUgVEFPIGZyb20gcm9vdCBzdWJuZXRgVW5hYmxlVG9SZWNvdmVyUHVibGljS2V5AFsEfFB1YmxpYyBrZXkgY2Fubm90IGJlIHJlY292ZXJlZC5kSW52YWxpZFJlY292ZXJlZFB1YmxpY0tleQBcBIBSZWNvdmVyZWQgcHVibGljIGtleSBpcyBpbnZhbGlkLkBTdWJ0b2tlbkRpc2FibGVkAF0EVFN1YlRva2VuIGRpc2FibGVkIG5vd4xIb3RLZXlTd2FwT25TdWJuZXRJbnRlcnZhbE5vdFBhc3NlZABeBIhUb28gZnJlcXVlbnQgaG90a2V5IHN3YXAgb24gc3VibmV0SFplcm9NYXhTdGFrZUFtb3VudABfBFRaZXJvIG1heCBzdGFrZSBhbW91bnQoU2FtZU5ldHVpZABgBGhJbnZhbGlkIG5ldHVpZCBkdXBsaWNhdGlvbkxJbnN1ZmZpY2llbnRCYWxhbmNlAGEE6FRoZSBjYWxsZXIgZG9lcyBub3QgaGF2ZSBlbm91Z2ggYmFsYW5jZSBmb3IgdGhlIG9wZXJhdGlvbi6EU3Rha2luZ09wZXJhdGlvblJhdGVMaW1pdEV4Y2VlZGVkAGIEfFRvbyBmcmVxdWVudCBzdGFraW5nIG9wZXJhdGlvbnNcSW52YWxpZExlYXNlQmVuZWZpY2lhcnkAYwTkSW52YWxpZCBsZWFzZSBiZW5lZmljaWFyeSB0byByZWdpc3RlciB0aGUgbGVhc2VkIG5ldHdvcmsuXExlYXNlQ2Fubm90RW5kSW5UaGVQYXN0AGQEdExlYXNlIGNhbm5vdCBlbmQgaW4gdGhlIHBhc3QuTExlYXNlTmV0dWlkTm90Rm91bmQAZQR8Q291bGRuJ3QgZmluZCB0aGUgbGVhc2UgbmV0dWlkLkRMZWFzZURvZXNOb3RFeGlzdABmBFRMZWFzZSBkb2VzIG5vdCBleGlzdC5ITGVhc2VIYXNOb0VuZEJsb2NrAGcEXExlYXNlIGhhcyBubyBlbmQgYmxvY2suQExlYXNlSGFzTm90RW5kZWQAaARQTGVhc2UgaGFzIG5vdCBlbmRlZC4gT3ZlcmZsb3cAaQRUQW4gb3ZlcmZsb3cgb2NjdXJyZWQubEJlbmVmaWNpYXJ5RG9lc05vdE93bkhvdGtleQBqBIBCZW5lZmljaWFyeSBkb2VzIG5vdCBvd24gaG90a2V5LmRFeHBlY3RlZEJlbmVmaWNpYXJ5T3JpZ2luAGsEcEV4cGVjdGVkIGJlbmVmaWNpYXJ5IG9yaWdpbi6gQWRtaW5BY3Rpb25Qcm9oaWJpdGVkRHVyaW5nV2VpZ2h0c1dpbmRvdwBsBAUBQWRtaW4gb3BlcmF0aW9uIGlzIHByb2hpYml0ZWQgZHVyaW5nIHRoZSBwcm90ZWN0ZWQgd2VpZ2h0cyB3aW5kb3dIU3ltYm9sRG9lc05vdEV4aXN0AG0EWFN5bWJvbCBkb2VzIG5vdCBleGlzdC5IU3ltYm9sQWxyZWFkeUluVXNlAG4EWFN5bWJvbCBhbHJlYWR5IGluIHVzZS5wSW5jb3JyZWN0Q29tbWl0UmV2ZWFsVmVyc2lvbgBvBIBJbmNvcnJlY3QgY29tbWl0LXJldmVhbCB2ZXJzaW9uLlBSZXZlYWxQZXJpb2RUb29MYXJnZQBwBGxSZXZlYWwgcGVyaW9kIGlzIHRvbyBsYXJnZS5QUmV2ZWFsUGVyaW9kVG9vU21hbGwAcQRsUmV2ZWFsIHBlcmlvZCBpcyB0b28gc21hbGwuMEludmFsaWRWYWx1ZQByBLhHZW5lcmljIGVycm9yIGZvciBvdXQtb2YtcmFuZ2UgcGFyYW1ldGVyIHZhbHVlSFN1Ym5ldExpbWl0UmVhY2hlZABzBOxTdWJuZXQgbGltaXQgcmVhY2hlZCAmIHRoZXJlIGlzIG5vIGVsaWdpYmxlIHN1Ym5ldCB0byBwcnVuZVBDYW5ub3RBZmZvcmRMb2NrQ29zdAB0BLxJbnN1ZmZpY2llbnQgZnVuZHMgdG8gbWVldCB0aGUgc3VibmV0IGxvY2sgY29zdIBFdm1LZXlBc3NvY2lhdGVSYXRlTGltaXRFeGNlZWRlZAB1BMxleGNlZWRlZCB0aGUgcmF0ZSBsaW1pdCBmb3IgYXNzb2NpYXRpbmcgYW4gRVZNIGtleS50U2FtZUF1dG9TdGFrZUhvdGtleUFscmVhZHlTZXQAdgSIU2FtZSBhdXRvIHN0YWtlIGhvdGtleSBhbHJlYWR5IHNldFxVaWRNYXBDb3VsZE5vdEJlQ2xlYXJlZAB3BLxUaGUgVUlEIG1hcCBmb3IgdGhlIHN1Ym5ldCBjb3VsZCBub3QgYmUgY2xlYXJlZJhUcmltbWluZ1dvdWxkRXhjZWVkTWF4SW1tdW5lUGVyY2VudGFnZQB4BNxUcmltbWluZyB3b3VsZCBleGNlZWQgdGhlIG1heCBpbW11bmUgbmV1cm9ucyBwZXJjZW50YWdlYENoaWxkUGFyZW50SW5jb25zaXN0ZW5jeQB5BNRWaW9sYXRpbmcgdGhlIHJ1bGVzIG9mIENoaWxka2V5LVBhcmVudGtleSBjb25zaXN0ZW5jeUxJbnZhbGlkTnVtUm9vdENsYWltAHoEdEludmFsaWQgbnVtYmVyIG9mIHJvb3QgY2xhaW1zZEludmFsaWRSb290Q2xhaW1UaHJlc2hvbGQAewSUSW52YWxpZCB2YWx1ZSBvZiByb290IGNsYWltIHRocmVzaG9sZExJbnZhbGlkU3VibmV0TnVtYmVyAHwElEV4Y2VlZGVkIHN1Ym5ldCBsaW1pdCBudW1iZXIgb3IgemVyby5cVG9vTWFueVVJRHNQZXJNZWNoYW5pc20AfQQVAVRoZSBtYXhpbXVtIGFsbG93ZWQgVUlEcyB0aW1lcyBtZWNoYW5pc20gY291bnQgc2hvdWxkIG5vdCBleGNlZWQgMjU2LnRWb3RpbmdQb3dlclRyYWNraW5nTm90RW5hYmxlZAB+BNRWb3RpbmcgcG93ZXIgdHJhY2tpbmcgaXMgbm90IGVuYWJsZWQgZm9yIHRoaXMgc3VibmV0LmhJbnZhbGlkVm90aW5nUG93ZXJFbWFBbHBoYQB/BOBJbnZhbGlkIHZvdGluZyBwb3dlciBFTUEgYWxwaGEgdmFsdWUgKG11c3QgYmUgPD0gMTBeMTgpLjRQcmVjaXNpb25Mb3NzAIAEuFVuaW50ZW5kZWQgcHJlY2lzaW9uIGxvc3Mgd2hlbiB1bnN0YWtpbmcgYWxwaGEoRGVwcmVjYXRlZACBBEBEZXByZWNhdGVkIGNhbGwudEFkZFN0YWtlQnVyblJhdGVMaW1pdEV4Y2VlZGVkAIIE2CJBZGQgc3Rha2UgYW5kIGJ1cm4iIGV4Y2VlZGVkIHRoZSBvcGVyYXRpb24gcmF0ZSBsaW1pdASAVGhlIGBFcnJvcmAgZW51bSBvZiB0aGlzIHBhbGxldC5FBwxgcGFsbGV0X3N1YnRlbnNvcl91dGlsaXR5GHBhbGxldBRFcnJvcgQEVAABCDBUb29NYW55Q2FsbHMAAARcVG9vIG1hbnkgY2FsbHMgYmF0Y2hlZC5USW52YWxpZERlcml2ZWRBY2NvdW50AAEElEJhZCBpbnB1dCBkYXRhIGZvciBkZXJpdmVkIGFjY291bnQgSUQEgFRoZSBgRXJyb3JgIGVudW0gb2YgdGhpcyBwYWxsZXQuSQcMLHBhbGxldF9zdWRvGHBhbGxldBRFcnJvcgQEVAABBCxSZXF1aXJlU3VkbwAABIBTZW5kZXIgbXVzdCBiZSB0aGUgU3VkbyBhY2NvdW50LgRoRXJyb3IgZm9yIHRoZSBTdWRvIHBhbGxldC5NBwAABAgABABRBwg8cGFsbGV0X211bHRpc2lnIE11bHRpc2lnECxCbG9ja051bWJlcgEQHEJhbGFuY2UBGCRBY2NvdW50SWQBADBNYXhBcHByb3ZhbHMAABABEHdoZW7wAVhUaW1lcG9pbnQ8QmxvY2tOdW1iZXI+AAEcZGVwb3NpdBgBHEJhbGFuY2UAASRkZXBvc2l0b3IAASRBY2NvdW50SWQAASRhcHByb3ZhbHNVBwGMQm91bmRlZFZlYzxBY2NvdW50SWQsIE1heEFwcHJvdmFscz4AAFUHDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQBAARTAAAEAEECARhWZWM8VD4AAFkHDDxwYWxsZXRfbXVsdGlzaWcYcGFsbGV0FEVycm9yBARUAAE4QE1pbmltdW1UaHJlc2hvbGQAAAR8VGhyZXNob2xkIG11c3QgYmUgMiBvciBncmVhdGVyLjxBbHJlYWR5QXBwcm92ZWQAAQSsQ2FsbCBpcyBhbHJlYWR5IGFwcHJvdmVkIGJ5IHRoaXMgc2lnbmF0b3J5LkROb0FwcHJvdmFsc05lZWRlZAACBJxDYWxsIGRvZXNuJ3QgbmVlZCBhbnkgKG1vcmUpIGFwcHJvdmFscy5EVG9vRmV3U2lnbmF0b3JpZXMAAwSoVGhlcmUgYXJlIHRvbyBmZXcgc2lnbmF0b3JpZXMgaW4gdGhlIGxpc3QuSFRvb01hbnlTaWduYXRvcmllcwAEBKxUaGVyZSBhcmUgdG9vIG1hbnkgc2lnbmF0b3JpZXMgaW4gdGhlIGxpc3QuVFNpZ25hdG9yaWVzT3V0T2ZPcmRlcgAFBA0BVGhlIHNpZ25hdG9yaWVzIHdlcmUgcHJvdmlkZWQgb3V0IG9mIG9yZGVyOyB0aGV5IHNob3VsZCBiZSBvcmRlcmVkLkxTZW5kZXJJblNpZ25hdG9yaWVzAAYEDQFUaGUgc2VuZGVyIHdhcyBjb250YWluZWQgaW4gdGhlIG90aGVyIHNpZ25hdG9yaWVzOyBpdCBzaG91bGRuJ3QgYmUuIE5vdEZvdW5kAAcEoE11bHRpc2lnIG9wZXJhdGlvbiBub3QgZm91bmQgaW4gc3RvcmFnZS4gTm90T3duZXIACAhRAU9ubHkgdGhlIGFjY291bnQgdGhhdCBvcmlnaW5hbGx5IGNyZWF0ZWQgdGhlIG11bHRpc2lnIGlzIGFibGUgdG8gY2FuY2VsIGl0IG9yIHVwZGF0ZTRpdHMgZGVwb3NpdHMuLE5vVGltZXBvaW50AAkEHQFObyB0aW1lcG9pbnQgd2FzIGdpdmVuLCB5ZXQgdGhlIG11bHRpc2lnIG9wZXJhdGlvbiBpcyBhbHJlYWR5IHVuZGVyd2F5LjhXcm9uZ1RpbWVwb2ludAAKBC0BQSBkaWZmZXJlbnQgdGltZXBvaW50IHdhcyBnaXZlbiB0byB0aGUgbXVsdGlzaWcgb3BlcmF0aW9uIHRoYXQgaXMgdW5kZXJ3YXkuTFVuZXhwZWN0ZWRUaW1lcG9pbnQACwT0QSB0aW1lcG9pbnQgd2FzIGdpdmVuLCB5ZXQgbm8gbXVsdGlzaWcgb3BlcmF0aW9uIGlzIHVuZGVyd2F5LjxNYXhXZWlnaHRUb29Mb3cADATQVGhlIG1heGltdW0gd2VpZ2h0IGluZm9ybWF0aW9uIHByb3ZpZGVkIHdhcyB0b28gbG93LjRBbHJlYWR5U3RvcmVkAA0EoFRoZSBkYXRhIHRvIGJlIHN0b3JlZCBpcyBhbHJlYWR5IHN0b3JlZC4EgFRoZSBgRXJyb3JgIGVudW0gb2YgdGhpcyBwYWxsZXQuXQcIPHBhbGxldF9wcmVpbWFnZUBPbGRSZXF1ZXN0U3RhdHVzCCRBY2NvdW50SWQBABxCYWxhbmNlARgBCCxVbnJlcXVlc3RlZAgBHGRlcG9zaXRhBwFQKEFjY291bnRJZCwgQmFsYW5jZSkAAQxsZW4QAQx1MzIAAAAkUmVxdWVzdGVkDAEcZGVwb3NpdGUHAXBPcHRpb248KEFjY291bnRJZCwgQmFsYW5jZSk+AAEUY291bnQQAQx1MzIAAQxsZW7MASxPcHRpb248dTMyPgABAABhBwAABAgAGABlBwQYT3B0aW9uBARUAWEHAQgQTm9uZQAAABBTb21lBABhBwAAAQAAaQcIPHBhbGxldF9wcmVpbWFnZTRSZXF1ZXN0U3RhdHVzCCRBY2NvdW50SWQBABhUaWNrZXQBbQcBCCxVbnJlcXVlc3RlZAgBGHRpY2tldHEHAUwoQWNjb3VudElkLCBUaWNrZXQpAAEMbGVuEAEMdTMyAAAAJFJlcXVlc3RlZAwBMG1heWJlX3RpY2tldHUHAWxPcHRpb248KEFjY291bnRJZCwgVGlja2V0KT4AARRjb3VudBABDHUzMgABJG1heWJlX2xlbswBLE9wdGlvbjx1MzI+AAEAAG0HFDRmcmFtZV9zdXBwb3J0GHRyYWl0cxh0b2tlbnMgZnVuZ2libGVESG9sZENvbnNpZGVyYXRpb24UBEEABEYABFIABEQACEZwAAAEABgBKEY6OkJhbGFuY2UAAHEHAAAECABtBwB1BwQYT3B0aW9uBARUAXEHAQgQTm9uZQAAABBTb21lBABxBwAAAQAAeQcAAAQINBAAfQcMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAEIBFMAAAQAOAEYVmVjPFQ+AACBBww8cGFsbGV0X3ByZWltYWdlGHBhbGxldBRFcnJvcgQEVAABIBhUb29CaWcAAASgUHJlaW1hZ2UgaXMgdG9vIGxhcmdlIHRvIHN0b3JlIG9uLWNoYWluLjBBbHJlYWR5Tm90ZWQAAQSkUHJlaW1hZ2UgaGFzIGFscmVhZHkgYmVlbiBub3RlZCBvbi1jaGFpbi40Tm90QXV0aG9yaXplZAACBMhUaGUgdXNlciBpcyBub3QgYXV0aG9yaXplZCB0byBwZXJmb3JtIHRoaXMgYWN0aW9uLiBOb3ROb3RlZAADBPxUaGUgcHJlaW1hZ2UgY2Fubm90IGJlIHJlbW92ZWQgc2luY2UgaXQgaGFzIG5vdCB5ZXQgYmVlbiBub3RlZC4kUmVxdWVzdGVkAAQECQFBIHByZWltYWdlIG1heSBub3QgYmUgcmVtb3ZlZCB3aGVuIHRoZXJlIGFyZSBvdXRzdGFuZGluZyByZXF1ZXN0cy4wTm90UmVxdWVzdGVkAAUELQFUaGUgcHJlaW1hZ2UgcmVxdWVzdCBjYW5ub3QgYmUgcmVtb3ZlZCBzaW5jZSBubyBvdXRzdGFuZGluZyByZXF1ZXN0cyBleGlzdC4cVG9vTWFueQAGBFUBTW9yZSB0aGFuIGBNQVhfSEFTSF9VUEdSQURFX0JVTEtfQ09VTlRgIGhhc2hlcyB3ZXJlIHJlcXVlc3RlZCB0byBiZSB1cGdyYWRlZCBhdCBvbmNlLhhUb29GZXcABwTkVG9vIGZldyBoYXNoZXMgd2VyZSByZXF1ZXN0ZWQgdG8gYmUgdXBncmFkZWQgKGkuZS4gemVybykuBIBUaGUgYEVycm9yYCBlbnVtIG9mIHRoaXMgcGFsbGV0LoUHDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQBiQcEUwAABACZBwEYVmVjPFQ+AACJBwQYT3B0aW9uBARUAY0HAQgQTm9uZQAAABBTb21lBACNBwAAAQAAjQcIQHBhbGxldF9zY2hlZHVsZXIkU2NoZWR1bGVkFBBOYW1lAQQQQ2FsbAGRByxCbG9ja051bWJlcgEQNFBhbGxldHNPcmlnaW4BjQIkQWNjb3VudElkAQAAFAEgbWF5YmVfaWQBAQEwT3B0aW9uPE5hbWU+AAEgcHJpb3JpdHkIAUhzY2hlZHVsZTo6UHJpb3JpdHkAARBjYWxskQcBEENhbGwAAThtYXliZV9wZXJpb2RpY60CAZRPcHRpb248c2NoZWR1bGU6OlBlcmlvZDxCbG9ja051bWJlcj4+AAEYb3JpZ2lujQIBNFBhbGxldHNPcmlnaW4AAJEHEDRmcmFtZV9zdXBwb3J0GHRyYWl0cyRwcmVpbWFnZXMcQm91bmRlZAgEVAH5AQRIAd0FAQwYTGVnYWN5BAEQaGFzaDQBJEg6Ok91dHB1dAAAABhJbmxpbmUEAJUHATRCb3VuZGVkSW5saW5lAAEAGExvb2t1cAgBEGhhc2g0ASRIOjpPdXRwdXQAAQxsZW4QAQx1MzIAAgAAlQcMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAEIBFMAAAQAOAEYVmVjPFQ+AACZBwAAAokHAJ0HCEBwYWxsZXRfc2NoZWR1bGVyLFJldHJ5Q29uZmlnBBhQZXJpb2QBEAAMATR0b3RhbF9yZXRyaWVzCAEIdTgAASRyZW1haW5pbmcIAQh1OAABGHBlcmlvZBABGFBlcmlvZAAAoQcMQHBhbGxldF9zY2hlZHVsZXIYcGFsbGV0FEVycm9yBARUAAEUQEZhaWxlZFRvU2NoZWR1bGUAAARkRmFpbGVkIHRvIHNjaGVkdWxlIGEgY2FsbCBOb3RGb3VuZAABBHxDYW5ub3QgZmluZCB0aGUgc2NoZWR1bGVkIGNhbGwuXFRhcmdldEJsb2NrTnVtYmVySW5QYXN0AAIEpEdpdmVuIHRhcmdldCBibG9jayBudW1iZXIgaXMgaW4gdGhlIHBhc3QuSFJlc2NoZWR1bGVOb0NoYW5nZQADBPBSZXNjaGVkdWxlIGZhaWxlZCBiZWNhdXNlIGl0IGRvZXMgbm90IGNoYW5nZSBzY2hlZHVsZWQgdGltZS4UTmFtZWQABATQQXR0ZW1wdCB0byB1c2UgYSBub24tbmFtZWQgZnVuY3Rpb24gb24gYSBuYW1lZCB0YXNrLgSAVGhlIGBFcnJvcmAgZW51bSBvZiB0aGlzIHBhbGxldC6lBwAABAipBxgAqQcMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAGtBwRTAAAEALEHARhWZWM8VD4AAK0HCFhwYWxsZXRfc3VidGVuc29yX3Byb3h5PFByb3h5RGVmaW5pdGlvbgwkQWNjb3VudElkAQAkUHJveHlUeXBlAQkBLEJsb2NrTnVtYmVyARAADAEgZGVsZWdhdGUAASRBY2NvdW50SWQAAShwcm94eV90eXBlCQEBJFByb3h5VHlwZQABFGRlbGF5EAEsQmxvY2tOdW1iZXIAALEHAAACrQcAtQcAAAQIuQcYALkHDExib3VuZGVkX2NvbGxlY3Rpb25zLGJvdW5kZWRfdmVjKEJvdW5kZWRWZWMIBFQBvQcEUwAABADBBwEYVmVjPFQ+AAC9BwhYcGFsbGV0X3N1YnRlbnNvcl9wcm94eTBBbm5vdW5jZW1lbnQMJEFjY291bnRJZAEAEEhhc2gBNCxCbG9ja051bWJlcgEQAAwBEHJlYWwAASRBY2NvdW50SWQAASRjYWxsX2hhc2g0ARBIYXNoAAEYaGVpZ2h0EAEsQmxvY2tOdW1iZXIAAMEHAAACvQcAxQcMWHBhbGxldF9zdWJ0ZW5zb3JfcHJveHkYcGFsbGV0FEVycm9yBARUAAEoHFRvb01hbnkAAAQhAVRoZXJlIGFyZSB0b28gbWFueSBwcm94aWVzIHJlZ2lzdGVyZWQgb3IgdG9vIG1hbnkgYW5ub3VuY2VtZW50cyBwZW5kaW5nLiBOb3RGb3VuZAABBHRQcm94eSByZWdpc3RyYXRpb24gbm90IGZvdW5kLiBOb3RQcm94eQACBMxTZW5kZXIgaXMgbm90IGEgcHJveHkgb2YgdGhlIGFjY291bnQgdG8gYmUgcHJveGllZC4sVW5wcm94eWFibGUAAwQhAUEgY2FsbCB3aGljaCBpcyBpbmNvbXBhdGlibGUgd2l0aCB0aGUgcHJveHkgdHlwZSdzIGZpbHRlciB3YXMgYXR0ZW1wdGVkLiREdXBsaWNhdGUABARsQWNjb3VudCBpcyBhbHJlYWR5IGEgcHJveHkuME5vUGVybWlzc2lvbgAFBBUBQ2FsbCBtYXkgbm90IGJlIG1hZGUgYnkgcHJveHkgYmVjYXVzZSBpdCBtYXkgZXNjYWxhdGUgaXRzIHByaXZpbGVnZXMuLFVuYW5ub3VuY2VkAAYE0EFubm91bmNlbWVudCwgaWYgbWFkZSBhdCBhbGwsIHdhcyBtYWRlIHRvbyByZWNlbnRseS4sTm9TZWxmUHJveHkABwRkQ2Fubm90IGFkZCBzZWxmIGFzIHByb3h5LpBBbm5vdW5jZW1lbnREZXBvc2l0SW52YXJpYW50VmlvbGF0ZWQACARVAUludmFyaWFudCB2aW9sYXRlZDogZGVwb3NpdCByZWNvbXB1dGF0aW9uIHJldHVybmVkIE5vbmUgYWZ0ZXIgdXBkYXRpbmcgYW5ub3VuY2VtZW50cy5cSW52YWxpZERlcml2ZWRBY2NvdW50SWQACQT4RmFpbGVkIHRvIGRlcml2ZSBhIHZhbGlkIGFjY291bnQgaWQgZnJvbSB0aGUgcHJvdmlkZWQgZW50cm9weS4EgFRoZSBgRXJyb3JgIGVudW0gb2YgdGhpcyBwYWxsZXQuyQcMPHBhbGxldF9yZWdpc3RyeRR0eXBlczBSZWdpc3RyYXRpb24IHEJhbGFuY2UBGExNYXhBZGRpdGlvbmFsRmllbGRzAAAIARxkZXBvc2l0GAEcQmFsYW5jZQABEGluZm+9AgGESWRlbnRpdHlJbmZvPE1heEFkZGl0aW9uYWxGaWVsZHM+AADNBww8cGFsbGV0X3JlZ2lzdHJ5GHBhbGxldBRFcnJvcgQEVAABDDhDYW5ub3RSZWdpc3RlcgAABDUBQWNjb3VudCBhdHRlbXB0ZWQgdG8gcmVnaXN0ZXIgYW4gaWRlbnRpdHkgYnV0IGRvZXMgbm90IG1lZXQgdGhlIHJlcXVpcmVtZW50cy5sVG9vTWFueUZpZWxkc0luSWRlbnRpdHlJbmZvAAEE7EFjY291bnQgcGFzc2VkIHRvbyBtYW55IGFkZGl0aW9uYWwgZmllbGRzIHRvIHRoZWlyIGlkZW50aXR5NE5vdFJlZ2lzdGVyZWQAAgSoQWNjb3VudCBkb2Vzbid0IGhhdmUgYSByZWdpc3RlcmVkIGlkZW50aXR5BIBUaGUgYEVycm9yYCBlbnVtIG9mIHRoaXMgcGFsbGV0LtEHBCBCVHJlZVNldAQEVAGlBgAEANUHAAAA1QcAAAKlBgDZBwxIcGFsbGV0X2NvbW1pdG1lbnRzFHR5cGVzMFJlZ2lzdHJhdGlvbgwcQmFsYW5jZQEYJE1heEZpZWxkcwAsQmxvY2tOdW1iZXIBEAAMARxkZXBvc2l0GAEcQmFsYW5jZQABFGJsb2NrEAEsQmxvY2tOdW1iZXIAARBpbmZvyQMBZENvbW1pdG1lbnRJbmZvPE1heEZpZWxkcz4AAN0HAAAC4QcA4QcAAAQIOBgA5QcMSHBhbGxldF9jb21taXRtZW50cxR0eXBlczBVc2FnZVRyYWNrZXIAAAgBKGxhc3RfZXBvY2gYAQx1NjQAASh1c2VkX3NwYWNlGAEMdTY0AADpBwxIcGFsbGV0X2NvbW1pdG1lbnRzGHBhbGxldBRFcnJvcgQEVAABEHRUb29NYW55RmllbGRzSW5Db21taXRtZW50SW5mbwAABPRBY2NvdW50IHBhc3NlZCB0b28gbWFueSBhZGRpdGlvbmFsIGZpZWxkcyB0byB0aGVpciBjb21taXRtZW50XEFjY291bnROb3RBbGxvd2VkQ29tbWl0AAEE3EFjY291bnQgaXMgbm90IGFsbG93ZWQgdG8gbWFrZSBjb21taXRtZW50cyB0byB0aGUgY2hhaW5IU3BhY2VMaW1pdEV4Y2VlZGVkAAIEtFNwYWNlIExpbWl0IEV4Y2VlZGVkIGZvciB0aGUgY3VycmVudCBpbnRlcnZhbGxVbmV4cGVjdGVkVW5yZXNlcnZlTGVmdG92ZXIAAwQJAUluZGljYXRlcyB0aGF0IHVucmVzZXJ2ZSByZXR1cm5lZCBhIGxlZnRvdmVyLCB3aGljaCBpcyB1bmV4cGVjdGVkLgSAVGhlIGBFcnJvcmAgZW51bSBvZiB0aGlzIHBhbGxldC7tBwxIcGFsbGV0X2FkbWluX3V0aWxzGHBhbGxldBRFcnJvcgQEVAABLEhTdWJuZXREb2VzTm90RXhpc3QAAATUVGhlIHN1Ym5ldCBkb2VzIG5vdCBleGlzdCwgY2hlY2sgdGhlIG5ldHVpZCBwYXJhbWV0ZXJ4TWF4VmFsaWRhdG9yc0xhcmdlclRoYW5NYXhVSWRzAAEErQFUaGUgbWF4aW11bSBudW1iZXIgb2Ygc3VibmV0IHZhbGlkYXRvcnMgbXVzdCBiZSBsZXNzIHRoYW4gdGhlIG1heGltdW0gbnVtYmVyIG9mIGFsbG93ZWQgVUlEcyBpbiB0aGUgc3VibmV0LoRNYXhBbGxvd2VkVUlkc0xlc3NUaGFuQ3VycmVudFVJZHMAAgStAVRoZSBtYXhpbXVtIG51bWJlciBvZiBzdWJuZXQgdmFsaWRhdG9ycyBtdXN0IGJlIG1vcmUgdGhhbiB0aGUgY3VycmVudCBudW1iZXIgb2YgVUlEcyBhbHJlYWR5IGluIHRoZSBzdWJuZXQucEJvbmRzTW92aW5nQXZlcmFnZU1heFJlYWNoZWQAAwTUVGhlIG1heGltdW0gdmFsdWUgZm9yIGJvbmRzIG1vdmluZyBhdmVyYWdlIGlzIHJlYWNoZWRgTmVnYXRpdmVTaWdtb2lkU3RlZXBuZXNzAAQEzE9ubHkgcm9vdCBjYW4gc2V0IG5lZ2F0aXZlIHNpZ21vaWQgc3RlZXBuZXNzIHZhbHVlc0BWYWx1ZU5vdEluQm91bmRzAAUEcFZhbHVlIG5vdCBpbiBhbGxvd2VkIGJvdW5kcy6QTWluQWxsb3dlZFVpZHNHcmVhdGVyVGhhbkN1cnJlbnRVaWRzAAYEUQFUaGUgbWluaW11bSBhbGxvd2VkIFVJRHMgbXVzdCBiZSBsZXNzIHRoYW4gdGhlIGN1cnJlbnQgbnVtYmVyIG9mIFVJRHMgaW4gdGhlIHN1Ym5ldC6cTWluQWxsb3dlZFVpZHNHcmVhdGVyVGhhbk1heEFsbG93ZWRVaWRzAAcEEQFUaGUgbWluaW11bSBhbGxvd2VkIFVJRHMgbXVzdCBiZSBsZXNzIHRoYW4gdGhlIG1heGltdW0gYWxsb3dlZCBVSURzLpBNYXhBbGxvd2VkVWlkc0xlc3NUaGFuTWluQWxsb3dlZFVpZHMACAQdAVRoZSBtYXhpbXVtIGFsbG93ZWQgVUlEcyBtdXN0IGJlIGdyZWF0ZXIgdGhhbiB0aGUgbWluaW11bSBhbGxvd2VkIFVJRHMuuE1heEFsbG93ZWRVaWRzR3JlYXRlclRoYW5EZWZhdWx0TWF4QWxsb3dlZFVpZHMACQQxAVRoZSBtYXhpbXVtIGFsbG93ZWQgVUlEcyBtdXN0IGJlIGxlc3MgdGhhbiB0aGUgZGVmYXVsdCBtYXhpbXVtIGFsbG93ZWQgVUlEcy4wSW52YWxpZFZhbHVlAAoETEJhZCBwYXJhbWV0ZXIgdmFsdWUEgFRoZSBgRXJyb3JgIGVudW0gb2YgdGhpcyBwYWxsZXQu8QcAAAQIABAA9QcMQHBhbGxldF9zYWZlX21vZGUYcGFsbGV0FEVycm9yBARUAAEcHEVudGVyZWQAAASwVGhlIHNhZmUtbW9kZSBpcyAoYWxyZWFkeSBvciBzdGlsbCkgZW50ZXJlZC4YRXhpdGVkAAEErFRoZSBzYWZlLW1vZGUgaXMgKGFscmVhZHkgb3Igc3RpbGwpIGV4aXRlZC40Tm90Q29uZmlndXJlZAACBAkBVGhpcyBmdW5jdGlvbmFsaXR5IG9mIHRoZSBwYWxsZXQgaXMgZGlzYWJsZWQgYnkgdGhlIGNvbmZpZ3VyYXRpb24uJE5vRGVwb3NpdAADBHRUaGVyZSBpcyBubyBiYWxhbmNlIHJlc2VydmVkLkBBbHJlYWR5RGVwb3NpdGVkAAQEXQFUaGUgYWNjb3VudCBhbHJlYWR5IGhhcyBhIGRlcG9zaXQgcmVzZXJ2ZWQgYW5kIGNhbiB0aGVyZWZvcmUgbm90IGVudGVyIG9yIGV4dGVuZCBhZ2Fpbi5AQ2Fubm90UmVsZWFzZVlldAAFBJBUaGlzIGRlcG9zaXQgY2Fubm90IGJlIHJlbGVhc2VkIHlldC40Q3VycmVuY3lFcnJvcgAGBKBBbiBlcnJvciBmcm9tIHRoZSB1bmRlcmx5aW5nIGBDdXJyZW5jeWAuBIBUaGUgYEVycm9yYCBlbnVtIG9mIHRoaXMgcGFsbGV0LvkHAAAEDDUF/QcRCAD9BwgYZnBfcnBjRFRyYW5zYWN0aW9uU3RhdHVzAAAcAUB0cmFuc2FjdGlvbl9oYXNoNAEQSDI1NgABRHRyYW5zYWN0aW9uX2luZGV4EAEMdTMyAAEQZnJvbcQBHEFkZHJlc3MAAQh0bwEIATxPcHRpb248QWRkcmVzcz4AAUBjb250cmFjdF9hZGRyZXNzAQgBPE9wdGlvbjxBZGRyZXNzPgABEGxvZ3MFCAEgVmVjPExvZz4AAShsb2dzX2Jsb29tCQgBFEJsb29tAAABCAQYT3B0aW9uBARUAcQBCBBOb25lAAAAEFNvbWUEAMQAAAEAAAUIAAACUQEACQgIIGV0aGJsb29tFEJsb29tAAAEAA0IAUBbdTg7IEJMT09NX1NJWkVdAAANCAAAAwABAAAIABEIDCBldGhlcmV1bRxyZWNlaXB0JFJlY2VpcHRWNAABEBhMZWdhY3kEABUIAURFSVA2NThSZWNlaXB0RGF0YQAAABxFSVAyOTMwBAAVCAFIRUlQMjkzMFJlY2VpcHREYXRhAAEAHEVJUDE1NTkEABUIAUhFSVAxNTU5UmVjZWlwdERhdGEAAgAcRUlQNzcwMgQAFQgBSEVJUDc3MDJSZWNlaXB0RGF0YQADAAAVCAwgZXRoZXJldW0ccmVjZWlwdERFSVA2NThSZWNlaXB0RGF0YQAAEAEsc3RhdHVzX2NvZGUIAQh1OAABIHVzZWRfZ2FzWQEBEFUyNTYAAShsb2dzX2Jsb29tCQgBFEJsb29tAAEQbG9ncwUIASBWZWM8TG9nPgAAGQgMIGV0aGVyZXVtFGJsb2NrFEJsb2NrBARUATUFAAwBGGhlYWRlch0IARhIZWFkZXIAATB0cmFuc2FjdGlvbnMlCAEYVmVjPFQ+AAEYb21tZXJzKQgBLFZlYzxIZWFkZXI+AAAdCAwgZXRoZXJldW0YaGVhZGVyGEhlYWRlcgAAPAEscGFyZW50X2hhc2g0ARBIMjU2AAEsb21tZXJzX2hhc2g0ARBIMjU2AAEsYmVuZWZpY2lhcnnEARBIMTYwAAEoc3RhdGVfcm9vdDQBEEgyNTYAAUR0cmFuc2FjdGlvbnNfcm9vdDQBEEgyNTYAATRyZWNlaXB0c19yb290NAEQSDI1NgABKGxvZ3NfYmxvb20JCAEUQmxvb20AAShkaWZmaWN1bHR5WQEBEFUyNTYAARhudW1iZXJZAQEQVTI1NgABJGdhc19saW1pdFkBARBVMjU2AAEgZ2FzX3VzZWRZAQEQVTI1NgABJHRpbWVzdGFtcBgBDHU2NAABKGV4dHJhX2RhdGE4ARRCeXRlcwABIG1peF9oYXNoNAEQSDI1NgABFG5vbmNlIQgBDEg2NAAAIQgMOGV0aGVyZXVtX3R5cGVzEGhhc2gMSDY0AAAEAPEBARxbdTg7IDhdAAAlCAAAAjUFACkIAAACHQgALQgAAAIRCAAxCAAAAv0HADUIDDxwYWxsZXRfZXRoZXJldW0YcGFsbGV0FEVycm9yBARUAAEIQEludmFsaWRTaWduYXR1cmUAAARUU2lnbmF0dXJlIGlzIGludmFsaWQuMFByZUxvZ0V4aXN0cwABBNhQcmUtbG9nIGlzIHByZXNlbnQsIHRoZXJlZm9yZSB0cmFuc2FjdCBpcyBub3QgYWxsb3dlZC4EgFRoZSBgRXJyb3JgIGVudW0gb2YgdGhpcyBwYWxsZXQuOQgIKHBhbGxldF9ldm0wQ29kZU1ldGFkYXRhAAAIARBzaXplGAEMdTY0AAEQaGFzaDQBEEgyNTYAAD0IAAAECMQ0AEEIDChwYWxsZXRfZXZtGHBhbGxldBRFcnJvcgQEVAABPChCYWxhbmNlTG93AAAEkE5vdCBlbm91Z2ggYmFsYW5jZSB0byBwZXJmb3JtIGFjdGlvbixGZWVPdmVyZmxvdwABBIBDYWxjdWxhdGluZyB0b3RhbCBmZWUgb3ZlcmZsb3dlZDxQYXltZW50T3ZlcmZsb3cAAgSQQ2FsY3VsYXRpbmcgdG90YWwgcGF5bWVudCBvdmVyZmxvd2VkOFdpdGhkcmF3RmFpbGVkAAMETFdpdGhkcmF3IGZlZSBmYWlsZWQ4R2FzUHJpY2VUb29Mb3cABARUR2FzIHByaWNlIGlzIHRvbyBsb3cuMEludmFsaWROb25jZQAFBEBOb25jZSBpcyBpbnZhbGlkOEdhc0xpbWl0VG9vTG93AAYEVEdhcyBsaW1pdCBpcyB0b28gbG93LjxHYXNMaW1pdFRvb0hpZ2gABwRYR2FzIGxpbWl0IGlzIHRvbyBoaWdoLjhJbnZhbGlkQ2hhaW5JZAAIBGBUaGUgY2hhaW4gaWQgaXMgaW52YWxpZC5ASW52YWxpZFNpZ25hdHVyZQAJBGR0aGUgc2lnbmF0dXJlIGlzIGludmFsaWQuKFJlZW50cmFuY3kACgQ4RVZNIHJlZW50cmFuY3loVHJhbnNhY3Rpb25NdXN0Q29tZUZyb21FT0EACwQkRUlQLTM2MDcsJFVuZGVmaW5lZAAMBEBVbmRlZmluZWQgZXJyb3IuKE5vdEFsbG93ZWQADQS8T3JpZ2luIGlzIG5vdCBhbGxvd2VkIHRvIHBlcmZvcm0gdGhlIG9wZXJhdGlvbi5YQ3JlYXRlT3JpZ2luTm90QWxsb3dlZAAOBCkBQWRkcmVzcyBub3QgYWxsb3dlZCB0byBkZXBsb3kgY29udHJhY3RzIGVpdGhlciB2aWEgQ1JFQVRFIG9yIENBTEwoQ1JFQVRFKS4EgFRoZSBgRXJyb3JgIGVudW0gb2YgdGhpcyBwYWxsZXQuRQgMMHBhbGxldF9kcmFuZBhwYWxsZXQURXJyb3IEBFQAARgkTm9uZVZhbHVlAAAE+FRoZSB2YWx1ZSByZXRyaWV2ZWQgd2FzIGBOb25lYCBhcyBubyB2YWx1ZSB3YXMgcHJldmlvdXNseSBzZXQuPFN0b3JhZ2VPdmVyZmxvdwABBB0BVGhlcmUgd2FzIGFuIGF0dGVtcHQgdG8gaW5jcmVtZW50IHRoZSB2YWx1ZSBpbiBzdG9yYWdlIG92ZXIgYHUzMjo6TUFYYC5YRHJhbmRDb25uZWN0aW9uRmFpbHVyZQACBGBmYWlsZWQgdG8gY29ubmVjdCB0byB0aGU8VW52ZXJpZmllZFB1bHNlAAMEUHRoZSBwdWxzZSBpcyBpbnZhbGlkSEludmFsaWRSb3VuZE51bWJlcgAEBIh0aGUgcm91bmQgbnVtYmVyIGRpZCBub3QgaW5jcmVtZW50WFB1bHNlVmVyaWZpY2F0aW9uRXJyb3IABQR8dGhlIHB1bHNlIGNvdWxkIG5vdCBiZSB2ZXJpZmllZASAVGhlIGBFcnJvcmAgZW51bSBvZiB0aGlzIHBhbGxldC5JCAhAcGFsbGV0X2Nyb3dkbG9hbjRDcm93ZGxvYW5JbmZvECRBY2NvdW50SWQBABxCYWxhbmNlARgsQmxvY2tOdW1iZXIBEBBDYWxsAZEHACwBHGNyZWF0b3IAASRBY2NvdW50SWQAARxkZXBvc2l0GAEcQmFsYW5jZQABQG1pbl9jb250cmlidXRpb24YARxCYWxhbmNlAAEMZW5kEAEsQmxvY2tOdW1iZXIAAQxjYXAYARxCYWxhbmNlAAE0ZnVuZHNfYWNjb3VudAABJEFjY291bnRJZAABGHJhaXNlZBgBHEJhbGFuY2UAATh0YXJnZXRfYWRkcmVzc+gBRE9wdGlvbjxBY2NvdW50SWQ+AAEQY2FsbE0IATBPcHRpb248Q2FsbD4AASRmaW5hbGl6ZWQkARBib29sAAFIY29udHJpYnV0b3JzX2NvdW50EAEMdTMyAABNCAQYT3B0aW9uBARUAZEHAQgQTm9uZQAAABBTb21lBACRBwAAAQAAUQgINGZyYW1lX3N1cHBvcnQgUGFsbGV0SWQAAAQA8QEBHFt1ODsgOF0AAFUIDEBwYWxsZXRfY3Jvd2Rsb2FuGHBhbGxldBRFcnJvcgQEVAABWDREZXBvc2l0VG9vTG93AAAEpFRoZSBjcm93ZGxvYW4gaW5pdGlhbCBkZXBvc2l0IGlzIHRvbyBsb3cuJENhcFRvb0xvdwABBHRUaGUgY3Jvd2Rsb2FuIGNhcCBpcyB0b28gbG93LmRNaW5pbXVtQ29udHJpYnV0aW9uVG9vTG93AAIEkFRoZSBtaW5pbXVtIGNvbnRyaWJ1dGlvbiBpcyB0b28gbG93LjxDYW5ub3RFbmRJblBhc3QAAwSUVGhlIGNyb3dkbG9hbiBjYW5ub3QgZW5kIGluIHRoZSBwYXN0LlRCbG9ja0R1cmF0aW9uVG9vU2hvcnQABASoVGhlIGNyb3dkbG9hbiBibG9jayBkdXJhdGlvbiBpcyB0b28gc2hvcnQuUEJsb2NrRHVyYXRpb25Ub29Mb25nAAUEfFRoZSBibG9jayBkdXJhdGlvbiBpcyB0b28gbG9uZy5MSW5zdWZmaWNpZW50QmFsYW5jZQAGBFUBVGhlIGFjY291bnQgZG9lcyBub3QgaGF2ZSBlbm91Z2ggYmFsYW5jZSB0byBwYXkgZm9yIHRoZSBpbml0aWFsIGRlcG9zaXQvY29udHJpYnV0aW9uLiBPdmVyZmxvdwAHBFRBbiBvdmVyZmxvdyBvY2N1cnJlZC5ISW52YWxpZENyb3dkbG9hbklkAAgEcFRoZSBjcm93ZGxvYW4gaWQgaXMgaW52YWxpZC4kQ2FwUmFpc2VkAAkEoFRoZSBjcm93ZGxvYW4gY2FwIGhhcyBiZWVuIGZ1bGx5IHJhaXNlZC5cQ29udHJpYnV0aW9uUGVyaW9kRW5kZWQACgSIVGhlIGNvbnRyaWJ1dGlvbiBwZXJpb2QgaGFzIGVuZGVkLkhDb250cmlidXRpb25Ub29Mb3cACwRwVGhlIGNvbnRyaWJ1dGlvbiBpcyB0b28gbG93LjRJbnZhbGlkT3JpZ2luAAwEjFRoZSBvcmlnaW4gb2YgdGhpcyBjYWxsIGlzIGludmFsaWQuQEFscmVhZHlGaW5hbGl6ZWQADQSkVGhlIGNyb3dkbG9hbiBoYXMgYWxyZWFkeSBiZWVuIGZpbmFsaXplZC5oQ29udHJpYnV0aW9uUGVyaW9kTm90RW5kZWQADgTQVGhlIGNyb3dkbG9hbiBjb250cmlidXRpb24gcGVyaW9kIGhhcyBub3QgZW5kZWQgeWV0LjhOb0NvbnRyaWJ1dGlvbgAPBNxUaGUgY29udHJpYnV0b3IgaGFzIG5vIGNvbnRyaWJ1dGlvbiBmb3IgdGhpcyBjcm93ZGxvYW4uMENhcE5vdFJhaXNlZAAQBJhUaGUgY3Jvd2Rsb2FuIGNhcCBoYXMgbm90IGJlZW4gcmFpc2VkLiRVbmRlcmZsb3cAEQRYQW4gdW5kZXJmbG93IG9jY3VycmVkLjxDYWxsVW5hdmFpbGFibGUAEgTcQ2FsbCB0byBkaXNwYXRjaCB3YXMgbm90IGZvdW5kIGluIHRoZSBwcmVpbWFnZSBzdG9yYWdlLkhOb3RSZWFkeVRvRGlzc29sdmUAEwQdAVRoZSBjcm93ZGxvYW4gaXMgbm90IHJlYWR5IHRvIGJlIGRpc3NvbHZlZCwgaXQgc3RpbGwgaGFzIGNvbnRyaWJ1dGlvbnMuYERlcG9zaXRDYW5ub3RCZVdpdGhkcmF3bgAUBMxUaGUgZGVwb3NpdCBjYW5ub3QgYmUgd2l0aGRyYXduIGZyb20gdGhlIGNyb3dkbG9hbi5YTWF4Q29udHJpYnV0b3JzUmVhY2hlZAAVBNBUaGUgbWF4aW11bSBudW1iZXIgb2YgY29udHJpYnV0b3JzIGhhcyBiZWVuIHJlYWNoZWQuBIBUaGUgYEVycm9yYCBlbnVtIG9mIHRoaXMgcGFsbGV0LlkIAAAECKB5AQBdCAxUcGFsbGV0X3N1YnRlbnNvcl9zd2FwEHRpY2sQVGljawAAEAE0bGlxdWlkaXR5X25ldBkFARBpMTI4AAE8bGlxdWlkaXR5X2dyb3NzGAEMdTY0AAEwZmVlc19vdXRfdGFvIQUBGEk2NEY2NAABOGZlZXNfb3V0X2FscGhhIQUBGEk2NEY2NAAAYQgAAAQMoAB1AQBlCAxUcGFsbGV0X3N1YnRlbnNvcl9zd2FwIHBvc2l0aW9uIFBvc2l0aW9uBARUAAAcAQhpZHUBAShQb3NpdGlvbklkAAEYbmV0dWlkoAEYTmV0VWlkAAEgdGlja19sb3d5AQEkVGlja0luZGV4AAEkdGlja19oaWdoeQEBJFRpY2tJbmRleAABJGxpcXVpZGl0eRgBDHU2NAABIGZlZXNfdGFvIQUBGEk2NEY2NAABKGZlZXNfYWxwaGEhBQEYSTY0RjY0AABpCAAABAygbQgQAG0IDFRwYWxsZXRfc3VidGVuc29yX3N3YXAQdGljayhMYXllckxldmVsAAEMDFRvcAAAABhNaWRkbGUAAQAYQm90dG9tAAIAAHEIBChOb25aZXJvVTY0AAAEABgAAAB1CBBUcGFsbGV0X3N1YnRlbnNvcl9zd2FwGHBhbGxldBhwYWxsZXQURXJyb3IEBFQAATg4RmVlUmF0ZVRvb0hpZ2gAAARgVGhlIGZlZSByYXRlIGlzIHRvbyBoaWdoXEluc3VmZmljaWVudElucHV0QW1vdW50AAEExFRoZSBwcm92aWRlZCBhbW91bnQgaXMgaW5zdWZmaWNpZW50IGZvciB0aGUgc3dhcC5USW5zdWZmaWNpZW50TGlxdWlkaXR5AAIE5FRoZSBwcm92aWRlZCBsaXF1aWRpdHkgaXMgaW5zdWZmaWNpZW50IGZvciB0aGUgb3BlcmF0aW9uLkhQcmljZUxpbWl0RXhjZWVkZWQAAwSsVGhlIG9wZXJhdGlvbiB3b3VsZCBleGNlZWQgdGhlIHByaWNlIGxpbWl0LkxJbnN1ZmZpY2llbnRCYWxhbmNlAAQE6FRoZSBjYWxsZXIgZG9lcyBub3QgaGF2ZSBlbm91Z2ggYmFsYW5jZSBmb3IgdGhlIG9wZXJhdGlvbi5ETGlxdWlkaXR5Tm90Rm91bmQABQTIQXR0ZW1wdGVkIHRvIHJlbW92ZSBsaXF1aWRpdHkgdGhhdCBkb2VzIG5vdCBleGlzdC5ASW52YWxpZFRpY2tSYW5nZQAGBIxUaGUgcHJvdmlkZWQgdGljayByYW5nZSBpcyBpbnZhbGlkLlBNYXhQb3NpdGlvbnNFeGNlZWRlZAAHBHxNYXhpbXVtIHVzZXIgcG9zaXRpb25zIGV4Y2VlZGVkQFRvb01hbnlTd2FwU3RlcHMACARMVG9vIG1hbnkgc3dhcCBzdGVwc1RJbnZhbGlkTGlxdWlkaXR5VmFsdWUACQToUHJvdmlkZWQgbGlxdWlkaXR5IHBhcmFtZXRlciBpcyBpbnZhbGlkIChsaWtlbHkgdG9vIHNtYWxsKThSZXNlcnZlc1Rvb0xvdwAKBHxSZXNlcnZlcyB0b28gbG93IGZvciBvcGVyYXRpb24uVE1lY2hhbmlzbURvZXNOb3RFeGlzdAALBGhUaGUgc3VibmV0IGRvZXMgbm90IGV4aXN0LlRVc2VyTGlxdWlkaXR5RGlzYWJsZWQADATYVXNlciBsaXF1aWRpdHkgb3BlcmF0aW9ucyBhcmUgZGlzYWJsZWQgZm9yIHRoaXMgc3VibmV0QFN1YnRva2VuRGlzYWJsZWQADQSkVGhlIHN1Ym5ldCBkb2VzIG5vdCBoYXZlIHN1YnRva2VuIGVuYWJsZWQEgFRoZSBgRXJyb3JgIGVudW0gb2YgdGhpcyBwYWxsZXQueQgMTGJvdW5kZWRfY29sbGVjdGlvbnMsYm91bmRlZF92ZWMoQm91bmRlZFZlYwgEVAEIBFMAAAQAOAEYVmVjPFQ+AAB9CAxAcGFsbGV0X2NvbnRyYWN0cxB3YXNtIENvZGVJbmZvBARUAAAUARRvd25lcgABOEFjY291bnRJZE9mPFQ+AAEcZGVwb3NpdD0CATBCYWxhbmNlT2Y8VD4AASByZWZjb3VudDABDHU2NAABLGRldGVybWluaXNtzQUBLERldGVybWluaXNtAAEgY29kZV9sZW4QAQx1MzIAAIEIDEBwYWxsZXRfY29udHJhY3RzHHN0b3JhZ2UwQ29udHJhY3RJbmZvBARUAAAgARx0cmllX2lklQcBGFRyaWVJZAABJGNvZGVfaGFzaDQBLENvZGVIYXNoPFQ+AAE0c3RvcmFnZV9ieXRlcxABDHUzMgABNHN0b3JhZ2VfaXRlbXMQAQx1MzIAAVBzdG9yYWdlX2J5dGVfZGVwb3NpdBgBMEJhbGFuY2VPZjxUPgABUHN0b3JhZ2VfaXRlbV9kZXBvc2l0GAEwQmFsYW5jZU9mPFQ+AAFQc3RvcmFnZV9iYXNlX2RlcG9zaXQYATBCYWxhbmNlT2Y8VD4AAVRkZWxlZ2F0ZV9kZXBlbmRlbmNpZXOFCAEdAUJvdW5kZWRCVHJlZU1hcDxDb2RlSGFzaDxUPiwgQmFsYW5jZU9mPFQ+LCBUOjoKTWF4RGVsZWdhdGVEZXBlbmRlbmNpZXM+AACFCAxMYm91bmRlZF9jb2xsZWN0aW9uc0Rib3VuZGVkX2J0cmVlX21hcDxCb3VuZGVkQlRyZWVNYXAMBEsBNARWARgEUwAABACJCAE4QlRyZWVNYXA8SywgVj4AAIkIBCBCVHJlZU1hcAgESwE0BFYBGAAEAI0IAAAAjQgAAAKRCACRCAAABAg0GACVCAxAcGFsbGV0X2NvbnRyYWN0cxxzdG9yYWdlUERlbGV0aW9uUXVldWVNYW5hZ2VyBARUAAAIAThpbnNlcnRfY291bnRlchABDHUzMgABOGRlbGV0ZV9jb3VudGVyEAEMdTMyAACZCAxAcGFsbGV0X2NvbnRyYWN0cyBzY2hlZHVsZSBTY2hlZHVsZQQEVAAACAEYbGltaXRznQgBGExpbWl0cwABTGluc3RydWN0aW9uX3dlaWdodHOhCAFUSW5zdHJ1Y3Rpb25XZWlnaHRzPFQ+AACdCAxAcGFsbGV0X2NvbnRyYWN0cyBzY2hlZHVsZRhMaW1pdHMAABwBMGV2ZW50X3RvcGljcxABDHUzMgABMG1lbW9yeV9wYWdlcxABDHUzMgABLHN1YmplY3RfbGVuEAEMdTMyAAEscGF5bG9hZF9sZW4QAQx1MzIAAThydW50aW1lX21lbW9yeRABDHUzMgABYHZhbGlkYXRvcl9ydW50aW1lX21lbW9yeRABDHUzMgABOGV2ZW50X3JlZl90aW1lGAEMdTY0AAChCAxAcGFsbGV0X2NvbnRyYWN0cyBzY2hlZHVsZUhJbnN0cnVjdGlvbldlaWdodHMEBFQAAAQBEGJhc2UQAQx1MzIAAKUIDDRzcF9hcml0aG1ldGljKHBlcl90aGluZ3McUGVyYmlsbAAABAAQAQx1MzIAAKkICEBwYWxsZXRfY29udHJhY3RzLEVudmlyb25tZW50BARUAAAYAShhY2NvdW50X2lkrQgBfEVudmlyb25tZW50VHlwZTxBY2NvdW50SWRPZjxUPj4AARxiYWxhbmNlsQgBdEVudmlyb25tZW50VHlwZTxCYWxhbmNlT2Y8VD4+AAEQaGFzaLUIAchFbnZpcm9ubWVudFR5cGU8PFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+OjpIYXNoPgABGGhhc2hlcrkIAdRFbnZpcm9ubWVudFR5cGU8PFQgYXMgZnJhbWVfc3lzdGVtOjpDb25maWc+OjpIYXNoaW5nPgABJHRpbWVzdGFtcL0IAXBFbnZpcm9ubWVudFR5cGU8TW9tZW50T2Y8VD4+AAEwYmxvY2tfbnVtYmVywQgBiEVudmlyb25tZW50VHlwZTxCbG9ja051bWJlckZvcjxUPj4AAK0ICEBwYWxsZXRfY29udHJhY3RzPEVudmlyb25tZW50VHlwZQQEVAEAAAAAsQgIQHBhbGxldF9jb250cmFjdHM8RW52aXJvbm1lbnRUeXBlBARUARgAAAC1CAhAcGFsbGV0X2NvbnRyYWN0czxFbnZpcm9ubWVudFR5cGUEBFQBNAAAALkICEBwYWxsZXRfY29udHJhY3RzPEVudmlyb25tZW50VHlwZQQEVAHdBQAAAL0ICEBwYWxsZXRfY29udHJhY3RzPEVudmlyb25tZW50VHlwZQQEVAEYAAAAwQgIQHBhbGxldF9jb250cmFjdHM8RW52aXJvbm1lbnRUeXBlBARUARAAAADFCAhAcGFsbGV0X2NvbnRyYWN0cyhBcGlWZXJzaW9uAAAEAKABDHUxNgAAyQgMQHBhbGxldF9jb250cmFjdHMYcGFsbGV0FEVycm9yBARUAAGUPEludmFsaWRTY2hlZHVsZQAABBkBSW52YWxpZCBzY2hlZHVsZSBzdXBwbGllZCwgZS5nLiB3aXRoIHplcm8gd2VpZ2h0IG9mIGEgYmFzaWMgb3BlcmF0aW9uLkBJbnZhbGlkQ2FsbEZsYWdzAAEENQFJbnZhbGlkIGNvbWJpbmF0aW9uIG9mIGZsYWdzIHN1cHBsaWVkIHRvIGBzZWFsX2NhbGxgIG9yIGBzZWFsX2RlbGVnYXRlX2NhbGxgLiBPdXRPZkdhcwACBLhUaGUgZXhlY3V0ZWQgY29udHJhY3QgZXhoYXVzdGVkIGl0cyBnYXMgbGltaXQuUE91dHB1dEJ1ZmZlclRvb1NtYWxsAAMEAQFUaGUgb3V0cHV0IGJ1ZmZlciBzdXBwbGllZCB0byBhIGNvbnRyYWN0IEFQSSBjYWxsIHdhcyB0b28gc21hbGwuOFRyYW5zZmVyRmFpbGVkAAQINQFQZXJmb3JtaW5nIHRoZSByZXF1ZXN0ZWQgdHJhbnNmZXIgZmFpbGVkLiBQcm9iYWJseSBiZWNhdXNlIHRoZXJlIGlzbid0IGVub3VnaJRmcmVlIGJhbGFuY2UgaW4gdGhlIHNlbmRlcidzIGFjY291bnQuTE1heENhbGxEZXB0aFJlYWNoZWQABQghAVBlcmZvcm1pbmcgYSBjYWxsIHdhcyBkZW5pZWQgYmVjYXVzZSB0aGUgY2FsbGluZyBkZXB0aCByZWFjaGVkIHRoZSBsaW1pdJRvZiB3aGF0IGlzIHNwZWNpZmllZCBpbiB0aGUgc2NoZWR1bGUuQENvbnRyYWN0Tm90Rm91bmQABgS8Tm8gY29udHJhY3Qgd2FzIGZvdW5kIGF0IHRoZSBzcGVjaWZpZWQgYWRkcmVzcy4wQ29kZVRvb0xhcmdlAAcIPQFUaGUgY29kZSBzdXBwbGllZCB0byBgaW5zdGFudGlhdGVfd2l0aF9jb2RlYCBleGNlZWRzIHRoZSBsaW1pdCBzcGVjaWZpZWQgaW4gdGhlRGN1cnJlbnQgc2NoZWR1bGUuMENvZGVOb3RGb3VuZAAIBMRObyBjb2RlIGNvdWxkIGJlIGZvdW5kIGF0IHRoZSBzdXBwbGllZCBjb2RlIGhhc2guQENvZGVJbmZvTm90Rm91bmQACQTYTm8gY29kZSBpbmZvIGNvdWxkIGJlIGZvdW5kIGF0IHRoZSBzdXBwbGllZCBjb2RlIGhhc2guLE91dE9mQm91bmRzAAoEJQFBIGJ1ZmZlciBvdXRzaWRlIG9mIHNhbmRib3ggbWVtb3J5IHdhcyBwYXNzZWQgdG8gYSBjb250cmFjdCBBUEkgZnVuY3Rpb24uOERlY29kaW5nRmFpbGVkAAsEKQFJbnB1dCBwYXNzZWQgdG8gYSBjb250cmFjdCBBUEkgZnVuY3Rpb24gZmFpbGVkIHRvIGRlY29kZSBhcyBleHBlY3RlZCB0eXBlLjxDb250cmFjdFRyYXBwZWQADASIQ29udHJhY3QgdHJhcHBlZCBkdXJpbmcgZXhlY3V0aW9uLjRWYWx1ZVRvb0xhcmdlAA0EzFRoZSBzaXplIGRlZmluZWQgaW4gYFQ6Ok1heFZhbHVlU2l6ZWAgd2FzIGV4Y2VlZGVkLmBUZXJtaW5hdGVkV2hpbGVSZWVudHJhbnQADggZAVRlcm1pbmF0aW9uIG9mIGEgY29udHJhY3QgaXMgbm90IGFsbG93ZWQgd2hpbGUgdGhlIGNvbnRyYWN0IGlzIGFscmVhZHngb24gdGhlIGNhbGwgc3RhY2suIENhbiBiZSB0cmlnZ2VyZWQgYnkgYHNlYWxfdGVybWluYXRlYC44SW5wdXRGb3J3YXJkZWQADwRBAWBzZWFsX2NhbGxgIGZvcndhcmRlZCB0aGlzIGNvbnRyYWN0cyBpbnB1dC4gSXQgdGhlcmVmb3JlIGlzIG5vIGxvbmdlciBhdmFpbGFibGUuUFJhbmRvbVN1YmplY3RUb29Mb25nABAE2FRoZSBzdWJqZWN0IHBhc3NlZCB0byBgc2VhbF9yYW5kb21gIGV4Y2VlZHMgdGhlIGxpbWl0LjRUb29NYW55VG9waWNzABEEHQFUaGUgYW1vdW50IG9mIHRvcGljcyBwYXNzZWQgdG8gYHNlYWxfZGVwb3NpdF9ldmVudHNgIGV4Y2VlZHMgdGhlIGxpbWl0LkBOb0NoYWluRXh0ZW5zaW9uABIMRQFUaGUgY2hhaW4gZG9lcyBub3QgcHJvdmlkZSBhIGNoYWluIGV4dGVuc2lvbi4gQ2FsbGluZyB0aGUgY2hhaW4gZXh0ZW5zaW9uIHJlc3VsdHNNAWluIHRoaXMgZXJyb3IuIE5vdGUgdGhhdCB0aGlzIHVzdWFsbHkgIHNob3VsZG4ndCBoYXBwZW4gYXMgZGVwbG95aW5nIHN1Y2ggY29udHJhY3RzMGlzIHJlamVjdGVkLjxYQ01EZWNvZGVGYWlsZWQAEwSERmFpbGVkIHRvIGRlY29kZSB0aGUgWENNIHByb2dyYW0uRER1cGxpY2F0ZUNvbnRyYWN0ABQEyEEgY29udHJhY3Qgd2l0aCB0aGUgc2FtZSBBY2NvdW50SWQgYWxyZWFkeSBleGlzdHMuXFRlcm1pbmF0ZWRJbkNvbnN0cnVjdG9yABUMuEEgY29udHJhY3Qgc2VsZiBkZXN0cnVjdGVkIGluIGl0cyBjb25zdHJ1Y3Rvci4A0FRoaXMgY2FuIGJlIHRyaWdnZXJlZCBieSBhIGNhbGwgdG8gYHNlYWxfdGVybWluYXRlYC5AUmVlbnRyYW5jZURlbmllZAAWEA0BQSBjYWxsIHRyaWVkIHRvIGludm9rZSBhIGNvbnRyYWN0IHRoYXQgaXMgZmxhZ2dlZCBhcyBub24tcmVlbnRyYW50Ll0BVGhlIG9ubHkgb3RoZXIgY2F1c2UgaXMgdGhhdCBhIGNhbGwgZnJvbSBhIGNvbnRyYWN0IGludG8gdGhlIHJ1bnRpbWUgdHJpZWQgdG8gY2FsbCBiYWNrSQFpbnRvIGBwYWxsZXQtY29udHJhY3RzYC4gVGhpcyB3b3VsZCBtYWtlIHRoZSB3aG9sZSBwYWxsZXQgcmVlbnRyYW50IHdpdGggcmVnYXJkIHRvvGNvbnRyYWN0IGNvZGUgZXhlY3V0aW9uIHdoaWNoIGlzIG5vdCBzdXBwb3J0ZWQuRFN0YXRlQ2hhbmdlRGVuaWVkABcETQFBIGNvbnRyYWN0IGF0dGVtcHRlZCB0byBpbnZva2UgYSBzdGF0ZSBtb2RpZnlpbmcgQVBJIHdoaWxlIGJlaW5nIGluIHJlYWQtb25seSBtb2RlLnBTdG9yYWdlRGVwb3NpdE5vdEVub3VnaEZ1bmRzABgEIQFPcmlnaW4gZG9lc24ndCBoYXZlIGVub3VnaCBiYWxhbmNlIHRvIHBheSB0aGUgcmVxdWlyZWQgc3RvcmFnZSBkZXBvc2l0cy5wU3RvcmFnZURlcG9zaXRMaW1pdEV4aGF1c3RlZAAZBA0BTW9yZSBzdG9yYWdlIHdhcyBjcmVhdGVkIHRoYW4gYWxsb3dlZCBieSB0aGUgc3RvcmFnZSBkZXBvc2l0IGxpbWl0LiRDb2RlSW5Vc2UAGgRJAUNvZGUgcmVtb3ZhbCB3YXMgZGVuaWVkIGJlY2F1c2UgdGhlIGNvZGUgaXMgc3RpbGwgaW4gdXNlIGJ5IGF0IGxlYXN0IG9uZSBjb250cmFjdC5AQ29udHJhY3RSZXZlcnRlZAAbECUBVGhlIGNvbnRyYWN0IHJhbiB0byBjb21wbGV0aW9uIGJ1dCBkZWNpZGVkIHRvIHJldmVydCBpdHMgc3RvcmFnZSBjaGFuZ2VzLkkBUGxlYXNlIG5vdGUgdGhhdCB0aGlzIGVycm9yIGlzIG9ubHkgcmV0dXJuZWQgZnJvbSBleHRyaW5zaWNzLiBXaGVuIGNhbGxlZCBkaXJlY3RseV0Bb3IgdmlhIFJQQyBhbiBgT2tgIHdpbGwgYmUgcmV0dXJuZWQuIEluIHRoaXMgY2FzZSB0aGUgY2FsbGVyIG5lZWRzIHRvIGluc3BlY3QgdGhlIGZsYWdzxHRvIGRldGVybWluZSB3aGV0aGVyIGEgcmV2ZXJzaW9uIGhhcyB0YWtlbiBwbGFjZS4wQ29kZVJlamVjdGVkABwg+FRoZSBjb250cmFjdCdzIGNvZGUgd2FzIGZvdW5kIHRvIGJlIGludmFsaWQgZHVyaW5nIHZhbGlkYXRpb24uAE0BVGhlIG1vc3QgbGlrZWx5IGNhdXNlIG9mIHRoaXMgaXMgdGhhdCBhbiBBUEkgd2FzIHVzZWQgd2hpY2ggaXMgbm90IHN1cHBvcnRlZCBieSB0aGVRAW5vZGUuIFRoaXMgaGFwcGVucyBpZiBhbiBvbGRlciBub2RlIGlzIHVzZWQgd2l0aCBhIG5ldyB2ZXJzaW9uIG9mIGluayEuIFRyeSB1cGRhdGluZ6h5b3VyIG5vZGUgdG8gdGhlIG5ld2VzdCBhdmFpbGFibGUgdmVyc2lvbi4AUQFBIG1vcmUgZGV0YWlsZWQgZXJyb3IgY2FuIGJlIGZvdW5kIG9uIHRoZSBub2RlIGNvbnNvbGUgaWYgZGVidWcgbWVzc2FnZXMgYXJlIGVuYWJsZWSoYnkgc3VwcGx5aW5nIGAtbHJ1bnRpbWU6OmNvbnRyYWN0cz1kZWJ1Z2AuPEluZGV0ZXJtaW5pc3RpYwAdBCkBQW4gaW5kZXRlcm1pbmlzdGljIGNvZGUgd2FzIHVzZWQgaW4gYSBjb250ZXh0IHdoZXJlIHRoaXMgaXMgbm90IHBlcm1pdHRlZC5MTWlncmF0aW9uSW5Qcm9ncmVzcwAeBCUBQSBwZW5kaW5nIG1pZ3JhdGlvbiBuZWVkcyB0byBjb21wbGV0ZSBiZWZvcmUgdGhlIGV4dHJpbnNpYyBjYW4gYmUgY2FsbGVkLlBOb01pZ3JhdGlvblBlcmZvcm1lZAAfBA0BTWlncmF0ZSBkaXNwYXRjaCBjYWxsIHdhcyBhdHRlbXB0ZWQgYnV0IG5vIG1pZ3JhdGlvbiB3YXMgcGVyZm9ybWVkLnhNYXhEZWxlZ2F0ZURlcGVuZGVuY2llc1JlYWNoZWQAIAQVAVRoZSBjb250cmFjdCBoYXMgcmVhY2hlZCBpdHMgbWF4aW11bSBudW1iZXIgb2YgZGVsZWdhdGUgZGVwZW5kZW5jaWVzLmhEZWxlZ2F0ZURlcGVuZGVuY3lOb3RGb3VuZAAhBBUBVGhlIGRlcGVuZGVuY3kgd2FzIG5vdCBmb3VuZCBpbiB0aGUgY29udHJhY3QncyBkZWxlZ2F0ZSBkZXBlbmRlbmNpZXMufERlbGVnYXRlRGVwZW5kZW5jeUFscmVhZHlFeGlzdHMAIgT4VGhlIGNvbnRyYWN0IGFscmVhZHkgZGVwZW5kcyBvbiB0aGUgZ2l2ZW4gZGVsZWdhdGUgZGVwZW5kZW5jeS6EQ2Fubm90QWRkU2VsZkFzRGVsZWdhdGVEZXBlbmRlbmN5ACMEKQFDYW4gbm90IGFkZCBhIGRlbGVnYXRlIGRlcGVuZGVuY3kgdG8gdGhlIGNvZGUgaGFzaCBvZiB0aGUgY29udHJhY3QgaXRzZWxmLlRPdXRPZlRyYW5zaWVudFN0b3JhZ2UAJASsQ2FuIG5vdCBhZGQgbW9yZSBkYXRhIHRvIHRyYW5zaWVudCBzdG9yYWdlLgSAVGhlIGBFcnJvcmAgZW51bSBvZiB0aGlzIHBhbGxldC7NCAw0cGFsbGV0X3NoaWVsZBhwYWxsZXQoU3VibWlzc2lvbgwkQWNjb3VudElkAQAsQmxvY2tOdW1iZXIBEBBIYXNoATQAEAEYYXV0aG9yAAEkQWNjb3VudElkAAEoY29tbWl0bWVudDQBEEhhc2gAAShjaXBoZXJ0ZXh02QUBeEJvdW5kZWRWZWM8dTgsIENvbnN0VTMyPDgxOTI+PgABMHN1Ym1pdHRlZF9pbhABLEJsb2NrTnVtYmVyAADRCAw0cGFsbGV0X3NoaWVsZBhwYWxsZXQURXJyb3IEBFQAARxcU3VibWlzc2lvbkFscmVhZHlFeGlzdHMAAAT4QSBzdWJtaXNzaW9uIHdpdGggdGhlIHNhbWUgaWQgYWxyZWFkeSBleGlzdHMgaW4gYFN1Ym1pc3Npb25zYC5ETWlzc2luZ1N1Ym1pc3Npb24AAQT0VGhlIHJlZmVyZW5jZWQgc3VibWlzc2lvbiBpZCBkb2VzIG5vdCBleGlzdCBpbiBgU3VibWlzc2lvbnNgLkhDb21taXRtZW50TWlzbWF0Y2gAAgT8VGhlIHJlY29tcHV0ZWQgY29tbWl0bWVudCBkb2VzIG5vdCBtYXRjaCB0aGUgc3RvcmVkIGNvbW1pdG1lbnQuQFNpZ25hdHVyZUludmFsaWQAAwTMVGhlIHByb3ZpZGVkIHNpZ25hdHVyZSBvdmVyIHRoZSBwYXlsb2FkIGlzIGludmFsaWQuPEJhZFB1YmxpY0tleUxlbgAEBNBUaGUgYW5ub3VuY2VkIE1M4oCRS0VNIHB1YmxpYyBrZXkgbGVuZ3RoIGlzIGludmFsaWQuKEtleUV4cGlyZWQABQRVAVRoZSBNRVbigJFTaGllbGQga2V5IGVwb2NoIGZvciB0aGlzIHN1Ym1pc3Npb24gaGFzIGV4cGlyZWQgYW5kIGlzIG5vIGxvbmdlciBhY2NlcHRlZC48S2V5SGFzaE1pc21hdGNoAAYEDQFUaGUgcHJvdmlkZWQgYGtleV9oYXNoYCBkb2VzIG5vdCBtYXRjaCB0aGUgZXhwZWN0ZWQgZXBvY2gga2V5IGhhc2guBIBUaGUgYEVycm9yYCBlbnVtIG9mIHRoaXMgcGFsbGV0LtUICChzcF9ydW50aW1lWEV4dHJpbnNpY0luY2x1c2lvbk1vZGUAAQg0QWxsRXh0cmluc2ljcwAAADRPbmx5SW5oZXJlbnRzAAEAANkICBxzcF9jb3JlOE9wYXF1ZU1ldGFkYXRhAAAEADgBHFZlYzx1OD4AAN0IBBhPcHRpb24EBFQB2QgBCBBOb25lAAAAEFNvbWUEANkIAAABAADhCAAAAhAA5QgEGFJlc3VsdAgEVAGoBEUB6QgBCAhPawQAqAAAAAAMRXJyBADpCAAAAQAA6QgMKHNwX3J1bnRpbWVQdHJhbnNhY3Rpb25fdmFsaWRpdHlgVHJhbnNhY3Rpb25WYWxpZGl0eUVycm9yAAEIHEludmFsaWQEAO0IAUhJbnZhbGlkVHJhbnNhY3Rpb24AAAAcVW5rbm93bgQA8QgBSFVua25vd25UcmFuc2FjdGlvbgABAADtCAwoc3BfcnVudGltZVB0cmFuc2FjdGlvbl92YWxpZGl0eUhJbnZhbGlkVHJhbnNhY3Rpb24AATQQQ2FsbAAAABxQYXltZW50AAEAGEZ1dHVyZQACABRTdGFsZQADACBCYWRQcm9vZgAEAERBbmNpZW50QmlydGhCbG9jawAFAERFeGhhdXN0c1Jlc291cmNlcwAGABhDdXN0b20EAAgBCHU4AAcAMEJhZE1hbmRhdG9yeQAIAExNYW5kYXRvcnlWYWxpZGF0aW9uAAkAJEJhZFNpZ25lcgAKAFRJbmRldGVybWluYXRlSW1wbGljaXQACwA0VW5rbm93bk9yaWdpbgAMAADxCAwoc3BfcnVudGltZVB0cmFuc2FjdGlvbl92YWxpZGl0eUhVbmtub3duVHJhbnNhY3Rpb24AAQwwQ2Fubm90TG9va3VwAAAATE5vVW5zaWduZWRWYWxpZGF0b3IAAQAYQ3VzdG9tBAAIAQh1OAACAAD1CAgwc3BfaW5oZXJlbnRzMEluaGVyZW50RGF0YQAABAEQZGF0YfkIAZRCVHJlZU1hcDxJbmhlcmVudElkZW50aWZpZXIsIFZlYzx1OD4+AAD5CAQgQlRyZWVNYXAIBEsB8QEEVgE4AAQA/QgAAAD9CAAAAgEJAAEJAAAECPEBOAAFCQgwc3BfaW5oZXJlbnRzUENoZWNrSW5oZXJlbnRzUmVzdWx0AAAMARBva2F5JAEQYm9vbAABLGZhdGFsX2Vycm9yJAEQYm9vbAABGGVycm9yc/UIATBJbmhlcmVudERhdGEAAAkJBBhSZXN1bHQIBFQBrARFAUEBAQgIT2sEAKwAAAAADEVycgQAQQEAAAEAAA0JBBhPcHRpb24EBFQBQQEBCBBOb25lAAAAEFNvbWUEAEEBAAABAAARCQAAAkEBABUJDChzcF9ydW50aW1lUHRyYW5zYWN0aW9uX3ZhbGlkaXR5RFRyYW5zYWN0aW9uU291cmNlAAEMHEluQmxvY2sAAAAUTG9jYWwAAQAgRXh0ZXJuYWwAAgAAGQkEGFJlc3VsdAgEVAEdCQRFAekIAQgIT2sEAB0JAAAAAAxFcnIEAOkIAAABAAAdCQwoc3BfcnVudGltZVB0cmFuc2FjdGlvbl92YWxpZGl0eUBWYWxpZFRyYW5zYWN0aW9uAAAUASBwcmlvcml0eRgBTFRyYW5zYWN0aW9uUHJpb3JpdHkAASByZXF1aXJlc8UBAUxWZWM8VHJhbnNhY3Rpb25UYWc+AAEgcHJvdmlkZXPFAQFMVmVjPFRyYW5zYWN0aW9uVGFnPgABJGxvbmdldml0eRgBUFRyYW5zYWN0aW9uTG9uZ2V2aXR5AAEkcHJvcGFnYXRlJAEQYm9vbAAAIQkISHNwX2NvbnNlbnN1c19zbG90czBTbG90RHVyYXRpb24AAAQAGAEMdTY0AAAlCQQYT3B0aW9uBARUASkJAQgQTm9uZQAAABBTb21lBAApCQAAAQAAKQkAAAItCQAtCQAABAg4MQkAMQkMHHNwX2NvcmUYY3J5cHRvJEtleVR5cGVJZAAABABIARxbdTg7IDRdAAA1CQgoc3BfcnVudGltZSxPcGFxdWVWYWx1ZQAABAA4ARxWZWM8dTg+AAA5CQQYT3B0aW9uBARUAawBCBBOb25lAAAAEFNvbWUEAKwAAAEAAD0JBBhPcHRpb24EBFQBNQkBCBBOb25lAAAAEFNvbWUEADUJAAABAABBCQxocGFsbGV0X3RyYW5zYWN0aW9uX3BheW1lbnQUdHlwZXNMUnVudGltZURpc3BhdGNoSW5mbwgcQmFsYW5jZQEYGFdlaWdodAEsAAwBGHdlaWdodCwBGFdlaWdodAABFGNsYXNzYAE0RGlzcGF0Y2hDbGFzcwABLHBhcnRpYWxfZmVlGAEcQmFsYW5jZQAARQkMaHBhbGxldF90cmFuc2FjdGlvbl9wYXltZW50FHR5cGVzKEZlZURldGFpbHMEHEJhbGFuY2UBGAAIATRpbmNsdXNpb25fZmVlSQkBdE9wdGlvbjxJbmNsdXNpb25GZWU8QmFsYW5jZT4+AAEMdGlwGAEcQmFsYW5jZQAASQkEGE9wdGlvbgQEVAFNCQEIEE5vbmUAAAAQU29tZQQATQkAAAEAAE0JDGhwYWxsZXRfdHJhbnNhY3Rpb25fcGF5bWVudBR0eXBlczBJbmNsdXNpb25GZWUEHEJhbGFuY2UBGAAMASBiYXNlX2ZlZRgBHEJhbGFuY2UAARxsZW5fZmVlGAEcQmFsYW5jZQABTGFkanVzdGVkX3dlaWdodF9mZWUYARxCYWxhbmNlAABRCQwMZXZtHGJhY2tlbmQUQmFzaWMAAAgBHGJhbGFuY2VZAQEQVTI1NgABFG5vbmNlWQEBEFUyNTYAAFUJBBhPcHRpb24EBFQBdQUBCBBOb25lAAAAEFNvbWUEAHUFAAABAABZCQQYT3B0aW9uBARUAWEFAQgQTm9uZQAAABBTb21lBABhBQAAAQAAXQkEGFJlc3VsdAgEVAFhCQRFAWgBCAhPawQAYQkAAAAADEVycgQAaAAAAQAAYQkIGGZwX2V2bTxFeGVjdXRpb25JbmZvVjIEBFQBOAAUASxleGl0X3JlYXNvbi0BAShFeGl0UmVhc29uAAEUdmFsdWU4AQRUAAEgdXNlZF9nYXNlCQEcVXNlZEdhcwABLHdlaWdodF9pbmZvaQkBSE9wdGlvbjxXZWlnaHRJbmZvPgABEGxvZ3MFCAEgVmVjPExvZz4AAGUJCBhmcF9ldm0cVXNlZEdhcwAACAEgc3RhbmRhcmRZAQEQVTI1NgABJGVmZmVjdGl2ZVkBARBVMjU2AABpCQQYT3B0aW9uBARUAW0JAQgQTm9uZQAAABBTb21lBABtCQAAAQAAbQkIGGZwX2V2bShXZWlnaHRJbmZvAAAQAThyZWZfdGltZV9saW1pdHEJASxPcHRpb248dTY0PgABQHByb29mX3NpemVfbGltaXRxCQEsT3B0aW9uPHU2ND4AAThyZWZfdGltZV91c2FnZXEJASxPcHRpb248dTY0PgABQHByb29mX3NpemVfdXNhZ2VxCQEsT3B0aW9uPHU2ND4AAHEJBBhPcHRpb24EBFQBGAEIEE5vbmUAAAAQU29tZQQAGAAAAQAAdQkEGFJlc3VsdAgEVAF5CQRFAWgBCAhPawQAeQkAAAAADEVycgQAaAAAAQAAeQkIGGZwX2V2bTxFeGVjdXRpb25JbmZvVjIEBFQBxAAUASxleGl0X3JlYXNvbi0BAShFeGl0UmVhc29uAAEUdmFsdWXEAQRUAAEgdXNlZF9nYXNlCQEcVXNlZEdhcwABLHdlaWdodF9pbmZvaQkBSE9wdGlvbjxXZWlnaHRJbmZvPgABEGxvZ3MFCAEgVmVjPExvZz4AAH0JBBhPcHRpb24EBFQBGQgBCBBOb25lAAAAEFNvbWUEABkIAAABAACBCQQYT3B0aW9uBARUAS0IAQgQTm9uZQAAABBTb21lBAAtCAAAAQAAhQkEGE9wdGlvbgQEVAExCAEIEE5vbmUAAAAQU29tZQQAMQgAAAEAAIkJAAAEDH0JgQmFCQCNCQQYT3B0aW9uBARUAWEBAQgQTm9uZQAAABBTb21lBABhAQAAAQAAkQkAAAQIfQmFCQCVCQxAcGFsbGV0X2NvbnRyYWN0cyhwcmltaXRpdmVzOENvbnRyYWN0UmVzdWx0DARSAZkJHEJhbGFuY2UBGCxFdmVudFJlY29yZAFQABgBMGdhc19jb25zdW1lZCwBGFdlaWdodAABMGdhc19yZXF1aXJlZCwBGFdlaWdodAABPHN0b3JhZ2VfZGVwb3NpdKUJAVxTdG9yYWdlRGVwb3NpdDxCYWxhbmNlPgABNGRlYnVnX21lc3NhZ2U4ARxWZWM8dTg+AAEYcmVzdWx0mQkBBFIAARhldmVudHOpCQFgT3B0aW9uPFZlYzxFdmVudFJlY29yZD4+AACZCQQYUmVzdWx0CARUAZ0JBEUBaAEICE9rBACdCQAAAAAMRXJyBABoAAABAACdCQxAcGFsbGV0X2NvbnRyYWN0cyhwcmltaXRpdmVzPEV4ZWNSZXR1cm5WYWx1ZQAACAEUZmxhZ3OhCQEsUmV0dXJuRmxhZ3MAARBkYXRhOAEcVmVjPHU4PgAAoQkMVHBhbGxldF9jb250cmFjdHNfdWFwaRRmbGFncyxSZXR1cm5GbGFncwAABAEQYml0cxABDHUzMgAApQkMQHBhbGxldF9jb250cmFjdHMocHJpbWl0aXZlczhTdG9yYWdlRGVwb3NpdAQcQmFsYW5jZQEYAQgYUmVmdW5kBAAYARxCYWxhbmNlAAAAGENoYXJnZQQAGAEcQmFsYW5jZQABAACpCQQYT3B0aW9uBARUAa0JAQgQTm9uZQAAABBTb21lBACtCQAAAQAArQkAAAJQALEJDEBwYWxsZXRfY29udHJhY3RzKHByaW1pdGl2ZXMQQ29kZQQQSGFzaAE0AQgYVXBsb2FkBAA4ARxWZWM8dTg+AAAAIEV4aXN0aW5nBAA0ARBIYXNoAAEAALUJDEBwYWxsZXRfY29udHJhY3RzKHByaW1pdGl2ZXM4Q29udHJhY3RSZXN1bHQMBFIBuQkcQmFsYW5jZQEYLEV2ZW50UmVjb3JkAVAAGAEwZ2FzX2NvbnN1bWVkLAEYV2VpZ2h0AAEwZ2FzX3JlcXVpcmVkLAEYV2VpZ2h0AAE8c3RvcmFnZV9kZXBvc2l0pQkBXFN0b3JhZ2VEZXBvc2l0PEJhbGFuY2U+AAE0ZGVidWdfbWVzc2FnZTgBHFZlYzx1OD4AARhyZXN1bHS5CQEEUgABGGV2ZW50c6kJAWBPcHRpb248VmVjPEV2ZW50UmVjb3JkPj4AALkJBBhSZXN1bHQIBFQBvQkERQFoAQgIT2sEAL0JAAAAAAxFcnIEAGgAAAEAAL0JDEBwYWxsZXRfY29udHJhY3RzKHByaW1pdGl2ZXNYSW5zdGFudGlhdGVSZXR1cm5WYWx1ZQQkQWNjb3VudElkAQAACAEYcmVzdWx0nQkBPEV4ZWNSZXR1cm5WYWx1ZQABKGFjY291bnRfaWQAASRBY2NvdW50SWQAAMEJBBhSZXN1bHQIBFQBxQkERQFoAQgIT2sEAMUJAAAAAAxFcnIEAGgAAAEAAMUJDEBwYWxsZXRfY29udHJhY3RzKHByaW1pdGl2ZXNUQ29kZVVwbG9hZFJldHVyblZhbHVlCCBDb2RlSGFzaAE0HEJhbGFuY2UBGAAIASRjb2RlX2hhc2g0ASBDb2RlSGFzaAABHGRlcG9zaXQYARxCYWxhbmNlAADJCQQYUmVzdWx0CARUAb0GBEUBzQkBCAhPawQAvQYAAAAADEVycgQAzQkAAAEAAM0JDEBwYWxsZXRfY29udHJhY3RzKHByaW1pdGl2ZXNMQ29udHJhY3RBY2Nlc3NFcnJvcgABDCxEb2VzbnRFeGlzdAAAAERLZXlEZWNvZGluZ0ZhaWxlZAABAExNaWdyYXRpb25JblByb2dyZXNzAAIAANEJAAAC1QkA1QkQQHBhbGxldF9zdWJ0ZW5zb3IgcnBjX2luZm80ZGVsZWdhdGVfaW5mbzBEZWxlZ2F0ZUluZm8EJEFjY291bnRJZAEAACABNGRlbGVnYXRlX3NzNTgAASRBY2NvdW50SWQAARB0YWtlXQIBMENvbXBhY3Q8dTE2PgABKG5vbWluYXRvcnPZCQHYVmVjPChBY2NvdW50SWQsIFZlYzwoQ29tcGFjdDxOZXRVaWQ+LCBDb21wYWN0PHU2ND4pPik+AAEob3duZXJfc3M1OAABJEFjY291bnRJZAABNHJlZ2lzdHJhdGlvbnO8AVBWZWM8Q29tcGFjdDxOZXRVaWQ+PgABRHZhbGlkYXRvcl9wZXJtaXRzvAFQVmVjPENvbXBhY3Q8TmV0VWlkPj4AATxyZXR1cm5fcGVyXzEwMDAwATBDb21wYWN0PHU2ND4AAUh0b3RhbF9kYWlseV9yZXR1cm4wATBDb21wYWN0PHU2ND4AANkJAAAC3QkA3QkAAAQIAOEJAOEJAAAC5QkA5QkAAAQIwDAA6QkEGE9wdGlvbgQEVAHVCQEIEE5vbmUAAAAQU29tZQQA1QkAAAEAAO0JAAAC8QkA8QkAAAQI1Qn1CQD1CQAABAjA+QkA+QkAAAYYAP0JAAACAQoAAQoQQHBhbGxldF9zdWJ0ZW5zb3IgcnBjX2luZm8sbmV1cm9uX2luZm8oTmV1cm9uSW5mbwQkQWNjb3VudElkAQAAUAEYaG90a2V5AAEkQWNjb3VudElkAAEcY29sZGtleQABJEFjY291bnRJZAABDHVpZF0CATBDb21wYWN0PHUxNj4AARhuZXR1aWTAATxDb21wYWN0PE5ldFVpZD4AARhhY3RpdmUkARBib29sAAEkYXhvbl9pbmZv6QYBIEF4b25JbmZvAAE8cHJvbWV0aGV1c19pbmZv9QYBOFByb21ldGhldXNJbmZvAAEUc3Rha2UFCgGcVmVjPChBY2NvdW50SWQsIENvbXBhY3Q8QWxwaGFCYWxhbmNlPik+AAEQcmFua10CATBDb21wYWN0PHUxNj4AASBlbWlzc2lvbvkJAVRDb21wYWN0PEFscGhhQmFsYW5jZT4AASRpbmNlbnRpdmVdAgEwQ29tcGFjdDx1MTY+AAEkY29uc2Vuc3VzXQIBMENvbXBhY3Q8dTE2PgABFHRydXN0XQIBMENvbXBhY3Q8dTE2PgABPHZhbGlkYXRvcl90cnVzdF0CATBDb21wYWN0PHUxNj4AASRkaXZpZGVuZHNdAgEwQ29tcGFjdDx1MTY+AAEsbGFzdF91cGRhdGUwATBDb21wYWN0PHU2ND4AAUB2YWxpZGF0b3JfcGVybWl0JAEQYm9vbAABHHdlaWdodHNVAgGEVmVjPChDb21wYWN0PHUxNj4sIENvbXBhY3Q8dTE2Pik+AAEUYm9uZHNVAgGEVmVjPChDb21wYWN0PHUxNj4sIENvbXBhY3Q8dTE2Pik+AAE0cHJ1bmluZ19zY29yZV0CATBDb21wYWN0PHUxNj4AAAUKAAACCQoACQoAAAQIAPkJAA0KBBhPcHRpb24EBFQBAQoBCBBOb25lAAAAEFNvbWUEAAEKAAABAAARCgAAAhUKABUKEEBwYWxsZXRfc3VidGVuc29yIHJwY19pbmZvLG5ldXJvbl9pbmZvOE5ldXJvbkluZm9MaXRlBCRBY2NvdW50SWQBAABIARhob3RrZXkAASRBY2NvdW50SWQAARxjb2xka2V5AAEkQWNjb3VudElkAAEMdWlkXQIBMENvbXBhY3Q8dTE2PgABGG5ldHVpZMABPENvbXBhY3Q8TmV0VWlkPgABGGFjdGl2ZSQBEGJvb2wAASRheG9uX2luZm/pBgEgQXhvbkluZm8AATxwcm9tZXRoZXVzX2luZm/1BgE4UHJvbWV0aGV1c0luZm8AARRzdGFrZQUKAZxWZWM8KEFjY291bnRJZCwgQ29tcGFjdDxBbHBoYUJhbGFuY2U+KT4AARByYW5rXQIBMENvbXBhY3Q8dTE2PgABIGVtaXNzaW9u+QkBVENvbXBhY3Q8QWxwaGFCYWxhbmNlPgABJGluY2VudGl2ZV0CATBDb21wYWN0PHUxNj4AASRjb25zZW5zdXNdAgEwQ29tcGFjdDx1MTY+AAEUdHJ1c3RdAgEwQ29tcGFjdDx1MTY+AAE8dmFsaWRhdG9yX3RydXN0XQIBMENvbXBhY3Q8dTE2PgABJGRpdmlkZW5kc10CATBDb21wYWN0PHUxNj4AASxsYXN0X3VwZGF0ZTABMENvbXBhY3Q8dTY0PgABQHZhbGlkYXRvcl9wZXJtaXQkARBib29sAAE0cHJ1bmluZ19zY29yZV0CATBDb21wYWN0PHUxNj4AABkKBBhPcHRpb24EBFQBFQoBCBBOb25lAAAAEFNvbWUEABUKAAABAAAdCgQYT3B0aW9uBARUASEKAQgQTm9uZQAAABBTb21lBAAhCgAAAQAAIQoQQHBhbGxldF9zdWJ0ZW5zb3IgcnBjX2luZm8sc3VibmV0X2luZm8oU3VibmV0SW5mbwQkQWNjb3VudElkAQAASAEYbmV0dWlkwAE8Q29tcGFjdDxOZXRVaWQ+AAEMcmhvXQIBMENvbXBhY3Q8dTE2PgABFGthcHBhXQIBMENvbXBhY3Q8dTE2PgABKGRpZmZpY3VsdHkwATBDb21wYWN0PHU2ND4AATxpbW11bml0eV9wZXJpb2RdAgEwQ29tcGFjdDx1MTY+AAFYbWF4X2FsbG93ZWRfdmFsaWRhdG9yc10CATBDb21wYWN0PHUxNj4AAUxtaW5fYWxsb3dlZF93ZWlnaHRzXQIBMENvbXBhY3Q8dTE2PgABRG1heF93ZWlnaHRzX2xpbWl0XQIBMENvbXBhY3Q8dTE2PgABRHNjYWxpbmdfbGF3X3Bvd2VyXQIBMENvbXBhY3Q8dTE2PgABMHN1Ym5ldHdvcmtfbl0CATBDb21wYWN0PHUxNj4AAUBtYXhfYWxsb3dlZF91aWRzXQIBMENvbXBhY3Q8dTE2PgABWGJsb2Nrc19zaW5jZV9sYXN0X3N0ZXAwATBDb21wYWN0PHU2ND4AARR0ZW1wb10CATBDb21wYWN0PHUxNj4AAUBuZXR3b3JrX21vZGFsaXR5XQIBMENvbXBhY3Q8dTE2PgABPG5ldHdvcmtfY29ubmVjdCUKATRWZWM8W3UxNjsgMl0+AAE8ZW1pc3Npb25fdmFsdWVzMAEwQ29tcGFjdDx1NjQ+AAEQYnVybj0CAUxDb21wYWN0PFRhb0JhbGFuY2U+AAEUb3duZXIAASRBY2NvdW50SWQAACUKAAACKQoAKQoAAAMCAAAAoAAtCgAAAh0KADEKBBhPcHRpb24EBFQBNQoBCBBOb25lAAAAEFNvbWUEADUKAAABAAA1ChBAcGFsbGV0X3N1YnRlbnNvciBycGNfaW5mbyxzdWJuZXRfaW5mbzBTdWJuZXRJbmZvdjIEJEFjY291bnRJZAEAAEwBGG5ldHVpZMABPENvbXBhY3Q8TmV0VWlkPgABDHJob10CATBDb21wYWN0PHUxNj4AARRrYXBwYV0CATBDb21wYWN0PHUxNj4AAShkaWZmaWN1bHR5MAEwQ29tcGFjdDx1NjQ+AAE8aW1tdW5pdHlfcGVyaW9kXQIBMENvbXBhY3Q8dTE2PgABWG1heF9hbGxvd2VkX3ZhbGlkYXRvcnNdAgEwQ29tcGFjdDx1MTY+AAFMbWluX2FsbG93ZWRfd2VpZ2h0c10CATBDb21wYWN0PHUxNj4AAURtYXhfd2VpZ2h0c19saW1pdF0CATBDb21wYWN0PHUxNj4AAURzY2FsaW5nX2xhd19wb3dlcl0CATBDb21wYWN0PHUxNj4AATBzdWJuZXR3b3JrX25dAgEwQ29tcGFjdDx1MTY+AAFAbWF4X2FsbG93ZWRfdWlkc10CATBDb21wYWN0PHUxNj4AAVhibG9ja3Nfc2luY2VfbGFzdF9zdGVwMAEwQ29tcGFjdDx1NjQ+AAEUdGVtcG9dAgEwQ29tcGFjdDx1MTY+AAFAbmV0d29ya19tb2RhbGl0eV0CATBDb21wYWN0PHUxNj4AATxuZXR3b3JrX2Nvbm5lY3QlCgE0VmVjPFt1MTY7IDJdPgABOGVtaXNzaW9uX3ZhbHVlMAEwQ29tcGFjdDx1NjQ+AAEQYnVybj0CAUxDb21wYWN0PFRhb0JhbGFuY2U+AAEUb3duZXIAASRBY2NvdW50SWQAASBpZGVudGl0eXECAWBPcHRpb248U3VibmV0SWRlbnRpdHlWMz4AADkKAAACMQoAPQoEGE9wdGlvbgQEVAFBCgEIEE5vbmUAAAAQU29tZQQAQQoAAAEAAEEKEEBwYWxsZXRfc3VidGVuc29yIHJwY19pbmZvLHN1Ym5ldF9pbmZvRFN1Ym5ldEh5cGVycGFyYW1zAABsAQxyaG9dAgEwQ29tcGFjdDx1MTY+AAEUa2FwcGFdAgEwQ29tcGFjdDx1MTY+AAE8aW1tdW5pdHlfcGVyaW9kXQIBMENvbXBhY3Q8dTE2PgABTG1pbl9hbGxvd2VkX3dlaWdodHNdAgEwQ29tcGFjdDx1MTY+AAFEbWF4X3dlaWdodHNfbGltaXRdAgEwQ29tcGFjdDx1MTY+AAEUdGVtcG9dAgEwQ29tcGFjdDx1MTY+AAE4bWluX2RpZmZpY3VsdHkwATBDb21wYWN0PHU2ND4AAThtYXhfZGlmZmljdWx0eTABMENvbXBhY3Q8dTY0PgABPHdlaWdodHNfdmVyc2lvbjABMENvbXBhY3Q8dTY0PgABSHdlaWdodHNfcmF0ZV9saW1pdDABMENvbXBhY3Q8dTY0PgABTGFkanVzdG1lbnRfaW50ZXJ2YWxdAgEwQ29tcGFjdDx1MTY+AAE8YWN0aXZpdHlfY3V0b2ZmXQIBMENvbXBhY3Q8dTE2PgABUHJlZ2lzdHJhdGlvbl9hbGxvd2VkJAEQYm9vbAABYHRhcmdldF9yZWdzX3Blcl9pbnRlcnZhbF0CATBDb21wYWN0PHUxNj4AASBtaW5fYnVybj0CAUxDb21wYWN0PFRhb0JhbGFuY2U+AAEgbWF4X2J1cm49AgFMQ29tcGFjdDxUYW9CYWxhbmNlPgABQGJvbmRzX21vdmluZ19hdmcwATBDb21wYWN0PHU2ND4AAUhtYXhfcmVnc19wZXJfYmxvY2tdAgEwQ29tcGFjdDx1MTY+AAFIc2VydmluZ19yYXRlX2xpbWl0MAEwQ29tcGFjdDx1NjQ+AAE4bWF4X3ZhbGlkYXRvcnNdAgEwQ29tcGFjdDx1MTY+AAFAYWRqdXN0bWVudF9hbHBoYTABMENvbXBhY3Q8dTY0PgABKGRpZmZpY3VsdHkwATBDb21wYWN0PHU2ND4AAVBjb21taXRfcmV2ZWFsX3BlcmlvZDABMENvbXBhY3Q8dTY0PgABdGNvbW1pdF9yZXZlYWxfd2VpZ2h0c19lbmFibGVkJAEQYm9vbAABKGFscGhhX2hpZ2hdAgEwQ29tcGFjdDx1MTY+AAEkYWxwaGFfbG93XQIBMENvbXBhY3Q8dTE2PgABUGxpcXVpZF9hbHBoYV9lbmFibGVkJAEQYm9vbAAARQoEGE9wdGlvbgQEVAFJCgEIEE5vbmUAAAAQU29tZQQASQoAAAEAAEkKEEBwYWxsZXRfc3VidGVuc29yIHJwY19pbmZvLHN1Ym5ldF9pbmZvTFN1Ym5ldEh5cGVycGFyYW1zVjIAAIQBDHJob10CATBDb21wYWN0PHUxNj4AARRrYXBwYV0CATBDb21wYWN0PHUxNj4AATxpbW11bml0eV9wZXJpb2RdAgEwQ29tcGFjdDx1MTY+AAFMbWluX2FsbG93ZWRfd2VpZ2h0c10CATBDb21wYWN0PHUxNj4AAURtYXhfd2VpZ2h0c19saW1pdF0CATBDb21wYWN0PHUxNj4AARR0ZW1wb10CATBDb21wYWN0PHUxNj4AAThtaW5fZGlmZmljdWx0eTABMENvbXBhY3Q8dTY0PgABOG1heF9kaWZmaWN1bHR5MAEwQ29tcGFjdDx1NjQ+AAE8d2VpZ2h0c192ZXJzaW9uMAEwQ29tcGFjdDx1NjQ+AAFId2VpZ2h0c19yYXRlX2xpbWl0MAEwQ29tcGFjdDx1NjQ+AAFMYWRqdXN0bWVudF9pbnRlcnZhbF0CATBDb21wYWN0PHUxNj4AATxhY3Rpdml0eV9jdXRvZmZdAgEwQ29tcGFjdDx1MTY+AAFQcmVnaXN0cmF0aW9uX2FsbG93ZWQkARBib29sAAFgdGFyZ2V0X3JlZ3NfcGVyX2ludGVydmFsXQIBMENvbXBhY3Q8dTE2PgABIG1pbl9idXJuPQIBTENvbXBhY3Q8VGFvQmFsYW5jZT4AASBtYXhfYnVybj0CAUxDb21wYWN0PFRhb0JhbGFuY2U+AAFAYm9uZHNfbW92aW5nX2F2ZzABMENvbXBhY3Q8dTY0PgABSG1heF9yZWdzX3Blcl9ibG9ja10CATBDb21wYWN0PHUxNj4AAUhzZXJ2aW5nX3JhdGVfbGltaXQwATBDb21wYWN0PHU2ND4AAThtYXhfdmFsaWRhdG9yc10CATBDb21wYWN0PHUxNj4AAUBhZGp1c3RtZW50X2FscGhhMAEwQ29tcGFjdDx1NjQ+AAEoZGlmZmljdWx0eTABMENvbXBhY3Q8dTY0PgABUGNvbW1pdF9yZXZlYWxfcGVyaW9kMAEwQ29tcGFjdDx1NjQ+AAF0Y29tbWl0X3JldmVhbF93ZWlnaHRzX2VuYWJsZWQkARBib29sAAEoYWxwaGFfaGlnaF0CATBDb21wYWN0PHUxNj4AASRhbHBoYV9sb3ddAgEwQ29tcGFjdDx1MTY+AAFQbGlxdWlkX2FscGhhX2VuYWJsZWQkARBib29sAAFcYWxwaGFfc2lnbW9pZF9zdGVlcG5lc3NNCgEYSTMyRjMyAAEweXVtYV92ZXJzaW9uXQIBMENvbXBhY3Q8dTE2PgABQHN1Ym5ldF9pc19hY3RpdmUkARBib29sAAFEdHJhbnNmZXJzX2VuYWJsZWQkARBib29sAAFMYm9uZHNfcmVzZXRfZW5hYmxlZCQBEGJvb2wAAVh1c2VyX2xpcXVpZGl0eV9lbmFibGVkJAEQYm9vbAAATQoIPHN1YnN0cmF0ZV9maXhlZCBGaXhlZEk2NAQQRnJhYwH1BAAEARBiaXRzgQEBDGk2NAAAUQoAAAJVCgBVCgQYT3B0aW9uBARUAVkKAQgQTm9uZQAAABBTb21lBABZCgAAAQAAWQoQQHBhbGxldF9zdWJ0ZW5zb3IgcnBjX2luZm8wZHluYW1pY19pbmZvLER5bmFtaWNJbmZvBCRBY2NvdW50SWQBAABUARhuZXR1aWTAATxDb21wYWN0PE5ldFVpZD4AATBvd25lcl9ob3RrZXkAASRBY2NvdW50SWQAATRvd25lcl9jb2xka2V5AAEkQWNjb3VudElkAAEsc3VibmV0X25hbWVdCgFAVmVjPENvbXBhY3Q8dTg+PgABMHRva2VuX3N5bWJvbF0KAUBWZWM8Q29tcGFjdDx1OD4+AAEUdGVtcG9dAgEwQ29tcGFjdDx1MTY+AAEkbGFzdF9zdGVwMAEwQ29tcGFjdDx1NjQ+AAFYYmxvY2tzX3NpbmNlX2xhc3Rfc3RlcDABMENvbXBhY3Q8dTY0PgABIGVtaXNzaW9uMAEwQ29tcGFjdDx1NjQ+AAEgYWxwaGFfaW75CQFUQ29tcGFjdDxBbHBoYUJhbGFuY2U+AAEkYWxwaGFfb3V0+QkBVENvbXBhY3Q8QWxwaGFCYWxhbmNlPgABGHRhb19pbj0CAUxDb21wYWN0PFRhb0JhbGFuY2U+AAFIYWxwaGFfb3V0X2VtaXNzaW9u+QkBVENvbXBhY3Q8QWxwaGFCYWxhbmNlPgABRGFscGhhX2luX2VtaXNzaW9u+QkBVENvbXBhY3Q8QWxwaGFCYWxhbmNlPgABPHRhb19pbl9lbWlzc2lvbj0CAUxDb21wYWN0PFRhb0JhbGFuY2U+AAFYcGVuZGluZ19hbHBoYV9lbWlzc2lvbvkJAVRDb21wYWN0PEFscGhhQmFsYW5jZT4AAVRwZW5kaW5nX3Jvb3RfZW1pc3Npb249AgFMQ29tcGFjdDxUYW9CYWxhbmNlPgABNHN1Ym5ldF92b2x1bWVlCgE0Q29tcGFjdDx1MTI4PgABVG5ldHdvcmtfcmVnaXN0ZXJlZF9hdDABMENvbXBhY3Q8dTY0PgABPHN1Ym5ldF9pZGVudGl0eXECAWBPcHRpb248U3VibmV0SWRlbnRpdHlWMz4AATBtb3ZpbmdfcHJpY2XxBAEYSTk2RjMyAABdCgAAAmEKAGEKAAAGCABlCgAABiAAaQoAAAJtCgBtCgQYT3B0aW9uBARUAXEKAQgQTm9uZQAAABBTb21lBABxCgAAAQAAcQoQQHBhbGxldF9zdWJ0ZW5zb3IgcnBjX2luZm8kbWV0YWdyYXBoJE1ldGFncmFwaAQkQWNjb3VudElkAQAAIQEBGG5ldHVpZMABPENvbXBhY3Q8TmV0VWlkPgABEG5hbWVdCgFAVmVjPENvbXBhY3Q8dTg+PgABGHN5bWJvbF0KAUBWZWM8Q29tcGFjdDx1OD4+AAEgaWRlbnRpdHlxAgFgT3B0aW9uPFN1Ym5ldElkZW50aXR5VjM+AAFUbmV0d29ya19yZWdpc3RlcmVkX2F0MAEwQ29tcGFjdDx1NjQ+AAEwb3duZXJfaG90a2V5AAEkQWNjb3VudElkAAE0b3duZXJfY29sZGtleQABJEFjY291bnRJZAABFGJsb2NrMAEwQ29tcGFjdDx1NjQ+AAEUdGVtcG9dAgEwQ29tcGFjdDx1MTY+AAEkbGFzdF9zdGVwMAEwQ29tcGFjdDx1NjQ+AAFYYmxvY2tzX3NpbmNlX2xhc3Rfc3RlcDABMENvbXBhY3Q8dTY0PgABPHN1Ym5ldF9lbWlzc2lvbjABMENvbXBhY3Q8dTY0PgABIGFscGhhX2lu+QkBVENvbXBhY3Q8QWxwaGFCYWxhbmNlPgABJGFscGhhX291dPkJAVRDb21wYWN0PEFscGhhQmFsYW5jZT4AARh0YW9faW49AgFMQ29tcGFjdDxUYW9CYWxhbmNlPgABSGFscGhhX291dF9lbWlzc2lvbvkJAVRDb21wYWN0PEFscGhhQmFsYW5jZT4AAURhbHBoYV9pbl9lbWlzc2lvbvkJAVRDb21wYWN0PEFscGhhQmFsYW5jZT4AATx0YW9faW5fZW1pc3Npb249AgFMQ29tcGFjdDxUYW9CYWxhbmNlPgABWHBlbmRpbmdfYWxwaGFfZW1pc3Npb275CQFUQ29tcGFjdDxBbHBoYUJhbGFuY2U+AAFUcGVuZGluZ19yb290X2VtaXNzaW9uPQIBTENvbXBhY3Q8VGFvQmFsYW5jZT4AATRzdWJuZXRfdm9sdW1lZQoBNENvbXBhY3Q8dTEyOD4AATBtb3ZpbmdfcHJpY2XxBAEYSTk2RjMyAAEMcmhvXQIBMENvbXBhY3Q8dTE2PgABFGthcHBhXQIBMENvbXBhY3Q8dTE2PgABTG1pbl9hbGxvd2VkX3dlaWdodHNdAgEwQ29tcGFjdDx1MTY+AAFEbWF4X3dlaWdodHNfbGltaXRdAgEwQ29tcGFjdDx1MTY+AAE8d2VpZ2h0c192ZXJzaW9uMAEwQ29tcGFjdDx1NjQ+AAFId2VpZ2h0c19yYXRlX2xpbWl0MAEwQ29tcGFjdDx1NjQ+AAE8YWN0aXZpdHlfY3V0b2ZmXQIBMENvbXBhY3Q8dTE2PgABOG1heF92YWxpZGF0b3JzXQIBMENvbXBhY3Q8dTE2PgABIG51bV91aWRzXQIBMENvbXBhY3Q8dTE2PgABIG1heF91aWRzXQIBMENvbXBhY3Q8dTE2PgABEGJ1cm49AgFMQ29tcGFjdDxUYW9CYWxhbmNlPgABKGRpZmZpY3VsdHkwATBDb21wYWN0PHU2ND4AAVByZWdpc3RyYXRpb25fYWxsb3dlZCQBEGJvb2wAAWBwb3dfcmVnaXN0cmF0aW9uX2FsbG93ZWQkARBib29sAAE8aW1tdW5pdHlfcGVyaW9kXQIBMENvbXBhY3Q8dTE2PgABOG1pbl9kaWZmaWN1bHR5MAEwQ29tcGFjdDx1NjQ+AAE4bWF4X2RpZmZpY3VsdHkwATBDb21wYWN0PHU2ND4AASBtaW5fYnVybj0CAUxDb21wYWN0PFRhb0JhbGFuY2U+AAEgbWF4X2J1cm49AgFMQ29tcGFjdDxUYW9CYWxhbmNlPgABQGFkanVzdG1lbnRfYWxwaGEwATBDb21wYWN0PHU2ND4AAUxhZGp1c3RtZW50X2ludGVydmFsXQIBMENvbXBhY3Q8dTE2PgABYHRhcmdldF9yZWdzX3Blcl9pbnRlcnZhbF0CATBDb21wYWN0PHUxNj4AAUhtYXhfcmVnc19wZXJfYmxvY2tdAgEwQ29tcGFjdDx1MTY+AAFIc2VydmluZ19yYXRlX2xpbWl0MAEwQ29tcGFjdDx1NjQ+AAF0Y29tbWl0X3JldmVhbF93ZWlnaHRzX2VuYWJsZWQkARBib29sAAFQY29tbWl0X3JldmVhbF9wZXJpb2QwATBDb21wYWN0PHU2ND4AAVBsaXF1aWRfYWxwaGFfZW5hYmxlZCQBEGJvb2wAAShhbHBoYV9oaWdoXQIBMENvbXBhY3Q8dTE2PgABJGFscGhhX2xvd10CATBDb21wYWN0PHUxNj4AAUBib25kc19tb3ZpbmdfYXZnMAEwQ29tcGFjdDx1NjQ+AAEcaG90a2V5c0ECAThWZWM8QWNjb3VudElkPgABIGNvbGRrZXlzQQIBOFZlYzxBY2NvdW50SWQ+AAEoaWRlbnRpdGllc3UKAXhWZWM8T3B0aW9uPENoYWluSWRlbnRpdHlPZlYyPj4AARRheG9uc30KATRWZWM8QXhvbkluZm8+AAEYYWN0aXZl3QYBJFZlYzxib29sPgABQHZhbGlkYXRvcl9wZXJtaXTdBgEkVmVjPGJvb2w+AAE0cHJ1bmluZ19zY29yZYEKAURWZWM8Q29tcGFjdDx1MTY+PgABLGxhc3RfdXBkYXRlYQIBRFZlYzxDb21wYWN0PHU2ND4+AAEgZW1pc3Npb26FCgFoVmVjPENvbXBhY3Q8QWxwaGFCYWxhbmNlPj4AASRkaXZpZGVuZHOBCgFEVmVjPENvbXBhY3Q8dTE2Pj4AAShpbmNlbnRpdmVzgQoBRFZlYzxDb21wYWN0PHUxNj4+AAEkY29uc2Vuc3VzgQoBRFZlYzxDb21wYWN0PHUxNj4+AAEUdHJ1c3SBCgFEVmVjPENvbXBhY3Q8dTE2Pj4AARByYW5rgQoBRFZlYzxDb21wYWN0PHUxNj4+AAFUYmxvY2tfYXRfcmVnaXN0cmF0aW9uYQIBRFZlYzxDb21wYWN0PHU2ND4+AAEsYWxwaGFfc3Rha2WFCgFoVmVjPENvbXBhY3Q8QWxwaGFCYWxhbmNlPj4AASR0YW9fc3Rha2WJCgFgVmVjPENvbXBhY3Q8VGFvQmFsYW5jZT4+AAEsdG90YWxfc3Rha2WJCgFgVmVjPENvbXBhY3Q8VGFvQmFsYW5jZT4+AAFgdGFvX2RpdmlkZW5kc19wZXJfaG90a2V5jQoBlFZlYzwoQWNjb3VudElkLCBDb21wYWN0PFRhb0JhbGFuY2U+KT4AAWhhbHBoYV9kaXZpZGVuZHNfcGVyX2hvdGtleQUKAZxWZWM8KEFjY291bnRJZCwgQ29tcGFjdDxBbHBoYUJhbGFuY2U+KT4AAHUKAAACeQoAeQoEGE9wdGlvbgQEVAH5BgEIEE5vbmUAAAAQU29tZQQA+QYAAAEAAH0KAAAC6QYAgQoAAAJdAgCFCgAAAvkJAIkKAAACPQIAjQoAAAKRCgCRCgAABAgAPQIAlQoEGE9wdGlvbgQEVAGZCgEIEE5vbmUAAAAQU29tZQQAmQoAAAEAAJkKEEBwYWxsZXRfc3VidGVuc29yIHJwY19pbmZvLHNob3dfc3VibmV0LFN1Ym5ldFN0YXRlBCRBY2NvdW50SWQBAABIARhuZXR1aWTAATxDb21wYWN0PE5ldFVpZD4AARxob3RrZXlzQQIBOFZlYzxBY2NvdW50SWQ+AAEgY29sZGtleXNBAgE4VmVjPEFjY291bnRJZD4AARhhY3RpdmXdBgEkVmVjPGJvb2w+AAFAdmFsaWRhdG9yX3Blcm1pdN0GASRWZWM8Ym9vbD4AATRwcnVuaW5nX3Njb3JlgQoBRFZlYzxDb21wYWN0PHUxNj4+AAEsbGFzdF91cGRhdGVhAgFEVmVjPENvbXBhY3Q8dTY0Pj4AASBlbWlzc2lvboUKAWhWZWM8Q29tcGFjdDxBbHBoYUJhbGFuY2U+PgABJGRpdmlkZW5kc4EKAURWZWM8Q29tcGFjdDx1MTY+PgABKGluY2VudGl2ZXOBCgFEVmVjPENvbXBhY3Q8dTE2Pj4AASRjb25zZW5zdXOBCgFEVmVjPENvbXBhY3Q8dTE2Pj4AARR0cnVzdIEKAURWZWM8Q29tcGFjdDx1MTY+PgABEHJhbmuBCgFEVmVjPENvbXBhY3Q8dTE2Pj4AAVRibG9ja19hdF9yZWdpc3RyYXRpb25hAgFEVmVjPENvbXBhY3Q8dTY0Pj4AASxhbHBoYV9zdGFrZYUKAWhWZWM8Q29tcGFjdDxBbHBoYUJhbGFuY2U+PgABJHRhb19zdGFrZYkKAWBWZWM8Q29tcGFjdDxUYW9CYWxhbmNlPj4AASx0b3RhbF9zdGFrZYkKAWBWZWM8Q29tcGFjdDxUYW9CYWxhbmNlPj4AAUBlbWlzc2lvbl9oaXN0b3J5nQoBfFZlYzxWZWM8Q29tcGFjdDxBbHBoYUJhbGFuY2U+Pj4AAJ0KAAAChQoAoQoEGE9wdGlvbgQEVAGlCgEIEE5vbmUAAAAQU29tZQQApQoAAAEAAKUKEEBwYWxsZXRfc3VidGVuc29yIHJwY19pbmZvJG1ldGFncmFwaEhTZWxlY3RpdmVNZXRhZ3JhcGgEJEFjY291bnRJZAEAACkBARhuZXR1aWTAATxDb21wYWN0PE5ldFVpZD4AARBuYW1lqQoBYE9wdGlvbjxWZWM8Q29tcGFjdDx1OD4+PgABGHN5bWJvbKkKAWBPcHRpb248VmVjPENvbXBhY3Q8dTg+Pj4AASBpZGVudGl0ea0KAYBPcHRpb248T3B0aW9uPFN1Ym5ldElkZW50aXR5VjM+PgABVG5ldHdvcmtfcmVnaXN0ZXJlZF9hdLEKAVBPcHRpb248Q29tcGFjdDx1NjQ+PgABMG93bmVyX2hvdGtleegBRE9wdGlvbjxBY2NvdW50SWQ+AAE0b3duZXJfY29sZGtleegBRE9wdGlvbjxBY2NvdW50SWQ+AAEUYmxvY2uxCgFQT3B0aW9uPENvbXBhY3Q8dTY0Pj4AARR0ZW1wb7UKAVBPcHRpb248Q29tcGFjdDx1MTY+PgABJGxhc3Rfc3RlcLEKAVBPcHRpb248Q29tcGFjdDx1NjQ+PgABWGJsb2Nrc19zaW5jZV9sYXN0X3N0ZXCxCgFQT3B0aW9uPENvbXBhY3Q8dTY0Pj4AATxzdWJuZXRfZW1pc3Npb26xCgFQT3B0aW9uPENvbXBhY3Q8dTY0Pj4AASBhbHBoYV9pbrkKAXRPcHRpb248Q29tcGFjdDxBbHBoYUJhbGFuY2U+PgABJGFscGhhX291dLkKAXRPcHRpb248Q29tcGFjdDxBbHBoYUJhbGFuY2U+PgABGHRhb19pbskFAWxPcHRpb248Q29tcGFjdDxUYW9CYWxhbmNlPj4AAUhhbHBoYV9vdXRfZW1pc3Npb265CgF0T3B0aW9uPENvbXBhY3Q8QWxwaGFCYWxhbmNlPj4AAURhbHBoYV9pbl9lbWlzc2lvbrkKAXRPcHRpb248Q29tcGFjdDxBbHBoYUJhbGFuY2U+PgABPHRhb19pbl9lbWlzc2lvbskFAWxPcHRpb248Q29tcGFjdDxUYW9CYWxhbmNlPj4AAVhwZW5kaW5nX2FscGhhX2VtaXNzaW9uuQoBdE9wdGlvbjxDb21wYWN0PEFscGhhQmFsYW5jZT4+AAFUcGVuZGluZ19yb290X2VtaXNzaW9uyQUBbE9wdGlvbjxDb21wYWN0PFRhb0JhbGFuY2U+PgABNHN1Ym5ldF92b2x1bWW9CgFUT3B0aW9uPENvbXBhY3Q8dTEyOD4+AAEwbW92aW5nX3ByaWNlwQoBOE9wdGlvbjxJOTZGMzI+AAEMcmhvtQoBUE9wdGlvbjxDb21wYWN0PHUxNj4+AAEUa2FwcGG1CgFQT3B0aW9uPENvbXBhY3Q8dTE2Pj4AAUxtaW5fYWxsb3dlZF93ZWlnaHRztQoBUE9wdGlvbjxDb21wYWN0PHUxNj4+AAFEbWF4X3dlaWdodHNfbGltaXS1CgFQT3B0aW9uPENvbXBhY3Q8dTE2Pj4AATx3ZWlnaHRzX3ZlcnNpb26xCgFQT3B0aW9uPENvbXBhY3Q8dTY0Pj4AAUh3ZWlnaHRzX3JhdGVfbGltaXSxCgFQT3B0aW9uPENvbXBhY3Q8dTY0Pj4AATxhY3Rpdml0eV9jdXRvZma1CgFQT3B0aW9uPENvbXBhY3Q8dTE2Pj4AAThtYXhfdmFsaWRhdG9yc7UKAVBPcHRpb248Q29tcGFjdDx1MTY+PgABIG51bV91aWRztQoBUE9wdGlvbjxDb21wYWN0PHUxNj4+AAEgbWF4X3VpZHO1CgFQT3B0aW9uPENvbXBhY3Q8dTE2Pj4AARBidXJuyQUBbE9wdGlvbjxDb21wYWN0PFRhb0JhbGFuY2U+PgABKGRpZmZpY3VsdHmxCgFQT3B0aW9uPENvbXBhY3Q8dTY0Pj4AAVByZWdpc3RyYXRpb25fYWxsb3dlZMUKATBPcHRpb248Ym9vbD4AAWBwb3dfcmVnaXN0cmF0aW9uX2FsbG93ZWTFCgEwT3B0aW9uPGJvb2w+AAE8aW1tdW5pdHlfcGVyaW9ktQoBUE9wdGlvbjxDb21wYWN0PHUxNj4+AAE4bWluX2RpZmZpY3VsdHmxCgFQT3B0aW9uPENvbXBhY3Q8dTY0Pj4AAThtYXhfZGlmZmljdWx0ebEKAVBPcHRpb248Q29tcGFjdDx1NjQ+PgABIG1pbl9idXJuyQUBbE9wdGlvbjxDb21wYWN0PFRhb0JhbGFuY2U+PgABIG1heF9idXJuyQUBbE9wdGlvbjxDb21wYWN0PFRhb0JhbGFuY2U+PgABQGFkanVzdG1lbnRfYWxwaGGxCgFQT3B0aW9uPENvbXBhY3Q8dTY0Pj4AAUxhZGp1c3RtZW50X2ludGVydmFstQoBUE9wdGlvbjxDb21wYWN0PHUxNj4+AAFgdGFyZ2V0X3JlZ3NfcGVyX2ludGVydmFstQoBUE9wdGlvbjxDb21wYWN0PHUxNj4+AAFIbWF4X3JlZ3NfcGVyX2Jsb2NrtQoBUE9wdGlvbjxDb21wYWN0PHUxNj4+AAFIc2VydmluZ19yYXRlX2xpbWl0sQoBUE9wdGlvbjxDb21wYWN0PHU2ND4+AAF0Y29tbWl0X3JldmVhbF93ZWlnaHRzX2VuYWJsZWTFCgEwT3B0aW9uPGJvb2w+AAFQY29tbWl0X3JldmVhbF9wZXJpb2SxCgFQT3B0aW9uPENvbXBhY3Q8dTY0Pj4AAVBsaXF1aWRfYWxwaGFfZW5hYmxlZMUKATBPcHRpb248Ym9vbD4AAShhbHBoYV9oaWdotQoBUE9wdGlvbjxDb21wYWN0PHUxNj4+AAEkYWxwaGFfbG93tQoBUE9wdGlvbjxDb21wYWN0PHUxNj4+AAFAYm9uZHNfbW92aW5nX2F2Z7EKAVBPcHRpb248Q29tcGFjdDx1NjQ+PgABHGhvdGtleXPJCgFYT3B0aW9uPFZlYzxBY2NvdW50SWQ+PgABIGNvbGRrZXlzyQoBWE9wdGlvbjxWZWM8QWNjb3VudElkPj4AAShpZGVudGl0aWVzzQoBmE9wdGlvbjxWZWM8T3B0aW9uPENoYWluSWRlbnRpdHlPZlYyPj4+AAEUYXhvbnPRCgFUT3B0aW9uPFZlYzxBeG9uSW5mbz4+AAEYYWN0aXZl1QoBRE9wdGlvbjxWZWM8Ym9vbD4+AAFAdmFsaWRhdG9yX3Blcm1pdNUKAURPcHRpb248VmVjPGJvb2w+PgABNHBydW5pbmdfc2NvcmXZCgFkT3B0aW9uPFZlYzxDb21wYWN0PHUxNj4+PgABLGxhc3RfdXBkYXRl3QoBZE9wdGlvbjxWZWM8Q29tcGFjdDx1NjQ+Pj4AASBlbWlzc2lvbuEKAYhPcHRpb248VmVjPENvbXBhY3Q8QWxwaGFCYWxhbmNlPj4+AAEkZGl2aWRlbmRz2QoBZE9wdGlvbjxWZWM8Q29tcGFjdDx1MTY+Pj4AAShpbmNlbnRpdmVz2QoBZE9wdGlvbjxWZWM8Q29tcGFjdDx1MTY+Pj4AASRjb25zZW5zdXPZCgFkT3B0aW9uPFZlYzxDb21wYWN0PHUxNj4+PgABFHRydXN02QoBZE9wdGlvbjxWZWM8Q29tcGFjdDx1MTY+Pj4AARByYW5r2QoBZE9wdGlvbjxWZWM8Q29tcGFjdDx1MTY+Pj4AAVRibG9ja19hdF9yZWdpc3RyYXRpb27dCgFkT3B0aW9uPFZlYzxDb21wYWN0PHU2ND4+PgABLGFscGhhX3N0YWtl4QoBiE9wdGlvbjxWZWM8Q29tcGFjdDxBbHBoYUJhbGFuY2U+Pj4AASR0YW9fc3Rha2XlCgGAT3B0aW9uPFZlYzxDb21wYWN0PFRhb0JhbGFuY2U+Pj4AASx0b3RhbF9zdGFrZeUKAYBPcHRpb248VmVjPENvbXBhY3Q8VGFvQmFsYW5jZT4+PgABYHRhb19kaXZpZGVuZHNfcGVyX2hvdGtleekKAbRPcHRpb248VmVjPChBY2NvdW50SWQsIENvbXBhY3Q8VGFvQmFsYW5jZT4pPj4AAWhhbHBoYV9kaXZpZGVuZHNfcGVyX2hvdGtlee0KAbxPcHRpb248VmVjPChBY2NvdW50SWQsIENvbXBhY3Q8QWxwaGFCYWxhbmNlPik+PgABKHZhbGlkYXRvcnPZCgFkT3B0aW9uPFZlYzxDb21wYWN0PHUxNj4+PgABLGNvbW1pdG1lbnRz8QoBqE9wdGlvbjxWZWM8KEFjY291bnRJZCwgVmVjPENvbXBhY3Q8dTg+Pik+PgAAqQoEGE9wdGlvbgQEVAFdCgEIEE5vbmUAAAAQU29tZQQAXQoAAAEAAK0KBBhPcHRpb24EBFQBcQIBCBBOb25lAAAAEFNvbWUEAHECAAABAACxCgQYT3B0aW9uBARUATABCBBOb25lAAAAEFNvbWUEADAAAAEAALUKBBhPcHRpb24EBFQBXQIBCBBOb25lAAAAEFNvbWUEAF0CAAABAAC5CgQYT3B0aW9uBARUAfkJAQgQTm9uZQAAABBTb21lBAD5CQAAAQAAvQoEGE9wdGlvbgQEVAFlCgEIEE5vbmUAAAAQU29tZQQAZQoAAAEAAMEKBBhPcHRpb24EBFQB8QQBCBBOb25lAAAAEFNvbWUEAPEEAAABAADFCgQYT3B0aW9uBARUASQBCBBOb25lAAAAEFNvbWUEACQAAAEAAMkKBBhPcHRpb24EBFQBQQIBCBBOb25lAAAAEFNvbWUEAEECAAABAADNCgQYT3B0aW9uBARUAXUKAQgQTm9uZQAAABBTb21lBAB1CgAAAQAA0QoEGE9wdGlvbgQEVAF9CgEIEE5vbmUAAAAQU29tZQQAfQoAAAEAANUKBBhPcHRpb24EBFQB3QYBCBBOb25lAAAAEFNvbWUEAN0GAAABAADZCgQYT3B0aW9uBARUAYEKAQgQTm9uZQAAABBTb21lBACBCgAAAQAA3QoEGE9wdGlvbgQEVAFhAgEIEE5vbmUAAAAQU29tZQQAYQIAAAEAAOEKBBhPcHRpb24EBFQBhQoBCBBOb25lAAAAEFNvbWUEAIUKAAABAADlCgQYT3B0aW9uBARUAYkKAQgQTm9uZQAAABBTb21lBACJCgAAAQAA6QoEGE9wdGlvbgQEVAGNCgEIEE5vbmUAAAAQU29tZQQAjQoAAAEAAO0KBBhPcHRpb24EBFQBBQoBCBBOb25lAAAAEFNvbWUEAAUKAAABAADxCgQYT3B0aW9uBARUAfUKAQgQTm9uZQAAABBTb21lBAD1CgAAAQAA9QoAAAL5CgD5CgAABAgAXQoA/QoAAAIBCwABCxBAcGFsbGV0X3N1YnRlbnNvciBycGNfaW5mbyhzdGFrZV9pbmZvJFN0YWtlSW5mbwQkQWNjb3VudElkAQAAJAEYaG90a2V5AAEkQWNjb3VudElkAAEcY29sZGtleQABJEFjY291bnRJZAABGG5ldHVpZMABPENvbXBhY3Q8TmV0VWlkPgABFHN0YWtl+QkBVENvbXBhY3Q8QWxwaGFCYWxhbmNlPgABGGxvY2tlZDABMENvbXBhY3Q8dTY0PgABIGVtaXNzaW9u+QkBVENvbXBhY3Q8QWxwaGFCYWxhbmNlPgABMHRhb19lbWlzc2lvbj0CAUxDb21wYWN0PFRhb0JhbGFuY2U+AAEUZHJhaW4wATBDb21wYWN0PHU2ND4AATRpc19yZWdpc3RlcmVkJAEQYm9vbAAABQsAAAIJCwAJCwAABAgA/QoADQsEGE9wdGlvbgQEVAEBCwEIEE5vbmUAAAAQU29tZQQAAQsAAAEAABELBBhPcHRpb24EBFQBqQYBCBBOb25lAAAAEFNvbWUEAKkGAAABAAAVCwhEc3BfY29uc2Vuc3VzX2JhYmVEQmFiZUNvbmZpZ3VyYXRpb24AABgBNHNsb3RfZHVyYXRpb24YAQx1NjQAATBlcG9jaF9sZW5ndGgYAQx1NjQAAQRjGQsBKCh1NjQsIHU2NCkAASxhdXRob3JpdGllcx0LAZxWZWM8KEF1dGhvcml0eUlkLCBCYWJlQXV0aG9yaXR5V2VpZ2h0KT4AAShyYW5kb21uZXNzBAEoUmFuZG9tbmVzcwABNGFsbG93ZWRfc2xvdHMpCwEwQWxsb3dlZFNsb3RzAAAZCwAABAgYGAAdCwAAAiELACELAAAECCULGAAlCwxEc3BfY29uc2Vuc3VzX2JhYmUMYXBwGFB1YmxpYwAABAAEATxzcjI1NTE5OjpQdWJsaWMAACkLCERzcF9jb25zZW5zdXNfYmFiZTBBbGxvd2VkU2xvdHMAAQwwUHJpbWFyeVNsb3RzAAAAdFByaW1hcnlBbmRTZWNvbmRhcnlQbGFpblNsb3RzAAEAbFByaW1hcnlBbmRTZWNvbmRhcnlWUkZTbG90cwACAAAtCwhEc3BfY29uc2Vuc3VzX2JhYmUURXBvY2gAABgBLGVwb2NoX2luZGV4GAEMdTY0AAEoc3RhcnRfc2xvdDkGARBTbG90AAEgZHVyYXRpb24YAQx1NjQAASxhdXRob3JpdGllcx0LAZxWZWM8KEF1dGhvcml0eUlkLCBCYWJlQXV0aG9yaXR5V2VpZ2h0KT4AAShyYW5kb21uZXNzBAEoUmFuZG9tbmVzcwABGGNvbmZpZzELAVhCYWJlRXBvY2hDb25maWd1cmF0aW9uAAAxCwhEc3BfY29uc2Vuc3VzX2JhYmVYQmFiZUVwb2NoQ29uZmlndXJhdGlvbgAACAEEYxkLASgodTY0LCB1NjQpAAE0YWxsb3dlZF9zbG90cykLATBBbGxvd2VkU2xvdHMAADULBBhPcHRpb24EBFQBOQsBCBBOb25lAAAAEFNvbWUEADkLAAABAAA5CwhEc3BfY29uc2Vuc3VzX2JhYmVcT3BhcXVlS2V5T3duZXJzaGlwUHJvb2YAAAQAOAEcVmVjPHU4PgAAPQsISHNwX2NvbnNlbnN1c19zbG90c0RFcXVpdm9jYXRpb25Qcm9vZggYSGVhZGVyAeUFCElkASULABABIG9mZmVuZGVyJQsBCElkAAEQc2xvdDkGARBTbG90AAEwZmlyc3RfaGVhZGVy5QUBGEhlYWRlcgABNHNlY29uZF9oZWFkZXLlBQEYSGVhZGVyAABBCwAAAkULAEULCIRwYWxsZXRfc3VidGVuc29yX3N3YXBfcnVudGltZV9hcGksU3VibmV0UHJpY2UAAAgBGG5ldHVpZKABGE5ldFVpZAABFHByaWNlGAEMdTY0AABJCwiEcGFsbGV0X3N1YnRlbnNvcl9zd2FwX3J1bnRpbWVfYXBpNFNpbVN3YXBSZXN1bHQAABgBKHRhb19hbW91bnQYAShUYW9CYWxhbmNlAAEwYWxwaGFfYW1vdW50GAEwQWxwaGFCYWxhbmNlAAEcdGFvX2ZlZRgBKFRhb0JhbGFuY2UAASRhbHBoYV9mZWUYATBBbHBoYUJhbGFuY2UAATB0YW9fc2xpcHBhZ2UYAShUYW9CYWxhbmNlAAE4YWxwaGFfc2xpcHBhZ2UYATBBbHBoYUJhbGFuY2UAAE0LCFhub2RlX3N1YnRlbnNvcl9ydW50aW1lMFJ1bnRpbWVFcnJvcgABVBhTeXN0ZW0EAPUBAXBmcmFtZV9zeXN0ZW06OkVycm9yPFJ1bnRpbWU+AAAAHEdyYW5kcGEEAEkGAXhwYWxsZXRfZ3JhbmRwYTo6RXJyb3I8UnVudGltZT4ABAAgQmFsYW5jZXMEAJkGAXxwYWxsZXRfYmFsYW5jZXM6OkVycm9yPFJ1bnRpbWU+AAUAPFN1YnRlbnNvck1vZHVsZQQAQQcBgHBhbGxldF9zdWJ0ZW5zb3I6OkVycm9yPFJ1bnRpbWU+AAcAHFV0aWxpdHkEAEUHAXhwYWxsZXRfdXRpbGl0eTo6RXJyb3I8UnVudGltZT4ACwAQU3VkbwQASQcBbHBhbGxldF9zdWRvOjpFcnJvcjxSdW50aW1lPgAMACBNdWx0aXNpZwQAWQcBfHBhbGxldF9tdWx0aXNpZzo6RXJyb3I8UnVudGltZT4ADQAgUHJlaW1hZ2UEAIEHAXxwYWxsZXRfcHJlaW1hZ2U6OkVycm9yPFJ1bnRpbWU+AA4AJFNjaGVkdWxlcgQAoQcBgHBhbGxldF9zY2hlZHVsZXI6OkVycm9yPFJ1bnRpbWU+AA8AFFByb3h5BADFBwFwcGFsbGV0X3Byb3h5OjpFcnJvcjxSdW50aW1lPgAQACBSZWdpc3RyeQQAzQcBfHBhbGxldF9yZWdpc3RyeTo6RXJyb3I8UnVudGltZT4AEQAsQ29tbWl0bWVudHMEAOkHAYhwYWxsZXRfY29tbWl0bWVudHM6OkVycm9yPFJ1bnRpbWU+ABIAKEFkbWluVXRpbHMEAO0HAYhwYWxsZXRfYWRtaW5fdXRpbHM6OkVycm9yPFJ1bnRpbWU+ABMAIFNhZmVNb2RlBAD1BwGAcGFsbGV0X3NhZmVfbW9kZTo6RXJyb3I8UnVudGltZT4AFAAgRXRoZXJldW0EADUIAXxwYWxsZXRfZXRoZXJldW06OkVycm9yPFJ1bnRpbWU+ABUADEVWTQQAQQgBaHBhbGxldF9ldm06OkVycm9yPFJ1bnRpbWU+ABYAFERyYW5kBABFCAFwcGFsbGV0X2RyYW5kOjpFcnJvcjxSdW50aW1lPgAaACRDcm93ZGxvYW4EAFUIAYBwYWxsZXRfY3Jvd2Rsb2FuOjpFcnJvcjxSdW50aW1lPgAbABBTd2FwBAB1CAGUcGFsbGV0X3N1YnRlbnNvcl9zd2FwOjpFcnJvcjxSdW50aW1lPgAcACRDb250cmFjdHMEAMkIAYBwYWxsZXRfY29udHJhY3RzOjpFcnJvcjxSdW50aW1lPgAdACRNZXZTaGllbGQEANEIAXRwYWxsZXRfc2hpZWxkOjpFcnJvcjxSdW50aW1lPgAeAABsGFN5c3RlbQEYU3lzdGVtTBxBY2NvdW50AQEEAgAM4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACABOggVGhlIGZ1bGwgYWNjb3VudCBpbmZvcm1hdGlvbiBmb3IgYSBwYXJ0aWN1bGFyIGFjY291bnQgSUQuADhFeHRyaW5zaWNDb3VudAAAEAQABLggVG90YWwgZXh0cmluc2ljcyBjb3VudCBmb3IgdGhlIGN1cnJlbnQgYmxvY2suAEBJbmhlcmVudHNBcHBsaWVkAQAkBAAEpCBXaGV0aGVyIGFsbCBpbmhlcmVudHMgaGF2ZSBiZWVuIGFwcGxpZWQuACxCbG9ja1dlaWdodAEAKBgAAAAAAAAEiCBUaGUgY3VycmVudCB3ZWlnaHQgZm9yIHRoZSBibG9jay4AQEFsbEV4dHJpbnNpY3NMZW4AABAEAARBASBUb3RhbCBsZW5ndGggKGluIGJ5dGVzKSBmb3IgYWxsIGV4dHJpbnNpY3MgcHV0IHRvZ2V0aGVyLCBmb3IgdGhlIGN1cnJlbnQgYmxvY2suACRCbG9ja0hhc2gBAQQFEDSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEmCBNYXAgb2YgYmxvY2sgbnVtYmVycyB0byBibG9jayBoYXNoZXMuADRFeHRyaW5zaWNEYXRhAQEEBRA4BAAEPQEgRXh0cmluc2ljcyBkYXRhIGZvciB0aGUgY3VycmVudCBibG9jayAobWFwcyBhbiBleHRyaW5zaWMncyBpbmRleCB0byBpdHMgZGF0YSkuABhOdW1iZXIBABAQAAAAAAQJASBUaGUgY3VycmVudCBibG9jayBudW1iZXIgYmVpbmcgcHJvY2Vzc2VkLiBTZXQgYnkgYGV4ZWN1dGVfYmxvY2tgLgAoUGFyZW50SGFzaAEANIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARwIEhhc2ggb2YgdGhlIHByZXZpb3VzIGJsb2NrLgAYRGlnZXN0AQA8BAAE8CBEaWdlc3Qgb2YgdGhlIGN1cnJlbnQgYmxvY2ssIGFsc28gcGFydCBvZiB0aGUgYmxvY2sgaGVhZGVyLgAYRXZlbnRzAQBMBAAcoCBFdmVudHMgZGVwb3NpdGVkIGZvciB0aGUgY3VycmVudCBibG9jay4AHQEgTk9URTogVGhlIGl0ZW0gaXMgdW5ib3VuZCBhbmQgc2hvdWxkIHRoZXJlZm9yZSBuZXZlciBiZSByZWFkIG9uIGNoYWluLtAgSXQgY291bGQgb3RoZXJ3aXNlIGluZmxhdGUgdGhlIFBvViBzaXplIG9mIGEgYmxvY2suAC0BIEV2ZW50cyBoYXZlIGEgbGFyZ2UgaW4tbWVtb3J5IHNpemUuIEJveCB0aGUgZXZlbnRzIHRvIG5vdCBnbyBvdXQtb2YtbWVtb3J5/CBqdXN0IGluIGNhc2Ugc29tZW9uZSBzdGlsbCByZWFkcyB0aGVtIGZyb20gd2l0aGluIHRoZSBydW50aW1lLgAoRXZlbnRDb3VudAEAEBAAAAAABLggVGhlIG51bWJlciBvZiBldmVudHMgaW4gdGhlIGBFdmVudHM8VD5gIGxpc3QuACxFdmVudFRvcGljcwEBBAI0qQEEACglASBNYXBwaW5nIGJldHdlZW4gYSB0b3BpYyAocmVwcmVzZW50ZWQgYnkgVDo6SGFzaCkgYW5kIGEgdmVjdG9yIG9mIGluZGV4ZXOUIG9mIGV2ZW50cyBpbiB0aGUgYDxFdmVudHM8VD4+YCBsaXN0LgBRASBBbGwgdG9waWMgdmVjdG9ycyBoYXZlIGRldGVybWluaXN0aWMgc3RvcmFnZSBsb2NhdGlvbnMgZGVwZW5kaW5nIG9uIHRoZSB0b3BpYy4gVGhpc0UBIGFsbG93cyBsaWdodC1jbGllbnRzIHRvIGxldmVyYWdlIHRoZSBjaGFuZ2VzIHRyaWUgc3RvcmFnZSB0cmFja2luZyBtZWNoYW5pc20gYW5k5CBpbiBjYXNlIG9mIGNoYW5nZXMgZmV0Y2ggdGhlIGxpc3Qgb2YgZXZlbnRzIG9mIGludGVyZXN0LgBZASBUaGUgdmFsdWUgaGFzIHRoZSB0eXBlIGAoQmxvY2tOdW1iZXJGb3I8VD4sIEV2ZW50SW5kZXgpYCBiZWNhdXNlIGlmIHdlIHVzZWQgb25seSBqdXN0TQEgdGhlIGBFdmVudEluZGV4YCB0aGVuIGluIGNhc2UgaWYgdGhlIHRvcGljIGhhcyB0aGUgc2FtZSBjb250ZW50cyBvbiB0aGUgbmV4dCBibG9jawEBIG5vIG5vdGlmaWNhdGlvbiB3aWxsIGJlIHRyaWdnZXJlZCB0aHVzIHRoZSBldmVudCBtaWdodCBiZSBsb3N0LgBITGFzdFJ1bnRpbWVVcGdyYWRlAACtAQQABFUBIFN0b3JlcyB0aGUgYHNwZWNfdmVyc2lvbmAgYW5kIGBzcGVjX25hbWVgIG9mIHdoZW4gdGhlIGxhc3QgcnVudGltZSB1cGdyYWRlIGhhcHBlbmVkLgBUVXBncmFkZWRUb1UzMlJlZkNvdW50AQAkBAAETQEgVHJ1ZSBpZiB3ZSBoYXZlIHVwZ3JhZGVkIHNvIHRoYXQgYHR5cGUgUmVmQ291bnRgIGlzIGB1MzJgLiBGYWxzZSAoZGVmYXVsdCkgaWYgbm90LgBgVXBncmFkZWRUb1RyaXBsZVJlZkNvdW50AQAkBAAIXQEgVHJ1ZSBpZiB3ZSBoYXZlIHVwZ3JhZGVkIHNvIHRoYXQgQWNjb3VudEluZm8gY29udGFpbnMgdGhyZWUgdHlwZXMgb2YgYFJlZkNvdW50YC4gRmFsc2VIIChkZWZhdWx0KSBpZiBub3QuADhFeGVjdXRpb25QaGFzZQAApQEEAASIIFRoZSBleGVjdXRpb24gcGhhc2Ugb2YgdGhlIGJsb2NrLgBEQXV0aG9yaXplZFVwZ3JhZGUAALUBBAAEuCBgU29tZWAgaWYgYSBjb2RlIHVwZ3JhZGUgaGFzIGJlZW4gYXV0aG9yaXplZC4AYEV4dHJpbnNpY1dlaWdodFJlY2xhaW1lZAEALAgAABygIFRoZSB3ZWlnaHQgcmVjbGFpbWVkIGZvciB0aGUgZXh0cmluc2ljLgAhASBUaGlzIGluZm9ybWF0aW9uIGlzIGF2YWlsYWJsZSB1bnRpbCB0aGUgZW5kIG9mIHRoZSBleHRyaW5zaWMgZXhlY3V0aW9uLiEBIE1vcmUgcHJlY2lzZWx5IHRoaXMgaW5mb3JtYXRpb24gaXMgcmVtb3ZlZCBpbiBgbm90ZV9hcHBsaWVkX2V4dHJpbnNpY2AuAHEBIExvZ2ljIGRvaW5nIHNvbWUgcG9zdCBkaXNwYXRjaCB3ZWlnaHQgcmVkdWN0aW9uIG11c3QgdXBkYXRlIHRoaXMgc3RvcmFnZSB0byBhdm9pZCBkdXBsaWNhdGUsIHJlZHVjdGlvbi4AAbkBAAFYABgwQmxvY2tXZWlnaHRzyQH5AcKg52YACwBAlFKjAxP//////////yJhyRkAAQu4N6FVXQITZmZmZmZmZqYBCwAw7326AhP/////////vwEAACJhyRkAAQu4R0YqRgMTZmZmZmZmZuYBCwBAlFKjAxP//////////wEHABCl1OgTAAAAAAAAAEAiYckZAAAAAATQIEJsb2NrICYgZXh0cmluc2ljcyB3ZWlnaHRzOiBiYXNlIHZhbHVlcyBhbmQgbGltaXRzLgAsQmxvY2tMZW5ndGjVATAAAHgAAACgAAAAoAAEqCBUaGUgbWF4aW11bSBsZW5ndGggb2YgYSBibG9jayAoaW4gYnl0ZXMpLgA4QmxvY2tIYXNoQ291bnQQEGAJAAAEVQEgTWF4aW11bSBudW1iZXIgb2YgYmxvY2sgbnVtYmVyIHRvIGJsb2NrIGhhc2ggbWFwcGluZ3MgdG8ga2VlcCAob2xkZXN0IHBydW5lZCBmaXJzdCkuACBEYldlaWdodN0BQEB4fQEAAAAAAOH1BQAAAAAECQEgVGhlIHdlaWdodCBvZiBydW50aW1lIGRhdGFiYXNlIG9wZXJhdGlvbnMgdGhlIHJ1bnRpbWUgY2FuIGludm9rZS4AHFZlcnNpb27hAeEEOG5vZGUtc3VidGVuc29yOG5vZGUtc3VidGVuc29yAQAAAH0BAAABAAAAWN9qy2iZB2CbBQAAADfjl/x8kfXkAgAAAED+OtQB+JWaBgAAAPvFd7nXR+/WAQAAANK8mJfu0I8VAwAAAPeLJ4vlP0VMAgAAAN1xjVzFMmLUAQAAAKs8BXIpH+uLAQAAAO2ZxayyXu31AwAAALydiZBPW5I/AQAAADfIuxNQqaKoBAAAAPP/FNWrUnBZAwAAAFgiEfZbsUuJBgAAAOZbAORs7dCqAgAAAGi2a6EiyT+nAgAAAELmK+SjnltgAQAAAIBt9MyqntSFAQAAAIN1EEspm3TFAQAAAF0fv76FLygHAQAAAMaIbi+OWYsKAQAAAMvKJeOfFCOHAgAAAKiwk+ZQjZ6cAQAAAAEAAAABBIQgR2V0IHRoZSBjaGFpbidzIGluLWNvZGUgdmVyc2lvbi4AKFNTNThQcmVmaXigCCoAFKggVGhlIGRlc2lnbmF0ZWQgU1M1OCBwcmVmaXggb2YgdGhpcyBjaGFpbi4AOQEgVGhpcyByZXBsYWNlcyB0aGUgInNzNThGb3JtYXQiIHByb3BlcnR5IGRlY2xhcmVkIGluIHRoZSBjaGFpbiBzcGVjLiBSZWFzb24gaXMxASB0aGF0IHRoZSBydW50aW1lIHNob3VsZCBrbm93IGFib3V0IHRoZSBwcmVmaXggaW4gb3JkZXIgdG8gbWFrZSB1c2Ugb2YgaXQgYXNwIGFuIGlkZW50aWZpZXIgb2YgdGhlIGNoYWluLgAB9QEAHCxSdW50aW1lQ2FsbPkBBIwgVGhlIGFnZ3JlZ2F0ZWQgYFJ1bnRpbWVDYWxsYCB0eXBlLhROb25jZRAESQEgVGhpcyBzdG9yZXMgdGhlIG51bWJlciBvZiBwcmV2aW91cyB0cmFuc2FjdGlvbnMgYXNzb2NpYXRlZCB3aXRoIGEgc2VuZGVyIGFjY291bnQuEEhhc2g0BJggVGhlIG91dHB1dCBvZiB0aGUgYEhhc2hpbmdgIGZ1bmN0aW9uLhxIYXNoaW5n3QUEIQEgVGhlIGhhc2hpbmcgc3lzdGVtIChhbGdvcml0aG0pIGJlaW5nIHVzZWQgaW4gdGhlIHJ1bnRpbWUgKGUuZy4gQmxha2UyKS4kQWNjb3VudElkAATIIFRoZSB1c2VyIGFjY291bnQgaWRlbnRpZmllciB0eXBlIGZvciB0aGUgcnVudGltZS4UQmxvY2vhBQhhASBUaGUgQmxvY2sgdHlwZSB1c2VkIGJ5IHRoZSBydW50aW1lLiBUaGlzIGlzIHVzZWQgYnkgYGNvbnN0cnVjdF9ydW50aW1lYCB0byByZXRyaWV2ZSB0aGXMIGV4dHJpbnNpY3Mgb3Igb3RoZXIgYmxvY2sgc3BlY2lmaWMgZGF0YSBhcyBuZWVkZWQuLEFjY291bnREYXRhFAhhASBEYXRhIHRvIGJlIGFzc29jaWF0ZWQgd2l0aCBhbiBhY2NvdW50IChvdGhlciB0aGFuIG5vbmNlL3RyYW5zYWN0aW9uIGNvdW50ZXIsIHdoaWNoIHRoaXNkIHBhbGxldCBkb2VzIHJlZ2FyZGxlc3MpLgAAAABgUmFuZG9tbmVzc0NvbGxlY3RpdmVGbGlwAWBSYW5kb21uZXNzQ29sbGVjdGl2ZUZsaXAEOFJhbmRvbU1hdGVyaWFsAQA1BgQADGEBIFNlcmllcyBvZiBibG9jayBoZWFkZXJzIGZyb20gdGhlIGxhc3QgODEgYmxvY2tzIHRoYXQgYWN0cyBhcyByYW5kb20gc2VlZCBtYXRlcmlhbC4gVGhpc2EBIGlzIGFycmFuZ2VkIGFzIGEgcmluZyBidWZmZXIgd2l0aCBgYmxvY2tfbnVtYmVyICUgODFgIGJlaW5nIHRoZSBpbmRleCBpbnRvIHRoZSBgVmVjYCBvZkQgdGhlIG9sZGVzdCBoYXNoLgAAAAAAAAABAAAkVGltZXN0YW1wASRUaW1lc3RhbXAIDE5vdwEAGCAAAAAAAAAAAASgIFRoZSBjdXJyZW50IHRpbWUgZm9yIHRoZSBjdXJyZW50IGJsb2NrLgAkRGlkVXBkYXRlAQAkBAAQ2CBXaGV0aGVyIHRoZSB0aW1lc3RhbXAgaGFzIGJlZW4gdXBkYXRlZCBpbiB0aGlzIGJsb2NrLgBVASBUaGlzIHZhbHVlIGlzIHVwZGF0ZWQgdG8gYHRydWVgIHVwb24gc3VjY2Vzc2Z1bCBzdWJtaXNzaW9uIG9mIGEgdGltZXN0YW1wIGJ5IGEgbm9kZS5FASBJdCBpcyB0aGVuIGNoZWNrZWQgYXQgdGhlIGVuZCBvZiBlYWNoIGJsb2NrIGV4ZWN1dGlvbiBpbiB0aGUgYG9uX2ZpbmFsaXplYCBob29rLgAB/QEAAAQ0TWluaW11bVBlcmlvZBggfQAAAAAAAAAYjCBUaGUgbWluaW11bSBwZXJpb2QgYmV0d2VlbiBibG9ja3MuAE0BIEJlIGF3YXJlIHRoYXQgdGhpcyBpcyBkaWZmZXJlbnQgdG8gdGhlICpleHBlY3RlZCogcGVyaW9kIHRoYXQgdGhlIGJsb2NrIHByb2R1Y3Rpb25JASBhcHBhcmF0dXMgcHJvdmlkZXMuIFlvdXIgY2hvc2VuIGNvbnNlbnN1cyBzeXN0ZW0gd2lsbCBnZW5lcmFsbHkgd29yayB3aXRoIHRoaXMgdG9hASBkZXRlcm1pbmUgYSBzZW5zaWJsZSBibG9jayB0aW1lLiBGb3IgZXhhbXBsZSwgaW4gdGhlIEF1cmEgcGFsbGV0IGl0IHdpbGwgYmUgZG91YmxlIHRoaXNwIHBlcmlvZCBvbiBkZWZhdWx0IHNldHRpbmdzLgAABBhNb21lbnQYBJggVHlwZSB1c2VkIGZvciBleHByZXNzaW5nIGEgdGltZXN0YW1wLgACAAAQQXVyYQEQQXVyYQgsQXV0aG9yaXRpZXMBAOEEBAAEbCBUaGUgY3VycmVudCBhdXRob3JpdHkgc2V0LgAsQ3VycmVudFNsb3QBADkGIAAAAAAAAAAADIAgVGhlIGN1cnJlbnQgc2xvdCBvZiB0aGlzIGJsb2NrLgCUIFRoaXMgd2lsbCBiZSBzZXQgaW4gYG9uX2luaXRpYWxpemVgLgAAAAQwU2xvdER1cmF0aW9uGCD6AAAAAAAAABANASBUaGUgc2xvdCBkdXJhdGlvbiBBdXJhIHNob3VsZCBydW4gd2l0aCwgZXhwcmVzc2VkIGluIG1pbGxpc2Vjb25kcy49ASBUaGUgZWZmZWN0aXZlIHZhbHVlIG9mIHRoaXMgdHlwZSBzaG91bGQgbm90IGNoYW5nZSB3aGlsZSB0aGUgY2hhaW4gaXMgcnVubmluZy4ANQEgRm9yIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5IGVpdGhlciB1c2UgW2BNaW5pbXVtUGVyaW9kVGltZXNUd29gXSBvciBhIGNvbnN0LgAABCxBdXRob3JpdHlJZOUEBJggVGhlIGlkZW50aWZpZXIgdHlwZSBmb3IgYW4gYXV0aG9yaXR5LgADAAAcR3JhbmRwYQEcR3JhbmRwYRwUU3RhdGUBAD0GBAAEkCBTdGF0ZSBvZiB0aGUgY3VycmVudCBhdXRob3JpdHkgc2V0LgA0UGVuZGluZ0NoYW5nZQAAQQYEAATEIFBlbmRpbmcgY2hhbmdlOiAoc2lnbmFsZWQgYXQsIHNjaGVkdWxlZCBjaGFuZ2UpLgAoTmV4dEZvcmNlZAAAEAQABLwgbmV4dCBibG9jayBudW1iZXIgd2hlcmUgd2UgY2FuIGZvcmNlIGEgY2hhbmdlLgAcU3RhbGxlZAAA/AQABJAgYHRydWVgIGlmIHdlIGFyZSBjdXJyZW50bHkgc3RhbGxlZC4AMEN1cnJlbnRTZXRJZAEAGCAAAAAAAAAAAAhdASBUaGUgbnVtYmVyIG9mIGNoYW5nZXMgKGJvdGggaW4gdGVybXMgb2Yga2V5cyBhbmQgdW5kZXJseWluZyBlY29ub21pYyByZXNwb25zaWJpbGl0aWVzKcQgaW4gdGhlICJzZXQiIG9mIEdyYW5kcGEgdmFsaWRhdG9ycyBmcm9tIGdlbmVzaXMuADBTZXRJZFNlc3Npb24AAQQFGBAEAChZASBBIG1hcHBpbmcgZnJvbSBncmFuZHBhIHNldCBJRCB0byB0aGUgaW5kZXggb2YgdGhlICptb3N0IHJlY2VudCogc2Vzc2lvbiBmb3Igd2hpY2ggaXRzaCBtZW1iZXJzIHdlcmUgcmVzcG9uc2libGUuAEUBIFRoaXMgaXMgb25seSB1c2VkIGZvciB2YWxpZGF0aW5nIGVxdWl2b2NhdGlvbiBwcm9vZnMuIEFuIGVxdWl2b2NhdGlvbiBwcm9vZiBtdXN0TQEgY29udGFpbnMgYSBrZXktb3duZXJzaGlwIHByb29mIGZvciBhIGdpdmVuIHNlc3Npb24sIHRoZXJlZm9yZSB3ZSBuZWVkIGEgd2F5IHRvIHRpZUUBIHRvZ2V0aGVyIHNlc3Npb25zIGFuZCBHUkFORFBBIHNldCBpZHMsIGkuZS4gd2UgbmVlZCB0byB2YWxpZGF0ZSB0aGF0IGEgdmFsaWRhdG9yQQEgd2FzIHRoZSBvd25lciBvZiBhIGdpdmVuIGtleSBvbiBhIGdpdmVuIHNlc3Npb24sIGFuZCB3aGF0IHRoZSBhY3RpdmUgc2V0IElEIHdhc1QgZHVyaW5nIHRoYXQgc2Vzc2lvbi4AuCBUV09YLU5PVEU6IGBTZXRJZGAgaXMgbm90IHVuZGVyIHVzZXIgY29udHJvbC4ALEF1dGhvcml0aWVzAQBFBgQABIQgVGhlIGN1cnJlbnQgbGlzdCBvZiBhdXRob3JpdGllcy4AAQECAAGAAAw4TWF4QXV0aG9yaXRpZXMQECAAAAAEXCBNYXggQXV0aG9yaXRpZXMgaW4gdXNlADRNYXhOb21pbmF0b3JzEBAUAAAABNQgVGhlIG1heGltdW0gbnVtYmVyIG9mIG5vbWluYXRvcnMgZm9yIGVhY2ggdmFsaWRhdG9yLgBYTWF4U2V0SWRTZXNzaW9uRW50cmllcxggAAAAAAAAAAAYOQEgVGhlIG1heGltdW0gbnVtYmVyIG9mIGVudHJpZXMgdG8ga2VlcCBpbiB0aGUgc2V0IGlkIHRvIHNlc3Npb24gaW5kZXggbWFwcGluZy4AMQEgU2luY2UgdGhlIGBTZXRJZFNlc3Npb25gIG1hcCBpcyBvbmx5IHVzZWQgZm9yIHZhbGlkYXRpbmcgZXF1aXZvY2F0aW9ucyB0aGlzKQEgdmFsdWUgc2hvdWxkIHJlbGF0ZSB0byB0aGUgYm9uZGluZyBkdXJhdGlvbiBvZiB3aGF0ZXZlciBzdGFraW5nIHN5c3RlbSBpczUBIGJlaW5nIHVzZWQgKGlmIGFueSkuIElmIGVxdWl2b2NhdGlvbiBoYW5kbGluZyBpcyBub3QgZW5hYmxlZCB0aGVuIHRoaXMgdmFsdWU0IGNhbiBiZSB6ZXJvLgABSQYABDRLZXlPd25lclByb29mLQIMFQEgVGhlIHByb29mIG9mIGtleSBvd25lcnNoaXAsIHVzZWQgZm9yIHZhbGlkYXRpbmcgZXF1aXZvY2F0aW9uIHJlcG9ydHP8IFRoZSBwcm9vZiBpbmNsdWRlIHRoZSBzZXNzaW9uIGluZGV4IGFuZCB2YWxpZGF0b3IgY291bnQgb2YgdGhlsCBzZXNzaW9uIGF0IHdoaWNoIHRoZSBlcXVpdm9jYXRpb24gb2NjdXJyZWQuAAQAACBCYWxhbmNlcwEgQmFsYW5jZXMcNFRvdGFsSXNzdWFuY2UBABggAAAAAAAAAAAEmCBUaGUgdG90YWwgdW5pdHMgaXNzdWVkIGluIHRoZSBzeXN0ZW0uAEBJbmFjdGl2ZUlzc3VhbmNlAQAYIAAAAAAAAAAABAkBIFRoZSB0b3RhbCB1bml0cyBvZiBvdXRzdGFuZGluZyBkZWFjdGl2YXRlZCBiYWxhbmNlIGluIHRoZSBzeXN0ZW0uABxBY2NvdW50AQEEAgAUoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBgCQEgVGhlIEJhbGFuY2VzIHBhbGxldCBleGFtcGxlIG9mIHN0b3JpbmcgdGhlIGJhbGFuY2Ugb2YgYW4gYWNjb3VudC4AKCAjIEV4YW1wbGUANCBgYGBub2NvbXBpbGWwICBpbXBsIHBhbGxldF9iYWxhbmNlczo6Q29uZmlnIGZvciBSdW50aW1lIHsZAiAgICB0eXBlIEFjY291bnRTdG9yZSA9IFN0b3JhZ2VNYXBTaGltPFNlbGY6OkFjY291bnQ8UnVudGltZT4sIGZyYW1lX3N5c3RlbTo6UHJvdmlkZXI8UnVudGltZT4sIEFjY291bnRJZCwgU2VsZjo6QWNjb3VudERhdGE8QmFsYW5jZT4+DCAgfRAgYGBgABUBIFlvdSBjYW4gYWxzbyBzdG9yZSB0aGUgYmFsYW5jZSBvZiBhbiBhY2NvdW50IGluIHRoZSBgU3lzdGVtYCBwYWxsZXQuACggIyBFeGFtcGxlADQgYGBgbm9jb21waWxlsCAgaW1wbCBwYWxsZXRfYmFsYW5jZXM6OkNvbmZpZyBmb3IgUnVudGltZSB7dCAgIHR5cGUgQWNjb3VudFN0b3JlID0gU3lzdGVtDCAgfRAgYGBgAFEBIEJ1dCB0aGlzIGNvbWVzIHdpdGggdHJhZGVvZmZzLCBzdG9yaW5nIGFjY291bnQgYmFsYW5jZXMgaW4gdGhlIHN5c3RlbSBwYWxsZXQgc3RvcmVzbQEgYGZyYW1lX3N5c3RlbWAgZGF0YSBhbG9uZ3NpZGUgdGhlIGFjY291bnQgZGF0YSBjb250cmFyeSB0byBzdG9yaW5nIGFjY291bnQgYmFsYW5jZXMgaW4gdGhlKQEgYEJhbGFuY2VzYCBwYWxsZXQsIHdoaWNoIHVzZXMgYSBgU3RvcmFnZU1hcGAgdG8gc3RvcmUgYmFsYW5jZXMgZGF0YSBvbmx5LkEBIE5PVEU6IFRoaXMgaXMgb25seSB1c2VkIGluIHRoZSBjYXNlIHRoYXQgdGhpcyBwYWxsZXQgaXMgdXNlZCB0byBzdG9yZSBiYWxhbmNlcy4AFExvY2tzAQEEAgBNBgQAELggQW55IGxpcXVpZGl0eSBsb2NrcyBvbiBzb21lIGFjY291bnQgYmFsYW5jZXMuJQEgTk9URTogU2hvdWxkIG9ubHkgYmUgYWNjZXNzZWQgd2hlbiBzZXR0aW5nLCBjaGFuZ2luZyBhbmQgZnJlZWluZyBhIGxvY2suAK0BIFVzZSBvZiBsb2NrcyBpcyBkZXByZWNhdGVkIGluIGZhdm91ciBvZiBmcmVlemVzLiBTZWUgYGh0dHBzOi8vZ2l0aHViLmNvbS9wYXJpdHl0ZWNoL3N1YnN0cmF0ZS9wdWxsLzEyOTUxL2AAIFJlc2VydmVzAQEEAgBdBgQADKQgTmFtZWQgcmVzZXJ2ZXMgb24gc29tZSBhY2NvdW50IGJhbGFuY2VzLgCxASBVc2Ugb2YgcmVzZXJ2ZXMgaXMgZGVwcmVjYXRlZCBpbiBmYXZvdXIgb2YgaG9sZHMuIFNlZSBgaHR0cHM6Ly9naXRodWIuY29tL3Bhcml0eXRlY2gvc3Vic3RyYXRlL3B1bGwvMTI5NTEvYAAUSG9sZHMBAQQCAGkGBAAEbCBIb2xkcyBvbiBhY2NvdW50IGJhbGFuY2VzLgAcRnJlZXplcwEBBAIAiQYEAASIIEZyZWV6ZSBsb2NrcyBvbiBhY2NvdW50IGJhbGFuY2VzLgABMQIAAZAAEEhFeGlzdGVudGlhbERlcG9zaXQYIPQBAAAAAAAAIEEBIFRoZSBtaW5pbXVtIGFtb3VudCByZXF1aXJlZCB0byBrZWVwIGFuIGFjY291bnQgb3Blbi4gTVVTVCBCRSBHUkVBVEVSIFRIQU4gWkVSTyEAWQEgSWYgeW91ICpyZWFsbHkqIG5lZWQgaXQgdG8gYmUgemVybywgeW91IGNhbiBlbmFibGUgdGhlIGZlYXR1cmUgYGluc2VjdXJlX3plcm9fZWRgIGZvcmEBIHRoaXMgcGFsbGV0LiBIb3dldmVyLCB5b3UgZG8gc28gYXQgeW91ciBvd24gcmlzazogdGhpcyB3aWxsIG9wZW4gdXAgYSBtYWpvciBEb1MgdmVjdG9yLlkBIEluIGNhc2UgeW91IGhhdmUgbXVsdGlwbGUgc291cmNlcyBvZiBwcm92aWRlciByZWZlcmVuY2VzLCB5b3UgbWF5IGFsc28gZ2V0IHVuZXhwZWN0ZWSMIGJlaGF2aW91ciBpZiB5b3Ugc2V0IHRoaXMgdG8gemVyby4A8CBCb3R0b20gbGluZTogRG8geW91cnNlbGYgYSBmYXZvdXIgYW5kIG1ha2UgaXQgYXQgbGVhc3Qgb25lIQAgTWF4TG9ja3MQEDIAAAAQ9CBUaGUgbWF4aW11bSBudW1iZXIgb2YgbG9ja3MgdGhhdCBzaG91bGQgZXhpc3Qgb24gYW4gYWNjb3VudC7cIE5vdCBzdHJpY3RseSBlbmZvcmNlZCwgYnV0IHVzZWQgZm9yIHdlaWdodCBlc3RpbWF0aW9uLgCtASBVc2Ugb2YgbG9ja3MgaXMgZGVwcmVjYXRlZCBpbiBmYXZvdXIgb2YgZnJlZXplcy4gU2VlIGBodHRwczovL2dpdGh1Yi5jb20vcGFyaXR5dGVjaC9zdWJzdHJhdGUvcHVsbC8xMjk1MS9gACxNYXhSZXNlcnZlcxAQMgAAAAwNASBUaGUgbWF4aW11bSBudW1iZXIgb2YgbmFtZWQgcmVzZXJ2ZXMgdGhhdCBjYW4gZXhpc3Qgb24gYW4gYWNjb3VudC4AsQEgVXNlIG9mIHJlc2VydmVzIGlzIGRlcHJlY2F0ZWQgaW4gZmF2b3VyIG9mIGhvbGRzLiBTZWUgYGh0dHBzOi8vZ2l0aHViLmNvbS9wYXJpdHl0ZWNoL3N1YnN0cmF0ZS9wdWxsLzEyOTUxL2AAKE1heEZyZWV6ZXMQEDIAAAAEYQEgVGhlIG1heGltdW0gbnVtYmVyIG9mIGluZGl2aWR1YWwgZnJlZXplIGxvY2tzIHRoYXQgY2FuIGV4aXN0IG9uIGFuIGFjY291bnQgYXQgYW55IHRpbWUuAAGZBgAQRFJ1bnRpbWVIb2xkUmVhc29ucQYEdCBUaGUgb3ZlcmFyY2hpbmcgaG9sZCByZWFzb24uHEJhbGFuY2UYBGwgVGhlIGJhbGFuY2Ugb2YgYW4gYWNjb3VudC5EUmVzZXJ2ZUlkZW50aWZpZXLxAQxoIFRoZSBJRCB0eXBlIGZvciByZXNlcnZlcy4AsQEgVXNlIG9mIHJlc2VydmVzIGlzIGRlcHJlY2F0ZWQgaW4gZmF2b3VyIG9mIGhvbGRzLiBTZWUgYGh0dHBzOi8vZ2l0aHViLmNvbS9wYXJpdHl0ZWNoL3N1YnN0cmF0ZS9wdWxsLzEyOTUxL2BARnJlZXplSWRlbnRpZmllcpEGBGQgVGhlIElEIHR5cGUgZm9yIGZyZWV6ZXMuAAUAAEhUcmFuc2FjdGlvblBheW1lbnQBSFRyYW5zYWN0aW9uUGF5bWVudAhETmV4dEZlZU11bHRpcGxpZXIBAJ0GQAAAZKeztuANAAAAAAAAAAAAADhTdG9yYWdlVmVyc2lvbgEAoQYEAAAAAAGYAARgT3BlcmF0aW9uYWxGZWVNdWx0aXBsaWVyCAQFVFkBIEEgZmVlIG11bHRpcGxpZXIgZm9yIGBPcGVyYXRpb25hbGAgZXh0cmluc2ljcyB0byBjb21wdXRlICJ2aXJ0dWFsIHRpcCIgdG8gYm9vc3QgdGhlaXIsIGBwcmlvcml0eWAAUQEgVGhpcyB2YWx1ZSBpcyBtdWx0aXBsaWVkIGJ5IHRoZSBgZmluYWxfZmVlYCB0byBvYnRhaW4gYSAidmlydHVhbCB0aXAiIHRoYXQgaXMgbGF0ZXL0IGFkZGVkIHRvIGEgdGlwIGNvbXBvbmVudCBpbiByZWd1bGFyIGBwcmlvcml0eWAgY2FsY3VsYXRpb25zLk0BIEl0IG1lYW5zIHRoYXQgYSBgTm9ybWFsYCB0cmFuc2FjdGlvbiBjYW4gZnJvbnQtcnVuIGEgc2ltaWxhcmx5LXNpemVkIGBPcGVyYXRpb25hbGBBASBleHRyaW5zaWMgKHdpdGggbm8gdGlwKSwgYnkgaW5jbHVkaW5nIGEgdGlwIHZhbHVlIGdyZWF0ZXIgdGhhbiB0aGUgdmlydHVhbCB0aXAuADwgYGBgcnVzdCxpZ25vcmVAIC8vIEZvciBgTm9ybWFsYIwgbGV0IHByaW9yaXR5ID0gcHJpb3JpdHlfY2FsYyh0aXApOwBUIC8vIEZvciBgT3BlcmF0aW9uYWxgEQEgbGV0IHZpcnR1YWxfdGlwID0gKGluY2x1c2lvbl9mZWUgKyB0aXApICogT3BlcmF0aW9uYWxGZWVNdWx0aXBsaWVyO8QgbGV0IHByaW9yaXR5ID0gcHJpb3JpdHlfY2FsYyh0aXAgKyB2aXJ0dWFsX3RpcCk7ECBgYGAAUQEgTm90ZSB0aGF0IHNpbmNlIHdlIHVzZSBgZmluYWxfZmVlYCB0aGUgbXVsdGlwbGllciBhcHBsaWVzIGFsc28gdG8gdGhlIHJlZ3VsYXIgYHRpcGBdASBzZW50IHdpdGggdGhlIHRyYW5zYWN0aW9uLiBTbywgbm90IG9ubHkgZG9lcyB0aGUgdHJhbnNhY3Rpb24gZ2V0IGEgcHJpb3JpdHkgYnVtcCBiYXNlZGEBIG9uIHRoZSBgaW5jbHVzaW9uX2ZlZWAsIGJ1dCB3ZSBhbHNvIGFtcGxpZnkgdGhlIGltcGFjdCBvZiB0aXBzIGFwcGxpZWQgdG8gYE9wZXJhdGlvbmFsYDggdHJhbnNhY3Rpb25zLgAAAAAGAAA8U3VidGVuc29yTW9kdWxlATxTdWJ0ZW5zb3JNb2R1bGUJA0RNaW5BY3Rpdml0eUN1dG9mZgEAoAhoAQAAREFkbWluRnJlZXplV2luZG93AQCgCAoABEkBIEdsb2JhbCB3aW5kb3cgKGluIGJsb2NrcykgYXQgdGhlIGVuZCBvZiBlYWNoIHRlbXBvIHdoZXJlIGFkbWluIG9wcyBhcmUgZGlzYWxsb3dlZABgT3duZXJIeXBlcnBhcmFtUmF0ZUxpbWl0AQCgCAIABD0BIEdsb2JhbCBudW1iZXIgb2YgZXBvY2hzIHVzZWQgdG8gcmF0ZSBsaW1pdCBzdWJuZXQgb3duZXIgaHlwZXJwYXJhbWV0ZXIgdXBkYXRlcwB8RGlzc29sdmVOZXR3b3JrU2NoZWR1bGVEdXJhdGlvbgEAEBCgjAAABNwgRHVyYXRpb24gb2YgZGlzc29sdmUgbmV0d29yayBzY2hlZHVsZSBiZWZvcmUgZXhlY3V0aW9uAFhMYXN0SG90a2V5U3dhcE9uTmV0dWlkAQEIBgKlBhggAAAAAAAAAAAEMQEgLS0tIERNYXAgKCBuZXR1aWQsIGNvbGRrZXkgKSAtLT4gYmxvY2tudW1iZXIgfCBsYXN0IGhvdGtleSBzd2FwIG9uIG5ldHdvcmsuADhOZXh0U3Rha2VKb2JJZAEAGCAAAAAAAAAAAAS0IEVuc3VyZXMgdW5pcXVlIElEcyBmb3IgU3Rha2VKb2JzIHN0b3JhZ2UgbWFwACRUYW9XZWlnaHQBABgg/GLgPvo8fA00dCA9PT09PT09PT09PT09PT09PT09PT09PT09PT09cCA9PT09IFN0YWtpbmcgVmFyaWFibGVzID09PT10ID09PT09PT09PT09PT09PT09PT09PT09PT09PT2JASBUaGUgU3VidGVuc29yIFtgVG90YWxJc3N1YW5jZWBdIHJlcHJlc2VudHMgdGhlIHRvdGFsIGlzc3VhbmNlIG9mIHRva2VucyBvbiB0aGUgQml0dGVuc29yIG5ldHdvcmsuAIAgSXQgaXMgY29tcHJpc2VkIG9mIHRocmVlIHBhcnRzOmUBIC0gVGhlIHRvdGFsIGFtb3VudCBvZiBpc3N1ZWQgdG9rZW5zLCB0cmFja2VkIGluIHRoZSBUb3RhbElzc3VhbmNlIG9mIHRoZSBCYWxhbmNlcyBwYWxsZXQ1ASAtIFRoZSB0b3RhbCBhbW91bnQgb2YgdG9rZW5zIHN0YWtlZCBpbiB0aGUgc3lzdGVtLCB0cmFja2VkIGluIFtgVG90YWxTdGFrZWBdAQIgLSBUaGUgdG90YWwgYW1vdW50IG9mIHRva2VucyBsb2NrZWQgdXAgZm9yIHN1Ym5ldCByZWcsIHRyYWNrZWQgaW4gW2BUb3RhbFN1Ym5ldExvY2tlZGBdIGF0dGFpbmVkIGJ5IGl0ZXJhdGluZyBvdmVyIHN1Ym5ldCBsb2NrLgB1ASBFdmVudHVhbGx5LCBCaXR0ZW5zb3Igc2hvdWxkIG1pZ3JhdGUgdG8gdXNpbmcgSG9sZHMgYWZ0ZXJ3aGljaCB0aW1lIHdlIHdpbGwgbm90IHJlcXVpcmUgdGhpc1Qgc2VwYXJhdGUgYWNjb3VudGluZy5sIC0tLSBJVEVNIC0tPiBHbG9iYWwgd2VpZ2h0ABhDS0J1cm4BABggAAAAAAAAAAAEVCAtLS0gSVRFTSAtLT4gQ0sgYnVybgA8TWF4RGVsZWdhdGVUYWtlAQCgCBQuBIwgLS0tIElURU0gKCBkZWZhdWx0X2RlbGVnYXRlX3Rha2UgKQA8TWluRGVsZWdhdGVUYWtlAQCgCAAABHwgLS0tIElURU0gKCBtaW5fZGVsZWdhdGVfdGFrZSApADxNYXhDaGlsZGtleVRha2UBAKAIFC4EjCAtLS0gSVRFTSAoIGRlZmF1bHRfY2hpbGRrZXlfdGFrZSApADxNaW5DaGlsZGtleVRha2UBAKAIAAAEfCAtLS0gSVRFTSAoIG1pbl9jaGlsZGtleV90YWtlICkAFE93bmVyAQEEAgAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBEBIE1BUCAoIGhvdCApIC0tPiBjb2xkIHwgUmV0dXJucyB0aGUgY29udHJvbGxpbmcgY29sZGtleSBmb3IgYSBob3RrZXkAJERlbGVnYXRlcwEBBAIAoAgULgSxASBNQVAgKCBob3QgKSAtLT4gdGFrZSB8IFJldHVybnMgdGhlIGhvdGtleSBkZWxlZ2F0aW9uIHRha2UuIEFuZCBzaWduYWxzIHRoYXQgdGhpcyBrZXkgaXMgb3BlbiBmb3IgZGVsZWdhdGlvbgAwQ2hpbGRrZXlUYWtlAQEIAgapBqAIAAAEXQEgRE1BUCAoIGhvdCwgbmV0dWlkICkgLS0+IHRha2UgfCBSZXR1cm5zIHRoZSBob3RrZXkgY2hpbGRrZXkgdGFrZSBmb3IgYSBzcGVjaWZpYyBzdWJuZXQAQFBlbmRpbmdDaGlsZEtleXMBAQgGAqUGrQYkAAAAAAAAAAAABB0BIERNQVAgKCBuZXR1aWQsIHBhcmVudCApIC0tPiAoVmVjPChwcm9wb3J0aW9uLGNoaWxkKT4sIGNvb2xfZG93bl9ibG9jaykAJENoaWxkS2V5cwEBCAIGqQawBAAE0CBETUFQICggcGFyZW50LCBuZXR1aWQgKSAtLT4gVmVjPChwcm9wb3J0aW9uLGNoaWxkKT4AKFBhcmVudEtleXMBAQgCBqkGsAQABNAgRE1BUCAoIGNoaWxkLCBuZXR1aWQgKSAtLT4gVmVjPChwcm9wb3J0aW9uLHBhcmVudCk+AFxBbHBoYURpdmlkZW5kc1BlclN1Ym5ldAEBCAYCpQYYIAAAAAAAAAAABFEBIC0tLSBETUFQICggbmV0dWlkLCBob3RrZXkgKSAtLT4gdTY0IHwgTGFzdCBhbHBoYSBkaXZpZGVuZCB0aGlzIGhvdGtleSBnb3Qgb24gdGVtcG8uAGxSb290QWxwaGFEaXZpZGVuZHNQZXJTdWJuZXQBAQgGAqUGGCAAAAAAAAAAAARlASAtLS0gRE1BUCAoIG5ldHVpZCwgaG90a2V5ICkgLS0+IHU2NCB8IExhc3Qgcm9vdCBhbHBoYSBkaXZpZGVuZCB0aGlzIGhvdGtleSBnb3Qgb24gdGVtcG8uADRCbG9ja0VtaXNzaW9uAQAYIADKmjsAAAAAEEwgPT09PT09PT09PT09PT09PT09TCA9PT09IENvaW5iYXNlID09PT1MID09PT09PT09PT09PT09PT09PZwgLS0tIElURU0gKCBnbG9iYWxfYmxvY2tfZW1pc3Npb24gKSAgICAAaExhc3RIb3RrZXlFbWlzc2lvbk9uTmV0dWlkAQEIAgapBhggAAAAAAAAAAAEJQEgLS0tIERNYXAgKCBob3QsIG5ldHVpZCApIC0tPiBlbWlzc2lvbiB8IGxhc3QgaG90a2V5IGVtaXNzaW9uIG9uIG5ldHdvcmsuACxTdWJuZXRMaW1pdAEAoAiAADRsID09PT09PT09PT09PT09PT09PT09PT09PT09bCA9PT09IFN0YWtpbmcgQ291bnRlcnMgPT09PWwgPT09PT09PT09PT09PT09PT09PT09PT09PT2JASBUaGUgU3VidGVuc29yIFtgVG90YWxJc3N1YW5jZWBdIHJlcHJlc2VudHMgdGhlIHRvdGFsIGlzc3VhbmNlIG9mIHRva2VucyBvbiB0aGUgQml0dGVuc29yIG5ldHdvcmsuAIAgSXQgaXMgY29tcHJpc2VkIG9mIHRocmVlIHBhcnRzOmUBIC0gVGhlIHRvdGFsIGFtb3VudCBvZiBpc3N1ZWQgdG9rZW5zLCB0cmFja2VkIGluIHRoZSBUb3RhbElzc3VhbmNlIG9mIHRoZSBCYWxhbmNlcyBwYWxsZXQ1ASAtIFRoZSB0b3RhbCBhbW91bnQgb2YgdG9rZW5zIHN0YWtlZCBpbiB0aGUgc3lzdGVtLCB0cmFja2VkIGluIFtgVG90YWxTdGFrZWBdAQIgLSBUaGUgdG90YWwgYW1vdW50IG9mIHRva2VucyBsb2NrZWQgdXAgZm9yIHN1Ym5ldCByZWcsIHRyYWNrZWQgaW4gW2BUb3RhbFN1Ym5ldExvY2tlZGBdIGF0dGFpbmVkIGJ5IGl0ZXJhdGluZyBvdmVyIHN1Ym5ldCBsb2NrLgB1ASBFdmVudHVhbGx5LCBCaXR0ZW5zb3Igc2hvdWxkIG1pZ3JhdGUgdG8gdXNpbmcgSG9sZHMgYWZ0ZXJ3aGljaCB0aW1lIHdlIHdpbGwgbm90IHJlcXVpcmUgdGhpc1Qgc2VwYXJhdGUgYWNjb3VudGluZy6gIC0tLSBJVEVNICggbWF4aW11bV9udW1iZXJfb2ZfbmV0d29ya3MgKQA0VG90YWxJc3N1YW5jZQEAGCAAAAAAAAAAAARwIC0tLSBJVEVNICggdG90YWxfaXNzdWFuY2UgKQAoVG90YWxTdGFrZQEAGCAAAAAAAAAAAARkIC0tLSBJVEVNICggdG90YWxfc3Rha2UgKQBEU3VibmV0TW92aW5nQWxwaGEBAPEEQFUyAAAAAAAAAAAAAAAAAAAE7CAtLS0gSVRFTSAoIG1vdmluZ19hbHBoYSApIC0tIHN1Ym5ldCBtb3ZpbmcgYWxwaGEuICAgICAgICAgAERTdWJuZXRNb3ZpbmdQcmljZQEBBAag8QRAAAAAAAAAAAAAAAAAAAAAAAT8IC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gbW92aW5nX3ByaWNlIHwgVGhlIHN1Ym5ldCBtb3ZpbmcgcHJpY2UuACBSb290UHJvcAEBBAagsQZAAAAAAAAAAAAAAAAAAAAAAAT8IC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gcm9vdF9wcm9wIHwgVGhlIHN1Ym5ldCByb290IHByb3BvcnRpb24uADBTdWJuZXRWb2x1bWUBAQQGoCBAAAAAAAAAAAAAAAAAAAAAAAS5ASAtLS0gTUFQICggbmV0dWlkICkgLS0+IHRvdGFsX3ZvbHVtZSB8IFRoZSB0b3RhbCBhbW91bnQgb2YgVEFPIGJvdWdodCBhbmQgc29sZCBzaW5jZSB0aGUgc3RhcnQgb2YgdGhlIG5ldHdvcmsuACRTdWJuZXRUQU8BAQQGoBggAAAAAAAAAAAEQQEgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiB0YW9faW5fc3VibmV0IHwgUmV0dXJucyB0aGUgYW1vdW50IG9mIFRBTyBpbiB0aGUgc3VibmV0LgBEU3VibmV0VGFvUHJvdmlkZWQBAQQGoBggAAAAAAAAAAAE8QEgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiB0YW9faW5fdXNlcl9zdWJuZXQgfCBSZXR1cm5zIHRoZSBhbW91bnQgb2YgVEFPIGluIHRoZSBzdWJuZXQgcmVzZXJ2ZSBwcm92aWRlZCBieSB1c2VycyBhcyBsaXF1aWRpdHkuAFRTdWJuZXRBbHBoYUluRW1pc3Npb24BAQQGoBggAAAAAAAAAAAEsQEgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBhbHBoYV9pbl9lbWlzc2lvbiB8IFJldHVybnMgdGhlIGFtb3VudCBvZiBhbHBoIGluICBlbWlzc2lvbiBpbnRvIHRoZSBwb29sIHBlciBibG9jay4AWFN1Ym5ldEFscGhhT3V0RW1pc3Npb24BAQQGoBggAAAAAAAAAAAExQEgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBhbHBoYV9vdXRfZW1pc3Npb24gfCBSZXR1cm5zIHRoZSBhbW91bnQgb2YgYWxwaGEgb3V0IGVtaXNzaW9uIGludG8gdGhlIG5ldHdvcmsgcGVyIGJsb2NrLgBMU3VibmV0VGFvSW5FbWlzc2lvbgEBBAagGCAAAAAAAAAAAAS9ASAtLS0gTUFQICggbmV0dWlkICkgLS0+IHRhb19pbl9lbWlzc2lvbiB8IFJldHVybnMgdGhlIGFtb3VudCBvZiB0YW8gZW1pdHRlZCBpbnRvIHRoaXMgc3ViZW50IG9uIHRoZSBsYXN0IGJsb2NrLgA0U3VibmV0QWxwaGFJbgEBBAagGCAAAAAAAAAAAARdASAtLS0gTUFQICggbmV0dWlkICkgLS0+IGFscGhhX3N1cHBseV9pbl9wb29sIHwgUmV0dXJucyB0aGUgYW1vdW50IG9mIGFscGhhIGluIHRoZSBwb29sLgBUU3VibmV0QWxwaGFJblByb3ZpZGVkAQEEBqAYIAAAAAAAAAAABO0BIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gYWxwaGFfc3VwcGx5X3VzZXJfaW5fcG9vbCB8IFJldHVybnMgdGhlIGFtb3VudCBvZiBhbHBoYSBpbiB0aGUgcG9vbCBwcm92aWRlZCBieSB1c2VycyBhcyBsaXF1aWRpdHkuADhTdWJuZXRBbHBoYU91dAEBBAagGCAAAAAAAAAAAARtASAtLS0gTUFQICggbmV0dWlkICkgLS0+IGFscGhhX3N1cHBseV9pbl9zdWJuZXQgfCBSZXR1cm5zIHRoZSBhbW91bnQgb2YgYWxwaGEgaW4gdGhlIHN1Ym5ldC4AOFN0YWtpbmdIb3RrZXlzAQEEAgBBAgQABCUBIC0tLSBNQVAgKCBjb2xkICkgLS0+IFZlYzxob3Q+IHwgTWFwcyBjb2xka2V5IHRvIGhvdGtleXMgdGhhdCBzdGFrZSB0byBpdAAwT3duZWRIb3RrZXlzAQEEAgBBAgQABGkBIC0tLSBNQVAgKCBjb2xkICkgLS0+IFZlYzxob3Q+IHwgUmV0dXJucyB0aGUgdmVjdG9yIG9mIGhvdGtleXMgY29udHJvbGxlZCBieSB0aGlzIGNvbGRrZXkuAFBBdXRvU3Rha2VEZXN0aW5hdGlvbgABCAIGqQYABAAEnQEgLS0tIERNQVAgKCBjb2xkLCBuZXR1aWQgKS0tPiBob3QgfCBSZXR1cm5zIHRoZSBob3RrZXkgYSBjb2xka2V5IHdpbGwgYXV0b3N0YWtlIHRvIHdpdGggbWluaW5nIHJld2FyZHMuAHBBdXRvU3Rha2VEZXN0aW5hdGlvbkNvbGRrZXlzAQEIAgapBkECBAAEkQEgLS0tIERNQVAgKCBob3QsIG5ldHVpZCApLS0+IFZlYzxjb2xkPiB8IFJldHVybnMgYSBsaXN0IG9mIGNvbGRrZXlzIHRoYXQgYXJlIGF1dG9zdGFraW5nIHRvIGEgaG90a2V5AHBDb2xka2V5U3dhcEFubm91bmNlbWVudERlbGF5AQAQEDIAAAAEIQEgVGhlIGRlbGF5IGFmdGVyIGFuIGFubm91bmNlbWVudCBiZWZvcmUgYSBjb2xka2V5IHN3YXAgY2FuIGJlIHBlcmZvcm1lZC4AeENvbGRrZXlTd2FwUmVhbm5vdW5jZW1lbnREZWxheQEAEBAKAAAABFEBIFRoZSBkZWxheSBhZnRlciB0aGUgaW5pdGlhbCBkZWxheSBoYXMgcGFzc2VkIGJlZm9yZSBhIG5ldyBhbm5vdW5jZW1lbnQgY2FuIGJlIG1hZGUuAGBDb2xka2V5U3dhcEFubm91bmNlbWVudHMAAQQFALUGBAAI3CBBIG1hcCBvZiB0aGUgY29sZGtleSBzd2FwIGFubm91bmNlbWVudHMgZnJvbSBhIGNvbGRrZXncIHRvIHRoZSBibG9jayBudW1iZXIgdGhlIGNvbGRrZXkgc3dhcCBjYW4gYmUgcGVyZm9ybWVkLgBMQ29sZGtleVN3YXBEaXNwdXRlcwABBAUAEAQACOQgQSBtYXAgb2YgdGhlIGNvbGRrZXkgc3dhcCBkaXNwdXRlcyBmcm9tIGEgY29sZGtleSB0byB0aGWwIGJsb2NrIG51bWJlciB0aGUgY29sZGtleSBzd2FwIHdhcyBkaXNwdXRlZC4AQFRvdGFsSG90a2V5QWxwaGEBAQgCBqkGGCAAAAAAAAAAAARZASAtLS0gRE1BUCAoIGhvdCwgbmV0dWlkICkgLS0+IGFscGhhIHwgUmV0dXJucyB0aGUgdG90YWwgYW1vdW50IG9mIGFscGhhIGEgaG90a2V5IG93bnMuAGRUb3RhbEhvdGtleUFscGhhTGFzdEVwb2NoAQEIAgapBhggAAAAAAAAAAAEpQEgLS0tIERNQVAgKCBob3QsIG5ldHVpZCApIC0tPiBhbHBoYSB8IFJldHVybnMgdGhlIHRvdGFsIGFtb3VudCBvZiBhbHBoYSBhIGhvdGtleSBvd25lZCBpbiB0aGUgbGFzdCBlcG9jaC4ARFRvdGFsSG90a2V5U2hhcmVzAQEIAgapBikFQAAAAAAAAAAAAAAAAAAAAAAErQEgRE1BUCAoIGhvdCwgbmV0dWlkICkgLS0+IHRvdGFsX2FscGhhX3NoYXJlcyB8IFJldHVybnMgdGhlIG51bWJlciBvZiBhbHBoYSBzaGFyZXMgZm9yIGEgaG90a2V5IG9uIGEgc3VibmV0LgAUQWxwaGEBAQwCAga5BikFQAAAAAAAAAAAAAAAAAAAAAAErQEgLS0tIE5NQVAgKCBob3QsIGNvbGQsIG5ldHVpZCApIC0tPiBhbHBoYSB8IFJldHVybnMgdGhlIGFscGhhIHNoYXJlcyBmb3IgYSBob3RrZXksIGNvbGRrZXksIG5ldHVpZCB0cmlwbGV0LgA8QWxwaGFNYXBMYXN0S2V5AQC9BgQABPQgQ29udGFpbnMgbGFzdCBBbHBoYSBzdG9yYWdlIG1hcCBrZXkgdG8gaXRlcmF0ZSAoY2hlY2sgZmlyc3QpACxUb2tlblN5bWJvbAEBBAagOBQQ8J2cjwQ1ASAtLS0gTUFQICggbmV0dWlkICkgLS0+IHRva2VuX3N5bWJvbCB8IFJldHVybnMgdGhlIHRva2VuIHN5bWJvbCBmb3IgYSBzdWJuZXQuADRTdWJuZXRUYW9GbG93AQEEBqCBASAAAAAAAAAAAARFASAtLS0gTUFQICggbmV0dWlkICkgLS0+IHN1Ym5ldF90YW9fZmxvdyB8IFJldHVybnMgdGhlIFRBTyBpbmZsb3ctb3V0ZmxvdyBiYWxhbmNlLgBAU3VibmV0RW1hVGFvRmxvdwABBAagwQYEAARxASAtLS0gTUFQICggbmV0dWlkICkgLS0+IHN1Ym5ldF9lbWFfdGFvX2Zsb3cgfCBSZXR1cm5zIHRoZSBFTUEgb2YgVEFPIGluZmxvdy1vdXRmbG93IGJhbGFuY2UuADRUYW9GbG93Q3V0b2ZmAQAhBUAAAAAAAAAAAAAAAAAAAAAABHQgLS0tIElURU0gLS0+IFRBTyBGbG93IEN1dG9mZgBARmxvd05vcm1FeHBvbmVudAEAKQVAAAAAAAAAAAABAAAAAAAAAAS0IC0tLSBJVEVNIC0tPiBGbG93IE5vcm1hbGl6YXRpb24gRXhwb25lbnQgKHApAFhGbG93RW1hU21vb3RoaW5nRmFjdG9yAQAYIJ3Vq0vrGgAABBEBIC0tLSBJVEVNIC0tPiBGbG93IEVNQSBzbW9vdGhpbmcgZmFjdG9yIChmbG93IGFscGhhKSwgdTY0IG5vcm1hbGl6ZWQAIFVzZWRXb3JrAQEEBjgYIAAAAAAAAAAAEHQgPT09PT09PT09PT09PT09PT09PT09PT09PT09PXQgPT09PSBHbG9iYWwgUGFyYW1ldGVycyA9PT09PXQgPT09PT09PT09PT09PT09PT09PT09PT09PT09PYggLS0tIFN0b3JhZ2VJdGVtIEdsb2JhbCBVc2VkIFdvcmsuAGBNYXhSZWdpc3RyYXRpb25zUGVyQmxvY2sBAQQGoKAIAQAEvCAtLS0gSVRFTSggZ2xvYmFsX21heF9yZWdpc3RyYXRpb25zX3Blcl9ibG9jayApADRUb3RhbE5ldHdvcmtzAQCgCAAABLggLS0tIElURU0oIHRvdGFsX251bWJlcl9vZl9leGlzdGluZ19uZXR3b3JrcyApAFROZXR3b3JrSW1tdW5pdHlQZXJpb2QBABgggMYTAAAAAAAEgCBJVEVNKCBuZXR3b3JrX2ltbXVuaXR5X3BlcmlvZCApADhTdGFydENhbGxEZWxheQEAGCAAAAAAAAAAAARkIElURU0oIHN0YXJ0X2NhbGxfZGVsYXkgKQBITmV0d29ya01pbkxvY2tDb3N0AQAYIAAQpdToAAAABHggSVRFTSggbWluX25ldHdvcmtfbG9ja19jb3N0ICkATE5ldHdvcmtMYXN0TG9ja0Nvc3QBABggABCl1OgAAAAEfCBJVEVNKCBsYXN0X25ldHdvcmtfbG9ja19jb3N0ICkAcE5ldHdvcmtMb2NrUmVkdWN0aW9uSW50ZXJ2YWwBABggwIkBAAAAAAAEoCBJVEVNKCBuZXR3b3JrX2xvY2tfcmVkdWN0aW9uX2ludGVydmFsICkAOFN1Ym5ldE93bmVyQ3V0AQCgCBQuBGQgSVRFTSggc3VibmV0X293bmVyX2N1dCApAEBOZXR3b3JrUmF0ZUxpbWl0AQAYIAAAAAAAAAAABGwgSVRFTSggbmV0d29ya19yYXRlX2xpbWl0ICkAZE5vbWluYXRvck1pblJlcXVpcmVkU3Rha2UBABggAAAAAAAAAAAEbQEgLS0tIElURU0oIG5vbWluYXRvcl9taW5fcmVxdWlyZWRfc3Rha2UgKSAtLS0gRmFjdG9yIG9mIERlZmF1bHRNaW5TdGFrZSBpbiBwZXItbWlsbCBmb3JtYXQuAGhXZWlnaHRzVmVyc2lvbktleVJhdGVMaW1pdAEAGCAFAAAAAAAAAAQFASBJVEVNKCB3ZWlnaHRzX3ZlcnNpb25fa2V5X3JhdGVfbGltaXQgKSAtLS0gUmF0ZSBsaW1pdCBpbiB0ZW1wb3MuAFBMYXN0UmF0ZUxpbWl0ZWRCbG9jawEBBAbFBhggAAAAAAAAAAAQdCA9PT09PT09PT09PT09PT09PT09PT09PT09PT09ZCA9PT09IFJhdGUgTGltaXRpbmcgPT09PT10ID09PT09PT09PT09PT09PT09PT09PT09PT09PT1tASAtLS0gTUFQICggUmF0ZUxpbWl0S2V5ICkgLS0+IEJsb2NrIG51bWJlciBpbiB3aGljaCB0aGUgbGFzdCByYXRlIGxpbWl0ZWQgb3BlcmF0aW9uIG9jY3VyZWQAOFRyYW5zZmVyVG9nZ2xlAQEEBqAkBAEQdCA9PT09PT09PT09PT09PT09PT09PT09PT09PT09YCA9PT09IFN1Ym5ldCBMb2NrcyA9PT09PXQgPT09PT09PT09PT09PT09PT09PT09PT09PT09PZwgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiB0cmFuc2Zlcl90b2dnbGUAMFN1Ym5ldExvY2tlZAEBBAagGCAAAAAAAAAAAASsIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gdG90YWxfc3VibmV0X2xvY2tlZAA0TGFyZ2VzdExvY2tlZAEBBAagGCAAAAAAAAAAAASYIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gbGFyZ2VzdF9sb2NrZWQAFFRlbXBvAQEEBqCgCAoAEEggPT09PT09PT09PT09PT09PT1IID09PT0gVGVtcG9zID09PT09SCA9PT09PT09PT09PT09PT09PXQgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiB0ZW1wbwBgRmlyc3RFbWlzc2lvbkJsb2NrTnVtYmVyAAEEBqAYBAAQdCA9PT09PT09PT09PT09PT09PT09PT09PT09PT09dCA9PT09IFN1Ym5ldCBQYXJhbWV0ZXJzID09PT09dCA9PT09PT09PT09PT09PT09PT09PT09PT09PT092CAtLS0gTUFQICggbmV0dWlkICkgLS0+IGJsb2NrIG51bWJlciBvZiBmaXJzdCBlbWlzc2lvbgA8U3VibmV0TWVjaGFuaXNtAQEEBqCgCAAABKAgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBzdWJuZXQgbWVjaGFuaXNtACxTdWJuZXR3b3JrTgEBBAagoAgAAAQVASAtLS0gTUFQICggbmV0dWlkICkgLS0+IHN1Ym5ldHdvcmtfbiAoTnVtYmVyIG9mIFVJRHMgaW4gdGhlIG5ldHdvcmspLgA0TmV0d29ya3NBZGRlZAEBBAagJAQABKAgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBuZXR3b3JrX2lzX2FkZGVkADxJc05ldHdvcmtNZW1iZXIBAQgCBqkGJAQABJQgLS0tIERNQVAgKCBob3RrZXksIG5ldHVpZCApIC0tPiBib29sAGhOZXR3b3JrUmVnaXN0cmF0aW9uQWxsb3dlZAEBBAagJAQBBNAgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBuZXR3b3JrX3JlZ2lzdHJhdGlvbl9hbGxvd2VkAHROZXR3b3JrUG93UmVnaXN0cmF0aW9uQWxsb3dlZAEBBAagJAQBBKwgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBuZXR3b3JrX3Bvd19hbGxvd2VkAExOZXR3b3JrUmVnaXN0ZXJlZEF0AQEEBqAYIAAAAAAAAAAABJQgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBibG9ja19jcmVhdGVkAFRQZW5kaW5nU2VydmVyRW1pc3Npb24BAQQGoBggAAAAAAAAAAAEvCAtLS0gTUFQICggbmV0dWlkICkgLS0+IHBlbmRpbmdfc2VydmVyX2VtaXNzaW9uAGBQZW5kaW5nVmFsaWRhdG9yRW1pc3Npb24BAQQGoBggAAAAAAAAAAAEyCAtLS0gTUFQICggbmV0dWlkICkgLS0+IHBlbmRpbmdfdmFsaWRhdG9yX2VtaXNzaW9uAFBQZW5kaW5nUm9vdEFscGhhRGl2cwEBBAagGCAAAAAAAAAAAATMIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gcGVuZGluZ19yb290X2FscGhhX2VtaXNzaW9uADxQZW5kaW5nT3duZXJDdXQBAQQGoBggAAAAAAAAAAAEpCAtLS0gTUFQICggbmV0dWlkICkgLS0+IHBlbmRpbmdfb3duZXJfY3V0AExCbG9ja3NTaW5jZUxhc3RTdGVwAQEEBqAYIAAAAAAAAAAABLggLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBibG9ja3Nfc2luY2VfbGFzdF9zdGVwAFhMYXN0TWVjaGFuc2ltU3RlcEJsb2NrAQEEBqAYIAAAAAAAAAAABMQgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBsYXN0X21lY2hhbmlzbV9zdGVwX2Jsb2NrACxTdWJuZXRPd25lcgEBBAagAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASQIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gc3VibmV0X293bmVyAERTdWJuZXRPd25lckhvdGtleQEBBAagAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASsIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gc3VibmV0X293bmVyX2hvdGtleQA0UmVjeWNsZU9yQnVybgEBBAag7QQEAAScIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gcmVjeWNsZV9vcl9idXJuAEBTZXJ2aW5nUmF0ZUxpbWl0AQEEBqAYIDIAAAAAAAAABKggLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBzZXJ2aW5nX3JhdGVfbGltaXQADFJobwEBBAagoAgKAARsIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gUmhvAFRBbHBoYVNpZ21vaWRTdGVlcG5lc3MBAQQGoKQI6AMEtCAtLS0gTUFQICggbmV0dWlkICkgLS0+IEFscGhhU2lnbW9pZFN0ZWVwbmVzcwAUS2FwcGEBAQQGoKAI/38EdCAtLS0gTUFQICggbmV0dWlkICkgLS0+IEthcHBhAGRSZWdpc3RyYXRpb25zVGhpc0ludGVydmFsAQEEBqCgCAAABMwgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiByZWdpc3RyYXRpb25zX3RoaXNfaW50ZXJ2YWwAcFBPV1JlZ2lzdHJhdGlvbnNUaGlzSW50ZXJ2YWwBAQQGoKAIAAAE3CAtLS0gTUFQICggbmV0dWlkICkgLS0+IHBvd19yZWdpc3RyYXRpb25zX3RoaXNfaW50ZXJ2YWwAdEJ1cm5SZWdpc3RyYXRpb25zVGhpc0ludGVydmFsAQEEBqCgCAAABOAgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBidXJuX3JlZ2lzdHJhdGlvbnNfdGhpc19pbnRlcnZhbAA4TWluQWxsb3dlZFVpZHMBAQQGoKAIQAAEoCAtLS0gTUFQICggbmV0dWlkICkgLS0+IG1pbl9hbGxvd2VkX3VpZHMAOE1heEFsbG93ZWRVaWRzAQEEBqCgCAABBKAgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBtYXhfYWxsb3dlZF91aWRzADhJbW11bml0eVBlcmlvZAEBBAagoAgAEAScIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gaW1tdW5pdHlfcGVyaW9kADhBY3Rpdml0eUN1dG9mZgEBBAagoAiIEwScIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gYWN0aXZpdHlfY3V0b2ZmADxNYXhXZWlnaHRzTGltaXQBAQQGoKAI//8EoCAtLS0gTUFQICggbmV0dWlkICkgLS0+IG1heF93ZWlnaHRfbGltaXQARFdlaWdodHNWZXJzaW9uS2V5AQEEBqAYIAAAAAAAAAAABKwgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiB3ZWlnaHRzX3ZlcnNpb25fa2V5AERNaW5BbGxvd2VkV2VpZ2h0cwEBBAagoAgABASsIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gbWluX2FsbG93ZWRfd2VpZ2h0cwBQTWF4QWxsb3dlZFZhbGlkYXRvcnMBAQQGoKAIgAAEuCAtLS0gTUFQICggbmV0dWlkICkgLS0+IG1heF9hbGxvd2VkX3ZhbGlkYXRvcnMASEFkanVzdG1lbnRJbnRlcnZhbAEBBAagoAhkAASsIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gYWRqdXN0bWVudF9pbnRlcnZhbABIQm9uZHNNb3ZpbmdBdmVyYWdlAQEEBqAYIKC7DQAAAAAABLAgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBib25kc19tb3ZpbmdfYXZlcmFnZQAwQm9uZHNQZW5hbHR5AQEEBqCgCP//BJQgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBib25kc19wZW5hbHR5ADBCb25kc1Jlc2V0T24BAQQGoCQEAASMIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gYm9uZHNfcmVzZXQATFdlaWdodHNTZXRSYXRlTGltaXQBAQQGoBggZAAAAAAAAAAEuCAtLS0gTUFQICggbmV0dWlkICkgLS0+IHdlaWdodHNfc2V0X3JhdGVfbGltaXQARFZhbGlkYXRvclBydW5lTGVuAQEEBqAYIAEAAAAAAAAABKwgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiB2YWxpZGF0b3JfcHJ1bmVfbGVuADxTY2FsaW5nTGF3UG93ZXIBAQQGoKAIMgAEpCAtLS0gTUFQICggbmV0dWlkICkgLS0+IHNjYWxpbmdfbGF3X3Bvd2VyAHhUYXJnZXRSZWdpc3RyYXRpb25zUGVySW50ZXJ2YWwBAQQGoKAIAgAE6CAtLS0gTUFQICggbmV0dWlkICkgLS0+IHRhcmdldF9yZWdpc3RyYXRpb25zX3RoaXNfaW50ZXJ2YWwAPEFkanVzdG1lbnRBbHBoYQEBBAagGCAAAAAAAAAAAASgIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gYWRqdXN0bWVudF9hbHBoYQBoQ29tbWl0UmV2ZWFsV2VpZ2h0c0VuYWJsZWQBAQQGoCQEAQTwIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gY29tbWl0IHJldmVhbCB2MiB3ZWlnaHRzIGFyZSBlbmFibGVkABBCdXJuAQEEBqAYIADh9QUAAAAABHAgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBCdXJuAChEaWZmaWN1bHR5AQEEBqAYIICWmAAAAAAABIggLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBEaWZmaWN1bHR5ABxNaW5CdXJuAQEEBqAYICChBwAAAAAABHwgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBNaW5CdXJuABxNYXhCdXJuAQEEBqAYIADodkgXAAAABHwgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBNYXhCdXJuADRNaW5EaWZmaWN1bHR5AQEEBqAYIICWmAAAAAAABJQgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBNaW5EaWZmaWN1bHR5ADRNYXhEaWZmaWN1bHR5AQEEBqAYIP////////8/BJQgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBNYXhEaWZmaWN1bHR5AExMYXN0QWRqdXN0bWVudEJsb2NrAQEEBqAYIAAAAAAAAAAABMggLS0tIE1BUCAoIG5ldHVpZCApIC0tPiAgQmxvY2sgYXQgbGFzdCBhZGp1c3RtZW50LgBYUmVnaXN0cmF0aW9uc1RoaXNCbG9jawEBBAagoAgAAATQIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gUmVnaXN0cmF0aW9ucyBvZiB0aGlzIEJsb2NrLgBURU1BUHJpY2VIYWx2aW5nQmxvY2tzAQEEBqAYIIATAwAAAAAABPQgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBIYWx2aW5nIHRpbWUgb2YgYXZlcmFnZSBtb3ZpbmcgcHJpY2UuAGhSQU9SZWN5Y2xlZEZvclJlZ2lzdHJhdGlvbgEBBAagGCAAAAAAAAAAAATwIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gZ2xvYmFsX1JBT19yZWN5Y2xlZF9mb3JfcmVnaXN0cmF0aW9uACxUeFJhdGVMaW1pdAEAGCDoAwAAAAAAAARsIC0tLSBJVEVNICggdHhfcmF0ZV9saW1pdCApAFxUeERlbGVnYXRlVGFrZVJhdGVMaW1pdAEAGCDASwMAAAAAAASkIC0tLSBJVEVNICggdHhfZGVsZWdhdGVfdGFrZV9yYXRlX2xpbWl0ICkAXFR4Q2hpbGRrZXlUYWtlUmF0ZUxpbWl0AQAYIAUAAAAAAAAABKQgLS0tIElURU0gKCB0eF9jaGlsZGtleV90YWtlX3JhdGVfbGltaXQgKQA0TGlxdWlkQWxwaGFPbgEBBAKgJAQABPggLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBXaGV0aGVyIG9yIG5vdCBMaXF1aWQgQWxwaGEgaXMgZW5hYmxlZAAcWXVtYTNPbgEBBAKgJAQABNwgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBXaGV0aGVyIG9yIG5vdCBZdW1hMyBpcyBlbmFibGVkACxBbHBoYVZhbHVlcwEBBAagzQYQM7Nm5gSwICBNQVAgKCBuZXR1aWQgKSAtLT4gKGFscGhhX2xvdywgYWxwaGFfaGlnaCkAPFN1YnRva2VuRW5hYmxlZAEBBAagJAQABMwgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBJZiBzdWJ0b2tlbiB0cmFkaW5nIGVuYWJsZWQALFZvdGluZ1Bvd2VyAQEIBgKlBhggAAAAAAAAAAAMHQEgLS0tIERNQVAgKCBuZXR1aWQsIGhvdGtleSApIC0tPiB2b3RpbmdfcG93ZXIgfCBFTUEgb2Ygc3Rha2UgZm9yIHZvdGluZ00BIFRoaXMgdHJhY2tzIHN0YWtlIEVNQSB1cGRhdGVkIGV2ZXJ5IGVwb2NoIHdoZW4gVm90aW5nUG93ZXJUcmFja2luZ0VuYWJsZWQgaXMgdHJ1ZS5NASBVc2VkIGJ5IHNtYXJ0IGNvbnRyYWN0cyB0byBkZXRlcm1pbmUgdmFsaWRhdG9yIHZvdGluZyBwb3dlciBmb3Igc3VibmV0IGdvdmVybmFuY2UuAGhWb3RpbmdQb3dlclRyYWNraW5nRW5hYmxlZAEBBAagJAQADGEBIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gYm9vbCB8IFdoZXRoZXIgdm90aW5nIHBvd2VyIHRyYWNraW5nIGlzIGVuYWJsZWQgZm9yIHRoaXMgc3VibmV0LiEBIFdoZW4gZW5hYmxlZCwgVm90aW5nUG93ZXIgRU1BIGlzIHVwZGF0ZWQgZXZlcnkgZXBvY2guIERlZmF1bHQgaXMgZmFsc2UuOQEgV2hlbiBkaXNhYmxlZCB3aXRoIGRpc2FibGVfYXRfYmxvY2sgc2V0LCB0cmFja2luZyBjb250aW51ZXMgdW50aWwgdGhhdCBibG9jay4AZFZvdGluZ1Bvd2VyRGlzYWJsZUF0QmxvY2sBAQQGoBggAAAAAAAAAAAMdQEgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBibG9ja19udW1iZXIgfCBCbG9jayBhdCB3aGljaCB2b3RpbmcgcG93ZXIgdHJhY2tpbmcgd2lsbCBiZSBkaXNhYmxlZC5ZASBXaGVuIHNldCAobm9uLXplcm8pLCB0cmFja2luZyBjb250aW51ZXMgdW50aWwgdGhpcyBibG9jaywgdGhlbiBhdXRvbWF0aWNhbGx5IGRpc2FibGVzPQEgYW5kIGNsZWFycyBWb3RpbmdQb3dlciBlbnRyaWVzIGZvciB0aGUgc3VibmV0LiBQcm92aWRlcyBhIDE0LWRheSBncmFjZSBwZXJpb2QuAExWb3RpbmdQb3dlckVtYUFscGhhAQEEBqAYIAAg2WXlrgwAEC0BIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gdTY0IHwgRU1BIGFscGhhIHZhbHVlIGZvciB2b3RpbmcgcG93ZXIgY2FsY3VsYXRpb24uxCBIaWdoZXIgYWxwaGEgPSBmYXN0ZXIgcmVzcG9uc2UgdG8gc3Rha2UgY2hhbmdlcy7cIFN0b3JlZCBhcyB1NjQgd2l0aCAxOCBkZWNpbWFsIHByZWNpc2lvbiAoMS4wID0gMTBeMTgpLnAgT25seSBzZXR0YWJsZSBieSBzdWRvL3Jvb3QuAFBJbW11bmVPd25lclVpZHNMaW1pdAEBBAagoAgBAASYIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gQnVybiBrZXkgbGltaXQALFN0YWtlV2VpZ2h0AQEEBqBNAgQAEKAgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09oCA9PT09IFN1Ym5ldHdvcmsgQ29uc2Vuc3VzIFN0b3JhZ2UgID09PT2gID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PREBIC0tLSBETUFQICggbmV0dWlkICkgLS0+IHN0YWtlX3dlaWdodCB8IHdlaWdodCBmb3Igc3Rha2UgdXNlZCBpbiBZQy4AEFVpZHMAAQgGAqUGoAQABJAgLS0tIERNQVAgKCBuZXR1aWQsIGhvdGtleSApIC0tPiB1aWQAEEtleXMBAQgGBtEGAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASQIC0tLSBETUFQICggbmV0dWlkLCB1aWQgKSAtLT4gaG90a2V5ADhMb2FkZWRFbWlzc2lvbgABBAag1QYEAASgIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gKGhvdGtleSwgc2UsIHZlKQAYQWN0aXZlAQEEBqDdBgQABHggLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBhY3RpdmUAEFJhbmsBAQQGoE0CBAAEcCAtLS0gTUFQICggbmV0dWlkICkgLS0+IHJhbmsAFFRydXN0AQEEBqBNAgQABHQgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiB0cnVzdAAkQ29uc2Vuc3VzAQEEBqBNAgQABIQgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBjb25zZW5zdXMAJEluY2VudGl2ZQEBBAagTQIEAASEIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gaW5jZW50aXZlACREaXZpZGVuZHMBAQQGoE0CBAAEhCAtLS0gTUFQICggbmV0dWlkICkgLS0+IGRpdmlkZW5kcwAgRW1pc3Npb24BAQQGoNAEAASAIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gZW1pc3Npb24AKExhc3RVcGRhdGUBAQQGoGkBBAAEjCAtLS0gTUFQICggbmV0dWlkICkgLS0+IGxhc3RfdXBkYXRlADhWYWxpZGF0b3JUcnVzdAEBBAagTQIEAAScIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gdmFsaWRhdG9yX3RydXN0ADRQcnVuaW5nU2NvcmVzAQEEBqBNAgQABJggLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBwcnVuaW5nX3Njb3JlcwA8VmFsaWRhdG9yUGVybWl0AQEEBqDdBgQABKAgLS0tIE1BUCAoIG5ldHVpZCApIC0tPiB2YWxpZGF0b3JfcGVybWl0ABxXZWlnaHRzAQEIBgbhBuUGBAAElCAtLS0gRE1BUCAoIG5ldHVpZCwgdWlkICkgLS0+IHdlaWdodHMAFEJvbmRzAQEIBgbhBuUGBAAEjCAtLS0gRE1BUCAoIG5ldHVpZCwgdWlkICkgLS0+IGJvbmRzAExCbG9ja0F0UmVnaXN0cmF0aW9uAQEIBgbRBhggAAAAAAAAAAAEzCAtLS0gRE1BUCAoIG5ldHVpZCwgdWlkICkgLS0+IGJsb2NrX2F0X3JlZ2lzdHJhdGlvbgAUQXhvbnMAAQgGAqUG6QYEAASkIC0tLSBNQVAgKCBuZXR1aWQsIGhvdGtleSApIC0tPiBheG9uX2luZm8ASE5ldXJvbkNlcnRpZmljYXRlcwABCAYCpQbtBgQABKwgLS0tIE1BUCAoIG5ldHVpZCwgaG90a2V5ICkgLS0+IGNlcnRpZmljYXRlAChQcm9tZXRoZXVzAAEIBgKlBvUGBAAEvCAtLS0gTUFQICggbmV0dWlkLCBob3RrZXkgKSAtLT4gcHJvbWV0aGV1c19pbmZvADBJZGVudGl0aWVzVjIAAQQCAPkGBAAEhCAtLS0gTUFQICggY29sZGtleSApIC0tPiBpZGVudGl0eQBIU3VibmV0SWRlbnRpdGllc1YzAAEEAqB1AgQABKggLS0tIE1BUCAoIG5ldHVpZCApIC0tPiBTdWJuZXRJZGVudGl0eU9mVjMAXFRyYW5zYWN0aW9uS2V5TGFzdEJsb2NrAQEMAgYG/QYYIAAAAAAAAAAAEIggPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09iCA9PT09IEF4b24gLyBQcm9tbyBFbmRwb2ludHMgPT09PT2IID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Pe0BIC0tLSBOTUFQICggaG90LCBuZXR1aWQsIG5hbWUgKSAtLT4gbGFzdF9ibG9jayB8IFJldHVybnMgdGhlIGxhc3QgYmxvY2sgb2YgYSB0cmFuc2FjdGlvbiBmb3IgYSBnaXZlbiBrZXksIG5ldHVpZCwgYW5kIG5hbWUuACxMYXN0VHhCbG9jawEBBAYAGCAAAAAAAAAAAAR8IC0tLSBNQVAgKCBrZXkgKSAtLT4gbGFzdF9ibG9jawFcTGFzdFR4QmxvY2tDaGlsZEtleVRha2UBAQQGABggAAAAAAAAAAAEwCAtLS0gTUFQICgga2V5ICkgLS0+IGxhc3RfdHhfYmxvY2tfY2hpbGRrZXlfdGFrZQFcTGFzdFR4QmxvY2tEZWxlZ2F0ZVRha2UBAQQGABggAAAAAAAAAAAEwCAtLS0gTUFQICgga2V5ICkgLS0+IGxhc3RfdHhfYmxvY2tfZGVsZWdhdGVfdGFrZQE4U3Rha2VUaHJlc2hvbGQBABggAAAAAAAAAAAEaCBJVEVNKCB3ZWlnaHRzX21pbl9zdGFrZSApADRXZWlnaHRDb21taXRzAAEIBQUBBwUHBAAEeQIgLS0tIE1BUCAobmV0dWlkLCB3aG8pIC0tPiBWZWNEZXF1ZTwoaGFzaCwgY29tbWl0X2Jsb2NrLCBmaXJzdF9yZXZlYWxfYmxvY2ssIGxhc3RfcmV2ZWFsX2Jsb2NrKT4gfCBTdG9yZXMgYSBxdWV1ZSBvZiBjb21taXRzIGZvciBhbiBhY2NvdW50IG9uIGEgZ2l2ZW4gbmV0dWlkLgBcVGltZWxvY2tlZFdlaWdodENvbW1pdHMBAQgFBQ0HEQcEAAhBASBNQVAgKG5ldHVpZCwgZXBvY2gpIOKGkiBWZWNEZXF1ZTwod2hvLCBjb21taXRfYmxvY2ssIGNpcGhlcnRleHQsIHJldmVhbF9yb3VuZCk+DQEgU3RvcmVzIGEgcXVldWUgb2Ygd2VpZ2h0IGNvbW1pdHMgZm9yIGFuIGFjY291bnQgb24gYSBnaXZlbiBzdWJuZXQuAERDUlYzV2VpZ2h0Q29tbWl0cwEBCAUFDQcZBwQACAkBIE1BUCAobmV0dWlkLCBlcG9jaCkg4oaSIFZlY0RlcXVlPCh3aG8sIGNpcGhlcnRleHQsIHJldmVhbF9yb3VuZCk+jCBERVBSRUNBVEVEIGZvciBDUlYzV2VpZ2h0Q29tbWl0c1YyAExDUlYzV2VpZ2h0Q29tbWl0c1YyAQEIBQUNBxEHBAAIQQEgTUFQIChuZXR1aWQsIGVwb2NoKSDihpIgVmVjRGVxdWU8KHdobywgY29tbWl0X2Jsb2NrLCBjaXBoZXJ0ZXh0LCByZXZlYWxfcm91bmQpPpwgREVQUkVDQVRFRCBmb3IgVGltZWxvY2tlZFdlaWdodENvbW1pdHMASFJldmVhbFBlcmlvZEVwb2NocwEBBAWgGCABAAAAAAAAAAQhASAtLS0gTWFwIChuZXR1aWQpIC0tPiBOdW1iZXIgb2YgZXBvY2hzIGFsbG93ZWQgZm9yIGNvbW1pdCByZXZlYWwgcGVyaW9kcwBsTGFzdENvbGRrZXlIb3RrZXlTdGFrZUJsb2NrAAEIBQUhBxgEAARNASAtLS0gTWFwIChjb2xka2V5LCBob3RrZXkpIC0tPiB1NjQgdGhlIGxhc3QgYmxvY2sgYXQgd2hpY2ggc3Rha2Ugd2FzIGFkZGVkL3JlbW92ZWQuAGxTdGFraW5nT3BlcmF0aW9uUmF0ZUxpbWl0ZXIBAQwCAga5BiQEAAgJASBETUFQICggaG90LCBjb2xkLCBuZXR1aWQgKSAtLT4gcmF0ZSBsaW1pdHMgZm9yIHN0YWtpbmcgb3BlcmF0aW9uc+AgVmFsdWUgY29udGFpbnMganVzdCBhIG1hcmtlcjogd2UgdXNlIHRoaXMgbWFwIGFzIGEgc2V0LgBYUm9vdENsYWltYWJsZVRocmVzaG9sZAEBBAKg8QRAAAAAACChBwAAAAAAAAAAAAAANFJvb3RDbGFpbWFibGUBAQQCACUHBAAAACxSb290Q2xhaW1lZAEBDAYCAjEHIEAAAAAAAAAAAAAAAAAAAAAAAAA0Um9vdENsYWltVHlwZQEBBAIA1AQAAABYU3Rha2luZ0NvbGRrZXlzQnlJbmRleAABBAYYAAQAAAA8U3Rha2luZ0NvbGRrZXlzAAEEBgAYBAAAAEhOdW1TdGFraW5nQ29sZGtleXMBABggAAAAAAAAAAAAADBOdW1Sb290Q2xhaW0BABggBQAAAAAAAAAAAFBBc3NvY2lhdGVkRXZtQWRkcmVzcwABCAUF0QY1BwQAEHggPT09PT09PT09PT09PT09PT09PT09PT09PT09PT14ID09PT0gRVZNIHJlbGF0ZWQgc3RvcmFnZSA9PT09eCA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PSUBIC0tLSBETUFQIChuZXR1aWQsIHVpZCkgLS0+IChIMTYwLCBsYXN0X2Jsb2NrX3doZXJlX293bmVyc2hpcF93YXNfcHJvdmVuKQAwU3VibmV0TGVhc2VzAAEEBRA5BwQAEGQgPT09PT09PT09PT09PT09PT09PT09PT09ZCA9PT09IFN1Ym5ldCBMZWFzaW5nID09PT1kID09PT09PT09PT09PT09PT09PT09PT09PT0BIC0tLSBNQVAgKCBsZWFzZV9pZCApIC0tPiBzdWJuZXQgbGVhc2UgfCBUaGUgc3VibmV0IGxlYXNlIGZvciBhIGdpdmVuIGxlYXNlIGlkLgBEU3VibmV0TGVhc2VTaGFyZXMBAQgFBj0HKQVAAAAAAAAAAAAAAAAAAAAAAAR9ASAtLS0gRE1BUCAoIGxlYXNlX2lkLCBjb250cmlidXRvciApIC0tPiBzaGFyZXMgfCBUaGUgc2hhcmVzIG9mIGEgY29udHJpYnV0b3IgZm9yIGEgZ2l2ZW4gbGVhc2UuAEhTdWJuZXRVaWRUb0xlYXNlSWQAAQQFoBAEAAQNASAtLS0gTUFQICggbmV0dWlkICkgLS0+IGxlYXNlX2lkIHwgVGhlIGxlYXNlIGlkIGZvciBhIGdpdmVuIG5ldHVpZC4ARE5leHRTdWJuZXRMZWFzZUlkAQAQEAAAAAAEwCAtLS0gSVRFTSAoIG5leHRfbGVhc2VfaWQgKSB8IFRoZSBuZXh0IGxlYXNlIGlkLgBkQWNjdW11bGF0ZWRMZWFzZURpdmlkZW5kcwEBBAUQGCAAAAAAAAAAAATtASAtLS0gTUFQICggbGVhc2VfaWQgKSAtLT4gYWNjdW11bGF0ZWRfZGl2aWRlbmRzIHwgVGhlIGFjY3VtdWxhdGVkIGRpdmlkZW5kcyBmb3IgYSBnaXZlbiBsZWFzZSB0aGF0IG5lZWRzIHRvIGJlIGRpc3RyaWJ1dGVkLgBoQ29tbWl0UmV2ZWFsV2VpZ2h0c1ZlcnNpb24BAKAIBAAEoCAtLS0gSVRFTSAoIENvbW1pdFJldmVhbFdlaWdodHNWZXJzaW9uICkAdE5ldHdvcmtSZWdpc3RyYXRpb25TdGFydEJsb2NrAQAYIAAAAAAAAAAABJggSVRFTSggTmV0d29ya1JlZ2lzdHJhdGlvblN0YXJ0QmxvY2sgKQBATWluTm9uSW1tdW5lVWlkcwEBBAagoAgKAARFASAtLS0gTUFQICggbmV0dWlkICkgLS0+IG1pbmltdW0gcmVxdWlyZWQgbnVtYmVyIG9mIG5vbi1pbW1vcnRhbCAmIG5vbi1pbW11bmUgVUlEcwBETWF4TWVjaGFuaXNtQ291bnQBAAgEAgRwIElURU0oIG1heF9tZWNoYW5pc21fY291bnQgKQBUTWVjaGFuaXNtQ291bnRDdXJyZW50AQEEBaAIBAEE7CAtLS0gTUFQICggbmV0dWlkICkgLS0+IEN1cnJlbnQgbnVtYmVyIG9mIHN1Ym5ldCBtZWNoYW5pc21zAFhNZWNoYW5pc21FbWlzc2lvblNwbGl0AAEEBaBNAgQABIEBIC0tLSBNQVAgKCBuZXR1aWQgKSAtLT4gTm9ybWFsaXplZCB2ZWN0b3Igb2YgZW1pc3Npb24gc3BsaXQgcHJvcG9ydGlvbiBiZXR3ZWVuIHN1Ym5ldCBtZWNoYW5pc21zADxIYXNNaWdyYXRpb25SdW4BAQQGOCQEABBMID09PT09PT09PT09PT09PT09PUwgPT09PSBHZW5lc2lzID09PT09TCA9PT09PT09PT09PT09PT09PT2UIC0tLSBTdG9yYWdlIGZvciBtaWdyYXRpb24gcnVuIHN0YXR1cwBcUGVuZGluZ0NoaWxkS2V5Q29vbGRvd24BABggDwAAAAAAAAAE/CBTdG9yYWdlIHZhbHVlIGZvciBwZW5kaW5nIGNoaWxka2V5IGNvb2xkb3duLCBzZXR0YWJsZSBieSByb290LgABSQIESQIRAURlcHJlY2F0ZWQsIHBsZWFzZSBtaWdyYXRlIHRvIGBhbm5vdW5jZV9jb2xka2V5X3N3YXBgL2Bjb2xka2V5X3N3YXBgAAGcBAoC7E1heCB3ZWlnaHQgbGltaXQgaXMgbm93IGEgY29uc3RhbnQgYW5kIHRoaXMgZXZlbnQgaXMgdW51c2VkAPQ8SW5pdGlhbElzc3VhbmNlGCAAAAAAAAAAABCIID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PYggPT09PSBJbml0aWFsIFZhbHVlIENvbnN0YW50cyA9PT09iCA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT1sIEluaXRpYWwgY3VycmVuY3kgaXNzdWFuY2UuAGBJbml0aWFsTWluQWxsb3dlZFdlaWdodHOgCAAEBJQgSW5pdGlhbCBtaW4gYWxsb3dlZCB3ZWlnaHRzIHNldHRpbmcuAFBJbml0aWFsRW1pc3Npb25WYWx1ZaAIAAAEYCBJbml0aWFsIEVtaXNzaW9uIFJhdGlvLgAwSW5pdGlhbFRlbXBvoAgKAARgIFRlbXBvIGZvciBlYWNoIG5ldHdvcmsuAERJbml0aWFsRGlmZmljdWx0eRgggJaYAAAAAAAEUCBJbml0aWFsIERpZmZpY3VsdHkuAFBJbml0aWFsTWF4RGlmZmljdWx0eRgg/////////z8EYCBJbml0aWFsIE1heCBEaWZmaWN1bHR5LgBQSW5pdGlhbE1pbkRpZmZpY3VsdHkYIICWmAAAAAAABGAgSW5pdGlhbCBNaW4gRGlmZmljdWx0eS4AhEluaXRpYWxSQU9SZWN5Y2xlZEZvclJlZ2lzdHJhdGlvbhggAAAAAAAAAAAEWCBJbml0aWFsIFJBTyBSZWN5Y2xlZC4ALEluaXRpYWxCdXJuGCAA4fUFAAAAAAQ4IEluaXRpYWwgQnVybi4AOEluaXRpYWxNYXhCdXJuGCAA6HZIFwAAAARIIEluaXRpYWwgTWF4IEJ1cm4uADhJbml0aWFsTWluQnVybhggIKEHAAAAAAAESCBJbml0aWFsIE1pbiBCdXJuLgBETWluQnVyblVwcGVyQm91bmQYIADKmjsAAAAABFwgTWluICBidXJuIHVwcGVyIGJvdW5kLgBETWF4QnVybkxvd2VyQm91bmQYIADh9QUAAAAABFggTWF4IGJ1cm4gbG93ZXIgYm91bmQuAGRJbml0aWFsQWRqdXN0bWVudEludGVydmFsoAhkAAR0IEluaXRpYWwgYWRqdXN0bWVudCBpbnRlcnZhbC4AZEluaXRpYWxCb25kc01vdmluZ0F2ZXJhZ2UYIKC7DQAAAAAABHggSW5pdGlhbCBib25kcyBtb3ZpbmcgYXZlcmFnZS4ATEluaXRpYWxCb25kc1BlbmFsdHmgCP//BFwgSW5pdGlhbCBib25kcyBwZW5hbHR5LgBMSW5pdGlhbEJvbmRzUmVzZXRPbiQEAARUIEluaXRpYWwgYm9uZHMgcmVzZXQuAJRJbml0aWFsVGFyZ2V0UmVnaXN0cmF0aW9uc1BlckludGVydmFsoAgCAASsIEluaXRpYWwgdGFyZ2V0IHJlZ2lzdHJhdGlvbnMgcGVyIGludGVydmFsLgAoSW5pdGlhbFJob6AICgAEOCBSaG8gY29uc3RhbnQuAHBJbml0aWFsQWxwaGFTaWdtb2lkU3RlZXBuZXNzpAjoAwSAIEFscGhhU2lnbW9pZFN0ZWVwbmVzcyBjb25zdGFudC4AMEluaXRpYWxLYXBwYaAI/38EQCBLYXBwYSBjb25zdGFudC4AVEluaXRpYWxNaW5BbGxvd2VkVWlkc6AIQAAElCBJbml0aWFsIG1pbmltdW0gYWxsb3dlZCBuZXR3b3JrIFVJRHMAVEluaXRpYWxNYXhBbGxvd2VkVWlkc6AIAAEElCBJbml0aWFsIG1heGltdW0gYWxsb3dlZCBuZXR3b3JrIFVJRHMAYEluaXRpYWxWYWxpZGF0b3JQcnVuZUxlbhggAQAAAAAAAAAEqCBJbml0aWFsIHZhbGlkYXRvciBjb250ZXh0IHBydW5pbmcgbGVuZ3RoLgBYSW5pdGlhbFNjYWxpbmdMYXdQb3dlcqAIMgAEbCBJbml0aWFsIHNjYWxpbmcgbGF3IHBvd2VyLgBUSW5pdGlhbEltbXVuaXR5UGVyaW9koAgAEARoIEltbXVuaXR5IFBlcmlvZCBDb25zdGFudC4AVEluaXRpYWxBY3Rpdml0eUN1dG9mZqAIiBMETCBBY3Rpdml0eSBjb25zdGFudC4AfEluaXRpYWxNYXhSZWdpc3RyYXRpb25zUGVyQmxvY2ugCAEABJQgSW5pdGlhbCBtYXggcmVnaXN0cmF0aW9ucyBwZXIgYmxvY2suAExJbml0aWFsUHJ1bmluZ1Njb3JloAj//wScIEluaXRpYWwgcHJ1bmluZyBzY29yZSBmb3IgZWFjaCBuZXVyb24uAGxJbml0aWFsTWF4QWxsb3dlZFZhbGlkYXRvcnOgCIAABMAgSW5pdGlhbCBtYXhpbXVtIGFsbG93ZWQgdmFsaWRhdG9ycyBwZXIgbmV0d29yay4AaEluaXRpYWxEZWZhdWx0RGVsZWdhdGVUYWtloAgULgSEIEluaXRpYWwgZGVmYXVsdCBkZWxlZ2F0aW9uIHRha2UuAFhJbml0aWFsTWluRGVsZWdhdGVUYWtloAgAAASEIEluaXRpYWwgbWluaW11bSBkZWxlZ2F0aW9uIHRha2UuAGhJbml0aWFsRGVmYXVsdENoaWxkS2V5VGFrZaAIAAAEfCBJbml0aWFsIGRlZmF1bHQgY2hpbGRrZXkgdGFrZS4AWEluaXRpYWxNaW5DaGlsZEtleVRha2WgCAAABHwgSW5pdGlhbCBtaW5pbXVtIGNoaWxka2V5IHRha2UuAFhJbml0aWFsTWF4Q2hpbGRLZXlUYWtloAgULgR8IEluaXRpYWwgbWF4aW11bSBjaGlsZGtleSB0YWtlLgBgSW5pdGlhbFdlaWdodHNWZXJzaW9uS2V5GCAAAAAAAAAAAAR0IEluaXRpYWwgd2VpZ2h0cyB2ZXJzaW9uIGtleS4AXEluaXRpYWxTZXJ2aW5nUmF0ZUxpbWl0GCAyAAAAAAAAAARwIEluaXRpYWwgc2VydmluZyByYXRlIGxpbWl0LgBISW5pdGlhbFR4UmF0ZUxpbWl0GCDoAwAAAAAAAASAIEluaXRpYWwgdHJhbnNhY3Rpb24gcmF0ZSBsaW1pdC4AeEluaXRpYWxUeERlbGVnYXRlVGFrZVJhdGVMaW1pdBggwEsDAAAAAAAEuCBJbml0aWFsIGRlbGVnYXRlIHRha2UgdHJhbnNhY3Rpb24gcmF0ZSBsaW1pdC4AeEluaXRpYWxUeENoaWxkS2V5VGFrZVJhdGVMaW1pdBggBQAAAAAAAAAEuCBJbml0aWFsIGNoaWxka2V5IHRha2UgdHJhbnNhY3Rpb24gcmF0ZSBsaW1pdC4AWEluaXRpYWxBZGp1c3RtZW50QWxwaGEYIAAAAAAAAAAABKggSW5pdGlhbCBhZGp1c3RtZW50IGFscGhhIG9uIGJ1cm4gYW5kIHBvdy4AcEluaXRpYWxOZXR3b3JrSW1tdW5pdHlQZXJpb2QYIIDGEwAAAAAABIAgSW5pdGlhbCBuZXR3b3JrIGltbXVuaXR5IHBlcmlvZABkSW5pdGlhbE5ldHdvcmtNaW5Mb2NrQ29zdBggABCl1OgAAAAEiCBJbml0aWFsIG5ldHdvcmsgbWluaW11bSBidXJuIGNvc3QAVEluaXRpYWxTdWJuZXRPd25lckN1dKAIFC4EcCBJbml0aWFsIG5ldHdvcmsgc3VibmV0IGN1dC4AjEluaXRpYWxOZXR3b3JrTG9ja1JlZHVjdGlvbkludGVydmFsGCDAiQEAAAAAAASEIEluaXRpYWwgbG9jayByZWR1Y3Rpb24gaW50ZXJ2YWwuAFxJbml0aWFsTmV0d29ya1JhdGVMaW1pdBggIBwAAAAAAAAEkCBJbml0aWFsIG5ldHdvcmsgY3JlYXRpb24gcmF0ZSBsaW1pdAAsS2V5U3dhcENvc3QYIADh9QUAAAAABGwgQ29zdCBvZiBzd2FwcGluZyBhIGhvdGtleS4AJEFscGhhSGlnaKAIZuYEAQEgVGhlIHVwcGVyIGJvdW5kIGZvciB0aGUgYWxwaGEgcGFyYW1ldGVyLiBVc2VkIGZvciBMaXF1aWQgQWxwaGEuACBBbHBoYUxvd6AIM7MEAQEgVGhlIGxvd2VyIGJvdW5kIGZvciB0aGUgYWxwaGEgcGFyYW1ldGVyLiBVc2VkIGZvciBMaXF1aWQgQWxwaGEuADRMaXF1aWRBbHBoYU9uJAQABLwgQSBmbGFnIHRvIGluZGljYXRlIGlmIExpcXVpZCBBbHBoYSBpcyBlbmFibGVkLgAcWXVtYTNPbiQEAASgIEEgZmxhZyB0byBpbmRpY2F0ZSBpZiBZdW1hMyBpcyBlbmFibGVkLgCMSW5pdGlhbENvbGRrZXlTd2FwQW5ub3VuY2VtZW50RGVsYXkQEDIAAAAEhCBDb2xka2V5IHN3YXAgYW5ub3VuY2VtZW50IGRlbGF5LgCUSW5pdGlhbENvbGRrZXlTd2FwUmVhbm5vdW5jZW1lbnREZWxheRAQCgAAAASMIENvbGRrZXkgc3dhcCByZWFubm91bmNlbWVudCBkZWxheS4AmEluaXRpYWxEaXNzb2x2ZU5ldHdvcmtTY2hlZHVsZUR1cmF0aW9uEBCgjAAABIwgRGlzc29sdmUgbmV0d29yayBzY2hlZHVsZSBkdXJhdGlvbgBASW5pdGlhbFRhb1dlaWdodBgg/GLgPvo8fA0EUCBJbml0aWFsIFRBTyB3ZWlnaHQuAHBJbml0aWFsRW1hUHJpY2VIYWx2aW5nUGVyaW9kGCCAEwMAAAAAAASEIEluaXRpYWwgRU1BIHByaWNlIGhhbHZpbmcgcGVyaW9kAFRJbml0aWFsU3RhcnRDYWxsRGVsYXkYIAAAAAAAAAAABAkBIERlbGF5IGFmdGVyIHdoaWNoIGEgbmV3IHN1Ym5ldCBjYW4gZGlzcGF0Y2ggc3RhcnQgY2FsbCBleHRyaW5zaWMuAExLZXlTd2FwT25TdWJuZXRDb3N0GCBAQg8AAAAAAAScIENvc3Qgb2Ygc3dhcHBpbmcgYSBob3RrZXkgaW4gYSBzdWJuZXQuAGhIb3RrZXlTd2FwT25TdWJuZXRJbnRlcnZhbBggoIwAAAAAAAAE/CBCbG9jayBudW1iZXIgZm9yIGEgY29sZGtleSBzd2FwIHRoZSBob3RrZXkgaW4gc3BlY2lmaWMgc3VibmV0LgCITGVhc2VEaXZpZGVuZHNEaXN0cmlidXRpb25JbnRlcnZhbBAQZAAAAATEIE51bWJlciBvZiBibG9ja3MgYmV0d2VlbiBkaXZpZGVuZHMgZGlzdHJpYnV0aW9uLgBcTWF4SW1tdW5lVWlkc1BlcmNlbnRhZ2WBAgRQBIwgTWF4aW11bSBwZXJjZW50YWdlIG9mIGltbXVuZSBVSURzLgABQQcACCxSdW50aW1lQ2FsbPkBBCggY2FsbCB0eXBlPFN1ZG9SdW50aW1lQ2FsbPkBBEggQSBzdWRvLWFibGUgY2FsbC4ABwAAHFV0aWxpdHkAAYUCAAHgAARMYmF0Y2hlZF9jYWxsc19saW1pdBAQqioAAASoIFRoZSBsaW1pdCBvbiB0aGUgbnVtYmVyIG9mIGJhdGNoZWQgY2FsbHMuAAFFBwAILFJ1bnRpbWVDYWxs+QEEbCBUaGUgb3ZlcmFyY2hpbmcgY2FsbCB0eXBlLjRQYWxsZXRzT3JpZ2lujQIE8CBUaGUgY2FsbGVyIG9yaWdpbiwgb3ZlcmFyY2hpbmcgdHlwZSBvZiBhbGwgcGFsbGV0cyBvcmlnaW5zLgALAAAQU3VkbwEQU3VkbwQMS2V5AAAABAAEhCBUaGUgYEFjY291bnRJZGAgb2YgdGhlIHN1ZG8ga2V5LgABmQIAAeQAAAFJBwAELFJ1bnRpbWVDYWxs+QEESCBBIHN1ZG8tYWJsZSBjYWxsLgAMAAAgTXVsdGlzaWcBIE11bHRpc2lnBCRNdWx0aXNpZ3MAAQgFAk0HUQcEAASUIFRoZSBzZXQgb2Ygb3BlbiBtdWx0aXNpZyBvcGVyYXRpb25zLgABnQIAAewADCxEZXBvc2l0QmFzZRggACneBwAAAAAYWQEgVGhlIGJhc2UgYW1vdW50IG9mIGN1cnJlbmN5IG5lZWRlZCB0byByZXNlcnZlIGZvciBjcmVhdGluZyBhIG11bHRpc2lnIGV4ZWN1dGlvbiBvciB0b4Qgc3RvcmUgYSBkaXNwYXRjaCBjYWxsIGZvciBsYXRlci4AAQEgVGhpcyBpcyBoZWxkIGZvciBhbiBhZGRpdGlvbmFsIHN0b3JhZ2UgaXRlbSB3aG9zZSB2YWx1ZSBzaXplIGlzMQEgYDQgKyBzaXplb2YoKEJsb2NrTnVtYmVyLCBCYWxhbmNlLCBBY2NvdW50SWQpKWAgYnl0ZXMgYW5kIHdob3NlIGtleSBzaXplIGlzgCBgMzIgKyBzaXplb2YoQWNjb3VudElkKWAgYnl0ZXMuADREZXBvc2l0RmFjdG9yGCAASOgBAAAAAAxVASBUaGUgYW1vdW50IG9mIGN1cnJlbmN5IG5lZWRlZCBwZXIgdW5pdCB0aHJlc2hvbGQgd2hlbiBjcmVhdGluZyBhIG11bHRpc2lnIGV4ZWN1dGlvbi4AJQEgVGhpcyBpcyBoZWxkIGZvciBhZGRpbmcgMzIgYnl0ZXMgbW9yZSBpbnRvIGEgcHJlLWV4aXN0aW5nIHN0b3JhZ2UgdmFsdWUuADhNYXhTaWduYXRvcmllcxAQZAAAAATsIFRoZSBtYXhpbXVtIGFtb3VudCBvZiBzaWduYXRvcmllcyBhbGxvd2VkIGluIHRoZSBtdWx0aXNpZy4AAVkHAAQsUnVudGltZUNhbGz5AQRsIFRoZSBvdmVyYXJjaGluZyBjYWxsIHR5cGUuAA0AACBQcmVpbWFnZQEgUHJlaW1hZ2UMJFN0YXR1c0ZvcgABBAY0XQcEAASQIFRoZSByZXF1ZXN0IHN0YXR1cyBvZiBhIGdpdmVuIGhhc2guAkBSZXF1ZXN0U3RhdHVzRm9yAEBSZXF1ZXN0U3RhdHVzRm9yAAEEBjRpBwQABJAgVGhlIHJlcXVlc3Qgc3RhdHVzIG9mIGEgZ2l2ZW4gaGFzaC4ALFByZWltYWdlRm9yAAEEBnkHfQcEAAAAAaUCAAH0AAABgQcAAAAOAAAkU2NoZWR1bGVyASRTY2hlZHVsZXIQPEluY29tcGxldGVTaW5jZQAAEAQABPQgQmxvY2sgbnVtYmVyIGF0IHdoaWNoIHRoZSBhZ2VuZGEgYmVnYW4gaW5jb21wbGV0ZSBleGVjdXRpb24uABhBZ2VuZGEBAQQFEIUHBAAETQEgSXRlbXMgdG8gYmUgZXhlY3V0ZWQsIGluZGV4ZWQgYnkgdGhlIGJsb2NrIG51bWJlciB0aGF0IHRoZXkgc2hvdWxkIGJlIGV4ZWN1dGVkIG9uLgAcUmV0cmllcwABBAL8nQcEAAQhASBSZXRyeSBjb25maWd1cmF0aW9ucyBmb3IgaXRlbXMgdG8gYmUgZXhlY3V0ZWQsIGluZGV4ZWQgYnkgdGFzayBhZGRyZXNzLgAYTG9va3VwAAEEBQT8BAAQ+CBMb29rdXAgZnJvbSBhIG5hbWUgdG8gdGhlIGJsb2NrIG51bWJlciBhbmQgaW5kZXggb2YgdGhlIHRhc2suAFkBIEZvciB2MyAtPiB2NCB0aGUgcHJldmlvdXNseSB1bmJvdW5kZWQgaWRlbnRpdGllcyBhcmUgQmxha2UyLTI1NiBoYXNoZWQgdG8gZm9ybSB0aGUgdjQwIGlkZW50aXRpZXMuAAGpAgAB+AAINE1heGltdW1XZWlnaHQsQAsAAN0O6QITzMzMzMzMzMwEKQEgVGhlIG1heGltdW0gd2VpZ2h0IHRoYXQgbWF5IGJlIHNjaGVkdWxlZCBwZXIgYmxvY2sgZm9yIGFueSBkaXNwYXRjaGFibGVzLgBQTWF4U2NoZWR1bGVkUGVyQmxvY2sQEDIAAAAUHQEgVGhlIG1heGltdW0gbnVtYmVyIG9mIHNjaGVkdWxlZCBjYWxscyBpbiB0aGUgcXVldWUgZm9yIGEgc2luZ2xlIGJsb2NrLgAYIE5PVEU6UQEgKyBEZXBlbmRlbnQgcGFsbGV0cycgYmVuY2htYXJrcyBtaWdodCByZXF1aXJlIGEgaGlnaGVyIGxpbWl0IGZvciB0aGUgc2V0dGluZy4gU2V0IGHEIGhpZ2hlciBsaW1pdCB1bmRlciBgcnVudGltZS1iZW5jaG1hcmtzYCBmZWF0dXJlLgABoQcABCxSdW50aW1lQ2FsbPkBBGggVGhlIGFnZ3JlZ2F0ZWQgY2FsbCB0eXBlLgAPAAAUUHJveHkBFFByb3h5DBxQcm94aWVzAQEEBQClByQAAAAAAAAAAAAIRQEgVGhlIHNldCBvZiBhY2NvdW50IHByb3hpZXMuIE1hcHMgdGhlIGFjY291bnQgd2hpY2ggaGFzIGRlbGVnYXRlZCB0byB0aGUgYWNjb3VudHMhASB3aGljaCBhcmUgYmVpbmcgZGVsZWdhdGVkIHRvLCB0b2dldGhlciB3aXRoIHRoZSBhbW91bnQgaGVsZCBvbiBkZXBvc2l0LgA0QW5ub3VuY2VtZW50cwEBBAUAtQckAAAAAAAAAAAABKwgVGhlIGFubm91bmNlbWVudHMgbWFkZSBieSB0aGUgcHJveHkgKGtleSkuADhMYXN0Q2FsbFJlc3VsdAABBAUAqAQABNQgVGhlIHJlc3VsdCBvZiB0aGUgbGFzdCBjYWxsIG1hZGUgYnkgdGhlIHByb3h5IChrZXkpLgABsQIAAQUBABhAUHJveHlEZXBvc2l0QmFzZRggAIeTAwAAAAAQEQEgVGhlIGJhc2UgYW1vdW50IG9mIGN1cnJlbmN5IG5lZWRlZCB0byByZXNlcnZlIGZvciBjcmVhdGluZyBhIHByb3h5LgABASBUaGlzIGlzIGhlbGQgZm9yIGFuIGFkZGl0aW9uYWwgc3RvcmFnZSBpdGVtIHdob3NlIHZhbHVlIHNpemUgaXMlASBgc2l6ZW9mKEJhbGFuY2UpYCBieXRlcyBhbmQgd2hvc2Uga2V5IHNpemUgaXMgYHNpemVvZihBY2NvdW50SWQpYCBieXRlcy4ASFByb3h5RGVwb3NpdEZhY3RvchggQIr3AQAAAAAUvCBUaGUgYW1vdW50IG9mIGN1cnJlbmN5IG5lZWRlZCBwZXIgcHJveHkgYWRkZWQuADUBIFRoaXMgaXMgaGVsZCBmb3IgYWRkaW5nIDMyIGJ5dGVzIHBsdXMgYW4gaW5zdGFuY2Ugb2YgYFByb3h5VHlwZWAgbW9yZSBpbnRvIGFhASBwcmUtZXhpc3Rpbmcgc3RvcmFnZSB2YWx1ZS4gVGh1cywgd2hlbiBjb25maWd1cmluZyBgUHJveHlEZXBvc2l0RmFjdG9yYCBvbmUgc2hvdWxkIHRha2X0IGludG8gYWNjb3VudCBgMzIgKyBwcm94eV90eXBlLmVuY29kZSgpLmxlbigpYCBieXRlcyBvZiBkYXRhLgAoTWF4UHJveGllcxAQFAAAAATwIFRoZSBtYXhpbXVtIGFtb3VudCBvZiBwcm94aWVzIGFsbG93ZWQgZm9yIGEgc2luZ2xlIGFjY291bnQuAChNYXhQZW5kaW5nEBBLAAAABEUBIFRoZSBtYXhpbXVtIGFtb3VudCBvZiB0aW1lLWRlbGF5ZWQgYW5ub3VuY2VtZW50cyB0aGF0IGFyZSBhbGxvd2VkIHRvIGJlIHBlbmRpbmcuAFxBbm5vdW5jZW1lbnREZXBvc2l0QmFzZRggAFElAgAAAAAQMQEgVGhlIGJhc2UgYW1vdW50IG9mIGN1cnJlbmN5IG5lZWRlZCB0byByZXNlcnZlIGZvciBjcmVhdGluZyBhbiBhbm5vdW5jZW1lbnQuAEkBIFRoaXMgaXMgaGVsZCB3aGVuIGEgbmV3IHN0b3JhZ2UgaXRlbSBob2xkaW5nIGEgYEJhbGFuY2VgIGlzIGNyZWF0ZWQgKHR5cGljYWxseSAxNiAgYnl0ZXMpLgBkQW5ub3VuY2VtZW50RGVwb3NpdEZhY3RvchggAJkNBAAAAAAQ1CBUaGUgYW1vdW50IG9mIGN1cnJlbmN5IG5lZWRlZCBwZXIgYW5ub3VuY2VtZW50IG1hZGUuAFkBIFRoaXMgaXMgaGVsZCBmb3IgYWRkaW5nIGFuIGBBY2NvdW50SWRgLCBgSGFzaGAgYW5kIGBCbG9ja051bWJlcmAgKHR5cGljYWxseSA2OCBieXRlcymMIGludG8gYSBwcmUtZXhpc3Rpbmcgc3RvcmFnZSB2YWx1ZS4AAcUHAAgsUnVudGltZUNhbGz5AQRsIFRoZSBvdmVyYXJjaGluZyBjYWxsIHR5cGUuJFByb3h5VHlwZQkBEFUBIEEga2luZCBvZiBwcm94eTsgc3BlY2lmaWVkIHdpdGggdGhlIHByb3h5IGFuZCBwYXNzZWQgaW4gdG8gdGhlIGBJc1Byb3h5YWJsZWAgZmlsdGVyLlEBIFRoZSBpbnN0YW5jZSBmaWx0ZXIgZGV0ZXJtaW5lcyB3aGV0aGVyIGEgZ2l2ZW4gY2FsbCBtYXkgYmUgcHJveGllZCB1bmRlciB0aGlzIHR5cGUuAE0BIElNUE9SVEFOVDogYERlZmF1bHRgIG11c3QgYmUgcHJvdmlkZWQgYW5kIE1VU1QgQkUgdGhlIHRoZSAqbW9zdCBwZXJtaXNzaXZlKiB2YWx1ZS4IGAnXg0Zyeg71jA+gO6+jI8vFFIjZKhqnE3sDv7UO/BdEY2hlY2tfcGVybWlzc2lvbnMIEGNhbGz5AShwcm94eV90eXBlCQEkBPQgQ2hlY2sgaWYgYSBgUnVudGltZUNhbGxgIGlzIGFsbG93ZWQgZm9yIGEgZ2l2ZW4gYFByb3h5VHlwZWAuABgJ14NGcnoO9YwPoDuvoyMXFLBgfWKvCjs7CtLF1VxYLGlzX3N1cGVyc2V0CCB0b19jaGVjawkBHGFnYWluc3QJASQE9CBDaGVjayBpZiBvbmUgYFByb3h5VHlwZWAgaXMgYSBzdWJzZXQgb2YgYW5vdGhlciBgUHJveHlUeXBlYC4AEAAAIFJlZ2lzdHJ5ASBSZWdpc3RyeQQoSWRlbnRpdHlPZgABBAUAyQcEAARkIElkZW50aXR5IGRhdGEgYnkgYWNjb3VudAABuQIAAREBAAxMTWF4QWRkaXRpb25hbEZpZWxkcxAQAQAAAAhUIENvbmZpZ3VyYXRpb24gZmllbGRzqCBNYXhpbXVtIHVzZXItY29uZmlndXJlZCBhZGRpdGlvbmFsIGZpZWxkcwA4SW5pdGlhbERlcG9zaXQYIADh9QUAAAAABNQgVGhlIGFtb3VudCBoZWxkIG9uIGRlcG9zaXQgZm9yIGEgcmVnaXN0ZXJlZCBpZGVudGl0eQAwRmllbGREZXBvc2l0GCAA4fUFAAAAAAQtASBUaGUgYW1vdW50IGhlbGQgb24gZGVwb3NpdCBwZXIgYWRkaXRpb25hbCBmaWVsZCBmb3IgYSByZWdpc3RlcmVkIGlkZW50aXR5LgABzQcAAAARAAAsQ29tbWl0bWVudHMBLENvbW1pdG1lbnRzHDxUaW1lbG9ja2VkSW5kZXgBANEHBAAEBQEgVHJhY2tzIGFsbCBDb21taXRtZW50T2YgdGhhdCBoYXZlIGF0IGxlYXN0IG9uZSB0aW1lbG9ja2VkIGZpZWxkLgAwQ29tbWl0bWVudE9mAAEIBgWlBtkHBAAEZCBJZGVudGl0eSBkYXRhIGJ5IGFjY291bnQAOExhc3RDb21taXRtZW50AAEIBgWlBhAEAAAAOExhc3RCb25kc1Jlc2V0AAEIBgWlBhAEAAAATFJldmVhbGVkQ29tbWl0bWVudHMAAQgGBaUG3QcEAAAALFVzZWRTcGFjZU9mAAEIBgWlBuUHBAAIFQEgTWFwcyAobmV0dWlkLCB3aG8pIC0+IHVzYWdlIChob3cgbWFueSDigJxieXRlc+KAnSB0aGV5J3ZlIGNvbW1pdHRlZClgIGluIHRoZSBSYXRlTGltaXQgd2luZG93ACBNYXhTcGFjZQEAEBAcDAAAAAABxQMAARUBAAwkTWF4RmllbGRzEBADAAAABCkBIFRoZSBtYXhpbXVtIG51bWJlciBvZiBhZGRpdGlvbmFsIGZpZWxkcyB0aGF0IGNhbiBiZSBhZGRlZCB0byBhIGNvbW1pdG1lbnQAOEluaXRpYWxEZXBvc2l0GCAAAAAAAAAAAATUIFRoZSBhbW91bnQgaGVsZCBvbiBkZXBvc2l0IGZvciBhIHJlZ2lzdGVyZWQgaWRlbnRpdHkAMEZpZWxkRGVwb3NpdBggAAAAAAAAAAAELQEgVGhlIGFtb3VudCBoZWxkIG9uIGRlcG9zaXQgcGVyIGFkZGl0aW9uYWwgZmllbGQgZm9yIGEgcmVnaXN0ZXJlZCBpZGVudGl0eS4AAekHAAAAEgAAKEFkbWluVXRpbHMBKEFkbWluVXRpbHMEQFByZWNvbXBpbGVFbmFibGUBAQQCHQEkBAEEfCBNYXAgUHJlY29tcGlsZUVudW0gLS0+IGVuYWJsZWQAAd0EAAEZAQAAAe0HAAQsQXV0aG9yaXR5SWTlBASYIFRoZSBpZGVudGlmaWVyIHR5cGUgZm9yIGFuIGF1dGhvcml0eS4AEwAAIFNhZmVNb2RlASBTYWZlTW9kZQgwRW50ZXJlZFVudGlsAAAQBAAUKQEgQ29udGFpbnMgdGhlIGxhc3QgYmxvY2sgbnVtYmVyIHRoYXQgdGhlIHNhZmUtbW9kZSB3aWxsIHJlbWFpbiBlbnRlcmVkIGluLgCkICBTZXQgdG8gYE5vbmVgIHdoZW4gc2FmZS1tb2RlIGlzIGV4aXRlZC4AUQEgU2FmZS1tb2RlIGlzIGF1dG9tYXRpY2FsbHkgZXhpdGVkIHdoZW4gdGhlIGN1cnJlbnQgYmxvY2sgbnVtYmVyIGV4Y2VlZHMgdGhpcyB2YWx1ZS4AIERlcG9zaXRzAAEIBQXxBxgEABA1ASBIb2xkcyB0aGUgcmVzZXJ2ZSB0aGF0IHdhcyB0YWtlbiBmcm9tIGFuIGFjY291bnQgYXQgYSBzcGVjaWZpYyBibG9jayBudW1iZXIuAHUBIFRoaXMgaGVscHMgZ292ZXJuYW5jZSB0byBoYXZlIGFuIG92ZXJ2aWV3IG9mIG91dHN0YW5kaW5nIGRlcG9zaXRzIHRoYXQgc2hvdWxkIGJlIHJldHVybmVkIG9yJCBzbGFzaGVkLgABLQUAASEBABQ0RW50ZXJEdXJhdGlvbhAQAAAAAAQhASBGb3IgaG93IG1hbnkgYmxvY2tzIHRoZSBzYWZlLW1vZGUgd2lsbCBiZSBlbnRlcmVkIGJ5IFtgUGFsbGV0OjplbnRlcmBdLgA4RXh0ZW5kRHVyYXRpb24QEAAAAAAMTQEgRm9yIGhvdyBtYW55IGJsb2NrcyB0aGUgc2FmZS1tb2RlIGNhbiBiZSBleHRlbmRlZCBieSBlYWNoIFtgUGFsbGV0OjpleHRlbmRgXSBjYWxsLgBNASBUaGlzIGRvZXMgbm90IGltcG9zZSBhIGhhcmQgbGltaXQgYXMgdGhlIHNhZmUtbW9kZSBjYW4gYmUgZXh0ZW5kZWQgbXVsdGlwbGUgdGltZXMuAEhFbnRlckRlcG9zaXRBbW91bnR9AgQADAUBIFRoZSBhbW91bnQgdGhhdCB3aWxsIGJlIHJlc2VydmVkIHVwb24gY2FsbGluZyBbYFBhbGxldDo6ZW50ZXJgXS4AQQEgYE5vbmVgIGRpc2FsbG93cyBwZXJtaXNzaW9ubGVzc2x5IGVuYWJsaW5nIHRoZSBzYWZlLW1vZGUgYW5kIGlzIGEgc2FuZSBkZWZhdWx0LgBMRXh0ZW5kRGVwb3NpdEFtb3VudH0CBAAMCQEgVGhlIGFtb3VudCB0aGF0IHdpbGwgYmUgcmVzZXJ2ZWQgdXBvbiBjYWxsaW5nIFtgUGFsbGV0OjpleHRlbmRgXS4ARQEgYE5vbmVgIGRpc2FsbG93cyBwZXJtaXNzaW9ubGVzc2x5IGV4dGVuZGluZyB0aGUgc2FmZS1tb2RlIGFuZCBpcyBhIHNhbmUgZGVmYXVsdC4AMFJlbGVhc2VEZWxhecwEACBJASBUaGUgbWluaW1hbCBkdXJhdGlvbiBhIGRlcG9zaXQgd2lsbCByZW1haW4gcmVzZXJ2ZWQgYWZ0ZXIgc2FmZS1tb2RlIGlzIGVudGVyZWQgb3JJASBleHRlbmRlZCwgdW5sZXNzIFtgUGFsbGV0Ojpmb3JjZV9yZWxlYXNlX2RlcG9zaXRgXSBpcyBzdWNjZXNzZnVsbHkgY2FsbGVkIHNvb25lci4AWQEgRXZlcnkgZGVwb3NpdCBpcyB0aWVkIHRvIGEgc3BlY2lmaWMgYWN0aXZhdGlvbiBvciBleHRlbnNpb24sIHRodXMgZWFjaCBkZXBvc2l0IGNhbiBiZeggcmVsZWFzZWQgaW5kZXBlbmRlbnRseSBhZnRlciB0aGUgZGVsYXkgZm9yIGl0IGhhcyBwYXNzZWQuAEUBIGBOb25lYCBkaXNhbGxvd3MgcGVybWlzc2lvbmxlc3NseSByZWxlYXNpbmcgdGhlIHNhZmUtbW9kZSBkZXBvc2l0cyBhbmQgaXMgYSBzYW5lJCBkZWZhdWx0LgAB9QcAAAAUAAAgRXRoZXJldW0BIEV0aGVyZXVtGBxQZW5kaW5nAAEEBhD5BwQABDUBIE1hcHBpbmcgZnJvbSB0cmFuc2FjdGlvbiBpbmRleCB0byB0cmFuc2FjdGlvbiBpbiB0aGUgY3VycmVudCBidWlsZGluZyBibG9jay4ARENvdW50ZXJGb3JQZW5kaW5nAQAQEAAAAAAErENvdW50ZXIgZm9yIHRoZSByZWxhdGVkIGNvdW50ZWQgc3RvcmFnZSBtYXAAMEN1cnJlbnRCbG9jawAAGQgEAARwIFRoZSBjdXJyZW50IEV0aGVyZXVtIGJsb2NrLgA8Q3VycmVudFJlY2VpcHRzAAAtCAQABHwgVGhlIGN1cnJlbnQgRXRoZXJldW0gcmVjZWlwdHMuAGhDdXJyZW50VHJhbnNhY3Rpb25TdGF0dXNlcwAAMQgEAASIIFRoZSBjdXJyZW50IHRyYW5zYWN0aW9uIHN0YXR1c2VzLgAkQmxvY2tIYXNoAQEEBVkBNIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATEFAAEpAQAAATUIAAAAFQAADEVWTQEMRVZNFDBBY2NvdW50Q29kZXMBAQQCxDgEAAAAUEFjY291bnRDb2Rlc01ldGFkYXRhAAEEAsQ5CAQAAAA8QWNjb3VudFN0b3JhZ2VzAQEIAgI9CDSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAExXaGl0ZWxpc3RlZENyZWF0b3JzAQB9BQQAAABURGlzYWJsZVdoaXRlbGlzdENoZWNrAQAkBAAAAAFtBQABTQEAAAFBCAAAABYAAChFVk1DaGFpbklkAShFVk1DaGFpbklkBBxDaGFpbklkAQAYIAAAAAAAAAAABEggVGhlIEVWTSBjaGFpbiBJRC4AAAAAAAAAFwAAHEJhc2VGZWUBHEJhc2VGZWUINEJhc2VGZWVQZXJHYXMBAFkBgADIF6gEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoRWxhc3RpY2l0eQEAYQEQSOgBAAAAAYEFAAFVAQAAAAAAGQAAFERyYW5kARREcmFuZBgwQmVhY29uQ29uZmlnAQCtBTkDgQGDzw8olq3ufri18B/K05EiEsQ34Ac+kR+5ACLT52AYPIxLRQtqCmw6xqV3ai0QZFENH+x1jJIcwisOF+Y6r0vLXtZjBN6c+Am9J0ynO6tK9abpx2pLwJ526uiZHvXs5FoDAAAAJyHmZIBS25unDgzA9ur3gD3QdEeh9Ud3Nf0/ZheSupRgDITpcYD0d9XInyGhfIY6f5N8am0VhZQU0r4JzUSNQnmvMxxdPmBibHMtdW5jaGFpbmVkLWcxLXJmYzkzODAgcXVpY2tuZXQEfCB0aGUgZHJhbmQgYmVhY29uIGNvbmZpZ3VyYXRpb24APEhhc01pZ3JhdGlvblJ1bgEBBAaVByQEAASEIFN0b3JhZ2UgZm9yIG1pZ3JhdGlvbiBydW4gc3RhdHVzABhQdWxzZXMAAQQCGJUFBAAEaCBtYXAgcm91bmQgbnVtYmVyIHRvIHB1bHNlADxMYXN0U3RvcmVkUm91bmQBABggAAAAAAAAAAAAAERPbGRlc3RTdG9yZWRSb3VuZAEAGCAAAAAAAAAAAARQIG9sZGVzdCBzdG9yZWQgcm91bmQAOE5leHRVbnNpZ25lZEF0AQAQEAAAAAAUDQEgRGVmaW5lcyB0aGUgYmxvY2sgd2hlbiBuZXh0IHVuc2lnbmVkIHRyYW5zYWN0aW9uIHdpbGwgYmUgYWNjZXB0ZWQuAB0BIFRvIHByZXZlbnQgc3BhbSBvZiB1bnNpZ25lZCAoYW5kIHVucGFpZCEpIHRyYW5zYWN0aW9ucyBvbiB0aGUgbmV0d29yayykIHdlIG9ubHkgYWxsb3cgb25lIHRyYW5zYWN0aW9uIHBlciBibG9jay4lASBUaGlzIHN0b3JhZ2UgZW50cnkgZGVmaW5lcyB3aGVuIG5ldyB0cmFuc2FjdGlvbiBpcyBnb2luZyB0byBiZSBhY2NlcHRlZC4AAYUFAAFlAQAIQFVuc2lnbmVkUHJpb3JpdHkYIAAAEAAAAAAAEPAgQSBjb25maWd1cmF0aW9uIGZvciBiYXNlIHByaW9yaXR5IG9mIHVuc2lnbmVkIHRyYW5zYWN0aW9ucy4AFQEgVGhpcyBpcyBleHBvc2VkIHNvIHRoYXQgaXQgY2FuIGJlIHR1bmVkIGZvciBwYXJ0aWN1bGFyIHJ1bnRpbWUsIHdoZW60IG11bHRpcGxlIHBhbGxldHMgc2VuZCB1bnNpZ25lZCB0cmFuc2FjdGlvbnMuAEBIdHRwRmV0Y2hUaW1lb3V0GCDoAwAAAAAAAAhJASBUaGUgbWF4aW11bSBudW1iZXIgb2YgbWlsbGlzZWNvbmRzIHdlIGFyZSB3aWxsaW5nIHRvIHdhaXQgZm9yIHRoZSBIVFRQIHJlcXVlc3QgdG8oIGNvbXBsZXRlLgABRQgAAAAaAAAkQ3Jvd2Rsb2FuASRDcm93ZGxvYW4UKENyb3dkbG9hbnMAAQQFEEkIBAAEtCBBIG1hcCBvZiBjcm93ZGxvYW4gaWRzIHRvIHRoZWlyIGluZm9ybWF0aW9uLgA8TmV4dENyb3dkbG9hbklkAQAQEAAAAAAEkCBUaGUgbmV4dCBpbmNyZW1lbnRpbmcgY3Jvd2Rsb2FuIGlkLgA0Q29udHJpYnV0aW9ucwABCAUGPQcYBAAEGQEgQSBtYXAgb2YgY3Jvd2Rsb2FuIGlkcyB0byB0aGVpciBjb250cmlidXRvcnMgYW5kIHRoZWlyIGNvbnRyaWJ1dGlvbnMuAEhDdXJyZW50Q3Jvd2Rsb2FuSWQAABAEAAg5ASBUaGUgY3VycmVudCBjcm93ZGxvYW4gaWQgdGhhdCB3aWxsIGJlIHNldCBkdXJpbmcgdGhlIGZpbmFsaXplIGNhbGwsIG1ha2luZyBpdLwgdGVtcG9yYXJpbHkgYWNjZXNzaWJsZSB0byB0aGUgZGlzcGF0Y2hlZCBjYWxsLgA8SGFzTWlncmF0aW9uUnVuAQEEBpUHJAQABJggU3RvcmFnZSBmb3IgdGhlIG1pZ3JhdGlvbiBydW4gc3RhdHVzLgABuQUAAW0BABwgUGFsbGV0SWRRCCBidC9jbG9hbgQFASBUaGUgcGFsbGV0IGlkIHRoYXQgd2lsbCBiZSB1c2VkIHRvIGRlcml2ZSBjcm93ZGxvYW4gYWNjb3VudCBpZHMuADhNaW5pbXVtRGVwb3NpdBggAOQLVAIAAAAE0CBUaGUgbWluaW11bSBkZXBvc2l0IHJlcXVpcmVkIHRvIGNyZWF0ZSBhIGNyb3dkbG9hbi4AbEFic29sdXRlTWluaW11bUNvbnRyaWJ1dGlvbhggAOH1BQAAAAAEJQEgVGhlIGFic29sdXRlIG1pbmltdW0gY29udHJpYnV0aW9uIHJlcXVpcmVkIHRvIGNvbnRyaWJ1dGUgdG8gYSBjcm93ZGxvYW4uAFBNaW5pbXVtQmxvY2tEdXJhdGlvbhAQMgAAAASwIFRoZSBtaW5pbXVtIGJsb2NrIGR1cmF0aW9uIGZvciBhIGNyb3dkbG9hbi4AUE1heGltdW1CbG9ja0R1cmF0aW9uEBAgTgAABLAgVGhlIG1heGltdW0gYmxvY2sgZHVyYXRpb24gZm9yIGEgY3Jvd2Rsb2FuLgBcUmVmdW5kQ29udHJpYnV0b3JzTGltaXQQEDIAAAAEMQEgVGhlIG1heGltdW0gbnVtYmVyIG9mIGNvbnRyaWJ1dG9ycyB0aGF0IGNhbiBiZSByZWZ1bmRlZCBpbiBhIHNpbmdsZSByZWZ1bmQuADxNYXhDb250cmlidXRvcnMQEPQBAAAAAAFVCAAELFJ1bnRpbWVDYWxs+QEEbCBUaGUgb3ZlcmFyY2hpbmcgY2FsbCB0eXBlLgAbAAAQU3dhcAEQU3dhcDgcRmVlUmF0ZQEBBAWgoAghAARJASBUaGUgZmVlIHJhdGUgYXBwbGllZCB0byBzd2FwcyBwZXIgc3VibmV0LCBub3JtYWxpemVkIHZhbHVlIGJldHdlZW4gMCBhbmQgdTE2OjpNQVgAMEZlZUdsb2JhbFRhbwEBBAWgKQVAAAAAAAAAAAAAAAAAAAAAAAAAOEZlZUdsb2JhbEFscGhhAQEEBaApBUAAAAAAAAAAAAAAAAAAAAAAAAAUVGlja3MAAQgFBVkIXQgEAAR5ASBTdG9yYWdlIGZvciBhbGwgdGlja3MsIHVzaW5nIHN1Ym5ldCBJRCBhcyB0aGUgcHJpbWFyeSBrZXkgYW5kIHRpY2sgaW5kZXggYXMgdGhlIHNlY29uZGFyeSBrZXkARFN3YXBWM0luaXRpYWxpemVkAQEEBaAkBAAEMQEgU3RvcmFnZSB0byBkZXRlcm1pbmUgd2hldGhlciBzd2FwIFYzIHdhcyBpbml0aWFsaXplZCBmb3IgYSBzcGVjaWZpYyBzdWJuZXQuADhBbHBoYVNxcnRQcmljZQEBBAWgKQVAAAAAAAAAAAAAAAAAAAAAAAQJASBTdG9yYWdlIGZvciB0aGUgc3F1YXJlIHJvb3QgcHJpY2Ugb2YgQWxwaGEgdG9rZW4gZm9yIGVhY2ggc3VibmV0LgAsQ3VycmVudFRpY2sBAQQFoHkBEAAAAAAEkCBTdG9yYWdlIGZvciB0aGUgY3VycmVudCBwcmljZSB0aWNrLgBAQ3VycmVudExpcXVpZGl0eQEBBAWgGCAAAAAAAAAAAAToIFN0b3JhZ2UgZm9yIHRoZSBjdXJyZW50IGxpcXVpZGl0eSBhbW91bnQgZm9yIGVhY2ggc3VibmV0LgBQRW5hYmxlZFVzZXJMaXF1aWRpdHkBAQQFoCQEAAwFASBJbmRpY2F0ZXMgd2hldGhlciBhIHN1Ym5ldCBoYXMgYmVlbiBzd2l0Y2hlZCB0byBWMyBzd2FwIGZyb20gVjIuTQEgSWYgYHRydWVgLCB0aGUgc3VibmV0IGlzIHBlcm1hbmVudGx5IG9uIFYzIHN3YXAgbW9kZSBhbGxvd2luZyBhZGQvcmVtb3ZlIGxpcXVpZGl0eU0BIG9wZXJhdGlvbnMuIE9uY2Ugc2V0IHRvIGB0cnVlYCBmb3IgYSBzdWJuZXQsIGl0IGNhbm5vdCBiZSBjaGFuZ2VkIGJhY2sgdG8gYGZhbHNlYC4AJFBvc2l0aW9ucwABDAUFBWEIZQgEAAgNASBTdG9yYWdlIGZvciB1c2VyIHBvc2l0aW9ucywgdXNpbmcgc3VibmV0IElEIGFuZCBhY2NvdW50IElEIGFzIGtleXN1ASBUaGUgdmFsdWUgaXMgYSBib3VuZGVkIHZlY3RvciBvZiBQb3NpdGlvbiBzdHJ1Y3RzIHdpdGggZGV0YWlscyBhYm91dCB0aGUgbGlxdWlkaXR5IHBvc2l0aW9ucwA4TGFzdFBvc2l0aW9uSWQBACBAAAAAAAAAAAAAAAAAAAAAAARUIFBvc2l0aW9uIElEIGNvdW50ZXIuAFBUaWNrSW5kZXhCaXRtYXBXb3JkcwEBDAUFBWkIIEAAAAAAAAAAAAAAAAAAAAAABIAgVGljayBpbmRleCBiaXRtYXAgd29yZHMgc3RvcmFnZQBEU2NyYXBSZXNlcnZvaXJUYW8BAQQFoBggAAAAAAAAAAAEzCBUQU8gcmVzZXJ2b2lyIGZvciBzY3JhcHMgb2YgcHJvdG9jb2wgY2xhaW1lZCBmZWVzLgBMU2NyYXBSZXNlcnZvaXJBbHBoYQEBBAWgGCAAAAAAAAAAAATUIEFscGhhIHJlc2Vydm9pciBmb3Igc2NyYXBzIG9mIHByb3RvY29sIGNsYWltZWQgZmVlcy4AAcEFAAFxAQAUKFByb3RvY29sSWRRCCB0ZW4vc3dhcATAIFRoaXMgdHlwZSBpcyB1c2VkIHRvIGRlcml2ZSBwcm90b2NvbCBhY2NvdW4gSUQuAChNYXhGZWVSYXRloAgQJwSUIFRoZSBtYXhpbXVtIGZlZSByYXRlIHRoYXQgY2FuIGJlIHNldAAwTWF4UG9zaXRpb25zEBBkAAAABMAgVGhlIG1heGltdW0gbnVtYmVyIG9mIHBvc2l0aW9ucyBhIHVzZXIgY2FuIGhhdmUAQE1pbmltdW1MaXF1aWRpdHkYIOgDAAAAAAAABPggTWluaW11bSBsaXF1aWRpdHkgdGhhdCBpcyBzYWZlIGZvciByb3VuZGluZyBhbmQgaW50ZWdlciBtYXRoLgA4TWluaW11bVJlc2VydmVxCCBAQg8AAAAAAASIIE1pbmltdW0gcmVzZXJ2ZSBmb3IgdGFvIGFuZCBhbHBoYQABdQgAAAAcAAAkQ29udHJhY3RzASRDb250cmFjdHMcMFByaXN0aW5lQ29kZQABBAY0eQgEAATMIEEgbWFwcGluZyBmcm9tIGEgY29udHJhY3QncyBjb2RlIGhhc2ggdG8gaXRzIGNvZGUuAChDb2RlSW5mb09mAAEEBjR9CAQABOAgQSBtYXBwaW5nIGZyb20gYSBjb250cmFjdCdzIGNvZGUgaGFzaCB0byBpdHMgY29kZSBpbmZvLgAUTm9uY2UBABggAAAAAAAAAABYHQEgVGhpcyBpcyBhICoqbW9ub3RvbmljKiogY291bnRlciBpbmNyZW1lbnRlZCBvbiBjb250cmFjdCBpbnN0YW50aWF0aW9uLgAFASBUaGlzIGlzIHVzZWQgaW4gb3JkZXIgdG8gZ2VuZXJhdGUgdW5pcXVlIHRyaWUgaWRzIGZvciBjb250cmFjdHMuKQEgVGhlIHRyaWUgaWQgb2YgYSBuZXcgY29udHJhY3QgaXMgY2FsY3VsYXRlZCBmcm9tIGhhc2goYWNjb3VudF9pZCwgbm9uY2UpLjUBIFRoZSBub25jZSBpcyByZXF1aXJlZCBiZWNhdXNlIG90aGVyd2lzZSB0aGUgZm9sbG93aW5nIHNlcXVlbmNlIHdvdWxkIGxlYWQgdG+EIGEgcG9zc2libGUgY29sbGlzaW9uIG9mIHN0b3JhZ2U6AGggMS4gQ3JlYXRlIGEgbmV3IGNvbnRyYWN0LmwgMi4gVGVybWluYXRlIHRoZSBjb250cmFjdC78IDMuIEltbWVkaWF0ZWx5IHJlY3JlYXRlIHRoZSBjb250cmFjdCB3aXRoIHRoZSBzYW1lIGFjY291bnRfaWQuAEUBIFRoaXMgaXMgYmFkIGJlY2F1c2UgdGhlIGNvbnRlbnRzIG9mIGEgdHJpZSBhcmUgZGVsZXRlZCBsYXppbHkgYW5kIHRoZXJlIG1pZ2h0IGJlWQEgc3RvcmFnZSBvZiB0aGUgb2xkIGluc3RhbnRpYXRpb24gc3RpbGwgaW4gaXQgd2hlbiB0aGUgbmV3IGNvbnRyYWN0IGlzIGNyZWF0ZWQuIFBsZWFzZVkBIG5vdGUgdGhhdCB3ZSBjYW4ndCByZXBsYWNlIHRoZSBjb3VudGVyIGJ5IHRoZSBibG9jayBudW1iZXIgYmVjYXVzZSB0aGUgc2VxdWVuY2UgYWJvdmVRASBjYW4gaGFwcGVuIGluIHRoZSBzYW1lIGJsb2NrLiBXZSBhbHNvIGNhbid0IGtlZXAgdGhlIGFjY291bnQgY291bnRlciBpbiBtZW1vcnkgb25seUkBIGJlY2F1c2Ugc3RvcmFnZSBpcyB0aGUgb25seSB3YXkgdG8gY29tbXVuaWNhdGUgYWNyb3NzIGRpZmZlcmVudCBleHRyaW5zaWNzIGluIHRoZTAgc2FtZSBibG9jay4AHCAjIE5vdGUAPQEgRG8gbm90IHVzZSBpdCB0byBkZXRlcm1pbmUgdGhlIG51bWJlciBvZiBjb250cmFjdHMuIEl0IHdvbid0IGJlIGRlY3JlbWVudGVkIGlmZCBhIGNvbnRyYWN0IGlzIGRlc3Ryb3llZC4AOENvbnRyYWN0SW5mb09mAAEEBQCBCAQADKggVGhlIGNvZGUgYXNzb2NpYXRlZCB3aXRoIGEgZ2l2ZW4gYWNjb3VudC4A0CBUV09YLU5PVEU6IFNBRkUgc2luY2UgYEFjY291bnRJZGAgaXMgYSBzZWN1cmUgaGFzaC4ANERlbGV0aW9uUXVldWUAAQQFEJUHBAAQyCBFdmljdGVkIGNvbnRyYWN0cyB0aGF0IGF3YWl0IGNoaWxkIHRyaWUgZGVsZXRpb24uAEkBIENoaWxkIHRyaWUgZGVsZXRpb24gaXMgYSBoZWF2eSBvcGVyYXRpb24gZGVwZW5kaW5nIG9uIHRoZSBhbW91bnQgb2Ygc3RvcmFnZSBpdGVtc0EBIHN0b3JlZCBpbiBzYWlkIHRyaWUuIFRoZXJlZm9yZSB0aGlzIG9wZXJhdGlvbiBpcyBwZXJmb3JtZWQgbGF6aWx5IGluIGBvbl9pZGxlYC4AUERlbGV0aW9uUXVldWVDb3VudGVyAQCVCCAAAAAAAAAAAAhNASBBIHBhaXIgb2YgbW9ub3RvbmljIGNvdW50ZXJzIHVzZWQgdG8gdHJhY2sgdGhlIGxhdGVzdCBjb250cmFjdCBtYXJrZWQgZm9yIGRlbGV0aW9uqCBhbmQgdGhlIGxhdGVzdCBkZWxldGVkIGNvbnRyYWN0IGluIHF1ZXVlLgBMTWlncmF0aW9uSW5Qcm9ncmVzcwAA0QQEAAhhASBBIG1pZ3JhdGlvbiBjYW4gc3BhbiBhY3Jvc3MgbXVsdGlwbGUgYmxvY2tzLiBUaGlzIHN0b3JhZ2UgZGVmaW5lcyBhIGN1cnNvciB0byB0cmFjayB0aGVNASBwcm9ncmVzcyBvZiB0aGUgbWlncmF0aW9uLCBlbmFibGluZyB1cyB0byByZXN1bWUgZnJvbSB0aGUgbGFzdCBjb21wbGV0ZWQgcG9zaXRpb24uAAHFBQwAAvQxRCB3ZWlnaHQgaXMgdXNlZCBpbiB0aGlzIGV4dHJpbnNpYywgcGxlYXNlIG1pZ3JhdGUgdG8gYGNhbGxgAAECOQExRCB3ZWlnaHQgaXMgdXNlZCBpbiB0aGlzIGV4dHJpbnNpYywgcGxlYXNlIG1pZ3JhdGUgdG8gYGluc3RhbnRpYXRlX3dpdGhfY29kZWAAAgIRATFEIHdlaWdodCBpcyB1c2VkIGluIHRoaXMgZXh0cmluc2ljLCBwbGVhc2UgbWlncmF0ZSB0byBgaW5zdGFudGlhdGVgAAGFAQA0IFNjaGVkdWxlmQiQBAAAABAAAAAgAAAAAEAAAAAAAEAAAACAYOoAAAAAAADrBAAABGggQ29zdCBzY2hlZHVsZSBhbmQgbGltaXRzLgA4RGVwb3NpdFBlckJ5dGUYIB4AAAAAAAAAFBEBIFRoZSBhbW91bnQgb2YgYmFsYW5jZSBhIGNhbGxlciBoYXMgdG8gcGF5IGZvciBlYWNoIGJ5dGUgb2Ygc3RvcmFnZS4AHCAjIE5vdGUAKQEgQ2hhbmdpbmcgdGhpcyB2YWx1ZSBmb3IgYW4gZXhpc3RpbmcgY2hhaW4gbWlnaHQgbmVlZCBhIHN0b3JhZ2UgbWlncmF0aW9uLgBMRGVmYXVsdERlcG9zaXRMaW1pdBggACzhAQAAAAAERQEgRmFsbGJhY2sgdmFsdWUgdG8gbGltaXQgdGhlIHN0b3JhZ2UgZGVwb3NpdCBpZiBpdCdzIG5vdCBiZWluZyBzZXQgYnkgdGhlIGNhbGxlci4AOERlcG9zaXRQZXJJdGVtGCBLAAAAAAAAABQFASBUaGUgYW1vdW50IG9mIGJhbGFuY2UgYSBjYWxsZXIgaGFzIHRvIHBheSBmb3IgZWFjaCBzdG9yYWdlIGl0ZW0uABwgIyBOb3RlACkBIENoYW5naW5nIHRoaXMgdmFsdWUgZm9yIGFuIGV4aXN0aW5nIGNoYWluIG1pZ2h0IG5lZWQgYSBzdG9yYWdlIG1pZ3JhdGlvbi4AcENvZGVIYXNoTG9ja3VwRGVwb3NpdFBlcmNlbnSlCBAAo+EREEUBIFRoZSBwZXJjZW50YWdlIG9mIHRoZSBzdG9yYWdlIGRlcG9zaXQgdGhhdCBzaG91bGQgYmUgaGVsZCBmb3IgdXNpbmcgYSBjb2RlIGhhc2guYQEgSW5zdGFudGlhdGluZyBhIGNvbnRyYWN0LCBvciBjYWxsaW5nIFtgY2hhaW5fZXh0ZW5zaW9uOjpFeHQ6OmxvY2tfZGVsZWdhdGVfZGVwZW5kZW5jeWBdSQEgcHJvdGVjdHMgdGhlIGNvZGUgZnJvbSBiZWluZyByZW1vdmVkLiBJbiBvcmRlciB0byBwcmV2ZW50IGFidXNlIHRoZXNlIGFjdGlvbnMgYXJlxCBwcm90ZWN0ZWQgd2l0aCBhIHBlcmNlbnRhZ2Ugb2YgdGhlIGNvZGUgZGVwb3NpdC4AKE1heENvZGVMZW4QEAAAAgAUwCBUaGUgbWF4aW11bSBsZW5ndGggb2YgYSBjb250cmFjdCBjb2RlIGluIGJ5dGVzLgBZASBUaGUgdmFsdWUgc2hvdWxkIGJlIGNob3NlbiBjYXJlZnVsbHkgdGFraW5nIGludG8gdGhlIGFjY291bnQgdGhlIG92ZXJhbGwgbWVtb3J5IGxpbWl08CB5b3VyIHJ1bnRpbWUgaGFzLCBhcyB3ZWxsIGFzIHRoZSBbbWF4aW11bSBhbGxvd2VkIGNhbGxzdGFja10BIGRlcHRoXSgjYXNzb2NpYXRlZHR5cGUuQ2FsbFN0YWNrKS4gTG9vayBpbnRvIHRoZSBgaW50ZWdyaXR5X3Rlc3QoKWAgZm9yIHNvbWUgaW5zaWdodHMuAEBNYXhTdG9yYWdlS2V5TGVuEBCAAAAABOAgVGhlIG1heGltdW0gYWxsb3dhYmxlIGxlbmd0aCBpbiBieXRlcyBmb3Igc3RvcmFnZSBrZXlzLgBcTWF4VHJhbnNpZW50U3RvcmFnZVNpemUQEAAAEAAI0CBUaGUgbWF4aW11bSBzaXplIG9mIHRoZSB0cmFuc2llbnQgc3RvcmFnZSBpbiBieXRlcy4xASBUaGlzIGluY2x1ZGVzIGtleXMsIHZhbHVlcywgYW5kIHByZXZpb3VzIGVudHJpZXMgdXNlZCBmb3Igc3RvcmFnZSByb2xsYmFjay4AXE1heERlbGVnYXRlRGVwZW5kZW5jaWVzEBAgAAAACCkBIFRoZSBtYXhpbXVtIG51bWJlciBvZiBkZWxlZ2F0ZV9kZXBlbmRlbmNpZXMgdGhhdCBhIGNvbnRyYWN0IGNhbiBsb2NrIHdpdGjQIFtgY2hhaW5fZXh0ZW5zaW9uOjpFeHQ6OmxvY2tfZGVsZWdhdGVfZGVwZW5kZW5jeWBdLgBcVW5zYWZlVW5zdGFibGVJbnRlcmZhY2UkBAAkEQEgTWFrZSBjb250cmFjdCBjYWxsYWJsZSBmdW5jdGlvbnMgbWFya2VkIGFzIGAjW3Vuc3RhYmxlXWAgYXZhaWxhYmxlLgA9ASBDb250cmFjdHMgdGhhdCB1c2UgYCNbdW5zdGFibGVdYCBmdW5jdGlvbnMgd29uJ3QgYmUgYWJsZSB0byBiZSB1cGxvYWRlZCB1bmxlc3NFASB0aGlzIGlzIHNldCB0byBgdHJ1ZWAuIFRoaXMgaXMgb25seSBtZWFudCBmb3IgdGVzdG5ldHMgYW5kIGRldiBub2RlcyBpbiBvcmRlciB0b3ggZXhwZXJpbWVudCB3aXRoIG5ldyBmZWF0dXJlcy4AKCAjIFdhcm5pbmcAwCBEbyAqKm5vdCoqIHNldCB0byBgdHJ1ZWAgb24gcHJvZHVjdGlvbnMgY2hhaW5zLgBETWF4RGVidWdCdWZmZXJMZW4QEAAAIAAExCBUaGUgbWF4aW11bSBsZW5ndGggb2YgdGhlIGRlYnVnIGJ1ZmZlciBpbiBieXRlcy4ALEVudmlyb25tZW50qQgAECUBIFR5cGUgdGhhdCBidW5kbGVzIHRvZ2V0aGVyIGFsbCB0aGUgcnVudGltZSBjb25maWd1cmFibGUgaW50ZXJmYWNlIHR5cGVzLgA1ASBUaGlzIGlzIG5vdCBhIHJlYWwgY29uZmlnLiBXZSBqdXN0IG1lbnRpb24gdGhlIHR5cGUgaGVyZSBhcyBjb25zdGFudCBzbyB0aGF08CBpdHMgdHlwZSBhcHBlYXJzIGluIHRoZSBtZXRhZGF0YS4gT25seSB2YWxpZCB2YWx1ZSBpcyBgKClgLgAoQXBpVmVyc2lvbsUICAQADAkBIFRoZSB2ZXJzaW9uIG9mIHRoZSBIb3N0Rm4gQVBJcyB0aGF0IGFyZSBhdmFpbGFibGUgaW4gdGhlIHJ1bnRpbWUuAGggT25seSB2YWxpZCB2YWx1ZSBpcyBgKClgLgAByQgAAAAdAAAkTWV2U2hpZWxkASRNZXZTaGllbGQQKEN1cnJlbnRLZXkAANUFBAAE4CBDdXJyZW50IE1M4oCRS0VN4oCRNzY4IHB1YmxpYyBrZXkgYnl0ZXMgKGVuY29kZWQgZm9ybSkuABxOZXh0S2V5AADVBQQABBUBIE5leHQgTUzigJFLRU3igJE3NjggcHVibGljIGtleSBieXRlcywgYW5ub3VuY2VkIGJ5IHRoZSBibG9jayBhdXRob3IuACxTdWJtaXNzaW9ucwABBAI0zQgEAATcIEJ1ZmZlcmVkIGVuY3J5cHRlZCBzdWJtaXNzaW9ucywgaW5kZXhlZCBieSB3cmFwcGVyIGlkLgA4S2V5SGFzaEJ5QmxvY2sAAQQCEDQEAARFASBIYXNoKEN1cnJlbnRLZXkpIHBlciBibG9jaywgdXNlZCB0byBiaW5kIGBrZXlfaGFzaGAgdG8gdGhlIGVwb2NoIGF0IHN1Ym1pdCB0aW1lLgAB0QUAAZEBAAAB0QgABCxSdW50aW1lQ2FsbPkBAAAeAAAIBAU1AvkBpQUEADAABAgMEBQYHCAkKCwwSENoZWNrTm9uWmVyb1NlbmRlcvEFrEBDaGVja1NwZWNWZXJzaW9u9QUQOENoZWNrVHhWZXJzaW9u+QUQMENoZWNrR2VuZXNpc/0FNDhDaGVja01vcnRhbGl0eQEGNChDaGVja05vbmNlCQasLENoZWNrV2VpZ2h0DQasYENoYXJnZVRyYW5zYWN0aW9uUGF5bWVudBUGrGBTdWRvVHJhbnNhY3Rpb25FeHRlbnNpb24ZBqx0U3VidGVuc29yVHJhbnNhY3Rpb25FeHRlbnNpb24dBqw0RHJhbmRQcmlvcml0eSEGrERDaGVja01ldGFkYXRhSGFzaCUGAQFYEENvcmUMHHZlcnNpb24A4QEEkCBSZXR1cm5zIHRoZSB2ZXJzaW9uIG9mIHRoZSBydW50aW1lLgA0ZXhlY3V0ZV9ibG9jawQUYmxvY2vhBawEZCBFeGVjdXRlIHRoZSBnaXZlbiBibG9jay4AQGluaXRpYWxpemVfYmxvY2sEGGhlYWRlcuUF1QgEQQEgSW5pdGlhbGl6ZSBhIGJsb2NrIHdpdGggdGhlIGdpdmVuIGhlYWRlciBhbmQgcmV0dXJuIHRoZSBydW50aW1lIGV4ZWN1dGl2ZSBtb2RlLgAEIQEgVGhlIGBDb3JlYCBydW50aW1lIGFwaSB0aGF0IGV2ZXJ5IFN1YnN0cmF0ZSBydW50aW1lIG5lZWRzIHRvIGltcGxlbWVudC4UACBNZXRhZGF0YQwgbWV0YWRhdGEA2QgEjCBSZXR1cm5zIHRoZSBtZXRhZGF0YSBvZiBhIHJ1bnRpbWUuAExtZXRhZGF0YV9hdF92ZXJzaW9uBBx2ZXJzaW9uEN0IEKQgUmV0dXJucyB0aGUgbWV0YWRhdGEgYXQgYSBnaXZlbiB2ZXJzaW9uLgAFASBJZiB0aGUgZ2l2ZW4gYHZlcnNpb25gIGlzbid0IHN1cHBvcnRlZCwgdGhpcyB3aWxsIHJldHVybiBgTm9uZWAudQEgVXNlIFtgU2VsZjo6bWV0YWRhdGFfdmVyc2lvbnNgXSB0byBmaW5kIG91dCBhYm91dCBzdXBwb3J0ZWQgbWV0YWRhdGEgdmVyc2lvbiBvZiB0aGUgcnVudGltZS4ARG1ldGFkYXRhX3ZlcnNpb25zAOEIDKQgUmV0dXJucyB0aGUgc3VwcG9ydGVkIG1ldGFkYXRhIHZlcnNpb25zLgDAIFRoaXMgY2FuIGJlIHVzZWQgdG8gY2FsbCBgbWV0YWRhdGFfYXRfdmVyc2lvbmAuAAQBASBUaGUgYE1ldGFkYXRhYCBhcGkgdHJhaXQgdGhhdCByZXR1cm5zIG1ldGFkYXRhIGZvciB0aGUgcnVudGltZS4IADBCbG9ja0J1aWxkZXIQPGFwcGx5X2V4dHJpbnNpYwQkZXh0cmluc2lj6QXlCBBsIEFwcGx5IHRoZSBnaXZlbiBleHRyaW5zaWMuADkBIFJldHVybnMgYW4gaW5jbHVzaW9uIG91dGNvbWUgd2hpY2ggc3BlY2lmaWVzIGlmIHRoaXMgZXh0cmluc2ljIGlzIGluY2x1ZGVkIGluTCB0aGlzIGJsb2NrIG9yIG5vdC4AOGZpbmFsaXplX2Jsb2NrAOUFBGggRmluaXNoIHRoZSBjdXJyZW50IGJsb2NrLgBMaW5oZXJlbnRfZXh0cmluc2ljcwQgaW5oZXJlbnT1CDEGBD0BIEdlbmVyYXRlIGluaGVyZW50IGV4dHJpbnNpY3MuIFRoZSBpbmhlcmVudCBkYXRhIHdpbGwgdmFyeSBmcm9tIGNoYWluIHRvIGNoYWluLgA8Y2hlY2tfaW5oZXJlbnRzCBRibG9ja+EFEGRhdGH1CAUJBFUBIENoZWNrIHRoYXQgdGhlIGluaGVyZW50cyBhcmUgdmFsaWQuIFRoZSBpbmhlcmVudCBkYXRhIHdpbGwgdmFyeSBmcm9tIGNoYWluIHRvIGNoYWluLgAEcQEgVGhlIGBCbG9ja0J1aWxkZXJgIGFwaSB0cmFpdCB0aGF0IHByb3ZpZGVzIHRoZSByZXF1aXJlZCBmdW5jdGlvbmFsaXR5IGZvciBidWlsZGluZyBhIGJsb2NrLhgAOEdlbmVzaXNCdWlsZGVyDCxidWlsZF9zdGF0ZQQQanNvbjgJCShlASBCdWlsZCBgUnVudGltZUdlbmVzaXNDb25maWdgIGZyb20gYSBKU09OIGJsb2Igbm90IHVzaW5nIGFueSBkZWZhdWx0cyBhbmQgc3RvcmUgaXQgaW4gdGhlJCBzdG9yYWdlLgApASBJbiB0aGUgY2FzZSBvZiBhIEZSQU1FLWJhc2VkIHJ1bnRpbWUsIHRoaXMgZnVuY3Rpb24gZGVzZXJpYWxpemVzIHRoZSBmdWxsVQEgYFJ1bnRpbWVHZW5lc2lzQ29uZmlnYCBmcm9tIHRoZSBnaXZlbiBKU09OIGJsb2IgYW5kIHB1dHMgaXQgaW50byB0aGUgc3RvcmFnZS4gSWYgdGhlVQEgcHJvdmlkZWQgSlNPTiBibG9iIGlzIGluY29ycmVjdCBvciBpbmNvbXBsZXRlIG9yIHRoZSBkZXNlcmlhbGl6YXRpb24gZmFpbHMsIGFuIGVycm9yNCBpcyByZXR1cm5lZC4AXQEgUGxlYXNlIG5vdGUgdGhhdCBwcm92aWRlZCBKU09OIGJsb2IgbXVzdCBjb250YWluIGFsbCBgUnVudGltZUdlbmVzaXNDb25maWdgIGZpZWxkcywgbm9cIGRlZmF1bHRzIHdpbGwgYmUgdXNlZC4AKGdldF9wcmVzZXQECGlkDQm9BjhhASBSZXR1cm5zIGEgSlNPTiBibG9iIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBidWlsdC1pbiBgUnVudGltZUdlbmVzaXNDb25maWdgIGlkZW50aWZpZWQgYnkYIGBpZGAuAFUBIElmIGBpZGAgaXMgYE5vbmVgIHRoZSBmdW5jdGlvbiBzaG91bGQgcmV0dXJuIEpTT04gYmxvYiByZXByZXNlbnRhdGlvbiBvZiB0aGUgZGVmYXVsdEkBIGBSdW50aW1lR2VuZXNpc0NvbmZpZ2Agc3RydWN0IG9mIHRoZSBydW50aW1lLiBJbXBsZW1lbnRhdGlvbiBtdXN0IHByb3ZpZGUgZGVmYXVsdGAgYFJ1bnRpbWVHZW5lc2lzQ29uZmlnYC4AIQEgT3RoZXJ3aXNlIGZ1bmN0aW9uIHJldHVybnMgYSBKU09OIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBidWlsdC1pbiwgbmFtZWRRASBgUnVudGltZUdlbmVzaXNDb25maWdgIHByZXNldCBpZGVudGlmaWVkIGJ5IGBpZGAsIG9yIGBOb25lYCBpZiBzdWNoIHByZXNldCBkb2VzIG5vdGEBIGV4aXN0LiBSZXR1cm5lZCBgVmVjPHU4PmAgY29udGFpbnMgYnl0ZXMgb2YgSlNPTiBibG9iIChwYXRjaCkgd2hpY2ggY29tcHJpc2VzIGEgbGlzdCBvZk0BIChwb3RlbnRpYWxseSBuZXN0ZWQpIGtleS12YWx1ZSBwYWlycyB0aGF0IGFyZSBpbnRlbmRlZCBmb3IgY3VzdG9taXppbmcgdGhlIGRlZmF1bHRlASBydW50aW1lIGdlbmVzaXMgY29uZmlnLiBUaGUgcGF0Y2ggc2hhbGwgYmUgbWVyZ2VkIChyZmM3Mzg2KSB3aXRoIHRoZSBKU09OIHJlcHJlc2VudGF0aW9uYQEgb2YgdGhlIGRlZmF1bHQgYFJ1bnRpbWVHZW5lc2lzQ29uZmlnYCB0byBjcmVhdGUgYSBjb21wcmVoZW5zaXZlIGdlbmVzaXMgY29uZmlnIHRoYXQgY2FuhCBiZSB1c2VkIGluIGBidWlsZF9zdGF0ZWAgbWV0aG9kLgAwcHJlc2V0X25hbWVzABEJEFEBIFJldHVybnMgYSBsaXN0IG9mIGlkZW50aWZpZXJzIGZvciBhdmFpbGFibGUgYnVpbHRpbiBgUnVudGltZUdlbmVzaXNDb25maWdgIHByZXNldHMuAGEBIFRoZSBwcmVzZXRzIGZyb20gdGhlIGxpc3QgY2FuIGJlIHF1ZXJpZWQgd2l0aCBbYEdlbmVzaXNCdWlsZGVyOjpnZXRfcHJlc2V0YF0gbWV0aG9kLiBJZgEBIG5vIG5hbWVkIHByZXNldHMgYXJlIHByb3ZpZGVkIGJ5IHRoZSBydW50aW1lIHRoZSBsaXN0IGlzIGVtcHR5LgAE8CBBUEkgdG8gaW50ZXJhY3Qgd2l0aCBgUnVudGltZUdlbmVzaXNDb25maWdgIGZvciB0aGUgcnVudGltZQQAWFRhZ2dlZFRyYW5zYWN0aW9uUXVldWUEUHZhbGlkYXRlX3RyYW5zYWN0aW9uDBhzb3VyY2UVCQh0eOkFKGJsb2NrX2hhc2g0GQkkaCBWYWxpZGF0ZSB0aGUgdHJhbnNhY3Rpb24uAGUBIFRoaXMgbWV0aG9kIGlzIGludm9rZWQgYnkgdGhlIHRyYW5zYWN0aW9uIHBvb2wgdG8gbGVhcm4gZGV0YWlscyBhYm91dCBnaXZlbiB0cmFuc2FjdGlvbi5FASBUaGUgaW1wbGVtZW50YXRpb24gc2hvdWxkIG1ha2Ugc3VyZSB0byB2ZXJpZnkgdGhlIGNvcnJlY3RuZXNzIG9mIHRoZSB0cmFuc2FjdGlvbk0BIGFnYWluc3QgY3VycmVudCBzdGF0ZS4gVGhlIGdpdmVuIGBibG9ja19oYXNoYCBjb3JyZXNwb25kcyB0byB0aGUgaGFzaCBvZiB0aGUgYmxvY2t8IHRoYXQgaXMgdXNlZCBhcyBjdXJyZW50IHN0YXRlLgBFASBOb3RlIHRoYXQgdGhpcyBjYWxsIG1heSBiZSBwZXJmb3JtZWQgYnkgdGhlIHBvb2wgbXVsdGlwbGUgdGltZXMgYW5kIHRyYW5zYWN0aW9uc6QgbWlnaHQgYmUgdmVyaWZpZWQgaW4gYW55IHBvc3NpYmxlIG9yZGVyLgAETQEgVGhlIGBUYWdnZWRUcmFuc2FjdGlvblF1ZXVlYCBhcGkgdHJhaXQgZm9yIGludGVyZmVyaW5nIHdpdGggdGhlIHRyYW5zYWN0aW9uIHF1ZXVlLgwARE9mZmNoYWluV29ya2VyQXBpBDxvZmZjaGFpbl93b3JrZXIEGGhlYWRlcuUFrATIIFN0YXJ0cyB0aGUgb2ZmLWNoYWluIHRhc2sgZm9yIGdpdmVuIGJsb2NrIGhlYWRlci4ABGQgVGhlIG9mZmNoYWluIHdvcmtlciBhcGkuCAAcQXVyYUFwaQg0c2xvdF9kdXJhdGlvbgAhCQyQIFJldHVybnMgdGhlIHNsb3QgZHVyYXRpb24gZm9yIEF1cmEuACUBIEN1cnJlbnRseSwgb25seSB0aGUgdmFsdWUgcHJvdmlkZWQgYnkgdGhpcyB0eXBlIGF0IGdlbmVzaXMgd2lsbCBiZSB1c2VkLgAsYXV0aG9yaXRpZXMA6QQEnCBSZXR1cm4gdGhlIGN1cnJlbnQgc2V0IG9mIGF1dGhvcml0aWVzLgAEuCBBUEkgbmVjZXNzYXJ5IGZvciBibG9jayBhdXRob3JzaGlwIHdpdGggYXVyYS4EACxTZXNzaW9uS2V5cwhUZ2VuZXJhdGVfc2Vzc2lvbl9rZXlzBBBzZWVkvQY4HBUBIEdlbmVyYXRlIGEgc2V0IG9mIHNlc3Npb24ga2V5cyB3aXRoIG9wdGlvbmFsbHkgdXNpbmcgdGhlIGdpdmVuIHNlZWQuCQEgVGhlIGtleXMgc2hvdWxkIGJlIHN0b3JlZCB3aXRoaW4gdGhlIGtleXN0b3JlIGV4cG9zZWQgdmlhIHJ1bnRpbWU8IGV4dGVybmFsaXRpZXMuALAgVGhlIHNlZWQgbmVlZHMgdG8gYmUgYSB2YWxpZCBgdXRmOGAgc3RyaW5nLgDQIFJldHVybnMgdGhlIGNvbmNhdGVuYXRlZCBTQ0FMRSBlbmNvZGVkIHB1YmxpYyBrZXlzLgBMZGVjb2RlX3Nlc3Npb25fa2V5cwQcZW5jb2RlZDglCQyYIERlY29kZSB0aGUgZ2l2ZW4gcHVibGljIHNlc3Npb24ga2V5cy4A3CBSZXR1cm5zIHRoZSBsaXN0IG9mIHB1YmxpYyByYXcgcHVibGljIGtleXMgKyBrZXkgdHlwZS4ABGggU2Vzc2lvbiBrZXlzIHJ1bnRpbWUgYXBpLgQAKEdyYW5kcGFBcGkQTGdyYW5kcGFfYXV0aG9yaXRpZXMAhBg9ASBHZXQgdGhlIGN1cnJlbnQgR1JBTkRQQSBhdXRob3JpdGllcyBhbmQgd2VpZ2h0cy4gVGhpcyBzaG91bGQgbm90IGNoYW5nZSBleGNlcHQdASBmb3Igd2hlbiBjaGFuZ2VzIGFyZSBzY2hlZHVsZWQgYW5kIHRoZSBjb3JyZXNwb25kaW5nIGRlbGF5IGhhcyBwYXNzZWQuADUBIFdoZW4gY2FsbGVkIGF0IGJsb2NrIEIsIGl0IHdpbGwgcmV0dXJuIHRoZSBzZXQgb2YgYXV0aG9yaXRpZXMgdGhhdCBzaG91bGQgYmU9ASB1c2VkIHRvIGZpbmFsaXplIGRlc2NlbmRhbnRzIG9mIHRoaXMgYmxvY2sgKEIrMSwgQisyLCAuLi4pLiBUaGUgYmxvY2sgQiBpdHNlbGbAIGlzIGZpbmFsaXplZCBieSB0aGUgYXV0aG9yaXRpZXMgZnJvbSBibG9jayBCLTEuALRzdWJtaXRfcmVwb3J0X2VxdWl2b2NhdGlvbl91bnNpZ25lZF9leHRyaW5zaWMISGVxdWl2b2NhdGlvbl9wcm9vZgUCPGtleV9vd25lcl9wcm9vZjUJOQkgEQEgU3VibWl0cyBhbiB1bnNpZ25lZCBleHRyaW5zaWMgdG8gcmVwb3J0IGFuIGVxdWl2b2NhdGlvbi4gVGhlIGNhbGxlcvggbXVzdCBwcm92aWRlIHRoZSBlcXVpdm9jYXRpb24gcHJvb2YgYW5kIGEga2V5IG93bmVyc2hpcCBwcm9vZvwgKHNob3VsZCBiZSBvYnRhaW5lZCB1c2luZyBgZ2VuZXJhdGVfa2V5X293bmVyc2hpcF9wcm9vZmApLiBUaGUFASBleHRyaW5zaWMgd2lsbCBiZSB1bnNpZ25lZCBhbmQgc2hvdWxkIG9ubHkgYmUgYWNjZXB0ZWQgZm9yIGxvY2FsFQEgYXV0aG9yc2hpcCAobm90IHRvIGJlIGJyb2FkY2FzdCB0byB0aGUgbmV0d29yaykuIFRoaXMgbWV0aG9kIHJldHVybnMJASBgTm9uZWAgd2hlbiBjcmVhdGlvbiBvZiB0aGUgZXh0cmluc2ljIGZhaWxzLCBlLmcuIGlmIGVxdWl2b2NhdGlvbgUBIHJlcG9ydGluZyBpcyBkaXNhYmxlZCBmb3IgdGhlIGdpdmVuIHJ1bnRpbWUgKGkuZS4gdGhpcyBtZXRob2QgaXMFASBoYXJkY29kZWQgdG8gcmV0dXJuIGBOb25lYCkuIE9ubHkgdXNlZnVsIGluIGFuIG9mZmNoYWluIGNvbnRleHQuAHBnZW5lcmF0ZV9rZXlfb3duZXJzaGlwX3Byb29mCBhzZXRfaWQYMGF1dGhvcml0eV9pZIw9CSwJASBHZW5lcmF0ZXMgYSBwcm9vZiBvZiBrZXkgb3duZXJzaGlwIGZvciB0aGUgZ2l2ZW4gYXV0aG9yaXR5IGluIHRoZfwgZ2l2ZW4gc2V0LiBBbiBleGFtcGxlIHVzYWdlIG9mIHRoaXMgbW9kdWxlIGlzIGNvdXBsZWQgd2l0aCB0aGUFASBzZXNzaW9uIGhpc3RvcmljYWwgbW9kdWxlIHRvIHByb3ZlIHRoYXQgYSBnaXZlbiBhdXRob3JpdHkga2V5IGlzDQEgdGllZCB0byBhIGdpdmVuIHN0YWtpbmcgaWRlbnRpdHkgZHVyaW5nIGEgc3BlY2lmaWMgc2Vzc2lvbi4gUHJvb2ZzEQEgb2Yga2V5IG93bmVyc2hpcCBhcmUgbmVjZXNzYXJ5IGZvciBzdWJtaXR0aW5nIGVxdWl2b2NhdGlvbiByZXBvcnRzLhEBIE5PVEU6IGV2ZW4gdGhvdWdoIHRoZSBBUEkgdGFrZXMgYSBgc2V0X2lkYCBhcyBwYXJhbWV0ZXIgdGhlIGN1cnJlbnT8IGltcGxlbWVudGF0aW9ucyBpZ25vcmUgdGhpcyBwYXJhbWV0ZXIgYW5kIGluc3RlYWQgcmVseSBvbiB0aGlzDQEgbWV0aG9kIGJlaW5nIGNhbGxlZCBhdCB0aGUgY29ycmVjdCBibG9jayBoZWlnaHQsIGkuZS4gYW55IHBvaW50IGF0FQEgd2hpY2ggdGhlIGdpdmVuIHNldCBpZCBpcyBsaXZlIG9uLWNoYWluLiBGdXR1cmUgaW1wbGVtZW50YXRpb25zIHdpbGwNASBpbnN0ZWFkIHVzZSBpbmRleGVkIGRhdGEgdGhyb3VnaCBhbiBvZmZjaGFpbiB3b3JrZXIsIG5vdCByZXF1aXJpbmd4IG9sZGVyIHN0YXRlcyB0byBiZSBhdmFpbGFibGUuADhjdXJyZW50X3NldF9pZAAYBJggR2V0IGN1cnJlbnQgR1JBTkRQQSBhdXRob3JpdHkgc2V0IGlkLgAkAQEgQVBJcyBmb3IgaW50ZWdyYXRpbmcgdGhlIEdSQU5EUEEgZmluYWxpdHkgZ2FkZ2V0IGludG8gcnVudGltZXMuwCBUaGlzIHNob3VsZCBiZSBpbXBsZW1lbnRlZCBvbiB0aGUgcnVudGltZSBzaWRlLgAVASBUaGlzIGlzIHByaW1hcmlseSB1c2VkIGZvciBuZWdvdGlhdGluZyBhdXRob3JpdHktc2V0IGNoYW5nZXMgZm9yIHRoZQ0BIGdhZGdldC4gR1JBTkRQQSB1c2VzIGEgc2lnbmFsaW5nIG1vZGVsIG9mIGNoYW5naW5nIGF1dGhvcml0eSBzZXRzOjEBIGNoYW5nZXMgc2hvdWxkIGJlIHNpZ25hbGVkIHdpdGggYSBkZWxheSBvZiBOIGJsb2NrcywgYW5kIHRoZW4gYXV0b21hdGljYWxseeQgYXBwbGllZCBpbiB0aGUgcnVudGltZSBhZnRlciB0aG9zZSBOIGJsb2NrcyBoYXZlIHBhc3NlZC4A/CBUaGUgY29uc2Vuc3VzIHByb3RvY29sIHdpbGwgY29vcmRpbmF0ZSB0aGUgaGFuZG9mZiBleHRlcm5hbGx5LgwAPEFjY291bnROb25jZUFwaQQ0YWNjb3VudF9ub25jZQQcYWNjb3VudAAQBMAgR2V0IGN1cnJlbnQgYWNjb3VudCBub25jZSBvZiBnaXZlbiBgQWNjb3VudElkYC4ABIAgVGhlIEFQSSB0byBxdWVyeSBhY2NvdW50IG5vbmNlLgQAVFRyYW5zYWN0aW9uUGF5bWVudEFwaRAocXVlcnlfaW5mbwgMdXh06QUMbGVuEEEJAABEcXVlcnlfZmVlX2RldGFpbHMIDHV4dOkFDGxlbhBFCQAATHF1ZXJ5X3dlaWdodF90b19mZWUEGHdlaWdodCwYAABMcXVlcnlfbGVuZ3RoX3RvX2ZlZQQYbGVuZ3RoEBgAAAAQAGRUcmFuc2FjdGlvblBheW1lbnRDYWxsQXBpEDxxdWVyeV9jYWxsX2luZm8IEGNhbGz5AQxsZW4QQQkESQEgUXVlcnkgaW5mb3JtYXRpb24gb2YgYSBkaXNwYXRjaCBjbGFzcywgd2VpZ2h0LCBhbmQgZmVlIG9mIGEgZ2l2ZW4gZW5jb2RlZCBgQ2FsbGAuAFhxdWVyeV9jYWxsX2ZlZV9kZXRhaWxzCBBjYWxs+QEMbGVuEEUJBLQgUXVlcnkgZmVlIGRldGFpbHMgb2YgYSBnaXZlbiBlbmNvZGVkIGBDYWxsYC4ATHF1ZXJ5X3dlaWdodF90b19mZWUEGHdlaWdodCwYBAEBIFF1ZXJ5IHRoZSBvdXRwdXQgb2YgdGhlIGN1cnJlbnQgYFdlaWdodFRvRmVlYCBnaXZlbiBzb21lIGlucHV0LgBMcXVlcnlfbGVuZ3RoX3RvX2ZlZQQYbGVuZ3RoEBgEAQEgUXVlcnkgdGhlIG91dHB1dCBvZiB0aGUgY3VycmVudCBgTGVuZ3RoVG9GZWVgIGdpdmVuIHNvbWUgaW5wdXQuAAAMAFRFdGhlcmV1bVJ1bnRpbWVSUENBcGlEIGNoYWluX2lkABgEtCBSZXR1cm5zIHJ1bnRpbWUgZGVmaW5lZCBwYWxsZXRfZXZtOjpDaGFpbklkLgA0YWNjb3VudF9iYXNpYwQcYWRkcmVzc8RRCQSkIFJldHVybnMgcGFsbGV0X2V2bTo6QWNjb3VudHMgYnkgYWRkcmVzcy4AJGdhc19wcmljZQBZAQSUIFJldHVybnMgRml4ZWRHYXNQcmljZTo6bWluX2dhc19wcmljZQA8YWNjb3VudF9jb2RlX2F0BBxhZGRyZXNzxDgE/CBGb3IgYSBnaXZlbiBhY2NvdW50IGFkZHJlc3MsIHJldHVybnMgcGFsbGV0X2V2bTo6QWNjb3VudENvZGVzLgAYYXV0aG9yAMQE8CBSZXR1cm5zIHRoZSBjb252ZXJ0ZWQgRmluZEF1dGhvcjo6ZmluZF9hdXRob3IgYXV0aG9yaXR5IGlkLgAoc3RvcmFnZV9hdAgcYWRkcmVzc8QUaW5kZXhZATQEMQEgRm9yIGEgZ2l2ZW4gYWNjb3VudCBhZGRyZXNzIGFuZCBpbmRleCwgcmV0dXJucyBwYWxsZXRfZXZtOjpBY2NvdW50U3RvcmFnZXMuABBjYWxsLBBmcm9txAh0b8QQZGF0YTgUdmFsdWVZASRnYXNfbGltaXRZATxtYXhfZmVlX3Blcl9nYXNxBWBtYXhfcHJpb3JpdHlfZmVlX3Blcl9nYXNxBRRub25jZXEFIGVzdGltYXRlJCxhY2Nlc3NfbGlzdFUJSGF1dGhvcml6YXRpb25fbGlzdFkJXQkAABhjcmVhdGUoEGZyb23EEGRhdGE4FHZhbHVlWQEkZ2FzX2xpbWl0WQE8bWF4X2ZlZV9wZXJfZ2FzcQVgbWF4X3ByaW9yaXR5X2ZlZV9wZXJfZ2FzcQUUbm9uY2VxBSBlc3RpbWF0ZSQsYWNjZXNzX2xpc3RVCUhhdXRob3JpemF0aW9uX2xpc3RZCXUJAAA0Y3VycmVudF9ibG9jawB9CQRoIFJldHVybiB0aGUgY3VycmVudCBibG9jay4AQGN1cnJlbnRfcmVjZWlwdHMAgQkEcCBSZXR1cm4gdGhlIGN1cnJlbnQgcmVjZWlwdC4AcGN1cnJlbnRfdHJhbnNhY3Rpb25fc3RhdHVzZXMAhQkEnCBSZXR1cm4gdGhlIGN1cnJlbnQgdHJhbnNhY3Rpb24gc3RhdHVzLgAsY3VycmVudF9hbGwAiQkAAEBleHRyaW5zaWNfZmlsdGVyBAx4dHMxBiUIBDUBIFJlY2VpdmVzIGEgYFZlYzxPcGFxdWVFeHRyaW5zaWM+YCBhbmQgZmlsdGVycyBhbGwgdGhlIGV0aGVyZXVtIHRyYW5zYWN0aW9ucy4AKGVsYXN0aWNpdHkAjQkEiCBSZXR1cm4gdGhlIGVsYXN0aWNpdHkgbXVsdGlwbGllci4AcGdhc19saW1pdF9tdWx0aXBsaWVyX3N1cHBvcnQArAh1ASBVc2VkIHRvIGRldGVybWluZSBpZiBnYXMgbGltaXQgbXVsdGlwbGllciBmb3Igbm9uLXRyYW5zYWN0aW9uYWwgY2FsbHMgKGV0aF9jYWxsL2VzdGltYXRlR2FzKTggaXMgc3VwcG9ydGVkLgA0cGVuZGluZ19ibG9jawQMeHRzMQaRCQRoIFJldHVybiB0aGUgcGVuZGluZyBibG9jay4AYGluaXRpYWxpemVfcGVuZGluZ19ibG9jawQYaGVhZGVy5QWsFHggSW5pdGlhbGl6ZSB0aGUgcGVuZGluZyBibG9jay41ASBUaGUgYmVoYXZpb3Igc2hvdWxkIGJlIHRoZSBzYW1lIGFzIHRoZSBydW50aW1lIGFwaSBDb3JlX2luaXRpYWxpemVfYmxvY2sgYnV0XCBmb3IgYSAicGVuZGluZyIgYmxvY2suYQEgSWYgeW91ciBwcm9qZWN0IGRvbid0IG5lZWQgdG8gaGF2ZSBhIGRpZmZlcmVudCBiZWhhdmlvciB0byBpbml0aWFsaXplICJwZW5kaW5nIiBibG9ja3Ms4CB5b3UgY2FuIGNvcHkgeW91ciBDb3JlX2luaXRpYWxpemVfYmxvY2sgaW1wbGVtZW50YXRpb24uAATAIEFQSSBuZWNlc3NhcnkgZm9yIEV0aGVyZXVtLWNvbXBhdGliaWxpdHkgbGF5ZXIuGABwQ29udmVydFRyYW5zYWN0aW9uUnVudGltZUFwaQRMY29udmVydF90cmFuc2FjdGlvbgQsdHJhbnNhY3Rpb241BekFAAAACAAwQ29udHJhY3RzQXBpEBBjYWxsGBhvcmlnaW4AEGRlc3QAFHZhbHVlGCRnYXNfbGltaXSdAVRzdG9yYWdlX2RlcG9zaXRfbGltaXR9AihpbnB1dF9kYXRhOJUJDPQgUGVyZm9ybSBhIGNhbGwgZnJvbSBhIHNwZWNpZmllZCBhY2NvdW50IHRvIGEgZ2l2ZW4gY29udHJhY3QuAIggU2VlIFtgY3JhdGU6OlBhbGxldDo6YmFyZV9jYWxsYF0uACxpbnN0YW50aWF0ZRwYb3JpZ2luABR2YWx1ZRgkZ2FzX2xpbWl0nQFUc3RvcmFnZV9kZXBvc2l0X2xpbWl0fQIQY29kZbEJEGRhdGE4EHNhbHQ4tQkMcCBJbnN0YW50aWF0ZSBhIG5ldyBjb250cmFjdC4ApCBTZWUgYFtjcmF0ZTo6UGFsbGV0OjpiYXJlX2luc3RhbnRpYXRlXWAuACx1cGxvYWRfY29kZRAYb3JpZ2luABBjb2RlOFRzdG9yYWdlX2RlcG9zaXRfbGltaXR9AixkZXRlcm1pbmlzbc0FwQkM6CBVcGxvYWQgbmV3IGNvZGUgd2l0aG91dCBpbnN0YW50aWF0aW5nIGEgY29udHJhY3QgZnJvbSBpdC4ApCBTZWUgW2BjcmF0ZTo6UGFsbGV0OjpiYXJlX3VwbG9hZF9jb2RlYF0uACxnZXRfc3RvcmFnZQgcYWRkcmVzcwAMa2V5OMkJFLwgUXVlcnkgYSBnaXZlbiBzdG9yYWdlIGtleSBpbiBhIGdpdmVuIGNvbnRyYWN0LgBNASBSZXR1cm5zIGBPayhTb21lKFZlYzx1OD4pKWAgaWYgdGhlIHN0b3JhZ2UgdmFsdWUgZXhpc3RzIHVuZGVyIHRoZSBnaXZlbiBrZXkgaW4gdGhlYQEgc3BlY2lmaWVkIGFjY291bnQgYW5kIGBPayhOb25lKWAgaWYgaXQgZG9lc24ndC4gSWYgdGhlIGFjY291bnQgc3BlY2lmaWVkIGJ5IHRoZSBhZGRyZXNzCQEgZG9lc24ndCBleGlzdCwgb3IgZG9lc24ndCBoYXZlIGEgY29udHJhY3QgdGhlbiBgRXJyYCBpcyByZXR1cm5lZC4ABLwgVGhlIEFQSSB1c2VkIHRvIGRyeS1ydW4gY29udHJhY3QgaW50ZXJhY3Rpb25zLggAWERlbGVnYXRlSW5mb1J1bnRpbWVBcGkMNGdldF9kZWxlZ2F0ZXMA0QkAADBnZXRfZGVsZWdhdGUEQGRlbGVnYXRlX2FjY291bnQA6QkAADRnZXRfZGVsZWdhdGVkBERkZWxlZ2F0ZWVfYWNjb3VudADtCQAAAAQAUE5ldXJvbkluZm9SdW50aW1lQXBpECxnZXRfbmV1cm9ucwQYbmV0dWlkoP0JAAAoZ2V0X25ldXJvbggYbmV0dWlkoAx1aWSgDQoAAEBnZXRfbmV1cm9uc19saXRlBBhuZXR1aWSgEQoAADxnZXRfbmV1cm9uX2xpdGUIGG5ldHVpZKAMdWlkoBkKAAAABABQU3VibmV0SW5mb1J1bnRpbWVBcGlEPGdldF9zdWJuZXRfaW5mbwQYbmV0dWlkoB0KAABAZ2V0X3N1Ym5ldHNfaW5mbwAtCgAASGdldF9zdWJuZXRfaW5mb192MgQYbmV0dWlkoDEKAABMZ2V0X3N1Ym5ldHNfaW5mb192MgA5CgAAWGdldF9zdWJuZXRfaHlwZXJwYXJhbXMEGG5ldHVpZKA9CgAAZGdldF9zdWJuZXRfaHlwZXJwYXJhbXNfdjIEGG5ldHVpZKBFCgAAUGdldF9hbGxfZHluYW1pY19pbmZvAFEKAABIZ2V0X2FsbF9tZXRhZ3JhcGhzAGkKAAA0Z2V0X21ldGFncmFwaAQYbmV0dWlkoG0KAABMZ2V0X2FsbF9tZWNoYWdyYXBocwBpCgAAOGdldF9tZWNoYWdyYXBoCBhuZXR1aWSgFG1lY2lkCG0KAABAZ2V0X2R5bmFtaWNfaW5mbwQYbmV0dWlkoFUKAABAZ2V0X3N1Ym5ldF9zdGF0ZQQYbmV0dWlkoJUKAABcZ2V0X3NlbGVjdGl2ZV9tZXRhZ3JhcGgIGG5ldHVpZKBEbWV0YWdyYXBoX2luZGV4ZXNNAqEKAAB0Z2V0X2NvbGRrZXlfYXV0b19zdGFrZV9ob3RrZXkIHGNvbGRrZXkAGG5ldHVpZKDoAABgZ2V0X3NlbGVjdGl2ZV9tZWNoYWdyYXBoDBhuZXR1aWSgFHN1YmlkCERtZXRhZ3JhcGhfaW5kZXhlc00CoQoAAExnZXRfc3VibmV0X3RvX3BydW5lAG0CAAAABABMU3Rha2VJbmZvUnVudGltZUFwaRBoZ2V0X3N0YWtlX2luZm9fZm9yX2NvbGRrZXkEPGNvbGRrZXlfYWNjb3VudAD9CgAAbGdldF9zdGFrZV9pbmZvX2Zvcl9jb2xka2V5cwRAY29sZGtleV9hY2NvdW50c0ECBQsAAKBnZXRfc3Rha2VfaW5mb19mb3JfaG90a2V5X2NvbGRrZXlfbmV0dWlkDDhob3RrZXlfYWNjb3VudAA8Y29sZGtleV9hY2NvdW50ABhuZXR1aWSgDQsAADRnZXRfc3Rha2VfZmVlFBhvcmlnaW4RC1hvcmlnaW5fY29sZGtleV9hY2NvdW50ACxkZXN0aW5hdGlvbhELbGRlc3RpbmF0aW9uX2NvbGRrZXlfYWNjb3VudAAYYW1vdW50GBgAAAAEAHBTdWJuZXRSZWdpc3RyYXRpb25SdW50aW1lQXBpBHRnZXRfbmV0d29ya19yZWdpc3RyYXRpb25fY29zdAAYAAAABAAcQmFiZUFwaRg0Y29uZmlndXJhdGlvbgAVCwSMIFJldHVybiB0aGUgY29uZmlndXJhdGlvbiBmb3IgQkFCRS4ATGN1cnJlbnRfZXBvY2hfc3RhcnQAOQYExCBSZXR1cm5zIHRoZSBzbG90IHRoYXQgc3RhcnRlZCB0aGUgY3VycmVudCBlcG9jaC4ANGN1cnJlbnRfZXBvY2gALQsExCBSZXR1cm5zIGluZm9ybWF0aW9uIHJlZ2FyZGluZyB0aGUgY3VycmVudCBlcG9jaC4AKG5leHRfZXBvY2gALQsIAQEgUmV0dXJucyBpbmZvcm1hdGlvbiByZWdhcmRpbmcgdGhlIG5leHQgZXBvY2ggKHdoaWNoIHdhcyBhbHJlYWR5XCBwcmV2aW91c2x5IGFubm91bmNlZCkuAHBnZW5lcmF0ZV9rZXlfb3duZXJzaGlwX3Byb29mCBBzbG90OQYwYXV0aG9yaXR5X2lkJQs1CywJASBHZW5lcmF0ZXMgYSBwcm9vZiBvZiBrZXkgb3duZXJzaGlwIGZvciB0aGUgZ2l2ZW4gYXV0aG9yaXR5IGluIHRoZQ0BIGN1cnJlbnQgZXBvY2guIEFuIGV4YW1wbGUgdXNhZ2Ugb2YgdGhpcyBtb2R1bGUgaXMgY291cGxlZCB3aXRoIHRoZQUBIHNlc3Npb24gaGlzdG9yaWNhbCBtb2R1bGUgdG8gcHJvdmUgdGhhdCBhIGdpdmVuIGF1dGhvcml0eSBrZXkgaXMNASB0aWVkIHRvIGEgZ2l2ZW4gc3Rha2luZyBpZGVudGl0eSBkdXJpbmcgYSBzcGVjaWZpYyBzZXNzaW9uLiBQcm9vZnMRASBvZiBrZXkgb3duZXJzaGlwIGFyZSBuZWNlc3NhcnkgZm9yIHN1Ym1pdHRpbmcgZXF1aXZvY2F0aW9uIHJlcG9ydHMuCQEgTk9URTogZXZlbiB0aG91Z2ggdGhlIEFQSSB0YWtlcyBhIGBzbG90YCBhcyBwYXJhbWV0ZXIgdGhlIGN1cnJlbnQJASBpbXBsZW1lbnRhdGlvbnMgaWdub3JlcyB0aGlzIHBhcmFtZXRlciBhbmQgaW5zdGVhZCByZWxpZXMgb24gdGhpcw0BIG1ldGhvZCBiZWluZyBjYWxsZWQgYXQgdGhlIGNvcnJlY3QgYmxvY2sgaGVpZ2h0LCBpLmUuIGFueSBwb2ludCBhdPAgd2hpY2ggdGhlIGVwb2NoIGZvciB0aGUgZ2l2ZW4gc2xvdCBpcyBsaXZlIG9uLWNoYWluLiBGdXR1cmUJASBpbXBsZW1lbnRhdGlvbnMgd2lsbCBpbnN0ZWFkIHVzZSBpbmRleGVkIGRhdGEgdGhyb3VnaCBhbiBvZmZjaGFpbtAgd29ya2VyLCBub3QgcmVxdWlyaW5nIG9sZGVyIHN0YXRlcyB0byBiZSBhdmFpbGFibGUuALRzdWJtaXRfcmVwb3J0X2VxdWl2b2NhdGlvbl91bnNpZ25lZF9leHRyaW5zaWMISGVxdWl2b2NhdGlvbl9wcm9vZj0LPGtleV9vd25lcl9wcm9vZjkLOQkgEQEgU3VibWl0cyBhbiB1bnNpZ25lZCBleHRyaW5zaWMgdG8gcmVwb3J0IGFuIGVxdWl2b2NhdGlvbi4gVGhlIGNhbGxlcvggbXVzdCBwcm92aWRlIHRoZSBlcXVpdm9jYXRpb24gcHJvb2YgYW5kIGEga2V5IG93bmVyc2hpcCBwcm9vZvwgKHNob3VsZCBiZSBvYnRhaW5lZCB1c2luZyBgZ2VuZXJhdGVfa2V5X293bmVyc2hpcF9wcm9vZmApLiBUaGUFASBleHRyaW5zaWMgd2lsbCBiZSB1bnNpZ25lZCBhbmQgc2hvdWxkIG9ubHkgYmUgYWNjZXB0ZWQgZm9yIGxvY2FsFQEgYXV0aG9yc2hpcCAobm90IHRvIGJlIGJyb2FkY2FzdCB0byB0aGUgbmV0d29yaykuIFRoaXMgbWV0aG9kIHJldHVybnMJASBgTm9uZWAgd2hlbiBjcmVhdGlvbiBvZiB0aGUgZXh0cmluc2ljIGZhaWxzLCBlLmcuIGlmIGVxdWl2b2NhdGlvbgUBIHJlcG9ydGluZyBpcyBkaXNhYmxlZCBmb3IgdGhlIGdpdmVuIHJ1bnRpbWUgKGkuZS4gdGhpcyBtZXRob2QgaXMFASBoYXJkY29kZWQgdG8gcmV0dXJuIGBOb25lYCkuIE9ubHkgdXNlZnVsIGluIGFuIG9mZmNoYWluIGNvbnRleHQuAAS4IEFQSSBuZWNlc3NhcnkgZm9yIGJsb2NrIGF1dGhvcnNoaXAgd2l0aCBCQUJFLggAOFN3YXBSdW50aW1lQXBpEExjdXJyZW50X2FscGhhX3ByaWNlBBhuZXR1aWSgGAAAXGN1cnJlbnRfYWxwaGFfcHJpY2VfYWxsAEELAABYc2ltX3N3YXBfdGFvX2Zvcl9hbHBoYQgYbmV0dWlkoAx0YW8YSQsAAFhzaW1fc3dhcF9hbHBoYV9mb3JfdGFvCBhuZXR1aWSgFGFscGhhGEkLAAAABAD5AVRNCwA="; +var devnet_metadata_default = binMeta; +export { + devnet_metadata_default as default +}; diff --git a/contract-tests/.papi/descriptors/dist/devnet_metadata.d.ts b/contract-tests/.papi/descriptors/dist/devnet_metadata.d.ts new file mode 100644 index 0000000000..e54c947520 --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/devnet_metadata.d.ts @@ -0,0 +1,2 @@ +declare const binMeta: string; +export default binMeta; diff --git a/contract-tests/.papi/descriptors/dist/index.d.ts b/contract-tests/.papi/descriptors/dist/index.d.ts new file mode 100644 index 0000000000..2eb940c203 --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/index.d.ts @@ -0,0 +1,6 @@ +import { default as devnet } from "./devnet"; +export { devnet }; +export type * from "./devnet"; +export { DigestItem, Phase, DispatchClass, TokenError, ArithmeticError, TransactionalError, GrandpaEvent, BalanceStatus, TransactionPaymentEvent, PreimageEvent, GrandpaStoredState, BalancesTypesReasons, PreimagePalletHoldReason, TransactionPaymentReleases, PreimageOldRequestStatus, PreimageRequestStatus, PreimagesBounded, GrandpaEquivocation, MultiAddress, BalancesAdjustmentDirection, MultiSigner, MultiSignature, TransactionValidityUnknownTransaction, TransactionValidityTransactionSource, BabeAllowedSlots } from './common-types'; +export declare const getMetadata: (codeHash: string) => Promise; +export * as contracts from './contracts'; diff --git a/contract-tests/.papi/descriptors/dist/index.js b/contract-tests/.papi/descriptors/dist/index.js new file mode 100644 index 0000000000..3ffecd8693 --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/index.js @@ -0,0 +1,194 @@ +"use strict"; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __esm = (fn, res) => function __init() { + return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; +}; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// .papi/descriptors/src/descriptors.ts +var descriptors_exports = {}; +__export(descriptors_exports, { + Devnet: () => Devnet +}); +var minified, commonTrees, tokens, replaceTokens, tokenizedCommonTrees, unwrap, getChainDescriptors, Devnet; +var init_descriptors = __esm({ + ".papi/descriptors/src/descriptors.ts"() { + "use strict"; + [minified, commonTrees, tokens] = JSON.parse(`[{"devnet":{"storage":{"2":{"0":0,"1":4,"ExtrinsicCount":1,"InherentsApplied":2,"BlockWeight":3,"AllExtrinsicsLen":1,"ExtrinsicData":5,"Number":1,"ParentHash":6,"Digest":7,"Events":8,"EventCount":1,"EventTopics":9,"LastRuntimeUpgrade":10,"UpgradedToU32RefCount":2,"UpgradedToTripleRefCount":2,"ExecutionPhase":11,"AuthorizedUpgrade":12,"ExtrinsicWeightReclaimed":13},"3":{"RandomMaterial":33},"4":{"Now":34,"DidUpdate":2},"6":{"5":33,"CurrentSlot":34},"7":{"5":40,"State":36,"PendingChange":37,"NextForced":1,"Stalled":38,"CurrentSetId":34,"SetIdSession":39},"9":{"0":44,"8":34,"InactiveIssuance":34,"Locks":45,"Reserves":46,"Holds":47,"Freezes":48},"10":{"NextFeeMultiplier":34,"StorageVersion":66},"17":{"8":34,"11":86,"12":86,"13":86,"14":86,"15":112,"16":117,"MinActivityCutoff":1,"AdminFreezeWindow":1,"OwnerHyperparamRateLimit":1,"DissolveNetworkScheduleDuration":1,"LastHotkeySwapOnNetuid":68,"NextStakeJobId":34,"TaoWeight":34,"CKBurn":34,"MaxDelegateTake":1,"MinDelegateTake":1,"MaxChildkeyTake":1,"MinChildkeyTake":1,"Owner":69,"Delegates":70,"ChildkeyTake":71,"PendingChildKeys":72,"ChildKeys":73,"ParentKeys":73,"AlphaDividendsPerSubnet":68,"RootAlphaDividendsPerSubnet":68,"BlockEmission":34,"LastHotkeyEmissionOnNetuid":74,"SubnetLimit":1,"TotalStake":34,"SubnetMovingAlpha":34,"SubnetMovingPrice":75,"RootProp":75,"SubnetVolume":75,"SubnetTAO":75,"SubnetTaoProvided":75,"SubnetAlphaInEmission":75,"SubnetAlphaOutEmission":75,"SubnetTaoInEmission":75,"SubnetAlphaIn":75,"SubnetAlphaInProvided":75,"SubnetAlphaOut":75,"StakingHotkeys":76,"OwnedHotkeys":76,"AutoStakeDestination":77,"AutoStakeDestinationColdkeys":78,"ColdkeySwapAnnouncementDelay":1,"ColdkeySwapReannouncementDelay":1,"ColdkeySwapAnnouncements":79,"ColdkeySwapDisputes":70,"TotalHotkeyAlpha":74,"TotalHotkeyAlphaLastEpoch":74,"TotalHotkeyShares":74,"Alpha":80,"AlphaMapLastKey":81,"TokenSymbol":5,"SubnetTaoFlow":75,"SubnetEmaTaoFlow":82,"TaoFlowCutoff":34,"FlowNormExponent":34,"FlowEmaSmoothingFactor":34,"UsedWork":83,"MaxRegistrationsPerBlock":84,"TotalNetworks":1,"NetworkImmunityPeriod":34,"StartCallDelay":34,"NetworkMinLockCost":34,"NetworkLastLockCost":34,"NetworkLockReductionInterval":34,"SubnetOwnerCut":1,"NetworkRateLimit":34,"NominatorMinRequiredStake":34,"WeightsVersionKeyRateLimit":34,"LastRateLimitedBlock":85,"SubnetLocked":75,"LargestLocked":75,"Tempo":84,"FirstEmissionBlockNumber":75,"SubnetMechanism":84,"SubnetworkN":84,"NetworksAdded":86,"IsNetworkMember":87,"NetworkRegistrationAllowed":86,"NetworkPowRegistrationAllowed":86,"NetworkRegisteredAt":75,"PendingServerEmission":75,"PendingValidatorEmission":75,"PendingRootAlphaDivs":75,"PendingOwnerCut":75,"BlocksSinceLastStep":75,"LastMechansimStepBlock":75,"SubnetOwner":88,"SubnetOwnerHotkey":88,"RecycleOrBurn":89,"ServingRateLimit":75,"Rho":84,"AlphaSigmoidSteepness":84,"Kappa":84,"RegistrationsThisInterval":84,"POWRegistrationsThisInterval":84,"BurnRegistrationsThisInterval":84,"MinAllowedUids":84,"MaxAllowedUids":84,"ImmunityPeriod":84,"ActivityCutoff":84,"MaxWeightsLimit":84,"WeightsVersionKey":75,"MinAllowedWeights":84,"MaxAllowedValidators":84,"AdjustmentInterval":84,"BondsMovingAverage":75,"BondsPenalty":84,"BondsResetOn":86,"WeightsSetRateLimit":75,"ValidatorPruneLen":75,"ScalingLawPower":84,"TargetRegistrationsPerInterval":84,"AdjustmentAlpha":75,"CommitRevealWeightsEnabled":86,"Burn":75,"Difficulty":75,"MinBurn":75,"MaxBurn":75,"MinDifficulty":75,"MaxDifficulty":75,"LastAdjustmentBlock":75,"RegistrationsThisBlock":84,"EMAPriceHalvingBlocks":75,"RAORecycledForRegistration":75,"TxRateLimit":34,"TxDelegateTakeRateLimit":34,"TxChildkeyTakeRateLimit":34,"AlphaValues":90,"SubtokenEnabled":86,"VotingPower":68,"VotingPowerDisableAtBlock":75,"VotingPowerEmaAlpha":75,"ImmuneOwnerUidsLimit":84,"StakeWeight":91,"Uids":92,"Keys":93,"LoadedEmission":94,"Active":95,"Rank":91,"Trust":91,"Consensus":91,"Incentive":91,"Dividends":91,"Emission":96,"LastUpdate":96,"ValidatorTrust":91,"PruningScores":91,"ValidatorPermit":95,"Weights":97,"Bonds":97,"BlockAtRegistration":98,"Axons":99,"NeuronCertificates":100,"Prometheus":101,"IdentitiesV2":102,"SubnetIdentitiesV3":103,"TransactionKeyLastBlock":104,"LastTxBlock":105,"LastTxBlockChildKeyTake":105,"LastTxBlockDelegateTake":105,"StakeThreshold":34,"WeightCommits":106,"TimelockedWeightCommits":107,"CRV3WeightCommits":108,"CRV3WeightCommitsV2":107,"RevealPeriodEpochs":75,"LastColdkeyHotkeyStakeBlock":109,"StakingOperationRateLimiter":110,"RootClaimableThreshold":75,"RootClaimable":111,"RootClaimType":113,"StakingColdkeysByIndex":114,"StakingColdkeys":105,"NumStakingColdkeys":34,"NumRootClaim":34,"AssociatedEvmAddress":115,"SubnetLeases":116,"SubnetLeaseShares":68,"SubnetUidToLeaseId":84,"NextSubnetLeaseId":1,"AccumulatedLeaseDividends":75,"CommitRevealWeightsVersion":1,"NetworkRegistrationStartBlock":34,"MinNonImmuneUids":84,"MaxMechanismCount":1,"MechanismCountCurrent":84,"MechanismEmissionSplit":91,"PendingChildKeyCooldown":34},"18":0,"19":{"Key":228},"20":{"Multisigs":234},"21":{"StatusFor":245,"RequestStatusFor":246,"PreimageFor":247},"22":{"IncompleteSince":1,"Agenda":252,"Retries":253,"Lookup":254},"23":{"Proxies":269,"Announcements":270,"LastCallResult":271},"24":{"IdentityOf":286},"25":{"TimelockedIndex":289,"CommitmentOf":290,"LastCommitment":92,"LastBondsReset":92,"RevealedCommitments":291,"UsedSpaceOf":292,"MaxSpace":1},"26":{"PrecompileEnable":297},"27":{"EnteredUntil":1,"Deposits":74},"28":{"1":371,"Pending":367,"CounterForPending":1,"CurrentBlock":368,"CurrentReceipts":369,"CurrentTransactionStatuses":370},"29":{"AccountCodes":374,"AccountCodesMetadata":375,"AccountStorages":376,"WhitelistedCreators":377,"DisableWhitelistCheck":2},"30":{"ChainId":34},"31":{"BaseFeePerGas":386,"Elasticity":1},"32":{"16":117,"BeaconConfig":391,"Pulses":392,"LastStoredRound":34,"OldestStoredRound":34,"NextUnsignedAt":1},"33":{"16":117,"Crowdloans":397,"NextCrowdloanId":1,"Contributions":68,"CurrentCrowdloanId":1},"34":{"FeeRate":84,"FeeGlobalTao":75,"FeeGlobalAlpha":75,"Ticks":411,"SwapV3Initialized":86,"AlphaSqrtPrice":75,"CurrentTick":84,"CurrentLiquidity":75,"EnabledUserLiquidity":86,"Positions":412,"LastPositionId":34,"TickIndexBitmapWords":413,"ScrapReservoirTao":75,"ScrapReservoirAlpha":75},"35":{"PristineCode":423,"CodeInfoOf":424,"Nonce":34,"ContractInfoOf":425,"DeletionQueue":5,"DeletionQueueCounter":426,"MigrationInProgress":427},"36":{"CurrentKey":427,"NextKey":427,"Submissions":447,"KeyHashByBlock":4}},"tx":{"2":{"37":20,"remark":18,"set_heap_pages":19,"set_code_without_checks":20,"set_storage":21,"kill_storage":22,"kill_prefix":23,"remark_with_event":18,"authorize_upgrade":24,"authorize_upgrade_without_checks":24,"apply_authorized_upgrade":20},"3":0,"4":{"set":35},"6":0,"7":{"report_equivocation":41,"report_equivocation_unsigned":41,"note_stalled":42},"9":{"transfer_allow_death":49,"force_transfer":50,"transfer_keep_alive":49,"transfer_all":51,"force_unreserve":52,"upgrade_accounts":53,"force_set_balance":54,"force_adjust_total_issuance":55,"burn":56},"10":0,"17":{"38":146,"set_weights":118,"set_mechanism_weights":119,"batch_set_weights":120,"commit_weights":121,"commit_mechanism_weights":122,"batch_commit_weights":123,"reveal_weights":124,"reveal_mechanism_weights":125,"commit_crv3_mechanism_weights":126,"batch_reveal_weights":127,"decrease_take":128,"increase_take":128,"add_stake":129,"remove_stake":130,"serve_axon":131,"serve_axon_tls":132,"serve_prometheus":133,"register":134,"root_register":135,"burned_register":136,"swap_hotkey":137,"swap_coldkey":138,"set_childkey_take":139,"sudo_set_tx_childkey_take_rate_limit":140,"sudo_set_min_childkey_take":141,"sudo_set_max_childkey_take":141,"register_network":135,"faucet":142,"dissolve_network":143,"set_children":144,"schedule_swap_coldkey":145,"set_subnet_identity":147,"register_network_with_identity":148,"unstake_all":135,"unstake_all_alpha":135,"move_stake":149,"transfer_stake":150,"swap_stake":151,"add_stake_limit":152,"remove_stake_limit":153,"swap_stake_limit":154,"try_associate_hotkey":135,"start_call":155,"associate_evm_key":156,"recycle_alpha":157,"burn_alpha":157,"set_pending_childkey_cooldown":158,"remove_stake_full_limit":159,"register_leased_network":160,"terminate_lease":161,"update_symbol":162,"commit_timelocked_weights":163,"set_coldkey_auto_stake_hotkey":136,"commit_timelocked_mechanism_weights":164,"root_dissolve_network":155,"claim_root":165,"set_root_claim_type":166,"sudo_set_num_root_claims":167,"sudo_set_root_claim_threshold":168,"announce_coldkey_swap":169,"swap_coldkey_announced":145,"dispute_coldkey_swap":170,"reset_coldkey_swap":171,"enable_voting_power_tracking":155,"disable_voting_power_tracking":155,"sudo_set_voting_power_ema_alpha":172,"add_stake_burn":173},"18":{"batch":219,"as_derivative":220,"batch_all":219,"dispatch_as":221,"force_batch":219,"with_weight":222,"if_else":223,"dispatch_as_fallible":221},"19":{"sudo":229,"sudo_unchecked_weight":222,"set_key":230,"sudo_as":231,"remove_key":170},"20":{"39":239,"as_multi_threshold_1":235,"as_multi":236,"approve_as_multi":237,"cancel_as_multi":238},"21":{"note_preimage":248,"unnote_preimage":249,"request_preimage":249,"unrequest_preimage":249,"ensure_updated":250},"22":{"schedule":255,"cancel":256,"schedule_named":257,"cancel_named":258,"schedule_after":259,"schedule_named_after":260,"set_retry":261,"set_retry_named":262,"cancel_retry":263,"cancel_retry_named":258},"23":{"39":170,"proxy":274,"add_proxy":275,"remove_proxy":275,"remove_proxies":170,"create_pure":276,"kill_pure":277,"announce":278,"remove_announcement":278,"reject_announcement":279,"proxy_announced":280},"24":{"38":287,"clear_identity":288},"25":{"set_commitment":293,"set_max_space":294},"26":{"swap_authorities":298,"sudo_set_default_take":299,"sudo_set_tx_rate_limit":140,"sudo_set_serving_rate_limit":300,"sudo_set_min_difficulty":301,"sudo_set_max_difficulty":302,"sudo_set_weights_version_key":303,"sudo_set_weights_set_rate_limit":304,"sudo_set_adjustment_interval":305,"sudo_set_adjustment_alpha":306,"sudo_set_immunity_period":307,"sudo_set_min_allowed_weights":308,"sudo_set_max_allowed_uids":309,"sudo_set_kappa":310,"sudo_set_rho":311,"sudo_set_activity_cutoff":312,"sudo_set_network_registration_allowed":313,"sudo_set_network_pow_registration_allowed":313,"sudo_set_target_registrations_per_interval":314,"sudo_set_min_burn":315,"sudo_set_max_burn":316,"sudo_set_difficulty":317,"sudo_set_max_allowed_validators":318,"sudo_set_bonds_moving_average":319,"sudo_set_bonds_penalty":320,"sudo_set_max_registrations_per_block":321,"sudo_set_subnet_owner_cut":322,"sudo_set_network_rate_limit":323,"sudo_set_tempo":324,"sudo_set_total_issuance":325,"sudo_set_network_immunity_period":326,"sudo_set_network_min_lock_cost":327,"sudo_set_subnet_limit":328,"sudo_set_lock_reduction_interval":329,"sudo_set_rao_recycled":330,"sudo_set_stake_threshold":331,"sudo_set_nominator_min_required_stake":331,"sudo_set_tx_delegate_take_rate_limit":140,"sudo_set_min_delegate_take":141,"sudo_set_commit_reveal_weights_enabled":332,"sudo_set_liquid_alpha_enabled":332,"sudo_set_alpha_values":333,"sudo_set_dissolve_network_schedule_duration":334,"sudo_set_commit_reveal_weights_interval":335,"sudo_set_evm_chain_id":336,"schedule_grandpa_change":337,"sudo_set_toggle_transfer":338,"sudo_set_recycle_or_burn":339,"sudo_toggle_evm_precompile":340,"sudo_set_subnet_moving_alpha":341,"sudo_set_subnet_owner_hotkey":136,"sudo_set_ema_price_halving_period":342,"sudo_set_alpha_sigmoid_steepness":343,"sudo_set_yuma3_enabled":332,"sudo_set_bonds_reset_enabled":332,"sudo_set_sn_owner_hotkey":136,"sudo_set_subtoken_enabled":344,"sudo_set_commit_reveal_version":345,"sudo_set_owner_immune_neuron_limit":346,"sudo_set_ck_burn":347,"sudo_set_admin_freeze_window":348,"sudo_set_owner_hparam_rate_limit":349,"sudo_set_mechanism_count":350,"sudo_set_mechanism_emission_split":351,"sudo_trim_to_max_allowed_uids":352,"sudo_set_min_allowed_uids":353,"sudo_set_tao_flow_cutoff":354,"sudo_set_tao_flow_normalization_exponent":355,"sudo_set_tao_flow_smoothing_factor":356,"sudo_set_max_mechanism_count":357,"sudo_set_min_non_immune_uids":358,"sudo_set_start_call_delay":359,"sudo_set_coldkey_swap_announcement_delay":334,"sudo_set_coldkey_swap_reannouncement_delay":334},"27":{"enter":170,"force_enter":170,"extend":170,"force_extend":170,"force_exit":170,"force_slash_deposit":364,"release_deposit":364,"force_release_deposit":364},"28":{"transact":372},"29":{"40":378,"41":379,"42":380,"create2":381,"set_whitelist":382,"disable_whitelist":383},"30":0,"31":{"set_base_fee_per_gas":387,"set_elasticity":388},"32":{"write_pulse":393,"set_beacon_config":394,"set_oldest_stored_round":395},"33":{"40":401,"42":399,"contribute":400,"finalize":401,"refund":401,"dissolve":401,"update_min_contribution":402,"update_end":403,"update_cap":404},"34":{"set_fee_rate":414,"toggle_user_liquidity":415,"add_liquidity":416,"remove_liquidity":417,"modify_position":418,"disable_lp":170},"35":{"37":434,"41":435,"43":433,"44":437,"call_old_weight":430,"instantiate_with_code_old_weight":431,"instantiate_old_weight":432,"remove_code":24,"instantiate_with_code":436,"migrate":438},"36":{"announce_next_key":448,"submit_encrypted":449,"mark_decryption_failed":450}},"events":{"2":{"ExtrinsicSuccess":25,"ExtrinsicFailed":26,"CodeUpdated":27,"NewAccount":28,"KilledAccount":28,"Remarked":29,"UpgradeAuthorized":30,"RejectedInvalidAuthorizedUpgrade":31},"3":0,"4":0,"6":0,"7":{"NewAuthorities":43,"Paused":27,"Resumed":27},"9":{"Endowed":57,"DustLost":58,"Transfer":59,"BalanceSet":60,"Reserved":61,"Unreserved":61,"ReserveRepatriated":62,"Deposit":61,"Withdraw":61,"Slashed":61,"Minted":61,"Burned":61,"Suspended":61,"Restored":61,"Upgraded":63,"Issued":64,"Rescinded":64,"Locked":61,"Unlocked":61,"Frozen":61,"Thawed":61,"TotalIssuanceForced":65},"10":{"TransactionFeePaid":67},"17":{"11":181,"14":214,"15":191,"45":186,"46":27,"NetworkAdded":174,"NetworkRemoved":175,"StakeAdded":176,"StakeRemoved":176,"StakeMoved":177,"WeightsSet":174,"NeuronRegistered":178,"BulkNeuronsRegistered":174,"BulkBalancesSet":174,"MaxAllowedUidsSet":174,"MaxWeightLimitSet":174,"DifficultySet":179,"AdjustmentIntervalSet":174,"RegistrationPerIntervalSet":174,"MaxRegistrationsPerBlockSet":174,"ActivityCutoffSet":174,"RhoSet":174,"AlphaSigmoidSteepnessSet":180,"KappaSet":174,"MinAllowedWeightSet":174,"ValidatorPruneLenSet":179,"ScalingLawPowerSet":174,"WeightsSetRateLimitSet":179,"ImmunityPeriodSet":174,"BondsMovingAverageSet":179,"BondsPenaltySet":174,"BondsResetOnSet":181,"MaxAllowedValidatorsSet":174,"AxonServed":182,"PrometheusServed":182,"DelegateAdded":183,"DefaultTakeSet":175,"WeightsVersionKeySet":179,"MinDifficultySet":179,"MaxDifficultySet":179,"ServingRateLimitSet":179,"BurnSet":179,"MaxBurnSet":179,"MinBurnSet":179,"TxRateLimitSet":184,"TxDelegateTakeRateLimitSet":184,"TxChildKeyTakeRateLimitSet":184,"AdminFreezeWindowSet":175,"OwnerHyperparamRateLimitSet":175,"MinChildKeyTakeSet":175,"MaxChildKeyTakeSet":175,"ChildKeyTakeSet":185,"RegistrationAllowed":181,"PowRegistrationAllowed":181,"TempoSet":174,"RAORecycledForRegistrationSet":179,"StakeThresholdSet":184,"AdjustmentAlphaSet":179,"Faucet":187,"SubnetOwnerCutSet":175,"NetworkRateLimitSet":184,"NetworkImmunityPeriodSet":184,"StartCallDelaySet":184,"NetworkMinLockCostSet":184,"SubnetLimitSet":175,"NetworkLockCostReductionIntervalSet":184,"TakeDecreased":183,"TakeIncreased":183,"HotkeySwapped":188,"MaxDelegateTakeSet":175,"MinDelegateTakeSet":175,"ColdkeySwapAnnounced":189,"ColdkeySwapReset":63,"ColdkeySwapped":190,"ColdkeySwapDisputed":191,"AllBalanceUnstakedAndTransferredToNewColdkey":192,"ArbitrationPeriodExtended":191,"SetChildrenScheduled":193,"SetChildren":194,"ChainIdentitySet":195,"SubnetIdentitySet":175,"SubnetIdentityRemoved":175,"DissolveNetworkScheduled":196,"ColdkeySwapAnnouncementDelaySet":175,"ColdkeySwapReannouncementDelaySet":175,"DissolveNetworkScheduleDurationSet":175,"CRV3WeightsCommitted":197,"WeightsCommitted":197,"WeightsRevealed":197,"WeightsBatchRevealed":198,"BatchWeightsCompleted":199,"BatchWeightItemFailed":200,"StakeTransferred":201,"StakeSwapped":202,"SubnetOwnerHotkeySet":182,"FirstEmissionBlockNumberSet":179,"AlphaRecycled":203,"AlphaBurned":203,"EvmKeyAssociated":204,"CRV3WeightsRevealed":182,"CommitRevealPeriodsSet":179,"CommitRevealEnabled":181,"HotkeySwappedOnSubnet":205,"SubnetLeaseCreated":206,"SubnetLeaseTerminated":207,"SymbolUpdated":208,"CommitRevealVersionSet":175,"TimelockedWeightsCommitted":209,"TimelockedWeightsRevealed":182,"AutoStakeAdded":210,"IncentiveAlphaEmittedToMiners":211,"MinAllowedUidsSet":174,"AutoStakeDestinationSet":212,"MinNonImmuneUidsSet":174,"RootClaimTypeSet":213,"VotingPowerTrackingDisableScheduled":215,"VotingPowerTrackingDisabled":214,"VotingPowerEmaAlphaSet":216,"SubnetLeaseDividendsDistributed":217,"AddStakeBurn":218},"18":{"46":27,"BatchInterrupted":224,"BatchCompleted":27,"ItemCompleted":27,"ItemFailed":225,"DispatchedAs":226,"IfElseMainSuccess":27,"IfElseFallbackCalled":227},"19":{"45":232,"KeyChanged":233,"KeyRemoved":27,"SudoAsDone":232},"20":{"47":244,"NewMultisig":240,"MultisigApproval":241,"MultisigExecuted":242,"MultisigCancelled":243},"21":{"Noted":251,"Requested":251,"Cleared":251},"22":{"Scheduled":264,"Canceled":264,"Dispatched":265,"RetrySet":266,"RetryCancelled":267,"CallUnavailable":267,"PeriodicFailed":267,"RetryFailed":267,"PermanentlyOverweight":267,"AgendaIncomplete":268},"23":{"47":285,"ProxyExecuted":226,"PureCreated":281,"PureKilled":282,"Announced":283,"ProxyAdded":284,"ProxyRemoved":284},"24":{"IdentitySet":63,"IdentityDissolved":63},"25":{"Commitment":295,"TimelockCommitment":296,"CommitmentRevealed":295},"26":{"PrecompileUpdated":360,"Yuma3EnableToggled":361,"BondsResetToggled":361},"27":{"Entered":365,"Extended":365,"Exited":366,"DepositPlaced":58,"DepositReleased":58,"DepositSlashed":58,"CannotDeposit":27,"CannotRelease":27},"28":{"48":373},"29":{"48":385,"49":385,"Log":384,"CreatedFailed":385,"ExecutedFailed":385},"30":0,"31":{"NewBaseFeePerGas":389,"BaseFeeOverflow":27,"NewElasticity":390},"32":{"BeaconConfigChanged":27,"NewPulse":396,"SetOldestStoredRound":184},"33":{"49":405,"Contributed":406,"Withdrew":406,"PartiallyRefunded":407,"AllRefunded":407,"Finalized":407,"Dissolved":407,"MinContributionUpdated":408,"EndUpdated":409,"CapUpdated":410},"34":{"FeeRateSet":419,"UserLiquidityToggled":420,"LiquidityAdded":421,"LiquidityRemoved":422,"LiquidityModified":422},"35":{"Instantiated":439,"Terminated":440,"CodeStored":441,"ContractEmitted":442,"CodeRemoved":443,"ContractCodeUpdated":444,"Called":445,"DelegateCalled":446,"StorageDepositTransferredAndHeld":59,"StorageDepositTransferredAndReleased":59},"36":{"EncryptedSubmitted":451,"DecryptedExecuted":452,"DecryptedRejected":453,"DecryptionFailed":454}},"constants":{"2":{"BlockWeights":14,"BlockLength":15,"BlockHashCount":1,"DbWeight":16,"Version":17,"SS58Prefix":1},"3":0,"4":{"MinimumPeriod":34},"6":{"SlotDuration":34},"7":{"MaxAuthorities":1,"MaxNominators":1,"MaxSetIdSessionEntries":34},"9":{"ExistentialDeposit":34,"MaxLocks":1,"MaxReserves":1,"MaxFreezes":1},"10":{"OperationalFeeMultiplier":1},"17":{"12":2,"13":2,"InitialIssuance":34,"InitialMinAllowedWeights":1,"InitialEmissionValue":1,"InitialTempo":1,"InitialDifficulty":34,"InitialMaxDifficulty":34,"InitialMinDifficulty":34,"InitialRAORecycledForRegistration":34,"InitialBurn":34,"InitialMaxBurn":34,"InitialMinBurn":34,"MinBurnUpperBound":34,"MaxBurnLowerBound":34,"InitialAdjustmentInterval":1,"InitialBondsMovingAverage":34,"InitialBondsPenalty":1,"InitialBondsResetOn":2,"InitialTargetRegistrationsPerInterval":1,"InitialRho":1,"InitialAlphaSigmoidSteepness":1,"InitialKappa":1,"InitialMinAllowedUids":1,"InitialMaxAllowedUids":1,"InitialValidatorPruneLen":34,"InitialScalingLawPower":1,"InitialImmunityPeriod":1,"InitialActivityCutoff":1,"InitialMaxRegistrationsPerBlock":1,"InitialPruningScore":1,"InitialMaxAllowedValidators":1,"InitialDefaultDelegateTake":1,"InitialMinDelegateTake":1,"InitialDefaultChildKeyTake":1,"InitialMinChildKeyTake":1,"InitialMaxChildKeyTake":1,"InitialWeightsVersionKey":34,"InitialServingRateLimit":34,"InitialTxRateLimit":34,"InitialTxDelegateTakeRateLimit":34,"InitialTxChildKeyTakeRateLimit":34,"InitialAdjustmentAlpha":34,"InitialNetworkImmunityPeriod":34,"InitialNetworkMinLockCost":34,"InitialSubnetOwnerCut":1,"InitialNetworkLockReductionInterval":34,"InitialNetworkRateLimit":34,"KeySwapCost":34,"AlphaHigh":1,"AlphaLow":1,"InitialColdkeySwapAnnouncementDelay":1,"InitialColdkeySwapReannouncementDelay":1,"InitialDissolveNetworkScheduleDuration":1,"InitialTaoWeight":34,"InitialEmaPriceHalvingPeriod":34,"InitialStartCallDelay":34,"KeySwapOnSubnetCost":34,"HotkeySwapOnSubnetInterval":34,"LeaseDividendsDistributionInterval":1,"MaxImmuneUidsPercentage":1},"18":{"batched_calls_limit":1},"19":0,"20":{"DepositBase":34,"DepositFactor":34,"MaxSignatories":1},"21":0,"22":{"MaximumWeight":13,"MaxScheduledPerBlock":1},"23":{"ProxyDepositBase":34,"ProxyDepositFactor":34,"MaxProxies":1,"MaxPending":1,"AnnouncementDepositBase":34,"AnnouncementDepositFactor":34},"24":{"50":34,"51":34,"MaxAdditionalFields":1},"25":{"50":34,"51":34,"MaxFields":1},"26":0,"27":{"EnterDuration":1,"ExtendDuration":1,"EnterDepositAmount":362,"ExtendDepositAmount":362,"ReleaseDelay":363},"28":0,"29":0,"30":0,"31":0,"32":{"UnsignedPriority":34,"HttpFetchTimeout":34},"33":{"PalletId":398,"MinimumDeposit":34,"AbsoluteMinimumContribution":34,"MinimumBlockDuration":1,"MaximumBlockDuration":1,"RefundContributorsLimit":1,"MaxContributors":1},"34":{"ProtocolId":398,"MaxFeeRate":1,"MaxPositions":1,"MinimumLiquidity":34,"MinimumReserve":34},"35":{"Schedule":428,"DepositPerByte":34,"DefaultDepositLimit":34,"DepositPerItem":34,"CodeHashLockupDepositPercent":1,"MaxCodeLen":1,"MaxStorageKeyLen":1,"MaxTransientStorageSize":1,"MaxDelegateDependencies":1,"UnsafeUnstableInterface":2,"MaxDebugBufferLen":1,"Environment":429,"ApiVersion":1},"36":0},"viewFns":{"2":0,"3":0,"4":0,"6":0,"7":0,"9":0,"10":0,"17":0,"18":0,"19":0,"20":0,"21":0,"22":0,"23":{"check_permissions":272,"is_superset":273},"24":0,"25":0,"26":0,"27":0,"28":0,"29":0,"30":0,"31":0,"32":0,"33":0,"34":0,"35":0,"36":0},"apis":{"Core":{"version":455,"execute_block":456,"initialize_block":457},"Metadata":{"metadata":458,"metadata_at_version":459,"metadata_versions":460},"BlockBuilder":{"apply_extrinsic":461,"finalize_block":462,"inherent_extrinsics":463,"check_inherents":464},"GenesisBuilder":{"build_state":465,"get_preset":466,"preset_names":467},"TaggedTransactionQueue":{"validate_transaction":468},"OffchainWorkerApi":{"offchain_worker":469},"AuraApi":{"slot_duration":470,"authorities":471},"SessionKeys":{"generate_session_keys":472,"decode_session_keys":473},"GrandpaApi":{"52":475,"53":476,"grandpa_authorities":474,"current_set_id":470},"AccountNonceApi":{"account_nonce":477},"TransactionPaymentApi":{"54":480,"55":481,"query_info":478,"query_fee_details":479},"TransactionPaymentCallApi":{"54":480,"55":481,"query_call_info":482,"query_call_fee_details":483},"EthereumRuntimeRPCApi":{"41":489,"42":490,"chain_id":470,"account_basic":484,"gas_price":485,"account_code_at":486,"author":487,"storage_at":488,"current_block":491,"current_receipts":492,"current_transaction_statuses":493,"current_all":494,"extrinsic_filter":495,"elasticity":496,"gas_limit_multiplier_support":497,"pending_block":498,"initialize_pending_block":469},"ConvertTransactionRuntimeApi":{"convert_transaction":499},"ContractsApi":{"41":500,"43":502,"44":501,"get_storage":503},"DelegateInfoRuntimeApi":{"get_delegates":504,"get_delegate":505,"get_delegated":506},"NeuronInfoRuntimeApi":{"get_neurons":507,"get_neuron":508,"get_neurons_lite":509,"get_neuron_lite":510},"SubnetInfoRuntimeApi":{"get_subnet_info":511,"get_subnets_info":512,"get_subnet_info_v2":513,"get_subnets_info_v2":514,"get_subnet_hyperparams":515,"get_subnet_hyperparams_v2":516,"get_all_dynamic_info":517,"get_all_metagraphs":518,"get_metagraph":519,"get_all_mechagraphs":518,"get_mechagraph":520,"get_dynamic_info":521,"get_subnet_state":522,"get_selective_metagraph":523,"get_coldkey_auto_stake_hotkey":524,"get_selective_mechagraph":525,"get_subnet_to_prune":496},"StakeInfoRuntimeApi":{"get_stake_info_for_coldkey":526,"get_stake_info_for_coldkeys":527,"get_stake_info_for_hotkey_coldkey_netuid":528,"get_stake_fee":529},"SubnetRegistrationRuntimeApi":{"get_network_registration_cost":470},"BabeApi":{"52":533,"53":532,"configuration":530,"current_epoch_start":470,"current_epoch":531,"next_epoch":531},"SwapRuntimeApi":{"current_alpha_price":534,"current_alpha_price_all":535,"sim_swap_tao_for_alpha":536,"sim_swap_alpha_for_tao":537}}}},[{}],["Account","BlockHash","System","RandomnessCollectiveFlip","Timestamp","Authorities","Aura","Grandpa","TotalIssuance","Balances","TransactionPayment","TransferToggle","LiquidAlphaOn","Yuma3On","VotingPowerTrackingEnabled","RootClaimed","HasMigrationRun","SubtensorModule","Utility","Sudo","Multisig","Preimage","Scheduler","Proxy","Registry","Commitments","AdminUtils","SafeMode","Ethereum","EVM","EVMChainId","BaseFee","Drand","Crowdloan","Swap","Contracts","MevShield","set_code","set_identity","poke_deposit","withdraw","call","create","upload_code","instantiate","Sudid","BatchCompletedWithErrors","DepositPoked","Executed","Created","InitialDeposit","FieldDeposit","submit_report_equivocation_unsigned_extrinsic","generate_key_ownership_proof","query_weight_to_fee","query_length_to_fee"]]`); + replaceTokens = (obj) => Object.fromEntries( + Object.entries(obj).map(([key, value]) => { + const unwrappedValue = typeof value === "object" ? replaceTokens(value) : value; + const numericKey = Number(key); + if (Number.isNaN(numericKey)) { + return [key, unwrappedValue]; + } + return [tokens[numericKey], unwrappedValue]; + }) + ); + tokenizedCommonTrees = commonTrees.map(replaceTokens); + unwrap = (obj, depth) => depth === 0 ? obj : Object.fromEntries( + Object.entries(obj).map(([key, value]) => [ + key, + unwrap( + typeof value === "object" ? value : tokenizedCommonTrees[value], + depth - 1 + ) + ]) + ); + getChainDescriptors = (key) => unwrap(replaceTokens(minified[key]), 2); + Devnet = getChainDescriptors("devnet"); + } +}); + +// .papi/descriptors/src/metadataTypes.ts +var metadataTypes_exports = {}; +__export(metadataTypes_exports, { + default: () => metadataTypes_default +}); +var content, metadataTypes_default; +var init_metadataTypes = __esm({ + ".papi/descriptors/src/metadataTypes.ts"() { + "use strict"; + content = "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"; + metadataTypes_default = content; + } +}); + +// .papi/descriptors/src/devnet_metadata.ts +var devnet_metadata_exports = {}; +__export(devnet_metadata_exports, { + default: () => devnet_metadata_default +}); +var binMeta, devnet_metadata_default; +var init_devnet_metadata = __esm({ + ".papi/descriptors/src/devnet_metadata.ts"() { + "use strict"; + binMeta = "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"; + devnet_metadata_default = binMeta; + } +}); + +// .papi/descriptors/src/index.ts +var index_exports = {}; +__export(index_exports, { + ArithmeticError: () => ArithmeticError, + BabeAllowedSlots: () => BabeAllowedSlots, + BalanceStatus: () => BalanceStatus, + BalancesAdjustmentDirection: () => BalancesAdjustmentDirection, + BalancesTypesReasons: () => BalancesTypesReasons, + DigestItem: () => DigestItem, + DispatchClass: () => DispatchClass, + GrandpaEquivocation: () => GrandpaEquivocation, + GrandpaEvent: () => GrandpaEvent, + GrandpaStoredState: () => GrandpaStoredState, + MultiAddress: () => MultiAddress, + MultiSignature: () => MultiSignature, + MultiSigner: () => MultiSigner, + Phase: () => Phase, + PreimageEvent: () => PreimageEvent, + PreimageOldRequestStatus: () => PreimageOldRequestStatus, + PreimagePalletHoldReason: () => PreimagePalletHoldReason, + PreimageRequestStatus: () => PreimageRequestStatus, + PreimagesBounded: () => PreimagesBounded, + TokenError: () => TokenError, + TransactionPaymentEvent: () => TransactionPaymentEvent, + TransactionPaymentReleases: () => TransactionPaymentReleases, + TransactionValidityTransactionSource: () => TransactionValidityTransactionSource, + TransactionValidityUnknownTransaction: () => TransactionValidityUnknownTransaction, + TransactionalError: () => TransactionalError, + contracts: () => contracts_exports, + devnet: () => devnet_default, + getMetadata: () => getMetadata2 +}); +module.exports = __toCommonJS(index_exports); + +// .papi/descriptors/src/common.ts +var table = new Uint8Array(128); +for (let i = 0; i < 64; i++) table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i; +var toBinary = (base64) => { + const n = base64.length, bytes = new Uint8Array((n - Number(base64[n - 1] === "=") - Number(base64[n - 2] === "=")) * 3 / 4 | 0); + for (let i2 = 0, j = 0; i2 < n; ) { + const c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)]; + const c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)]; + bytes[j++] = c0 << 2 | c1 >> 4; + bytes[j++] = c1 << 4 | c2 >> 2; + bytes[j++] = c2 << 6 | c3; + } + return bytes; +}; + +// .papi/descriptors/src/devnet.ts +var descriptorValues = Promise.resolve().then(() => (init_descriptors(), descriptors_exports)).then((module2) => module2["Devnet"]); +var metadataTypes = Promise.resolve().then(() => (init_metadataTypes(), metadataTypes_exports)).then( + (module2) => toBinary("default" in module2 ? module2.default : module2) +); +var asset = {}; +var extensions = {}; +var getMetadata = () => Promise.resolve().then(() => (init_devnet_metadata(), devnet_metadata_exports)).then( + (module2) => toBinary("default" in module2 ? module2.default : module2) +); +var genesis = "0x56c04ae0094e08e671ff781eb7122ffca041a55d208befc4603bd441b44e8e3a"; +var _allDescriptors = { descriptors: descriptorValues, metadataTypes, asset, extensions, getMetadata, genesis }; +var devnet_default = _allDescriptors; + +// .papi/descriptors/src/common-types.ts +var import_polkadot_api = require("polkadot-api"); +var DigestItem = import_polkadot_api._Enum; +var Phase = import_polkadot_api._Enum; +var DispatchClass = import_polkadot_api._Enum; +var TokenError = import_polkadot_api._Enum; +var ArithmeticError = import_polkadot_api._Enum; +var TransactionalError = import_polkadot_api._Enum; +var GrandpaEvent = import_polkadot_api._Enum; +var BalanceStatus = import_polkadot_api._Enum; +var TransactionPaymentEvent = import_polkadot_api._Enum; +var PreimageEvent = import_polkadot_api._Enum; +var GrandpaStoredState = import_polkadot_api._Enum; +var BalancesTypesReasons = import_polkadot_api._Enum; +var PreimagePalletHoldReason = import_polkadot_api._Enum; +var TransactionPaymentReleases = import_polkadot_api._Enum; +var PreimageOldRequestStatus = import_polkadot_api._Enum; +var PreimageRequestStatus = import_polkadot_api._Enum; +var PreimagesBounded = import_polkadot_api._Enum; +var GrandpaEquivocation = import_polkadot_api._Enum; +var MultiAddress = import_polkadot_api._Enum; +var BalancesAdjustmentDirection = import_polkadot_api._Enum; +var MultiSigner = import_polkadot_api._Enum; +var MultiSignature = import_polkadot_api._Enum; +var TransactionValidityUnknownTransaction = import_polkadot_api._Enum; +var TransactionValidityTransactionSource = import_polkadot_api._Enum; +var BabeAllowedSlots = import_polkadot_api._Enum; + +// .papi/descriptors/src/contracts/index.ts +var contracts_exports = {}; +__export(contracts_exports, { + bittensor: () => descriptor +}); + +// .papi/descriptors/src/contracts/bittensor.ts +var descriptor = { metadata: { "source": { "hash": "0xd15a29edfb7134dface2e0b6c704c173d47d3b48f1afc87193922ff8114e457d", "language": "ink! 5.1.1", "compiler": "rustc 1.89.0", "build_info": { "build_mode": "Release", "cargo_contract_version": "5.0.3", "rust_toolchain": "stable-aarch64-apple-darwin", "wasm_opt_settings": { "keep_debug_symbols": false, "optimization_passes": "Z" } } }, "contract": { "name": "bittensor", "version": "0.1.0", "authors": ["[your_name] <[your_email]>"] }, "image": null, "spec": { "constructors": [{ "args": [], "default": false, "docs": ["Constructor"], "label": "new", "payable": false, "returnType": { "displayName": ["ink_primitives", "ConstructorResult"], "type": 1 }, "selector": "0x9bae9d5e" }, { "args": [], "default": false, "docs": ["Constructor"], "label": "default", "payable": false, "returnType": { "displayName": ["ink_primitives", "ConstructorResult"], "type": 1 }, "selector": "0xed4b9d1b" }], "docs": [], "environment": { "accountId": { "displayName": ["AccountId"], "type": 11 }, "balance": { "displayName": ["Balance"], "type": 14 }, "blockNumber": { "displayName": ["BlockNumber"], "type": 24 }, "chainExtension": { "displayName": ["ChainExtension"], "type": 25 }, "hash": { "displayName": ["Hash"], "type": 23 }, "maxEventTopics": 4, "staticBufferSize": 16384, "timestamp": { "displayName": ["Timestamp"], "type": 14 } }, "events": [], "lang_error": { "displayName": ["ink", "LangError"], "type": 3 }, "messages": [{ "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "coldkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }], "default": false, "docs": [], "label": "get_stake_info_for_hotkey_coldkey_netuid", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 7 }, "selector": "0x5b73b8b9" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "add_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3a656e31" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "remove_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x7758d434" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "unstake_all", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3f525cc7" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "unstake_all_alpha", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xab74c422" }, { "args": [{ "label": "origin_hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "destination_hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "move_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xa06b0c55" }, { "args": [{ "label": "destination_coldkey", "type": { "displayName": [], "type": 4 } }, { "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "transfer_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3528ef5e" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "swap_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x04f7ca30" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "add_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x30013b98" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "remove_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xc3ce39c8" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "swap_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x212ef7ad" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "remove_stake_full_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xa6d6ea64" }, { "args": [{ "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "set_coldkey_auto_stake_hotkey", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xe24f0d8a" }, { "args": [{ "label": "delegate", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "add_proxy", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x528b6757" }, { "args": [{ "label": "delegate", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "remove_proxy", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x129d4f75" }, { "args": [{ "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }], "default": false, "docs": [], "label": "get_alpha_price", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 21 }, "selector": "0x08adc2e2" }] }, "storage": { "root": { "layout": { "struct": { "fields": [], "name": "Bittensor" } }, "root_key": "0x00000000", "ty": 0 } }, "types": [{ "id": 0, "type": { "def": { "composite": {} }, "path": ["bittensor", "bittensor", "Bittensor"] } }, { "id": 1, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 2 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 2 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 2, "type": { "def": { "tuple": [] } } }, { "id": 3, "type": { "def": { "variant": { "variants": [{ "index": 1, "name": "CouldNotReadInput" }] } }, "path": ["ink_primitives", "LangError"] } }, { "id": 4, "type": { "def": { "array": { "len": 32, "type": 5 } } } }, { "id": 5, "type": { "def": { "primitive": "u8" } } }, { "id": 6, "type": { "def": { "primitive": "u16" } } }, { "id": 7, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 8 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 8 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 8, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 9 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 9 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 9, "type": { "def": { "variant": { "variants": [{ "index": 0, "name": "None" }, { "fields": [{ "type": 10 }], "index": 1, "name": "Some" }] } }, "params": [{ "name": "T", "type": 10 }], "path": ["Option"] } }, { "id": 10, "type": { "def": { "composite": { "fields": [{ "name": "hotkey", "type": 11, "typeName": "AccountId" }, { "name": "coldkey", "type": 11, "typeName": "AccountId" }, { "name": "netuid", "type": 12, "typeName": "Compact" }, { "name": "stake", "type": 13, "typeName": "Compact" }, { "name": "locked", "type": 15, "typeName": "Compact" }, { "name": "emission", "type": 13, "typeName": "Compact" }, { "name": "tao_emission", "type": 16, "typeName": "Compact" }, { "name": "drain", "type": 15, "typeName": "Compact" }, { "name": "is_registered", "type": 17, "typeName": "bool" }] } }, "params": [{ "name": "AccountId", "type": 11 }], "path": ["bittensor", "StakeInfo"] } }, { "id": 11, "type": { "def": { "composite": { "fields": [{ "type": 4, "typeName": "[u8; 32]" }] } }, "path": ["ink_primitives", "types", "AccountId"] } }, { "id": 12, "type": { "def": { "compact": { "type": 6 } } } }, { "id": 13, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 14, "type": { "def": { "primitive": "u64" } } }, { "id": 15, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 16, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 17, "type": { "def": { "primitive": "bool" } } }, { "id": 18, "type": { "def": { "variant": { "variants": [{ "index": 0, "name": "ReadFailed" }, { "index": 1, "name": "WriteFailed" }] } }, "path": ["bittensor", "ReadWriteErrorCode"] } }, { "id": 19, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 20 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 20 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 20, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 2 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 2 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 21, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 22 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 22 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 22, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 14 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 14 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 23, "type": { "def": { "composite": { "fields": [{ "type": 4, "typeName": "[u8; 32]" }] } }, "path": ["ink_primitives", "types", "Hash"] } }, { "id": 24, "type": { "def": { "primitive": "u32" } } }, { "id": 25, "type": { "def": { "variant": {} }, "path": ["bittensor", "RuntimeReadWrite"] } }], "version": 5 } }; + +// .papi/descriptors/src/index.ts +var metadatas = { ["0xf3fc94ee2cf40e8a3e48a4d88d4880d606a706312512f6e0317eba65e032a0d8"]: devnet_default }; +var getMetadata2 = async (codeHash) => { + try { + return await metadatas[codeHash].getMetadata(); + } catch { + } + return null; +}; diff --git a/contract-tests/.papi/descriptors/dist/index.mjs b/contract-tests/.papi/descriptors/dist/index.mjs new file mode 100644 index 0000000000..ed55d00497 --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/index.mjs @@ -0,0 +1,109 @@ +import { + __export +} from "./chunk-7P6ASYW6.mjs"; + +// .papi/descriptors/src/common.ts +var table = new Uint8Array(128); +for (let i = 0; i < 64; i++) table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i; +var toBinary = (base64) => { + const n = base64.length, bytes = new Uint8Array((n - Number(base64[n - 1] === "=") - Number(base64[n - 2] === "=")) * 3 / 4 | 0); + for (let i2 = 0, j = 0; i2 < n; ) { + const c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)]; + const c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)]; + bytes[j++] = c0 << 2 | c1 >> 4; + bytes[j++] = c1 << 4 | c2 >> 2; + bytes[j++] = c2 << 6 | c3; + } + return bytes; +}; + +// .papi/descriptors/src/devnet.ts +var descriptorValues = import("./descriptors-UMN7HDMZ.mjs").then((module) => module["Devnet"]); +var metadataTypes = import("./metadataTypes-4SGFT3Q5.mjs").then( + (module) => toBinary("default" in module ? module.default : module) +); +var asset = {}; +var extensions = {}; +var getMetadata = () => import("./devnet_metadata-NGDS3DPZ.mjs").then( + (module) => toBinary("default" in module ? module.default : module) +); +var genesis = "0x56c04ae0094e08e671ff781eb7122ffca041a55d208befc4603bd441b44e8e3a"; +var _allDescriptors = { descriptors: descriptorValues, metadataTypes, asset, extensions, getMetadata, genesis }; +var devnet_default = _allDescriptors; + +// .papi/descriptors/src/common-types.ts +import { _Enum } from "polkadot-api"; +var DigestItem = _Enum; +var Phase = _Enum; +var DispatchClass = _Enum; +var TokenError = _Enum; +var ArithmeticError = _Enum; +var TransactionalError = _Enum; +var GrandpaEvent = _Enum; +var BalanceStatus = _Enum; +var TransactionPaymentEvent = _Enum; +var PreimageEvent = _Enum; +var GrandpaStoredState = _Enum; +var BalancesTypesReasons = _Enum; +var PreimagePalletHoldReason = _Enum; +var TransactionPaymentReleases = _Enum; +var PreimageOldRequestStatus = _Enum; +var PreimageRequestStatus = _Enum; +var PreimagesBounded = _Enum; +var GrandpaEquivocation = _Enum; +var MultiAddress = _Enum; +var BalancesAdjustmentDirection = _Enum; +var MultiSigner = _Enum; +var MultiSignature = _Enum; +var TransactionValidityUnknownTransaction = _Enum; +var TransactionValidityTransactionSource = _Enum; +var BabeAllowedSlots = _Enum; + +// .papi/descriptors/src/contracts/index.ts +var contracts_exports = {}; +__export(contracts_exports, { + bittensor: () => descriptor +}); + +// .papi/descriptors/src/contracts/bittensor.ts +var descriptor = { metadata: { "source": { "hash": "0xd15a29edfb7134dface2e0b6c704c173d47d3b48f1afc87193922ff8114e457d", "language": "ink! 5.1.1", "compiler": "rustc 1.89.0", "build_info": { "build_mode": "Release", "cargo_contract_version": "5.0.3", "rust_toolchain": "stable-aarch64-apple-darwin", "wasm_opt_settings": { "keep_debug_symbols": false, "optimization_passes": "Z" } } }, "contract": { "name": "bittensor", "version": "0.1.0", "authors": ["[your_name] <[your_email]>"] }, "image": null, "spec": { "constructors": [{ "args": [], "default": false, "docs": ["Constructor"], "label": "new", "payable": false, "returnType": { "displayName": ["ink_primitives", "ConstructorResult"], "type": 1 }, "selector": "0x9bae9d5e" }, { "args": [], "default": false, "docs": ["Constructor"], "label": "default", "payable": false, "returnType": { "displayName": ["ink_primitives", "ConstructorResult"], "type": 1 }, "selector": "0xed4b9d1b" }], "docs": [], "environment": { "accountId": { "displayName": ["AccountId"], "type": 11 }, "balance": { "displayName": ["Balance"], "type": 14 }, "blockNumber": { "displayName": ["BlockNumber"], "type": 24 }, "chainExtension": { "displayName": ["ChainExtension"], "type": 25 }, "hash": { "displayName": ["Hash"], "type": 23 }, "maxEventTopics": 4, "staticBufferSize": 16384, "timestamp": { "displayName": ["Timestamp"], "type": 14 } }, "events": [], "lang_error": { "displayName": ["ink", "LangError"], "type": 3 }, "messages": [{ "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "coldkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }], "default": false, "docs": [], "label": "get_stake_info_for_hotkey_coldkey_netuid", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 7 }, "selector": "0x5b73b8b9" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "add_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3a656e31" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "remove_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x7758d434" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "unstake_all", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3f525cc7" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "unstake_all_alpha", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xab74c422" }, { "args": [{ "label": "origin_hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "destination_hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "move_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xa06b0c55" }, { "args": [{ "label": "destination_coldkey", "type": { "displayName": [], "type": 4 } }, { "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "transfer_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x3528ef5e" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "swap_stake", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x04f7ca30" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "add_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x30013b98" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "remove_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xc3ce39c8" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "origin_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "destination_netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "amount", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }, { "label": "allow_partial", "type": { "displayName": ["bool"], "type": 17 } }], "default": false, "docs": [], "label": "swap_stake_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x212ef7ad" }, { "args": [{ "label": "hotkey", "type": { "displayName": [], "type": 4 } }, { "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "limit_price", "type": { "displayName": ["u64"], "type": 14 } }], "default": false, "docs": [], "label": "remove_stake_full_limit", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xa6d6ea64" }, { "args": [{ "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }, { "label": "hotkey", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "set_coldkey_auto_stake_hotkey", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0xe24f0d8a" }, { "args": [{ "label": "delegate", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "add_proxy", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x528b6757" }, { "args": [{ "label": "delegate", "type": { "displayName": [], "type": 4 } }], "default": false, "docs": [], "label": "remove_proxy", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 19 }, "selector": "0x129d4f75" }, { "args": [{ "label": "netuid", "type": { "displayName": ["u16"], "type": 6 } }], "default": false, "docs": [], "label": "get_alpha_price", "mutates": false, "payable": false, "returnType": { "displayName": ["ink", "MessageResult"], "type": 21 }, "selector": "0x08adc2e2" }] }, "storage": { "root": { "layout": { "struct": { "fields": [], "name": "Bittensor" } }, "root_key": "0x00000000", "ty": 0 } }, "types": [{ "id": 0, "type": { "def": { "composite": {} }, "path": ["bittensor", "bittensor", "Bittensor"] } }, { "id": 1, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 2 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 2 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 2, "type": { "def": { "tuple": [] } } }, { "id": 3, "type": { "def": { "variant": { "variants": [{ "index": 1, "name": "CouldNotReadInput" }] } }, "path": ["ink_primitives", "LangError"] } }, { "id": 4, "type": { "def": { "array": { "len": 32, "type": 5 } } } }, { "id": 5, "type": { "def": { "primitive": "u8" } } }, { "id": 6, "type": { "def": { "primitive": "u16" } } }, { "id": 7, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 8 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 8 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 8, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 9 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 9 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 9, "type": { "def": { "variant": { "variants": [{ "index": 0, "name": "None" }, { "fields": [{ "type": 10 }], "index": 1, "name": "Some" }] } }, "params": [{ "name": "T", "type": 10 }], "path": ["Option"] } }, { "id": 10, "type": { "def": { "composite": { "fields": [{ "name": "hotkey", "type": 11, "typeName": "AccountId" }, { "name": "coldkey", "type": 11, "typeName": "AccountId" }, { "name": "netuid", "type": 12, "typeName": "Compact" }, { "name": "stake", "type": 13, "typeName": "Compact" }, { "name": "locked", "type": 15, "typeName": "Compact" }, { "name": "emission", "type": 13, "typeName": "Compact" }, { "name": "tao_emission", "type": 16, "typeName": "Compact" }, { "name": "drain", "type": 15, "typeName": "Compact" }, { "name": "is_registered", "type": 17, "typeName": "bool" }] } }, "params": [{ "name": "AccountId", "type": 11 }], "path": ["bittensor", "StakeInfo"] } }, { "id": 11, "type": { "def": { "composite": { "fields": [{ "type": 4, "typeName": "[u8; 32]" }] } }, "path": ["ink_primitives", "types", "AccountId"] } }, { "id": 12, "type": { "def": { "compact": { "type": 6 } } } }, { "id": 13, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 14, "type": { "def": { "primitive": "u64" } } }, { "id": 15, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 16, "type": { "def": { "compact": { "type": 14 } } } }, { "id": 17, "type": { "def": { "primitive": "bool" } } }, { "id": 18, "type": { "def": { "variant": { "variants": [{ "index": 0, "name": "ReadFailed" }, { "index": 1, "name": "WriteFailed" }] } }, "path": ["bittensor", "ReadWriteErrorCode"] } }, { "id": 19, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 20 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 20 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 20, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 2 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 2 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 21, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 22 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 3 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 22 }, { "name": "E", "type": 3 }], "path": ["Result"] } }, { "id": 22, "type": { "def": { "variant": { "variants": [{ "fields": [{ "type": 14 }], "index": 0, "name": "Ok" }, { "fields": [{ "type": 18 }], "index": 1, "name": "Err" }] } }, "params": [{ "name": "T", "type": 14 }, { "name": "E", "type": 18 }], "path": ["Result"] } }, { "id": 23, "type": { "def": { "composite": { "fields": [{ "type": 4, "typeName": "[u8; 32]" }] } }, "path": ["ink_primitives", "types", "Hash"] } }, { "id": 24, "type": { "def": { "primitive": "u32" } } }, { "id": 25, "type": { "def": { "variant": {} }, "path": ["bittensor", "RuntimeReadWrite"] } }], "version": 5 } }; + +// .papi/descriptors/src/index.ts +var metadatas = { ["0xf3fc94ee2cf40e8a3e48a4d88d4880d606a706312512f6e0317eba65e032a0d8"]: devnet_default }; +var getMetadata2 = async (codeHash) => { + try { + return await metadatas[codeHash].getMetadata(); + } catch { + } + return null; +}; +export { + ArithmeticError, + BabeAllowedSlots, + BalanceStatus, + BalancesAdjustmentDirection, + BalancesTypesReasons, + DigestItem, + DispatchClass, + GrandpaEquivocation, + GrandpaEvent, + GrandpaStoredState, + MultiAddress, + MultiSignature, + MultiSigner, + Phase, + PreimageEvent, + PreimageOldRequestStatus, + PreimagePalletHoldReason, + PreimageRequestStatus, + PreimagesBounded, + TokenError, + TransactionPaymentEvent, + TransactionPaymentReleases, + TransactionValidityTransactionSource, + TransactionValidityUnknownTransaction, + TransactionalError, + contracts_exports as contracts, + devnet_default as devnet, + getMetadata2 as getMetadata +}; diff --git a/contract-tests/.papi/descriptors/dist/metadataTypes-4SGFT3Q5.mjs b/contract-tests/.papi/descriptors/dist/metadataTypes-4SGFT3Q5.mjs new file mode 100644 index 0000000000..797b0fcb7b --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/metadataTypes-4SGFT3Q5.mjs @@ -0,0 +1,8 @@ +import "./chunk-7P6ASYW6.mjs"; + +// .papi/descriptors/src/metadataTypes.ts +var content = "aQgAAAAQAQEFAAQBAQUAFAEBBQAcAAQAIAAEACQBAQUAIAEBBQAwAQEFAJkBACAAnQEBAQUAoQEBAQUANAEBBQClAQEBBQAYAQEFALEBAQEFALUBAQEFALkBAQEFAMkBAQAEGHJlbWFyayQBAQUBAAQUcGFnZXMIAQEFAQAEEGNvZGUkAQEFAQAEFGl0ZW1z0QEBAQUBAAQQa2V5c9UBAQEFAQAIGHByZWZpeCQcc3Via2V5cwQBAQUBAAQkY29kZV9oYXNoIAEBBQEBBQEABDRkaXNwYXRjaF9pbmZvQAEBBQEACDhkaXNwYXRjaF9lcnJvcqw0ZGlzcGF0Y2hfaW5mb0ABAQUBAQUBAQUBAAQcYWNjb3VudAABAQUBAAgYc2VuZGVyABBoYXNoIAEBBQEACCRjb2RlX2hhc2ggNGNoZWNrX3ZlcnNpb24UAQEFAQAIJGNvZGVfaGFzaCAUZXJyb3KsAQEFAQEFAQEFANwBAQUACAEABAxub3cIAQEFAQEFANkBAQEFAN0BAQEFABEBAAgABAEBBQC4AQAESGVxdWl2b2NhdGlvbl9wcm9vZvUBAQEFAQAIFGRlbGF5BGxiZXN0X2ZpbmFsaXplZF9ibG9ja19udW1iZXIEAQEFAQEFAQAENGF1dGhvcml0eV9zZXS4AAAADAAAAAECAAAACQIAAAAlAgAAAC0CAQAIEGRlc3QxAhR2YWx1ZQgBAQUBAAwYc291cmNlMQIQZGVzdDECFHZhbHVlCAEBBQEACBBkZXN0MQIoa2VlcF9hbGl2ZRQBAQUBAAgMd2hvMQIYYW1vdW50CAEBBQEABAx3aG81AgEBBQEACAx3aG8xAiBuZXdfZnJlZQgBAQUBAAgkZGlyZWN0aW9uOQIUZGVsdGEIAQEFAQAIFHZhbHVlCChrZWVwX2FsaXZlFAEBBQEBBQEACBxhY2NvdW50ADBmcmVlX2JhbGFuY2UIAQEFAQAIHGFjY291bnQAGGFtb3VudAgBAQUBAAwQZnJvbQAIdG8AGGFtb3VudAgBAQUBAAgMd2hvABBmcmVlCAEBBQEACAx3aG8AGGFtb3VudAgBAQUBABAQZnJvbQAIdG8AGGFtb3VudAhIZGVzdGluYXRpb25fc3RhdHVzwAEBBQEABAx3aG8AAQEFAQAEGGFtb3VudAgBAQUBAAgMb2xkCAxuZXcIAQEFAD0CAQEFAQAMDHdobwAoYWN0dWFsX2ZlZQgMdGlwCABBAgAIAAAAAAAAAAQARQIABABBAgBJAgBFAgDYAEUCAAgABAAIAAAANQIARQIAAABFAgA1AgAAAE0CAFECAAgBAQUAVQIABABZAgAkAAgABAAEAGECAAgABAAUAEUCABQABAAAAAQAZQIABAARAQAEAOAAQQIABAARAQAAAAQAbQIABABxAgAEAOwAEQEAnQEAEQEACABBAgB1AgBBAgB5AgBBAgB9AgAAAIECAAQAhQIAiQIACAAAAAgAQQIAkQIAlQIAnQIAlQIApQIAqQIACABRAgAUAAAArQIAsQIACAAAAPAACAAAABEBALUCAAQAuQIAJAAUAQAQGG5ldHVpZAQUZGVzdHPgHHdlaWdodHPgLHZlcnNpb25fa2V5CAEBBQEAFBhuZXR1aWQEFG1lY2lkBBRkZXN0c+Acd2VpZ2h0c+AsdmVyc2lvbl9rZXkIAQEFAQAMHG5ldHVpZHPgHHdlaWdodHO9AjB2ZXJzaW9uX2tleXPsAQEFAQAIGG5ldHVpZAQsY29tbWl0X2hhc2ggAQEFAQAMGG5ldHVpZAQUbWVjaWQELGNvbW1pdF9oYXNoIAEBBQEACBxuZXR1aWRz4DRjb21taXRfaGFzaGVz3AEBBQEAFBhuZXR1aWQEEHVpZHPgGHZhbHVlc+AQc2FsdOAsdmVyc2lvbl9rZXkIAQEFAQAYGG5ldHVpZAQUbWVjaWQEEHVpZHPgGHZhbHVlc+AQc2FsdOAsdmVyc2lvbl9rZXkIAQEFAQAQGG5ldHVpZAQUbWVjaWQEGGNvbW1pdCQwcmV2ZWFsX3JvdW5kCAEBBQEAFBhuZXR1aWQEJHVpZHNfbGlzdMECLHZhbHVlc19saXN0wQIoc2FsdHNfbGlzdMECMHZlcnNpb25fa2V5c+wBAQUBAAgYaG90a2V5ABB0YWtlBAEBBQEADBhob3RrZXkAGG5ldHVpZAQ0YW1vdW50X3N0YWtlZAgBAQUBAAwYaG90a2V5ABhuZXR1aWQEPGFtb3VudF91bnN0YWtlZAgBAQUBACAYbmV0dWlkBBx2ZXJzaW9uBAhpcAgQcG9ydAQcaXBfdHlwZQQgcHJvdG9jb2wEMHBsYWNlaG9sZGVyMQQwcGxhY2Vob2xkZXIyBAEBBQEAJBhuZXR1aWQEHHZlcnNpb24ECGlwCBBwb3J0BBxpcF90eXBlBCBwcm90b2NvbAQwcGxhY2Vob2xkZXIxBDBwbGFjZWhvbGRlcjIELGNlcnRpZmljYXRlJAEBBQEAFBhuZXR1aWQEHHZlcnNpb24ECGlwCBBwb3J0BBxpcF90eXBlBAEBBQEAGBhuZXR1aWQEMGJsb2NrX251bWJlcggUbm9uY2UIEHdvcmskGGhvdGtleQAcY29sZGtleQABAQUBAAQYaG90a2V5AAEBBQEACBhuZXR1aWQEGGhvdGtleQABAQUBAAwYaG90a2V5AChuZXdfaG90a2V5ABhuZXR1aWToAQEFAQAMLG9sZF9jb2xka2V5ACxuZXdfY29sZGtleQAkc3dhcF9jb3N0CAEBBQEADBhob3RrZXkAGG5ldHVpZAQQdGFrZQQBAQUBAAQ0dHhfcmF0ZV9saW1pdAgBAQUBAAQQdGFrZQQBAQUBAAwwYmxvY2tfbnVtYmVyCBRub25jZQgQd29yayQBAQUBAAgcY29sZGtleQAYbmV0dWlkBAEBBQEADBhob3RrZXkAGG5ldHVpZAQgY2hpbGRyZW7YAQEFAQAELG5ld19jb2xka2V5AAEBBQEAHBBuYW1lJAx1cmwkLGdpdGh1Yl9yZXBvJBRpbWFnZSQcZGlzY29yZCQsZGVzY3JpcHRpb24kKGFkZGl0aW9uYWwkAQEFAQAkGG5ldHVpZAQsc3VibmV0X25hbWUkLGdpdGh1Yl9yZXBvJDhzdWJuZXRfY29udGFjdCQoc3VibmV0X3VybCQcZGlzY29yZCQsZGVzY3JpcHRpb24kIGxvZ29fdXJsJChhZGRpdGlvbmFsJAEBBQEACBhob3RrZXkAIGlkZW50aXR5xQIBAQUBABQ0b3JpZ2luX2hvdGtleQBIZGVzdGluYXRpb25faG90a2V5ADRvcmlnaW5fbmV0dWlkBEhkZXN0aW5hdGlvbl9uZXR1aWQEMGFscGhhX2Ftb3VudAgBAQUBABRMZGVzdGluYXRpb25fY29sZGtleQAYaG90a2V5ADRvcmlnaW5fbmV0dWlkBEhkZXN0aW5hdGlvbl9uZXR1aWQEMGFscGhhX2Ftb3VudAgBAQUBABAYaG90a2V5ADRvcmlnaW5fbmV0dWlkBEhkZXN0aW5hdGlvbl9uZXR1aWQEMGFscGhhX2Ftb3VudAgBAQUBABQYaG90a2V5ABhuZXR1aWQENGFtb3VudF9zdGFrZWQILGxpbWl0X3ByaWNlCDRhbGxvd19wYXJ0aWFsFAEBBQEAFBhob3RrZXkAGG5ldHVpZAQ8YW1vdW50X3Vuc3Rha2VkCCxsaW1pdF9wcmljZQg0YWxsb3dfcGFydGlhbBQBAQUBABgYaG90a2V5ADRvcmlnaW5fbmV0dWlkBEhkZXN0aW5hdGlvbl9uZXR1aWQEMGFscGhhX2Ftb3VudAgsbGltaXRfcHJpY2UINGFsbG93X3BhcnRpYWwUAQEFAQAEGG5ldHVpZAQBAQUBABAYbmV0dWlkBBxldm1fa2V55DBibG9ja19udW1iZXIIJHNpZ25hdHVyZckCAQEFAQAMGGhvdGtleQAYYW1vdW50CBhuZXR1aWQEAQEFAQAEIGNvb2xkb3duCAEBBQEADBhob3RrZXkAGG5ldHVpZAQsbGltaXRfcHJpY2XNAgEBBQEACDxlbWlzc2lvbnNfc2hhcmUEJGVuZF9ibG9ja+gBAQUBAAggbGVhc2VfaWQEGGhvdGtleQABAQUBAAgYbmV0dWlkBBhzeW1ib2wkAQEFAQAQGG5ldHVpZAQYY29tbWl0JDByZXZlYWxfcm91bmQIVGNvbW1pdF9yZXZlYWxfdmVyc2lvbgQBAQUBABQYbmV0dWlkBBRtZWNpZAQYY29tbWl0JDByZXZlYWxfcm91bmQIVGNvbW1pdF9yZXZlYWxfdmVyc2lvbgQBAQUBAAQcc3VibmV0c+ABAQUBAARMbmV3X3Jvb3RfY2xhaW1fdHlwZfABAQUBAAQkbmV3X3ZhbHVlCAEBBQEACBhuZXR1aWQEJG5ld192YWx1ZQgBAQUBAARAbmV3X2NvbGRrZXlfaGFzaCABAQUBAQUBAQUBAAQcY29sZGtleQABAQUBAAgYbmV0dWlkBBRhbHBoYQgBAQUBABAYaG90a2V5ABhuZXR1aWQEGGFtb3VudAgUbGltaXTNAgEBBQEBBQEEBAEIAQEFAAQBAQUBAxgAAAgIBAgBAQUBAxgAAAQABAgBAQUBAwwEBAABAQUBAwgECAEBBQEDCAQEAQEFAQMIBBQBAQUBAwgEAAEBBQEDDAAABAEBBQAIAQEFAQMIAAQBAQUA0AEBBQEDCAAIAQEFAQAMHGNvbGRrZXkAKG9sZF9ob3RrZXkAKG5ld19ob3RrZXkAAQEFAQAIDHdobwBAbmV3X2NvbGRrZXlfaGFzaCABAQUBAAgsb2xkX2NvbGRrZXkALG5ld19jb2xka2V5AAEBBQEABBxjb2xka2V5AAEBBQEADDxjdXJyZW50X2NvbGRrZXkALG5ld19jb2xka2V5ADR0b3RhbF9iYWxhbmNlCAEBBQEDEAAECNgBAQUBAwwABNgBAQUAAAEBBQEADBxhY2NvdW50ABhuZXR1aWQEPGV4ZWN1dGlvbl9ibG9jawQBAQUBAwwABCABAQUBAwwABNwBAQUBAwjgAAEBBQCsAQEFAQMYAAAABAQIAQEFAQMUAAAEBAgBAQUBAxAAAAgEAQEFAQAQGG5ldHVpZAQYaG90a2V5ABxldm1fa2V55EBibG9ja19hc3NvY2lhdGVkCAEBBQEAEBxjb2xka2V5AChvbGRfaG90a2V5AChuZXdfaG90a2V5ABhuZXR1aWQEAQEFAQAQLGJlbmVmaWNpYXJ5ACBsZWFzZV9pZAQYbmV0dWlkBCRlbmRfYmxvY2voAQEFAQAILGJlbmVmaWNpYXJ5ABhuZXR1aWQEAQEFAQAIGG5ldHVpZAQYc3ltYm9sJAEBBQEDEAAEIAgBAQUBABQYbmV0dWlkBCxkZXN0aW5hdGlvbgAYaG90a2V5ABRvd25lcgAkaW5jZW50aXZlCAEBBQEACBhuZXR1aWQEJGVtaXNzaW9uc+wBAQUBAAwcY29sZGtleQAYbmV0dWlkBBhob3RrZXkAAQEFAQAIHGNvbGRrZXkAPHJvb3RfY2xhaW1fdHlwZfABAQUBAAQYbmV0dWlkBAEBBQEACBhuZXR1aWQEQGRpc2FibGVfYXRfYmxvY2sIAQEFAQAIGG5ldHVpZAQUYWxwaGEIAQEFAQAMIGxlYXNlX2lkBCxjb250cmlidXRvcgAUYWxwaGEIAQEFAQAQGG5ldHVpZAQYaG90a2V5ABhhbW91bnQIFGFscGhhCAEABBRjYWxsc7UFAQEFAQAIFGluZGV4BBBjYWxssQUBAQUBAAgkYXNfb3JpZ2lu7QIQY2FsbLEFAQEFAQAIEGNhbGyxBRh3ZWlnaHQYAQEFAQAIEG1haW6xBSBmYWxsYmFja7EFAQEFAQEFAQAIFGluZGV4BBRlcnJvcqwBAQUBAAQUZXJyb3KsAQEFAQAEGHJlc3VsdNABAQUBAAQobWFpbl9lcnJvcqwBAQUAAAEABBBjYWxssQUBAQUBAAQMbmV3MQIBAQUBAAgMd2hvMQIQY2FsbLEFAQEFAQEFAQAELHN1ZG9fcmVzdWx00AEBBQEACAxvbGT8DG5ldwAAuQUAvQUBAAhEb3RoZXJfc2lnbmF0b3JpZXM1AhBjYWxssQUBAQUBABQkdGhyZXNob2xkBERvdGhlcl9zaWduYXRvcmllczUCPG1heWJlX3RpbWVwb2ludPkCEGNhbGyxBShtYXhfd2VpZ2h0GAEBBQEAFCR0aHJlc2hvbGQERG90aGVyX3NpZ25hdG9yaWVzNQI8bWF5YmVfdGltZXBvaW50+QIkY2FsbF9oYXNoIChtYXhfd2VpZ2h0GAEBBQEAECR0aHJlc2hvbGQERG90aGVyX3NpZ25hdG9yaWVzNQIkdGltZXBvaW50BQEkY2FsbF9oYXNoIAEBBQEADCR0aHJlc2hvbGQERG90aGVyX3NpZ25hdG9yaWVzNQIkY2FsbF9oYXNoIAEBBQEBBQEADCRhcHByb3ZpbmcAIG11bHRpc2lnACRjYWxsX2hhc2ggAQEFAQAQJGFwcHJvdmluZwAkdGltZXBvaW50BQEgbXVsdGlzaWcAJGNhbGxfaGFzaCABAQUBABQkYXBwcm92aW5nACR0aW1lcG9pbnQFASBtdWx0aXNpZwAkY2FsbF9oYXNoIBhyZXN1bHTQAQEFAQAQKGNhbmNlbGxpbmcAJHRpbWVwb2ludAUBIG11bHRpc2lnACRjYWxsX2hhc2ggAQEFAQAQDHdobwAkY2FsbF9oYXNoICxvbGRfZGVwb3NpdAgsbmV3X2RlcG9zaXQIACAAyQUAIADNBQDRBQAkAQAEFGJ5dGVzJAEBBQEABBBoYXNoIAEBBQEABBhoYXNoZXPcAQEFAQEFAQAEEGhhc2ggAAQA4QUAEQEA5QUAIAARAQEAEBB3aGVuBDhtYXliZV9wZXJpb2RpYwUDIHByaW9yaXR5BBBjYWxssQUBAQUBAAgQd2hlbgQUaW5kZXgEAQEFAQAUCGlkIBB3aGVuBDhtYXliZV9wZXJpb2RpYwUDIHByaW9yaXR5BBBjYWxssQUBAQUBAAQIaWQgAQEFAQAQFGFmdGVyBDhtYXliZV9wZXJpb2RpYwUDIHByaW9yaXR5BBBjYWxssQUBAQUBABQIaWQgFGFmdGVyBDhtYXliZV9wZXJpb2RpYwUDIHByaW9yaXR5BBBjYWxssQUBAQUBAAwQdGFzaxEBHHJldHJpZXMEGHBlcmlvZAQBAQUBAAwIaWQgHHJldHJpZXMEGHBlcmlvZAQBAQUBAAQQdGFzaxEBAQEFAQEFAQAIEHdoZW4EFGluZGV4BAEBBQEADBB0YXNrEQEIaWQVARhyZXN1bHTQAQEFAQAQEHRhc2sRAQhpZBUBGHBlcmlvZAQccmV0cmllcwQBAQUBAAgQdGFzaxEBCGlkFQEBAQUBAAQQd2hlbgQAAADxBQAAAP0FAAAA0AEDCLEFHQEAFAEDCB0BHQEAFAEADBByZWFsMQJAZm9yY2VfcHJveHlfdHlwZQ0DEGNhbGyxBQEBBQEADCBkZWxlZ2F0ZTECKHByb3h5X3R5cGUdARRkZWxheQQBAQUBAAwocHJveHlfdHlwZR0BFGRlbGF5BBRpbmRleAQBAQUBABQcc3Bhd25lcjECKHByb3h5X3R5cGUdARRpbmRleAQYaGVpZ2h0BCRleHRfaW5kZXgEAQEFAQAIEHJlYWwxAiRjYWxsX2hhc2ggAQEFAQAIIGRlbGVnYXRlMQIkY2FsbF9oYXNoIAEBBQEAECBkZWxlZ2F0ZTECEHJlYWwxAkBmb3JjZV9wcm94eV90eXBlDQMQY2FsbLEFAQEFAQEFAQAQEHB1cmUADHdobwAocHJveHlfdHlwZR0BUGRpc2FtYmlndWF0aW9uX2luZGV4BAEBBQEAEBBwdXJlABxzcGF3bmVyAChwcm94eV90eXBlHQFQZGlzYW1iaWd1YXRpb25faW5kZXgEAQEFAQAMEHJlYWwAFHByb3h5ACRjYWxsX2hhc2ggAQEFAQAQJGRlbGVnYXRvcgAkZGVsZWdhdGVlAChwcm94eV90eXBlHQEUZGVsYXkEAQEFAQAQDHdobwAQa2luZCEBLG9sZF9kZXBvc2l0CCxuZXdfZGVwb3NpdAgAAAABBgEACChpZGVudGlmaWVkABBpbmZvDQQBAQUBAAQoaWRlbnRpZmllZAABAQUBAQUABQYAQQIACQYAQQIAEQYAQQIAFQYBAAgYbmV0dWlkBBBpbmZvFQUBAQUBAAQkbmV3X2xpbWl0BAEBBQEBBQEACBhuZXR1aWQEDHdobwABAQUBAAwYbmV0dWlkBAx3aG8AMHJldmVhbF9yb3VuZAgAMQEAFAEABDxuZXdfYXV0aG9yaXRpZXPcAQEFAQAEMGRlZmF1bHRfdGFrZQQBAQUBAAgYbmV0dWlkBEhzZXJ2aW5nX3JhdGVfbGltaXQIAQEFAQAIGG5ldHVpZAQ4bWluX2RpZmZpY3VsdHkIAQEFAQAIGG5ldHVpZAQ4bWF4X2RpZmZpY3VsdHkIAQEFAQAIGG5ldHVpZARMd2VpZ2h0c192ZXJzaW9uX2tleQgBAQUBAAgYbmV0dWlkBFh3ZWlnaHRzX3NldF9yYXRlX2xpbWl0CAEBBQEACBhuZXR1aWQETGFkanVzdG1lbnRfaW50ZXJ2YWwEAQEFAQAIGG5ldHVpZARAYWRqdXN0bWVudF9hbHBoYQgBAQUBAAgYbmV0dWlkBDxpbW11bml0eV9wZXJpb2QEAQEFAQAIGG5ldHVpZARMbWluX2FsbG93ZWRfd2VpZ2h0cwQBAQUBAAgYbmV0dWlkBEBtYXhfYWxsb3dlZF91aWRzBAEBBQEACBhuZXR1aWQEFGthcHBhBAEBBQEACBhuZXR1aWQEDHJobwQBAQUBAAgYbmV0dWlkBDxhY3Rpdml0eV9jdXRvZmYEAQEFAQAIGG5ldHVpZARQcmVnaXN0cmF0aW9uX2FsbG93ZWQUAQEFAQAIGG5ldHVpZASEdGFyZ2V0X3JlZ2lzdHJhdGlvbnNfcGVyX2ludGVydmFsBAEBBQEACBhuZXR1aWQEIG1pbl9idXJuCAEBBQEACBhuZXR1aWQEIG1heF9idXJuCAEBBQEACBhuZXR1aWQEKGRpZmZpY3VsdHkIAQEFAQAIGG5ldHVpZARYbWF4X2FsbG93ZWRfdmFsaWRhdG9ycwQBAQUBAAgYbmV0dWlkBFBib25kc19tb3ZpbmdfYXZlcmFnZQgBAQUBAAgYbmV0dWlkBDRib25kc19wZW5hbHR5BAEBBQEACBhuZXR1aWQEbG1heF9yZWdpc3RyYXRpb25zX3Blcl9ibG9jawQBAQUBAARAc3VibmV0X293bmVyX2N1dAQBAQUBAAQocmF0ZV9saW1pdAgBAQUBAAgYbmV0dWlkBBR0ZW1wbwQBAQUBAAQ4dG90YWxfaXNzdWFuY2UIAQEFAQAEPGltbXVuaXR5X3BlcmlvZAgBAQUBAAQkbG9ja19jb3N0CAEBBQEABCxtYXhfc3VibmV0cwQBAQUBAAQgaW50ZXJ2YWwIAQEFAQAIGG5ldHVpZAQwcmFvX3JlY3ljbGVkCAEBBQEABCRtaW5fc3Rha2UIAQEFAQAIGG5ldHVpZAQcZW5hYmxlZBQBAQUBAAwYbmV0dWlkBCRhbHBoYV9sb3cEKGFscGhhX2hpZ2gEAQEFAQAEIGR1cmF0aW9uBAEBBQEACBhuZXR1aWQEIGludGVydmFsCAEBBQEABCBjaGFpbl9pZAgBAQUBAAxAbmV4dF9hdXRob3JpdGllc7gkaW5fYmxvY2tzBBhmb3JjZWToAQEFAQAIGG5ldHVpZAQYdG9nZ2xlFAEBBQEACBhuZXR1aWQEPHJlY3ljbGVfb3JfYnVybmUCAQEFAQAINHByZWNvbXBpbGVfaWQxARxlbmFibGVkFAEBBQEABBRhbHBoYQgBAQUBAAgYbmV0dWlkBCxlbWFfaGFsdmluZwgBAQUBAAgYbmV0dWlkBCRzdGVlcG5lc3MEAQEFAQAIGG5ldHVpZARAc3VidG9rZW5fZW5hYmxlZBQBAQUBAAQcdmVyc2lvbgQBAQUBAAgYbmV0dWlkBDhpbW11bmVfbmV1cm9ucwQBAQUBAAQQYnVybggBAQUBAAQYd2luZG93BAEBBQEABBhlcG9jaHMEAQEFAQAIGG5ldHVpZAQ8bWVjaGFuaXNtX2NvdW50BAEBBQEACBhuZXR1aWQELG1heWJlX3NwbGl0HQUBAQUBAAgYbmV0dWlkBBRtYXhfbgQBAQUBAAgYbmV0dWlkBEBtaW5fYWxsb3dlZF91aWRzBAEBBQEABCxmbG93X2N1dG9mZggBAQUBAAQgZXhwb25lbnQIAQEFAQAEQHNtb290aGluZ19mYWN0b3IIAQEFAQAETG1heF9tZWNoYW5pc21fY291bnQEAQEFAQAIGG5ldHVpZAQMbWluBAEBBQEABBRkZWxheQgBAQUBAQUBAAg0cHJlY29tcGlsZV9pZDEBHGVuYWJsZWQUAQEFAQAIGG5ldHVpZAQcZW5hYmxlZBQBAQUAzQIBAQUA6AEACBxhY2NvdW50ABRibG9jawQBAQUBAQUBAAQUdW50aWwEAQEFAQAEGHJlYXNvbjkBAAQALQYBAQUAPQYBAQUAQQYBAQUARQYAZQEAIAEABCx0cmFuc2FjdGlvblUFAQEFAQEFAQAUEGZyb23kCHRv5EB0cmFuc2FjdGlvbl9oYXNoICxleGl0X3JlYXNvblUBKGV4dHJhX2RhdGEkAOQAJADkAEkGAE0GACABAQUAaQUBAAgcYWRkcmVzc+QUdmFsdWUIAQEFAQAoGHNvdXJjZeQYdGFyZ2V05BRpbnB1dCQUdmFsdWVlASRnYXNfbGltaXQIPG1heF9mZWVfcGVyX2dhc2UBYG1heF9wcmlvcml0eV9mZWVfcGVyX2dhc10FFG5vbmNlXQUsYWNjZXNzX2xpc3RlBUhhdXRob3JpemF0aW9uX2xpc3RNBQEBBQEAJBhzb3VyY2XkEGluaXQkFHZhbHVlZQEkZ2FzX2xpbWl0CDxtYXhfZmVlX3Blcl9nYXNlAWBtYXhfcHJpb3JpdHlfZmVlX3Blcl9nYXNdBRRub25jZV0FLGFjY2Vzc19saXN0ZQVIYXV0aG9yaXphdGlvbl9saXN0TQUBAQUBACgYc291cmNl5BBpbml0JBBzYWx0IBR2YWx1ZWUBJGdhc19saW1pdAg8bWF4X2ZlZV9wZXJfZ2FzZQFgbWF4X3ByaW9yaXR5X2ZlZV9wZXJfZ2FzXQUUbm9uY2VdBSxhY2Nlc3NfbGlzdGUFSGF1dGhvcml6YXRpb25fbGlzdE0FAQEFAQAEDG5ld2kFAQEFAQAEIGRpc2FibGVkFAEBBQEBBQEABAxsb2ddAQEBBQEABBxhZGRyZXNz5AEBBQBlAQEABAxmZWVlAQEBBQEABChlbGFzdGljaXR5BAEBBQEBBQEABAxmZWVlAQEBBQEABChlbGFzdGljaXR5BAEBBQCNBQAIAHUFAQAIOHB1bHNlc19wYXlsb2FkgQUkc2lnbmF0dXJliQUBAQUBAAg4Y29uZmlnX3BheWxvYWSRBSRzaWduYXR1cmWJBQEBBQEABDBvbGRlc3Rfcm91bmQIAQEFAQEFAQAEGHJvdW5kc+wABABVBgEBBQC9AQEAGBxkZXBvc2l0CEBtaW5fY29udHJpYnV0aW9uCAxjYXAIDGVuZAQQY2FsbJkFOHRhcmdldF9hZGRyZXNz/AEBBQEACDBjcm93ZGxvYW5faWQEGGFtb3VudAgBAQUBAAQwY3Jvd2Rsb2FuX2lkBAEBBQEACDBjcm93ZGxvYW5faWQEUG5ld19taW5fY29udHJpYnV0aW9uCAEBBQEACDBjcm93ZGxvYW5faWQEHG5ld19lbmQEAQEFAQAIMGNyb3dkbG9hbl9pZAQcbmV3X2NhcAgBAQUBAQUBABAwY3Jvd2Rsb2FuX2lkBBxjcmVhdG9yAAxlbmQEDGNhcAgBAQUBAAwwY3Jvd2Rsb2FuX2lkBCxjb250cmlidXRvcgAYYW1vdW50CAEBBQEABDBjcm93ZGxvYW5faWQEAQEFAQAIMGNyb3dkbG9hbl9pZARQbmV3X21pbl9jb250cmlidXRpb24IAQEFAQAIMGNyb3dkbG9hbl9pZAQcbmV3X2VuZAQBAQUBAAgwY3Jvd2Rsb2FuX2lkBBxuZXdfY2FwCABZBgBdBgBhBgBlBgBtBgAIAQAIGG5ldHVpZAQQcmF0ZQQBAQUBAAgYbmV0dWlkBBhlbmFibGUUAQEFAQAUGGhvdGtleQAYbmV0dWlkBCB0aWNrX2xvdwQkdGlja19oaWdoBCRsaXF1aWRpdHkIAQEFAQAMGGhvdGtleQAYbmV0dWlkBCxwb3NpdGlvbl9pZAgBAQUBABAYaG90a2V5ABhuZXR1aWQELHBvc2l0aW9uX2lkCDxsaXF1aWRpdHlfZGVsdGEIAQEFAQEFAQAIGG5ldHVpZAQQcmF0ZQQBAQUBAAgYbmV0dWlkBBhlbmFibGUUAQEFAQAkHGNvbGRrZXkAGGhvdGtleQAYbmV0dWlkBCxwb3NpdGlvbl9pZAgkbGlxdWlkaXR5CAx0YW8IFGFscGhhCCB0aWNrX2xvdwQkdGlja19oaWdoBAEBBQEALBxjb2xka2V5ABhob3RrZXkAGG5ldHVpZAQscG9zaXRpb25faWQIJGxpcXVpZGl0eQgMdGFvCBRhbHBoYQgcZmVlX3RhbwgkZmVlX2FscGhhCCB0aWNrX2xvdwQkdGlja19oaWdoBAAgACQAIABxBgAAAHUGAQEFAHkGAQEFACQBAQUAgQYBAQUAhQYBABQQZGVzdDECFHZhbHVlCCRnYXNfbGltaXQIVHN0b3JhZ2VfZGVwb3NpdF9saW1pdM0CEGRhdGEkAQEFAQAYFHZhbHVlCCRnYXNfbGltaXQIVHN0b3JhZ2VfZGVwb3NpdF9saW1pdM0CEGNvZGUkEGRhdGEkEHNhbHQkAQEFAQAYFHZhbHVlCCRnYXNfbGltaXQIVHN0b3JhZ2VfZGVwb3NpdF9saW1pdM0CJGNvZGVfaGFzaCAQZGF0YSQQc2FsdCQBAQUBAAwQY29kZSRUc3RvcmFnZV9kZXBvc2l0X2xpbWl0zQIsZGV0ZXJtaW5pc22lBQEBBQEACBBkZXN0MQIkY29kZV9oYXNoIAEBBQEAFBBkZXN0MQIUdmFsdWUIJGdhc19saW1pdBhUc3RvcmFnZV9kZXBvc2l0X2xpbWl0zQIQZGF0YSQBAQUBABgUdmFsdWUIJGdhc19saW1pdBhUc3RvcmFnZV9kZXBvc2l0X2xpbWl0zQIQY29kZSQQZGF0YSQQc2FsdCQBAQUBABgUdmFsdWUIJGdhc19saW1pdBhUc3RvcmFnZV9kZXBvc2l0X2xpbWl0zQIkY29kZV9oYXNoIBBkYXRhJBBzYWx0JAEBBQEABDB3ZWlnaHRfbGltaXQYAQEFAQEFAQAIIGRlcGxveWVyACBjb250cmFjdAABAQUBAAggY29udHJhY3QALGJlbmVmaWNpYXJ5AAEBBQEADCRjb2RlX2hhc2ggMGRlcG9zaXRfaGVsZAggdXBsb2FkZXIAAQEFAQAIIGNvbnRyYWN0ABBkYXRhJAEBBQEADCRjb2RlX2hhc2ggQGRlcG9zaXRfcmVsZWFzZWQIHHJlbW92ZXIAAQEFAQAMIGNvbnRyYWN0ADRuZXdfY29kZV9oYXNoIDRvbGRfY29kZV9oYXNoIAEBBQEACBhjYWxsZXJ5ASBjb250cmFjdAABAQUBAAggY29udHJhY3QAJGNvZGVfaGFzaCAAIACJBgEABChwdWJsaWNfa2V5JAEBBQEACChjb21taXRtZW50IChjaXBoZXJ0ZXh0JAEBBQEACAhpZCAYcmVhc29uJAEBBQEBBQEACAhpZCAMd2hvAAEBBQEACAhpZCAYc2lnbmVyAAEBBQEACAhpZCAYcmVhc29uiQEBAQUBAAgIaWQgGHJlYXNvbiQBAwAAyQEBAwSRBgDMAQMEjQYAlQYBAwAAJAEDBAQAVQIBAwAA4AEDBCQApQYBAwAAjQYBAwStBgDVAQEDCJEGrQYAsQYBAwQkALUGAQMEuQYAVQIBAwAAvQYBAwzBBiQgAMkGAQMEjQYAzAEDAAAIAQMAANwBAwRVAgAkAQMEJADVBgEDAAC4AQMI9QEkABQBAwgIIABVAgEDBAAABAEDCCQEANkGAQMIJAQA5QYBAwQYAAgBAwQEAAgBAwixBQQA2QYBAwixBQQA5QYBAwTkAOkGAQMAAGUBAQME5AAkAQMAAOQBAwjkZQEAIAEDLOTkJGUBZQFdBV0FXQUU7QbxBgAFBwEDKOQkZQFlAV0FXQVdBRTtBvEGAA0HAQMAABEHAQMAABUHAQMAABkHAQMAAB0HAQME1QEANQYBAwAA6AEDAADMAQME1QEAIQcBAwRVBQAkAQMYAAAIgQHNAiQANQcBAxwACIEBzQI5ByQkAEUHAQMQACTNAqUFAE0HAQMIACQAVQcBAwAAZQcBAwQAAGkHAQMEAABxBwEDBAQAfQcBAwgEBACBBwEDBAQAiQcBAwgEBACNBwEDBAQAlQcBAwAAmQcBAwQEAKEHAQMAAKUHAQMEBACtBwEDBAQAtQcBAwAAwQcBAwAA2QcBAwQEANUHAQMIBAQA1QcBAwQEAL0HAQMEBADlBwEDCATgABkIAQMIAAQA/AEDDAQE4AAZCAEDBAAAIQgBAwQ1AgApCAEDDAAABAAtCAEDFDEIADEIAAgACAEDAAA9CAEDAABFCAEDCAggAFUCAQMISQgkABQBAwQEAAgBAwAAUQgBAwgECABVCAEDCAQIAFUIWQgBAQECAQMAEBBmcmVlCCByZXNlcnZlZAgYZnJvemVuCBRmbGFncwgAFBRub25jZQQkY29uc3VtZXJzBCRwcm92aWRlcnMELHN1ZmZpY2llbnRzBBBkYXRhDAEAAAggcmVmX3RpbWUIKHByb29mX3NpemUIAAwYbm9ybWFsGCxvcGVyYXRpb25hbBgkbWFuZGF0b3J5GAUBgAUABQEQAhQoUHJlUnVudGltZQADCCgkJENvbnNlbnN1cwADCCgkEFNlYWwAAwgoJBRPdGhlcgEkZFJ1bnRpbWVFbnZpcm9ubWVudFVwZGF0ZWQAAQUELAACDDhBcHBseUV4dHJpbnNpYwEEMEZpbmFsaXphdGlvbgABBThJbml0aWFsaXphdGlvbgABBQIMGE5vcm1hbAABBSxPcGVyYXRpb25hbAABBSRNYW5kYXRvcnkAAQUCCAxZZXMAAQUITm8AAQUADBh3ZWlnaHQYFGNsYXNzOCBwYXlzX2ZlZTwCJDxJbnZhbGlkU3BlY05hbWUAAQVoU3BlY1ZlcnNpb25OZWVkc1RvSW5jcmVhc2UAAQV0RmFpbGVkVG9FeHRyYWN0UnVudGltZVZlcnNpb24AAQVMTm9uRGVmYXVsdENvbXBvc2l0ZQABBTxOb25aZXJvUmVmQ291bnQAAQUwQ2FsbEZpbHRlcmVkAAEFbE11bHRpQmxvY2tNaWdyYXRpb25zT25nb2luZwABBUROb3RoaW5nQXV0aG9yaXplZAABBTBVbmF1dGhvcml6ZWQAAQUCHCxQYXVzZUZhaWxlZAABBTBSZXN1bWVGYWlsZWQAAQU0Q2hhbmdlUGVuZGluZwABBRxUb29Tb29uAAEFYEludmFsaWRLZXlPd25lcnNoaXBQcm9vZgABBWBJbnZhbGlkRXF1aXZvY2F0aW9uUHJvb2YAAQVYRHVwbGljYXRlT2ZmZW5jZVJlcG9ydAABBQIwOFZlc3RpbmdCYWxhbmNlAAEFVExpcXVpZGl0eVJlc3RyaWN0aW9ucwABBUxJbnN1ZmZpY2llbnRCYWxhbmNlAAEFSEV4aXN0ZW50aWFsRGVwb3NpdAABBTRFeHBlbmRhYmlsaXR5AAEFXEV4aXN0aW5nVmVzdGluZ1NjaGVkdWxlAAEFLERlYWRBY2NvdW50AAEFPFRvb01hbnlSZXNlcnZlcwABBTBUb29NYW55SG9sZHMAAQU4VG9vTWFueUZyZWV6ZXMAAQVMSXNzdWFuY2VEZWFjdGl2YXRlZAABBSREZWx0YVplcm8AAQUCDQJcUm9vdE5ldHdvcmtEb2VzTm90RXhpc3QAAQU0SW52YWxpZElwVHlwZQABBUBJbnZhbGlkSXBBZGRyZXNzAAEFLEludmFsaWRQb3J0AAEFbEhvdEtleU5vdFJlZ2lzdGVyZWRJblN1Yk5ldAABBVhIb3RLZXlBY2NvdW50Tm90RXhpc3RzAAEFcEhvdEtleU5vdFJlZ2lzdGVyZWRJbk5ldHdvcmsAAQVQTm9uQXNzb2NpYXRlZENvbGRLZXkAAQU4Tm90RW5vdWdoU3Rha2UAAQVgTm90RW5vdWdoU3Rha2VUb1dpdGhkcmF3AAEFaE5vdEVub3VnaFN0YWtlVG9TZXRXZWlnaHRzAAEFcE5vdEVub3VnaFN0YWtlVG9TZXRDaGlsZGtleXMAAQVcTm90RW5vdWdoQmFsYW5jZVRvU3Rha2UAAQVYQmFsYW5jZVdpdGhkcmF3YWxFcnJvcgABBWRaZXJvQmFsYW5jZUFmdGVyV2l0aGRyYXduAAEFXE5ldXJvbk5vVmFsaWRhdG9yUGVybWl0AAEFVFdlaWdodFZlY05vdEVxdWFsU2l6ZQABBTREdXBsaWNhdGVVaWRzAAEFXFVpZFZlY0NvbnRhaW5JbnZhbGlkT25lAAEFUFdlaWdodFZlY0xlbmd0aElzTG93AAEFdFRvb01hbnlSZWdpc3RyYXRpb25zVGhpc0Jsb2NrAAEFfEhvdEtleUFscmVhZHlSZWdpc3RlcmVkSW5TdWJOZXQAAQVYTmV3SG90S2V5SXNTYW1lV2l0aE9sZAABBUBJbnZhbGlkV29ya0Jsb2NrAAEFREludmFsaWREaWZmaWN1bHR5AAEFLEludmFsaWRTZWFsAAEFRE1heFdlaWdodEV4Y2VlZGVkAAEFVEhvdEtleUFscmVhZHlEZWxlZ2F0ZQABBVRTZXR0aW5nV2VpZ2h0c1Rvb0Zhc3QAAQVkSW5jb3JyZWN0V2VpZ2h0VmVyc2lvbktleQABBWBTZXJ2aW5nUmF0ZUxpbWl0RXhjZWVkZWQAAQVwVWlkc0xlbmd0aEV4Y2VlZFVpZHNJblN1Yk5ldAABBWhOZXR3b3JrVHhSYXRlTGltaXRFeGNlZWRlZAABBWxEZWxlZ2F0ZVR4UmF0ZUxpbWl0RXhjZWVkZWQAAQVwSG90S2V5U2V0VHhSYXRlTGltaXRFeGNlZWRlZAABBWBTdGFraW5nUmF0ZUxpbWl0RXhjZWVkZWQAAQVoU3ViTmV0UmVnaXN0cmF0aW9uRGlzYWJsZWQAAQWAVG9vTWFueVJlZ2lzdHJhdGlvbnNUaGlzSW50ZXJ2YWwAAQV8VHJhbnNhY3RvckFjY291bnRTaG91bGRCZUhvdEtleQABBThGYXVjZXREaXNhYmxlZAABBThOb3RTdWJuZXRPd25lcgABBZBSZWdpc3RyYXRpb25Ob3RQZXJtaXR0ZWRPblJvb3RTdWJuZXQAAQVIU3Rha2VUb29Mb3dGb3JSb290AAEFVEFsbE5ldHdvcmtzSW5JbW11bml0eQABBXxOb3RFbm91Z2hCYWxhbmNlVG9QYXlTd2FwSG90S2V5AAEFNE5vdFJvb3RTdWJuZXQAAQVsQ2FuTm90U2V0Um9vdE5ldHdvcmtXZWlnaHRzAAEFTE5vTmV1cm9uSWRBdmFpbGFibGUAAQVIRGVsZWdhdGVUYWtlVG9vTG93AAEFTERlbGVnYXRlVGFrZVRvb0hpZ2gAAQVQTm9XZWlnaHRzQ29tbWl0Rm91bmQAAQV8SW52YWxpZFJldmVhbENvbW1pdEhhc2hOb3RNYXRjaAABBUxDb21taXRSZXZlYWxFbmFibGVkAAEFUENvbW1pdFJldmVhbERpc2FibGVkAAEFTExpcXVpZEFscGhhRGlzYWJsZWQAAQU8QWxwaGFIaWdoVG9vTG93AAEFSEFscGhhTG93T3V0T2ZSYW5nZQABBWBDb2xkS2V5QWxyZWFkeUFzc29jaWF0ZWQAAQWATm90RW5vdWdoQmFsYW5jZVRvUGF5U3dhcENvbGRLZXkAAQUwSW52YWxpZENoaWxkAAEFOER1cGxpY2F0ZUNoaWxkAAEFSFByb3BvcnRpb25PdmVyZmxvdwABBTxUb29NYW55Q2hpbGRyZW4AAQVMVHhSYXRlTGltaXRFeGNlZWRlZAABBXxDb2xka2V5U3dhcEFubm91bmNlbWVudE5vdEZvdW5kAAEFTENvbGRrZXlTd2FwVG9vRWFybHkAAQV4Q29sZGtleVN3YXBSZWFubm91bmNlZFRvb0Vhcmx5AAEFgEFubm91bmNlZENvbGRrZXlIYXNoRG9lc05vdE1hdGNoAAEFaENvbGRrZXlTd2FwQWxyZWFkeURpc3B1dGVkAAEFSE5ld0NvbGRLZXlJc0hvdGtleQABBUxJbnZhbGlkQ2hpbGRrZXlUYWtlAAEFfFR4Q2hpbGRrZXlUYWtlUmF0ZUxpbWl0RXhjZWVkZWQAAQU8SW52YWxpZElkZW50aXR5AAEFVE1lY2hhbmlzbURvZXNOb3RFeGlzdAABBURDYW5ub3RVbnN0YWtlTG9jawABBTxTdWJuZXROb3RFeGlzdHMAAQVgVG9vTWFueVVucmV2ZWFsZWRDb21taXRzAAEFTEV4cGlyZWRXZWlnaHRDb21taXQAAQU4UmV2ZWFsVG9vRWFybHkAAQVMSW5wdXRMZW5ndGhzVW5lcXVhbAABBWBDb21taXR0aW5nV2VpZ2h0c1Rvb0Zhc3QAAQUwQW1vdW50VG9vTG93AAEFVEluc3VmZmljaWVudExpcXVpZGl0eQABBTxTbGlwcGFnZVRvb0hpZ2gAAQVIVHJhbnNmZXJEaXNhbGxvd2VkAAEFUEFjdGl2aXR5Q3V0b2ZmVG9vTG93AAEFMENhbGxEaXNhYmxlZAABBYhGaXJzdEVtaXNzaW9uQmxvY2tOdW1iZXJBbHJlYWR5U2V0AAEFfE5lZWRXYWl0aW5nTW9yZUJsb2Nrc1RvU3RhckNhbGwAAQVoTm90RW5vdWdoQWxwaGFPdXRUb1JlY3ljbGUAAQV8Q2Fubm90QnVybk9yUmVjeWNsZU9uUm9vdFN1Ym5ldAABBWBVbmFibGVUb1JlY292ZXJQdWJsaWNLZXkAAQVkSW52YWxpZFJlY292ZXJlZFB1YmxpY0tleQABBUBTdWJ0b2tlbkRpc2FibGVkAAEFjEhvdEtleVN3YXBPblN1Ym5ldEludGVydmFsTm90UGFzc2VkAAEFSFplcm9NYXhTdGFrZUFtb3VudAABBShTYW1lTmV0dWlkAAEFTEluc3VmZmljaWVudEJhbGFuY2UAAQWEU3Rha2luZ09wZXJhdGlvblJhdGVMaW1pdEV4Y2VlZGVkAAEFXEludmFsaWRMZWFzZUJlbmVmaWNpYXJ5AAEFXExlYXNlQ2Fubm90RW5kSW5UaGVQYXN0AAEFTExlYXNlTmV0dWlkTm90Rm91bmQAAQVETGVhc2VEb2VzTm90RXhpc3QAAQVITGVhc2VIYXNOb0VuZEJsb2NrAAEFQExlYXNlSGFzTm90RW5kZWQAAQUgT3ZlcmZsb3cAAQVsQmVuZWZpY2lhcnlEb2VzTm90T3duSG90a2V5AAEFZEV4cGVjdGVkQmVuZWZpY2lhcnlPcmlnaW4AAQWgQWRtaW5BY3Rpb25Qcm9oaWJpdGVkRHVyaW5nV2VpZ2h0c1dpbmRvdwABBUhTeW1ib2xEb2VzTm90RXhpc3QAAQVIU3ltYm9sQWxyZWFkeUluVXNlAAEFcEluY29ycmVjdENvbW1pdFJldmVhbFZlcnNpb24AAQVQUmV2ZWFsUGVyaW9kVG9vTGFyZ2UAAQVQUmV2ZWFsUGVyaW9kVG9vU21hbGwAAQUwSW52YWxpZFZhbHVlAAEFSFN1Ym5ldExpbWl0UmVhY2hlZAABBVBDYW5ub3RBZmZvcmRMb2NrQ29zdAABBYBFdm1LZXlBc3NvY2lhdGVSYXRlTGltaXRFeGNlZWRlZAABBXRTYW1lQXV0b1N0YWtlSG90a2V5QWxyZWFkeVNldAABBVxVaWRNYXBDb3VsZE5vdEJlQ2xlYXJlZAABBZhUcmltbWluZ1dvdWxkRXhjZWVkTWF4SW1tdW5lUGVyY2VudGFnZQABBWBDaGlsZFBhcmVudEluY29uc2lzdGVuY3kAAQVMSW52YWxpZE51bVJvb3RDbGFpbQABBWRJbnZhbGlkUm9vdENsYWltVGhyZXNob2xkAAEFTEludmFsaWRTdWJuZXROdW1iZXIAAQVcVG9vTWFueVVJRHNQZXJNZWNoYW5pc20AAQV0Vm90aW5nUG93ZXJUcmFja2luZ05vdEVuYWJsZWQAAQVoSW52YWxpZFZvdGluZ1Bvd2VyRW1hQWxwaGEAAQU0UHJlY2lzaW9uTG9zcwABBShEZXByZWNhdGVkAAEFdEFkZFN0YWtlQnVyblJhdGVMaW1pdEV4Y2VlZGVkAAEFAggwVG9vTWFueUNhbGxzAAEFVEludmFsaWREZXJpdmVkQWNjb3VudAABBQIELFJlcXVpcmVTdWRvAAEFAjhATWluaW11bVRocmVzaG9sZAABBTxBbHJlYWR5QXBwcm92ZWQAAQVETm9BcHByb3ZhbHNOZWVkZWQAAQVEVG9vRmV3U2lnbmF0b3JpZXMAAQVIVG9vTWFueVNpZ25hdG9yaWVzAAEFVFNpZ25hdG9yaWVzT3V0T2ZPcmRlcgABBUxTZW5kZXJJblNpZ25hdG9yaWVzAAEFIE5vdEZvdW5kAAEFIE5vdE93bmVyAAEFLE5vVGltZXBvaW50AAEFOFdyb25nVGltZXBvaW50AAEFTFVuZXhwZWN0ZWRUaW1lcG9pbnQAAQU8TWF4V2VpZ2h0VG9vTG93AAEFNEFscmVhZHlTdG9yZWQAAQUCIBhUb29CaWcAAQUwQWxyZWFkeU5vdGVkAAEFNE5vdEF1dGhvcml6ZWQAAQUgTm90Tm90ZWQAAQUkUmVxdWVzdGVkAAEFME5vdFJlcXVlc3RlZAABBRxUb29NYW55AAEFGFRvb0ZldwABBQIUQEZhaWxlZFRvU2NoZWR1bGUAAQUgTm90Rm91bmQAAQVcVGFyZ2V0QmxvY2tOdW1iZXJJblBhc3QAAQVIUmVzY2hlZHVsZU5vQ2hhbmdlAAEFFE5hbWVkAAEFAigcVG9vTWFueQABBSBOb3RGb3VuZAABBSBOb3RQcm94eQABBSxVbnByb3h5YWJsZQABBSREdXBsaWNhdGUAAQUwTm9QZXJtaXNzaW9uAAEFLFVuYW5ub3VuY2VkAAEFLE5vU2VsZlByb3h5AAEFkEFubm91bmNlbWVudERlcG9zaXRJbnZhcmlhbnRWaW9sYXRlZAABBVxJbnZhbGlkRGVyaXZlZEFjY291bnRJZAABBQIMOENhbm5vdFJlZ2lzdGVyAAEFbFRvb01hbnlGaWVsZHNJbklkZW50aXR5SW5mbwABBTROb3RSZWdpc3RlcmVkAAEFAhB0VG9vTWFueUZpZWxkc0luQ29tbWl0bWVudEluZm8AAQVcQWNjb3VudE5vdEFsbG93ZWRDb21taXQAAQVIU3BhY2VMaW1pdEV4Y2VlZGVkAAEFbFVuZXhwZWN0ZWRVbnJlc2VydmVMZWZ0b3ZlcgABBQIsSFN1Ym5ldERvZXNOb3RFeGlzdAABBXhNYXhWYWxpZGF0b3JzTGFyZ2VyVGhhbk1heFVJZHMAAQWETWF4QWxsb3dlZFVJZHNMZXNzVGhhbkN1cnJlbnRVSWRzAAEFcEJvbmRzTW92aW5nQXZlcmFnZU1heFJlYWNoZWQAAQVgTmVnYXRpdmVTaWdtb2lkU3RlZXBuZXNzAAEFQFZhbHVlTm90SW5Cb3VuZHMAAQWQTWluQWxsb3dlZFVpZHNHcmVhdGVyVGhhbkN1cnJlbnRVaWRzAAEFnE1pbkFsbG93ZWRVaWRzR3JlYXRlclRoYW5NYXhBbGxvd2VkVWlkcwABBZBNYXhBbGxvd2VkVWlkc0xlc3NUaGFuTWluQWxsb3dlZFVpZHMAAQW4TWF4QWxsb3dlZFVpZHNHcmVhdGVyVGhhbkRlZmF1bHRNYXhBbGxvd2VkVWlkcwABBTBJbnZhbGlkVmFsdWUAAQUCHBxFbnRlcmVkAAEFGEV4aXRlZAABBTROb3RDb25maWd1cmVkAAEFJE5vRGVwb3NpdAABBUBBbHJlYWR5RGVwb3NpdGVkAAEFQENhbm5vdFJlbGVhc2VZZXQAAQU0Q3VycmVuY3lFcnJvcgABBQIIQEludmFsaWRTaWduYXR1cmUAAQUwUHJlTG9nRXhpc3RzAAEFAjwoQmFsYW5jZUxvdwABBSxGZWVPdmVyZmxvdwABBTxQYXltZW50T3ZlcmZsb3cAAQU4V2l0aGRyYXdGYWlsZWQAAQU4R2FzUHJpY2VUb29Mb3cAAQUwSW52YWxpZE5vbmNlAAEFOEdhc0xpbWl0VG9vTG93AAEFPEdhc0xpbWl0VG9vSGlnaAABBThJbnZhbGlkQ2hhaW5JZAABBUBJbnZhbGlkU2lnbmF0dXJlAAEFKFJlZW50cmFuY3kAAQVoVHJhbnNhY3Rpb25NdXN0Q29tZUZyb21FT0EAAQUkVW5kZWZpbmVkAAEFKE5vdEFsbG93ZWQAAQVYQ3JlYXRlT3JpZ2luTm90QWxsb3dlZAABBQIYJE5vbmVWYWx1ZQABBTxTdG9yYWdlT3ZlcmZsb3cAAQVYRHJhbmRDb25uZWN0aW9uRmFpbHVyZQABBTxVbnZlcmlmaWVkUHVsc2UAAQVISW52YWxpZFJvdW5kTnVtYmVyAAEFWFB1bHNlVmVyaWZpY2F0aW9uRXJyb3IAAQUCWDREZXBvc2l0VG9vTG93AAEFJENhcFRvb0xvdwABBWRNaW5pbXVtQ29udHJpYnV0aW9uVG9vTG93AAEFPENhbm5vdEVuZEluUGFzdAABBVRCbG9ja0R1cmF0aW9uVG9vU2hvcnQAAQVQQmxvY2tEdXJhdGlvblRvb0xvbmcAAQVMSW5zdWZmaWNpZW50QmFsYW5jZQABBSBPdmVyZmxvdwABBUhJbnZhbGlkQ3Jvd2Rsb2FuSWQAAQUkQ2FwUmFpc2VkAAEFXENvbnRyaWJ1dGlvblBlcmlvZEVuZGVkAAEFSENvbnRyaWJ1dGlvblRvb0xvdwABBTRJbnZhbGlkT3JpZ2luAAEFQEFscmVhZHlGaW5hbGl6ZWQAAQVoQ29udHJpYnV0aW9uUGVyaW9kTm90RW5kZWQAAQU4Tm9Db250cmlidXRpb24AAQUwQ2FwTm90UmFpc2VkAAEFJFVuZGVyZmxvdwABBTxDYWxsVW5hdmFpbGFibGUAAQVITm90UmVhZHlUb0Rpc3NvbHZlAAEFYERlcG9zaXRDYW5ub3RCZVdpdGhkcmF3bgABBVhNYXhDb250cmlidXRvcnNSZWFjaGVkAAEFAjg4RmVlUmF0ZVRvb0hpZ2gAAQVcSW5zdWZmaWNpZW50SW5wdXRBbW91bnQAAQVUSW5zdWZmaWNpZW50TGlxdWlkaXR5AAEFSFByaWNlTGltaXRFeGNlZWRlZAABBUxJbnN1ZmZpY2llbnRCYWxhbmNlAAEFRExpcXVpZGl0eU5vdEZvdW5kAAEFQEludmFsaWRUaWNrUmFuZ2UAAQVQTWF4UG9zaXRpb25zRXhjZWVkZWQAAQVAVG9vTWFueVN3YXBTdGVwcwABBVRJbnZhbGlkTGlxdWlkaXR5VmFsdWUAAQU4UmVzZXJ2ZXNUb29Mb3cAAQVUTWVjaGFuaXNtRG9lc05vdEV4aXN0AAEFVFVzZXJMaXF1aWRpdHlEaXNhYmxlZAABBUBTdWJ0b2tlbkRpc2FibGVkAAEFApQ8SW52YWxpZFNjaGVkdWxlAAEFQEludmFsaWRDYWxsRmxhZ3MAAQUgT3V0T2ZHYXMAAQVQT3V0cHV0QnVmZmVyVG9vU21hbGwAAQU4VHJhbnNmZXJGYWlsZWQAAQVMTWF4Q2FsbERlcHRoUmVhY2hlZAABBUBDb250cmFjdE5vdEZvdW5kAAEFMENvZGVUb29MYXJnZQABBTBDb2RlTm90Rm91bmQAAQVAQ29kZUluZm9Ob3RGb3VuZAABBSxPdXRPZkJvdW5kcwABBThEZWNvZGluZ0ZhaWxlZAABBTxDb250cmFjdFRyYXBwZWQAAQU0VmFsdWVUb29MYXJnZQABBWBUZXJtaW5hdGVkV2hpbGVSZWVudHJhbnQAAQU4SW5wdXRGb3J3YXJkZWQAAQVQUmFuZG9tU3ViamVjdFRvb0xvbmcAAQU0VG9vTWFueVRvcGljcwABBUBOb0NoYWluRXh0ZW5zaW9uAAEFPFhDTURlY29kZUZhaWxlZAABBUREdXBsaWNhdGVDb250cmFjdAABBVxUZXJtaW5hdGVkSW5Db25zdHJ1Y3RvcgABBUBSZWVudHJhbmNlRGVuaWVkAAEFRFN0YXRlQ2hhbmdlRGVuaWVkAAEFcFN0b3JhZ2VEZXBvc2l0Tm90RW5vdWdoRnVuZHMAAQVwU3RvcmFnZURlcG9zaXRMaW1pdEV4aGF1c3RlZAABBSRDb2RlSW5Vc2UAAQVAQ29udHJhY3RSZXZlcnRlZAABBTBDb2RlUmVqZWN0ZWQAAQU8SW5kZXRlcm1pbmlzdGljAAEFTE1pZ3JhdGlvbkluUHJvZ3Jlc3MAAQVQTm9NaWdyYXRpb25QZXJmb3JtZWQAAQV4TWF4RGVsZWdhdGVEZXBlbmRlbmNpZXNSZWFjaGVkAAEFaERlbGVnYXRlRGVwZW5kZW5jeU5vdEZvdW5kAAEFfERlbGVnYXRlRGVwZW5kZW5jeUFscmVhZHlFeGlzdHMAAQWEQ2Fubm90QWRkU2VsZkFzRGVsZWdhdGVEZXBlbmRlbmN5AAEFVE91dE9mVHJhbnNpZW50U3RvcmFnZQABBQIcXFN1Ym1pc3Npb25BbHJlYWR5RXhpc3RzAAEFRE1pc3NpbmdTdWJtaXNzaW9uAAEFSENvbW1pdG1lbnRNaXNtYXRjaAABBUBTaWduYXR1cmVJbnZhbGlkAAEFPEJhZFB1YmxpY0tleUxlbgABBShLZXlFeHBpcmVkAAEFPEtleUhhc2hNaXNtYXRjaAABBQJsGFN5c3RlbQFEYFJhbmRvbW5lc3NDb2xsZWN0aXZlRmxpcAABBSRUaW1lc3RhbXAAAQUQQXVyYQABBRxHcmFuZHBhAUggQmFsYW5jZXMBTEhUcmFuc2FjdGlvblBheW1lbnQAAQU8U3VidGVuc29yTW9kdWxlAVAcVXRpbGl0eQFUEFN1ZG8BWCBNdWx0aXNpZwFcIFByZWltYWdlAWAkU2NoZWR1bGVyAWQUUHJveHkBaCBSZWdpc3RyeQFsLENvbW1pdG1lbnRzAXAoQWRtaW5VdGlscwF0IFNhZmVNb2RlAXggRXRoZXJldW0BfAxFVk0BgChFVk1DaGFpbklkAAEFHEJhc2VGZWUAAQUURHJhbmQBhCRDcm93ZGxvYW4BiBBTd2FwAYwkQ29udHJhY3RzAZAkTWV2U2hpZWxkAZQCKEBGdW5kc1VuYXZhaWxhYmxlAAEFME9ubHlQcm92aWRlcgABBTBCZWxvd01pbmltdW0AAQUwQ2Fubm90Q3JlYXRlAAEFMFVua25vd25Bc3NldAABBRhGcm96ZW4AAQUsVW5zdXBwb3J0ZWQAAQVAQ2Fubm90Q3JlYXRlSG9sZAABBTROb3RFeHBlbmRhYmxlAAEFHEJsb2NrZWQAAQUCDCRVbmRlcmZsb3cAAQUgT3ZlcmZsb3cAAQU4RGl2aXNpb25CeVplcm8AAQUCCDBMaW1pdFJlYWNoZWQAAQUcTm9MYXllcgABBQI4QEludmFsaWRTdGF0ZVJvb3QAAQVISW5jb21wbGV0ZURhdGFiYXNlAAEFUFZhbHVlQXRJbmNvbXBsZXRlS2V5AAEFMERlY29kZXJFcnJvcgABBSxJbnZhbGlkSGFzaAABBTBEdXBsaWNhdGVLZXkAAQU4RXh0cmFuZW91c05vZGUAAQU8RXh0cmFuZW91c1ZhbHVlAAEFXEV4dHJhbmVvdXNIYXNoUmVmZXJlbmNlAAEFVEludmFsaWRDaGlsZFJlZmVyZW5jZQABBTRWYWx1ZU1pc21hdGNoAAEFPEluY29tcGxldGVQcm9vZgABBTBSb290TWlzbWF0Y2gAAQUsRGVjb2RlRXJyb3IAAQUCPBRPdGhlcgABBTBDYW5ub3RMb29rdXAAAQUkQmFkT3JpZ2luAAEFGE1vZHVsZQGYRENvbnN1bWVyUmVtYWluaW5nAAEFLE5vUHJvdmlkZXJzAAEFQFRvb01hbnlDb25zdW1lcnMAAQUUVG9rZW4BnChBcml0aG1ldGljAaA0VHJhbnNhY3Rpb25hbAGkJEV4aGF1c3RlZAABBShDb3JydXB0aW9uAAEFLFVuYXZhaWxhYmxlAAEFOFJvb3ROb3RBbGxvd2VkAAEFEFRyaWUBqAIgQEV4dHJpbnNpY1N1Y2Nlc3MAAAQ0ZGlzcGF0Y2hfaW5mb0A8RXh0cmluc2ljRmFpbGVkAAAIOGRpc3BhdGNoX2Vycm9yrDRkaXNwYXRjaF9pbmZvQCxDb2RlVXBkYXRlZAABBShOZXdBY2NvdW50AAAEHGFjY291bnQANEtpbGxlZEFjY291bnQAAAQcYWNjb3VudAAgUmVtYXJrZWQAAAgYc2VuZGVyABBoYXNoIERVcGdyYWRlQXV0aG9yaXplZAAACCRjb2RlX2hhc2ggNGNoZWNrX3ZlcnNpb24UgFJlamVjdGVkSW52YWxpZEF1dGhvcml6ZWRVcGdyYWRlAAAIJGNvZGVfaGFzaCAUZXJyb3KsAwggCAS0AAIMOE5ld0F1dGhvcml0aWVzAAAENGF1dGhvcml0eV9zZXS4GFBhdXNlZAABBRxSZXN1bWVkAAEFAggQRnJlZQABBSBSZXNlcnZlZAABBQJYHEVuZG93ZWQAAAgcYWNjb3VudAAwZnJlZV9iYWxhbmNlCCBEdXN0TG9zdAAACBxhY2NvdW50ABhhbW91bnQIIFRyYW5zZmVyAAAMEGZyb20ACHRvABhhbW91bnQIKEJhbGFuY2VTZXQAAAgMd2hvABBmcmVlCCBSZXNlcnZlZAAACAx3aG8AGGFtb3VudAgoVW5yZXNlcnZlZAAACAx3aG8AGGFtb3VudAhIUmVzZXJ2ZVJlcGF0cmlhdGVkAAAQEGZyb20ACHRvABhhbW91bnQISGRlc3RpbmF0aW9uX3N0YXR1c8AcRGVwb3NpdAAACAx3aG8AGGFtb3VudAggV2l0aGRyYXcAAAgMd2hvABhhbW91bnQIHFNsYXNoZWQAAAgMd2hvABhhbW91bnQIGE1pbnRlZAAACAx3aG8AGGFtb3VudAgYQnVybmVkAAAIDHdobwAYYW1vdW50CCRTdXNwZW5kZWQAAAgMd2hvABhhbW91bnQIIFJlc3RvcmVkAAAIDHdobwAYYW1vdW50CCBVcGdyYWRlZAAABAx3aG8AGElzc3VlZAAABBhhbW91bnQIJFJlc2NpbmRlZAAABBhhbW91bnQIGExvY2tlZAAACAx3aG8AGGFtb3VudAggVW5sb2NrZWQAAAgMd2hvABhhbW91bnQIGEZyb3plbgAACAx3aG8AGGFtb3VudAgYVGhhd2VkAAAIDHdobwAYYW1vdW50CExUb3RhbElzc3VhbmNlRm9yY2VkAAAIDG9sZAgMbmV3CAIESFRyYW5zYWN0aW9uRmVlUGFpZAAADAx3aG8AKGFjdHVhbF9mZWUIDHRpcAgBBQfMrAMICAAE1AAEIAAEBAAFAVAGBAQIAAIMEFN3YXAAAQUQS2VlcAABBSxLZWVwU3VibmV0cwAABBxzdWJuZXRz4ALhATBOZXR3b3JrQWRkZWQABAQBCDhOZXR3b3JrUmVtb3ZlZAEEKFN0YWtlQWRkZWQAAxgAAAgIBAgwU3Rha2VSZW1vdmVkAAMYAAAICAQIKFN0YWtlTW92ZWQAAxgAAAQABAgoV2VpZ2h0c1NldAAEBAEIQE5ldXJvblJlZ2lzdGVyZWQAAwwEBABUQnVsa05ldXJvbnNSZWdpc3RlcmVkAAQEAQg8QnVsa0JhbGFuY2VzU2V0AAQEAQhETWF4QWxsb3dlZFVpZHNTZXQABAQBCERNYXhXZWlnaHRMaW1pdFNldAAEBAEINERpZmZpY3VsdHlTZXQAAwgECFRBZGp1c3RtZW50SW50ZXJ2YWxTZXQABAQBCGhSZWdpc3RyYXRpb25QZXJJbnRlcnZhbFNldAAEBAEIbE1heFJlZ2lzdHJhdGlvbnNQZXJCbG9ja1NldAAEBAEIREFjdGl2aXR5Q3V0b2ZmU2V0AAQEAQgYUmhvU2V0AAQEAQhgQWxwaGFTaWdtb2lkU3RlZXBuZXNzU2V0AAMIBAQgS2FwcGFTZXQABAQBCExNaW5BbGxvd2VkV2VpZ2h0U2V0AAQEAQhQVmFsaWRhdG9yUHJ1bmVMZW5TZXQAAwgECEhTY2FsaW5nTGF3UG93ZXJTZXQABAQBCFhXZWlnaHRzU2V0UmF0ZUxpbWl0U2V0AAMIBAhESW1tdW5pdHlQZXJpb2RTZXQABAQBCFRCb25kc01vdmluZ0F2ZXJhZ2VTZXQAAwgECDxCb25kc1BlbmFsdHlTZXQABAQBCDxCb25kc1Jlc2V0T25TZXQAAwgEFFxNYXhBbGxvd2VkVmFsaWRhdG9yc1NldAAEBAEIKEF4b25TZXJ2ZWQAAwgEAEBQcm9tZXRoZXVzU2VydmVkAAMIBAA0RGVsZWdhdGVBZGRlZAADDAAABDhEZWZhdWx0VGFrZVNldAEEUFdlaWdodHNWZXJzaW9uS2V5U2V0AAMIBAhATWluRGlmZmljdWx0eVNldAADCAQIQE1heERpZmZpY3VsdHlTZXQAAwgECExTZXJ2aW5nUmF0ZUxpbWl0U2V0AAMIBAgcQnVyblNldAADCAQIKE1heEJ1cm5TZXQAAwgECChNaW5CdXJuU2V0AAMIBAg4VHhSYXRlTGltaXRTZXQBCGhUeERlbGVnYXRlVGFrZVJhdGVMaW1pdFNldAEIaFR4Q2hpbGRLZXlUYWtlUmF0ZUxpbWl0U2V0AQhQQWRtaW5GcmVlemVXaW5kb3dTZXQBBGxPd25lckh5cGVycGFyYW1SYXRlTGltaXRTZXQBBEhNaW5DaGlsZEtleVRha2VTZXQBBEhNYXhDaGlsZEtleVRha2VTZXQBBDxDaGlsZEtleVRha2VTZXQAAwgABBRTdWRpZAHQTFJlZ2lzdHJhdGlvbkFsbG93ZWQAAwgEFFhQb3dSZWdpc3RyYXRpb25BbGxvd2VkAAMIBBQgVGVtcG9TZXQABAQBCHRSQU9SZWN5Y2xlZEZvclJlZ2lzdHJhdGlvblNldAADCAQIRFN0YWtlVGhyZXNob2xkU2V0AQhIQWRqdXN0bWVudEFscGhhU2V0AAMIBAgYRmF1Y2V0AAMIAAhEU3VibmV0T3duZXJDdXRTZXQBBExOZXR3b3JrUmF0ZUxpbWl0U2V0AQhgTmV0d29ya0ltbXVuaXR5UGVyaW9kU2V0AQhEU3RhcnRDYWxsRGVsYXlTZXQBCFROZXR3b3JrTWluTG9ja0Nvc3RTZXQBCDhTdWJuZXRMaW1pdFNldAEEjE5ldHdvcmtMb2NrQ29zdFJlZHVjdGlvbkludGVydmFsU2V0AQg0VGFrZURlY3JlYXNlZAADDAAABDRUYWtlSW5jcmVhc2VkAAMMAAAENEhvdGtleVN3YXBwZWQAAAwcY29sZGtleQAob2xkX2hvdGtleQAobmV3X2hvdGtleQBITWF4RGVsZWdhdGVUYWtlU2V0AQRITWluRGVsZWdhdGVUYWtlU2V0AQRQQ29sZGtleVN3YXBBbm5vdW5jZWQAAAgMd2hvAEBuZXdfY29sZGtleV9oYXNoIEBDb2xka2V5U3dhcFJlc2V0AAAEDHdobwA4Q29sZGtleVN3YXBwZWQAAAgsb2xkX2NvbGRrZXkALG5ld19jb2xka2V5AExDb2xka2V5U3dhcERpc3B1dGVkAAAEHGNvbGRrZXkAsEFsbEJhbGFuY2VVbnN0YWtlZEFuZFRyYW5zZmVycmVkVG9OZXdDb2xka2V5AAAMPGN1cnJlbnRfY29sZGtleQAsbmV3X2NvbGRrZXkANHRvdGFsX2JhbGFuY2UIZEFyYml0cmF0aW9uUGVyaW9kRXh0ZW5kZWQAAAQcY29sZGtleQBQU2V0Q2hpbGRyZW5TY2hlZHVsZWQAAxAABAjYLFNldENoaWxkcmVuAAMMAATYQENoYWluSWRlbnRpdHlTZXQBAERTdWJuZXRJZGVudGl0eVNldAEEVFN1Ym5ldElkZW50aXR5UmVtb3ZlZAEEYERpc3NvbHZlTmV0d29ya1NjaGVkdWxlZAAADBxhY2NvdW50ABhuZXR1aWQEPGV4ZWN1dGlvbl9ibG9jawR8Q29sZGtleVN3YXBBbm5vdW5jZW1lbnREZWxheVNldAEEhENvbGRrZXlTd2FwUmVhbm5vdW5jZW1lbnREZWxheVNldAEEiERpc3NvbHZlTmV0d29ya1NjaGVkdWxlRHVyYXRpb25TZXQBBFBDUlYzV2VpZ2h0c0NvbW1pdHRlZAADDAAEIEBXZWlnaHRzQ29tbWl0dGVkAAMMAAQgPFdlaWdodHNSZXZlYWxlZAADDAAEIFBXZWlnaHRzQmF0Y2hSZXZlYWxlZAADDAAE3FRCYXRjaFdlaWdodHNDb21wbGV0ZWQAAwjgAGBCYXRjaENvbXBsZXRlZFdpdGhFcnJvcnMAAQVUQmF0Y2hXZWlnaHRJdGVtRmFpbGVkAaxAU3Rha2VUcmFuc2ZlcnJlZAADGAAAAAQECDBTdGFrZVN3YXBwZWQAAxQAAAQECDhUcmFuc2ZlclRvZ2dsZQADCAQUUFN1Ym5ldE93bmVySG90a2V5U2V0AAMIBABsRmlyc3RFbWlzc2lvbkJsb2NrTnVtYmVyU2V0AAMIBAg0QWxwaGFSZWN5Y2xlZAADEAAACAQsQWxwaGFCdXJuZWQAAxAAAAgEQEV2bUtleUFzc29jaWF0ZWQAABAYbmV0dWlkBBhob3RrZXkAHGV2bV9rZXnkQGJsb2NrX2Fzc29jaWF0ZWQITENSVjNXZWlnaHRzUmV2ZWFsZWQAAwgEAFhDb21taXRSZXZlYWxQZXJpb2RzU2V0AAMIBAhMQ29tbWl0UmV2ZWFsRW5hYmxlZAADCAQUVEhvdGtleVN3YXBwZWRPblN1Ym5ldAAAEBxjb2xka2V5AChvbGRfaG90a2V5AChuZXdfaG90a2V5ABhuZXR1aWQESFN1Ym5ldExlYXNlQ3JlYXRlZAAAECxiZW5lZmljaWFyeQAgbGVhc2VfaWQEGG5ldHVpZAQkZW5kX2Jsb2Nr6FRTdWJuZXRMZWFzZVRlcm1pbmF0ZWQAAAgsYmVuZWZpY2lhcnkAGG5ldHVpZAQ0U3ltYm9sVXBkYXRlZAAACBhuZXR1aWQEGHN5bWJvbCRYQ29tbWl0UmV2ZWFsVmVyc2lvblNldAEEaFRpbWVsb2NrZWRXZWlnaHRzQ29tbWl0dGVkAAMQAAQgCGRUaW1lbG9ja2VkV2VpZ2h0c1JldmVhbGVkAAMIBAA4QXV0b1N0YWtlQWRkZWQAABQYbmV0dWlkBCxkZXN0aW5hdGlvbgAYaG90a2V5ABRvd25lcgAkaW5jZW50aXZlCHRJbmNlbnRpdmVBbHBoYUVtaXR0ZWRUb01pbmVycwAACBhuZXR1aWQEJGVtaXNzaW9uc+xETWluQWxsb3dlZFVpZHNTZXQABAQBCFxBdXRvU3Rha2VEZXN0aW5hdGlvblNldAAADBxjb2xka2V5ABhuZXR1aWQEGGhvdGtleQBMTWluTm9uSW1tdW5lVWlkc1NldAAEBAEILFJvb3RDbGFpbWVkAAAEHGNvbGRrZXkAQFJvb3RDbGFpbVR5cGVTZXQAAAgcY29sZGtleQA8cm9vdF9jbGFpbV90eXBl8GhWb3RpbmdQb3dlclRyYWNraW5nRW5hYmxlZAAABBhuZXR1aWQEjFZvdGluZ1Bvd2VyVHJhY2tpbmdEaXNhYmxlU2NoZWR1bGVkAAAIGG5ldHVpZARAZGlzYWJsZV9hdF9ibG9jawhsVm90aW5nUG93ZXJUcmFja2luZ0Rpc2FibGVkAAAEGG5ldHVpZARYVm90aW5nUG93ZXJFbWFBbHBoYVNldAAACBhuZXR1aWQEFGFscGhhCHxTdWJuZXRMZWFzZURpdmlkZW5kc0Rpc3RyaWJ1dGVkAAAMIGxlYXNlX2lkBCxjb250cmlidXRvcgAUYWxwaGEIMEFkZFN0YWtlQnVybgAAEBhuZXR1aWQEGGhvdGtleQAYYW1vdW50CBRhbHBoYQgCIEBCYXRjaEludGVycnVwdGVkAAAIFGluZGV4BBRlcnJvcqw4QmF0Y2hDb21wbGV0ZWQAAQVgQmF0Y2hDb21wbGV0ZWRXaXRoRXJyb3JzAAEFNEl0ZW1Db21wbGV0ZWQAAQUoSXRlbUZhaWxlZAAABBRlcnJvcqwwRGlzcGF0Y2hlZEFzAAAEGHJlc3VsdNBESWZFbHNlTWFpblN1Y2Nlc3MAAQVQSWZFbHNlRmFsbGJhY2tDYWxsZWQAAAQobWFpbl9lcnJvcqwGAAIQFFN1ZGlkAAAELHN1ZG9fcmVzdWx00ChLZXlDaGFuZ2VkAAAIDG9sZPwMbmV3AChLZXlSZW1vdmVkAAEFKFN1ZG9Bc0RvbmUAAAQsc3Vkb19yZXN1bHTQAAgYaGVpZ2h0BBRpbmRleAQCFCxOZXdNdWx0aXNpZwAADCRhcHByb3ZpbmcAIG11bHRpc2lnACRjYWxsX2hhc2ggQE11bHRpc2lnQXBwcm92YWwAABAkYXBwcm92aW5nACR0aW1lcG9pbnQFASBtdWx0aXNpZwAkY2FsbF9oYXNoIEBNdWx0aXNpZ0V4ZWN1dGVkAAAUJGFwcHJvdmluZwAkdGltZXBvaW50BQEgbXVsdGlzaWcAJGNhbGxfaGFzaCAYcmVzdWx00ERNdWx0aXNpZ0NhbmNlbGxlZAAAEChjYW5jZWxsaW5nACR0aW1lcG9pbnQFASBtdWx0aXNpZwAkY2FsbF9oYXNoIDBEZXBvc2l0UG9rZWQAABAMd2hvACRjYWxsX2hhc2ggLG9sZF9kZXBvc2l0CCxuZXdfZGVwb3NpdAgCDBROb3RlZAAABBBoYXNoICRSZXF1ZXN0ZWQAAAQQaGFzaCAcQ2xlYXJlZAAABBBoYXNoIAQEAQgGIAIoJFNjaGVkdWxlZAAACBB3aGVuBBRpbmRleAQgQ2FuY2VsZWQAAAgQd2hlbgQUaW5kZXgEKERpc3BhdGNoZWQAAAwQdGFzaxEBCGlkFQEYcmVzdWx00CBSZXRyeVNldAAAEBB0YXNrEQEIaWQVARhwZXJpb2QEHHJldHJpZXMEOFJldHJ5Q2FuY2VsbGVkAAAIEHRhc2sRAQhpZBUBPENhbGxVbmF2YWlsYWJsZQAACBB0YXNrEQEIaWQVAThQZXJpb2RpY0ZhaWxlZAAACBB0YXNrEQEIaWQVASxSZXRyeUZhaWxlZAAACBB0YXNrEQEIaWQVAVRQZXJtYW5lbnRseU92ZXJ3ZWlnaHQAAAgQdGFzaxEBCGlkFQFAQWdlbmRhSW5jb21wbGV0ZQAABBB3aGVuBAJIDEFueQABBRRPd25lcgABBSxOb25Dcml0aWNhbAABBSxOb25UcmFuc2ZlcgABBRhTZW5hdGUAAQUsTm9uRnVuZ2libGUAAQUsVHJpdW12aXJhdGUAAQUoR292ZXJuYW5jZQABBRxTdGFraW5nAAEFMFJlZ2lzdHJhdGlvbgABBSBUcmFuc2ZlcgABBTRTbWFsbFRyYW5zZmVyAAEFLFJvb3RXZWlnaHRzAAEFJENoaWxkS2V5cwABBVBTdWRvVW5jaGVja2VkU2V0Q29kZQABBShTd2FwSG90a2V5AAEFWFN1Ym5ldExlYXNlQmVuZWZpY2lhcnkAAQUkUm9vdENsYWltAAEFAggcUHJveGllcwABBTRBbm5vdW5jZW1lbnRzAAEFAhw0UHJveHlFeGVjdXRlZAAABBhyZXN1bHTQLFB1cmVDcmVhdGVkAAAQEHB1cmUADHdobwAocHJveHlfdHlwZR0BUGRpc2FtYmlndWF0aW9uX2luZGV4BChQdXJlS2lsbGVkAAAQEHB1cmUAHHNwYXduZXIAKHByb3h5X3R5cGUdAVBkaXNhbWJpZ3VhdGlvbl9pbmRleAQkQW5ub3VuY2VkAAAMEHJlYWwAFHByb3h5ACRjYWxsX2hhc2ggKFByb3h5QWRkZWQAABAkZGVsZWdhdG9yACRkZWxlZ2F0ZWUAKHByb3h5X3R5cGUdARRkZWxheQQwUHJveHlSZW1vdmVkAAAQJGRlbGVnYXRvcgAkZGVsZWdhdGVlAChwcm94eV90eXBlHQEUZGVsYXkEMERlcG9zaXRQb2tlZAAAEAx3aG8AEGtpbmQhASxvbGRfZGVwb3NpdAgsbmV3X2RlcG9zaXQIAggsSWRlbnRpdHlTZXQAAAQMd2hvAERJZGVudGl0eURpc3NvbHZlZAAABAx3aG8AAgwoQ29tbWl0bWVudAAACBhuZXR1aWQEDHdobwBIVGltZWxvY2tDb21taXRtZW50AAAMGG5ldHVpZAQMd2hvADByZXZlYWxfcm91bmQISENvbW1pdG1lbnRSZXZlYWxlZAAACBhuZXR1aWQEDHdobwACMDxCYWxhbmNlVHJhbnNmZXIAAQUcU3Rha2luZwABBRhTdWJuZXQAAQUkTWV0YWdyYXBoAAEFGE5ldXJvbgABBSRVaWRMb29rdXAAAQUUQWxwaGEAAQUkQ3Jvd2Rsb2FuAAEFFFByb3h5AAEFHExlYXNpbmcAAQU4QWRkcmVzc01hcHBpbmcAAQUsVm90aW5nUG93ZXIAAQUCDERQcmVjb21waWxlVXBkYXRlZAAACDRwcmVjb21waWxlX2lkMQEcZW5hYmxlZBRIWXVtYTNFbmFibGVUb2dnbGVkAAAIGG5ldHVpZAQcZW5hYmxlZBREQm9uZHNSZXNldFRvZ2dsZWQAAAgYbmV0dWlkBBxlbmFibGVkFAIIHFRpbWVvdXQAAQUURm9yY2UAAQUCIBxFbnRlcmVkAAAEFHVudGlsBCBFeHRlbmRlZAAABBR1bnRpbAQYRXhpdGVkAAAEGHJlYXNvbjkBNERlcG9zaXRQbGFjZWQAAAgcYWNjb3VudAAYYW1vdW50CDxEZXBvc2l0UmVsZWFzZWQAAAgcYWNjb3VudAAYYW1vdW50CDhEZXBvc2l0U2xhc2hlZAAACBxhY2NvdW50ABhhbW91bnQINENhbm5vdERlcG9zaXQAAQU0Q2Fubm90UmVsZWFzZQABBQIMHFN0b3BwZWQAAQUgUmV0dXJuZWQAAQUgU3VpY2lkZWQAAQUBAQJAOFN0YWNrVW5kZXJmbG93AAEFNFN0YWNrT3ZlcmZsb3cAAQUsSW52YWxpZEp1bXAAAQUwSW52YWxpZFJhbmdlAAEFRERlc2lnbmF0ZWRJbnZhbGlkAAEFLENhbGxUb29EZWVwAAEFPENyZWF0ZUNvbGxpc2lvbgABBUxDcmVhdGVDb250cmFjdExpbWl0AAEFLEludmFsaWRDb2RlAQQsT3V0T2ZPZmZzZXQAAQUgT3V0T2ZHYXMAAQUkT3V0T2ZGdW5kAAEFLFBDVW5kZXJmbG93AAEFLENyZWF0ZUVtcHR5AAEFFE90aGVyAUUBIE1heE5vbmNlAAEFAgQgUmV2ZXJ0ZWQAAQUCEDBOb3RTdXBwb3J0ZWQAAQVIVW5oYW5kbGVkSW50ZXJydXB0AAEFQENhbGxFcnJvckFzRmF0YWwBSQEUT3RoZXIBRQECEBxTdWNjZWVkAUEBFEVycm9yAUkBGFJldmVydAFNARRGYXRhbAFRAQIEIEV4ZWN1dGVkAAAUEGZyb23kCHRv5EB0cmFuc2FjdGlvbl9oYXNoICxleGl0X3JlYXNvblUBKGV4dHJhX2RhdGEkAAwcYWRkcmVzc+QYdG9waWNz3BBkYXRhJAIUDExvZwAABAxsb2ddARxDcmVhdGVkAAAEHGFkZHJlc3PkNENyZWF0ZWRGYWlsZWQAAAQcYWRkcmVzc+QgRXhlY3V0ZWQAAAQcYWRkcmVzc+Q4RXhlY3V0ZWRGYWlsZWQAAAQcYWRkcmVzc+QECAEQAgxATmV3QmFzZUZlZVBlckdhcwAABAxmZWVlATxCYXNlRmVlT3ZlcmZsb3cAAQU0TmV3RWxhc3RpY2l0eQAABChlbGFzdGljaXR5BAIMTEJlYWNvbkNvbmZpZ0NoYW5nZWQAAQUgTmV3UHVsc2UAAAQYcm91bmRz7FBTZXRPbGRlc3RTdG9yZWRSb3VuZAEIAigcQ3JlYXRlZAAAEDBjcm93ZGxvYW5faWQEHGNyZWF0b3IADGVuZAQMY2FwCCxDb250cmlidXRlZAAADDBjcm93ZGxvYW5faWQELGNvbnRyaWJ1dG9yABhhbW91bnQIIFdpdGhkcmV3AAAMMGNyb3dkbG9hbl9pZAQsY29udHJpYnV0b3IAGGFtb3VudAhEUGFydGlhbGx5UmVmdW5kZWQAAAQwY3Jvd2Rsb2FuX2lkBCxBbGxSZWZ1bmRlZAAABDBjcm93ZGxvYW5faWQEJEZpbmFsaXplZAAABDBjcm93ZGxvYW5faWQEJERpc3NvbHZlZAAABDBjcm93ZGxvYW5faWQEWE1pbkNvbnRyaWJ1dGlvblVwZGF0ZWQAAAgwY3Jvd2Rsb2FuX2lkBFBuZXdfbWluX2NvbnRyaWJ1dGlvbggoRW5kVXBkYXRlZAAACDBjcm93ZGxvYW5faWQEHG5ld19lbmQEKENhcFVwZGF0ZWQAAAgwY3Jvd2Rsb2FuX2lkBBxuZXdfY2FwCAIUKEZlZVJhdGVTZXQAAAgYbmV0dWlkBBByYXRlBFBVc2VyTGlxdWlkaXR5VG9nZ2xlZAAACBhuZXR1aWQEGGVuYWJsZRQ4TGlxdWlkaXR5QWRkZWQAACQcY29sZGtleQAYaG90a2V5ABhuZXR1aWQELHBvc2l0aW9uX2lkCCRsaXF1aWRpdHkIDHRhbwgUYWxwaGEIIHRpY2tfbG93BCR0aWNrX2hpZ2gEQExpcXVpZGl0eVJlbW92ZWQAACwcY29sZGtleQAYaG90a2V5ABhuZXR1aWQELHBvc2l0aW9uX2lkCCRsaXF1aWRpdHkIDHRhbwgUYWxwaGEIHGZlZV90YW8IJGZlZV9hbHBoYQggdGlja19sb3cEJHRpY2tfaGlnaARETGlxdWlkaXR5TW9kaWZpZWQAACwcY29sZGtleQAYaG90a2V5ABhuZXR1aWQELHBvc2l0aW9uX2lkCCRsaXF1aWRpdHkIDHRhbwgUYWxwaGEIHGZlZV90YW8IJGZlZV9hbHBoYQggdGlja19sb3cEJHRpY2tfaGlnaAQCCBBSb290AAEFGFNpZ25lZAEAAigwSW5zdGFudGlhdGVkAAAIIGRlcGxveWVyACBjb250cmFjdAAoVGVybWluYXRlZAAACCBjb250cmFjdAAsYmVuZWZpY2lhcnkAKENvZGVTdG9yZWQAAAwkY29kZV9oYXNoIDBkZXBvc2l0X2hlbGQIIHVwbG9hZGVyADxDb250cmFjdEVtaXR0ZWQAAAggY29udHJhY3QAEGRhdGEkLENvZGVSZW1vdmVkAAAMJGNvZGVfaGFzaCBAZGVwb3NpdF9yZWxlYXNlZAgccmVtb3ZlcgBMQ29udHJhY3RDb2RlVXBkYXRlZAAADCBjb250cmFjdAA0bmV3X2NvZGVfaGFzaCA0b2xkX2NvZGVfaGFzaCAYQ2FsbGVkAAAIGGNhbGxlcnkBIGNvbnRyYWN0ADhEZWxlZ2F0ZUNhbGxlZAAACCBjb250cmFjdAAkY29kZV9oYXNoIIBTdG9yYWdlRGVwb3NpdFRyYW5zZmVycmVkQW5kSGVsZAAADBBmcm9tAAh0bwAYYW1vdW50CJBTdG9yYWdlRGVwb3NpdFRyYW5zZmVycmVkQW5kUmVsZWFzZWQAAAwQZnJvbQAIdG8AGGFtb3VudAgGGAAINGFjdHVhbF93ZWlnaHSBASBwYXlzX2ZlZTwACCRwb3N0X2luZm+FARRlcnJvcqwCEEhFbmNyeXB0ZWRTdWJtaXR0ZWQAAAgIaWQgDHdobwBERGVjcnlwdGVkRXhlY3V0ZWQAAAgIaWQgGHNpZ25lcgBERGVjcnlwdGVkUmVqZWN0ZWQAAAgIaWQgGHJlYXNvbokBQERlY3J5cHRpb25GYWlsZWQAAAgIaWQgGHJlYXNvbiQCXBhTeXN0ZW0BsBxHcmFuZHBhAbwgQmFsYW5jZXMBxEhUcmFuc2FjdGlvblBheW1lbnQByDxTdWJ0ZW5zb3JNb2R1bGUB9BxVdGlsaXR5AfgQU3VkbwEBASBNdWx0aXNpZwEJASBQcmVpbWFnZQENASRTY2hlZHVsZXIBGQEUUHJveHkBJQEgUmVnaXN0cnkBKQEsQ29tbWl0bWVudHMBLQEoQWRtaW5VdGlscwE1ASBTYWZlTW9kZQE9ASBFdGhlcmV1bQFZAQxFVk0BYQEcQmFzZUZlZQFpARREcmFuZAFtASRDcm93ZGxvYW4BcQEQU3dhcAF1ASRDb250cmFjdHMBfQEkTWV2U2hpZWxkAY0BAAwUcGhhc2U0FGV2ZW50kQEYdG9waWNz3ASVAQAEEQEAAAgwc3BlY192ZXJzaW9uBCRzcGVjX25hbWVFAQAIJGNvZGVfaGFzaCA0Y2hlY2tfdmVyc2lvbhQAEDhiYXNlX2V4dHJpbnNpYxg0bWF4X2V4dHJpbnNpY4EBJG1heF90b3RhbIEBIHJlc2VydmVkgQEADBhub3JtYWypASxvcGVyYXRpb25hbKkBJG1hbmRhdG9yeakBAAwoYmFzZV9ibG9jaxgkbWF4X2Jsb2NrGCRwZXJfY2xhc3OtAQAMGG5vcm1hbAQsb3BlcmF0aW9uYWwEJG1hbmRhdG9yeQQACBByZWFkCBR3cml0ZQgFASADCL0BBATBAQAAICRzcGVjX25hbWVFASRpbXBsX25hbWVFAURhdXRob3JpbmdfdmVyc2lvbgQwc3BlY192ZXJzaW9uBDBpbXBsX3ZlcnNpb24EEGFwaXPFAUx0cmFuc2FjdGlvbl92ZXJzaW9uBDhzeXN0ZW1fdmVyc2lvbgQEJAEIBM0BAAQkAAIQEExpdmUAAQUwUGVuZGluZ1BhdXNlAAAIMHNjaGVkdWxlZF9hdAQUZGVsYXkEGFBhdXNlZAABBTRQZW5kaW5nUmVzdW1lAAAIMHNjaGVkdWxlZF9hdAQUZGVsYXkEABAwc2NoZWR1bGVkX2F0BBRkZWxheQRAbmV4dF9hdXRob3JpdGllc7gYZm9yY2Vk6AAILHRhcmdldF9oYXNoIDR0YXJnZXRfbnVtYmVyBAUBAQEDCOEB5QEAEDByb3VuZF9udW1iZXIIIGlkZW50aXR5IBRmaXJzdOkBGHNlY29uZOkBAggcUHJldm90ZQHtASRQcmVjb21taXQB7QEACBhzZXRfaWQIMGVxdWl2b2NhdGlvbvEBAgwMRmVlAAEFEE1pc2MAAQUMQWxsAAEFAAwIaWS9ARhhbW91bnQIHHJlYXNvbnP5AQT9AQAACAhpZL0BGGFtb3VudAgEBQIAAgQgUHJlaW1hZ2UAAQUCBEBSZWdpc3RyeUlkZW50aXR5AAEFAgQ0RW50ZXJPckV4dGVuZAABBQIIYENvZGVVcGxvYWREZXBvc2l0UmVzZXJ2ZQABBVRTdG9yYWdlRGVwb3NpdFJlc2VydmUAAQUCECBQcmVpbWFnZQENAiBSZWdpc3RyeQERAiBTYWZlTW9kZQEVAiRDb250cmFjdHMBGQIACAhpZB0CGGFtb3VudAgEIQIAAAQYYW1vdW50CAQpAgACFAhJZAEAFEluZGV4AcwMUmF3ASQkQWRkcmVzczMyASAkQWRkcmVzczIwAeQEAAACCCBJbmNyZWFzZQABBSBEZWNyZWFzZQABBQIIJFYxQW5jaWVudAABBQhWMgABBQMIBAADCAAEAwjYCAMIBCADDAAABAYkAwgICAJoHFVua25vd24AAQVAU2VydmluZ1JhdGVMaW1pdAABBTRNYXhEaWZmaWN1bHR5AAEFPEFkanVzdG1lbnRBbHBoYQABBThNYXhXZWlnaHRMaW1pdAABBThJbW11bml0eVBlcmlvZAABBURNaW5BbGxvd2VkV2VpZ2h0cwABBRRLYXBwYQABBQxSaG8AAQU4QWN0aXZpdHlDdXRvZmYAAQVYUG93UmVnaXN0cmF0aW9uQWxsb3dlZAABBRxNaW5CdXJuAAEFHE1heEJ1cm4AAQVIQm9uZHNNb3ZpbmdBdmVyYWdlAAEFMEJvbmRzUGVuYWx0eQABBUxDb21taXRSZXZlYWxFbmFibGVkAAEFSExpcXVpZEFscGhhRW5hYmxlZAABBSxBbHBoYVZhbHVlcwABBVBXZWlnaHRDb21taXRJbnRlcnZhbAABBTxUcmFuc2ZlckVuYWJsZWQAAQVUQWxwaGFTaWdtb2lkU3RlZXBuZXNzAAEFMFl1bWEzRW5hYmxlZAABBURCb25kc1Jlc2V0RW5hYmxlZAABBURJbW11bmVOZXVyb25MaW1pdAABBTRSZWN5Y2xlT3JCdXJuAAEFOE1heEFsbG93ZWRVaWRzAAEFAhxAU2V0U05Pd25lckhvdGtleQEEVE93bmVySHlwZXJwYXJhbVVwZGF0ZQADCARdAlROZXR3b3JrTGFzdFJlZ2lzdGVyZWQAAQUsTGFzdFR4QmxvY2sBAFxMYXN0VHhCbG9ja0NoaWxkS2V5VGFrZQEAXExhc3RUeEJsb2NrRGVsZWdhdGVUYWtlAQAwQWRkU3Rha2VCdXJuAQQCCBBCdXJuAAEFHFJlY3ljbGUAAQUDDAAICARpAgAEFAAAIBRibG9jawgcdmVyc2lvbgQIaXAIEHBvcnQEHGlwX3R5cGUEIHByb3RvY29sBDBwbGFjZWhvbGRlcjEEMHBsYWNlaG9sZGVyMgQACChwdWJsaWNfa2V5JCRhbGdvcml0aG0EABQUYmxvY2sIHHZlcnNpb24ECGlwCBBwb3J0BBxpcF90eXBlBAAcEG5hbWUkDHVybCQsZ2l0aHViX3JlcG8kFGltYWdlJBxkaXNjb3JkJCxkZXNjcmlwdGlvbiQoYWRkaXRpb25hbCQAICxzdWJuZXRfbmFtZSQsZ2l0aHViX3JlcG8kOHN1Ym5ldF9jb250YWN0JChzdWJuZXRfdXJsJBxkaXNjb3JkJCxkZXNjcmlwdGlvbiQgbG9nb191cmwkKGFkZGl0aW9uYWwkAwwABAQDECAICAgEjQIAAwgECAMQAAgkCASZAgADDAAkCAShAgAEAAEIBJUCAAMMBAAAAwjkCAAcLGJlbmVmaWNpYXJ5ABxjb2xka2V5ABhob3RrZXkAPGVtaXNzaW9uc19zaGFyZQQkZW5kX2Jsb2Nr6BhuZXR1aWQEEGNvc3QIBJ0BAATgAAaFAgUBBQEGCAIsGHJlbWFyawAABBhyZW1hcmskOHNldF9oZWFwX3BhZ2VzAAAEFHBhZ2VzCCBzZXRfY29kZQAABBBjb2RlJFxzZXRfY29kZV93aXRob3V0X2NoZWNrcwAABBBjb2RlJCxzZXRfc3RvcmFnZQAABBRpdGVtc9EBMGtpbGxfc3RvcmFnZQAABBBrZXlz1QEsa2lsbF9wcmVmaXgAAAgYcHJlZml4JBxzdWJrZXlzBERyZW1hcmtfd2l0aF9ldmVudAAABBhyZW1hcmskRGF1dGhvcml6ZV91cGdyYWRlAAAEJGNvZGVfaGFzaCCAYXV0aG9yaXplX3VwZ3JhZGVfd2l0aG91dF9jaGVja3MAAAQkY29kZV9oYXNoIGBhcHBseV9hdXRob3JpemVkX3VwZ3JhZGUAAAQQY29kZSQCBAxzZXQAAAQMbm93CAIMTHJlcG9ydF9lcXVpdm9jYXRpb24AAARIZXF1aXZvY2F0aW9uX3Byb29m9QFwcmVwb3J0X2VxdWl2b2NhdGlvbl91bnNpZ25lZAAABEhlcXVpdm9jYXRpb25fcHJvb2b1ATBub3RlX3N0YWxsZWQAAAgUZGVsYXkEbGJlc3RfZmluYWxpemVkX2Jsb2NrX251bWJlcgQCJFB0cmFuc2Zlcl9hbGxvd19kZWF0aAAACBBkZXN0MQIUdmFsdWUIOGZvcmNlX3RyYW5zZmVyAAAMGHNvdXJjZTECEGRlc3QxAhR2YWx1ZQhMdHJhbnNmZXJfa2VlcF9hbGl2ZQAACBBkZXN0MQIUdmFsdWUIMHRyYW5zZmVyX2FsbAAACBBkZXN0MQIoa2VlcF9hbGl2ZRQ8Zm9yY2VfdW5yZXNlcnZlAAAIDHdobzECGGFtb3VudAhAdXBncmFkZV9hY2NvdW50cwAABAx3aG81AkRmb3JjZV9zZXRfYmFsYW5jZQAACAx3aG8xAiBuZXdfZnJlZQhsZm9yY2VfYWRqdXN0X3RvdGFsX2lzc3VhbmNlAAAIJGRpcmVjdGlvbjkCFGRlbHRhCBBidXJuAAAIFHZhbHVlCChrZWVwX2FsaXZlFAIRASxzZXRfd2VpZ2h0cwAAEBhuZXR1aWQEFGRlc3Rz4Bx3ZWlnaHRz4Cx2ZXJzaW9uX2tleQhUc2V0X21lY2hhbmlzbV93ZWlnaHRzAAAUGG5ldHVpZAQUbWVjaWQEFGRlc3Rz4Bx3ZWlnaHRz4Cx2ZXJzaW9uX2tleQhEYmF0Y2hfc2V0X3dlaWdodHMAAAwcbmV0dWlkc+Acd2VpZ2h0c70CMHZlcnNpb25fa2V5c+w4Y29tbWl0X3dlaWdodHMAAAgYbmV0dWlkBCxjb21taXRfaGFzaCBgY29tbWl0X21lY2hhbmlzbV93ZWlnaHRzAAAMGG5ldHVpZAQUbWVjaWQELGNvbW1pdF9oYXNoIFBiYXRjaF9jb21taXRfd2VpZ2h0cwAACBxuZXR1aWRz4DRjb21taXRfaGFzaGVz3DhyZXZlYWxfd2VpZ2h0cwAAFBhuZXR1aWQEEHVpZHPgGHZhbHVlc+AQc2FsdOAsdmVyc2lvbl9rZXkIYHJldmVhbF9tZWNoYW5pc21fd2VpZ2h0cwAAGBhuZXR1aWQEFG1lY2lkBBB1aWRz4Bh2YWx1ZXPgEHNhbHTgLHZlcnNpb25fa2V5CHRjb21taXRfY3J2M19tZWNoYW5pc21fd2VpZ2h0cwAAEBhuZXR1aWQEFG1lY2lkBBhjb21taXQkMHJldmVhbF9yb3VuZAhQYmF0Y2hfcmV2ZWFsX3dlaWdodHMAABQYbmV0dWlkBCR1aWRzX2xpc3TBAix2YWx1ZXNfbGlzdMECKHNhbHRzX2xpc3TBAjB2ZXJzaW9uX2tleXPsNGRlY3JlYXNlX3Rha2UAAAgYaG90a2V5ABB0YWtlBDRpbmNyZWFzZV90YWtlAAAIGGhvdGtleQAQdGFrZQQkYWRkX3N0YWtlAAAMGGhvdGtleQAYbmV0dWlkBDRhbW91bnRfc3Rha2VkCDByZW1vdmVfc3Rha2UAAAwYaG90a2V5ABhuZXR1aWQEPGFtb3VudF91bnN0YWtlZAgoc2VydmVfYXhvbgAAIBhuZXR1aWQEHHZlcnNpb24ECGlwCBBwb3J0BBxpcF90eXBlBCBwcm90b2NvbAQwcGxhY2Vob2xkZXIxBDBwbGFjZWhvbGRlcjIEOHNlcnZlX2F4b25fdGxzAAAkGG5ldHVpZAQcdmVyc2lvbgQIaXAIEHBvcnQEHGlwX3R5cGUEIHByb3RvY29sBDBwbGFjZWhvbGRlcjEEMHBsYWNlaG9sZGVyMgQsY2VydGlmaWNhdGUkQHNlcnZlX3Byb21ldGhldXMAABQYbmV0dWlkBBx2ZXJzaW9uBAhpcAgQcG9ydAQcaXBfdHlwZQQgcmVnaXN0ZXIAABgYbmV0dWlkBDBibG9ja19udW1iZXIIFG5vbmNlCBB3b3JrJBhob3RrZXkAHGNvbGRrZXkANHJvb3RfcmVnaXN0ZXIAAAQYaG90a2V5ADxidXJuZWRfcmVnaXN0ZXIAAAgYbmV0dWlkBBhob3RrZXkALHN3YXBfaG90a2V5AAAMGGhvdGtleQAobmV3X2hvdGtleQAYbmV0dWlk6DBzd2FwX2NvbGRrZXkAAAwsb2xkX2NvbGRrZXkALG5ld19jb2xka2V5ACRzd2FwX2Nvc3QIRHNldF9jaGlsZGtleV90YWtlAAAMGGhvdGtleQAYbmV0dWlkBBB0YWtlBJBzdWRvX3NldF90eF9jaGlsZGtleV90YWtlX3JhdGVfbGltaXQAAAQ0dHhfcmF0ZV9saW1pdAhoc3Vkb19zZXRfbWluX2NoaWxka2V5X3Rha2UAAAQQdGFrZQRoc3Vkb19zZXRfbWF4X2NoaWxka2V5X3Rha2UAAAQQdGFrZQRAcmVnaXN0ZXJfbmV0d29yawAABBhob3RrZXkAGGZhdWNldAAADDBibG9ja19udW1iZXIIFG5vbmNlCBB3b3JrJEBkaXNzb2x2ZV9uZXR3b3JrAAAIHGNvbGRrZXkAGG5ldHVpZAQwc2V0X2NoaWxkcmVuAAAMGGhvdGtleQAYbmV0dWlkBCBjaGlsZHJlbthUc2NoZWR1bGVfc3dhcF9jb2xka2V5AAAELG5ld19jb2xka2V5ADBzZXRfaWRlbnRpdHkAABwQbmFtZSQMdXJsJCxnaXRodWJfcmVwbyQUaW1hZ2UkHGRpc2NvcmQkLGRlc2NyaXB0aW9uJChhZGRpdGlvbmFsJExzZXRfc3VibmV0X2lkZW50aXR5AAAkGG5ldHVpZAQsc3VibmV0X25hbWUkLGdpdGh1Yl9yZXBvJDhzdWJuZXRfY29udGFjdCQoc3VibmV0X3VybCQcZGlzY29yZCQsZGVzY3JpcHRpb24kIGxvZ29fdXJsJChhZGRpdGlvbmFsJHhyZWdpc3Rlcl9uZXR3b3JrX3dpdGhfaWRlbnRpdHkAAAgYaG90a2V5ACBpZGVudGl0ecUCLHVuc3Rha2VfYWxsAAAEGGhvdGtleQBEdW5zdGFrZV9hbGxfYWxwaGEAAAQYaG90a2V5AChtb3ZlX3N0YWtlAAAUNG9yaWdpbl9ob3RrZXkASGRlc3RpbmF0aW9uX2hvdGtleQA0b3JpZ2luX25ldHVpZARIZGVzdGluYXRpb25fbmV0dWlkBDBhbHBoYV9hbW91bnQIOHRyYW5zZmVyX3N0YWtlAAAUTGRlc3RpbmF0aW9uX2NvbGRrZXkAGGhvdGtleQA0b3JpZ2luX25ldHVpZARIZGVzdGluYXRpb25fbmV0dWlkBDBhbHBoYV9hbW91bnQIKHN3YXBfc3Rha2UAABAYaG90a2V5ADRvcmlnaW5fbmV0dWlkBEhkZXN0aW5hdGlvbl9uZXR1aWQEMGFscGhhX2Ftb3VudAg8YWRkX3N0YWtlX2xpbWl0AAAUGGhvdGtleQAYbmV0dWlkBDRhbW91bnRfc3Rha2VkCCxsaW1pdF9wcmljZQg0YWxsb3dfcGFydGlhbBRIcmVtb3ZlX3N0YWtlX2xpbWl0AAAUGGhvdGtleQAYbmV0dWlkBDxhbW91bnRfdW5zdGFrZWQILGxpbWl0X3ByaWNlCDRhbGxvd19wYXJ0aWFsFEBzd2FwX3N0YWtlX2xpbWl0AAAYGGhvdGtleQA0b3JpZ2luX25ldHVpZARIZGVzdGluYXRpb25fbmV0dWlkBDBhbHBoYV9hbW91bnQILGxpbWl0X3ByaWNlCDRhbGxvd19wYXJ0aWFsFFB0cnlfYXNzb2NpYXRlX2hvdGtleQAABBhob3RrZXkAKHN0YXJ0X2NhbGwAAAQYbmV0dWlkBERhc3NvY2lhdGVfZXZtX2tleQAAEBhuZXR1aWQEHGV2bV9rZXnkMGJsb2NrX251bWJlcggkc2lnbmF0dXJlyQI0cmVjeWNsZV9hbHBoYQAADBhob3RrZXkAGGFtb3VudAgYbmV0dWlkBChidXJuX2FscGhhAAAMGGhvdGtleQAYYW1vdW50CBhuZXR1aWQEdHNldF9wZW5kaW5nX2NoaWxka2V5X2Nvb2xkb3duAAAEIGNvb2xkb3duCFxyZW1vdmVfc3Rha2VfZnVsbF9saW1pdAAADBhob3RrZXkAGG5ldHVpZAQsbGltaXRfcHJpY2XNAlxyZWdpc3Rlcl9sZWFzZWRfbmV0d29yawAACDxlbWlzc2lvbnNfc2hhcmUEJGVuZF9ibG9ja+g8dGVybWluYXRlX2xlYXNlAAAIIGxlYXNlX2lkBBhob3RrZXkANHVwZGF0ZV9zeW1ib2wAAAgYbmV0dWlkBBhzeW1ib2wkZGNvbW1pdF90aW1lbG9ja2VkX3dlaWdodHMAABAYbmV0dWlkBBhjb21taXQkMHJldmVhbF9yb3VuZAhUY29tbWl0X3JldmVhbF92ZXJzaW9uBHRzZXRfY29sZGtleV9hdXRvX3N0YWtlX2hvdGtleQAACBhuZXR1aWQEGGhvdGtleQCMY29tbWl0X3RpbWVsb2NrZWRfbWVjaGFuaXNtX3dlaWdodHMAABQYbmV0dWlkBBRtZWNpZAQYY29tbWl0JDByZXZlYWxfcm91bmQIVGNvbW1pdF9yZXZlYWxfdmVyc2lvbgRUcm9vdF9kaXNzb2x2ZV9uZXR3b3JrAAAEGG5ldHVpZAQoY2xhaW1fcm9vdAAABBxzdWJuZXRz4ExzZXRfcm9vdF9jbGFpbV90eXBlAAAETG5ld19yb290X2NsYWltX3R5cGXwYHN1ZG9fc2V0X251bV9yb290X2NsYWltcwAABCRuZXdfdmFsdWUIdHN1ZG9fc2V0X3Jvb3RfY2xhaW1fdGhyZXNob2xkAAAIGG5ldHVpZAQkbmV3X3ZhbHVlCFRhbm5vdW5jZV9jb2xka2V5X3N3YXAAAARAbmV3X2NvbGRrZXlfaGFzaCBYc3dhcF9jb2xka2V5X2Fubm91bmNlZAAABCxuZXdfY29sZGtleQBQZGlzcHV0ZV9jb2xka2V5X3N3YXAAAQVIcmVzZXRfY29sZGtleV9zd2FwAAAEHGNvbGRrZXkAcGVuYWJsZV92b3RpbmdfcG93ZXJfdHJhY2tpbmcAAAQYbmV0dWlkBHRkaXNhYmxlX3ZvdGluZ19wb3dlcl90cmFja2luZwAABBhuZXR1aWQEfHN1ZG9fc2V0X3ZvdGluZ19wb3dlcl9lbWFfYWxwaGEAAAgYbmV0dWlkBBRhbHBoYQg4YWRkX3N0YWtlX2J1cm4AABAYaG90a2V5ABhuZXR1aWQEGGFtb3VudAgUbGltaXTNAgIQEFJvb3QAAQUYU2lnbmVkAQAQTm9uZQABBShBdXRob3JpemVkAAEFAgRMRXRoZXJldW1UcmFuc2FjdGlvbgHkAggYc3lzdGVtAeUCIEV0aGVyZXVtAekCAiAUYmF0Y2gAAAQUY2FsbHO1BTRhc19kZXJpdmF0aXZlAAAIFGluZGV4BBBjYWxssQUkYmF0Y2hfYWxsAAAEFGNhbGxztQUsZGlzcGF0Y2hfYXMAAAgkYXNfb3JpZ2lu7QIQY2FsbLEFLGZvcmNlX2JhdGNoAAAEFGNhbGxztQUsd2l0aF93ZWlnaHQAAAgQY2FsbLEFGHdlaWdodBgcaWZfZWxzZQAACBBtYWlusQUgZmFsbGJhY2uxBVBkaXNwYXRjaF9hc19mYWxsaWJsZQAACCRhc19vcmlnaW7tAhBjYWxssQUCFBBzdWRvAAAEEGNhbGyxBVRzdWRvX3VuY2hlY2tlZF93ZWlnaHQAAAgQY2FsbLEFGHdlaWdodBgcc2V0X2tleQAABAxuZXcxAhxzdWRvX2FzAAAIDHdobzECEGNhbGyxBShyZW1vdmVfa2V5AAEFBgUBAhRQYXNfbXVsdGlfdGhyZXNob2xkXzEAAAhEb3RoZXJfc2lnbmF0b3JpZXM1AhBjYWxssQUgYXNfbXVsdGkAABQkdGhyZXNob2xkBERvdGhlcl9zaWduYXRvcmllczUCPG1heWJlX3RpbWVwb2ludPkCEGNhbGyxBShtYXhfd2VpZ2h0GEBhcHByb3ZlX2FzX211bHRpAAAUJHRocmVzaG9sZAREb3RoZXJfc2lnbmF0b3JpZXM1AjxtYXliZV90aW1lcG9pbnT5AiRjYWxsX2hhc2ggKG1heF93ZWlnaHQYPGNhbmNlbF9hc19tdWx0aQAAECR0aHJlc2hvbGQERG90aGVyX3NpZ25hdG9yaWVzNQIkdGltZXBvaW50BQEkY2FsbF9oYXNoIDBwb2tlX2RlcG9zaXQAAAwkdGhyZXNob2xkBERvdGhlcl9zaWduYXRvcmllczUCJGNhbGxfaGFzaCACFDRub3RlX3ByZWltYWdlAAAEFGJ5dGVzJDx1bm5vdGVfcHJlaW1hZ2UAAAQQaGFzaCBAcmVxdWVzdF9wcmVpbWFnZQAABBBoYXNoIEh1bnJlcXVlc3RfcHJlaW1hZ2UAAAQQaGFzaCA4ZW5zdXJlX3VwZGF0ZWQAAAQYaGFzaGVz3AYRAQIoIHNjaGVkdWxlAAAQEHdoZW4EOG1heWJlX3BlcmlvZGljBQMgcHJpb3JpdHkEEGNhbGyxBRhjYW5jZWwAAAgQd2hlbgQUaW5kZXgEOHNjaGVkdWxlX25hbWVkAAAUCGlkIBB3aGVuBDhtYXliZV9wZXJpb2RpYwUDIHByaW9yaXR5BBBjYWxssQUwY2FuY2VsX25hbWVkAAAECGlkIDhzY2hlZHVsZV9hZnRlcgAAEBRhZnRlcgQ4bWF5YmVfcGVyaW9kaWMFAyBwcmlvcml0eQQQY2FsbLEFUHNjaGVkdWxlX25hbWVkX2FmdGVyAAAUCGlkIBRhZnRlcgQ4bWF5YmVfcGVyaW9kaWMFAyBwcmlvcml0eQQQY2FsbLEFJHNldF9yZXRyeQAADBB0YXNrEQEccmV0cmllcwQYcGVyaW9kBDxzZXRfcmV0cnlfbmFtZWQAAAwIaWQgHHJldHJpZXMEGHBlcmlvZAQwY2FuY2VsX3JldHJ5AAAEEHRhc2sRAUhjYW5jZWxfcmV0cnlfbmFtZWQAAAQIaWQgBh0BAiwUcHJveHkAAAwQcmVhbDECQGZvcmNlX3Byb3h5X3R5cGUNAxBjYWxssQUkYWRkX3Byb3h5AAAMIGRlbGVnYXRlMQIocHJveHlfdHlwZR0BFGRlbGF5BDByZW1vdmVfcHJveHkAAAwgZGVsZWdhdGUxAihwcm94eV90eXBlHQEUZGVsYXkEOHJlbW92ZV9wcm94aWVzAAEFLGNyZWF0ZV9wdXJlAAAMKHByb3h5X3R5cGUdARRkZWxheQQUaW5kZXgEJGtpbGxfcHVyZQAAFBxzcGF3bmVyMQIocHJveHlfdHlwZR0BFGluZGV4BBhoZWlnaHQEJGV4dF9pbmRleAQgYW5ub3VuY2UAAAgQcmVhbDECJGNhbGxfaGFzaCBMcmVtb3ZlX2Fubm91bmNlbWVudAAACBByZWFsMQIkY2FsbF9oYXNoIExyZWplY3RfYW5ub3VuY2VtZW50AAAIIGRlbGVnYXRlMQIkY2FsbF9oYXNoIDxwcm94eV9hbm5vdW5jZWQAABAgZGVsZWdhdGUxAhByZWFsMQJAZm9yY2VfcHJveHlfdHlwZQ0DEGNhbGyxBTBwb2tlX2RlcG9zaXQAAQUFAQgFAQwFARQFARgFARwFASQFASgFASwFATAFATQFATgFATwFAUAFAUQFAUgFAUwFAVQFAVgFAVwFAWAFAWQFAWgFAWwFAXAFAXQFAXgFAXwFAYQFAYgFAYwFAZAFAZQFAZgFAZwFAaAFAaQFAagFAawFAbAFAbQFAbgFAbwFAcAFAcQFAcgFAcwFAdAFAdQFAdgFAdwFAeAFAeQFAegFAewFAfAFAfQFAfgFAfwCGQEQTm9uZQABBRBSYXcwAcwQUmF3MQEEEFJhdzIBFQMQUmF3MwEZAxBSYXc0ASgQUmF3NQEdAxBSYXc2ASEDEFJhdzcBJQMQUmF3OAG9ARBSYXc5ASkDFFJhdzEwAS0DFFJhdzExATEDFFJhdzEyATUDFFJhdzEzATkDFFJhdzE0AT0DFFJhdzE1AUEDFFJhdzE2AUUDFFJhdzE3AUkDFFJhdzE4AU0DFFJhdzE5AVEDFFJhdzIwAeQUUmF3MjEBVQMUUmF3MjIBWQMUUmF3MjMBXQMUUmF3MjQBYQMUUmF3MjUBZQMUUmF3MjYBaQMUUmF3MjcBbQMUUmF3MjgBcQMUUmF3MjkBdQMUUmF3MzABeQMUUmF3MzEBfQMUUmF3MzIBIBRSYXczMwGBAxRSYXczNAGFAxRSYXczNQGJAxRSYXczNgGNAxRSYXczNwGRAxRSYXczOAGVAxRSYXczOQGZAxRSYXc0MAGdAxRSYXc0MQGhAxRSYXc0MgGlAxRSYXc0MwGpAxRSYXc0NAGtAxRSYXc0NQGxAxRSYXc0NgG1AxRSYXc0NwG5AxRSYXc0OAG9AxRSYXc0OQHBAxRSYXc1MAHFAxRSYXc1MQHJAxRSYXc1MgHNAxRSYXc1MwHRAxRSYXc1NAHVAxRSYXc1NQHZAxRSYXc1NgHdAxRSYXc1NwHhAxRSYXc1OAHlAxRSYXc1OQHpAxRSYXc2MAHtAxRSYXc2MQHxAxRSYXc2MgH1AxRSYXc2MwH5AxRSYXc2NAHlASxCbGFrZVR3bzI1NgEgGFNoYTI1NgEgJEtlY2NhazI1NgEgLFNoYVRocmVlMjU2ASAE/QMBCAQBBAAG5AAkKGFkZGl0aW9uYWwFBBxkaXNwbGF5/QMUbGVnYWz9Awx3ZWL9AxByaW90/QMUZW1haWz9AzxwZ3BfZmluZ2VycHJpbnQJBBRpbWFnZf0DHHR3aXR0ZXL9AwIIMHNldF9pZGVudGl0eQAACChpZGVudGlmaWVkABBpbmZvDQQ4Y2xlYXJfaWRlbnRpdHkAAAQoaWRlbnRpZmllZAAFAQkBBQENAQUBEQEFARUBBQEZAQUBHQEFASEBBQElAQUBKQEFAS0BBQExAQUBNQEFATkBBQE9AQUBQQEFAUUBBQFJAQUBTQEFAVEBBQFVAQUBWQEFAV0BBQFhAQUBZQEFAWkBBQFtAQUBcQEFAXUBBQF5AQUBfQEFAYEBBQGFAQUBiQEFAY0BBQGRAQUBlQEFAZkBBQGdAQUBoQEFAaUBBQGpAQUBrQEFAbEBBQG1AQUBuQEFAb0BBQHBAQUBxQEFAckBBQHNAQUB0QEFAdUBBQHZAQUB3QEFAeEBBQHlAQUB6QEFAe0BBQHxAQUB9QEFAfkBBQH9AQUBAQICJQIQTm9uZQABBRBSYXcwAcwQUmF3MQEEEFJhdzIBFQMQUmF3MwEZAxBSYXc0ASgQUmF3NQEdAxBSYXc2ASEDEFJhdzcBJQMQUmF3OAG9ARBSYXc5ASkDFFJhdzEwAS0DFFJhdzExATEDFFJhdzEyATUDFFJhdzEzATkDFFJhdzE0AT0DFFJhdzE1AUEDFFJhdzE2AUUDFFJhdzE3AUkDFFJhdzE4AU0DFFJhdzE5AVEDFFJhdzIwAeQUUmF3MjEBVQMUUmF3MjIBWQMUUmF3MjMBXQMUUmF3MjQBYQMUUmF3MjUBZQMUUmF3MjYBaQMUUmF3MjcBbQMUUmF3MjgBcQMUUmF3MjkBdQMUUmF3MzABeQMUUmF3MzEBfQMUUmF3MzIBIBRSYXczMwGBAxRSYXczNAGFAxRSYXczNQGJAxRSYXczNgGNAxRSYXczNwGRAxRSYXczOAGVAxRSYXczOQGZAxRSYXc0MAGdAxRSYXc0MQGhAxRSYXc0MgGlAxRSYXc0MwGpAxRSYXc0NAGtAxRSYXc0NQGxAxRSYXc0NgG1AxRSYXc0NwG5AxRSYXc0OAG9AxRSYXc0OQHBAxRSYXc1MAHFAxRSYXc1MQHJAxRSYXc1MgHNAxRSYXc1MwHRAxRSYXc1NAHVAxRSYXc1NQHZAxRSYXc1NgHdAxRSYXc1NwHhAxRSYXc1OAHlAxRSYXc1OQHpAxRSYXc2MAHtAxRSYXc2MQHxAxRSYXc2MgH1AxRSYXc2MwH5AxRSYXc2NAHlARRSYXc2NQHJAhRSYXc2NgEVBBRSYXc2NwEZBBRSYXc2OAEdBBRSYXc2OQEhBBRSYXc3MAElBBRSYXc3MQEpBBRSYXc3MgEtBBRSYXc3MwExBBRSYXc3NAE1BBRSYXc3NQE5BBRSYXc3NgE9BBRSYXc3NwFBBBRSYXc3OAFFBBRSYXc3OQFJBBRSYXc4MAFNBBRSYXc4MQFRBBRSYXc4MgFVBBRSYXc4MwFZBBRSYXc4NAFdBBRSYXc4NQFhBBRSYXc4NgFlBBRSYXc4NwFpBBRSYXc4OAFtBBRSYXc4OQFxBBRSYXc5MAF1BBRSYXc5MQF5BBRSYXc5MgF9BBRSYXc5MwGBBBRSYXc5NAGFBBRSYXc5NQGJBBRSYXc5NgGNBBRSYXc5NwGRBBRSYXc5OAGVBBRSYXc5OQGZBBhSYXcxMDABnQQYUmF3MTAxAaEEGFJhdzEwMgGlBBhSYXcxMDMBqQQYUmF3MTA0Aa0EGFJhdzEwNQGxBBhSYXcxMDYBtQQYUmF3MTA3AbkEGFJhdzEwOAG9BBhSYXcxMDkBwQQYUmF3MTEwAcUEGFJhdzExMQHJBBhSYXcxMTIBzQQYUmF3MTEzAdEEGFJhdzExNAHVBBhSYXcxMTUB2QQYUmF3MTE2Ad0EGFJhdzExNwHhBBhSYXcxMTgB5QQYUmF3MTE5AekEGFJhdzEyMAHtBBhSYXcxMjEB8QQYUmF3MTIyAfUEGFJhdzEyMwH5BBhSYXcxMjQB/QQYUmF3MTI1AQEFGFJhdzEyNgEFBRhSYXcxMjcBCQUYUmF3MTI4AQ0FLEJsYWtlVHdvMjU2ASAYU2hhMjU2ASAkS2VjY2FrMjU2ASAsU2hhVGhyZWUyNTYBIERUaW1lbG9ja0VuY3J5cHRlZAAACCRlbmNyeXB0ZWQkMHJldmVhbF9yb3VuZAg4UmVzZXRCb25kc0ZsYWcAAQUYQmlnUmF3ASQEEQUAAgg4c2V0X2NvbW1pdG1lbnQAAAgYbmV0dWlkBBBpbmZvFQU0c2V0X21heF9zcGFjZQAABCRuZXdfbGltaXQEBuACKQFAc3dhcF9hdXRob3JpdGllcwAABDxuZXdfYXV0aG9yaXRpZXPcVHN1ZG9fc2V0X2RlZmF1bHRfdGFrZQAABDBkZWZhdWx0X3Rha2UEWHN1ZG9fc2V0X3R4X3JhdGVfbGltaXQAAAQ0dHhfcmF0ZV9saW1pdAhsc3Vkb19zZXRfc2VydmluZ19yYXRlX2xpbWl0AAAIGG5ldHVpZARIc2VydmluZ19yYXRlX2xpbWl0CFxzdWRvX3NldF9taW5fZGlmZmljdWx0eQAACBhuZXR1aWQEOG1pbl9kaWZmaWN1bHR5CFxzdWRvX3NldF9tYXhfZGlmZmljdWx0eQAACBhuZXR1aWQEOG1heF9kaWZmaWN1bHR5CHBzdWRvX3NldF93ZWlnaHRzX3ZlcnNpb25fa2V5AAAIGG5ldHVpZARMd2VpZ2h0c192ZXJzaW9uX2tleQh8c3Vkb19zZXRfd2VpZ2h0c19zZXRfcmF0ZV9saW1pdAAACBhuZXR1aWQEWHdlaWdodHNfc2V0X3JhdGVfbGltaXQIcHN1ZG9fc2V0X2FkanVzdG1lbnRfaW50ZXJ2YWwAAAgYbmV0dWlkBExhZGp1c3RtZW50X2ludGVydmFsBGRzdWRvX3NldF9hZGp1c3RtZW50X2FscGhhAAAIGG5ldHVpZARAYWRqdXN0bWVudF9hbHBoYQhgc3Vkb19zZXRfaW1tdW5pdHlfcGVyaW9kAAAIGG5ldHVpZAQ8aW1tdW5pdHlfcGVyaW9kBHBzdWRvX3NldF9taW5fYWxsb3dlZF93ZWlnaHRzAAAIGG5ldHVpZARMbWluX2FsbG93ZWRfd2VpZ2h0cwRkc3Vkb19zZXRfbWF4X2FsbG93ZWRfdWlkcwAACBhuZXR1aWQEQG1heF9hbGxvd2VkX3VpZHMEOHN1ZG9fc2V0X2thcHBhAAAIGG5ldHVpZAQUa2FwcGEEMHN1ZG9fc2V0X3JobwAACBhuZXR1aWQEDHJobwRgc3Vkb19zZXRfYWN0aXZpdHlfY3V0b2ZmAAAIGG5ldHVpZAQ8YWN0aXZpdHlfY3V0b2ZmBJRzdWRvX3NldF9uZXR3b3JrX3JlZ2lzdHJhdGlvbl9hbGxvd2VkAAAIGG5ldHVpZARQcmVnaXN0cmF0aW9uX2FsbG93ZWQUpHN1ZG9fc2V0X25ldHdvcmtfcG93X3JlZ2lzdHJhdGlvbl9hbGxvd2VkAAAIGG5ldHVpZARQcmVnaXN0cmF0aW9uX2FsbG93ZWQUqHN1ZG9fc2V0X3RhcmdldF9yZWdpc3RyYXRpb25zX3Blcl9pbnRlcnZhbAAACBhuZXR1aWQEhHRhcmdldF9yZWdpc3RyYXRpb25zX3Blcl9pbnRlcnZhbAREc3Vkb19zZXRfbWluX2J1cm4AAAgYbmV0dWlkBCBtaW5fYnVybghEc3Vkb19zZXRfbWF4X2J1cm4AAAgYbmV0dWlkBCBtYXhfYnVybghMc3Vkb19zZXRfZGlmZmljdWx0eQAACBhuZXR1aWQEKGRpZmZpY3VsdHkIfHN1ZG9fc2V0X21heF9hbGxvd2VkX3ZhbGlkYXRvcnMAAAgYbmV0dWlkBFhtYXhfYWxsb3dlZF92YWxpZGF0b3JzBHRzdWRvX3NldF9ib25kc19tb3ZpbmdfYXZlcmFnZQAACBhuZXR1aWQEUGJvbmRzX21vdmluZ19hdmVyYWdlCFhzdWRvX3NldF9ib25kc19wZW5hbHR5AAAIGG5ldHVpZAQ0Ym9uZHNfcGVuYWx0eQSQc3Vkb19zZXRfbWF4X3JlZ2lzdHJhdGlvbnNfcGVyX2Jsb2NrAAAIGG5ldHVpZARsbWF4X3JlZ2lzdHJhdGlvbnNfcGVyX2Jsb2NrBGRzdWRvX3NldF9zdWJuZXRfb3duZXJfY3V0AAAEQHN1Ym5ldF9vd25lcl9jdXQEbHN1ZG9fc2V0X25ldHdvcmtfcmF0ZV9saW1pdAAABChyYXRlX2xpbWl0CDhzdWRvX3NldF90ZW1wbwAACBhuZXR1aWQEFHRlbXBvBFxzdWRvX3NldF90b3RhbF9pc3N1YW5jZQAABDh0b3RhbF9pc3N1YW5jZQiAc3Vkb19zZXRfbmV0d29ya19pbW11bml0eV9wZXJpb2QAAAQ8aW1tdW5pdHlfcGVyaW9kCHhzdWRvX3NldF9uZXR3b3JrX21pbl9sb2NrX2Nvc3QAAAQkbG9ja19jb3N0CFRzdWRvX3NldF9zdWJuZXRfbGltaXQAAAQsbWF4X3N1Ym5ldHMEgHN1ZG9fc2V0X2xvY2tfcmVkdWN0aW9uX2ludGVydmFsAAAEIGludGVydmFsCFRzdWRvX3NldF9yYW9fcmVjeWNsZWQAAAgYbmV0dWlkBDByYW9fcmVjeWNsZWQIYHN1ZG9fc2V0X3N0YWtlX3RocmVzaG9sZAAABCRtaW5fc3Rha2UIlHN1ZG9fc2V0X25vbWluYXRvcl9taW5fcmVxdWlyZWRfc3Rha2UAAAQkbWluX3N0YWtlCJBzdWRvX3NldF90eF9kZWxlZ2F0ZV90YWtlX3JhdGVfbGltaXQAAAQ0dHhfcmF0ZV9saW1pdAhoc3Vkb19zZXRfbWluX2RlbGVnYXRlX3Rha2UAAAQQdGFrZQSYc3Vkb19zZXRfY29tbWl0X3JldmVhbF93ZWlnaHRzX2VuYWJsZWQAAAgYbmV0dWlkBBxlbmFibGVkFHRzdWRvX3NldF9saXF1aWRfYWxwaGFfZW5hYmxlZAAACBhuZXR1aWQEHGVuYWJsZWQUVHN1ZG9fc2V0X2FscGhhX3ZhbHVlcwAADBhuZXR1aWQEJGFscGhhX2xvdwQoYWxwaGFfaGlnaASsc3Vkb19zZXRfZGlzc29sdmVfbmV0d29ya19zY2hlZHVsZV9kdXJhdGlvbgAABCBkdXJhdGlvbgScc3Vkb19zZXRfY29tbWl0X3JldmVhbF93ZWlnaHRzX2ludGVydmFsAAAIGG5ldHVpZAQgaW50ZXJ2YWwIVHN1ZG9fc2V0X2V2bV9jaGFpbl9pZAAABCBjaGFpbl9pZAhcc2NoZWR1bGVfZ3JhbmRwYV9jaGFuZ2UAAAxAbmV4dF9hdXRob3JpdGllc7gkaW5fYmxvY2tzBBhmb3JjZWToYHN1ZG9fc2V0X3RvZ2dsZV90cmFuc2ZlcgAACBhuZXR1aWQEGHRvZ2dsZRRgc3Vkb19zZXRfcmVjeWNsZV9vcl9idXJuAAAIGG5ldHVpZAQ8cmVjeWNsZV9vcl9idXJuZQJoc3Vkb190b2dnbGVfZXZtX3ByZWNvbXBpbGUAAAg0cHJlY29tcGlsZV9pZDEBHGVuYWJsZWQUcHN1ZG9fc2V0X3N1Ym5ldF9tb3ZpbmdfYWxwaGEAAAQUYWxwaGEIcHN1ZG9fc2V0X3N1Ym5ldF9vd25lcl9ob3RrZXkAAAgYbmV0dWlkBBhob3RrZXkAhHN1ZG9fc2V0X2VtYV9wcmljZV9oYWx2aW5nX3BlcmlvZAAACBhuZXR1aWQELGVtYV9oYWx2aW5nCIBzdWRvX3NldF9hbHBoYV9zaWdtb2lkX3N0ZWVwbmVzcwAACBhuZXR1aWQEJHN0ZWVwbmVzcwRYc3Vkb19zZXRfeXVtYTNfZW5hYmxlZAAACBhuZXR1aWQEHGVuYWJsZWQUcHN1ZG9fc2V0X2JvbmRzX3Jlc2V0X2VuYWJsZWQAAAgYbmV0dWlkBBxlbmFibGVkFGBzdWRvX3NldF9zbl9vd25lcl9ob3RrZXkAAAgYbmV0dWlkBBhob3RrZXkAZHN1ZG9fc2V0X3N1YnRva2VuX2VuYWJsZWQAAAgYbmV0dWlkBEBzdWJ0b2tlbl9lbmFibGVkFHhzdWRvX3NldF9jb21taXRfcmV2ZWFsX3ZlcnNpb24AAAQcdmVyc2lvbgSIc3Vkb19zZXRfb3duZXJfaW1tdW5lX25ldXJvbl9saW1pdAAACBhuZXR1aWQEOGltbXVuZV9uZXVyb25zBEBzdWRvX3NldF9ja19idXJuAAAEEGJ1cm4IcHN1ZG9fc2V0X2FkbWluX2ZyZWV6ZV93aW5kb3cAAAQYd2luZG93BIBzdWRvX3NldF9vd25lcl9ocGFyYW1fcmF0ZV9saW1pdAAABBhlcG9jaHMEYHN1ZG9fc2V0X21lY2hhbmlzbV9jb3VudAAACBhuZXR1aWQEPG1lY2hhbmlzbV9jb3VudASEc3Vkb19zZXRfbWVjaGFuaXNtX2VtaXNzaW9uX3NwbGl0AAAIGG5ldHVpZAQsbWF5YmVfc3BsaXQdBXRzdWRvX3RyaW1fdG9fbWF4X2FsbG93ZWRfdWlkcwAACBhuZXR1aWQEFG1heF9uBGRzdWRvX3NldF9taW5fYWxsb3dlZF91aWRzAAAIGG5ldHVpZARAbWluX2FsbG93ZWRfdWlkcwRgc3Vkb19zZXRfdGFvX2Zsb3dfY3V0b2ZmAAAELGZsb3dfY3V0b2ZmCKBzdWRvX3NldF90YW9fZmxvd19ub3JtYWxpemF0aW9uX2V4cG9uZW50AAAEIGV4cG9uZW50CIhzdWRvX3NldF90YW9fZmxvd19zbW9vdGhpbmdfZmFjdG9yAAAEQHNtb290aGluZ19mYWN0b3IIcHN1ZG9fc2V0X21heF9tZWNoYW5pc21fY291bnQAAARMbWF4X21lY2hhbmlzbV9jb3VudARwc3Vkb19zZXRfbWluX25vbl9pbW11bmVfdWlkcwAACBhuZXR1aWQEDG1pbgRkc3Vkb19zZXRfc3RhcnRfY2FsbF9kZWxheQAABBRkZWxheQigc3Vkb19zZXRfY29sZGtleV9zd2FwX2Fubm91bmNlbWVudF9kZWxheQAABCBkdXJhdGlvbgSoc3Vkb19zZXRfY29sZGtleV9zd2FwX3JlYW5ub3VuY2VtZW50X2RlbGF5AAAEIGR1cmF0aW9uBAIgFGVudGVyAAEFLGZvcmNlX2VudGVyAAEFGGV4dGVuZAABBTBmb3JjZV9leHRlbmQAAQUoZm9yY2VfZXhpdAABBUxmb3JjZV9zbGFzaF9kZXBvc2l0AAAIHGFjY291bnQAFGJsb2NrBDxyZWxlYXNlX2RlcG9zaXQAAAgcYWNjb3VudAAUYmxvY2sEVGZvcmNlX3JlbGVhc2VfZGVwb3NpdAAACBxhY2NvdW50ABRibG9jawQCCBBDYWxsAeQYQ3JlYXRlAAEFAAwEdggEciAEcyAAHBRub25jZWUBJGdhc19wcmljZWUBJGdhc19saW1pdGUBGGFjdGlvbikFFHZhbHVlZQEUaW5wdXQkJHNpZ25hdHVyZS0FAAgcYWRkcmVzc+Qwc3RvcmFnZV9rZXlz3AQ1BQAADDBvZGRfeV9wYXJpdHkUBHIgBHMgACQgY2hhaW5faWQIFG5vbmNlZQEkZ2FzX3ByaWNlZQEkZ2FzX2xpbWl0ZQEYYWN0aW9uKQUUdmFsdWVlARRpbnB1dCQsYWNjZXNzX2xpc3Q5BSRzaWduYXR1cmU9BQAoIGNoYWluX2lkCBRub25jZWUBYG1heF9wcmlvcml0eV9mZWVfcGVyX2dhc2UBPG1heF9mZWVfcGVyX2dhc2UBJGdhc19saW1pdGUBGGFjdGlvbikFFHZhbHVlZQEUaW5wdXQkLGFjY2Vzc19saXN0OQUkc2lnbmF0dXJlPQUAECBjaGFpbl9pZAgcYWRkcmVzc+QUbm9uY2VlASRzaWduYXR1cmU9BQRJBQAALCBjaGFpbl9pZAgUbm9uY2VlAWBtYXhfcHJpb3JpdHlfZmVlX3Blcl9nYXNlATxtYXhfZmVlX3Blcl9nYXNlASRnYXNfbGltaXRlASxkZXN0aW5hdGlvbikFFHZhbHVlZQEQZGF0YSQsYWNjZXNzX2xpc3Q5BUhhdXRob3JpemF0aW9uX2xpc3RNBSRzaWduYXR1cmU9BQIQGExlZ2FjeQExBRxFSVAyOTMwAUEFHEVJUDE1NTkBRQUcRUlQNzcwMgFRBQIEIHRyYW5zYWN0AAAELHRyYW5zYWN0aW9uVQUGZQEDCOTcBGEFAATkAAIYIHdpdGhkcmF3AAAIHGFkZHJlc3PkFHZhbHVlCBBjYWxsAAAoGHNvdXJjZeQYdGFyZ2V05BRpbnB1dCQUdmFsdWVlASRnYXNfbGltaXQIPG1heF9mZWVfcGVyX2dhc2UBYG1heF9wcmlvcml0eV9mZWVfcGVyX2dhc10FFG5vbmNlXQUsYWNjZXNzX2xpc3RlBUhhdXRob3JpemF0aW9uX2xpc3RNBRhjcmVhdGUAACQYc291cmNl5BBpbml0JBR2YWx1ZWUBJGdhc19saW1pdAg8bWF4X2ZlZV9wZXJfZ2FzZQFgbWF4X3ByaW9yaXR5X2ZlZV9wZXJfZ2FzXQUUbm9uY2VdBSxhY2Nlc3NfbGlzdGUFSGF1dGhvcml6YXRpb25fbGlzdE0FHGNyZWF0ZTIAACgYc291cmNl5BBpbml0JBBzYWx0IBR2YWx1ZWUBJGdhc19saW1pdAg8bWF4X2ZlZV9wZXJfZ2FzZQFgbWF4X3ByaW9yaXR5X2ZlZV9wZXJfZ2FzXQUUbm9uY2VdBSxhY2Nlc3NfbGlzdGUFSGF1dGhvcml6YXRpb25fbGlzdE0FNHNldF93aGl0ZWxpc3QAAAQMbmV3aQVEZGlzYWJsZV93aGl0ZWxpc3QAAAQgZGlzYWJsZWQUAghQc2V0X2Jhc2VfZmVlX3Blcl9nYXMAAAQMZmVlZQE4c2V0X2VsYXN0aWNpdHkAAAQoZWxhc3RpY2l0eQQADBRyb3VuZAgocmFuZG9tbmVzcyQkc2lnbmF0dXJlJAR1BQACDBxFZDI1NTE5ASAcU3IyNTUxOQEgFEVjZHNhAYEDAAwwYmxvY2tfbnVtYmVyBBhwdWxzZXN5BRhwdWJsaWN9BQIMHEVkMjU1MTkB5QEcU3IyNTUxOQHlARRFY2RzYQHJAgaFBQAcKHB1YmxpY19rZXkkGHBlcmlvZAQwZ2VuZXNpc190aW1lBBBoYXNoJChncm91cF9oYXNoJCRzY2hlbWVfaWQkIG1ldGFkYXRhJAAMMGJsb2NrX251bWJlcgQYY29uZmlnjQUYcHVibGljfQUCDCx3cml0ZV9wdWxzZQAACDhwdWxzZXNfcGF5bG9hZIEFJHNpZ25hdHVyZYkFRHNldF9iZWFjb25fY29uZmlnAAAIOGNvbmZpZ19wYXlsb2FkkQUkc2lnbmF0dXJliQVcc2V0X29sZGVzdF9zdG9yZWRfcm91bmQAAAQwb2xkZXN0X3JvdW5kCAaxBQIkGGNyZWF0ZQAAGBxkZXBvc2l0CEBtaW5fY29udHJpYnV0aW9uCAxjYXAIDGVuZAQQY2FsbJkFOHRhcmdldF9hZGRyZXNz/Chjb250cmlidXRlAAAIMGNyb3dkbG9hbl9pZAQYYW1vdW50CCB3aXRoZHJhdwAABDBjcm93ZGxvYW5faWQEIGZpbmFsaXplAAAEMGNyb3dkbG9hbl9pZAQYcmVmdW5kAAAEMGNyb3dkbG9hbl9pZAQgZGlzc29sdmUAAAQwY3Jvd2Rsb2FuX2lkBFx1cGRhdGVfbWluX2NvbnRyaWJ1dGlvbgAACDBjcm93ZGxvYW5faWQEUG5ld19taW5fY29udHJpYnV0aW9uCCh1cGRhdGVfZW5kAAAIMGNyb3dkbG9hbl9pZAQcbmV3X2VuZAQodXBkYXRlX2NhcAAACDBjcm93ZGxvYW5faWQEHG5ld19jYXAIAhgwc2V0X2ZlZV9yYXRlAAAIGG5ldHVpZAQQcmF0ZQRUdG9nZ2xlX3VzZXJfbGlxdWlkaXR5AAAIGG5ldHVpZAQYZW5hYmxlFDRhZGRfbGlxdWlkaXR5AAAUGGhvdGtleQAYbmV0dWlkBCB0aWNrX2xvdwQkdGlja19oaWdoBCRsaXF1aWRpdHkIQHJlbW92ZV9saXF1aWRpdHkAAAwYaG90a2V5ABhuZXR1aWQELHBvc2l0aW9uX2lkCDxtb2RpZnlfcG9zaXRpb24AABAYaG90a2V5ABhuZXR1aWQELHBvc2l0aW9uX2lkCDxsaXF1aWRpdHlfZGVsdGEIKGRpc2FibGVfbHAAAQUCCCBFbmZvcmNlZAABBRxSZWxheGVkAAEFAig8Y2FsbF9vbGRfd2VpZ2h0AAAUEGRlc3QxAhR2YWx1ZQgkZ2FzX2xpbWl0CFRzdG9yYWdlX2RlcG9zaXRfbGltaXTNAhBkYXRhJIBpbnN0YW50aWF0ZV93aXRoX2NvZGVfb2xkX3dlaWdodAAAGBR2YWx1ZQgkZ2FzX2xpbWl0CFRzdG9yYWdlX2RlcG9zaXRfbGltaXTNAhBjb2RlJBBkYXRhJBBzYWx0JFhpbnN0YW50aWF0ZV9vbGRfd2VpZ2h0AAAYFHZhbHVlCCRnYXNfbGltaXQIVHN0b3JhZ2VfZGVwb3NpdF9saW1pdM0CJGNvZGVfaGFzaCAQZGF0YSQQc2FsdCQsdXBsb2FkX2NvZGUAAAwQY29kZSRUc3RvcmFnZV9kZXBvc2l0X2xpbWl0zQIsZGV0ZXJtaW5pc22lBSxyZW1vdmVfY29kZQAABCRjb2RlX2hhc2ggIHNldF9jb2RlAAAIEGRlc3QxAiRjb2RlX2hhc2ggEGNhbGwAABQQZGVzdDECFHZhbHVlCCRnYXNfbGltaXQYVHN0b3JhZ2VfZGVwb3NpdF9saW1pdM0CEGRhdGEkVGluc3RhbnRpYXRlX3dpdGhfY29kZQAAGBR2YWx1ZQgkZ2FzX2xpbWl0GFRzdG9yYWdlX2RlcG9zaXRfbGltaXTNAhBjb2RlJBBkYXRhJBBzYWx0JCxpbnN0YW50aWF0ZQAAGBR2YWx1ZQgkZ2FzX2xpbWl0GFRzdG9yYWdlX2RlcG9zaXRfbGltaXTNAiRjb2RlX2hhc2ggEGRhdGEkEHNhbHQkHG1pZ3JhdGUAAAQwd2VpZ2h0X2xpbWl0GAIMRGFubm91bmNlX25leHRfa2V5AAAEKHB1YmxpY19rZXkkQHN1Ym1pdF9lbmNyeXB0ZWQAAAgoY29tbWl0bWVudCAoY2lwaGVydGV4dCRYbWFya19kZWNyeXB0aW9uX2ZhaWxlZAAACAhpZCAYcmVhc29uJAJcGFN5c3RlbQHRAiRUaW1lc3RhbXAB1QIcR3JhbmRwYQHZAiBCYWxhbmNlcwHdAjxTdWJ0ZW5zb3JNb2R1bGUB4QIcVXRpbGl0eQHxAhBTdWRvAfUCIE11bHRpc2lnAf0CIFByZWltYWdlAQEDJFNjaGVkdWxlcgEJAxRQcm94eQERAyBSZWdpc3RyeQERBCxDb21taXRtZW50cwEZBShBZG1pblV0aWxzASEFIFNhZmVNb2RlASUFIEV0aGVyZXVtAVkFDEVWTQFtBRxCYXNlRmVlAXEFFERyYW5kAZUFJENyb3dkbG9hbgGdBRBTd2FwAaEFJENvbnRyYWN0cwGpBSRNZXZTaGllbGQBrQUEsQUAAwgAIAAQEHdoZW4FARxkZXBvc2l0CCRkZXBvc2l0b3IAJGFwcHJvdmFsczUCAwgACAbBBQIILFVucmVxdWVzdGVkAAAIHGRlcG9zaXTBBQxsZW4EJFJlcXVlc3RlZAAADBxkZXBvc2l0xQUUY291bnQEDGxlbugCCCxVbnJlcXVlc3RlZAAACBh0aWNrZXTBBQxsZW4EJFJlcXVlc3RlZAAADDBtYXliZV90aWNrZXTFBRRjb3VudAQkbWF5YmVfbGVu6AMIIAQCDBhMZWdhY3kAAAQQaGFzaCAYSW5saW5lASQYTG9va3VwAAAIEGhhc2ggDGxlbgQAFCBtYXliZV9pZBUBIHByaW9yaXR5BBBjYWxs1QU4bWF5YmVfcGVyaW9kaWMFAxhvcmlnaW7tAgbZBQTdBQAADDR0b3RhbF9yZXRyaWVzBCRyZW1haW5pbmcEGHBlcmlvZAQADCBkZWxlZ2F0ZQAocHJveHlfdHlwZR0BFGRlbGF5BATpBQADCO0FCAAMEHJlYWwAJGNhbGxfaGFzaCAYaGVpZ2h0BAT1BQADCPkFCAAIHGRlcG9zaXQIEGluZm8NBARBAgAADBxkZXBvc2l0CBRibG9jawQQaW5mbxUFAwgkCAQNBgAACChsYXN0X2Vwb2NoCCh1c2VkX3NwYWNlCARdAQAFAQEEABxAdHJhbnNhY3Rpb25faGFzaCBEdHJhbnNhY3Rpb25faW5kZXgEEGZyb23kCHRvCQRAY29udHJhY3RfYWRkcmVzcwkEEGxvZ3MZBihsb2dzX2Jsb29tHQYAECxzdGF0dXNfY29kZQQgdXNlZF9nYXNlAShsb2dzX2Jsb29tHQYQbG9ncxkGAhAYTGVnYWN5ASUGHEVJUDI5MzABJQYcRUlQMTU1OQElBhxFSVA3NzAyASUGAwxVBSEGKQYAPCxwYXJlbnRfaGFzaCAsb21tZXJzX2hhc2ggLGJlbmVmaWNpYXJ55ChzdGF0ZV9yb290IER0cmFuc2FjdGlvbnNfcm9vdCA0cmVjZWlwdHNfcm9vdCAobG9nc19ibG9vbR0GKGRpZmZpY3VsdHllARhudW1iZXJlASRnYXNfbGltaXRlASBnYXNfdXNlZGUBJHRpbWVzdGFtcAgoZXh0cmFfZGF0YSQgbWl4X2hhc2ggFG5vbmNlvQEEVQUABDEGAAAMGGhlYWRlcjEGMHRyYW5zYWN0aW9uczUGGG9tbWVyczkGBCkGAAQhBgAACBBzaXplCBBoYXNoIAMI5CAG1QUALBxjcmVhdG9yABxkZXBvc2l0CEBtaW5fY29udHJpYnV0aW9uCAxlbmQEDGNhcAg0ZnVuZHNfYWNjb3VudAAYcmFpc2VkCDh0YXJnZXRfYWRkcmVzc/wQY2FsbFEGJGZpbmFsaXplZBRIY29udHJpYnV0b3JzX2NvdW50BAMIBAQAEDRsaXF1aWRpdHlfbmV0CDxsaXF1aWRpdHlfZ3Jvc3MIMGZlZXNfb3V0X3Rhbwg4ZmVlc19vdXRfYWxwaGEIAwwEAAgAHAhpZAgYbmV0dWlkBCB0aWNrX2xvdwQkdGlja19oaWdoBCRsaXF1aWRpdHkIIGZlZXNfdGFvCChmZWVzX2FscGhhCAIMDFRvcAABBRhNaWRkbGUAAQUYQm90dG9tAAEFAwwEaQYEABQUb3duZXIAHGRlcG9zaXQIIHJlZmNvdW50CCxkZXRlcm1pbmlzbaUFIGNvZGVfbGVuBAAgHHRyaWVfaWQkJGNvZGVfaGFzaCA0c3RvcmFnZV9ieXRlcwQ0c3RvcmFnZV9pdGVtcwRQc3RvcmFnZV9ieXRlX2RlcG9zaXQIUHN0b3JhZ2VfaXRlbV9kZXBvc2l0CFBzdG9yYWdlX2Jhc2VfZGVwb3NpdAhUZGVsZWdhdGVfZGVwZW5kZW5jaWVzuAAIOGluc2VydF9jb3VudGVyBDhkZWxldGVfY291bnRlcgQAHDBldmVudF90b3BpY3MEMG1lbW9yeV9wYWdlcwQsc3ViamVjdF9sZW4ELHBheWxvYWRfbGVuBDhydW50aW1lX21lbW9yeQRgdmFsaWRhdG9yX3J1bnRpbWVfbWVtb3J5BDhldmVudF9yZWZfdGltZQgACBhsaW1pdHN9BkxpbnN0cnVjdGlvbl93ZWlnaHRzBAAAABAYYXV0aG9yAChjb21taXRtZW50IChjaXBoZXJ0ZXh0JDBzdWJtaXR0ZWRfaW4EABQscGFyZW50X2hhc2ggGG51bWJlcgQoc3RhdGVfcm9vdCA8ZXh0cmluc2ljc19yb290IBhkaWdlc3QwAAgYaGVhZGVyjQYoZXh0cmluc2ljc9UBAgg0QWxsRXh0cmluc2ljcwABBTRPbmx5SW5oZXJlbnRzAAEFAjQQQ2FsbAABBRxQYXltZW50AAEFGEZ1dHVyZQABBRRTdGFsZQABBSBCYWRQcm9vZgABBURBbmNpZW50QmlydGhCbG9jawABBURFeGhhdXN0c1Jlc291cmNlcwABBRhDdXN0b20BBDBCYWRNYW5kYXRvcnkAAQVMTWFuZGF0b3J5VmFsaWRhdGlvbgABBSRCYWRTaWduZXIAAQVUSW5kZXRlcm1pbmF0ZUltcGxpY2l0AAEFNFVua25vd25PcmlnaW4AAQUCDDBDYW5ub3RMb29rdXAAAQVMTm9VbnNpZ25lZFZhbGlkYXRvcgABBRhDdXN0b20BBAIIHEludmFsaWQBmQYcVW5rbm93bgGdBgfQoQYDCL0BJASpBgAADBBva2F5FCxmYXRhbF9lcnJvchQYZXJyb3JzrQYHzEUBBkUBBEUBAAIMHEluQmxvY2sAAQUUTG9jYWwAAQUgRXh0ZXJuYWwAAQUAFCBwcmlvcml0eQggcmVxdWlyZXPVASBwcm92aWRlc9UBJGxvbmdldml0eQgkcHJvcGFnYXRlFAfFBqEGAwgkKATNBgAG0QYADBh3ZWlnaHQYFGNsYXNzOCxwYXJ0aWFsX2ZlZQgADCBiYXNlX2ZlZQgcbGVuX2ZlZQhMYWRqdXN0ZWRfd2VpZ2h0X2ZlZQgG3QYACDRpbmNsdXNpb25fZmVl4QYMdGlwCAAIHGJhbGFuY2VlARRub25jZWUBBmUFBk0FAAggc3RhbmRhcmRlASRlZmZlY3RpdmVlAQAQOHJlZl90aW1lX2xpbWl0zQJAcHJvb2Zfc2l6ZV9saW1pdM0COHJlZl90aW1lX3VzYWdlzQJAcHJvb2Zfc2l6ZV91c2FnZc0CBvkGABQsZXhpdF9yZWFzb25VARR2YWx1ZSQgdXNlZF9nYXP1Bix3ZWlnaHRfaW5mb/0GEGxvZ3MZBgcBB6wAFCxleGl0X3JlYXNvblUBFHZhbHVl5CB1c2VkX2dhc/UGLHdlaWdodF9pbmZv/QYQbG9ncxkGBwkHrAY9BgZBBgZFBgMMEQcVBxkHAwgRBxkHAggYUmVmdW5kAQgYQ2hhcmdlAQgACBRmbGFncwQQZGF0YSQHKQesBpkBABgwZ2FzX2NvbnN1bWVkGDBnYXNfcmVxdWlyZWQYPHN0b3JhZ2VfZGVwb3NpdCUHNGRlYnVnX21lc3NhZ2UkGHJlc3VsdC0HGGV2ZW50czEHAggYVXBsb2FkASQgRXhpc3RpbmcBIAAIGHJlc3VsdCkHKGFjY291bnRfaWQABz0HrAAYMGdhc19jb25zdW1lZBgwZ2FzX3JlcXVpcmVkGDxzdG9yYWdlX2RlcG9zaXQlBzRkZWJ1Z19tZXNzYWdlJBhyZXN1bHRBBxhldmVudHMxBwAIJGNvZGVfaGFzaCAcZGVwb3NpdAgHSQesAgwsRG9lc250RXhpc3QAAQVES2V5RGVjb2RpbmdGYWlsZWQAAQVMTWlncmF0aW9uSW5Qcm9ncmVzcwABBQdVAlEHAwgArQIEWQcAACA0ZGVsZWdhdGVfc3M1OAAQdGFrZQQobm9taW5hdG9yc10HKG93bmVyX3NzNTgANHJlZ2lzdHJhdGlvbnPgRHZhbGlkYXRvcl9wZXJtaXRz4DxyZXR1cm5fcGVyXzEwMDAISHRvdGFsX2RhaWx5X3JldHVybggEYQcABmEHAwhhB5UCBG0HAATBBQAAUBhob3RrZXkAHGNvbGRrZXkADHVpZAQYbmV0dWlkBBhhY3RpdmUUJGF4b25faW5mb3UCPHByb21ldGhldXNfaW5mb30CFHN0YWtldQcQcmFuawQgZW1pc3Npb24IJGluY2VudGl2ZQQkY29uc2Vuc3VzBBR0cnVzdAQ8dmFsaWRhdG9yX3RydXN0BCRkaXZpZGVuZHMELGxhc3RfdXBkYXRlCEB2YWxpZGF0b3JfcGVybWl0FBx3ZWlnaHRznQEUYm9uZHOdATRwcnVuaW5nX3Njb3JlBAR5BwAGeQcASBhob3RrZXkAHGNvbGRrZXkADHVpZAQYbmV0dWlkBBhhY3RpdmUUJGF4b25faW5mb3UCPHByb21ldGhldXNfaW5mb30CFHN0YWtldQcQcmFuawQgZW1pc3Npb24IJGluY2VudGl2ZQQkY29uc2Vuc3VzBBR0cnVzdAQ8dmFsaWRhdG9yX3RydXN0BCRkaXZpZGVuZHMELGxhc3RfdXBkYXRlCEB2YWxpZGF0b3JfcGVybWl0FDRwcnVuaW5nX3Njb3JlBASFBwAGhQcASBhuZXR1aWQEDHJobwQUa2FwcGEEKGRpZmZpY3VsdHkIPGltbXVuaXR5X3BlcmlvZARYbWF4X2FsbG93ZWRfdmFsaWRhdG9ycwRMbWluX2FsbG93ZWRfd2VpZ2h0cwREbWF4X3dlaWdodHNfbGltaXQERHNjYWxpbmdfbGF3X3Bvd2VyBDBzdWJuZXR3b3JrX24EQG1heF9hbGxvd2VkX3VpZHMEWGJsb2Nrc19zaW5jZV9sYXN0X3N0ZXAIFHRlbXBvBEBuZXR3b3JrX21vZGFsaXR5BDxuZXR3b3JrX2Nvbm5lY3SdATxlbWlzc2lvbl92YWx1ZXMIEGJ1cm4IFG93bmVyAAaRBwSVBwAATBhuZXR1aWQEDHJobwQUa2FwcGEEKGRpZmZpY3VsdHkIPGltbXVuaXR5X3BlcmlvZARYbWF4X2FsbG93ZWRfdmFsaWRhdG9ycwRMbWluX2FsbG93ZWRfd2VpZ2h0cwREbWF4X3dlaWdodHNfbGltaXQERHNjYWxpbmdfbGF3X3Bvd2VyBDBzdWJuZXR3b3JrX24EQG1heF9hbGxvd2VkX3VpZHMEWGJsb2Nrc19zaW5jZV9sYXN0X3N0ZXAIFHRlbXBvBEBuZXR3b3JrX21vZGFsaXR5BDxuZXR3b3JrX2Nvbm5lY3SdAThlbWlzc2lvbl92YWx1ZQgQYnVybggUb3duZXIAIGlkZW50aXR5xQIGnQcEoQcAAGwMcmhvBBRrYXBwYQQ8aW1tdW5pdHlfcGVyaW9kBExtaW5fYWxsb3dlZF93ZWlnaHRzBERtYXhfd2VpZ2h0c19saW1pdAQUdGVtcG8EOG1pbl9kaWZmaWN1bHR5CDhtYXhfZGlmZmljdWx0eQg8d2VpZ2h0c192ZXJzaW9uCEh3ZWlnaHRzX3JhdGVfbGltaXQITGFkanVzdG1lbnRfaW50ZXJ2YWwEPGFjdGl2aXR5X2N1dG9mZgRQcmVnaXN0cmF0aW9uX2FsbG93ZWQUYHRhcmdldF9yZWdzX3Blcl9pbnRlcnZhbAQgbWluX2J1cm4IIG1heF9idXJuCEBib25kc19tb3ZpbmdfYXZnCEhtYXhfcmVnc19wZXJfYmxvY2sESHNlcnZpbmdfcmF0ZV9saW1pdAg4bWF4X3ZhbGlkYXRvcnMEQGFkanVzdG1lbnRfYWxwaGEIKGRpZmZpY3VsdHkIUGNvbW1pdF9yZXZlYWxfcGVyaW9kCHRjb21taXRfcmV2ZWFsX3dlaWdodHNfZW5hYmxlZBQoYWxwaGFfaGlnaAQkYWxwaGFfbG93BFBsaXF1aWRfYWxwaGFfZW5hYmxlZBQGqQcAhAxyaG8EFGthcHBhBDxpbW11bml0eV9wZXJpb2QETG1pbl9hbGxvd2VkX3dlaWdodHMERG1heF93ZWlnaHRzX2xpbWl0BBR0ZW1wbwQ4bWluX2RpZmZpY3VsdHkIOG1heF9kaWZmaWN1bHR5CDx3ZWlnaHRzX3ZlcnNpb24ISHdlaWdodHNfcmF0ZV9saW1pdAhMYWRqdXN0bWVudF9pbnRlcnZhbAQ8YWN0aXZpdHlfY3V0b2ZmBFByZWdpc3RyYXRpb25fYWxsb3dlZBRgdGFyZ2V0X3JlZ3NfcGVyX2ludGVydmFsBCBtaW5fYnVybgggbWF4X2J1cm4IQGJvbmRzX21vdmluZ19hdmcISG1heF9yZWdzX3Blcl9ibG9jawRIc2VydmluZ19yYXRlX2xpbWl0CDhtYXhfdmFsaWRhdG9ycwRAYWRqdXN0bWVudF9hbHBoYQgoZGlmZmljdWx0eQhQY29tbWl0X3JldmVhbF9wZXJpb2QIdGNvbW1pdF9yZXZlYWxfd2VpZ2h0c19lbmFibGVkFChhbHBoYV9oaWdoBCRhbHBoYV9sb3cEUGxpcXVpZF9hbHBoYV9lbmFibGVkFFxhbHBoYV9zaWdtb2lkX3N0ZWVwbmVzcwgweXVtYV92ZXJzaW9uBEBzdWJuZXRfaXNfYWN0aXZlFER0cmFuc2ZlcnNfZW5hYmxlZBRMYm9uZHNfcmVzZXRfZW5hYmxlZBRYdXNlcl9saXF1aWRpdHlfZW5hYmxlZBQGsQcAVBhuZXR1aWQEMG93bmVyX2hvdGtleQA0b3duZXJfY29sZGtleQAsc3VibmV0X25hbWXgMHRva2VuX3N5bWJvbOAUdGVtcG8EJGxhc3Rfc3RlcAhYYmxvY2tzX3NpbmNlX2xhc3Rfc3RlcAggZW1pc3Npb24IIGFscGhhX2luCCRhbHBoYV9vdXQIGHRhb19pbghIYWxwaGFfb3V0X2VtaXNzaW9uCERhbHBoYV9pbl9lbWlzc2lvbgg8dGFvX2luX2VtaXNzaW9uCFhwZW5kaW5nX2FscGhhX2VtaXNzaW9uCFRwZW5kaW5nX3Jvb3RfZW1pc3Npb24INHN1Ym5ldF92b2x1bWUIVG5ldHdvcmtfcmVnaXN0ZXJlZF9hdAg8c3VibmV0X2lkZW50aXR5xQIwbW92aW5nX3ByaWNlCAa5BwS9BwAGgQIExQcABHUCAAAhARhuZXR1aWQEEG5hbWXgGHN5bWJvbOAgaWRlbnRpdHnFAlRuZXR3b3JrX3JlZ2lzdGVyZWRfYXQIMG93bmVyX2hvdGtleQA0b3duZXJfY29sZGtleQAUYmxvY2sIFHRlbXBvBCRsYXN0X3N0ZXAIWGJsb2Nrc19zaW5jZV9sYXN0X3N0ZXAIPHN1Ym5ldF9lbWlzc2lvbgggYWxwaGFfaW4IJGFscGhhX291dAgYdGFvX2luCEhhbHBoYV9vdXRfZW1pc3Npb24IRGFscGhhX2luX2VtaXNzaW9uCDx0YW9faW5fZW1pc3Npb24IWHBlbmRpbmdfYWxwaGFfZW1pc3Npb24IVHBlbmRpbmdfcm9vdF9lbWlzc2lvbgg0c3VibmV0X3ZvbHVtZQgwbW92aW5nX3ByaWNlCAxyaG8EFGthcHBhBExtaW5fYWxsb3dlZF93ZWlnaHRzBERtYXhfd2VpZ2h0c19saW1pdAQ8d2VpZ2h0c192ZXJzaW9uCEh3ZWlnaHRzX3JhdGVfbGltaXQIPGFjdGl2aXR5X2N1dG9mZgQ4bWF4X3ZhbGlkYXRvcnMEIG51bV91aWRzBCBtYXhfdWlkcwQQYnVybggoZGlmZmljdWx0eQhQcmVnaXN0cmF0aW9uX2FsbG93ZWQUYHBvd19yZWdpc3RyYXRpb25fYWxsb3dlZBQ8aW1tdW5pdHlfcGVyaW9kBDhtaW5fZGlmZmljdWx0eQg4bWF4X2RpZmZpY3VsdHkIIG1pbl9idXJuCCBtYXhfYnVybghAYWRqdXN0bWVudF9hbHBoYQhMYWRqdXN0bWVudF9pbnRlcnZhbARgdGFyZ2V0X3JlZ3NfcGVyX2ludGVydmFsBEhtYXhfcmVnc19wZXJfYmxvY2sESHNlcnZpbmdfcmF0ZV9saW1pdAh0Y29tbWl0X3JldmVhbF93ZWlnaHRzX2VuYWJsZWQUUGNvbW1pdF9yZXZlYWxfcGVyaW9kCFBsaXF1aWRfYWxwaGFfZW5hYmxlZBQoYWxwaGFfaGlnaAQkYWxwaGFfbG93BEBib25kc19tb3ZpbmdfYXZnCBxob3RrZXlzNQIgY29sZGtleXM1AihpZGVudGl0aWVzyQcUYXhvbnPNBxhhY3RpdmVxAkB2YWxpZGF0b3JfcGVybWl0cQI0cHJ1bmluZ19zY29yZeAsbGFzdF91cGRhdGXsIGVtaXNzaW9u7CRkaXZpZGVuZHPgKGluY2VudGl2ZXPgJGNvbnNlbnN1c+AUdHJ1c3TgEHJhbmvgVGJsb2NrX2F0X3JlZ2lzdHJhdGlvbuwsYWxwaGFfc3Rha2XsJHRhb19zdGFrZewsdG90YWxfc3Rha2XsYHRhb19kaXZpZGVuZHNfcGVyX2hvdGtleXUHaGFscGhhX2RpdmlkZW5kc19wZXJfaG90a2V5dQcG0QcE1QcABOwAAEgYbmV0dWlkBBxob3RrZXlzNQIgY29sZGtleXM1AhhhY3RpdmVxAkB2YWxpZGF0b3JfcGVybWl0cQI0cHJ1bmluZ19zY29yZeAsbGFzdF91cGRhdGXsIGVtaXNzaW9u7CRkaXZpZGVuZHPgKGluY2VudGl2ZXPgJGNvbnNlbnN1c+AUdHJ1c3TgEHJhbmvgVGJsb2NrX2F0X3JlZ2lzdHJhdGlvbuwsYWxwaGFfc3Rha2XsJHRhb19zdGFrZewsdG90YWxfc3Rha2XsQGVtaXNzaW9uX2hpc3RvcnndBwbhBwbFAgYUBjUCBskHBs0HBnECBuwGdQcDCADgBAkIAAYNCAApARhuZXR1aWQEEG5hbWUdBRhzeW1ib2wdBSBpZGVudGl0eekHVG5ldHdvcmtfcmVnaXN0ZXJlZF9hdM0CMG93bmVyX2hvdGtlefw0b3duZXJfY29sZGtlefwUYmxvY2vNAhR0ZW1wb+gkbGFzdF9zdGVwzQJYYmxvY2tzX3NpbmNlX2xhc3Rfc3RlcM0CPHN1Ym5ldF9lbWlzc2lvbs0CIGFscGhhX2luzQIkYWxwaGFfb3V0zQIYdGFvX2luzQJIYWxwaGFfb3V0X2VtaXNzaW9uzQJEYWxwaGFfaW5fZW1pc3Npb27NAjx0YW9faW5fZW1pc3Npb27NAlhwZW5kaW5nX2FscGhhX2VtaXNzaW9uzQJUcGVuZGluZ19yb290X2VtaXNzaW9uzQI0c3VibmV0X3ZvbHVtZc0CMG1vdmluZ19wcmljZc0CDHJob+gUa2FwcGHoTG1pbl9hbGxvd2VkX3dlaWdodHPoRG1heF93ZWlnaHRzX2xpbWl06Dx3ZWlnaHRzX3ZlcnNpb27NAkh3ZWlnaHRzX3JhdGVfbGltaXTNAjxhY3Rpdml0eV9jdXRvZmboOG1heF92YWxpZGF0b3Jz6CBudW1fdWlkc+ggbWF4X3VpZHPoEGJ1cm7NAihkaWZmaWN1bHR5zQJQcmVnaXN0cmF0aW9uX2FsbG93ZWTtB2Bwb3dfcmVnaXN0cmF0aW9uX2FsbG93ZWTtBzxpbW11bml0eV9wZXJpb2ToOG1pbl9kaWZmaWN1bHR5zQI4bWF4X2RpZmZpY3VsdHnNAiBtaW5fYnVybs0CIG1heF9idXJuzQJAYWRqdXN0bWVudF9hbHBoYc0CTGFkanVzdG1lbnRfaW50ZXJ2YWzoYHRhcmdldF9yZWdzX3Blcl9pbnRlcnZhbOhIbWF4X3JlZ3NfcGVyX2Jsb2Nr6EhzZXJ2aW5nX3JhdGVfbGltaXTNAnRjb21taXRfcmV2ZWFsX3dlaWdodHNfZW5hYmxlZO0HUGNvbW1pdF9yZXZlYWxfcGVyaW9kzQJQbGlxdWlkX2FscGhhX2VuYWJsZWTtByhhbHBoYV9oaWdo6CRhbHBoYV9sb3foQGJvbmRzX21vdmluZ19hdmfNAhxob3RrZXlz8QcgY29sZGtleXPxByhpZGVudGl0aWVz9QcUYXhvbnP5BxhhY3RpdmX9B0B2YWxpZGF0b3JfcGVybWl0/Qc0cHJ1bmluZ19zY29yZR0FLGxhc3RfdXBkYXRlAQggZW1pc3Npb24BCCRkaXZpZGVuZHMdBShpbmNlbnRpdmVzHQUkY29uc2Vuc3VzHQUUdHJ1c3QdBRByYW5rHQVUYmxvY2tfYXRfcmVnaXN0cmF0aW9uAQgsYWxwaGFfc3Rha2UBCCR0YW9fc3Rha2UBCCx0b3RhbF9zdGFrZQEIYHRhb19kaXZpZGVuZHNfcGVyX2hvdGtleQUIaGFscGhhX2RpdmlkZW5kc19wZXJfaG90a2V5BQgodmFsaWRhdG9ycx0FLGNvbW1pdG1lbnRzEQgGFQgAJBhob3RrZXkAHGNvbGRrZXkAGG5ldHVpZAQUc3Rha2UIGGxvY2tlZAggZW1pc3Npb24IMHRhb19lbWlzc2lvbggUZHJhaW4INGlzX3JlZ2lzdGVyZWQUBB0IAAMIACEIBCUIAAYdCAZFAgQIAQgCDDBQcmltYXJ5U2xvdHMAAQV0UHJpbWFyeUFuZFNlY29uZGFyeVBsYWluU2xvdHMAAQVsUHJpbWFyeUFuZFNlY29uZGFyeVZSRlNsb3RzAAEFABg0c2xvdF9kdXJhdGlvbggwZXBvY2hfbGVuZ3RoCARjNQgsYXV0aG9yaXRpZXO4KHJhbmRvbW5lc3MgNGFsbG93ZWRfc2xvdHM5CAAIBGM1CDRhbGxvd2VkX3Nsb3RzOQgAGCxlcG9jaF9pbmRleAgoc3RhcnRfc2xvdAggZHVyYXRpb24ILGF1dGhvcml0aWVzuChyYW5kb21uZXNzIBhjb25maWdBCAAQIG9mZmVuZGVyIBBzbG90CDBmaXJzdF9oZWFkZXKNBjRzZWNvbmRfaGVhZGVyjQYACBhuZXR1aWQEFHByaWNlCARNCAAAGCh0YW9fYW1vdW50CDBhbHBoYV9hbW91bnQIHHRhb19mZWUIJGFscGhhX2ZlZQgwdGFvX3NsaXBwYWdlCDhhbHBoYV9zbGlwcGFnZQg="; +var metadataTypes_default = content; +export { + metadataTypes_default as default +}; diff --git a/contract-tests/.papi/descriptors/dist/metadataTypes.d.ts b/contract-tests/.papi/descriptors/dist/metadataTypes.d.ts new file mode 100644 index 0000000000..fa22880cac --- /dev/null +++ b/contract-tests/.papi/descriptors/dist/metadataTypes.d.ts @@ -0,0 +1,2 @@ +declare const content = "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"; +export default content; diff --git a/pallets/subtensor/src/macros/dispatches.rs b/pallets/subtensor/src/macros/dispatches.rs index 08e5bb8fdf..010f434cbd 100644 --- a/pallets/subtensor/src/macros/dispatches.rs +++ b/pallets/subtensor/src/macros/dispatches.rs @@ -611,7 +611,7 @@ mod dispatches { /// - The delegate is setting a take which is not lower than the previous. /// #[pallet::call_index(65)] - #[pallet::weight((::WeightInfo::decrease_take(), DispatchClass::Normal, Pays::No))] + #[pallet::weight((::WeightInfo::decrease_take(), DispatchClass::Normal, Pays::Yes))] pub fn decrease_take( origin: OriginFor, hotkey: T::AccountId, @@ -651,7 +651,7 @@ mod dispatches { /// - The delegate is setting a take which is not greater than the previous. /// #[pallet::call_index(66)] - #[pallet::weight((::WeightInfo::increase_take(), DispatchClass::Normal, Pays::No))] + #[pallet::weight((::WeightInfo::increase_take(), DispatchClass::Normal, Pays::Yes))] pub fn increase_take( origin: OriginFor, hotkey: T::AccountId, diff --git a/pallets/subtensor/src/swap/swap_hotkey.rs b/pallets/subtensor/src/swap/swap_hotkey.rs index a266798aeb..ee97d3d099 100644 --- a/pallets/subtensor/src/swap/swap_hotkey.rs +++ b/pallets/subtensor/src/swap/swap_hotkey.rs @@ -46,17 +46,21 @@ impl Pallet { Error::::NonAssociatedColdKey ); - // 3. If the new hotkey already exists globally, ensure the coldkey owns it + // 3. Initialize the weight for this operation. This includes the old-hotkey + // owner check above. + let mut weight = T::DbWeight::get().reads(2); + + // 4. If the new hotkey already exists globally, ensure the coldkey owns it if Self::hotkey_account_exists(new_hotkey) { + weight.saturating_accrue(T::DbWeight::get().reads(3)); ensure!( Self::coldkey_owns_hotkey(&coldkey, new_hotkey), Error::::NonAssociatedColdKey ); + } else { + weight.saturating_accrue(T::DbWeight::get().reads(1)); } - // 4. Initialize the weight for this operation - let mut weight = T::DbWeight::get().reads(2); - // 5. Ensure the new hotkey is different from the old one ensure!(old_hotkey != new_hotkey, Error::::NewHotKeyIsSameWithOld); diff --git a/pallets/subtensor/src/tests/staking.rs b/pallets/subtensor/src/tests/staking.rs index 660b6957d7..b4753b0797 100644 --- a/pallets/subtensor/src/tests/staking.rs +++ b/pallets/subtensor/src/tests/staking.rs @@ -22,6 +22,26 @@ use crate::*; staking::add_stake() tests ************************************************************/ +#[test] +fn test_delegate_take_dispatch_info_pays_fee() { + new_test_ext(1).execute_with(|| { + let hotkey = U256::from(1); + let take = SubtensorModule::get_min_delegate_take(); + + let decrease_take_call = + RuntimeCall::SubtensorModule(SubtensorCall::decrease_take { hotkey, take }); + let decrease_take_dispatch_info = decrease_take_call.get_dispatch_info(); + assert_eq!(decrease_take_dispatch_info.class, DispatchClass::Normal); + assert_eq!(decrease_take_dispatch_info.pays_fee, Pays::Yes); + + let increase_take_call = + RuntimeCall::SubtensorModule(SubtensorCall::increase_take { hotkey, take }); + let increase_take_dispatch_info = increase_take_call.get_dispatch_info(); + assert_eq!(increase_take_dispatch_info.class, DispatchClass::Normal); + assert_eq!(increase_take_dispatch_info.pays_fee, Pays::Yes); + }); +} + #[test] fn test_add_stake_dispatch_info_ok() { new_test_ext(1).execute_with(|| { diff --git a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs index 1e200aaedd..beb8ec9a75 100644 --- a/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs +++ b/pallets/subtensor/src/tests/swap_hotkey_with_subnet.rs @@ -900,22 +900,23 @@ fn test_swap_owner_old_hotkey_not_exist() { }); } -// SKIP_WASM_BUILD=1 RUST_LOG=debug cargo test --test swap_hotkey_with_subnet -- test_swap_owner_new_hotkey_already_exists --exact --nocapture +// SKIP_WASM_BUILD=1 cargo test --package pallet-subtensor --lib -- tests::swap_hotkey_with_subnet::test_swap_owner_new_hotkey_already_exists --exact --nocapture #[test] fn test_swap_owner_new_hotkey_already_exists() { new_test_ext(1).execute_with(|| { let old_hotkey = U256::from(1); let new_hotkey = U256::from(2); let coldkey = U256::from(3); + let another_coldkey = U256::from(4); - let netuid = add_dynamic_network(&new_hotkey, &coldkey); + let netuid = add_dynamic_network(&old_hotkey, &coldkey); add_balance_to_coldkey_account(&coldkey, 1_000_000_000_000_u64.into()); // old_hotkey is owned by coldkey; new_hotkey was already registered on `netuid` // by add_dynamic_network (the condition under test). Do NOT reassign new_hotkey to // a foreign coldkey — the new_hotkey-ownership check (NonAssociatedColdKey) would // then fire before the already-registered-in-subnet check this test targets. - Owner::::insert(old_hotkey, coldkey); + Owner::::insert(new_hotkey, another_coldkey); // Perform the swap System::set_block_number(System::block_number() + HotkeySwapOnSubnetInterval::get()); @@ -927,7 +928,7 @@ fn test_swap_owner_new_hotkey_already_exists() { Some(netuid), false ), - Error::::HotKeyAlreadyRegisteredInSubNet + Error::::NonAssociatedColdKey ); // Verify the swap diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index a39c473880..52a517873a 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -234,7 +234,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // `spec_version`, and `authoring_version` are the same between Wasm and native. // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use // the compatible custom types. - spec_version: 423, + spec_version: 424, impl_version: 1, apis: RUNTIME_API_VERSIONS, transaction_version: 1,