Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "./ERC20.sol";
import "./ERC20Burnable.sol";
import "./ERC20Snapshot.sol";
import "./AccessControl.sol";
import "./draft-ERC20Permit.sol";

contract IAGON is ERC20, ERC20Burnable, ERC20Snapshot, AccessControl, ERC20Permit {
    bytes32 public constant SNAPSHOT_ROLE = keccak256("SNAPSHOT_ROLE");

    constructor() ERC20("IAGON", "IAG") ERC20Permit("IAGON") {
        _setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _setupRole(SNAPSHOT_ROLE, msg.sender);
        _mint(msg.sender, 1000000000 * 10 ** decimals());
    }

    function snapshot() public {
        require(hasRole(SNAPSHOT_ROLE, msg.sender));
        _snapshot();
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount)
        internal
        override(ERC20, ERC20Snapshot)
    {
        super._beforeTokenTransfer(from, to, amount);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";
import "./Strings.sol";
import "./ERC165.sol";

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    function hasRole(bytes32 role, address account) external view returns (bool);
    function getRoleAdmin(bytes32 role) external view returns (bytes32);
    function grantRole(bytes32 role, address account) external;
    function revokeRole(bytes32 role, address account) external;
    function renounceRole(bytes32 role, address account) external;
}

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping (address => bool) members;
        bytes32 adminRole;
    }

    mapping (bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role, _msgSender());
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId
            || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/
     */
    function _checkRole(bytes32 role, address account) internal view {
        if(!hasRole(role, account)) {
            revert(string(abi.encodePacked(
                "AccessControl: account ",
                Strings.toHexString(uint160(account), 20),
                " is missing role ",
                Strings.toHexString(uint256(role), 32)
            )));
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);
        _roles[role].adminRole = adminRole;
    }

    function _grantRole(bytes32 role, address account) private {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Math.sol";

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

// SPDX-License-Identifier: MIT

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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. 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;
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
 * `CREATE2` can be used to compute in advance the address where a smart
 * contract will be deployed, which allows for interesting new mechanisms known
 * as 'counterfactual interactions'.
 *
 * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
 * information.
 */
library Create2 {
    /**
     * @dev Deploys a contract using `CREATE2`. The address where the contract
     * will be deployed can be known in advance via {computeAddress}.
     *
     * The bytecode for a contract can be obtained from Solidity with
     * `type(contractName).creationCode`.
     *
     * Requirements:
     *
     * - `bytecode` must not be empty.
     * - `salt` must have not been used for `bytecode` already.
     * - the factory must have a balance of at least `amount`.
     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
     */
    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address) {
        address addr;
        require(address(this).balance >= amount, "Create2: insufficient balance");
        require(bytecode.length != 0, "Create2: bytecode length is zero");
        // solhint-disable-next-line no-inline-assembly
        assembly {
            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
        }
        require(addr != address(0), "Create2: Failed on deploy");
        return addr;
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
     * `bytecodeHash` or `salt` will result in a new destination address.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
        return computeAddress(salt, bytecodeHash, address(this));
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address) {
        bytes32 _data = keccak256(
            abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash)
        );
        return address(uint160(uint256(_data)));
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ECDSA.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _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;

    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);
        _TYPE_HASH = typeHash;
    }

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./draft-IERC20Permit.sol";
import "./ERC20.sol";
import "./draft-EIP712.sol";
import "./ECDSA.sol";
import "./Counters.sol";

/**
 * @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 {
        // solhint-disable-next-line not-rely-on-time
        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();
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

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

// SPDX-License-Identifier: MIT

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 {
    /**
     * @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) {
        // Divide the signature in r, s and v variables
        bytes32 r;
        bytes32 s;
        uint8 v;

        // 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) {
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            // solhint-disable-next-line no-inline-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
        } else if (signature.length == 64) {
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            // solhint-disable-next-line no-inline-assembly
            assembly {
                let vs := mload(add(signature, 0x40))
                r := mload(add(signature, 0x20))
                s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
                v := add(shr(255, vs), 27)
            }
        } else {
            revert("ECDSA: invalid signature length");
        }

        return recover(hash, v, r, s);
    }

    /**
     * @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) {
        // 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 (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): 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.
        require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
        require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        require(signer != address(0), "ECDSA: invalid signature");

        return signer;
    }

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./IERC20Metadata.sol";
import "./Context.sol";

/**
 * @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 guidelines: functions revert instead
 * of 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 defaut 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");
        _approve(sender, _msgSender(), currentAllowance - amount);

        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");
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);

        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is 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");
        _balances[sender] = senderBalance - amount;
        _balances[recipient] += amount;

        emit Transfer(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:
     *
     * - `to` 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);
    }

    /**
     * @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");
        _balances[account] = accountBalance - amount;
        _totalSupply -= amount;

        emit Transfer(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 to 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 { }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC20.sol";
import "./Context.sol";

/**
 * @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");
        _approve(account, _msgSender(), currentAllowance - amount);
        _burn(account, amount);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC20.sol";
import "./Arrays.sol";
import "./Counters.sol";

/**
 * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and
 * total supply at the time are recorded for later access.
 *
 * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting.
 * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different
 * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be
 * used to create an efficient ERC20 forking mechanism.
 *
 * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a
 * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot
 * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id
 * and the account address.
 *
 * ==== Gas Costs
 *
 * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log
 * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much
 * smaller since identical balances in subsequent snapshots are stored as a single entry.
 *
 * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is
 * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent
 * transfers will have normal cost until the next snapshot, and so on.
 */
