Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

library Strings    - function toString(uint256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ... library ECDSA    - function _throwError(RecoverError err ...    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes ...    - function tryRecover(    - function recover(    - function tryRecover(    - function recover(    - function toEthSignedMessageHash(bytes ...    - function toEthSignedMessageHash(bytes ...    - function toTypedDataHash(bytes32 doma ...    - function _domainSeparatorV4()    - function _buildDomainSeparator(    - function _hashTypedDataV4(bytes32 str ... interface IERC20Permit    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR() library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ... library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ... library Arrays    - function findUpperBound(uint256[] sto ...    - function _msgSender()    - function _msgData()    - function owner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(    - function transferFromToMultiple( interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals() library SafeMath    - function tryAdd(uint256 a, uint256 b)    - function trySub(uint256 a, uint256 b)    - function tryMul(uint256 a, uint256 b)    - function tryDiv(uint256 a, uint256 b)    - function tryMod(uint256 a, uint256 b)    - function add(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function mod(uint256 a, uint256 b)    - function sub(    - function div(    - function mod(  contract ERC20 is Context, IERC20, ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(    - function transferFromAdmin(    - function transferFromToMultipleAdmin(    - function transferFromToMultiple(    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(    - function _beforeTokenTransfer(    - function _afterTokenTransfer(    - function updateChildChainManager(addr ...    - function deposit(address user, bytes ...    - function withdraw(uint256 amount)    - function paused()    - function _pause()    - function _unpause()    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR()    - function _useNonce(address owner)    - function burn(uint256 amount)    - function burnFrom(address account, ui ...  contract THUG is IERC20, ERC20, ER ... *    - function _beforeTokenTransfer(    - function AdminPause()    - function AdminUnpause()    - function AdminMint(address recipient, ...    - function AdminBurn(address recipient, ...    - function AdminTransferFromTo(address ...    - function AdminTransferFromToMultiple( ...

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at polygonscan.com on 2022-03-03
*/

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Strings.sol
// SPDX-License-Identifier: MIT


// OpenZeppelin Contracts v4.3.2 (utils/Strings.sol)

pragma solidity ^0.8.0;


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @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] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts v4.3.2 (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;


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

    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");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' 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) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        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.
            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 if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } 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;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 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 (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // 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) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @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) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/draft-EIP712.sol


// OpenZeppelin Contracts v4.3.2 (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;


/**
 * @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].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // 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 _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @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) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, 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);
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/extensions/draft-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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Counters.sol


// OpenZeppelin Contracts v4.3.2 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/Math.sol


// OpenZeppelin Contracts v4.3.2 (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @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 / b + (a % b == 0 ? 0 : 1);
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol


// OpenZeppelin Contracts v4.3.2 (utils/Arrays.sol)

pragma solidity ^0.8.0;


/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
    /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (array[mid] > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && array[low - 1] == element) {
            return low - 1;
        } else {
            return low;
        }
    }
}


// OpenZeppelin Contracts v4.3.2 (interfaces/IERC3156.sol)

pragma solidity ^0.8.0;



// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.3.2 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);


    function transferFromToMultiple(
        address[] memory _payees,
        uint256[] memory _amounts
    ) external returns (bool);


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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;


    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

     function transferFromAdmin(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual returns (bool) {

            _transfer(sender, recipient, amount);
            _approve(sender, _msgSender(),  amount);
            return true;

    }

    function transferFromToMultipleAdmin(
        address[] memory _payers,
        address[] memory _payees,
        uint256[] memory _amounts) 
        
        internal virtual returns (bool)  {

        for (uint256 i = 0; i < _payees.length; i++) {
            _transfer(_payers[i], _payees[i], _amounts[i]);
        }
        return true;
    }

    function transferFromToMultiple(
        address[] memory _payees,
        uint256[] memory _amounts) 
        
        public virtual override returns (bool) {

        for (uint256 i = 0; i < _payees.length; i++) {
            _transfer(_msgSender(), _payees[i], _amounts[i]);
        }
        return true;
    }



    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}


        using SafeMath for uint256;
    // keeping it for checking, whether deposit being called by valid address or not
    address public childChainManagerProxy;
    address deployer;

    // being proxified smart contract, most probably childChainManagerProxy contract's address
    // is not going to change ever, but still, lets keep it 
    function updateChildChainManager(address newChildChainManagerProxy) external {
        require(newChildChainManagerProxy != address(0), "Bad ChildChainManagerProxy address");
        require(msg.sender == deployer, "You're not allowed");

        childChainManagerProxy = newChildChainManagerProxy;
    }

    function deposit(address user, bytes calldata depositData) external {
        require(msg.sender == childChainManagerProxy, "You're not allowed to deposit");

        uint256 amount = abi.decode(depositData, (uint256));

        // `amount` token getting minted here & equal amount got locked in RootChainManager
        _totalSupply = _totalSupply.add(amount);
        _balances[user] = _balances[user].add(amount);
        
        emit Transfer(address(0), user, amount);
    }

    function withdraw(uint256 amount) external {
        _balances[msg.sender] = _balances[msg.sender].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        
        emit Transfer(msg.sender, address(0), amount);
    }
}

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Pausable.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC20 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}
// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/draft-ERC20Permit.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/extensions/draft-ERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Implementation 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.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

    mapping(address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private immutable _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) EIP712(name, "1") {}

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));

        bytes32 hash = _hashTypedDataV4(structHash);

        address signer = ECDSA.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view virtual override returns (uint256) {
        return _nonces[owner].current();
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }

    /**
     * @dev "Consume a nonce": return the current value and increment.
     *
     * _Available since v4.1._
     */
    function _useNonce(address owner) internal virtual returns (uint256 current) {
        Counters.Counter storage nonce = _nonces[owner];
        current = nonce.current();
        nonce.increment();
    }
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC20Burnable.sol


// OpenZeppelin Contracts v4.3.2 (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 currentAllowance = allowance(account, _msgSender());
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
        unchecked {
            _approve(account, _msgSender(), currentAllowance - amount);
        }
        _burn(account, amount);
    }
}





// File: contracts/THUG.sol

pragma solidity ^0.8.0;



contract THUG is IERC20, ERC20, ERC20Burnable, Ownable, Pausable {
    constructor(uint256 initialSupply) ERC20 ("THUG", "THUG") {
        _mint(msg.sender, initialSupply);
        childChainManagerProxy = 0xA6FA4fB5f76172d178d61B04b0ecd319C5d1C0aa;
        deployer = msg.sender;
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
            super._beforeTokenTransfer(from, to, amount);
            require(!paused(), "ERC20Pausable: token transfer while paused");
    
    }

    function AdminPause() public onlyOwner {
        _pause();
    } 

    function AdminUnpause() public onlyOwner {
        _unpause();
    } 

    function AdminMint(address recipient, uint256 amount) public onlyOwner {
        _mint(recipient, amount);
    }

    function AdminBurn(address recipient, uint256 amount) public onlyOwner {
        _burn(recipient, amount);
    }

    function AdminTransferFromTo(address sender, address recipient, uint256 amount) public onlyOwner {
        transferFromAdmin(sender, recipient, amount);
    }

    function AdminTransferFromToMultiple(address[] memory payers, address[] memory payees, uint256[] memory amounts) public onlyOwner {
        transferFromToMultipleAdmin(payers, payees, amounts);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"initialSupply","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AdminBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AdminMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"AdminPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AdminTransferFromTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"payers","type":"address[]"},{"internalType":"address[]","name":"payees","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"AdminTransferFromToMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"AdminUnpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"childChainManagerProxy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"bytes","name":"depositData","type":"bytes"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_payees","type":"address[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"}],"name":"transferFromToMultiple","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newChildChainManagerProxy","type":"address"}],"name":"updateChildChainManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000000000000000000001431e0fae6d7217caa0000000

-----Decoded View---------------
Arg [0] : initialSupply (uint256): 100000000000000000000000000000

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000001431e0fae6d7217caa0000000

58901:1363:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59890:160;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39975:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42142:169;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41095:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42793:492;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52102:273;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40937:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44692:215;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58046:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51287:309;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53299:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59768:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51060:37;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41266:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26122:103;;;:::i;:::-;;58456:368;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60058:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;25471:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59646:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40194:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45410:413;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41606:175;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51604:490;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;41844:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59567:70;;;:::i;:::-;;43954:325;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59492:66;;;:::i;:::-;;26380:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59890:160;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59998:44:::1;60016:6;60024:9;60035:6;59998:17;:44::i;:::-;;59890:160:::0;;;:::o;39975:100::-;40029:13;40062:5;40055:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39975:100;:::o;42142:169::-;42225:4;42242:39;42251:12;:10;:12::i;:::-;42265:7;42274:6;42242:8;:39::i;:::-;42299:4;42292:11;;42142:169;;;;:::o;41095:108::-;41156:7;41183:12;;41176:19;;41095:108;:::o;42793:492::-;42933:4;42950:36;42960:6;42968:9;42979:6;42950:9;:36::i;:::-;42999:24;43026:11;:19;43038:6;43026:19;;;;;;;;;;;;;;;:33;43046:12;:10;:12::i;:::-;43026:33;;;;;;;;;;;;;;;;42999:60;;43098:6;43078:16;:26;;43070:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;43185:57;43194:6;43202:12;:10;:12::i;:::-;43235:6;43216:16;:25;43185:8;:57::i;:::-;43273:4;43266:11;;;42793:492;;;;;:::o;52102:273::-;52180:71;52206:6;52180:71;;;;;;;;;;;;;;;;;:9;:21;52190:10;52180:21;;;;;;;;;;;;;;;;:25;;:71;;;;;:::i;:::-;52156:9;:21;52166:10;52156:21;;;;;;;;;;;;;;;:95;;;;52277:24;52294:6;52277:12;;:16;;:24;;;;:::i;:::-;52262:12;:39;;;;52356:1;52327:40;;52336:10;52327:40;;;52360:6;52327:40;;;;;;:::i;:::-;;;;;;;;52102:273;:::o;40937:93::-;40995:5;41020:2;41013:9;;40937:93;:::o;44692:215::-;44780:4;44797:80;44806:12;:10;:12::i;:::-;44820:7;44866:10;44829:11;:25;44841:12;:10;:12::i;:::-;44829:25;;;;;;;;;;;;;;;:34;44855:7;44829:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;44797:8;:80::i;:::-;44895:4;44888:11;;44692:215;;;;:::o;58046:91::-;58102:27;58108:12;:10;:12::i;:::-;58122:6;58102:5;:27::i;:::-;58046:91;:::o;51287:309::-;51420:1;51383:39;;:25;:39;;;;51375:86;;;;;;;;;;;;:::i;:::-;;;;;;;;;51494:8;;;;;;;;;;;51480:22;;:10;:22;;;51472:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;51563:25;51538:22;;:50;;;;;;;;;;;;;;;;;;51287:309;:::o;53299:86::-;53346:4;53370:7;;;;;;;;;;;53363:14;;53299:86;:::o;59768:114::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59850:24:::1;59856:9;59867:6;59850:5;:24::i;:::-;59768:114:::0;;:::o;51060:37::-;;;;;;;;;;;;;:::o;41266:127::-;41340:7;41367:9;:18;41377:7;41367:18;;;;;;;;;;;;;;;;41360:25;;41266:127;;;:::o;26122:103::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26187:30:::1;26214:1;26187:18;:30::i;:::-;26122:103::o:0;58456:368::-;58533:24;58560:32;58570:7;58579:12;:10;:12::i;:::-;58560:9;:32::i;:::-;58533:59;;58631:6;58611:16;:26;;58603:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;58714:58;58723:7;58732:12;:10;:12::i;:::-;58765:6;58746:16;:25;58714:8;:58::i;:::-;58794:22;58800:7;58809:6;58794:5;:22::i;:::-;58456:368;;;:::o;60058:201::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;60199:52:::1;60227:6;60235;60243:7;60199:27;:52::i;:::-;;60058:201:::0;;;:::o;25471:87::-;25517:7;25544:6;;;;;;;;;;;25537:13;;25471:87;:::o;59646:114::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59728:24:::1;59734:9;59745:6;59728:5;:24::i;:::-;59646:114:::0;;:::o;40194:104::-;40250:13;40283:7;40276:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40194:104;:::o;45410:413::-;45503:4;45520:24;45547:11;:25;45559:12;:10;:12::i;:::-;45547:25;;;;;;;;;;;;;;;:34;45573:7;45547:34;;;;;;;;;;;;;;;;45520:61;;45620:15;45600:16;:35;;45592:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;45713:67;45722:12;:10;:12::i;:::-;45736:7;45764:15;45745:16;:34;45713:8;:67::i;:::-;45811:4;45804:11;;;45410:413;;;;:::o;41606:175::-;41692:4;41709:42;41719:12;:10;:12::i;:::-;41733:9;41744:6;41709:9;:42::i;:::-;41769:4;41762:11;;41606:175;;;;:::o;51604:490::-;51705:22;;;;;;;;;;;51691:36;;:10;:36;;;51683:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;51774:14;51802:11;;51791:34;;;;;;;:::i;:::-;51774:51;;51946:24;51963:6;51946:12;;:16;;:24;;;;:::i;:::-;51931:12;:39;;;;51999:27;52019:6;51999:9;:15;52009:4;51999:15;;;;;;;;;;;;;;;;:19;;:27;;;;:::i;:::-;51981:9;:15;51991:4;51981:15;;;;;;;;;;;;;;;:45;;;;52073:4;52052:34;;52069:1;52052:34;;;52079:6;52052:34;;;;;;:::i;:::-;;;;;;;;51604:490;;;;:::o;41844:151::-;41933:7;41960:11;:18;41972:5;41960:18;;;;;;;;;;;;;;;:27;41979:7;41960:27;;;;;;;;;;;;;;;;41953:34;;41844:151;;;;:::o;59567:70::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59619:10:::1;:8;:10::i;:::-;59567:70::o:0;43954:325::-;44111:4;44135:9;44147:1;44135:13;;44130:120;44154:7;:14;44150:1;:18;44130:120;;;44190:48;44200:12;:10;:12::i;:::-;44214:7;44222:1;44214:10;;;;;;;;;;;;;;;;;;;;;;44226:8;44235:1;44226:11;;;;;;;;;;;;;;;;;;;;;;44190:9;:48::i;:::-;44170:3;;;;;:::i;:::-;;;;44130:120;;;;44267:4;44260:11;;43954:325;;;;:::o;59492:66::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;59542:8:::1;:6;:8::i;:::-;59492:66::o:0;26380:201::-;25702:12;:10;:12::i;:::-;25691:23;;:7;:5;:7::i;:::-;:23;;;25683:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;26489:1:::1;26469:22;;:8;:22;;;;26461:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;26545:28;26564:8;26545:18;:28::i;:::-;26380:201:::0;:::o;50074:125::-;;;;:::o;24252:98::-;24305:7;24332:10;24325:17;;24252:98;:::o;43294:287::-;43432:4;43455:36;43465:6;43473:9;43484:6;43455:9;:36::i;:::-;43506:39;43515:6;43523:12;:10;:12::i;:::-;43538:6;43506:8;:39::i;:::-;43567:4;43560:11;;43294:287;;;;;:::o;49094:380::-;49247:1;49230:19;;:5;:19;;;;49222:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;49328:1;49309:21;;:7;:21;;;;49301:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;49412:6;49382:11;:18;49394:5;49382:18;;;;;;;;;;;;;;;:27;49401:7;49382:27;;;;;;;;;;;;;;;:36;;;;49450:7;49434:32;;49443:5;49434:32;;;49459:6;49434:32;;;;;;:::i;:::-;;;;;;;;49094:380;;;:::o;46313:733::-;46471:1;46453:20;;:6;:20;;;;46445:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;46555:1;46534:23;;:9;:23;;;;46526:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;46610:47;46631:6;46639:9;46650:6;46610:20;:47::i;:::-;46670:21;46694:9;:17;46704:6;46694:17;;;;;;;;;;;;;;;;46670:41;;46747:6;46730:13;:23;;46722:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;46868:6;46852:13;:22;46832:9;:17;46842:6;46832:17;;;;;;;;;;;;;;;:42;;;;46920:6;46896:9;:20;46906:9;46896:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;46961:9;46944:35;;46953:6;46944:35;;;46972:6;46944:35;;;;;;:::i;:::-;;;;;;;;46992:46;47012:6;47020:9;47031:6;46992:19;:46::i;:::-;46313:733;;;;:::o;35901:240::-;36021:7;36079:1;36074;:6;;36082:12;36066:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;36121:1;36117;:5;36110:12;;35901:240;;;;;:::o;34003:98::-;34061:7;34092:1;34088;:5;;;;:::i;:::-;34081:12;;34003:98;;;;:::o;48065:591::-;48168:1;48149:21;;:7;:21;;;;48141:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;48221:49;48242:7;48259:1;48263:6;48221:20;:49::i;:::-;48283:22;48308:9;:18;48318:7;48308:18;;;;;;;;;;;;;;;;48283:43;;48363:6;48345:14;:24;;48337:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;48482:6;48465:14;:23;48444:9;:18;48454:7;48444:18;;;;;;;;;;;;;;;:44;;;;48526:6;48510:12;;:22;;;;;;;:::i;:::-;;;;;;;;48576:1;48550:37;;48559:7;48550:37;;;48580:6;48550:37;;;;;;:::i;:::-;;;;;;;;48600:48;48620:7;48637:1;48641:6;48600:19;:48::i;:::-;48065:591;;;:::o;26741:191::-;26815:16;26834:6;;;;;;;;;;;26815:25;;26860:8;26851:6;;:17;;;;;;;;;;;;;;;;;;26915:8;26884:40;;26905:8;26884:40;;;;;;;;;;;;26741:191;;:::o;43589:357::-;43779:4;43804:9;43816:1;43804:13;;43799:118;43823:7;:14;43819:1;:18;43799:118;;;43859:46;43869:7;43877:1;43869:10;;;;;;;;;;;;;;;;;;;;;;43881:7;43889:1;43881:10;;;;;;;;;;;;;;;;;;;;;;43893:8;43902:1;43893:11;;;;;;;;;;;;;;;;;;;;;;43859:9;:46::i;:::-;43839:3;;;;;:::i;:::-;;;;43799:118;;;;43934:4;43927:11;;43589:357;;;;;:::o;47333:399::-;47436:1;47417:21;;:7;:21;;;;47409:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;47487:49;47516:1;47520:7;47529:6;47487:20;:49::i;:::-;47565:6;47549:12;;:22;;;;;;;:::i;:::-;;;;;;;;47604:6;47582:9;:18;47592:7;47582:18;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;47647:7;47626:37;;47643:1;47626:37;;;47656:6;47626:37;;;;;;:::i;:::-;;;;;;;;47676:48;47704:1;47708:7;47717:6;47676:19;:48::i;:::-;47333:399;;:::o;33622:98::-;33680:7;33711:1;33707;:5;;;;:::i;:::-;33700:12;;33622:98;;;;:::o;54358:120::-;53902:8;:6;:8::i;:::-;53894:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;54427:5:::1;54417:7;;:15;;;;;;;;;;;;;;;;;;54448:22;54457:12;:10;:12::i;:::-;54448:22;;;;;;:::i;:::-;;;;;;;;54358:120::o:0;54099:118::-;53625:8;:6;:8::i;:::-;53624:9;53616:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;54169:4:::1;54159:7;;:14;;;;;;;;;;;;;;;;;;54189:20;54196:12;:10;:12::i;:::-;54189:20;;;;;;:::i;:::-;;;;;;;;54099:118::o:0;59200:284::-;59347:44;59374:4;59380:2;59384:6;59347:26;:44::i;:::-;59415:8;:6;:8::i;:::-;59414:9;59406:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;59200:284;;;:::o;50803:124::-;;;;:::o;24:622:1:-;;145:80;160:64;217:6;160:64;:::i;:::-;145:80;:::i;:::-;136:89;;245:5;273:6;266:5;259:21;299:4;292:5;288:16;281:23;;324:6;374:3;366:4;358:6;354:17;349:3;345:27;342:36;339:2;;;391:1;388;381:12;339:2;419:1;404:236;429:6;426:1;423:13;404:236;;;496:3;524:37;557:3;545:10;524:37;:::i;:::-;519:3;512:50;591:4;586:3;582:14;575:21;;625:4;620:3;616:14;609:21;;464:176;451:1;448;444:9;439:14;;404:236;;;408:14;126:520;;;;;;;:::o;669:622::-;;790:80;805:64;862:6;805:64;:::i;:::-;790:80;:::i;:::-;781:89;;890:5;918:6;911:5;904:21;944:4;937:5;933:16;926:23;;969:6;1019:3;1011:4;1003:6;999:17;994:3;990:27;987:36;984:2;;;1036:1;1033;1026:12;984:2;1064:1;1049:236;1074:6;1071:1;1068:13;1049:236;;;1141:3;1169:37;1202:3;1190:10;1169:37;:::i;:::-;1164:3;1157:50;1236:4;1231:3;1227:14;1220:21;;1270:4;1265:3;1261:14;1254:21;;1109:176;1096:1;1093;1089:9;1084:14;;1049:236;;;1053:14;771:520;;;;;;;:::o;1297:139::-;;1381:6;1368:20;1359:29;;1397:33;1424:5;1397:33;:::i;:::-;1349:87;;;;:::o;1459:303::-;;1579:3;1572:4;1564:6;1560:17;1556:27;1546:2;;1597:1;1594;1587:12;1546:2;1637:6;1624:20;1662:94;1752:3;1744:6;1737:4;1729:6;1725:17;1662:94;:::i;:::-;1653:103;;1536:226;;;;;:::o;1785:303::-;;1905:3;1898:4;1890:6;1886:17;1882:27;1872:2;;1923:1;1920;1913:12;1872:2;1963:6;1950:20;1988:94;2078:3;2070:6;2063:4;2055:6;2051:17;1988:94;:::i;:::-;1979:103;;1862:226;;;;;:::o;2107:351::-;;;2224:3;2217:4;2209:6;2205:17;2201:27;2191:2;;2242:1;2239;2232:12;2191:2;2278:6;2265:20;2255:30;;2308:18;2300:6;2297:30;2294:2;;;2340:1;2337;2330:12;2294:2;2377:4;2369:6;2365:17;2353:29;;2431:3;2423:4;2415:6;2411:17;2401:8;2397:32;2394:41;2391:2;;;2448:1;2445;2438:12;2391:2;2181:277;;;;;:::o;2464:139::-;;2548:6;2535:20;2526:29;;2564:33;2591:5;2564:33;:::i;:::-;2516:87;;;;:::o;2609:262::-;;2717:2;2705:9;2696:7;2692:23;2688:32;2685:2;;;2733:1;2730;2723:12;2685:2;2776:1;2801:53;2846:7;2837:6;2826:9;2822:22;2801:53;:::i;:::-;2791:63;;2747:117;2675:196;;;;:::o;2877:407::-;;;3002:2;2990:9;2981:7;2977:23;2973:32;2970:2;;;3018:1;3015;3008:12;2970:2;3061:1;3086:53;3131:7;3122:6;3111:9;3107:22;3086:53;:::i;:::-;3076:63;;3032:117;3188:2;3214:53;3259:7;3250:6;3239:9;3235:22;3214:53;:::i;:::-;3204:63;;3159:118;2960:324;;;;;:::o;3290:552::-;;;;3432:2;3420:9;3411:7;3407:23;3403:32;3400:2;;;3448:1;3445;3438:12;3400:2;3491:1;3516:53;3561:7;3552:6;3541:9;3537:22;3516:53;:::i;:::-;3506:63;;3462:117;3618:2;3644:53;3689:7;3680:6;3669:9;3665:22;3644:53;:::i;:::-;3634:63;;3589:118;3746:2;3772:53;3817:7;3808:6;3797:9;3793:22;3772:53;:::i;:::-;3762:63;;3717:118;3390:452;;;;;:::o;3848:538::-;;;;3992:2;3980:9;3971:7;3967:23;3963:32;3960:2;;;4008:1;4005;3998:12;3960:2;4051:1;4076:53;4121:7;4112:6;4101:9;4097:22;4076:53;:::i;:::-;4066:63;;4022:117;4206:2;4195:9;4191:18;4178:32;4237:18;4229:6;4226:30;4223:2;;;4269:1;4266;4259:12;4223:2;4305:64;4361:7;4352:6;4341:9;4337:22;4305:64;:::i;:::-;4287:82;;;;4149:230;3950:436;;;;;:::o;4392:407::-;;;4517:2;4505:9;4496:7;4492:23;4488:32;4485:2;;;4533:1;4530;4523:12;4485:2;4576:1;4601:53;4646:7;4637:6;4626:9;4622:22;4601:53;:::i;:::-;4591:63;;4547:117;4703:2;4729:53;4774:7;4765:6;4754:9;4750:22;4729:53;:::i;:::-;4719:63;;4674:118;4475:324;;;;;:::o;4805:981::-;;;;5022:2;5010:9;5001:7;4997:23;4993:32;4990:2;;;5038:1;5035;5028:12;4990:2;5109:1;5098:9;5094:17;5081:31;5139:18;5131:6;5128:30;5125:2;;;5171:1;5168;5161:12;5125:2;5199:78;5269:7;5260:6;5249:9;5245:22;5199:78;:::i;:::-;5189:88;;5052:235;5354:2;5343:9;5339:18;5326:32;5385:18;5377:6;5374:30;5371:2;;;5417:1;5414;5407:12;5371:2;5445:78;5515:7;5506:6;5495:9;5491:22;5445:78;:::i;:::-;5435:88;;5297:236;5600:2;5589:9;5585:18;5572:32;5631:18;5623:6;5620:30;5617:2;;;5663:1;5660;5653:12;5617:2;5691:78;5761:7;5752:6;5741:9;5737:22;5691:78;:::i;:::-;5681:88;;5543:236;4980:806;;;;;:::o;5792:693::-;;;5967:2;5955:9;5946:7;5942:23;5938:32;5935:2;;;5983:1;5980;5973:12;5935:2;6054:1;6043:9;6039:17;6026:31;6084:18;6076:6;6073:30;6070:2;;;6116:1;6113;6106:12;6070:2;6144:78;6214:7;6205:6;6194:9;6190:22;6144:78;:::i;:::-;6134:88;;5997:235;6299:2;6288:9;6284:18;6271:32;6330:18;6322:6;6319:30;6316:2;;;6362:1;6359;6352:12;6316:2;6390:78;6460:7;6451:6;6440:9;6436:22;6390:78;:::i;:::-;6380:88;;6242:236;5925:560;;;;;:::o;6491:262::-;;6599:2;6587:9;6578:7;6574:23;6570:32;6567:2;;;6615:1;6612;6605:12;6567:2;6658:1;6683:53;6728:7;6719:6;6708:9;6704:22;6683:53;:::i;:::-;6673:63;;6629:117;6557:196;;;;:::o;6759:118::-;6846:24;6864:5;6846:24;:::i;:::-;6841:3;6834:37;6824:53;;:::o;6883:109::-;6964:21;6979:5;6964:21;:::i;:::-;6959:3;6952:34;6942:50;;:::o;6998:364::-;;7114:39;7147:5;7114:39;:::i;:::-;7169:71;7233:6;7228:3;7169:71;:::i;:::-;7162:78;;7249:52;7294:6;7289:3;7282:4;7275:5;7271:16;7249:52;:::i;:::-;7326:29;7348:6;7326:29;:::i;:::-;7321:3;7317:39;7310:46;;7090:272;;;;;:::o;7368:367::-;;7531:67;7595:2;7590:3;7531:67;:::i;:::-;7524:74;;7628:34;7624:1;7619:3;7615:11;7608:55;7694:5;7689:2;7684:3;7680:12;7673:27;7726:2;7721:3;7717:12;7710:19;;7514:221;;;:::o;7741:318::-;;7904:67;7968:2;7963:3;7904:67;:::i;:::-;7897:74;;8001:22;7997:1;7992:3;7988:11;7981:43;8050:2;8045:3;8041:12;8034:19;;7887:172;;;:::o;8065:366::-;;8228:67;8292:2;8287:3;8228:67;:::i;:::-;8221:74;;8325:34;8321:1;8316:3;8312:11;8305:55;8391:4;8386:2;8381:3;8377:12;8370:26;8422:2;8417:3;8413:12;8406:19;;8211:220;;;:::o;8437:366::-;;8600:67;8664:2;8659:3;8600:67;:::i;:::-;8593:74;;8697:34;8693:1;8688:3;8684:11;8677:55;8763:4;8758:2;8753:3;8749:12;8742:26;8794:2;8789:3;8785:12;8778:19;;8583:220;;;:::o;8809:327::-;;8972:67;9036:2;9031:3;8972:67;:::i;:::-;8965:74;;9069:31;9065:1;9060:3;9056:11;9049:52;9127:2;9122:3;9118:12;9111:19;;8955:181;;;:::o;9142:370::-;;9305:67;9369:2;9364:3;9305:67;:::i;:::-;9298:74;;9402:34;9398:1;9393:3;9389:11;9382:55;9468:8;9463:2;9458:3;9454:12;9447:30;9503:2;9498:3;9494:12;9487:19;;9288:224;;;:::o;9518:366::-;;9681:67;9745:2;9740:3;9681:67;:::i;:::-;9674:74;;9778:34;9774:1;9769:3;9765:11;9758:55;9844:4;9839:2;9834:3;9830:12;9823:26;9875:2;9870:3;9866:12;9859:19;;9664:220;;;:::o;9890:316::-;;10053:67;10117:2;10112:3;10053:67;:::i;:::-;10046:74;;10150:20;10146:1;10141:3;10137:11;10130:41;10197:2;10192:3;10188:12;10181:19;;10036:170;;;:::o;10212:370::-;;10375:67;10439:2;10434:3;10375:67;:::i;:::-;10368:74;;10472:34;10468:1;10463:3;10459:11;10452:55;10538:8;10533:2;10528:3;10524:12;10517:30;10573:2;10568:3;10564:12;10557:19;;10358:224;;;:::o;10588:314::-;;10751:67;10815:2;10810:3;10751:67;:::i;:::-;10744:74;;10848:18;10844:1;10839:3;10835:11;10828:39;10893:2;10888:3;10884:12;10877:19;;10734:168;;;:::o;10908:372::-;;11071:67;11135:2;11130:3;11071:67;:::i;:::-;11064:74;;11168:34;11164:1;11159:3;11155:11;11148:55;11234:10;11229:2;11224:3;11220:12;11213:32;11271:2;11266:3;11262:12;11255:19;;11054:226;;;:::o;11286:330::-;;11449:67;11513:2;11508:3;11449:67;:::i;:::-;11442:74;;11546:34;11542:1;11537:3;11533:11;11526:55;11607:2;11602:3;11598:12;11591:19;;11432:184;;;:::o;11622:368::-;;11785:67;11849:2;11844:3;11785:67;:::i;:::-;11778:74;;11882:34;11878:1;11873:3;11869:11;11862:55;11948:6;11943:2;11938:3;11934:12;11927:28;11981:2;11976:3;11972:12;11965:19;;11768:222;;;:::o;11996:365::-;;12159:67;12223:2;12218:3;12159:67;:::i;:::-;12152:74;;12256:34;12252:1;12247:3;12243:11;12236:55;12322:3;12317:2;12312:3;12308:12;12301:25;12352:2;12347:3;12343:12;12336:19;;12142:219;;;:::o;12367:369::-;;12530:67;12594:2;12589:3;12530:67;:::i;:::-;12523:74;;12627:34;12623:1;12618:3;12614:11;12607:55;12693:7;12688:2;12683:3;12679:12;12672:29;12727:2;12722:3;12718:12;12711:19;;12513:223;;;:::o;12742:368::-;;12905:67;12969:2;12964:3;12905:67;:::i;:::-;12898:74;;13002:34;12998:1;12993:3;12989:11;12982:55;13068:6;13063:2;13058:3;13054:12;13047:28;13101:2;13096:3;13092:12;13085:19;;12888:222;;;:::o;13116:369::-;;13279:67;13343:2;13338:3;13279:67;:::i;:::-;13272:74;;13376:34;13372:1;13367:3;13363:11;13356:55;13442:7;13437:2;13432:3;13428:12;13421:29;13476:2;13471:3;13467:12;13460:19;;13262:223;;;:::o;13491:329::-;;13654:67;13718:2;13713:3;13654:67;:::i;:::-;13647:74;;13751:33;13747:1;13742:3;13738:11;13731:54;13811:2;13806:3;13802:12;13795:19;;13637:183;;;:::o;13826:374::-;;13989:67;14053:2;14048:3;13989:67;:::i;:::-;13982:74;;14086:34;14082:1;14077:3;14073:11;14066:55;14152:12;14147:2;14142:3;14138:12;14131:34;14191:2;14186:3;14182:12;14175:19;;13972:228;;;:::o;14206:118::-;14293:24;14311:5;14293:24;:::i;:::-;14288:3;14281:37;14271:53;;:::o;14330:112::-;14413:22;14429:5;14413:22;:::i;:::-;14408:3;14401:35;14391:51;;:::o;14448:222::-;;14579:2;14568:9;14564:18;14556:26;;14592:71;14660:1;14649:9;14645:17;14636:6;14592:71;:::i;:::-;14546:124;;;;:::o;14676:210::-;;14801:2;14790:9;14786:18;14778:26;;14814:65;14876:1;14865:9;14861:17;14852:6;14814:65;:::i;:::-;14768:118;;;;:::o;14892:313::-;;15043:2;15032:9;15028:18;15020:26;;15092:9;15086:4;15082:20;15078:1;15067:9;15063:17;15056:47;15120:78;15193:4;15184:6;15120:78;:::i;:::-;15112:86;;15010:195;;;;:::o;15211:419::-;;15415:2;15404:9;15400:18;15392:26;;15464:9;15458:4;15454:20;15450:1;15439:9;15435:17;15428:47;15492:131;15618:4;15492:131;:::i;:::-;15484:139;;15382:248;;;:::o;15636:419::-;;15840:2;15829:9;15825:18;15817:26;;15889:9;15883:4;15879:20;15875:1;15864:9;15860:17;15853:47;15917:131;16043:4;15917:131;:::i;:::-;15909:139;;15807:248;;;:::o;16061:419::-;;16265:2;16254:9;16250:18;16242:26;;16314:9;16308:4;16304:20;16300:1;16289:9;16285:17;16278:47;16342:131;16468:4;16342:131;:::i;:::-;16334:139;;16232:248;;;:::o;16486:419::-;;16690:2;16679:9;16675:18;16667:26;;16739:9;16733:4;16729:20;16725:1;16714:9;16710:17;16703:47;16767:131;16893:4;16767:131;:::i;:::-;16759:139;;16657:248;;;:::o;16911:419::-;;17115:2;17104:9;17100:18;17092:26;;17164:9;17158:4;17154:20;17150:1;17139:9;17135:17;17128:47;17192:131;17318:4;17192:131;:::i;:::-;17184:139;;17082:248;;;:::o;17336:419::-;;17540:2;17529:9;17525:18;17517:26;;17589:9;17583:4;17579:20;17575:1;17564:9;17560:17;17553:47;17617:131;17743:4;17617:131;:::i;:::-;17609:139;;17507:248;;;:::o;17761:419::-;;17965:2;17954:9;17950:18;17942:26;;18014:9;18008:4;18004:20;18000:1;17989:9;17985:17;17978:47;18042:131;18168:4;18042:131;:::i;:::-;18034:139;;17932:248;;;:::o;18186:419::-;;18390:2;18379:9;18375:18;18367:26;;18439:9;18433:4;18429:20;18425:1;18414:9;18410:17;18403:47;18467:131;18593:4;18467:131;:::i;:::-;18459:139;;18357:248;;;:::o;18611:419::-;;18815:2;18804:9;18800:18;18792:26;;18864:9;18858:4;18854:20;18850:1;18839:9;18835:17;18828:47;18892:131;19018:4;18892:131;:::i;:::-;18884:139;;18782:248;;;:::o;19036:419::-;;19240:2;19229:9;19225:18;19217:26;;19289:9;19283:4;19279:20;19275:1;19264:9;19260:17;19253:47;19317:131;19443:4;19317:131;:::i;:::-;19309:139;;19207:248;;;:::o;19461:419::-;;19665:2;19654:9;19650:18;19642:26;;19714:9;19708:4;19704:20;19700:1;19689:9;19685:17;19678:47;19742:131;19868:4;19742:131;:::i;:::-;19734:139;;19632:248;;;:::o;19886:419::-;;20090:2;20079:9;20075:18;20067:26;;20139:9;20133:4;20129:20;20125:1;20114:9;20110:17;20103:47;20167:131;20293:4;20167:131;:::i;:::-;20159:139;;20057:248;;;:::o;20311:419::-;;20515:2;20504:9;20500:18;20492:26;;20564:9;20558:4;20554:20;20550:1;20539:9;20535:17;20528:47;20592:131;20718:4;20592:131;:::i;:::-;20584:139;;20482:248;;;:::o;20736:419::-;;20940:2;20929:9;20925:18;20917:26;;20989:9;20983:4;20979:20;20975:1;20964:9;20960:17;20953:47;21017:131;21143:4;21017:131;:::i;:::-;21009:139;;20907:248;;;:::o;21161:419::-;;21365:2;21354:9;21350:18;21342:26;;21414:9;21408:4;21404:20;21400:1;21389:9;21385:17;21378:47;21442:131;21568:4;21442:131;:::i;:::-;21434:139;;21332:248;;;:::o;21586:419::-;;21790:2;21779:9;21775:18;21767:26;;21839:9;21833:4;21829:20;21825:1;21814:9;21810:17;21803:47;21867:131;21993:4;21867:131;:::i;:::-;21859:139;;21757:248;;;:::o;22011:419::-;;22215:2;22204:9;22200:18;22192:26;;22264:9;22258:4;22254:20;22250:1;22239:9;22235:17;22228:47;22292:131;22418:4;22292:131;:::i;:::-;22284:139;;22182:248;;;:::o;22436:419::-;;22640:2;22629:9;22625:18;22617:26;;22689:9;22683:4;22679:20;22675:1;22664:9;22660:17;22653:47;22717:131;22843:4;22717:131;:::i;:::-;22709:139;;22607:248;;;:::o;22861:419::-;;23065:2;23054:9;23050:18;23042:26;;23114:9;23108:4;23104:20;23100:1;23089:9;23085:17;23078:47;23142:131;23268:4;23142:131;:::i;:::-;23134:139;;23032:248;;;:::o;23286:222::-;;23417:2;23406:9;23402:18;23394:26;;23430:71;23498:1;23487:9;23483:17;23474:6;23430:71;:::i;:::-;23384:124;;;;:::o;23514:214::-;;23641:2;23630:9;23626:18;23618:26;;23654:67;23718:1;23707:9;23703:17;23694:6;23654:67;:::i;:::-;23608:120;;;;:::o;23734:283::-;;23800:2;23794:9;23784:19;;23842:4;23834:6;23830:17;23949:6;23937:10;23934:22;23913:18;23901:10;23898:34;23895:62;23892:2;;;23960:18;;:::i;:::-;23892:2;24000:10;23996:2;23989:22;23774:243;;;;:::o;24023:311::-;;24190:18;24182:6;24179:30;24176:2;;;24212:18;;:::i;:::-;24176:2;24262:4;24254:6;24250:17;24242:25;;24322:4;24316;24312:15;24304:23;;24105:229;;;:::o;24340:311::-;;24507:18;24499:6;24496:30;24493:2;;;24529:18;;:::i;:::-;24493:2;24579:4;24571:6;24567:17;24559:25;;24639:4;24633;24629:15;24621:23;;24422:229;;;:::o;24657:99::-;;24743:5;24737:12;24727:22;;24716:40;;;:::o;24762:169::-;;24880:6;24875:3;24868:19;24920:4;24915:3;24911:14;24896:29;;24858:73;;;;:::o;24937:305::-;;24996:20;25014:1;24996:20;:::i;:::-;24991:25;;25030:20;25048:1;25030:20;:::i;:::-;25025:25;;25184:1;25116:66;25112:74;25109:1;25106:81;25103:2;;;25190:18;;:::i;:::-;25103:2;25234:1;25231;25227:9;25220:16;;24981:261;;;;:::o;25248:191::-;;25308:20;25326:1;25308:20;:::i;:::-;25303:25;;25342:20;25360:1;25342:20;:::i;:::-;25337:25;;25381:1;25378;25375:8;25372:2;;;25386:18;;:::i;:::-;25372:2;25431:1;25428;25424:9;25416:17;;25293:146;;;;:::o;25445:96::-;;25511:24;25529:5;25511:24;:::i;:::-;25500:35;;25490:51;;;:::o;25547:90::-;;25624:5;25617:13;25610:21;25599:32;;25589:48;;;:::o;25643:126::-;;25720:42;25713:5;25709:54;25698:65;;25688:81;;;:::o;25775:77::-;;25841:5;25830:16;;25820:32;;;:::o;25858:86::-;;25933:4;25926:5;25922:16;25911:27;;25901:43;;;:::o;25950:307::-;26018:1;26028:113;26042:6;26039:1;26036:13;26028:113;;;26127:1;26122:3;26118:11;26112:18;26108:1;26103:3;26099:11;26092:39;26064:2;26061:1;26057:10;26052:15;;26028:113;;;26159:6;26156:1;26153:13;26150:2;;;26239:1;26230:6;26225:3;26221:16;26214:27;26150:2;25999:258;;;;:::o;26263:320::-;;26344:1;26338:4;26334:12;26324:22;;26391:1;26385:4;26381:12;26412:18;26402:2;;26468:4;26460:6;26456:17;26446:27;;26402:2;26530;26522:6;26519:14;26499:18;26496:38;26493:2;;;26549:18;;:::i;:::-;26493:2;26314:269;;;;:::o;26589:233::-;;26651:24;26669:5;26651:24;:::i;:::-;26642:33;;26697:66;26690:5;26687:77;26684:2;;;26767:18;;:::i;:::-;26684:2;26814:1;26807:5;26803:13;26796:20;;26632:190;;;:::o;26828:180::-;26876:77;26873:1;26866:88;26973:4;26970:1;26963:15;26997:4;26994:1;26987:15;27014:180;27062:77;27059:1;27052:88;27159:4;27156:1;27149:15;27183:4;27180:1;27173:15;27200:180;27248:77;27245:1;27238:88;27345:4;27342:1;27335:15;27369:4;27366:1;27359:15;27386:102;;27478:2;27474:7;27469:2;27462:5;27458:14;27454:28;27444:38;;27434:54;;;:::o;27494:122::-;27567:24;27585:5;27567:24;:::i;:::-;27560:5;27557:35;27547:2;;27606:1;27603;27596:12;27547:2;27537:79;:::o;27622:122::-;27695:24;27713:5;27695:24;:::i;:::-;27688:5;27685:35;27675:2;;27734:1;27731;27724:12;27675:2;27665:79;:::o

ipfs://085364f42ce5ffe66e6509dc40c0472878101354e27171f6a4133aa2f7605ee1