Token Maple

/**
 *Submitted for verification at Etherscan.io on 2022-03-14
*/

// Sources flattened with hardhat v2.6.1 https://hardhat.org

// File @openzeppelin/contracts/token/ERC20/[email protected]

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


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

pragma solidity ^0.8.0;

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

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

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


// File @openzeppelin/contracts/utils/[email protected]


pragma solidity ^0.8.0;

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

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


// File @openzeppelin/contracts/token/ERC20/[email protected]

pragma solidity ^0.8.0;



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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

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

        return true;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

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

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

pragma solidity ^0.8.0;


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

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


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

pragma solidity ^0.8.0;

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

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

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


// File @openzeppelin/contracts/utils/cryptography/[email protected]

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


// File @openzeppelin/contracts/utils/cryptography/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;

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

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


// File @openzeppelin/contracts/utils/[email protected]

pragma solidity ^0.8.0;

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

pragma solidity ^0.8.0;





/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
    using Counters for Counters.Counter;

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

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

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

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

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

        bytes32 hash = _hashTypedDataV4(structHash);

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

        _approve(owner, spender, value);
    }

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

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

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


// File @openzeppelin/contracts/utils/math/[email protected]

pragma solidity ^0.8.0;

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

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

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

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


// File @openzeppelin/contracts/utils/math/[email protected]

pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128) {
        require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
        return int128(value);
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64) {
        require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
        return int64(value);
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32) {
        require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
        return int32(value);
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16) {
        require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
        return int16(value);
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits.
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8) {
        require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
        return int8(value);
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]

pragma solidity ^0.8.0;




/**
 * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's,
 * and supports token supply up to 2^224^ - 1, while COMP is limited to 2^96^ - 1.
 *
 * NOTE: If exact COMP compatibility is required, use the {ERC20VotesComp} variant of this module.
 *
 * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either
 * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting
 * power can be queried through the public accessors {getVotes} and {getPastVotes}.
 *
 * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it
 * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked.
 * Enabling self-delegation can easily be done by overriding the {delegates} function. Keep in mind however that this
 * will significantly increase the base gas cost of transfers.
 *
 * _Available since v4.2._
 */
abstract contract ERC20Votes is ERC20Permit {
    struct Checkpoint {
        uint32 fromBlock;
        uint224 votes;
    }

    bytes32 private constant _DELEGATION_TYPEHASH =
        keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    mapping(address => address) private _delegates;
    mapping(address => Checkpoint[]) private _checkpoints;
    Checkpoint[] private _totalSupplyCheckpoints;

    /**
     * @dev Emitted when an account changes their delegate.
     */
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /**
     * @dev Emitted when a token transfer or delegate change results in changes to an account's voting power.
     */
    event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);

    /**
     * @dev Get the `pos`-th checkpoint for `account`.
     */
    function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) {
        return _checkpoints[account][pos];
    }

    /**
     * @dev Get number of checkpoints for `account`.
     */
    function numCheckpoints(address account) public view virtual returns (uint32) {
        return SafeCast.toUint32(_checkpoints[account].length);
    }

    /**
     * @dev Get the address `account` is currently delegating to.
     */
    function delegates(address account) public view virtual returns (address) {
        return _delegates[account];
    }

    /**
     * @dev Gets the current votes balance for `account`
     */
    function getVotes(address account) public view returns (uint256) {
        uint256 pos = _checkpoints[account].length;
        return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;
    }

    /**
     * @dev Retrieve the number of votes for `account` at the end of `blockNumber`.
     *
     * Requirements:
     *
     * - `blockNumber` must have been already mined
     */
    function getPastVotes(address account, uint256 blockNumber) public view returns (uint256) {
        require(blockNumber < block.number, "ERC20Votes: block not yet mined");
        return _checkpointsLookup(_checkpoints[account], blockNumber);
    }

    /**
     * @dev Retrieve the `totalSupply` at the end of `blockNumber`. Note, this value is the sum of all balances.
     * It is but NOT the sum of all the delegated votes!
     *
     * Requirements:
     *
     * - `blockNumber` must have been already mined
     */
    function getPastTotalSupply(uint256 blockNumber) public view returns (uint256) {
        require(blockNumber < block.number, "ERC20Votes: block not yet mined");
        return _checkpointsLookup(_totalSupplyCheckpoints, blockNumber);
    }

    /**
     * @dev Lookup a value in a list of (sorted) checkpoints.
     */
    function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 blockNumber) private view returns (uint256) {
        // We run a binary search to look for the earliest checkpoint taken after `blockNumber`.
        //
        // During the loop, the index of the wanted checkpoint remains in the range [low-1, high).
        // With each iteration, either `low` or `high` is moved towards the middle of the range to maintain the invariant.
        // - If the middle checkpoint is after `blockNumber`, we look in [low, mid)
        // - If the middle checkpoint is before or equal to `blockNumber`, we look in [mid+1, high)
        // Once we reach a single value (when low == high), we've found the right checkpoint at the index high-1, if not
        // out of bounds (in which case we're looking too far in the past and the result is 0).
        // Note that if the latest checkpoint available is exactly for `blockNumber`, we end up with an index that is
        // past the end of the array, so we technically don't find a checkpoint after `blockNumber`, but it works out
        // the same.
        uint256 high = ckpts.length;
        uint256 low = 0;
        while (low < high) {
            uint256 mid = Math.average(low, high);
            if (ckpts[mid].fromBlock > blockNumber) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        return high == 0 ? 0 : ckpts[high - 1].votes;
    }

    /**
     * @dev Delegate votes from the sender to `delegatee`.
     */
    function delegate(address delegatee) public virtual {
        return _delegate(_msgSender(), delegatee);
    }

    /**
     * @dev Delegates votes from signer to `delegatee`
     */
    function delegateBySig(
        address delegatee,
        uint256 nonce,
        uint256 expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        require(block.timestamp <= expiry, "ERC20Votes: signature expired");
        address signer = ECDSA.recover(
            _hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))),
            v,
            r,
            s
        );
        require(nonce == _useNonce(signer), "ERC20Votes: invalid nonce");
        return _delegate(signer, delegatee);
    }

    /**
     * @dev Maximum token supply. Defaults to `type(uint224).max` (2^224^ - 1).
     */
    function _maxSupply() internal view virtual returns (uint224) {
        return type(uint224).max;
    }

    /**
     * @dev Snapshots the totalSupply after it has been increased.
     */
    function _mint(address account, uint256 amount) internal virtual override {
        super._mint(account, amount);
        require(totalSupply() <= _maxSupply(), "ERC20Votes: total supply risks overflowing votes");

        _writeCheckpoint(_totalSupplyCheckpoints, _add, amount);
    }

    /**
     * @dev Snapshots the totalSupply after it has been decreased.
     */
    function _burn(address account, uint256 amount) internal virtual override {
        super._burn(account, amount);

        _writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount);
    }

    /**
     * @dev Move voting power when tokens are transferred.
     *
     * Emits a {DelegateVotesChanged} event.
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._afterTokenTransfer(from, to, amount);

        _moveVotingPower(delegates(from), delegates(to), amount);
    }

    /**
     * @dev Change delegation for `delegator` to `delegatee`.
     *
     * Emits events {DelegateChanged} and {DelegateVotesChanged}.
     */
    function _delegate(address delegator, address delegatee) internal virtual {
        address currentDelegate = delegates(delegator);
        uint256 delegatorBalance = balanceOf(delegator);
        _delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveVotingPower(currentDelegate, delegatee, delegatorBalance);
    }

    function _moveVotingPower(
        address src,
        address dst,
        uint256 amount
    ) private {
        if (src != dst && amount > 0) {
            if (src != address(0)) {
                (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount);
                emit DelegateVotesChanged(src, oldWeight, newWeight);
            }

            if (dst != address(0)) {
                (uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount);
                emit DelegateVotesChanged(dst, oldWeight, newWeight);
            }
        }
    }

    function _writeCheckpoint(
        Checkpoint[] storage ckpts,
        function(uint256, uint256) view returns (uint256) op,
        uint256 delta
    ) private returns (uint256 oldWeight, uint256 newWeight) {
        uint256 pos = ckpts.length;
        oldWeight = pos == 0 ? 0 : ckpts[pos - 1].votes;
        newWeight = op(oldWeight, delta);

        if (pos > 0 && ckpts[pos - 1].fromBlock == block.number) {
            ckpts[pos - 1].votes = SafeCast.toUint224(newWeight);
        } else {
            ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(block.number), votes: SafeCast.toUint224(newWeight)}));
        }
    }

    function _add(uint256 a, uint256 b) private pure returns (uint256) {
        return a + b;
    }

    function _subtract(uint256 a, uint256 b) private pure returns (uint256) {
        return a - b;
    }
}