abstract contract ERC20Snapshot is ERC20 {
    // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
    // https://github.com/Giveth/minimd/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

    using Arrays for uint256[];
    using Counters for Counters.Counter;

    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
    // Snapshot struct, but that would impede usage of functions that work on an array.
    struct Snapshots {
        uint256[] ids;
        uint256[] values;
    }

    mapping (address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;

    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
    Counters.Counter private _currentSnapshotId;

    /**
     * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created.
     */
    event Snapshot(uint256 id);

    /**
     * @dev Creates a new snapshot and returns its snapshot id.
     *
     * Emits a {Snapshot} event that contains the same id.
     *
     * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
     * set of accounts, for example using {AccessControl}, or it may be open to the public.
     *
     * [WARNING]
     * ====
     * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking,
     * you must consider that it can potentially be used by attackers in two ways.
     *
     * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow
     * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target
     * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs
     * section above.
     *
     * We haven't measured the actual numbers; if this is something you're interested in please reach out to us.
     * ====
     */
    function _snapshot() internal virtual returns (uint256) {
        _currentSnapshotId.increment();

        uint256 currentId = _currentSnapshotId.current();
        emit Snapshot(currentId);
        return currentId;
    }

    /**
     * @dev Retrieves the balance of `account` at the time `snapshotId` was created.
     */
    function balanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);

        return snapshotted ? value : balanceOf(account);
    }

    /**
     * @dev Retrieves the total supply at the time `snapshotId` was created.
     */
    function totalSupplyAt(uint256 snapshotId) public view virtual returns(uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);

        return snapshotted ? value : totalSupply();
    }


    // Update balance and/or total supply snapshots before the values are modified. This is implemented
    // in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations.
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
      super._beforeTokenTransfer(from, to, amount);

      if (from == address(0)) {
        // mint
        _updateAccountSnapshot(to);
        _updateTotalSupplySnapshot();
      } else if (to == address(0)) {
        // burn
        _updateAccountSnapshot(from);
        _updateTotalSupplySnapshot();
      } else {
        // transfer
        _updateAccountSnapshot(from);
        _updateAccountSnapshot(to);
      }
    }

    function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
        private view returns (bool, uint256)
    {
        require(snapshotId > 0, "ERC20Snapshot: id is 0");
        // solhint-disable-next-line max-line-length
        require(snapshotId <= _currentSnapshotId.current(), "ERC20Snapshot: nonexistent id");

        // When a valid snapshot is queried, there are three possibilities:
        //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
        //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
        //  to this id is the current one.
        //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
        //  requested id, and its value is the one to return.
        //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
        //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
        //  larger than the requested one.
        //
        // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
        // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
        // exactly this.

        uint256 index = snapshots.ids.findUpperBound(snapshotId);

        if (index == snapshots.ids.length) {
            return (false, 0);
        } else {
            return (true, snapshots.values[index]);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }

    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
        uint256 currentId = _currentSnapshotId.current();
        if (_lastSnapshotId(snapshots.ids) < currentId) {
            snapshots.ids.push(currentId);
            snapshots.values.push(currentValue);
        }
    }

    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
        if (ids.length == 0) {
            return 0;
        } else {
            return ids[ids.length - 1];
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";

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

// SPDX-License-Identifier: MIT

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, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Address.sol";

/**
 * @dev Provides a function to batch together multiple calls in a single external call.
 *
 * _Available since v4.1._
 */
abstract contract Multicall {
    /**
    * @dev Receives and executes a batch of function calls on this contract.
    */
    function multicall(bytes[] calldata data) external returns (bytes[] memory results) {
        results = new bytes[](data.length);
        for (uint i = 0; i < data.length; i++) {
            results[i] = Address.functionDelegateCall(address(this), data[i]);
        }
        return results;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant alphabet = "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] = alphabet[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"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":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","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"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SNAPSHOT_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","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":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","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":"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":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"snapshot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","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"}]

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

213:717:21:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4038:214:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2056:98:8;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4153:166;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3144:106;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4786:414;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5313:121:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5684:145;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2993:91:8;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2482:113:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6701:214:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5595:212:8;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;473:89:9;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4191:262:10;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;302:66:21;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3308:125:8;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;868:327:9;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2232:126:19;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4339:137:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2267:102:8;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;610:111:21;;;:::i;:::-;;4552:229:10;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2359:49:0;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6294:371:8;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3636:172;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1421:750:19;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;6063:147:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3866:149:8;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4038:214:0;4123:4;4161:32;4146:47;;;:11;:47;;;;:99;;;;4209:36;4233:11;4209:23;:36::i;:::-;4146:99;4139:106;;4038:214;;;:::o;2056:98:8:-;2110:13;2142:5;2135:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2056:98;:::o;4153:166::-;4236:4;4252:39;4261:12;:10;:12::i;:::-;4275:7;4284:6;4252:8;:39::i;:::-;4308:4;4301:11;;4153:166;;;;:::o;3144:106::-;3205:7;3231:12;;3224:19;;3144:106;:::o;4786:414::-;4892:4;4908:36;4918:6;4926:9;4937:6;4908:9;:36::i;:::-;4955:24;4982:11;:19;4994:6;4982:19;;;;;;;;;;;;;;;:33;5002:12;:10;:12::i;:::-;4982:33;;;;;;;;;;;;;;;;4955:60;;5053:6;5033:16;:26;;5025:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;5114:57;5123:6;5131:12;:10;:12::i;:::-;5164:6;5145:16;:25;;;;:::i;:::-;5114:8;:57::i;:::-;5189:4;5182:11;;;4786:414;;;;;:::o;5313:121:0:-;5379:7;5405:6;:12;5412:4;5405:12;;;;;;;;;;;:22;;;5398:29;;5313:121;;;:::o;5684:145::-;5767:18;5780:4;5767:12;:18::i;:::-;3923:30;3934:4;3940:12;:10;:12::i;:::-;3923:10;:30::i;:::-;5797:25:::1;5808:4;5814:7;5797:10;:25::i;:::-;5684:145:::0;;;:::o;2993:91:8:-;3051:5;3075:2;3068:9;;2993:91;:::o;2482:113:19:-;2542:7;2568:20;:18;:20::i;:::-;2561:27;;2482:113;:::o;6701:214:0:-;6807:12;:10;:12::i;:::-;6796:23;;:7;:23;;;6788:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;6882:26;6894:4;6900:7;6882:11;:26::i;:::-;6701:214;;:::o;5595:212:8:-;5683:4;5699:80;5708:12;:10;:12::i;:::-;5722:7;5768:10;5731:11;:25;5743:12;:10;:12::i;:::-;5731:25;;;;;;;;;;;;;;;:34;5757:7;5731:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;5699:8;:80::i;:::-;5796:4;5789:11;;5595:212;;;;:::o;473:89:9:-;528:27;534:12;:10;:12::i;:::-;548:6;528:5;:27::i;:::-;473:89;:::o;4191:262:10:-;4278:7;4298:16;4316:13;4333:55;4342:10;4354:24;:33;4379:7;4354:33;;;;;;;;;;;;;;;4333:8;:55::i;:::-;4297:91;;;;4406:11;:40;;4428:18;4438:7;4428:9;:18::i;:::-;4406:40;;;4420:5;4406:40;4399:47;;;;4191:262;;;;:::o;302:66:21:-;342:26;302:66;:::o;3308:125:8:-;3382:7;3408:9;:18;3418:7;3408:18;;;;;;;;;;;;;;;;3401:25;;3308:125;;;:::o;868:327:9:-;944:24;971:32;981:7;990:12;:10;:12::i;:::-;971:9;:32::i;:::-;944:59;;1041:6;1021:16;:26;;1013:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;1098:58;1107:7;1116:12;:10;:12::i;:::-;1149:6;1130:16;:25;;;;:::i;:::-;1098:8;:58::i;:::-;1166:22;1172:7;1181:6;1166:5;:22::i;:::-;868:327;;;:::o;2232:126:19:-;2301:7;2327:24;:7;:14;2335:5;2327:14;;;;;;;;;;;;;;;:22;:24::i;:::-;2320:31;;2232:126;;;:::o;4339:137:0:-;4417:4;4440:6;:12;4447:4;4440:12;;;;;;;;;;;:20;;:29;4461:7;4440:29;;;;;;;;;;;;;;;;;;;;;;;;;4433:36;;4339:137;;;;:::o;2267:102:8:-;2323:13;2355:7;2348:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2267:102;:::o;610:111:21:-;656:34;342:26;679:10;656:7;:34::i;:::-;648:43;;;;;;702:11;:9;:11::i;:::-;;610:111::o;4552:229:10:-;4623:7;4643:16;4661:13;4678:43;4687:10;4699:21;4678:8;:43::i;:::-;4642:79;;;;4739:11;:35;;4761:13;:11;:13::i;:::-;4739:35;;;4753:5;4739:35;4732:42;;;;4552:229;;;:::o;2359:49:0:-;2404:4;2359:49;;;:::o;6294:371:8:-;6387:4;6403:24;6430:11;:25;6442:12;:10;:12::i;:::-;6430:25;;;;;;;;;;;;;;;:34;6456:7;6430:34;;;;;;;;;;;;;;;;6403:61;;6502:15;6482:16;:35;;6474:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;6569:67;6578:12;:10;:12::i;:::-;6592:7;6620:15;6601:16;:34;;;;:::i;:::-;6569:8;:67::i;:::-;6654:4;6647:11;;;6294:371;;;;:::o;3636:172::-;3722:4;3738:42;3748:12;:10;:12::i;:::-;3762:9;3773:6;3738:9;:42::i;:::-;3797:4;3790:11;;3636:172;;;;:::o;1421:750:19:-;1648:8;1629:15;:27;;1621:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;1701:18;1773:16;1807:5;1830:7;1855:5;1878:16;1888:5;1878:9;:16::i;:::-;1912:8;1745:189;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;1722:222;;;;;;1701:243;;1955:12;1970:28;1987:10;1970:16;:28::i;:::-;1955:43;;2009:14;2026:28;2040:4;2046:1;2049;2052;2026:13;:28::i;:::-;2009:45;;2082:5;2072:15;;:6;:15;;;2064:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;2133:31;2142:5;2149:7;2158:5;2133:8;:31::i;:::-;1421:750;;;;;;;;;;:::o;6063:147:0:-;6147:18;6160:4;6147:12;:18::i;:::-;3923:30;3934:4;3940:12;:10;:12::i;:::-;3923:10;:30::i;:::-;6177:26:::1;6189:4;6195:7;6177:11;:26::i;:::-;6063:147:::0;;;:::o;3866:149:8:-;3955:7;3981:11;:18;3993:5;3981:18;;;;;;;;;;;;;;;:27;4000:7;3981:27;;;;;;;;;;;;;;;;3974:34;;3866:149;;;;:::o;4995:526:10:-;5101:44;5128:4;5134:2;5138:6;5101:26;:44::i;:::-;5174:1;5158:18;;:4;:18;;;5154:361;;;5204:26;5227:2;5204:22;:26::i;:::-;5240:28;:26;:28::i;:::-;5154:361;;;5301:1;5287:16;;:2;:16;;;5283:232;;;5331:28;5354:4;5331:22;:28::i;:::-;5369;:26;:28::i;:::-;5283:232;;;5442:28;5465:4;5442:22;:28::i;:::-;5480:26;5503:2;5480:22;:26::i;:::-;5283:232;5154:361;4995:526;;;:::o;10485:92:8:-;;;;:::o;773:112:4:-;838:7;864;:14;;;857:21;;773:112;;;:::o;763:155:7:-;848:4;886:25;871:40;;;:11;:40;;;;864:47;;763:155;;;:::o;586:96:3:-;639:7;665:10;658:17;;586:96;:::o;9558:340:8:-;9676:1;9659:19;;:5;:19;;;;9651:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;9756:1;9737:21;;:7;:21;;;;9729:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;9838:6;9808:11;:18;9820:5;9808:18;;;;;;;;;;;;;;;:27;9827:7;9808:27;;;;;;;;;;;;;;;:36;;;;9875:7;9859:32;;9868:5;9859:32;;;9884:6;9859:32;;;;;;:::i;:::-;;;;;;;;9558:340;;;:::o;7139:592::-;7262:1;7244:20;;:6;:20;;;;7236:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;7345:1;7324:23;;:9;:23;;;;7316:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;7398:47;7419:6;7427:9;7438:6;7398:20;:47::i;:::-;7456:21;7480:9;:17;7490:6;7480:17;;;;;;;;;;;;;;;;7456:41;;7532:6;7515:13;:23;;7507:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;7627:6;7611:13;:22;;;;:::i;:::-;7591:9;:17;7601:6;7591:17;;;;;;;;;;;;;;;:42;;;;7667:6;7643:9;:20;7653:9;7643:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;7706:9;7689:35;;7698:6;7689:35;;;7717:6;7689:35;;;;;;:::i;:::-;;;;;;;;7139:592;;;;:::o;4757:375:0:-;4836:22;4844:4;4850:7;4836;:22::i;:::-;4832:294;;4965:41;4993:7;4965:41;;5003:2;4965:19;:41::i;:::-;5061:38;5089:4;5081:13;;5096:2;5061:19;:38::i;:::-;4888:225;;;;;;;;;:::i;:::-;;;;;;;;;;;;;4874:241;;;;;;;;;;;:::i;:::-;;;;;;;;4832:294;4757:375;;:::o;7913:224::-;7987:22;7995:4;8001:7;7987;:22::i;:::-;7982:149;;8057:4;8025:6;:12;8032:4;8025:12;;;;;;;;;;;:20;;:29;8046:7;8025:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;8107:12;:10;:12::i;:::-;8080:40;;8098:7;8080:40;;8092:4;8080:40;;;;;;;;;;7982:149;7913:224;;:::o;2967:275:18:-;3020:7;3060:16;3043:13;:33;3039:197;;;3099:24;3092:31;;;;3039:197;3161:64;3183:10;3195:12;3209:15;3161:21;:64::i;:::-;3154:71;;2967:275;;:::o;8143:225:0:-;8217:22;8225:4;8231:7;8217;:22::i;:::-;8213:149;;;8287:5;8255:6;:12;8262:4;8255:12;;;;;;;;;;;:20;;:29;8276:7;8255:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;8338:12;:10;:12::i;:::-;8311:40;;8329:7;8311:40;;8323:4;8311:40;;;;;;;;;;8213:149;8143:225;;:::o;8652:483:8:-;8754:1;8735:21;;:7;:21;;;;8727:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;8805:49;8826:7;8843:1;8847:6;8805:20;:49::i;:::-;8865:22;8890:9;:18;8900:7;8890:18;;;;;;;;;;;;;;;;8865:43;;8944:6;8926:14;:24;;8918:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;9037:6;9020:14;:23;;;;:::i;:::-;8999:9;:18;9009:7;8999:18;;;;;;;;;;;;;;;:44;;;;9069:6;9053:12;;:22;;;;;;;:::i;:::-;;;;;;;;9117:1;9091:37;;9100:7;9091:37;;;9121:6;9091:37;;;;;;:::i;:::-;;;;;;;;8652:483;;;:::o;5527:1664:10:-;5624:4;5630:7;5674:1;5661:10;:14;5653:49;;;;;;;;;;;;:::i;:::-;;;;;;;;;5787:28;:18;:26;:28::i;:::-;5773:10;:42;;5765:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;6972:13;6988:40;7017:10;6988:9;:13;;:28;;:40;;;;:::i;:::-;6972:56;;7052:9;:13;;:20;;;;7043:5;:29;7039:146;;;7096:5;7103:1;7088:17;;;;;;;7039:146;7144:4;7150:9;:16;;7167:5;7150:23;;;;;;;;;;;;;;;;;;;;;;;;7136:38;;;;;5527:1664;;;;;;:::o;3862:222::-;3909:7;3928:30;:18;:28;:30::i;:::-;3969:17;3989:28;:18;:26;:28::i;:::-;3969:48;;4032:19;4041:9;4032:19;;;;;;:::i;:::-;;;;;;;;4068:9;4061:16;;;3862:222;:::o;2726:203:19:-;2786:15;2813:30;2846:7;:14;2854:5;2846:14;;;;;;;;;;;;;;;2813:47;;2880:15;:5;:13;:15::i;:::-;2870:25;;2905:17;:5;:15;:17::i;:::-;2726:203;;;;:::o;4200:165:18:-;4277:7;4303:55;4325:20;:18;:20::i;:::-;4347:10;4303:21;:55::i;:::-;4296:62;;4200:165;;;:::o;2656:1414:6:-;2741:7;3656:66;3650:1;3642:10;;:80;;3634:127;;;;;;;;;;;;:::i;:::-;;;;;;;;;3784:2;3779:1;:7;;;:18;;;;3795:2;3790:1;:7;;;3779:18;3771:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;3931:14;3948:24;3958:4;3964:1;3967;3970;3948:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3931:41;;4008:1;3990:20;;:6;:20;;;;3982:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;4057:6;4050:13;;;2656:1414;;;;;;:::o;7197:144:10:-;7264:70;7280:24;:33;7305:7;7280:33;;;;;;;;;;;;;;;7315:18;7325:7;7315:9;:18::i;:::-;7264:15;:70::i;:::-;7197:144;:::o;7347:116::-;7403:53;7419:21;7442:13;:11;:13::i;:::-;7403:15;:53::i;:::-;7347:116::o;729:198:21:-;875:44;902:4;908:2;912:6;875:26;:44::i;:::-;729:198;;;:::o;1531:437:17:-;1606:13;1631:19;1676:1;1667:6;1663:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;1653:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1631:47;;1688:15;:6;1695:1;1688:9;;;;;;;;;;;;;;;;;;;:15;;;;;;;;;;;1713;:6;1720:1;1713:9;;;;;;;;;;;;;;;;;;;:15;;;;;;;;;;;1743:9;1768:1;1759:6;1755:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;1743:26;;1738:128;1775:1;1771;:5;1738:128;;;1809:8;1826:3;1818:5;:11;1809:21;;;;;;;;;;;;;;;;;;1797:6;1804:1;1797:9;;;;;;;;;;;;;;;;;;;:33;;;;;;;;;;;1854:1;1844:11;;;;;1778:3;;;;:::i;:::-;;;1738:128;;;;1892:1;1883:5;:10;1875:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;1954:6;1940:21;;;1531:437;;;;:::o;3248:327:18:-;3350:7;3427:8;3453:4;3475:7;3500:13;3539:4;3399:159;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3376:192;;;;;;3369:199;;3248:327;;;;;:::o;576:892:2:-;665:7;704:1;688:5;:12;;;;:17;684:56;;;728:1;721:8;;;;684:56;750:11;775:12;790:5;:12;;;;775:27;;813:414;826:4;820:3;:10;813:414;;;846:11;860:23;873:3;878:4;860:12;:23::i;:::-;846:37;;1113:7;1100:5;1106:3;1100:10;;;;;;;;;;;;;;;;;;;;;;;;:20;1096:121;;;1147:3;1140:10;;1096:121;;;1201:1;1195:3;:7;;;;:::i;:::-;1189:13;;1096:121;813:414;;;;1350:1;1344:3;:7;:36;;;;;1373:7;1355:5;1367:1;1361:3;:7;;;;:::i;:::-;1355:14;;;;;;;;;;;;;;;;;;;;;;;;:25;1344:36;1340:122;;;1409:1;1403:3;:7;;;;:::i;:::-;1396:14;;;;;;1340:122;1448:3;1441:10;;;;576:892;;;;;:::o;891:123:4:-;996:1;978:7;:14;;;:19;;;;;;;;;;;891:123;:::o;4964:194:6:-;5057:7;5122:15;5139:10;5093:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;5083:68;;;;;;5076:75;;4964:194;;;;:::o;7469:309:10:-;7563:17;7583:28;:18;:26;:28::i;:::-;7563:48;;7658:9;7625:30;7641:9;:13;;7625:15;:30::i;:::-;:42;7621:151;;;7683:9;:13;;7702:9;7683:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7726:9;:16;;7748:12;7726:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7621:151;7469:309;;;:::o;608:190:14:-;670:7;789:1;784;780;:5;;;;:::i;:::-;776:1;772;:5;;;;:::i;:::-;:13;;;;:::i;:::-;771:19;;;;:::i;:::-;765:1;761;:5;;;;:::i;:::-;755:1;751;:5;;;;:::i;:::-;750:17;;;;:::i;:::-;:41;;;;:::i;:::-;743:48;;608:190;;;;:::o;7784:206:10:-;7854:7;7891:1;7877:3;:10;;;;:15;7873:111;;;7915:1;7908:8;;;;7873:111;7954:3;7971:1;7958:3;:10;;;;:14;;;;:::i;:::-;7954:19;;;;;;;;;;;;;;;;;;;;;;;;7947:26;;7784:206;;;;:::o;7:139:22:-;;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;152:139::-;;236:6;223:20;214:29;;252:33;279:5;252:33;:::i;:::-;204:87;;;;:::o;297:137::-;;380:6;367:20;358:29;;396:32;422:5;396:32;:::i;:::-;348:86;;;;:::o;440:139::-;;524:6;511:20;502:29;;540:33;567:5;540:33;:::i;:::-;492:87;;;;:::o;585:135::-;;667:6;654:20;645:29;;683:31;708:5;683:31;:::i;:::-;635:85;;;;:::o;726:262::-;;834:2;822:9;813:7;809:23;805:32;802:2;;;850:1;847;840:12;802:2;893:1;918:53;963:7;954:6;943:9;939:22;918:53;:::i;:::-;908:63;;864:117;792:196;;;;:::o;994:407::-;;;1119:2;1107:9;1098:7;1094:23;1090:32;1087:2;;;1135:1;1132;1125:12;1087:2;1178:1;1203:53;1248:7;1239:6;1228:9;1224:22;1203:53;:::i;:::-;1193:63;;1149:117;1305:2;1331:53;1376:7;1367:6;1356:9;1352:22;1331:53;:::i;:::-;1321:63;;1276:118;1077:324;;;;;:::o;1407:552::-;;;;1549:2;1537:9;1528:7;1524:23;1520:32;1517:2;;;1565:1;1562;1555:12;1517:2;1608:1;1633:53;1678:7;1669:6;1658:9;1654:22;1633:53;:::i;:::-;1623:63;;1579:117;1735:2;1761:53;1806:7;1797:6;1786:9;1782:22;1761:53;:::i;:::-;1751:63;;1706:118;1863:2;1889:53;1934:7;1925:6;1914:9;1910:22;1889:53;:::i;:::-;1879:63;;1834:118;1507:452;;;;;:::o;1965:1132::-;;;;;;;;2173:3;2161:9;2152:7;2148:23;2144:33;2141:2;;;2190:1;2187;2180:12;2141:2;2233:1;2258:53;2303:7;2294:6;2283:9;2279:22;2258:53;:::i;:::-;2248:63;;2204:117;2360:2;2386:53;2431:7;2422:6;2411:9;2407:22;2386:53;:::i;:::-;2376:63;;2331:118;2488:2;2514:53;2559:7;2550:6;2539:9;2535:22;2514:53;:::i;:::-;2504:63;;2459:118;2616:2;2642:53;2687:7;2678:6;2667:9;2663:22;2642:53;:::i;:::-;2632:63;;2587:118;2744:3;2771:51;2814:7;2805:6;2794:9;2790:22;2771:51;:::i;:::-;2761:61;;2715:117;2871:3;2898:53;2943:7;2934:6;2923:9;2919:22;2898:53;:::i;:::-;2888:63;;2842:119;3000:3;3027:53;3072:7;3063:6;3052:9;3048:22;3027:53;:::i;:::-;3017:63;;2971:119;2131:966;;;;;;;;;;:::o;3103:407::-;;;3228:2;3216:9;3207:7;3203:23;3199:32;3196:2;;;3244:1;3241;3234:12;3196:2;3287:1;3312:53;3357:7;3348:6;3337:9;3333:22;3312:53;:::i;:::-;3302:63;;3258:117;3414:2;3440:53;3485:7;3476:6;3465:9;3461:22;3440:53;:::i;:::-;3430:63;;3385:118;3186:324;;;;;:::o;3516:262::-;;3624:2;3612:9;3603:7;3599:23;3595:32;3592:2;;;3640:1;3637;3630:12;3592:2;3683:1;3708:53;3753:7;3744:6;3733:9;3729:22;3708:53;:::i;:::-;3698:63;;3654:117;3582:196;;;;:::o;3784:407::-;;;3909:2;3897:9;3888:7;3884:23;3880:32;3877:2;;;3925:1;3922;3915:12;3877:2;3968:1;3993:53;4038:7;4029:6;4018:9;4014:22;3993:53;:::i;:::-;3983:63;;3939:117;4095:2;4121:53;4166:7;4157:6;4146:9;4142:22;4121:53;:::i;:::-;4111:63;;4066:118;3867:324;;;;;:::o;4197:260::-;;4304:2;4292:9;4283:7;4279:23;4275:32;4272:2;;;4320:1;4317;4310:12;4272:2;4363:1;4388:52;4432:7;4423:6;4412:9;4408:22;4388:52;:::i;:::-;4378:62;;4334:116;4262:195;;;;:::o;4463:262::-;;4571:2;4559:9;4550:7;4546:23;4542:32;4539:2;;;4587:1;4584;4577:12;4539:2;4630:1;4655:53;4700:7;4691:6;4680:9;4676:22;4655:53;:::i;:::-;4645:63;;4601:117;4529:196;;;;:::o;4731:118::-;4818:24;4836:5;4818:24;:::i;:::-;4813:3;4806:37;4796:53;;:::o;4855:109::-;4936:21;4951:5;4936:21;:::i;:::-;4931:3;4924:34;4914:50;;:::o;4970:118::-;5057:24;5075:5;5057:24;:::i;:::-;5052:3;5045:37;5035:53;;:::o;5094:157::-;5199:45;5219:24;5237:5;5219:24;:::i;:::-;5199:45;:::i;:::-;5194:3;5187:58;5177:74;;:::o;5257:364::-;;5373:39;5406:5;5373:39;:::i;:::-;5428:71;5492:6;5487:3;5428:71;:::i;:::-;5421:78;;5508:52;5553:6;5548:3;5541:4;5534:5;5530:16;5508:52;:::i;:::-;5585:29;5607:6;5585:29;:::i;:::-;5580:3;5576:39;5569:46;;5349:272;;;;;:::o;5627:377::-;;5761:39;5794:5;5761:39;:::i;:::-;5816:89;5898:6;5893:3;5816:89;:::i;:::-;5809:96;;5914:52;5959:6;5954:3;5947:4;5940:5;5936:16;5914:52;:::i;:::-;5991:6;5986:3;5982:16;5975:23;;5737:267;;;;;:::o;6010:366::-;;6173:67;6237:2;6232:3;6173:67;:::i;:::-;6166:74;;6249:93;6338:3;6249:93;:::i;:::-;6367:2;6362:3;6358:12;6351:19;;6156:220;;;:::o;6382:366::-;;6545:67;6609:2;6604:3;6545:67;:::i;:::-;6538:74;;6621:93;6710:3;6621:93;:::i;:::-;6739:2;6734:3;6730:12;6723:19;;6528:220;;;:::o;6754:366::-;;6917:67;6981:2;6976:3;6917:67;:::i;:::-;6910:74;;6993:93;7082:3;6993:93;:::i;:::-;7111:2;7106:3;7102:12;7095:19;;6900:220;;;:::o;7126:366::-;;7289:67;7353:2;7348:3;7289:67;:::i;:::-;7282:74;;7365:93;7454:3;7365:93;:::i;:::-;7483:2;7478:3;7474:12;7467:19;;7272:220;;;:::o;7498:366::-;;7661:67;7725:2;7720:3;7661:67;:::i;:::-;7654:74;;7737:93;7826:3;7737:93;:::i;:::-;7855:2;7850:3;7846:12;7839:19;;7644:220;;;:::o;7870:366::-;;8033:67;8097:2;8092:3;8033:67;:::i;:::-;8026:74;;8109:93;8198:3;8109:93;:::i;:::-;8227:2;8222:3;8218:12;8211:19;;8016:220;;;:::o;8242:400::-;;8423:84;8505:1;8500:3;8423:84;:::i;:::-;8416:91;;8516:93;8605:3;8516:93;:::i;:::-;8634:1;8629:3;8625:11;8618:18;;8406:236;;;:::o;8648:366::-;;8811:67;8875:2;8870:3;8811:67;:::i;:::-;8804:74;;8887:93;8976:3;8887:93;:::i;:::-;9005:2;9000:3;8996:12;8989:19;;8794:220;;;:::o;9020:366::-;;9183:67;9247:2;9242:3;9183:67;:::i;:::-;9176:74;;9259:93;9348:3;9259:93;:::i;:::-;9377:2;9372:3;9368:12;9361:19;;9166:220;;;:::o;9392:366::-;;9555:67;9619:2;9614:3;9555:67;:::i;:::-;9548:74;;9631:93;9720:3;9631:93;:::i;:::-;9749:2;9744:3;9740:12;9733:19;;9538:220;;;:::o;9764:366::-;;9927:67;9991:2;9986:3;9927:67;:::i;:::-;9920:74;;10003:93;10092:3;10003:93;:::i;:::-;10121:2;10116:3;10112:12;10105:19;;9910:220;;;:::o;10136:366::-;;10299:67;10363:2;10358:3;10299:67;:::i;:::-;10292:74;;10375:93;10464:3;10375:93;:::i;:::-;10493:2;10488:3;10484:12;10477:19;;10282:220;;;:::o;10508:366::-;;10671:67;10735:2;10730:3;10671:67;:::i;:::-;10664:74;;10747:93;10836:3;10747:93;:::i;:::-;10865:2;10860:3;10856:12;10849:19;;10654:220;;;:::o;10880:366::-;;11043:67;11107:2;11102:3;11043:67;:::i;:::-;11036:74;;11119:93;11208:3;11119:93;:::i;:::-;11237:2;11232:3;11228:12;11221:19;;11026:220;;;:::o;11252:366::-;;11415:67;11479:2;11474:3;11415:67;:::i;:::-;11408:74;;11491:93;11580:3;11491:93;:::i;:::-;11609:2;11604:3;11600:12;11593:19;;11398:220;;;:::o;11624:366::-;;11787:67;11851:2;11846:3;11787:67;:::i;:::-;11780:74;;11863:93;11952:3;11863:93;:::i;:::-;11981:2;11976:3;11972:12;11965:19;;11770:220;;;:::o;11996:366::-;;12159:67;12223:2;12218:3;12159:67;:::i;:::-;12152:74;;12235:93;12324:3;12235:93;:::i;:::-;12353:2;12348:3;12344:12;12337:19;;12142:220;;;:::o;12368:366::-;;12531:67;12595:2;12590:3;12531:67;:::i;:::-;12524:74;;12607:93;12696:3;12607:93;:::i;:::-;12725:2;12720:3;12716:12;12709:19;;12514:220;;;:::o;12740:402::-;;12921:85;13003:2;12998:3;12921:85;:::i;:::-;12914:92;;13015:93;13104:3;13015:93;:::i;:::-;13133:2;13128:3;13124:12;13117:19;;12904:238;;;:::o;13148:366::-;;13311:67;13375:2;13370:3;13311:67;:::i;:::-;13304:74;;13387:93;13476:3;13387:93;:::i;:::-;13505:2;13500:3;13496:12;13489:19;;13294:220;;;:::o;13520:402::-;;13701:85;13783:2;13778:3;13701:85;:::i;:::-;13694:92;;13795:93;13884:3;13795:93;:::i;:::-;13913:2;13908:3;13904:12;13897:19;;13684:238;;;:::o;13928:366::-;;14091:67;14155:2;14150:3;14091:67;:::i;:::-;14084:74;;14167:93;14256:3;14167:93;:::i;:::-;14285:2;14280:3;14276:12;14269:19;;14074:220;;;:::o;14300:118::-;14387:24;14405:5;14387:24;:::i;:::-;14382:3;14375:37;14365:53;;:::o;14424:112::-;14507:22;14523:5;14507:22;:::i;:::-;14502:3;14495:35;14485:51;;:::o;14542:663::-;;14805:148;14949:3;14805:148;:::i;:::-;14798:155;;14963:75;15034:3;15025:6;14963:75;:::i;:::-;15063:2;15058:3;15054:12;15047:19;;15076:75;15147:3;15138:6;15076:75;:::i;:::-;15176:2;15171:3;15167:12;15160:19;;15196:3;15189:10;;14787:418;;;;;:::o;15211:967::-;;15615:148;15759:3;15615:148;:::i;:::-;15608:155;;15780:95;15871:3;15862:6;15780:95;:::i;:::-;15773:102;;15892:148;16036:3;15892:148;:::i;:::-;15885:155;;16057:95;16148:3;16139:6;16057:95;:::i;:::-;16050:102;;16169:3;16162:10;;15597:581;;;;;:::o;16184:210::-;;16309:2;16298:9;16294:18;16286:26;;16322:65;16384:1;16373:9;16369:17;16360:6;16322:65;:::i;:::-;16276:118;;;;:::o;16400:222::-;;16531:2;16520:9;16516:18;16508:26;;16544:71;16612:1;16601:9;16597:17;16588:6;16544:71;:::i;:::-;16498:124;;;;:::o;16628:775::-;;16899:3;16888:9;16884:19;16876:27;;16913:71;16981:1;16970:9;16966:17;16957:6;16913:71;:::i;:::-;16994:72;17062:2;17051:9;17047:18;17038:6;16994:72;:::i;:::-;17076;17144:2;17133:9;17129:18;17120:6;17076:72;:::i;:::-;17158;17226:2;17215:9;17211:18;17202:6;17158:72;:::i;:::-;17240:73;17308:3;17297:9;17293:19;17284:6;17240:73;:::i;:::-;17323;17391:3;17380:9;17376:19;17367:6;17323:73;:::i;:::-;16866:537;;;;;;;;;:::o;17409:664::-;;17652:3;17641:9;17637:19;17629:27;;17666:71;17734:1;17723:9;17719:17;17710:6;17666:71;:::i;:::-;17747:72;17815:2;17804:9;17800:18;17791:6;17747:72;:::i;:::-;17829;17897:2;17886:9;17882:18;17873:6;17829:72;:::i;:::-;17911;17979:2;17968:9;17964:18;17955:6;17911:72;:::i;:::-;17993:73;18061:3;18050:9;18046:19;18037:6;17993:73;:::i;:::-;17619:454;;;;;;;;:::o;18079:545::-;;18290:3;18279:9;18275:19;18267:27;;18304:71;18372:1;18361:9;18357:17;18348:6;18304:71;:::i;:::-;18385:68;18449:2;18438:9;18434:18;18425:6;18385:68;:::i;:::-;18463:72;18531:2;18520:9;18516:18;18507:6;18463:72;:::i;:::-;18545;18613:2;18602:9;18598:18;18589:6;18545:72;:::i;:::-;18257:367;;;;;;;:::o;18630:313::-;;18781:2;18770:9;18766:18;18758:26;;18830:9;18824:4;18820:20;18816:1;18805:9;18801:17;18794:47;18858:78;18931:4;18922:6;18858:78;:::i;:::-;18850:86;;18748:195;;;;:::o;18949:419::-;;19153:2;19142:9;19138:18;19130:26;;19202:9;19196:4;19192:20;19188:1;19177:9;19173:17;19166:47;19230:131;19356:4;19230:131;:::i;:::-;19222:139;;19120:248;;;:::o;19374:419::-;;19578:2;19567:9;19563:18;19555:26;;19627:9;19621:4;19617:20;19613:1;19602:9;19598:17;19591:47;19655:131;19781:4;19655:131;:::i;:::-;19647:139;;19545:248;;;:::o;19799:419::-;;20003:2;19992:9;19988:18;19980:26;;20052:9;20046:4;20042:20;20038:1;20027:9;20023:17;20016:47;20080:131;20206:4;20080:131;:::i;:::-;20072:139;;19970:248;;;:::o;20224:419::-;;20428:2;20417:9;20413:18;20405:26;;20477:9;20471:4;20467:20;20463:1;20452:9;20448:17;20441:47;20505:131;20631:4;20505:131;:::i;:::-;20497:139;;20395:248;;;:::o;20649:419::-;;20853:2;20842:9;20838:18;20830:26;;20902:9;20896:4;20892:20;20888:1;20877:9;20873:17;20866:47;20930:131;21056:4;20930:131;:::i;:::-;20922:139;;20820:248;;;:::o;21074:419::-;;21278:2;21267:9;21263:18;21255:26;;21327:9;21321:4;21317:20;21313:1;21302:9;21298:17;21291:47;21355:131;21481:4;21355:131;:::i;:::-;21347:139;;21245:248;;;:::o;21499:419::-;;21703:2;21692:9;21688:18;21680:26;;21752:9;21746:4;21742:20;21738:1;21727:9;21723:17;21716:47;21780:131;21906:4;21780:131;:::i;:::-;21772:139;;21670:248;;;:::o;21924:419::-;;22128:2;22117:9;22113:18;22105:26;;22177:9;22171:4;22167:20;22163:1;22152:9;22148:17;22141:47;22205:131;22331:4;22205:131;:::i;:::-;22197:139;;22095:248;;;:::o;22349:419::-;;22553:2;22542:9;22538:18;22530:26;;22602:9;22596:4;22592:20;22588:1;22577:9;22573:17;22566:47;22630:131;22756:4;22630:131;:::i;:::-;22622:139;;22520:248;;;:::o;22774:419::-;;22978:2;22967:9;22963:18;22955:26;;23027:9;23021:4;23017:20;23013:1;23002:9;22998:17;22991:47;23055:131;23181:4;23055:131;:::i;:::-;23047:139;;22945:248;;;:::o;23199:419::-;;23403:2;23392:9;23388:18;23380:26;;23452:9;23446:4;23442:20;23438:1;23427:9;23423:17;23416:47;23480:131;23606:4;23480:131;:::i;:::-;23472:139;;23370:248;;;:::o;23624:419::-;;23828:2;23817:9;23813:18;23805:26;;23877:9;23871:4;23867:20;23863:1;23852:9;23848:17;23841:47;23905:131;24031:4;23905:131;:::i;:::-;23897:139;;23795:248;;;:::o;24049:419::-;;24253:2;24242:9;24238:18;24230:26;;24302:9;24296:4;24292:20;24288:1;24277:9;24273:17;24266:47;24330:131;24456:4;24330:131;:::i;:::-;24322:139;;24220:248;;;:::o;24474:419::-;;24678:2;24667:9;24663:18;24655:26;;24727:9;24721:4;24717:20;24713:1;24702:9;24698:17;24691:47;24755:131;24881:4;24755:131;:::i;:::-;24747:139;;24645:248;;;:::o;24899:419::-;;25103:2;25092:9;25088:18;25080:26;;25152:9;25146:4;25142:20;25138:1;25127:9;25123:17;25116:47;25180:131;25306:4;25180:131;:::i;:::-;25172:139;;25070:248;;;:::o;25324:419::-;;25528:2;25517:9;25513:18;25505:26;;25577:9;25571:4;25567:20;25563:1;25552:9;25548:17;25541:47;25605:131;25731:4;25605:131;:::i;:::-;25597:139;;25495:248;;;:::o;25749:419::-;;25953:2;25942:9;25938:18;25930:26;;26002:9;25996:4;25992:20;25988:1;25977:9;25973:17;25966:47;26030:131;26156:4;26030:131;:::i;:::-;26022:139;;25920:248;;;:::o;26174:419::-;;26378:2;26367:9;26363:18;26355:26;;26427:9;26421:4;26417:20;26413:1;26402:9;26398:17;26391:47;26455:131;26581:4;26455:131;:::i;:::-;26447:139;;26345:248;;;:::o;26599:419::-;;26803:2;26792:9;26788:18;26780:26;;26852:9;26846:4;26842:20;26838:1;26827:9;26823:17;26816:47;26880:131;27006:4;26880:131;:::i;:::-;26872:139;;26770:248;;;:::o;27024:222::-;;27155:2;27144:9;27140:18;27132:26;;27168:71;27236:1;27225:9;27221:17;27212:6;27168:71;:::i;:::-;27122:124;;;;:::o;27252:214::-;;27379:2;27368:9;27364:18;27356:26;;27392:67;27456:1;27445:9;27441:17;27432:6;27392:67;:::i;:::-;27346:120;;;;:::o;27472:99::-;;27558:5;27552:12;27542:22;;27531:40;;;:::o;27577:169::-;;27695:6;27690:3;27683:19;27735:4;27730:3;27726:14;27711:29;;27673:73;;;;:::o;27752:148::-;;27891:3;27876:18;;27866:34;;;;:::o;27906:305::-;;27965:20;27983:1;27965:20;:::i;:::-;27960:25;;27999:20;28017:1;27999:20;:::i;:::-;27994:25;;28153:1;28085:66;28081:74;28078:1;28075:81;28072:2;;;28159:18;;:::i;:::-;28072:2;28203:1;28200;28196:9;28189:16;;27950:261;;;;:::o;28217:185::-;;28274:20;28292:1;28274:20;:::i;:::-;28269:25;;28308:20;28326:1;28308:20;:::i;:::-;28303:25;;28347:1;28337:2;;28352:18;;:::i;:::-;28337:2;28394:1;28391;28387:9;28382:14;;28259:143;;;;:::o;28408:348::-;;28471:20;28489:1;28471:20;:::i;:::-;28466:25;;28505:20;28523:1;28505:20;:::i;:::-;28500:25;;28693:1;28625:66;28621:74;28618:1;28615:81;28610:1;28603:9;28596:17;28592:105;28589:2;;;28700:18;;:::i;:::-;28589:2;28748:1;28745;28741:9;28730:20;;28456:300;;;;:::o;28762:191::-;;28822:20;28840:1;28822:20;:::i;:::-;28817:25;;28856:20;28874:1;28856:20;:::i;:::-;28851:25;;28895:1;28892;28889:8;28886:2;;;28900:18;;:::i;:::-;28886:2;28945:1;28942;28938:9;28930:17;;28807:146;;;;:::o;28959:96::-;;29025:24;29043:5;29025:24;:::i;:::-;29014:35;;29004:51;;;:::o;29061:90::-;;29138:5;29131:13;29124:21;29113:32;;29103:48;;;:::o;29157:77::-;;29223:5;29212:16;;29202:32;;;:::o;29240:149::-;;29316:66;29309:5;29305:78;29294:89;;29284:105;;;:::o;29395:126::-;;29472:42;29465:5;29461:54;29450:65;;29440:81;;;:::o;29527:77::-;;29593:5;29582:16;;29572:32;;;:::o;29610:86::-;;29685:4;29678:5;29674:16;29663:27;;29653:43;;;:::o;29702:307::-;29770:1;29780:113;29794:6;29791:1;29788:13;29780:113;;;29879:1;29874:3;29870:11;29864:18;29860:1;29855:3;29851:11;29844:39;29816:2;29813:1;29809:10;29804:15;;29780:113;;;29911:6;29908:1;29905:13;29902:2;;;29991:1;29982:6;29977:3;29973:16;29966:27;29902:2;29751:258;;;;:::o;30015:171::-;;30077:24;30095:5;30077:24;:::i;:::-;30068:33;;30123:4;30116:5;30113:15;30110:2;;;30131:18;;:::i;:::-;30110:2;30178:1;30171:5;30167:13;30160:20;;30058:128;;;:::o;30192:320::-;;30273:1;30267:4;30263:12;30253:22;;30320:1;30314:4;30310:12;30341:18;30331:2;;30397:4;30389:6;30385:17;30375:27;;30331:2;30459;30451:6;30448:14;30428:18;30425:38;30422:2;;;30478:18;;:::i;:::-;30422:2;30243:269;;;;:::o;30518:79::-;;30586:5;30575:16;;30565:32;;;:::o;30603:176::-;;30652:20;30670:1;30652:20;:::i;:::-;30647:25;;30686:20;30704:1;30686:20;:::i;:::-;30681:25;;30725:1;30715:2;;30730:18;;:::i;:::-;30715:2;30771:1;30768;30764:9;30759:14;;30637:142;;;;:::o;30785:180::-;30833:77;30830:1;30823:88;30930:4;30927:1;30920:15;30954:4;30951:1;30944:15;30971:180;31019:77;31016:1;31009:88;31116:4;31113:1;31106:15;31140:4;31137:1;31130:15;31157:180;31205:77;31202:1;31195:88;31302:4;31299:1;31292:15;31326:4;31323:1;31316:15;31343:102;;31435:2;31431:7;31426:2;31419:5;31415:14;31411:28;31401:38;;31391:54;;;:::o;31451:174::-;31591:26;31587:1;31579:6;31575:14;31568:50;31557:68;:::o;31631:179::-;31771:31;31767:1;31759:6;31755:14;31748:55;31737:73;:::o;31816:182::-;31956:34;31952:1;31944:6;31940:14;31933:58;31922:76;:::o;32004:222::-;32144:34;32140:1;32132:6;32128:14;32121:58;32213:5;32208:2;32200:6;32196:15;32189:30;32110:116;:::o;32232:221::-;32372:34;32368:1;32360:6;32356:14;32349:58;32441:4;32436:2;32428:6;32424:15;32417:29;32338:115;:::o;32459:221::-;32599:34;32595:1;32587:6;32583:14;32576:58;32668:4;32663:2;32655:6;32651:15;32644:29;32565:115;:::o;32686:214::-;32826:66;32822:1;32814:6;32810:14;32803:90;32792:108;:::o;32906:179::-;33046:31;33042:1;33034:6;33030:14;33023:55;33012:73;:::o;33091:225::-;33231:34;33227:1;33219:6;33215:14;33208:58;33300:8;33295:2;33287:6;33283:15;33276:33;33197:119;:::o;33322:221::-;33462:34;33458:1;33450:6;33446:14;33439:58;33531:4;33526:2;33518:6;33514:15;33507:29;33428:115;:::o;33549:221::-;33689:34;33685:1;33677:6;33673:14;33666:58;33758:4;33753:2;33745:6;33741:15;33734:29;33655:115;:::o;33776:180::-;33916:32;33912:1;33904:6;33900:14;33893:56;33882:74;:::o;33962:227::-;34102:34;34098:1;34090:6;34086:14;34079:58;34171:10;34166:2;34158:6;34154:15;34147:35;34068:121;:::o;34195:223::-;34335:34;34331:1;34323:6;34319:14;34312:58;34404:6;34399:2;34391:6;34387:15;34380:31;34301:117;:::o;34424:220::-;34564:34;34560:1;34552:6;34548:14;34541:58;34633:3;34628:2;34620:6;34616:15;34609:28;34530:114;:::o;34650:224::-;34790:34;34786:1;34778:6;34774:14;34767:58;34859:7;34854:2;34846:6;34842:15;34835:32;34756:118;:::o;34880:223::-;35020:34;35016:1;35008:6;35004:14;34997:58;35089:6;35084:2;35076:6;35072:15;35065:31;34986:117;:::o;35109:172::-;35249:24;35245:1;35237:6;35233:14;35226:48;35215:66;:::o;35287:173::-;35427:25;35423:1;35415:6;35411:14;35404:49;35393:67;:::o;35466:224::-;35606:34;35602:1;35594:6;35590:14;35583:58;35675:7;35670:2;35662:6;35658:15;35651:32;35572:118;:::o;35696:167::-;35836:19;35832:1;35824:6;35820:14;35813:43;35802:61;:::o;35869:234::-;36009:34;36005:1;35997:6;35993:14;35986:58;36078:17;36073:2;36065:6;36061:15;36054:42;35975:128;:::o;36109:122::-;36182:24;36200:5;36182:24;:::i;:::-;36175:5;36172:35;36162:2;;36221:1;36218;36211:12;36162:2;36152:79;:::o;36237:122::-;36310:24;36328:5;36310:24;:::i;:::-;36303:5;36300:35;36290:2;;36349:1;36346;36339:12;36290:2;36280:79;:::o;36365:120::-;36437:23;36454:5;36437:23;:::i;:::-;36430:5;36427:34;36417:2;;36475:1;36472;36465:12;36417:2;36407:78;:::o;36491:122::-;36564:24;36582:5;36564:24;:::i;:::-;36557:5;36554:35;36544:2;;36603:1;36600;36593:12;36544:2;36534:79;:::o;36619:118::-;36690:22;36706:5;36690:22;:::i;:::-;36683:5;36680:33;36670:2;;36727:1;36724;36717:12;36670:2;36660:77;:::o

ipfs://b53ace510a8e606f8d3f3225e976a64beb199986ff8676694c576419061e4da7