Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import { ACCOUNT_VALIDATION_SUCCESS_MAGIC } from "@matterlabs/zksync-contracts/l2/system-contracts/interfaces/IAccount.sol";
import { Transaction, TransactionHelper } from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/TransactionHelper.sol";
import { EfficientCall } from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/EfficientCall.sol";
import { NONCE_HOLDER_SYSTEM_CONTRACT, DEPLOYER_SYSTEM_CONTRACT } from "@matterlabs/zksync-contracts/l2/system-contracts/Constants.sol";
import { INonceHolder } from "@matterlabs/zksync-contracts/l2/system-contracts/interfaces/INonceHolder.sol";
import { SystemContractsCaller } from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/SystemContractsCaller.sol";
import { Utils } from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/Utils.sol";
import { Initializable } from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";

import { HookManager } from "./managers/HookManager.sol";
import { Utils as SsoUtils } from "./helpers/Utils.sol";

import { TokenCallbackHandler } from "./helpers/TokenCallbackHandler.sol";

import { Errors } from "./libraries/Errors.sol";
import { SignatureDecoder } from "./libraries/SignatureDecoder.sol";

import { ERC1271Handler } from "./handlers/ERC1271Handler.sol";
import { BatchCaller } from "./batch/BatchCaller.sol";

import { BootloaderAuth } from "./auth/BootloaderAuth.sol";

import { ISsoAccount } from "./interfaces/ISsoAccount.sol";
import { IModuleValidator } from "./interfaces/IModuleValidator.sol";

/// @title SSO Account
/// @author Matter Labs
/// @custom:security-contact [email protected]
/// @notice The implementation is inspired by Clave wallet.
/// @notice This contract is a modular and extensible account implementation with support of
/// multi-ownership, custom modules, validation/execution hooks and different signature validation formats.
/// @dev Contract is expected to be used as Beacon proxy implementation.
contract SsoAccount is
  Initializable,
  HookManager,
  ERC1271Handler,
  TokenCallbackHandler,
  BatchCaller,
  ISsoAccount,
  BootloaderAuth
{
  // Helper library for the Transaction struct
  using TransactionHelper for Transaction;

  constructor() {
    _disableInitializers();
  }

  /// @notice Initializer function that sets account initial configuration. Expected to be used in the proxy.
  /// @dev Sets passkey and passkey validator within account storage
  /// @param initialValidators An array of module validator addresses and initial validation keys
  /// in an ABI encoded format of `abi.encode(validatorAddr,validationKey)`.
  /// @param initialK1Owners An array of addresses with full control over the account.
  function initialize(bytes[] calldata initialValidators, address[] calldata initialK1Owners) external initializer {
    if (initialValidators.length == 0 && initialK1Owners.length == 0) {
      revert Errors.INVALID_ACCOUNT_KEYS();
    }

    address validatorAddr;
    bytes memory initData;
    for (uint256 i = 0; i < initialValidators.length; ++i) {
      (validatorAddr, initData) = abi.decode(initialValidators[i], (address, bytes));
      _addModuleValidator(validatorAddr, initData);
    }
    for (uint256 i = 0; i < initialK1Owners.length; ++i) {
      _addK1Owner(initialK1Owners[i]);
    }
  }

  /// @dev Account might receive/hold base tokens.
  receive() external payable {}

  /// @notice Called by the bootloader to validate that an account agrees to process the transaction
  /// (and potentially pay for it).
  /// @dev The developer should strive to preserve as many steps as possible both for valid
  /// and invalid transactions as this very method is also used during the gas fee estimation
  /// (without some of the necessary data, e.g. signature).
  /// @param _suggestedSignedHash The suggested hash of the transaction that is signed by the signer.
  /// @param _transaction The transaction data.
  /// @return magic The magic value that should be equal to the signature of this function.
  /// if the user agrees to proceed with the transaction.
  function validateTransaction(
    bytes32,
    bytes32 _suggestedSignedHash,
    Transaction calldata _transaction
  ) external payable override onlyBootloader returns (bytes4 magic) {
    // TODO: session txs have their own nonce managers, so they have to not alter this nonce
    _incrementNonce(_transaction.nonce);

    // If there is not enough balance for the transaction, the account should reject it
    // on the validation step to prevent paying fees for revertable transactions.
    uint256 requiredBalance = _transaction.totalRequiredBalance();
    if (requiredBalance > address(this).balance) {
      revert Errors.INSUFFICIENT_FUNDS(requiredBalance, address(this).balance);
    }

    // While the suggested signed hash is usually provided, it is generally
    // not recommended to rely on it to be present, since in the future
    // there may be tx types with no suggested signed hash.
    bytes32 signedHash = _suggestedSignedHash == bytes32(0) ? _transaction.encodeHash() : _suggestedSignedHash;

    magic = _validateTransaction(signedHash, _transaction);
  }

  /// @notice Called by the bootloader to make the account execute the transaction.
  /// @dev The transaction is considered successful if this function does not revert
  /// @param _transaction The transaction data.
  function executeTransaction(
    bytes32,
    bytes32,
    Transaction calldata _transaction
  ) external payable override onlyBootloader runExecutionHooks(_transaction) {
    address to = SsoUtils.safeCastToAddress(_transaction.to);
    uint128 value = Utils.safeCastToU128(_transaction.value);

    _executeCall(to, value, _transaction.data);
  }

  /// @notice Executes a call to a given address with a specified value and calldata.
  /// @param _to The address to which the call is made.
  /// @param _value The value to send along with the call.
  /// @param _data The calldata to pass along with the call.
  function _executeCall(address _to, uint128 _value, bytes calldata _data) private {
    uint32 gas = Utils.safeCastToU32(gasleft());
    bool success;

    if (_to == address(DEPLOYER_SYSTEM_CONTRACT) && _data.length >= 4) {
      bytes4 selector = bytes4(_data[:4]);
      // Check that called function is the deployment method,
      // the other deployer methods are not supposed to be called from the account.
      // NOTE: DefaultAccount has the same behavior.
      bool isSystemCall = selector == DEPLOYER_SYSTEM_CONTRACT.create.selector ||
        selector == DEPLOYER_SYSTEM_CONTRACT.create2.selector ||
        selector == DEPLOYER_SYSTEM_CONTRACT.createAccount.selector ||
        selector == DEPLOYER_SYSTEM_CONTRACT.create2Account.selector;
      // Note, that the deployer contract can only be called with a "isSystemCall" flag.
      success = EfficientCall.rawCall({
        _gas: gas,
        _address: _to,
        _value: _value,
        _data: _data,
        _isSystem: isSystemCall
      });
    } else {
      success = EfficientCall.rawCall(gas, _to, _value, _data, false);
    }

    if (!success) {
      EfficientCall.propagateRevert();
    }
  }

  /// @notice This function allows an EOA to start a transaction for the account. The main purpose of which is
  /// to have and entry point for escaping funds when L2 transactions are censored by the chain, and only
  /// forced transactions are accepted by the network.
  /// @dev It is not implemented yet.
  function executeTransactionFromOutside(Transaction calldata) external payable override {
    revert Errors.METHOD_NOT_IMPLEMENTED();
  }

  /// @notice This function allows the account to pay for its own gas and used when there is no paymaster.
  /// @param _transaction The transaction data.
  /// @dev This method must send at least `tx.gasprice * tx.gasLimit` ETH to the bootloader address.
  function payForTransaction(
    bytes32,
    bytes32,
    Transaction calldata _transaction
  ) external payable override onlyBootloader {
    bool success = _transaction.payToTheBootloader();

    if (!success) {
      revert Errors.FEE_PAYMENT_FAILED();
    }
  }
  /// @notice This function is called by the system if the transaction has a paymaster
  /// and prepares the interaction with the paymaster.
  /// @param _transaction The transaction data.
  function prepareForPaymaster(
    bytes32,
    bytes32,
    Transaction calldata _transaction
  ) external payable override onlyBootloader {
    _transaction.processPaymasterInput();
  }

  /// @dev type(ISsoAccount).interfaceId indicates SSO accounts
  function supportsInterface(bytes4 interfaceId) public view override(IERC165, TokenCallbackHandler) returns (bool) {
    return interfaceId == type(ISsoAccount).interfaceId || super.supportsInterface(interfaceId);
  }

  /// @notice Validates the provided transaction by validating signature of ECDSA k1 owner.
  /// or running validation hooks and signature validation in the provided validator address.
  /// @param _signedHash The signed hash of the transaction.
  /// @param _transaction The transaction data.
  /// @return The magic value if the validation was successful and bytes4(0) otherwise.
  function _validateTransaction(bytes32 _signedHash, Transaction calldata _transaction) private returns (bytes4) {
    // Run validation hooks
    bool hookSuccess = runValidationHooks(_signedHash, _transaction);
    if (!hookSuccess) {
      return bytes4(0);
    }

    if (_transaction.signature.length == 65) {
      (address signer, ECDSA.RecoverError err) = ECDSA.tryRecover(_signedHash, _transaction.signature);
      return
        signer == address(0) || err != ECDSA.RecoverError.NoError || !_isK1Owner(signer)
          ? bytes4(0)
          : ACCOUNT_VALIDATION_SUCCESS_MAGIC;
    }

    // Extract the signature, validator address and hook data from the _transaction.signature
    //  the signature value is not necessary, omitting it
    // slither-disable-next-line unused-return
    (, address validator) = SignatureDecoder.decodeSignatureNoHookData(_transaction.signature);

    bool validationSuccess = _isModuleValidator(validator) &&
      IModuleValidator(validator).validateTransaction(_signedHash, _transaction);
    if (!validationSuccess) {
      return bytes4(0);
    }

    return ACCOUNT_VALIDATION_SUCCESS_MAGIC;
  }

  /// @dev Increments the nonce value in Nonce Holder system contract to ensure replay attack protection.
  /// @dev Reverts if the Nonce Holder stores different `_nonce` value from the expected one.
  /// @param _expectedNonce The nonce value expected for the account to be stored in the Nonce Holder.
  function _incrementNonce(uint256 _expectedNonce) private {
    // Allow-listing slither finding as the call's success is checked+revert within the fn
    // slither-disable-next-line unused-return
    SystemContractsCaller.systemCallWithPropagatedRevert(
      uint32(gasleft()),
      address(NONCE_HOLDER_SYSTEM_CONTRACT),
      0,
      abi.encodeCall(INonceHolder.incrementMinNonceIfEquals, (_expectedNonce))
    );
  }
}

// SPDX-License-Identifier: MIT

import { Errors } from "../libraries/Errors.sol";

/// @title Utility functions
/// @dev Utility functions for used in ZKsync SSO contracts
/// @author Matter Labs
/// @custom:security-contact [email protected]
library Utils {
  /// @dev Safely casts a uint256 to an address.
  /// @dev Revert if the value exceeds the maximum size for an address (160 bits).
  function safeCastToAddress(uint256 _value) internal pure returns (address) {
    if (_value > type(uint160).max) {
      revert Errors.ADDRESS_CAST_OVERFLOW(_value);
    }
    return address(uint160(_value));
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

/// @title Errors
/// @notice Errors used by ZKsync SSO and its components
/// @author Initial version by getclave.io, modified by Matter Labs
library Errors {
  // Account errors
  error INSUFFICIENT_FUNDS(uint256 required, uint256 available);
  error FEE_PAYMENT_FAILED();
  error ACCOUNT_ALREADY_EXISTS(address account);
  error INVALID_ACCOUNT_KEYS();
  error METHOD_NOT_IMPLEMENTED();

  // ERC165 module errors
  error VALIDATOR_ERC165_FAIL(address validator);
  error HOOK_ERC165_FAIL(address hookAddress, bool isValidation);

  // Auth errors
  error NOT_FROM_BOOTLOADER(address notBootloader);
  error NOT_FROM_SELF(address notSelf);
  error NOT_FROM_INITIALIZED_ACCOUNT(address notInitialized);

  // Manager errors
  error OWNER_ALREADY_EXISTS(address owner);
  error OWNER_NOT_FOUND(address owner);
  error VALIDATOR_ALREADY_EXISTS(address validator);
  error VALIDATOR_NOT_FOUND(address validator);
  error HOOK_ALREADY_EXISTS(address hook, bool isValidation);
  error HOOK_NOT_FOUND(address hook, bool isValidation);

  // Sessions errors
  error UNINSTALL_WITH_OPEN_SESSIONS(uint256 openSessions);
  error SESSION_ZERO_SIGNER();
  error SESSION_INVALID_SIGNER(address recovered, address expected);
  error SESSION_ALREADY_EXISTS(bytes32 sessionHash);
  error SESSION_UNLIMITED_FEES();
  error SESSION_EXPIRES_TOO_SOON(uint256 expiresAt);
  error SESSION_NOT_ACTIVE();
  error SESSION_LIFETIME_USAGE_EXCEEDED(uint256 lifetimeUsage, uint256 maxUsage);
  error SESSION_ALLOWANCE_EXCEEDED(uint256 allowance, uint256 maxAllowance, uint64 period);
  error SESSION_INVALID_DATA_LENGTH(uint256 actualLength, uint256 expectedMinimumLength);
  error SESSION_CONDITION_FAILED(bytes32 param, bytes32 refValue, uint8 condition);
  error SESSION_CALL_POLICY_VIOLATED(address target, bytes4 selector);
  error SESSION_TRANSFER_POLICY_VIOLATED(address target);
  error SESSION_MAX_VALUE_EXCEEDED(uint256 usedValue, uint256 maxValuePerUse);

  // Misc
  error BATCH_MSG_VALUE_MISMATCH(uint256 actualValue, uint256 expectedValue);
  error NO_TIMESTAMP_ASSERTER(uint256 chainId);
  error ADDRESS_CAST_OVERFLOW(uint256 value);
  error INVALID_PAYMASTER_INPUT(bytes input);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

library SignatureDecoder {
  // Decode transaction.signature into signature, validator and hook data
  function decodeSignature(
    bytes calldata txSignature
  ) internal pure returns (bytes memory signature, address validator, bytes memory validatorData) {
    (signature, validator, validatorData) = abi.decode(txSignature, (bytes, address, bytes));
  }

  // Decode signature into signature and validator
  function decodeSignatureNoHookData(
    bytes memory signatureAndValidator
  ) internal pure returns (bytes memory signature, address validator) {
    (signature, validator) = abi.decode(signatureAndValidator, (bytes, address));
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import { Transaction } from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/TransactionHelper.sol";
import { IModule } from "./IModule.sol";

/**
 * @title Modular validator interface for native AA
 * @notice Validators are used for custom validation of transactions and/or message signatures
 */
interface IModuleValidator is IModule, IERC165 {
  /**
   * @notice Validate transaction for account
   * @param signedHash Hash of the transaction
   * @param transaction Transaction to validate
   * @return bool True if transaction is valid
   */
  function validateTransaction(bytes32 signedHash, Transaction calldata transaction) external returns (bool);

  /**
   * @notice Validate signature for account (including via EIP-1271)
   * @dev If module is not supposed to validate signatures, it MUST return false
   * @param signedHash Hash of the message
   * @param signature Signature of the message
   * @return bool True if signature is valid
   */
  function validateSignature(bytes32 signedHash, bytes calldata signature) external view returns (bool);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { BOOTLOADER_FORMAL_ADDRESS } from "@matterlabs/zksync-contracts/l2/system-contracts/Constants.sol";
import { Errors } from "../libraries/Errors.sol";

/**
 * @title BootloaderAuth
 * @notice Abstract contract that allows only calls from bootloader
 * @author https://getclave.io
 */
abstract contract BootloaderAuth {
  modifier onlyBootloader() {
    if (msg.sender != BOOTLOADER_FORMAL_ADDRESS) {
      revert Errors.NOT_FROM_BOOTLOADER(msg.sender);
    }
    _;
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { IERC1271Upgradeable } from "@openzeppelin/contracts-upgradeable/interfaces/IERC1271Upgradeable.sol";
import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import { EIP712 } from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";

import { SignatureDecoder } from "../libraries/SignatureDecoder.sol";
import { IModuleValidator } from "../interfaces/IModuleValidator.sol";
import { OwnerManager } from "../managers/OwnerManager.sol";
import { ValidatorManager } from "../managers/ValidatorManager.sol";

/// @title ERC1271Handler
/// @author Matter Labs
/// @notice Contract which provides ERC1271 signature validation
/// @notice The implementation is inspired by Clave wallet.
abstract contract ERC1271Handler is IERC1271Upgradeable, EIP712("Sso1271", "1.0.0"), OwnerManager, ValidatorManager {
  struct SsoMessage {
    bytes32 signedHash;
  }

  bytes32 private constant _SSO_MESSAGE_TYPEHASH = keccak256("SsoMessage(bytes32 signedHash)");

  bytes4 private constant _ERC1271_MAGIC = 0x1626ba7e;

  /**
   * @dev Should return whether the signature provided is valid for the provided data. Does not run validation hooks.
   * @param hash bytes32 - Hash of the data that is signed
   * @param signature bytes calldata - K1 owner signature OR validator address concatenated to signature
   * @return magicValue bytes4 - Magic value if the signature is valid, 0 otherwise
   */
  function isValidSignature(bytes32 hash, bytes memory signature) external view override returns (bytes4 magicValue) {
    if (signature.length == 65) {
      (address signer, ECDSA.RecoverError err) = ECDSA.tryRecover(hash, signature);
      return
        signer == address(0) || err != ECDSA.RecoverError.NoError || !_isK1Owner(signer) ? bytes4(0) : _ERC1271_MAGIC;
    }

    (bytes memory decodedSignature, address validator) = SignatureDecoder.decodeSignatureNoHookData(signature);

    bytes32 eip712Hash = _hashTypedDataV4(_ssoMessageHash(SsoMessage(hash)));

    bool isValid = _isModuleValidator(validator) &&
      IModuleValidator(validator).validateSignature(eip712Hash, decodedSignature);

    magicValue = isValid ? _ERC1271_MAGIC : bytes4(0);
  }

  /**
   * @notice Returns the EIP-712 hash of the Sso message
   * @param ssoMessage SsoMessage calldata - The message containing signedHash
   * @return bytes32 - EIP712 hash of the message
   */
  function getEip712Hash(SsoMessage calldata ssoMessage) external view returns (bytes32) {
    return _hashTypedDataV4(_ssoMessageHash(ssoMessage));
  }

  /**
   * @notice Returns the typehash for the sso message struct
   * @return bytes32 - Sso message typehash
   */
  function ssoMessageTypeHash() external pure returns (bytes32) {
    return _SSO_MESSAGE_TYPEHASH;
  }

  function _ssoMessageHash(SsoMessage memory ssoMessage) private pure returns (bytes32) {
    return keccak256(abi.encode(_SSO_MESSAGE_TYPEHASH, ssoMessage.signedHash));
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { Transaction } from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/TransactionHelper.sol";
import { ExcessivelySafeCall } from "@nomad-xyz/excessively-safe-call/src/ExcessivelySafeCall.sol";

import { SelfAuth } from "../auth/SelfAuth.sol";
import { SsoStorage } from "../libraries/SsoStorage.sol";
import { Errors } from "../libraries/Errors.sol";
import { IExecutionHook, IValidationHook } from "../interfaces/IHook.sol";
import { IHookManager } from "../interfaces/IHookManager.sol";
import { IModule } from "../interfaces/IModule.sol";

/**
 * @title Manager contract for hooks
 * @notice Abstract contract for managing the enabled hooks of the account
 * @dev Hook addresses are stored in an enumerable set
 * @author Initially https://getclave.io, then updated by Matter Labs
 */
abstract contract HookManager is IHookManager, SelfAuth {
  using EnumerableSet for EnumerableSet.AddressSet;
  // Interface helper library
  using ERC165Checker for address;
  // Low level calls helper library
  using ExcessivelySafeCall for address;

  /// @inheritdoc IHookManager
  function addHook(address hook, bool isValidation, bytes calldata initData) external override onlySelf {
    _addHook(hook, isValidation, initData);
  }

  /// @inheritdoc IHookManager
  function removeHook(address hook, bool isValidation, bytes calldata deinitData) external override onlySelf {
    _removeHook(hook, isValidation);
    IModule(hook).onUninstall(deinitData);
  }

  /// @inheritdoc IHookManager
  function unlinkHook(address hook, bool isValidation, bytes calldata deinitData) external onlySelf {
    _removeHook(hook, isValidation);
    // Allow-listing slither finding as we don´t want reverting calls to prevent unlinking
    // slither-disable-next-line unused-return
    hook.excessivelySafeCall(gasleft(), 0, abi.encodeCall(IModule.onUninstall, (deinitData)));
  }

  /// @inheritdoc IHookManager
  function isHook(address addr) external view override returns (bool) {
    return _isHook(addr);
  }

  /// @inheritdoc IHookManager
  function listHooks(bool isValidation) external view override returns (address[] memory hookList) {
    if (isValidation) {
      hookList = SsoStorage.validationHooks().values();
    } else {
      hookList = SsoStorage.executionHooks().values();
    }
  }

  // Runs the validation hooks that are enabled by the account and returns true if none reverts
  function runValidationHooks(bytes32 signedHash, Transaction calldata transaction) internal returns (bool) {
    EnumerableSet.AddressSet storage hookList = SsoStorage.validationHooks();
    uint256 totalHooks = hookList.length();

    for (uint256 i = 0; i < totalHooks; i++) {
      bool success = _call(hookList.at(i), abi.encodeCall(IValidationHook.validationHook, (signedHash, transaction)));

      if (!success) {
        return false;
      }
    }

    return true;
  }

  // Runs the execution hooks that are enabled by the account before and after _executeTransaction
  modifier runExecutionHooks(Transaction calldata transaction) {
    address[] memory hookList = SsoStorage.executionHooks().values();
    uint256 totalHooks = hookList.length;
    bytes[] memory context = new bytes[](totalHooks);

    for (uint256 i = 0; i < totalHooks; i++) {
      context[i] = IExecutionHook(hookList[i]).preExecutionHook(transaction);
    }

    _;

    EnumerableSet.AddressSet storage newHookList = SsoStorage.executionHooks();

    for (uint256 i = 0; i < totalHooks; i++) {
      // Only execute hooks which are both in the old `hookList` and the `newHookList`,
      // and we don't want to execute hooks that were removed and/or added during this transaction.
      if (newHookList.contains(hookList[i])) {
        IExecutionHook(hookList[i]).postExecutionHook(context[i]);
      }
    }
  }

  function _addHook(address hook, bool isValidation, bytes calldata initData) private {
    if (!_supportsHook(hook, isValidation)) {
      revert Errors.HOOK_ERC165_FAIL(hook, isValidation);
    }

    // Regardless of whether or not it is a validation or an execution hook,
    // if the module is already installed, it cannot be installed again (even as another type).
    if (SsoStorage.validationHooks().contains(hook)) {
      revert Errors.HOOK_ALREADY_EXISTS(hook, true);
    }
    if (SsoStorage.executionHooks().contains(hook)) {
      revert Errors.HOOK_ALREADY_EXISTS(hook, false);
    }
    if (SsoStorage.validators().contains(hook)) {
      revert Errors.VALIDATOR_ALREADY_EXISTS(hook);
    }

    // No need to check the return value of .add() as we just checked that it is not already present.
    if (isValidation) {
      bool _result = SsoStorage.validationHooks().add(hook);
    } else {
      bool _result = SsoStorage.executionHooks().add(hook);
    }

    IModule(hook).onInstall(initData);

    emit HookAdded(hook);
  }

  function _removeHook(address hook, bool isValidation) private {
    if (isValidation) {
      if (!SsoStorage.validationHooks().remove(hook)) {
        revert Errors.HOOK_NOT_FOUND(hook, isValidation);
      }
    } else {
      if (!SsoStorage.executionHooks().remove(hook)) {
        revert Errors.HOOK_NOT_FOUND(hook, isValidation);
      }
    }

    emit HookRemoved(hook);
  }

  function _isHook(address addr) internal view returns (bool) {
    return SsoStorage.validationHooks().contains(addr) || SsoStorage.executionHooks().contains(addr);
  }

  function _call(address target, bytes memory data) private returns (bool success) {
    assembly ("memory-safe") {
      success := call(gas(), target, 0, add(data, 0x20), mload(data), 0, 0)
    }
  }

  function _supportsHook(address hook, bool isValidation) private view returns (bool) {
    bytes4[] memory interfaces = new bytes4[](2);
    interfaces[0] = isValidation ? type(IValidationHook).interfaceId : type(IExecutionHook).interfaceId;
    interfaces[1] = type(IModule).interfaceId;
    return hook.supportsAllInterfaces(interfaces);
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { IAccount } from "@matterlabs/zksync-contracts/l2/system-contracts/interfaces/IAccount.sol";

import { IERC1271Upgradeable } from "@openzeppelin/contracts-upgradeable/interfaces/IERC1271Upgradeable.sol";
import { IERC721Receiver } from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import { IERC1155Receiver } from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";

import { IHookManager } from "./IHookManager.sol";
import { IOwnerManager } from "./IOwnerManager.sol";
import { IValidatorManager } from "./IValidatorManager.sol";

/**
 * @title ISsoAccount
 * @notice Interface for the SSO contract
 * @dev Implementations of this interface are contracts that can be used as an SSO account (it's no longer Clave compatible)
 */
interface ISsoAccount is
  IERC1271Upgradeable,
  IERC721Receiver,
  IERC1155Receiver,
  IHookManager,
  IOwnerManager,
  IValidatorManager,
  IAccount
{
  function initialize(bytes[] calldata initialValidators, address[] calldata initialK1Owners) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import { IERC721Receiver } from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import { IERC1155Receiver } from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";

/**
 * @title Token callback handler
 * @notice Contract to handle ERC721 and ERC1155 token callbacks
 * @author https://getclave.io
 */
contract TokenCallbackHandler is IERC721Receiver, IERC1155Receiver {
  function onERC721Received(address, address, uint256, bytes calldata) external pure override returns (bytes4) {
    return IERC721Receiver.onERC721Received.selector;
  }

  function onERC1155Received(
    address,
    address,
    uint256,
    uint256,
    bytes calldata
  ) external pure override returns (bytes4) {
    return IERC1155Receiver.onERC1155Received.selector;
  }

  function onERC1155BatchReceived(
    address,
    address,
    uint256[] calldata,
    uint256[] calldata,
    bytes calldata
  ) external pure override returns (bytes4) {
    return IERC1155Receiver.onERC1155BatchReceived.selector;
  }

  /// @dev function visibility changed to public to allow overriding
  function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
    return
      interfaceId == type(IERC721Receiver).interfaceId ||
      interfaceId == type(IERC1155Receiver).interfaceId ||
      interfaceId == type(IERC165).interfaceId;
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import { EfficientCall } from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/EfficientCall.sol";
import { Utils } from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/Utils.sol";
import { DEPLOYER_SYSTEM_CONTRACT } from "@matterlabs/zksync-contracts/l2/system-contracts/Constants.sol";
import { Errors } from "../libraries/Errors.sol";
import { SelfAuth } from "../auth/SelfAuth.sol";

/// @dev Represents an external call data.
/// @param target The address to which the call will be made.
/// @param allowFailure Flag that represents whether to revert the whole batch if the call fails.
/// @param value The amount of Ether (in wei) to be sent along with the call.
/// @param callData The calldata to be executed on the `target` address.
struct Call {
  address target;
  bool allowFailure;
  uint256 value;
  bytes callData;
}

/// @title SSO Account
/// @author Matter Labs
/// @custom:security-contact [email protected]
/// @notice Make multiple calls from Account in a single transaction.
/// @notice The implementation is inspired by Clave wallet.
abstract contract BatchCaller is SelfAuth {
  /// @notice Emits information about a failed call.
  /// @param index The index of the failed call in the batch.
  /// @param revertData The return data of the failed call.
  event BatchCallFailure(uint256 indexed index, bytes revertData);

  /// @notice Make multiple calls, ensure success if required.
  /// @dev The total Ether sent across all calls must be equal to `msg.value` to maintain the invariant
  /// that `msg.value` + `tx.fee` is the maximum amount of Ether that can be spent on the transaction.
  /// @param _calls Array of Call structs, each representing an individual external call to be made.
  function batchCall(Call[] calldata _calls) external payable onlySelf {
    uint256 totalValue;
    uint256 len = _calls.length;

    for (uint256 i = 0; i < len; ++i) {
      totalValue += _calls[i].value;
      bool success;
      uint32 gas = Utils.safeCastToU32(gasleft());

      if (_calls[i].target == address(DEPLOYER_SYSTEM_CONTRACT)) {
        bytes4 selector = bytes4(_calls[i].callData[:4]);
        // Check that called function is the deployment method,
        // the other deployer methods are not supposed to be called from the account.
        // NOTE: DefaultAccount has the same behavior.
        bool isSystemCall = selector == DEPLOYER_SYSTEM_CONTRACT.create.selector ||
          selector == DEPLOYER_SYSTEM_CONTRACT.create2.selector ||
          selector == DEPLOYER_SYSTEM_CONTRACT.createAccount.selector ||
          selector == DEPLOYER_SYSTEM_CONTRACT.create2Account.selector;
        // Note, that the deployer contract can only be called with a "isSystemCall" flag.
        success = EfficientCall.rawCall({
          _gas: gas,
          _address: _calls[i].target,
          _value: _calls[i].value,
          _data: _calls[i].callData,
          _isSystem: isSystemCall
        });
      } else {
        success = EfficientCall.rawCall(gas, _calls[i].target, _calls[i].value, _calls[i].callData, false);
      }

      if (!success) {
        emit BatchCallFailure(i, getReturnData());
        if (!_calls[i].allowFailure) {
          EfficientCall.propagateRevert();
        }
      }
    }

    if (totalValue != msg.value) {
      revert Errors.BATCH_MSG_VALUE_MISMATCH(msg.value, totalValue);
    }
  }

  function getReturnData() private pure returns (bytes memory data) {
    assembly {
      let size := returndatasize()
      data := mload(0x40)
      mstore(data, size)
      returndatacopy(add(data, 0x20), 0, size)
    }
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./interfaces/IAccountCodeStorage.sol";
import "./interfaces/INonceHolder.sol";
import "./interfaces/IContractDeployer.sol";
import "./interfaces/IKnownCodesStorage.sol";
import "./interfaces/IImmutableSimulator.sol";
import "./interfaces/IEthToken.sol";
import "./interfaces/IL1Messenger.sol";
import "./interfaces/ISystemContext.sol";
import "./interfaces/IBytecodeCompressor.sol";
import "./BootloaderUtilities.sol";

/// @dev All the system contracts introduced by zkSync have their addresses
/// started from 2^15 in order to avoid collision with Ethereum precompiles.
uint160 constant SYSTEM_CONTRACTS_OFFSET = 0x8000; // 2^15

/// @dev All the system contracts must be located in the kernel space,
/// i.e. their addresses must be below 2^16.
uint160 constant MAX_SYSTEM_CONTRACT_ADDRESS = 0xffff; // 2^16 - 1

address constant ECRECOVER_SYSTEM_CONTRACT = address(0x01);
address constant SHA256_SYSTEM_CONTRACT = address(0x02);

/// @dev The current maximum deployed precompile address.
/// Note: currently only two precompiles are deployed:
/// 0x01 - ecrecover
/// 0x02 - sha256
/// Important! So the constant should be updated if more precompiles are deployed.
uint256 constant CURRENT_MAX_PRECOMPILE_ADDRESS = uint256(uint160(SHA256_SYSTEM_CONTRACT));

address payable constant BOOTLOADER_FORMAL_ADDRESS = payable(address(SYSTEM_CONTRACTS_OFFSET + 0x01));
IAccountCodeStorage constant ACCOUNT_CODE_STORAGE_SYSTEM_CONTRACT = IAccountCodeStorage(
    address(SYSTEM_CONTRACTS_OFFSET + 0x02)
);
INonceHolder constant NONCE_HOLDER_SYSTEM_CONTRACT = INonceHolder(address(SYSTEM_CONTRACTS_OFFSET + 0x03));
IKnownCodesStorage constant KNOWN_CODE_STORAGE_CONTRACT = IKnownCodesStorage(address(SYSTEM_CONTRACTS_OFFSET + 0x04));
IImmutableSimulator constant IMMUTABLE_SIMULATOR_SYSTEM_CONTRACT = IImmutableSimulator(
    address(SYSTEM_CONTRACTS_OFFSET + 0x05)
);
IContractDeployer constant DEPLOYER_SYSTEM_CONTRACT = IContractDeployer(address(SYSTEM_CONTRACTS_OFFSET + 0x06));

// A contract that is allowed to deploy any codehash
// on any address. To be used only during an upgrade.
address constant FORCE_DEPLOYER = address(SYSTEM_CONTRACTS_OFFSET + 0x07);
IL1Messenger constant L1_MESSENGER_CONTRACT = IL1Messenger(address(SYSTEM_CONTRACTS_OFFSET + 0x08));
address constant MSG_VALUE_SYSTEM_CONTRACT = address(SYSTEM_CONTRACTS_OFFSET + 0x09);

IEthToken constant ETH_TOKEN_SYSTEM_CONTRACT = IEthToken(address(SYSTEM_CONTRACTS_OFFSET + 0x0a));

address constant KECCAK256_SYSTEM_CONTRACT = address(SYSTEM_CONTRACTS_OFFSET + 0x10);

ISystemContext constant SYSTEM_CONTEXT_CONTRACT = ISystemContext(payable(address(SYSTEM_CONTRACTS_OFFSET + 0x0b)));

BootloaderUtilities constant BOOTLOADER_UTILITIES = BootloaderUtilities(address(SYSTEM_CONTRACTS_OFFSET + 0x0c));

address constant EVENT_WRITER_CONTRACT = address(SYSTEM_CONTRACTS_OFFSET + 0x0d);

IBytecodeCompressor constant BYTECODE_COMPRESSOR_CONTRACT = IBytecodeCompressor(
    address(SYSTEM_CONTRACTS_OFFSET + 0x0e)
);

/// @dev If the bitwise AND of the extraAbi[2] param when calling the MSG_VALUE_SIMULATOR
/// is non-zero, the call will be assumed to be a system one.
uint256 constant MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT = 1;

/// @dev The maximal msg.value that context can have
uint256 constant MAX_MSG_VALUE = 2 ** 128 - 1;

/// @dev Prefix used during derivation of account addresses using CREATE2
/// @dev keccak256("zksyncCreate2")
bytes32 constant CREATE2_PREFIX = 0x2020dba91b30cc0006188af794c2fb30dd8520db7e2c088b7fc7c103c00ca494;
/// @dev Prefix used during derivation of account addresses using CREATE
/// @dev keccak256("zksyncCreate")
bytes32 constant CREATE_PREFIX = 0x63bae3a9951d38e8a3fbb7b70909afc1200610fc5bc55ade242f815974674f23;

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../openzeppelin/token/ERC20/IERC20.sol";
import "../openzeppelin/token/ERC20/utils/SafeERC20.sol";

import "../interfaces/IPaymasterFlow.sol";
import "../interfaces/IContractDeployer.sol";
import {ETH_TOKEN_SYSTEM_CONTRACT, BOOTLOADER_FORMAL_ADDRESS} from "../Constants.sol";
import "./RLPEncoder.sol";
import "./EfficientCall.sol";

/// @dev The type id of zkSync's EIP-712-signed transaction.
uint8 constant EIP_712_TX_TYPE = 0x71;

/// @dev The type id of legacy transactions.
uint8 constant LEGACY_TX_TYPE = 0x0;
/// @dev The type id of legacy transactions.
uint8 constant EIP_2930_TX_TYPE = 0x01;
/// @dev The type id of EIP1559 transactions.
uint8 constant EIP_1559_TX_TYPE = 0x02;

/// @notice Structure used to represent zkSync transaction.
struct Transaction {
    // The type of the transaction.
    uint256 txType;
    // The caller.
    uint256 from;
    // The callee.
    uint256 to;
    // The gasLimit to pass with the transaction.
    // It has the same meaning as Ethereum's gasLimit.
    uint256 gasLimit;
    // The maximum amount of gas the user is willing to pay for a byte of pubdata.
    uint256 gasPerPubdataByteLimit;
    // The maximum fee per gas that the user is willing to pay.
    // It is akin to EIP1559's maxFeePerGas.
    uint256 maxFeePerGas;
    // The maximum priority fee per gas that the user is willing to pay.
    // It is akin to EIP1559's maxPriorityFeePerGas.
    uint256 maxPriorityFeePerGas;
    // The transaction's paymaster. If there is no paymaster, it is equal to 0.
    uint256 paymaster;
    // The nonce of the transaction.
    uint256 nonce;
    // The value to pass with the transaction.
    uint256 value;
    // In the future, we might want to add some
    // new fields to the struct. The `txData` struct
    // is to be passed to account and any changes to its structure
    // would mean a breaking change to these accounts. In order to prevent this,
    // we should keep some fields as "reserved".
    // It is also recommended that their length is fixed, since
    // it would allow easier proof integration (in case we will need
    // some special circuit for preprocessing transactions).
    uint256[4] reserved;
    // The transaction's calldata.
    bytes data;
    // The signature of the transaction.
    bytes signature;
    // The properly formatted hashes of bytecodes that must be published on L1
    // with the inclusion of this transaction. Note, that a bytecode has been published
    // before, the user won't pay fees for its republishing.
    bytes32[] factoryDeps;
    // The input to the paymaster.
    bytes paymasterInput;
    // Reserved dynamic type for the future use-case. Using it should be avoided,
    // But it is still here, just in case we want to enable some additional functionality.
    bytes reservedDynamic;
}

/**
 * @author Matter Labs
 * @notice Library is used to help custom accounts to work with common methods for the Transaction type.
 */
library TransactionHelper {
    using SafeERC20 for IERC20;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 constant EIP712_DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId)");

    bytes32 constant EIP712_TRANSACTION_TYPE_HASH =
        keccak256(
            "Transaction(uint256 txType,uint256 from,uint256 to,uint256 gasLimit,uint256 gasPerPubdataByteLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,uint256 paymaster,uint256 nonce,uint256 value,bytes data,bytes32[] factoryDeps,bytes paymasterInput)"
        );

    /// @notice Whether the token is Ethereum.
    /// @param _addr The address of the token
    /// @return `true` or `false` based on whether the token is Ether.
    /// @dev This method assumes that address is Ether either if the address is 0 (for convenience)
    /// or if the address is the address of the L2EthToken system contract.
    function isEthToken(uint256 _addr) internal pure returns (bool) {
        return _addr == uint256(uint160(address(ETH_TOKEN_SYSTEM_CONTRACT))) || _addr == 0;
    }

    /// @notice Calculate the suggested signed hash of the transaction,
    /// i.e. the hash that is signed by EOAs and is recommended to be signed by other accounts.
    function encodeHash(Transaction calldata _transaction) internal view returns (bytes32 resultHash) {
        if (_transaction.txType == LEGACY_TX_TYPE) {
            resultHash = _encodeHashLegacyTransaction(_transaction);
        } else if (_transaction.txType == EIP_712_TX_TYPE) {
            resultHash = _encodeHashEIP712Transaction(_transaction);
        } else if (_transaction.txType == EIP_1559_TX_TYPE) {
            resultHash = _encodeHashEIP1559Transaction(_transaction);
        } else if (_transaction.txType == EIP_2930_TX_TYPE) {
            resultHash = _encodeHashEIP2930Transaction(_transaction);
        } else {
            // Currently no other transaction types are supported.
            // Any new transaction types will be processed in a similar manner.
            revert("Encoding unsupported tx");
        }
    }

    /// @notice Encode hash of the zkSync native transaction type.
    /// @return keccak256 hash of the EIP-712 encoded representation of transaction
    function _encodeHashEIP712Transaction(Transaction calldata _transaction) private view returns (bytes32) {
        bytes32 structHash = keccak256(
            abi.encode(
                EIP712_TRANSACTION_TYPE_HASH,
                _transaction.txType,
                _transaction.from,
                _transaction.to,
                _transaction.gasLimit,
                _transaction.gasPerPubdataByteLimit,
                _transaction.maxFeePerGas,
                _transaction.maxPriorityFeePerGas,
                _transaction.paymaster,
                _transaction.nonce,
                _transaction.value,
                EfficientCall.keccak(_transaction.data),
                keccak256(abi.encodePacked(_transaction.factoryDeps)),
                EfficientCall.keccak(_transaction.paymasterInput)
            )
        );

        bytes32 domainSeparator = keccak256(
            abi.encode(EIP712_DOMAIN_TYPEHASH, keccak256("zkSync"), keccak256("2"), block.chainid)
        );

        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }

    /// @notice Encode hash of the legacy transaction type.
    /// @return keccak256 of the serialized RLP encoded representation of transaction
    function _encodeHashLegacyTransaction(Transaction calldata _transaction) private view returns (bytes32) {
        // Hash of legacy transactions are encoded as one of the:
        // - RLP(nonce, gasPrice, gasLimit, to, value, data, chainId, 0, 0)
        // - RLP(nonce, gasPrice, gasLimit, to, value, data)
        //
        // In this RLP encoding, only the first one above list appears, so we encode each element
        // inside list and then concatenate the length of all elements with them.

        bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
        // Encode `gasPrice` and `gasLimit` together to prevent "stack too deep error".
        bytes memory encodedGasParam;
        {
            bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            encodedGasParam = bytes.concat(encodedGasPrice, encodedGasLimit);
        }

        bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
        bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        // Encode `chainId` according to EIP-155, but only if the `chainId` is specified in the transaction.
        bytes memory encodedChainId;
        if (_transaction.reserved[0] != 0) {
            encodedChainId = bytes.concat(RLPEncoder.encodeUint256(block.chainid), hex"80_80");
        }

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedNonce.length +
                encodedGasParam.length +
                encodedTo.length +
                encodedValue.length +
                encodedDataLength.length +
                _transaction.data.length +
                encodedChainId.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    encodedListLength,
                    encodedNonce,
                    encodedGasParam,
                    encodedTo,
                    encodedValue,
                    encodedDataLength,
                    _transaction.data,
                    encodedChainId
                )
            );
    }

    /// @notice Encode hash of the EIP2930 transaction type.
    /// @return keccak256 of the serialized RLP encoded representation of transaction
    function _encodeHashEIP2930Transaction(Transaction calldata _transaction) private view returns (bytes32) {
        // Hash of EIP2930 transactions is encoded the following way:
        // H(0x01 || RLP(chain_id, nonce, gas_price, gas_limit, destination, amount, data, access_list))
        //
        // Note, that on zkSync access lists are not supported and should always be empty.

        // Encode all fixed-length params to avoid "stack too deep error"
        bytes memory encodedFixedLengthParams;
        {
            bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
            bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
            bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
            bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
            encodedFixedLengthParams = bytes.concat(
                encodedChainId,
                encodedNonce,
                encodedGasPrice,
                encodedGasLimit,
                encodedTo,
                encodedValue
            );
        }

        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        // On zkSync, access lists are always zero length (at least for now).
        bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedFixedLengthParams.length +
                encodedDataLength.length +
                _transaction.data.length +
                encodedAccessListLength.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    "\x01",
                    encodedListLength,
                    encodedFixedLengthParams,
                    encodedDataLength,
                    _transaction.data,
                    encodedAccessListLength
                )
            );
    }

    /// @notice Encode hash of the EIP1559 transaction type.
    /// @return keccak256 of the serialized RLP encoded representation of transaction
    function _encodeHashEIP1559Transaction(Transaction calldata _transaction) private view returns (bytes32) {
        // Hash of EIP1559 transactions is encoded the following way:
        // H(0x02 || RLP(chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, destination, amount, data, access_list))
        //
        // Note, that on zkSync access lists are not supported and should always be empty.

        // Encode all fixed-length params to avoid "stack too deep error"
        bytes memory encodedFixedLengthParams;
        {
            bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
            bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
            bytes memory encodedMaxPriorityFeePerGas = RLPEncoder.encodeUint256(_transaction.maxPriorityFeePerGas);
            bytes memory encodedMaxFeePerGas = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
            bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
            encodedFixedLengthParams = bytes.concat(
                encodedChainId,
                encodedNonce,
                encodedMaxPriorityFeePerGas,
                encodedMaxFeePerGas,
                encodedGasLimit,
                encodedTo,
                encodedValue
            );
        }

        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        // On zkSync, access lists are always zero length (at least for now).
        bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedFixedLengthParams.length +
                encodedDataLength.length +
                _transaction.data.length +
                encodedAccessListLength.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    "\x02",
                    encodedListLength,
                    encodedFixedLengthParams,
                    encodedDataLength,
                    _transaction.data,
                    encodedAccessListLength
                )
            );
    }

    /// @notice Processes the common paymaster flows, e.g. setting proper allowance
    /// for tokens, etc. For more information on the expected behavior, check out
    /// the "Paymaster flows" section in the documentation.
    function processPaymasterInput(Transaction calldata _transaction) internal {
        require(_transaction.paymasterInput.length >= 4, "The standard paymaster input must be at least 4 bytes long");

        bytes4 paymasterInputSelector = bytes4(_transaction.paymasterInput[0:4]);
        if (paymasterInputSelector == IPaymasterFlow.approvalBased.selector) {
            require(
                _transaction.paymasterInput.length >= 68,
                "The approvalBased paymaster input must be at least 68 bytes long"
            );

            // While the actual data consists of address, uint256 and bytes data,
            // the data is needed only for the paymaster, so we ignore it here for the sake of optimization
            (address token, uint256 minAllowance) = abi.decode(_transaction.paymasterInput[4:68], (address, uint256));
            address paymaster = address(uint160(_transaction.paymaster));

            uint256 currentAllowance = IERC20(token).allowance(address(this), paymaster);
            if (currentAllowance < minAllowance) {
                // Some tokens, e.g. USDT require that the allowance is firsty set to zero
                // and only then updated to the new value.

                IERC20(token).safeApprove(paymaster, 0);
                IERC20(token).safeApprove(paymaster, minAllowance);
            }
        } else if (paymasterInputSelector == IPaymasterFlow.general.selector) {
            // Do nothing. general(bytes) paymaster flow means that the paymaster must interpret these bytes on his own.
        } else {
            revert("Unsupported paymaster flow");
        }
    }

    /// @notice Pays the required fee for the transaction to the bootloader.
    /// @dev Currently it pays the maximum amount "_transaction.maxFeePerGas * _transaction.gasLimit",
    /// it will change in the future.
    function payToTheBootloader(Transaction calldata _transaction) internal returns (bool success) {
        address bootloaderAddr = BOOTLOADER_FORMAL_ADDRESS;
        uint256 amount = _transaction.maxFeePerGas * _transaction.gasLimit;

        assembly {
            success := call(gas(), bootloaderAddr, amount, 0, 0, 0, 0)
        }
    }

    // Returns the balance required to process the transaction.
    function totalRequiredBalance(Transaction calldata _transaction) internal pure returns (uint256 requiredBalance) {
        if (address(uint160(_transaction.paymaster)) != address(0)) {
            // Paymaster pays for the fee
            requiredBalance = _transaction.value;
        } else {
            // The user should have enough balance for both the fee and the value of the transaction
            requiredBalance = _transaction.maxFeePerGas * _transaction.gasLimit + _transaction.value;
        }
    }
}

// SPDX-License-Identifier: MIT OR Apache-2.0

pragma solidity ^0.8.0;

import "./SystemContractHelper.sol";
import "./Utils.sol";
import {SHA256_SYSTEM_CONTRACT, KECCAK256_SYSTEM_CONTRACT} from "../Constants.sol";

/**
 * @author Matter Labs
 * @notice This library is used to perform ultra-efficient calls using zkEVM-specific features.
 * @dev EVM calls always accept a memory slice as input and return a memory slice as output.
 * Therefore, even if the user has a ready-made calldata slice, they still need to copy it to memory
 * before calling. This is especially inefficient for large inputs (proxies, multi-calls, etc.).
 * In turn, zkEVM operates over a fat pointer, which is a set of (memory page, offset, start, length) in the memory/calldata/returndata.
 * This allows forwarding the calldata slice as is, without copying it to memory.
 * @dev Fat pointer is not just an integer, it is an extended data type supported on the VM level.
 * zkEVM creates the wellformed fat pointers for all the calldata/returndata regions, later
 * the contract may manipulate the already created fat pointers to forward a slice of the data, but not
 * to create new fat pointers!
 * @dev The allowed operation on fat pointers are:
 * 1. `ptr.add` - Transforms `ptr.offset` into `ptr.offset + u32(_value)`. If overflow happens then it panics.
 * 2. `ptr.sub` - Transforms `ptr.offset` into `ptr.offset - u32(_value)`. If underflow happens then it panics.
 * 3. `ptr.pack` - Do the concatenation between the lowest 128 bits of the pointer itself and the highest 128 bits of `_value`. It is typically used to prepare the ABI for external calls.
 * 4. `ptr.shrink` - Transforms `ptr.length` into `ptr.length - u32(_shrink)`. If underflow happens then it panics.
 * @dev The call opcodes accept the fat pointer and change it to its canonical form before passing it to the child call
 * 1. `ptr.start` is transformed into `ptr.offset + ptr.start`
 * 2. `ptr.length` is transformed into `ptr.length - ptr.offset`
 * 3. `ptr.offset` is transformed into `0`
 */
library EfficientCall {
    /// @notice Call the `keccak256` without copying calldata to memory.
    /// @param _data The preimage data.
    /// @return The `keccak256` hash.
    function keccak(bytes calldata _data) internal view returns (bytes32) {
        bytes memory returnData = staticCall(gasleft(), KECCAK256_SYSTEM_CONTRACT, _data);
        require(returnData.length == 32, "keccak256 returned invalid data");
        return bytes32(returnData);
    }

    /// @notice Call the `sha256` precompile without copying calldata to memory.
    /// @param _data The preimage data.
    /// @return The `sha256` hash.
    function sha(bytes calldata _data) internal view returns (bytes32) {
        bytes memory returnData = staticCall(gasleft(), SHA256_SYSTEM_CONTRACT, _data);
        require(returnData.length == 32, "sha returned invalid data");
        return bytes32(returnData);
    }

    /// @notice Perform a `call` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _value The `msg.value` to send.
    /// @param _data The calldata to use for the call.
    /// @param _isSystem Whether the call should contain the `isSystem` flag.
    /// @return returnData The copied to memory return data.
    function call(
        uint256 _gas,
        address _address,
        uint256 _value,
        bytes calldata _data,
        bool _isSystem
    ) internal returns (bytes memory returnData) {
        bool success = rawCall(_gas, _address, _value, _data, _isSystem);
        returnData = _verifyCallResult(success);
    }

    /// @notice Perform a `staticCall` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @return returnData The copied to memory return data.
    function staticCall(
        uint256 _gas,
        address _address,
        bytes calldata _data
    ) internal view returns (bytes memory returnData) {
        bool success = rawStaticCall(_gas, _address, _data);
        returnData = _verifyCallResult(success);
    }

    /// @notice Perform a `delegateCall` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @return returnData The copied to memory return data.
    function delegateCall(
        uint256 _gas,
        address _address,
        bytes calldata _data
    ) internal returns (bytes memory returnData) {
        bool success = rawDelegateCall(_gas, _address, _data);
        returnData = _verifyCallResult(success);
    }

    /// @notice Perform a `mimicCall` (a call with custom msg.sender) without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @param _whoToMimic The `msg.sender` for the next call.
    /// @param _isConstructor Whether the call should contain the `isConstructor` flag.
    /// @param _isSystem Whether the call should contain the `isSystem` flag.
    /// @return returnData The copied to memory return data.
    function mimicCall(
        uint256 _gas,
        address _address,
        bytes calldata _data,
        address _whoToMimic,
        bool _isConstructor,
        bool _isSystem
    ) internal returns (bytes memory returnData) {
        bool success = rawMimicCall(_gas, _address, _data, _whoToMimic, _isConstructor, _isSystem);
        returnData = _verifyCallResult(success);
    }

    /// @notice Perform a `call` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _value The `msg.value` to send.
    /// @param _data The calldata to use for the call.
    /// @param _isSystem Whether the call should contain the `isSystem` flag.
    /// @return success whether the call was successful.
    function rawCall(
        uint256 _gas,
        address _address,
        uint256 _value,
        bytes calldata _data,
        bool _isSystem
    ) internal returns (bool success) {
        if (_value == 0) {
            _loadFarCallABIIntoActivePtr(_gas, _data, false, _isSystem);

            address callAddr = RAW_FAR_CALL_BY_REF_CALL_ADDRESS;
            assembly {
                success := call(_address, callAddr, 0, 0, 0xFFFF, 0, 0)
            }
        } else {
            _loadFarCallABIIntoActivePtr(_gas, _data, false, true);

            // If there is provided `msg.value` call the `MsgValueSimulator` to forward ether.
            address msgValueSimulator = MSG_VALUE_SYSTEM_CONTRACT;
            address callAddr = SYSTEM_CALL_BY_REF_CALL_ADDRESS;
            // We need to supply the mask to the MsgValueSimulator to denote
            // that the call should be a system one.
            uint256 forwardMask = _isSystem ? MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT : 0;

            assembly {
                success := call(msgValueSimulator, callAddr, _value, _address, 0xFFFF, forwardMask, 0)
            }
        }
    }

    /// @notice Perform a `staticCall` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @return success whether the call was successful.
    function rawStaticCall(uint256 _gas, address _address, bytes calldata _data) internal view returns (bool success) {
        _loadFarCallABIIntoActivePtr(_gas, _data, false, false);

        address callAddr = RAW_FAR_CALL_BY_REF_CALL_ADDRESS;
        assembly {
            success := staticcall(_address, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Perform a `delegatecall` without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @return success whether the call was successful.
    function rawDelegateCall(uint256 _gas, address _address, bytes calldata _data) internal returns (bool success) {
        _loadFarCallABIIntoActivePtr(_gas, _data, false, false);

        address callAddr = RAW_FAR_CALL_BY_REF_CALL_ADDRESS;
        assembly {
            success := delegatecall(_address, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Perform a `mimicCall` (call with custom msg.sender) without copying calldata to memory.
    /// @param _gas The gas to use for the call.
    /// @param _address The address to call.
    /// @param _data The calldata to use for the call.
    /// @param _whoToMimic The `msg.sender` for the next call.
    /// @param _isConstructor Whether the call should contain the `isConstructor` flag.
    /// @param _isSystem Whether the call should contain the `isSystem` flag.
    /// @return success whether the call was successful.
    /// @dev If called not in kernel mode, it will result in a revert (enforced by the VM)
    function rawMimicCall(
        uint256 _gas,
        address _address,
        bytes calldata _data,
        address _whoToMimic,
        bool _isConstructor,
        bool _isSystem
    ) internal returns (bool success) {
        _loadFarCallABIIntoActivePtr(_gas, _data, _isConstructor, _isSystem);

        address callAddr = MIMIC_CALL_BY_REF_CALL_ADDRESS;
        uint256 cleanupMask = ADDRESS_MASK;
        assembly {
            // Clearing values before usage in assembly, since Solidity
            // doesn't do it by default
            _whoToMimic := and(_whoToMimic, cleanupMask)

            success := call(_address, callAddr, 0, 0, _whoToMimic, 0, 0)
        }
    }

    /// @dev Verify that a low-level call was successful, and revert if it wasn't, by bubbling the revert reason.
    /// @param _success Whether the call was successful.
    /// @return returnData The copied to memory return data.
    function _verifyCallResult(bool _success) private pure returns (bytes memory returnData) {
        if (_success) {
            uint256 size;
            assembly {
                size := returndatasize()
            }

            returnData = new bytes(size);
            assembly {
                returndatacopy(add(returnData, 0x20), 0, size)
            }
        } else {
            propagateRevert();
        }
    }

    /// @dev Propagate the revert reason from the current call to the caller.
    function propagateRevert() internal pure {
        assembly {
            let size := returndatasize()
            returndatacopy(0, 0, size)
            revert(0, size)
        }
    }

    /// @dev Load the far call ABI into active ptr, that will be used for the next call by reference.
    /// @param _gas The gas to be passed to the call.
    /// @param _data The calldata to be passed to the call.
    /// @param _isConstructor Whether the call is a constructor call.
    /// @param _isSystem Whether the call is a system call.
    function _loadFarCallABIIntoActivePtr(
        uint256 _gas,
        bytes calldata _data,
        bool _isConstructor,
        bool _isSystem
    ) private view {
        SystemContractHelper.loadCalldataIntoActivePtr();

        // Currently, zkEVM considers the pointer valid if(ptr.offset < ptr.length || (ptr.length == 0 && ptr.offset == 0)), otherwise panics.
        // So, if the data is empty we need to make the `ptr.length = ptr.offset = 0`, otherwise follow standard logic.
        if (_data.length == 0) {
            // Safe to cast, offset is never bigger than `type(uint32).max`
            SystemContractHelper.ptrShrinkIntoActive(uint32(msg.data.length));
        } else {
            uint256 dataOffset;
            assembly {
                dataOffset := _data.offset
            }

            // Safe to cast, offset is never bigger than `type(uint32).max`
            SystemContractHelper.ptrAddIntoActive(uint32(dataOffset));
            // Safe to cast, `data.length` is never bigger than `type(uint32).max`
            uint32 shrinkTo = uint32(msg.data.length - (_data.length + dataOffset));
            SystemContractHelper.ptrShrinkIntoActive(shrinkTo);
        }

        uint32 gas = Utils.safeCastToU32(_gas);
        uint256 farCallAbi = SystemContractsCaller.getFarCallABIWithEmptyFatPointer(
            gas,
            // Only rollup is supported for now
            0,
            CalldataForwardingMode.ForwardFatPointer,
            _isConstructor,
            _isSystem
        );
        SystemContractHelper.ptrPackIntoActivePtr(farCallAbi);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @author Matter Labs
 * @dev Interface of the nonce holder contract -- a contract used by the system to ensure
 * that there is always a unique identifier for a transaction with a particular account (we call it nonce).
 * In other words, the pair of (address, nonce) should always be unique.
 * @dev Custom accounts should use methods of this contract to store nonces or other possible unique identifiers
 * for the transaction.
 */
interface INonceHolder {
    event ValueSetUnderNonce(address indexed accountAddress, uint256 indexed key, uint256 value);

    /// @dev Returns the current minimal nonce for account.
    function getMinNonce(address _address) external view returns (uint256);

    /// @dev Returns the raw version of the current minimal nonce
    /// (equal to minNonce + 2^128 * deployment nonce).
    function getRawNonce(address _address) external view returns (uint256);

    /// @dev Increases the minimal nonce for the msg.sender.
    function increaseMinNonce(uint256 _value) external returns (uint256);

    /// @dev Sets the nonce value `key` as used.
    function setValueUnderNonce(uint256 _key, uint256 _value) external;

    /// @dev Gets the value stored inside a custom nonce.
    function getValueUnderNonce(uint256 _key) external view returns (uint256);

    /// @dev A convenience method to increment the minimal nonce if it is equal
    /// to the `_expectedNonce`.
    function incrementMinNonceIfEquals(uint256 _expectedNonce) external;

    /// @dev Returns the deployment nonce for the accounts used for CREATE opcode.
    function getDeploymentNonce(address _address) external view returns (uint256);

    /// @dev Increments the deployment nonce for the account and returns the previous one.
    function incrementDeploymentNonce(address _address) external returns (uint256);

    /// @dev Determines whether a certain nonce has been already used for an account.
    function validateNonceUsage(address _address, uint256 _key, bool _shouldBeUsed) external view;

    /// @dev Returns whether a nonce has been used for an account.
    function isNonceUsed(address _address, uint256 _nonce) external view returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8;

import {MSG_VALUE_SYSTEM_CONTRACT, MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT} from "../Constants.sol";
import "./Utils.sol";

// Addresses used for the compiler to be replaced with the
// zkSync-specific opcodes during the compilation.
// IMPORTANT: these are just compile-time constants and are used
// only if used in-place by Yul optimizer.
address constant TO_L1_CALL_ADDRESS = address((1 << 16) - 1);
address constant CODE_ADDRESS_CALL_ADDRESS = address((1 << 16) - 2);
address constant PRECOMPILE_CALL_ADDRESS = address((1 << 16) - 3);
address constant META_CALL_ADDRESS = address((1 << 16) - 4);
address constant MIMIC_CALL_CALL_ADDRESS = address((1 << 16) - 5);
address constant SYSTEM_MIMIC_CALL_CALL_ADDRESS = address((1 << 16) - 6);
address constant MIMIC_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 7);
address constant SYSTEM_MIMIC_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 8);
address constant RAW_FAR_CALL_CALL_ADDRESS = address((1 << 16) - 9);
address constant RAW_FAR_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 10);
address constant SYSTEM_CALL_CALL_ADDRESS = address((1 << 16) - 11);
address constant SYSTEM_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 12);
address constant SET_CONTEXT_VALUE_CALL_ADDRESS = address((1 << 16) - 13);
address constant SET_PUBDATA_PRICE_CALL_ADDRESS = address((1 << 16) - 14);
address constant INCREMENT_TX_COUNTER_CALL_ADDRESS = address((1 << 16) - 15);
address constant PTR_CALLDATA_CALL_ADDRESS = address((1 << 16) - 16);
address constant CALLFLAGS_CALL_ADDRESS = address((1 << 16) - 17);
address constant PTR_RETURNDATA_CALL_ADDRESS = address((1 << 16) - 18);
address constant EVENT_INITIALIZE_ADDRESS = address((1 << 16) - 19);
address constant EVENT_WRITE_ADDRESS = address((1 << 16) - 20);
address constant LOAD_CALLDATA_INTO_ACTIVE_PTR_CALL_ADDRESS = address((1 << 16) - 21);
address constant LOAD_LATEST_RETURNDATA_INTO_ACTIVE_PTR_CALL_ADDRESS = address((1 << 16) - 22);
address constant PTR_ADD_INTO_ACTIVE_CALL_ADDRESS = address((1 << 16) - 23);
address constant PTR_SHRINK_INTO_ACTIVE_CALL_ADDRESS = address((1 << 16) - 24);
address constant PTR_PACK_INTO_ACTIVE_CALL_ADDRESS = address((1 << 16) - 25);
address constant MULTIPLICATION_HIGH_ADDRESS = address((1 << 16) - 26);
address constant GET_EXTRA_ABI_DATA_ADDRESS = address((1 << 16) - 27);

// All the offsets are in bits
uint256 constant META_GAS_PER_PUBDATA_BYTE_OFFSET = 0 * 8;
uint256 constant META_HEAP_SIZE_OFFSET = 8 * 8;
uint256 constant META_AUX_HEAP_SIZE_OFFSET = 12 * 8;
uint256 constant META_SHARD_ID_OFFSET = 28 * 8;
uint256 constant META_CALLER_SHARD_ID_OFFSET = 29 * 8;
uint256 constant META_CODE_SHARD_ID_OFFSET = 30 * 8;

/// @notice The way to forward the calldata:
/// - Use the current heap (i.e. the same as on EVM).
/// - Use the auxiliary heap.
/// - Forward via a pointer
/// @dev Note, that currently, users do not have access to the auxiliary
/// heap and so the only type of forwarding that will be used by the users
/// are UseHeap and ForwardFatPointer for forwarding a slice of the current calldata
/// to the next call.
enum CalldataForwardingMode {
    UseHeap,
    ForwardFatPointer,
    UseAuxHeap
}

/**
 * @author Matter Labs
 * @notice A library that allows calling contracts with the `isSystem` flag.
 * @dev It is needed to call ContractDeployer and NonceHolder.
 */
library SystemContractsCaller {
    /// @notice Makes a call with the `isSystem` flag.
    /// @param gasLimit The gas limit for the call.
    /// @param to The address to call.
    /// @param value The value to pass with the transaction.
    /// @param data The calldata.
    /// @return success Whether the transaction has been successful.
    /// @dev Note, that the `isSystem` flag can only be set when calling system contracts.
    function systemCall(uint32 gasLimit, address to, uint256 value, bytes memory data) internal returns (bool success) {
        address callAddr = SYSTEM_CALL_CALL_ADDRESS;

        uint32 dataStart;
        assembly {
            dataStart := add(data, 0x20)
        }
        uint32 dataLength = uint32(Utils.safeCastToU32(data.length));

        uint256 farCallAbi = SystemContractsCaller.getFarCallABI(
            0,
            0,
            dataStart,
            dataLength,
            gasLimit,
            // Only rollup is supported for now
            0,
            CalldataForwardingMode.UseHeap,
            false,
            true
        );

        if (value == 0) {
            // Doing the system call directly
            assembly {
                success := call(to, callAddr, 0, 0, farCallAbi, 0, 0)
            }
        } else {
            address msgValueSimulator = MSG_VALUE_SYSTEM_CONTRACT;
            // We need to supply the mask to the MsgValueSimulator to denote
            // that the call should be a system one.
            uint256 forwardMask = MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT;

            assembly {
                success := call(msgValueSimulator, callAddr, value, to, farCallAbi, forwardMask, 0)
            }
        }
    }

    /// @notice Makes a call with the `isSystem` flag.
    /// @param gasLimit The gas limit for the call.
    /// @param to The address to call.
    /// @param value The value to pass with the transaction.
    /// @param data The calldata.
    /// @return success Whether the transaction has been successful.
    /// @return returnData The returndata of the transaction (revert reason in case the transaction has failed).
    /// @dev Note, that the `isSystem` flag can only be set when calling system contracts.
    function systemCallWithReturndata(
        uint32 gasLimit,
        address to,
        uint128 value,
        bytes memory data
    ) internal returns (bool success, bytes memory returnData) {
        success = systemCall(gasLimit, to, value, data);

        uint256 size;
        assembly {
            size := returndatasize()
        }

        returnData = new bytes(size);
        assembly {
            returndatacopy(add(returnData, 0x20), 0, size)
        }
    }

    /// @notice Makes a call with the `isSystem` flag.
    /// @param gasLimit The gas limit for the call.
    /// @param to The address to call.
    /// @param value The value to pass with the transaction.
    /// @param data The calldata.
    /// @return returnData The returndata of the transaction. In case the transaction reverts, the error
    /// bubbles up to the parent frame.
    /// @dev Note, that the `isSystem` flag can only be set when calling system contracts.
    function systemCallWithPropagatedRevert(
        uint32 gasLimit,
        address to,
        uint128 value,
        bytes memory data
    ) internal returns (bytes memory returnData) {
        bool success;
        (success, returnData) = systemCallWithReturndata(gasLimit, to, value, data);

        if (!success) {
            assembly {
                let size := mload(returnData)
                revert(add(returnData, 0x20), size)
            }
        }
    }

    /// @notice Calculates the packed representation of the FarCallABI.
    /// @param dataOffset Calldata offset in memory. Provide 0 unless using custom pointer.
    /// @param memoryPage Memory page to use. Provide 0 unless using custom pointer.
    /// @param dataStart The start of the calldata slice. Provide the offset in memory
    /// if not using custom pointer.
    /// @param dataLength The calldata length. Provide the length of the calldata in bytes
    /// unless using custom pointer.
    /// @param gasPassed The gas to pass with the call.
    /// @param shardId Of the account to call. Currently only 0 is supported.
    /// @param forwardingMode The forwarding mode to use:
    /// - provide CalldataForwardingMode.UseHeap when using your current memory
    /// - provide CalldataForwardingMode.ForwardFatPointer when using custom pointer.
    /// @param isConstructorCall Whether the call will be a call to the constructor
    /// (ignored when the caller is not a system contract).
    /// @param isSystemCall Whether the call will have the `isSystem` flag.
    /// @return farCallAbi The far call ABI.
    /// @dev The `FarCallABI` has the following structure:
    /// pub struct FarCallABI {
    ///     pub memory_quasi_fat_pointer: FatPointer,
    ///     pub gas_passed: u32,
    ///     pub shard_id: u8,
    ///     pub forwarding_mode: FarCallForwardPageType,
    ///     pub constructor_call: bool,
    ///     pub to_system: bool,
    /// }
    ///
    /// The FatPointer struct:
    ///
    /// pub struct FatPointer {
    ///     pub offset: u32, // offset relative to `start`
    ///     pub memory_page: u32, // memory page where slice is located
    ///     pub start: u32, // absolute start of the slice
    ///     pub length: u32, // length of the slice
    /// }
    ///
    /// @dev Note, that the actual layout is the following:
    ///
    /// [0..32) bits -- the calldata offset
    /// [32..64) bits -- the memory page to use. Can be left blank in most of the cases.
    /// [64..96) bits -- the absolute start of the slice
    /// [96..128) bits -- the length of the slice.
    /// [128..192) bits -- empty bits.
    /// [192..224) bits -- gasPassed.
    /// [224..232) bits -- forwarding_mode
    /// [232..240) bits -- shard id.
    /// [240..248) bits -- constructor call flag
    /// [248..256] bits -- system call flag
    function getFarCallABI(
        uint32 dataOffset,
        uint32 memoryPage,
        uint32 dataStart,
        uint32 dataLength,
        uint32 gasPassed,
        uint8 shardId,
        CalldataForwardingMode forwardingMode,
        bool isConstructorCall,
        bool isSystemCall
    ) internal pure returns (uint256 farCallAbi) {
        // Fill in the call parameter fields
        farCallAbi = getFarCallABIWithEmptyFatPointer(
            gasPassed,
            shardId,
            forwardingMode,
            isConstructorCall,
            isSystemCall
        );
        // Fill in the fat pointer fields
        farCallAbi |= dataOffset;
        farCallAbi |= (uint256(memoryPage) << 32);
        farCallAbi |= (uint256(dataStart) << 64);
        farCallAbi |= (uint256(dataLength) << 96);
    }

    /// @notice Calculates the packed representation of the FarCallABI with zero fat pointer fields.
    /// @param gasPassed The gas to pass with the call.
    /// @param shardId Of the account to call. Currently only 0 is supported.
    /// @param forwardingMode The forwarding mode to use:
    /// - provide CalldataForwardingMode.UseHeap when using your current memory
    /// - provide CalldataForwardingMode.ForwardFatPointer when using custom pointer.
    /// @param isConstructorCall Whether the call will be a call to the constructor
    /// (ignored when the caller is not a system contract).
    /// @param isSystemCall Whether the call will have the `isSystem` flag.
    /// @return farCallAbiWithEmptyFatPtr The far call ABI with zero fat pointer fields.
    function getFarCallABIWithEmptyFatPointer(
        uint32 gasPassed,
        uint8 shardId,
        CalldataForwardingMode forwardingMode,
        bool isConstructorCall,
        bool isSystemCall
    ) internal pure returns (uint256 farCallAbiWithEmptyFatPtr) {
        farCallAbiWithEmptyFatPtr |= (uint256(gasPassed) << 192);
        farCallAbiWithEmptyFatPtr |= (uint256(forwardingMode) << 224);
        farCallAbiWithEmptyFatPtr |= (uint256(shardId) << 232);
        if (isConstructorCall) {
            farCallAbiWithEmptyFatPtr |= (1 << 240);
        }
        if (isSystemCall) {
            farCallAbiWithEmptyFatPtr |= (1 << 248);
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

import "./EfficientCall.sol";

/**
 * @author Matter Labs
 * @dev Common utilities used in zkSync system contracts
 */
library Utils {
    /// @dev Bit mask of bytecode hash "isConstructor" marker
    bytes32 constant IS_CONSTRUCTOR_BYTECODE_HASH_BIT_MASK =
        0x00ff000000000000000000000000000000000000000000000000000000000000;

    /// @dev Bit mask to set the "isConstructor" marker in the bytecode hash
    bytes32 constant SET_IS_CONSTRUCTOR_MARKER_BIT_MASK =
        0x0001000000000000000000000000000000000000000000000000000000000000;

    function safeCastToU128(uint256 _x) internal pure returns (uint128) {
        require(_x <= type(uint128).max, "Overflow");

        return uint128(_x);
    }

    function safeCastToU32(uint256 _x) internal pure returns (uint32) {
        require(_x <= type(uint32).max, "Overflow");

        return uint32(_x);
    }

    function safeCastToU24(uint256 _x) internal pure returns (uint24) {
        require(_x <= type(uint24).max, "Overflow");

        return uint24(_x);
    }

    /// @return codeLength The bytecode length in bytes
    function bytecodeLenInBytes(bytes32 _bytecodeHash) internal pure returns (uint256 codeLength) {
        codeLength = bytecodeLenInWords(_bytecodeHash) << 5; // _bytecodeHash * 32
    }

    /// @return codeLengthInWords The bytecode length in machine words
    function bytecodeLenInWords(bytes32 _bytecodeHash) internal pure returns (uint256 codeLengthInWords) {
        unchecked {
            codeLengthInWords = uint256(uint8(_bytecodeHash[2])) * 256 + uint256(uint8(_bytecodeHash[3]));
        }
    }

    /// @notice Denotes whether bytecode hash corresponds to a contract that already constructed
    function isContractConstructed(bytes32 _bytecodeHash) internal pure returns (bool) {
        return _bytecodeHash[1] == 0x00;
    }

    /// @notice Denotes whether bytecode hash corresponds to a contract that is on constructor or has already been constructed
    function isContractConstructing(bytes32 _bytecodeHash) internal pure returns (bool) {
        return _bytecodeHash[1] == 0x01;
    }

    /// @notice Sets "isConstructor" flag to TRUE for the bytecode hash
    /// @param _bytecodeHash The bytecode hash for which it is needed to set the constructing flag
    /// @return The bytecode hash with "isConstructor" flag set to TRUE
    function constructingBytecodeHash(bytes32 _bytecodeHash) internal pure returns (bytes32) {
        // Clear the "isConstructor" marker and set it to 0x01.
        return constructedBytecodeHash(_bytecodeHash) | SET_IS_CONSTRUCTOR_MARKER_BIT_MASK;
    }

    /// @notice Sets "isConstructor" flag to FALSE for the bytecode hash
    /// @param _bytecodeHash The bytecode hash for which it is needed to set the constructing flag
    /// @return The bytecode hash with "isConstructor" flag set to FALSE
    function constructedBytecodeHash(bytes32 _bytecodeHash) internal pure returns (bytes32) {
        return _bytecodeHash & ~IS_CONSTRUCTOR_BYTECODE_HASH_BIT_MASK;
    }

    /// @notice Validate the bytecode format and calculate its hash.
    /// @param _bytecode The bytecode to hash.
    /// @return hashedBytecode The 32-byte hash of the bytecode.
    /// Note: The function reverts the execution if the bytecode has non expected format:
    /// - Bytecode bytes length is not a multiple of 32
    /// - Bytecode bytes length is not less than 2^21 bytes (2^16 words)
    /// - Bytecode words length is not odd
    function hashL2Bytecode(bytes calldata _bytecode) internal view returns (bytes32 hashedBytecode) {
        // Note that the length of the bytecode must be provided in 32-byte words.
        require(_bytecode.length % 32 == 0, "po");

        uint256 bytecodeLenInWords = _bytecode.length / 32;
        require(bytecodeLenInWords < 2 ** 16, "pp"); // bytecode length must be less than 2^16 words
        require(bytecodeLenInWords % 2 == 1, "pr"); // bytecode length in words must be odd
        hashedBytecode =
            EfficientCall.sha(_bytecode) &
            0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
        // Setting the version of the hash
        hashedBytecode = (hashedBytecode | bytes32(uint256(1 << 248)));
        // Setting the length
        hashedBytecode = hashedBytecode | bytes32(bytecodeLenInWords << 224);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../libraries/TransactionHelper.sol";

bytes4 constant ACCOUNT_VALIDATION_SUCCESS_MAGIC = IAccount.validateTransaction.selector;

interface IAccount {
    /// @notice Called by the bootloader to validate that an account agrees to process the transaction
    /// (and potentially pay for it).
    /// @param _txHash The hash of the transaction to be used in the explorer
    /// @param _suggestedSignedHash The hash of the transaction is signed by EOAs
    /// @param _transaction The transaction itself
    /// @return magic The magic value that should be equal to the signature of this function
    /// if the user agrees to proceed with the transaction.
    /// @dev The developer should strive to preserve as many steps as possible both for valid
    /// and invalid transactions as this very method is also used during the gas fee estimation
    /// (without some of the necessary data, e.g. signature).
    function validateTransaction(
        bytes32 _txHash,
        bytes32 _suggestedSignedHash,
        Transaction calldata _transaction
    ) external payable returns (bytes4 magic);

    function executeTransaction(
        bytes32 _txHash,
        bytes32 _suggestedSignedHash,
        Transaction calldata _transaction
    ) external payable;

    // There is no point in providing possible signed hash in the `executeTransactionFromOutside` method,
    // since it typically should not be trusted.
    function executeTransactionFromOutside(Transaction calldata _transaction) external payable;

    function payForTransaction(
        bytes32 _txHash,
        bytes32 _suggestedSignedHash,
        Transaction calldata _transaction
    ) external payable;

    function prepareForPaymaster(
        bytes32 _txHash,
        bytes32 _possibleSignedHash,
        Transaction calldata _transaction
    ) external payable;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

/// @title Module interface
/// @dev Interface for a module that can be added to SSO account (e.g. hook or validator).
interface IModule {
  /// @dev This function is called by the smart account during installation of the module
  /// @param data arbitrary data that may be required on the module during `onInstall` initialization
  function onInstall(bytes calldata data) external;

  /// @dev This function is called by the smart account during uninstallation of the module
  /// @param data arbitrary data that may be required on the module during `onUninstall` de-initialization
  function onUninstall(bytes calldata data) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

/**
 * @title Interface of the manager contract for hooks
 * @author https://getclave.io
 */
interface IHookManager {
  /**
   * @notice Event emitted when a hook is added
   * @param hook address - Address of the added hook
   */
  event HookAdded(address indexed hook);

  /**
   * @notice Event emitted when a hook is removed
   * @param hook address - Address of the removed hook
   */
  event HookRemoved(address indexed hook);

  /**
   * @notice Add a hook to the list of hooks and call its init function
   * @notice BEWARE: These global hooks can easily lock an account if a single hook always fails,
   * @notice  or if there are too many hooks to execute within the gas limit. USE WITH EXTREME CAUTION!
   * @dev Can only be called by self
   * @param hook - Address of the hook
   * @param isValidation bool          - True if the hook is a validation hook, false otherwise
   * @param initData bytes calldata    - Data to pass to the hook's `onInstall` function
   */
  function addHook(address hook, bool isValidation, bytes calldata initData) external;

  /**
   * @notice Remove a hook from the list of hooks
   * @dev Can only be called by self
   * @param hook address      - Address of the hook to remove
   * @param isValidation bool - True if the hook is a validation hook, false otherwise
   * @param deinitData bytes calldata - Data to pass to the hook's `onUninstall` function
   */
  function removeHook(address hook, bool isValidation, bytes calldata deinitData) external;

  /**
   * @notice Remove a hook from the list of hooks while ignoring reverts from its `onUninstall` teardown function
   * @dev Can only be called by self
   * @param hook address      - Address of the hook to remove
   * @param isValidation bool - True if the hook is a validation hook, false otherwise
   * @param deinitData bytes calldata - Data to pass to the hook's `onUninstall` function
   */
  function unlinkHook(address hook, bool isValidation, bytes calldata deinitData) external;

  /**
   * @notice Check if an address is in the list of hooks
   * @param addr address - Address to check
   * @return bool        - True if the address is a hook, false otherwise
   */
  function isHook(address addr) external view returns (bool);

  /**
   * @notice Get the list of validation or execution hooks
   * @param isValidation bool          - True if the list of validation hooks should be returned, false otherwise
   * @return hookList address[] memory - List of validation or execution hooks
   */
  function listHooks(bool isValidation) external view returns (address[] memory hookList);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { Transaction } from "@matterlabs/zksync-contracts/l2/system-contracts/libraries/TransactionHelper.sol";
import { IERC165 } from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import { IModule } from "./IModule.sol";

/// @title Validation hook interface for native AA
/// @author Initially getclave.io, updated by Matter Labs
/// @notice Validation hooks trigger before each transaction,
/// can be used to enforce additional restrictions on the account and/or transaction during the validation phase.
interface IValidationHook is IModule, IERC165 {
  /// @notice Hook that triggers before each transaction during the validation phase.
  /// @param signedHash Hash of the transaction that is being validated.
  /// @param transaction Transaction that is being validated.
  /// @dev If reverts, the transaction is rejected from the mempool and not included in the block.
  function validationHook(bytes32 signedHash, Transaction calldata transaction) external;
}

/// @title Execution hook interface for native AA
/// @author Initially getclave.io, updated by Matter Labs
/// @notice Execution hooks trigger before and after each transaction, during the execution phase.
interface IExecutionHook is IModule, IERC165 {
  /// @notice Hook that triggers before each transaction during the execution phase.
  /// @param transaction Transaction that is being executed.
  /// @return context Context that is passed to the postExecutionHook.
  function preExecutionHook(Transaction calldata transaction) external returns (bytes memory context);

  /// @notice Hook that triggers after each transaction during the execution phase.
  /// @param context Context that was returned by the preExecutionHook.
  function postExecutionHook(bytes calldata context) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { ERC165Checker } from "@openzeppelin/contracts/utils/introspection/ERC165Checker.sol";
import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { ExcessivelySafeCall } from "@nomad-xyz/excessively-safe-call/src/ExcessivelySafeCall.sol";

import { SelfAuth } from "../auth/SelfAuth.sol";
import { Errors } from "../libraries/Errors.sol";
import { SsoStorage } from "../libraries/SsoStorage.sol";
import { IValidatorManager } from "../interfaces/IValidatorManager.sol";
import { IModuleValidator } from "../interfaces/IModuleValidator.sol";
import { IModule } from "../interfaces/IModule.sol";

/**
 * @title Manager contract for validators
 * @notice Abstract contract for managing the validators of the account
 * @dev Validators are stored in an enumerable set
 * @author https://getclave.io
 */
abstract contract ValidatorManager is IValidatorManager, SelfAuth {
  using EnumerableSet for EnumerableSet.AddressSet;
  // Interface helper library
  using ERC165Checker for address;
  // Low level calls helper library
  using ExcessivelySafeCall for address;

  ///@inheritdoc IValidatorManager
  function addModuleValidator(address validator, bytes calldata initData) external onlySelf {
    _addModuleValidator(validator, initData);
  }

  ///@inheritdoc IValidatorManager
  function removeModuleValidator(address validator, bytes calldata deinitData) external onlySelf {
    _removeModuleValidator(validator);
    IModule(validator).onUninstall(deinitData);
  }

  ///@inheritdoc IValidatorManager
  function unlinkModuleValidator(address validator, bytes calldata deinitData) external onlySelf {
    _removeModuleValidator(validator);
    // Allow-listing slither finding as we don´t want reverting calls to prevent unlinking
    // slither-disable-next-line unused-return
    validator.excessivelySafeCall(gasleft(), 0, abi.encodeCall(IModule.onUninstall, (deinitData)));
  }

  /// @inheritdoc IValidatorManager
  function isModuleValidator(address validator) external view override returns (bool) {
    return _isModuleValidator(validator);
  }

  /// @inheritdoc IValidatorManager
  function listModuleValidators() external view override returns (address[] memory validatorList) {
    validatorList = SsoStorage.validators().values();
  }

  // Should not be set to private as it is called from SsoAccount's initialize
  function _addModuleValidator(address validator, bytes memory initData) internal {
    if (!_supportsModuleValidator(validator)) {
      revert Errors.VALIDATOR_ERC165_FAIL(validator);
    }

    // If the module is already installed, it cannot be installed again (even as another type).
    if (SsoStorage.validationHooks().contains(validator)) {
      revert Errors.HOOK_ALREADY_EXISTS(validator, true);
    }
    if (SsoStorage.executionHooks().contains(validator)) {
      revert Errors.HOOK_ALREADY_EXISTS(validator, false);
    }
    if (!SsoStorage.validators().add(validator)) {
      revert Errors.VALIDATOR_ALREADY_EXISTS(validator);
    }

    IModule(validator).onInstall(initData);

    emit ValidatorAdded(validator);
  }

  function _removeModuleValidator(address validator) private {
    if (!SsoStorage.validators().remove(validator)) {
      revert Errors.VALIDATOR_NOT_FOUND(validator);
    }

    emit ValidatorRemoved(validator);
  }

  function _isModuleValidator(address validator) internal view returns (bool) {
    return SsoStorage.validators().contains(validator);
  }

  function _supportsModuleValidator(address validator) private view returns (bool) {
    // Ah yes. Array literals are too hard for solidity to handle.
    bytes4[] memory interfaces = new bytes4[](2);
    interfaces[0] = type(IModuleValidator).interfaceId;
    interfaces[1] = type(IModule).interfaceId;
    return validator.supportsAllInterfaces(interfaces);
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { Errors } from "../libraries/Errors.sol";

/**
 * @title SelfAuth
 * @notice Abstract contract that allows only calls by the self contract
 * @author https://getclave.io
 */
abstract contract SelfAuth {
  modifier onlySelf() {
    if (msg.sender != address(this)) {
      revert Errors.NOT_FROM_SELF(msg.sender);
    }
    _;
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { SsoStorage } from "../libraries/SsoStorage.sol";
import { Errors } from "../libraries/Errors.sol";
import { SelfAuth } from "../auth/SelfAuth.sol";
import { IOwnerManager } from "../interfaces/IOwnerManager.sol";

/**
 * @title Manager contract for owners
 * @notice Abstract contract for managing the owners of the account
 * @dev K1 Owners are secp256k1 addresses
 * @dev Owners are stored in an enumerable set
 * @author https://getclave.io
 */
abstract contract OwnerManager is IOwnerManager, SelfAuth {
  using EnumerableSet for EnumerableSet.AddressSet;

  /// @inheritdoc IOwnerManager
  function addK1Owner(address addr) external override onlySelf {
    _addK1Owner(addr);
  }

  /// @inheritdoc IOwnerManager
  function removeK1Owner(address addr) external override onlySelf {
    _removeK1Owner(addr);
  }

  /// @inheritdoc IOwnerManager
  function isK1Owner(address addr) external view override returns (bool) {
    return _isK1Owner(addr);
  }

  /// @inheritdoc IOwnerManager
  function listK1Owners() external view override returns (address[] memory k1OwnerList) {
    k1OwnerList = _k1Owners().values();
  }

  // Should not be set to private as it is called from SsoAccount's initialize
  function _addK1Owner(address addr) internal {
    if (!_k1Owners().add(addr)) {
      revert Errors.OWNER_ALREADY_EXISTS(addr);
    }

    emit K1OwnerAdded(addr);
  }

  function _removeK1Owner(address addr) private {
    if (!_k1Owners().remove(addr)) {
      revert Errors.OWNER_NOT_FOUND(addr);
    }

    emit K1OwnerRemoved(addr);
  }

  function _isK1Owner(address addr) internal view returns (bool) {
    return _k1Owners().contains(addr);
  }

  function _k1Owners() private view returns (EnumerableSet.AddressSet storage k1Owners) {
    k1Owners = SsoStorage.layout().k1Owners;
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";

library SsoStorage {
  // @custom:storage-location erc7201:zksync-sso.contracts.SsoStorage
  bytes32 private constant SSO_STORAGE_SLOT = 0x76d91304710525fd07f6da5fffdfa69dbbabd80bc84f808f10d120a9bbff4600;

  struct Layout {
    // Ownership Data
    EnumerableSet.AddressSet k1Owners;
    // Validation
    EnumerableSet.AddressSet moduleValidators;
    // Hooks
    EnumerableSet.AddressSet validationHooks;
    EnumerableSet.AddressSet executionHooks;
    // Storage slots reserved for future upgrades
    uint256[256] __RESERVED;
  }

  function layout() internal pure returns (Layout storage l) {
    bytes32 slot = SSO_STORAGE_SLOT;
    assembly {
      l.slot := slot
    }
  }

  function validators() internal view returns (EnumerableSet.AddressSet storage) {
    return layout().moduleValidators;
  }

  function validationHooks() internal view returns (EnumerableSet.AddressSet storage) {
    return layout().validationHooks;
  }

  function executionHooks() internal view returns (EnumerableSet.AddressSet storage) {
    return layout().executionHooks;
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

/**
 * @title Manager contract for validators
 * @author https://getclave.io
 */
interface IValidatorManager {
  /**
   * @notice Event emitted when a modular validator is added
   * @param validator address - Address of the added modular validator
   */
  event ValidatorAdded(address indexed validator);

  /**
   * @notice Event emitted when a modular validator is removed
   * @param validator address - Address of the removed modular validator
   */
  event ValidatorRemoved(address indexed validator);

  /**
   * @notice Adds a validator to the list of modular validators
   * @dev Can only be called by self
   * @param validator address - Address of the generic validator to add
   * @param initData - Data to pass to the validator's `onInstall` function
   */
  function addModuleValidator(address validator, bytes memory initData) external;

  /**
   * @notice Removes a validator from the list of modular validators
   * @dev Can only be called by self
   * @param validator address - Address of the validator to remove
   * @param deinitData - Data to pass to the validator's `onUninstall` function
   */
  function removeModuleValidator(address validator, bytes calldata deinitData) external;

  /**
   * @notice Removes a validator from the list of modular validators while ignoring reverts from its `onUninstall` teardown function.
   * @dev Can only be called by self
   * @param validator address - Address of the validator to remove
   * @param deinitData - Data to pass to the validator's `onUninstall` function
   */
  function unlinkModuleValidator(address validator, bytes calldata deinitData) external;

  /**
   * @notice Checks if an address is in the modular validator list
   * @param validator address - Address of the validator to check
   * @return True if the address is a validator, false otherwise
   */
  function isModuleValidator(address validator) external view returns (bool);

  /**
   * @notice Returns the list of modular validators
   * @return validatorList address[] memory - Array of modular validator addresses
   */
  function listModuleValidators() external view returns (address[] memory validatorList);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

/**
 * @title Interface of the manager contract for owners
 * @author https://getclave.io
 */
interface IOwnerManager {
  /**
   * @notice Event emitted when a k1 owner is added
   * @param addr address - k1 owner that has been added
   */
  event K1OwnerAdded(address indexed addr);

  /**
   * @notice Event emitted when a k1 owner is removed
   * @param addr address - k1 owner that has been removed
   */
  event K1OwnerRemoved(address indexed addr);

  /**
   * @notice Adds a k1 owner to the list of k1 owners
   * @dev Can only be called by self
   * @dev Address can not be the zero address
   * @param addr address - Address to add to the list of k1 owners
   */
  function addK1Owner(address addr) external;

  /**
   * @notice Removes a k1 owner from the list of k1 owners
   * @dev Can only be called by self
   * @param addr address - Address to remove from the list of k1 owners
   */
  function removeK1Owner(address addr) external;

  /**
   * @notice Checks if an address is in the list of k1 owners
   * @param addr address - Address to check
   * @return bool - True if the address is in the list, false otherwise
   */
  function isK1Owner(address addr) external view returns (bool);

  /**
   * @notice Returns the list of k1 owners
   * @return k1OwnerList address[] memory - Array of k1 owner addresses
   */
  function listK1Owners() external view returns (address[] memory k1OwnerList);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./interfaces/IBootloaderUtilities.sol";
import "./libraries/TransactionHelper.sol";
import "./libraries/RLPEncoder.sol";
import "./libraries/EfficientCall.sol";

/**
 * @author Matter Labs
 * @notice A contract that provides some utility methods for the bootloader
 * that is very hard to write in Yul.
 */
contract BootloaderUtilities is IBootloaderUtilities {
    using TransactionHelper for *;

    /// @notice Calculates the canonical transaction hash and the recommended transaction hash.
    /// @param _transaction The transaction.
    /// @return txHash and signedTxHash of the transaction, i.e. the transaction hash to be used in the explorer and commits to all
    /// the fields of the transaction and the recommended hash to be signed for this transaction.
    /// @dev txHash must be unique for all transactions.
    function getTransactionHashes(
        Transaction calldata _transaction
    ) external view override returns (bytes32 txHash, bytes32 signedTxHash) {
        signedTxHash = _transaction.encodeHash();
        if (_transaction.txType == EIP_712_TX_TYPE) {
            txHash = keccak256(bytes.concat(signedTxHash, EfficientCall.keccak(_transaction.signature)));
        } else if (_transaction.txType == LEGACY_TX_TYPE) {
            txHash = encodeLegacyTransactionHash(_transaction);
        } else if (_transaction.txType == EIP_1559_TX_TYPE) {
            txHash = encodeEIP1559TransactionHash(_transaction);
        } else if (_transaction.txType == EIP_2930_TX_TYPE) {
            txHash = encodeEIP2930TransactionHash(_transaction);
        } else {
            revert("Unsupported tx type");
        }
    }

    /// @notice Calculates the hash for a legacy transaction.
    /// @param _transaction The legacy transaction.
    /// @return txHash The hash of the transaction.
    function encodeLegacyTransactionHash(Transaction calldata _transaction) internal view returns (bytes32 txHash) {
        // Hash of legacy transactions are encoded as one of the:
        // - RLP(nonce, gasPrice, gasLimit, to, value, data, chainId, 0, 0)
        // - RLP(nonce, gasPrice, gasLimit, to, value, data)
        //
        // In this RLP encoding, only the first one above list appears, so we encode each element
        // inside list and then concatenate the length of all elements with them.

        bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
        // Encode `gasPrice` and `gasLimit` together to prevent "stack too deep error".
        bytes memory encodedGasParam;
        {
            bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            encodedGasParam = bytes.concat(encodedGasPrice, encodedGasLimit);
        }

        bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
        bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        bytes memory rEncoded;
        {
            uint256 rInt = uint256(bytes32(_transaction.signature[0:32]));
            rEncoded = RLPEncoder.encodeUint256(rInt);
        }
        bytes memory sEncoded;
        {
            uint256 sInt = uint256(bytes32(_transaction.signature[32:64]));
            sEncoded = RLPEncoder.encodeUint256(sInt);
        }
        bytes memory vEncoded;
        {
            uint256 vInt = uint256(uint8(_transaction.signature[64]));
            require(vInt == 27 || vInt == 28, "Invalid v value");

            // If the `chainId` is specified in the transaction, then the `v` value is encoded as
            // `35 + y + 2 * chainId == vInt + 8 + 2 * chainId`, where y - parity bit (see EIP-155).
            if (_transaction.reserved[0] != 0) {
                vInt += 8 + block.chainid * 2;
            }

            vEncoded = RLPEncoder.encodeUint256(vInt);
        }

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedNonce.length +
                encodedGasParam.length +
                encodedTo.length +
                encodedValue.length +
                encodedDataLength.length +
                _transaction.data.length +
                rEncoded.length +
                sEncoded.length +
                vEncoded.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    encodedListLength,
                    encodedNonce,
                    encodedGasParam,
                    encodedTo,
                    encodedValue,
                    encodedDataLength,
                    _transaction.data,
                    vEncoded,
                    rEncoded,
                    sEncoded
                )
            );
    }

    /// @notice Calculates the hash for an EIP2930 transaction.
    /// @param _transaction The EIP2930 transaction.
    /// @return txHash The hash of the transaction.
    function encodeEIP2930TransactionHash(Transaction calldata _transaction) internal view returns (bytes32) {
        // Encode all fixed-length params to avoid "stack too deep error"
        bytes memory encodedFixedLengthParams;
        {
            bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
            bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
            bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
            bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
            encodedFixedLengthParams = bytes.concat(
                encodedChainId,
                encodedNonce,
                encodedGasPrice,
                encodedGasLimit,
                encodedTo,
                encodedValue
            );
        }

        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        // On zkSync, access lists are always zero length (at least for now).
        bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);

        bytes memory rEncoded;
        {
            uint256 rInt = uint256(bytes32(_transaction.signature[0:32]));
            rEncoded = RLPEncoder.encodeUint256(rInt);
        }
        bytes memory sEncoded;
        {
            uint256 sInt = uint256(bytes32(_transaction.signature[32:64]));
            sEncoded = RLPEncoder.encodeUint256(sInt);
        }
        bytes memory vEncoded;
        {
            uint256 vInt = uint256(uint8(_transaction.signature[64]));
            require(vInt == 27 || vInt == 28, "Invalid v value");

            vEncoded = RLPEncoder.encodeUint256(vInt - 27);
        }

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedFixedLengthParams.length +
                encodedDataLength.length +
                _transaction.data.length +
                encodedAccessListLength.length +
                rEncoded.length +
                sEncoded.length +
                vEncoded.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    "\x01",
                    encodedListLength,
                    encodedFixedLengthParams,
                    encodedDataLength,
                    _transaction.data,
                    encodedAccessListLength,
                    vEncoded,
                    rEncoded,
                    sEncoded
                )
            );
    }

    /// @notice Calculates the hash for an EIP1559 transaction.
    /// @param _transaction The legacy transaction.
    /// @return txHash The hash of the transaction.
    function encodeEIP1559TransactionHash(Transaction calldata _transaction) internal view returns (bytes32) {
        // The formula for hash of EIP1559 transaction in the original proposal:
        // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md

        // Encode all fixed-length params to avoid "stack too deep error"
        bytes memory encodedFixedLengthParams;
        {
            bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
            bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
            bytes memory encodedMaxPriorityFeePerGas = RLPEncoder.encodeUint256(_transaction.maxPriorityFeePerGas);
            bytes memory encodedMaxFeePerGas = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
            bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
            bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
            bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
            encodedFixedLengthParams = bytes.concat(
                encodedChainId,
                encodedNonce,
                encodedMaxPriorityFeePerGas,
                encodedMaxFeePerGas,
                encodedGasLimit,
                encodedTo,
                encodedValue
            );
        }

        // Encode only the length of the transaction data, and not the data itself,
        // so as not to copy to memory a potentially huge transaction data twice.
        bytes memory encodedDataLength;
        {
            // Safe cast, because the length of the transaction data can't be so large.
            uint64 txDataLen = uint64(_transaction.data.length);
            if (txDataLen != 1) {
                // If the length is not equal to one, then only using the length can it be encoded definitely.
                encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
            } else if (_transaction.data[0] >= 0x80) {
                // If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
                encodedDataLength = hex"81";
            }
            // Otherwise the length is not encoded at all.
        }

        // On zkSync, access lists are always zero length (at least for now).
        bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);

        bytes memory rEncoded;
        {
            uint256 rInt = uint256(bytes32(_transaction.signature[0:32]));
            rEncoded = RLPEncoder.encodeUint256(rInt);
        }
        bytes memory sEncoded;
        {
            uint256 sInt = uint256(bytes32(_transaction.signature[32:64]));
            sEncoded = RLPEncoder.encodeUint256(sInt);
        }
        bytes memory vEncoded;
        {
            uint256 vInt = uint256(uint8(_transaction.signature[64]));
            require(vInt == 27 || vInt == 28, "Invalid v value");

            vEncoded = RLPEncoder.encodeUint256(vInt - 27);
        }

        bytes memory encodedListLength;
        unchecked {
            uint256 listLength = encodedFixedLengthParams.length +
                encodedDataLength.length +
                _transaction.data.length +
                encodedAccessListLength.length +
                rEncoded.length +
                sEncoded.length +
                vEncoded.length;

            // Safe cast, because the length of the list can't be so large.
            encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
        }

        return
            keccak256(
                bytes.concat(
                    "\x02",
                    encodedListLength,
                    encodedFixedLengthParams,
                    encodedDataLength,
                    _transaction.data,
                    encodedAccessListLength,
                    vEncoded,
                    rEncoded,
                    sEncoded
                )
            );
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../libraries/TransactionHelper.sol";

interface IBootloaderUtilities {
    function getTransactionHashes(
        Transaction calldata _transaction
    ) external view returns (bytes32 txHash, bytes32 signedTxHash);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library RLPEncoder {
    function encodeAddress(address _val) internal pure returns (bytes memory encoded) {
        // The size is equal to 20 bytes of the address itself + 1 for encoding bytes length in RLP.
        encoded = new bytes(0x15);

        bytes20 shiftedVal = bytes20(_val);
        assembly {
            // In the first byte we write the encoded length as 0x80 + 0x14 == 0x94.
            mstore(add(encoded, 0x20), 0x9400000000000000000000000000000000000000000000000000000000000000)
            // Write address data without stripping zeros.
            mstore(add(encoded, 0x21), shiftedVal)
        }
    }

    function encodeUint256(uint256 _val) internal pure returns (bytes memory encoded) {
        unchecked {
            if (_val < 128) {
                encoded = new bytes(1);
                // Handle zero as a non-value, since stripping zeroes results in an empty byte array
                encoded[0] = (_val == 0) ? bytes1(uint8(128)) : bytes1(uint8(_val));
            } else {
                uint256 hbs = _highestByteSet(_val);

                encoded = new bytes(hbs + 2);
                encoded[0] = bytes1(uint8(hbs + 0x81));

                uint256 lbs = 31 - hbs;
                uint256 shiftedVal = _val << (lbs * 8);

                assembly {
                    mstore(add(encoded, 0x21), shiftedVal)
                }
            }
        }
    }

    /// @notice Encodes the size of bytes in RLP format.
    /// @param _len The length of the bytes to encode. It has a `uint64` type since as larger values are not supported.
    /// NOTE: panics if the length is 1 since the length encoding is ambiguous in this case.
    function encodeNonSingleBytesLen(uint64 _len) internal pure returns (bytes memory) {
        assert(_len != 1);
        return _encodeLength(_len, 0x80);
    }

    /// @notice Encodes the size of list items in RLP format.
    /// @param _len The length of the bytes to encode. It has a `uint64` type since as larger values are not supported.
    function encodeListLen(uint64 _len) internal pure returns (bytes memory) {
        return _encodeLength(_len, 0xc0);
    }

    function _encodeLength(uint64 _len, uint256 _offset) private pure returns (bytes memory encoded) {
        unchecked {
            if (_len < 56) {
                encoded = new bytes(1);
                encoded[0] = bytes1(uint8(_len + _offset));
            } else {
                uint256 hbs = _highestByteSet(uint256(_len));

                encoded = new bytes(hbs + 2);
                encoded[0] = bytes1(uint8(_offset + hbs + 56));

                uint256 lbs = 31 - hbs;
                uint256 shiftedVal = uint256(_len) << (lbs * 8);

                assembly {
                    mstore(add(encoded, 0x21), shiftedVal)
                }
            }
        }
    }

    /// @notice Computes the index of the highest byte set in number.
    /// @notice Uses little endian ordering (The least significant byte has index `0`).
    /// NOTE: returns `0` for `0`
    function _highestByteSet(uint256 _number) private pure returns (uint256 hbs) {
        unchecked {
            if (_number > type(uint128).max) {
                _number >>= 128;
                hbs += 16;
            }
            if (_number > type(uint64).max) {
                _number >>= 64;
                hbs += 8;
            }
            if (_number > type(uint32).max) {
                _number >>= 32;
                hbs += 4;
            }
            if (_number > type(uint16).max) {
                _number >>= 16;
                hbs += 2;
            }
            if (_number > type(uint8).max) {
                hbs += 1;
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IAccountCodeStorage {
    function storeAccountConstructingCodeHash(address _address, bytes32 _hash) external;

    function storeAccountConstructedCodeHash(address _address, bytes32 _hash) external;

    function markAccountCodeHashAsConstructed(address _address) external;

    function getRawCodeHash(address _address) external view returns (bytes32 codeHash);

    function getCodeHash(uint256 _input) external view returns (bytes32 codeHash);

    function getCodeSize(uint256 _input) external view returns (uint256 codeSize);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IContractDeployer {
    /// @notice Defines the version of the account abstraction protocol
    /// that a contract claims to follow.
    /// - `None` means that the account is just a contract and it should never be interacted
    /// with as a custom account
    /// - `Version1` means that the account follows the first version of the account abstraction protocol
    enum AccountAbstractionVersion {
        None,
        Version1
    }

    /// @notice Defines the nonce ordering used by the account
    /// - `Sequential` means that it is expected that the nonces are monotonic and increment by 1
    /// at a time (the same as EOAs).
    /// - `Arbitrary` means that the nonces for the accounts can be arbitrary. The operator
    /// should serve the transactions from such an account on a first-come-first-serve basis.
    /// @dev This ordering is more of a suggestion to the operator on how the AA expects its transactions
    /// to be processed and is not considered as a system invariant.
    enum AccountNonceOrdering {
        Sequential,
        Arbitrary
    }

    struct AccountInfo {
        AccountAbstractionVersion supportedAAVersion;
        AccountNonceOrdering nonceOrdering;
    }

    event ContractDeployed(
        address indexed deployerAddress,
        bytes32 indexed bytecodeHash,
        address indexed contractAddress
    );

    event AccountNonceOrderingUpdated(address indexed accountAddress, AccountNonceOrdering nonceOrdering);

    event AccountVersionUpdated(address indexed accountAddress, AccountAbstractionVersion aaVersion);

    function getNewAddressCreate2(
        address _sender,
        bytes32 _bytecodeHash,
        bytes32 _salt,
        bytes calldata _input
    ) external view returns (address newAddress);

    function getNewAddressCreate(address _sender, uint256 _senderNonce) external pure returns (address newAddress);

    function create2(
        bytes32 _salt,
        bytes32 _bytecodeHash,
        bytes calldata _input
    ) external payable returns (address newAddress);

    function create2Account(
        bytes32 _salt,
        bytes32 _bytecodeHash,
        bytes calldata _input,
        AccountAbstractionVersion _aaVersion
    ) external payable returns (address newAddress);

    /// @dev While the `_salt` parameter is not used anywhere here,
    /// it is still needed for consistency between `create` and
    /// `create2` functions (required by the compiler).
    function create(
        bytes32 _salt,
        bytes32 _bytecodeHash,
        bytes calldata _input
    ) external payable returns (address newAddress);

    /// @dev While `_salt` is never used here, we leave it here as a parameter
    /// for the consistency with the `create` function.
    function createAccount(
        bytes32 _salt,
        bytes32 _bytecodeHash,
        bytes calldata _input,
        AccountAbstractionVersion _aaVersion
    ) external payable returns (address newAddress);

    /// @notice Returns the information about a certain AA.
    function getAccountInfo(address _address) external view returns (AccountInfo memory info);

    /// @notice Can be called by an account to update its account version
    function updateAccountVersion(AccountAbstractionVersion _version) external;

    /// @notice Can be called by an account to update its nonce ordering
    function updateNonceOrdering(AccountNonceOrdering _nonceOrdering) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IKnownCodesStorage {
    event MarkedAsKnown(bytes32 indexed bytecodeHash, bool indexed sendBytecodeToL1);

    function markFactoryDeps(bool _shouldSendToL1, bytes32[] calldata _hashes) external;

    function markBytecodeAsPublished(
        bytes32 _bytecodeHash,
        bytes32 _l1PreimageHash,
        uint256 _l1PreimageBytesLen
    ) external;

    function getMarker(bytes32 _hash) external view returns (uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

struct ImmutableData {
    uint256 index;
    bytes32 value;
}

interface IImmutableSimulator {
    function getImmutable(address _dest, uint256 _index) external view returns (bytes32);

    function setImmutables(address _dest, ImmutableData[] calldata _immutables) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IEthToken {
    function balanceOf(uint256) external view returns (uint256);

    function transferFromTo(address _from, address _to, uint256 _amount) external;

    function totalSupply() external view returns (uint256);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function mint(address _account, uint256 _amount) external;

    function withdraw(address _l1Receiver) external payable;

    event Mint(address indexed account, uint256 amount);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Withdrawal(address indexed _l2Sender, address indexed _l1Receiver, uint256 _amount);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IL1Messenger {
    // Possibly in the future we will be able to track the messages sent to L1 with
    // some hooks in the VM. For now, it is much easier to track them with L2 events.
    event L1MessageSent(address indexed _sender, bytes32 indexed _hash, bytes _message);

    function sendToL1(bytes memory _message) external returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @author Matter Labs
 * @dev The interface that is used for encoding/decoding of
 * different types of paymaster flows.
 * @notice This is NOT an interface to be implementated
 * by contracts. It is just used for encoding.
 */
interface IPaymasterFlow {
    function general(bytes calldata input) external;

    function approvalBased(address _token, uint256 _minAllowance, bytes calldata _innerInput) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(
                oldAllowance >= value,
                "SafeERC20: decreased allowance below zero"
            );
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(
                token,
                abi.encodeWithSelector(
                    token.approve.selector,
                    spender,
                    newAllowance
                )
            );
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(
            nonceAfter == nonceBefore + 1,
            "SafeERC20: permit did not succeed"
        );
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        if (returndata.length > 0) {
            // Return data is optional
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.8;

import "./ECDSA.sol";
import "../ShortStrings.sol";
import "../../interfaces/IERC5267.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the `_domainSeparatorV4` function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 *
 * _Available since v3.4._
 *
 * @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
 */
abstract contract EIP712 is IERC5267 {
    using ShortStrings for *;

    bytes32 private constant _TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _cachedDomainSeparator;
    uint256 private immutable _cachedChainId;
    address private immutable _cachedThis;

    bytes32 private immutable _hashedName;
    bytes32 private immutable _hashedVersion;

    ShortString private immutable _name;
    ShortString private immutable _version;
    string private _nameFallback;
    string private _versionFallback;

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        _name = name.toShortStringWithFallback(_nameFallback);
        _version = version.toShortStringWithFallback(_versionFallback);
        _hashedName = keccak256(bytes(name));
        _hashedVersion = keccak256(bytes(version));

        _cachedChainId = block.chainid;
        _cachedDomainSeparator = _buildDomainSeparator();
        _cachedThis = address(this);
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
            return _cachedDomainSeparator;
        } else {
            return _buildDomainSeparator();
        }
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {EIP-5267}.
     *
     * _Available since v4.9._
     */
    function eip712Domain()
        public
        view
        virtual
        override
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        return (
            hex"0f", // 01111
            _name.toStringWithFallback(_nameFallback),
            _version.toStringWithFallback(_versionFallback),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 *
 * _Available since v4.1._
 */
interface IERC1271Upgradeable {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @author Matter Labs
 * @notice Contract that stores some of the context variables, that may be either
 * block-scoped, tx-scoped or system-wide.
 */
interface ISystemContext {
    function chainId() external view returns (uint256);

    function origin() external view returns (address);

    function gasPrice() external view returns (uint256);

    function blockGasLimit() external view returns (uint256);

    function coinbase() external view returns (address);

    function difficulty() external view returns (uint256);

    function baseFee() external view returns (uint256);

    function blockHash(uint256 _block) external view returns (bytes32);

    function getBlockHashEVM(uint256 _block) external view returns (bytes32);

    function getBlockNumberAndTimestamp() external view returns (uint256 blockNumber, uint256 blockTimestamp);

    // Note, that for now, the implementation of the bootloader allows this variables to
    // be incremented multiple times inside a block, so it should not relied upon right now.
    function getBlockNumber() external view returns (uint256);

    function getBlockTimestamp() external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.7.6;

library ExcessivelySafeCall {
    uint256 constant LOW_28_MASK =
        0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff;

    /// @notice Use when you _really_ really _really_ don't trust the called
    /// contract. This prevents the called contract from causing reversion of
    /// the caller in as many ways as we can.
    /// @dev The main difference between this and a solidity low-level call is
    /// that we limit the number of bytes that the callee can cause to be
    /// copied to caller memory. This prevents stupid things like malicious
    /// contracts returning 10,000,000 bytes causing a local OOG when copying
    /// to memory.
    /// @param _target The address to call
    /// @param _gas The amount of gas to forward to the remote contract
    /// @param _maxCopy The maximum number of bytes of returndata to copy
    /// to memory.
    /// @param _calldata The data to send to the remote contract
    /// @return success and returndata, as `.call()`. Returndata is capped to
    /// `_maxCopy` bytes.
    function excessivelySafeCall(
        address _target,
        uint256 _gas,
        uint16 _maxCopy,
        bytes memory _calldata
    ) internal returns (bool, bytes memory) {
        // set up for assembly call
        uint256 _toCopy;
        bool _success;
        bytes memory _returnData = new bytes(_maxCopy);
        // dispatch message to recipient
        // by assembly calling "handle" function
        // we call via assembly to avoid memcopying a very large returndata
        // returned by a malicious contract
        assembly {
            _success := call(
                _gas, // gas
                _target, // recipient
                0, // ether value
                add(_calldata, 0x20), // inloc
                mload(_calldata), // inlen
                0, // outloc
                0 // outlen
            )
            // limit our copy to 256 bytes
            _toCopy := returndatasize()
            if gt(_toCopy, _maxCopy) {
                _toCopy := _maxCopy
            }
            // Store the length of the copied bytes
            mstore(_returnData, _toCopy)
            // copy the bytes from returndata[0:_toCopy]
            returndatacopy(add(_returnData, 0x20), 0, _toCopy)
        }
        return (_success, _returnData);
    }

    /// @notice Use when you _really_ really _really_ don't trust the called
    /// contract. This prevents the called contract from causing reversion of
    /// the caller in as many ways as we can.
    /// @dev The main difference between this and a solidity low-level call is
    /// that we limit the number of bytes that the callee can cause to be
    /// copied to caller memory. This prevents stupid things like malicious
    /// contracts returning 10,000,000 bytes causing a local OOG when copying
    /// to memory.
    /// @param _target The address to call
    /// @param _gas The amount of gas to forward to the remote contract
    /// @param _maxCopy The maximum number of bytes of returndata to copy
    /// to memory.
    /// @param _calldata The data to send to the remote contract
    /// @return success and returndata, as `.call()`. Returndata is capped to
    /// `_maxCopy` bytes.
    function excessivelySafeStaticCall(
        address _target,
        uint256 _gas,
        uint16 _maxCopy,
        bytes memory _calldata
    ) internal view returns (bool, bytes memory) {
        // set up for assembly call
        uint256 _toCopy;
        bool _success;
        bytes memory _returnData = new bytes(_maxCopy);
        // dispatch message to recipient
        // by assembly calling "handle" function
        // we call via assembly to avoid memcopying a very large returndata
        // returned by a malicious contract
        assembly {
            _success := staticcall(
                _gas, // gas
                _target, // recipient
                add(_calldata, 0x20), // inloc
                mload(_calldata), // inlen
                0, // outloc
                0 // outlen
            )
            // limit our copy to 256 bytes
            _toCopy := returndatasize()
            if gt(_toCopy, _maxCopy) {
                _toCopy := _maxCopy
            }
            // Store the length of the copied bytes
            mstore(_returnData, _toCopy)
            // copy the bytes from returndata[0:_toCopy]
            returndatacopy(add(_returnData, 0x20), 0, _toCopy)
        }
        return (_success, _returnData);
    }

    /**
     * @notice Swaps function selectors in encoded contract calls
     * @dev Allows reuse of encoded calldata for functions with identical
     * argument types but different names. It simply swaps out the first 4 bytes
     * for the new selector. This function modifies memory in place, and should
     * only be used with caution.
     * @param _newSelector The new 4-byte selector
     * @param _buf The encoded contract args
     */
    function swapSelector(bytes4 _newSelector, bytes memory _buf)
        internal
        pure
    {
        require(_buf.length >= 4);
        uint256 _mask = LOW_28_MASK;
        assembly {
            // load the first word of
            let _word := mload(add(_buf, 0x20))
            // mask out the top 4 bytes
            // /x
            _word := and(_word, _mask)
            _word := or(_newSelector, _word)
            mstore(add(_buf, 0x20), _word)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/introspection/ERC165Checker.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Library used to query support of an interface declared via {IERC165}.
 *
 * Note that these functions return the actual result of the query: they do not
 * `revert` if an interface is not supported. It is up to the caller to decide
 * what to do in these cases.
 */
library ERC165Checker {
    // As per the EIP-165 spec, no interface should ever match 0xffffffff
    bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;

    /**
     * @dev Returns true if `account` supports the {IERC165} interface.
     */
    function supportsERC165(address account) internal view returns (bool) {
        // Any contract that implements ERC165 must explicitly indicate support of
        // InterfaceId_ERC165 and explicitly indicate non-support of InterfaceId_Invalid
        return
            supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) &&
            !supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID);
    }

    /**
     * @dev Returns true if `account` supports the interface defined by
     * `interfaceId`. Support for {IERC165} itself is queried automatically.
     *
     * See {IERC165-supportsInterface}.
     */
    function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
        // query support of both ERC165 as per the spec and support of _interfaceId
        return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId);
    }

    /**
     * @dev Returns a boolean array where each value corresponds to the
     * interfaces passed in and whether they're supported or not. This allows
     * you to batch check interfaces for a contract where your expectation
     * is that some interfaces may not be supported.
     *
     * See {IERC165-supportsInterface}.
     *
     * _Available since v3.4._
     */
    function getSupportedInterfaces(
        address account,
        bytes4[] memory interfaceIds
    ) internal view returns (bool[] memory) {
        // an array of booleans corresponding to interfaceIds and whether they're supported or not
        bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);

        // query support of ERC165 itself
        if (supportsERC165(account)) {
            // query support of each interface in interfaceIds
            for (uint256 i = 0; i < interfaceIds.length; i++) {
                interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]);
            }
        }

        return interfaceIdsSupported;
    }

    /**
     * @dev Returns true if `account` supports all the interfaces defined in
     * `interfaceIds`. Support for {IERC165} itself is queried automatically.
     *
     * Batch-querying can lead to gas savings by skipping repeated checks for
     * {IERC165} support.
     *
     * See {IERC165-supportsInterface}.
     */
    function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
        // query support of ERC165 itself
        if (!supportsERC165(account)) {
            return false;
        }

        // query support of each interface in interfaceIds
        for (uint256 i = 0; i < interfaceIds.length; i++) {
            if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) {
                return false;
            }
        }

        // all interfaces supported
        return true;
    }

    /**
     * @notice Query if a contract implements an interface, does not check ERC165 support
     * @param account The address of the contract to query for support of an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @return true if the contract at account indicates support of the interface with
     * identifier interfaceId, false otherwise
     * @dev Assumes that account contains a contract that supports ERC165, otherwise
     * the behavior of this method is undefined. This precondition can be checked
     * with {supportsERC165}.
     *
     * Some precompiled contracts will falsely indicate support for a given interface, so caution
     * should be exercised when using this function.
     *
     * Interface identification is specified in ERC-165.
     */
    function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) {
        // prepare call
        bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId);

        // perform static call
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly {
            success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0x00)
        }

        return success && returnSize >= 0x20 && returnValue > 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface IBytecodeCompressor {
    function publishCompressedBytecode(
        bytes calldata _bytecode,
        bytes calldata _rawCompressedData
    ) external payable returns (bytes32 bytecodeHash);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8;

import {MAX_SYSTEM_CONTRACT_ADDRESS, MSG_VALUE_SYSTEM_CONTRACT} from "../Constants.sol";

import "./SystemContractsCaller.sol";
import "./Utils.sol";

uint256 constant UINT32_MASK = 0xffffffff;
uint256 constant UINT128_MASK = 0xffffffffffffffffffffffffffffffff;
/// @dev The mask that is used to convert any uint256 to a proper address.
/// It needs to be padded with `00` to be treated as uint256 by Solidity
uint256 constant ADDRESS_MASK = 0x00ffffffffffffffffffffffffffffffffffffffff;

struct ZkSyncMeta {
    uint32 gasPerPubdataByte;
    uint32 heapSize;
    uint32 auxHeapSize;
    uint8 shardId;
    uint8 callerShardId;
    uint8 codeShardId;
}

enum Global {
    CalldataPtr,
    CallFlags,
    ExtraABIData1,
    ExtraABIData2,
    ReturndataPtr
}

/**
 * @author Matter Labs
 * @notice Library used for accessing zkEVM-specific opcodes, needed for the development
 * of system contracts.
 * @dev While this library will be eventually available to public, some of the provided
 * methods won't work for non-system contracts. We will not recommend this library
 * for external use.
 */
library SystemContractHelper {
    /// @notice Send an L2Log to L1.
    /// @param _isService The `isService` flag.
    /// @param _key The `key` part of the L2Log.
    /// @param _value The `value` part of the L2Log.
    /// @dev The meaning of all these parameters is context-dependent, but they
    /// have no intrinsic meaning per se.
    function toL1(bool _isService, bytes32 _key, bytes32 _value) internal {
        address callAddr = TO_L1_CALL_ADDRESS;
        assembly {
            // Ensuring that the type is bool
            _isService := and(_isService, 1)
            // This `success` is always 0, but the method always succeeds
            // (except for the cases when there is not enough gas)
            let success := call(_isService, callAddr, _key, _value, 0xFFFF, 0, 0)
        }
    }

    /// @notice Get address of the currently executed code.
    /// @dev This allows differentiating between `call` and `delegatecall`.
    /// During the former `this` and `codeAddress` are the same, while
    /// during the latter they are not.
    function getCodeAddress() internal view returns (address addr) {
        address callAddr = CODE_ADDRESS_CALL_ADDRESS;
        assembly {
            addr := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Provide a compiler hint, by placing calldata fat pointer into virtual `ACTIVE_PTR`,
    /// that can be manipulated by `ptr.add`/`ptr.sub`/`ptr.pack`/`ptr.shrink` later.
    /// @dev This allows making a call by forwarding calldata pointer to the child call.
    /// It is a much more efficient way to forward calldata, than standard EVM bytes copying.
    function loadCalldataIntoActivePtr() internal view {
        address callAddr = LOAD_CALLDATA_INTO_ACTIVE_PTR_CALL_ADDRESS;
        assembly {
            pop(staticcall(0, callAddr, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice Compiler simulation of the `ptr.pack` opcode for the virtual `ACTIVE_PTR` pointer.
    /// @dev Do the concatenation between lowest part of `ACTIVE_PTR` and highest part of `_farCallAbi`
    /// forming packed fat pointer for a far call or ret ABI when necessary.
    /// Note: Panics if the lowest 128 bits of `_farCallAbi` are not zeroes.
    function ptrPackIntoActivePtr(uint256 _farCallAbi) internal view {
        address callAddr = PTR_PACK_INTO_ACTIVE_CALL_ADDRESS;
        assembly {
            pop(staticcall(_farCallAbi, callAddr, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice Compiler simulation of the `ptr.add` opcode for the virtual `ACTIVE_PTR` pointer.
    /// @dev Transforms `ACTIVE_PTR.offset` into `ACTIVE_PTR.offset + u32(_value)`. If overflow happens then it panics.
    function ptrAddIntoActive(uint32 _value) internal view {
        address callAddr = PTR_ADD_INTO_ACTIVE_CALL_ADDRESS;
        uint256 cleanupMask = UINT32_MASK;
        assembly {
            // Clearing input params as they are not cleaned by Solidity by default
            _value := and(_value, cleanupMask)
            pop(staticcall(_value, callAddr, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice Compiler simulation of the `ptr.shrink` opcode for the virtual `ACTIVE_PTR` pointer.
    /// @dev Transforms `ACTIVE_PTR.length` into `ACTIVE_PTR.length - u32(_shrink)`. If underflow happens then it panics.
    function ptrShrinkIntoActive(uint32 _shrink) internal view {
        address callAddr = PTR_SHRINK_INTO_ACTIVE_CALL_ADDRESS;
        uint256 cleanupMask = UINT32_MASK;
        assembly {
            // Clearing input params as they are not cleaned by Solidity by default
            _shrink := and(_shrink, cleanupMask)
            pop(staticcall(_shrink, callAddr, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice packs precompile parameters into one word
    /// @param _inputMemoryOffset The memory offset in 32-byte words for the input data for calling the precompile.
    /// @param _inputMemoryLength The length of the input data in words.
    /// @param _outputMemoryOffset The memory offset in 32-byte words for the output data.
    /// @param _outputMemoryLength The length of the output data in words.
    /// @param _perPrecompileInterpreted The constant, the meaning of which is defined separately for
    /// each precompile. For information, please read the documentation of the precompilecall log in
    /// the VM.
    function packPrecompileParams(
        uint32 _inputMemoryOffset,
        uint32 _inputMemoryLength,
        uint32 _outputMemoryOffset,
        uint32 _outputMemoryLength,
        uint64 _perPrecompileInterpreted
    ) internal pure returns (uint256 rawParams) {
        rawParams = _inputMemoryOffset;
        rawParams |= uint256(_inputMemoryLength) << 32;
        rawParams |= uint256(_outputMemoryOffset) << 64;
        rawParams |= uint256(_outputMemoryLength) << 96;
        rawParams |= uint256(_perPrecompileInterpreted) << 192;
    }

    /// @notice Call precompile with given parameters.
    /// @param _rawParams The packed precompile params. They can be retrieved by
    /// the `packPrecompileParams` method.
    /// @param _gasToBurn The number of gas to burn during this call.
    /// @return success Whether the call was successful.
    /// @dev The list of currently available precompiles sha256, keccak256, ecrecover.
    /// NOTE: The precompile type depends on `this` which calls precompile, which means that only
    /// system contracts corresponding to the list of precompiles above can do `precompileCall`.
    /// @dev If used not in the `sha256`, `keccak256` or `ecrecover` contracts, it will just burn the gas provided.
    function precompileCall(uint256 _rawParams, uint32 _gasToBurn) internal view returns (bool success) {
        address callAddr = PRECOMPILE_CALL_ADDRESS;

        // After `precompileCall` gas will be burned down to 0 if there are not enough of them,
        // thats why it should be checked before the call.
        require(gasleft() >= _gasToBurn);
        uint256 cleanupMask = UINT32_MASK;
        assembly {
            // Clearing input params as they are not cleaned by Solidity by default
            _gasToBurn := and(_gasToBurn, cleanupMask)
            success := staticcall(_rawParams, callAddr, _gasToBurn, 0xFFFF, 0, 0)
        }
    }

    /// @notice Set `msg.value` to next far call.
    /// @param _value The msg.value that will be used for the *next* call.
    /// @dev If called not in kernel mode, it will result in a revert (enforced by the VM)
    function setValueForNextFarCall(uint128 _value) internal returns (bool success) {
        uint256 cleanupMask = UINT128_MASK;
        address callAddr = SET_CONTEXT_VALUE_CALL_ADDRESS;
        assembly {
            // Clearing input params as they are not cleaned by Solidity by default
            _value := and(_value, cleanupMask)
            success := call(0, callAddr, _value, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Initialize a new event.
    /// @param initializer The event initializing value.
    /// @param value1 The first topic or data chunk.
    function eventInitialize(uint256 initializer, uint256 value1) internal {
        address callAddr = EVENT_INITIALIZE_ADDRESS;
        assembly {
            pop(call(initializer, callAddr, value1, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice Continue writing the previously initialized event.
    /// @param value1 The first topic or data chunk.
    /// @param value2 The second topic or data chunk.
    function eventWrite(uint256 value1, uint256 value2) internal {
        address callAddr = EVENT_WRITE_ADDRESS;
        assembly {
            pop(call(value1, callAddr, value2, 0, 0xFFFF, 0, 0))
        }
    }

    /// @notice Get the packed representation of the `ZkSyncMeta` from the current context.
    /// @return meta The packed representation of the ZkSyncMeta.
    /// @dev The fields in ZkSyncMeta are NOT tightly packed, i.e. there is a special rule on how
    /// they are packed. For more information, please read the documentation on ZkSyncMeta.
    function getZkSyncMetaBytes() internal view returns (uint256 meta) {
        address callAddr = META_CALL_ADDRESS;
        assembly {
            meta := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Returns the bits [offset..offset+size-1] of the meta.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @param offset The offset of the bits.
    /// @param size The size of the extracted number in bits.
    /// @return result The extracted number.
    function extractNumberFromMeta(uint256 meta, uint256 offset, uint256 size) internal pure returns (uint256 result) {
        // Firstly, we delete all the bits after the field
        uint256 shifted = (meta << (256 - size - offset));
        // Then we shift everything back
        result = (shifted >> (256 - size));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the number of gas
    /// that a single byte sent to L1 as pubdata costs.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return gasPerPubdataByte The current price in gas per pubdata byte.
    function getGasPerPubdataByteFromMeta(uint256 meta) internal pure returns (uint32 gasPerPubdataByte) {
        gasPerPubdataByte = uint32(extractNumberFromMeta(meta, META_GAS_PER_PUBDATA_BYTE_OFFSET, 32));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the number of the current size
    /// of the heap in bytes.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return heapSize The size of the memory in bytes byte.
    /// @dev The following expression: getHeapSizeFromMeta(getZkSyncMetaBytes()) is
    /// equivalent to the MSIZE in Solidity.
    function getHeapSizeFromMeta(uint256 meta) internal pure returns (uint32 heapSize) {
        heapSize = uint32(extractNumberFromMeta(meta, META_HEAP_SIZE_OFFSET, 32));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the number of the current size
    /// of the auxilary heap in bytes.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return auxHeapSize The size of the auxilary memory in bytes byte.
    /// @dev You can read more on auxilary memory in the VM1.2 documentation.
    function getAuxHeapSizeFromMeta(uint256 meta) internal pure returns (uint32 auxHeapSize) {
        auxHeapSize = uint32(extractNumberFromMeta(meta, META_AUX_HEAP_SIZE_OFFSET, 32));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the shardId of `this`.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return shardId The shardId of `this`.
    /// @dev Currently only shard 0 (zkRollup) is supported.
    function getShardIdFromMeta(uint256 meta) internal pure returns (uint8 shardId) {
        shardId = uint8(extractNumberFromMeta(meta, META_SHARD_ID_OFFSET, 8));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the shardId of
    /// the msg.sender.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return callerShardId The shardId of the msg.sender.
    /// @dev Currently only shard 0 (zkRollup) is supported.
    function getCallerShardIdFromMeta(uint256 meta) internal pure returns (uint8 callerShardId) {
        callerShardId = uint8(extractNumberFromMeta(meta, META_CALLER_SHARD_ID_OFFSET, 8));
    }

    /// @notice Given the packed representation of `ZkSyncMeta`, retrieves the shardId of
    /// the currently executed code.
    /// @param meta Packed representation of the ZkSyncMeta.
    /// @return codeShardId The shardId of the currently executed code.
    /// @dev Currently only shard 0 (zkRollup) is supported.
    function getCodeShardIdFromMeta(uint256 meta) internal pure returns (uint8 codeShardId) {
        codeShardId = uint8(extractNumberFromMeta(meta, META_CODE_SHARD_ID_OFFSET, 8));
    }

    /// @notice Retrieves the ZkSyncMeta structure.
    /// @return meta The ZkSyncMeta execution context parameters.
    function getZkSyncMeta() internal view returns (ZkSyncMeta memory meta) {
        uint256 metaPacked = getZkSyncMetaBytes();
        meta.gasPerPubdataByte = getGasPerPubdataByteFromMeta(metaPacked);
        meta.shardId = getShardIdFromMeta(metaPacked);
        meta.callerShardId = getCallerShardIdFromMeta(metaPacked);
        meta.codeShardId = getCodeShardIdFromMeta(metaPacked);
    }

    /// @notice Returns the call flags for the current call.
    /// @return callFlags The bitmask of the callflags.
    /// @dev Call flags is the value of the first register
    /// at the start of the call.
    /// @dev The zero bit of the callFlags indicates whether the call is
    /// a constructor call. The first bit of the callFlags indicates whether
    /// the call is a system one.
    function getCallFlags() internal view returns (uint256 callFlags) {
        address callAddr = CALLFLAGS_CALL_ADDRESS;
        assembly {
            callFlags := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Returns the current calldata pointer.
    /// @return ptr The current calldata pointer.
    /// @dev NOTE: This file is just an integer and it can not be used
    /// to forward the calldata to the next calls in any way.
    function getCalldataPtr() internal view returns (uint256 ptr) {
        address callAddr = PTR_CALLDATA_CALL_ADDRESS;
        assembly {
            ptr := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Returns the N-th extraAbiParam for the current call.
    /// @return extraAbiData The value of the N-th extraAbiParam for this call.
    /// @dev It is equal to the value of the (N+2)-th register
    /// at the start of the call.
    function getExtraAbiData(uint256 index) internal view returns (uint256 extraAbiData) {
        require(index < 10, "There are only 10 accessible registers");

        address callAddr = GET_EXTRA_ABI_DATA_ADDRESS;
        assembly {
            extraAbiData := staticcall(index, callAddr, 0, 0xFFFF, 0, 0)
        }
    }

    /// @notice Retuns whether the current call is a system call.
    /// @return `true` or `false` based on whether the current call is a system call.
    function isSystemCall() internal view returns (bool) {
        uint256 callFlags = getCallFlags();
        // When the system call is passed, the 2-bit it set to 1
        return (callFlags & 2) != 0;
    }

    /// @notice Returns whether the address is a system contract.
    /// @param _address The address to test
    /// @return `true` or `false` based on whether the `_address` is a system contract.
    function isSystemContract(address _address) internal pure returns (bool) {
        return uint160(_address) <= uint160(MAX_SYSTEM_CONTRACT_ADDRESS);
    }
}

/// @dev Solidity does not allow exporting modifiers via libraries, so
/// the only way to do reuse modifiers is to have a base contract
abstract contract ISystemContract {
    /// @notice Modifier that makes sure that the method
    /// can only be called via a system call.
    modifier onlySystemCall() {
        require(
            SystemContractHelper.isSystemCall() || SystemContractHelper.isSystemContract(msg.sender),
            "This method require system call flag"
        );
        _;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(
            address(this).balance >= amount,
            "Address: insufficient balance"
        );

        (bool success, ) = recipient.call{value: amount}("");
        require(
            success,
            "Address: unable to send value, recipient may have reverted"
        );
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return
            functionCallWithValue(
                target,
                data,
                0,
                "Address: low-level call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                "Address: low-level call with value failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            "Address: insufficient balance for call"
        );
        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data)
        internal
        view
        returns (bytes memory)
    {
        return
            functionStaticCall(
                target,
                data,
                "Address: low-level static call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return
            functionDelegateCall(
                target,
                data,
                "Address: low-level delegate call failed"
            );
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage)
        private
        pure
    {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC5267.sol)

pragma solidity ^0.8.0;

interface IERC5267 {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/ShortStrings.sol)

pragma solidity ^0.8.8;

import "./StorageSlot.sol";

// | string  | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA   |
// | length  | 0x                                                              BB |
type ShortString is bytes32;

/**
 * @dev This library provides functions to convert short memory strings
 * into a `ShortString` type that can be used as an immutable variable.
 *
 * Strings of arbitrary length can be optimized using this library if
 * they are short enough (up to 31 bytes) by packing them with their
 * length (1 byte) in a single EVM word (32 bytes). Additionally, a
 * fallback mechanism can be used for every other case.
 *
 * Usage example:
 *
 * ```solidity
 * contract Named {
 *     using ShortStrings for *;
 *
 *     ShortString private immutable _name;
 *     string private _nameFallback;
 *
 *     constructor(string memory contractName) {
 *         _name = contractName.toShortStringWithFallback(_nameFallback);
 *     }
 *
 *     function name() external view returns (string memory) {
 *         return _name.toStringWithFallback(_nameFallback);
 *     }
 * }
 * ```
 */
library ShortStrings {
    // Used as an identifier for strings longer than 31 bytes.
    bytes32 private constant _FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;

    error StringTooLong(string str);
    error InvalidShortString();

    /**
     * @dev Encode a string of at most 31 chars into a `ShortString`.
     *
     * This will trigger a `StringTooLong` error is the input string is too long.
     */
    function toShortString(string memory str) internal pure returns (ShortString) {
        bytes memory bstr = bytes(str);
        if (bstr.length > 31) {
            revert StringTooLong(str);
        }
        return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
    }

    /**
     * @dev Decode a `ShortString` back to a "normal" string.
     */
    function toString(ShortString sstr) internal pure returns (string memory) {
        uint256 len = byteLength(sstr);
        // using `new string(len)` would work locally but is not memory safe.
        string memory str = new string(32);
        /// @solidity memory-safe-assembly
        assembly {
            mstore(str, len)
            mstore(add(str, 0x20), sstr)
        }
        return str;
    }

    /**
     * @dev Return the length of a `ShortString`.
     */
    function byteLength(ShortString sstr) internal pure returns (uint256) {
        uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
        if (result > 31) {
            revert InvalidShortString();
        }
        return result;
    }

    /**
     * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.
     */
    function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
        if (bytes(value).length < 32) {
            return toShortString(value);
        } else {
            StorageSlot.getStringSlot(store).value = value;
            return ShortString.wrap(_FALLBACK_SENTINEL);
        }
    }

    /**
     * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
     */
    function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
        if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
            return toString(value);
        } else {
            return store;
        }
    }

    /**
     * @dev Return the length of a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
     *
     * WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of
     * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.
     */
    function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
        if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
            return byteLength(value);
        } else {
            return bytes(store).length;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

{
  "evmVersion": "cancun",
  "codegen": "yul",
  "optimizer": {
    "enabled": true,
    "mode": "3"
  },
  "outputSelection": {
    "*": {
      "*": [
        "abi"
      ]
    }
  },
  "detectMissingLibraries": false,
  "forceEVMLA": false,
  "enableEraVMExtensions": true,
  "libraries": {}
}

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"ADDRESS_CAST_OVERFLOW","type":"error"},{"inputs":[{"internalType":"uint256","name":"actualValue","type":"uint256"},{"internalType":"uint256","name":"expectedValue","type":"uint256"}],"name":"BATCH_MSG_VALUE_MISMATCH","type":"error"},{"inputs":[],"name":"FEE_PAYMENT_FAILED","type":"error"},{"inputs":[{"internalType":"address","name":"hook","type":"address"},{"internalType":"bool","name":"isValidation","type":"bool"}],"name":"HOOK_ALREADY_EXISTS","type":"error"},{"inputs":[{"internalType":"address","name":"hookAddress","type":"address"},{"internalType":"bool","name":"isValidation","type":"bool"}],"name":"HOOK_ERC165_FAIL","type":"error"},{"inputs":[{"internalType":"address","name":"hook","type":"address"},{"internalType":"bool","name":"isValidation","type":"bool"}],"name":"HOOK_NOT_FOUND","type":"error"},{"inputs":[{"internalType":"uint256","name":"required","type":"uint256"},{"internalType":"uint256","name":"available","type":"uint256"}],"name":"INSUFFICIENT_FUNDS","type":"error"},{"inputs":[],"name":"INVALID_ACCOUNT_KEYS","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[],"name":"METHOD_NOT_IMPLEMENTED","type":"error"},{"inputs":[{"internalType":"address","name":"notBootloader","type":"address"}],"name":"NOT_FROM_BOOTLOADER","type":"error"},{"inputs":[{"internalType":"address","name":"notSelf","type":"address"}],"name":"NOT_FROM_SELF","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OWNER_ALREADY_EXISTS","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OWNER_NOT_FOUND","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"VALIDATOR_ALREADY_EXISTS","type":"error"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"VALIDATOR_ERC165_FAIL","type":"error"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"VALIDATOR_NOT_FOUND","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"revertData","type":"bytes"}],"name":"BatchCallFailure","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"hook","type":"address"}],"name":"HookAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"hook","type":"address"}],"name":"HookRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"K1OwnerAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"addr","type":"address"}],"name":"K1OwnerRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"validator","type":"address"}],"name":"ValidatorAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"validator","type":"address"}],"name":"ValidatorRemoved","type":"event"},{"inputs":[{"internalType":"address","name":"hook","type":"address"},{"internalType":"bool","name":"isValidation","type":"bool"},{"internalType":"bytes","name":"initData","type":"bytes"}],"name":"addHook","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"addK1Owner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"},{"internalType":"bytes","name":"initData","type":"bytes"}],"name":"addModuleValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"allowFailure","type":"bool"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Call[]","name":"_calls","type":"tuple[]"}],"name":"batchCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"},{"components":[{"internalType":"uint256","name":"txType","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPerPubdataByteLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"},{"internalType":"uint256","name":"paymaster","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256[4]","name":"reserved","type":"uint256[4]"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32[]","name":"factoryDeps","type":"bytes32[]"},{"internalType":"bytes","name":"paymasterInput","type":"bytes"},{"internalType":"bytes","name":"reservedDynamic","type":"bytes"}],"internalType":"struct Transaction","name":"_transaction","type":"tuple"}],"name":"executeTransaction","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"txType","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPerPubdataByteLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"},{"internalType":"uint256","name":"paymaster","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256[4]","name":"reserved","type":"uint256[4]"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32[]","name":"factoryDeps","type":"bytes32[]"},{"internalType":"bytes","name":"paymasterInput","type":"bytes"},{"internalType":"bytes","name":"reservedDynamic","type":"bytes"}],"internalType":"struct Transaction","name":"","type":"tuple"}],"name":"executeTransactionFromOutside","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"signedHash","type":"bytes32"}],"internalType":"struct ERC1271Handler.SsoMessage","name":"ssoMessage","type":"tuple"}],"name":"getEip712Hash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"initialValidators","type":"bytes[]"},{"internalType":"address[]","name":"initialK1Owners","type":"address[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isHook","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"isK1Owner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"}],"name":"isModuleValidator","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"hash","type":"bytes32"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"isValidSignature","outputs":[{"internalType":"bytes4","name":"magicValue","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"isValidation","type":"bool"}],"name":"listHooks","outputs":[{"internalType":"address[]","name":"hookList","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"listK1Owners","outputs":[{"internalType":"address[]","name":"k1OwnerList","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"listModuleValidators","outputs":[{"internalType":"address[]","name":"validatorList","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"},{"components":[{"internalType":"uint256","name":"txType","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPerPubdataByteLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"},{"internalType":"uint256","name":"paymaster","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256[4]","name":"reserved","type":"uint256[4]"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32[]","name":"factoryDeps","type":"bytes32[]"},{"internalType":"bytes","name":"paymasterInput","type":"bytes"},{"internalType":"bytes","name":"reservedDynamic","type":"bytes"}],"internalType":"struct Transaction","name":"_transaction","type":"tuple"}],"name":"payForTransaction","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"},{"components":[{"internalType":"uint256","name":"txType","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPerPubdataByteLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"},{"internalType":"uint256","name":"paymaster","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256[4]","name":"reserved","type":"uint256[4]"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32[]","name":"factoryDeps","type":"bytes32[]"},{"internalType":"bytes","name":"paymasterInput","type":"bytes"},{"internalType":"bytes","name":"reservedDynamic","type":"bytes"}],"internalType":"struct Transaction","name":"_transaction","type":"tuple"}],"name":"prepareForPaymaster","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"hook","type":"address"},{"internalType":"bool","name":"isValidation","type":"bool"},{"internalType":"bytes","name":"deinitData","type":"bytes"}],"name":"removeHook","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"removeK1Owner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"},{"internalType":"bytes","name":"deinitData","type":"bytes"}],"name":"removeModuleValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ssoMessageTypeHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"hook","type":"address"},{"internalType":"bool","name":"isValidation","type":"bool"},{"internalType":"bytes","name":"deinitData","type":"bytes"}],"name":"unlinkHook","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"validator","type":"address"},{"internalType":"bytes","name":"deinitData","type":"bytes"}],"name":"unlinkModuleValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"_suggestedSignedHash","type":"bytes32"},{"components":[{"internalType":"uint256","name":"txType","type":"uint256"},{"internalType":"uint256","name":"from","type":"uint256"},{"internalType":"uint256","name":"to","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"gasPerPubdataByteLimit","type":"uint256"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"},{"internalType":"uint256","name":"paymaster","type":"uint256"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256[4]","name":"reserved","type":"uint256[4]"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32[]","name":"factoryDeps","type":"bytes32[]"},{"internalType":"bytes","name":"paymasterInput","type":"bytes"},{"internalType":"bytes","name":"reservedDynamic","type":"bytes"}],"internalType":"struct Transaction","name":"_transaction","type":"tuple"}],"name":"validateTransaction","outputs":[{"internalType":"bytes4","name":"magic","type":"bytes4"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

3cda3351cdf1a1ba65694ff86240327ca8ccc847d6a9c376c73e8c6f802f2015b1b1aea601000dbf0b94c5c891b6d1c7db8dc21392f4f93f82c2b9cd01e2eaa0cd452a8600000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000

0x0014000000000002001c000000000002000000600310027000000ce70030019d00000ce703300197001300000031035500020000003103550003000000310355000400000031035500050000003103550006000000310355000700000031035500080000003103550009000000310355000a000000310355000b000000310355000c000000310355000d000000310355000e000000310355000f0000003103550010000000310355001100000031035500120000000103550000000100200190000000590000c13d0000008004000039000000400040043f000000040030008c000000ae0000413d000000000201043b000000e00220027000000cfa0020009c000000b20000a13d00000cfb0020009c000001210000a13d00000cfc0020009c0000014e0000213d00000d020020009c000002720000213d00000d050020009c000005630000613d00000d060020009c000006010000c13d000000240030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000401100370000000000101043b001900000001001d00000d230010009c000006010000213d0000001901000029000000000010043f00000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b000006cd0000c13d0000001901000029000000000010043f00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b0000000001000039000000010100c039000006ce0000013d0000016001000039000000400010043f0000000001000416000000000001004b000006010000c13d0000000701000039000001600010043f00000ce801000041000001800010043f000001e001000039000000400010043f0000000501000039000001a00010043f00000ce901000041000001c00010043f00000cea01000041000001200010043f00000ceb01000041000001400010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cec011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b001900000001001d000000e00010043f000001a00100043d00000ce70010009c00000ce7010080410000006001100210000000000200041400000ce70020009c00000ce702008041000000c002200210000000000121019f00000ced011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b001800000001001d000001000010043f00000cee010000410000000000100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000cef011001c70000800b02000039339833890000040f0000000100200190000023510000613d000000000201043b000000a00020043f000000400100043d00000080031000390000000000230435000000600210003900000018030000290000000000320435000000400210003900000019030000290000000000320435000000a0020000390000000002210436000000a0031000390000000004000410000000000043043500000cf003000041000000000032043500000cf10010009c000002b60000413d00000d8401000041000000000010043f0000004101000039000000040010043f00000d2b010000410000339a00010430000000000003004b000006010000c13d0000000001000019000033990001042e00000d100020009c000001050000213d00000d1a0020009c0000017a0000a13d00000d1b0020009c000001f00000213d00000d1e0020009c000003080000613d00000d1f0020009c000006010000c13d000000440030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b0000002404100370000000000504043b00000d240050009c000006010000213d0000002304500039000000000034004b000006010000813d0000000406500039000000000461034f000000000404043b00000d240040009c000000a80000213d0000001f0740003900000db6077001970000003f0770003900000db60770019700000d3c0070009c000000a80000213d00000024055000390000008007700039000000400070043f000000800040043f0000000005540019000000000035004b000006010000213d0000002003600039000000000331034f00000db6054001980000001f0640018f000000a001500039000000e80000613d000000a007000039000000000803034f000000008908043c0000000007970436000000000017004b000000e40000c13d000000000006004b000000f50000613d000000000353034f0000000305600210000000000601043300000000065601cf000000000656022f000000000303043b0000010005500089000000000353022f00000000035301cf000000000363019f0000000000310435000000a0014000390000000000010435000000800100043d000000410010008c000008cb0000c13d000000c00100043d00000da60010009c000009d80000a13d0000000002000019000000400100043d000000000021043500000ce70010009c00000ce701008041000000400110021000000d26011001c7000033990001042e00000d110020009c000001c40000a13d00000d120020009c000002040000213d00000d150020009c0000031e0000613d00000d160020009c000006010000c13d000000240030008c000006010000413d0000000002000416000000000002004b000006010000c13d000000a002000039000000400020043f0000000401100370000000000101043b000000800010043f000000800100003933982f890000040f33982fb20000040f000000400200043d000000000012043500000ce70020009c00000ce702008041000000400120021000000d26011001c7000033990001042e00000d070020009c000001de0000a13d00000d080020009c0000022d0000213d00000d0b0020009c000003b80000613d00000d0c0020009c000006010000c13d000000440030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b00000d230020009c000006010000213d00000000050200190000002402100370000000000202043b00000d240020009c000006010000213d0000002304200039000000000034004b000006010000813d0000000404200039000000000141034f000000000101043b001900000001001d00000d240010009c000006010000213d0000002402200039001800000002001d0000001901200029000000000031004b000006010000213d00000000010004110000000002000410000000000021004b0000063c0000c13d0000000001050019001600000005001d339832b30000040f0000000001000414000001ab0000013d00000cfd0020009c0000029c0000213d00000d000020009c0000059b0000613d00000d010020009c000006010000c13d000000640030008c000006010000413d0000004402100370000000000202043b00000d240020009c000006010000213d0000000003230049000000040330008a00000d270030009c000006010000213d000002600030008c000006010000413d0000000003000411000080010030008c000006d00000c13d000000a403200039000000000331034f0000006402200039000000000121034f000000000101043b000000000203043b000000000002004b0000072d0000c13d000000000100041400000ce70010009c00000ce701008041000000c0011002100000800102000039339833840000040f0013000000010355000000600110027000010ce70010019d0000000100200190000000b00000c13d00000d2c01000041000000000010043f00000d29010000410000339a0001043000000d200020009c000005080000613d00000d210020009c0000042e0000613d00000d220020009c000006010000c13d000000640030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b00000d230020009c000006010000213d00000000060200190000002402100370000000000202043b000000000002004b0000000004000039000000010400c039000000000042004b000006010000c13d0000004404100370000000000404043b00000d240040009c000006010000213d0000002305400039000000000035004b000006010000813d0000000405400039000000000151034f000000000101043b001900000001001d00000d240010009c000006010000213d0000002404400039001800000004001d0000001901400029000000000031004b000006010000213d00000000010004110000000003000410000000000031004b0000063c0000c13d0000000001060019001600000006001d33982e530000040f0000000001000414001500000001001d000000400300043d001700000003001d000000200130003900000d3802000041000000000021043500000024013000390000002002000039000000000021043500000044033000390000001801000029000000190200002933982e340000040f00000017030000290000000002310049000000200120008a0000000000130435000000000103001933982da80000040f00000016010000290000001502000029000000170300002933982f640000040f0000000001000019000033990001042e00000d170020009c000005190000613d00000d180020009c000004d80000613d00000d190020009c000006010000c13d0000000001000416000000000001004b000006010000c13d00000d5b02000041000000000102041a000000800010043f000000000020043f000000000001004b000003270000613d000000a00400003900000d880200004100000000030000190000000005040019000000000402041a000000000445043600000001022000390000000103300039000000000013004b000001d60000413d000006210000013d00000d0d0020009c0000053d0000613d00000d0e0020009c000004df0000613d00000d0f0020009c000006010000c13d000000240030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000401100370000000000101043b00000d230010009c000006010000213d000000000010043f00000d5901000041000003ad0000013d00000d1c0020009c000003290000613d00000d1d0020009c000006010000c13d000000240030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000401100370000000000101043b00000d230010009c000006010000213d00000000020004110000000003000410000000000032004b0000063e0000c13d3398306f0000040f0000000001000019000033990001042e00000d130020009c000003a20000613d00000d140020009c000006010000c13d000000240030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000401100370000000000101043b001900000001001d00000d230010009c000006010000213d00000000010004110000000002000410000000000021004b0000063c0000c13d0000001901000029000000000010043f00000d5f01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000201041a000000000002004b000006f70000c13d00000d8601000041000000000010043f0000001901000029000000040010043f00000d2b010000410000339a0001043000000d090020009c000003fb0000613d00000d0a0020009c000006010000c13d000000440030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b000f00000002001d00000d240020009c000006010000213d0000000f020000290000002302200039000000000032004b000006010000813d0000000f020000290000000402200039000000000221034f000000000202043b000e00000002001d00000d240020009c000006010000213d0000000f02000029001100240020003d0000000e0200002900000005022002100000001102200029000000000032004b000006010000213d0000002402100370000000000202043b00000d240020009c000006010000213d0000002304200039000000000034004b000006010000813d0000000404200039000000000141034f000000000101043b001400000001001d00000d240010009c000006010000213d001300240020003d000000140100002900000005011002100000001301100029000000000031004b000006010000213d000000000100041a001900000001001d000dff000010019400000a790000c13d00000000010004150000001a0110008a00180005001002180000001901000029000000ff00100190001a00000000003d001a00010000603d00000a7d0000c13d000001000100008a000000190110017f00000001011001bf00000db70110019700000100011001bf00000a9c0000013d00000d030020009c000005dc0000613d00000d040020009c000006010000c13d000000640030008c000006010000413d0000004401100370000000000101043b000200000001001d00000d240010009c000006010000213d00000002010000290000000404100039000000000143004900000d270010009c000006010000213d000002600010008c000006010000413d0000000001000411000080010010008c000006d50000c13d00000d3401000041000000000201041a001800000002001d000000800020043f000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039001900000004001d339833890000040f0000000100200190000006010000613d0000001805000029000000000005004b0000090f0000c13d000300200000003d000000a001000039000009200000013d00000cfe0020009c000005fb0000613d00000cff0020009c000006010000c13d000000a40030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b00000d230020009c000006010000213d0000002402100370000000000202043b00000d230020009c000006010000213d0000008401100370000000000101043b00000d240010009c000006010000213d0000000401100039000000000203001933982d8f0000040f00000d25010000410000011a0000013d000000c003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf2011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000800010043f0000000004000410000000c00040043f000000000200041a0000ff0000200190000006030000c13d000000ff0320018f000000ff0030008c000002ea0000613d000000ff012001bf000000000010041b000000ff01000039000000400200043d000000000012043500000ce70020009c00000ce7020080410000004001200210000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf7011001c70000800d02000039000000010300003900000cf804000041339833840000040f0000000100200190000006010000613d000000c00400043d000000800100043d00000140000004430000016000100443000000a00100043d00000020020000390000018000200443000001a0001004430000004001000039000001c000100443000001e0004004430000006001000039000000e00300043d000002000010044300000220003004430000008001000039000001000300043d00000240001004430000026000300443000001200100043d000000a0030000390000028000300443000002a000100443000000c001000039000001400300043d000002c000100443000002e00030044300000100002004430000000701000039000001200010044300000cf901000041000033990001042e000000840030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b00000d230020009c000006010000213d0000002402100370000000000202043b00000d230020009c000006010000213d0000006401100370000000000101043b00000d240010009c000006010000213d0000000401100039000000000203001933982d8f0000040f00000dad010000410000011a0000013d0000000001000416000000000001004b000006010000c13d00000d6102000041000000000102041a000000800010043f000000000020043f000000000001004b000006170000c13d0000002002000039000006220000013d000000640030008c000006010000413d0000004402100370000000000202043b000400000002001d00000d240020009c000006010000213d0000000402000029001900040020003d000000190230006a00000d270020009c000006010000213d000002600020008c000006010000413d0000002402100370000000000202043b001500000002001d0000000002000411000080010020008c000006560000c13d0000000402000029001801040020003d0000001801100360000000000101043b000000000200041400000d8a03000041000000a00030043f000000a40010043f0000002401000039000000800010043f000000e001000039000000400010043f000000c00120021000000d4b0110019700000d8b011001c700008003020000390000000003000019000000000400001900000000050000190000000006000019339833840000040f0013000000010355000000600310027000010ce70030019d00000ce7063001970000001f0360003900000d40073001970000003f0370003900000d6c05300197000000400400043d0000000003450019000000000053004b0000000005000039000000010500403900000d240030009c000000a80000213d0000000100500190000000a80000c13d000000400030043f00000000056404360000001203000367000000000007004b0000036f0000613d000000000775001900000000083003680000000009050019000000008a08043c0000000009a90436000000000079004b0000036b0000c13d0000001f0760018f00000d3b086001980000000006850019000003790000613d000000000901034f000000000a050019000000009b09043c000000000aba043600000000006a004b000003750000c13d000000000007004b000003860000613d000000000181034f0000000307700210000000000806043300000000087801cf000000000878022f000000000101043b0000010007700089000000000171022f00000000017101cf000000000181019f000000000016043500000001002001900000073c0000613d0000001801000029000000200210008a000000000123034f000000000101043b00000d2300100198001600000002001d000009730000c13d000000400120008a000000000113034f000000800220008a000000000423034f000000000404043b000000000501043b00000000015400a9000000000005004b0000039b0000613d00000000055100d9000000000045004b00000a3d0000c13d000000c002200039000000000223034f000000000202043b000000000012001a00000a3d0000413d0000000001120019000009770000013d000000240030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000401100370000000000101043b00000d230010009c000006010000213d000000000010043f00000d5f01000041000000200010043f00000040020000390000000001000019339833510000040f000000000101041a000000000001004b0000000001000039000000010100c039000000800010043f00000d7b01000041000033990001042e001900000004001d000000640030008c000006010000413d0000004402100370000000000202043b00000d240020009c000006010000213d0000000404200039000000000543004900000d270050009c000006010000213d000002600050008c000006010000413d0000000006000411000080010060008c0000065b0000c13d0000022402200039000000000621034f000000000606043b0000001f0550008a00000d3f0760019700000d3f08500197000000000987013f000000000087004b000000000700001900000d3f07004041000000000056004b000000000500001900000d3f0500804100000d3f0090009c000000000705c019000000000007004b000006010000c13d0000000005460019000000000451034f000000000404043b00000d240040009c000006010000213d0000000006430049000000200350003900000d3f0560019700000d3f07300197000000000857013f000000000057004b000000000500001900000d3f05004041000000000063004b000000000600001900000d3f0600204100000d3f0080009c000000000506c019000000000005004b000006010000c13d000000030040008c00000a230000213d00000cf501000041000000800010043f0000002001000039000000840010043f0000003a01000039000000a40010043f00000d7901000041000000c40010043f00000d7a01000041000000e40010043f00000d76010000410000339a00010430000000440030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b001900000002001d00000d230020009c000006010000213d0000002402100370000000000202043b00000d240020009c000006010000213d0000002304200039000000000034004b000006010000813d001700040020003d0000001701100360000000000101043b001800000001001d00000d240010009c000006010000213d00000018012000290000002401100039000000000031004b000006010000213d00000000010004110000000002000410000000000021004b0000063c0000c13d0000001901000029000000000010043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a001600000001001d000000000001004b00000a380000c13d00000d6501000041000002280000013d000000640030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b001800000002001d00000d230020009c000006010000213d0000002402100370000000000402043b000000000004004b0000000002000039000000010200c039001700000004001d000000000024004b000006010000c13d0000004402100370000000000202043b00000d240020009c000006010000213d0000002304200039000000000034004b000006010000813d001500040020003d0000001504100360000000000404043b001600000004001d00000d240040009c000006010000213d00000016022000290000002402200039000000000032004b000006010000213d00000000020004110000000004000410000000000042004b0000063e0000c13d000000000131034f0000000202000039000000800020043f000000a002000039000000001301043c0000000002320436000000e00020008c000004590000c13d000000170000006b00000da20100004100000dae01006041000000a00010043f00000d5501000041000000c00010043f00000d5601000041000001000010043f000001040010043f0000002401000039000000e00010043f0000014001000039000000400010043f00000daf010000410000001802000029339833890000040f000000600310027000000ce703300197000000200030008c000000200400003900000000040340190000001f0540018f00000020044001900000047b0000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b000004770000c13d000000000005004b000004880000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f0000000000540435000100000003001f00130000000103550000000100200190000004cf0000613d000000200030008c000004cf0000413d000000000100043d000000000001004b000004cf0000613d000000400100043d000000200210003900000d56030000410000000000320435000000240310003900000d440400004100000000004304350000002403000039000000000031043500000d530010009c000000a80000213d0000006003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f00000d57011001c70000001802000029339833890000040f000000600310027000000ce703300197000000200030008c000000200400003900000000040340190000001f0540018f0000002004400190000004b70000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b000004b30000c13d000000000005004b000004c40000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f00000000005404350013000000010355000100000003001f0000001f0030008c00000000010000390000000101002039000000000112016f000000010010008c00000e9e0000c13d000000000100043d000000000001004b00000e9e0000613d00000db101000041000000000010043f000000180100002900000d2301100197000000040010043f0000001701000029000000240010043f00000d32010000410000339a000104300000000001000416000000000001004b000006010000c13d00000d8901000041000000800010043f00000d7b01000041000033990001042e000000240030008c000006010000413d0000000402100370000000000202043b001500000002001d00000d240020009c000006010000213d00000015020000290000002302200039000000000032004b000006010000813d00000015020000290000000402200039000000000121034f000000000101043b001300000001001d00000d240010009c000006010000213d0000001501000029001600240010003d000000130100002900000005011002100000001601100029000000000031004b000006010000213d00000000010004110000000002000410000000000021004b0000063c0000c13d000000130000006b0000000008000019000007450000c13d0000000001000416000000000018004b000000b00000613d00000d7d02000041000000000020043f000000040010043f000000240080043f00000d32010000410000339a00010430000000240030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000401100370000000000201043b00000db200200198000006010000c13d000000010100003900000db30020009c000006470000213d00000d560020009c000004dc0000613d00000dad0020009c000004dc0000613d0000064b0000013d000000440030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b001900000002001d00000d230020009c000006010000213d0000002402100370000000000402043b00000d240040009c000006010000213d0000002302400039000000000032004b000006010000813d0000000402400039000000000121034f000000000201043b00000d240020009c000006010000213d00000024014000390000000004120019000000000034004b000006010000213d00000000040004110000000005000410000000000054004b000008c60000c13d33982dba0000040f00000000020100190000001901000029339830c40000040f0000000001000019000033990001042e0000000001000416000000000001004b000006010000c13d00000d7e01000041000000000010044300000000010004120000000400100443000000a0010000390000002400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f0000000100200190000023510000613d000000000101043b000000ff0010008c000006400000c13d0000000101000039000000000601041a000000010360019000000001056002700000007f0250018f00000000050260190000001f0050008c00000000040000390000000104002039000000000043004b000006600000613d00000d8401000041000000000010043f0000002201000039000000040010043f00000d2b010000410000339a00010430000000a40030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b00000d230020009c000006010000213d0000002402100370000000000202043b00000d230020009c000006010000213d0000004402100370000000000202043b00000d240020009c000006010000213d0000002304200039000000000034004b000006010000813d0000000404200039000000000441034f000000000404043b00000d240040009c000006010000213d000000050440021000000000024200190000002402200039000000000032004b000006010000213d0000006402100370000000000202043b00000d240020009c000006010000213d0000002304200039000000000034004b000006010000813d0000000404200039000000000441034f000000000404043b00000d240040009c000006010000213d000000050440021000000000024200190000002402200039000000000032004b000006010000213d0000008401100370000000000101043b00000d240010009c000006010000213d0000000401100039000000000203001933982d8f0000040f00000d50010000410000011a0000013d000000640030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000402100370000000000202043b001900000002001d00000d230020009c000006010000213d0000002402100370000000000202043b000000000002004b0000000004000039000000010400c039000000000042004b000006010000c13d0000004404100370000000000404043b00000d240040009c000006010000213d0000002305400039000000000035004b000006010000813d001700040040003d0000001701100360000000000101043b001800000001001d00000d240010009c000006010000213d00000018014000290000002401100039000000000031004b000006010000213d00000000010004110000000003000410000000000031004b0000063c0000c13d0000001901000029000000000010043f000000000002004b00000a610000c13d00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a001600000001001d000000000001004b00000f890000c13d00000d3101000041000000000010043f0000001901000029000000040010043f000000240000043f00000d32010000410000339a00010430000000240030008c000006010000413d0000000002000416000000000002004b000006010000c13d0000000401100370000000000101043b000000000001004b0000000002000039000000010200c039000000000021004b000006010000c13d000000000001004b0000064e0000c13d00000d3402000041000000000102041a000000800010043f000000000020043f000000000001004b000006540000613d000000a00400003900000d4f0200004100000000030000190000000005040019000000000402041a000000000445043600000001022000390000000103300039000000000013004b000005f30000413d000006c50000013d000000240030008c000006010000413d0000000401100370000000000101043b00000d240010009c000006320000a13d00000000010000190000339a00010430000000400100043d000000640210003900000cf3030000410000000000320435000000440210003900000cf403000041000000000032043500000024021000390000002703000039000000000032043500000cf502000041000000000021043500000004021000390000002003000039000000000032043500000ce70010009c00000ce701008041000000400110021000000cf6011001c70000339a00010430000000a00400003900000d870200004100000000030000190000000005040019000000000402041a000000000445043600000001022000390000000103300039000000000013004b0000061a0000413d000000600250008a000000800100003933982da80000040f000000400100043d001900000001001d000000800200003933982df20000040f0000001902000029000000000121004900000ce70010009c00000ce701008041000000600110021000000ce70020009c00000ce7020080410000004002200210000000000121019f000033990001042e0000000001130049000000040110008a00000d270010009c000006010000213d000002600010008c000006010000413d00000d2801000041000000000010043f00000d29010000410000339a0001043000000d2d02000041000006d60000013d00000d2d01000041000006570000013d000000ff0210018f000000200020008c000006760000413d00000d8101000041000000000010043f00000d29010000410000339a0001043000000db40020009c000004dc0000613d00000db50020009c000004dc0000613d000000800000043f00000d7b01000041000033990001042e00000d3002000041000000000102041a000000800010043f000000000020043f000000000001004b000006bb0000c13d0000002001000039000006c90000013d00000d2a01000041000000000010043f000000040020043f00000d2b010000410000339a0001043000000d2a01000041000000000010043f000000040060043f00000d2b010000410000339a00010430000000400400043d001900000004001d0000000004540436000000000003004b000006da0000c13d00000db8016001970000000000140435000000000002004b000000200200003900000000020060390000003f0120003900000db6021001970000001901200029000000000021004b0000000002000039000000010200403900000d240010009c000000a80000213d0000000100200190000000a80000c13d000000400010043f000006800000013d000000400300043d001900000003001d00000d800030009c000000a80000213d00000019040000290000004003400039000000400030043f00000020034000390000000000130435000000000024043500000d7e01000041000000000010044300000000010004120000000400100443000000c0010000390000002400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f0000000100200190000023510000613d000000000101043b000000ff0010008c0000093c0000c13d0000000201000039000000000601041a000000010360019000000001056002700000007f0250018f00000000050260190000001f0050008c00000000040000390000000104002039001700000006001d000000000446013f00000001004001900000055d0000c13d000000400400043d001800000004001d001500000005001d0000000004540436001600000004001d000000000003004b00000afa0000c13d000001000100008a000000170110017f00000016030000290000000000130435000000000002004b000000200200003900000000020060390000003f0120003900000db6011001970000001802100029000000000012004b00000000010000390000000101004039001700000002001d00000d240020009c000000a80000213d0000000100100190000000a80000c13d0000001701000029000000400010043f0000094b0000013d00000d4e02000041000000a00300003900000000040000190000000005030019000000000302041a000000000335043600000001022000390000000104400039000000000014004b000006be0000413d000000410150008a00000db60110019700000d3c0010009c000000a80000213d0000008001100039001900000001001d000000400010043f000006260000013d0000000101000039000000010110018f0000011a0000013d00000d2a01000041000000000010043f000000040030043f00000d2b010000410000339a0001043000000d2a02000041000000000020043f000000040010043f00000d2b010000410000339a00010430001600000006001d001700000004001d001800000005001d000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d0000001602000029000000020020008c0000000002000019000000180500002900000017060000290000066a0000413d000000000101043b00000000020000190000000003620019000000000401041a000000000043043500000001011000390000002002200039000000000052004b000006ef0000413d0000066a0000013d00000d6101000041000000000101041a000000000001004b00000a3d0000613d001800000002001d001700000001001d000000000021004b000009980000c13d00000d6101000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d0000001802000029000000010220008a000000000101043b0000000001210019000000000001041b00000d6101000041000000000021041b0000001901000029000000000010043f00000d5f01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000001041b000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf2011001c70000800d02000039000000020300003900000d85040000410000001905000029339833840000040f0000000100200190000000b00000c13d000006010000013d00000000032100a900000000022300d9000000000012004b00000a3d0000c13d0000000001000414000000000003004b0000016c0000613d00000ce70010009c00000ce701008041000000c00110021000000cf2011001c7000080090200003900008001040000390000000005000019000001700000013d00000ce70050009c00000ce7050080410000004001500210000000000204043300000ce70020009c00000ce7020080410000006002200210000000000112019f0000339a000104300000001501000029001200440010003d000000000b00001900000000080000190000074e0000013d0000000008870019000000010bb000390000001300b0006c000004ff0000813d0000000501b00210000000160d10002900000012010003670000000002d1034f000000000202043b000000000c0000310000001504c0006a000000a30440008a00000d3f0540019700000d3f06200197000000000756013f000000000056004b000000000500001900000d3f05004041000000000042004b000000000400001900000d3f0400804100000d3f0070009c000000000504c019000000000005004b000006010000c13d00000016052000290000004002500039000000000221034f000000000302043b000000000083001a00000a3d0000413d000000000200041400000ce70020009c00000de10000213d000000000451034f000000000404043b00000d230040009c000006010000213d0000006006500039000000000661034f00000000075c00490000001f0770008a000000000606043b000080060040008c001900000008001d001700000003001d00180000000b001d00140000000d001d000007a80000c13d000000000076004b000000000400001900000d3f0400804100000d3f0770019700000d3f08600197000000000978013f000000000078004b000000000700001900000d3f0700404100000d3f0090009c000000000704c019000000000007004b000006010000c13d0000000005560019000000000451034f000000000404043b00000d240040009c000006010000213d000000040040008c000006010000413d00000000074c00490000002006500039000000000076004b000000000500001900000d3f0500204100000d3f0770019700000d3f08600197000000000978013f000000000078004b000000000700001900000d3f0700404100000d3f0090009c000000000705c019000000000007004b000006010000c13d000000000561034f00000d4307000041000000000505043b00000d440550019700000d450050009c000007e00000213d00000d480050009c000007e70000613d00000d490050009c000007e30000013d000000000076004b000000000800001900000d3f0800804100000d3f0770019700000d3f09600197000000000a79013f000000000079004b000000000700001900000d3f0700404100000d3f00a0009c000000000708c019000000000007004b000006010000c13d0000000006560019000000000561034f000000000505043b00000d240050009c000006010000213d00000000075c0049000000200660003900000d3f0870019700000d3f09600197000000000a89013f000000000089004b000000000800001900000d3f08004041000000000076004b000000000700001900000d3f0700204100000d3f00a0009c000000000807c019000000000008004b000006010000c13d000000000003004b0000080c0000613d000000000005004b000007d50000613d00000ce7076001970002000000710355000000000065001a00000a3d0000413d0000000005650019000000000c5c004b00000a3d0000413d000000000171034f00000ce705c0019700000000015103df000000c00220021000000d4b0220019700000d43022001c700020000002103b500000000012103af0000800902000039000000000500001900000000060000190000081e0000013d00000d460050009c000007e70000613d00000d470050009c000000010500003900000d4a0700c041000000000500c019000007e80000013d00000001050000390000000008640019000000000a8c004b00000000090000390000000109004039000000000048004b00000001099041bf00000ce7046001970002000000410355000000000141034f000000000003004b000000010490018f000008010000613d000000000004004b00000a3d0000c13d00000ce704a0019700000000014103df000000c00220021000000d4b0220019700000d43022001c700020000002103b500000000012103af0000800902000039000080060400003900000000060000190000081e0000013d000000000004004b00000a3d0000c13d000000c00220021000000d4b02200197000000000227019f00000ce703a0019700000000013103df00020000002103b500000000012103af00008006020000390000081e0000013d000000000005004b000008160000613d00000ce7076001970002000000710355000000000065001a00000a3d0000413d0000000005650019000000000c5c004b00000a3d0000413d000000000171034f00000ce703c0019700000000013103df000000c00220021000000d4b0220019700000d4a022001c700020000002103b500000000012103af00000000020400193398338e0000040f0013000000010355000000600310027000010ce70030019d00000001002001900000001908000029000000180b00002900000017070000290000074a0000c13d00000ce706300197000000400300043d000000000263043600000d3b056001980000000004520019000008330000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b0000082f0000c13d0000001f06600190000008400000613d000000000151034f0000000305600210000000000604043300000000065601cf000000000656022f000000000101043b0000010005500089000000000151022f00000000015101cf000000000161019f0000000000140435000000400100043d000000200400003900000000044104360000000003030433000000000034043500000db6063001970000001f0530018f0000004004100039000000000042004b0000085a0000813d000000000006004b000008560000613d00000000085200190000000007540019000000200770008a000000200880008a0000000009670019000000000a680019000000000a0a04330000000000a90435000000200660008c000008500000c13d000000000005004b000008700000613d0000000007040019000008660000013d0000000007640019000000000006004b000008630000613d00000000080200190000000009040019000000008a0804340000000009a90436000000000079004b0000085f0000c13d000000000005004b000008700000613d00000000026200190000000305500210000000000607043300000000065601cf000000000656022f00000000020204330000010005500089000000000252022f00000000025201cf000000000262019f00000000002704350000001f0230003900000db60220019700000000034300190000000000030435000000400220003900000ce70020009c00000ce702008041000000600220021000000ce70010009c00000ce7010080410000004001100210000000000112019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000121019f00000cf2011001c70000800d02000039000000020300003900000d7c0400004100000000050b0019339833840000040f000000180b0000290000000100200190000000190800002900000017070000290000001402000029000006010000613d0000001201000367000000000221034f000000000202043b00000015030000290000000003300079000000a30330008a00000d3f0420019700000d3f05300197000000000654013f000000000054004b000000000400001900000d3f04004041000000000032004b000000000300001900000d3f0300804100000d3f0060009c000000000403c019000000000004004b000006010000c13d0000001202200029000000000121034f000000000101043b000000000001004b0000000002000039000000010200c039000000000021004b000006010000c13d000000000001004b0000074a0000c13d0000001303000367000000010100003100000db6021001980000001f0410018f000008b50000613d000000000503034f0000000006000019000000005705043c0000000006760436000000000026004b000008b10000c13d000000000004004b000008c20000613d000000000323034f0000000304400210000000000502043300000000054501cf000000000545022f000000000303043b0000010004400089000000000343022f00000000034301cf000000000353019f000000000032043500000ce70010009c00000ce70100804100000060011002100000339a0001043000000d2d01000041000000000010043f000000040040043f00000d2b010000410000339a0001043000000d270010009c000006010000213d000000400010008c000006010000413d000000a00300043d00000d240030009c000006010000213d000000bf05300039000000a00410003900000d3f0140019700000d3f06500197000000000716013f000000000016004b000000000100001900000d3f01004041000000000045004b000000000500001900000d3f0500804100000d3f0070009c000000000105c019000000000001004b000006010000c13d000000a001300039000000000101043300000d240010009c000000a80000213d0000001f0510003900000db6055001970000003f0550003900000db605500197000000400600043d0000000005560019001900000006001d000000000065004b0000000006000039000000010600403900000d240050009c000000a80000213d0000000100600190000000a80000c13d000000400050043f00000019050000290000000005150436001800000005001d000000c0033000390000000005310019000000000045004b000006010000213d00000db6051001970000001f0410018f000000180030006c000016f20000813d000000000005004b0000090b0000613d00000000074300190000001806400029000000200660008a000000200770008a0000000008560019000000000957001900000000090904330000000000980435000000200550008c000009050000c13d000000000004004b000017080000613d0000001806000029000016fe0000013d000000a002000039000000000101043b00000000030000190000000004020019000000000201041a000000000224043600000001011000390000000103300039000000000053004b000009120000413d000000410140008a00000db601100197000300000001001d00000d3c0010009c000000a80000213d00000003010000290000008001100039001400000001001d000000400010043f000000800100043d001500000001001d00000d240010009c000000a80000213d000000150100002900000005011002100000003f0210003900000d3d02200197000000140220002900000d240020009c000000a80000213d000000400020043f000000140200002900000015030000290000000000320435000000000003004b00000b140000c13d0000000201000029000100440010003d00000012010003670000000102100360000000000402043b00000d410040009c00000ddb0000413d00000d4d01000041000008c70000013d000000ff0210018f0000001f0020008c000006430000213d000000400300043d001800000003001d00000d800030009c000000a80000213d00000018040000290000004003400039000000400030043f000000200340003900000000001304350000000000240435000000400100043d001700000001001d000000170100002900000d820010009c000000a80000213d00000017010000290000002002100039001500000002001d000000400020043f0000000000010435000000400600043d0000002001600039000000e002000039000000000021043500000d83010000410000000000160435000000e00260003900000019010000290000000031010434000000000012043500000db6051001970000001f0410018f001600000006001d0000010002600039000000000023004b00000df20000813d000000000005004b0000096f0000613d00000000074300190000000006420019000000200660008a000000200770008a0000000008560019000000000957001900000000090904330000000000980435000000200550008c000009690000c13d000000000004004b00000e080000613d000000000602001900000dfe0000013d00000004010000290000012401100039000000000113034f000000000101043b001700000001001d00000d8c01000041000000000010044300000000010004100000000400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d37011001c70000800a02000039339833890000040f0000000100200190000023510000613d000000000101043b000000170010006b00000aa40000a13d0000000001000410001c00000001001d0000800a01000039000000240300003900000000040004150000001c0440008a000000050440021000000d8c02000041339833660000040f00000da902000041000000000020043f0000001702000029000000040020043f000000240010043f00000d32010000410000339a0001043000000d6101000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d00000018020000290016000100200092000000000101043b00000d6102000041000000000202041a000000160020006c00001d210000a13d0000001702000029000000010220008a0000000001120019000000000101041a001700000001001d00000d6101000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b00000016011000290000001702000029000000000021041b000000000020043f00000d5f01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b0000001802000029000000000021041b00000d6101000041000000000101041a001800000001001d000000000001004b000006ff0000c13d00000d8401000041000000000010043f0000003101000039000000040010043f00000d2b010000410000339a00010430000000400300043d0000006004300039000000e00500043d000000a00600043d000000000014043500000040013000390000000000610435000000f801500270000000200430003900000000001404350000000000230435000000000000043f00000ce70030009c00000ce7030080410000004001300210000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000da7011001c70000000102000039339833890000040f000000600310027000000ce703300197000000200030008c000000200400003900000000040340190000001f0540018f0000002004400190000009fd0000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b000009f90000c13d000000000005004b00000a0a0000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f0000000000540435000100000003001f0013000000010355000000010020019000000a430000613d000000000100043d00000d2301100198000000fd0000613d000000000010043f00000d5f01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d00000dac02000041000000000101043b000000000101041a000000000001004b0000000002006019000000fe0000013d000000000531034f000000000505043b00000d440550019700000d660050009c000000b00000613d00000d670050009c00000e940000c13d000000430040008c000014940000213d00000cf501000041000000800010043f0000002001000039000000840010043f0000004001000039000000a40010043f00000d7401000041000000c40010043f00000d7501000041000000e40010043f00000d76010000410000339a0001043000000d5b01000041000000000101041a001500000001001d000000000001004b00000d4f0000c13d00000d8401000041000000000010043f0000001101000039000000040010043f00000d2b010000410000339a000104300000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00000a4a0000c13d000000000005004b00000a5b0000613d000000000161034f0000000305500210000000000604043300000000065601cf000000000656022f000000000101043b0000010005500089000000000151022f00000000015101cf000000000161019f0000000000140435000000600130021000000ce70020009c00000ce7020080410000004002200210000000000112019f0000339a0001043000000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a001600000001001d000000000001004b00000fa90000c13d00000d3101000041000000000010043f0000001901000029000000040010043f0000000101000039000000240010043f00000d32010000410000339a0001043000000000010004150000001b0110008a0018000500100218001b00000000003d00000d3601000041000000000010044300000000010004100000000400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d37011001c70000800202000039339833890000040f0000000100200190000023510000613d000000000101043b000000000001004b00000e6c0000c13d0000001901000029000000ff0110018f000000010010008c00000018010000290000000501100270000000000100003f000000010100603f00000e6f0000c13d000000000200041a00000db80120019700000001011001bf0000000d0000006b0000ff010200608a000000000121616f00000100011061bf000000000010041b0000000e0200002900000014002001b000000e790000c13d00000d6301000041000000000010043f00000d29010000410000339a00010430000000150000006b000028b10000c13d0000001601000029000000e00210008a0000001201000367000000000221034f000000000202043b000000010020008c000010340000213d000000000002004b000015240000613d000000010020008c0000151d0000c13d00000cee010000410000000000100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000cef011001c70000800b02000039339833890000040f0000000100200190000023510000613d000000400300043d000000000401043b000000800040008c000017750000413d00000d420040009c000000000104001900000080011022700000000005000039000000100500203900000d240010009c00000008055021bf000000400110227000000ce70010009c00000004055021bf00000020011022700000ffff0010008c00000002055021bf0000001001102270000000ff0010008c0000000105502039000000210250003900000db6072001970000003f0270003900000db6012001970000000001130019000000000031004b0000000002000039000000010200403900000d240010009c000000a80000213d0000000100200190000000a80000c13d000000400010043f0000000201500039000000000613043600000012010003670000000002000031000000000007004b00000aea0000613d0000000007760019000000000821034f0000000009060019000000008a08043c0000000009a90436000000000079004b00000ae60000c13d0000000007030433000000000007004b00001d210000613d000000000706043300000d8d07700197000000f808500210000000000778019f00000d8e0770009a00000000007604350000000305500210000000f80550008900000000045401cf000000ff0050008c00000000040020190000002105300039000017840000013d000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d0000001702000029000000020020008c000000000200001900000015050000290000001606000029000006ad0000413d000000000101043b00000000020000190000000003620019000000000401041a000000000043043500000001011000390000002002200039000000000052004b00000b0c0000413d000006ad0000013d0000000302000029000000a00920003900000060020000390000000003000019000000000493001900000000002404350000002003300039000000000013004b00000b180000413d000000190f0000290005024000f0003d0006022000f0003d0007020000f0003d000801e000f0003d001301c000f0003d0012014000f0003d0011012000f0003d0010010000f0003d000f00e000f0003d000e00c000f0003d000d00a000f0003d000c008000f0003d000b006000f0003d000a004000f0003d0009002000f0003d0000000201000029000100440010003d000000000a000019000400000009001d000000800100043d0000000000a1004b00001d210000a13d00170000000a001d0000000501a00210001600000001001d000000a0011000390000000002010433000000400e00043d00000d3e0100004100000000001e04350000000401e000390000002003000039000000000031043500000012010003670000000003f1034f000000000403043b0000002403e0003900000000004304350000000904100360000000000404043b0000004405e0003900000000004504350000000a04100360000000000404043b0000006405e0003900000000004504350000000b04100360000000000404043b0000008405e0003900000000004504350000000c04100360000000000404043b000000a405e0003900000000004504350000000d04100360000000000404043b000000c405e0003900000000004504350000000e04100360000000000404043b000000e405e0003900000000004504350000000f04100360000000000404043b0000010405e0003900000000004504350000001004100360000000000404043b0000012405e0003900000000004504350000001104100360000000000404043b0000014405e000390000000000450435000001e407e000390000016404e0003900180d230020019b0000001205100360000000005605043c0000000004640436000000000074004b00000b6c0000c13d0000001304100360000000000804043b00000000040000310000000005f400490000001f0550008a00000d3f0650019700000d3f09800197000000000a69013f000000000069004b000000000900001900000d3f09004041000000000058004b000000000b00001900000d3f0b00804100000d3f00a0009c00000000090bc019000000000009004b000006010000c13d0000000009f80019000000000891034f000000000808043b00000d240080009c000006010000213d0000002009900039000000000a8400490000000000a9004b000000000b00001900000d3f0b00204100000d3f0aa0019700000d3f0c900197000000000dac013f0000000000ac004b000000000a00001900000d3f0a00404100000d3f00d0009c000000000a0bc01900000000000a004b000006010000c13d000002600a0000390000000000a704350000028407e000390000000000870435000000000a91034f00000db60b80019800000000020e0019000002a409e000390000000007b9001900000ba60000613d000000000c0a034f000000000d09001900000000ce0c043c000000000ded043600000000007d004b00000ba20000c13d0000001f0c80019000000bb30000613d000000000aba034f000000030bc00210000000000c070433000000000cbc01cf000000000cbc022f000000000a0a043b000001000bb00089000000000aba022f000000000aba01cf000000000aca019f0000000000a70435000000000798001900000000000704350000000807100360000000000707043b00000d3f0a700197000000000b6a013f00000000006a004b000000000a00001900000d3f0a004041000000000057004b000000000c00001900000d3f0c00804100000d3f00b0009c000000000a0cc01900000000000a004b000006010000c13d000000000af700190000000007a1034f000000000707043b00000d240070009c000006010000213d000000200aa00039000000000b7400490000000000ba004b000000000c00001900000d3f0c00204100000d3f0bb0019700000d3f0da00197000000000ebd013f0000000000bd004b000000000b00001900000d3f0b00404100000d3f00e0009c000000000b0cc01900000000000b004b000006010000c13d0000001f0880003900000db60880019700000000089800190000000009380049000002040b20003900000000009b0435000000000aa1034f000000000878043600000db60b7001980000000009b8001900000be80000613d000000000c0a034f000000000d08001900000000ce0c043c000000000ded043600000000009d004b00000be40000c13d0000001f0c70019000000bf50000613d000000000aba034f000000030bc00210000000000c090433000000000cbc01cf000000000cbc022f000000000a0a043b000001000bb00089000000000aba022f000000000aba01cf000000000aca019f0000000000a90435000000000987001900000000000904350000000709100360000000000909043b00000d3f0a900197000000000b6a013f00000000006a004b000000000a00001900000d3f0a004041000000000059004b000000000c00001900000d3f0c00804100000d3f00b0009c000000000a0cc01900000000000a004b000006010000c13d0000000009f90019000000000a91034f000000000b0a043b00000d2400b0009c000006010000213d000000200a9000390000000509b00210000000000c9400490000000000ca004b000000000d00001900000d3f0d00204100000d3f0cc0019700000d3f0ea00197000000000fce013f0000000000ce004b000000000c00001900000d3f0c00404100000d3f00f0009c000000190f000029000000000c0dc01900000000000c004b000006010000c13d000000000e0200190000001f0770003900000db60770019700000000078700190000000008370049000002240c20003900000000008c04350000000007b704360000000008970019000000000009004b00000c2b0000613d000000000aa1034f00000000ab0a043c0000000007b70436000000000087004b00000c270000c13d0000001f009001900000000607100360000000000707043b00000d3f09700197000000000a69013f000000000069004b000000000900001900000d3f09004041000000000057004b000000000b00001900000d3f0b00804100000d3f00a0009c00000000090bc019000000000009004b000006010000c13d0000000009f70019000000000791034f000000000707043b00000d240070009c000006010000213d0000002009900039000000000a7400490000000000a9004b000000000b00001900000d3f0b00204100000d3f0aa0019700000d3f0c900197000000000dac013f0000000000ac004b000000000a00001900000d3f0a00404100000d3f00d0009c000000000a0bc01900000000000a004b000006010000c13d000000000a380049000002440be000390000000000ab0435000000000a91034f000000000878043600000db60b7001980000000009b8001900000c5c0000613d000000000c0a034f000000000d08001900000000ce0c043c000000000ded043600000000009d004b00000c580000c13d0000001f0c70019000000c690000613d000000000aba034f000000030bc00210000000000c090433000000000cbc01cf000000000cbc022f000000000a0a043b000001000bb00089000000000aba022f000000000aba01cf000000000aca019f0000000000a90435000000000987001900000000000904350000000509100360000000000909043b00000d3f0a900197000000000b6a013f00000000006a004b000000000600001900000d3f06004041000000000059004b000000000500001900000d3f0500804100000d3f00b0009c000000000605c019000000000006004b000006010000c13d0000000006f90019000000000561034f000000000505043b00000d240050009c000006010000213d00000020066000390000000004540049000000000046004b000000000900001900000d3f0900204100000d3f0440019700000d3f0a600197000000000b4a013f00000000004a004b000000000400001900000d3f0400404100000d3f00b0009c000000000409c019000000000004004b000006010000c13d000000000c0200190000001f0470003900000db6044001970000000007840019000000000337004900000264042000390000000000340435000000000461034f000000000157043600000db606500198000000000361001900000c9f0000613d000000000704034f0000000008010019000000007907043c0000000008980436000000000038004b00000c9b0000c13d0000001f0750019000000cac0000613d000000000464034f0000000306700210000000000703043300000000076701cf000000000767022f000000000404043b0000010006600089000000000464022f00000000046401cf000000000474019f0000000000430435000000000315001900000000000304350000001f0350003900000db6033001970000000001c10049000000000131001900000ce70010009c00000ce701008041000000600110021000000ce700c0009c00000ce70300004100000000030c40190000004003300210000000000131019f000000000300041400000ce70030009c00000ce703008041000000c003300210000000000113019f000000180200002900180000000c001d339833840000040f00000060031002700000001f0430018f00000d3b0530019700010ce70030019d00000ce70330019700130000000103550000000100200190000016da0000613d00000018090000290000000002590019000000000005004b00000cd40000613d000000000601034f0000000007090019000000006806043c0000000007870436000000000027004b00000cd00000c13d000000000004004b000000190f00002900000ce20000613d000000000151034f0000000304400210000000000502043300000000054501cf000000000545022f000000000101043b0000010004400089000000000141022f00000000014101cf000000000151019f00000000001204350000001f0130003900000d40021001970000000001920019000000000021004b0000000002000039000000010200403900000d240010009c000000a80000213d0000000100200190000000a80000c13d000000400010043f000000200030008c000006010000413d000000000209043300000d240020009c000006010000213d000000000593001900000000029200190000001f03200039000000000053004b000000000400001900000d3f0400804100000d3f0330019700000d3f06500197000000000763013f000000000063004b000000000300001900000d3f0300404100000d3f0070009c000000000304c019000000000003004b000006010000c13d000000003202043400000d240020009c000000a80000213d0000001f0420003900000db6044001970000003f0440003900000db604400197000000000414001900000d240040009c000000a80000213d000000400040043f00000000042104360000000006320019000000000056004b000006010000213d00000db6062001970000001f0520018f000000000043004b00000d280000813d000000000006004b00000d210000613d00000000085300190000000007540019000000200770008a000000200880008a0000000009670019000000000a680019000000000a0a04330000000000a90435000000200660008c00000d1b0000c13d000000000005004b00000014080000290000000409000029000000170a00002900000d410000613d000000000704001900000d370000013d0000000007640019000000000006004b00000d310000613d00000000080300190000000009040019000000008a0804340000000009a90436000000000079004b00000d2d0000c13d000000000005004b00000014080000290000000409000029000000170a00002900000d410000613d00000000036300190000000305500210000000000607043300000000065601cf000000000656022f00000000030304330000010005500089000000000353022f00000000035301cf000000000363019f00000000003704350000000002420019000000000002043500000000020804330000000000a2004b00001d210000a13d0000001602900029000000000012043500000000010804330000000000a1004b00001d210000a13d000000010aa000390000001500a0006c00000b310000413d000009350000013d0000001502000029000000160020006c00000f4e0000c13d00000d5b01000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d0000001602000029000000010220008a000000000101043b0000000001210019000000000001041b00000d5b01000041000000000021041b0000001901000029000000000010043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000001041b000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf2011001c70000800d02000039000000020300003900000d64040000410000001905000029339833840000040f0000000100200190000006010000613d00000d3601000041000000000010044300000019010000290000000400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d37011001c70000800202000039339833890000040f0000000100200190000023510000613d000000000101043b000000000001004b000006010000613d000000400300043d00000d3801000041000000000013043500000004013000390000002002000039000000000021043500000024013000390000001802000029000000000021043500000db6042001980000001f0520018f001600000003001d0000004402300039000000000342001900000017060000290000002006600039000000120660036700000da70000613d000000000706034f0000000008020019000000007907043c0000000008980436000000000038004b00000da30000c13d000000000005004b00000db40000613d000000000446034f0000000305500210000000000603043300000000065601cf000000000656022f000000000404043b0000010005500089000000000454022f00000000045401cf000000000464019f00000000004304350000001803000029000000000232001900000000000204350000001f0230003900000db60120019700000d390010009c00000d39010080410000006001100210000000160200002900000ce70020009c00000ce7020080410000004002200210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000121019f00000d3a0110009a0000001902000029339833840000040f000000600310027000010ce70030019d001300000001035500000001002001900000102d0000c13d00000ce7033001970000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00000dd60000c13d00000a4e0000013d00000002020000290000012402200039000000000321034f000000000303043b00000d420030009c000012360000a13d000000400100043d000000440210003900000d9f03000041000000000032043500000024021000390000000803000039000000000032043500000cf502000041000000000021043500000004021000390000002003000039000000000032043500000ce70010009c00000ce701008041000000400110021000000d73011001c70000339a000104300000000006520019000000000005004b00000dfb0000613d0000000007030019000000000802001900000000790704340000000008980436000000000068004b00000df70000c13d000000000004004b00000e080000613d00000000035300190000000304400210000000000506043300000000054501cf000000000545022f00000000030304330000010004400089000000000343022f00000000034301cf000000000353019f0000000000360435000000000321001900000000000304350000001f0110003900000db6011001970000000002210019000000160300002900000000013200490000004003300039000000000013043500000018010000290000000016010434000000000562043600000db603600197001800000006001d0000001f0260018f001900000005001d000000000051004b00000e2a0000813d000000000003004b00000e260000613d00000000052100190000001904200029000000200440008a000000200550008a0000000006340019000000000735001900000000070704330000000000760435000000200330008c00000e200000c13d000000000002004b00000e400000613d000000190400002900000e360000013d0000001904300029000000000003004b00000e330000613d0000000005010019000000190600002900000000570504340000000006760436000000000046004b00000e2f0000c13d000000000002004b00000e400000613d00000000013100190000000302200210000000000304043300000000032301cf000000000323022f00000000010104330000010002200089000000000121022f00000000012101cf000000000131019f000000000014043500000018020000290000001901200029000000000001043500000cee010000410000000000100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000cef011001c70000800b02000039339833890000040f0000000100200190000023510000613d000000000101043b00000016040000290000008002400039000000000300041000000000003204350000006002400039000000000012043500000018010000290000001f0110003900000db60110019700000019011000290000000002410049000000c0034000390000000000230435000000a0024000390000000000020435000000170200002900000000020204330000000001210436000000000002004b00000e6a0000613d00000000030000190000001505000029000000005405043400000000014104360000000103300039000000000023004b00000e650000413d0000001602000029000006290000013d00000018010000290000000501100270000000000100003f000000400100043d000000640210003900000d51030000410000000000320435000000440210003900000d5203000041000000000032043500000024021000390000002e030000390000060c0000013d0000000e0000006b000012720000c13d000000140000006b000015af0000c13d0000000d0000006b000000b00000c13d000000000200041a00000db701200197000000000010041b0000000103000039000000400100043d000000000031043500000ce70010009c00000ce7010080410000004001100210000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf7011001c70000800d0200003900000cf804000041339833840000040f0000000100200190000000b00000c13d000006010000013d00000cf501000041000000800010043f0000002001000039000000840010043f0000001a01000039000000a40010043f00000d7701000041000000c40010043f00000d78010000410000339a00010430000000800100043d000000000001004b00000ee80000613d0000000002000019001900000002001d0000000501200210000000a0011000390000000003010433000000400100043d000000200210003900000d5604000041000000000042043500000d4403300197000000240410003900000000003404350000002403000039000000000031043500000d530010009c000000a80000213d0000006003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f00000d57011001c70000001802000029339833890000040f000000600310027000000ce703300197000000200030008c00000020050000390000000005034019000000200450019000000ecb0000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b00000ec70000c13d0000001f0550019000000ed80000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f00000000005404350013000000010355000100000003001f0000001f0030008c00000000010000390000000101002039000000000112016f000000010010008c000004cf0000c13d000000000100043d000000000001004b000004cf0000613d00000019020000290000000102200039000000800100043d000000000012004b00000ea20000413d000000180100002900000d2301100197001900000001001d000000000010043f00000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b000016d80000c13d0000001901000029000000000010043f00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b0000185e0000c13d0000001901000029000000000010043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b00001afd0000c13d0000001901000029000000000010043f000000170000006b00001bee0000c13d00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b00001c250000c13d00000d3401000041000000000201041a001800000002001d00000d240020009c000000a80000213d00000018020000290000000102200039000000000021041b000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b00000018011000290000001902000029000000000021041b00000d3401000041000000000101041a001800000001001d000000000020043f00000d3301000041000000200010043f000000000100041400001c1a0000013d00000d5b01000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d00000016020000290014000100200092000000000101043b00000d5b02000041000000000202041a000000140020006c00001d210000a13d0000001502000029000000010220008a0000000001120019000000000101041a001500000001001d00000d5b01000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b00000014011000290000001502000029000000000021041b000000000020043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b0000001602000029000000000021041b00000d5b01000041000000000101041a001600000001001d000000000001004b000009d20000613d00000d520000013d00000d3401000041000000000101041a001500000001001d000000000001004b00000a3d0000613d0000001502000029000000160020006c000016000000c13d00000d3401000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d0000001602000029000000010220008a000000000101043b0000000001210019000000000001041b00000d3401000041000000000021041b0000001901000029000000000010043f00000d3301000041000000200010043f000000000100041400000fc80000013d00000d3001000041000000000101041a001500000001001d000000000001004b00000a3d0000613d0000001502000029000000160020006c0000163b0000c13d00000d3001000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d0000001602000029000000010220008a000000000101043b0000000001210019000000000001041b00000d3001000041000000000021041b0000001901000029000000000010043f00000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000001041b000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf2011001c70000800d02000039000000020300003900000d35040000410000001905000029339833840000040f0000000100200190000006010000613d00000d3601000041000000000010044300000019010000290000000400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d37011001c70000800202000039339833890000040f0000000100200190000023510000613d000000000101043b000000000001004b000006010000613d000000400300043d00000d3801000041000000000013043500000004013000390000002002000039000000000021043500000024013000390000001802000029000000000021043500000db6042001980000001f0520018f001600000003001d00000044023000390000000003420019000000170600002900000020066000390000001206600367000010060000613d000000000706034f0000000008020019000000007907043c0000000008980436000000000038004b000010020000c13d000000000005004b000010130000613d000000000446034f0000000305500210000000000603043300000000065601cf000000000656022f000000000404043b0000010005500089000000000454022f00000000045401cf000000000464019f00000000004304350000001803000029000000000232001900000000000204350000001f0230003900000db60120019700000d390010009c00000d39010080410000006001100210000000160200002900000ce70020009c00000ce7020080410000004002200210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000121019f00000d3a0110009a0000001902000029339833840000040f000000600310027000010ce70030019d0013000000010355000000010020019000001bd80000613d000000160100002900000d240010009c000000a80000213d0000001601000029000000400010043f0000000001000019000033990001042e000000020020008c000015660000613d000000710020008c0000151d0000c13d000000040c000029001701c400c0003d0000001702100360000000000302043b00000000020000310000000004c20049000000230540008a00000d3f0450019700000d3f06300197000000000746013f000000000046004b000000000400001900000d3f04004041000000000053004b000000000500001900000d3f0500804100000d3f0070009c000000000405c0190000012405c00039000000000551034f000000e406c00039000000c407c00039000000a408c000390000008409c00039000000640ac00039000000440bc00039000000240cc00039000000000cc1034f000000000bb1034f000000000aa1034f000000000991034f000000000881034f000000000771034f000000000661034f000000180d100360000000000505043b000f00000005001d00000000050d043b001000000005001d000000000506043b001100000005001d000000000507043b001200000005001d000000000508043b001300000005001d000000000509043b001400000005001d00000000050a043b001500000005001d00000000050b043b001600000005001d00000000050c043b001800000005001d000000000004004b000006010000c13d0000001903300029000000000431034f000000000404043b00000d240040009c000006010000213d0000000006420049000000200530003900000d3f0360019700000d3f07500197000000000837013f000000000037004b000000000300001900000d3f03004041000000000065004b000000000600001900000d3f0600204100000d3f0080009c000000000306c019000000000003004b000006010000c13d0000000003000414000000000004004b0000108e0000613d00000ce7065001970002000000610355000000000054001a00000a3d0000413d0000000004540019000000000242004b00000a3d0000413d000000000161034f00000ce70220019700020000002103e500000d960030009c00000de10000813d00000000012103df000000c00230021000000d4b0220019700000d4a022001c700020000002103b500000000012103af0000801002000039339833930000040f000000600310027000010ce70030019d00000ce7043001970013000000010355000000010020019000001bc00000613d0000001f0240003900000d40072001970000003f0270003900000d6c02200197000000400600043d0000000002260019000000000062004b0000000003000039000000010300403900000d240020009c000000a80000213d0000000100300190000000a80000c13d000000400020043f000000000546043600000012020003670000000003000031000000000007004b000010ba0000613d0000000007750019000000000832034f0000000009050019000000008a08043c0000000009a90436000000000079004b000010b60000c13d0000001f0740018f00000d3b084001980000000004850019000010c40000613d000000000901034f000000000a050019000000009b09043c000000000aba043600000000004a004b000010c00000c13d000000000007004b000010d10000613d000000000181034f0000000307700210000000000804043300000000087801cf000000000878022f000000000101043b0000010007700089000000000171022f00000000017101cf000000000181019f00000000001404350000000001060433000000200010008c00001e140000c13d000000040430006a0000001701000029001700400010003d0000001701200360000000000101043b000000230440008a00000d3f0640019700000d3f07100197000000000867013f000000000067004b000000000600001900000d3f06004041000000000041004b000000000400001900000d3f0400804100000d3f0080009c000000000604c019000000000006004b000006010000c13d0000000004050433000e00000004001d0000001904100029000000000142034f000000000101043b00000d240010009c000006010000213d00000005011002100000000003130049000000200640003900000d3f0430019700000d3f05600197000000000745013f000000000045004b000000000400001900000d3f04004041000000000036004b000000000300001900000d3f0300204100000d3f0070009c000000000403c019000000000004004b000006010000c13d0000001f0510018f000000400300043d0000002004300039000000000001004b0000110a0000613d000000000262034f00000000061400190000000007040019000000002802043c0000000007870436000000000067004b000011060000c13d000000000005004b00000000001304350000003f0110003900000d3d011001970000000001130019000000000031004b0000000002000039000000010200403900000d240010009c000000a80000213d0000000100200190000000a80000c13d000000400010043f00000ce70040009c00000ce7040080410000004001400210000000000203043300000ce70020009c00000ce7020080410000006002200210000000000112019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf2011001c70000801002000039339833890000040f0000000100200190000006010000613d000000170200002900000020032000390000001202000367000000000332034f000000000403043b0000000003000031000000040530006a000000230550008a00000d3f0650019700000d3f07400197000000000867013f000000000067004b000000000600001900000d3f06004041000000000054004b000000000500001900000d3f0500804100000d3f0080009c000000000605c019000000000101043b001700000001001d000000000006004b000006010000c13d0000001901400029000000000412034f000000000404043b00000d240040009c000006010000213d0000000006430049000000200510003900000d3f0160019700000d3f07500197000000000817013f000000000017004b000000000100001900000d3f01004041000000000065004b000000000600001900000d3f0600204100000d3f0080009c000000000106c019000000000001004b000006010000c13d0000000001000414000000000004004b0000115f0000613d00000ce7065001970002000000620355000000000054001a00000a3d0000413d0000000004540019000000000343004b00000a3d0000413d000000000262034f00000ce70330019700020000003203e500000ce70010009c00000de10000213d00000000023203df000000c00110021000000d4b0110019700000d4a011001c700020000001203b500000000011203af0000801002000039339833930000040f000000600310027000010ce70030019d00000ce70330019700130000000103550000000100200190000027b80000613d0000001f0230003900000d40052001970000003f0250003900000d6c04200197000000400200043d0000000004420019000000000024004b0000000006000039000000010600403900000d240040009c000000a80000213d0000000100600190000000a80000c13d000000400040043f0000000004320436000000000005004b0000118a0000613d0000000005540019000000000600003100000012066003670000000007040019000000006806043c0000000007870436000000000057004b000011860000c13d0000001f0530018f00000d3b063001980000000003640019000011940000613d000000000701034f0000000008040019000000007907043c0000000008980436000000000038004b000011900000c13d000000000005004b000011a10000613d000000000161034f0000000305500210000000000603043300000000065601cf000000000656022f000000000101043b0000010005500089000000000151022f00000000015101cf000000000161019f00000000001304350000000001020433000000200010008c00001e140000c13d0000000002040433000000400100043d000001c0031000390000000000230435000001a0021000390000001703000029000000000032043500000180021000390000000e03000029000000000032043500000160021000390000000f030000290000000000320435000001400210003900000010030000290000000000320435000001200210003900000011030000290000000000320435000001000210003900000012030000290000000000320435000000e00210003900000013030000290000000000320435000000c00210003900000014030000290000000000320435000000a00210003900000015030000290000000000320435000000800210003900000016030000290000000000320435000000600210003900000018030000290000000000320435000000400210003900000071030000390000000000320435000000200210003900000d98030000410000000000320435000001c003000039000000000031043500000d990010009c000000a80000213d000001e003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf2011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b001700000001001d000000400100043d001800000001001d00000cee010000410000000000100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000cef011001c70000800b02000039339833890000040f0000000100200190000023510000613d00000018040000290000002002400039000000000101043b00000d9a03000041000000000032043500000080034000390000000000130435000000600140003900000d9b030000410000000000310435000000400140003900000d9c0300004100000000003104350000008001000039000000000014043500000d9d0040009c000000a80000213d0000001803000029000000a001300039000000400010043f00000ce70020009c00000ce7020080410000004001200210000000000203043300000ce70020009c00000ce7020080410000006002200210000000000112019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf2011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000301043b000000400100043d000000420210003900000017040000290000000000420435000000200210003900000d9e040000410000000000420435000000220410003900000000003404350000004203000039000000000031043500000d3c0010009c000000a80000213d0000008003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f0000000002000414000028a60000013d000000a002200039000000000221034f000000000502043b0000000002000031000000020620006a000000230660008a00000d3f0760019700000d3f08500197000000000978013f000000000078004b000000000700001900000d3f07004041000000000065004b000000000600001900000d3f0600804100000d3f0090009c000000000706c019000000000007004b0000001906000029000006010000c13d0000000005650019000000000651034f000000000706043b00000d240070009c000006010000213d0000000006720049000000200850003900000d3f0560019700000d3f09800197000000000a59013f000000000059004b000000000500001900000d3f05004041000000000068004b000000000600001900000d3f0600204100000d3f00a0009c000000000506c019000000000005004b000006010000c13d000000000600041400000ce70060009c00000de10000213d000080060040008c000019200000c13d000000040070008c000019200000413d000000000981034f000000010500003900000d4304000041000000000909043b00000d440990019700000d450090009c00001a0d0000213d00000d480090009c00001a130000613d00000d490090009c00000d4a0400c041000000000500c01900001a130000013d0000000002000019001000000002001d000000050120021000000011011000290000001201100367000000000201043b00000000010000310000000f0310006a000000430330008a00000d3f0430019700000d3f05200197000000000645013f000000000045004b000000000400001900000d3f04004041000000000032004b000000000300001900000d3f0300804100000d3f0060009c000000000403c019000000000004004b000006010000c13d00000011032000290000001202300367000000000202043b00000d240020009c000006010000213d0000000005210049000000200430003900000d3f0350019700000d3f06400197000000000736013f000000000036004b000000000300001900000d3f03004041000000000054004b000000000500001900000d3f0500204100000d3f0070009c000000000305c019000000000003004b000006010000c13d000000400020008c000006010000413d0000001203400367000000000303043b001800000003001d00000d230030009c000006010000213d00000020034000390000001203300367000000000503043b00000d240050009c000006010000213d000000000342001900000000044500190000001f02400039000000000032004b000000000500001900000d3f0500804100000d3f0220019700000d3f06300197000000000762013f000000000062004b000000000200001900000d3f0200404100000d3f0070009c000000000205c019000000000002004b000006010000c13d0000001202400367000000000202043b00000d240020009c000000a80000213d0000001f0520003900000db6055001970000003f0550003900000db605500197000000400600043d0000000005560019001200000006001d000000000065004b0000000006000039000000010600403900000d240050009c000000a80000213d0000000100600190000000a80000c13d0000002006400039000000400050043f00000012040000290000000004240436001500000004001d0000000004620019000000000034004b000006010000213d00000db60420019800000012056003670000001503400029000012dc0000613d000000000605034f0000001507000029000000006806043c0000000007870436000000000037004b000012d80000c13d0000001f06200190000012e90000613d000000000445034f0000000305600210000000000603043300000000065601cf000000000656022f000000000404043b0000010005500089000000000454022f00000000045401cf000000000464019f000000000043043500000015022000290000000000020435000000400200043d001700000002001d00000d530020009c000000a80000213d00000017040000290000006002400039000000400020043f000000020300003900000000033404360000001201100367001600000003001d000000001401043c0000000003430436000000000023004b000012f60000c13d00000d5401000041000000160200002900000000001204350000001701000029000000400110003900000d55020000410000000000210435000000400100043d000000200210003900000d56040000410000000000420435000000240310003900000000004304350000002403000039000000000031043500000d530010009c000000a80000213d0000006003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f00000d57011001c70000001802000029339833890000040f000000600310027000000ce703300197000000200030008c000000200500003900000000050340190000002004500190000013250000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b000013210000c13d0000001f05500190000013320000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f0000000000540435000100000003001f00130000000103550000000100200190000016760000613d000000200030008c000016760000413d000000000100043d000000000001004b000016760000613d000000400100043d000000200210003900000d56030000410000000000320435000000240310003900000d440400004100000000004304350000002403000039000000000031043500000d530010009c000000a80000213d0000006003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f00000d57011001c70000001802000029339833890000040f000000600310027000000ce703300197000000200030008c000000200500003900000000050340190000002004500190000013600000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b0000135c0000c13d0000001f055001900000136d0000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f00000000005404350013000000010355000100000003001f0000001f0030008c00000000010000390000000101002039000000000112016f000000010010008c000013780000c13d000000000100043d000000000001004b000016760000c13d00000017010000290000000001010433000000000001004b000013c40000613d0000000002000019001900000002001d000000050120021000000016011000290000000003010433000000400100043d000000200210003900000d5604000041000000000042043500000d4403300197000000240410003900000000003404350000002403000039000000000031043500000d530010009c000000a80000213d0000006003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f00000d57011001c70000001802000029339833890000040f000000600310027000000ce703300197000000200030008c000000200500003900000000050340190000002004500190000013a60000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b000013a20000c13d0000001f05500190000013b30000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f00000000005404350013000000010355000100000003001f0000001f0030008c00000000010000390000000101002039000000000112016f000000010010008c000016760000c13d000000000100043d000000000001004b000016760000613d0000001902000029000000010220003900000017010000290000000001010433000000000012004b0000137d0000413d0000001801000029000000000010043f00000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b00001aff0000c13d0000001801000029000000000010043f00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b00001b030000c13d0000001801000029000000000010043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b00001b070000c13d00000d5b01000041000000000101041a00000d240010009c000000a80000213d001900000001001d000000010110003900000d5b02000041000000000012041b000000000020043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b00000019011000290000001802000029000000000021041b00000d5b01000041000000000101041a001900000001001d000000000020043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b0000001902000029000000000021041b00000d3601000041000000000010044300000018010000290000000400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d37011001c70000800202000039339833890000040f0000000100200190000023510000613d000000000101043b000000000001004b000006010000613d000000400900043d00000d5c010000410000000000190435000000040190003900000020020000390000000000210435000000120100002900000000010104330000002402900039000000000012043500000db6041001970000001f0310018f0000004402900039000000150020006b0000144f0000813d000000000004004b0000144a0000613d00000015063000290000000005320019000000200550008a000000200660008a0000000007450019000000000846001900000000080804330000000000870435000000200440008c000014440000c13d000000000003004b000014650000613d000000000502001900000015060000290000145b0000013d0000000005420019000000000004004b000014580000613d0000001506000029000000000702001900000000680604340000000007870436000000000057004b000014540000c13d000000000003004b000014650000613d00000015064000290000000303300210000000000405043300000000043401cf000000000434022f00000000060604330000010003300089000000000636022f00000000033601cf000000000343019f00000000003504350000001f0310003900000db60330019700000000012100190000000000010435000000440130003900000ce70010009c00000ce701008041000000600110021000000ce70090009c00000ce70200004100000000020940190000004002200210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000121019f0000001802000029001900000009001d339833840000040f000000600310027000010ce70030019d0013000000010355000000010020019000001b090000613d000000190100002900000d240010009c000000a80000213d000000400010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf2011001c70000800d02000039000000020300003900000d5d040000410000001805000029339833840000040f0000000100200190000006010000613d000000100200002900000001022000390000000e0020006c000012730000413d00000e7b0000013d0000000403300039000000000431034f000000000404043b001800000004001d00000d230040009c000006010000213d000001400220008a000000000221034f0000002003300039000000000131034f000000000101043b001700000001001d000000000102043b00000d6802000041000000800020043f000000000200041000000d2302200197001500000002001d000000840020043f00000d2301100197001600000001001d000000a40010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d69011001c70000001802000029339833890000040f000000600310027000000ce703300197000000200030008c000000200400003900000000040340190000001f0640018f000000200740019000000080057001bf000014c00000613d0000008008000039000000000901034f000000009a09043c0000000008a80436000000000058004b000014bc0000c13d000000000006004b000014cd0000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f0000000000650435000100000003001f00130000000103550000000100200190000016cc0000613d0000001f01400039000000600210018f00000080012001bf000000400010043f000000200030008c000006010000413d000000800300043d000000170030006c000000b00000813d000000a00320003900000d6a040000410000000000430435000000a40420003900000016050000290000000000540435000000c4042000390000000000040435000000440400003900000000004104350000014004200039000000400040043f000001200420003900000d6b05000041000000000054043500000100042001bf0000002002000039001300000004001d00000000002404350000004002300210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000121019f0000001802000029339833840000040f0013000000010355000000600310027000010ce70030019d00000ce703300198000019350000c13d001400600000003d0000001401000029000000000101043300000001002001900000195f0000613d000000000001004b00001e1f0000c13d00000d3601000041000000000010044300000018010000290000000400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d37011001c70000800202000039339833890000040f0000000100200190000023510000613d000000000101043b000000000001004b00001e1b0000c13d000000400100043d000000440210003900000d7203000041000000000032043500000024021000390000001d0300003900000de70000013d000000400100043d000000440210003900000da80300004100000000003204350000002402100039000000170300003900000de70000013d0000001802100360000000400300043d001700000003001d000000000302043b000000800030008c0000167c0000413d00000d420030009c000000000203001900000080022022700000000004000039000000100400203900000d240020009c00000008044021bf000000400220227000000ce70020009c00000004044021bf00000020022022700000ffff0020008c00000002044021bf0000001002202270000000ff0020008c0000000104402039000000210540003900000db6065001970000003f0560003900000db6025001970000001702200029000000170020006c0000000005000039000000010500403900000d240020009c000000a80000213d0000000100500190000000a80000c13d000000400020043f0000000202400039000000170500002900000000052504360000000002000031000000000006004b000015540000613d0000000006650019000000000721034f0000000008050019000000007907043c0000000008980436000000000068004b000015500000c13d00000017060000290000000006060433000000000006004b00001d210000613d000000000605043300000d8d06600197000000f807400210000000000667019f00000d8e0660009a00000000006504350000000304400210000000f80440008900000000034301cf000000ff0040008c0000000003002019000000170400002900000021044000390000168c0000013d00000cee010000410000000000100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000cef011001c70000800b02000039339833890000040f0000000100200190000023510000613d000000400300043d000000000401043b000000800040008c000017c20000413d00000d420040009c000000000104001900000080011022700000000005000039000000100500203900000d240010009c00000008055021bf000000400110227000000ce70010009c00000004055021bf00000020011022700000ffff0010008c00000002055021bf0000001001102270000000ff0010008c0000000105502039000000210250003900000db6072001970000003f0270003900000db6012001970000000001130019000000000031004b0000000002000039000000010200403900000d240010009c000000a80000213d0000000100200190000000a80000c13d000000400010043f0000000201500039000000000613043600000012010003670000000002000031000000000007004b0000159f0000613d0000000007760019000000000821034f0000000009060019000000008a08043c0000000009a90436000000000079004b0000159b0000c13d0000000007030433000000000007004b00001d210000613d000000000706043300000d8d07700197000000f808500210000000000778019f00000d8e0770009a00000000007604350000000305500210000000f80550008900000000045401cf000000ff0050008c00000000040020190000002105300039000017d10000013d0000000002000019001800000002001d000000050120021000000013011000290000001201100367000000000301043b00000d230030009c000006010000213d000000000030043f00000d5f01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039001900000003001d339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b0000185c0000c13d00000d6102000041000000000102041a00000d240010009c000000a80000213d001700000001001d0000000101100039000000000012041b000000000020043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f00000001002001900000001902000029000006010000613d000000000101043b0000001701100029000000000021041b00000d6101000041000000000101041a001700000001001d000000000020043f00000d5f01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f00000019050000290000000100200190000006010000613d000000000101043b0000001702000029000000000021041b000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf2011001c70000800d02000039000000020300003900000d6204000041339833840000040f0000000100200190000006010000613d00000018020000290000000102200039000000140020006c000015b00000413d00000e7d0000013d00000d3401000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d00000016020000290014000100200092000000000101043b00000d3402000041000000000202041a000000140020006c00001d210000a13d0000001502000029000000010220008a0000000001120019000000000101041a001500000001001d00000d3401000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b00000014011000290000001502000029000000000021041b000000000020043f00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b0000001602000029000000000021041b00000d3401000041000000000101041a001600000001001d000000000001004b000009d20000613d00000f910000013d00000d3001000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d00000016020000290014000100200092000000000101043b00000d3002000041000000000202041a000000140020006c00001d210000a13d0000001502000029000000010220008a0000000001120019000000000101041a001500000001001d00000d3001000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b00000014011000290000001502000029000000000021041b000000000020043f00000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b0000001602000029000000000021041b00000d3001000041000000000101041a001600000001001d000000000001004b000009d20000613d00000fb10000013d00000d5e01000041000000000010043f0000001801000029000000040010043f00000d2b010000410000339a00010430000000170200002900000d800020009c000000a80000213d00000017040000290000004002400039000000400020043f00000001020000390000000004240436000000f805300210000000000003004b00000d3f050060410000000002000031000000000321034f000000000303043b00000d8d03300197000000000353019f0000000000340435000000400300043d0000001804000029000000600440008a000000000541034f000000000505043b000000800050008c0000180f0000413d00000d420050009c000000000705001900000080077022700000000006000039000000100600203900000d240070009c00000008066021bf000000400770227000000ce70070009c00000004066021bf00000020077022700000ffff0070008c00000002066021bf0000001007702270000000ff0070008c0000000106602039000000210860003900000db6088001970000003f0980003900000db6079001970000000007730019000000000037004b0000000009000039000000010900403900000d240070009c000000a80000213d0000000100900190000000a80000c13d000000400070043f00000002076000390000000007730436000000000008004b000016bc0000613d000000000921034f0000000008870019000000000a070019000000009b09043c000000000aba043600000000008a004b000016b80000c13d0000000008030433000000000008004b00001d210000613d000000000807043300000d8d08800197000000f809600210000000000889019f00000d8e0880009a00000000008704350000000306600210000000f80660008900000000056501cf000000ff0060008c000000000500201900000021063000390000181c0000013d0000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000016d30000c13d00000a4e0000013d00000d580100004100000a720000013d000000400200043d0000000006520019000000000005004b000016e40000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000068004b000016e00000c13d000000000004004b00000a5b0000613d000000000151034f0000000304400210000000000506043300000000054501cf000000000545022f000000000101043b0000010004400089000000000141022f00000000014101cf000000000151019f000000000016043500000a5b0000013d0000001806500029000000000005004b000016fb0000613d0000000007030019000000180800002900000000790704340000000008980436000000000068004b000016f70000c13d000000000004004b000017080000613d00000000035300190000000304400210000000000506043300000000054501cf000000000545022f00000000030304330000010004400089000000000343022f00000000034301cf000000000353019f000000000036043500000018011000290000000000010435000000c00100043d001700000001001d00000d230010009c000006010000213d000000400100043d00000d820010009c000000a80000213d0000002003100039000000400030043f0000000000210435000000400100043d000000400310003900000000002304350000004002000039000000000221043600000d8903000041000000000032043500000d530010009c000000a80000213d0000006003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf2011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b001600000001001d00000d7e0100004100000000001004430000000001000412000000040010044300000040010000390000002400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f0000000100200190000023510000613d000000000101043b00000d23011001970000000002000410000000000012004b00001d270000c13d00000d7e0100004100000000001004430000000001000412000000040010044300000020010000390000002400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f0000000100200190000023510000613d000000000101043b001500000001001d00000cee010000410000000000100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000cef011001c70000800b02000039339833890000040f0000000100200190000023510000613d000000000101043b000000150010006c00001d270000c13d00000d7e010000410000000000100443000000000100041200000004001004430000002400000443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f000000010020019000001d7f0000c13d000023510000013d00000d800030009c000000a80000213d0000004001300039000000400010043f00000001010000390000000005130436000000f806400210000000000004004b00000d3f0600604100000000020000310000001201000367000000000421034f000000000404043b00000d8d04400197000000000464019f00000000004504350000001804100360000000400600043d000000000404043b000000800040008c000018600000413d00000d420040009c000000000704001900000080077022700000000005000039000000100500203900000d240070009c00000008055021bf000000400770227000000ce70070009c00000004055021bf00000020077022700000ffff0070008c00000002055021bf0000001007702270000000ff0070008c0000000105502039000000210850003900000db6088001970000003f0980003900000db6079001970000000007760019000000000067004b0000000009000039000000010900403900000d240070009c000000a80000213d0000000100900190000000a80000c13d000000400070043f00000002075000390000000007760436000000000008004b000017b20000613d000000000921034f0000000008870019000000000a070019000000009b09043c000000000aba043600000000008a004b000017ae0000c13d0000000008060433000000000008004b00001d210000613d000000000807043300000d8d08800197000000f809500210000000000889019f00000d8e0880009a00000000008704350000000305500210000000f80550008900000000045401cf000000ff0050008c000000000400201900000021056000390000186d0000013d00000d800030009c000000a80000213d0000004001300039000000400010043f00000001010000390000000005130436000000f806400210000000000004004b00000d3f0600604100000000020000310000001201000367000000000421034f000000000404043b00000d8d04400197000000000464019f00000000004504350000001804100360000000400600043d000000000404043b000000800040008c000018ad0000413d00000d420040009c000000000704001900000080077022700000000005000039000000100500203900000d240070009c00000008055021bf000000400770227000000ce70070009c00000004055021bf00000020077022700000ffff0070008c00000002055021bf0000001007702270000000ff0070008c0000000105502039000000210850003900000db6088001970000003f0980003900000db6079001970000000007760019000000000067004b0000000009000039000000010900403900000d240070009c000000a80000213d0000000100900190000000a80000c13d000000400070043f00000002075000390000000007760436000000000008004b000017ff0000613d000000000921034f0000000008870019000000000a070019000000009b09043c000000000aba043600000000008a004b000017fb0000c13d0000000008060433000000000008004b00001d210000613d000000000807043300000d8d08800197000000f809500210000000000889019f00000d8e0880009a00000000008704350000000305500210000000f80550008900000000045401cf000000ff0050008c00000000040020190000002105600039000018ba0000013d00000d800030009c000000a80000213d0000004006300039000000400060043f00000001060000390000000006630436000000f807500210000000000005004b00000d3f07006041000000000521034f000000000505043b00000d8d05500197000000000575019f0000000000560435000000400440008a000000000441034f000000400500043d000000000604043b000000800060008c000018fa0000413d00000d420060009c000000000406001900000080044022700000000007000039000000100700203900000d240040009c00000008077021bf000000400440227000000ce70040009c00000004077021bf00000020044022700000ffff0040008c00000002077021bf0000001004402270000000ff0040008c0000000107702039000000210870003900000db6088001970000003f0980003900000db6049001970000000004450019000000000054004b0000000009000039000000010900403900000d240040009c000000a80000213d0000000100900190000000a80000c13d000000400040043f00000002047000390000000004450436000000000008004b0000184b0000613d000000000921034f0000000008840019000000000a040019000000009b09043c000000000aba043600000000008a004b000018470000c13d0000000008050433000000000008004b00001d210000613d000000000804043300000d8d08800197000000f809700210000000000889019f00000d8e0880009a00000000008404350000000307700210000000f80770008900000000067601cf000000ff0070008c000000000600201900000021075000390000000000670435000019080000013d00000d6001000041000002280000013d00000d5801000041000005d60000013d00000d800060009c000000a80000213d0000004005600039000000400050043f00000001050000390000000005560436000000f807400210000000000004004b00000d3f07006041000000000421034f000000000404043b00000d8d04400197000000000474019f0000000000450435000000400a00043d0000001804000029000000600440008a000000000541034f000000000505043b000000800050008c000019750000413d00000d420050009c000000000805001900000080088022700000000007000039000000100700203900000d240080009c00000008077021bf000000400880227000000ce70080009c00000004077021bf00000020088022700000ffff0080008c00000002077021bf0000001008802270000000ff0080008c0000000107702039000000210970003900000db6099001970000003f0b90003900000db608b0019700000000088a00190000000000a8004b000000000b000039000000010b00403900000d240080009c000000a80000213d0000000100b00190000000a80000c13d000000400080043f000000020870003900000000088a0436000000000009004b0000189d0000613d000000000b21034f0000000009980019000000000c08001900000000bd0b043c000000000cdc043600000000009c004b000018990000c13d00000000090a0433000000000009004b00001d210000613d000000000908043300000d8d09900197000000f80b70021000000000099b019f00000d8e0990009a00000000009804350000000307700210000000f80770008900000000057501cf000000ff0070008c00000000050020190000002107a00039000019820000013d00000d800060009c000000a80000213d0000004005600039000000400050043f00000001050000390000000005560436000000f807400210000000000004004b00000d3f07006041000000000421034f000000000404043b00000d8d04400197000000000474019f0000000000450435000000400700043d0000001804000029000000400440008a000000000541034f000000000505043b000000800050008c000019c10000413d00000d420050009c000000000905001900000080099022700000000008000039000000100800203900000d240090009c00000008088021bf000000400990227000000ce70090009c00000004088021bf00000020099022700000ffff0090008c00000002088021bf0000001009902270000000ff0090008c0000000108802039000000210a80003900000db60aa001970000003f0ba0003900000db609b001970000000009970019000000000079004b000000000b000039000000010b00403900000d240090009c000000a80000213d0000000100b00190000000a80000c13d000000400090043f0000000209800039000000000997043600000000000a004b000018ea0000613d000000000b21034f000000000aa90019000000000c09001900000000bd0b043c000000000cdc04360000000000ac004b000018e60000c13d000000000a07043300000000000a004b00001d210000613d000000000a09043300000d8d0aa00197000000f80b800210000000000aab019f00000d8e0aa0009a0000000000a904350000000308800210000000f80880008900000000058501cf000000ff0080008c00000000050020190000002108700039000019ce0000013d00000d800050009c000000a80000213d0000004004500039000000400040043f00000001040000390000000004450436000000f807600210000000000006004b00000d3f07006041000000000621034f000000000606043b00000d8d06600197000000000676019f0000000000640435000000006303043400000db6083001970000001f0730018f000000400900043d001600000009001d001800200090003d000000180060006c00001b160000813d000000000008004b0000191c0000613d000000000a7600190000001809700029000000200990008a000000200aa0008a000000000b890019000000000c8a0019000000000c0c04330000000000cb0435000000200880008c000019160000c13d000000000007004b00001b2c0000613d000000180900002900001b220000013d000000000003004b00001a290000c13d000000000007004b0000192c0000613d00000ce7038001970002000000310355000000000087001a00000a3d0000413d0000000005870019000000000252004b00000a3d0000413d000000000131034f00000ce70220019700000000012103df000000c00260021000000d4b0220019700000d4a022001c700020000002103b500000000012103af000000000204001900001a280000013d0000001f0430003900000d40044001970000003f0440003900000d6c04400197000000400500043d0000000004450019001400000005001d000000000054004b0000000005000039000000010500403900000d240040009c000000a80000213d0000000100500190000000a80000c13d000000400040043f0000001f0430018f0000001405000029000000000635043600000d3b05300198001900000006001d0000000003560019000019510000613d000000000601034f0000001907000029000000006806043c0000000007870436000000000037004b0000194d0000c13d000000000004004b000015000000613d000000000151034f0000000304400210000000000503043300000000054501cf000000000545022f000000000101043b0000010004400089000000000141022f00000000014101cf000000000151019f0000000000130435000015000000013d000000000001004b00001be50000c13d000000400300043d001900000003001d00000cf50100004100000000001304350000000401300039000000200200003900000000002104350000002402300039000000130100002933982e020000040f0000001902000029000000000121004900000ce70010009c00000ce70100804100000ce70020009c00000ce70200804100000060011002100000004002200210000000000121019f0000339a0001043000000d8000a0009c000000a80000213d0000004007a00039000000400070043f000000010700003900000000077a0436000000f808500210000000000005004b00000d3f08006041000000000521034f000000000505043b00000d8d05500197000000000585019f0000000000570435000000400b00043d000000400440008a000000000541034f000000000505043b000000800050008c00001c820000413d00000d420050009c000000000805001900000080088022700000000007000039000000100700203900000d240080009c00000008077021bf000000400880227000000ce70080009c00000004077021bf00000020088022700000ffff0080008c00000002077021bf0000001008802270000000ff0080008c0000000107702039000000210970003900000db6099001970000003f0c90003900000db608c0019700000000088b00190000000000b8004b000000000c000039000000010c00403900000d240080009c000000a80000213d0000000100c00190000000a80000c13d000000400080043f000000020870003900000000088b0436000000000009004b000019b10000613d000000000c21034f0000000009980019000000000d08001900000000ce0c043c000000000ded043600000000009d004b000019ad0000c13d00000000090b0433000000000009004b00001d210000613d000000000908043300000d8d09900197000000f80c70021000000000099c019f00000d8e0990009a00000000009804350000000307700210000000f80770008900000000057501cf000000ff0070008c00000000050020190000002107b0003900001c8f0000013d00000d800070009c000000a80000213d0000004008700039000000400080043f00000001080000390000000008870436000000f809500210000000000005004b00000d3f09006041000000000521034f000000000505043b00000d8d05500197000000000595019f0000000000580435000000400b00043d000000200440008a000000000541034f000000000505043b000000800050008c00001ce20000413d00000d420050009c000000000905001900000080099022700000000008000039000000100800203900000d240090009c00000008088021bf000000400990227000000ce70090009c00000004088021bf00000020099022700000ffff0090008c00000002088021bf0000001009902270000000ff0090008c0000000108802039000000210a80003900000db60aa001970000003f0ca0003900000db609c0019700000000099b00190000000000b9004b000000000c000039000000010c00403900000d240090009c000000a80000213d0000000100c00190000000a80000c13d000000400090043f000000020980003900000000099b043600000000000a004b000019fd0000613d000000000c21034f000000000aa90019000000000d09001900000000ce0c043c000000000ded04360000000000ad004b000019f90000c13d000000000a0b043300000000000a004b00001d210000613d000000000a09043300000d8d0aa00197000000f80c800210000000000aac019f00000d8e0aa0009a0000000000a904350000000308800210000000f80880008900000000058501cf000000ff0080008c00000000050020190000002108b0003900001cef0000013d00000d460090009c00001a130000613d00000d470090009c00001a130000613d00000d4a040000410000000005000019000000000a8700190000000002a2004b0000000009000039000000010900403900000000007a004b00000001099041bf00000ce7078001970002000000710355000000000171034f000000000003004b00001a3d0000c13d000000010090019000000a3d0000c13d000000c00360021000000d4b03300197000000000334019f00000ce70220019700000000012103df00020000003103b500000000013103af000080060200003900001a490000013d000000000007004b00001a330000613d00000ce7058001970002000000510355000000000087001a00000a3d0000413d0000000007870019000000000272004b00000a3d0000413d000000000151034f00000ce70220019700000000012103df000000c00260021000000d4b0220019700000d43022001c700020000002103b500000000012103af0000800902000039000000000500001900001a480000013d000000010090019000000a3d0000c13d00000ce70220019700000000012103df000000c00260021000000d4b0220019700000d43022001c700020000002103b500000000012103af0000800902000039000080060400003900000000060000193398338e0000040f0013000000010355000000600310027000010ce70030019d000000010020019000001ae40000613d000000150000006b000000b00000613d001900000000001d00001a580000013d00000019020000290000000102200039001900000002001d000000150020006c000000b00000813d000000800100043d0000001902000029000000000021004b00001d210000a13d0000000501200210000000a001100039001800000001001d000000000101043300000d2301100197000000000010043f00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b00001a530000613d000000800100043d0000001902000029000000000021004b000000140100002900001d210000a13d0000000001010433000000000021004b00001d210000a13d0000001803000029000000000103043300000d230210019700000003013000290000000001010433001700000001001d00000d36010000410000000000100443001800000002001d0000000400200443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d37011001c70000800202000039339833890000040f0000000100200190000023510000613d000000000101043b000000000001004b000006010000613d000000400b00043d00000d4c0100004100000000001b04350000000401b00039000000200200003900000000002104350000002402b0003900000017010000290000000031010434000000000012043500000db6051001970000001f0410018f000000440ab000390000000000a3004b00001aaf0000813d000000000005004b00001aaa0000613d000000000743001900000000064a0019000000200660008a000000200770008a0000000008560019000000000957001900000000090904330000000000980435000000200550008c00001aa40000c13d000000000004004b000000180200002900001ac60000613d00000000060a001900001abc0000013d00000000065a0019000000000005004b00001ab80000613d000000000703001900000000080a001900000000790704340000000008980436000000000068004b00001ab40000c13d000000000004004b000000180200002900001ac60000613d00000000035300190000000304400210000000000506043300000000054501cf000000000545022f00000000030304330000010004400089000000000343022f00000000034301cf000000000353019f00000000003604350000001f0310003900000db6033001970000000001a100190000000000010435000000440130003900000ce70010009c00000ce701008041000000600110021000000ce700b0009c00000ce70300004100000000030b40190000004003300210000000000131019f000000000300041400000ce70030009c00000ce703008041000000c003300210000000000131019f00180000000b001d339833840000040f000000600310027000010ce70030019d0013000000010355000000010020019000001f160000613d000000180200002900000d240020009c000000a80000213d000000400020043f00001a530000013d00000ce7023001970000001f0420018f00000d3b0320019800001aee0000613d000000000501034f0000000006000019000000005705043c0000000006760436000000000036004b00001aea0000c13d000000000004004b00001afb0000613d000000000131034f0000000304400210000000000503043300000000054501cf000000000545022f000000000101043b0000010004400089000000000141022f00000000014101cf000000000151019f000000000013043500000060012002100000339a0001043000000d5a01000041000002280000013d00000d5801000041000000000010043f000000180100002900000a740000013d00000d5801000041000000000010043f0000001801000029000005d80000013d00000d5a01000041000016770000013d00000ce7033001970000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00001b110000c13d00000a4e0000013d0000001809800029000000000008004b00001b1f0000613d000000000a060019000000180b00002900000000ac0a0434000000000bcb043600000000009b004b00001b1b0000c13d000000000007004b00001b2c0000613d00000000068600190000000307700210000000000809043300000000087801cf000000000878022f00000000060604330000010007700089000000000676022f00000000067601cf000000000686019f000000000069043500000018033000290000000000030435000000000505043300000db6075001970000001f0650018f000000000034004b00001b430000813d000000000007004b00001b3f0000613d00000000096400190000000008630019000000200880008a000000200990008a000000000a780019000000000b790019000000000b0b04330000000000ba0435000000200770008c00001b390000c13d000000000006004b000000000803001900001b4f0000c13d00001b590000013d0000000008730019000000000007004b00001b4c0000613d0000000009040019000000000a030019000000009b090434000000000aba043600000000008a004b00001b480000c13d000000000006004b00001b590000613d00000000047400190000000306600210000000000708043300000000076701cf000000000767022f00000000040404330000010006600089000000000464022f00000000046401cf000000000474019f00000000004804350000000003350019000000000003043500000016050000290000000003530049000000200430008a00000000004504350000001f0330003900000db6033001970000000004530019000000000034004b00000000030000390000000103004039001500000004001d00000d240040009c000000a80000213d0000000100300190000000a80000c13d0000001503000029000000400030043f00000d800030009c000000a80000213d00000004050000290000004403500039000000000331034f000000000303043b00000015070000290000004004700039000000400040043f000000200670003900000d8f04000041001300000006001d0000000000460435000000150400003900000000004704350000006003300210000000210470003900000000003404350000012403500039000000000431034f000000400500043d001400000005001d000000000404043b000000800040008c00001dcb0000413d00000d420040009c000000000604001900000080066022700000000005000039000000100500203900000d240060009c00000008055021bf000000400660227000000ce70060009c00000004055021bf00000020066022700000ffff0060008c00000002055021bf0000001006602270000000ff0060008c0000000105502039000000210650003900000db6076001970000003f0670003900000db6066001970000001406600029000000140060006c0000000008000039000000010800403900000d240060009c000000a80000213d0000000100800190000000a80000c13d000000400060043f000000020650003900000014080000290000000006680436000000000007004b00001bae0000613d000000000821034f00000000077600190000000009060019000000008a08043c0000000009a90436000000000079004b00001baa0000c13d00000014070000290000000007070433000000000007004b00001d210000613d000000000706043300000d8d07700197000000f808500210000000000778019f00000d8e0770009a00000000007604350000000305500210000000f80550008900000000045401cf000000ff0050008c00000000040020190000001405000029000000210550003900001dda0000013d0000001f0340018f00000d3b0240019800001bc90000613d000000000501034f0000000006000019000000005705043c0000000006760436000000000026004b00001bc50000c13d000000000003004b00001bd60000613d000000000121034f0000000303300210000000000502043300000000053501cf000000000535022f000000000101043b0000010003300089000000000131022f00000000013101cf000000000151019f000000000012043500000060014002100000339a0001043000000ce7033001970000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00001be00000c13d00000a4e0000013d000000190200002900000ce70020009c00000ce702008041000000400220021000000ce70010009c00000ce7010080410000006001100210000000000121019f0000339a0001043000000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b00001c250000c13d00000d3001000041000000000201041a001800000002001d00000d240020009c000000a80000213d00000018020000290000000102200039000000000021041b000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b00000018011000290000001902000029000000000021041b00000d3001000041000000000101041a001800000001001d000000000020043f00000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b0000001802000029000000000021041b00000d3601000041000000000010044300000019010000290000000400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d37011001c70000800202000039339833890000040f0000000100200190000023510000613d000000000101043b000000000001004b000006010000613d000000400300043d00000d5c01000041000000000013043500000004013000390000002002000039000000000021043500000024013000390000001602000029000000000021043500000db6042001980000001f0520018f001800000003001d0000004402300039000000000342001900000015060000290000002006600039000000120660036700001c4d0000613d000000000706034f0000000008020019000000007907043c0000000008980436000000000038004b00001c490000c13d000000000005004b00001c5a0000613d000000000446034f0000000305500210000000000603043300000000065601cf000000000656022f000000000404043b0000010005500089000000000454022f00000000045401cf000000000464019f000000000043043500000016040000290000001f0340003900000db60130019700000000024200190000000000020435000000440110003900000ce70010009c00000ce7010080410000006001100210000000180200002900000ce70020009c00000ce7020080410000004002200210000000000112019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f0000001902000029339833840000040f000000600310027000010ce70030019d0013000000010355000000010020019000001f860000613d000000180100002900000d240010009c000000a80000213d0000001801000029000000400010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf2011001c70000800d02000039000000020300003900000db004000041000007280000013d00000d8000b0009c000000a80000213d0000004007b00039000000400070043f000000010700003900000000077b0436000000f808500210000000000005004b00000d3f08006041000000000521034f000000000505043b00000d8d05500197000000000585019f0000000000570435000000400c00043d00000d8000c0009c000000a80000213d000000200540008a000000000551034f000000000505043b0000004007c00039000000400070043f0000002008c0003900000d8f07000041001800000008001d0000000000780435000000150700003900000000007c043500000060055002100000002107c000390000000000570435000000c004400039000000000441034f000000400900043d000000000404043b000000800040008c00001eef0000413d00000d420040009c000000000704001900000080077022700000000005000039000000100500203900000d240070009c00000008055021bf000000400770227000000ce70070009c00000004055021bf00000020077022700000ffff0070008c00000002055021bf0000001007702270000000ff0070008c0000000105502039000000210d50003900000db60dd001970000003f0ed0003900000db607e001970000000007790019000000000097004b000000000e000039000000010e00403900000d240070009c000000a80000213d0000000100e00190000000a80000c13d000000400070043f00000002075000390000000007790436001700000007001d00000000000d004b00001cd00000613d000000000e21034f000000170f000029000000000ddf001900000000e70e043c000000000f7f04360000000000df004b00001ccc0000c13d0000000007090433000000000007004b00001d210000613d0000001708000029000000000708043300000d8d07700197000000f80d50021000000000077d019f00000d8e0770009a00000000007804350000000305500210000000f80550008900000000045401cf000000ff0050008c00000000040020190000002105900039000000000045043500001efe0000013d00000d8000b0009c000000a80000213d0000004008b00039000000400080043f000000010800003900000000088b0436000000f809500210000000000005004b00000d3f09006041000000000521034f000000000505043b00000d8d05500197000000000595019f0000000000580435000000400c00043d000000400440008a000000000541034f000000000505043b000000800050008c00001ed50000413d00000d420050009c000000000905001900000080099022700000000008000039000000100800203900000d240090009c00000008088021bf000000400990227000000ce70090009c00000004088021bf00000020099022700000ffff0090008c00000002088021bf0000001009902270000000ff0090008c0000000108802039000000210a80003900000db60aa001970000003f0da0003900000db609d0019700000000099c00190000000000c9004b000000000d000039000000010d00403900000d240090009c000000a80000213d0000000100d00190000000a80000c13d000000400090043f000000020980003900000000099c043600000000000a004b00001d1e0000613d000000000d21034f000000000aa90019000000000e09001900000000df0d043c000000000efe04360000000000ae004b00001d1a0000c13d000000000a0c043300000000000a004b00001f230000c13d00000d8401000041000000000010043f0000003201000039000000040010043f00000d2b010000410000339a00010430000000400100043d001500000001001d000000200210003900000cf001000041001400000002001d000000000012043500000d7e0100004100000000001004430000000001000412000000040010044300000060010000390000002400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f0000000100200190000023510000613d000000000101043b00000015020000290000004002200039000000000012043500000d7e0100004100000000001004430000000001000412000000040010044300000080010000390000002400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f0000000100200190000023510000613d000000000101043b00000015020000290000006002200039000000000012043500000cee010000410000000000100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000cef011001c70000800b02000039339833890000040f0000000100200190000023510000613d000000000101043b0000001504000029000000a0024000390000000003000410000000000032043500000080024000390000000000120435000000a001000039000000000014043500000d6f0040009c000000a80000213d0000001502000029000000c001200039000000400010043f000000140100002900000ce70010009c00000ce7010080410000004001100210000000000202043300000ce70020009c00000ce7020080410000006002200210000000000112019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf2011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000400200043d00000022032000390000001604000029000000000043043500000d9e0300004100000000003204350000000203200039000000000013043500000ce70020009c00000ce7020080410000004001200210000000000200041400000ce70020009c00000ce702008041000000c002200210000000000121019f00000daa011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b001600000001001d0000001701000029000000000010043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b000000fd0000613d000000400500043d00000024015000390000004002000039000000000021043500000dab010000410000000000150435000000040150003900000016020000290000000000210435000000190100002900000000010104330000004402500039000000000012043500000db6041001970000001f0310018f001500000005001d0000006402500039000000180020006b000023520000813d000000000004004b00001dc70000613d00000018063000290000000005320019000000200550008a000000200660008a0000000007450019000000000846001900000000080804330000000000870435000000200440008c00001dc10000c13d000000000003004b000023690000613d00000000050200190000235e0000013d000000140500002900000d800050009c000000a80000213d00000014060000290000004005600039000000400050043f00000001050000390000000005560436000000f806400210000000000004004b00000d3f06006041000000000421034f000000000404043b00000d8d04400197000000000464019f0000000000450435000000190420006a000000a003300039000000000531034f000000000505043b0000001f0640008a00000d3f0460019700000d3f07500197000000000847013f000000000047004b000000000400001900000d3f04004041000000000065004b000000000700001900000d3f0700804100000d3f0080009c000000000407c019000000000004004b000006010000c13d0000001907500029000000000471034f000000000404043b00000d240040009c000006010000213d0000000008420049000000200770003900000d3f0980019700000d3f0a700197000000000b9a013f00000000009a004b000000000900001900000d3f09004041000000000087004b000000000800001900000d3f0800204100000d3f00b0009c000000000908c019000000000009004b000006010000c13d000000010040008c000022740000c13d000000000471034f000000000404043b00000d3f0040009c000022980000413d000000400400043d001200000004001d00000d800040009c000000a80000213d00000012070000290000004004700039000000400040043f0000000104000039000000000747043600000d9104000041001100000007001d0000000000470435000022ab0000013d000000400100043d000000440210003900000d9703000041000000000032043500000024021000390000001f0300003900000de70000013d00000014010000290000000001010433000000000001004b00001e360000613d00000d270010009c000006010000213d000000200010008c000006010000413d00000019010000290000000001010433000000000001004b0000000002000039000000010200c039000000000021004b000006010000c13d000000000001004b00001e360000c13d000000400100043d000000640210003900000d70030000410000000000320435000000440210003900000d7103000041000000000032043500000024021000390000002a030000390000060c0000013d000000400300043d001900000003001d00000024013000390000001602000029000000000021043500000d6801000041000000000013043500000004013000390000001502000029000000000021043500000ce70030009c00000ce70100004100000000010340190000004001100210000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000d32011001c70000001802000029339833890000040f000000600310027000000ce703300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000190b000029000000190570002900001e5c0000613d000000000801034f00000000090b0019000000008a08043c0000000009a90436000000000059004b00001e580000c13d000000000006004b00001e690000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f0000000000650435000100000003001f0013000000010355000000010020019000001ee30000613d0000001f01400039000000600210018f0000000001b20019000000000021004b0000000002000039000000010200403900000d240010009c000000a80000213d0000000100200190000000a80000c13d000000400010043f000000200030008c000006010000413d0000004403100039000000240410003900000000020b0433000000000002004b000020fb0000c13d000000200210003900000d6a05000041000000000052043500000016050000290000000000540435000000170400002900000000004304350000004403000039000000000031043500000d3c0010009c000000a80000213d0000008003100039001900000003001d000000400030043f00000d6f0010009c000000a80000213d000000c003100039000000400030043f000000200300003900000019040000290000000000340435000000a00310003900000d6b04000041000000000043043500000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000121019f0000001802000029339833840000040f0013000000010355000000600310027000010ce70030019d00000ce703300198000024040000c13d001700600000003d001600800000003d0000001701000029000000000101043300000001002001900000242e0000613d000000000001004b00001ec70000c13d00000d3601000041000000000010044300000018010000290000000400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d37011001c70000800202000039339833890000040f0000000100200190000023510000613d000000000101043b000000000001004b000015160000613d00000017010000290000000001010433000000000001004b000000b00000613d00000d270010009c000006010000213d000000200010008c000006010000413d00000016010000290000000001010433000000000001004b0000000002000039000000010200c039000000000021004b000006010000c13d000000000001004b000000b00000c13d00001e2c0000013d00000d8000c0009c000000a80000213d0000004008c00039000000400080043f000000010800003900000000088c0436000000f809500210000000000005004b00000d3f09006041000000000521034f000000000505043b00000d8d05500197000000000595019f00001f2f0000013d0000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00001eea0000c13d00000a4e0000013d00000d800090009c000000a80000213d0000004005900039000000400050043f00000001050000390000000007590436000000f805400210000000000004004b00000d3f05006041000000000421034f000000000404043b00000d8d04400197000000000454019f001700000007001d000000000047043500000000ed03043400000db603d001970000001f0fd0018f000000400400043d001500000004001d001600200040003d0000001600e0006c00001f930000813d000000000003004b00001f120000613d0000000005fe00190000001604f00029000000200440008a000000200550008a0000000007340019000000000835001900000000080804330000000000870435000000200330008c00001f0c0000c13d00000000000f004b00001fa90000613d000000160400002900001f9f0000013d00000ce7033001970000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00001f1e0000c13d00000a4e0000013d000000000a09043300000d8d0aa00197000000f80d800210000000000aad019f00000d8e0aa0009a0000000000a904350000000308800210000000f80880008900000000058501cf000000ff0080008c00000000050020190000002108c000390000000000580435000000400d00043d00000d8000d0009c000000a80000213d000000200540008a000000000551034f000000000505043b0000004008d00039000000400080043f0000002009d0003900000d8f08000041001700000009001d0000000000890435000000150800003900000000008d043500000060055002100000002108d000390000000000580435000000c004400039000000000441034f000000400500043d001800000005001d000000000404043b000000800040008c00001fc00000413d00000d420040009c000000000804001900000080088022700000000005000039000000100500203900000d240080009c00000008055021bf000000400880227000000ce70080009c00000004055021bf00000020088022700000ffff0080008c00000002055021bf0000001008802270000000ff0080008c0000000105502039000000210950003900000db60e9001970000003f09e0003900000db6089001970000001808800029000000180080006c0000000009000039000000010900403900000d240080009c000000a80000213d0000000100900190000000a80000c13d000000400080043f000000020850003900000018090000290000000008890436001600000008001d00000000000e004b00001f720000613d000000000f21034f0000001608000029000000000ee8001900000000f90f043c00000000089804360000000000e8004b00001f6e0000c13d00000018080000290000000008080433000000000008004b00001d210000613d000000160a00002900000000080a043300000d8d08800197000000f809500210000000000889019f00000d8e0880009a00000000008a04350000000305500210000000f80550008900000000045401cf000000ff0050008c000000000400201900000018050000290000002105500039000000000045043500001fd10000013d00000ce7033001970000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00001f8e0000c13d00000a4e0000013d0000001604300029000000000003004b00001f9c0000613d00000000050e0019000000160700002900000000580504340000000007870436000000000047004b00001f980000c13d00000000000f004b00001fa90000613d000000000e3e00190000000303f00210000000000504043300000000053501cf000000000535022f00000000070e04330000010003300089000000000737022f00000000033701cf000000000353019f0000000000340435000000160dd0002900000000000d043500000000e606043400000db6036001970000001f0f60018f0000000000de004b00001fe90000813d000000000003004b00001fbc0000613d0000000005fe00190000000004fd0019000000200440008a000000200550008a0000000007340019000000000835001900000000080804330000000000870435000000200330008c00001fb60000c13d00000000000f004b00001fff0000613d00000000040d001900001ff50000013d000000180500002900000d800050009c000000a80000213d00000018080000290000004005800039000000400050043f00000001050000390000000008580436000000f805400210000000000004004b00000d3f05006041000000000421034f000000000404043b00000d8d04400197000000000454019f001600000008001d000000000048043500000000fe03043400000db604e001970000001f03e0018f000000400500043d001400000005001d001500200050003d0000001500f0006c000021070000813d000000000004004b00001fe50000613d00000000083f00190000001505300029000000200550008a000000200880008a0000000009450019000000000a480019000000000a0a04330000000000a90435000000200440008c00001fdf0000c13d000000000003004b0000211d0000613d0000001505000029000021130000013d00000000043d0019000000000003004b00001ff20000613d00000000050e001900000000070d001900000000580504340000000007870436000000000047004b00001fee0000c13d00000000000f004b00001fff0000613d000000000e3e00190000000303f00210000000000504043300000000053501cf000000000535022f00000000070e04330000010003300089000000000737022f00000000033701cf000000000353019f00000000003404350000000006d60019000000000006043500000000da0a043400000db603a001970000001f0ea0018f00000000006d004b000020160000813d000000000003004b000020120000613d0000000005ed00190000000004e60019000000200440008a000000200550008a0000000007340019000000000835001900000000080804330000000000870435000000200330008c0000200c0000c13d00000000000e004b0000202c0000613d0000000004060019000020220000013d0000000004360019000000000003004b0000201f0000613d00000000050d0019000000000706001900000000580504340000000007870436000000000047004b0000201b0000c13d00000000000e004b0000202c0000613d000000000d3d00190000000303e00210000000000504043300000000053501cf000000000535022f00000000070d04330000010003300089000000000737022f00000000033701cf000000000353019f000000000034043500000000066a0019000000000006043500000000ba0b043400000db603a001970000001f0da0018f00000000006b004b000020430000813d000000000003004b0000203f0000613d0000000005db00190000000004d60019000000200440008a000000200550008a0000000007340019000000000835001900000000080804330000000000870435000000200330008c000020390000c13d00000000000d004b000020590000613d00000000040600190000204f0000013d0000000004360019000000000003004b0000204c0000613d00000000050b0019000000000706001900000000580504340000000007870436000000000047004b000020480000c13d00000000000d004b000020590000613d000000000b3b00190000000303d00210000000000504043300000000053501cf000000000535022f00000000070b04330000010003300089000000000737022f00000000033701cf000000000353019f000000000034043500000000066a00190000000000060435000000000a0c043300000db603a001970000001f0ba0018f000000180060006b000020700000813d000000000003004b0000206c0000613d0000001805b000290000000004b60019000000200440008a000000200550008a0000000007340019000000000835001900000000080804330000000000870435000000200330008c000020660000c13d00000000000b004b000020870000613d00000000040600190000207c0000013d0000000004360019000000000003004b000020790000613d0000001805000029000000000706001900000000580504340000000007870436000000000047004b000020750000c13d00000000000b004b000020870000613d001800180030002d0000000303b00210000000000504043300000000053501cf000000000535022f000000180700002900000000070704330000010003300089000000000737022f00000000033701cf000000000353019f000000000034043500000000066a00190000000000060435000000000809043300000db6038001970000001f0980018f000000170060006b0000209e0000813d000000000003004b0000209a0000613d00000017059000290000000004960019000000200440008a000000200550008a0000000007340019000000000a350019000000000a0a04330000000000a70435000000200330008c000020940000c13d000000000009004b0000000004060019000020aa0000c13d000020b50000013d0000000004360019000000000003004b000020a70000613d00000017050000290000000007060019000000005a0504340000000007a70436000000000047004b000020a30000c13d000000000009004b000020b50000613d001700170030002d0000000303900210000000000504043300000000053501cf000000000535022f000000170700002900000000070704330000010003300089000000000737022f00000000033701cf000000000353019f00000000003404350000000003680019000000000003043500000015050000290000000003530049000000200430008a00000000004504350000001f0330003900000db603300197000000000a53001900000000003a004b0000000003000039000000010300403900000d2400a0009c000000a80000213d0000000100300190000000a80000c13d0000004000a0043f00000004030000290000000004320049000001c403300039000000000331034f000000000303043b000000230440008a00000d3f0540019700000d3f06300197000000000756013f000000000056004b000000000500001900000d3f05004041000000000043004b000000000400001900000d3f0400804100000d3f0070009c000000000504c019000000000005004b000006010000c13d0000001903300029000000000431034f000000000604043b00000d240060009c000006010000213d0000000004620049000000200730003900000d3f0340019700000d3f05700197000000000835013f000000000035004b000000000300001900000d3f03004041000000000047004b000000000400001900000d3f0400204100000d3f0080009c000000000304c019000000000003004b000006010000c13d000000010060008c000023bf0000c13d000000000371034f000000000303043b00000d3f0030009c0000243c0000413d00000d8000a0009c000000a80000213d0000004003a00039000000400030043f0000000103000039000000000c3a043600000d91030000410000244b0000013d00000cf50200004100000000002104350000000402100039000000200500003900000000005204350000003602000039000000000024043500000d6d020000410000000000230435000000640210003900000d6e03000041000006110000013d0000001505400029000000000004004b000021100000613d00000000080f00190000001509000029000000008a0804340000000009a90436000000000059004b0000210c0000c13d000000000003004b0000211d0000613d000000000f4f00190000000303300210000000000405043300000000043401cf000000000434022f00000000080f04330000010003300089000000000838022f00000000033801cf000000000343019f0000000000350435000000150ee0002900000000000e043500000000f606043400000db6046001970000001f0360018f0000000000ef004b000021340000813d000000000004004b000021300000613d00000000083f001900000000053e0019000000200550008a000000200880008a0000000009450019000000000a480019000000000a0a04330000000000a90435000000200440008c0000212a0000c13d000000000003004b0000214a0000613d00000000050e0019000021400000013d00000000054e0019000000000004004b0000213d0000613d00000000080f001900000000090e0019000000008a0804340000000009a90436000000000059004b000021390000c13d000000000003004b0000214a0000613d000000000f4f00190000000303300210000000000405043300000000043401cf000000000434022f00000000080f04330000010003300089000000000838022f00000000033801cf000000000343019f00000000003504350000000006e60019000000000006043500000000e707043400000db6047001970000001f0370018f00000000006e004b000021610000813d000000000004004b0000215d0000613d00000000083e00190000000005360019000000200550008a000000200880008a0000000009450019000000000a480019000000000a0a04330000000000a90435000000200440008c000021570000c13d000000000003004b000021770000613d00000000050600190000216d0000013d0000000005460019000000000004004b0000216a0000613d00000000080e00190000000009060019000000008a0804340000000009a90436000000000059004b000021660000c13d000000000003004b000021770000613d000000000e4e00190000000303300210000000000405043300000000043401cf000000000434022f00000000080e04330000010003300089000000000838022f00000000033801cf000000000343019f00000000003504350000000006670019000000000006043500000000b70b043400000db6047001970000001f0370018f00000000006b004b0000218e0000813d000000000004004b0000218a0000613d00000000083b00190000000005360019000000200550008a000000200880008a0000000009450019000000000a480019000000000a0a04330000000000a90435000000200440008c000021840000c13d000000000003004b000021a40000613d00000000050600190000219a0000013d0000000005460019000000000004004b000021970000613d00000000080b00190000000009060019000000008a0804340000000009a90436000000000059004b000021930000c13d000000000003004b000021a40000613d000000000b4b00190000000303300210000000000405043300000000043401cf000000000434022f00000000080b04330000010003300089000000000838022f00000000033801cf000000000343019f00000000003504350000000006670019000000000006043500000000b70c043400000db6047001970000001f0370018f00000000006b004b000021bb0000813d000000000004004b000021b70000613d00000000083b00190000000005360019000000200550008a000000200880008a0000000009450019000000000a480019000000000a0a04330000000000a90435000000200440008c000021b10000c13d000000000003004b000021d10000613d0000000005060019000021c70000013d0000000005460019000000000004004b000021c40000613d00000000080b00190000000009060019000000008a0804340000000009a90436000000000059004b000021c00000c13d000000000003004b000021d10000613d000000000b4b00190000000303300210000000000405043300000000043401cf000000000434022f00000000080b04330000010003300089000000000838022f00000000033801cf000000000343019f00000000003504350000000006670019000000000006043500000000070d043300000db6047001970000001f0370018f000000170060006b000021e80000813d000000000004004b000021e40000613d00000017083000290000000005360019000000200550008a000000200880008a0000000009450019000000000a480019000000000a0a04330000000000a90435000000200440008c000021de0000c13d000000000003004b000021ff0000613d0000000005060019000021f40000013d0000000005460019000000000004004b000021f10000613d00000017080000290000000009060019000000008a0804340000000009a90436000000000059004b000021ed0000c13d000000000003004b000021ff0000613d001700170040002d0000000303300210000000000405043300000000043401cf000000000434022f000000170800002900000000080804330000010003300089000000000838022f00000000033801cf000000000343019f0000000000350435000000000667001900000000000604350000001803000029000000000703043300000db6047001970000001f0370018f000000160060006b000022170000813d000000000004004b000022130000613d00000016083000290000000005360019000000200550008a000000200880008a0000000009450019000000000a480019000000000a0a04330000000000a90435000000200440008c0000220d0000c13d000000000003004b0000000005060019000022230000c13d0000222e0000013d0000000005460019000000000004004b000022200000613d00000016080000290000000009060019000000008a0804340000000009a90436000000000059004b0000221c0000c13d000000000003004b0000222e0000613d001600160040002d0000000303300210000000000405043300000000043401cf000000000434022f000000160800002900000000080804330000010003300089000000000838022f00000000033801cf000000000343019f00000000003504350000000003670019000000000003043500000014050000290000000003530049000000200430008a00000000004504350000001f0330003900000db603300197000000000a53001900000000003a004b0000000003000039000000010300403900000d2400a0009c000000a80000213d0000000100300190000000a80000c13d0000004000a0043f00000004030000290000000004320049000001c403300039000000000331034f000000000303043b000000230440008a00000d3f0540019700000d3f06300197000000000756013f000000000056004b000000000500001900000d3f05004041000000000043004b000000000400001900000d3f0400804100000d3f0070009c000000000504c019000000000005004b000006010000c13d0000001903300029000000000431034f000000000604043b00000d240060009c000006010000213d0000000004620049000000200730003900000d3f0340019700000d3f05700197000000000835013f000000000035004b000000000300001900000d3f03004041000000000047004b000000000400001900000d3f0400204100000d3f0080009c000000000304c019000000000003004b000006010000c13d000000010060008c0000247e0000c13d000000000371034f000000000303043b00000d3f0030009c000025160000413d00000d8000a0009c000000a80000213d0000004003a00039000000400030043f0000000103000039000000000c3a043600000d9103000041000025250000013d000000400700043d001200000007001d000000380040008c0000229b0000413d000000120700002900000d800070009c000000a80000213d000000120b0000290000004007b00039000000400070043f00000ce70040009c00000000070400190000002007702270000000000800003900000004080020390000ffff0070008c00000002088021bf0000001007702270000000ff0070008c00000001088021bf000000000721034f0000000209800039000000000a9b0436000000000707043b00000d8d07700197000000f809800210000000000779019f00000d90077001c700110000000a001d00000000007a04350000000307800210000000f80770015f00000000047401cf0000002107b000390000000000470435000022ab0000013d001200600000003d001100800000003d000022ab0000013d000000120700002900000d800070009c000000a80000213d00000012080000290000004007800039000000400070043f00000001070000390000000008780436000000000721034f000000000707043b00000d8d07700197000000f804400210000000000447019f00000d3f044001c7001100000008001d0000000000480435000000800330008a000000000331034f000000000303043b000000000003004b000023070000c13d0000006004000039001000800000003d000000000065004b000000000700001900000d3f0700804100000d3f0660019700000d3f08500197000000000968013f000000000068004b000000000600001900000d3f0600404100000d3f0090009c000000000607c019000000000006004b000006010000c13d0000001706000029000000009a0604340000001606000029000000000b0604330000001506000029000000000c0604330000001406000029000000003d060434000f00000003001d0000001206000029000000000e0604330000001905500029000000000651034f000000000606043b00000d240060009c000006010000213d000000000f620049000000200350003900000d3f05f0019700000d3f08300197000000000758013f000000000058004b000000000500001900000d3f05004041000e00000003001d0000000000f3004b000000000800001900000d3f0800204100000d3f0070009c000000000508c019000000000005004b000006010000c13d0000000005ab00190000000005c500190000000005d500190000000005e50019000000000565001900000000070404330000000005750019000000400c00043d00000d2405500197000000380050008c000024f20000413d00000d8000c0009c000000a80000213d0000004007c00039000000400070043f00000ce70050009c00000000070500190000002007702270000000000800003900000004080020390000ffff0070008c00000002088021bf0000001007702270000000ff0070008c00000001088021bf000000000221034f000000020a800039000000000bac0436000000000202043b00000d8d02200197000000f807800210000000000227019f00000d94022001c700000000002b04350000000302800210000000f80220015f00000000022501cf0000002105c000390000000000250435000024ff0000013d00000cee010000410000000000100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000cef011001c70000800b02000039339833890000040f0000000100200190000023510000613d000000400300043d000000000401043b000000800040008c000023de0000413d00000d420040009c000000000104001900000080011022700000000007000039000000100700203900000d240010009c00000008077021bf000000400110227000000ce70010009c00000004077021bf00000020011022700000ffff0010008c00000002077021bf0000001001102270000000ff0010008c0000000107702039000000210170003900000db6061001970000003f0160003900000db6011001970000000001130019000000000031004b0000000002000039000000010200403900000d240010009c000000a80000213d0000000100200190000000a80000c13d000000400010043f0000000201700039000000000513043600000012010003670000000002000031000000000006004b000023400000613d0000000006650019000000000821034f0000000009050019000000008a08043c0000000009a90436000000000069004b0000233c0000c13d0000000006030433000000000006004b00001d210000613d000000000805043300000d8d08800197000000f809700210000000000889019f00000d8e0880009a00000000008504350000000307700210000000f80770008900000000047401cf000000ff0070008c000000000400201900000021033000390000000000430435000023ee0000013d000000000001042f0000000005420019000000000004004b0000235b0000613d0000001806000029000000000702001900000000680604340000000007870436000000000057004b000023570000c13d000000000003004b000023690000613d001800180040002d0000000303300210000000000405043300000000043401cf000000000434022f000000180600002900000000060604330000010003300089000000000636022f00000000033601cf000000000343019f00000000003504350000001f0310003900000db60330019700000000012100190000000000010435000000640130003900000ce70010009c00000ce7010080410000006001100210000000150200002900000ce70020009c00000ce7020080410000004002200210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f0000001702000029339833890000040f000000600310027000000ce703300197000000200030008c000000200400003900000000040340190000001f0640018f000000200740019000000015057000290000238c0000613d000000000801034f0000001509000029000000008a08043c0000000009a90436000000000059004b000023880000c13d000000000006004b000023990000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f0000000000650435000100000003001f00130000000103550000000100200190000023b30000613d0000001f01400039000000600210018f0000001501200029000000000021004b0000000002000039000000010200403900000d240010009c000000a80000213d0000000100200190000000a80000c13d000000400010043f000000200030008c000006010000413d00000015010000290000000001010433000000000001004b0000000002000039000000010200c039000000000021004b000006010000c13d00000dac0200004100000a200000013d0000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b000023ba0000c13d00000a4e0000013d000000380060008c0000243f0000413d00000d8000a0009c000000a80000213d0000004003a00039000000400030043f00000ce70060009c00000000030600190000002003302270000000000400003900000004040020390000ffff0030008c00000002044021bf0000001003302270000000ff0030008c00000001044021bf000000000321034f0000000205400039000000000c5a0436000000000303043b00000d8d03300197000000f805400210000000000335019f00000d90033001c700000000003c04350000000303400210000000f80330015f00000000033601cf0000002104a0003900000000003404350000244c0000013d00000d800030009c000000a80000213d0000004001300039000000400010043f000000f807400210000000000004004b00000d3f070060410000000106000039000000000563043600000000020000310000001201000367000000000321034f000000000303043b00000d8d03300197000000000373019f000000000035043500000db6086001970000001f0760018f000000400400043d001000200040003d000000100050006c0000249d0000813d000000000008004b000024000000613d000000000a7500190000001009700029000000200990008a000000200aa0008a000000000b890019000000000c8a0019000000000c0c04330000000000cb0435000000200880008c000023fa0000c13d000000000007004b0000001009000029000024a90000c13d000024b30000013d0000001f0430003900000d40044001970000003f0440003900000d6c04400197000000400500043d0000000004450019001700000005001d000000000054004b0000000005000039000000010500403900000d240040009c000000a80000213d0000000100500190000000a80000c13d000000400040043f0000001f0430018f0000001705000029000000000635043600000d3b05300198001600000006001d0000000003560019000024200000613d000000000601034f0000001607000029000000006806043c0000000007870436000000000037004b0000241c0000c13d000000000004004b00001ead0000613d000000000151034f0000000304400210000000000503043300000000054501cf000000000545022f000000000101043b0000010004400089000000000141022f00000000014101cf000000000151019f000000000013043500001ead0000013d000000000001004b000024f00000c13d000000400300043d001800000003001d00000cf50100004100000000001304350000000401300039000000200200003900000000002104350000002402300039000000190100002933982e020000040f00000018020000290000196c0000013d000000600a000039000000800c0000390000244c0000013d00000d8000a0009c000000a80000213d0000004003a00039000000400030043f0000000103000039000000000c3a0436000000000321034f000000000303043b00000d8d03300197000000f804600210000000000343019f00000d3f033001c700000000003c0435000000400b00043d00000d8000b0009c000000a80000213d0000004003b00039000000400030043f000000010400003900000000054b0436000000000221034f000000000202043b00000d8d0220019700000d92032001c7001800000005001d000000000035043500000015030000290000000003030433000000000336001900000000050a04330000000003530019000000400900043d000000010330003900000d2403300197000000380030008c000024cb0000413d00000d800090009c000000a80000213d00000ce70030009c00000000040300190000002004402270000000000500003900000004050020390000ffff0040008c00000002055021bf00000010044022700000004008900039000000400080043f000000ff0040008c00000001055021bf000000f804500210000000000224019f00000d94022001c7000000200d90003900000000002d04350000000302500210000000f80220015f00000000022301cf0000002103900039000000000023043500000002025000390000000000290435000024d40000013d000000380060008c000025190000413d00000d8000a0009c000000a80000213d0000004003a00039000000400030043f00000ce70060009c00000000030600190000002003302270000000000400003900000004040020390000ffff0030008c00000002044021bf0000001003302270000000ff0030008c00000001044021bf000000000321034f0000000205400039000000000c5a0436000000000303043b00000d8d03300197000000f805400210000000000335019f00000d90033001c700000000003c04350000000303400210000000f80330015f00000000033601cf0000002104a000390000000000340435000025260000013d0000001009800029000000000008004b000024a60000613d000000000a050019000000100b00002900000000ac0a0434000000000bcb043600000000009b004b000024a20000c13d000000000007004b000024b30000613d00000000058500190000000307700210000000000809043300000000087801cf000000000878022f00000000050504330000010007700089000000000575022f00000000057501cf000000000585019f0000000000590435000000100560002900000da006000041000000000065043500000000054500490000001e0650008a0000000000640435000000210550003900000db6065001970000000005460019000000000065004b0000000006000039000000010600403900000d240050009c000000a80000213d0000000100600190000000a80000c13d0000000407000029000001c406700039000000400050043f000000000561034f0000000006720049000000230660008a000000000505043b000022b20000013d00000d800090009c000000a80000213d0000004005900039000000400050043f000000000d490436000000f803300210000000000223019f00000d930220009a00000000002d0435000000400400043d000000200240003900000d9503000041001400000002001d0000000000320435000000000e09043300000db603e001970000001f09e0018f001700000004001d000000210840003900000000008d004b000025580000813d000000000003004b000024ec0000613d00000000059d00190000000004980019000000200440008a000000200550008a000000000f3400190000000002350019000000000202043300000000002f0435000000200330008c000024e60000c13d000000000009004b0000000004080019000025640000c13d0000256e0000013d000000160200002900001be60000013d00000d8000c0009c000000a80000213d0000004007c00039000000400070043f000000000221034f000000010a000039000000000bac0436000000000202043b00000d8d02200197000000f805500210000000000225019f00000d930220009a00000000002b043500000db60da001970000001f0ca0018f000000400200043d000d00000002001d000000200220003900000000002b004b000026540000813d00000000000d004b000025120000613d0000000005cb00190000000007c20019000000200e70008a000000200f50008a0000000005de00190000000007df001900000000070704330000000000750435000000200dd0008c0000250c0000c13d00000000000c004b000000000e020019000026600000c13d0000266a0000013d000000600a000039000000800c000039000025260000013d00000d8000a0009c000000a80000213d0000004003a00039000000400030043f0000000103000039000000000c3a0436000000000321034f000000000303043b00000d8d03300197000000f804600210000000000343019f00000d3f033001c700000000003c0435000000400b00043d00000d8000b0009c000000a80000213d0000004003b00039000000400030043f000000010500003900000000045b0436000000000221034f000000000202043b00000d8d0220019700000d92032001c7001800000004001d000000000034043500000014030000290000000003030433000000000336001900000000040a04330000000004430019000000400300043d000000010440003900000d2404400197000000380040008c0000262f0000413d00000d800030009c000000a80000213d00000ce70040009c00000000050400190000002005502270000000000800003900000004080020390000ffff0050008c00000002088021bf00000010055022700000004009300039000000400090043f000000ff0050008c00000001088021bf000000f805800210000000000225019f00000d94022001c7000000200d30003900000000002d04350000000302800210000000f80220015f00000000022401cf0000002104300039000000000024043500000002028000390000000000230435000026380000013d0000000004380019000000000003004b000025610000613d00000000050d0019000000000f0800190000000052050434000000000f2f043600000000004f004b0000255d0000c13d000000000009004b0000256e0000613d000000000d3d00190000000302900210000000000304043300000000032301cf000000000323022f00000000050d04330000010002200089000000000525022f00000000022501cf000000000232019f0000000000240435000000000d8e001900000000000d04350000001502000029000000000502043300000db6035001970000001f0e50018f0000001600d0006b000025860000813d000000000003004b000025820000613d0000001602e000290000000004ed0019000000200440008a000000200920008a0000000002340019000000000839001900000000080804330000000000820435000000200330008c0000257c0000c13d00000000000e004b0000259d0000613d00000000040d0019000025920000013d00000000043d0019000000000003004b0000258f0000613d000000160900002900000000080d001900000000920904340000000008280436000000000048004b0000258b0000c13d00000000000e004b0000259d0000613d001600160030002d0000000302e00210000000000304043300000000032301cf000000000323022f000000160800002900000000080804330000010002200089000000000828022f00000000022801cf000000000232019f00000000002404350000000004d50019000000000004043500000000050a043300000db6035001970000001f0a50018f00000000004c004b000025b40000813d000000000003004b000025b00000613d0000000002ac00190000000008a40019000000200980008a000000200d20008a000000000239001900000000083d001900000000080804330000000000820435000000200330008c000025aa0000c13d00000000000a004b000025ca0000613d0000000009040019000025c00000013d0000000009340019000000000003004b000025bd0000613d000000000d0c0019000000000804001900000000d20d04340000000008280436000000000098004b000025b90000c13d00000000000a004b000025ca0000613d000000000c3c00190000000302a00210000000000309043300000000032301cf000000000323022f00000000080c04330000010002200089000000000828022f00000000022801cf000000000232019f0000000000290435000000000771034f000000000145001900000db6046001980000001f0560018f00000000000104350000000003410019000025d70000613d000000000907034f0000000008010019000000009209043c0000000008280436000000000038004b000025d30000c13d000000000005004b000025e40000613d000000000247034f0000000304500210000000000503043300000000054501cf000000000545022f000000000202043b0000010004400089000000000242022f00000000024201cf000000000252019f00000000002304350000000001610019000000000001043500000000040b043300000db6034001970000001f0540018f000000180010006b000025fb0000813d000000000003004b000025f70000613d00000018025000290000000006510019000000200660008a000000200720008a0000000002360019000000000837001900000000080804330000000000820435000000200330008c000025f10000c13d000000000005004b000026120000613d0000000006010019000026070000013d0000000006310019000000000003004b000026040000613d0000001807000029000000000801001900000000720704340000000008280436000000000068004b000026000000c13d000000000005004b000026120000613d001800180030002d0000000302500210000000000306043300000000032301cf000000000323022f000000180500002900000000050504330000010002200089000000000525022f00000000022501cf000000000232019f00000000002604350000000001140019000000000001043500000017030000290000000001310049000000200210008a00000000002304350000001f0110003900000db6021001970000000001320019000000000021004b0000000003000039000000010300403900000d240010009c000000a80000213d0000000100300190000000a80000c13d000000400010043f000000140100002900000ce70010009c00000ce70100804100000040011002100000001702000029000000000202043300000ce70020009c00000ce7020080410000006002200210000000000112019f0000000002000414000028a60000013d00000d800030009c000000a80000213d0000004008300039000000400080043f000000000d530436000000f804400210000000000224019f00000d930220009a00000000002d0435000000400500043d000000200250003900000cf204000041001600000002001d0000000000420435000000000e03043300000db604e001970000001f03e0018f001700000005001d000000210850003900000000008d004b000027d00000813d000000000004004b000026500000613d00000000093d00190000000005380019000000200550008a000000200990008a000000000f4500190000000002490019000000000202043300000000002f0435000000200440008c0000264a0000c13d000000000003004b0000000005080019000027dc0000c13d000027e60000013d000000000ed2001900000000000d004b0000265d0000613d000000000f0b0019000000000502001900000000f70f043400000000057504360000000000e5004b000026590000c13d00000000000c004b0000266a0000613d000000000bdb00190000000305c0021000000000070e043300000000075701cf000000000757022f00000000080b04330000010005500089000000000858022f00000000055801cf000000000575019f00000000005e0435000000000aa2001900000000000a04350000001705000029000000000b05043300000db60db001970000001f0cb0018f0000000000a9004b000026820000813d00000000000d004b0000267e0000613d0000000005c900190000000007ca0019000000200e70008a000000200f50008a0000000005de00190000000007df001900000000070704330000000000750435000000200dd0008c000026780000c13d00000000000c004b000026980000613d000000000e0a00190000268e0000013d000000000eda001900000000000d004b0000268b0000613d000000000f09001900000000050a001900000000f70f043400000000057504360000000000e5004b000026870000c13d00000000000c004b000026980000613d0000000009d900190000000305c0021000000000070e043300000000075701cf000000000757022f00000000080904330000010005500089000000000858022f00000000055801cf000000000575019f00000000005e04350000000009ab001900000000000904350000001605000029000000000a05043300000db60ca001970000001f0ba0018f000000180090006b000026b00000813d00000000000c004b000026ac0000613d0000001805b000290000000007b90019000000200d70008a000000200e50008a0000000005cd00190000000007ce001900000000070704330000000000750435000000200cc0008c000026a60000c13d00000000000b004b000026c70000613d000000000d090019000026bc0000013d000000000dc9001900000000000c004b000026b90000613d000000180e000029000000000509001900000000e70e043400000000057504360000000000d5004b000026b50000c13d00000000000b004b000026c70000613d0018001800c0002d0000000305b0021000000000070d043300000000075701cf000000000757022f000000180800002900000000080804330000010005500089000000000858022f00000000055801cf000000000575019f00000000005d043500000000099a001900000000000904350000001505000029000000000a05043300000db60ca001970000001f0ba0018f000000130090006b000026df0000813d00000000000c004b000026db0000613d0000001305b000290000000007b90019000000200d70008a000000200e50008a0000000005cd00190000000007ce001900000000070704330000000000750435000000200cc0008c000026d50000c13d00000000000b004b000026f60000613d000000000d090019000026eb0000013d000000000dc9001900000000000c004b000026e80000613d000000130e000029000000000509001900000000e70e043400000000057504360000000000d5004b000026e40000c13d00000000000b004b000026f60000613d0013001300c0002d0000000305b0021000000000070d043300000000075701cf000000000757022f000000130800002900000000080804330000010005500089000000000858022f00000000055801cf000000000575019f00000000005d043500000000099a001900000000000904350000001405000029000000000a05043300000db60ca001970000001f0ba0018f0000000f0090006b0000270e0000813d00000000000c004b0000270a0000613d0000000f05b000290000000007b90019000000200d70008a000000200e50008a0000000005cd00190000000007ce001900000000070704330000000000750435000000200cc0008c000027040000c13d00000000000b004b000027250000613d000000000d0900190000271a0000013d000000000dc9001900000000000c004b000027170000613d0000000f0e000029000000000509001900000000e70e043400000000057504360000000000d5004b000027130000c13d00000000000b004b000027250000613d000f000f00c0002d0000000305b0021000000000070d043300000000075701cf000000000757022f0000000f0300002900000000080304330000010005500089000000000858022f00000000055801cf000000000575019f00000000005d043500000000089a001900000000000804350000001205000029000000000905043300000db60b9001970000001f0a90018f000000110080006b0000273d0000813d00000000000b004b000027390000613d0000001105a000290000000007a80019000000200c70008a000000200d50008a0000000005bc00190000000007bd001900000000070704330000000000750435000000200bb0008c000027330000c13d00000000000a004b000027540000613d000000000c080019000027490000013d000000000cb8001900000000000b004b000027460000613d000000110d000029000000000508001900000000d70d043400000000057504360000000000c5004b000027420000c13d00000000000a004b000027540000613d0011001100b0002d0000000305a0021000000000070c043300000000075701cf000000000757022f000000110a000029000000000a0a04330000010005500089000000000a5a022f00000000055a01cf000000000575019f00000000005c04350000000e0a100360000000000189001900000db6086001980000001f0960018f00000000000104350000000007810019000027610000613d000000000b0a034f000000000501001900000000bc0b043c0000000005c50436000000000075004b0000275d0000c13d000000000009004b0000276e0000613d00000000058a034f0000000308900210000000000907043300000000098901cf000000000989022f000000000505043b0000010008800089000000000585022f00000000058501cf000000000595019f000000000057043500000000016100190000000000010435000000000404043300000db6074001970000001f0640018f000000100010006b000027850000813d000000000007004b000027810000613d00000010056000290000000008610019000000200880008a000000200950008a0000000005780019000000000a790019000000000a0a04330000000000a50435000000200770008c0000277b0000c13d000000000006004b0000279c0000613d0000000008010019000027910000013d0000000008710019000000000007004b0000278e0000613d00000010090000290000000005010019000000009a0904340000000005a50436000000000085004b0000278a0000c13d000000000006004b0000279c0000613d001000100070002d0000000305600210000000000608043300000000065601cf000000000656022f000000100300002900000000030304330000010005500089000000000353022f00000000035301cf000000000363019f0000000000380435000000000114001900000000000104350000000d040000290000000001410049000000200310008a00000000003404350000001f0110003900000db6031001970000000001430019000000000031004b0000000003000039000000010300403900000d240010009c000000a80000213d0000000100300190000000a80000c13d000000400010043f00000ce70020009c00000ce70200804100000040012002100000000d02000029000000000202043300000ce70020009c00000ce7020080410000006002200210000000000112019f0000000002000414000028a60000013d0000001f0430018f00000d3b02300198000027c10000613d000000000501034f0000000006000019000000005705043c0000000006760436000000000026004b000027bd0000c13d000000000004004b000027ce0000613d000000000121034f0000000304400210000000000502043300000000054501cf000000000545022f000000000101043b0000010004400089000000000141022f00000000014101cf000000000151019f000000000012043500000060013002100000339a000104300000000005480019000000000004004b000027d90000613d00000000090d0019000000000f0800190000000092090434000000000f2f043600000000005f004b000027d50000c13d000000000003004b000027e60000613d000000000d4d00190000000302300210000000000305043300000000032301cf000000000323022f00000000040d04330000010002200089000000000424022f00000000022401cf000000000232019f0000000000250435000000000d8e001900000000000d04350000001402000029000000000502043300000db6045001970000001f0350018f0000001500d0006b000027fe0000813d000000000004004b000027fa0000613d000000150230002900000000083d0019000000200e80008a000000200920008a00000000024e0019000000000849001900000000080804330000000000820435000000200440008c000027f40000c13d000000000003004b000028150000613d000000000e0d00190000280a0000013d000000000e4d0019000000000004004b000028070000613d000000150900002900000000080d0019000000009209043400000000082804360000000000e8004b000028030000c13d000000000003004b000028150000613d001500150040002d000000030230021000000000030e043300000000032301cf000000000323022f000000150400002900000000040404330000010002200089000000000424022f00000000022401cf000000000232019f00000000002e04350000000004d50019000000000004043500000000050a043300000db60a5001970000001f0350018f00000000004c004b0000282c0000813d00000000000a004b000028280000613d00000000023c00190000000008340019000000200d80008a000000200920008a0000000002ad00190000000008a9001900000000080804330000000000820435000000200aa0008c000028220000c13d000000000003004b000028420000613d000000000d040019000028380000013d000000000da4001900000000000a004b000028350000613d00000000090c00190000000008040019000000009209043400000000082804360000000000d8004b000028310000c13d000000000003004b000028420000613d000000000cac0019000000030230021000000000030d043300000000032301cf000000000323022f00000000080c04330000010002200089000000000828022f00000000022801cf000000000232019f00000000002d0435000000000771034f000000000145001900000db6046001980000001f0560018f000000000001043500000000034100190000284f0000613d000000000907034f0000000008010019000000009209043c0000000008280436000000000038004b0000284b0000c13d000000000005004b0000285c0000613d000000000247034f0000000304500210000000000503043300000000054501cf000000000545022f000000000202043b0000010004400089000000000242022f00000000024201cf000000000252019f00000000002304350000000001610019000000000001043500000000040b043300000db6054001970000001f0340018f000000180010006b000028730000813d000000000005004b0000286f0000613d00000018023000290000000006310019000000200660008a000000200720008a0000000002560019000000000857001900000000080804330000000000820435000000200550008c000028690000c13d000000000003004b0000288a0000613d00000000060100190000287f0000013d0000000006510019000000000005004b0000287c0000613d0000001807000029000000000801001900000000720704340000000008280436000000000068004b000028780000c13d000000000003004b0000288a0000613d001800180050002d0000000302300210000000000306043300000000032301cf000000000323022f000000180500002900000000050504330000010002200089000000000525022f00000000022501cf000000000232019f00000000002604350000000001140019000000000001043500000017030000290000000001310049000000200210008a00000000002304350000001f0110003900000db6021001970000000001320019000000000021004b0000000003000039000000010300403900000d240010009c000000a80000213d0000000100300190000000a80000c13d000000400010043f000000160100002900000ce70010009c00000ce70100804100000040011002100000001702000029000000000202043300000ce70020009c00000ce7020080410000006002200210000000000112019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf2011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b001500000001001d00000d3002000041000000000102041a001400000001001d000000000001004b000029490000c13d0000000402000029001801e40020003d00000012030003670000001801300360000000000101043b00000000040000310000000002240049000000230220008a00000d3f0520019700000d3f06100197000000000756013f000000000056004b000000000500001900000d3f05004041000000000021004b000000000200001900000d3f0200804100000d3f0070009c000000000502c019000000000005004b000006010000c13d0000001905100029000000000153034f000000000201043b00000d240020009c000006010000213d0000000001240049000000200650003900000d3f0710019700000d3f08600197000000000978013f000000000078004b000000000700001900000d3f07004041000000000016004b000000000100001900000d3f0100204100000d3f0090009c000000000701c019000000000007004b000006010000c13d000000400100043d000000410020008c00002b030000c13d00000d3c0010009c000000a80000213d0000008002100039000000400020043f000000410200003900000000022104360000006105500039000000000045004b000006010000213d000000000463034f0000006003100039000000000504034f0000000006020019000000005705043c0000000006760436000000000036004b000028ef0000c13d0000004005200039000000000605043300000d8d066001970000004004400370000000000404043b00000da504400197000000000464019f0000000000450435000000610410003900000000000404350000004001100039000000000101043300000da60010009c000000fd0000213d00000000030304330000000002020433000000400400043d0000006005400039000000000015043500000040014000390000000000210435000000f8013002700000002002400039000000000012043500000015010000290000000000140435000000000000043f00000ce70040009c00000ce7040080410000004001400210000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000da7011001c70000000102000039339833890000040f000000600310027000000ce703300197000000200030008c000000200400003900000000040340190000001f0540018f0000002004400190000029270000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b000029230000c13d000000000005004b000029340000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f0000000000540435000100000003001f0013000000010355000000010020019000002b710000613d000000000100043d00000d2301100198000000fd0000613d000000000010043f00000d5f01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d00000da40200004100000a1e0000013d0000001901000029000502400010003d000602200010003d000702000010003d000801e00010003d001301c00010003d001201400010003d001101200010003d001001000010003d000f00e00010003d000e00c00010003d000d00a00010003d000c00800010003d000b00600010003d000a00400010003d000900200010003d0000000003000019000000000102041a000000000013004b00001d210000813d000000000020043f001600000003001d00000da10130009a000000000201041a000000400100043d000000440310003900000040040000390000000000430435000000200410003900000da203000041001700000004001d000000000034043500000024041000390000001503000029000000000034043500000012040003670000001905400360000000000605043b0000006403100039001800000003001d00000000006304350000000906400360000000000606043b000000840710003900000000006704350000000a06400360000000000606043b000000a40710003900000000006704350000000b06400360000000000606043b000000c40710003900000000006704350000000c06400360000000000606043b000000e40710003900000000006704350000000d06400360000000000606043b000001040710003900000000006704350000000e06400360000000000606043b000001240710003900000000006704350000000f06400360000000000606043b000001440710003900000000006704350000001006400360000000000606043b000001640710003900000000006704350000001106400360000000000606043b000001840710003900000000006704350000022409100039000001a40610003900000d23022001970000001207400360000000007807043c0000000006860436000000000096004b0000299a0000c13d0000001306400360000000000a06043b0000000006000031000000190760006a0000001f0770008a00000d3f0870019700000d3f0ba00197000000000c8b013f00000000008b004b000000000b00001900000d3f0b00404100000000007a004b000000000d00001900000d3f0d00804100000d3f00c0009c000000000b0dc01900000000000b004b000006010000c13d000000190ba00029000000000ab4034f000000000a0a043b00000d2400a0009c000006010000213d000000200bb00039000000000ca600490000000000cb004b000000000d00001900000d3f0d00204100000d3f0cc0019700000d3f0eb00197000000000fce013f0000000000ce004b000000000c00001900000d3f0c00404100000d3f00f0009c000000000c0dc01900000000000c004b000006010000c13d00000260030000390000000000390435000002c4091000390000000000a90435000000000cb4034f00000db60da00198000002e40b1000390000000009db0019000029d30000613d000000000e0c034f000000000f0b001900000000e30e043c000000000f3f043600000000009f004b000029cf0000c13d0000001f0ea00190000029e00000613d0000000003dc034f000000030ce00210000000000d090433000000000dcd01cf000000000dcd022f000000000303043b000001000cc000890000000003c3022f0000000003c301cf0000000003d3019f00000000003904350000000003ba001900000000000304350000000803400360000000000903043b00000d3f03900197000000000c83013f000000000083004b000000000300001900000d3f03004041000000000079004b000000000d00001900000d3f0d00804100000d3f00c0009c00000000030dc019000000000003004b000006010000c13d000000190c9000290000000003c4034f000000000903043b00000d240090009c000006010000213d000000200cc00039000000000396004900000000003c004b000000000d00001900000d3f0d00204100000d3f0330019700000d3f0ec00197000000000f3e013f00000000003e004b000000000300001900000d3f0300404100000d3f00f0009c00000000030dc019000000000003004b000006010000c13d0000001f03a0003900000db6033001970000000003b30019000000180a30006a000002440b1000390000000000ab0435000000000cc4034f000000000a93043600000db60d900198000000000bda001900002a150000613d000000000e0c034f000000000f0a001900000000e30e043c000000000f3f04360000000000bf004b00002a110000c13d0000001f0e90019000002a220000613d0000000003dc034f000000030ce00210000000000d0b0433000000000dcd01cf000000000dcd022f000000000303043b000001000cc000890000000003c3022f0000000003c301cf0000000003d3019f00000000003b04350000000003a9001900000000000304350000000703400360000000000b03043b00000d3f03b00197000000000c83013f000000000083004b000000000300001900000d3f0300404100000000007b004b000000000d00001900000d3f0d00804100000d3f00c0009c00000000030dc019000000000003004b000006010000c13d000000190bb000290000000003b4034f000000000d03043b00000d2400d0009c000006010000213d000000200cb00039000000050bd002100000000003b6004900000000003c004b000000000e00001900000d3f0e00204100000d3f0330019700000d3f0fc0019700000000053f013f00000000003f004b000000000300001900000d3f0300404100000d3f0050009c00000000030ec019000000000003004b000006010000c13d0000001f0390003900000db6033001970000000003a30019000000180530006a000002640910003900000000005904350000000009d30436000000000ab9001900000000000b004b00002a560000613d000000000cc4034f00000000c30c043c00000000093904360000000000a9004b00002a520000c13d0000001f00b001900000000603400360000000000903043b00000d3f03900197000000000583013f000000000083004b000000000300001900000d3f03004041000000000079004b000000000b00001900000d3f0b00804100000d3f0050009c00000000030bc019000000000003004b000006010000c13d000000190b9000290000000003b4034f000000000903043b00000d240090009c000006010000213d000000200bb00039000000000396004900000000003b004b000000000500001900000d3f0500204100000d3f0330019700000d3f0cb00197000000000d3c013f00000000003c004b000000000300001900000d3f0300404100000d3f00d0009c000000000305c019000000000003004b000006010000c13d0000001803a0006a00000284051000390000000000350435000000000cb4034f000000000a9a043600000db60d900198000000000bda001900002a870000613d000000000e0c034f000000000f0a001900000000e30e043c000000000f3f04360000000000bf004b00002a830000c13d0000001f0e90019000002a940000613d0000000003dc034f0000000305e00210000000000c0b0433000000000c5c01cf000000000c5c022f000000000303043b0000010005500089000000000353022f00000000035301cf0000000003c3019f00000000003b04350000000003a9001900000000000304350000000503400360000000000b03043b00000d3f03b00197000000000583013f000000000083004b000000000300001900000d3f0300404100000000007b004b000000000700001900000d3f0700804100000d3f0050009c000000000307c019000000000003004b000006010000c13d0000001908b00029000000000384034f000000000703043b00000d240070009c000006010000213d00000020088000390000000003760049000000000038004b000000000500001900000d3f0500204100000d3f0330019700000d3f06800197000000000b36013f000000000036004b000000000300001900000d3f0300404100000d3f00b0009c000000000305c019000000000003004b000006010000c13d0000001f0390003900000db6033001970000000003a30019000000180530006a000002a4061000390000000000560435000000000684034f000000000473043600000db608700198000000000584001900002ac90000613d000000000906034f000000000a040019000000009309043c000000000a3a043600000000005a004b00002ac50000c13d0000001f0970019000002ad60000613d000000000386034f0000000306900210000000000805043300000000086801cf000000000868022f000000000303043b0000010006600089000000000363022f00000000036301cf000000000383019f00000000003504350000000003470019000000000003043500000000031400490000001f0470003900000db6044001970000000003340019000000200430008a00000000004104350000001f0330003900000db6033001970000000004130019000000000034004b0000000005000039000000010500403900000d240040009c000000a80000213d0000000100500190000000a80000c13d000000400040043f000000170300002900000ce70030009c00000ce7030080410000004003300210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000131019f000000000300041400000ce70030009c00000ce703008041000000c003300210000000000131019f339833840000040f000000600310027000010ce70030019d00130000000103550000000100200190000000fd0000613d00000016030000290000000103300039000000140030006c00000d30020000410000295a0000413d000028b60000013d0000001f0520003900000db6055001970000003f0550003900000db6055001970000000005510019000000000015004b0000000007000039000000010700403900000d240050009c000000a80000213d0000000100700190000000a80000c13d000000400050043f00000000052104360000000007620019000000000047004b000006010000213d000000000463034f00000db6062001980000001f0720018f000000000365001900002b1f0000613d000000000804034f0000000009050019000000008a08043c0000000009a90436000000000039004b00002b1b0000c13d000000000007004b00002b2c0000613d000000000464034f0000000306700210000000000703043300000000076701cf000000000767022f000000000404043b0000010006600089000000000464022f00000000046401cf000000000474019f000000000043043500000000022500190000000000020435000000000201043300000d270020009c000006010000213d000000400020008c000006010000413d000000000305043300000d240030009c000006010000213d0000000004130019000000000552001900000d3f025001970000003f0340003900000d3f06300197000000000726013f000000000026004b000000000200001900000d3f02004041000000000053004b000000000300001900000d3f0300804100000d3f0070009c000000000203c019000000000002004b000006010000c13d0000002002400039000000000202043300000d240020009c000000a80000213d0000001f0320003900000db6033001970000003f0330003900000db606300197000000400300043d0000000006630019000000000036004b0000000007000039000000010700403900000d240060009c000000a80000213d0000000100700190000000a80000c13d000000400060043f000000000323043600000040044000390000000006420019000000000056004b000006010000213d00000db6062001970000001f0520018f000000000034004b00002b7d0000813d000000000006004b00002b6d0000613d00000000085400190000000007530019000000200770008a000000200880008a0000000009670019000000000a680019000000000a0a04330000000000a90435000000200660008c00002b670000c13d000000000005004b00002b930000613d000000000703001900002b890000013d0000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00002b780000c13d00000a4e0000013d0000000007630019000000000006004b00002b860000613d00000000080400190000000009030019000000008a0804340000000009a90436000000000079004b00002b820000c13d000000000005004b00002b930000613d00000000046400190000000305500210000000000607043300000000065601cf000000000656022f00000000040404330000010005500089000000000454022f00000000045401cf000000000464019f00000000004704350000000002230019000000000002043500000040011000390000000001010433001700000001001d00000d230010009c000006010000213d0000001701000029000000000010043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000006010000613d000000000101043b000000000101041a000000000001004b000000fd0000613d000000400700043d00000024017000390000004002000039000000000021043500000da301000041000000000017043500000004017000390000001502000029000000000021043500000012010003670000001905000029000000000251034f000000000302043b000000440270003900000000003204350000002003500039000000000331034f000000000303043b000000640470003900000000003404350000004003500039000000000331034f000000000303043b000000840470003900000000003404350000006003500039000000000331034f000000000303043b000000a40470003900000000003404350000008003500039000000000331034f000000000303043b000000c4047000390000000000340435000000a003500039000000000331034f000000000303043b000000e4047000390000000000340435000000c003500039000000000331034f000000000303043b00000104047000390000000000340435000000e003500039000000000331034f000000000303043b000001240470003900000000003404350000010003500039000000000331034f000000000303043b000001440470003900000000003404350000012003500039000000000331034f000000000303043b000001640470003900000000003404350000020406700039001600000007001d00000184047000390000014003500039000000000531034f000000005705043c0000000004740436000000000064004b00002bec0000c13d0000008003300039000000000331034f000000000703043b0000000003000031000000190430006a0000001f0440008a00000d3f0540019700000d3f08700197000000000958013f000000000058004b000000000800001900000d3f08004041000000000047004b000000000a00001900000d3f0a00804100000d3f0090009c00000000080ac019000000000008004b000006010000c13d0000001908700029000000000781034f000000000707043b00000d240070009c000006010000213d00000020088000390000000009730049000000000098004b000000000a00001900000d3f0a00204100000d3f0990019700000d3f0b800197000000000c9b013f00000000009b004b000000000900001900000d3f0900404100000d3f00c0009c00000000090ac019000000000009004b000006010000c13d00000260090000390000000000960435000000160c000029000002a406c000390000000000760435000000000981034f00000db60a7001980000001f0b70018f000002c408c000390000000006a8001900002c280000613d000000000c09034f000000000d08001900000000ce0c043c000000000ded043600000000006d004b00002c240000c13d00000000000b004b00002c350000613d0000000009a9034f000000030ab00210000000000b060433000000000bab01cf000000000bab022f000000000909043b000001000aa000890000000009a9022f0000000009a901cf0000000009b9019f0000000000960435000000000687001900000000000604350000001806100360000000000606043b00000d3f09600197000000000a59013f000000000059004b000000000900001900000d3f09004041000000000046004b000000000b00001900000d3f0b00804100000d3f00a0009c00000000090bc019000000000009004b000006010000c13d0000001909600029000000000691034f000000000606043b00000d240060009c000006010000213d0000002009900039000000000a6300490000000000a9004b000000000b00001900000d3f0b00204100000d3f0aa0019700000d3f0c900197000000000dac013f0000000000ac004b000000000a00001900000d3f0a00404100000d3f00d0009c000000000a0bc01900000000000a004b000006010000c13d0000001f0770003900000db60770019700000000078700190000000008270049000000160a000029000002240aa0003900000000008a0435000000000991034f000000000767043600000db60a6001980000001f0b60018f0000000008a7001900002c6c0000613d000000000c09034f000000000d07001900000000ce0c043c000000000ded043600000000008d004b00002c680000c13d00000000000b004b00002c790000613d0000000009a9034f000000030ab00210000000000b080433000000000bab01cf000000000bab022f000000000909043b000001000aa000890000000009a9022f0000000009a901cf0000000009b9019f00000000009804350000000008760019000000000008043500000004080000290000020408800039000000000981034f000000000909043b00000d3f0a900197000000000b5a013f00000000005a004b000000000a00001900000d3f0a004041000000000049004b000000000c00001900000d3f0c00804100000d3f00b0009c000000000a0cc01900000000000a004b000006010000c13d000000190a9000290000000009a1034f000000000909043b00000d240090009c000006010000213d000000200aa00039000000050b900210000000000cb300490000000000ca004b000000000d00001900000d3f0d00204100000d3f0cc0019700000d3f0ea00197000000000fce013f0000000000ce004b000000000c00001900000d3f0c00404100000d3f00f0009c000000000c0dc01900000000000c004b000006010000c13d0000001f0660003900000db60660019700000000067600190000000007260049000000160c000029000002440cc0003900000000007c043500000000079604360000001f06b0018f0000000009b7001900000000000b004b00002cb10000613d000000000aa1034f00000000ab0a043c0000000007b70436000000000097004b00002cad0000c13d000000000006004b0000002007800039000000000671034f000000000606043b00000d3f08600197000000000a58013f000000000058004b000000000800001900000d3f08004041000000000046004b000000000b00001900000d3f0b00804100000d3f00a0009c00000000080bc019000000000008004b000006010000c13d0000001908600029000000000681034f000000000606043b00000d240060009c000006010000213d0000002008800039000000000a6300490000000000a8004b000000000b00001900000d3f0b00204100000d3f0aa0019700000d3f0c800197000000000dac013f0000000000ac004b000000000a00001900000d3f0a00404100000d3f00d0009c000000000a0bc01900000000000a004b000006010000c13d000000000a290049000000160b000029000002640bb000390000000000ab0435000000000a81034f000000000869043600000db60b6001980000001f0c60018f0000000009b8001900002ce50000613d000000000d0a034f000000000e08001900000000df0d043c000000000efe043600000000009e004b00002ce10000c13d00000000000c004b00002cf20000613d000000000aba034f000000030bc00210000000000c090433000000000cbc01cf000000000cbc022f000000000a0a043b000001000bb00089000000000aba022f000000000aba01cf000000000aca019f0000000000a90435000000000986001900000000000904350000002007700039000000000771034f000000000707043b00000d3f09700197000000000a59013f000000000059004b000000000500001900000d3f05004041000000000047004b000000000400001900000d3f0400804100000d3f00a0009c000000000504c019000000000005004b000006010000c13d0000001905700029000000000451034f000000000404043b00000d240040009c000006010000213d00000020055000390000000003430049000000000035004b000000000700001900000d3f0700204100000d3f0330019700000d3f09500197000000000a39013f000000000039004b000000000300001900000d3f0300404100000d3f00a0009c000000000307c019000000000003004b000006010000c13d0000001f0360003900000db60330019700000000068300190000000002260049000000160300002900000284033000390000000000230435000000000351034f000000000146043600000db6054001980000001f0640018f000000000251001900002d2a0000613d000000000703034f0000000008010019000000007907043c0000000008980436000000000028004b00002d260000c13d000000000006004b00002d370000613d000000000353034f0000000305600210000000000602043300000000065601cf000000000656022f000000000303043b0000010005500089000000000353022f00000000035301cf000000000363019f0000000000320435000000000214001900000000000204350000001f0240003900000db60220019700000016030000290000000001310049000000000121001900000ce70010009c00000ce701008041000000600110021000000ce70030009c00000ce70200004100000000020340190000004002200210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f0000001702000029339833840000040f000000600310027000000ce703300197000000200030008c000000200400003900000000040340190000001f0640018f0000002007400190000000160570002900002d5c0000613d000000000801034f0000001609000029000000008a08043c0000000009a90436000000000059004b00002d580000c13d000000000006004b00002d690000613d000000000771034f0000000306600210000000000805043300000000086801cf000000000868022f000000000707043b0000010006600089000000000767022f00000000066701cf000000000686019f0000000000650435000100000003001f0013000000010355000000010020019000002d830000613d0000001f01400039000000600210018f0000001601200029000000000021004b0000000002000039000000010200403900000d240010009c000000a80000213d0000000100200190000000a80000c13d000000400010043f000000200030008c000006010000413d00000016010000290000000001010433000000000001004b0000000002000039000000010200c039000000000021004b000006010000c13d00000da40200004100000a200000013d0000001f0530018f00000d3b06300198000000400200043d000000000462001900000a4e0000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b00002d8a0000c13d00000a4e0000013d0000001f03100039000000000023004b000000000400001900000d3f0400404100000d3f0520019700000d3f03300197000000000653013f000000000053004b000000000300001900000d3f0300204100000d3f0060009c000000000304c019000000000003004b00002da60000613d0000001203100367000000000303043b00000d240030009c00002da60000213d00000000013100190000002001100039000000000021004b00002da60000213d000000000001042d00000000010000190000339a000104300000001f0220003900000db6022001970000000001120019000000000021004b0000000002000039000000010200403900000d240010009c00002db40000213d000000010020019000002db40000c13d000000400010043f000000000001042d00000d8401000041000000000010043f0000004101000039000000040010043f00000d2b010000410000339a0001043000000db90020009c00002dea0000813d00000000040100190000001f0120003900000db6011001970000003f0110003900000db605100197000000400100043d0000000005510019000000000015004b0000000007000039000000010700403900000d240050009c00002dea0000213d000000010070019000002dea0000c13d000000400050043f00000000052104360000000007420019000000000037004b00002df00000213d00000db6062001980000001f0720018f0000001204400367000000000365001900002dda0000613d000000000804034f0000000009050019000000008a08043c0000000009a90436000000000039004b00002dd60000c13d000000000007004b00002de70000613d000000000464034f0000000306700210000000000703043300000000076701cf000000000767022f000000000404043b0000010006600089000000000464022f00000000046401cf000000000474019f000000000043043500000000022500190000000000020435000000000001042d00000d8401000041000000000010043f0000004101000039000000040010043f00000d2b010000410000339a0001043000000000010000190000339a0001043000000020030000390000000004310436000000000302043300000000003404350000004001100039000000000003004b00002e010000613d00000000040000190000002002200039000000000502043300000d230550019700000000015104360000000104400039000000000034004b00002dfa0000413d000000000001042d0000000043010434000000000132043600000db6063001970000001f0530018f000000000014004b00002e180000813d000000000006004b00002e140000613d00000000085400190000000007510019000000200770008a000000200880008a0000000009670019000000000a680019000000000a0a04330000000000a90435000000200660008c00002e0e0000c13d000000000005004b00002e2e0000613d000000000701001900002e240000013d0000000007610019000000000006004b00002e210000613d00000000080400190000000009010019000000008a0804340000000009a90436000000000079004b00002e1d0000c13d000000000005004b00002e2e0000613d00000000046400190000000305500210000000000607043300000000065601cf000000000656022f00000000040404330000010005500089000000000454022f00000000045401cf000000000464019f0000000000470435000000000431001900000000000404350000001f0330003900000db6023001970000000001210019000000000001042d000000000323043600000db6062001980000001f0720018f0000000005630019000000120110036700002e400000613d000000000801034f0000000009030019000000008a08043c0000000009a90436000000000059004b00002e3c0000c13d000000000007004b00002e4d0000613d000000000161034f0000000306700210000000000705043300000000076701cf000000000767022f000000000101043b0000010006600089000000000161022f00000000016101cf000000000171019f0000000000150435000000000123001900000000000104350000001f0120003900000db6011001970000000001130019000000000001042d000400000000000200000d2301100197000400000001001d000000000010043f000000000002004b00002ec20000613d00000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f000000010020019000002f410000613d000000000101043b000000000201041a000000000002004b00002f490000613d00000d3001000041000000000101041a000000000001004b00002f430000613d000000000021004b000300000002001d00002eaa0000613d000200000001001d00000d3001000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f000000010020019000002f410000613d00000003020000290001000100200092000000000101043b00000d3002000041000000000202041a000000010020006c00002f510000a13d0000000202000029000000010220008a0000000001120019000000000101041a000200000001001d00000d3001000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f000000010020019000002f410000613d000000000101043b00000001011000290000000202000029000000000021041b000000000020043f00000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f000000010020019000002f410000613d000000000101043b0000000302000029000000000021041b00000d3001000041000000000101041a000300000001001d000000000001004b00002f570000613d00000d3001000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f000000010020019000002f410000613d0000000302000029000000010220008a000000000101043b0000000001210019000000000001041b00000d3001000041000000000021041b0000000401000029000000000010043f00000d2e01000041000000200010043f000000000100041400002f2a0000013d00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f000000010020019000002f410000613d000000000101043b000000000201041a000000000002004b00002f5d0000613d00000d3401000041000000000101041a000000000001004b00002f430000613d000000000021004b000300000002001d00002f130000613d000200000001001d00000d3401000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f000000010020019000002f410000613d00000003020000290001000100200092000000000101043b00000d3402000041000000000202041a000000010020006c00002f510000a13d0000000202000029000000010220008a0000000001120019000000000101041a000200000001001d00000d3401000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f000000010020019000002f410000613d000000000101043b00000001011000290000000202000029000000000021041b000000000020043f00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f000000010020019000002f410000613d000000000101043b0000000302000029000000000021041b00000d3401000041000000000101041a000300000001001d000000000001004b00002f570000613d00000d3401000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f000000010020019000002f410000613d0000000302000029000000010220008a000000000101043b0000000001210019000000000001041b00000d3401000041000000000021041b0000000401000029000000000010043f00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f000000010020019000002f410000613d000000000101043b000000000001041b000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf2011001c70000800d02000039000000020300003900000d35040000410000000405000029339833840000040f000000010020019000002f410000613d000000000001042d00000000010000190000339a0001043000000d8401000041000000000010043f0000001101000039000000040010043f00000d2b010000410000339a0001043000000d3101000041000000000010043f0000000401000029000000040010043f0000000101000039000000240010043f00000d32010000410000339a0001043000000d8401000041000000000010043f0000003201000039000000040010043f00000d2b010000410000339a0001043000000d8401000041000000000010043f0000003101000039000000040010043f00000d2b010000410000339a0001043000000d3101000041000000000010043f0000000401000029000000040010043f000000240000043f00000d32010000410000339a0001043000010000000000020000000004010019000000400100043d00000dba0010009c00002f830000813d0000000005010019000100000001001d0000002001100039000000400010043f0000000000050435000000200130003900000ce70010009c00000ce7010080410000004001100210000000000303043300000ce70030009c00000ce7030080410000006003300210000000000113019f00000ce70020009c00000ce702008041000000c002200210000000000121019f0000000002040019339833840000040f000000600210027000010ce70020019d001300000001035500000001010000290000000000010435000000000001042d00000d8401000041000000000010043f0000004101000039000000040010043f00000d2b010000410000339a000104300000000002010433000000400100043d00000040031000390000000000230435000000200210003900000d890300004100000000003204350000004003000039000000000031043500000dbb0010009c00002faa0000813d0000006003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf2011001c70000801002000039339833890000040f000000010020019000002fb00000613d000000000101043b000000000001042d00000d8401000041000000000010043f0000004101000039000000040010043f00000d2b010000410000339a0001043000000000010000190000339a000104300003000000000002000200000001001d00000d7e0100004100000000001004430000000001000412000000040010044300000040010000390000002400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f0000000100200190000030660000613d000000000101043b00000d23011001970000000002000410000000000012004b00002ff60000c13d00000d7e0100004100000000001004430000000001000412000000040010044300000020010000390000002400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f0000000100200190000030660000613d000000000101043b000300000001001d00000cee010000410000000000100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000cef011001c70000800b02000039339833890000040f0000000100200190000030660000613d000000000101043b000000030010006c00002ff60000c13d00000d7e010000410000000000100443000000000100041200000004001004430000002400000443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f00000001002001900000304e0000c13d000030660000013d000000400100043d000300000001001d000000200210003900000cf001000041000100000002001d000000000012043500000d7e0100004100000000001004430000000001000412000000040010044300000060010000390000002400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f0000000100200190000030660000613d000000000101043b00000003020000290000004002200039000000000012043500000d7e0100004100000000001004430000000001000412000000040010044300000080010000390000002400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d7f011001c70000800502000039339833890000040f0000000100200190000030660000613d000000000101043b00000003020000290000006002200039000000000012043500000cee010000410000000000100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000cef011001c70000800b02000039339833890000040f0000000100200190000030660000613d000000000101043b0000000304000029000000a0024000390000000003000410000000000032043500000080024000390000000000120435000000a001000039000000000014043500000cf10040009c000030690000813d0000000302000029000000c001200039000000400010043f000000010100002900000ce70010009c00000ce7010080410000004001100210000000000202043300000ce70020009c00000ce7020080410000006002200210000000000112019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf2011001c70000801002000039339833890000040f0000000100200190000030670000613d000000000101043b000000400200043d00000022032000390000000204000029000000000043043500000d9e0300004100000000003204350000000203200039000000000013043500000ce70020009c00000ce7020080410000004001200210000000000200041400000ce70020009c00000ce702008041000000c002200210000000000121019f00000daa011001c70000801002000039339833890000040f0000000100200190000030670000613d000000000101043b000000000001042d000000000001042f00000000010000190000339a0001043000000d8401000041000000000010043f0000004101000039000000040010043f00000d2b010000410000339a00010430000200000000000200000d2301100197000200000001001d000000000010043f00000d5f01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000030b60000613d000000000101043b000000000101041a000000000001004b000030b80000c13d00000d6101000041000000000201041a00000db90020009c000030be0000813d000100000002001d0000000102200039000000000021041b000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000030b60000613d000000000101043b00000001011000290000000202000029000000000021041b00000d6101000041000000000101041a000100000001001d000000000020043f00000d5f01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000030b60000613d000000000101043b0000000102000029000000000021041b000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf2011001c70000800d02000039000000020300003900000d62040000410000000205000029339833840000040f0000000100200190000030b60000613d000000000001042d00000000010000190000339a0001043000000d6001000041000000000010043f0000000201000029000000040010043f00000d2b010000410000339a0001043000000d8401000041000000000010043f0000004101000039000000040010043f00000d2b010000410000339a000104300005000000000002000100000002001d000400000001001d000000400100043d000300000001001d00000dbb0010009c0000326f0000813d00000003030000290000006001300039000000400010043f0000000202000039000000000323043600000000020000310000001202200367000200000003001d000000002402043c0000000003430436000000000013004b000030d30000c13d00000d5401000041000000020200002900000000001204350000000301000029000000400110003900000d55020000410000000000210435000000400100043d000000200210003900000d56030000410000000000320435000000240410003900000000003404350000002403000039000000000031043500000d530010009c0000326f0000213d0000006003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f00000d57011001c70000000402000029339833890000040f000000600310027000000ce703300197000000200030008c000000200400003900000000040340190000001f0540018f0000002004400190000031030000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b000030ff0000c13d000000000005004b000031100000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f0000000000540435000100000003001f00130000000103550000000100200190000032750000613d000000200030008c000032750000413d000000000100043d000000000001004b000032750000613d000000400100043d000000200210003900000d56030000410000000000320435000000240310003900000d440400004100000000004304350000002403000039000000000031043500000d530010009c0000326f0000213d0000006003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f00000d57011001c70000000402000029339833890000040f000000600310027000000ce703300197000000200030008c000000200400003900000000040340190000001f0540018f00000020044001900000313f0000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b0000313b0000c13d000000000005004b0000314c0000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f00000000005404350013000000010355000100000003001f0000001f0030008c00000000010000390000000101002039000000000112016f000000010010008c000031570000c13d000000000100043d000000000001004b000032750000c13d00000003010000290000000001010433000000000001004b000031a30000613d0000000002000019000500000002001d000000050120021000000002011000290000000003010433000000400100043d000000200210003900000d5604000041000000000042043500000d4403300197000000240410003900000000003404350000002403000039000000000031043500000d530010009c0000326f0000213d0000006003100039000000400030043f00000ce70020009c00000ce7020080410000004002200210000000000101043300000ce70010009c00000ce7010080410000006001100210000000000121019f00000d57011001c70000000402000029339833890000040f000000600310027000000ce703300197000000200030008c000000200500003900000000050340190000002004500190000031850000613d000000000601034f0000000007000019000000006806043c0000000007870436000000000047004b000031810000c13d0000001f05500190000031920000613d000000000641034f0000000305500210000000000704043300000000075701cf000000000757022f000000000606043b0000010005500089000000000656022f00000000055601cf000000000575019f00000000005404350013000000010355000100000003001f0000001f0030008c00000000010000390000000101002039000000000112016f000000010010008c000032750000c13d000000000100043d000000000001004b000032750000613d0000000502000029000000010220003900000003010000290000000001010433000000000012004b0000315c0000413d000000040100002900000d2301100197000500000001001d000000000010043f00000d2e01000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f00000001002001900000327c0000613d000000000101043b000000000101041a000000000001004b0000327e0000c13d0000000501000029000000000010043f00000d3301000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f00000001002001900000327c0000613d000000000101043b000000000101041a000000000001004b000032860000c13d0000000501000029000000000010043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f00000001002001900000327c0000613d000000000101043b000000000101041a000000000001004b0000328d0000c13d00000d5b01000041000000000201041a00000d240020009c0000326f0000213d000400000002001d0000000102200039000000000021041b000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f00000001002001900000327c0000613d000000000101043b00000004011000290000000502000029000000000021041b00000d5b01000041000000000101041a000400000001001d000000000020043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f00000001002001900000327c0000613d000000000101043b0000000402000029000000000021041b00000d3601000041000000000010044300000005010000290000000400100443000000000100041400000ce70010009c00000ce701008041000000c00110021000000d37011001c70000800202000039339833890000040f0000000100200190000032930000613d000000000101043b000000000001004b0000327c0000613d000000400b00043d00000d5c0100004100000000001b04350000000401b00039000000200200003900000000002104350000002402b0003900000001010000290000000041010434000000000012043500000db6061001970000001f0510018f0000004403b00039000000000034004b0000322e0000813d000000000006004b0000322a0000613d00000000085400190000000007530019000000200770008a000000200880008a0000000009670019000000000a680019000000000a0a04330000000000a90435000000200660008c000032240000c13d000000000005004b000032440000613d00000000070300190000323a0000013d0000000007630019000000000006004b000032370000613d00000000080400190000000009030019000000008a0804340000000009a90436000000000079004b000032330000c13d000000000005004b000032440000613d00000000046400190000000305500210000000000607043300000000065601cf000000000656022f00000000040404330000010005500089000000000454022f00000000045401cf000000000464019f00000000004704350000001f0410003900000db60240019700000000013100190000000000010435000000440120003900000ce70010009c00000ce701008041000000600110021000000ce700b0009c00000ce70200004100000000020b40190000004002200210000000000121019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000121019f000000050200002900040000000b001d339833840000040f000000600310027000010ce70030019d00130000000103550000000100200190000032940000613d000000040100002900000d240010009c0000326f0000213d000000400010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf2011001c70000800d02000039000000020300003900000d5d040000410000000505000029339833840000040f00000001002001900000327c0000613d000000000001042d00000d8401000041000000000010043f0000004101000039000000040010043f00000d2b010000410000339a0001043000000d5e01000041000000000010043f000000040100002900000d2301100197000000040010043f00000d2b010000410000339a0001043000000000010000190000339a0001043000000d5801000041000000000010043f0000000501000029000000040010043f0000000101000039000000240010043f00000d32010000410000339a0001043000000d5801000041000000000010043f0000000501000029000000040010043f000000240000043f00000d32010000410000339a0001043000000d5a01000041000000000010043f0000000501000029000000040010043f00000d2b010000410000339a00010430000000000001042f00000ce7033001970000001f0530018f00000d3b06300198000000400200043d0000000004620019000032a00000613d000000000701034f0000000008020019000000007907043c0000000008980436000000000048004b0000329c0000c13d000000000005004b000032ad0000613d000000000161034f0000000305500210000000000604043300000000065601cf000000000656022f000000000101043b0000010005500089000000000151022f00000000015101cf000000000161019f0000000000140435000000600130021000000ce70020009c00000ce7020080410000004002200210000000000112019f0000339a00010430000400000000000200000d2301100197000300000001001d000000000010043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000033360000613d000000000101043b000000000201041a000000000002004b000033380000613d00000d5b01000041000000000101041a000000000001004b0000333e0000613d000000000021004b000400000002001d000033080000613d000200000001001d00000d5b01000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000033360000613d00000004020000290001000100200092000000000101043b00000d5b02000041000000000202041a000000010020006c000033440000a13d0000000202000029000000010220008a0000000001120019000000000101041a000200000001001d00000d5b01000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000033360000613d000000000101043b00000001011000290000000202000029000000000021041b000000000020043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000033360000613d000000000101043b0000000402000029000000000021041b00000d5b01000041000000000101041a000400000001001d000000000001004b0000334a0000613d00000d5b01000041000000000010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf7011001c70000801002000039339833890000040f0000000100200190000033360000613d0000000402000029000000010220008a000000000101043b0000000001210019000000000001041b00000d5b01000041000000000021041b0000000301000029000000000010043f00000d5901000041000000200010043f000000000100041400000ce70010009c00000ce701008041000000c00110021000000d2f011001c70000801002000039339833890000040f0000000100200190000033360000613d000000000101043b000000000001041b000000000100041400000ce70010009c00000ce701008041000000c00110021000000cf2011001c70000800d02000039000000020300003900000d64040000410000000305000029339833840000040f0000000100200190000033360000613d000000000001042d00000000010000190000339a0001043000000d6501000041000000000010043f0000000301000029000000040010043f00000d2b010000410000339a0001043000000d8401000041000000000010043f0000001101000039000000040010043f00000d2b010000410000339a0001043000000d8401000041000000000010043f0000003201000039000000040010043f00000d2b010000410000339a0001043000000d8401000041000000000010043f0000003101000039000000040010043f00000d2b010000410000339a00010430000000000001042f00000ce70010009c00000ce701008041000000400110021000000ce70020009c00000ce7020080410000006002200210000000000112019f000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000cf2011001c70000801002000039339833890000040f0000000100200190000033640000613d000000000101043b000000000001042d00000000010000190000339a0001043000000000050100190000000000200443000000050030008c000033740000413d000000040100003900000000020000190000000506200210000000000664001900000005066002700000000006060031000000000161043a0000000102200039000000000031004b0000336c0000413d00000ce70030009c00000ce7030080410000006001300210000000000200041400000ce70020009c00000ce702008041000000c002200210000000000112019f00000dbc011001c70000000002050019339833890000040f0000000100200190000033830000613d000000000101043b000000000001042d000000000001042f00003387002104210000000102000039000000000001042d0000000002000019000000000001042d0000338c002104230000000102000039000000000001042d0000000002000019000000000001042d00003391002104210000000102000039000000000001042d0000000002000019000000000001042d00003396002104230000000102000039000000000001042d0000000002000019000000000001042d0000339800000432000033990001042e0000339a00010430000000000000000000000000000000000000000000000000000000000000000000000000ffffffff53736f3132373100000000000000000000000000000000000000000000000000312e302e3000000000000000000000000000000000000000000000000000000053736f3132373100000000000000000000000000000000000000000000000007312e302e3000000000000000000000000000000000000000000000000000000502000000000000000000000000000000000000070000018000000000000000000200000000000000000000000000000000000000000001c000000000000000009a8a0592ac89c5ad3bc6df8224c17b485976f597df104ee20d0df415241f670b02000002000000000000000000000000000000040000000000000000000000008b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f000000000000000000000000000000000000000000000000ffffffffffffff400200000000000000000000000000000000000000000000000000000000000000616c697a696e6700000000000000000000000000000000000000000000000000496e697469616c697a61626c653a20636f6e747261637420697320696e69746908c379a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008400000000000000000000000002000000000000000000000000000000000000200000000000000000000000007f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249800000002000000000000000000000000000002000000010000000000000000000000000000000000000000000000000000000000000000000000000084b0196d00000000000000000000000000000000000000000000000000000000bc197c8000000000000000000000000000000000000000000000000000000000e155128500000000000000000000000000000000000000000000000000000000eeb8cb0800000000000000000000000000000000000000000000000000000000eeb8cb0900000000000000000000000000000000000000000000000000000000f23a6e6100000000000000000000000000000000000000000000000000000000e155128600000000000000000000000000000000000000000000000000000000e2f318e300000000000000000000000000000000000000000000000000000000db8a323e00000000000000000000000000000000000000000000000000000000db8a323f00000000000000000000000000000000000000000000000000000000df9c158900000000000000000000000000000000000000000000000000000000bc197c8100000000000000000000000000000000000000000000000000000000d267652900000000000000000000000000000000000000000000000000000000a28c1aed00000000000000000000000000000000000000000000000000000000b027e50900000000000000000000000000000000000000000000000000000000b027e50a00000000000000000000000000000000000000000000000000000000b909499700000000000000000000000000000000000000000000000000000000a28c1aee00000000000000000000000000000000000000000000000000000000a7d525e80000000000000000000000000000000000000000000000000000000084b0196e000000000000000000000000000000000000000000000000000000008f0273a9000000000000000000000000000000000000000000000000000000009b7be156000000000000000000000000000000000000000000000000000000002e0b437c000000000000000000000000000000000000000000000000000000004f16eec7000000000000000000000000000000000000000000000000000000006e354cb7000000000000000000000000000000000000000000000000000000006e354cb800000000000000000000000000000000000000000000000000000000714da018000000000000000000000000000000000000000000000000000000004f16eec800000000000000000000000000000000000000000000000000000000624d2b53000000000000000000000000000000000000000000000000000000002e0b437d000000000000000000000000000000000000000000000000000000003b7caadd000000000000000000000000000000000000000000000000000000003d3a69bf00000000000000000000000000000000000000000000000000000000150b7a0100000000000000000000000000000000000000000000000000000000202bcce600000000000000000000000000000000000000000000000000000000202bcce70000000000000000000000000000000000000000000000000000000023cef13e00000000000000000000000000000000000000000000000000000000150b7a02000000000000000000000000000000000000000000000000000000001626ba7e0000000000000000000000000000000000000000000000000000000001ffc9a7000000000000000000000000000000000000000000000000000000000775a94e00000000000000000000000000000000000000000000000000000000126c46c1000000000000000000000000ffffffffffffffffffffffffffffffffffffffff000000000000000000000000000000000000000000000000fffffffffffffffff23a6e610000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000007ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa7dfb92000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000119db9bd0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000240000000000000000000000003d40a3a3000000000000000000000000000000000000000000000000000000003e8d8c120000000000000000000000000000000000000000000000000000000076d91304710525fd07f6da5fffdfa69dbbabd80bc84f808f10d120a9bbff4605020000000000000000000000000000000000004000000000000000000000000076d91304710525fd07f6da5fffdfa69dbbabd80bc84f808f10d120a9bbff4604c193b84400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004400000000000000000000000076d91304710525fd07f6da5fffdfa69dbbabd80bc84f808f10d120a9bbff460776d91304710525fd07f6da5fffdfa69dbbabd80bc84f808f10d120a9bbff460647d0871e905ac6550f54ba266e0d90d2dc8ed67a957c064ca3438eddf4e3fd891806aa1896bbf26568e884a7374b41e002500962caba6a15023a8d90e8508b8302000002000000000000000000000000000000240000000000000000000000008a91b0e30000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffbbffffffffffffffffffffffffffffffffffffffbc00000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffe0000000000000000000000000000000000000000000000000ffffffffffffff7f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0926a74a600000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001ffffffe0000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffff0100000100000000000000000000000000000000000000000000000000000000ffffffff000000000000000000000000000000000000000000000000000000009c4d535affffffffffffffffffffffffffffffffffffffffffffffffffffffff9c4d535b00000000000000000000000000000000000000000000000000000000ecf95b8a000000000000000000000000000000000000000000000000000000003cda3351000000000000000000000000000000000000000000000000000000005d38270000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0000000000000000000000000000000000000000000000003920e539000000000000000000000000000000000000000000000000000000001629fe560000000000000000000000000000000000000000000000000000000059b67d01d3aa88365b10f55e6587229e91b93dc13ae7971c4a90aa8f67f7aeed08dbb381e62d3793bb75142524c8a24607cbe12cc74809931249b7f641bc2242bc197c8100000000000000000000000000000000000000000000000000000000647920696e697469616c697a6564000000000000000000000000000000000000496e697469616c697a61626c653a20636f6e747261637420697320616c726561000000000000000000000000000000000000000000000000ffffffffffffff9f8c2a9c6b00000000000000000000000000000000000000000000000000000000e7f04e930000000000000000000000000000000000000000000000000000000001ffc9a700000000000000000000000000000000000000000000000000000000000000000000753000000000000000000000000000000000000000000000000060af18190000000000000000000000000000000000000000000000000000000076d91304710525fd07f6da5fffdfa69dbbabd80bc84f808f10d120a9bbff460337ee46cf0000000000000000000000000000000000000000000000000000000076d91304710525fd07f6da5fffdfa69dbbabd80bc84f808f10d120a9bbff46026d61fe7000000000000000000000000000000000000000000000000000000000e366c1c0452ed8eec96861e9e54141ebff23c9ec89fe27b996b45f5ec38849871809828f0000000000000000000000000000000000000000000000000000000076d91304710525fd07f6da5fffdfa69dbbabd80bc84f808f10d120a9bbff4601689416c70000000000000000000000000000000000000000000000000000000076d91304710525fd07f6da5fffdfa69dbbabd80bc84f808f10d120a9bbff460040097f116787d282c09163d089084b2d950545433dad84146baf8da81064e84c2c74c8c100000000000000000000000000000000000000000000000000000000e1434e25d6611e0db941968fdc97811c982ac1602e951637d206f5fdda9dd8f13e9608b6000000000000000000000000000000000000000000000000000000008c5a344500000000000000000000000000000000000000000000000000000000949431dc00000000000000000000000000000000000000000000000000000000dd62ed3e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044000000800000000000000000095ea7b3000000000000000000000000000000000000000000000000000000005361666545524332303a206c6f772d6c6576656c2063616c6c206661696c656400000000000000000000000000000000000000000000000000000003ffffffe05361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f20746f206e6f6e2d7a65726f20616c6c6f77616e636500000000000000000000000000000000000000000000000000000000000000000000ffffffffffffff3f6f742073756363656564000000000000000000000000000000000000000000005361666545524332303a204552433230206f7065726174696f6e20646964206e416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000000000000000000000000000000000000000006400000000000000000000000054686520617070726f76616c4261736564207061796d617374657220696e707574206d757374206265206174206c65617374203638206279746573206c6f6e670000000000000000000000000000000000000084000000800000000000000000556e737570706f72746564207061796d617374657220666c6f770000000000000000000000000000000000000000000000000064000000800000000000000000546865207374616e64617264207061796d617374657220696e707574206d757374206265206174206c656173742034206279746573206c6f6e670000000000000000000000000000000000000000000000000020000000800000000000000000860d60a3c3ed451a144846eba67081eb134233fed0aff20997e5110b942b3d0e05e8c2ed00000000000000000000000000000000000000000000000000000000310ab089e4439a4c15d089f94afb7896ff553aecb10793d0ab882de59d99a32e0200000200000000000000000000000000000044000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffbfb3512b0c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffdf0f000000000000000000000000000000000000000000000000000000000000004e487b7100000000000000000000000000000000000000000000000000000000e09f0b842a072d50a0b373f3255e2a4216aeb61908e35a93a499f0ff2aa4c8fa362af8a600000000000000000000000000000000000000000000000000000000d52eb8390c18c2c76bddf1290f222641050688bc255b208b6cb5f7e0af63ca418f040de5e2bc657cca8466c23876aac4b9b4f7aabcb97c19957eaec11b91c797328ad68a412ae955fa6a01679e42daaad6d5e59300f49e5d1f6ce8c1ad4f28a0e1239cd8000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000024000000a000000000000000009cc7f708afc65944829bd487b90b72536b1951864fbfc14e125fc972a6507f3900ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000009400000000000000000000000000000000000000000000000000000000000000b8000000000000000000000000000000000000000000000000000000000000008100000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000f800000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000006b656363616b3235362072657475726e656420696e76616c6964206461746100848e1bfa1ac4e3576b728bda6721b215c70a7799a5b4866282a71bab954baac8000000000000000000000000000000000000000000000000fffffffffffffe1fc2f8787176b8ac6bf7215b4adcc1e069bf4ab82d9ab1df05a57a91d425935b6ead7c5bef027816a800da1736444fb58a807ef4c9603b7848673f7e3a68eb14a519b453ce45aaaaf3a300f5a9ec95869b4f28ab10430b572ee218c3a6a5e07d6f000000000000000000000000000000000000000000000000ffffffffffffff5f19010000000000000000000000000000000000000000000000000000000000004f766572666c6f770000000000000000000000000000000000000000000000008080000000000000000000000000000000000000000000000000000000000000a64982fe2c5577c9a4ef0aa19a78dd616e46c23ec51868e3b56f55709808511337d5f03a00000000000000000000000000000000000000000000000000000000bf1733f900000000000000000000000000000000000000000000000000000000202bcce700000000000000000000000000000000000000000000000000000000ff000000000000000000000000000000000000000000000000000000000000007fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a00000000000000000000000000000000000000080000000000000000000000000456e636f64696e6720756e737570706f7274656420747800000000000000000009c55e6d000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000042000000000000000000000000333daf92000000000000000000000000000000000000000000000000000000001626ba7e00000000000000000000000000000000000000000000000000000000150b7a0200000000000000000000000000000000000000000000000000000000ab4a919f00000000000000000000000000000000000000000000000000000000000000000000753000000000000000000000002400000100000000000000000028e00134722f84e69c391c81e4fe022ee3e61048222a8ea2f98c9f235f7975087659c3ce0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff4e2312dfffffffffffffffffffffffffffffffffffffffffffffffffffffffffb9094997000000000000000000000000000000000000000000000000000000004e2312e000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000ffffffffffffffe0000000000000000000000000000000000000000000000000ffffffffffffffa0020000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006a7afb38ff88a1586b0f1b145564713a154c99c70f1c4a6f800a41e5c14b7006