Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

interface IERC20    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom( interface IERC20Metadata is IERC20    - function name()    - function symbol()    - function decimals()    - function _msgSender()    - function _msgData()  contract ERC20 is Context, IERC20, ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address to, uint256 ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(    - function _mint(address account, uint2 ...    - function _burn(address account, uint2 ...    - function _approve(    - function _spendAllowance(    - function _beforeTokenTransfer(    - function _afterTokenTransfer( interface IERC20Permit    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR() library Math    - function max(uint256 a, uint256 b)    - function min(uint256 a, uint256 b)    - function average(uint256 a, uint256 b ...    - function ceilDiv(uint256 a, uint256 b ...    - function mulDiv(    - function mulDiv(    - function sqrt(uint256 a)    - function sqrt(uint256 a, Rounding rou ...    - function log2(uint256 value)    - function log2(uint256 value, Rounding ...    - function log10(uint256 value)    - function log10(uint256 value, Roundin ...    - function log256(uint256 value)    - function log256(uint256 value, Roundi ... library Strings    - function toString(uint256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function toHexString(address addr) library ECDSA    - function _throwError(RecoverError err ...    - function tryRecover(bytes32 hash, byt ...    - function recover(bytes32 hash, bytes ...    - function tryRecover(    - function recover(    - function tryRecover(    - function recover(    - function toEthSignedMessageHash(bytes ...    - function toEthSignedMessageHash(bytes ...    - function toTypedDataHash(bytes32 doma ...    - function _domainSeparatorV4()    - function _buildDomainSeparator(    - function _hashTypedDataV4(bytes32 str ... library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ...    - function permit(    - function nonces(address owner)    - function DOMAIN_SEPARATOR()    - function _useNonce(address owner)    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ...  contract URANUS is ERC20, Ownable, ... *    - function sendToPresale()    - function airdropPresale(uint256 airdr ...    - function devMint(address _address)    - function setAllowContributions(bool _ ...    - function setAllowRefund(bool _value)    - function getRefund()    - function mintLPAmount()    - function withdrawBalance(address paya ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-05-31
*/

// In the grim darkness of the crypto-verse, where coins rise and fall, 
// one token dared to venture where none had ever gone before... Uranus. 
// The mission was risky, but we persevered. Born from the cosmic code dust of Ethereum, 
// $URANUS sprang forth like an unexpected gas emission in a quiet elevator, 
// surprising, unwelcome, yet undeniably present. 
// Touted as the galaxy's finest Shitcoin, its audacity is only surpassed by its name. 
// A Shitcoin? Certainly. A meme? Absolutely. But above all, $URANUS stands 
// as a testament to our shared sense of humor in the face of the abyss. 
// Never before has the financial world seen such a spectacle, 
// never has such a token been forged... until now. 
// Watch URANUS... Shit is about to get wild!

// Twitter: https://twitter.com/uranus_erc
// TG: https://t.me/+kgt8eGB5QjA1OTE0

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}


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

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

pragma solidity ^0.8.0;

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

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

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


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

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

pragma solidity ^0.8.0;

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

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


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

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;



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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, 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}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, 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}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, 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) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, 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) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * 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:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, 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;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _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;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _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 Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

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

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


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

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

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

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

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


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

// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

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

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

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

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

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}


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

// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}


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

// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

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

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

    /**
     * @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) {
        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.
            /// @solidity memory-safe-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 {
            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 = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 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 the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

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

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

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

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


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

// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/EIP712.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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


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

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

pragma solidity ^0.8.0;

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

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

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

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

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


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

// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/extensions/draft-ERC20Permit.sol)

pragma solidity ^0.8.0;





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

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

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private constant _PERMIT_TYPEHASH =
        keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    /**
     * @dev In previous versions `_PERMIT_TYPEHASH` was declared as `immutable`.
     * However, to ensure consistency with the upgradeable transpiler, we will continue
     * to reserve a slot.
     * @custom:oz-renamed-from _PERMIT_TYPEHASH
     */
    // solhint-disable-next-line var-name-mixedcase
    bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;

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

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

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

        bytes32 hash = _hashTypedDataV4(structHash);

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

        _approve(owner, spender, value);
    }

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

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

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


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

// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

pragma solidity ^0.8.9;
contract URANUS is ERC20, Ownable, ERC20Permit {
    constructor() ERC20("Ur Anus", "URANUS") ERC20Permit("URANUS"){}

    bool public allowContributions = false;

    bool public allowRefund = false;

    /// bool to only mint LP once
    bool public lpMinted = false;

    uint256 public constant MIN_CONTRIBUTION = .01 ether;

    uint256 public constant MAX_CONTRIBUTION = 0.1 ether;

    uint256 public constant HARD_CAP = 10 ether;

    /// total number of tokens available
    uint256 public constant MAX_SUPPLY = 6900000000000 * 10 ** 18;

    /// 45% of tokens reserved for presale
    uint256 public constant PRESALE_SUPPLY = 3105000000000 * 10 ** 18;

    /// 45% of tokens reserved for LP
    uint256 public constant LP_SUPPLY = 3105000000000 * 10 ** 18;

    uint256 public TOTAL_CONTRIBUTED;

    uint256 public NUMBER_OF_CONTRIBUTOORS;

    uint256 public AIRDROP_INDEX = 1;

    /// keep track of each contributoors address and contribution amount
    struct Contribution {
        address addr;
        uint256 amount;
    }

    /// mapping of contributions and contributoors
    mapping (uint256 => Contribution) public contribution;
    mapping (address => uint256) public contributoor;

    /// contribute to presale
    function sendToPresale() public payable {

        /// initialize a contribution index
        uint256 contributionIndex;

        /// check if contributions are allowed
        require (allowContributions, "Contributions not allowed");

        /// check min and max contribution
        require(msg.value >= MIN_CONTRIBUTION, "Contribution too low");
        require (msg.value <= MAX_CONTRIBUTION, "Contribution exceeds per wallet limit");

        /// enforce hard cap
        require (msg.value + TOTAL_CONTRIBUTED <= HARD_CAP, "Contribution exceeds hard cap"); 

        if (contributoor[msg.sender] != 0){
            /// avoid duplicates
            contributionIndex = contributoor[msg.sender];
        } else {
            /// keep track of each new contributor with a unique index
            contributionIndex = NUMBER_OF_CONTRIBUTOORS + 1;
            NUMBER_OF_CONTRIBUTOORS++;
            contributoor[msg.sender] = contributionIndex;
            contribution[contributionIndex].addr = msg.sender;
        }

        /// update total amt contributed
        TOTAL_CONTRIBUTED = TOTAL_CONTRIBUTED + msg.value;

        /// keep track of the address' contributions so far
        contribution[contributionIndex].amount += msg.value;
    }

    function airdropPresale(uint256 airdropamount) external onlyOwner {

        require (!allowContributions, "Presale is still on");

        /// determine the price per token
        uint256 pricePerToken = (HARD_CAP * 20 ** 18) /PRESALE_SUPPLY;

        //check to make sure you are not going over the number of contributoors
        uint256 minttoIndex = AIRDROP_INDEX + airdropamount;
        require(minttoIndex - 1 <= NUMBER_OF_CONTRIBUTOORS, "Out of airdrop range");

        /// loop over each contribution and distribute tokens
        for (uint256 i = AIRDROP_INDEX; i < minttoIndex; i++) {

            uint256 contributionAmount = contribution[i].amount * 20 ** 18;

            /// calculate the percentage of the pool based on the address' contribution
            uint256 numberOfTokensToMint = contributionAmount/pricePerToken;

            /// mint the tokens to the address
            _mint(contribution[i].addr, numberOfTokensToMint);
            }

        // update starting index for next airdrop
        AIRDROP_INDEX = minttoIndex;
    }

    /// dev mint the remainder of the pool to round out the supply
    function devMint(address _address) external onlyOwner {

        /// calculate the remaining supply
        uint256 numberToMint = MAX_SUPPLY - totalSupply();

        //make sure contributions are set to false
        require (!allowContributions, "presale is still on");

        /// mint the remaining supply
        _mint(_address, numberToMint);
    }

     /// toggle contributions
    function setAllowContributions(bool _value) external onlyOwner {
        allowContributions = _value;
    }

    /// toggle refunds
    function setAllowRefund(bool _value) external onlyOwner {
        allowRefund = _value;
    }

    /// allows users to get refunds of their contribution
    function getRefund() public {

        require (allowRefund, "refund is not allowed");
        require (!allowContributions, "presale is still on");
        require(contributoor[msg.sender] != 0, "user did not contribute");

        uint256 contributionIndex = contributoor[msg.sender];
        uint256 amountToRefund = contribution[contributionIndex].amount;

        require(amountToRefund > 0, "nothing to refund");
        contribution[contributionIndex].amount = 0;

        address payable refundAddress = payable(contribution[contributionIndex].addr);
        refundAddress.transfer(amountToRefund);
    }

    /// mint the LP tokens
    function mintLPAmount() external onlyOwner {
        require(!lpMinted, "LP Minted");
        lpMinted = true;
        _mint(msg.sender, LP_SUPPLY);
    }

    function withdrawBalance(address payable _address) external onlyOwner {
        (bool success, ) = _address.call{value: address(this).balance}("");
        require(success, "Withdraw failed");
    }
}

• 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":"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"},{"inputs":[],"name":"AIRDROP_INDEX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HARD_CAP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LP_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_CONTRIBUTION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MIN_CONTRIBUTION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NUMBER_OF_CONTRIBUTOORS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRESALE_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_CONTRIBUTED","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"airdropamount","type":"uint256"}],"name":"airdropPresale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"allowContributions","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allowRefund","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"contribution","outputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"contributoor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"devMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRefund","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lpMinted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintLPAmount","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":[],"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":"sendToPresale","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bool","name":"_value","type":"bool"}],"name":"setAllowContributions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_value","type":"bool"}],"name":"setAllowRefund","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":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","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":"address payable","name":"_address","type":"address"}],"name":"withdrawBalance","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

57229:5475:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58067:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7568:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9919:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8688:108;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59803:1085;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;10700:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8530:93;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57730:61;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54033:115;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61510:95;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;11404:238;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57636:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58425:48;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57514:52;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60964:366;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58513:1282;;;:::i;:::-;;58026:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57957:60;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57355:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8859:127;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56387:103;;;;;;;;;;;;;:::i;:::-;;57844:65;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62500:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53775:128;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58114:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61369:109;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55739:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57575:52;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7787:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12145:436;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57477:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9192:193;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61672:626;;;;;;;;;;;;;:::i;:::-;;62334:158;;;;;;;;;;;;;:::i;:::-;;53064:645;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;9448:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58365:53;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;56645:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57402:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58067:38;;;;:::o;7568:100::-;7622:13;7655:5;7648:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7568:100;:::o;9919:201::-;10002:4;10019:13;10035:12;:10;:12::i;:::-;10019:28;;10058:32;10067:5;10074:7;10083:6;10058:8;:32::i;:::-;10108:4;10101:11;;;9919:201;;;;:::o;8688:108::-;8749:7;8776:12;;8769:19;;8688:108;:::o;59803:1085::-;55625:13;:11;:13::i;:::-;59892:18:::1;;;;;;;;;;;59891:19;59882:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;59990:21;57885:24;60026:8;57671;60015:19;;;;:::i;:::-;60014:37;;;;:::i;:::-;59990:61;;60145:19;60183:13;60167;;:29;;;;:::i;:::-;60145:51;;60234:23;;60229:1;60215:11;:15;;;;:::i;:::-;:42;;60207:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;60363:9;60375:13;;60363:25;;60358:432;60394:11;60390:1;:15;60358:432;;;60429:26;60483:8;60458:12;:15;60471:1;60458:15;;;;;;;;;;;:22;;;:33;;;;:::i;:::-;60429:62;;60597:28;60647:13;60628:18;:32;;;;:::i;:::-;60597:63;;60725:49;60731:12;:15;60744:1;60731:15;;;;;;;;;;;:20;;;;;;;;;;;;60753;60725:5;:49::i;:::-;60412:378;;60407:3;;;;;:::i;:::-;;;;60358:432;;;;60869:11;60853:13;:27;;;;59869:1019;;59803:1085:::0;:::o;10700:295::-;10831:4;10848:15;10866:12;:10;:12::i;:::-;10848:30;;10889:38;10905:4;10911:7;10920:6;10889:15;:38::i;:::-;10938:27;10948:4;10954:2;10958:6;10938:9;:27::i;:::-;10983:4;10976:11;;;10700:295;;;;;:::o;8530:93::-;8588:5;8613:2;8606:9;;8530:93;:::o;57730:61::-;57767:24;57730:61;:::o;54033:115::-;54093:7;54120:20;:18;:20::i;:::-;54113:27;;54033:115;:::o;61510:95::-;55625:13;:11;:13::i;:::-;61591:6:::1;61577:11;;:20;;;;;;;;;;;;;;;;;;61510:95:::0;:::o;11404:238::-;11492:4;11509:13;11525:12;:10;:12::i;:::-;11509:28;;11548:64;11557:5;11564:7;11601:10;11573:25;11583:5;11590:7;11573:9;:25::i;:::-;:38;;;;:::i;:::-;11548:8;:64::i;:::-;11630:4;11623:11;;;11404:238;;;;:::o;57636:43::-;57671:8;57636:43;:::o;58425:48::-;;;;;;;;;;;;;;;;;:::o;57514:52::-;57557:9;57514:52;:::o;60964:366::-;55625:13;:11;:13::i;:::-;61075:20:::1;61111:13;:11;:13::i;:::-;57767:24;61098:26;;;;:::i;:::-;61075:49;;61199:18;;;;;;;;;;;61198:19;61189:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;61293:29;61299:8;61309:12;61293:5;:29::i;:::-;61018:312;60964:366:::0;:::o;58513:1282::-;58611:25;58706:18;;;;;;;;;;;58697:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;57557:9;58819;:29;;58811:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;57618:9;58893;:29;;58884:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;57671:8;59028:17;;59016:9;:29;;;;:::i;:::-;:41;;59007:84;;;;;;;;;;;;:::i;:::-;;;;;;;;;59137:1;59109:12;:24;59122:10;59109:24;;;;;;;;;;;;;;;;:29;59105:454;;59208:12;:24;59221:10;59208:24;;;;;;;;;;;;;;;;59188:44;;59105:454;;;59383:1;59357:23;;:27;;;;:::i;:::-;59337:47;;59399:23;;:25;;;;;;;;;:::i;:::-;;;;;;59466:17;59439:12;:24;59452:10;59439:24;;;;;;;;;;;;;;;:44;;;;59537:10;59498:12;:31;59511:17;59498:31;;;;;;;;;;;:36;;;:49;;;;;;;;;;;;;;;;;;59105:454;59653:9;59633:17;;:29;;;;:::i;:::-;59613:17;:49;;;;59778:9;59736:12;:31;59749:17;59736:31;;;;;;;;;;;:38;;;:51;;;;;;;:::i;:::-;;;;;;;;58553:1242;58513:1282::o;58026:32::-;;;;:::o;57957:60::-;57993:24;57957:60;:::o;57355:38::-;;;;;;;;;;;;;:::o;8859:127::-;8933:7;8960:9;:18;8970:7;8960:18;;;;;;;;;;;;;;;;8953:25;;8859:127;;;:::o;56387:103::-;55625:13;:11;:13::i;:::-;56452:30:::1;56479:1;56452:18;:30::i;:::-;56387:103::o:0;57844:65::-;57885:24;57844:65;:::o;62500:201::-;55625:13;:11;:13::i;:::-;62582:12:::1;62600:8;:13;;62621:21;62600:47;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62581:66;;;62666:7;62658:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;62570:131;62500:201:::0;:::o;53775:128::-;53844:7;53871:24;:7;:14;53879:5;53871:14;;;;;;;;;;;;;;;:22;:24::i;:::-;53864:31;;53775:128;;;:::o;58114:32::-;;;;:::o;61369:109::-;55625:13;:11;:13::i;:::-;61464:6:::1;61443:18;;:27;;;;;;;;;;;;;;;;;;61369:109:::0;:::o;55739:87::-;55785:7;55812:6;;;;;;;;;;;55805:13;;55739:87;:::o;57575:52::-;57618:9;57575:52;:::o;7787:104::-;7843:13;7876:7;7869:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7787:104;:::o;12145:436::-;12238:4;12255:13;12271:12;:10;:12::i;:::-;12255:28;;12294:24;12321:25;12331:5;12338:7;12321:9;:25::i;:::-;12294:52;;12385:15;12365:16;:35;;12357:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;12478:60;12487:5;12494:7;12522:15;12503:16;:34;12478:8;:60::i;:::-;12569:4;12562:11;;;;12145:436;;;;:::o;57477:28::-;;;;;;;;;;;;;:::o;9192:193::-;9271:4;9288:13;9304:12;:10;:12::i;:::-;9288:28;;9327;9337:5;9344:2;9348:6;9327:9;:28::i;:::-;9373:4;9366:11;;;9192:193;;;;:::o;61672:626::-;61722:11;;;;;;;;;;;61713:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;61780:18;;;;;;;;;;;61779:19;61770:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;61869:1;61841:12;:24;61854:10;61841:24;;;;;;;;;;;;;;;;:29;61833:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;61911:25;61939:12;:24;61952:10;61939:24;;;;;;;;;;;;;;;;61911:52;;61974:22;61999:12;:31;62012:17;61999:31;;;;;;;;;;;:38;;;61974:63;;62075:1;62058:14;:18;62050:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;62150:1;62109:12;:31;62122:17;62109:31;;;;;;;;;;;:38;;:42;;;;62164:29;62204:12;:31;62217:17;62204:31;;;;;;;;;;;:36;;;;;;;;;;;;62164:77;;62252:13;:22;;:38;62275:14;62252:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61700:598;;;61672:626::o;62334:158::-;55625:13;:11;:13::i;:::-;62397:8:::1;;;;;;;;;;;62396:9;62388:31;;;;;;;;;;;;:::i;:::-;;;;;;;;;62441:4;62430:8;;:15;;;;;;;;;;;;;;;;;;62456:28;62462:10;57993:24;62456:5;:28::i;:::-;62334:158::o:0;53064:645::-;53308:8;53289:15;:27;;53281:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;53363:18;52239:95;53423:5;53430:7;53439:5;53446:16;53456:5;53446:9;:16::i;:::-;53464:8;53394:79;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;53384:90;;;;;;53363:111;;53487:12;53502:28;53519:10;53502:16;:28::i;:::-;53487:43;;53543:14;53560:28;53574:4;53580:1;53583;53586;53560:13;:28::i;:::-;53543:45;;53617:5;53607:15;;:6;:15;;;53599:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;53670:31;53679:5;53686:7;53695:5;53670:8;:31::i;:::-;53270:439;;;53064:645;;;;;;;:::o;9448:151::-;9537:7;9564:11;:18;9576:5;9564:18;;;;;;;;;;;;;;;:27;9583:7;9564:27;;;;;;;;;;;;;;;;9557:34;;9448:151;;;;:::o;58365:53::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;56645:201::-;55625:13;:11;:13::i;:::-;56754:1:::1;56734:22;;:8;:22;;::::0;56726:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;56810:28;56829:8;56810:18;:28::i;:::-;56645:201:::0;:::o;57402:31::-;;;;;;;;;;;;;:::o;5206:98::-;5259:7;5286:10;5279:17;;5206:98;:::o;16172:380::-;16325:1;16308:19;;:5;:19;;;16300:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;16406:1;16387:21;;:7;:21;;;16379:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;16490:6;16460:11;:18;16472:5;16460:18;;;;;;;;;;;;;;;:27;16479:7;16460:27;;;;;;;;;;;;;;;:36;;;;16528:7;16512:32;;16521:5;16512:32;;;16537:6;16512:32;;;;;;:::i;:::-;;;;;;;;16172:380;;;:::o;55904:132::-;55979:12;:10;:12::i;:::-;55968:23;;:7;:5;:7::i;:::-;:23;;;55960:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;55904:132::o;14178:548::-;14281:1;14262:21;;:7;:21;;;14254:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;14332:49;14361:1;14365:7;14374:6;14332:20;:49::i;:::-;14410:6;14394:12;;:22;;;;;;;:::i;:::-;;;;;;;;14587:6;14565:9;:18;14575:7;14565:18;;;;;;;;;;;;;;;;:28;;;;;;;;;;;14641:7;14620:37;;14637:1;14620:37;;;14650:6;14620:37;;;;;;:::i;:::-;;;;;;;;14670:48;14698:1;14702:7;14711:6;14670:19;:48::i;:::-;14178:548;;:::o;16843:453::-;16978:24;17005:25;17015:5;17022:7;17005:9;:25::i;:::-;16978:52;;17065:17;17045:16;:37;17041:248;;17127:6;17107:16;:26;;17099:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;17211:51;17220:5;17227:7;17255:6;17236:16;:25;17211:8;:51::i;:::-;17041:248;16967:329;16843:453;;;:::o;13051:840::-;13198:1;13182:18;;:4;:18;;;13174:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;13275:1;13261:16;;:2;:16;;;13253:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;13330:38;13351:4;13357:2;13361:6;13330:20;:38::i;:::-;13381:19;13403:9;:15;13413:4;13403:15;;;;;;;;;;;;;;;;13381:37;;13452:6;13437:11;:21;;13429:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;13569:6;13555:11;:20;13537:9;:15;13547:4;13537:15;;;;;;;;;;;;;;;:38;;;;13772:6;13755:9;:13;13765:2;13755:13;;;;;;;;;;;;;;;;:23;;;;;;;;;;;13822:2;13807:26;;13816:4;13807:26;;;13826:6;13807:26;;;;;;:::i;:::-;;;;;;;;13846:37;13866:4;13872:2;13876:6;13846:19;:37::i;:::-;13163:728;13051:840;;;:::o;48338:314::-;48391:7;48432:12;48415:29;;48423:4;48415:29;;;:66;;;;;48465:16;48448:13;:33;48415:66;48411:234;;;48505:24;48498:31;;;;48411:234;48569:64;48591:10;48603:12;48617:15;48569:21;:64::i;:::-;48562:71;;48338:314;;:::o;57006:191::-;57080:16;57099:6;;;;;;;;;;;57080:25;;57125:8;57116:6;;:17;;;;;;;;;;;;;;;;;;57180:8;57149:40;;57170:8;57149:40;;;;;;;;;;;;57069:128;57006:191;:::o;50617:114::-;50682:7;50709;:14;;;50702:21;;50617:114;;;:::o;54286:207::-;54346:15;54374:30;54407:7;:14;54415:5;54407:14;;;;;;;;;;;;;;;54374:47;;54442:15;:5;:13;:15::i;:::-;54432:25;;54468:17;:5;:15;:17::i;:::-;54363:130;54286:207;;;:::o;49565:167::-;49642:7;49669:55;49691:20;:18;:20::i;:::-;49713:10;49669:21;:55::i;:::-;49662:62;;49565:167;;;:::o;43207:279::-;43335:7;43356:17;43375:18;43397:25;43408:4;43414:1;43417;43420;43397:10;:25::i;:::-;43355:67;;;;43433:18;43445:5;43433:11;:18::i;:::-;43469:9;43462:16;;;;43207:279;;;;;;:::o;17896:125::-;;;;:::o;18625:124::-;;;;:::o;48660:263::-;48804:7;48852:8;48862;48872:11;48885:13;48908:4;48841:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;48831:84;;;;;;48824:91;;48660:263;;;;;:::o;50739:127::-;50846:1;50828:7;:14;;;:19;;;;;;;;;;;50739:127;:::o;44898:196::-;44991:7;45057:15;45074:10;45028:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;45018:68;;;;;;45011:75;;44898:196;;;;:::o;41548:1520::-;41679:7;41688:12;42613:66;42608:1;42600:10;;:79;42596:163;;;42712:1;42716:30;42696:51;;;;;;42596:163;42856:14;42873:24;42883:4;42889:1;42892;42895;42873:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42856:41;;42930:1;42912:20;;:6;:20;;;42908:103;;42965:1;42969:29;42949:50;;;;;;;42908:103;43031:6;43039:20;43023:37;;;;;41548:1520;;;;;;;;:::o;36940:521::-;37018:20;37009:29;;;;;;;;:::i;:::-;;:5;:29;;;;;;;;:::i;:::-;;;37005:449;37055:7;37005:449;37116:29;37107:38;;;;;;;;:::i;:::-;;:5;:38;;;;;;;;:::i;:::-;;;37103:351;;37162:34;;;;;;;;;;:::i;:::-;;;;;;;;37103:351;37227:35;37218:44;;;;;;;;:::i;:::-;;:5;:44;;;;;;;;:::i;:::-;;;37214:240;;37279:41;;;;;;;;;;:::i;:::-;;;;;;;;37214:240;37351:30;37342:39;;;;;;;;:::i;:::-;;:5;:39;;;;;;;;:::i;:::-;;;37338:116;;37398:44;;;;;;;;;;:::i;:::-;;;;;;;;37338:116;36940:521;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:99::-;494:6;528:5;522:12;512:22;;442:99;;;:::o;547:169::-;631:11;665:6;660:3;653:19;705:4;700:3;696:14;681:29;;547:169;;;;:::o;722:246::-;803:1;813:113;827:6;824:1;821:13;813:113;;;912:1;907:3;903:11;897:18;893:1;888:3;884:11;877:39;849:2;846:1;842:10;837:15;;813:113;;;960:1;951:6;946:3;942:16;935:27;784:184;722:246;;;:::o;974:102::-;1015:6;1066:2;1062:7;1057:2;1050:5;1046:14;1042:28;1032:38;;974:102;;;:::o;1082:377::-;1170:3;1198:39;1231:5;1198:39;:::i;:::-;1253:71;1317:6;1312:3;1253:71;:::i;:::-;1246:78;;1333:65;1391:6;1386:3;1379:4;1372:5;1368:16;1333:65;:::i;:::-;1423:29;1445:6;1423:29;:::i;:::-;1418:3;1414:39;1407:46;;1174:285;1082:377;;;;:::o;1465:313::-;1578:4;1616:2;1605:9;1601:18;1593:26;;1665:9;1659:4;1655:20;1651:1;1640:9;1636:17;1629:47;1693:78;1766:4;1757:6;1693:78;:::i;:::-;1685:86;;1465:313;;;;:::o;1865:117::-;1974:1;1971;1964:12;2111:126;2148:7;2188:42;2181:5;2177:54;2166:65;;2111:126;;;:::o;2243:96::-;2280:7;2309:24;2327:5;2309:24;:::i;:::-;2298:35;;2243:96;;;:::o;2345:122::-;2418:24;2436:5;2418:24;:::i;:::-;2411:5;2408:35;2398:63;;2457:1;2454;2447:12;2398:63;2345:122;:::o;2473:139::-;2519:5;2557:6;2544:20;2535:29;;2573:33;2600:5;2573:33;:::i;:::-;2473:139;;;;:::o;2618:122::-;2691:24;2709:5;2691:24;:::i;:::-;2684:5;2681:35;2671:63;;2730:1;2727;2720:12;2671:63;2618:122;:::o;2746:139::-;2792:5;2830:6;2817:20;2808:29;;2846:33;2873:5;2846:33;:::i;:::-;2746:139;;;;:::o;2891:474::-;2959:6;2967;3016:2;3004:9;2995:7;2991:23;2987:32;2984:119;;;3022:79;;:::i;:::-;2984:119;3142:1;3167:53;3212:7;3203:6;3192:9;3188:22;3167:53;:::i;:::-;3157:63;;3113:117;3269:2;3295:53;3340:7;3331:6;3320:9;3316:22;3295:53;:::i;:::-;3285:63;;3240:118;2891:474;;;;;:::o;3371:90::-;3405:7;3448:5;3441:13;3434:21;3423:32;;3371:90;;;:::o;3467:109::-;3548:21;3563:5;3548:21;:::i;:::-;3543:3;3536:34;3467:109;;:::o;3582:210::-;3669:4;3707:2;3696:9;3692:18;3684:26;;3720:65;3782:1;3771:9;3767:17;3758:6;3720:65;:::i;:::-;3582:210;;;;:::o;3798:329::-;3857:6;3906:2;3894:9;3885:7;3881:23;3877:32;3874:119;;;3912:79;;:::i;:::-;3874:119;4032:1;4057:53;4102:7;4093:6;4082:9;4078:22;4057:53;:::i;:::-;4047:63;;4003:117;3798:329;;;;:::o;4133:619::-;4210:6;4218;4226;4275:2;4263:9;4254:7;4250:23;4246:32;4243:119;;;4281:79;;:::i;:::-;4243:119;4401:1;4426:53;4471:7;4462:6;4451:9;4447:22;4426:53;:::i;:::-;4416:63;;4372:117;4528:2;4554:53;4599:7;4590:6;4579:9;4575:22;4554:53;:::i;:::-;4544:63;;4499:118;4656:2;4682:53;4727:7;4718:6;4707:9;4703:22;4682:53;:::i;:::-;4672:63;;4627:118;4133:619;;;;;:::o;4758:86::-;4793:7;4833:4;4826:5;4822:16;4811:27;;4758:86;;;:::o;4850:112::-;4933:22;4949:5;4933:22;:::i;:::-;4928:3;4921:35;4850:112;;:::o;4968:214::-;5057:4;5095:2;5084:9;5080:18;5072:26;;5108:67;5172:1;5161:9;5157:17;5148:6;5108:67;:::i;:::-;4968:214;;;;:::o;5188:77::-;5225:7;5254:5;5243:16;;5188:77;;;:::o;5271:118::-;5358:24;5376:5;5358:24;:::i;:::-;5353:3;5346:37;5271:118;;:::o;5395:222::-;5488:4;5526:2;5515:9;5511:18;5503:26;;5539:71;5607:1;5596:9;5592:17;5583:6;5539:71;:::i;:::-;5395:222;;;;:::o;5623:116::-;5693:21;5708:5;5693:21;:::i;:::-;5686:5;5683:32;5673:60;;5729:1;5726;5719:12;5673:60;5623:116;:::o;5745:133::-;5788:5;5826:6;5813:20;5804:29;;5842:30;5866:5;5842:30;:::i;:::-;5745:133;;;;:::o;5884:323::-;5940:6;5989:2;5977:9;5968:7;5964:23;5960:32;5957:119;;;5995:79;;:::i;:::-;5957:119;6115:1;6140:50;6182:7;6173:6;6162:9;6158:22;6140:50;:::i;:::-;6130:60;;6086:114;5884:323;;;;:::o;6213:329::-;6272:6;6321:2;6309:9;6300:7;6296:23;6292:32;6289:119;;;6327:79;;:::i;:::-;6289:119;6447:1;6472:53;6517:7;6508:6;6497:9;6493:22;6472:53;:::i;:::-;6462:63;;6418:117;6213:329;;;;:::o;6548:104::-;6593:7;6622:24;6640:5;6622:24;:::i;:::-;6611:35;;6548:104;;;:::o;6658:138::-;6739:32;6765:5;6739:32;:::i;:::-;6732:5;6729:43;6719:71;;6786:1;6783;6776:12;6719:71;6658:138;:::o;6802:155::-;6856:5;6894:6;6881:20;6872:29;;6910:41;6945:5;6910:41;:::i;:::-;6802:155;;;;:::o;6963:345::-;7030:6;7079:2;7067:9;7058:7;7054:23;7050:32;7047:119;;;7085:79;;:::i;:::-;7047:119;7205:1;7230:61;7283:7;7274:6;7263:9;7259:22;7230:61;:::i;:::-;7220:71;;7176:125;6963:345;;;;:::o;7314:118::-;7401:24;7419:5;7401:24;:::i;:::-;7396:3;7389:37;7314:118;;:::o;7438:222::-;7531:4;7569:2;7558:9;7554:18;7546:26;;7582:71;7650:1;7639:9;7635:17;7626:6;7582:71;:::i;:::-;7438:222;;;;:::o;7666:118::-;7737:22;7753:5;7737:22;:::i;:::-;7730:5;7727:33;7717:61;;7774:1;7771;7764:12;7717:61;7666:118;:::o;7790:135::-;7834:5;7872:6;7859:20;7850:29;;7888:31;7913:5;7888:31;:::i;:::-;7790:135;;;;:::o;7931:122::-;8004:24;8022:5;8004:24;:::i;:::-;7997:5;7994:35;7984:63;;8043:1;8040;8033:12;7984:63;7931:122;:::o;8059:139::-;8105:5;8143:6;8130:20;8121:29;;8159:33;8186:5;8159:33;:::i;:::-;8059:139;;;;:::o;8204:1199::-;8315:6;8323;8331;8339;8347;8355;8363;8412:3;8400:9;8391:7;8387:23;8383:33;8380:120;;;8419:79;;:::i;:::-;8380:120;8539:1;8564:53;8609:7;8600:6;8589:9;8585:22;8564:53;:::i;:::-;8554:63;;8510:117;8666:2;8692:53;8737:7;8728:6;8717:9;8713:22;8692:53;:::i;:::-;8682:63;;8637:118;8794:2;8820:53;8865:7;8856:6;8845:9;8841:22;8820:53;:::i;:::-;8810:63;;8765:118;8922:2;8948:53;8993:7;8984:6;8973:9;8969:22;8948:53;:::i;:::-;8938:63;;8893:118;9050:3;9077:51;9120:7;9111:6;9100:9;9096:22;9077:51;:::i;:::-;9067:61;;9021:117;9177:3;9204:53;9249:7;9240:6;9229:9;9225:22;9204:53;:::i;:::-;9194:63;;9148:119;9306:3;9333:53;9378:7;9369:6;9358:9;9354:22;9333:53;:::i;:::-;9323:63;;9277:119;8204:1199;;;;;;;;;;:::o;9409:474::-;9477:6;9485;9534:2;9522:9;9513:7;9509:23;9505:32;9502:119;;;9540:79;;:::i;:::-;9502:119;9660:1;9685:53;9730:7;9721:6;9710:9;9706:22;9685:53;:::i;:::-;9675:63;;9631:117;9787:2;9813:53;9858:7;9849:6;9838:9;9834:22;9813:53;:::i;:::-;9803:63;;9758:118;9409:474;;;;;:::o;9889:332::-;10010:4;10048:2;10037:9;10033:18;10025:26;;10061:71;10129:1;10118:9;10114:17;10105:6;10061:71;:::i;:::-;10142:72;10210:2;10199:9;10195:18;10186:6;10142:72;:::i;:::-;9889:332;;;;;:::o;10227:180::-;10275:77;10272:1;10265:88;10372:4;10369:1;10362:15;10396:4;10393:1;10386:15;10413:320;10457:6;10494:1;10488:4;10484:12;10474:22;;10541:1;10535:4;10531:12;10562:18;10552:81;;10618:4;10610:6;10606:17;10596:27;;10552:81;10680:2;10672:6;10669:14;10649:18;10646:38;10643:84;;10699:18;;:::i;:::-;10643:84;10464:269;10413:320;;;:::o;10739:169::-;10879:21;10875:1;10867:6;10863:14;10856:45;10739:169;:::o;10914:366::-;11056:3;11077:67;11141:2;11136:3;11077:67;:::i;:::-;11070:74;;11153:93;11242:3;11153:93;:::i;:::-;11271:2;11266:3;11262:12;11255:19;;10914:366;;;:::o;11286:419::-;11452:4;11490:2;11479:9;11475:18;11467:26;;11539:9;11533:4;11529:20;11525:1;11514:9;11510:17;11503:47;11567:131;11693:4;11567:131;:::i;:::-;11559:139;;11286:419;;;:::o;11711:180::-;11759:77;11756:1;11749:88;11856:4;11853:1;11846:15;11880:4;11877:1;11870:15;11897:410;11937:7;11960:20;11978:1;11960:20;:::i;:::-;11955:25;;11994:20;12012:1;11994:20;:::i;:::-;11989:25;;12049:1;12046;12042:9;12071:30;12089:11;12071:30;:::i;:::-;12060:41;;12250:1;12241:7;12237:15;12234:1;12231:22;12211:1;12204:9;12184:83;12161:139;;12280:18;;:::i;:::-;12161:139;11945:362;11897:410;;;;:::o;12313:180::-;12361:77;12358:1;12351:88;12458:4;12455:1;12448:15;12482:4;12479:1;12472:15;12499:185;12539:1;12556:20;12574:1;12556:20;:::i;:::-;12551:25;;12590:20;12608:1;12590:20;:::i;:::-;12585:25;;12629:1;12619:35;;12634:18;;:::i;:::-;12619:35;12676:1;12673;12669:9;12664:14;;12499:185;;;;:::o;12690:191::-;12730:3;12749:20;12767:1;12749:20;:::i;:::-;12744:25;;12783:20;12801:1;12783:20;:::i;:::-;12778:25;;12826:1;12823;12819:9;12812:16;;12847:3;12844:1;12841:10;12838:36;;;12854:18;;:::i;:::-;12838:36;12690:191;;;;:::o;12887:194::-;12927:4;12947:20;12965:1;12947:20;:::i;:::-;12942:25;;12981:20;12999:1;12981:20;:::i;:::-;12976:25;;13025:1;13022;13018:9;13010:17;;13049:1;13043:4;13040:11;13037:37;;;13054:18;;:::i;:::-;13037:37;12887:194;;;;:::o;13087:170::-;13227:22;13223:1;13215:6;13211:14;13204:46;13087:170;:::o;13263:366::-;13405:3;13426:67;13490:2;13485:3;13426:67;:::i;:::-;13419:74;;13502:93;13591:3;13502:93;:::i;:::-;13620:2;13615:3;13611:12;13604:19;;13263:366;;;:::o;13635:419::-;13801:4;13839:2;13828:9;13824:18;13816:26;;13888:9;13882:4;13878:20;13874:1;13863:9;13859:17;13852:47;13916:131;14042:4;13916:131;:::i;:::-;13908:139;;13635:419;;;:::o;14060:233::-;14099:3;14122:24;14140:5;14122:24;:::i;:::-;14113:33;;14168:66;14161:5;14158:77;14155:103;;14238:18;;:::i;:::-;14155:103;14285:1;14278:5;14274:13;14267:20;;14060:233;;;:::o;14299:169::-;14439:21;14435:1;14427:6;14423:14;14416:45;14299:169;:::o;14474:366::-;14616:3;14637:67;14701:2;14696:3;14637:67;:::i;:::-;14630:74;;14713:93;14802:3;14713:93;:::i;:::-;14831:2;14826:3;14822:12;14815:19;;14474:366;;;:::o;14846:419::-;15012:4;15050:2;15039:9;15035:18;15027:26;;15099:9;15093:4;15089:20;15085:1;15074:9;15070:17;15063:47;15127:131;15253:4;15127:131;:::i;:::-;15119:139;;14846:419;;;:::o;15271:175::-;15411:27;15407:1;15399:6;15395:14;15388:51;15271:175;:::o;15452:366::-;15594:3;15615:67;15679:2;15674:3;15615:67;:::i;:::-;15608:74;;15691:93;15780:3;15691:93;:::i;:::-;15809:2;15804:3;15800:12;15793:19;;15452:366;;;:::o;15824:419::-;15990:4;16028:2;16017:9;16013:18;16005:26;;16077:9;16071:4;16067:20;16063:1;16052:9;16048:17;16041:47;16105:131;16231:4;16105:131;:::i;:::-;16097:139;;15824:419;;;:::o;16249:170::-;16389:22;16385:1;16377:6;16373:14;16366:46;16249:170;:::o;16425:366::-;16567:3;16588:67;16652:2;16647:3;16588:67;:::i;:::-;16581:74;;16664:93;16753:3;16664:93;:::i;:::-;16782:2;16777:3;16773:12;16766:19;;16425:366;;;:::o;16797:419::-;16963:4;17001:2;16990:9;16986:18;16978:26;;17050:9;17044:4;17040:20;17036:1;17025:9;17021:17;17014:47;17078:131;17204:4;17078:131;:::i;:::-;17070:139;;16797:419;;;:::o;17222:224::-;17362:34;17358:1;17350:6;17346:14;17339:58;17431:7;17426:2;17418:6;17414:15;17407:32;17222:224;:::o;17452:366::-;17594:3;17615:67;17679:2;17674:3;17615:67;:::i;:::-;17608:74;;17691:93;17780:3;17691:93;:::i;:::-;17809:2;17804:3;17800:12;17793:19;;17452:366;;;:::o;17824:419::-;17990:4;18028:2;18017:9;18013:18;18005:26;;18077:9;18071:4;18067:20;18063:1;18052:9;18048:17;18041:47;18105:131;18231:4;18105:131;:::i;:::-;18097:139;;17824:419;;;:::o;18249:179::-;18389:31;18385:1;18377:6;18373:14;18366:55;18249:179;:::o;18434:366::-;18576:3;18597:67;18661:2;18656:3;18597:67;:::i;:::-;18590:74;;18673:93;18762:3;18673:93;:::i;:::-;18791:2;18786:3;18782:12;18775:19;;18434:366;;;:::o;18806:419::-;18972:4;19010:2;18999:9;18995:18;18987:26;;19059:9;19053:4;19049:20;19045:1;19034:9;19030:17;19023:47;19087:131;19213:4;19087:131;:::i;:::-;19079:139;;18806:419;;;:::o;19231:147::-;19332:11;19369:3;19354:18;;19231:147;;;;:::o;19384:114::-;;:::o;19504:398::-;19663:3;19684:83;19765:1;19760:3;19684:83;:::i;:::-;19677:90;;19776:93;19865:3;19776:93;:::i;:::-;19894:1;19889:3;19885:11;19878:18;;19504:398;;;:::o;19908:379::-;20092:3;20114:147;20257:3;20114:147;:::i;:::-;20107:154;;20278:3;20271:10;;19908:379;;;:::o;20293:165::-;20433:17;20429:1;20421:6;20417:14;20410:41;20293:165;:::o;20464:366::-;20606:3;20627:67;20691:2;20686:3;20627:67;:::i;:::-;20620:74;;20703:93;20792:3;20703:93;:::i;:::-;20821:2;20816:3;20812:12;20805:19;;20464:366;;;:::o;20836:419::-;21002:4;21040:2;21029:9;21025:18;21017:26;;21089:9;21083:4;21079:20;21075:1;21064:9;21060:17;21053:47;21117:131;21243:4;21117:131;:::i;:::-;21109:139;;20836:419;;;:::o;21261:224::-;21401:34;21397:1;21389:6;21385:14;21378:58;21470:7;21465:2;21457:6;21453:15;21446:32;21261:224;:::o;21491:366::-;21633:3;21654:67;21718:2;21713:3;21654:67;:::i;:::-;21647:74;;21730:93;21819:3;21730:93;:::i;:::-;21848:2;21843:3;21839:12;21832:19;;21491:366;;;:::o;21863:419::-;22029:4;22067:2;22056:9;22052:18;22044:26;;22116:9;22110:4;22106:20;22102:1;22091:9;22087:17;22080:47;22144:131;22270:4;22144:131;:::i;:::-;22136:139;;21863:419;;;:::o;22288:171::-;22428:23;22424:1;22416:6;22412:14;22405:47;22288:171;:::o;22465:366::-;22607:3;22628:67;22692:2;22687:3;22628:67;:::i;:::-;22621:74;;22704:93;22793:3;22704:93;:::i;:::-;22822:2;22817:3;22813:12;22806:19;;22465:366;;;:::o;22837:419::-;23003:4;23041:2;23030:9;23026:18;23018:26;;23090:9;23084:4;23080:20;23076:1;23065:9;23061:17;23054:47;23118:131;23244:4;23118:131;:::i;:::-;23110:139;;22837:419;;;:::o;23262:173::-;23402:25;23398:1;23390:6;23386:14;23379:49;23262:173;:::o;23441:366::-;23583:3;23604:67;23668:2;23663:3;23604:67;:::i;:::-;23597:74;;23680:93;23769:3;23680:93;:::i;:::-;23798:2;23793:3;23789:12;23782:19;;23441:366;;;:::o;23813:419::-;23979:4;24017:2;24006:9;24002:18;23994:26;;24066:9;24060:4;24056:20;24052:1;24041:9;24037:17;24030:47;24094:131;24220:4;24094:131;:::i;:::-;24086:139;;23813:419;;;:::o;24238:167::-;24378:19;24374:1;24366:6;24362:14;24355:43;24238:167;:::o;24411:366::-;24553:3;24574:67;24638:2;24633:3;24574:67;:::i;:::-;24567:74;;24650:93;24739:3;24650:93;:::i;:::-;24768:2;24763:3;24759:12;24752:19;;24411:366;;;:::o;24783:419::-;24949:4;24987:2;24976:9;24972:18;24964:26;;25036:9;25030:4;25026:20;25022:1;25011:9;25007:17;25000:47;25064:131;25190:4;25064:131;:::i;:::-;25056:139;;24783:419;;;:::o;25208:159::-;25348:11;25344:1;25336:6;25332:14;25325:35;25208:159;:::o;25373:365::-;25515:3;25536:66;25600:1;25595:3;25536:66;:::i;:::-;25529:73;;25611:93;25700:3;25611:93;:::i;:::-;25729:2;25724:3;25720:12;25713:19;;25373:365;;;:::o;25744:419::-;25910:4;25948:2;25937:9;25933:18;25925:26;;25997:9;25991:4;25987:20;25983:1;25972:9;25968:17;25961:47;26025:131;26151:4;26025:131;:::i;:::-;26017:139;;25744:419;;;:::o;26169:179::-;26309:31;26305:1;26297:6;26293:14;26286:55;26169:179;:::o;26354:366::-;26496:3;26517:67;26581:2;26576:3;26517:67;:::i;:::-;26510:74;;26593:93;26682:3;26593:93;:::i;:::-;26711:2;26706:3;26702:12;26695:19;;26354:366;;;:::o;26726:419::-;26892:4;26930:2;26919:9;26915:18;26907:26;;26979:9;26973:4;26969:20;26965:1;26954:9;26950:17;26943:47;27007:131;27133:4;27007:131;:::i;:::-;26999:139;;26726:419;;;:::o;27151:775::-;27384:4;27422:3;27411:9;27407:19;27399:27;;27436:71;27504:1;27493:9;27489:17;27480:6;27436:71;:::i;:::-;27517:72;27585:2;27574:9;27570:18;27561:6;27517:72;:::i;:::-;27599;27667:2;27656:9;27652:18;27643:6;27599:72;:::i;:::-;27681;27749:2;27738:9;27734:18;27725:6;27681:72;:::i;:::-;27763:73;27831:3;27820:9;27816:19;27807:6;27763:73;:::i;:::-;27846;27914:3;27903:9;27899:19;27890:6;27846:73;:::i;:::-;27151:775;;;;;;;;;:::o;27932:180::-;28072:32;28068:1;28060:6;28056:14;28049:56;27932:180;:::o;28118:366::-;28260:3;28281:67;28345:2;28340:3;28281:67;:::i;:::-;28274:74;;28357:93;28446:3;28357:93;:::i;:::-;28475:2;28470:3;28466:12;28459:19;;28118:366;;;:::o;28490:419::-;28656:4;28694:2;28683:9;28679:18;28671:26;;28743:9;28737:4;28733:20;28729:1;28718:9;28714:17;28707:47;28771:131;28897:4;28771:131;:::i;:::-;28763:139;;28490:419;;;:::o;28915:225::-;29055:34;29051:1;29043:6;29039:14;29032:58;29124:8;29119:2;29111:6;29107:15;29100:33;28915:225;:::o;29146:366::-;29288:3;29309:67;29373:2;29368:3;29309:67;:::i;:::-;29302:74;;29385:93;29474:3;29385:93;:::i;:::-;29503:2;29498:3;29494:12;29487:19;;29146:366;;;:::o;29518:419::-;29684:4;29722:2;29711:9;29707:18;29699:26;;29771:9;29765:4;29761:20;29757:1;29746:9;29742:17;29735:47;29799:131;29925:4;29799:131;:::i;:::-;29791:139;;29518:419;;;:::o;29943:223::-;30083:34;30079:1;30071:6;30067:14;30060:58;30152:6;30147:2;30139:6;30135:15;30128:31;29943:223;:::o;30172:366::-;30314:3;30335:67;30399:2;30394:3;30335:67;:::i;:::-;30328:74;;30411:93;30500:3;30411:93;:::i;:::-;30529:2;30524:3;30520:12;30513:19;;30172:366;;;:::o;30544:419::-;30710:4;30748:2;30737:9;30733:18;30725:26;;30797:9;30791:4;30787:20;30783:1;30772:9;30768:17;30761:47;30825:131;30951:4;30825:131;:::i;:::-;30817:139;;30544:419;;;:::o;30969:221::-;31109:34;31105:1;31097:6;31093:14;31086:58;31178:4;31173:2;31165:6;31161:15;31154:29;30969:221;:::o;31196:366::-;31338:3;31359:67;31423:2;31418:3;31359:67;:::i;:::-;31352:74;;31435:93;31524:3;31435:93;:::i;:::-;31553:2;31548:3;31544:12;31537:19;;31196:366;;;:::o;31568:419::-;31734:4;31772:2;31761:9;31757:18;31749:26;;31821:9;31815:4;31811:20;31807:1;31796:9;31792:17;31785:47;31849:131;31975:4;31849:131;:::i;:::-;31841:139;;31568:419;;;:::o;31993:182::-;32133:34;32129:1;32121:6;32117:14;32110:58;31993:182;:::o;32181:366::-;32323:3;32344:67;32408:2;32403:3;32344:67;:::i;:::-;32337:74;;32420:93;32509:3;32420:93;:::i;:::-;32538:2;32533:3;32529:12;32522:19;;32181:366;;;:::o;32553:419::-;32719:4;32757:2;32746:9;32742:18;32734:26;;32806:9;32800:4;32796:20;32792:1;32781:9;32777:17;32770:47;32834:131;32960:4;32834:131;:::i;:::-;32826:139;;32553:419;;;:::o;32978:181::-;33118:33;33114:1;33106:6;33102:14;33095:57;32978:181;:::o;33165:366::-;33307:3;33328:67;33392:2;33387:3;33328:67;:::i;:::-;33321:74;;33404:93;33493:3;33404:93;:::i;:::-;33522:2;33517:3;33513:12;33506:19;;33165:366;;;:::o;33537:419::-;33703:4;33741:2;33730:9;33726:18;33718:26;;33790:9;33784:4;33780:20;33776:1;33765:9;33761:17;33754:47;33818:131;33944:4;33818:131;:::i;:::-;33810:139;;33537:419;;;:::o;33962:179::-;34102:31;34098:1;34090:6;34086:14;34079:55;33962:179;:::o;34147:366::-;34289:3;34310:67;34374:2;34369:3;34310:67;:::i;:::-;34303:74;;34386:93;34475:3;34386:93;:::i;:::-;34504:2;34499:3;34495:12;34488:19;;34147:366;;;:::o;34519:419::-;34685:4;34723:2;34712:9;34708:18;34700:26;;34772:9;34766:4;34762:20;34758:1;34747:9;34743:17;34736:47;34800:131;34926:4;34800:131;:::i;:::-;34792:139;;34519:419;;;:::o;34944:224::-;35084:34;35080:1;35072:6;35068:14;35061:58;35153:7;35148:2;35140:6;35136:15;35129:32;34944:224;:::o;35174:366::-;35316:3;35337:67;35401:2;35396:3;35337:67;:::i;:::-;35330:74;;35413:93;35502:3;35413:93;:::i;:::-;35531:2;35526:3;35522:12;35515:19;;35174:366;;;:::o;35546:419::-;35712:4;35750:2;35739:9;35735:18;35727:26;;35799:9;35793:4;35789:20;35785:1;35774:9;35770:17;35763:47;35827:131;35953:4;35827:131;:::i;:::-;35819:139;;35546:419;;;:::o;35971:222::-;36111:34;36107:1;36099:6;36095:14;36088:58;36180:5;36175:2;36167:6;36163:15;36156:30;35971:222;:::o;36199:366::-;36341:3;36362:67;36426:2;36421:3;36362:67;:::i;:::-;36355:74;;36438:93;36527:3;36438:93;:::i;:::-;36556:2;36551:3;36547:12;36540:19;;36199:366;;;:::o;36571:419::-;36737:4;36775:2;36764:9;36760:18;36752:26;;36824:9;36818:4;36814:20;36810:1;36799:9;36795:17;36788:47;36852:131;36978:4;36852:131;:::i;:::-;36844:139;;36571:419;;;:::o;36996:225::-;37136:34;37132:1;37124:6;37120:14;37113:58;37205:8;37200:2;37192:6;37188:15;37181:33;36996:225;:::o;37227:366::-;37369:3;37390:67;37454:2;37449:3;37390:67;:::i;:::-;37383:74;;37466:93;37555:3;37466:93;:::i;:::-;37584:2;37579:3;37575:12;37568:19;;37227:366;;;:::o;37599:419::-;37765:4;37803:2;37792:9;37788:18;37780:26;;37852:9;37846:4;37842:20;37838:1;37827:9;37823:17;37816:47;37880:131;38006:4;37880:131;:::i;:::-;37872:139;;37599:419;;;:::o;38024:664::-;38229:4;38267:3;38256:9;38252:19;38244:27;;38281:71;38349:1;38338:9;38334:17;38325:6;38281:71;:::i;:::-;38362:72;38430:2;38419:9;38415:18;38406:6;38362:72;:::i;:::-;38444;38512:2;38501:9;38497:18;38488:6;38444:72;:::i;:::-;38526;38594:2;38583:9;38579:18;38570:6;38526:72;:::i;:::-;38608:73;38676:3;38665:9;38661:19;38652:6;38608:73;:::i;:::-;38024:664;;;;;;;;:::o;38694:148::-;38796:11;38833:3;38818:18;;38694:148;;;;:::o;38848:214::-;38988:66;38984:1;38976:6;38972:14;38965:90;38848:214;:::o;39068:400::-;39228:3;39249:84;39331:1;39326:3;39249:84;:::i;:::-;39242:91;;39342:93;39431:3;39342:93;:::i;:::-;39460:1;39455:3;39451:11;39444:18;;39068:400;;;:::o;39474:79::-;39513:7;39542:5;39531:16;;39474:79;;;:::o;39559:157::-;39664:45;39684:24;39702:5;39684:24;:::i;:::-;39664:45;:::i;:::-;39659:3;39652:58;39559:157;;:::o;39722:663::-;39963:3;39985:148;40129:3;39985:148;:::i;:::-;39978:155;;40143:75;40214:3;40205:6;40143:75;:::i;:::-;40243:2;40238:3;40234:12;40227:19;;40256:75;40327:3;40318:6;40256:75;:::i;:::-;40356:2;40351:3;40347:12;40340:19;;40376:3;40369:10;;39722:663;;;;;:::o;40391:545::-;40564:4;40602:3;40591:9;40587:19;40579:27;;40616:71;40684:1;40673:9;40669:17;40660:6;40616:71;:::i;:::-;40697:68;40761:2;40750:9;40746:18;40737:6;40697:68;:::i;:::-;40775:72;40843:2;40832:9;40828:18;40819:6;40775:72;:::i;:::-;40857;40925:2;40914:9;40910:18;40901:6;40857:72;:::i;:::-;40391:545;;;;;;;:::o;40942:180::-;40990:77;40987:1;40980:88;41087:4;41084:1;41077:15;41111:4;41108:1;41101:15;41128:174;41268:26;41264:1;41256:6;41252:14;41245:50;41128:174;:::o;41308:366::-;41450:3;41471:67;41535:2;41530:3;41471:67;:::i;:::-;41464:74;;41547:93;41636:3;41547:93;:::i;:::-;41665:2;41660:3;41656:12;41649:19;;41308:366;;;:::o;41680:419::-;41846:4;41884:2;41873:9;41869:18;41861:26;;41933:9;41927:4;41923:20;41919:1;41908:9;41904:17;41897:47;41961:131;42087:4;41961:131;:::i;:::-;41953:139;;41680:419;;;:::o;42105:181::-;42245:33;42241:1;42233:6;42229:14;42222:57;42105:181;:::o;42292:366::-;42434:3;42455:67;42519:2;42514:3;42455:67;:::i;:::-;42448:74;;42531:93;42620:3;42531:93;:::i;:::-;42649:2;42644:3;42640:12;42633:19;;42292:366;;;:::o;42664:419::-;42830:4;42868:2;42857:9;42853:18;42845:26;;42917:9;42911:4;42907:20;42903:1;42892:9;42888:17;42881:47;42945:131;43071:4;42945:131;:::i;:::-;42937:139;;42664:419;;;:::o;43089:221::-;43229:34;43225:1;43217:6;43213:14;43206:58;43298:4;43293:2;43285:6;43281:15;43274:29;43089:221;:::o;43316:366::-;43458:3;43479:67;43543:2;43538:3;43479:67;:::i;:::-;43472:74;;43555:93;43644:3;43555:93;:::i;:::-;43673:2;43668:3;43664:12;43657:19;;43316:366;;;:::o;43688:419::-;43854:4;43892:2;43881:9;43877:18;43869:26;;43941:9;43935:4;43931:20;43927:1;43916:9;43912:17;43905:47;43969:131;44095:4;43969:131;:::i;:::-;43961:139;;43688:419;;;:::o

ipfs://dd4991576fe734ccd1f034fc98516b28b74281cea2c7b29f4c6e76b25137abea