Token xSCREAM

/**
 *Submitted for verification at Etherscan.io on 2021-07-30
*/

// 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 contracts/Interfaces/IxScream.sol

pragma solidity ^0.8.0;

interface IxSCREAM {
    event Deposit(address user, uint256 _scream);
    event Withdraw(address, uint256 _shares, uint256 _scream);

    struct Permit {
        address owner;
        address spender;
        uint256 amount;
        uint256 deadline;
        uint8 v;
        bytes32 r;
        bytes32 s;
    }
    
    function getShareValue() external returns (uint256);
    function deposit(uint256 _amount) external;
    function depositWithPermit(uint256 _amount, Permit calldata permit) external;
    function withdraw(uint256 _amount) external;
    function collect(IERC20 _token) external;
}


// File contracts/utils/Context.sol

pragma solidity ^0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN 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 memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


// File contracts/ERC20/IERC20Metadata.sol

pragma solidity ^0.8.0;

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
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 contracts/ERC20/ERC20.sol

pragma solidity ^0.8.0;



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

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

    uint256 internal _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

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

        return true;
    }

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

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

        emit Transfer(sender, recipient, amount);
    }

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

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

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

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

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

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

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


// File contracts/utils/Ownable.sol

pragma solidity ^0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

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

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

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


// File contracts/ERC20/IERC20Permit.sol

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `amount` 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 amount, 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/ERC20/ECDSA.sol

pragma solidity ^0.8.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        // Divide the signature in r, s and v variables
        bytes32 r;
        bytes32 s;
        uint8 v;

        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098)
        if (signature.length == 65) {
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            // solhint-disable-next-line no-inline-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
        } else if (signature.length == 64) {
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            // solhint-disable-next-line no-inline-assembly
            assembly {
                let vs := mload(add(signature, 0x40))
                r := mload(add(signature, 0x20))
                s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
                v := add(shr(255, vs), 27)
            }
        } else {
            revert("ECDSA: invalid signature length");
        }

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

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

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

        return signer;
    }

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

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


// File contracts/ERC20/EIP712.sol

pragma solidity ^0.8.0;

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

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;
    /* solhint-enable var-name-mixedcase */

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

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

    function _buildDomainSeparator(bytes32 typeHash, bytes32 name, bytes32 version) private view returns (bytes32) {
        return keccak256(
            abi.encode(
                typeHash,
                name,
                version,
                block.chainid,
                address(this)
            )
        );
    }

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


// File contracts/utils/Counters.sol

pragma solidity ^0.8.0;

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

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

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

    function decrement(Counter storage counter) internal {
        counter._value = counter._value - 1;
    }
}


// File contracts/ERC20/ERC20Permit.sol

pragma solidity ^0.8.0;





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

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

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

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

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

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

        bytes32 hash = _hashTypedDataV4(structHash);

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

        _approve(owner, spender, value);
    }

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

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

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


// File contracts/utils/Address.sol

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File contracts/ERC20/SafeERC20.sol

pragma solidity ^0.8.0;


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

    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'
        // solhint-disable-next-line max-line-length
        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
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


// File contracts/xScream.sol

pragma solidity ^0.8.0;






contract xSCREAM is ERC20("xSCREAM", "xSCREAM"), ERC20Permit("xSCREAM"), IxSCREAM, Ownable {
    using SafeERC20 for IERC20;
    IERC20 public immutable scream;

    constructor(IERC20 _scream) {
        scream = _scream;
    }

    function getShareValue() external view override returns (uint256) {
        return totalSupply() > 0
            ? 1e18 * scream.balanceOf(address(this)) / totalSupply()
            : 1e18;
    }

    function deposit(uint256 _amount) public override {
        uint256 totalScream = scream.balanceOf(address(this));
        uint256 totalShares = totalSupply();
        // if user is first depositer, mint _amount of xSTEAK
        if (totalShares == 0 || totalScream == 0) {
            _mint(msg.sender, _amount);
        } else {
            // loss of precision if totalScream is significantly greater than totalShares
            // seeding the pool with decent amount of SCREAM prevents this
            uint256 myShare = _amount * totalShares / totalScream;
            _mint(msg.sender, myShare);
        }
        scream.safeTransferFrom(msg.sender, address(this), _amount);
        emit Deposit(msg.sender, _amount);
    }

    function depositWithPermit(uint256 _amount, Permit calldata permit) external override {
        IERC20Permit(address(scream)).permit(
            permit.owner,
            permit.spender,
            permit.amount,
            permit.deadline,
            permit.v,
            permit.r,
            permit.s
        );
        deposit(_amount);
    }

    function withdraw(uint256 _share) external override {
        uint256 totalShares = totalSupply();
        uint256 shareInScream = _share * scream.balanceOf(address(this)) / totalShares;
        _burn(msg.sender, _share);
        scream.safeTransfer(msg.sender, shareInScream);
        emit Withdraw(msg.sender, _share, shareInScream);
    }

    /// @notice Tokens that are accidentally sent to this contract can be recovered
    function collect(IERC20 _token) external override onlyOwner {
        if (totalSupply() > 0) {
            require(_token != scream, "xSCREAM: cannot collect SCREAM");
        }
        uint256 balance = _token.balanceOf(address(this));
        require(balance > 0, "xSCREAM: _token balance is 0");
        _token.safeTransfer(msg.sender, balance);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_scream","type":"address"}],"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":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"_scream","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"","type":"address"},{"indexed":false,"internalType":"uint256","name":"_shares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_scream","type":"uint256"}],"name":"Withdraw","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":"contract IERC20","name":"_token","type":"address"}],"name":"collect","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","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"}],"internalType":"struct IxSCREAM.Permit","name":"permit","type":"tuple"}],"name":"depositWithPermit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getShareValue","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":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"scream","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_share","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000e0654c8e6fd4d733349ac7e09f6f23da256bf475

