Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function forceApprove(IERC20 token, a ...
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
•    - function _callOptionalReturnBool(IERC ...
•  contract BlockCommon
•    - function transferCommon(address token ...
•    - function withdrawCommon(bool flag,add ...
•  contract BlockATMCustomer is Block ... *
•    - function transferToken(address tokenA ...
•    - function withdrawToken(bool safeFlag, ...
•    - function getActiveFlag()
•    - function getWithdrawAddressList()
•    - function getWithdrawAddressFlag(addre ...
•    - function getOwnerAddressFlag(address ...
•    - function getOwnerAddressList()
•    - function setActiveFlag()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-10-27
*/

// File: @openzeppelin/contracts/utils/Address.sol


// 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://diligence.consensys.net/posts/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);
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol


// OpenZeppelin Contracts (last updated v4.9.0) (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);
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// 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);
}

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;




/**
 * @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;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    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));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    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");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Compatible with tokens that require the approval to be set to
     * 0 before setting it to a non-zero value.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    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");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation 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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

// File: contracts/BlockCommon.sol


pragma solidity >=0.8.0 <=0.8.17;



contract BlockCommon {

    using SafeERC20 for IERC20;

    modifier checkAmount(uint256 amount) {
        require(amount > 0, "amount must be greater than zero");
        _;
    }

    // "transfer token is the zero address"
    modifier checkTokenAddress(address tokenAddress){
        require(tokenAddress != address(0), "transfer token is the zero address");
        _;
    }

    modifier checkWithdrawAddress(address withdrawAddress){
        require(withdrawAddress != address(0), "withdraw address is the zero address");
        _;
    }


    function transferCommon(address tokenAddress,address to,uint256 amount) internal checkTokenAddress(tokenAddress) checkAmount(amount) returns(uint256) {
        IERC20 erc20 = IERC20(tokenAddress);
        uint256 beforeAmount = erc20.balanceOf(to);
        erc20.safeTransferFrom(msg.sender, to, amount);
        uint256 afterAmount = erc20.balanceOf(to);
        uint256 finalAmount = afterAmount - beforeAmount;
        require(finalAmount <= amount, "FinalAmount is error");
        return finalAmount;
    }

    function withdrawCommon(bool flag,address tokenAddress,address withdrawAddress,uint256 amount) internal checkAmount(amount) checkTokenAddress(tokenAddress) checkWithdrawAddress(withdrawAddress) {
        IERC20 erc20 = IERC20(tokenAddress);
        uint256 balance = erc20.balanceOf(address(this));
        require(balance >= amount, "Insufficient balance");
        if(flag){
            erc20.safeTransfer(withdrawAddress, amount);
        } else {
            erc20.transfer(withdrawAddress, amount);
        }

    }

}
// File: contracts/BlockATMCustomer.sol


pragma solidity >=0.8.0 <=0.8.17;


contract BlockATMCustomer is BlockCommon {

    mapping(address => bool) private withdrawMap;

    mapping(address => bool) private ownerMap;

    address[] private withdrawList;

    address[] private ownerList;

    bool private activeFlag;

    struct Withdraw{
        address tokenAddress;
        uint256 amount;
    }

    constructor(address[] memory newWithdrawList,address[] memory newOwnerList) {
        require(newWithdrawList.length > 0, "withdraw address is empty");
        for (uint i = 0; i < newWithdrawList.length; i++) {
            require(newWithdrawList[i] != address(0), "withdraw token is the zero address");
            withdrawMap[newWithdrawList[i]] = true;
        }
        withdrawList =  newWithdrawList;
        require(newOwnerList.length > 0, "owner address is empty");
        for (uint i = 0; i < newOwnerList.length; i++) {
            require(newOwnerList[i] != address(0), "owner is the zero address");
            ownerMap[newOwnerList[i]] = true;
        }
        ownerList = newOwnerList;
        activeFlag = true;
    }

    event TransferToken(address indexed from, address indexed to, address indexed token, uint256 amount,string orderId);

    event WithdrawToken(address indexed from, address indexed to, Withdraw[] withdrawInfo);

    event SetActiveFlag(bool indexed activeFlag);


    modifier onlyOwner() {
        require(ownerMap[msg.sender], "Not the owner");
        _;
    }

    function transferToken(address tokenAddress,uint256 amount,string memory orderId) public checkTokenAddress(tokenAddress) returns (bool)  {
        require(activeFlag, "The contract has already burned");
        uint256 finalAmount = super.transferCommon(tokenAddress,address(this),amount);
        emit TransferToken(msg.sender, address(this), tokenAddress, finalAmount,orderId); 
        return true;
    }

    function withdrawToken(bool safeFlag,Withdraw[] memory withdrawInfo,address withdrawAddress) public onlyOwner returns (bool) {
        // check withdrawAddress
        require(withdrawMap[withdrawAddress], "withdraw address not allowed");
        // check 
        for(uint16 i = 0; i < withdrawInfo.length; i++ ){
            Withdraw memory info = withdrawInfo[i];
            super.withdrawCommon(safeFlag,info.tokenAddress,withdrawAddress,info.amount);
        }
        emit WithdrawToken(msg.sender, withdrawAddress, withdrawInfo);
        return true;
    }


    function getActiveFlag() public view returns (bool) {
        return activeFlag;
    }

    function getWithdrawAddressList() public view returns(address[] memory){
        return withdrawList;
    }

    function getWithdrawAddressFlag(address withdrawAddress) public view returns(bool){
        return withdrawMap[withdrawAddress];
    }

    function getOwnerAddressFlag(address ownerAddress) public view returns(bool){
        return ownerMap[ownerAddress];
    }

    function getOwnerAddressList() public view returns(address[] memory){
        return ownerList;
    }
    
    function setActiveFlag() public onlyOwner {
        require(activeFlag, "The contract has already burned");
        activeFlag = false;
        emit SetActiveFlag(activeFlag);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address[]","name":"newWithdrawList","type":"address[]"},{"internalType":"address[]","name":"newOwnerList","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bool","name":"activeFlag","type":"bool"}],"name":"SetActiveFlag","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"string","name":"orderId","type":"string"}],"name":"TransferToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"components":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"indexed":false,"internalType":"struct BlockATMCustomer.Withdraw[]","name":"withdrawInfo","type":"tuple[]"}],"name":"WithdrawToken","type":"event"},{"inputs":[],"name":"getActiveFlag","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"ownerAddress","type":"address"}],"name":"getOwnerAddressFlag","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOwnerAddressList","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"withdrawAddress","type":"address"}],"name":"getWithdrawAddressFlag","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getWithdrawAddressList","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"setActiveFlag","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"string","name":"orderId","type":"string"}],"name":"transferToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"safeFlag","type":"bool"},{"components":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct BlockATMCustomer.Withdraw[]","name":"withdrawInfo","type":"tuple[]"},{"internalType":"address","name":"withdrawAddress","type":"address"}],"name":"withdrawToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

0x608060405234801561001057600080fd5b50600436106100885760003560e01c80637168aedf1161005b5780637168aedf146101295780637b9205ca146101595780637f955c1714610189578063f0a86a19146101a757610088565b806310228dc31461008d5780631227922c146100bd57806321d0034b146100db5780636109069a146100f9575b600080fd5b6100a760048036038101906100a29190611289565b6101b1565b6040516100b49190611313565b60405180910390f35b6100c561030c565b6040516100d291906113ec565b60405180910390f35b6100e361039a565b6040516100f091906113ec565b60405180910390f35b610113600480360381019061010e919061140e565b610428565b6040516101209190611313565b60405180910390f35b610143600480360381019061013e919061140e565b61047e565b6040516101509190611313565b60405180910390f35b610173600480360381019061016e9190611584565b6104d3565b6040516101809190611313565b60405180910390f35b6101916106b8565b60405161019e9190611313565b60405180910390f35b6101af6106cf565b005b600083600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603610223576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161021a90611676565b60405180910390fd5b600460009054906101000a900460ff16610272576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610269906116e2565b60405180910390fd5b600061027f863087610805565b90508573ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167fefbf9e71b8b9415ed6723cea57670470f2fa0e9cc6c4aebe4c25d90e4c68827784886040516102f792919061177f565b60405180910390a46001925050509392505050565b6060600280548060200260200160405190810160405280929190818152602001828054801561039057602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311610346575b5050505050905090565b6060600380548060200260200160405190810160405280929190818152602001828054801561041e57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190600101908083116103d4575b5050505050905090565b6000600160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff169050919050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff169050919050565b6000600160003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16610561576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610558906117fb565b60405180910390fd5b6000808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff166105ec576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105e390611867565b60405180910390fd5b60005b83518161ffff161015610647576000848261ffff168151811061061557610614611887565b5b60200260200101519050610633868260000151868460200151610a4c565b50808061063f906118f3565b9150506105ef565b508173ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2507215ab1d5d43708a53d0ea2dcbfb63ea4003b92cf3431497ec3f742a293b7856040516106a59190611a0a565b60405180910390a3600190509392505050565b6000600460009054906101000a900460ff16905090565b600160003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff1661075b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610752906117fb565b60405180910390fd5b600460009054906101000a900460ff166107aa576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107a1906116e2565b60405180910390fd5b6000600460006101000a81548160ff021916908315150217905550600460009054906101000a900460ff1615157f2a6621eea69f4fd8903c41e48fe39c9b68ff173291711f44ba20b7261d6d4d3360405160405180910390a2565b600083600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603610877576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161086e90611676565b60405180910390fd5b82600081116108bb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108b290611a78565b60405180910390fd5b600086905060008173ffffffffffffffffffffffffffffffffffffffff166370a08231886040518263ffffffff1660e01b81526004016108fb9190611aa7565b602060405180830381865afa158015610918573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061093c9190611ad7565b905061096b3388888573ffffffffffffffffffffffffffffffffffffffff16610cf7909392919063ffffffff16565b60008273ffffffffffffffffffffffffffffffffffffffff166370a08231896040518263ffffffff1660e01b81526004016109a69190611aa7565b602060405180830381865afa1580156109c3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109e79190611ad7565b9050600082826109f79190611b04565b905087811115610a3c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a3390611b84565b60405180910390fd5b8096505050505050509392505050565b8060008111610a90576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a8790611a78565b60405180910390fd5b83600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603610b00576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610af790611676565b60405180910390fd5b83600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603610b70576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b6790611c16565b60405180910390fd5b600086905060008173ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610bb09190611aa7565b602060405180830381865afa158015610bcd573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bf19190611ad7565b905085811015610c36576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c2d90611c82565b60405180910390fd5b8815610c6c57610c6787878473ffffffffffffffffffffffffffffffffffffffff16610d809092919063ffffffff16565b610cec565b8173ffffffffffffffffffffffffffffffffffffffff1663a9059cbb88886040518363ffffffff1660e01b8152600401610ca7929190611ca2565b6020604051808303816000875af1158015610cc6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610cea9190611ce0565b505b505050505050505050565b610d7a846323b872dd60e01b858585604051602401610d1893929190611d0d565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050610e06565b50505050565b610e018363a9059cbb60e01b8484604051602401610d9f929190611ca2565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050610e06565b505050565b6000610e68826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16610ece9092919063ffffffff16565b9050600081511480610e8a575080806020019051810190610e899190611ce0565b5b610ec9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ec090611db6565b60405180910390fd5b505050565b6060610edd8484600085610ee6565b90509392505050565b606082471015610f2b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f2290611e48565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff168587604051610f549190611eaf565b60006040518083038185875af1925050503d8060008114610f91576040519150601f19603f3d011682016040523d82523d6000602084013e610f96565b606091505b5091509150610fa787838387610fb3565b92505050949350505050565b6060831561101557600083510361100d57610fcd85611028565b61100c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161100390611f12565b60405180910390fd5b5b829050611020565b61101f838361104b565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b60008251111561105e5781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110929190611f32565b60405180910390fd5b6000604051905090565b600080fd5b600080fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b60006110da826110af565b9050919050565b6110ea816110cf565b81146110f557600080fd5b50565b600081359050611107816110e1565b92915050565b6000819050919050565b6111208161110d565b811461112b57600080fd5b50565b60008135905061113d81611117565b92915050565b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6111968261114d565b810181811067ffffffffffffffff821117156111b5576111b461115e565b5b80604052505050565b60006111c861109b565b90506111d4828261118d565b919050565b600067ffffffffffffffff8211156111f4576111f361115e565b5b6111fd8261114d565b9050602081019050919050565b82818337600083830152505050565b600061122c611227846111d9565b6111be565b90508281526020810184848401111561124857611247611148565b5b61125384828561120a565b509392505050565b600082601f8301126112705761126f611143565b5b8135611280848260208601611219565b91505092915050565b6000806000606084860312156112a2576112a16110a5565b5b60006112b0868287016110f8565b93505060206112c18682870161112e565b925050604084013567ffffffffffffffff8111156112e2576112e16110aa565b5b6112ee8682870161125b565b9150509250925092565b60008115159050919050565b61130d816112f8565b82525050565b60006020820190506113286000830184611304565b92915050565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b611363816110cf565b82525050565b6000611375838361135a565b60208301905092915050565b6000602082019050919050565b60006113998261132e565b6113a38185611339565b93506113ae8361134a565b8060005b838110156113df5781516113c68882611369565b97506113d183611381565b9250506001810190506113b2565b5085935050505092915050565b60006020820190508181036000830152611406818461138e565b905092915050565b600060208284031215611424576114236110a5565b5b6000611432848285016110f8565b91505092915050565b611444816112f8565b811461144f57600080fd5b50565b6000813590506114618161143b565b92915050565b600067ffffffffffffffff8211156114825761148161115e565b5b602082029050602081019050919050565b600080fd5b600080fd5b6000604082840312156114b3576114b2611498565b5b6114bd60406111be565b905060006114cd848285016110f8565b60008301525060206114e18482850161112e565b60208301525092915050565b60006115006114fb84611467565b6111be565b9050808382526020820190506040840283018581111561152357611522611493565b5b835b8181101561154c5780611538888261149d565b845260208401935050604081019050611525565b5050509392505050565b600082601f83011261156b5761156a611143565b5b813561157b8482602086016114ed565b91505092915050565b60008060006060848603121561159d5761159c6110a5565b5b60006115ab86828701611452565b935050602084013567ffffffffffffffff8111156115cc576115cb6110aa565b5b6115d886828701611556565b92505060406115e9868287016110f8565b9150509250925092565b600082825260208201905092915050565b7f7472616e7366657220746f6b656e20697320746865207a65726f20616464726560008201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b60006116606022836115f3565b915061166b82611604565b604082019050919050565b6000602082019050818103600083015261168f81611653565b9050919050565b7f54686520636f6e74726163742068617320616c7265616479206275726e656400600082015250565b60006116cc601f836115f3565b91506116d782611696565b602082019050919050565b600060208201905081810360008301526116fb816116bf565b9050919050565b61170b8161110d565b82525050565b600081519050919050565b60005b8381101561173a57808201518184015260208101905061171f565b60008484015250505050565b600061175182611711565b61175b81856115f3565b935061176b81856020860161171c565b6117748161114d565b840191505092915050565b60006040820190506117946000830185611702565b81810360208301526117a68184611746565b90509392505050565b7f4e6f7420746865206f776e657200000000000000000000000000000000000000600082015250565b60006117e5600d836115f3565b91506117f0826117af565b602082019050919050565b60006020820190508181036000830152611814816117d8565b9050919050565b7f77697468647261772061646472657373206e6f7420616c6c6f77656400000000600082015250565b6000611851601c836115f3565b915061185c8261181b565b602082019050919050565b6000602082019050818103600083015261188081611844565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600061ffff82169050919050565b60006118fe826118e5565b915061ffff8203611912576119116118b6565b5b600182019050919050565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b6119528161110d565b82525050565b60408201600082015161196e600085018261135a565b5060208201516119816020850182611949565b50505050565b60006119938383611958565b60408301905092915050565b6000602082019050919050565b60006119b78261191d565b6119c18185611928565b93506119cc83611939565b8060005b838110156119fd5781516119e48882611987565b97506119ef8361199f565b9250506001810190506119d0565b5085935050505092915050565b60006020820190508181036000830152611a2481846119ac565b905092915050565b7f616d6f756e74206d7573742062652067726561746572207468616e207a65726f600082015250565b6000611a626020836115f3565b9150611a6d82611a2c565b602082019050919050565b60006020820190508181036000830152611a9181611a55565b9050919050565b611aa1816110cf565b82525050565b6000602082019050611abc6000830184611a98565b92915050565b600081519050611ad181611117565b92915050565b600060208284031215611aed57611aec6110a5565b5b6000611afb84828501611ac2565b91505092915050565b6000611b0f8261110d565b9150611b1a8361110d565b9250828203905081811115611b3257611b316118b6565b5b92915050565b7f46696e616c416d6f756e74206973206572726f72000000000000000000000000600082015250565b6000611b6e6014836115f3565b9150611b7982611b38565b602082019050919050565b60006020820190508181036000830152611b9d81611b61565b9050919050565b7f7769746864726177206164647265737320697320746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b6000611c006024836115f3565b9150611c0b82611ba4565b604082019050919050565b60006020820190508181036000830152611c2f81611bf3565b9050919050565b7f496e73756666696369656e742062616c616e6365000000000000000000000000600082015250565b6000611c6c6014836115f3565b9150611c7782611c36565b602082019050919050565b60006020820190508181036000830152611c9b81611c5f565b9050919050565b6000604082019050611cb76000830185611a98565b611cc46020830184611702565b9392505050565b600081519050611cda8161143b565b92915050565b600060208284031215611cf657611cf56110a5565b5b6000611d0484828501611ccb565b91505092915050565b6000606082019050611d226000830186611a98565b611d2f6020830185611a98565b611d3c6040830184611702565b949350505050565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b6000611da0602a836115f3565b9150611dab82611d44565b604082019050919050565b60006020820190508181036000830152611dcf81611d93565b9050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b6000611e326026836115f3565b9150611e3d82611dd6565b604082019050919050565b60006020820190508181036000830152611e6181611e25565b9050919050565b600081519050919050565b600081905092915050565b6000611e8982611e68565b611e938185611e73565b9350611ea381856020860161171c565b80840191505092915050565b6000611ebb8284611e7e565b915081905092915050565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b6000611efc601d836115f3565b9150611f0782611ec6565b602082019050919050565b60006020820190508181036000830152611f2b81611eef565b9050919050565b60006020820190508181036000830152611f4c8184611746565b90509291505056fea2646970667358221220b7afcfd69f68c6c9114d60e2d3fd44cafa9120a07d80aaaf5cc159c353074ade64736f6c63430008110033

23472:3283:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24957:412;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26057:109;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26450:103;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26318:124;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26174:136;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25377:574;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25961:88;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26565:185;;;:::i;:::-;;24957:412;25087:4;25064:12;22082:1;22058:26;;:12;:26;;;22050:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;25113:10:::1;;;;;;;;;;;25105:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;25170:19;25192:55;25213:12;25234:4;25240:6;25192:20;:55::i;:::-;25170:77;;25304:12;25263:75;;25297:4;25263:75;;25277:10;25263:75;;;25318:11;25330:7;25263:75;;;;;;;:::i;:::-;;;;;;;;25357:4;25350:11;;;24957:412:::0;;;;;;:::o;26057:109::-;26111:16;26146:12;26139:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26057:109;:::o;26450:103::-;26501:16;26536:9;26529:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26450:103;:::o;26318:124::-;26389:4;26412:8;:22;26421:12;26412:22;;;;;;;;;;;;;;;;;;;;;;;;;26405:29;;26318:124;;;:::o;26174:136::-;26251:4;26274:11;:28;26286:15;26274:28;;;;;;;;;;;;;;;;;;;;;;;;;26267:35;;26174:136;;;:::o;25377:574::-;25496:4;24891:8;:20;24900:10;24891:20;;;;;;;;;;;;;;;;;;;;;;;;;24883:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;25555:11:::1;:28:::0;25567:15:::1;25555:28;;;;;;;;;;;;;;;;;;;;;;;;;25547:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;25650:8;25646:204;25668:12;:19;25664:1;:23;;;25646:204;;;25709:20;25732:12;25745:1;25732:15;;;;;;;;;;:::i;:::-;;;;;;;;25709:38;;25762:76;25783:8;25792:4;:17;;;25810:15;25826:4;:11;;;25762:20;:76::i;:::-;25694:156;25689:3;;;;;:::i;:::-;;;;25646:204;;;;25891:15;25865:56;;25879:10;25865:56;;;25908:12;25865:56;;;;;;:::i;:::-;;;;;;;;25939:4;25932:11;;25377:574:::0;;;;;:::o;25961:88::-;26007:4;26031:10;;;;;;;;;;;26024:17;;25961:88;:::o;26565:185::-;24891:8;:20;24900:10;24891:20;;;;;;;;;;;;;;;;;;;;;;;;;24883:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;26626:10:::1;;;;;;;;;;;26618:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;26696:5;26683:10;;:18;;;;;;;;;;;;;;;;;;26731:10;;;;;;;;;;;26717:25;;;;;;;;;;;;26565:185::o:0;22324:519::-;22465:7;22423:12;22082:1;22058:26;;:12;:26;;;22050:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;22449:6:::1;21880:1;21871:6;:10;21863:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;22485:12:::2;22507;22485:35;;22531:20;22554:5;:15;;;22570:2;22554:19;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22531:42;;22584:46;22607:10;22619:2;22623:6;22584:5;:22;;;;:46;;;;;;:::i;:::-;22641:19;22663:5;:15;;;22679:2;22663:19;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22641:41;;22693:19;22729:12;22715:11;:26;;;;:::i;:::-;22693:48;;22775:6;22760:11;:21;;22752:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;22824:11;22817:18;;;;;;22134:1:::1;22324:519:::0;;;;;;:::o;22851:530::-;22967:6;21880:1;21871:6;:10;21863:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;22993:12:::1;22082:1;22058:26;;:12;:26;;::::0;22050:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;23028:15:::2;22251:1;22224:29;;:15;:29;;::::0;22216:78:::2;;;;;;;;;;;;:::i;:::-;;;;;;;;;23056:12:::3;23078;23056:35;;23102:15;23120:5;:15;;;23144:4;23120:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23102:48;;23180:6;23169:7;:17;;23161:50;;;;;;;;;;;;:::i;:::-;;;;;;;;;23225:4;23222:150;;;23245:43;23264:15;23281:6;23245:5;:18;;;;:43;;;;;:::i;:::-;23222:150;;;23321:5;:14;;;23336:15;23353:6;23321:39;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;23222:150;23045:336;;22134:1:::2;21929::::1;22851:530:::0;;;;;:::o;15999:205::-;16100:96;16120:5;16150:27;;;16179:4;16185:2;16189:5;16127:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16100:19;:96::i;:::-;15999:205;;;;:::o;15577:177::-;15660:86;15680:5;15710:23;;;15735:2;15739:5;15687:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15660:19;:86::i;:::-;15577:177;;;:::o;19900:649::-;20324:23;20350:69;20378:4;20350:69;;;;;;;;;;;;;;;;;20358:5;20350:27;;;;:69;;;;;:::i;:::-;20324:95;;20459:1;20438:10;:17;:22;:56;;;;20475:10;20464:30;;;;;;;;;;;;:::i;:::-;20438:56;20430:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;19970:579;19900:649;;:::o;3990:229::-;4127:12;4159:52;4181:6;4189:4;4195:1;4198:12;4159:21;:52::i;:::-;4152:59;;3990:229;;;;;:::o;5110:455::-;5280:12;5338:5;5313:21;:30;;5305:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;5398:12;5412:23;5439:6;:11;;5458:5;5465:4;5439:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5397:73;;;;5488:69;5515:6;5523:7;5532:10;5544:12;5488:26;:69::i;:::-;5481:76;;;;5110:455;;;;;;:::o;7683:644::-;7868:12;7897:7;7893:427;;;7946:1;7925:10;:17;:22;7921:290;;8143:18;8154:6;8143:10;:18::i;:::-;8135:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;7921:290;8232:10;8225:17;;;;7893:427;8275:33;8283:10;8295:12;8275:7;:33::i;:::-;7683:644;;;;;;;:::o;1233:326::-;1293:4;1550:1;1528:7;:19;;;:23;1521:30;;1233:326;;;:::o;8869:552::-;9050:1;9030:10;:17;:21;9026:388;;;9262:10;9256:17;9319:15;9306:10;9302:2;9298:19;9291:44;9026:388;9389:12;9382:20;;;;;;;;;;;:::i;:::-;;;;;;;;7:75:1;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:77::-;878:7;907:5;896:16;;841:77;;;:::o;924:122::-;997:24;1015:5;997:24;:::i;:::-;990:5;987:35;977:63;;1036:1;1033;1026:12;977:63;924:122;:::o;1052:139::-;1098:5;1136:6;1123:20;1114:29;;1152:33;1179:5;1152:33;:::i;:::-;1052:139;;;;:::o;1197:117::-;1306:1;1303;1296:12;1320:117;1429:1;1426;1419:12;1443:102;1484:6;1535:2;1531:7;1526:2;1519:5;1515:14;1511:28;1501:38;;1443:102;;;:::o;1551:180::-;1599:77;1596:1;1589:88;1696:4;1693:1;1686:15;1720:4;1717:1;1710:15;1737:281;1820:27;1842:4;1820:27;:::i;:::-;1812:6;1808:40;1950:6;1938:10;1935:22;1914:18;1902:10;1899:34;1896:62;1893:88;;;1961:18;;:::i;:::-;1893:88;2001:10;1997:2;1990:22;1780:238;1737:281;;:::o;2024:129::-;2058:6;2085:20;;:::i;:::-;2075:30;;2114:33;2142:4;2134:6;2114:33;:::i;:::-;2024:129;;;:::o;2159:308::-;2221:4;2311:18;2303:6;2300:30;2297:56;;;2333:18;;:::i;:::-;2297:56;2371:29;2393:6;2371:29;:::i;:::-;2363:37;;2455:4;2449;2445:15;2437:23;;2159:308;;;:::o;2473:146::-;2570:6;2565:3;2560;2547:30;2611:1;2602:6;2597:3;2593:16;2586:27;2473:146;;;:::o;2625:425::-;2703:5;2728:66;2744:49;2786:6;2744:49;:::i;:::-;2728:66;:::i;:::-;2719:75;;2817:6;2810:5;2803:21;2855:4;2848:5;2844:16;2893:3;2884:6;2879:3;2875:16;2872:25;2869:112;;;2900:79;;:::i;:::-;2869:112;2990:54;3037:6;3032:3;3027;2990:54;:::i;:::-;2709:341;2625:425;;;;;:::o;3070:340::-;3126:5;3175:3;3168:4;3160:6;3156:17;3152:27;3142:122;;3183:79;;:::i;:::-;3142:122;3300:6;3287:20;3325:79;3400:3;3392:6;3385:4;3377:6;3373:17;3325:79;:::i;:::-;3316:88;;3132:278;3070:340;;;;:::o;3416:799::-;3503:6;3511;3519;3568:2;3556:9;3547:7;3543:23;3539:32;3536:119;;;3574:79;;:::i;:::-;3536:119;3694:1;3719:53;3764:7;3755:6;3744:9;3740:22;3719:53;:::i;:::-;3709:63;;3665:117;3821:2;3847:53;3892:7;3883:6;3872:9;3868:22;3847:53;:::i;:::-;3837:63;;3792:118;3977:2;3966:9;3962:18;3949:32;4008:18;4000:6;3997:30;3994:117;;;4030:79;;:::i;:::-;3994:117;4135:63;4190:7;4181:6;4170:9;4166:22;4135:63;:::i;:::-;4125:73;;3920:288;3416:799;;;;;:::o;4221:90::-;4255:7;4298:5;4291:13;4284:21;4273:32;;4221:90;;;:::o;4317:109::-;4398:21;4413:5;4398:21;:::i;:::-;4393:3;4386:34;4317:109;;:::o;4432:210::-;4519:4;4557:2;4546:9;4542:18;4534:26;;4570:65;4632:1;4621:9;4617:17;4608:6;4570:65;:::i;:::-;4432:210;;;;:::o;4648:114::-;4715:6;4749:5;4743:12;4733:22;;4648:114;;;:::o;4768:184::-;4867:11;4901:6;4896:3;4889:19;4941:4;4936:3;4932:14;4917:29;;4768:184;;;;:::o;4958:132::-;5025:4;5048:3;5040:11;;5078:4;5073:3;5069:14;5061:22;;4958:132;;;:::o;5096:108::-;5173:24;5191:5;5173:24;:::i;:::-;5168:3;5161:37;5096:108;;:::o;5210:179::-;5279:10;5300:46;5342:3;5334:6;5300:46;:::i;:::-;5378:4;5373:3;5369:14;5355:28;;5210:179;;;;:::o;5395:113::-;5465:4;5497;5492:3;5488:14;5480:22;;5395:113;;;:::o;5544:732::-;5663:3;5692:54;5740:5;5692:54;:::i;:::-;5762:86;5841:6;5836:3;5762:86;:::i;:::-;5755:93;;5872:56;5922:5;5872:56;:::i;:::-;5951:7;5982:1;5967:284;5992:6;5989:1;5986:13;5967:284;;;6068:6;6062:13;6095:63;6154:3;6139:13;6095:63;:::i;:::-;6088:70;;6181:60;6234:6;6181:60;:::i;:::-;6171:70;;6027:224;6014:1;6011;6007:9;6002:14;;5967:284;;;5971:14;6267:3;6260:10;;5668:608;;;5544:732;;;;:::o;6282:373::-;6425:4;6463:2;6452:9;6448:18;6440:26;;6512:9;6506:4;6502:20;6498:1;6487:9;6483:17;6476:47;6540:108;6643:4;6634:6;6540:108;:::i;:::-;6532:116;;6282:373;;;;:::o;6661:329::-;6720:6;6769:2;6757:9;6748:7;6744:23;6740:32;6737:119;;;6775:79;;:::i;:::-;6737:119;6895:1;6920:53;6965:7;6956:6;6945:9;6941:22;6920:53;:::i;:::-;6910:63;;6866:117;6661:329;;;;:::o;6996:116::-;7066:21;7081:5;7066:21;:::i;:::-;7059:5;7056:32;7046:60;;7102:1;7099;7092:12;7046:60;6996:116;:::o;7118:133::-;7161:5;7199:6;7186:20;7177:29;;7215:30;7239:5;7215:30;:::i;:::-;7118:133;;;;:::o;7257:337::-;7360:4;7450:18;7442:6;7439:30;7436:56;;;7472:18;;:::i;:::-;7436:56;7522:4;7514:6;7510:17;7502:25;;7582:4;7576;7572:15;7564:23;;7257:337;;;:::o;7600:117::-;7709:1;7706;7699:12;7723:117;7832:1;7829;7822:12;8009:585;8084:5;8128:4;8116:9;8111:3;8107:19;8103:30;8100:117;;;8136:79;;:::i;:::-;8100:117;8235:21;8251:4;8235:21;:::i;:::-;8226:30;;8323:1;8363:49;8408:3;8399:6;8388:9;8384:22;8363:49;:::i;:::-;8356:4;8349:5;8345:16;8338:75;8266:158;8485:2;8526:49;8571:3;8562:6;8551:9;8547:22;8526:49;:::i;:::-;8519:4;8512:5;8508:16;8501:75;8434:153;8009:585;;;;:::o;8642:788::-;8764:5;8789:107;8805:90;8888:6;8805:90;:::i;:::-;8789:107;:::i;:::-;8780:116;;8916:5;8945:6;8938:5;8931:21;8979:4;8972:5;8968:16;8961:23;;9032:4;9024:6;9020:17;9012:6;9008:30;9061:3;9053:6;9050:15;9047:122;;;9080:79;;:::i;:::-;9047:122;9195:6;9178:246;9212:6;9207:3;9204:15;9178:246;;;9287:3;9316:63;9375:3;9363:10;9316:63;:::i;:::-;9311:3;9304:76;9409:4;9404:3;9400:14;9393:21;;9254:170;9238:4;9233:3;9229:14;9222:21;;9178:246;;;9182:21;8770:660;;8642:788;;;;;:::o;9478:422::-;9575:5;9624:3;9617:4;9609:6;9605:17;9601:27;9591:122;;9632:79;;:::i;:::-;9591:122;9749:6;9736:20;9774:120;9890:3;9882:6;9875:4;9867:6;9863:17;9774:120;:::i;:::-;9765:129;;9581:319;9478:422;;;;:::o;9906:875::-;10031:6;10039;10047;10096:2;10084:9;10075:7;10071:23;10067:32;10064:119;;;10102:79;;:::i;:::-;10064:119;10222:1;10247:50;10289:7;10280:6;10269:9;10265:22;10247:50;:::i;:::-;10237:60;;10193:114;10374:2;10363:9;10359:18;10346:32;10405:18;10397:6;10394:30;10391:117;;;10427:79;;:::i;:::-;10391:117;10532:104;10628:7;10619:6;10608:9;10604:22;10532:104;:::i;:::-;10522:114;;10317:329;10685:2;10711:53;10756:7;10747:6;10736:9;10732:22;10711:53;:::i;:::-;10701:63;;10656:118;9906:875;;;;;:::o;10787:169::-;10871:11;10905:6;10900:3;10893:19;10945:4;10940:3;10936:14;10921:29;;10787:169;;;;:::o;10962:221::-;11102:34;11098:1;11090:6;11086:14;11079:58;11171:4;11166:2;11158:6;11154:15;11147:29;10962:221;:::o;11189:366::-;11331:3;11352:67;11416:2;11411:3;11352:67;:::i;:::-;11345:74;;11428:93;11517:3;11428:93;:::i;:::-;11546:2;11541:3;11537:12;11530:19;;11189:366;;;:::o;11561:419::-;11727:4;11765:2;11754:9;11750:18;11742:26;;11814:9;11808:4;11804:20;11800:1;11789:9;11785:17;11778:47;11842:131;11968:4;11842:131;:::i;:::-;11834:139;;11561:419;;;:::o;11986:181::-;12126:33;12122:1;12114:6;12110:14;12103:57;11986:181;:::o;12173:366::-;12315:3;12336:67;12400:2;12395:3;12336:67;:::i;:::-;12329:74;;12412:93;12501:3;12412:93;:::i;:::-;12530:2;12525:3;12521:12;12514:19;;12173:366;;;:::o;12545:419::-;12711:4;12749:2;12738:9;12734:18;12726:26;;12798:9;12792:4;12788:20;12784:1;12773:9;12769:17;12762:47;12826:131;12952:4;12826:131;:::i;:::-;12818:139;;12545:419;;;:::o;12970:118::-;13057:24;13075:5;13057:24;:::i;:::-;13052:3;13045:37;12970:118;;:::o;13094:99::-;13146:6;13180:5;13174:12;13164:22;;13094:99;;;:::o;13199:246::-;13280:1;13290:113;13304:6;13301:1;13298:13;13290:113;;;13389:1;13384:3;13380:11;13374:18;13370:1;13365:3;13361:11;13354:39;13326:2;13323:1;13319:10;13314:15;;13290:113;;;13437:1;13428:6;13423:3;13419:16;13412:27;13261:184;13199:246;;;:::o;13451:377::-;13539:3;13567:39;13600:5;13567:39;:::i;:::-;13622:71;13686:6;13681:3;13622:71;:::i;:::-;13615:78;;13702:65;13760:6;13755:3;13748:4;13741:5;13737:16;13702:65;:::i;:::-;13792:29;13814:6;13792:29;:::i;:::-;13787:3;13783:39;13776:46;;13543:285;13451:377;;;;:::o;13834:423::-;13975:4;14013:2;14002:9;13998:18;13990:26;;14026:71;14094:1;14083:9;14079:17;14070:6;14026:71;:::i;:::-;14144:9;14138:4;14134:20;14129:2;14118:9;14114:18;14107:48;14172:78;14245:4;14236:6;14172:78;:::i;:::-;14164:86;;13834:423;;;;;:::o;14263:163::-;14403:15;14399:1;14391:6;14387:14;14380:39;14263:163;:::o;14432:366::-;14574:3;14595:67;14659:2;14654:3;14595:67;:::i;:::-;14588:74;;14671:93;14760:3;14671:93;:::i;:::-;14789:2;14784:3;14780:12;14773:19;;14432:366;;;:::o;14804:419::-;14970:4;15008:2;14997:9;14993:18;14985:26;;15057:9;15051:4;15047:20;15043:1;15032:9;15028:17;15021:47;15085:131;15211:4;15085:131;:::i;:::-;15077:139;;14804:419;;;:::o;15229:178::-;15369:30;15365:1;15357:6;15353:14;15346:54;15229:178;:::o;15413:366::-;15555:3;15576:67;15640:2;15635:3;15576:67;:::i;:::-;15569:74;;15652:93;15741:3;15652:93;:::i;:::-;15770:2;15765:3;15761:12;15754:19;;15413:366;;;:::o;15785:419::-;15951:4;15989:2;15978:9;15974:18;15966:26;;16038:9;16032:4;16028:20;16024:1;16013:9;16009:17;16002:47;16066:131;16192:4;16066:131;:::i;:::-;16058:139;;15785:419;;;:::o;16210:180::-;16258:77;16255:1;16248:88;16355:4;16352:1;16345:15;16379:4;16376:1;16369:15;16396:180;16444:77;16441:1;16434:88;16541:4;16538:1;16531:15;16565:4;16562:1;16555:15;16582:89;16618:7;16658:6;16651:5;16647:18;16636:29;;16582:89;;;:::o;16677:171::-;16715:3;16738:23;16755:5;16738:23;:::i;:::-;16729:32;;16783:6;16776:5;16773:17;16770:43;;16793:18;;:::i;:::-;16770:43;16840:1;16833:5;16829:13;16822:20;;16677:171;;;:::o;16854:140::-;16947:6;16981:5;16975:12;16965:22;;16854:140;;;:::o;17000:210::-;17125:11;17159:6;17154:3;17147:19;17199:4;17194:3;17190:14;17175:29;;17000:210;;;;:::o;17216:158::-;17309:4;17332:3;17324:11;;17362:4;17357:3;17353:14;17345:22;;17216:158;;;:::o;17380:108::-;17457:24;17475:5;17457:24;:::i;:::-;17452:3;17445:37;17380:108;;:::o;17570:509::-;17709:4;17704:3;17700:14;17804:4;17797:5;17793:16;17787:23;17823:63;17880:4;17875:3;17871:14;17857:12;17823:63;:::i;:::-;17724:172;17980:4;17973:5;17969:16;17963:23;17999:63;18056:4;18051:3;18047:14;18033:12;17999:63;:::i;:::-;17906:166;17678:401;17570:509;;:::o;18085:283::-;18206:10;18227:98;18321:3;18313:6;18227:98;:::i;:::-;18357:4;18352:3;18348:14;18334:28;;18085:283;;;;:::o;18374:139::-;18470:4;18502;18497:3;18493:14;18485:22;;18374:139;;;:::o;18599:940::-;18770:3;18799:80;18873:5;18799:80;:::i;:::-;18895:112;19000:6;18995:3;18895:112;:::i;:::-;18888:119;;19031:82;19107:5;19031:82;:::i;:::-;19136:7;19167:1;19152:362;19177:6;19174:1;19171:13;19152:362;;;19253:6;19247:13;19280:115;19391:3;19376:13;19280:115;:::i;:::-;19273:122;;19418:86;19497:6;19418:86;:::i;:::-;19408:96;;19212:302;19199:1;19196;19192:9;19187:14;;19152:362;;;19156:14;19530:3;19523:10;;18775:764;;;18599:940;;;;:::o;19545:477::-;19740:4;19778:2;19767:9;19763:18;19755:26;;19827:9;19821:4;19817:20;19813:1;19802:9;19798:17;19791:47;19855:160;20010:4;20001:6;19855:160;:::i;:::-;19847:168;;19545:477;;;;:::o;20028:182::-;20168:34;20164:1;20156:6;20152:14;20145:58;20028:182;:::o;20216:366::-;20358:3;20379:67;20443:2;20438:3;20379:67;:::i;:::-;20372:74;;20455:93;20544:3;20455:93;:::i;:::-;20573:2;20568:3;20564:12;20557:19;;20216:366;;;:::o;20588:419::-;20754:4;20792:2;20781:9;20777:18;20769:26;;20841:9;20835:4;20831:20;20827:1;20816:9;20812:17;20805:47;20869:131;20995:4;20869:131;:::i;:::-;20861:139;;20588:419;;;:::o;21013:118::-;21100:24;21118:5;21100:24;:::i;:::-;21095:3;21088:37;21013:118;;:::o;21137:222::-;21230:4;21268:2;21257:9;21253:18;21245:26;;21281:71;21349:1;21338:9;21334:17;21325:6;21281:71;:::i;:::-;21137:222;;;;:::o;21365:143::-;21422:5;21453:6;21447:13;21438:22;;21469:33;21496:5;21469:33;:::i;:::-;21365:143;;;;:::o;21514:351::-;21584:6;21633:2;21621:9;21612:7;21608:23;21604:32;21601:119;;;21639:79;;:::i;:::-;21601:119;21759:1;21784:64;21840:7;21831:6;21820:9;21816:22;21784:64;:::i;:::-;21774:74;;21730:128;21514:351;;;;:::o;21871:194::-;21911:4;21931:20;21949:1;21931:20;:::i;:::-;21926:25;;21965:20;21983:1;21965:20;:::i;:::-;21960:25;;22009:1;22006;22002:9;21994:17;;22033:1;22027:4;22024:11;22021:37;;;22038:18;;:::i;:::-;22021:37;21871:194;;;;:::o;22071:170::-;22211:22;22207:1;22199:6;22195:14;22188:46;22071:170;:::o;22247:366::-;22389:3;22410:67;22474:2;22469:3;22410:67;:::i;:::-;22403:74;;22486:93;22575:3;22486:93;:::i;:::-;22604:2;22599:3;22595:12;22588:19;;22247:366;;;:::o;22619:419::-;22785:4;22823:2;22812:9;22808:18;22800:26;;22872:9;22866:4;22862:20;22858:1;22847:9;22843:17;22836:47;22900:131;23026:4;22900:131;:::i;:::-;22892:139;;22619:419;;;:::o;23044:223::-;23184:34;23180:1;23172:6;23168:14;23161:58;23253:6;23248:2;23240:6;23236:15;23229:31;23044:223;:::o;23273:366::-;23415:3;23436:67;23500:2;23495:3;23436:67;:::i;:::-;23429:74;;23512:93;23601:3;23512:93;:::i;:::-;23630:2;23625:3;23621:12;23614:19;;23273:366;;;:::o;23645:419::-;23811:4;23849:2;23838:9;23834:18;23826:26;;23898:9;23892:4;23888:20;23884:1;23873:9;23869:17;23862:47;23926:131;24052:4;23926:131;:::i;:::-;23918:139;;23645:419;;;:::o;24070:170::-;24210:22;24206:1;24198:6;24194:14;24187:46;24070:170;:::o;24246:366::-;24388:3;24409:67;24473:2;24468:3;24409:67;:::i;:::-;24402:74;;24485:93;24574:3;24485:93;:::i;:::-;24603:2;24598:3;24594:12;24587:19;;24246:366;;;:::o;24618:419::-;24784:4;24822:2;24811:9;24807:18;24799:26;;24871:9;24865:4;24861:20;24857:1;24846:9;24842:17;24835:47;24899:131;25025:4;24899:131;:::i;:::-;24891:139;;24618:419;;;:::o;25043:332::-;25164:4;25202:2;25191:9;25187:18;25179:26;;25215:71;25283:1;25272:9;25268:17;25259:6;25215:71;:::i;:::-;25296:72;25364:2;25353:9;25349:18;25340:6;25296:72;:::i;:::-;25043:332;;;;;:::o;25381:137::-;25435:5;25466:6;25460:13;25451:22;;25482:30;25506:5;25482:30;:::i;:::-;25381:137;;;;:::o;25524:345::-;25591:6;25640:2;25628:9;25619:7;25615:23;25611:32;25608:119;;;25646:79;;:::i;:::-;25608:119;25766:1;25791:61;25844:7;25835:6;25824:9;25820:22;25791:61;:::i;:::-;25781:71;;25737:125;25524:345;;;;:::o;25875:442::-;26024:4;26062:2;26051:9;26047:18;26039:26;;26075:71;26143:1;26132:9;26128:17;26119:6;26075:71;:::i;:::-;26156:72;26224:2;26213:9;26209:18;26200:6;26156:72;:::i;:::-;26238;26306:2;26295:9;26291:18;26282:6;26238:72;:::i;:::-;25875:442;;;;;;:::o;26323:229::-;26463:34;26459:1;26451:6;26447:14;26440:58;26532:12;26527:2;26519:6;26515:15;26508:37;26323:229;:::o;26558:366::-;26700:3;26721:67;26785:2;26780:3;26721:67;:::i;:::-;26714:74;;26797:93;26886:3;26797:93;:::i;:::-;26915:2;26910:3;26906:12;26899:19;;26558:366;;;:::o;26930:419::-;27096:4;27134:2;27123:9;27119:18;27111:26;;27183:9;27177:4;27173:20;27169:1;27158:9;27154:17;27147:47;27211:131;27337:4;27211:131;:::i;:::-;27203:139;;26930:419;;;:::o;27355:225::-;27495:34;27491:1;27483:6;27479:14;27472:58;27564:8;27559:2;27551:6;27547:15;27540:33;27355:225;:::o;27586:366::-;27728:3;27749:67;27813:2;27808:3;27749:67;:::i;:::-;27742:74;;27825:93;27914:3;27825:93;:::i;:::-;27943:2;27938:3;27934:12;27927:19;;27586:366;;;:::o;27958:419::-;28124:4;28162:2;28151:9;28147:18;28139:26;;28211:9;28205:4;28201:20;28197:1;28186:9;28182:17;28175:47;28239:131;28365:4;28239:131;:::i;:::-;28231:139;;27958:419;;;:::o;28383:98::-;28434:6;28468:5;28462:12;28452:22;;28383:98;;;:::o;28487:147::-;28588:11;28625:3;28610:18;;28487:147;;;;:::o;28640:386::-;28744:3;28772:38;28804:5;28772:38;:::i;:::-;28826:88;28907:6;28902:3;28826:88;:::i;:::-;28819:95;;28923:65;28981:6;28976:3;28969:4;28962:5;28958:16;28923:65;:::i;:::-;29013:6;29008:3;29004:16;28997:23;;28748:278;28640:386;;;;:::o;29032:271::-;29162:3;29184:93;29273:3;29264:6;29184:93;:::i;:::-;29177:100;;29294:3;29287:10;;29032:271;;;;:::o;29309:179::-;29449:31;29445:1;29437:6;29433:14;29426:55;29309:179;:::o;29494:366::-;29636:3;29657:67;29721:2;29716:3;29657:67;:::i;:::-;29650:74;;29733:93;29822:3;29733:93;:::i;:::-;29851:2;29846:3;29842:12;29835:19;;29494:366;;;:::o;29866:419::-;30032:4;30070:2;30059:9;30055:18;30047:26;;30119:9;30113:4;30109:20;30105:1;30094:9;30090:17;30083:47;30147:131;30273:4;30147:131;:::i;:::-;30139:139;;29866:419;;;:::o;30291:313::-;30404:4;30442:2;30431:9;30427:18;30419:26;;30491:9;30485:4;30481:20;30477:1;30466:9;30462:17;30455:47;30519:78;30592:4;30583:6;30519:78;:::i;:::-;30511:86;;30291:313;;;;:::o

ipfs://b7afcfd69f68c6c9114d60e2d3fd44cafa9120a07d80aaaf5cc159c353074ade