Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// File: @openzeppelin/contracts/utils/Counters.sol


// 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/security/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// 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/IERC20Metadata.sol


// 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/Strings.sol


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

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

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

// File: @openzeppelin/contracts/utils/Context.sol


// 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/access/Ownable.sol


// OpenZeppelin Contracts v4.4.1 (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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

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

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

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v4.6.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.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `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 `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `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;
        }
        _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;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

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

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

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

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

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

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

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

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

    /**
     * @dev 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/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` 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 tokenId
    ) 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.
     * - `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 tokenId
    ) internal virtual {}
}

// File: contracts/DEYEMarketPlaceV1.sol


// Author: Mas C. (Project Dark Eye)
pragma solidity ^0.8.0;







contract DEYEMarketplaceV1 is ReentrancyGuard, Ownable {
    using Counters for Counters.Counter;
    Counters.Counter private _itemCounter;

    enum State {
        Listed,
        Active,
        Sold,
        Inactive
    }

    struct Item {
        uint id;
        address nft;
        uint256 tokenId;
        address payable seller;
        address payable buyer;
        uint256 startingTime;
        uint256 startingPrice;
        uint256 discountRate;
        uint256 discountTime;
        uint256 endingPrice;
        uint256 soldPrice;
        uint256 soldTime;
        State state;
    }

    struct PricedItem {
        Item item;
        uint256 currentPrice;
        uint256 nextPrice;
        uint256 nextPriceTime;
    }

    mapping(uint256 => Item) private items;
    address public tokenAddress;

    bool public allowAnyListers = false;
    mapping(address => bool) private allowedListers;

    event MarketItemCreated (
        uint indexed id,
        address indexed nft,
        uint256 indexed tokenId,
        address seller,
        address buyer,
        uint256 startingTime,
        uint256 startingPrice,
        uint256 discountRate,
        uint256 discountTime,
        uint256 endingPrice,
        State state,
        uint256 timestamp
    );

    event MarketItemSold (
        uint indexed id,
        address indexed nft,
        uint256 indexed tokenId,
        address seller,
        address buyer,
        uint256 soldPrice,
        State state,
        uint256 timestamp
    );

    constructor(address tokenAddr, address allowedLister) {
        tokenAddress = tokenAddr;
        allowedListers[allowedLister] = true;
    }

    // Required for listers before listing an NFT.
    function setApprovalForAllForLister(address nft) public nonReentrant {
        IERC721(nft).setApprovalForAll(address(this), true);
    }

    // Required for buyers before buying an NFT.
    function setApprovalForToken() public nonReentrant {
        IERC20(tokenAddress).approve(address(this), 1e28);
    }

    // List an item.
    function listItem(
        address nft, uint256 tokenId, uint256 startingTime, uint256 startingPrice, uint256 discountRate, uint256 discountTime, uint256 endingPrice
    ) public nonReentrant {
        require(startingPrice > 0 && endingPrice > 0, "Prices must be greater than 0");
        require(IERC721(nft).ownerOf(tokenId) == msg.sender, "Sender must be the token owner");
        require(IERC721(nft).getApproved(tokenId) == address(this) || IERC721(nft).isApprovedForAll(msg.sender, address(this)), "NFT must be approved");
        require(allowAnyListers || allowedListers[msg.sender], "Lister not allowed");

        _itemCounter.increment();
        uint256 id = _itemCounter.current();

        items[id] = Item(
            id,
            nft,
            tokenId,
            payable(msg.sender),
            payable(address(0)),
            startingTime,
            startingPrice,
            discountRate,
            discountTime,
            endingPrice,
            0,
            0,
            State.Listed
        );

        emit MarketItemCreated(
            id,
            nft,
            tokenId,
            msg.sender,
            address(0),
            startingTime,
            startingPrice,
            discountRate,
            discountTime,
            endingPrice,
            State.Listed,
            block.timestamp
        );
    }

    // Delist an item.
    function delistItem(uint256 itemId) public nonReentrant {
        require(itemId <= _itemCounter.current(), "id must <= item count");
        require(items[itemId].state == State.Listed, "item must be in the listed state");
        require(IERC721(items[itemId].nft).ownerOf(items[itemId].tokenId) == msg.sender, "must be the owner");

        items[itemId].state = State.Inactive;

        emit MarketItemSold(
            itemId,
            items[itemId].nft,
            items[itemId].tokenId,
            items[itemId].seller,
            address(0),
            0,
            State.Inactive,
            block.timestamp
        );

    }

    // Buy an item.
    function buyItem(uint256 itemId, uint256 payment) public nonReentrant {
        require(itemId <= _itemCounter.current(), "id must <= item count");
        require(getState(itemId) == State.Active, "item not on sale yet");
        require(IERC721(items[itemId].nft).ownerOf(items[itemId].tokenId) == items[itemId].seller, "Sender must be the token owner");
        require(IERC721(items[itemId].nft).getApproved(items[itemId].tokenId) == address(this) || IERC721(items[itemId].nft).isApprovedForAll(items[itemId].seller, address(this)), "NFT must be approved to market");
        require(IERC20(tokenAddress).allowance(msg.sender, address(this)) >= payment, "Token must be approved to market");

        uint256 price = getPrice(itemId);
        require(payment >= price, "Not enough payment set");

        IERC721(items[itemId].nft).transferFrom(items[itemId].seller, msg.sender, items[itemId].tokenId);
        IERC20(tokenAddress).transferFrom(msg.sender, items[itemId].seller, payment);

        items[itemId].buyer = payable(msg.sender);
        items[itemId].state = State.Sold;
        items[itemId].soldPrice = payment;
        items[itemId].soldTime = block.timestamp;

        emit MarketItemSold(
            itemId,
            items[itemId].nft,
            items[itemId].tokenId,
            items[itemId].seller,
            items[itemId].buyer,
            items[itemId].soldPrice,
            items[itemId].state,
            block.timestamp
        );    
    }

    function getItemCount() public view returns (uint256) {
        return _itemCounter.current();
    }

    function getState(uint256 itemId) public view returns (State) {
        require(itemId <= _itemCounter.current(), "id must <= item count");
        if (items[itemId].state == State.Sold) {
            return State.Sold;
        }
        if (IERC721(items[itemId].nft).ownerOf(items[itemId].tokenId) != items[itemId].seller) {
            return State.Inactive;
        }
        if (IERC721(items[itemId].nft).getApproved(items[itemId].tokenId) != address(this) && !IERC721(items[itemId].nft).isApprovedForAll(items[itemId].seller, address(this))) {
            return State.Inactive;
        }
        if (items[itemId].state == State.Listed && block.timestamp >= items[itemId].startingTime) {
            return State.Active;
        }
        return items[itemId].state;
    }

    function getPricedItem(uint256 itemId) internal view returns (PricedItem memory) {
        return PricedItem(
            items[itemId],
            getPrice(itemId),
            getNextPrice(itemId),
            getNextPriceTime(itemId)
        );
    }

    function getItem(uint256 itemId) public view returns (PricedItem memory) {
        require(itemId <= _itemCounter.current(), "id must <= item count");
        return getPricedItem(itemId);
    }

    function getPrice(uint256 itemId) public view returns (uint256) {
        require(itemId <= _itemCounter.current(), "id must <= item count");
        if (items[itemId].state != State.Listed) {
            return items[itemId].soldPrice;
        }
        if (block.timestamp < items[itemId].startingTime || items[itemId].discountTime == 0) {
            return items[itemId].startingPrice;
        }
        uint256 numDiscounts = (block.timestamp - items[itemId].startingTime) / items[itemId].discountTime;
        uint256 discountPrice = items[itemId].startingPrice;
        for (uint i = 1; i <= numDiscounts; i++) {
            discountPrice = discountPrice * items[itemId].discountRate / 10000;
        }
        return discountPrice >= items[itemId].endingPrice ? discountPrice : items[itemId].endingPrice;
    }

    function getNextPrice(uint256 itemId) public view returns (uint256) {
        require(itemId <= _itemCounter.current(), "id must <= item count");
        if (items[itemId].state != State.Listed) {
            return items[itemId].soldPrice;
        }
        if (block.timestamp < items[itemId].startingTime || items[itemId].discountTime == 0) {
            return items[itemId].startingPrice;
        }
        uint256 numDiscounts = (block.timestamp - items[itemId].startingTime) / items[itemId].discountTime + 1;
        uint256 discountPrice = items[itemId].startingPrice;
        for (uint i = 1; i <= numDiscounts; i++) {
            discountPrice = discountPrice * items[itemId].discountRate / 10000;
        }
        return discountPrice >= items[itemId].endingPrice ? discountPrice : items[itemId].endingPrice;
    }

    function getNextPriceTime(uint256 itemId) public view returns (uint256) {
        require(itemId <= _itemCounter.current(), "id must <= item count");
        if (items[itemId].state != State.Listed) {
            return items[itemId].startingTime;
        }
        if (block.timestamp < items[itemId].startingTime || items[itemId].discountTime == 0) {
            return items[itemId].startingTime;
        }
        uint256 numDiscounts = (block.timestamp - items[itemId].startingTime) / items[itemId].discountTime + 1;
        uint256 discountPrice = items[itemId].startingPrice;
        uint256 time = items[itemId].startingTime;
        for (uint i = 1; i <= numDiscounts; i++) {
            if (discountPrice <= items[itemId].endingPrice) {
                return time;
            }
            discountPrice = discountPrice * items[itemId].discountRate / 10000;
            time = time + items[itemId].discountTime;
        }
        return time;
    }

    function getItemListByState(State state) public view returns (PricedItem[] memory) {
        uint itemCount = 0;
        for (uint i = 1; i <= getItemCount(); i++) {
            if (getState(i) == state) {
                itemCount++;
            }
        }

        uint index = 0;
        PricedItem[] memory itemList = new PricedItem[](itemCount);
        for (uint i = 1; i <= getItemCount(); i++) {
            if (getState(i) == state) {
                itemList[index] = getPricedItem(i);
                index++;
            }
        }
        return itemList;
    }

    // Owner Only Functions.

    function setItemState(uint256 itemId, State state) public onlyOwner {
        require(itemId <= _itemCounter.current(), "id must <= item count");
        items[itemId].state = state;
    }

    function setAllowAnyListers(bool allowed) public onlyOwner {
        allowAnyListers = allowed;
    }

    function setAllowedLister(address addr, bool allowed) public onlyOwner {
        allowedListers[addr] = allowed;
    }

    function setTokenAddress(address addr) public onlyOwner {
        tokenAddress = addr;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"tokenAddr","type":"address"},{"internalType":"address","name":"allowedLister","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"nft","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"address","name":"buyer","type":"address"},{"indexed":false,"internalType":"uint256","name":"startingTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"startingPrice","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"discountRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"discountTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endingPrice","type":"uint256"},{"indexed":false,"internalType":"enum DEYEMarketplaceV1.State","name":"state","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"MarketItemCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"nft","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"address","name":"buyer","type":"address"},{"indexed":false,"internalType":"uint256","name":"soldPrice","type":"uint256"},{"indexed":false,"internalType":"enum DEYEMarketplaceV1.State","name":"state","type":"uint8"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"MarketItemSold","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"},{"inputs":[],"name":"allowAnyListers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"itemId","type":"uint256"},{"internalType":"uint256","name":"payment","type":"uint256"}],"name":"buyItem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"itemId","type":"uint256"}],"name":"delistItem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"itemId","type":"uint256"}],"name":"getItem","outputs":[{"components":[{"components":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"nft","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address payable","name":"seller","type":"address"},{"internalType":"address payable","name":"buyer","type":"address"},{"internalType":"uint256","name":"startingTime","type":"uint256"},{"internalType":"uint256","name":"startingPrice","type":"uint256"},{"internalType":"uint256","name":"discountRate","type":"uint256"},{"internalType":"uint256","name":"discountTime","type":"uint256"},{"internalType":"uint256","name":"endingPrice","type":"uint256"},{"internalType":"uint256","name":"soldPrice","type":"uint256"},{"internalType":"uint256","name":"soldTime","type":"uint256"},{"internalType":"enum DEYEMarketplaceV1.State","name":"state","type":"uint8"}],"internalType":"struct DEYEMarketplaceV1.Item","name":"item","type":"tuple"},{"internalType":"uint256","name":"currentPrice","type":"uint256"},{"internalType":"uint256","name":"nextPrice","type":"uint256"},{"internalType":"uint256","name":"nextPriceTime","type":"uint256"}],"internalType":"struct DEYEMarketplaceV1.PricedItem","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getItemCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum DEYEMarketplaceV1.State","name":"state","type":"uint8"}],"name":"getItemListByState","outputs":[{"components":[{"components":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"nft","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address payable","name":"seller","type":"address"},{"internalType":"address payable","name":"buyer","type":"address"},{"internalType":"uint256","name":"startingTime","type":"uint256"},{"internalType":"uint256","name":"startingPrice","type":"uint256"},{"internalType":"uint256","name":"discountRate","type":"uint256"},{"internalType":"uint256","name":"discountTime","type":"uint256"},{"internalType":"uint256","name":"endingPrice","type":"uint256"},{"internalType":"uint256","name":"soldPrice","type":"uint256"},{"internalType":"uint256","name":"soldTime","type":"uint256"},{"internalType":"enum DEYEMarketplaceV1.State","name":"state","type":"uint8"}],"internalType":"struct DEYEMarketplaceV1.Item","name":"item","type":"tuple"},{"internalType":"uint256","name":"currentPrice","type":"uint256"},{"internalType":"uint256","name":"nextPrice","type":"uint256"},{"internalType":"uint256","name":"nextPriceTime","type":"uint256"}],"internalType":"struct DEYEMarketplaceV1.PricedItem[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"itemId","type":"uint256"}],"name":"getNextPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"itemId","type":"uint256"}],"name":"getNextPriceTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"itemId","type":"uint256"}],"name":"getPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"itemId","type":"uint256"}],"name":"getState","outputs":[{"internalType":"enum DEYEMarketplaceV1.State","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"nft","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"startingTime","type":"uint256"},{"internalType":"uint256","name":"startingPrice","type":"uint256"},{"internalType":"uint256","name":"discountRate","type":"uint256"},{"internalType":"uint256","name":"discountTime","type":"uint256"},{"internalType":"uint256","name":"endingPrice","type":"uint256"}],"name":"listItem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"allowed","type":"bool"}],"name":"setAllowAnyListers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bool","name":"allowed","type":"bool"}],"name":"setAllowedLister","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"nft","type":"address"}],"name":"setApprovalForAllForLister","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setApprovalForToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"itemId","type":"uint256"},{"internalType":"enum DEYEMarketplaceV1.State","name":"state","type":"uint8"}],"name":"setItemState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"setTokenAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tokenAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000e81b6ef5ef04972d9d0548848024058b59d00ff00000000000000000000000003af7e24f2246998d9a873dbfb410c15affff1cab

-----Decoded View---------------
Arg [0] : tokenAddr (address): 0xE81b6ef5eF04972D9d0548848024058b59d00Ff0
Arg [1] : allowedLister (address): 0x3AF7e24F2246998D9A873DBFB410C15affff1cAB

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000e81b6ef5ef04972d9d0548848024058b59d00ff0
Arg [1] : 0000000000000000000000003af7e24f2246998d9a873dbfb410c15affff1cab

58126:11032:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68623:191;;;;;;:::i;:::-;;:::i;:::-;;61721:662;;;;;;:::i;:::-;;:::i;60273:1416::-;;;;;;:::i;:::-;;:::i;68933:120::-;;;;;;:::i;:::-;;:::i;69061:94::-;;;;;;:::i;:::-;;:::i;65110:197::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64038:795;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;68822:103::-;;;;;;:::i;:::-;;:::i;60124:119::-;;;:::i;12568:103::-;;;:::i;63928:102::-;;;:::i;:::-;;;15688:25:1;;;15676:2;15661:18;63928:102:0;15542:177:1;11917:87:0;11990:6;;-1:-1:-1;;;;;11990:6:0;11917:87;;;-1:-1:-1;;;;;5136:32:1;;;5118:51;;5106:2;5091:18;11917:87:0;4972:203:1;66155:840:0;;;;;;:::i;:::-;;:::i;67003:979::-;;;;;;:::i;:::-;;:::i;62412:1508::-;;;;;;:::i;:::-;;:::i;58951:27::-;;;;;-1:-1:-1;;;;;58951:27:0;;;67990:593;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;65315:832::-;;;;;;:::i;:::-;;:::i;59927:139::-;;;;;;:::i;:::-;;:::i;12826:201::-;;;;;;:::i;:::-;;:::i;58987:35::-;;;;;-1:-1:-1;;;58987:35:0;;;;;;;;;10031:14:1;;10024:22;10006:41;;9994:2;9979:18;58987:35:0;9866:187:1;68623:191:0;11990:6;;-1:-1:-1;;;;;11990:6:0;10721:10;12137:23;12129:68;;;;-1:-1:-1;;;12129:68:0;;;;;;;:::i;:::-;;;;;;;;;68720:12:::1;964:14:::0;68710:6:::1;:32;;68702:66;;;;-1:-1:-1::0;;;68702:66:0::1;;;;;;;:::i;:::-;68779:13;::::0;;;:5:::1;:13;::::0;;;;;;;:19:::1;;:27:::0;;68801:5;;-1:-1:-1;;68779:27:0;;::::1;::::0;;;68801:5;;68779:27;::::1;;;;;;:::i;:::-;;;;;;68623:191:::0;;:::o;61721:662::-;3277:1;3875:7;;:19;;3867:63;;;;-1:-1:-1;;;3867:63:0;;;;;;;:::i;:::-;3277:1;4008:7;:18;;;964:14;61796:6:::1;:32;;61788:66;;;;-1:-1:-1::0;;;61788:66:0::1;;;;;;;:::i;:::-;61896:12;61873:13:::0;;;:5:::1;:13;::::0;;;;;;:19:::1;;::::0;::::1;;::::0;:35;::::1;;;;;;:::i;:::-;;61865:80;;;::::0;-1:-1:-1;;;61865:80:0;;12288:2:1;61865:80:0::1;::::0;::::1;12270:21:1::0;;;12307:18;;;12300:30;12366:34;12346:18;;;12339:62;12418:18;;61865:80:0::1;12086:356:1::0;61865:80:0::1;61972:13;::::0;;;:5:::1;:13;::::0;;;;;;:17:::1;::::0;::::1;::::0;61999:21:::1;::::0;;::::1;::::0;61964:57;;-1:-1:-1;;;61964:57:0;;::::1;::::0;::::1;15688:25:1::0;;;;62025:10:0::1;::::0;-1:-1:-1;;;;;61972:17:0;;::::1;::::0;61964:34:::1;::::0;15661:18:1;;61964:57:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;61964:71:0::1;;61956:101;;;::::0;-1:-1:-1;;;61956:101:0;;10465:2:1;61956:101:0::1;::::0;::::1;10447:21:1::0;10504:2;10484:18;;;10477:30;-1:-1:-1;;;10523:18:1;;;10516:47;10580:18;;61956:101:0::1;10263:341:1::0;61956:101:0::1;62070:13;::::0;;;62092:14:::1;62070:13;::::0;;;;;;;:19:::1;::::0;::::1;:36:::0;;-1:-1:-1;;62070:36:0::1;::::0;::::1;::::0;;62206:21:::1;::::0;::::1;::::0;62070:36;62174:17;::::1;::::0;62242:20;;::::1;::::0;62124:249;;62206:21;;-1:-1:-1;;;;;62174:17:0;;::::1;::::0;62070:13;;62124:249:::1;::::0;::::1;::::0;62242:20;::::1;::::0;62070:13;;;62347:15:::1;::::0;62124:249:::1;:::i;:::-;;;;;;;;-1:-1:-1::0;3233:1:0;4187:7;:22;61721:662::o;60273:1416::-;3277:1;3875:7;;:19;;3867:63;;;;-1:-1:-1;;;3867:63:0;;;;;;;:::i;:::-;3277:1;4008:7;:18;60486:17;;;;;:36:::1;;;60521:1;60507:11;:15;60486:36;60478:78;;;::::0;-1:-1:-1;;;60478:78:0;;11218:2:1;60478:78:0::1;::::0;::::1;11200:21:1::0;11257:2;11237:18;;;11230:30;11296:31;11276:18;;;11269:59;11345:18;;60478:78:0::1;11016:353:1::0;60478:78:0::1;60575:29;::::0;-1:-1:-1;;;60575:29:0;;::::1;::::0;::::1;15688:25:1::0;;;60608:10:0::1;::::0;-1:-1:-1;;;;;60575:20:0;::::1;::::0;::::1;::::0;15661:18:1;;60575:29:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;60575:43:0::1;;60567:86;;;::::0;-1:-1:-1;;;60567:86:0;;14764:2:1;60567:86:0::1;::::0;::::1;14746:21:1::0;14803:2;14783:18;;;14776:30;14842:32;14822:18;;;14815:60;14892:18;;60567:86:0::1;14562:354:1::0;60567:86:0::1;60672:33;::::0;-1:-1:-1;;;60672:33:0;;::::1;::::0;::::1;15688:25:1::0;;;60717:4:0::1;::::0;-1:-1:-1;;;;;60672:24:0;::::1;::::0;::::1;::::0;15661:18:1;;60672:33:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;60672:50:0::1;;:110;;;-1:-1:-1::0;60726:56:0::1;::::0;-1:-1:-1;;;60726:56:0;;60756:10:::1;60726:56;::::0;::::1;5400:34:1::0;60776:4:0::1;5450:18:1::0;;;5443:43;-1:-1:-1;;;;;60726:29:0;::::1;::::0;::::1;::::0;5335:18:1;;60726:56:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60664:143;;;::::0;-1:-1:-1;;;60664:143:0;;14415:2:1;60664:143:0::1;::::0;::::1;14397:21:1::0;14454:2;14434:18;;;14427:30;-1:-1:-1;;;14473:18:1;;;14466:50;14533:18;;60664:143:0::1;14213:344:1::0;60664:143:0::1;60826:15;::::0;-1:-1:-1;;;60826:15:0;::::1;;;::::0;:45:::1;;-1:-1:-1::0;60860:10:0::1;60845:26;::::0;;;:14:::1;:26;::::0;;;;;::::1;;60826:45;60818:76;;;::::0;-1:-1:-1;;;60818:76:0;;12649:2:1;60818:76:0::1;::::0;::::1;12631:21:1::0;12688:2;12668:18;;;12661:30;-1:-1:-1;;;12707:18:1;;;12700:48;12765:18;;60818:76:0::1;12447:342:1::0;60818:76:0::1;60907:24;:12;1083:19:::0;;1101:1;1083:19;;;994:127;60907:24:::1;60942:10;60955:22;:12;964:14:::0;;872:114;60955:22:::1;60942:35;;61002:334;;;;;;;;61021:2;61002:334;;;;61038:3;-1:-1:-1::0;;;;;61002:334:0::1;;;;;61056:7;61002:334;;;;61086:10;-1:-1:-1::0;;;;;61002:334:0::1;;;;;61128:1;-1:-1:-1::0;;;;;61002:334:0::1;;;;;61146:12;61002:334;;;;61173:13;61002:334;;;;61201:12;61002:334;;;;61228:12;61002:334;;;;61255:11;61002:334;;;;61281:1;61002:334;;;;61297:1;61002:334;;;;61313:12;61002:334;;;;;;;;:::i;:::-;::::0;;60990:9:::1;::::0;;;:5:::1;:9;::::0;;;;;;;;:346;;;;;;::::1;::::0;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;60990:346:0;;::::1;-1:-1:-1::0;;;;;60990:346:0;;::::1;;::::0;;;;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;:9;;:346;;;;-1:-1:-1;;60990:346:0::1;::::0;;;;;::::1;;;;;;:::i;:::-;;;;;;;;;61421:7;61403:3;-1:-1:-1::0;;;;;61354:327:0::1;61386:2;61354:327;61443:10;61476:1;61493:12;61520:13;61548:12;61575;61602:11;61628:12;61655:15;61354:327;;;;;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;3233:1:0;4187:7;:22;-1:-1:-1;;;;;;60273:1416:0:o;68933:120::-;11990:6;;-1:-1:-1;;;;;11990:6:0;10721:10;12137:23;12129:68;;;;-1:-1:-1;;;12129:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;69015:20:0;;;::::1;;::::0;;;:14:::1;:20;::::0;;;;:30;;-1:-1:-1;;69015:30:0::1;::::0;::::1;;::::0;;;::::1;::::0;;68933:120::o;69061:94::-;11990:6;;-1:-1:-1;;;;;11990:6:0;10721:10;12137:23;12129:68;;;;-1:-1:-1;;;12129:68:0;;;;;;;:::i;:::-;69128:12:::1;:19:::0;;-1:-1:-1;;;;;;69128:19:0::1;-1:-1:-1::0;;;;;69128:19:0;;;::::1;::::0;;;::::1;::::0;;69061:94::o;65110:197::-;65164:17;;:::i;:::-;65212:12;964:14;65202:6;:32;;65194:66;;;;-1:-1:-1;;;65194:66:0;;;;;;;:::i;:::-;65278:21;65292:6;65278:13;:21::i;:::-;65271:28;65110:197;-1:-1:-1;;65110:197:0:o;64038:795::-;64093:5;64129:22;:12;964:14;;872:114;64129:22;64119:6;:32;;64111:66;;;;-1:-1:-1;;;64111:66:0;;;;;;;:::i;:::-;64215:10;64192:13;;;;:5;:13;;;;;;;;:19;;;;;;:33;;;;;;;:::i;:::-;;64188:83;;;-1:-1:-1;64249:10:0;;64038:795;-1:-1:-1;64038:795:0:o;64188:83::-;64346:13;;;;:5;:13;;;;;;;;;:20;;;;;64293:17;;;64320:21;;;;;64285:57;;-1:-1:-1;;;64285:57:0;;;;;15688:25:1;;;;-1:-1:-1;;;;;64346:20:0;;;;64293:17;;;64285:34;;15661:18:1;;64285:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;64285:81:0;;64281:135;;-1:-1:-1;64390:14:0;;64038:795;-1:-1:-1;64038:795:0:o;64281:135::-;64438:13;;;;:5;:13;;;;;;;:17;;;;64469:21;;;;;64430:61;;-1:-1:-1;;;64430:61:0;;;;;15688:25:1;;;;64503:4:0;;-1:-1:-1;;;;;64438:17:0;;;;64430:38;;15661:18:1;;64430:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;64430:78:0;;;:163;;;;-1:-1:-1;64521:13:0;;;;:5;:13;;;;;;;;;:17;;;;64557:20;;;64513:80;;-1:-1:-1;;;64513:80:0;;-1:-1:-1;;;;;64557:20:0;;;64513:80;;;5400:34:1;64587:4:0;5450:18:1;;;5443:43;64521:17:0;;;64513:43;;5335:18:1;;64513:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64512:81;64430:163;64426:217;;;-1:-1:-1;64617:14:0;;64038:795;-1:-1:-1;64038:795:0:o;64426:217::-;64680:12;64657:13;;;:5;:13;;;;;;;:19;;;;;;:35;;;;;;;:::i;:::-;;:84;;;;-1:-1:-1;64715:13:0;;;;:5;:13;;;;;:26;;;64696:15;:45;;64657:84;64653:136;;;-1:-1:-1;64765:12:0;;64038:795;-1:-1:-1;64038:795:0:o;64653:136::-;-1:-1:-1;64806:13:0;;;;:5;:13;;;;;:19;;;;;;64038:795::o;68822:103::-;11990:6;;-1:-1:-1;;;;;11990:6:0;10721:10;12137:23;12129:68;;;;-1:-1:-1;;;12129:68:0;;;;;;;:::i;:::-;68892:15:::1;:25:::0;;;::::1;;-1:-1:-1::0;;;68892:25:0::1;-1:-1:-1::0;;;;68892:25:0;;::::1;::::0;;;::::1;::::0;;68822:103::o;60124:119::-;3277:1;3875:7;;:19;;3867:63;;;;-1:-1:-1;;;3867:63:0;;;;;;;:::i;:::-;3277:1;4008:7;:18;60193:12:::1;::::0;;60186:49:::1;::::0;-1:-1:-1;;;60186:49:0;;60223:4:::1;60186:49:::0;;::::1;9042:51:1::0;;;;60230:4:0::1;9109:18:1::0;;;9102:34;-1:-1:-1;;;;;60193:12:0::1;::::0;60186:28:::1;::::0;9015:18:1;;60186:49:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;3233:1:0;4187:7;:22;60124:119::o;12568:103::-;11990:6;;-1:-1:-1;;;;;11990:6:0;10721:10;12137:23;12129:68;;;;-1:-1:-1;;;12129:68:0;;;;;;;:::i;:::-;12633:30:::1;12660:1;12633:18;:30::i;:::-;12568:103::o:0;63928:102::-;63973:7;64000:22;:12;964:14;;872:114;64000:22;63993:29;;63928:102;:::o;66155:840::-;66214:7;66252:22;:12;964:14;;872:114;66252:22;66242:6;:32;;66234:66;;;;-1:-1:-1;;;66234:66:0;;;;;;;:::i;:::-;66338:12;66315:13;;;:5;:13;;;;;;;:19;;;;;;:35;;;;;;;:::i;:::-;;66311:98;;-1:-1:-1;66374:13:0;;;;:5;:13;;;;;:23;;;;66155:840::o;66311:98::-;66441:13;;;;:5;:13;;;;;:26;;;66423:15;:44;;:79;;-1:-1:-1;66471:13:0;;;;:5;:13;;;;;:26;;;:31;66423:79;66419:146;;;-1:-1:-1;66526:13:0;;;;:5;:13;;;;;:27;;;;66155:840::o;66419:146::-;66575:20;66647:13;;;:5;:13;;;;;:26;;;;66617;;;;;66599:44;;:15;:44;:::i;:::-;66598:75;;;;:::i;:::-;:79;;66676:1;66598:79;:::i;:::-;66688:21;66712:13;;;:5;:13;;;;;:27;;;66575:102;;-1:-1:-1;66764:1:0;66750:134;66772:12;66767:1;:17;66750:134;;66838:13;;;;:5;:13;;;;;:26;;;66867:5;;66822:42;;:13;:42;:::i;:::-;:50;;;;:::i;:::-;66806:66;-1:-1:-1;66786:3:0;;;;:::i;:::-;;;;66750:134;;;-1:-1:-1;66918:13:0;;;;:5;:13;;;;;:25;;;66901:42;;;:86;;66962:13;;;;:5;:13;;;;;:25;;;66901:86;;;66946:13;66901:86;66894:93;66155:840;-1:-1:-1;;;;66155:840:0:o;67003:979::-;67066:7;67104:22;:12;964:14;;872:114;67104:22;67094:6;:32;;67086:66;;;;-1:-1:-1;;;67086:66:0;;;;;;;:::i;:::-;67190:12;67167:13;;;:5;:13;;;;;;;:19;;;;;;:35;;;;;;;:::i;:::-;;67163:101;;-1:-1:-1;67226:13:0;;;;:5;:13;;;;;:26;;;;67003:979::o;67163:101::-;67296:13;;;;:5;:13;;;;;:26;;;67278:15;:44;;:79;;-1:-1:-1;67326:13:0;;;;:5;:13;;;;;:26;;;:31;67278:79;67274:145;;;-1:-1:-1;67381:13:0;;;;:5;:13;;;;;:26;;;;67003:979::o;67274:145::-;67429:20;67501:13;;;:5;:13;;;;;:26;;;;67471;;;;;67453:44;;:15;:44;:::i;:::-;67452:75;;;;:::i;:::-;:79;;67530:1;67452:79;:::i;:::-;67542:21;67566:13;;;:5;:13;;;;;:27;;;;67619:26;;;;;67429:102;;-1:-1:-1;67566:27:0;67670:1;67656:297;67678:12;67673:1;:17;67656:297;;67733:13;;;;:5;:13;;;;;:25;;;67716:42;;67712:94;;-1:-1:-1;67786:4:0;67003:979;-1:-1:-1;;;;67003:979:0:o;67712:94::-;67852:13;;;;:5;:13;;;;;:26;;;67881:5;;67836:42;;:13;:42;:::i;:::-;:50;;;;:::i;:::-;67915:13;;;;:5;:13;;;;;:26;;;67820:66;;-1:-1:-1;67908:33:0;;:4;:33;:::i;:::-;67901:40;-1:-1:-1;67692:3:0;;;;:::i;:::-;;;;67656:297;;;-1:-1:-1;67970:4:0;67003:979;-1:-1:-1;;;;67003:979:0:o;62412:1508::-;3277:1;3875:7;;:19;;3867:63;;;;-1:-1:-1;;;3867:63:0;;;;;;;:::i;:::-;3277:1;4008:7;:18;;;964:14;62501:6:::1;:32;;62493:66;;;;-1:-1:-1::0;;;62493:66:0::1;;;;;;;:::i;:::-;62598:12;62578:16;62587:6;62578:8;:16::i;:::-;:32;;;;;;;;:::i;:::-;;62570:65;;;::::0;-1:-1:-1;;;62570:65:0;;13707:2:1;62570:65:0::1;::::0;::::1;13689:21:1::0;13746:2;13726:18;;;13719:30;-1:-1:-1;;;13765:18:1;;;13758:50;13825:18;;62570:65:0::1;13505:344:1::0;62570:65:0::1;62715:13;::::0;;;:5:::1;:13;::::0;;;;;;;;:20;;::::1;::::0;;62662:17;::::1;::::0;62689:21:::1;::::0;;::::1;::::0;62654:57;;-1:-1:-1;;;62654:57:0;;::::1;::::0;::::1;15688:25:1::0;;;;-1:-1:-1;;;;;62715:20:0;;::::1;::::0;62662:17;::::1;::::0;62654:34:::1;::::0;15661:18:1;;62654:57:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;62654:81:0::1;;62646:124;;;::::0;-1:-1:-1;;;62646:124:0;;14764:2:1;62646:124:0::1;::::0;::::1;14746:21:1::0;14803:2;14783:18;;;14776:30;14842:32;14822:18;;;14815:60;14892:18;;62646:124:0::1;14562:354:1::0;62646:124:0::1;62797:13;::::0;;;:5:::1;:13;::::0;;;;;;:17:::1;::::0;::::1;::::0;62828:21:::1;::::0;;::::1;::::0;62789:61;;-1:-1:-1;;;62789:61:0;;::::1;::::0;::::1;15688:25:1::0;;;;62862:4:0::1;::::0;-1:-1:-1;;;;;62797:17:0;;::::1;::::0;62789:38:::1;::::0;15661:18:1;;62789:61:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;62789:78:0::1;;:162;;;-1:-1:-1::0;62879:13:0::1;::::0;;;:5:::1;:13;::::0;;;;;;;;:17:::1;::::0;::::1;::::0;62915:20;::::1;::::0;62871:80;;-1:-1:-1;;;62871:80:0;;-1:-1:-1;;;;;62915:20:0;;::::1;62871:80;::::0;::::1;5400:34:1::0;62945:4:0::1;5450:18:1::0;;;5443:43;62879:17:0;::::1;::::0;62871:43:::1;::::0;5335:18:1;;62871:80:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62781:205;;;::::0;-1:-1:-1;;;62781:205:0;;14056:2:1;62781:205:0::1;::::0;::::1;14038:21:1::0;14095:2;14075:18;;;14068:30;14134:32;14114:18;;;14107:60;14184:18;;62781:205:0::1;13854:354:1::0;62781:205:0::1;63012:12;::::0;;63005:57:::1;::::0;-1:-1:-1;;;63005:57:0;;63036:10:::1;63005:57:::0;;::::1;5400:34:1::0;;;;63056:4:0::1;5450:18:1::0;;;5443:43;63066:7:0;;-1:-1:-1;;;;;63012:12:0;;::::1;::::0;63005:30:::1;::::0;5335:18:1;;63005:57:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:68;;62997:113;;;::::0;-1:-1:-1;;;62997:113:0;;11576:2:1;62997:113:0::1;::::0;::::1;11558:21:1::0;;;11595:18;;;11588:30;11654:34;11634:18;;;11627:62;11706:18;;62997:113:0::1;11374:356:1::0;62997:113:0::1;63123:13;63139:16;63148:6;63139:8;:16::i;:::-;63123:32;;63185:5;63174:7;:16;;63166:51;;;::::0;-1:-1:-1;;;63166:51:0;;11937:2:1;63166:51:0::1;::::0;::::1;11919:21:1::0;11976:2;11956:18;;;11949:30;-1:-1:-1;;;11995:18:1;;;11988:52;12057:18;;63166:51:0::1;11735:346:1::0;63166:51:0::1;63238:13;::::0;;;:5:::1;:13;::::0;;;;;;;;:17:::1;::::0;::::1;::::0;63270:20;;::::1;::::0;63304:21:::1;::::0;;::::1;::::0;63230:96;;-1:-1:-1;;;63230:96:0;;-1:-1:-1;;;;;63270:20:0;;::::1;63230:96;::::0;::::1;6871:34:1::0;63292:10:0::1;6921:18:1::0;;;6914:43;6973:18;;;6966:34;;;;63238:17:0::1;::::0;63230:39:::1;::::0;6806:18:1;;63230:96:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;63344:12:0::1;::::0;;::::1;63383:13:::0;;;:5:::1;:13;::::0;;;;;;;;:20:::1;::::0;63337:76;;-1:-1:-1;;;63337:76:0;;63371:10:::1;63337:76:::0;;::::1;6871:34:1::0;;;;-1:-1:-1;;;;;63383:20:0;;::::1;6921:18:1::0;;;6914:43;6973:18;;;6966:34;;;63344:12:0::1;::::0;-1:-1:-1;63337:33:0::1;::::0;-1:-1:-1;6806:18:1;;63337:76:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;63426:13:0::1;::::0;;;:5:::1;:13;::::0;;;;;;;;:19:::1;::::0;::::1;:41:::0;;63456:10:::1;-1:-1:-1::0;;;;;;63426:41:0;;::::1;::::0;::::1;::::0;;;63478:19:::1;::::0;::::1;:32:::0;;-1:-1:-1;;63478:32:0::1;63500:10;63478:32:::0;;::::1;::::0;;;63521:23:::1;::::0;::::1;:33:::0;;;63590:15:::1;63565:22;::::0;::::1;:40:::0;;;63705:21;;::::1;::::0;-1:-1:-1;63673:17:0;::::1;::::0;63741:20;;;::::1;::::0;63623:285;;63705:21;;-1:-1:-1;;;;;63673:17:0;;::::1;::::0;63426:13;;63623:285:::1;::::0;::::1;::::0;63741:20;;;::::1;::::0;63521:33;;63623:285:::1;:::i;:::-;;;;;;;;-1:-1:-1::0;;3233:1:0;4187:7;:22;-1:-1:-1;62412:1508:0:o;67990:593::-;68052:19;68084:14;68127:1;68113:141;68135:14;:12;:14::i;:::-;68130:1;:19;68113:141;;68190:5;68175:20;;;;;;;;:::i;:::-;:11;68184:1;68175:8;:11::i;:::-;:20;;;;;;;;:::i;:::-;;68171:72;;;68216:11;;;;:::i;:::-;;;;68171:72;68151:3;;;;:::i;:::-;;;;68113:141;;;;68266:10;68291:28;68339:9;68322:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;68291:58:0;-1:-1:-1;68374:1:0;68360:190;68382:14;:12;:14::i;:::-;68377:1;:19;68360:190;;68437:5;68422:20;;;;;;;;:::i;:::-;:11;68431:1;68422:8;:11::i;:::-;:20;;;;;;;;:::i;:::-;;68418:121;;;68481:16;68495:1;68481:13;:16::i;:::-;68463:8;68472:5;68463:15;;;;;;;;:::i;:::-;;;;;;:34;;;;68516:7;;;;;:::i;:::-;;;;68418:121;68398:3;;;;:::i;:::-;;;;68360:190;;65315:832;65370:7;65408:22;:12;964:14;;872:114;65408:22;65398:6;:32;;65390:66;;;;-1:-1:-1;;;65390:66:0;;;;;;;:::i;:::-;65494:12;65471:13;;;:5;:13;;;;;;;:19;;;;;;:35;;;;;;;:::i;:::-;;65467:98;;-1:-1:-1;65530:13:0;;;;:5;:13;;;;;:23;;;;65315:832::o;65467:98::-;65597:13;;;;:5;:13;;;;;:26;;;65579:15;:44;;:79;;-1:-1:-1;65627:13:0;;;;:5;:13;;;;;:26;;;:31;65579:79;65575:146;;;-1:-1:-1;65682:13:0;;;;:5;:13;;;;;:27;;;;65315:832::o;65575:146::-;65731:20;65803:13;;;:5;:13;;;;;:26;;;;65773;;;;;65755:44;;:15;:44;:::i;:::-;65754:75;;;;:::i;:::-;65840:21;65864:13;;;:5;:13;;;;;:27;;;65731:98;;-1:-1:-1;65916:1:0;65902:134;65924:12;65919:1;:17;65902:134;;65990:13;;;;:5;:13;;;;;:26;;;66019:5;;65974:42;;:13;:42;:::i;:::-;:50;;;;:::i;:::-;65958:66;-1:-1:-1;65938:3:0;;;;:::i;:::-;;;;65902:134;;59927:139;3277:1;3875:7;;:19;;3867:63;;;;-1:-1:-1;;;3867:63:0;;;;;;;:::i;:::-;3277:1;4008:7;:18;60007:51:::1;::::0;-1:-1:-1;;;60007:51:0;;60046:4:::1;60007:51;::::0;::::1;8711::1::0;60053:4:0::1;8778:18:1::0;;;8771:50;-1:-1:-1;;;;;60007:30:0;::::1;::::0;::::1;::::0;8684:18:1;;60007:51:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;3233:1:0;4187:7;:22;-1:-1:-1;;;59927:139:0:o;12826:201::-;11990:6;;-1:-1:-1;;;;;11990:6:0;10721:10;12137:23;12129:68;;;;-1:-1:-1;;;12129:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;12915:22:0;::::1;12907:73;;;::::0;-1:-1:-1;;;12907:73:0;;10811:2:1;12907:73:0::1;::::0;::::1;10793:21:1::0;10850:2;10830:18;;;10823:30;10889:34;10869:18;;;10862:62;-1:-1:-1;;;10940:18:1;;;10933:36;10986:19;;12907:73:0::1;10609:402:1::0;12907:73:0::1;12991:28;13010:8;12991:18;:28::i;:::-;12826:201:::0;:::o;64841:261::-;64903:17;;:::i;:::-;64940:154;;;-1:-1:-1;64965:13:0;;;:5;:13;;;;;;;;64940:154;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;64940:154:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64965:13;;64940:154;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;-1:-1:-1;64940:154:0;;;;64993:16;65002:6;64993:8;:16::i;:::-;64940:154;;;;65024:20;65037:6;65024:12;:20::i;:::-;64940:154;;;;65059:24;65076:6;65059:16;:24::i;:::-;64940:154;;64933:161;64841:261;-1:-1:-1;;64841:261:0:o;13187:191::-;13280:6;;;-1:-1:-1;;;;;13297:17:0;;;-1:-1:-1;;;;;;13297:17:0;;;;;;;13330:40;;13280:6;;;13297:17;13280:6;;13330:40;;13261:16;;13330:40;13250:128;13187:191;:::o;-1:-1:-1:-;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::o;14:146:1:-;85:20;;134:1;124:12;;114:40;;150:1;147;140:12;114:40;14:146;;;:::o;165:247::-;224:6;277:2;265:9;256:7;252:23;248:32;245:52;;;293:1;290;283:12;245:52;332:9;319:23;351:31;376:5;351:31;:::i;:::-;401:5;165:247;-1:-1:-1;;;165:247:1:o;417:251::-;487:6;540:2;528:9;519:7;515:23;511:32;508:52;;;556:1;553;546:12;508:52;588:9;582:16;607:31;632:5;607:31;:::i;673:382::-;738:6;746;799:2;787:9;778:7;774:23;770:32;767:52;;;815:1;812;805:12;767:52;854:9;841:23;873:31;898:5;873:31;:::i;:::-;923:5;-1:-1:-1;980:2:1;965:18;;952:32;993:30;952:32;993:30;:::i;:::-;1042:7;1032:17;;;673:382;;;;;:::o;1060:659::-;1173:6;1181;1189;1197;1205;1213;1221;1274:3;1262:9;1253:7;1249:23;1245:33;1242:53;;;1291:1;1288;1281:12;1242:53;1330:9;1317:23;1349:31;1374:5;1349:31;:::i;:::-;1399:5;1451:2;1436:18;;1423:32;;-1:-1:-1;1502:2:1;1487:18;;1474:32;;1553:2;1538:18;;1525:32;;-1:-1:-1;1604:3:1;1589:19;;1576:33;;-1:-1:-1;1656:3:1;1641:19;;1628:33;;-1:-1:-1;1708:3:1;1693:19;1680:33;;-1:-1:-1;1060:659:1;-1:-1:-1;;;1060:659:1:o;1724:241::-;1780:6;1833:2;1821:9;1812:7;1808:23;1804:32;1801:52;;;1849:1;1846;1839:12;1801:52;1888:9;1875:23;1907:28;1929:5;1907:28;:::i;1970:245::-;2037:6;2090:2;2078:9;2069:7;2065:23;2061:32;2058:52;;;2106:1;2103;2096:12;2058:52;2138:9;2132:16;2157:28;2179:5;2157:28;:::i;2220:199::-;2289:6;2342:2;2330:9;2321:7;2317:23;2313:32;2310:52;;;2358:1;2355;2348:12;2310:52;2381:32;2403:9;2381:32;:::i;2424:180::-;2483:6;2536:2;2524:9;2515:7;2511:23;2507:32;2504:52;;;2552:1;2549;2542:12;2504:52;-1:-1:-1;2575:23:1;;2424:180;-1:-1:-1;2424:180:1:o;2609:184::-;2679:6;2732:2;2720:9;2711:7;2707:23;2703:32;2700:52;;;2748:1;2745;2738:12;2700:52;-1:-1:-1;2771:16:1;;2609:184;-1:-1:-1;2609:184:1:o;2798:267::-;2876:6;2884;2937:2;2925:9;2916:7;2912:23;2908:32;2905:52;;;2953:1;2950;2943:12;2905:52;2989:9;2976:23;2966:33;;3018:41;3055:2;3044:9;3040:18;3018:41;:::i;:::-;3008:51;;2798:267;;;;;:::o;3070:248::-;3138:6;3146;3199:2;3187:9;3178:7;3174:23;3170:32;3167:52;;;3215:1;3212;3205:12;3167:52;-1:-1:-1;;3238:23:1;;;3308:2;3293:18;;;3280:32;;-1:-1:-1;3070:248:1:o;3440:233::-;3517:1;3510:5;3507:12;3497:143;;3562:10;3557:3;3553:20;3550:1;3543:31;3597:4;3594:1;3587:15;3625:4;3622:1;3615:15;3497:143;3649:18;;3440:233::o;3678:1289::-;3758:5;3752:12;3791:2;3785:9;3780:3;3773:22;3838:4;3834:2;3830:13;3824:20;3853:56;3903:4;3898:3;3894:14;3880:12;-1:-1:-1;;;;;3397:31:1;3385:44;;3323:112;3853:56;;3955:4;3951:2;3947:13;3941:20;3934:4;3929:3;3925:14;3918:44;4007:4;4003:2;3999:13;3993:20;4022:58;4074:4;4069:3;4065:14;4049;-1:-1:-1;;;;;3397:31:1;3385:44;;3323:112;4022:58;;4125:4;4121:2;4117:13;4111:20;4140:58;4192:4;4187:3;4183:14;4167;-1:-1:-1;;;;;3397:31:1;3385:44;;3323:112;4140:58;-1:-1:-1;4244:4:1;4236:13;;;4230:20;4214:14;;;4207:44;4297:4;4289:13;;;4283:20;4267:14;;;4260:44;4350:4;4342:13;;;4336:20;4320:14;;;4313:44;4376:6;4418:11;;;4412:18;4398:12;;;4391:40;4450:6;4492:11;;;4486:18;4472:12;;;4465:40;4524:6;4566:11;;;4560:18;4546:12;;;4539:40;4598:6;4640:11;;;4634:18;4620:12;;;4613:40;4672:6;4715:11;;;4709:18;;4736:51;4774:12;;;4709:18;4736:51;:::i;:::-;-1:-1:-1;;4838:4:1;4827:16;;4821:23;4812:6;4803:16;;4796:49;4896:4;4885:16;;4879:23;4870:6;4861:16;;4854:49;4954:4;4943:16;4937:23;4928:6;4919:16;;;4912:49;3678:1289::o;5497:558::-;-1:-1:-1;;;;;5836:15:1;;;5818:34;;5888:15;;5883:2;5868:18;;5861:43;5935:2;5920:18;;5913:34;;;5767:3;5752:19;;5956:49;6001:2;5986:18;;5978:6;5956:49;:::i;:::-;6042:6;6036:3;6025:9;6021:19;6014:35;5497:558;;;;;;;;:::o;7708:830::-;-1:-1:-1;;;;;8143:15:1;;;8125:34;;8195:15;;8190:2;8175:18;;8168:43;8242:2;8227:18;;8220:34;;;8285:2;8270:18;;8263:34;;;8328:3;8313:19;;8306:35;;;8105:3;8357:19;;8350:35;;;8416:3;8401:19;;8394:35;;;8074:3;8059:19;;8438:50;8483:3;8468:19;;8460:6;8438:50;:::i;:::-;8525:6;8519:3;8508:9;8504:19;8497:35;7708:830;;;;;;;;;;;;:::o;9147:714::-;9374:2;9426:21;;;9496:13;;9399:18;;;9518:22;;;9345:4;;9374:2;9597:15;;;;9571:2;9556:18;;;9345:4;9640:195;9654:6;9651:1;9648:13;9640:195;;;9703:48;9747:3;9738:6;9732:13;9703:48;:::i;:::-;9810:15;;;;9780:6;9771:16;;;;;9676:1;9669:9;9640:195;;;-1:-1:-1;9852:3:1;;9147:714;-1:-1:-1;;;;;;9147:714:1:o;10058:200::-;10200:2;10185:18;;10212:40;10189:9;10234:6;10212:40;:::i;12794:345::-;12996:2;12978:21;;;13035:2;13015:18;;;13008:30;-1:-1:-1;;;13069:2:1;13054:18;;13047:51;13130:2;13115:18;;12794:345::o;13144:356::-;13346:2;13328:21;;;13365:18;;;13358:30;13424:34;13419:2;13404:18;;13397:62;13491:2;13476:18;;13144:356::o;14921:355::-;15123:2;15105:21;;;15162:2;15142:18;;;15135:30;15201:33;15196:2;15181:18;;15174:61;15267:2;15252:18;;14921:355::o;15281:256::-;15471:3;15456:19;;15484:47;15460:9;15513:6;15484:47;:::i;15724:128::-;15764:3;15795:1;15791:6;15788:1;15785:13;15782:39;;;15801:18;;:::i;:::-;-1:-1:-1;15837:9:1;;15724:128::o;15857:217::-;15897:1;15923;15913:132;;15967:10;15962:3;15958:20;15955:1;15948:31;16002:4;15999:1;15992:15;16030:4;16027:1;16020:15;15913:132;-1:-1:-1;16059:9:1;;15857:217::o;16079:168::-;16119:7;16185:1;16181;16177:6;16173:14;16170:1;16167:21;16162:1;16155:9;16148:17;16144:45;16141:71;;;16192:18;;:::i;:::-;-1:-1:-1;16232:9:1;;16079:168::o;16252:125::-;16292:4;16320:1;16317;16314:8;16311:34;;;16325:18;;:::i;:::-;-1:-1:-1;16362:9:1;;16252:125::o;16382:135::-;16421:3;-1:-1:-1;;16442:17:1;;16439:43;;;16462:18;;:::i;:::-;-1:-1:-1;16509:1:1;16498:13;;16382:135::o;16522:127::-;16583:10;16578:3;16574:20;16571:1;16564:31;16614:4;16611:1;16604:15;16638:4;16635:1;16628:15;16654:127;16715:10;16710:3;16706:20;16703:1;16696:31;16746:4;16743:1;16736:15;16770:4;16767:1;16760:15;16786:127;16847:10;16842:3;16838:20;16835:1;16828:31;16878:4;16875:1;16868:15;16902:4;16899:1;16892:15;16918:127;16979:10;16974:3;16970:20;16967:1;16960:31;17010:4;17007:1;17000:15;17034:4;17031:1;17024:15;17050:131;-1:-1:-1;;;;;17125:31:1;;17115:42;;17105:70;;17171:1;17168;17161:12;17186:118;17272:5;17265:13;17258:21;17251:5;17248:32;17238:60;;17294:1;17291;17284:12

ipfs://ae2b129f7866551ecceb48429b40b1418ccaa1833f081bb4a317414dfd71226a