Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at moonbeam.moonscan.io on 2025-04-22
*/

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

// SPDX-License-Identifier: MIT

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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)

pragma solidity ^0.8.20;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    /**
     * @dev The `account` is missing a role.
     */
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);

    /**
     * @dev The caller of a function is not the expected one.
     *
     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
     */
    error AccessControlBadConfirmation();

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     */
    function renounceRole(bytes32 role, address callerConfirmation) external;
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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/utils/introspection/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @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/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

/**
 * @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);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)

pragma solidity ^0.8.20;



/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```solidity
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```solidity
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address account => bool) hasRole;
        bytes32 adminRole;
    }

    mapping(bytes32 role => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with an {AccessControlUnauthorizedAccount} error including the required role.
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

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

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual returns (bool) {
        return _roles[role].hasRole[account];
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
     * is missing `role`.
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert AccessControlUnauthorizedAccount(account, role);
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address callerConfirmation) public virtual {
        if (callerConfirmation != _msgSender()) {
            revert AccessControlBadConfirmation();
        }

        _revokeRole(role, callerConfirmation);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
        if (!hasRole(role, account)) {
            _roles[role].hasRole[account] = true;
            emit RoleGranted(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
        if (hasRole(role, account)) {
            _roles[role].hasRole[account] = false;
            emit RoleRevoked(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

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

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

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


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

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

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


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;



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

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

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

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.20;

/**
 * @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`.
     *
     * 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;

    /**
     * @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 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 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 address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

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

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


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.20;

/**
 * @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/[email protected]

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.20;

/**
 * @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 `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

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

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

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

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

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

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

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)

pragma solidity ^0.8.20;


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

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

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

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toStringSigned(int256 value) internal pure returns (string memory) {
        return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
    }

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        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_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        return string(buffer);
    }

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

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.20;







/**
 * @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}.
 */
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    mapping(uint256 tokenId => address) private _owners;

    mapping(address owner => uint256) private _balances;

    mapping(uint256 tokenId => address) private _tokenApprovals;

    mapping(address owner => mapping(address operator => 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 returns (uint256) {
        if (owner == address(0)) {
            revert ERC721InvalidOwner(address(0));
        }
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual returns (address) {
        return _requireOwned(tokenId);
    }

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
        _requireOwned(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string.concat(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 {
        _approve(to, tokenId, _msgSender());
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual returns (address) {
        _requireOwned(tokenId);

        return _getApproved(tokenId);
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        address previousOwner = _update(to, tokenId, _msgSender());
        if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
        transferFrom(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     *
     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
     * core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances
     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
     */
    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
     * particular (ignoring whether it is owned by `owner`).
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
        return
            spender != address(0) &&
            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
    }

    /**
     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
     * Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets
     * the `spender` for the specific `tokenId`.
     *
     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
     * assumption.
     */
    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
        if (!_isAuthorized(owner, spender, tokenId)) {
            if (owner == address(0)) {
                revert ERC721NonexistentToken(tokenId);
            } else {
                revert ERC721InsufficientApproval(spender, tokenId);
            }
        }
    }

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
     *
     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
     * remain consistent with one another.
     */
    function _increaseBalance(address account, uint128 value) internal virtual {
        unchecked {
            _balances[account] += value;
        }
    }

    /**
     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
     *
     * Emits a {Transfer} event.
     *
     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
        address from = _ownerOf(tokenId);

        // Perform (optional) operator check
        if (auth != address(0)) {
            _checkAuthorized(from, auth, tokenId);
        }

        // Execute the update
        if (from != address(0)) {
            // Clear approval. No need to re-authorize or emit the Approval event
            _approve(address(0), tokenId, address(0), false);

            unchecked {
                _balances[from] -= 1;
            }
        }

        if (to != address(0)) {
            unchecked {
                _balances[to] += 1;
            }
        }

        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        return from;
    }

    /**
     * @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 {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner != address(0)) {
            revert ERC721InvalidSender(address(0));
        }
    }

    /**
     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
     *
     * 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 {
        _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);
        _checkOnERC721Received(address(0), to, tokenId, data);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal {
        address previousOwner = _update(address(0), tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(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 {
        if (to == address(0)) {
            revert ERC721InvalidReceiver(address(0));
        }
        address previousOwner = _update(to, tokenId, address(0));
        if (previousOwner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        } else if (previousOwner != from) {
            revert ERC721IncorrectOwner(from, tokenId, previousOwner);
        }
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
     * are aware of the ERC721 standard 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 like {safeTransferFrom} in the sense that it invokes
     * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `tokenId` token must exist and be owned by `from`.
     * - `to` cannot be the zero address.
     * - `from` cannot be the zero address.
     * - 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) internal {
        _safeTransfer(from, to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        _checkOnERC721Received(from, to, tokenId, data);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
     * either the owner of the token, or approved to operate on all tokens held by this owner.
     *
     * Emits an {Approval} event.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address to, uint256 tokenId, address auth) internal {
        _approve(to, tokenId, auth, true);
    }

    /**
     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
     * emitted in the context of transfers.
     */
    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
        // Avoid reading the owner unless necessary
        if (emitEvent || auth != address(0)) {
            address owner = _requireOwned(tokenId);

            // We do not use _isAuthorized because single-token approvals should not be able to call approve
            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
                revert ERC721InvalidApprover(auth);
            }

            if (emitEvent) {
                emit Approval(owner, to, tokenId);
            }
        }

        _tokenApprovals[tokenId] = to;
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Requirements:
     * - operator can't be the address zero.
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        if (operator == address(0)) {
            revert ERC721InvalidOperator(operator);
        }
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
     * Returns the owner.
     *
     * Overrides to ownership logic should be done to {_ownerOf}.
     */
    function _requireOwned(uint256 tokenId) internal view returns (address) {
        address owner = _ownerOf(tokenId);
        if (owner == address(0)) {
            revert ERC721NonexistentToken(tokenId);
        }
        return owner;
    }

    /**
     * @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the
     * recipient doesn't accept the token transfer. 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
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {
        if (to.code.length > 0) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                if (retval != IERC721Receiver.onERC721Received.selector) {
                    revert ERC721InvalidReceiver(to);
                }
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert ERC721InvalidReceiver(to);
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        }
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Burnable.sol)

pragma solidity ^0.8.20;


/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
        _update(address(0), tokenId, _msgSender());
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.20;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.20;



/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds enumerability
 * of all the token ids in the contract as well as all token ids owned by each account.
 *
 * CAUTION: `ERC721` extensions that implement custom `balanceOf` logic, such as `ERC721Consecutive`,
 * interfere with enumerability and should not be used together with `ERC721Enumerable`.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    mapping(address owner => mapping(uint256 index => uint256)) private _ownedTokens;
    mapping(uint256 tokenId => uint256) private _ownedTokensIndex;

    uint256[] private _allTokens;
    mapping(uint256 tokenId => uint256) private _allTokensIndex;

    /**
     * @dev An `owner`'s token query was out of bounds for `index`.
     *
     * NOTE: The owner being `address(0)` indicates a global out of bounds index.
     */
    error ERC721OutOfBoundsIndex(address owner, uint256 index);

    /**
     * @dev Batch mint is not allowed.
     */
    error ERC721EnumerableForbiddenBatchMint();

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256) {
        if (index >= balanceOf(owner)) {
            revert ERC721OutOfBoundsIndex(owner, index);
        }
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual returns (uint256) {
        if (index >= totalSupply()) {
            revert ERC721OutOfBoundsIndex(address(0), index);
        }
        return _allTokens[index];
    }

    /**
     * @dev See {ERC721-_update}.
     */
    function _update(address to, uint256 tokenId, address auth) internal virtual override returns (address) {
        address previousOwner = super._update(to, tokenId, auth);

        if (previousOwner == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (previousOwner != to) {
            _removeTokenFromOwnerEnumeration(previousOwner, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (previousOwner != to) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }

        return previousOwner;
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = balanceOf(to) - 1;
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = balanceOf(from);
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }

    /**
     * See {ERC721-_increaseBalance}. We need that to account tokens that were minted in batch
     */
    function _increaseBalance(address account, uint128 amount) internal virtual override {
        if (amount > 0) {
            revert ERC721EnumerableForbiddenBatchMint();
        }
        super._increaseBalance(account, amount);
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}


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

// Original license: SPDX_License_Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721Pausable.sol)

pragma solidity ^0.8.20;


/**
 * @dev ERC721 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 *
 * IMPORTANT: This contract does not include public pause and unpause functions. In
 * addition to inheriting this contract, you must define both functions, invoking the
 * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate
 * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will
 * make the contract pause mechanism of the contract unreachable, and thus unusable.
 */
abstract contract ERC721Pausable is ERC721, Pausable {
    /**
     * @dev See {ERC721-_update}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _update(
        address to,
        uint256 tokenId,
        address auth
    ) internal virtual override whenNotPaused returns (address) {
        return super._update(to, tokenId, auth);
    }
}


// File contracts/Moonbeam-OlderfallFallens.sol

// Original license: SPDX_License_Identifier: MIT
pragma solidity ^0.8.24;
contract OlderfallFallens is ERC721, ERC721Pausable, ERC721Burnable, ERC721Enumerable, AccessControl {
	using SafeERC20 for IERC20Metadata;

	uint256 public tokenIdCounter;

	struct FallenDNAs {
		uint168 dnaAppearance;
		uint32 dnaIdentity;
		uint56 dnaMetadata;
	}

	mapping(uint256 => FallenDNAs) public dnas;
	mapping(uint256 => uint64) public dateCreation;

	IERC20Metadata public erc20Token;
	uint8 public erc20TokenDecimals;

	uint64 public startDate;
	uint256 private firstPrice;
	uint256 private secondPrice;
	uint32 private tokenLimitPrice;

	uint32 public tokenPurchaseLimit;
	uint32 public tokenDropLimit;

	uint32 public purchasedTokensMinted = 0;
	uint32 public droppedTokensMinted = 0;

	bool public isFallenMintingAllowed = true;
	bool public isFallenPurchaseAllowed = false;
	bool public isFallenDropAllowed = true;

	string private fallenTokenUri;
	string private contractUri;

	bytes32 public constant DNA_UPDATER_ROLE = keccak256("DNA_UPDATER_ROLE");
	bytes32 public constant TOKEN_DROPPER_ROLE = keccak256("TOKEN_DROPPER_ROLE");

	constructor(
		uint64 _startDate,
		uint256 _firstPrice,
		uint256 _secondPrice,
		uint32 _tokenLimitPrice,
		uint32 _tokenPurchaseLimit,
		uint32 _tokenDropLimit,
		address _initialOwner,
		address _erc20TokenAddress
	) ERC721("Olderfall Fallens - Moonbeam Collection", "FALLEN") {
		_grantRole(DEFAULT_ADMIN_ROLE, _initialOwner);
		_grantRole(DNA_UPDATER_ROLE, _initialOwner);
		_grantRole(TOKEN_DROPPER_ROLE, _initialOwner);
		setStartDate(_startDate);
		setFallenFirstPurchasePrice(_firstPrice);
		setFallenSecondPurchasePrice(_secondPrice);
		setTokenLimitPrice(_tokenLimitPrice);
		setTokenPurchaseLimit(_tokenPurchaseLimit);
		setTokenDropLimit(_tokenDropLimit);
		setERC20Token(_erc20TokenAddress);
	}

	//onlyRole(DEFAULT_ADMIN_ROLE) Functions

	function setStartDate(uint64 _startDate) public onlyRole(DEFAULT_ADMIN_ROLE) {
		startDate = _startDate;
	}

	function setTokenPurchaseLimit(uint32 _tokenPurchaseLimit) public onlyRole(DEFAULT_ADMIN_ROLE) {
		require(_tokenPurchaseLimit >= purchasedTokensMinted, "Value cannot be less than the number of tokens purchased");
		tokenPurchaseLimit = _tokenPurchaseLimit;
	}

	function setTokenDropLimit(uint32 _tokenDropLimit) public onlyRole(DEFAULT_ADMIN_ROLE) {
		require(_tokenDropLimit > droppedTokensMinted, "Value cannot be less than the number of tokens dropped");
		tokenDropLimit = _tokenDropLimit;
	}

	function setFallenTokenURI(string memory _newuri) public onlyRole(DEFAULT_ADMIN_ROLE) {
		fallenTokenUri = _newuri;
	}

	  function setContractURI(string memory _newuri) public onlyRole(DEFAULT_ADMIN_ROLE) {
		contractUri = _newuri;
	}

	function pause() public onlyRole(DEFAULT_ADMIN_ROLE) {
		_pause();
	}

	function unpause() public onlyRole(DEFAULT_ADMIN_ROLE) {
		_unpause();
	}

	function reclaimBalance(address _withdrawalAccount) external onlyRole(DEFAULT_ADMIN_ROLE) {
		erc20Token.safeTransfer(_withdrawalAccount, erc20Token.balanceOf(address(this)));
	}

	function setDnas(uint256 _tokenId, uint168 _dnaAppearance, uint32 _dnaIdentity, uint56 _dnaMetadata) external {
		require(hasRole(DNA_UPDATER_ROLE, msg.sender), "Only the owner and the authorized address can update the Dnas");
		require(_dnaAppearance > 0, "Dna Appearance must be greater than zero");
		require(_dnaIdentity > 0, "Dna Identity must be greater than zero");
		require(_dnaMetadata > 0, "Dna Metadata must be greater than zero");
		dnas[_tokenId].dnaAppearance = _dnaAppearance;
		dnas[_tokenId].dnaIdentity = _dnaIdentity;
		dnas[_tokenId].dnaMetadata = _dnaMetadata;
	}

	function toggleFallenMintingStatus() public onlyRole(DEFAULT_ADMIN_ROLE) {
		isFallenMintingAllowed = !isFallenMintingAllowed;
	}

	function toggleFallenPurchaseStatus() public onlyRole(DEFAULT_ADMIN_ROLE) {
		isFallenPurchaseAllowed = !isFallenPurchaseAllowed;
	}

	function toggleFallenDropStatus() public onlyRole(DEFAULT_ADMIN_ROLE) {
		isFallenDropAllowed = !isFallenDropAllowed;
	}

	function setFallenFirstPurchasePrice(uint256 _firstPrice) public onlyRole(DEFAULT_ADMIN_ROLE) {
		require(_firstPrice > 0, "Price must be more than zero");
		firstPrice = _firstPrice;
	}

	function setFallenSecondPurchasePrice(uint256 _secondPrice) public onlyRole(DEFAULT_ADMIN_ROLE) {
		require(_secondPrice > 0, "Price must be more than zero");
		secondPrice = _secondPrice;
	}

	function setTokenLimitPrice(uint32 _tokenLimitPrice) public onlyRole(DEFAULT_ADMIN_ROLE) {
		tokenLimitPrice = _tokenLimitPrice;
	}

	function setERC20Token(address _erc20TokenAddress) public onlyRole(DEFAULT_ADMIN_ROLE) {
		erc20Token = IERC20Metadata(_erc20TokenAddress);
		erc20TokenDecimals = erc20Token.decimals();
	}

	//Get Token Price

	function getCurrentPrice() public view returns (uint256 price) {
		return
			purchasedTokensMinted < tokenLimitPrice ? calculateExponent(firstPrice, 10, erc20TokenDecimals) : calculateExponent(secondPrice, 10, erc20TokenDecimals);
	}

	//Get Token Limit

	function getTokenLimit() public view returns (uint256 tokenLimit) {
		return tokenDropLimit + tokenPurchaseLimit;
	}

	//Get Data Functions from Tokens

	function getTokenIds(address _owner) public view returns (uint256[] memory) {
		uint256 i;
		uint256 balanceOfOwner = ERC721.balanceOf(_owner);
		uint256[] memory _tokensOfOwner = new uint256[](balanceOfOwner);

		for (i = 0; i < balanceOfOwner; i++) {
			_tokensOfOwner[i] = tokenOfOwnerByIndex(_owner, i);
		}

		return _tokensOfOwner;
	}

	function getDnas(uint256 _tokenId) public view returns (FallenDNAs memory) {
		return dnas[_tokenId];
	}

	function getDnasArray(uint256[] memory _tokenIdArray) public view returns (FallenDNAs[] memory) {
		require(_tokenIdArray.length <= 100, "Array exceeds maximum length of 100");

		FallenDNAs[] memory fallenDNAs = new FallenDNAs[](_tokenIdArray.length);

		for (uint i = 0; i < _tokenIdArray.length; i++) {
			FallenDNAs memory _dna = dnas[_tokenIdArray[i]];
			fallenDNAs[i] = _dna;
		}

		return (fallenDNAs);
	}

	function getNumberOfTokensCreated() public view returns (uint256) {
		return tokenIdCounter;
	}

	function tokenURI(uint256 _tokenId) public view override returns (string memory) {
		return string(abi.encodePacked(fallenTokenUri, Strings.toString(_tokenId)));
	}

	function contractURI() public view returns (string memory) {
		return contractUri;
	}

	// The following functions are overrides required by Solidity.

	function _update(address to, uint256 tokenId, address auth) internal override(ERC721, ERC721Pausable, ERC721Enumerable) returns (address) {
		return super._update(to, tokenId, auth);
	}

	function supportsInterface(bytes4 _interfaceId) public view override(ERC721, ERC721Enumerable, AccessControl) returns (bool) {
		return super.supportsInterface(_interfaceId);
	}

	function _increaseBalance(address account, uint128 value) internal override(ERC721, ERC721Enumerable) {
		super._increaseBalance(account, value);
	}

	//Mint Functions

	function safeMint(address _to) private returns (uint256) {
		require(isFallenMintingAllowed == true, "Minting is not longer allowed");
		uint256 tokenId = tokenIdCounter;
		dateCreation[tokenId] = uint64(block.timestamp);
		tokenIdCounter += 1;
		_safeMint(_to, tokenId);
		return tokenId;
	}

	function buyToken() public returns (uint256) {
		require(block.timestamp >= startDate, "Purchases are not available");
		require(getTokenLimit() > tokenIdCounter, "All tokens have been minted");
		require(tokenPurchaseLimit > purchasedTokensMinted, "All tokens have been minted");
		require(isFallenPurchaseAllowed == true, "Purchases are not longer allowed");
		erc20Token.safeTransferFrom(msg.sender, address(this), getCurrentPrice());
		uint256 tokenId = safeMint(msg.sender);
		purchasedTokensMinted++;
		return tokenId;
	}

	function dropToken(address _to) public returns (uint256) {
		require(hasRole(TOKEN_DROPPER_ROLE, msg.sender), "Only the owner and the authorized address can drop tokens");
		require(block.timestamp >= startDate, "Drops are not available");
		require(getTokenLimit() > tokenIdCounter, "All tokens have been minted");
		require(tokenDropLimit > droppedTokensMinted, "All tokens have been minted");
		require(isFallenDropAllowed == true, "Drops are not longer allowed");
		uint256 tokenId = safeMint(_to);
		droppedTokensMinted++;
		return tokenId;
	}

	function dropTokens(address _to, uint256 _quantity) public returns (uint256[] memory) {
		require(hasRole(TOKEN_DROPPER_ROLE, msg.sender), "Only the owner and the authorized address can drop tokens");
		require(block.timestamp >= startDate, "Drops are not available");
		require(getTokenLimit() > tokenIdCounter, "All tokens have been minted");
		require(tokenDropLimit > droppedTokensMinted, "All tokens have been minted");
		require(isFallenDropAllowed == true, "Drops are not longer allowed");
		require(getTokenLimit() >= (tokenIdCounter + _quantity), "There are not enough tokens to mint");
		require(tokenDropLimit >= (droppedTokensMinted + _quantity), "There are not enough tokens to mint");

		uint256[] memory _tokenIds = new uint256[](_quantity);

		for (uint256 i = 0; i < _quantity; i++) {
			uint256 _tokenId = safeMint(_to);
			droppedTokensMinted++;
			_tokenIds[i] = _tokenId;
		}

		return _tokenIds;
	}

	//Utils

	function calculateExponent(uint256 _value, uint256 _base, uint256 _exponent) private pure returns (uint256 priceOnWei) {
		return _value * _base ** (_exponent);
	}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint64","name":"_startDate","type":"uint64"},{"internalType":"uint256","name":"_firstPrice","type":"uint256"},{"internalType":"uint256","name":"_secondPrice","type":"uint256"},{"internalType":"uint32","name":"_tokenLimitPrice","type":"uint32"},{"internalType":"uint32","name":"_tokenPurchaseLimit","type":"uint32"},{"internalType":"uint32","name":"_tokenDropLimit","type":"uint32"},{"internalType":"address","name":"_initialOwner","type":"address"},{"internalType":"address","name":"_erc20TokenAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"ERC721EnumerableForbiddenBatchMint","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"ERC721OutOfBoundsIndex","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DNA_UPDATER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_DROPPER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"buyToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"dateCreation","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"dnas","outputs":[{"internalType":"uint168","name":"dnaAppearance","type":"uint168"},{"internalType":"uint32","name":"dnaIdentity","type":"uint32"},{"internalType":"uint56","name":"dnaMetadata","type":"uint56"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"dropToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"dropTokens","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"droppedTokensMinted","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc20Token","outputs":[{"internalType":"contract IERC20Metadata","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc20TokenDecimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentPrice","outputs":[{"internalType":"uint256","name":"price","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getDnas","outputs":[{"components":[{"internalType":"uint168","name":"dnaAppearance","type":"uint168"},{"internalType":"uint32","name":"dnaIdentity","type":"uint32"},{"internalType":"uint56","name":"dnaMetadata","type":"uint56"}],"internalType":"struct OlderfallFallens.FallenDNAs","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIdArray","type":"uint256[]"}],"name":"getDnasArray","outputs":[{"components":[{"internalType":"uint168","name":"dnaAppearance","type":"uint168"},{"internalType":"uint32","name":"dnaIdentity","type":"uint32"},{"internalType":"uint56","name":"dnaMetadata","type":"uint56"}],"internalType":"struct OlderfallFallens.FallenDNAs[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNumberOfTokensCreated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"getTokenIds","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenLimit","outputs":[{"internalType":"uint256","name":"tokenLimit","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isFallenDropAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isFallenMintingAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isFallenPurchaseAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"purchasedTokensMinted","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_withdrawalAccount","type":"address"}],"name":"reclaimBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newuri","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint168","name":"_dnaAppearance","type":"uint168"},{"internalType":"uint32","name":"_dnaIdentity","type":"uint32"},{"internalType":"uint56","name":"_dnaMetadata","type":"uint56"}],"name":"setDnas","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_erc20TokenAddress","type":"address"}],"name":"setERC20Token","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_firstPrice","type":"uint256"}],"name":"setFallenFirstPurchasePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_secondPrice","type":"uint256"}],"name":"setFallenSecondPurchasePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newuri","type":"string"}],"name":"setFallenTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_startDate","type":"uint64"}],"name":"setStartDate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_tokenDropLimit","type":"uint32"}],"name":"setTokenDropLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_tokenLimitPrice","type":"uint32"}],"name":"setTokenLimitPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_tokenPurchaseLimit","type":"uint32"}],"name":"setTokenPurchaseLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startDate","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleFallenDropStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleFallenMintingStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleFallenPurchaseStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenDropLimit","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenIdCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenPurchaseLimit","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561000f575f80fd5b50600436106103ca575f3560e01c8063880c0ed411610200578063b2dfdd9c1161011f578063d17fc522116100b4578063e1621c6611610084578063e1621c6614610985578063e8a3d4851461099c578063e985e9c5146109a4578063eb91d37e146109b7578063fce9266b146109bf575f80fd5b8063d17fc52214610922578063d547741f14610948578063d5b49e521461095b578063de56248714610972575f80fd5b8063c87b56dd116100ef578063c87b56dd146108b4578063cee806bc146108c7578063d004b036146108ef578063d1590c761461090f575f80fd5b8063b2dfdd9c14610853578063b495518c14610867578063b88d4fde1461087a578063c17eaf851461088d575f80fd5b8063966007a511610195578063a217fddf11610165578063a217fddf1461081a578063a22cb46514610821578063a482171914610834578063a4c003c71461083c575f80fd5b8063966007a514610769578063970df9801461077c57806398bdf6f51461078f5780639c00d89514610798575f80fd5b806391d14854116101d057806391d1485414610728578063938e3d7b1461073b5780639548fd7d1461074e57806395d89b4114610761575f80fd5b8063880c0ed4146106ce5780638a13eea7146106e15780638a8ead21146106f45780638d2a054614610714575f80fd5b80632f745c59116102ec5780634f6ccce71161028157806370a082311161025157806370a082311461069857806383666ce7146106ab5780638456cb59146106b357806384b80b86146106bb575f80fd5b80634f6ccce7146106535780635c975abb146106665780635ff6bbf2146106715780636352211e14610685575f80fd5b806342842e0e116102bc57806342842e0e1461061257806342966c6814610625578063461b458d146106385780634a0c517d1461064b575f80fd5b80632f745c591461056957806334e80ea31461057c57806336568abe146105f75780633f4ba83a1461060a575f80fd5b8063190b71a51161036257806326fe024a1161033257806326fe024a1461051f57806328485586146105465780632a62c37d1461054e5780632f2ff15d14610556575f80fd5b8063190b71a5146104cf57806323a557fa146104e257806323b872dd146104ea578063248a9ca3146104fd575f80fd5b806309a7bdf91161039d57806309a7bdf91461044b5780630b97bc861461045e5780630f13f1611461049057806318160ddd146104bd575f80fd5b806301ffc9a7146103ce57806306fdde03146103f6578063081812fc1461040b578063095ea7b314610436575b5f80fd5b6103e16103dc366004612bd4565b6109d2565b60405190151581526020015b60405180910390f35b6103fe6109e2565b6040516103ed9190612c3c565b61041e610419366004612c4e565b610a71565b6040516001600160a01b0390911681526020016103ed565b610449610444366004612c80565b610a98565b005b610449610459366004612cbb565b610aa7565b600f5461047890600160a81b90046001600160401b031681565b6040516001600160401b0390911681526020016103ed565b6012546104a890640100000000900463ffffffff1681565b60405163ffffffff90911681526020016103ed565b6009545b6040519081526020016103ed565b6104c16104dd366004612d1f565b610cd8565b610449610e8b565b6104496104f8366004612d38565b610eb7565b6104c161050b366004612c4e565b5f908152600b602052604090206001015490565b6104c17f1cc379b3b1230648195bddcf59b12ea9dea3827d1cc7359d0039d3ce2e2a900b81565b6104c1610f40565b600c546104c1565b610449610564366004612d71565b610f71565b6104c1610577366004612c80565b610f95565b6105c461058a366004612c4e565b600d6020525f90815260409020546001600160a81b03811690600160a81b810463ffffffff1690600160c81b900466ffffffffffffff1683565b604080516001600160a81b03909416845263ffffffff909216602084015266ffffffffffffff16908201526060016103ed565b610449610605366004612d71565b610ff8565b610449611030565b610449610620366004612d38565b611045565b610449610633366004612c4e565b61105f565b610449610646366004612c4e565b61106a565b6104496110c9565b6104c1610661366004612c4e565b6110f5565b60065460ff166103e1565b6012546103e190600160b01b900460ff1681565b61041e610693366004612c4e565b61114a565b6104c16106a6366004612d1f565b611154565b610449611199565b6104496111c5565b6104496106c9366004612c4e565b6111d7565b6104496106dc366004612e33565b611236565b600f5461041e906001600160a01b031681565b610707610702366004612e77565b61124c565b6040516103ed9190612f17565b6012546103e190600160a01b900460ff1681565b6103e1610736366004612d71565b6113c2565b610449610749366004612e33565b6113ec565b61044961075c366004612f90565b611402565b6103fe61143a565b610449610777366004612fb6565b611449565b61044961078a366004612fb6565b611470565b6104c1600c5481565b61080d6107a6366004612c4e565b60408051606080820183525f8083526020808401829052928401819052938452600d82529282902082519384018352546001600160a81b0381168452600160a81b810463ffffffff1691840191909152600160c81b900466ffffffffffffff169082015290565b6040516103ed9190612fcf565b6104c15f81565b61044961082f366004613015565b611527565b6104c1611532565b6012546104a890600160601b900463ffffffff1681565b6012546103e190600160a81b900460ff1681565b610449610875366004612fb6565b6116c6565b61044961088836600461304a565b611782565b6104c17f1045b94a155e441356ffc7c7445b88647948afdd960b9795fc0b729d08007d9f81565b6103fe6108c2366004612c4e565b611799565b6104786108d5366004612c4e565b600e6020525f90815260409020546001600160401b031681565b6109026108fd366004612d1f565b6117cd565b6040516103ed91906130c0565b61044961091d366004612d1f565b611867565b600f5461093690600160a01b900460ff1681565b60405160ff90911681526020016103ed565b610449610956366004612d71565b6118f4565b6012546104a890600160401b900463ffffffff1681565b610449610980366004612d1f565b611918565b6012546104a890600160801b900463ffffffff1681565b6103fe6119bb565b6103e16109b23660046130f7565b6119ca565b6104c16119f7565b6109026109cd366004612c80565b611a51565b5f6109dc82611cf7565b92915050565b60605f80546109f09061311f565b80601f0160208091040260200160405190810160405280929190818152602001828054610a1c9061311f565b8015610a675780601f10610a3e57610100808354040283529160200191610a67565b820191905f5260205f20905b815481529060010190602001808311610a4a57829003601f168201915b5050505050905090565b5f610a7b82611d1b565b505f828152600460205260409020546001600160a01b03166109dc565b610aa3828233611d53565b5050565b610ad17f1045b94a155e441356ffc7c7445b88647948afdd960b9795fc0b729d08007d9f336113c2565b610b485760405162461bcd60e51b815260206004820152603d60248201527f4f6e6c7920746865206f776e657220616e642074686520617574686f72697a6560448201527f6420616464726573732063616e207570646174652074686520446e617300000060648201526084015b60405180910390fd5b5f836001600160a81b031611610bb15760405162461bcd60e51b815260206004820152602860248201527f446e6120417070656172616e6365206d7573742062652067726561746572207460448201526768616e207a65726f60c01b6064820152608401610b3f565b5f8263ffffffff1611610c155760405162461bcd60e51b815260206004820152602660248201527f446e61204964656e74697479206d7573742062652067726561746572207468616044820152656e207a65726f60d01b6064820152608401610b3f565b5f8166ffffffffffffff1611610c7c5760405162461bcd60e51b815260206004820152602660248201527f446e61204d65746164617461206d7573742062652067726561746572207468616044820152656e207a65726f60d01b6064820152608401610b3f565b5f938452600d6020526040909320805466ffffffffffffff909416600160c81b026001600160c81b0363ffffffff909316600160a81b026001600160c81b03199095166001600160a81b03909416939093179390931716179055565b5f610d037f1cc379b3b1230648195bddcf59b12ea9dea3827d1cc7359d0039d3ce2e2a900b336113c2565b610d1f5760405162461bcd60e51b8152600401610b3f90613157565b600f54600160a81b90046001600160401b0316421015610d7b5760405162461bcd60e51b815260206004820152601760248201527644726f707320617265206e6f7420617661696c61626c6560481b6044820152606401610b3f565b600c54610d86610f40565b11610da35760405162461bcd60e51b8152600401610b3f906131b4565b60125463ffffffff600160801b82048116600160401b9092041611610dda5760405162461bcd60e51b8152600401610b3f906131b4565b601254600160b01b900460ff161515600114610e385760405162461bcd60e51b815260206004820152601c60248201527f44726f707320617265206e6f74206c6f6e67657220616c6c6f776564000000006044820152606401610b3f565b5f610e4283611d60565b60128054919250600160801b90910463ffffffff16906010610e63836131ff565b91906101000a81548163ffffffff021916908363ffffffff1602179055505080915050919050565b5f610e9581611e10565b506012805460ff60a81b198116600160a81b9182900460ff1615909102179055565b6001600160a01b038216610ee057604051633250574960e11b81525f6004820152602401610b3f565b5f610eec838333611e1a565b9050836001600160a01b0316816001600160a01b031614610f3a576040516364283d7b60e01b81526001600160a01b0380861660048301526024820184905282166044820152606401610b3f565b50505050565b6012545f90610f669063ffffffff6401000000008204811691600160401b900416613221565b63ffffffff16905090565b5f828152600b6020526040902060010154610f8b81611e10565b610f3a8383611e30565b5f610f9f83611154565b8210610fd05760405163295f44f760e21b81526001600160a01b038416600482015260248101839052604401610b3f565b506001600160a01b03919091165f908152600760209081526040808320938352929052205490565b6001600160a01b03811633146110215760405163334bd91960e11b815260040160405180910390fd5b61102b8282611ec1565b505050565b5f61103a81611e10565b611042611f2c565b50565b61102b83838360405180602001604052805f815250611782565b610aa35f8233611e1a565b5f61107481611e10565b5f82116110c35760405162461bcd60e51b815260206004820152601c60248201527f5072696365206d757374206265206d6f7265207468616e207a65726f000000006044820152606401610b3f565b50601055565b5f6110d381611e10565b506012805460ff60b01b198116600160b01b9182900460ff1615909102179055565b5f6110ff60095490565b82106111275760405163295f44f760e21b81525f600482015260248101839052604401610b3f565b6009828154811061113a5761113a61323e565b905f5260205f2001549050919050565b5f6109dc82611d1b565b5f6001600160a01b03821661117e576040516322718ad960e21b81525f6004820152602401610b3f565b506001600160a01b03165f9081526003602052604090205490565b5f6111a381611e10565b506012805460ff60a01b198116600160a01b9182900460ff1615909102179055565b5f6111cf81611e10565b611042611f7e565b5f6111e181611e10565b5f82116112305760405162461bcd60e51b815260206004820152601c60248201527f5072696365206d757374206265206d6f7265207468616e207a65726f000000006044820152606401610b3f565b50601155565b5f61124081611e10565b601361102b8382613296565b60606064825111156112ac5760405162461bcd60e51b815260206004820152602360248201527f41727261792065786365656473206d6178696d756d206c656e677468206f662060448201526203130360ec1b6064820152608401610b3f565b5f82516001600160401b038111156112c6576112c6612d9b565b60405190808252806020026020018201604052801561130f57816020015b604080516060810182525f80825260208083018290529282015282525f199092019101816112e45790505b5090505f5b83518110156113bb575f600d5f8684815181106113335761133361323e565b60209081029190910181015182528181019290925260409081015f20815160608101835290546001600160a81b0381168252600160a81b810463ffffffff1693820193909352600160c81b90920466ffffffffffffff1690820152835190915081908490849081106113a7576113a761323e565b602090810291909101015250600101611314565b5092915050565b5f918252600b602090815260408084206001600160a01b0393909316845291905290205460ff1690565b5f6113f681611e10565b601461102b8382613296565b5f61140c81611e10565b50600f80546001600160401b03909216600160a81b0267ffffffffffffffff60a81b19909216919091179055565b6060600180546109f09061311f565b5f61145381611e10565b506012805463ffffffff191663ffffffff92909216919091179055565b5f61147a81611e10565b60125463ffffffff600160801b9091048116908316116114fb5760405162461bcd60e51b815260206004820152603660248201527f56616c75652063616e6e6f74206265206c657373207468616e20746865206e756044820152751b58995c881bd9881d1bdad95b9cc8191c9bdc1c195960521b6064820152608401610b3f565b506012805463ffffffff909216600160401b026bffffffff000000000000000019909216919091179055565b610aa3338383611fbb565b600f545f90600160a81b90046001600160401b03164210156115965760405162461bcd60e51b815260206004820152601b60248201527f50757263686173657320617265206e6f7420617661696c61626c6500000000006044820152606401610b3f565b600c546115a1610f40565b116115be5760405162461bcd60e51b8152600401610b3f906131b4565b60125463ffffffff600160601b8204811664010000000090920416116115f65760405162461bcd60e51b8152600401610b3f906131b4565b601254600160a81b900460ff1615156001146116545760405162461bcd60e51b815260206004820181905260248201527f50757263686173657320617265206e6f74206c6f6e67657220616c6c6f7765646044820152606401610b3f565b61167533306116616119f7565b600f546001600160a01b0316929190612059565b5f61167f33611d60565b60128054919250600160601b90910463ffffffff1690600c6116a0836131ff565b91906101000a81548163ffffffff021916908363ffffffff160217905550508091505090565b5f6116d081611e10565b60125463ffffffff600160601b909104811690831610156117595760405162461bcd60e51b815260206004820152603860248201527f56616c75652063616e6e6f74206265206c657373207468616e20746865206e7560448201527f6d626572206f6620746f6b656e732070757263686173656400000000000000006064820152608401610b3f565b506012805463ffffffff9092166401000000000267ffffffff0000000019909216919091179055565b61178d848484610eb7565b610f3a848484846120c0565b606060136117a6836121e6565b6040516020016117b7929190613355565b6040516020818303038152906040529050919050565b60605f806117da84611154565b90505f816001600160401b038111156117f5576117f5612d9b565b60405190808252806020026020018201604052801561181e578160200160208202803683370190505b5090505f92505b8183101561185f576118378584610f95565b8184815181106118495761184961323e565b6020908102919091010152600190920191611825565b949350505050565b5f61187181611e10565b600f546040516370a0823160e01b8152306004820152610aa39184916001600160a01b03909116906370a0823190602401602060405180830381865afa1580156118bd573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906118e191906133d8565b600f546001600160a01b03169190612275565b5f828152600b602052604090206001015461190e81611e10565b610f3a8383611ec1565b5f61192281611e10565b600f80546001600160a01b0319166001600160a01b0384169081179091556040805163313ce56760e01b8152905163313ce567916004808201926020929091908290030181865afa158015611979573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061199d91906133ef565b600f60146101000a81548160ff021916908360ff1602179055505050565b6060601480546109f09061311f565b6001600160a01b039182165f90815260056020908152604080832093909416825291909152205460ff1690565b6012545f9063ffffffff808216600160601b9092041610611a3457601154600f54611a2f9190600a90600160a01b900460ff166122a6565b905090565b601054600f54611a2f9190600a90600160a01b900460ff166122a6565b6060611a7d7f1cc379b3b1230648195bddcf59b12ea9dea3827d1cc7359d0039d3ce2e2a900b336113c2565b611a995760405162461bcd60e51b8152600401610b3f90613157565b600f54600160a81b90046001600160401b0316421015611af55760405162461bcd60e51b815260206004820152601760248201527644726f707320617265206e6f7420617661696c61626c6560481b6044820152606401610b3f565b600c54611b00610f40565b11611b1d5760405162461bcd60e51b8152600401610b3f906131b4565b60125463ffffffff600160801b82048116600160401b9092041611611b545760405162461bcd60e51b8152600401610b3f906131b4565b601254600160b01b900460ff161515600114611bb25760405162461bcd60e51b815260206004820152601c60248201527f44726f707320617265206e6f74206c6f6e67657220616c6c6f776564000000006044820152606401610b3f565b81600c54611bc0919061340f565b611bc8610f40565b1015611be65760405162461bcd60e51b8152600401610b3f90613422565b601254611c01908390600160801b900463ffffffff1661340f565b601254600160401b900463ffffffff161015611c2f5760405162461bcd60e51b8152600401610b3f90613422565b5f826001600160401b03811115611c4857611c48612d9b565b604051908082528060200260200182016040528015611c71578160200160208202803683370190505b5090505f5b83811015611cef575f611c8886611d60565b60128054919250600160801b90910463ffffffff16906010611ca9836131ff565b91906101000a81548163ffffffff021916908363ffffffff1602179055505080838381518110611cdb57611cdb61323e565b602090810291909101015250600101611c76565b509392505050565b5f6001600160e01b03198216637965db0b60e01b14806109dc57506109dc826122bb565b5f818152600260205260408120546001600160a01b0316806109dc57604051637e27328960e01b815260048101849052602401610b3f565b61102b83838360016122df565b6012545f90600160a01b900460ff161515600114611dc05760405162461bcd60e51b815260206004820152601d60248201527f4d696e74696e67206973206e6f74206c6f6e67657220616c6c6f7765640000006044820152606401610b3f565b600c80545f818152600e60205260408120805467ffffffffffffffff1916426001600160401b031617905582549192600192909190611e0090849061340f565b909155506109dc905083826123e3565b61104281336123fc565b5f611e26848484612435565b90505b9392505050565b5f611e3b83836113c2565b611eba575f838152600b602090815260408083206001600160a01b03861684529091529020805460ff19166001179055611e723390565b6001600160a01b0316826001600160a01b0316847f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45060016109dc565b505f6109dc565b5f611ecc83836113c2565b15611eba575f838152600b602090815260408083206001600160a01b0386168085529252808320805460ff1916905551339286917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45060016109dc565b611f34612500565b6006805460ff191690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa335b6040516001600160a01b03909116815260200160405180910390a1565b611f86612525565b6006805460ff191660011790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258611f613390565b6001600160a01b038216611fed57604051630b61174360e31b81526001600160a01b0383166004820152602401610b3f565b6001600160a01b038381165f81815260056020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b6040516001600160a01b038481166024830152838116604483015260648201839052610f3a9186918216906323b872dd906084015b604051602081830303815290604052915060e01b6020820180516001600160e01b038381831617835250505050612549565b6001600160a01b0383163b15610f3a57604051630a85bd0160e11b81526001600160a01b0384169063150b7a0290612102903390889087908790600401613465565b6020604051808303815f875af192505050801561213c575060408051601f3d908101601f1916820190925261213991810190613497565b60015b6121a3573d808015612169576040519150601f19603f3d011682016040523d82523d5f602084013e61216e565b606091505b5080515f0361219b57604051633250574960e11b81526001600160a01b0385166004820152602401610b3f565b805181602001fd5b6001600160e01b03198116630a85bd0160e11b146121df57604051633250574960e11b81526001600160a01b0385166004820152602401610b3f565b5050505050565b60605f6121f2836125aa565b60010190505f816001600160401b0381111561221057612210612d9b565b6040519080825280601f01601f19166020018201604052801561223a576020820181803683370190505b5090508181016020015b5f19016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a850494508461224457509392505050565b6040516001600160a01b0383811660248301526044820183905261102b91859182169063a9059cbb9060640161208e565b5f6122b18284613592565b611e26908561359d565b5f6001600160e01b0319821663780e9d6360e01b14806109dc57506109dc82612681565b80806122f357506001600160a01b03821615155b156123b4575f61230284611d1b565b90506001600160a01b0383161580159061232e5750826001600160a01b0316816001600160a01b031614155b8015612341575061233f81846119ca565b155b1561236a5760405163a9fbf51f60e01b81526001600160a01b0384166004820152602401610b3f565b81156123b25783856001600160a01b0316826001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45b505b50505f90815260046020526040902080546001600160a01b0319166001600160a01b0392909216919091179055565b610aa3828260405180602001604052805f8152506126d0565b61240682826113c2565b610aa35760405163e2517d3f60e01b81526001600160a01b038216600482015260248101839052604401610b3f565b5f806124428585856126e6565b90506001600160a01b03811661249e5761249984600980545f838152600a60205260408120829055600182018355919091527f6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af0155565b6124c1565b846001600160a01b0316816001600160a01b0316146124c1576124c181856126fa565b6001600160a01b0385166124dd576124d884612787565b611e26565b846001600160a01b0316816001600160a01b031614611e2657611e26858561282e565b60065460ff1661252357604051638dfc202b60e01b815260040160405180910390fd5b565b60065460ff16156125235760405163d93c066560e01b815260040160405180910390fd5b5f61255d6001600160a01b0384168361287c565b905080515f1415801561258157508080602001905181019061257f91906135b4565b155b1561102b57604051635274afe760e01b81526001600160a01b0384166004820152602401610b3f565b5f8072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b83106125e85772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef81000000008310612614576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc10000831061263257662386f26fc10000830492506010015b6305f5e100831061264a576305f5e100830492506008015b612710831061265e57612710830492506004015b60648310612670576064830492506002015b600a83106109dc5760010192915050565b5f6001600160e01b031982166380ac58cd60e01b14806126b157506001600160e01b03198216635b5e139f60e01b145b806109dc57506301ffc9a760e01b6001600160e01b03198316146109dc565b6126da8383612889565b61102b5f8484846120c0565b5f6126ef612525565b611e268484846128ea565b5f61270483611154565b5f83815260086020526040902054909150808214612755576001600160a01b0384165f9081526007602090815260408083208584528252808320548484528184208190558352600890915290208190555b505f9182526008602090815260408084208490556001600160a01b039094168352600781528383209183525290812055565b6009545f90612798906001906135cf565b5f838152600a6020526040812054600980549394509092849081106127bf576127bf61323e565b905f5260205f200154905080600983815481106127de576127de61323e565b5f918252602080832090910192909255828152600a90915260408082208490558582528120556009805480612815576128156135e2565b600190038181905f5260205f20015f9055905550505050565b5f600161283a84611154565b61284491906135cf565b6001600160a01b039093165f908152600760209081526040808320868452825280832085905593825260089052919091209190915550565b6060611e2983835f6129dc565b6001600160a01b0382166128b257604051633250574960e11b81525f6004820152602401610b3f565b5f6128be83835f611e1a565b90506001600160a01b0381161561102b576040516339e3563760e11b81525f6004820152602401610b3f565b5f828152600260205260408120546001600160a01b039081169083161561291657612916818486612a75565b6001600160a01b03811615612950576129315f855f806122df565b6001600160a01b0381165f90815260036020526040902080545f190190555b6001600160a01b0385161561297e576001600160a01b0385165f908152600360205260409020805460010190555b5f8481526002602052604080822080546001600160a01b0319166001600160a01b0389811691821790925591518793918516917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4949350505050565b606081471015612a015760405163cd78605960e01b8152306004820152602401610b3f565b5f80856001600160a01b03168486604051612a1c91906135f6565b5f6040518083038185875af1925050503d805f8114612a56576040519150601f19603f3d011682016040523d82523d5f602084013e612a5b565b606091505b5091509150612a6b868383612ad9565b9695505050505050565b612a80838383612b35565b61102b576001600160a01b038316612aae57604051637e27328960e01b815260048101829052602401610b3f565b60405163177e802f60e01b81526001600160a01b038316600482015260248101829052604401610b3f565b606082612aee57612ae982612b96565b611e29565b8151158015612b0557506001600160a01b0384163b155b15612b2e57604051639996b31560e01b81526001600160a01b0385166004820152602401610b3f565b5080611e29565b5f6001600160a01b03831615801590611e265750826001600160a01b0316846001600160a01b03161480612b6e5750612b6e84846119ca565b80611e265750505f908152600460205260409020546001600160a01b03908116911614919050565b805115612ba65780518082602001fd5b604051630a12f52160e11b815260040160405180910390fd5b6001600160e01b031981168114611042575f80fd5b5f60208284031215612be4575f80fd5b8135611e2981612bbf565b5f5b83811015612c09578181015183820152602001612bf1565b50505f910152565b5f8151808452612c28816020860160208601612bef565b601f01601f19169290920160200192915050565b602081525f611e296020830184612c11565b5f60208284031215612c5e575f80fd5b5035919050565b80356001600160a01b0381168114612c7b575f80fd5b919050565b5f8060408385031215612c91575f80fd5b612c9a83612c65565b946020939093013593505050565b803563ffffffff81168114612c7b575f80fd5b5f805f8060808587031215612cce575f80fd5b8435935060208501356001600160a81b0381168114612ceb575f80fd5b9250612cf960408601612ca8565b9150606085013566ffffffffffffff81168114612d14575f80fd5b939692955090935050565b5f60208284031215612d2f575f80fd5b611e2982612c65565b5f805f60608486031215612d4a575f80fd5b612d5384612c65565b9250612d6160208501612c65565b9150604084013590509250925092565b5f8060408385031215612d82575f80fd5b82359150612d9260208401612c65565b90509250929050565b634e487b7160e01b5f52604160045260245ffd5b604051601f8201601f191681016001600160401b0381118282101715612dd757612dd7612d9b565b604052919050565b5f6001600160401b03831115612df757612df7612d9b565b612e0a601f8401601f1916602001612daf565b9050828152838383011115612e1d575f80fd5b828260208301375f602084830101529392505050565b5f60208284031215612e43575f80fd5b81356001600160401b03811115612e58575f80fd5b8201601f81018413612e68575f80fd5b61185f84823560208401612ddf565b5f6020808385031215612e88575f80fd5b82356001600160401b0380821115612e9e575f80fd5b818501915085601f830112612eb1575f80fd5b813581811115612ec357612ec3612d9b565b8060051b9150612ed4848301612daf565b8181529183018401918481019088841115612eed575f80fd5b938501935b83851015612f0b57843582529385019390850190612ef2565b98975050505050505050565b602080825282518282018190525f9190848201906040850190845b81811015612f8457612f7183855180516001600160a81b0316825260208082015163ffffffff169083015260409081015166ffffffffffffff16910152565b9284019260609290920191600101612f32565b50909695505050505050565b5f60208284031215612fa0575f80fd5b81356001600160401b0381168114611e29575f80fd5b5f60208284031215612fc6575f80fd5b611e2982612ca8565b81516001600160a81b0316815260208083015163ffffffff169082015260408083015166ffffffffffffff1690820152606081016109dc565b8015158114611042575f80fd5b5f8060408385031215613026575f80fd5b61302f83612c65565b9150602083013561303f81613008565b809150509250929050565b5f805f806080858703121561305d575f80fd5b61306685612c65565b935061307460208601612c65565b92506040850135915060608501356001600160401b03811115613095575f80fd5b8501601f810187136130a5575f80fd5b6130b487823560208401612ddf565b91505092959194509250565b602080825282518282018190525f9190848201906040850190845b81811015612f84578351835292840192918401916001016130db565b5f8060408385031215613108575f80fd5b61311183612c65565b9150612d9260208401612c65565b600181811c9082168061313357607f821691505b60208210810361315157634e487b7160e01b5f52602260045260245ffd5b50919050565b60208082526039908201527f4f6e6c7920746865206f776e657220616e642074686520617574686f72697a6560408201527f6420616464726573732063616e2064726f7020746f6b656e7300000000000000606082015260800190565b6020808252601b908201527f416c6c20746f6b656e732068617665206265656e206d696e7465640000000000604082015260600190565b634e487b7160e01b5f52601160045260245ffd5b5f63ffffffff808316818103613217576132176131eb565b6001019392505050565b63ffffffff8181168382160190808211156113bb576113bb6131eb565b634e487b7160e01b5f52603260045260245ffd5b601f82111561102b57805f5260205f20601f840160051c810160208510156132775750805b601f840160051c820191505b818110156121df575f8155600101613283565b81516001600160401b038111156132af576132af612d9b565b6132c3816132bd845461311f565b84613252565b602080601f8311600181146132f6575f84156132df5750858301515b5f19600386901b1c1916600185901b17855561334d565b5f85815260208120601f198616915b8281101561332457888601518255948401946001909101908401613305565b508582101561334157878501515f19600388901b60f8161c191681555b505060018460011b0185555b505050505050565b5f8084546133628161311f565b6001828116801561337a576001811461338f576133bb565b60ff19841687528215158302870194506133bb565b885f526020805f205f5b858110156133b25781548a820152908401908201613399565b50505082870194505b5050505083516133cf818360208801612bef565b01949350505050565b5f602082840312156133e8575f80fd5b5051919050565b5f602082840312156133ff575f80fd5b815160ff81168114611e29575f80fd5b808201808211156109dc576109dc6131eb565b60208082526023908201527f546865726520617265206e6f7420656e6f75676820746f6b656e7320746f206d6040820152621a5b9d60ea1b606082015260800190565b6001600160a01b03858116825284166020820152604081018390526080606082018190525f90612a6b90830184612c11565b5f602082840312156134a7575f80fd5b8151611e2981612bbf565b600181815b808511156134ec57815f19048211156134d2576134d26131eb565b808516156134df57918102915b93841c93908002906134b7565b509250929050565b5f82613502575060016109dc565b8161350e57505f6109dc565b8160018114613524576002811461352e5761354a565b60019150506109dc565b60ff84111561353f5761353f6131eb565b50506001821b6109dc565b5060208310610133831016604e8410600b841016171561356d575081810a6109dc565b61357783836134b2565b805f190482111561358a5761358a6131eb565b029392505050565b5f611e2983836134f4565b80820281158282048414176109dc576109dc6131eb565b5f602082840312156135c4575f80fd5b8151611e2981613008565b818103818111156109dc576109dc6131eb565b634e487b7160e01b5f52603160045260245ffd5b5f8251613607818460208701612bef565b919091019291505056fea2646970667358221220d58c764f4675a8de916a72a42928edbf9d10f826e40660adc0725dbcfd66fa3564736f6c63430008180033

000000000000000000000000000000000000000000000000000000006806dc00000000000000000000000000000000000000000000000000000000000000000f000000000000000000000000000000000000000000000000000000000000001900000000000000000000000000000000000000000000000000000000000001f400000000000000000000000000000000000000000000000000000000000003e800000000000000000000000000000000000000000000000000000000000027100000000000000000000000006f4768d90264063880bbacf473d14d94941acd8d000000000000000000000000ffffffff7d2b0b761af01ca8e25242976ac0ad7d

-----Decoded View---------------
Arg [0] : _startDate (uint64): 1745280000
Arg [1] : _firstPrice (uint256): 15
Arg [2] : _secondPrice (uint256): 25
Arg [3] : _tokenLimitPrice (uint32): 500
Arg [4] : _tokenPurchaseLimit (uint32): 1000
Arg [5] : _tokenDropLimit (uint32): 10000
Arg [6] : _initialOwner (address): 0x6f4768d90264063880bbACf473d14d94941ACd8d
Arg [7] : _erc20TokenAddress (address): 0xFFfffffF7D2B0B761Af01Ca8e25242976ac0aD7D

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 000000000000000000000000000000000000000000000000000000006806dc00
Arg [1] : 000000000000000000000000000000000000000000000000000000000000000f
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000019
Arg [3] : 00000000000000000000000000000000000000000000000000000000000001f4
Arg [4] : 00000000000000000000000000000000000000000000000000000000000003e8
Arg [5] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [6] : 0000000000000000000000006f4768d90264063880bbacf473d14d94941acd8d
Arg [7] : 000000000000000000000000ffffffff7d2b0b761af01ca8e25242976ac0ad7d

99638:9662:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;106410:179;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;106410:179:0;;;;;;;;69939:91;;;:::i;:::-;;;;;;;:::i;71111:158::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;71111:158:0;1533:203:1;70930:115:0;;;;;;:::i;:::-;;:::i;:::-;;102719:593;;;;;;:::i;:::-;;:::i;100089:23::-;;;;;-1:-1:-1;;;100089:23:0;;-1:-1:-1;;;;;100089:23:0;;;;;;-1:-1:-1;;;;;3118:31:1;;;3100:50;;3088:2;3073:18;100089:23:0;2956:200:1;100213:32:0;;;;;;;;;;;;;;;3335:10:1;3323:23;;;3305:42;;3293:2;3278:18;100213:32:0;3161:192:1;89805:104:0;89884:10;:17;89805:104;;;3504:25:1;;;3492:2;3477:18;89805:104:0;3358:177:1;107615:557:0;;;;;;:::i;:::-;;:::i;103453:134::-;;;:::i;71780:588::-;;;;;;:::i;:::-;;:::i;10336:122::-;;;;;;:::i;:::-;10401:7;10428:12;;;:6;:12;;;;;:22;;;;10336:122;100646:76;;100691:31;100646:76;;104731:118;;;:::i;105786:97::-;105864:14;;105786:97;;10768:138;;;;;;:::i;:::-;;:::i;89469:260::-;;;;;;:::i;:::-;;:::i;99918:42::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;99918:42:0;;;-1:-1:-1;;;99918:42:0;;;;;-1:-1:-1;;;99918:42:0;;;;;;;;;;-1:-1:-1;;;;;4906:32:1;;;4888:51;;4987:10;4975:23;;;4970:2;4955:18;;4948:51;5047:16;5035:29;5015:18;;;5008:57;4876:2;4861:18;99918:42:0;4690:381:1;11905:251:0;;;;;;:::i;:::-;;:::i;102454:75::-;;;:::i;72439:134::-;;;;;;:::i;:::-;;:::i;86283:318::-;;;;;;:::i;:::-;;:::i;103719:189::-;;;;;;:::i;:::-;;:::i;103592:122::-;;;:::i;89986:231::-;;;;;;:::i;:::-;;:::i;97103:86::-;97174:7;;;;97103:86;;100461:38;;;;;-1:-1:-1;;;100461:38:0;;;;;;69752:120;;;;;;:::i;:::-;;:::i;69477:213::-;;;;;;:::i;:::-;;:::i;103317:131::-;;;:::i;102378:71::-;;;:::i;103913:194::-;;;;;;:::i;:::-;;:::i;102132:120::-;;;;;;:::i;:::-;;:::i;100016:32::-;;;;;-1:-1:-1;;;;;100016:32:0;;;105357:424;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;100369:41::-;;;;;-1:-1:-1;;;100369:41:0;;;;;;9352:138;;;;;;:::i;:::-;;:::i;102259:114::-;;;;;;:::i;:::-;;:::i;101507:109::-;;;;;;:::i;:::-;;:::i;70099:95::-;;;:::i;104112:133::-;;;;;;:::i;:::-;;:::i;101889:238::-;;;;;;:::i;:::-;;:::i;99783:29::-;;;;;;105246:106;;;;;;:::i;:::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;105333:14:0;;;:4;:14;;;;;;105326:21;;;;;;;;-1:-1:-1;;;;;105326:21:0;;;;-1:-1:-1;;;105326:21:0;;;;;;;;;;;-1:-1:-1;;;105326:21:0;;;;;;;;;105246:106;;;;;;;;:::i;8664:49::-;;8709:4;8664:49;;71341:146;;;;;;:::i;:::-;;:::i;107074:536::-;;;:::i;100283:39::-;;;;;-1:-1:-1;;;100283:39:0;;;;;;100414:43;;;;;-1:-1:-1;;;100414:43:0;;;;;;101621:263;;;;;;:::i;:::-;;:::i;72644:211::-;;;;;;:::i;:::-;;:::i;100570:72::-;;100613:29;100570:72;;105888:166;;;;;;:::i;:::-;;:::i;99964:46::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;99964:46:0;;;104891:350;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;102534:180::-;;;;;;:::i;:::-;;:::i;100052:31::-;;;;;-1:-1:-1;;;100052:31:0;;;;;;;;;11194:4:1;11182:17;;;11164:36;;11152:2;11137:18;100052:31:0;11022:184:1;11199:140:0;;;;;;:::i;:::-;;:::i;100249:28::-;;;;;-1:-1:-1;;;100249:28:0;;;;;;104250:191;;;;;;:::i;:::-;;:::i;100326:37::-;;;;;-1:-1:-1;;;100326:37:0;;;;;;106059:87;;;:::i;71558:155::-;;;;;;:::i;:::-;;:::i;104468:236::-;;;:::i;108177:938::-;;;;;;:::i;:::-;;:::i;106410:179::-;106529:4;106547:37;106571:12;106547:23;:37::i;:::-;106540:44;106410:179;-1:-1:-1;;106410:179:0:o;69939:91::-;69984:13;70017:5;70010:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69939:91;:::o;71111:158::-;71178:7;71198:22;71212:7;71198:13;:22::i;:::-;-1:-1:-1;73687:7:0;73714:24;;;:15;:24;;;;;;-1:-1:-1;;;;;73714:24:0;71240:21;73617:129;70930:115;71002:35;71011:2;71015:7;4377:10;71002:8;:35::i;:::-;70930:115;;:::o;102719:593::-;102842:37;100613:29;102868:10;102842:7;:37::i;:::-;102834:111;;;;-1:-1:-1;;;102834:111:0;;12063:2:1;102834:111:0;;;12045:21:1;12102:2;12082:18;;;12075:30;12141:34;12121:18;;;12114:62;12212:31;12192:18;;;12185:59;12261:19;;102834:111:0;;;;;;;;;102975:1;102958:14;-1:-1:-1;;;;;102958:18:0;;102950:71;;;;-1:-1:-1;;;102950:71:0;;12493:2:1;102950:71:0;;;12475:21:1;12532:2;12512:18;;;12505:30;12571:34;12551:18;;;12544:62;-1:-1:-1;;;12622:18:1;;;12615:38;12670:19;;102950:71:0;12291:404:1;102950:71:0;103049:1;103034:12;:16;;;103026:67;;;;-1:-1:-1;;;103026:67:0;;12902:2:1;103026:67:0;;;12884:21:1;12941:2;12921:18;;;12914:30;12980:34;12960:18;;;12953:62;-1:-1:-1;;;13031:18:1;;;13024:36;13077:19;;103026:67:0;12700:402:1;103026:67:0;103121:1;103106:12;:16;;;103098:67;;;;-1:-1:-1;;;103098:67:0;;13309:2:1;103098:67:0;;;13291:21:1;13348:2;13328:18;;;13321:30;13387:34;13367:18;;;13360:62;-1:-1:-1;;;13438:18:1;;;13431:36;13484:19;;103098:67:0;13107:402:1;103098:67:0;103170:14;;;;:4;:14;;;;;;:45;;103266:41;;;;-1:-1:-1;;;103266:41:0;-1:-1:-1;;;;;103220:41:0;;;;-1:-1:-1;;;103220:41:0;-1:-1:-1;;;;;;103220:41:0;;;-1:-1:-1;;;;;103170:45:0;;;103220:41;;;;;;;;103266;;;;102719:593::o;107615:557::-;107663:7;107685:39;100691:31;107713:10;107685:7;:39::i;:::-;107677:109;;;;-1:-1:-1;;;107677:109:0;;;;;;;:::i;:::-;107818:9;;-1:-1:-1;;;107818:9:0;;-1:-1:-1;;;;;107818:9:0;107799:15;:28;;107791:64;;;;-1:-1:-1;;;107791:64:0;;14142:2:1;107791:64:0;;;14124:21:1;14181:2;14161:18;;;14154:30;-1:-1:-1;;;14200:18:1;;;14193:53;14263:18;;107791:64:0;13940:347:1;107791:64:0;107886:14;;107868:15;:13;:15::i;:::-;:32;107860:72;;;;-1:-1:-1;;;107860:72:0;;;;;;;:::i;:::-;107962:19;;;-1:-1:-1;;;107962:19:0;;;;-1:-1:-1;;;107945:14:0;;;;:36;107937:76;;;;-1:-1:-1;;;107937:76:0;;;;;;;:::i;:::-;108026:19;;-1:-1:-1;;;108026:19:0;;;;:27;;108049:4;108026:27;108018:68;;;;-1:-1:-1;;;108018:68:0;;14850:2:1;108018:68:0;;;14832:21:1;14889:2;14869:18;;;14862:30;14928;14908:18;;;14901:58;14976:18;;108018:68:0;14648:352:1;108018:68:0;108091:15;108109:13;108118:3;108109:8;:13::i;:::-;108127:19;:21;;108091:31;;-1:-1:-1;;;;108127:21:0;;;;;;:19;:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;108160:7;108153:14;;;107615:557;;;:::o;103453:134::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;-1:-1:-1;103559:23:0::1;::::0;;-1:-1:-1;;;;103532:50:0;::::1;-1:-1:-1::0;;;103559:23:0;;;::::1;;;103558:24;103532:50:::0;;::::1;;::::0;;103453:134::o;71780:588::-;-1:-1:-1;;;;;71875:16:0;;71871:89;;71915:33;;-1:-1:-1;;;71915:33:0;;71945:1;71915:33;;;1679:51:1;1652:18;;71915:33:0;1533:203:1;71871:89:0;72181:21;72205:34;72213:2;72217:7;4377:10;72205:7;:34::i;:::-;72181:58;;72271:4;-1:-1:-1;;;;;72254:21:0;:13;-1:-1:-1;;;;;72254:21:0;;72250:111;;72299:50;;-1:-1:-1;;;72299:50:0;;-1:-1:-1;;;;;15601:15:1;;;72299:50:0;;;15583:34:1;15633:18;;;15626:34;;;15696:15;;15676:18;;;15669:43;15518:18;;72299:50:0;15343:375:1;72250:111:0;71860:508;71780:588;;;:::o;104731:118::-;104826:18;;104777;;104809:35;;104826:18;;;;;;;-1:-1:-1;;;104809:14:0;;;:35;:::i;:::-;104802:42;;;;104731:118;:::o;10768:138::-;10401:7;10428:12;;;:6;:12;;;;;:22;;;8948:16;8959:4;8948:10;:16::i;:::-;10873:25:::1;10884:4;10890:7;10873:10;:25::i;89469:260::-:0;89557:7;89590:16;89600:5;89590:9;:16::i;:::-;89581:5;:25;89577:101;;89630:36;;-1:-1:-1;;;89630:36:0;;-1:-1:-1;;;;;16092:32:1;;89630:36:0;;;16074:51:1;16141:18;;;16134:34;;;16047:18;;89630:36:0;15900:274:1;89577:101:0;-1:-1:-1;;;;;;89695:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;89469:260::o;11905:251::-;-1:-1:-1;;;;;11999:34:0;;4377:10;11999:34;11995:104;;12057:30;;-1:-1:-1;;;12057:30:0;;;;;;;;;;;11995:104;12111:37;12123:4;12129:18;12111:11;:37::i;:::-;;11905:251;;:::o;102454:75::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;102514:10:::1;:8;:10::i;:::-;102454:75:::0;:::o;72439:134::-;72526:39;72543:4;72549:2;72553:7;72526:39;;;;;;;;;;;;:16;:39::i;86283:318::-;86551:42;86567:1;86571:7;4377:10;72205:7;:34::i;103719:189::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;103840:1:::1;103826:11;:15;103818:56;;;::::0;-1:-1:-1;;;103818:56:0;;16381:2:1;103818:56:0::1;::::0;::::1;16363:21:1::0;16420:2;16400:18;;;16393:30;16459;16439:18;;;16432:58;16507:18;;103818:56:0::1;16179:352:1::0;103818:56:0::1;-1:-1:-1::0;103879:10:0::1;:24:::0;103719:189::o;103592:122::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;-1:-1:-1;103690:19:0::1;::::0;;-1:-1:-1;;;;103667:42:0;::::1;-1:-1:-1::0;;;103690:19:0;;;::::1;;;103689:20;103667:42:::0;;::::1;;::::0;;103592:122::o;89986:231::-;90052:7;90085:13;89884:10;:17;;89805:104;90085:13;90076:5;:22;90072:103;;90122:41;;-1:-1:-1;;;90122:41:0;;90153:1;90122:41;;;16074:51:1;16141:18;;;16134:34;;;16047:18;;90122:41:0;15900:274:1;90072:103:0;90192:10;90203:5;90192:17;;;;;;;;:::i;:::-;;;;;;;;;90185:24;;89986:231;;;:::o;69752:120::-;69815:7;69842:22;69856:7;69842:13;:22::i;69477:213::-;69540:7;-1:-1:-1;;;;;69564:19:0;;69560:89;;69607:30;;-1:-1:-1;;;69607:30:0;;69634:1;69607:30;;;1679:51:1;1652:18;;69607:30:0;1533:203:1;69560:89:0;-1:-1:-1;;;;;;69666:16:0;;;;;:9;:16;;;;;;;69477:213::o;103317:131::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;-1:-1:-1;103421:22:0::1;::::0;;-1:-1:-1;;;;103395:48:0;::::1;-1:-1:-1::0;;;103421:22:0;;;::::1;;;103420:23;103395:48:::0;;::::1;;::::0;;103317:131::o;102378:71::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;102436:8:::1;:6;:8::i;103913:194::-:0;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;104037:1:::1;104022:12;:16;104014:57;;;::::0;-1:-1:-1;;;104014:57:0;;16381:2:1;104014:57:0::1;::::0;::::1;16363:21:1::0;16420:2;16400:18;;;16393:30;16459;16439:18;;;16432:58;16507:18;;104014:57:0::1;16179:352:1::0;104014:57:0::1;-1:-1:-1::0;104076:11:0::1;:26:::0;103913:194::o;102132:120::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;102223:14:::1;:24;102240:7:::0;102223:14;:24:::1;:::i;105357:424::-:0;105432:19;105490:3;105466:13;:20;:27;;105458:75;;;;-1:-1:-1;;;105458:75:0;;19040:2:1;105458:75:0;;;19022:21:1;19079:2;19059:18;;;19052:30;19118:34;19098:18;;;19091:62;-1:-1:-1;;;19169:18:1;;;19162:33;19212:19;;105458:75:0;18838:399:1;105458:75:0;105540:30;105590:13;:20;-1:-1:-1;;;;;105573:38:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;105573:38:0;;-1:-1:-1;;105573:38:0;;;;;;;;;;;;105540:71;;105623:6;105618:133;105639:13;:20;105635:1;:24;105618:133;;;105672:22;105697:4;:22;105702:13;105716:1;105702:16;;;;;;;;:::i;:::-;;;;;;;;;;;;105697:22;;;;;;;;;;;;;-1:-1:-1;105697:22:0;105672:47;;;;;;;;;-1:-1:-1;;;;;105672:47:0;;;;-1:-1:-1;;;105672:47:0;;;;;;;;;;;-1:-1:-1;;;105672:47:0;;;;;;;;;105725:13;;105672:47;;-1:-1:-1;105672:47:0;;105725:13;;105736:1;;105725:13;;;;;;:::i;:::-;;;;;;;;;;:20;-1:-1:-1;105661:3:0;;105618:133;;;-1:-1:-1;105765:10:0;105357:424;-1:-1:-1;;105357:424:0:o;9352:138::-;9429:4;9453:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;9453:29:0;;;;;;;;;;;;;;;9352:138::o;102259:114::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;102347:11:::1;:21;102361:7:::0;102347:11;:21:::1;:::i;101507:109::-:0;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;-1:-1:-1;101589:9:0::1;:22:::0;;-1:-1:-1;;;;;101589:22:0;;::::1;-1:-1:-1::0;;;101589:22:0::1;-1:-1:-1::0;;;;101589:22:0;;::::1;::::0;;;::::1;::::0;;101507:109::o;70099:95::-;70146:13;70179:7;70172:14;;;;;:::i;104112:133::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;-1:-1:-1;104206:15:0::1;:34:::0;;-1:-1:-1;;104206:34:0::1;;::::0;;;::::1;::::0;;;::::1;::::0;;104112:133::o;101889:238::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;102007:19:::1;::::0;::::1;-1:-1:-1::0;;;102007:19:0;;::::1;::::0;::::1;101989:37:::0;;::::1;;101981:104;;;::::0;-1:-1:-1;;;101981:104:0;;19444:2:1;101981:104:0::1;::::0;::::1;19426:21:1::0;19483:2;19463:18;;;19456:30;19522:34;19502:18;;;19495:62;-1:-1:-1;;;19573:18:1;;;19566:52;19635:19;;101981:104:0::1;19242:418:1::0;101981:104:0::1;-1:-1:-1::0;102090:14:0::1;:32:::0;;::::1;::::0;;::::1;-1:-1:-1::0;;;102090:32:0::1;-1:-1:-1::0;;102090:32:0;;::::1;::::0;;;::::1;::::0;;101889:238::o;71341:146::-;71427:52;4377:10;71460:8;71470;71427:18;:52::i;107074:536::-;107151:9;;107110:7;;-1:-1:-1;;;107151:9:0;;-1:-1:-1;;;;;107151:9:0;107132:15;:28;;107124:68;;;;-1:-1:-1;;;107124:68:0;;19867:2:1;107124:68:0;;;19849:21:1;19906:2;19886:18;;;19879:30;19945:29;19925:18;;;19918:57;19992:18;;107124:68:0;19665:351:1;107124:68:0;107223:14;;107205:15;:13;:15::i;:::-;:32;107197:72;;;;-1:-1:-1;;;107197:72:0;;;;;;;:::i;:::-;107303:21;;;-1:-1:-1;;;107303:21:0;;;;107282:18;;;;;:42;107274:82;;;;-1:-1:-1;;;107274:82:0;;;;;;;:::i;:::-;107369:23;;-1:-1:-1;;;107369:23:0;;;;:31;;107396:4;107369:31;107361:76;;;;-1:-1:-1;;;107361:76:0;;20223:2:1;107361:76:0;;;20205:21:1;;;20242:18;;;20235:30;20301:34;20281:18;;;20274:62;20353:18;;107361:76:0;20021:356:1;107361:76:0;107442:73;107470:10;107490:4;107497:17;:15;:17::i;:::-;107442:10;;-1:-1:-1;;;;;107442:10:0;;:73;;:27;:73::i;:::-;107520:15;107538:20;107547:10;107538:8;:20::i;:::-;107563:21;:23;;107520:38;;-1:-1:-1;;;;107563:23:0;;;;;;:21;:23;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;107598:7;107591:14;;;107074:536;:::o;101621:263::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;101752:21:::1;::::0;::::1;-1:-1:-1::0;;;101752:21:0;;::::1;::::0;::::1;101729:44:::0;;::::1;;;101721:113;;;::::0;-1:-1:-1;;;101721:113:0;;20584:2:1;101721:113:0::1;::::0;::::1;20566:21:1::0;20623:2;20603:18;;;20596:30;20662:34;20642:18;;;20635:62;20733:26;20713:18;;;20706:54;20777:19;;101721:113:0::1;20382:420:1::0;101721:113:0::1;-1:-1:-1::0;101839:18:0::1;:40:::0;;::::1;::::0;;::::1;::::0;::::1;-1:-1:-1::0;;101839:40:0;;::::1;::::0;;;::::1;::::0;;101621:263::o;72644:211::-;72758:31;72771:4;72777:2;72781:7;72758:12;:31::i;:::-;72800:47;72823:4;72829:2;72833:7;72842:4;72800:22;:47::i;105888:166::-;105954:13;106005:14;106021:26;106038:8;106021:16;:26::i;:::-;105988:60;;;;;;;;;:::i;:::-;;;;;;;;;;;;;105974:75;;105888:166;;;:::o;104891:350::-;104949:16;104972:9;104986:22;105011:24;105028:6;105011:16;:24::i;:::-;104986:49;;105040:31;105088:14;-1:-1:-1;;;;;105074:29:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;105074:29:0;;105040:63;;105119:1;105115:5;;105110:99;105126:14;105122:1;:18;105110:99;;;105173:30;105193:6;105201:1;105173:19;:30::i;:::-;105153:14;105168:1;105153:17;;;;;;;;:::i;:::-;;;;;;;;;;:50;105142:3;;;;;105110:99;;;105222:14;104891:350;-1:-1:-1;;;;104891:350:0:o;102534:180::-;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;102673:10:::1;::::0;:35:::1;::::0;-1:-1:-1;;;102673:35:0;;102702:4:::1;102673:35;::::0;::::1;1679:51:1::0;102629:80:0::1;::::0;102653:18;;-1:-1:-1;;;;;102673:10:0;;::::1;::::0;:20:::1;::::0;1652:18:1;;102673:35:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;102629:10;::::0;-1:-1:-1;;;;;102629:10:0::1;::::0;:80;:23:::1;:80::i;11199:140::-:0;10401:7;10428:12;;;:6;:12;;;;;:22;;;8948:16;8959:4;8948:10;:16::i;:::-;11305:26:::1;11317:4;11323:7;11305:11;:26::i;104250:191::-:0;8709:4;8948:16;8709:4;8948:10;:16::i;:::-;104342:10:::1;:47:::0;;-1:-1:-1;;;;;;104342:47:0::1;-1:-1:-1::0;;;;;104342:47:0;::::1;::::0;;::::1;::::0;;;104415:21:::1;::::0;;-1:-1:-1;;;104415:21:0;;;;:19:::1;::::0;:21:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;104342:47;104415:21:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;104394:18;;:42;;;;;;;;;;;;;;;;;;104250:191:::0;;:::o;106059:87::-;106103:13;106130:11;106123:18;;;;;:::i;71558:155::-;-1:-1:-1;;;;;71670:25:0;;;71646:4;71670:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;71558:155::o;104468:236::-;104571:15;;104516:13;;104571:15;;;;-1:-1:-1;;;104547:21:0;;;;:39;:152;;104663:11;;104680:18;;104645:54;;104663:11;104676:2;;-1:-1:-1;;;104680:18:0;;;;104645:17;:54::i;:::-;104536:163;;104468:236;:::o;104547:152::-;104607:10;;104623:18;;104589:53;;104607:10;104619:2;;-1:-1:-1;;;104623:18:0;;;;104589:17;:53::i;108177:938::-;108245:16;108276:39;100691:31;108304:10;108276:7;:39::i;:::-;108268:109;;;;-1:-1:-1;;;108268:109:0;;;;;;;:::i;:::-;108409:9;;-1:-1:-1;;;108409:9:0;;-1:-1:-1;;;;;108409:9:0;108390:15;:28;;108382:64;;;;-1:-1:-1;;;108382:64:0;;14142:2:1;108382:64:0;;;14124:21:1;14181:2;14161:18;;;14154:30;-1:-1:-1;;;14200:18:1;;;14193:53;14263:18;;108382:64:0;13940:347:1;108382:64:0;108477:14;;108459:15;:13;:15::i;:::-;:32;108451:72;;;;-1:-1:-1;;;108451:72:0;;;;;;;:::i;:::-;108553:19;;;-1:-1:-1;;;108553:19:0;;;;-1:-1:-1;;;108536:14:0;;;;:36;108528:76;;;;-1:-1:-1;;;108528:76:0;;;;;;;:::i;:::-;108617:19;;-1:-1:-1;;;108617:19:0;;;;:27;;108640:4;108617:27;108609:68;;;;-1:-1:-1;;;108609:68:0;;14850:2:1;108609:68:0;;;14832:21:1;14889:2;14869:18;;;14862:30;14928;14908:18;;;14901:58;14976:18;;108609:68:0;14648:352:1;108609:68:0;108727:9;108710:14;;:26;;;;:::i;:::-;108690:15;:13;:15::i;:::-;:47;;108682:95;;;;-1:-1:-1;;;108682:95:0;;;;;;;:::i;:::-;108809:19;;:31;;108831:9;;-1:-1:-1;;;108809:19:0;;;;:31;:::i;:::-;108790:14;;-1:-1:-1;;;108790:14:0;;;;:51;;108782:99;;;;-1:-1:-1;;;108782:99:0;;;;;;;:::i;:::-;108888:26;108931:9;-1:-1:-1;;;;;108917:24:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;108917:24:0;;108888:53;;108953:9;108948:140;108972:9;108968:1;:13;108948:140;;;108994:16;109013:13;109022:3;109013:8;:13::i;:::-;109032:19;:21;;108994:32;;-1:-1:-1;;;;109032:21:0;;;;;;:19;:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;109074:8;109059:9;109069:1;109059:12;;;;;;;;:::i;:::-;;;;;;;;;;:23;-1:-1:-1;108983:3:0;;108948:140;;;-1:-1:-1;109101:9:0;108177:938;-1:-1:-1;;;108177:938:0:o;9056:204::-;9141:4;-1:-1:-1;;;;;;9165:47:0;;-1:-1:-1;;;9165:47:0;;:87;;;9216:36;9240:11;9216:23;:36::i;84086:247::-;84149:7;73472:16;;;:7;:16;;;;;;-1:-1:-1;;;;;73472:16:0;;84213:90;;84260:31;;-1:-1:-1;;;84260:31:0;;;;;3504:25:1;;;3477:18;;84260:31:0;3358:177:1;82318:122:0;82399:33;82408:2;82412:7;82421:4;82427;82399:8;:33::i;106770:299::-;106840:22;;106818:7;;-1:-1:-1;;;106840:22:0;;;;:30;;106866:4;106840:30;106832:72;;;;-1:-1:-1;;;106832:72:0;;23036:2:1;106832:72:0;;;23018:21:1;23075:2;23055:18;;;23048:30;23114:31;23094:18;;;23087:59;23163:18;;106832:72:0;22834:353:1;106832:72:0;106927:14;;;106909:15;106946:21;;;:12;:21;;;;;:47;;-1:-1:-1;;106946:47:0;106977:15;-1:-1:-1;;;;;106946:47:0;;;;106998:19;;106927:14;;-1:-1:-1;;106927:14:0;;106909:15;106998:19;;-1:-1:-1;;106998:19:0;:::i;:::-;;;;-1:-1:-1;107022:23:0;;-1:-1:-1;107032:3:0;107037:7;107022:9;:23::i;9705:105::-;9772:30;9783:4;4377:10;9772;:30::i;106218:187::-;106347:7;106368:32;106382:2;106386:7;106395:4;106368:13;:32::i;:::-;106361:39;;106218:187;;;;;;:::o;12782:324::-;12859:4;12881:22;12889:4;12895:7;12881;:22::i;:::-;12876:223;;12920:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;12920:29:0;;;;;;;;;:36;;-1:-1:-1;;12920:36:0;12952:4;12920:36;;;13003:12;4377:10;;4297:98;13003:12;-1:-1:-1;;;;;12976:40:0;12994:7;-1:-1:-1;;;;;12976:40:0;12988:4;12976:40;;;;;;;;;;-1:-1:-1;13038:4:0;13031:11;;12876:223;-1:-1:-1;13082:5:0;13075:12;;13350:325;13428:4;13449:22;13457:4;13463:7;13449;:22::i;:::-;13445:223;;;13520:5;13488:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;13488:29:0;;;;;;;;;;:37;;-1:-1:-1;;13488:37:0;;;13545:40;4377:10;;13488:12;;13545:40;;13520:5;13545:40;-1:-1:-1;13607:4:0;13600:11;;98004:120;96967:16;:14;:16::i;:::-;98063:7:::1;:15:::0;;-1:-1:-1;;98063:15:0::1;::::0;;98094:22:::1;4377:10:::0;98103:12:::1;98094:22;::::0;-1:-1:-1;;;;;1697:32:1;;;1679:51;;1667:2;1652:18;98094:22:0::1;;;;;;;98004:120::o:0;97745:118::-;96708:19;:17;:19::i;:::-;97805:7:::1;:14:::0;;-1:-1:-1;;97805:14:0::1;97815:4;97805:14;::::0;;97835:20:::1;97842:12;4377:10:::0;;4297:98;83525:318;-1:-1:-1;;;;;83633:22:0;;83629:93;;83679:31;;-1:-1:-1;;;83679:31:0;;-1:-1:-1;;;;;1697:32:1;;83679:31:0;;;1679:51:1;1652:18;;83679:31:0;1533:203:1;83629:93:0;-1:-1:-1;;;;;83732:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;83732:46:0;;;;;;;;;;83794:41;;540::1;;;83794::0;;513:18:1;83794:41:0;;;;;;;83525:318;;;:::o;29588:190::-;29716:53;;-1:-1:-1;;;;;23450:15:1;;;29716:53:0;;;23432:34:1;23502:15;;;23482:18;;;23475:43;23534:18;;;23527:34;;;29689:81:0;;29709:5;;29731:18;;;;;23367::1;;29716:53:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;29716:53:0;;;;;;;;;;;29689:19;:81::i;84883:799::-;-1:-1:-1;;;;;85000:14:0;;;:18;84996:679;;85039:71;;-1:-1:-1;;;85039:71:0;;-1:-1:-1;;;;;85039:36:0;;;;;:71;;4377:10;;85090:4;;85096:7;;85105:4;;85039:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;85039:71:0;;;;;;;;-1:-1:-1;;85039:71:0;;;;;;;;;;;;:::i;:::-;;;85035:629;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85353:6;:13;85370:1;85353:18;85349:300;;85403:25;;-1:-1:-1;;;85403:25:0;;-1:-1:-1;;;;;1697:32:1;;85403:25:0;;;1679:51:1;1652:18;;85403:25:0;1533:203:1;85349:300:0;85599:6;85593:13;85584:6;85580:2;85576:15;85569:38;85035:629;-1:-1:-1;;;;;;85158:51:0;;-1:-1:-1;;;85158:51:0;85154:132;;85241:25;;-1:-1:-1;;;85241:25:0;;-1:-1:-1;;;;;1697:32:1;;85241:25:0;;;1679:51:1;1652:18;;85241:25:0;1533:203:1;85154:132:0;85111:190;84883:799;;;;:::o;65272:718::-;65328:13;65379:14;65396:17;65407:5;65396:10;:17::i;:::-;65416:1;65396:21;65379:38;;65432:20;65466:6;-1:-1:-1;;;;;65455:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65455:18:0;-1:-1:-1;65432:41:0;-1:-1:-1;65597:28:0;;;65613:2;65597:28;65654:290;-1:-1:-1;;65686:5:0;-1:-1:-1;;;65823:2:0;65812:14;;65807:32;65686:5;65794:46;65886:2;65877:11;;;-1:-1:-1;65907:21:0;65654:290;65907:21;-1:-1:-1;65965:6:0;65272:718;-1:-1:-1;;;65272:718:0:o;29181:162::-;29291:43;;-1:-1:-1;;;;;16092:32:1;;;29291:43:0;;;16074:51:1;16141:18;;;16134:34;;;29264:71:0;;29284:5;;29306:14;;;;;16047:18:1;;29291:43:0;15900:274:1;109132:165:0;109231:18;109272:20;109282:9;109272:5;:20;:::i;:::-;109263:29;;:6;:29;:::i;89161:224::-;89263:4;-1:-1:-1;;;;;;89287:50:0;;-1:-1:-1;;;89287:50:0;;:90;;;89341:36;89365:11;89341:23;:36::i;82628:678::-;82790:9;:31;;;-1:-1:-1;;;;;;82803:18:0;;;;82790:31;82786:471;;;82838:13;82854:22;82868:7;82854:13;:22::i;:::-;82838:38;-1:-1:-1;;;;;;83007:18:0;;;;;;:35;;;83038:4;-1:-1:-1;;;;;83029:13:0;:5;-1:-1:-1;;;;;83029:13:0;;;83007:35;:69;;;;;83047:29;83064:5;83071:4;83047:16;:29::i;:::-;83046:30;83007:69;83003:144;;;83104:27;;-1:-1:-1;;;83104:27:0;;-1:-1:-1;;;;;1697:32:1;;83104:27:0;;;1679:51:1;1652:18;;83104:27:0;1533:203:1;83003:144:0;83167:9;83163:83;;;83222:7;83218:2;-1:-1:-1;;;;;83202:28:0;83211:5;-1:-1:-1;;;;;83202:28:0;;;;;;;;;;;83163:83;82823:434;82786:471;-1:-1:-1;;83269:24:0;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;83269:29:0;-1:-1:-1;;;;;83269:29:0;;;;;;;;;;82628:678::o;78437:102::-;78505:26;78515:2;78519:7;78505:26;;;;;;;;;;;;:9;:26::i;9946:201::-;10035:22;10043:4;10049:7;10035;:22::i;:::-;10030:110;;10081:47;;-1:-1:-1;;;10081:47:0;;-1:-1:-1;;;;;16092:32:1;;10081:47:0;;;16074:51:1;16141:18;;;16134:34;;;16047:18;;10081:47:0;15900:274:1;90278:640:0;90373:7;90393:21;90417:32;90431:2;90435:7;90444:4;90417:13;:32::i;:::-;90393:56;-1:-1:-1;;;;;;90466:27:0;;90462:214;;90510:40;90542:7;91742:10;:17;;91715:24;;;;:15;:24;;;;;:44;;;91770:24;;;;;;;;;;;;91638:164;90510:40;90462:214;;;90589:2;-1:-1:-1;;;;;90572:19:0;:13;-1:-1:-1;;;;;90572:19:0;;90568:108;;90608:56;90641:13;90656:7;90608:32;:56::i;:::-;-1:-1:-1;;;;;90690:16:0;;90686:192;;90723:45;90760:7;90723:36;:45::i;:::-;90686:192;;;90807:2;-1:-1:-1;;;;;90790:19:0;:13;-1:-1:-1;;;;;90790:19:0;;90786:92;;90826:40;90854:2;90858:7;90826:27;:40::i;97471:130::-;97174:7;;;;97530:64;;97567:15;;-1:-1:-1;;;97567:15:0;;;;;;;;;;;97530:64;97471:130::o;97262:132::-;97174:7;;;;97324:63;;;97360:15;;-1:-1:-1;;;97360:15:0;;;;;;;;;;;31992:638;32416:23;32442:33;-1:-1:-1;;;;;32442:27:0;;32470:4;32442:27;:33::i;:::-;32416:59;;32490:10;:17;32511:1;32490:22;;:57;;;;;32528:10;32517:30;;;;;;;;;;;;:::i;:::-;32516:31;32490:57;32486:137;;;32571:40;;-1:-1:-1;;;32571:40:0;;-1:-1:-1;;;;;1697:32:1;;32571:40:0;;;1679:51:1;1652:18;;32571:40:0;1533:203:1;60224:948:0;60277:7;;-1:-1:-1;;;60355:17:0;;60351:106;;-1:-1:-1;;;60393:17:0;;;-1:-1:-1;60439:2:0;60429:12;60351:106;60484:8;60475:5;:17;60471:106;;60522:8;60513:17;;;-1:-1:-1;60559:2:0;60549:12;60471:106;60604:8;60595:5;:17;60591:106;;60642:8;60633:17;;;-1:-1:-1;60679:2:0;60669:12;60591:106;60724:7;60715:5;:16;60711:103;;60761:7;60752:16;;;-1:-1:-1;60797:1:0;60787:11;60711:103;60841:7;60832:5;:16;60828:103;;60878:7;60869:16;;;-1:-1:-1;60914:1:0;60904:11;60828:103;60958:7;60949:5;:16;60945:103;;60995:7;60986:16;;;-1:-1:-1;61031:1:0;61021:11;60945:103;61075:7;61066:5;:16;61062:68;;61113:1;61103:11;61158:6;60224:948;-1:-1:-1;;60224:948:0:o;69108:305::-;69210:4;-1:-1:-1;;;;;;69247:40:0;;-1:-1:-1;;;69247:40:0;;:105;;-1:-1:-1;;;;;;;69304:48:0;;-1:-1:-1;;;69304:48:0;69247:105;:158;;;-1:-1:-1;;;;;;;;;;6437:40:0;;;69369:36;6337:148;78766:185;78861:18;78867:2;78871:7;78861:5;:18::i;:::-;78890:53;78921:1;78925:2;78929:7;78938:4;78890:22;:53::i;99291:210::-;99434:7;96708:19;:17;:19::i;:::-;99461:32:::1;99475:2;99479:7;99488:4;99461:13;:32::i;92429:977::-:0;92695:22;92720:15;92730:4;92720:9;:15::i;:::-;92746:18;92767:26;;;:17;:26;;;;;;92695:40;;-1:-1:-1;92900:28:0;;;92896:328;;-1:-1:-1;;;;;92967:18:0;;92945:19;92967:18;;;:12;:18;;;;;;;;:34;;;;;;;;;93018:30;;;;;;:44;;;93135:30;;:17;:30;;;;;:43;;;92896:328;-1:-1:-1;93320:26:0;;;;:17;:26;;;;;;;;93313:33;;;-1:-1:-1;;;;;93364:18:0;;;;;:12;:18;;;;;:34;;;;;;;93357:41;92429:977::o;93701:1079::-;93979:10;:17;93954:22;;93979:21;;93999:1;;93979:21;:::i;:::-;94011:18;94032:24;;;:15;:24;;;;;;94405:10;:26;;93954:46;;-1:-1:-1;94032:24:0;;93954:46;;94405:26;;;;;;:::i;:::-;;;;;;;;;94383:48;;94469:11;94444:10;94455;94444:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;94549:28;;;:15;:28;;;;;;;:41;;;94721:24;;;;;94714:31;94756:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;93772:1008;;;93701:1079;:::o;91219:218::-;91304:14;91337:1;91321:13;91331:2;91321:9;:13::i;:::-;:17;;;;:::i;:::-;-1:-1:-1;;;;;91349:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;91394:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;91219:218:0:o;24252:153::-;24327:12;24359:38;24381:6;24389:4;24395:1;24359:21;:38::i;77739:335::-;-1:-1:-1;;;;;77807:16:0;;77803:89;;77847:33;;-1:-1:-1;;;77847:33:0;;77877:1;77847:33;;;1679:51:1;1652:18;;77847:33:0;1533:203:1;77803:89:0;77902:21;77926:32;77934:2;77938:7;77955:1;77926:7;:32::i;:::-;77902:56;-1:-1:-1;;;;;;77973:27:0;;;77969:98;;78024:31;;-1:-1:-1;;;78024:31:0;;78052:1;78024:31;;;1679:51:1;1652:18;;78024:31:0;1533:203:1;76579:824:0;76665:7;73472:16;;;:7;:16;;;;;;-1:-1:-1;;;;;73472:16:0;;;;76780:18;;;76776:88;;76815:37;76832:4;76838;76844:7;76815:16;:37::i;:::-;-1:-1:-1;;;;;76911:18:0;;;76907:263;;77029:48;77046:1;77050:7;77067:1;77071:5;77029:8;:48::i;:::-;-1:-1:-1;;;;;77123:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;77123:20:0;;;76907:263;-1:-1:-1;;;;;77186:16:0;;;77182:111;;-1:-1:-1;;;;;77248:13:0;;;;;;:9;:13;;;;;:18;;77265:1;77248:18;;;77182:111;77305:16;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;77305:21:0;-1:-1:-1;;;;;77305:21:0;;;;;;;;;77344:27;;77305:16;;77344:27;;;;;;;77391:4;76579:824;-1:-1:-1;;;;76579:824:0:o;24740:398::-;24839:12;24892:5;24868:21;:29;24864:110;;;24921:41;;-1:-1:-1;;;24921:41:0;;24956:4;24921:41;;;1679:51:1;1652:18;;24921:41:0;1533:203:1;24864:110:0;24985:12;24999:23;25026:6;-1:-1:-1;;;;;25026:11:0;25045:5;25052:4;25026:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24984:73;;;;25075:55;25102:6;25110:7;25119:10;25075:26;:55::i;:::-;25068:62;24740:398;-1:-1:-1;;;;;;24740:398:0:o;74786:376::-;74899:38;74913:5;74920:7;74929;74899:13;:38::i;:::-;74894:261;;-1:-1:-1;;;;;74958:19:0;;74954:190;;75005:31;;-1:-1:-1;;;75005:31:0;;;;;3504:25:1;;;3477:18;;75005:31:0;3358:177:1;74954:190:0;75084:44;;-1:-1:-1;;;75084:44:0;;-1:-1:-1;;;;;16092:32:1;;75084:44:0;;;16074:51:1;16141:18;;;16134:34;;;16047:18;;75084:44:0;15900:274:1;26216:597:0;26364:12;26394:7;26389:417;;26418:19;26426:10;26418:7;:19::i;:::-;26389:417;;;26646:17;;:22;:49;;;;-1:-1:-1;;;;;;26672:18:0;;;:23;26646:49;26642:121;;;26723:24;;-1:-1:-1;;;26723:24:0;;-1:-1:-1;;;;;1697:32:1;;26723:24:0;;;1679:51:1;1652:18;;26723:24:0;1533:203:1;26642:121:0;-1:-1:-1;26784:10:0;26777:17;;74066:276;74169:4;-1:-1:-1;;;;;74206:21:0;;;;;;:128;;;74254:7;-1:-1:-1;;;;;74245:16:0;:5;-1:-1:-1;;;;;74245:16:0;;:52;;;;74265:32;74282:5;74289:7;74265:16;:32::i;:::-;74245:88;;;-1:-1:-1;;73687:7:0;73714:24;;;:15;:24;;;;;;-1:-1:-1;;;;;73714:24:0;;;74301:32;;;;;-1:-1:-1;74066:276:0:o;27366:528::-;27499:17;;:21;27495:392;;27731:10;27725:17;27788:15;27775:10;27771:2;27767:19;27760:44;27495:392;27858:17;;-1:-1:-1;;;27858:17:0;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1348:180::-;1407:6;1460:2;1448:9;1439:7;1435:23;1431:32;1428:52;;;1476:1;1473;1466:12;1428:52;-1:-1:-1;1499:23:1;;1348:180;-1:-1:-1;1348:180:1:o;1741:173::-;1809:20;;-1:-1:-1;;;;;1858:31:1;;1848:42;;1838:70;;1904:1;1901;1894:12;1838:70;1741:173;;;:::o;1919:254::-;1987:6;1995;2048:2;2036:9;2027:7;2023:23;2019:32;2016:52;;;2064:1;2061;2054:12;2016:52;2087:29;2106:9;2087:29;:::i;:::-;2077:39;2163:2;2148:18;;;;2135:32;;-1:-1:-1;;;1919:254:1:o;2178:163::-;2245:20;;2305:10;2294:22;;2284:33;;2274:61;;2331:1;2328;2321:12;2346:605;2430:6;2438;2446;2454;2507:3;2495:9;2486:7;2482:23;2478:33;2475:53;;;2524:1;2521;2514:12;2475:53;2547:23;;;-1:-1:-1;2620:2:1;2605:18;;2592:32;-1:-1:-1;;;;;2653:31:1;;2643:42;;2633:70;;2699:1;2696;2689:12;2633:70;2722:5;-1:-1:-1;2746:37:1;2779:2;2764:18;;2746:37;:::i;:::-;2736:47;;2835:2;2824:9;2820:18;2807:32;2883:16;2874:7;2870:30;2861:7;2858:43;2848:71;;2915:1;2912;2905:12;2848:71;2346:605;;;;-1:-1:-1;2346:605:1;;-1:-1:-1;;2346:605:1:o;3540:186::-;3599:6;3652:2;3640:9;3631:7;3627:23;3623:32;3620:52;;;3668:1;3665;3658:12;3620:52;3691:29;3710:9;3691:29;:::i;3731:328::-;3808:6;3816;3824;3877:2;3865:9;3856:7;3852:23;3848:32;3845:52;;;3893:1;3890;3883:12;3845:52;3916:29;3935:9;3916:29;:::i;:::-;3906:39;;3964:38;3998:2;3987:9;3983:18;3964:38;:::i;:::-;3954:48;;4049:2;4038:9;4034:18;4021:32;4011:42;;3731:328;;;;;:::o;4431:254::-;4499:6;4507;4560:2;4548:9;4539:7;4535:23;4531:32;4528:52;;;4576:1;4573;4566:12;4528:52;4612:9;4599:23;4589:33;;4641:38;4675:2;4664:9;4660:18;4641:38;:::i;:::-;4631:48;;4431:254;;;;;:::o;5076:127::-;5137:10;5132:3;5128:20;5125:1;5118:31;5168:4;5165:1;5158:15;5192:4;5189:1;5182:15;5208:275;5279:2;5273:9;5344:2;5325:13;;-1:-1:-1;;5321:27:1;5309:40;;-1:-1:-1;;;;;5364:34:1;;5400:22;;;5361:62;5358:88;;;5426:18;;:::i;:::-;5462:2;5455:22;5208:275;;-1:-1:-1;5208:275:1:o;5488:407::-;5553:5;-1:-1:-1;;;;;5579:6:1;5576:30;5573:56;;;5609:18;;:::i;:::-;5647:57;5692:2;5671:15;;-1:-1:-1;;5667:29:1;5698:4;5663:40;5647:57;:::i;:::-;5638:66;;5727:6;5720:5;5713:21;5767:3;5758:6;5753:3;5749:16;5746:25;5743:45;;;5784:1;5781;5774:12;5743:45;5833:6;5828:3;5821:4;5814:5;5810:16;5797:43;5887:1;5880:4;5871:6;5864:5;5860:18;5856:29;5849:40;5488:407;;;;;:::o;5900:451::-;5969:6;6022:2;6010:9;6001:7;5997:23;5993:32;5990:52;;;6038:1;6035;6028:12;5990:52;6078:9;6065:23;-1:-1:-1;;;;;6103:6:1;6100:30;6097:50;;;6143:1;6140;6133:12;6097:50;6166:22;;6219:4;6211:13;;6207:27;-1:-1:-1;6197:55:1;;6248:1;6245;6238:12;6197:55;6271:74;6337:7;6332:2;6319:16;6314:2;6310;6306:11;6271:74;:::i;6586:946::-;6670:6;6701:2;6744;6732:9;6723:7;6719:23;6715:32;6712:52;;;6760:1;6757;6750:12;6712:52;6800:9;6787:23;-1:-1:-1;;;;;6870:2:1;6862:6;6859:14;6856:34;;;6886:1;6883;6876:12;6856:34;6924:6;6913:9;6909:22;6899:32;;6969:7;6962:4;6958:2;6954:13;6950:27;6940:55;;6991:1;6988;6981:12;6940:55;7027:2;7014:16;7049:2;7045;7042:10;7039:36;;;7055:18;;:::i;:::-;7101:2;7098:1;7094:10;7084:20;;7124:28;7148:2;7144;7140:11;7124:28;:::i;:::-;7186:15;;;7256:11;;;7252:20;;;7217:12;;;;7284:19;;;7281:39;;;7316:1;7313;7306:12;7281:39;7340:11;;;;7360:142;7376:6;7371:3;7368:15;7360:142;;;7442:17;;7430:30;;7393:12;;;;7480;;;;7360:142;;;7521:5;6586:946;-1:-1:-1;;;;;;;;6586:946:1:o;7815:712::-;8042:2;8094:21;;;8164:13;;8067:18;;;8186:22;;;8013:4;;8042:2;8265:15;;;;8239:2;8224:18;;;8013:4;8308:193;8322:6;8319:1;8316:13;8308:193;;;8371:48;8415:3;8406:6;8400:13;7617:12;;-1:-1:-1;;;;;7613:38:1;7601:51;;7705:4;7694:16;;;7688:23;7713:10;7684:40;7668:14;;;7661:64;7778:4;7767:16;;;7761:23;7786:16;7757:46;7741:14;;7734:70;7537:273;8371:48;8476:15;;;;8448:4;8439:14;;;;;8344:1;8337:9;8308:193;;;-1:-1:-1;8518:3:1;;7815:712;-1:-1:-1;;;;;;7815:712:1:o;8532:284::-;8590:6;8643:2;8631:9;8622:7;8618:23;8614:32;8611:52;;;8659:1;8656;8649:12;8611:52;8698:9;8685:23;-1:-1:-1;;;;;8741:5:1;8737:30;8730:5;8727:41;8717:69;;8782:1;8779;8772:12;8821:184;8879:6;8932:2;8920:9;8911:7;8907:23;8903:32;8900:52;;;8948:1;8945;8938:12;8900:52;8971:28;8989:9;8971:28;:::i;9010:255::-;7617:12;;-1:-1:-1;;;;;7613:38:1;7601:51;;7705:4;7694:16;;;7688:23;7713:10;7684:40;7668:14;;;7661:64;7778:4;7767:16;;;7761:23;7786:16;7757:46;7741:14;;;7734:70;9200:2;9185:18;;9212:47;7537:273;9270:118;9356:5;9349:13;9342:21;9335:5;9332:32;9322:60;;9378:1;9375;9368:12;9393:315;9458:6;9466;9519:2;9507:9;9498:7;9494:23;9490:32;9487:52;;;9535:1;9532;9525:12;9487:52;9558:29;9577:9;9558:29;:::i;:::-;9548:39;;9637:2;9626:9;9622:18;9609:32;9650:28;9672:5;9650:28;:::i;:::-;9697:5;9687:15;;;9393:315;;;;;:::o;9713:667::-;9808:6;9816;9824;9832;9885:3;9873:9;9864:7;9860:23;9856:33;9853:53;;;9902:1;9899;9892:12;9853:53;9925:29;9944:9;9925:29;:::i;:::-;9915:39;;9973:38;10007:2;9996:9;9992:18;9973:38;:::i;:::-;9963:48;;10058:2;10047:9;10043:18;10030:32;10020:42;;10113:2;10102:9;10098:18;10085:32;-1:-1:-1;;;;;10132:6:1;10129:30;10126:50;;;10172:1;10169;10162:12;10126:50;10195:22;;10248:4;10240:13;;10236:27;-1:-1:-1;10226:55:1;;10277:1;10274;10267:12;10226:55;10300:74;10366:7;10361:2;10348:16;10343:2;10339;10335:11;10300:74;:::i;:::-;10290:84;;;9713:667;;;;;;;:::o;10385:632::-;10556:2;10608:21;;;10678:13;;10581:18;;;10700:22;;;10527:4;;10556:2;10779:15;;;;10753:2;10738:18;;;10527:4;10822:169;10836:6;10833:1;10830:13;10822:169;;;10897:13;;10885:26;;10966:15;;;;10931:12;;;;10858:1;10851:9;10822:169;;11211:260;11279:6;11287;11340:2;11328:9;11319:7;11315:23;11311:32;11308:52;;;11356:1;11353;11346:12;11308:52;11379:29;11398:9;11379:29;:::i;:::-;11369:39;;11427:38;11461:2;11450:9;11446:18;11427:38;:::i;11476:380::-;11555:1;11551:12;;;;11598;;;11619:61;;11673:4;11665:6;11661:17;11651:27;;11619:61;11726:2;11718:6;11715:14;11695:18;11692:38;11689:161;;11772:10;11767:3;11763:20;11760:1;11753:31;11807:4;11804:1;11797:15;11835:4;11832:1;11825:15;11689:161;;11476:380;;;:::o;13514:421::-;13716:2;13698:21;;;13755:2;13735:18;;;13728:30;13794:34;13789:2;13774:18;;13767:62;13865:27;13860:2;13845:18;;13838:55;13925:3;13910:19;;13514:421::o;14292:351::-;14494:2;14476:21;;;14533:2;14513:18;;;14506:30;14572:29;14567:2;14552:18;;14545:57;14634:2;14619:18;;14292:351::o;15005:127::-;15066:10;15061:3;15057:20;15054:1;15047:31;15097:4;15094:1;15087:15;15121:4;15118:1;15111:15;15137:201;15175:3;15203:10;15248:2;15241:5;15237:14;15275:2;15266:7;15263:15;15260:41;;15281:18;;:::i;:::-;15330:1;15317:15;;15137:201;-1:-1:-1;;;15137:201:1:o;15723:172::-;15790:10;15820;;;15832;;;15816:27;;15855:11;;;15852:37;;;15869:18;;:::i;16536:127::-;16597:10;16592:3;16588:20;16585:1;16578:31;16628:4;16625:1;16618:15;16652:4;16649:1;16642:15;16794:518;16896:2;16891:3;16888:11;16885:421;;;16932:5;16929:1;16922:16;16976:4;16973:1;16963:18;17046:2;17034:10;17030:19;17027:1;17023:27;17017:4;17013:38;17082:4;17070:10;17067:20;17064:47;;;-1:-1:-1;17105:4:1;17064:47;17160:2;17155:3;17151:12;17148:1;17144:20;17138:4;17134:31;17124:41;;17215:81;17233:2;17226:5;17223:13;17215:81;;;17292:1;17278:16;;17259:1;17248:13;17215:81;;17488:1345;17614:3;17608:10;-1:-1:-1;;;;;17633:6:1;17630:30;17627:56;;;17663:18;;:::i;:::-;17692:97;17782:6;17742:38;17774:4;17768:11;17742:38;:::i;:::-;17736:4;17692:97;:::i;:::-;17844:4;;17901:2;17890:14;;17918:1;17913:663;;;;18620:1;18637:6;18634:89;;;-1:-1:-1;18689:19:1;;;18683:26;18634:89;-1:-1:-1;;17445:1:1;17441:11;;;17437:24;17433:29;17423:40;17469:1;17465:11;;;17420:57;18736:81;;17883:944;;17913:663;16741:1;16734:14;;;16778:4;16765:18;;-1:-1:-1;;17949:20:1;;;18067:236;18081:7;18078:1;18075:14;18067:236;;;18170:19;;;18164:26;18149:42;;18262:27;;;;18230:1;18218:14;;;;18097:19;;18067:236;;;18071:3;18331:6;18322:7;18319:19;18316:201;;;18392:19;;;18386:26;-1:-1:-1;;18475:1:1;18471:14;;;18487:3;18467:24;18463:37;18459:42;18444:58;18429:74;;18316:201;;;18563:1;18554:6;18551:1;18547:14;18543:22;18537:4;18530:36;17883:944;;;;;17488:1345;;:::o;20807:1021::-;20983:3;21012:1;21045:6;21039:13;21075:36;21101:9;21075:36;:::i;:::-;21130:1;21147:17;;;21173:133;;;;21320:1;21315:358;;;;21140:533;;21173:133;-1:-1:-1;;21206:24:1;;21194:37;;21279:14;;21272:22;21260:35;;21251:45;;;-1:-1:-1;21173:133:1;;21315:358;21346:6;21343:1;21336:17;21376:4;21421;21418:1;21408:18;21448:1;21462:165;21476:6;21473:1;21470:13;21462:165;;;21554:14;;21541:11;;;21534:35;21597:16;;;;21491:10;;21462:165;;;21466:3;;;21656:6;21651:3;21647:16;21640:23;;21140:533;;;;;21704:6;21698:13;21720:68;21779:8;21774:3;21767:4;21759:6;21755:17;21720:68;:::i;:::-;21804:18;;20807:1021;-1:-1:-1;;;;20807:1021:1:o;21833:184::-;21903:6;21956:2;21944:9;21935:7;21931:23;21927:32;21924:52;;;21972:1;21969;21962:12;21924:52;-1:-1:-1;21995:16:1;;21833:184;-1:-1:-1;21833:184:1:o;22022:273::-;22090:6;22143:2;22131:9;22122:7;22118:23;22114:32;22111:52;;;22159:1;22156;22149:12;22111:52;22191:9;22185:16;22241:4;22234:5;22230:16;22223:5;22220:27;22210:55;;22261:1;22258;22251:12;22300:125;22365:9;;;22386:10;;;22383:36;;;22399:18;;:::i;22430:399::-;22632:2;22614:21;;;22671:2;22651:18;;;22644:30;22710:34;22705:2;22690:18;;22683:62;-1:-1:-1;;;22776:2:1;22761:18;;22754:33;22819:3;22804:19;;22430:399::o;23572:489::-;-1:-1:-1;;;;;23841:15:1;;;23823:34;;23893:15;;23888:2;23873:18;;23866:43;23940:2;23925:18;;23918:34;;;23988:3;23983:2;23968:18;;23961:31;;;23766:4;;24009:46;;24035:19;;24027:6;24009:46;:::i;24066:249::-;24135:6;24188:2;24176:9;24167:7;24163:23;24159:32;24156:52;;;24204:1;24201;24194:12;24156:52;24236:9;24230:16;24255:30;24279:5;24255:30;:::i;24452:416::-;24541:1;24578:5;24541:1;24592:270;24613:7;24603:8;24600:21;24592:270;;;24672:4;24668:1;24664:6;24660:17;24654:4;24651:27;24648:53;;;24681:18;;:::i;:::-;24731:7;24721:8;24717:22;24714:55;;;24751:16;;;;24714:55;24830:22;;;;24790:15;;;;24592:270;;;24596:3;24452:416;;;;;:::o;24873:806::-;24922:5;24952:8;24942:80;;-1:-1:-1;24993:1:1;25007:5;;24942:80;25041:4;25031:76;;-1:-1:-1;25078:1:1;25092:5;;25031:76;25123:4;25141:1;25136:59;;;;25209:1;25204:130;;;;25116:218;;25136:59;25166:1;25157:10;;25180:5;;;25204:130;25241:3;25231:8;25228:17;25225:43;;;25248:18;;:::i;:::-;-1:-1:-1;;25304:1:1;25290:16;;25319:5;;25116:218;;25418:2;25408:8;25405:16;25399:3;25393:4;25390:13;25386:36;25380:2;25370:8;25367:16;25362:2;25356:4;25353:12;25349:35;25346:77;25343:159;;;-1:-1:-1;25455:19:1;;;25487:5;;25343:159;25534:34;25559:8;25553:4;25534:34;:::i;:::-;25604:6;25600:1;25596:6;25592:19;25583:7;25580:32;25577:58;;;25615:18;;:::i;:::-;25653:20;;24873:806;-1:-1:-1;;;24873:806:1:o;25684:131::-;25744:5;25773:36;25800:8;25794:4;25773:36;:::i;25820:168::-;25893:9;;;25924;;25941:15;;;25935:22;;25921:37;25911:71;;25962:18;;:::i;26272:245::-;26339:6;26392:2;26380:9;26371:7;26367:23;26363:32;26360:52;;;26408:1;26405;26398:12;26360:52;26440:9;26434:16;26459:28;26481:5;26459:28;:::i;26522:128::-;26589:9;;;26610:11;;;26607:37;;;26624:18;;:::i;26655:127::-;26716:10;26711:3;26707:20;26704:1;26697:31;26747:4;26744:1;26737:15;26771:4;26768:1;26761:15;26787:287;26916:3;26954:6;26948:13;26970:66;27029:6;27024:3;27017:4;27009:6;27005:17;26970:66;:::i;:::-;27052:16;;;;;26787:287;-1:-1:-1;;26787:287:1:o

ipfs://d58c764f4675a8de916a72a42928edbf9d10f826e40660adc0725dbcfd66fa35