-----Decoded View---------------
Arg [0] : _scream (address): 0xe0654c8e6fd4d733349ac7e09f6f23da256bf475

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000e0654c8e6fd4d733349ac7e09f6f23da256bf475

44959:2374:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46969:361;;;;;;:::i;:::-;;:::i;:::-;;7062:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9229:169;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;8182:108::-;;;:::i;:::-;;;;;;;:::i;9880:422::-;;;;;;:::i;:::-;;:::i;46159:362::-;;;;;;:::i;:::-;;:::i;46529:347::-;;;;;;:::i;:::-;;:::i;8024:93::-;;;:::i;:::-;;;;;;;:::i;32652:115::-;;;:::i;10711:215::-;;;;;;:::i;:::-;;:::i;45200:199::-;;;:::i;8353:127::-;;;;;;:::i;:::-;;:::i;16672:148::-;;;:::i;32394:128::-;;;;;;:::i;:::-;;:::i;16030:79::-;;;:::i;:::-;;;;;;;:::i;7281:104::-;;;:::i;11429:377::-;;;;;;:::i;:::-;;:::i;8693:175::-;;;;;;:::i;:::-;;:::i;45407:744::-;;;;;;:::i;:::-;;:::i;31557:771::-;;;;;;:::i;:::-;;:::i;8931:151::-;;;;;;:::i;:::-;;:::i;45090:30::-;;;:::i;16975:244::-;;;;;;:::i;:::-;;:::i;46969:361::-;16252:12;:10;:12::i;:::-;16242:6;;-1:-1:-1;;;;;16242:6:0;;;:22;;;16234:67;;;;-1:-1:-1;;;16234:67:0;;;;;;;:::i;:::-;;;;;;;;;47060:1:::1;47044:13;:11;:13::i;:::-;:17;47040:109;;;47096:6;-1:-1:-1::0;;;;;47086:16:0::1;:6;-1:-1:-1::0;;;;;47086:16:0::1;;;47078:59;;;;-1:-1:-1::0;;;47078:59:0::1;;;;;;;:::i;:::-;47177:31;::::0;-1:-1:-1;;;47177:31:0;;47159:15:::1;::::0;-1:-1:-1;;;;;47177:16:0;::::1;::::0;::::1;::::0;:31:::1;::::0;47202:4:::1;::::0;47177:31:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47159:49;;47237:1;47227:7;:11;47219:52;;;;-1:-1:-1::0;;;47219:52:0::1;;;;;;;:::i;:::-;47282:40;-1:-1:-1::0;;;;;47282:19:0;::::1;47302:10;47314:7:::0;47282:19:::1;:40::i;:::-;16312:1;46969:361:::0;:::o;7062:100::-;7116:13;7149:5;7142:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7062:100;;:::o;9229:169::-;9312:4;9329:39;9338:12;:10;:12::i;:::-;9352:7;9361:6;9329:8;:39::i;:::-;-1:-1:-1;9386:4:0;9229:169;;;;:::o;8182:108::-;8270:12;;8182:108;:::o;9880:422::-;9986:4;10003:36;10013:6;10021:9;10032:6;10003:9;:36::i;:::-;-1:-1:-1;;;;;10079:19:0;;10052:24;10079:19;;;:11;:19;;;;;10052:24;10099:12;:10;:12::i;:::-;-1:-1:-1;;;;;10079:33:0;-1:-1:-1;;;;;10079:33:0;;;;;;;;;;;;;10052:60;;10151:6;10131:16;:26;;10123:79;;;;-1:-1:-1;;;10123:79:0;;;;;;;:::i;:::-;10213:57;10222:6;10230:12;:10;:12::i;:::-;10244:25;10263:6;10244:16;:25;:::i;:::-;10213:8;:57::i;:::-;10290:4;10283:11;;;9880:422;;;;;;:::o;46159:362::-;-1:-1:-1;;;;;46277:6:0;46256:36;;46307:12;;;;:6;:12;:::i;:::-;46334:14;;;;;;;;:::i;:::-;46363:13;;;;46391:15;;;;46421:8;;;;;;;;:::i;:::-;46444:6;:8;;;46467:6;:8;;;46256:230;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46497:16;46505:7;46497;:16::i;46529:347::-;46592:19;46614:13;:11;:13::i;:::-;46592:35;;46638:21;46705:11;46671:6;-1:-1:-1;;;;;46671:16:0;;46696:4;46671:31;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46662:40;;:6;:40;:::i;:::-;:54;;;;:::i;:::-;46638:78;;46727:25;46733:10;46745:6;46727:5;:25::i;:::-;46763:46;-1:-1:-1;;;;;46763:6:0;:19;46783:10;46795:13;46763:19;:46::i;:::-;46825:43;46834:10;46846:6;46854:13;46825:43;;;;;;;;:::i;:::-;;;;;;;;46529:347;;;:::o;8024:93::-;8107:2;8024:93;:::o;32652:115::-;32712:7;32739:20;:18;:20::i;:::-;32732:27;;32652:115;:::o;10711:215::-;10799:4;10816:80;10825:12;:10;:12::i;:::-;10839:7;10885:10;10848:11;:25;10860:12;:10;:12::i;:::-;-1:-1:-1;;;;;10848:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;10848:25:0;;;:34;;;;;;;;;;:47;;;;:::i;45200:199::-;45257:7;45300:1;45284:13;:11;:13::i;:::-;:17;:107;;45387:4;45284:107;;;45358:13;:11;:13::i;:::-;45324:31;;-1:-1:-1;;;45324:31:0;;-1:-1:-1;;;;;45324:6:0;:16;;;;:31;;45349:4;;45324:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45317:38;;:4;:38;:::i;:::-;:54;;;;:::i;8353:127::-;-1:-1:-1;;;;;8454:18:0;;8427:7;8454:18;;;;;;;;;;;8353:127;;;;:::o;16672:148::-;16252:12;:10;:12::i;:::-;16242:6;;-1:-1:-1;;;;;16242:6:0;;;:22;;;16234:67;;;;-1:-1:-1;;;16234:67:0;;;;;;;:::i;:::-;16763:6:::1;::::0;16742:40:::1;::::0;16779:1:::1;::::0;-1:-1:-1;;;;;16763:6:0::1;::::0;16742:40:::1;::::0;16779:1;;16742:40:::1;16793:6;:19:::0;;;::::1;::::0;;16672:148::o;32394:128::-;-1:-1:-1;;;;;32490:14:0;;32463:7;32490:14;;;:7;:14;;;;;:24;;:22;:24::i;:::-;32483:31;32394:128;-1:-1:-1;;32394:128:0:o;16030:79::-;16095:6;;-1:-1:-1;;;;;16095:6:0;16030:79;:::o;7281:104::-;7337:13;7370:7;7363:14;;;;;:::i;11429:377::-;11522:4;11539:24;11566:11;:25;11578:12;:10;:12::i;:::-;-1:-1:-1;;;;;11566:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;11566:25:0;;;:34;;;;;;;;;;;-1:-1:-1;11619:35:0;;;;11611:85;;;;-1:-1:-1;;;11611:85:0;;;;;;;:::i;:::-;11707:67;11716:12;:10;:12::i;:::-;11730:7;11739:34;11758:15;11739:16;:34;:::i;11707:67::-;-1:-1:-1;11794:4:0;;11429:377;-1:-1:-1;;;11429:377:0:o;8693:175::-;8779:4;8796:42;8806:12;:10;:12::i;:::-;8820:9;8831:6;8796:9;:42::i;45407:744::-;45490:31;;-1:-1:-1;;;45490:31:0;;45468:19;;-1:-1:-1;;;;;45490:6:0;:16;;;;:31;;45515:4;;45490:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45468:53;;45532:19;45554:13;:11;:13::i;:::-;45532:35;-1:-1:-1;45645:16:0;;;:36;;-1:-1:-1;45665:16:0;;45645:36;45641:389;;;45698:26;45704:10;45716:7;45698:5;:26::i;:::-;45641:389;;;45924:15;45966:11;45942:21;45952:11;45942:7;:21;:::i;:::-;:35;;;;:::i;:::-;45924:53;;45992:26;45998:10;46010:7;45992:5;:26::i;:::-;45641:389;;46040:59;-1:-1:-1;;;;;46040:6:0;:23;46064:10;46084:4;46091:7;46040:23;:59::i;:::-;46115:28;46123:10;46135:7;46115:28;;;;;;;:::i;31557:771::-;31786:8;31767:15;:27;;31759:69;;;;-1:-1:-1;;;31759:69:0;;;;;;;:::i;:::-;31841:18;31915:16;31950:5;31974:7;32000:5;32024:16;32034:5;32024:9;:16::i;:::-;32059:8;31886:196;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;31862:231;;;;;;31841:252;;32106:12;32121:28;32138:10;32121:16;:28::i;:::-;32106:43;;32162:14;32179:28;32193:4;32199:1;32202;32205;32179:13;:28::i;:::-;32162:45;;32236:5;-1:-1:-1;;;;;32226:15:0;:6;-1:-1:-1;;;;;32226:15:0;;32218:58;;;;-1:-1:-1;;;32218:58:0;;;;;;;:::i;:::-;32289:31;32298:5;32305:7;32314:5;32289:8;:31::i;:::-;31557:771;;;;;;;;;;:::o;8931:151::-;-1:-1:-1;;;;;9047:18:0;;;9020:7;9047:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;8931:151::o;45090:30::-;;;:::o;16975:244::-;16252:12;:10;:12::i;:::-;16242:6;;-1:-1:-1;;;;;16242:6:0;;;:22;;;16234:67;;;;-1:-1:-1;;;16234:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;17064:22:0;::::1;17056:73;;;;-1:-1:-1::0;;;17056:73:0::1;;;;;;;:::i;:::-;17166:6;::::0;17145:38:::1;::::0;-1:-1:-1;;;;;17145:38:0;;::::1;::::0;17166:6:::1;::::0;17145:38:::1;::::0;17166:6:::1;::::0;17145:38:::1;17194:6;:17:::0;;;::::1;-1:-1:-1::0;;;;;17194:17:0;;;::::1;::::0;;;::::1;::::0;;16975:244::o;4085:98::-;4165:10;4085:98;:::o;41685:177::-;41768:86;41788:5;41818:23;;;41843:2;41847:5;41795:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;41795:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;41768:19;:86::i;:::-;41685:177;;;:::o;14601:346::-;-1:-1:-1;;;;;14703:19:0;;14695:68;;;;-1:-1:-1;;;14695:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;14782:21:0;;14774:68;;;;-1:-1:-1;;;14774:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;14855:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;14907:32;;;;;14885:6;;14907:32;:::i;:::-;;;;;;;;14601:346;;;:::o;12296:544::-;-1:-1:-1;;;;;12402:20:0;;12394:70;;;;-1:-1:-1;;;12394:70:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;12483:23:0;;12475:71;;;;-1:-1:-1;;;12475:71:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;12583:17:0;;12559:21;12583:17;;;;;;;;;;;12619:23;;;;12611:74;;;;-1:-1:-1;;;12611:74:0;;;;;;;:::i;:::-;12716:22;12732:6;12716:13;:22;:::i;:::-;-1:-1:-1;;;;;12696:17:0;;;:9;:17;;;;;;;;;;;:42;;;;12749:20;;;;;;;;:30;;12773:6;;12696:9;12749:30;;12773:6;;12749:30;:::i;:::-;;;;;;;;12814:9;-1:-1:-1;;;;;12797:35:0;12806:6;-1:-1:-1;;;;;12797:35:0;;12825:6;12797:35;;;;;;:::i;:::-;;;;;;;;12296:544;;;;:::o;13731:432::-;-1:-1:-1;;;;;13815:21:0;;13807:67;;;;-1:-1:-1;;;13807:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;13912:18:0;;13887:22;13912:18;;;;;;;;;;;13949:24;;;;13941:71;;;;-1:-1:-1;;;13941:71:0;;;;;;;:::i;:::-;14044:23;14061:6;14044:14;:23;:::i;:::-;-1:-1:-1;;;;;14023:18:0;;:9;:18;;;;;;;;;;:44;;;;14078:12;:22;;14094:6;;14023:9;14078:22;;14094:6;;14078:22;:::i;:::-;;;;-1:-1:-1;;14118:37:0;;14144:1;;-1:-1:-1;;;;;14118:37:0;;;;;;;14148:6;;14118:37;:::i;27632:281::-;27685:7;27726:16;27709:13;:33;27705:201;;;-1:-1:-1;27766:24:0;27759:31;;27705:201;27830:64;27852:10;27864:12;27878:15;27830:21;:64::i;:::-;27823:71;;;;29884:114;29976:14;;29884:114::o;13122:276::-;-1:-1:-1;;;;;13206:21:0;;13198:65;;;;-1:-1:-1;;;13198:65:0;;;;;;;:::i;:::-;13292:6;13276:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;13309:18:0;;:9;:18;;;;;;;;;;:28;;13331:6;;13309:9;:28;;13331:6;;13309:28;:::i;:::-;;;;-1:-1:-1;;13353:37:0;;-1:-1:-1;;;;;13353:37:0;;;13370:1;;13353:37;;;;13383:6;;13353:37;:::i;:::-;;;;;;;;13122:276;;:::o;41870:205::-;41971:96;41991:5;42021:27;;;42050:4;42056:2;42060:5;41998:68;;;;;;;;;;:::i;41971:96::-;41870:205;;;;:::o;32865:207::-;-1:-1:-1;;;;;32986:14:0;;32925:15;32986:14;;;:7;:14;;;;;33021:15;32986:14;33021:13;:15::i;:::-;33011:25;;33047:17;:5;:15;:17::i;:::-;32865:207;;;;:::o;28900:177::-;28969:7;29035:20;:18;:20::i;:::-;29057:10;29006:62;;;;;;;;;:::i;:::-;;;;;;;;;;;;;28996:73;;;;;;28989:80;;28900:177;;;:::o;22099:1432::-;22184:7;23109:66;23095:80;;;23087:127;;;;-1:-1:-1;;;23087:127:0;;;;;;;:::i;:::-;23233:1;:7;;23238:2;23233:7;:18;;;;23244:1;:7;;23249:2;23244:7;23233:18;23225:65;;;;-1:-1:-1;;;23225:65:0;;;;;;;:::i;:::-;23388:14;23405:24;23415:4;23421:1;23424;23427;23405:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;23405:24:0;;-1:-1:-1;;23405:24:0;;;-1:-1:-1;;;;;;;23448:20:0;;23440:57;;;;-1:-1:-1;;;23440:57:0;;;;;;;:::i;:::-;23517:6;22099:1432;-1:-1:-1;;;;;22099:1432:0:o;44119:761::-;44543:23;44569:69;44597:4;44569:69;;;;;;;;;;;;;;;;;44577:5;-1:-1:-1;;;;;44569:27:0;;;:69;;;;;:::i;:::-;44653:17;;44543:95;;-1:-1:-1;44653:21:0;44649:224;;44795:10;44784:30;;;;;;;;;;;;:::i;:::-;44776:85;;;;-1:-1:-1;;;44776:85:0;;;;;;;:::i;27921:337::-;28023:7;28103:8;28130:4;28153:7;28179:13;28219:4;28074:165;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;28050:200;;;;;;28043:207;;27921:337;;;;;:::o;30006:91::-;30088:1;30070:7;:14;;;:19;;;;;;;:::i;:::-;;;;-1:-1:-1;;;30006:91:0:o;36746:195::-;36849:12;36881:52;36903:6;36911:4;36917:1;36920:12;36881:21;:52::i;:::-;36874:59;36746:195;-1:-1:-1;;;;36746:195:0:o;37798:530::-;37925:12;37983:5;37958:21;:30;;37950:81;;;;-1:-1:-1;;;37950:81:0;;;;;;;:::i;:::-;38050:18;38061:6;38050:10;:18::i;:::-;38042:60;;;;-1:-1:-1;;;38042:60:0;;;;;;;:::i;:::-;38176:12;38190:23;38217:6;-1:-1:-1;;;;;38217:11:0;38237:5;38245:4;38217:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38175:75;;;;38268:52;38286:7;38295:10;38307:12;38268:17;:52::i;:::-;38261:59;37798:530;-1:-1:-1;;;;;;;37798:530:0:o;33828:422::-;34195:20;34234:8;;;33828:422::o;40338:742::-;40453:12;40482:7;40478:595;;;-1:-1:-1;40513:10:0;40506:17;;40478:595;40627:17;;:21;40623:439;;40890:10;40884:17;40951:15;40938:10;40934:2;40930:19;40923:44;40838:148;41033:12;41026:20;;-1:-1:-1;;;41026:20:0;;;;;;;;:::i;14:158:1:-;82:20;;142:4;131:16;;121:27;;111:2;;162:1;159;152:12;177:259;;289:2;277:9;268:7;264:23;260:32;257:2;;;310:6;302;295:22;257:2;354:9;341:23;373:33;400:5;373:33;:::i;441:402::-;;;570:2;558:9;549:7;545:23;541:32;538:2;;;591:6;583;576:22;538:2;635:9;622:23;654:33;681:5;654:33;:::i;:::-;706:5;-1:-1:-1;763:2:1;748:18;;735:32;776:35;735:32;776:35;:::i;:::-;830:7;820:17;;;528:315;;;;;:::o;848:470::-;;;;994:2;982:9;973:7;969:23;965:32;962:2;;;1015:6;1007;1000:22;962:2;1059:9;1046:23;1078:33;1105:5;1078:33;:::i;:::-;1130:5;-1:-1:-1;1187:2:1;1172:18;;1159:32;1200:35;1159:32;1200:35;:::i;:::-;952:366;;1254:7;;-1:-1:-1;;;1308:2:1;1293:18;;;;1280:32;;952:366::o;1323:750::-;;;;;;;;1535:3;1523:9;1514:7;1510:23;1506:33;1503:2;;;1557:6;1549;1542:22;1503:2;1601:9;1588:23;1620:33;1647:5;1620:33;:::i;:::-;1672:5;-1:-1:-1;1729:2:1;1714:18;;1701:32;1742:35;1701:32;1742:35;:::i;:::-;1796:7;-1:-1:-1;1850:2:1;1835:18;;1822:32;;-1:-1:-1;1901:2:1;1886:18;;1873:32;;-1:-1:-1;1924:39:1;1958:3;1943:19;;1924:39;:::i;:::-;1914:49;;2010:3;1999:9;1995:19;1982:33;1972:43;;2062:3;2051:9;2047:19;2034:33;2024:43;;1493:580;;;;;;;;;;:::o;2078:327::-;;;2207:2;2195:9;2186:7;2182:23;2178:32;2175:2;;;2228:6;2220;2213:22;2175:2;2272:9;2259:23;2291:33;2318:5;2291:33;:::i;:::-;2343:5;2395:2;2380:18;;;;2367:32;;-1:-1:-1;;;2165:240:1:o;2410:297::-;;2530:2;2518:9;2509:7;2505:23;2501:32;2498:2;;;2551:6;2543;2536:22;2498:2;2588:9;2582:16;2641:5;2634:13;2627:21;2620:5;2617:32;2607:2;;2668:6;2660;2653:22;2989:190;;3101:2;3089:9;3080:7;3076:23;3072:32;3069:2;;;3122:6;3114;3107:22;3069:2;-1:-1:-1;3150:23:1;;3059:120;-1:-1:-1;3059:120:1:o;3184:194::-;;3307:2;3295:9;3286:7;3282:23;3278:32;3275:2;;;3328:6;3320;3313:22;3275:2;-1:-1:-1;3356:16:1;;3265:113;-1:-1:-1;3265:113:1:o;3383:415::-;;;3528:9;3519:7;3515:23;3558:3;3554:2;3550:12;3547:2;;;3580:6;3572;3565:22;3547:2;3621:9;3608:23;3598:33;;3724:3;-1:-1:-1;;3651:2:1;3647:75;3643:85;3640:2;;;3746:6;3738;3731:22;3640:2;;3789;3778:9;3774:18;3764:28;;3495:303;;;;;:::o;3803:194::-;;3913:2;3901:9;3892:7;3888:23;3884:32;3881:2;;;3934:6;3926;3919:22;3881:2;3962:29;3981:9;3962:29;:::i;4002:274::-;;4169:6;4163:13;4185:53;4231:6;4226:3;4219:4;4211:6;4207:17;4185:53;:::i;:::-;4254:16;;;;;4139:137;-1:-1:-1;;4139:137:1:o;4281:444::-;4551:66;4539:79;;4643:1;4634:11;;4627:27;;;;4679:2;4670:12;;4663:28;4716:2;4707:12;;4529:196::o;4730:226::-;-1:-1:-1;;;;;4894:55:1;;;;4876:74;;4864:2;4849:18;;4831:125::o;4961:398::-;-1:-1:-1;;;;;5242:15:1;;;5224:34;;5294:15;;;;5289:2;5274:18;;5267:43;5341:2;5326:18;;5319:34;;;;5151:2;5136:18;;5118:241::o;5364:693::-;-1:-1:-1;;;;;5754:15:1;;;5736:34;;5806:15;;;;5801:2;5786:18;;5779:43;5853:2;5838:18;;5831:34;;;;5896:2;5881:18;;5874:34;;;;5957:4;5945:17;5939:3;5924:19;;5917:46;5994:3;5979:19;;5972:35;6038:3;6023:19;;6016:35;;;;5662:3;5647:19;;5629:428::o;6062:297::-;-1:-1:-1;;;;;6254:55:1;;;;6236:74;;6341:2;6326:18;;6319:34;6224:2;6209:18;;6191:168::o;6364:368::-;-1:-1:-1;;;;;6584:55:1;;;;6566:74;;6671:2;6656:18;;6649:34;;;;6714:2;6699:18;;6692:34;6554:2;6539:18;;6521:211::o;6737:187::-;6902:14;;6895:22;6877:41;;6865:2;6850:18;;6832:92::o;6929:177::-;7075:25;;;7063:2;7048:18;;7030:76::o;7111:614::-;7398:25;;;-1:-1:-1;;;;;7520:15:1;;;7515:2;7500:18;;7493:43;7572:15;;;;7567:2;7552:18;;7545:43;7619:2;7604:18;;7597:34;7662:3;7647:19;;7640:35;;;;7706:3;7691:19;;7684:35;7385:3;7370:19;;7352:373::o;7730:512::-;7989:25;;;8045:2;8030:18;;8023:34;;;;8088:2;8073:18;;8066:34;;;;8131:2;8116:18;;8109:34;-1:-1:-1;;;;;8180:55:1;8174:3;8159:19;;8152:84;7976:3;7961:19;;7943:299::o;8247:398::-;8474:25;;;8547:4;8535:17;;;;8530:2;8515:18;;8508:45;8584:2;8569:18;;8562:34;8627:2;8612:18;;8605:34;8461:3;8446:19;;8428:217::o;8894:442::-;;9043:2;9032:9;9025:21;9075:6;9069:13;9118:6;9113:2;9102:9;9098:18;9091:34;9134:66;9193:6;9188:2;9177:9;9173:18;9168:2;9160:6;9156:15;9134:66;:::i;:::-;9252:2;9240:15;-1:-1:-1;;9236:88:1;9221:104;;;;9327:2;9217:113;;9015:321;-1:-1:-1;;9015:321:1:o;9341:348::-;9543:2;9525:21;;;9582:2;9562:18;;;9555:30;9621:26;9616:2;9601:18;;9594:54;9680:2;9665:18;;9515:174::o;9694:399::-;9896:2;9878:21;;;9935:2;9915:18;;;9908:30;9974:34;9969:2;9954:18;;9947:62;10045:5;10040:2;10025:18;;10018:33;10083:3;10068:19;;9868:225::o;10098:354::-;10300:2;10282:21;;;10339:2;10319:18;;;10312:30;10378:32;10373:2;10358:18;;10351:60;10443:2;10428:18;;10272:180::o;10457:398::-;10659:2;10641:21;;;10698:2;10678:18;;;10671:30;10737:34;10732:2;10717:18;;10710:62;10808:4;10803:2;10788:18;;10781:32;10845:3;10830:19;;10631:224::o;10860:402::-;11062:2;11044:21;;;11101:2;11081:18;;;11074:30;11140:34;11135:2;11120:18;;11113:62;11211:8;11206:2;11191:18;;11184:36;11252:3;11237:19;;11034:228::o;11267:398::-;11469:2;11451:21;;;11508:2;11488:18;;;11481:30;11547:34;11542:2;11527:18;;11520:62;11618:4;11613:2;11598:18;;11591:32;11655:3;11640:19;;11441:224::o;11670:353::-;11872:2;11854:21;;;11911:2;11891:18;;;11884:30;11950:31;11945:2;11930:18;;11923:59;12014:2;11999:18;;11844:179::o;12028:402::-;12230:2;12212:21;;;12269:2;12249:18;;;12242:30;12308:34;12303:2;12288:18;;12281:62;12379:8;12374:2;12359:18;;12352:36;12420:3;12405:19;;12202:228::o;12435:398::-;12637:2;12619:21;;;12676:2;12656:18;;;12649:30;12715:34;12710:2;12695:18;;12688:62;12786:4;12781:2;12766:18;;12759:32;12823:3;12808:19;;12609:224::o;12838:402::-;13040:2;13022:21;;;13079:2;13059:18;;;13052:30;13118:34;13113:2;13098:18;;13091:62;13189:8;13184:2;13169:18;;13162:36;13230:3;13215:19;;13012:228::o;13245:398::-;13447:2;13429:21;;;13486:2;13466:18;;;13459:30;13525:34;13520:2;13505:18;;13498:62;13596:4;13591:2;13576:18;;13569:32;13633:3;13618:19;;13419:224::o;13648:354::-;13850:2;13832:21;;;13889:2;13869:18;;;13862:30;13928:32;13923:2;13908:18;;13901:60;13993:2;13978:18;;13822:180::o;14007:404::-;14209:2;14191:21;;;14248:2;14228:18;;;14221:30;14287:34;14282:2;14267:18;;14260:62;14358:10;14353:2;14338:18;;14331:38;14401:3;14386:19;;14181:230::o;14416:356::-;14618:2;14600:21;;;14637:18;;;14630:30;14696:34;14691:2;14676:18;;14669:62;14763:2;14748:18;;14590:182::o;14777:397::-;14979:2;14961:21;;;15018:2;14998:18;;;14991:30;15057:34;15052:2;15037:18;;15030:62;15128:3;15123:2;15108:18;;15101:31;15164:3;15149:19;;14951:223::o;15179:352::-;15381:2;15363:21;;;15420:2;15400:18;;;15393:30;15459;15454:2;15439:18;;15432:58;15522:2;15507:18;;15353:178::o;15536:401::-;15738:2;15720:21;;;15777:2;15757:18;;;15750:30;15816:34;15811:2;15796:18;;15789:62;15887:7;15882:2;15867:18;;15860:35;15927:3;15912:19;;15710:227::o;15942:400::-;16144:2;16126:21;;;16183:2;16163:18;;;16156:30;16222:34;16217:2;16202:18;;16195:62;16293:6;16288:2;16273:18;;16266:34;16332:3;16317:19;;16116:226::o;16347:353::-;16549:2;16531:21;;;16588:2;16568:18;;;16561:30;16627:31;16622:2;16607:18;;16600:59;16691:2;16676:18;;16521:179::o;16705:406::-;16907:2;16889:21;;;16946:2;16926:18;;;16919:30;16985:34;16980:2;16965:18;;16958:62;17056:12;17051:2;17036:18;;17029:40;17101:3;17086:19;;16879:232::o;17116:401::-;17318:2;17300:21;;;17357:2;17337:18;;;17330:30;17396:34;17391:2;17376:18;;17369:62;17467:7;17462:2;17447:18;;17440:35;17507:3;17492:19;;17290:227::o;17522:355::-;17724:2;17706:21;;;17763:2;17743:18;;;17736:30;17802:33;17797:2;17782:18;;17775:61;17868:2;17853:18;;17696:181::o;18064:184::-;18236:4;18224:17;;;;18206:36;;18194:2;18179:18;;18161:87::o;18253:128::-;;18324:1;18320:6;18317:1;18314:13;18311:2;;;18330:18;;:::i;:::-;-1:-1:-1;18366:9:1;;18301:80::o;18386:274::-;;18452:1;18442:2;;-1:-1:-1;;;18484:1:1;18477:88;18588:4;18585:1;18578:15;18616:4;18613:1;18606:15;18442:2;-1:-1:-1;18645:9:1;;18432:228::o;18665:::-;;18831:1;18763:66;18759:74;18756:1;18753:81;18748:1;18741:9;18734:17;18730:105;18727:2;;;18838:18;;:::i;:::-;-1:-1:-1;18878:9:1;;18717:176::o;18898:125::-;;18966:1;18963;18960:8;18957:2;;;18971:18;;:::i;:::-;-1:-1:-1;19008:9:1;;18947:76::o;19028:258::-;19100:1;19110:113;19124:6;19121:1;19118:13;19110:113;;;19200:11;;;19194:18;19181:11;;;19174:39;19146:2;19139:10;19110:113;;;19241:6;19238:1;19235:13;19232:2;;;-1:-1:-1;;19276:1:1;19258:16;;19251:27;19081:205::o;19291:437::-;19376:1;19366:12;;19423:1;19413:12;;;19434:2;;19488:4;19480:6;19476:17;19466:27;;19434:2;19541;19533:6;19530:14;19510:18;19507:38;19504:2;;;-1:-1:-1;;;19575:1:1;19568:88;19679:4;19676:1;19669:15;19707:4;19704:1;19697:15;19733:184;-1:-1:-1;;;19782:1:1;19775:88;19882:4;19879:1;19872:15;19906:4;19903:1;19896:15;19922:156;-1:-1:-1;;;;;20003:5:1;19999:54;19992:5;19989:65;19979:2;;20068:1;20065;20058:12;19979:2;19969:109;:::o

ipfs://ac91fa6596c095cffed577760f1c0d32f331b1dface0e96dc79e6258b11f4e6e