Token MiniYAK

/**
 *Submitted for verification at Etherscan.io on 2021-11-03
*/

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

// File contracts/libs/openzeppelin/token/ERC20/IERC20.sol

// SPDX-License-Identifier: GPL-3.0
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 contracts/libs/openzeppelin/utils/Context.sol

/*
 * @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 contracts/libs/openzeppelin/token/ERC20/ERC20.sol

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 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 contracts/libs/openzeppelin/token/ERC20/extensions/IERC20Permit.sol

/**
 * @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 contracts/libs/openzeppelin/utils/cryptography/ECDSA.sol

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

    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 contracts/libs/openzeppelin/utils/cryptography/EIP712.sol


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

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

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

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _TYPE_HASH = typeHash;
    }

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

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 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 contracts/libs/openzeppelin/utils/Counters.sol

/**
 * @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 contracts/libs/openzeppelin/token/ERC20/extensions/ERC20Permit.sol

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

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

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

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

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual override {
        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 contracts/libs/openzeppelin/utils/Address.sol

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

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File contracts/libs/openzeppelin/token/ERC20/utils/SafeERC20.sol

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

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

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

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

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

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

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

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


// File contracts/libs/openzeppelin/utils/math/Math.sol

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

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

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

    /**
     * @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 contracts/core/MiniYak.sol

contract MiniYak is ERC20Permit {
    using SafeERC20 for IERC20;
    constructor() ERC20("MiniYAK", "mYAK") ERC20Permit("MiniYak") {}
    address public YAK = 0x59414b3089ce2AF0010e7523Dea7E2b35d776ec7;

    /**
     * @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`).
     */
    function decimals() public pure override returns (uint8) {
        return 12;
    }

    /**
     * @notice moons Yak to mini Yak (mints mini Yak )
     * @param amount amount of YAK that will be mooned
     * @param to address of caller or the address to which miniYAK would be transferred to
     */
    function moon(uint amount, address to) external {
        uint mint_amount = Math.min(amount, IERC20(YAK).balanceOf(msg.sender));
        IERC20(YAK).safeTransferFrom(msg.sender,address(this),mint_amount);
        _mint(to, mint_amount);
    }

    /**
     * @notice approves contract and moons Yak to mini Yak (mints mini Yak )
     * @param amount amount of YAK that will be mooned
     * @param to address of caller or the address to which miniYAK would be transferred to
     */
    function moonWithPermit(uint amount, address to, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
        IERC20Permit(YAK).permit(msg.sender, address(this), amount, deadline, v, r, s);
        uint mint_amount = Math.min(amount, IERC20(YAK).balanceOf(msg.sender));
        IERC20(YAK).safeTransferFrom(msg.sender,address(this),mint_amount);
        _mint(to, mint_amount);
    }


    /**
     * @notice unmoons mini Yak to Yak and burns mini Yak
     * @param amount amount of miniyak
     * @param to address of caller or the address to which YAK would be transferred to
     */
    function unmoon(uint amount, address to) external {
        uint burn_amount = Math.min(amount, this.balanceOf(msg.sender));
        _burn(msg.sender, burn_amount);
        IERC20(YAK).safeTransfer(to, burn_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":"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":[],"name":"YAK","outputs":[{"internalType":"address","name":"","type":"address"}],"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":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","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":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"moon","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"},{"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":"moonWithPermit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"unmoon","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

48529:2104:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5763:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7903:169;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6856:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8554:492;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;48982:85;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35031:115;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9455:215;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49297:247;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7027:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34773:128;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49796:392;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5973:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10173:413;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7367:175;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50403:225;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;48671:63;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34062:645;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7605:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5763:91;5808:13;5841:5;5834:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5763:91;:::o;7903:169::-;7986:4;8003:39;8012:12;:10;:12::i;:::-;8026:7;8035:6;8003:8;:39::i;:::-;8060:4;8053:11;;7903:169;;;;:::o;6856:108::-;6917:7;6944:12;;6937:19;;6856:108;:::o;8554:492::-;8694:4;8711:36;8721:6;8729:9;8740:6;8711:9;:36::i;:::-;8760:24;8787:11;:19;8799:6;8787:19;;;;;;;;;;;;;;;:33;8807:12;:10;:12::i;:::-;8787:33;;;;;;;;;;;;;;;;8760:60;;8859:6;8839:16;:26;;8831:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;8946:57;8955:6;8963:12;:10;:12::i;:::-;8996:6;8977:16;:25;8946:8;:57::i;:::-;9034:4;9027:11;;;8554:492;;;;;:::o;48982:85::-;49032:5;49057:2;49050:9;;48982:85;:::o;35031:115::-;35091:7;35118:20;:18;:20::i;:::-;35111:27;;35031:115;:::o;9455:215::-;9543:4;9560:80;9569:12;:10;:12::i;:::-;9583:7;9629:10;9592:11;:25;9604:12;:10;:12::i;:::-;9592:25;;;;;;;;;;;;;;;:34;9618:7;9592:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;9560:8;:80::i;:::-;9658:4;9651:11;;9455:215;;;;:::o;49297:247::-;49356:16;49375:51;49384:6;49399:3;;;;;;;;;;;49392:21;;;49414:10;49392:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49375:8;:51::i;:::-;49356:70;;49437:66;49466:10;49485:4;49491:11;49444:3;;;;;;;;;;;49437:28;;;;:66;;;;;;:::i;:::-;49514:22;49520:2;49524:11;49514:5;:22::i;:::-;49297:247;;;:::o;7027:127::-;7101:7;7128:9;:18;7138:7;7128:18;;;;;;;;;;;;;;;;7121:25;;7027:127;;;:::o;34773:128::-;34842:7;34869:24;:7;:14;34877:5;34869:14;;;;;;;;;;;;;;;:22;:24::i;:::-;34862:31;;34773:128;;;:::o;49796:392::-;49924:3;;;;;;;;;;;49911:24;;;49936:10;49956:4;49963:6;49971:8;49981:1;49984;49987;49911:78;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50000:16;50019:51;50028:6;50043:3;;;;;;;;;;;50036:21;;;50058:10;50036:33;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50019:8;:51::i;:::-;50000:70;;50081:66;50110:10;50129:4;50135:11;50088:3;;;;;;;;;;;50081:28;;;;:66;;;;;;:::i;:::-;50158:22;50164:2;50168:11;50158:5;:22::i;:::-;49796:392;;;;;;;:::o;5973:95::-;6020:13;6053:7;6046:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5973:95;:::o;10173:413::-;10266:4;10283:24;10310:11;:25;10322:12;:10;:12::i;:::-;10310:25;;;;;;;;;;;;;;;:34;10336:7;10310:34;;;;;;;;;;;;;;;;10283:61;;10383:15;10363:16;:35;;10355:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;10476:67;10485:12;:10;:12::i;:::-;10499:7;10527:15;10508:16;:34;10476:8;:67::i;:::-;10574:4;10567:11;;;10173:413;;;;:::o;7367:175::-;7453:4;7470:42;7480:12;:10;:12::i;:::-;7494:9;7505:6;7470:9;:42::i;:::-;7530:4;7523:11;;7367:175;;;;:::o;50403:225::-;50464:16;50483:44;50492:6;50500:4;:14;;;50515:10;50500:26;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50483:8;:44::i;:::-;50464:63;;50538:30;50544:10;50556:11;50538:5;:30::i;:::-;50579:41;50604:2;50608:11;50586:3;;;;;;;;;;;50579:24;;;;:41;;;;;:::i;:::-;50403:225;;;:::o;48671:63::-;;;;;;;;;;;;;:::o;34062:645::-;34306:8;34287:15;:27;;34279:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;34361:18;34403:16;34421:5;34428:7;34437:5;34444:16;34454:5;34444:9;:16::i;:::-;34462:8;34392:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;34382:90;;;;;;34361:111;;34485:12;34500:28;34517:10;34500:16;:28::i;:::-;34485:43;;34541:14;34558:28;34572:4;34578:1;34581;34584;34558:13;:28::i;:::-;34541:45;;34615:5;34605:15;;:6;:15;;;34597:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;34668:31;34677:5;34684:7;34693:5;34668:8;:31::i;:::-;34062:645;;;;;;;;;;:::o;7605:151::-;7694:7;7721:11;:18;7733:5;7721:18;;;;;;;;;;;;;;;:27;7740:7;7721:27;;;;;;;;;;;;;;;;7714:34;;7605:151;;;;:::o;3535:98::-;3588:7;3615:10;3608:17;;3535:98;:::o;13857:380::-;14010:1;13993:19;;:5;:19;;;;13985:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;14091:1;14072:21;;:7;:21;;;;14064:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;14175:6;14145:11;:18;14157:5;14145:18;;;;;;;;;;;;;;;:27;14164:7;14145:27;;;;;;;;;;;;;;;:36;;;;14213:7;14197:32;;14206:5;14197:32;;;14222:6;14197:32;;;;;;:::i;:::-;;;;;;;;13857:380;;;:::o;11076:733::-;11234:1;11216:20;;:6;:20;;;;11208:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;11318:1;11297:23;;:9;:23;;;;11289:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;11373:47;11394:6;11402:9;11413:6;11373:20;:47::i;:::-;11433:21;11457:9;:17;11467:6;11457:17;;;;;;;;;;;;;;;;11433:41;;11510:6;11493:13;:23;;11485:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;11631:6;11615:13;:22;11595:9;:17;11605:6;11595:17;;;;;;;;;;;;;;;:42;;;;11683:6;11659:9;:20;11669:9;11659:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;11724:9;11707:35;;11716:6;11707:35;;;11735:6;11707:35;;;;;;:::i;:::-;;;;;;;;11755:46;11775:6;11783:9;11794:6;11755:19;:46::i;:::-;11076:733;;;;:::o;29970:281::-;30023:7;30064:16;30047:13;:33;30043:201;;;30104:24;30097:31;;;;30043:201;30168:64;30190:10;30202:12;30216:15;30168:21;:64::i;:::-;30161:71;;29970:281;;:::o;47655:106::-;47713:7;47744:1;47740;:5;:13;;47752:1;47740:13;;;47748:1;47740:13;47733:20;;47655:106;;;;:::o;44170:248::-;44314:96;44334:5;44364:27;;;44393:4;44399:2;44403:5;44341:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44314:19;:96::i;:::-;44170:248;;;;:::o;12096:399::-;12199:1;12180:21;;:7;:21;;;;12172:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;12250:49;12279:1;12283:7;12292:6;12250:20;:49::i;:::-;12328:6;12312:12;;:22;;;;;;;:::i;:::-;;;;;;;;12367:6;12345:9;:18;12355:7;12345:18;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;12410:7;12389:37;;12406:1;12389:37;;;12419:6;12389:37;;;;;;:::i;:::-;;;;;;;;12439:48;12467:1;12471:7;12480:6;12439:19;:48::i;:::-;12096:399;;:::o;32129:114::-;32194:7;32221;:14;;;32214:21;;32129:114;;;:::o;12828:591::-;12931:1;12912:21;;:7;:21;;;;12904:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;12984:49;13005:7;13022:1;13026:6;12984:20;:49::i;:::-;13046:22;13071:9;:18;13081:7;13071:18;;;;;;;;;;;;;;;;13046:43;;13126:6;13108:14;:24;;13100:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;13245:6;13228:14;:23;13207:9;:18;13217:7;13207:18;;;;;;;;;;;;;;;:44;;;;13289:6;13273:12;;:22;;;;;;;:::i;:::-;;;;;;;;13339:1;13313:37;;13322:7;13313:37;;;13343:6;13313:37;;;;;;:::i;:::-;;;;;;;;13363:48;13383:7;13400:1;13404:6;13363:19;:48::i;:::-;12828:591;;;:::o;43951:211::-;44068:86;44088:5;44118:23;;;44143:2;44147:5;44095:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44068:19;:86::i;:::-;43951:211;;;:::o;35284:207::-;35344:15;35372:30;35405:7;:14;35413:5;35405:14;;;;;;;;;;;;;;;35372:47;;35440:15;:5;:13;:15::i;:::-;35430:25;;35466:17;:5;:15;:17::i;:::-;35284:207;;;;:::o;31164:167::-;31241:7;31268:55;31290:20;:18;:20::i;:::-;31312:10;31268:21;:55::i;:::-;31261:62;;31164:167;;;:::o;25527:279::-;25655:7;25676:17;25695:18;25717:25;25728:4;25734:1;25737;25740;25717:10;:25::i;:::-;25675:67;;;;25753:18;25765:5;25753:11;:18::i;:::-;25789:9;25782:16;;;;25527:279;;;;;;:::o;14837:125::-;;;;:::o;15566:124::-;;;;:::o;30259:263::-;30403:7;30451:8;30461;30471:11;30484:13;30507:4;30440:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;30430:84;;;;;;30423:91;;30259:263;;;;;:::o;46524:716::-;46948:23;46974:69;47002:4;46974:69;;;;;;;;;;;;;;;;;46982:5;46974:27;;;;:69;;;;;:::i;:::-;46948:95;;47078:1;47058:10;:17;:21;47054:179;;;47155:10;47144:30;;;;;;;;;;;;:::i;:::-;47136:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;47054:179;46524:716;;;:::o;32251:127::-;32358:1;32340:7;:14;;;:19;;;;;;;;;;;32251:127;:::o;26725:196::-;26818:7;26884:15;26901:10;26855:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;26845:68;;;;;;26838:75;;26725:196;;;;:::o;23756:1632::-;23887:7;23896:12;24821:66;24816:1;24808:10;;:79;24804:163;;;24920:1;24924:30;24904:51;;;;;;24804:163;24986:2;24981:1;:7;;;;:18;;;;;24997:2;24992:1;:7;;;;24981:18;24977:102;;;25032:1;25036:30;25016:51;;;;;;24977:102;25176:14;25193:24;25203:4;25209:1;25212;25215;25193:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25176:41;;25250:1;25232:20;;:6;:20;;;25228:103;;;25285:1;25289:29;25269:50;;;;;;;25228:103;25351:6;25359:20;25343:37;;;;;23756:1632;;;;;;;;:::o;18418:643::-;18496:20;18487:29;;;;;;;;;;;;;;;;:5;:29;;;;;;;;;;;;;;;;;18483:571;;;18533:7;;18483:571;18594:29;18585:38;;;;;;;;;;;;;;;;:5;:38;;;;;;;;;;;;;;;;;18581:473;;;18640:34;;;;;;;;;;:::i;:::-;;;;;;;;18581:473;18705:35;18696:44;;;;;;;;;;;;;;;;:5;:44;;;;;;;;;;;;;;;;;18692:362;;;18757:41;;;;;;;;;;:::i;:::-;;;;;;;;18692:362;18829:30;18820:39;;;;;;;;;;;;;;;;:5;:39;;;;;;;;;;;;;;;;;18816:238;;;18876:44;;;;;;;;;;:::i;:::-;;;;;;;;18816:238;18951:30;18942:39;;;;;;;;;;;;;;;;:5;:39;;;;;;;;;;;;;;;;;18938:116;;;18998:44;;;;;;;;;;:::i;:::-;;;;;;;;18938:116;18418:643;;:::o;39044:229::-;39181:12;39213:52;39235:6;39243:4;39249:1;39252:12;39213:21;:52::i;:::-;39206:59;;39044:229;;;;;:::o;40164:511::-;40334:12;40392:5;40367:21;:30;;40359:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;40459:18;40470:6;40459:10;:18::i;:::-;40451:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;40525:12;40539:23;40566:6;:11;;40585:5;40592:4;40566:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40524:73;;;;40615:52;40633:7;40642:10;40654:12;40615:17;:52::i;:::-;40608:59;;;;40164:511;;;;;;:::o;36238:387::-;36298:4;36506:12;36573:7;36561:20;36553:28;;36616:1;36609:4;:8;36602:15;;;36238:387;;;:::o;42633:712::-;42783:12;42812:7;42808:530;;;42843:10;42836:17;;;;42808:530;42977:1;42957:10;:17;:21;42953:374;;;43155:10;43149:17;43216:15;43203:10;43199:2;43195:19;43188:44;43103:148;43298:12;43291:20;;;;;;;;;;;:::i;:::-;;;;;;;;42633:712;;;;;;:::o;7:139:1:-;;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;59:87;;;;:::o;152:137::-;;237:6;231:13;222:22;;253:30;277:5;253:30;:::i;:::-;212:77;;;;:::o;295:139::-;;379:6;366:20;357:29;;395:33;422:5;395:33;:::i;:::-;347:87;;;;:::o;440:139::-;;524:6;511:20;502:29;;540:33;567:5;540:33;:::i;:::-;492:87;;;;:::o;585:143::-;;673:6;667:13;658:22;;689:33;716:5;689:33;:::i;:::-;648:80;;;;:::o;734:135::-;;816:6;803:20;794:29;;832:31;857:5;832:31;:::i;:::-;784:85;;;;:::o;875:262::-;;983:2;971:9;962:7;958:23;954:32;951:2;;;999:1;996;989:12;951:2;1042:1;1067:53;1112:7;1103:6;1092:9;1088:22;1067:53;:::i;:::-;1057:63;;1013:117;941:196;;;;:::o;1143:407::-;;;1268:2;1256:9;1247:7;1243:23;1239:32;1236:2;;;1284:1;1281;1274:12;1236:2;1327:1;1352:53;1397:7;1388:6;1377:9;1373:22;1352:53;:::i;:::-;1342:63;;1298:117;1454:2;1480:53;1525:7;1516:6;1505:9;1501:22;1480:53;:::i;:::-;1470:63;;1425:118;1226:324;;;;;:::o;1556:552::-;;;;1698:2;1686:9;1677:7;1673:23;1669:32;1666:2;;;1714:1;1711;1704:12;1666:2;1757:1;1782:53;1827:7;1818:6;1807:9;1803:22;1782:53;:::i;:::-;1772:63;;1728:117;1884:2;1910:53;1955:7;1946:6;1935:9;1931:22;1910:53;:::i;:::-;1900:63;;1855:118;2012:2;2038:53;2083:7;2074:6;2063:9;2059:22;2038:53;:::i;:::-;2028:63;;1983:118;1656:452;;;;;:::o;2114:1132::-;;;;;;;;2322:3;2310:9;2301:7;2297:23;2293:33;2290:2;;;2339:1;2336;2329:12;2290:2;2382:1;2407:53;2452:7;2443:6;2432:9;2428:22;2407:53;:::i;:::-;2397:63;;2353:117;2509:2;2535:53;2580:7;2571:6;2560:9;2556:22;2535:53;:::i;:::-;2525:63;;2480:118;2637:2;2663:53;2708:7;2699:6;2688:9;2684:22;2663:53;:::i;:::-;2653:63;;2608:118;2765:2;2791:53;2836:7;2827:6;2816:9;2812:22;2791:53;:::i;:::-;2781:63;;2736:118;2893:3;2920:51;2963:7;2954:6;2943:9;2939:22;2920:51;:::i;:::-;2910:61;;2864:117;3020:3;3047:53;3092:7;3083:6;3072:9;3068:22;3047:53;:::i;:::-;3037:63;;2991:119;3149:3;3176:53;3221:7;3212:6;3201:9;3197:22;3176:53;:::i;:::-;3166:63;;3120:119;2280:966;;;;;;;;;;:::o;3252:407::-;;;3377:2;3365:9;3356:7;3352:23;3348:32;3345:2;;;3393:1;3390;3383:12;3345:2;3436:1;3461:53;3506:7;3497:6;3486:9;3482:22;3461:53;:::i;:::-;3451:63;;3407:117;3563:2;3589:53;3634:7;3625:6;3614:9;3610:22;3589:53;:::i;:::-;3579:63;;3534:118;3335:324;;;;;:::o;3665:278::-;;3781:2;3769:9;3760:7;3756:23;3752:32;3749:2;;;3797:1;3794;3787:12;3749:2;3840:1;3865:61;3918:7;3909:6;3898:9;3894:22;3865:61;:::i;:::-;3855:71;;3811:125;3739:204;;;;:::o;3949:284::-;;4068:2;4056:9;4047:7;4043:23;4039:32;4036:2;;;4084:1;4081;4074:12;4036:2;4127:1;4152:64;4208:7;4199:6;4188:9;4184:22;4152:64;:::i;:::-;4142:74;;4098:128;4026:207;;;;:::o;4239:407::-;;;4364:2;4352:9;4343:7;4339:23;4335:32;4332:2;;;4380:1;4377;4370:12;4332:2;4423:1;4448:53;4493:7;4484:6;4473:9;4469:22;4448:53;:::i;:::-;4438:63;;4394:117;4550:2;4576:53;4621:7;4612:6;4601:9;4597:22;4576:53;:::i;:::-;4566:63;;4521:118;4322:324;;;;;:::o;4652:986::-;;;;;;;4843:3;4831:9;4822:7;4818:23;4814:33;4811:2;;;4860:1;4857;4850:12;4811:2;4903:1;4928:53;4973:7;4964:6;4953:9;4949:22;4928:53;:::i;:::-;4918:63;;4874:117;5030:2;5056:53;5101:7;5092:6;5081:9;5077:22;5056:53;:::i;:::-;5046:63;;5001:118;5158:2;5184:53;5229:7;5220:6;5209:9;5205:22;5184:53;:::i;:::-;5174:63;;5129:118;5286:2;5312:51;5355:7;5346:6;5335:9;5331:22;5312:51;:::i;:::-;5302:61;;5257:116;5412:3;5439:53;5484:7;5475:6;5464:9;5460:22;5439:53;:::i;:::-;5429:63;;5383:119;5541:3;5568:53;5613:7;5604:6;5593:9;5589:22;5568:53;:::i;:::-;5558:63;;5512:119;4801:837;;;;;;;;:::o;5644:118::-;5731:24;5749:5;5731:24;:::i;:::-;5726:3;5719:37;5709:53;;:::o;5768:109::-;5849:21;5864:5;5849:21;:::i;:::-;5844:3;5837:34;5827:50;;:::o;5883:118::-;5970:24;5988:5;5970:24;:::i;:::-;5965:3;5958:37;5948:53;;:::o;6007:157::-;6112:45;6132:24;6150:5;6132:24;:::i;:::-;6112:45;:::i;:::-;6107:3;6100:58;6090:74;;:::o;6170:373::-;;6302:38;6334:5;6302:38;:::i;:::-;6356:88;6437:6;6432:3;6356:88;:::i;:::-;6349:95;;6453:52;6498:6;6493:3;6486:4;6479:5;6475:16;6453:52;:::i;:::-;6530:6;6525:3;6521:16;6514:23;;6278:265;;;;;:::o;6549:364::-;;6665:39;6698:5;6665:39;:::i;:::-;6720:71;6784:6;6779:3;6720:71;:::i;:::-;6713:78;;6800:52;6845:6;6840:3;6833:4;6826:5;6822:16;6800:52;:::i;:::-;6877:29;6899:6;6877:29;:::i;:::-;6872:3;6868:39;6861:46;;6641:272;;;;;:::o;6919:366::-;;7082:67;7146:2;7141:3;7082:67;:::i;:::-;7075:74;;7158:93;7247:3;7158:93;:::i;:::-;7276:2;7271:3;7267:12;7260:19;;7065:220;;;:::o;7291:366::-;;7454:67;7518:2;7513:3;7454:67;:::i;:::-;7447:74;;7530:93;7619:3;7530:93;:::i;:::-;7648:2;7643:3;7639:12;7632:19;;7437:220;;;:::o;7663:366::-;;7826:67;7890:2;7885:3;7826:67;:::i;:::-;7819:74;;7902:93;7991:3;7902:93;:::i;:::-;8020:2;8015:3;8011:12;8004:19;;7809:220;;;:::o;8035:366::-;;8198:67;8262:2;8257:3;8198:67;:::i;:::-;8191:74;;8274:93;8363:3;8274:93;:::i;:::-;8392:2;8387:3;8383:12;8376:19;;8181:220;;;:::o;8407:366::-;;8570:67;8634:2;8629:3;8570:67;:::i;:::-;8563:74;;8646:93;8735:3;8646:93;:::i;:::-;8764:2;8759:3;8755:12;8748:19;;8553:220;;;:::o;8779:400::-;;8960:84;9042:1;9037:3;8960:84;:::i;:::-;8953:91;;9053:93;9142:3;9053:93;:::i;:::-;9171:1;9166:3;9162:11;9155:18;;8943:236;;;:::o;9185:366::-;;9348:67;9412:2;9407:3;9348:67;:::i;:::-;9341:74;;9424:93;9513:3;9424:93;:::i;:::-;9542:2;9537:3;9533:12;9526:19;;9331:220;;;:::o;9557:366::-;;9720:67;9784:2;9779:3;9720:67;:::i;:::-;9713:74;;9796:93;9885:3;9796:93;:::i;:::-;9914:2;9909:3;9905:12;9898:19;;9703:220;;;:::o;9929:366::-;;10092:67;10156:2;10151:3;10092:67;:::i;:::-;10085:74;;10168:93;10257:3;10168:93;:::i;:::-;10286:2;10281:3;10277:12;10270:19;;10075:220;;;:::o;10301:366::-;;10464:67;10528:2;10523:3;10464:67;:::i;:::-;10457:74;;10540:93;10629:3;10540:93;:::i;:::-;10658:2;10653:3;10649:12;10642:19;;10447:220;;;:::o;10673:366::-;;10836:67;10900:2;10895:3;10836:67;:::i;:::-;10829:74;;10912:93;11001:3;10912:93;:::i;:::-;11030:2;11025:3;11021:12;11014:19;;10819:220;;;:::o;11045:366::-;;11208:67;11272:2;11267:3;11208:67;:::i;:::-;11201:74;;11284:93;11373:3;11284:93;:::i;:::-;11402:2;11397:3;11393:12;11386:19;;11191:220;;;:::o;11417:366::-;;11580:67;11644:2;11639:3;11580:67;:::i;:::-;11573:74;;11656:93;11745:3;11656:93;:::i;:::-;11774:2;11769:3;11765:12;11758:19;;11563:220;;;:::o;11789:366::-;;11952:67;12016:2;12011:3;11952:67;:::i;:::-;11945:74;;12028:93;12117:3;12028:93;:::i;:::-;12146:2;12141:3;12137:12;12130:19;;11935:220;;;:::o;12161:366::-;;12324:67;12388:2;12383:3;12324:67;:::i;:::-;12317:74;;12400:93;12489:3;12400:93;:::i;:::-;12518:2;12513:3;12509:12;12502:19;;12307:220;;;:::o;12533:366::-;;12696:67;12760:2;12755:3;12696:67;:::i;:::-;12689:74;;12772:93;12861:3;12772:93;:::i;:::-;12890:2;12885:3;12881:12;12874:19;;12679:220;;;:::o;12905:366::-;;13068:67;13132:2;13127:3;13068:67;:::i;:::-;13061:74;;13144:93;13233:3;13144:93;:::i;:::-;13262:2;13257:3;13253:12;13246:19;;13051:220;;;:::o;13277:366::-;;13440:67;13504:2;13499:3;13440:67;:::i;:::-;13433:74;;13516:93;13605:3;13516:93;:::i;:::-;13634:2;13629:3;13625:12;13618:19;;13423:220;;;:::o;13649:366::-;;13812:67;13876:2;13871:3;13812:67;:::i;:::-;13805:74;;13888:93;13977:3;13888:93;:::i;:::-;14006:2;14001:3;13997:12;13990:19;;13795:220;;;:::o;14021:366::-;;14184:67;14248:2;14243:3;14184:67;:::i;:::-;14177:74;;14260:93;14349:3;14260:93;:::i;:::-;14378:2;14373:3;14369:12;14362:19;;14167:220;;;:::o;14393:118::-;14480:24;14498:5;14480:24;:::i;:::-;14475:3;14468:37;14458:53;;:::o;14517:112::-;14600:22;14616:5;14600:22;:::i;:::-;14595:3;14588:35;14578:51;;:::o;14635:271::-;;14787:93;14876:3;14867:6;14787:93;:::i;:::-;14780:100;;14897:3;14890:10;;14769:137;;;;:::o;14912:663::-;;15175:148;15319:3;15175:148;:::i;:::-;15168:155;;15333:75;15404:3;15395:6;15333:75;:::i;:::-;15433:2;15428:3;15424:12;15417:19;;15446:75;15517:3;15508:6;15446:75;:::i;:::-;15546:2;15541:3;15537:12;15530:19;;15566:3;15559:10;;15157:418;;;;;:::o;15581:222::-;;15712:2;15701:9;15697:18;15689:26;;15725:71;15793:1;15782:9;15778:17;15769:6;15725:71;:::i;:::-;15679:124;;;;:::o;15809:442::-;;15996:2;15985:9;15981:18;15973:26;;16009:71;16077:1;16066:9;16062:17;16053:6;16009:71;:::i;:::-;16090:72;16158:2;16147:9;16143:18;16134:6;16090:72;:::i;:::-;16172;16240:2;16229:9;16225:18;16216:6;16172:72;:::i;:::-;15963:288;;;;;;:::o;16257:878::-;;16552:3;16541:9;16537:19;16529:27;;16566:71;16634:1;16623:9;16619:17;16610:6;16566:71;:::i;:::-;16647:72;16715:2;16704:9;16700:18;16691:6;16647:72;:::i;:::-;16729;16797:2;16786:9;16782:18;16773:6;16729:72;:::i;:::-;16811;16879:2;16868:9;16864:18;16855:6;16811:72;:::i;:::-;16893:69;16957:3;16946:9;16942:19;16933:6;16893:69;:::i;:::-;16972:73;17040:3;17029:9;17025:19;17016:6;16972:73;:::i;:::-;17055;17123:3;17112:9;17108:19;17099:6;17055:73;:::i;:::-;16519:616;;;;;;;;;;:::o;17141:332::-;;17300:2;17289:9;17285:18;17277:26;;17313:71;17381:1;17370:9;17366:17;17357:6;17313:71;:::i;:::-;17394:72;17462:2;17451:9;17447:18;17438:6;17394:72;:::i;:::-;17267:206;;;;;:::o;17479:210::-;;17604:2;17593:9;17589:18;17581:26;;17617:65;17679:1;17668:9;17664:17;17655:6;17617:65;:::i;:::-;17571:118;;;;:::o;17695:222::-;;17826:2;17815:9;17811:18;17803:26;;17839:71;17907:1;17896:9;17892:17;17883:6;17839:71;:::i;:::-;17793:124;;;;:::o;17923:775::-;;18194:3;18183:9;18179:19;18171:27;;18208:71;18276:1;18265:9;18261:17;18252:6;18208:71;:::i;:::-;18289:72;18357:2;18346:9;18342:18;18333:6;18289:72;:::i;:::-;18371;18439:2;18428:9;18424:18;18415:6;18371:72;:::i;:::-;18453;18521:2;18510:9;18506:18;18497:6;18453:72;:::i;:::-;18535:73;18603:3;18592:9;18588:19;18579:6;18535:73;:::i;:::-;18618;18686:3;18675:9;18671:19;18662:6;18618:73;:::i;:::-;18161:537;;;;;;;;;:::o;18704:664::-;;18947:3;18936:9;18932:19;18924:27;;18961:71;19029:1;19018:9;19014:17;19005:6;18961:71;:::i;:::-;19042:72;19110:2;19099:9;19095:18;19086:6;19042:72;:::i;:::-;19124;19192:2;19181:9;19177:18;19168:6;19124:72;:::i;:::-;19206;19274:2;19263:9;19259:18;19250:6;19206:72;:::i;:::-;19288:73;19356:3;19345:9;19341:19;19332:6;19288:73;:::i;:::-;18914:454;;;;;;;;:::o;19374:545::-;;19585:3;19574:9;19570:19;19562:27;;19599:71;19667:1;19656:9;19652:17;19643:6;19599:71;:::i;:::-;19680:68;19744:2;19733:9;19729:18;19720:6;19680:68;:::i;:::-;19758:72;19826:2;19815:9;19811:18;19802:6;19758:72;:::i;:::-;19840;19908:2;19897:9;19893:18;19884:6;19840:72;:::i;:::-;19552:367;;;;;;;:::o;19925:313::-;;20076:2;20065:9;20061:18;20053:26;;20125:9;20119:4;20115:20;20111:1;20100:9;20096:17;20089:47;20153:78;20226:4;20217:6;20153:78;:::i;:::-;20145:86;;20043:195;;;;:::o;20244:419::-;;20448:2;20437:9;20433:18;20425:26;;20497:9;20491:4;20487:20;20483:1;20472:9;20468:17;20461:47;20525:131;20651:4;20525:131;:::i;:::-;20517:139;;20415:248;;;:::o;20669:419::-;;20873:2;20862:9;20858:18;20850:26;;20922:9;20916:4;20912:20;20908:1;20897:9;20893:17;20886:47;20950:131;21076:4;20950:131;:::i;:::-;20942:139;;20840:248;;;:::o;21094:419::-;;21298:2;21287:9;21283:18;21275:26;;21347:9;21341:4;21337:20;21333:1;21322:9;21318:17;21311:47;21375:131;21501:4;21375:131;:::i;:::-;21367:139;;21265:248;;;:::o;21519:419::-;;21723:2;21712:9;21708:18;21700:26;;21772:9;21766:4;21762:20;21758:1;21747:9;21743:17;21736:47;21800:131;21926:4;21800:131;:::i;:::-;21792:139;;21690:248;;;:::o;21944:419::-;;22148:2;22137:9;22133:18;22125:26;;22197:9;22191:4;22187:20;22183:1;22172:9;22168:17;22161:47;22225:131;22351:4;22225:131;:::i;:::-;22217:139;;22115:248;;;:::o;22369:419::-;;22573:2;22562:9;22558:18;22550:26;;22622:9;22616:4;22612:20;22608:1;22597:9;22593:17;22586:47;22650:131;22776:4;22650:131;:::i;:::-;22642:139;;22540:248;;;:::o;22794:419::-;;22998:2;22987:9;22983:18;22975:26;;23047:9;23041:4;23037:20;23033:1;23022:9;23018:17;23011:47;23075:131;23201:4;23075:131;:::i;:::-;23067:139;;22965:248;;;:::o;23219:419::-;;23423:2;23412:9;23408:18;23400:26;;23472:9;23466:4;23462:20;23458:1;23447:9;23443:17;23436:47;23500:131;23626:4;23500:131;:::i;:::-;23492:139;;23390:248;;;:::o;23644:419::-;;23848:2;23837:9;23833:18;23825:26;;23897:9;23891:4;23887:20;23883:1;23872:9;23868:17;23861:47;23925:131;24051:4;23925:131;:::i;:::-;23917:139;;23815:248;;;:::o;24069:419::-;;24273:2;24262:9;24258:18;24250:26;;24322:9;24316:4;24312:20;24308:1;24297:9;24293:17;24286:47;24350:131;24476:4;24350:131;:::i;:::-;24342:139;;24240:248;;;:::o;24494:419::-;;24698:2;24687:9;24683:18;24675:26;;24747:9;24741:4;24737:20;24733:1;24722:9;24718:17;24711:47;24775:131;24901:4;24775:131;:::i;:::-;24767:139;;24665:248;;;:::o;24919:419::-;;25123:2;25112:9;25108:18;25100:26;;25172:9;25166:4;25162:20;25158:1;25147:9;25143:17;25136:47;25200:131;25326:4;25200:131;:::i;:::-;25192:139;;25090:248;;;:::o;25344:419::-;;25548:2;25537:9;25533:18;25525:26;;25597:9;25591:4;25587:20;25583:1;25572:9;25568:17;25561:47;25625:131;25751:4;25625:131;:::i;:::-;25617:139;;25515:248;;;:::o;25769:419::-;;25973:2;25962:9;25958:18;25950:26;;26022:9;26016:4;26012:20;26008:1;25997:9;25993:17;25986:47;26050:131;26176:4;26050:131;:::i;:::-;26042:139;;25940:248;;;:::o;26194:419::-;;26398:2;26387:9;26383:18;26375:26;;26447:9;26441:4;26437:20;26433:1;26422:9;26418:17;26411:47;26475:131;26601:4;26475:131;:::i;:::-;26467:139;;26365:248;;;:::o;26619:419::-;;26823:2;26812:9;26808:18;26800:26;;26872:9;26866:4;26862:20;26858:1;26847:9;26843:17;26836:47;26900:131;27026:4;26900:131;:::i;:::-;26892:139;;26790:248;;;:::o;27044:419::-;;27248:2;27237:9;27233:18;27225:26;;27297:9;27291:4;27287:20;27283:1;27272:9;27268:17;27261:47;27325:131;27451:4;27325:131;:::i;:::-;27317:139;;27215:248;;;:::o;27469:419::-;;27673:2;27662:9;27658:18;27650:26;;27722:9;27716:4;27712:20;27708:1;27697:9;27693:17;27686:47;27750:131;27876:4;27750:131;:::i;:::-;27742:139;;27640:248;;;:::o;27894:419::-;;28098:2;28087:9;28083:18;28075:26;;28147:9;28141:4;28137:20;28133:1;28122:9;28118:17;28111:47;28175:131;28301:4;28175:131;:::i;:::-;28167:139;;28065:248;;;:::o;28319:222::-;;28450:2;28439:9;28435:18;28427:26;;28463:71;28531:1;28520:9;28516:17;28507:6;28463:71;:::i;:::-;28417:124;;;;:::o;28547:214::-;;28674:2;28663:9;28659:18;28651:26;;28687:67;28751:1;28740:9;28736:17;28727:6;28687:67;:::i;:::-;28641:120;;;;:::o;28767:98::-;;28852:5;28846:12;28836:22;;28825:40;;;:::o;28871:99::-;;28957:5;28951:12;28941:22;;28930:40;;;:::o;28976:147::-;;29114:3;29099:18;;29089:34;;;;:::o;29129:169::-;;29247:6;29242:3;29235:19;29287:4;29282:3;29278:14;29263:29;;29225:73;;;;:::o;29304:148::-;;29443:3;29428:18;;29418:34;;;;:::o;29458:305::-;;29517:20;29535:1;29517:20;:::i;:::-;29512:25;;29551:20;29569:1;29551:20;:::i;:::-;29546:25;;29705:1;29637:66;29633:74;29630:1;29627:81;29624:2;;;29711:18;;:::i;:::-;29624:2;29755:1;29752;29748:9;29741:16;;29502:261;;;;:::o;29769:191::-;;29829:20;29847:1;29829:20;:::i;:::-;29824:25;;29863:20;29881:1;29863:20;:::i;:::-;29858:25;;29902:1;29899;29896:8;29893:2;;;29907:18;;:::i;:::-;29893:2;29952:1;29949;29945:9;29937:17;;29814:146;;;;:::o;29966:96::-;;30032:24;30050:5;30032:24;:::i;:::-;30021:35;;30011:51;;;:::o;30068:90::-;;30145:5;30138:13;30131:21;30120:32;;30110:48;;;:::o;30164:77::-;;30230:5;30219:16;;30209:32;;;:::o;30247:126::-;;30324:42;30317:5;30313:54;30302:65;;30292:81;;;:::o;30379:77::-;;30445:5;30434:16;;30424:32;;;:::o;30462:86::-;;30537:4;30530:5;30526:16;30515:27;;30505:43;;;:::o;30554:307::-;30622:1;30632:113;30646:6;30643:1;30640:13;30632:113;;;30731:1;30726:3;30722:11;30716:18;30712:1;30707:3;30703:11;30696:39;30668:2;30665:1;30661:10;30656:15;;30632:113;;;30763:6;30760:1;30757:13;30754:2;;;30843:1;30834:6;30829:3;30825:16;30818:27;30754:2;30603:258;;;;:::o;30867:320::-;;30948:1;30942:4;30938:12;30928:22;;30995:1;30989:4;30985:12;31016:18;31006:2;;31072:4;31064:6;31060:17;31050:27;;31006:2;31134;31126:6;31123:14;31103:18;31100:38;31097:2;;;31153:18;;:::i;:::-;31097:2;30918:269;;;;:::o;31193:79::-;;31261:5;31250:16;;31240:32;;;:::o;31278:180::-;31326:77;31323:1;31316:88;31423:4;31420:1;31413:15;31447:4;31444:1;31437:15;31464:180;31512:77;31509:1;31502:88;31609:4;31606:1;31599:15;31633:4;31630:1;31623:15;31650:102;;31742:2;31738:7;31733:2;31726:5;31722:14;31718:28;31708:38;;31698:54;;;:::o;31758:174::-;31898:26;31894:1;31886:6;31882:14;31875:50;31864:68;:::o;31938:222::-;32078:34;32074:1;32066:6;32062:14;32055:58;32147:5;32142:2;32134:6;32130:15;32123:30;32044:116;:::o;32166:221::-;32306:34;32302:1;32294:6;32290:14;32283:58;32375:4;32370:2;32362:6;32358:15;32351:29;32272:115;:::o;32393:181::-;32533:33;32529:1;32521:6;32517:14;32510:57;32499:75;:::o;32580:221::-;32720:34;32716:1;32708:6;32704:14;32697:58;32789:4;32784:2;32776:6;32772:15;32765:29;32686:115;:::o;32807:214::-;32947:66;32943:1;32935:6;32931:14;32924:90;32913:108;:::o;33027:179::-;33167:31;33163:1;33155:6;33151:14;33144:55;33133:73;:::o;33212:225::-;33352:34;33348:1;33340:6;33336:14;33329:58;33421:8;33416:2;33408:6;33404:15;33397:33;33318:119;:::o;33443:221::-;33583:34;33579:1;33571:6;33567:14;33560:58;33652:4;33647:2;33639:6;33635:15;33628:29;33549:115;:::o;33670:225::-;33810:34;33806:1;33798:6;33794:14;33787:58;33879:8;33874:2;33866:6;33862:15;33855:33;33776:119;:::o;33901:221::-;34041:34;34037:1;34029:6;34025:14;34018:58;34110:4;34105:2;34097:6;34093:15;34086:29;34007:115;:::o;34128:180::-;34268:32;34264:1;34256:6;34252:14;34245:56;34234:74;:::o;34314:227::-;34454:34;34450:1;34442:6;34438:14;34431:58;34523:10;34518:2;34510:6;34506:15;34499:35;34420:121;:::o;34547:220::-;34687:34;34683:1;34675:6;34671:14;34664:58;34756:3;34751:2;34743:6;34739:15;34732:28;34653:114;:::o;34773:224::-;34913:34;34909:1;34901:6;34897:14;34890:58;34982:7;34977:2;34969:6;34965:15;34958:32;34879:118;:::o;35003:223::-;35143:34;35139:1;35131:6;35127:14;35120:58;35212:6;35207:2;35199:6;35195:15;35188:31;35109:117;:::o;35232:179::-;35372:31;35368:1;35360:6;35356:14;35349:55;35338:73;:::o;35417:229::-;35557:34;35553:1;35545:6;35541:14;35534:58;35626:12;35621:2;35613:6;35609:15;35602:37;35523:123;:::o;35652:224::-;35792:34;35788:1;35780:6;35776:14;35769:58;35861:7;35856:2;35848:6;35844:15;35837:32;35758:118;:::o;35882:181::-;36022:33;36018:1;36010:6;36006:14;35999:57;35988:75;:::o;36069:122::-;36142:24;36160:5;36142:24;:::i;:::-;36135:5;36132:35;36122:2;;36181:1;36178;36171:12;36122:2;36112:79;:::o;36197:116::-;36267:21;36282:5;36267:21;:::i;:::-;36260:5;36257:32;36247:2;;36303:1;36300;36293:12;36247:2;36237:76;:::o;36319:122::-;36392:24;36410:5;36392:24;:::i;:::-;36385:5;36382:35;36372:2;;36431:1;36428;36421:12;36372:2;36362:79;:::o;36447:122::-;36520:24;36538:5;36520:24;:::i;:::-;36513:5;36510:35;36500:2;;36559:1;36556;36549:12;36500:2;36490:79;:::o;36575:118::-;36646:22;36662:5;36646:22;:::i;:::-;36639:5;36636:33;36626:2;;36683:1;36680;36673:12;36626:2;36616:77;:::o

ipfs://d9aebefb4e0374d8041b67a41cd25f5dc976199e34056067767660c917bd8d96