// File contracts/Maple.sol

pragma solidity ^0.8.4;




contract Maple is ERC20, ERC20Burnable, ERC20Permit, ERC20Votes {
    constructor() ERC20("Maple", "MPL") ERC20Permit("Maple") {
        _mint(msg.sender, 1000000000 * 10 ** decimals());
    }

    // The following functions are overrides required by Solidity.

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

    function _mint(address to, uint256 amount)
        internal
        override(ERC20, ERC20Votes)
    {
        super._mint(to, amount);
    }

    function _burn(address account, uint256 amount)
        internal
        override(ERC20, ERC20Votes)
    {
        super._burn(account, amount);
    }
}

• 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":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","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":"DOMAIN_SEPARATOR","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":"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":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint32","name":"pos","type":"uint32"}],"name":"checkpoints","outputs":[{"components":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint224","name":"votes","type":"uint224"}],"internalType":"struct ERC20Votes.Checkpoint","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"account","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"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":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

56873:785:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6517:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8684:169;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7637:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9335:492;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7479:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37264:115;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10236:215;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50219:251;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;16971:91;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49619:119;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52658:112;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49375:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7808:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;17381:368;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37006:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50759:242;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6736:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49822:195;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10954:413;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8148:175;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52852:589;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;36295:645;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;8386:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49145:150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6517:100;6571:13;6604:5;6597:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6517:100;:::o;8684:169::-;8767:4;8784:39;8793:12;:10;:12::i;:::-;8807:7;8816:6;8784:8;:39::i;:::-;8841:4;8834:11;;8684:169;;;;:::o;7637:108::-;7698:7;7725:12;;7718:19;;7637:108;:::o;9335:492::-;9475:4;9492:36;9502:6;9510:9;9521:6;9492:9;:36::i;:::-;9541:24;9568:11;:19;9580:6;9568:19;;;;;;;;;;;;;;;:33;9588:12;:10;:12::i;:::-;9568:33;;;;;;;;;;;;;;;;9541:60;;9640:6;9620:16;:26;;9612:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;9727:57;9736:6;9744:12;:10;:12::i;:::-;9777:6;9758:16;:25;9727:8;:57::i;:::-;9815:4;9808:11;;;9335:492;;;;;:::o;7479:93::-;7537:5;7562:2;7555:9;;7479:93;:::o;37264:115::-;37324:7;37351:20;:18;:20::i;:::-;37344:27;;37264:115;:::o;10236:215::-;10324:4;10341:80;10350:12;:10;:12::i;:::-;10364:7;10410:10;10373:11;:25;10385:12;:10;:12::i;:::-;10373:25;;;;;;;;;;;;;;;:34;10399:7;10373:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;10341:8;:80::i;:::-;10439:4;10432:11;;10236:215;;;;:::o;50219:251::-;50300:7;50342:12;50328:11;:26;50320:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;50408:54;50427:12;:21;50440:7;50427:21;;;;;;;;;;;;;;;50450:11;50408:18;:54::i;:::-;50401:61;;50219:251;;;;:::o;16971:91::-;17027:27;17033:12;:10;:12::i;:::-;17047:6;17027:5;:27::i;:::-;16971:91;:::o;49619:119::-;49684:7;49711:10;:19;49722:7;49711:19;;;;;;;;;;;;;;;;;;;;;;;;;49704:26;;49619:119;;;:::o;52658:112::-;52728:34;52738:12;:10;:12::i;:::-;52752:9;52728;:34::i;:::-;52658:112;:::o;49375:151::-;49445:6;49471:47;49489:12;:21;49502:7;49489:21;;;;;;;;;;;;;;;:28;;;;49471:17;:47::i;:::-;49464:54;;49375:151;;;:::o;7808:127::-;7882:7;7909:9;:18;7919:7;7909:18;;;;;;;;;;;;;;;;7902:25;;7808:127;;;:::o;17381:368::-;17458:24;17485:32;17495:7;17504:12;:10;:12::i;:::-;17485:9;:32::i;:::-;17458:59;;17556:6;17536:16;:26;;17528:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;17639:58;17648:7;17657:12;:10;:12::i;:::-;17690:6;17671:16;:25;17639:8;:58::i;:::-;17719:22;17725:7;17734:6;17719:5;:22::i;:::-;17381:368;;;:::o;37006:128::-;37075:7;37102:24;:7;:14;37110:5;37102:14;;;;;;;;;;;;;;;:22;:24::i;:::-;37095:31;;37006:128;;;:::o;50759:242::-;50829:7;50871:12;50857:11;:26;50849:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;50937:56;50956:23;50981:11;50937:18;:56::i;:::-;50930:63;;50759:242;;;:::o;6736:104::-;6792:13;6825:7;6818:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6736:104;:::o;49822:195::-;49878:7;49898:11;49912:12;:21;49925:7;49912:21;;;;;;;;;;;;;;;:28;;;;49898:42;;49965:1;49958:3;:8;:51;;49973:12;:21;49986:7;49973:21;;;;;;;;;;;;;;;50001:1;49995:3;:7;;;;:::i;:::-;49973:30;;;;;;;;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;49958:51;;;49969:1;49958:51;49951:58;;;;;49822:195;;;:::o;10954:413::-;11047:4;11064:24;11091:11;:25;11103:12;:10;:12::i;:::-;11091:25;;;;;;;;;;;;;;;:34;11117:7;11091:34;;;;;;;;;;;;;;;;11064:61;;11164:15;11144:16;:35;;11136:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;11257:67;11266:12;:10;:12::i;:::-;11280:7;11308:15;11289:16;:34;11257:8;:67::i;:::-;11355:4;11348:11;;;10954:413;;;;:::o;8148:175::-;8234:4;8251:42;8261:12;:10;:12::i;:::-;8275:9;8286:6;8251:9;:42::i;:::-;8311:4;8304:11;;8148:175;;;;:::o;52852:589::-;53070:6;53051:15;:25;;53043:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;53121:14;53138:174;53166:87;48396:71;53226:9;53237:5;53244:6;53193:58;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;53183:69;;;;;;53166:16;:87::i;:::-;53268:1;53284;53300;53138:13;:174::i;:::-;53121:191;;53340:17;53350:6;53340:9;:17::i;:::-;53331:5;:26;53323:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;53405:28;53415:6;53423:9;53405;:28::i;:::-;53398:35;52852:589;;;;;;:::o;36295:645::-;36539:8;36520:15;:27;;36512:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;36594:18;36636:16;36654:5;36661:7;36670:5;36677:16;36687:5;36677:9;:16::i;:::-;36695:8;36625:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;36615:90;;;;;;36594:111;;36718:12;36733:28;36750:10;36733:16;:28::i;:::-;36718:43;;36774:14;36791:28;36805:4;36811:1;36814;36817;36791:13;:28::i;:::-;36774:45;;36848:5;36838:15;;:6;:15;;;36830:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;36901:31;36910:5;36917:7;36926:5;36901:8;:31::i;:::-;36295:645;;;;;;;;;;:::o;8386:151::-;8475:7;8502:11;:18;8514:5;8502:18;;;;;;;;;;;;;;;:27;8521:7;8502:27;;;;;;;;;;;;;;;;8495:34;;8386:151;;;;:::o;49145:150::-;49224:17;;:::i;:::-;49261:12;:21;49274:7;49261:21;;;;;;;;;;;;;;;49283:3;49261:26;;;;;;;;;;;;;;;;;;;;;;;;;49254:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49145:150;;;;:::o;53747:290::-;53832:28;53844:7;53853:6;53832:11;:28::i;:::-;53896:12;:10;:12::i;:::-;53879:29;;:13;:11;:13::i;:::-;:29;;53871:90;;;;;;;;;;;;:::i;:::-;;;;;;;;;53974:55;53991:23;54016:4;54022:6;53974:16;:55::i;:::-;;;53747:290;;:::o;12877:399::-;12980:1;12961:21;;:7;:21;;;;12953:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;13031:49;13060:1;13064:7;13073:6;13031:20;:49::i;:::-;13109:6;13093:12;;:22;;;;;;;:::i;:::-;;;;;;;;13148:6;13126:9;:18;13136:7;13126:18;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;13191:7;13170:37;;13187:1;13170:37;;;13200:6;13170:37;;;;;;:::i;:::-;;;;;;;;13220:48;13248:1;13252:7;13261:6;13220:19;:48::i;:::-;12877:399;;:::o;56591:98::-;56649:7;56680:1;56676;:5;;;;:::i;:::-;56669:12;;56591:98;;;;:::o;40100:195::-;40157:7;40194:17;40185:26;;:5;:26;;40177:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;40281:5;40266:21;;40100:195;;;:::o;42070:190::-;42126:6;42162:16;42153:25;;:5;:25;;42145:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;42246:5;42232:20;;42070:190;;;:::o;54465:262::-;54607:43;54633:4;54639:2;54643:6;54607:25;:43::i;:::-;54663:56;54680:15;54690:4;54680:9;:15::i;:::-;54697:13;54707:2;54697:9;:13::i;:::-;54712:6;54663:16;:56::i;:::-;54465:262;;;:::o;16347:124::-;;;;:::o;56697:103::-;56760:7;56791:1;56787;:5;;;;:::i;:::-;56780:12;;56697:103;;;;:::o;4228:98::-;4281:7;4308:10;4301:17;;4228:98;:::o;14638:380::-;14791:1;14774:19;;:5;:19;;;;14766:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;14872:1;14853:21;;:7;:21;;;;14845:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;14956:6;14926:11;:18;14938:5;14926:18;;;;;;;;;;;;;;;:27;14945:7;14926:27;;;;;;;;;;;;;;;:36;;;;14994:7;14978:32;;14987:5;14978:32;;;15003:6;14978:32;;;;;;:::i;:::-;;;;;;;;14638:380;;;:::o;11857:733::-;12015:1;11997:20;;:6;:20;;;;11989:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;12099:1;12078:23;;:9;:23;;;;12070:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;12154:47;12175:6;12183:9;12194:6;12154:20;:47::i;:::-;12214:21;12238:9;:17;12248:6;12238:17;;;;;;;;;;;;;;;;12214:41;;12291:6;12274:13;:23;;12266:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;12412:6;12396:13;:22;12376:9;:17;12386:6;12376:17;;;;;;;;;;;;;;;:42;;;;12464:6;12440:9;:20;12450:9;12440:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;12505:9;12488:35;;12497:6;12488:35;;;12516:6;12488:35;;;;;;:::i;:::-;;;;;;;;12536:46;12556:6;12564:9;12575:6;12536:19;:46::i;:::-;11857:733;;;;:::o;32129:281::-;32182:7;32223:16;32206:13;:33;32202:201;;;32263:24;32256:31;;;;32202:201;32327:64;32349:10;32361:12;32375:15;32327:21;:64::i;:::-;32320:71;;32129:281;;:::o;51090:1482::-;51189:7;52208:12;52223:5;:12;;;;52208:27;;52246:11;52272:236;52285:4;52279:3;:10;52272:236;;;52306:11;52320:23;52333:3;52338:4;52320:12;:23::i;:::-;52306:37;;52385:11;52362:5;52368:3;52362:10;;;;;;;;;;;;;;;;;;;;;;;:20;;;;;;;;;;;;:34;;;52358:139;;;52424:3;52417:10;;52358:139;;;52480:1;52474:3;:7;;;;:::i;:::-;52468:13;;52358:139;52272:236;;;;52535:1;52527:4;:9;:37;;52543:5;52556:1;52549:4;:8;;;;:::i;:::-;52543:15;;;;;;;;;;;;;;;;;;;;;;;:21;;;;;;;;;;;;52527:37;;;52539:1;52527:37;52520:44;;;;;;51090:1482;;;;:::o;57500:155::-;57619:28;57631:7;57640:6;57619:11;:28::i;:::-;57500:155;;:::o;54891:388::-;54976:23;55002:20;55012:9;55002;:20::i;:::-;54976:46;;55033:24;55060:20;55070:9;55060;:20::i;:::-;55033:47;;55115:9;55091:10;:21;55102:9;55091:21;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;55186:9;55142:54;;55169:15;55142:54;;55158:9;55142:54;;;;;;;;;;;;55209:62;55226:15;55243:9;55254:16;55209;:62::i;:::-;54891:388;;;;:::o;34318:114::-;34383:7;34410;:14;;;34403:21;;34318:114;;;:::o;33323:167::-;33400:7;33427:55;33449:20;:18;:20::i;:::-;33471:10;33427:21;:55::i;:::-;33420:62;;33323:167;;;:::o;27652:279::-;27780:7;27801:17;27820:18;27842:25;27853:4;27859:1;27862;27865;27842:10;:25::i;:::-;27800:67;;;;27878:18;27890:5;27878:11;:18::i;:::-;27914:9;27907:16;;;;27652:279;;;;;;:::o;37517:207::-;37577:15;37605:30;37638:7;:14;37646:5;37638:14;;;;;;;;;;;;;;;37605:47;;37673:15;:5;:13;:15::i;:::-;37663:25;;37699:17;:5;:15;:17::i;:::-;37517:207;;;;:::o;53548:105::-;53601:7;53628:17;53621:24;;53548:105;:::o;55938:645::-;56112:17;56131;56161:11;56175:5;:12;;;;56161:26;;56217:1;56210:3;:8;:35;;56225:5;56237:1;56231:3;:7;;;;:::i;:::-;56225:14;;;;;;;;;;;;;;;;;;;;;;;:20;;;;;;;;;;;;56210:35;;;56221:1;56210:35;56198:47;;;;56268:20;56271:9;56282:5;56268:2;:20;;:::i;:::-;56256:32;;56311:1;56305:3;:7;:51;;;;;56344:12;56316:5;56328:1;56322:3;:7;;;;:::i;:::-;56316:14;;;;;;;;;;;;;;;;;;;;;;;:24;;;;;;;;;;;;:40;;;56305:51;56301:275;;;56396:29;56415:9;56396:18;:29::i;:::-;56373:5;56385:1;56379:3;:7;;;;:::i;:::-;56373:14;;;;;;;;;;;;;;;;;;;;;;;:20;;;:52;;;;;;;;;;;;;;;;;;56301:275;;;56458:5;56469:94;;;;;;;;56492:31;56510:12;56492:17;:31::i;:::-;56469:94;;;;;;56532:29;56551:9;56532:18;:29::i;:::-;56469:94;;;;;56458:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56301:275;55938:645;;;;;;;:::o;15618:125::-;;;;:::o;57146:193::-;57288:43;57314:4;57320:2;57324:6;57288:25;:43::i;:::-;57146:193;;;:::o;55287:643::-;55419:3;55412:10;;:3;:10;;;;:24;;;;;55435:1;55426:6;:10;55412:24;55408:515;;;55472:1;55457:17;;:3;:17;;;55453:224;;55496:17;55515;55536:54;55553:12;:17;55566:3;55553:17;;;;;;;;;;;;;;;55572:9;55583:6;55536:16;:54::i;:::-;55495:95;;;;55635:3;55614:47;;;55640:9;55651;55614:47;;;;;;;:::i;:::-;;;;;;;;55453:224;;;55712:1;55697:17;;:3;:17;;;55693:219;;55736:17;55755;55776:49;55793:12;:17;55806:3;55793:17;;;;;;;;;;;;;;;55812:4;55818:6;55776:16;:49::i;:::-;55735:90;;;;55870:3;55849:47;;;55875:9;55886;55849:47;;;;;;;:::i;:::-;;;;;;;;55693:219;;;55408:515;55287:643;;;:::o;32418:263::-;32562:7;32610:8;32620;32630:11;32643:13;32666:4;32599:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;32589:84;;;;;;32582:91;;32418:263;;;;;:::o;38394:156::-;38456:7;38541:1;38536;38532;:5;38531:11;;;;:::i;:::-;38526:1;38522;:5;38521:21;;;;:::i;:::-;38514:28;;38394:156;;;;:::o;54131:194::-;54216:28;54228:7;54237:6;54216:11;:28::i;:::-;54257:60;54274:23;54299:9;54310:6;54257:16;:60::i;:::-;;;54131:194;;:::o;28850:196::-;28943:7;29009:15;29026:10;28980:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;28970:68;;;;;;28963:75;;28850:196;;;;:::o;25881:1632::-;26012:7;26021:12;26946:66;26941:1;26933:10;;:79;26929:163;;;27045:1;27049:30;27029:51;;;;;;26929:163;27111:2;27106:1;:7;;;;:18;;;;;27122:2;27117:1;:7;;;;27106:18;27102:102;;;27157:1;27161:30;27141:51;;;;;;27102:102;27301:14;27318:24;27328:4;27334:1;27337;27340;27318:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27301:41;;27375:1;27357:20;;:6;:20;;;27353:103;;;27410:1;27414:29;27394:50;;;;;;;27353:103;27476:6;27484:20;27468:37;;;;;25881:1632;;;;;;;;:::o;20543:643::-;20621:20;20612:29;;;;;;;;;;;;;;;;:5;:29;;;;;;;;;;;;;;;;;20608:571;;;20658:7;;20608:571;20719:29;20710:38;;;;;;;;;;;;;;;;:5;:38;;;;;;;;;;;;;;;;;20706:473;;;20765:34;;;;;;;;;;:::i;:::-;;;;;;;;20706:473;20830:35;20821:44;;;;;;;;;;;;;;;;:5;:44;;;;;;;;;;;;;;;;;20817:362;;;20882:41;;;;;;;;;;:::i;:::-;;;;;;;;20817:362;20954:30;20945:39;;;;;;;;;;;;;;;;:5;:39;;;;;;;;;;;;;;;;;20941:238;;;21001:44;;;;;;;;;;:::i;:::-;;;;;;;;20941:238;21076:30;21067:39;;;;;;;;;;;;;;;;:5;:39;;;;;;;;;;;;;;;;;21063:116;;;21123:44;;;;;;;;;;:::i;:::-;;;;;;;;21063:116;20543:643;;:::o;34440:127::-;34547:1;34529:7;:14;;;:19;;;;;;;;;;;34440:127;:::o;13609:591::-;13712:1;13693:21;;:7;:21;;;;13685:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;13765:49;13786:7;13803:1;13807:6;13765:20;:49::i;:::-;13827:22;13852:9;:18;13862:7;13852:18;;;;;;;;;;;;;;;;13827:43;;13907:6;13889:14;:24;;13881:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;14026:6;14009:14;:23;13988:9;:18;13998:7;13988:18;;;;;;;;;;;;;;;:44;;;;14070:6;14054:12;;:22;;;;;;;:::i;:::-;;;;;;;;14120:1;14094:37;;14103:7;14094:37;;;14124:6;14094:37;;;;;;:::i;:::-;;;;;;;;14144:48;14164:7;14181:1;14185:6;14144:19;:48::i;:::-;13609:591;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;:::o;7:139:1:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;152:139::-;198:5;236:6;223:20;214:29;;252:33;279:5;252:33;:::i;:::-;204:87;;;;:::o;297:139::-;343:5;381:6;368:20;359:29;;397:33;424:5;397:33;:::i;:::-;349:87;;;;:::o;442:137::-;487:5;525:6;512:20;503:29;;541:32;567:5;541:32;:::i;:::-;493:86;;;;:::o;585:135::-;629:5;667:6;654:20;645:29;;683:31;708:5;683:31;:::i;:::-;635:85;;;;:::o;726:262::-;785:6;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::-;1062:6;1070;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::-;1484:6;1492;1500;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::-;2076:6;2084;2092;2100;2108;2116;2124;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::-;3171:6;3179;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:986::-;3618:6;3626;3634;3642;3650;3658;3707:3;3695:9;3686:7;3682:23;3678:33;3675:2;;;3724:1;3721;3714:12;3675:2;3767:1;3792:53;3837:7;3828:6;3817:9;3813:22;3792:53;:::i;:::-;3782:63;;3738:117;3894:2;3920:53;3965:7;3956:6;3945:9;3941:22;3920:53;:::i;:::-;3910:63;;3865:118;4022:2;4048:53;4093:7;4084:6;4073:9;4069:22;4048:53;:::i;:::-;4038:63;;3993:118;4150:2;4176:51;4219:7;4210:6;4199:9;4195:22;4176:51;:::i;:::-;4166:61;;4121:116;4276:3;4303:53;4348:7;4339:6;4328:9;4324:22;4303:53;:::i;:::-;4293:63;;4247:119;4405:3;4432:53;4477:7;4468:6;4457:9;4453:22;4432:53;:::i;:::-;4422:63;;4376:119;3665:837;;;;;;;;:::o;4508:405::-;4575:6;4583;4632:2;4620:9;4611:7;4607:23;4603:32;4600:2;;;4648:1;4645;4638:12;4600:2;4691:1;4716:53;4761:7;4752:6;4741:9;4737:22;4716:53;:::i;:::-;4706:63;;4662:117;4818:2;4844:52;4888:7;4879:6;4868:9;4864:22;4844:52;:::i;:::-;4834:62;;4789:117;4590:323;;;;;:::o;4919:262::-;4978:6;5027:2;5015:9;5006:7;5002:23;4998:32;4995:2;;;5043:1;5040;5033:12;4995:2;5086:1;5111:53;5156:7;5147:6;5136:9;5132:22;5111:53;:::i;:::-;5101:63;;5057:117;4985:196;;;;:::o;5187:118::-;5274:24;5292:5;5274:24;:::i;:::-;5269:3;5262:37;5252:53;;:::o;5311:109::-;5392:21;5407:5;5392:21;:::i;:::-;5387:3;5380:34;5370:50;;:::o;5426:118::-;5513:24;5531:5;5513:24;:::i;:::-;5508:3;5501:37;5491:53;;:::o;5550:157::-;5655:45;5675:24;5693:5;5675:24;:::i;:::-;5655:45;:::i;:::-;5650:3;5643:58;5633:74;;:::o;5713:364::-;5801:3;5829:39;5862:5;5829:39;:::i;:::-;5884:71;5948:6;5943:3;5884:71;:::i;:::-;5877:78;;5964:52;6009:6;6004:3;5997:4;5990:5;5986:16;5964:52;:::i;:::-;6041:29;6063:6;6041:29;:::i;:::-;6036:3;6032:39;6025:46;;5805:272;;;;;:::o;6083:366::-;6225:3;6246:67;6310:2;6305:3;6246:67;:::i;:::-;6239:74;;6322:93;6411:3;6322:93;:::i;:::-;6440:2;6435:3;6431:12;6424:19;;6229:220;;;:::o;6455:366::-;6597:3;6618:67;6682:2;6677:3;6618:67;:::i;:::-;6611:74;;6694:93;6783:3;6694:93;:::i;:::-;6812:2;6807:3;6803:12;6796:19;;6601:220;;;:::o;6827:366::-;6969:3;6990:67;7054:2;7049:3;6990:67;:::i;:::-;6983:74;;7066:93;7155:3;7066:93;:::i;:::-;7184:2;7179:3;7175:12;7168:19;;6973:220;;;:::o;7199:366::-;7341:3;7362:67;7426:2;7421:3;7362:67;:::i;:::-;7355:74;;7438:93;7527:3;7438:93;:::i;:::-;7556:2;7551:3;7547:12;7540:19;;7345:220;;;:::o;7571:366::-;7713:3;7734:67;7798:2;7793:3;7734:67;:::i;:::-;7727:74;;7810:93;7899:3;7810:93;:::i;:::-;7928:2;7923:3;7919:12;7912:19;;7717:220;;;:::o;7943:366::-;8085:3;8106:67;8170:2;8165:3;8106:67;:::i;:::-;8099:74;;8182:93;8271:3;8182:93;:::i;:::-;8300:2;8295:3;8291:12;8284:19;;8089:220;;;:::o;8315:366::-;8457:3;8478:67;8542:2;8537:3;8478:67;:::i;:::-;8471:74;;8554:93;8643:3;8554:93;:::i;:::-;8672:2;8667:3;8663:12;8656:19;;8461:220;;;:::o;8687:366::-;8829:3;8850:67;8914:2;8909:3;8850:67;:::i;:::-;8843:74;;8926:93;9015:3;8926:93;:::i;:::-;9044:2;9039:3;9035:12;9028:19;;8833:220;;;:::o;9059:400::-;9219:3;9240:84;9322:1;9317:3;9240:84;:::i;:::-;9233:91;;9333:93;9422:3;9333:93;:::i;:::-;9451:1;9446:3;9442:11;9435:18;;9223:236;;;:::o;9465:366::-;9607:3;9628:67;9692:2;9687:3;9628:67;:::i;:::-;9621:74;;9704:93;9793:3;9704:93;:::i;:::-;9822:2;9817:3;9813:12;9806:19;;9611:220;;;:::o;9837:366::-;9979:3;10000:67;10064:2;10059:3;10000:67;:::i;:::-;9993:74;;10076:93;10165:3;10076:93;:::i;:::-;10194:2;10189:3;10185:12;10178:19;;9983:220;;;:::o;10209:366::-;10351:3;10372:67;10436:2;10431:3;10372:67;:::i;:::-;10365:74;;10448:93;10537:3;10448:93;:::i;:::-;10566:2;10561:3;10557:12;10550:19;;10355:220;;;:::o;10581:366::-;10723:3;10744:67;10808:2;10803:3;10744:67;:::i;:::-;10737:74;;10820:93;10909:3;10820:93;:::i;:::-;10938:2;10933:3;10929:12;10922:19;;10727:220;;;:::o;10953:366::-;11095:3;11116:67;11180:2;11175:3;11116:67;:::i;:::-;11109:74;;11192:93;11281:3;11192:93;:::i;:::-;11310:2;11305:3;11301:12;11294:19;;11099:220;;;:::o;11325:366::-;11467:3;11488:67;11552:2;11547:3;11488:67;:::i;:::-;11481:74;;11564:93;11653:3;11564:93;:::i;:::-;11682:2;11677:3;11673:12;11666:19;;11471:220;;;:::o;11697:366::-;11839:3;11860:67;11924:2;11919:3;11860:67;:::i;:::-;11853:74;;11936:93;12025:3;11936:93;:::i;:::-;12054:2;12049:3;12045:12;12038:19;;11843:220;;;:::o;12069:366::-;12211:3;12232:67;12296:2;12291:3;12232:67;:::i;:::-;12225:74;;12308:93;12397:3;12308:93;:::i;:::-;12426:2;12421:3;12417:12;12410:19;;12215:220;;;:::o;12441:366::-;12583:3;12604:67;12668:2;12663:3;12604:67;:::i;:::-;12597:74;;12680:93;12769:3;12680:93;:::i;:::-;12798:2;12793:3;12789:12;12782:19;;12587:220;;;:::o;12813:366::-;12955:3;12976:67;13040:2;13035:3;12976:67;:::i;:::-;12969:74;;13052:93;13141:3;13052:93;:::i;:::-;13170:2;13165:3;13161:12;13154:19;;12959:220;;;:::o;13185:366::-;13327:3;13348:67;13412:2;13407:3;13348:67;:::i;:::-;13341:74;;13424:93;13513:3;13424:93;:::i;:::-;13542:2;13537:3;13533:12;13526:19;;13331:220;;;:::o;13557:366::-;13699:3;13720:67;13784:2;13779:3;13720:67;:::i;:::-;13713:74;;13796:93;13885:3;13796:93;:::i;:::-;13914:2;13909:3;13905:12;13898:19;;13703:220;;;:::o;13929:366::-;14071:3;14092:67;14156:2;14151:3;14092:67;:::i;:::-;14085:74;;14168:93;14257:3;14168:93;:::i;:::-;14286:2;14281:3;14277:12;14270:19;;14075:220;;;:::o;14301:366::-;14443:3;14464:67;14528:2;14523:3;14464:67;:::i;:::-;14457:74;;14540:93;14629:3;14540:93;:::i;:::-;14658:2;14653:3;14649:12;14642:19;;14447:220;;;:::o;14673:366::-;14815:3;14836:67;14900:2;14895:3;14836:67;:::i;:::-;14829:74;;14912:93;15001:3;14912:93;:::i;:::-;15030:2;15025:3;15021:12;15014:19;;14819:220;;;:::o;15113:517::-;15266:4;15261:3;15257:14;15358:4;15351:5;15347:16;15341:23;15377:61;15432:4;15427:3;15423:14;15409:12;15377:61;:::i;:::-;15281:167;15531:4;15524:5;15520:16;15514:23;15550:63;15607:4;15602:3;15598:14;15584:12;15550:63;:::i;:::-;15458:165;15235:395;;;:::o;15636:108::-;15713:24;15731:5;15713:24;:::i;:::-;15708:3;15701:37;15691:53;;:::o;15750:118::-;15837:24;15855:5;15837:24;:::i;:::-;15832:3;15825:37;15815:53;;:::o;15874:105::-;15949:23;15966:5;15949:23;:::i;:::-;15944:3;15937:36;15927:52;;:::o;15985:115::-;16070:23;16087:5;16070:23;:::i;:::-;16065:3;16058:36;16048:52;;:::o;16106:112::-;16189:22;16205:5;16189:22;:::i;:::-;16184:3;16177:35;16167:51;;:::o;16224:663::-;16465:3;16487:148;16631:3;16487:148;:::i;:::-;16480:155;;16645:75;16716:3;16707:6;16645:75;:::i;:::-;16745:2;16740:3;16736:12;16729:19;;16758:75;16829:3;16820:6;16758:75;:::i;:::-;16858:2;16853:3;16849:12;16842:19;;16878:3;16871:10;;16469:418;;;;;:::o;16893:222::-;16986:4;17024:2;17013:9;17009:18;17001:26;;17037:71;17105:1;17094:9;17090:17;17081:6;17037:71;:::i;:::-;16991:124;;;;:::o;17121:210::-;17208:4;17246:2;17235:9;17231:18;17223:26;;17259:65;17321:1;17310:9;17306:17;17297:6;17259:65;:::i;:::-;17213:118;;;;:::o;17337:222::-;17430:4;17468:2;17457:9;17453:18;17445:26;;17481:71;17549:1;17538:9;17534:17;17525:6;17481:71;:::i;:::-;17435:124;;;;:::o;17565:775::-;17798:4;17836:3;17825:9;17821:19;17813:27;;17850:71;17918:1;17907:9;17903:17;17894:6;17850:71;:::i;:::-;17931:72;17999:2;17988:9;17984:18;17975:6;17931:72;:::i;:::-;18013;18081:2;18070:9;18066:18;18057:6;18013:72;:::i;:::-;18095;18163:2;18152:9;18148:18;18139:6;18095:72;:::i;:::-;18177:73;18245:3;18234:9;18230:19;18221:6;18177:73;:::i;:::-;18260;18328:3;18317:9;18313:19;18304:6;18260:73;:::i;:::-;17803:537;;;;;;;;;:::o;18346:553::-;18523:4;18561:3;18550:9;18546:19;18538:27;;18575:71;18643:1;18632:9;18628:17;18619:6;18575:71;:::i;:::-;18656:72;18724:2;18713:9;18709:18;18700:6;18656:72;:::i;:::-;18738;18806:2;18795:9;18791:18;18782:6;18738:72;:::i;:::-;18820;18888:2;18877:9;18873:18;18864:6;18820:72;:::i;:::-;18528:371;;;;;;;:::o;18905:664::-;19110:4;19148:3;19137:9;19133:19;19125:27;;19162:71;19230:1;19219:9;19215:17;19206:6;19162:71;:::i;:::-;19243:72;19311:2;19300:9;19296:18;19287:6;19243:72;:::i;:::-;19325;19393:2;19382:9;19378:18;19369:6;19325:72;:::i;:::-;19407;19475:2;19464:9;19460:18;19451:6;19407:72;:::i;:::-;19489:73;19557:3;19546:9;19542:19;19533:6;19489:73;:::i;:::-;19115:454;;;;;;;;:::o;19575:545::-;19748:4;19786:3;19775:9;19771:19;19763:27;;19800:71;19868:1;19857:9;19853:17;19844:6;19800:71;:::i;:::-;19881:68;19945:2;19934:9;19930:18;19921:6;19881:68;:::i;:::-;19959:72;20027:2;20016:9;20012:18;20003:6;19959:72;:::i;:::-;20041;20109:2;20098:9;20094:18;20085:6;20041:72;:::i;:::-;19753:367;;;;;;;:::o;20126:313::-;20239:4;20277:2;20266:9;20262:18;20254:26;;20326:9;20320:4;20316:20;20312:1;20301:9;20297:17;20290:47;20354:78;20427:4;20418:6;20354:78;:::i;:::-;20346:86;;20244:195;;;;:::o;20445:419::-;20611:4;20649:2;20638:9;20634:18;20626:26;;20698:9;20692:4;20688:20;20684:1;20673:9;20669:17;20662:47;20726:131;20852:4;20726:131;:::i;:::-;20718:139;;20616:248;;;:::o;20870:419::-;21036:4;21074:2;21063:9;21059:18;21051:26;;21123:9;21117:4;21113:20;21109:1;21098:9;21094:17;21087:47;21151:131;21277:4;21151:131;:::i;:::-;21143:139;;21041:248;;;:::o;21295:419::-;21461:4;21499:2;21488:9;21484:18;21476:26;;21548:9;21542:4;21538:20;21534:1;21523:9;21519:17;21512:47;21576:131;21702:4;21576:131;:::i;:::-;21568:139;;21466:248;;;:::o;21720:419::-;21886:4;21924:2;21913:9;21909:18;21901:26;;21973:9;21967:4;21963:20;21959:1;21948:9;21944:17;21937:47;22001:131;22127:4;22001:131;:::i;:::-;21993:139;;21891:248;;;:::o;22145:419::-;22311:4;22349:2;22338:9;22334:18;22326:26;;22398:9;22392:4;22388:20;22384:1;22373:9;22369:17;22362:47;22426:131;22552:4;22426:131;:::i;:::-;22418:139;;22316:248;;;:::o;22570:419::-;22736:4;22774:2;22763:9;22759:18;22751:26;;22823:9;22817:4;22813:20;22809:1;22798:9;22794:17;22787:47;22851:131;22977:4;22851:131;:::i;:::-;22843:139;;22741:248;;;:::o;22995:419::-;23161:4;23199:2;23188:9;23184:18;23176:26;;23248:9;23242:4;23238:20;23234:1;23223:9;23219:17;23212:47;23276:131;23402:4;23276:131;:::i;:::-;23268:139;;23166:248;;;:::o;23420:419::-;23586:4;23624:2;23613:9;23609:18;23601:26;;23673:9;23667:4;23663:20;23659:1;23648:9;23644:17;23637:47;23701:131;23827:4;23701:131;:::i;:::-;23693:139;;23591:248;;;:::o;23845:419::-;24011:4;24049:2;24038:9;24034:18;24026:26;;24098:9;24092:4;24088:20;24084:1;24073:9;24069:17;24062:47;24126:131;24252:4;24126:131;:::i;:::-;24118:139;;24016:248;;;:::o;24270:419::-;24436:4;24474:2;24463:9;24459:18;24451:26;;24523:9;24517:4;24513:20;24509:1;24498:9;24494:17;24487:47;24551:131;24677:4;24551:131;:::i;:::-;24543:139;;24441:248;;;:::o;24695:419::-;24861:4;24899:2;24888:9;24884:18;24876:26;;24948:9;24942:4;24938:20;24934:1;24923:9;24919:17;24912:47;24976:131;25102:4;24976:131;:::i;:::-;24968:139;;24866:248;;;:::o;25120:419::-;25286:4;25324:2;25313:9;25309:18;25301:26;;25373:9;25367:4;25363:20;25359:1;25348:9;25344:17;25337:47;25401:131;25527:4;25401:131;:::i;:::-;25393:139;;25291:248;;;:::o;25545:419::-;25711:4;25749:2;25738:9;25734:18;25726:26;;25798:9;25792:4;25788:20;25784:1;25773:9;25769:17;25762:47;25826:131;25952:4;25826:131;:::i;:::-;25818:139;;25716:248;;;:::o;25970:419::-;26136:4;26174:2;26163:9;26159:18;26151:26;;26223:9;26217:4;26213:20;26209:1;26198:9;26194:17;26187:47;26251:131;26377:4;26251:131;:::i;:::-;26243:139;;26141:248;;;:::o;26395:419::-;26561:4;26599:2;26588:9;26584:18;26576:26;;26648:9;26642:4;26638:20;26634:1;26623:9;26619:17;26612:47;26676:131;26802:4;26676:131;:::i;:::-;26668:139;;26566:248;;;:::o;26820:419::-;26986:4;27024:2;27013:9;27009:18;27001:26;;27073:9;27067:4;27063:20;27059:1;27048:9;27044:17;27037:47;27101:131;27227:4;27101:131;:::i;:::-;27093:139;;26991:248;;;:::o;27245:419::-;27411:4;27449:2;27438:9;27434:18;27426:26;;27498:9;27492:4;27488:20;27484:1;27473:9;27469:17;27462:47;27526:131;27652:4;27526:131;:::i;:::-;27518:139;;27416:248;;;:::o;27670:419::-;27836:4;27874:2;27863:9;27859:18;27851:26;;27923:9;27917:4;27913:20;27909:1;27898:9;27894:17;27887:47;27951:131;28077:4;27951:131;:::i;:::-;27943:139;;27841:248;;;:::o;28095:419::-;28261:4;28299:2;28288:9;28284:18;28276:26;;28348:9;28342:4;28338:20;28334:1;28323:9;28319:17;28312:47;28376:131;28502:4;28376:131;:::i;:::-;28368:139;;28266:248;;;:::o;28520:419::-;28686:4;28724:2;28713:9;28709:18;28701:26;;28773:9;28767:4;28763:20;28759:1;28748:9;28744:17;28737:47;28801:131;28927:4;28801:131;:::i;:::-;28793:139;;28691:248;;;:::o;28945:419::-;29111:4;29149:2;29138:9;29134:18;29126:26;;29198:9;29192:4;29188:20;29184:1;29173:9;29169:17;29162:47;29226:131;29352:4;29226:131;:::i;:::-;29218:139;;29116:248;;;:::o;29370:419::-;29536:4;29574:2;29563:9;29559:18;29551:26;;29623:9;29617:4;29613:20;29609:1;29598:9;29594:17;29587:47;29651:131;29777:4;29651:131;:::i;:::-;29643:139;;29541:248;;;:::o;29795:419::-;29961:4;29999:2;29988:9;29984:18;29976:26;;30048:9;30042:4;30038:20;30034:1;30023:9;30019:17;30012:47;30076:131;30202:4;30076:131;:::i;:::-;30068:139;;29966:248;;;:::o;30220:334::-;30369:4;30407:2;30396:9;30392:18;30384:26;;30420:127;30544:1;30533:9;30529:17;30520:6;30420:127;:::i;:::-;30374:180;;;;:::o;30560:222::-;30653:4;30691:2;30680:9;30676:18;30668:26;;30704:71;30772:1;30761:9;30757:17;30748:6;30704:71;:::i;:::-;30658:124;;;;:::o;30788:332::-;30909:4;30947:2;30936:9;30932:18;30924:26;;30960:71;31028:1;31017:9;31013:17;31004:6;30960:71;:::i;:::-;31041:72;31109:2;31098:9;31094:18;31085:6;31041:72;:::i;:::-;30914:206;;;;;:::o;31126:218::-;31217:4;31255:2;31244:9;31240:18;31232:26;;31268:69;31334:1;31323:9;31319:17;31310:6;31268:69;:::i;:::-;31222:122;;;;:::o;31350:214::-;31439:4;31477:2;31466:9;31462:18;31454:26;;31490:67;31554:1;31543:9;31539:17;31530:6;31490:67;:::i;:::-;31444:120;;;;:::o;31570:99::-;31622:6;31656:5;31650:12;31640:22;;31629:40;;;:::o;31675:169::-;31759:11;31793:6;31788:3;31781:19;31833:4;31828:3;31824:14;31809:29;;31771:73;;;;:::o;31850:148::-;31952:11;31989:3;31974:18;;31964:34;;;;:::o;32004:305::-;32044:3;32063:20;32081:1;32063:20;:::i;:::-;32058:25;;32097:20;32115:1;32097:20;:::i;:::-;32092:25;;32251:1;32183:66;32179:74;32176:1;32173:81;32170:2;;;32257:18;;:::i;:::-;32170:2;32301:1;32298;32294:9;32287:16;;32048:261;;;;:::o;32315:185::-;32355:1;32372:20;32390:1;32372:20;:::i;:::-;32367:25;;32406:20;32424:1;32406:20;:::i;:::-;32401:25;;32445:1;32435:2;;32450:18;;:::i;:::-;32435:2;32492:1;32489;32485:9;32480:14;;32357:143;;;;:::o;32506:191::-;32546:4;32566:20;32584:1;32566:20;:::i;:::-;32561:25;;32600:20;32618:1;32600:20;:::i;:::-;32595:25;;32639:1;32636;32633:8;32630:2;;;32644:18;;:::i;:::-;32630:2;32689:1;32686;32682:9;32674:17;;32551:146;;;;:::o;32703:96::-;32740:7;32769:24;32787:5;32769:24;:::i;:::-;32758:35;;32748:51;;;:::o;32805:90::-;32839:7;32882:5;32875:13;32868:21;32857:32;;32847:48;;;:::o;32901:77::-;32938:7;32967:5;32956:16;;32946:32;;;:::o;32984:126::-;33021:7;33061:42;33054:5;33050:54;33039:65;;33029:81;;;:::o;33116:142::-;33153:7;33193:58;33186:5;33182:70;33171:81;;33161:97;;;:::o;33264:77::-;33301:7;33330:5;33319:16;;33309:32;;;:::o;33347:93::-;33383:7;33423:10;33416:5;33412:22;33401:33;;33391:49;;;:::o;33446:86::-;33481:7;33521:4;33514:5;33510:16;33499:27;;33489:43;;;:::o;33538:307::-;33606:1;33616:113;33630:6;33627:1;33624:13;33616:113;;;33715:1;33710:3;33706:11;33700:18;33696:1;33691:3;33687:11;33680:39;33652:2;33649:1;33645:10;33640:15;;33616:113;;;33747:6;33744:1;33741:13;33738:2;;;33827:1;33818:6;33813:3;33809:16;33802:27;33738:2;33587:258;;;;:::o;33851:320::-;33895:6;33932:1;33926:4;33922:12;33912:22;;33979:1;33973:4;33969:12;34000:18;33990:2;;34056:4;34048:6;34044:17;34034:27;;33990:2;34118;34110:6;34107:14;34087:18;34084:38;34081:2;;;34137:18;;:::i;:::-;34081:2;33902:269;;;;:::o;34177:79::-;34216:7;34245:5;34234:16;;34224:32;;;:::o;34262:180::-;34310:77;34307:1;34300:88;34407:4;34404:1;34397:15;34431:4;34428:1;34421:15;34448:180;34496:77;34493:1;34486:88;34593:4;34590:1;34583:15;34617:4;34614:1;34607:15;34634:180;34682:77;34679:1;34672:88;34779:4;34776:1;34769:15;34803:4;34800:1;34793:15;34820:102;34861:6;34912:2;34908:7;34903:2;34896:5;34892:14;34888:28;34878:38;;34868:54;;;:::o;34928:174::-;35068:26;35064:1;35056:6;35052:14;35045:50;35034:68;:::o;35108:222::-;35248:34;35244:1;35236:6;35232:14;35225:58;35317:5;35312:2;35304:6;35300:15;35293:30;35214:116;:::o;35336:181::-;35476:33;35472:1;35464:6;35460:14;35453:57;35442:75;:::o;35523:179::-;35663:31;35659:1;35651:6;35647:14;35640:55;35629:73;:::o;35708:221::-;35848:34;35844:1;35836:6;35832:14;35825:58;35917:4;35912:2;35904:6;35900:15;35893:29;35814:115;:::o;35935:181::-;36075:33;36071:1;36063:6;36059:14;36052:57;36041:75;:::o;36122:175::-;36262:27;36258:1;36250:6;36246:14;36239:51;36228:69;:::o;36303:221::-;36443:34;36439:1;36431:6;36427:14;36420:58;36512:4;36507:2;36499:6;36495:15;36488:29;36409:115;:::o;36530:214::-;36670:66;36666:1;36658:6;36654:14;36647:90;36636:108;:::o;36750:179::-;36890:31;36886:1;36878:6;36874:14;36867:55;36856:73;:::o;36935:225::-;37075:34;37071:1;37063:6;37059:14;37052:58;37144:8;37139:2;37131:6;37127:15;37120:33;37041:119;:::o;37166:221::-;37306:34;37302:1;37294:6;37290:14;37283:58;37375:4;37370:2;37362:6;37358:15;37351:29;37272:115;:::o;37393:221::-;37533:34;37529:1;37521:6;37517:14;37510:58;37602:4;37597:2;37589:6;37585:15;37578:29;37499:115;:::o;37620:180::-;37760:32;37756:1;37748:6;37744:14;37737:56;37726:74;:::o;37806:227::-;37946:34;37942:1;37934:6;37930:14;37923:58;38015:10;38010:2;38002:6;37998:15;37991:35;37912:121;:::o;38039:235::-;38179:34;38175:1;38167:6;38163:14;38156:58;38248:18;38243:2;38235:6;38231:15;38224:43;38145:129;:::o;38280:226::-;38420:34;38416:1;38408:6;38404:14;38397:58;38489:9;38484:2;38476:6;38472:15;38465:34;38386:120;:::o;38512:223::-;38652:34;38648:1;38640:6;38636:14;38629:58;38721:6;38716:2;38708:6;38704:15;38697:31;38618:117;:::o;38741:220::-;38881:34;38877:1;38869:6;38865:14;38858:58;38950:3;38945:2;38937:6;38933:15;38926:28;38847:114;:::o;38967:224::-;39107:34;39103:1;39095:6;39091:14;39084:58;39176:7;39171:2;39163:6;39159:15;39152:32;39073:118;:::o;39197:225::-;39337:34;39333:1;39325:6;39321:14;39314:58;39406:8;39401:2;39393:6;39389:15;39382:33;39303:119;:::o;39428:223::-;39568:34;39564:1;39556:6;39552:14;39545:58;39637:6;39632:2;39624:6;39620:15;39613:31;39534:117;:::o;39657:224::-;39797:34;39793:1;39785:6;39781:14;39774:58;39866:7;39861:2;39853:6;39849:15;39842:32;39763:118;:::o;39887:181::-;40027:33;40023:1;40015:6;40011:14;40004:57;39993:75;:::o;40074:122::-;40147:24;40165:5;40147:24;:::i;:::-;40140:5;40137:35;40127:2;;40186:1;40183;40176:12;40127:2;40117:79;:::o;40202:122::-;40275:24;40293:5;40275:24;:::i;:::-;40268:5;40265:35;40255:2;;40314:1;40311;40304:12;40255:2;40245:79;:::o;40330:122::-;40403:24;40421:5;40403:24;:::i;:::-;40396:5;40393:35;40383:2;;40442:1;40439;40432:12;40383:2;40373:79;:::o;40458:120::-;40530:23;40547:5;40530:23;:::i;:::-;40523:5;40520:34;40510:2;;40568:1;40565;40558:12;40510:2;40500:78;:::o;40584:118::-;40655:22;40671:5;40655:22;:::i;:::-;40648:5;40645:33;40635:2;;40692:1;40689;40682:12;40635:2;40625:77;:::o

ipfs://3e09ec2e15aeb9effd56665bc49b558bf190e39bdbf814db7137a09a17774a55