Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

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

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

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

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

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

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

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

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

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

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

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Capped.sol)

pragma solidity ^0.8.0;

import "../ERC20.sol";

/**
 * @dev Extension of {ERC20} that adds a cap to the supply of tokens.
 */
abstract contract ERC20Capped is ERC20 {
    uint256 private immutable _cap;

    /**
     * @dev Sets the value of the `cap`. This value is immutable, it can only be
     * set once during construction.
     */
    constructor(uint256 cap_) {
        require(cap_ > 0, "ERC20Capped: cap is 0");
        _cap = cap_;
    }

    /**
     * @dev Returns the cap on the token's total supply.
     */
    function cap() public view virtual returns (uint256) {
        return _cap;
    }

    /**
     * @dev See {ERC20-_mint}.
     */
    function _mint(address account, uint256 amount) internal virtual override {
        require(ERC20.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
        super._mint(account, amount);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

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

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

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

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC721.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

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

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

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) 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(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

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

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

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

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..).
 *
 * Assumes the number of issuable tokens (collection size) is capped and fits in a uint128.
 *
 * Does not support burning tokens to address(0).
 */
contract ERC721A is
  Context,
  ERC165,
  IERC721,
  IERC721Metadata,
  IERC721Enumerable
{
  using Address for address;
  using Strings for uint256;

  struct TokenOwnership {
    address addr;
    uint64 startTimestamp;
  }

  struct AddressData {
    uint128 balance;
    uint128 numberMinted;
  }

  uint256 private currentIndex = 0;

  uint256 internal immutable collectionSize;
  uint256 internal immutable maxBatchSize;

  // Token name
  string private _name;

  // Token symbol
  string private _symbol;

  // Mapping from token ID to ownership details
  // An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
  mapping(uint256 => TokenOwnership) private _ownerships;

  // Mapping owner address to address data
  mapping(address => AddressData) private _addressData;

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

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

  /**
   * @dev
   * `maxBatchSize` refers to how much a minter can mint at a time.
   * `collectionSize_` refers to how many tokens are in the collection.
   */
  constructor(
    string memory name_,
    string memory symbol_,
    uint256 maxBatchSize_,
    uint256 collectionSize_
  ) {
    require(
      collectionSize_ > 0,
      "ERC721A: collection must have a nonzero supply"
    );
    require(maxBatchSize_ > 0, "ERC721A: max batch size must be nonzero");
    _name = name_;
    _symbol = symbol_;
    maxBatchSize = maxBatchSize_;
    collectionSize = collectionSize_;
  }

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

  /**
   * @dev See {IERC721Enumerable-tokenByIndex}.
   */
  function tokenByIndex(uint256 index) public view override returns (uint256) {
    require(index < totalSupply(), "ERC721A: global index out of bounds");
    return index;
  }

  /**
   * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
   * This read function is O(collectionSize). If calling from a separate contract, be sure to test gas first.
   * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
   */
  function tokenOfOwnerByIndex(address owner, uint256 index)
    public
    view
    override
    returns (uint256)
  {
    require(index < balanceOf(owner), "ERC721A: owner index out of bounds");
    uint256 numMintedSoFar = totalSupply();
    uint256 tokenIdsIdx = 0;
    address currOwnershipAddr = address(0);
    for (uint256 i = 0; i < numMintedSoFar; i++) {
      TokenOwnership memory ownership = _ownerships[i];
      if (ownership.addr != address(0)) {
        currOwnershipAddr = ownership.addr;
      }
      if (currOwnershipAddr == owner) {
        if (tokenIdsIdx == index) {
          return i;
        }
        tokenIdsIdx++;
      }
    }
    revert("ERC721A: unable to get token of owner by index");
  }

  /**
   * @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 ||
      interfaceId == type(IERC721Enumerable).interfaceId ||
      super.supportsInterface(interfaceId);
  }

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

  function _numberMinted(address owner) internal view returns (uint256) {
    require(
      owner != address(0),
      "ERC721A: number minted query for the zero address"
    );
    return uint256(_addressData[owner].numberMinted);
  }

  function ownershipOf(uint256 tokenId)
    internal
    view
    returns (TokenOwnership memory)
  {
    require(_exists(tokenId), "ERC721A: owner query for nonexistent token");

    uint256 lowestTokenToCheck;
    if (tokenId >= maxBatchSize) {
      lowestTokenToCheck = tokenId - maxBatchSize + 1;
    }

    for (uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) {
      TokenOwnership memory ownership = _ownerships[curr];
      if (ownership.addr != address(0)) {
        return ownership;
      }
    }

    revert("ERC721A: unable to determine the owner of token");
  }

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

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

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

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

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

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

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

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

    _approve(to, tokenId, owner);
  }

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

    return _tokenApprovals[tokenId];
  }

  /**
   * @dev See {IERC721-setApprovalForAll}.
   */
  function setApprovalForAll(address operator, bool approved) public override {
    require(operator != _msgSender(), "ERC721A: approve to caller");

    _operatorApprovals[_msgSender()][operator] = approved;
    emit ApprovalForAll(_msgSender(), operator, approved);
  }

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

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

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

  /**
   * @dev See {IERC721-safeTransferFrom}.
   */
  function safeTransferFrom(
    address from,
    address to,
    uint256 tokenId,
    bytes memory _data
  ) public override {
    _transfer(from, to, tokenId);
    require(
      _checkOnERC721Received(from, to, tokenId, _data),
      "ERC721A: transfer to non ERC721Receiver implementer"
    );
  }

  /**
   * @dev Returns whether `tokenId` exists.
   *
   * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
   *
   * Tokens start existing when they are minted (`_mint`),
   */
  function _exists(uint256 tokenId) internal view returns (bool) {
    return tokenId < currentIndex;
  }

  function _safeMint(address to, uint256 quantity) internal {
    _safeMint(to, quantity, "");
  }

  /**
   * @dev Mints `quantity` tokens and transfers them to `to`.
   *
   * Requirements:
   *
   * - there must be `quantity` tokens remaining unminted in the total collection.
   * - `to` cannot be the zero address.
   * - `quantity` cannot be larger than the max batch size.
   *
   * Emits a {Transfer} event.
   */
  function _safeMint(
    address to,
    uint256 quantity,
    bytes memory _data
  ) internal {
    uint256 startTokenId = currentIndex;
    require(to != address(0), "ERC721A: mint to the zero address");
    // We know if the first token in the batch doesn't exist, the other ones don't as well, because of serial ordering.
    require(!_exists(startTokenId), "ERC721A: token already minted");
    require(quantity <= maxBatchSize, "ERC721A: quantity to mint too high");

    _beforeTokenTransfers(address(0), to, startTokenId, quantity);

    AddressData memory addressData = _addressData[to];
    _addressData[to] = AddressData(
      addressData.balance + uint128(quantity),
      addressData.numberMinted + uint128(quantity)
    );
    _ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp));

    uint256 updatedIndex = startTokenId;

    for (uint256 i = 0; i < quantity; i++) {
      emit Transfer(address(0), to, updatedIndex);
      require(
        _checkOnERC721Received(address(0), to, updatedIndex, _data),
        "ERC721A: transfer to non ERC721Receiver implementer"
      );
      updatedIndex++;
    }

    currentIndex = updatedIndex;
    _afterTokenTransfers(address(0), to, startTokenId, quantity);
  }

  /**
   * @dev Transfers `tokenId` from `from` to `to`.
   *
   * 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
  ) private {
    TokenOwnership memory prevOwnership = ownershipOf(tokenId);

    bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
      getApproved(tokenId) == _msgSender() ||
      isApprovedForAll(prevOwnership.addr, _msgSender()));

    require(
      isApprovedOrOwner,
      "ERC721A: transfer caller is not owner nor approved"
    );

    require(
      prevOwnership.addr == from,
      "ERC721A: transfer from incorrect owner"
    );
    require(to != address(0), "ERC721A: transfer to the zero address");

    _beforeTokenTransfers(from, to, tokenId, 1);

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

    _addressData[from].balance -= 1;
    _addressData[to].balance += 1;
    _ownerships[tokenId] = TokenOwnership(to, uint64(block.timestamp));

    // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
    // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
    uint256 nextTokenId = tokenId + 1;
    if (_ownerships[nextTokenId].addr == address(0)) {
      if (_exists(nextTokenId)) {
        _ownerships[nextTokenId] = TokenOwnership(
          prevOwnership.addr,
          prevOwnership.startTimestamp
        );
      }
    }

    emit Transfer(from, to, tokenId);
    _afterTokenTransfers(from, to, tokenId, 1);
  }

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

  uint256 public nextOwnerToExplicitlySet = 0;

  /**
   * @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf().
   */
  function _setOwnersExplicit(uint256 quantity) internal {
    uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet;
    require(quantity > 0, "quantity must be nonzero");
    uint256 endIndex = oldNextOwnerToSet + quantity - 1;
    if (endIndex > collectionSize - 1) {
      endIndex = collectionSize - 1;
    }
    // We know if the last one in the group exists, all in the group exist, due to serial ordering.
    require(_exists(endIndex), "not enough minted yet for this cleanup");
    for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) {
      if (_ownerships[i].addr == address(0)) {
        TokenOwnership memory ownership = ownershipOf(i);
        _ownerships[i] = TokenOwnership(
          ownership.addr,
          ownership.startTimestamp
        );
      }
    }
    nextOwnerToExplicitlySet = endIndex + 1;
  }

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

  /**
   * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
   *
   * startTokenId - the first token id to be transferred
   * quantity - the amount to be transferred
   *
   * Calling conditions:
   *
   * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
   * transferred to `to`.
   * - When `from` is zero, `tokenId` will be minted for `to`.
   */
  function _beforeTokenTransfers(
    address from,
    address to,
    uint256 startTokenId,
    uint256 quantity
  ) internal virtual {}

  /**
   * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
   * minting.
   *
   * startTokenId - the first token id to be transferred
   * quantity - the amount to be transferred
   *
   * Calling conditions:
   *
   * - when `from` and `to` are both non-zero.
   * - `from` and `to` are never both zero.
   */
  function _afterTokenTransfers(
    address from,
    address to,
    uint256 startTokenId,
    uint256 quantity
  ) internal virtual {}
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./ERC721A.sol";

contract TBone is ERC20Capped, Ownable, ReentrancyGuard {
  bool public phaseOneOpen = false;
  bool public phaseTwoOpen = false;

  // Phase Supply Limit

  uint256 public _phaseOneSupply = 20984691 * 1e18; // phase 1 supply
  uint256 public _phaseTwoSupply = 29849070 * 1e18; // phase 2 supply

  uint256 public _reserveSupply = 18166239 * 1e18; // reserved supply

  address signer;

  struct Claim {
    bool isClaimed;
    address addressClaimed;
  }

  mapping(address => uint256) addressBlockBought;
  mapping(string => bool) signatureUsed;
  mapping(uint256 => Claim) public isTboneClaimed;
  mapping(string => Claim) public isPhaseTwoClaimed;

  constructor(
    uint256 cap, 
    address _signer, 
    address[] memory receipient, 
    uint256[] memory amount
    ) ERC20("TBone", "TBONE") ERC20Capped(cap * 1e18) {
    signer = _signer;
    _mint(msg.sender, _reserveSupply);

    for(uint256 i = 0; i < receipient.length; i++) {
      _mint(receipient[i], amount[i] * 1e18);
    }
  }

  modifier isSecured(uint8 phaseType) {
    require(addressBlockBought[msg.sender] < block.timestamp, "Not allowed to proceed in the same block");
    require(tx.origin == msg.sender, "Sender is not allowed to mint");

    if (phaseType == 1) {
      require(phaseOneOpen, "Phase 1 not active");
    }
    if (phaseType == 2) {
      require(phaseTwoOpen, "Phase 2 not active");
    }
    _;
  }

  function togglePhaseOne() external onlyOwner {
    phaseOneOpen = !phaseOneOpen;
  }

  function togglePhaseTwo() external onlyOwner {
    phaseTwoOpen = !phaseTwoOpen;
  }

  function claimTbonePhaseOne(uint64 expireTime, bytes memory sig, uint256 amount, uint256[] memory tokenIds) external isSecured(1) {
    bytes32 digest = keccak256(abi.encodePacked(msg.sender, amount, expireTime));
    uint256 claim_amount = amount * 1e18;
    require(isAuthorized(sig, digest), "Signature is invalid");
    require(totalSupply() + claim_amount <= _phaseOneSupply + _reserveSupply, "Amount exceeds the phase supply");
    require(totalSupply() + claim_amount <= cap(), "Supply is depleted");
    require(signatureUsed[string(sig)] == false, "Signature is already used");
    require(amount > 0, "Amount should be greater than 0");

    for(uint256 i = 0; i < tokenIds.length; i++) {
      require(!isTboneClaimed[tokenIds[i]].isClaimed, "Already Claimed");
      isTboneClaimed[tokenIds[i]] = Claim(true, msg.sender);
    }
    signatureUsed[string(sig)] = true;
    addressBlockBought[msg.sender] = block.timestamp;
    _mint(msg.sender, claim_amount);
  }

  function claimTbonePhaseTwo(bytes memory sig, uint64 exp, uint256 amount, string[] memory entryId) external isSecured(2) {
    bytes32 digest = keccak256(abi.encodePacked(msg.sender, amount, exp));
    uint256 claim_amount = amount * 1e18;
    require(isAuthorized(sig, digest), "Signature is invalid");
    require(totalSupply() + claim_amount <= _phaseOneSupply + _phaseTwoSupply + _reserveSupply, "Amount exceeds the phase supply");
    require(totalSupply() + claim_amount <= cap(), "Supply is depleted");
    require(signatureUsed[string(sig)] == false, "Signature is already used");
    require(amount > 0, "Amount should be greater than 0");

    for(uint256 i = 0; i < entryId.length; i++) {
      require(!isPhaseTwoClaimed[entryId[i]].isClaimed, "Already Claimed");
      isPhaseTwoClaimed[entryId[i]] = Claim(true, msg.sender);
    }
    
    signatureUsed[string(sig)] = true;
    addressBlockBought[msg.sender] = block.timestamp;
    _mint(msg.sender, claim_amount);
  }

  function setSigner(address _signer) external onlyOwner {
    signer = _signer;
  }

  function setIsClaimed(uint256[] memory _tokenIds, address[] memory owner, bool _isClaimed) external onlyOwner {
    for(uint256 i = 0; i < _tokenIds.length; i++) {
      isTboneClaimed[_tokenIds[i]] = Claim(_isClaimed, owner[i]);
    }
  }

  function isAuthorized(bytes memory sig, bytes32 digest) private view returns (bool) {
    return ECDSA.recover(digest, sig) == signer;
  }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"address","name":"_signer","type":"address"},{"internalType":"address[]","name":"receipient","type":"address[]"},{"internalType":"uint256[]","name":"amount","type":"uint256[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"_phaseOneSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_phaseTwoSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_reserveSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"expireTime","type":"uint64"},{"internalType":"bytes","name":"sig","type":"bytes"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"claimTbonePhaseOne","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"sig","type":"bytes"},{"internalType":"uint64","name":"exp","type":"uint64"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"string[]","name":"entryId","type":"string[]"}],"name":"claimTbonePhaseTwo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"isPhaseTwoClaimed","outputs":[{"internalType":"bool","name":"isClaimed","type":"bool"},{"internalType":"address","name":"addressClaimed","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"isTboneClaimed","outputs":[{"internalType":"bool","name":"isClaimed","type":"bool"},{"internalType":"address","name":"addressClaimed","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"phaseOneOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"phaseTwoOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"address[]","name":"owner","type":"address[]"},{"internalType":"bool","name":"_isClaimed","type":"bool"}],"name":"setIsClaimed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signer","type":"address"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"togglePhaseOne","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"togglePhaseTwo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b50600436106101c45760003560e01c80636cb1bbcc116100f9578063a457c2d711610097578063de3e7f7811610071578063de3e7f7814610408578063e27f76ac14610411578063f2fde38b14610419578063f7f00ef61461042c57600080fd5b8063a457c2d7146103cf578063a9059cbb146103e2578063dd62ed3e146103f557600080fd5b80638da5cb5b116100d35780638da5cb5b146103665780638eab37581461038157806395d89b41146103b4578063973404f7146103bc57600080fd5b80636cb1bbcc1461032257806370a0823114610335578063715018a61461035e57600080fd5b8063313ce56711610166578063631588d811610140578063631588d8146102e757806365c16038146102f45780636abb908d146103065780636c19e7831461030f57600080fd5b8063313ce5671461029f578063355274ea146102ae57806339509351146102d457600080fd5b8063095ea7b3116101a2578063095ea7b3146102575780630a0a4b381461027a57806318160ddd1461028457806323b872dd1461028c57600080fd5b8063037d5556146101c957806306fdde03146101e5578063080dfb77146101fa575b600080fd5b6101d260095481565b6040519081526020015b60405180910390f35b6101ed61043f565b6040516101dc9190611945565b610238610208366004611a2f565b8051602081830181018051600f8252928201919093012091525460ff81169061010090046001600160a01b031682565b6040805192151583526001600160a01b039091166020830152016101dc565b61026a610265366004611a88565b6104d1565b60405190151581526020016101dc565b6102826104eb565b005b6002546101d2565b61026a61029a366004611ab2565b61050d565b604051601281526020016101dc565b7f0000000000000000000000000000000000000000003913517ebd3c0c650000006101d2565b61026a6102e2366004611a88565b610531565b60075461026a9060ff1681565b60075461026a90610100900460ff1681565b6101d260085481565b61028261031d366004611aee565b610553565b610282610330366004611baf565b61057d565b6101d2610343366004611aee565b6001600160a01b031660009081526020819052604090205490565b61028261064d565b6005546040516001600160a01b0390911681526020016101dc565b61023861038f366004611c81565b600e6020526000908152604090205460ff81169061010090046001600160a01b031682565b6101ed610661565b6102826103ca366004611cb2565b610670565b61026a6103dd366004611a88565b610b66565b61026a6103f0366004611a88565b610be1565b6101d2610403366004611d9f565b610bef565b6101d2600a5481565b610282610c1a565b610282610427366004611aee565b610c3f565b61028261043a366004611dd2565b610cb8565b60606003805461044e90611e50565b80601f016020809104026020016040519081016040528092919081815260200182805461047a90611e50565b80156104c75780601f1061049c576101008083540402835291602001916104c7565b820191906000526020600020905b8154815290600101906020018083116104aa57829003601f168201915b5050505050905090565b6000336104df81858561120b565b60019150505b92915050565b6104f361132f565b6007805460ff19811660ff90911615179055565b60025490565b60003361051b858285611389565b6105268585856113fd565b506001949350505050565b6000336104df8185856105448383610bef565b61054e9190611ea0565b61120b565b61055b61132f565b600b80546001600160a01b0319166001600160a01b0392909216919091179055565b61058561132f565b60005b835181101561064757604051806040016040528083151581526020018483815181106105b6576105b6611eb3565b60200260200101516001600160a01b0316815250600e60008684815181106105e0576105e0611eb3565b6020908102919091018101518252818101929092526040016000208251815493909201516001600160a01b031661010002610100600160a81b0319921515929092166001600160a81b0319909316929092171790558061063f81611ec9565b915050610588565b50505050565b61065561132f565b61065f60006115a1565b565b60606004805461044e90611e50565b336000908152600c602052604090205460029042116106aa5760405162461bcd60e51b81526004016106a190611ee2565b60405180910390fd5b3233146106f95760405162461bcd60e51b815260206004820152601d60248201527f53656e646572206973206e6f7420616c6c6f77656420746f206d696e7400000060448201526064016106a1565b8060ff1660010361074b5760075460ff1661074b5760405162461bcd60e51b815260206004820152601260248201527150686173652031206e6f742061637469766560701b60448201526064016106a1565b8060ff166002036107a257600754610100900460ff166107a25760405162461bcd60e51b815260206004820152601260248201527150686173652032206e6f742061637469766560701b60448201526064016106a1565b60003384866040516020016107b993929190611f2a565b604051602081830303815290604052805190602001209050600084670de0b6b3a76400006107e79190611f61565b90506107f387836115f3565b6108365760405162461bcd60e51b815260206004820152601460248201527314da59db985d1d5c99481a5cc81a5b9d985b1a5960621b60448201526064016106a1565b600a546009546008546108499190611ea0565b6108539190611ea0565b8161085d60025490565b6108679190611ea0565b11156108b55760405162461bcd60e51b815260206004820152601f60248201527f416d6f756e7420657863656564732074686520706861736520737570706c790060448201526064016106a1565b7f0000000000000000000000000000000000000000003913517ebd3c0c65000000816108e060025490565b6108ea9190611ea0565b111561092d5760405162461bcd60e51b815260206004820152601260248201527114dd5c1c1b1e481a5cc819195c1b195d195960721b60448201526064016106a1565b600d8760405161093d9190611f80565b9081526040519081900360200190205460ff16156109995760405162461bcd60e51b815260206004820152601960248201527814da59db985d1d5c99481a5cc8185b1c9958591e481d5cd959603a1b60448201526064016106a1565b600085116109e95760405162461bcd60e51b815260206004820152601f60248201527f416d6f756e742073686f756c642062652067726561746572207468616e20300060448201526064016106a1565b60005b8451811015610b0e57600f858281518110610a0957610a09611eb3565b6020026020010151604051610a1e9190611f80565b9081526040519081900360200190205460ff1615610a705760405162461bcd60e51b815260206004820152600f60248201526e105b1c9958591e4810db185a5b5959608a1b60448201526064016106a1565b60408051808201909152600181523360208201528551600f90879084908110610a9b57610a9b611eb3565b6020026020010151604051610ab09190611f80565b9081526040519081900360209081019091208251815493909201516001600160a01b031661010002610100600160a81b0319921515929092166001600160a81b03199093169290921717905580610b0681611ec9565b9150506109ec565b506001600d88604051610b219190611f80565b9081526040805160209281900383019020805460ff191693151593909317909255336000818152600c909252919020429055610b5d908261161d565b50505050505050565b60003381610b748286610bef565b905083811015610bd45760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77604482015264207a65726f60d81b60648201526084016106a1565b610526828686840361120b565b6000336104df8185856113fd565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b610c2261132f565b6007805461ff001981166101009182900460ff1615909102179055565b610c4761132f565b6001600160a01b038116610cac5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016106a1565b610cb5816115a1565b50565b336000908152600c60205260409020546001904211610ce95760405162461bcd60e51b81526004016106a190611ee2565b323314610d385760405162461bcd60e51b815260206004820152601d60248201527f53656e646572206973206e6f7420616c6c6f77656420746f206d696e7400000060448201526064016106a1565b8060ff16600103610d8a5760075460ff16610d8a5760405162461bcd60e51b815260206004820152601260248201527150686173652031206e6f742061637469766560701b60448201526064016106a1565b8060ff16600203610de157600754610100900460ff16610de15760405162461bcd60e51b815260206004820152601260248201527150686173652032206e6f742061637469766560701b60448201526064016106a1565b6000338487604051602001610df893929190611f2a565b604051602081830303815290604052805190602001209050600084670de0b6b3a7640000610e269190611f61565b9050610e3286836115f3565b610e755760405162461bcd60e51b815260206004820152601460248201527314da59db985d1d5c99481a5cc81a5b9d985b1a5960621b60448201526064016106a1565b600a54600854610e859190611ea0565b81610e8f60025490565b610e999190611ea0565b1115610ee75760405162461bcd60e51b815260206004820152601f60248201527f416d6f756e7420657863656564732074686520706861736520737570706c790060448201526064016106a1565b7f0000000000000000000000000000000000000000003913517ebd3c0c6500000081610f1260025490565b610f1c9190611ea0565b1115610f5f5760405162461bcd60e51b815260206004820152601260248201527114dd5c1c1b1e481a5cc819195c1b195d195960721b60448201526064016106a1565b600d86604051610f6f9190611f80565b9081526040519081900360200190205460ff1615610fcb5760405162461bcd60e51b815260206004820152601960248201527814da59db985d1d5c99481a5cc8185b1c9958591e481d5cd959603a1b60448201526064016106a1565b6000851161101b5760405162461bcd60e51b815260206004820152601f60248201527f416d6f756e742073686f756c642062652067726561746572207468616e20300060448201526064016106a1565b60005b845181101561113857600e600086838151811061103d5761103d611eb3565b60209081029190910181015182528101919091526040016000205460ff161561109a5760405162461bcd60e51b815260206004820152600f60248201526e105b1c9958591e4810db185a5b5959608a1b60448201526064016106a1565b6040518060400160405280600115158152602001336001600160a01b0316815250600e60008784815181106110d1576110d1611eb3565b6020908102919091018101518252818101929092526040016000208251815493909201516001600160a01b031661010002610100600160a81b0319921515929092166001600160a81b0319909316929092171790558061113081611ec9565b91505061101e565b506001600d87604051610b219190611f80565b6001600160a01b0382166111a15760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f20616464726573730060448201526064016106a1565b80600260008282546111b39190611ea0565b90915550506001600160a01b038216600081815260208181526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a35b5050565b6001600160a01b03831661126d5760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b60648201526084016106a1565b6001600160a01b0382166112ce5760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b60648201526084016106a1565b6001600160a01b0383811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b6005546001600160a01b0316331461065f5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016106a1565b60006113958484610bef565b9050600019811461064757818110156113f05760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e636500000060448201526064016106a1565b610647848484840361120b565b6001600160a01b0383166114615760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b60648201526084016106a1565b6001600160a01b0382166114c35760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b60648201526084016106a1565b6001600160a01b0383166000908152602081905260409020548181101561153b5760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604482015265616c616e636560d01b60648201526084016106a1565b6001600160a01b03848116600081815260208181526040808320878703905593871680835291849020805487019055925185815290927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3610647565b600580546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b600b546000906001600160a01b031661160c83856116aa565b6001600160a01b0316149392505050565b7f0000000000000000000000000000000000000000003913517ebd3c0c650000008161164860025490565b6116529190611ea0565b11156116a05760405162461bcd60e51b815260206004820152601960248201527f45524332304361707065643a206361702065786365656465640000000000000060448201526064016106a1565b611207828261114b565b60008060006116b985856116ce565b915091506116c681611713565b509392505050565b60008082516041036117045760208301516040840151606085015160001a6116f88782858561185d565b9450945050505061170c565b506000905060025b9250929050565b600081600481111561172757611727611f9c565b0361172f5750565b600181600481111561174357611743611f9c565b036117905760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e6174757265000000000000000060448201526064016106a1565b60028160048111156117a4576117a4611f9c565b036117f15760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e6774680060448201526064016106a1565b600381600481111561180557611805611f9c565b03610cb55760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b60648201526084016106a1565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08311156118945750600090506003611918565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa1580156118e8573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b03811661191157600060019250925050611918565b9150600090505b94509492505050565b60005b8381101561193c578181015183820152602001611924565b50506000910152565b6020815260008251806020840152611964816040850160208701611921565b601f01601f19169190910160400192915050565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff811182821017156119b7576119b7611978565b604052919050565b600082601f8301126119d057600080fd5b813567ffffffffffffffff8111156119ea576119ea611978565b6119fd601f8201601f191660200161198e565b818152846020838601011115611a1257600080fd5b816020850160208301376000918101602001919091529392505050565b600060208284031215611a4157600080fd5b813567ffffffffffffffff811115611a5857600080fd5b611a64848285016119bf565b949350505050565b80356001600160a01b0381168114611a8357600080fd5b919050565b60008060408385031215611a9b57600080fd5b611aa483611a6c565b946020939093013593505050565b600080600060608486031215611ac757600080fd5b611ad084611a6c565b9250611ade60208501611a6c565b9150604084013590509250925092565b600060208284031215611b0057600080fd5b611b0982611a6c565b9392505050565b600067ffffffffffffffff821115611b2a57611b2a611978565b5060051b60200190565b600082601f830112611b4557600080fd5b81356020611b5a611b5583611b10565b61198e565b82815260059290921b84018101918181019086841115611b7957600080fd5b8286015b84811015611b945780358352918301918301611b7d565b509695505050505050565b80358015158114611a8357600080fd5b600080600060608486031215611bc457600080fd5b833567ffffffffffffffff80821115611bdc57600080fd5b611be887838801611b34565b9450602091508186013581811115611bff57600080fd5b86019050601f81018713611c1257600080fd5b8035611c20611b5582611b10565b81815260059190911b82018301908381019089831115611c3f57600080fd5b928401925b82841015611c6457611c5584611a6c565b82529284019290840190611c44565b8096505050505050611c7860408501611b9f565b90509250925092565b600060208284031215611c9357600080fd5b5035919050565b803567ffffffffffffffff81168114611a8357600080fd5b60008060008060808587031215611cc857600080fd5b843567ffffffffffffffff80821115611ce057600080fd5b611cec888389016119bf565b955060209150611cfd828801611c9a565b945060408701359350606087013581811115611d1857600080fd5b8701601f81018913611d2957600080fd5b8035611d37611b5582611b10565b81815260059190911b8201840190848101908b831115611d5657600080fd5b8584015b83811015611d8e57803586811115611d725760008081fd5b611d808e89838901016119bf565b845250918601918601611d5a565b50989b979a50959850505050505050565b60008060408385031215611db257600080fd5b611dbb83611a6c565b9150611dc960208401611a6c565b90509250929050565b60008060008060808587031215611de857600080fd5b611df185611c9a565b9350602085013567ffffffffffffffff80821115611e0e57600080fd5b611e1a888389016119bf565b9450604087013593506060870135915080821115611e3757600080fd5b50611e4487828801611b34565b91505092959194509250565b600181811c90821680611e6457607f821691505b602082108103611e8457634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b808201808211156104e5576104e5611e8a565b634e487b7160e01b600052603260045260246000fd5b600060018201611edb57611edb611e8a565b5060010190565b60208082526028908201527f4e6f7420616c6c6f77656420746f2070726f6365656420696e207468652073616040820152676d6520626c6f636b60c01b606082015260800190565b60609390931b6bffffffffffffffffffffffff19168352601483019190915260c01b6001600160c01b0319166034820152603c0190565b6000816000190483118215151615611f7b57611f7b611e8a565b500290565b60008251611f92818460208701611921565b9190910192915050565b634e487b7160e01b600052602160045260246000fdfea2646970667358221220b5d438ee181ecf6bfff1671de74a070c7e13430452eca14e1059f7ff8ada514364736f6c63430008100033

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

-----Decoded View---------------
Arg [0] : cap (uint256): 69000000
Arg [1] : _signer (address): 0x617A2b689fD584ab7Bf6ee914f6Afcd3090deA4f
Arg [2] : receipient (address[]): 0xc9a65A7561619D9e6E7e8C6D8a63Ff5d4365aae0,0x056EDAB5Ac58ff2f92C9CeB49fE9866BA034EbB1,0x6ddcE6089D4Ab0Dc90204e92071031c0C80DDc76,0x4cFDA5B63E80e309882E52971132cB035A25b4E2,0x973a0C43f17aD37421bBcD272a8D2ee0B4C61a87,0xd3027794E08bb744a6640EF3e39694c7C840899c,0x01feAC78015114371251E79EC564E8BfD23214A1,0x53615Db874A51bF22089e6677F56D1812C6a4150,0x6867c340F17cb63f243d9062B31144C2a692fBD1,0x0f1B8176466695875a421893333455a2D5016362,0x9888eDdF5CC6c5Bda466a994F0Ebd8efB5ee90d1,0x977E302B1554C970E9f0Ea88A63FA78FE4D7AFE4,0xb2E0F4dee26CcCf1f3A267Ad185f212Dd3e7a6b1,0x4eB59146668537fB4C0FE35C0d1a2aEBCcB53272,0xBb13C0560C8A8354E6A914f1f2b873CEfE0dF9F7,0x1Df3810db24b44aeb62242FC5011fe6671135389,0x93Ce5486824C3e5beA5561ce7e7DAcD51F924526,0xd11BAA5966e266396e9Ed723C96B613B9C39620c,0xBa52c4B1bf0a3a2788c87f4D785B7B0B59F79169,0x854969544408FCEfb326464B0787227eb767BDDE,0x1fd0847d0d2cd41c18cAf7F755779A7Cf92B6394,0x9232355Dba7473A47887abb6Df1AB76e1BB7B456,0x43f78f7CDD066427B9D0b8fE19220B3325A0e1f1,0x9275198560dF5215440565C6Bd0b9d2E99b6aa9C,0x24343b73379831d7A200968b9D69e98D2C2f4fD2,0xf8A06c01b8AbA37204E15c03C5a2b351C3e284FE,0x3a327EaaFD07A8F4f5001481943E69D8c618e2FB,0xeA98c541CB125E42bFB23d35331A49dF59f22b05,0x0B363d91e9455333e0Ce12AE9C25356CD5Ff9602,0x64Db6ff0D04ddD8A1AD693DF6709E6c1B61c1365,0x535d3E92DF5F3D51Da66021aA5c3896B688b8076,0x31A5b6b433f30Fd55EA147C1BE2b6C7E0389CEE0,0x6719b8a3d44777d5f43D96DE0F0f91a57Aed7A3A,0x015Ee97544A8B44460F51860EfBdD769cFcb20E3,0x3D52b45278e81985Bd5733C645A7A21b0912BBFA,0xd7147d3EF653ABcAFb13035B6aAEAbF68032f5AD,0xc4eFF7Bd089A515355B23b0cd79Eb5EF08e6FEFE,0x8ad400C7A6db13159baE9c2bEa879501e981788D,0x88815CeE9D678B6e288fb48DA3abbD4514Ff06C3,0x8d2501C2eFe7dAfF638cE9145b36040B3f1cb6f6,0x7CD175BF2d10CDA21130b2255413b294BdcE970B,0x8209A0f91fE84e756A624F079e51E9E29fDC252a,0x73d90dB79da0eE77C42cD6014180Cb69602a3a22,0xDAB0F4C7db6e55B29B4cCd9471A60740573E23B4,0xB9833C4e67212E560855CC15C2746fA14E9337aC,0x8d114068e90845ad5FD9Eb91157802b9E4B36ce4,0x41009b7eaCD96B01687EC633962256ED1C433229,0x4De76a2D2A4deCFd68566889E63D571173F930e4,0x5381315A97df70fC1f47fe8489eFB12ad48FC187,0xaaF851270B5FD32bAEc366BF56161cFF6Cb97fb9,0xBde56c3FeB1Da63a6759D8A34c74f8602A0b2731,0xAb66Ec57D13429D59038C119544041f09f2b16BE,0xC541BC01c71D83f10f42f5040094cdFfED5741b1,0x9F6CDd213bc4BCd29921264a86eDa57A339A43b3,0x3EA5Faf6b9A05876128B50b52db6f2C25b30b32b,0x47B8Cc37D6128122585AB7fa6f6f02f25C958b59,0x5eF25c9e0E0c17257f437087A1fc629c1151c5e9,0x973Ee618BFd3fb0e49c8A1a0CA2e2E6Aeb930aF3,0x9Fe7D6Fb7e14F0cfa8cDa7BF539aD1B021F6bd2a,0xB53cD2295012a31EFc99d278596CE7C963F7BAe5,0xb9fE1E88622e712546Ef7D0d9dc00DbA25282A93,0x6d621AE05e58F3216E783B619dC9CCd81D5Db9F6,0x82b1E570e4dd0B87c1CCa4b22C500fe6956CeDB0,0x6b7e9bF25cebcFA5C782fB5A6b0BaB5ABE3C100A,0x92c5b356e99d12Dac31d8e1e9fA84735132386DA,0xf866B5b53EA94F640b19e7550fe4fD2C18bfaFfb,0x30E7B25175Cd2d8EA54E22df246B1562CCD258dF,0xB7E1789D7DCc6E0E40b35796FFF1516CE9d794fD,0xA56f58b68d196Ac01849F6F95DFEF644520730AD,0xC2F259B7d529357D207dfBE74540f4430605d3ea,0xd5454F9505f2374d5F1f1eD81528D6D26FaE9322,0x77B2f25816450FD70cc1854fc5767b061de54173,0xA22aa948E131f1b98c710cBBdEC57dB7Ba027FFB,0x2Da791359933011B4F74042a241Fbbf09F6CBcAB,0x301392a1d8C68bb21a91ECBD3F67237D87D8BfAC,0x845Bdc128ea511cCdF38b3fE47201195b689B123,0xED3D39bB918500B520e601df4f1eFC14feAe3872,0x47C3c798d5a906f5AAbeE62b1CBc6368eD1c8898,0xAb9c177023A3a212948CdAEE64b1e8654fEcADEa,0xF202223e1903b3bAAB3574B89Febc576052a16eA,0x1925F489BF876e2F218a5D5D9b48f50469cB4220,0x53FA7673371d5c3F033265671F67434e023512F6,0x9E38c367ca5dbEbaA449F6ADe17A2a895342E260,0x7C5Ce57d179F51aB5043ce9b897Fca4AD500Ad63,0x1d79a3770b3598d25Fa10682b35626B237011074,0x559B07AFDF937c8Ff425cc506735C93015B341Dd,0x34E667710C5f5FBF366023FA1664bfC71e4BB2aE,0x909c31560DB77C1ab9e7F2E23fc6fFC2F16D1BfC,0x1a5389cAA12792eECDB8651312A346773778e52D,0x71866Ffb7E700E0832aD51f230B75668305493ff,0x2935C4D9CFE50413870A592D1EC368bB691De2D7,0x26D9c8Aca64882A05C43a59AD5b59cc5E6cE20be,0x2248bf80865f89ae6d029c080B344D1B66aCD8C8,0xF692ec3d930D26A0287bA28f75DC718330558168,0xD001A432318c1eb228C5E9AC9a55C24F2F32eF2A,0x1A7c37ae22a75AD0e428b75E4C8311bA82A75105,0x2c64dA7097533DB7a585ee62CDE17CAE0bCb2046,0x0196cBc6C7B1506C2385c8D29850dfe2a317FE00,0x9Fe2aB08d8A63b1D6dD6C9E55561149BDED65FD9,0x86883dAD25ceF1ACE4bBbBD40807e710BDF435c0,0xd965667BA11a3c20CAa64b6EDDDD5379e98f0eB8,0xAB1632d51237D6D3D605B9a90bdB7aF6F2B79E78,0xAC2DD8a732d6ce49BaB1cd48a5672Ce076bbB5E4,0x6C4Fd511973a0097D235F1D11F7Ce18EDD0e9F63,0x906a485BBdd9260219bf9a385254De0CFcbf650B,0x940EC171090E4920f3ADb90D52c66Ff1dFbe7037,0x110A413472687D3fF215a5793BedF24E7E16251F,0x6C6499802a591b6d25d916e5984ac9dB34b96108,0x224Bd2eDFc38c3B6Fa7E615C58908d803a4B770E,0xf6DD849a1C72E4FBd9c8c1d06de5660C0aF3e67E,0x6D31ea580f7de23518f074ff5d32E87C0b577880,0x07C4A05a8e9F038fA2E708A2CbAbBc79d065CD58,0x9eF46a791ecb0199E59CD4b1A549307fB52bF919,0x406d7bc28B3E226E89803212ad979F90EecFD525,0xa0FE2486b4a9d860B9b246980A07F790e8fEfd77,0x7458e69a5B3F33c56C77c0BFDb5B30F6E6AFA452,0x8c63625AFa43D517f50712C50989A3Fd87B5eD4C,0x1c9eA0BB36A9fa526f76b51DD55Ce1F23D352c26,0xb2e1462847E6244f9931915EA2294005643B4861,0xa159aB70DfcB10f4b3714317070A8625eCb9895b,0xd3A5247aE8E4D6038F55b103d5F5cAfd2efd8e92,0x317444472B04374DFd63494bacf41D9d23EdBb71,0x64E55C710550A89D00F39E38dFd07548b51B4943,0x19a23BDa7C6c09E691454e1bE07FAa54c4b9d9da,0xb161b69cEc2fC8af7f146F19d02F9E86806e9CDc,0x9af99903aEC634A8060d511A896CdE774623D7aa,0x15Ef6067CB7f8aa57C8A3cC51175Ec0298752567,0x6f9cFAccA63145c906fAE462433Aa1d1F147eec9,0x5836E12ec2cCD5e43aE27aef8804A0281E7876eb,0x8e0879FD2E8B499E86C60706e518fc1aEaa2abAB,0xc1A0c3980e9dF32ea752aB673351008287B7f6A5,0x53971185820c818351C90C51b8b358EEA400b5b4,0xbDC90Db179f44668bbECdAa62333207BBdb350ee,0x03fF18d6F1a9F90E7A37cd228629a159d6576598,0xFF8cbA42f41f6736c236A22ef565a6884e705efF,0xd8fEf6a115D444cBD283Ebc80567851c1F28767C,0xE218115537e73023486BcABC23f5315677AB2055,0x4E35554E4065d9c8352CB076FB4B2e0E5AAB4564,0x3c12bA2B6D6a1f1Bc754315d30eBd65F954A7530,0x9be99D014990d0DA6c96c7Ff97Ef915cE24Aef83,0x8187098B10f95eE29C8C244699744f95c84d6305,0xCAda0879e545D046EddC16838a69c8E6aaB7D72C,0x8a5a03ca4391Ea37970cd3f18f30578efFA0F699,0x6a75CF98bcBC78E204c2a8733cdd62027acbf92F,0xEC959F0D95793CC120c09034cc9F10212656a952,0xD4c39f36fB7AD8D7FF491885F19d905415b81267,0x51510CF446DB43068507b6D9EfD9b33Ab5238451,0x084195E5ED377212DbEEBc1A8615Bfd77c744790,0xAf2564E7fbA89f16942c798EbaeC2653049e33CE,0xC500A3D9A20086a559f55a616587A9192e201751,0x793260f70fDBc74840502f936e6b1E09A2Daa6bb,0x543ab56119496b81580d42b134f4061ed4b7619e,0x0D9d8Be1f3494e0228646f92E7C2f0aB4af67d7b
Arg [3] : amount (uint256[]): 1704,2056,2056,2306,2306,2908,3144,3185,3394,3537,3613,4012,4112,4306,4556,4694,4852,4852,5330,5333,5350,5363,5655,5695,5726,5746,5753,6224,6243,6423,6444,6486,6587,6595,6605,6885,6898,6937,6964,7030,7102,7106,7129,7338,7666,7715,7724,7999,8119,8122,8168,8269,8304,8346,8380,8408,8410,8426,8428,8438,8438,8561,8568,8579,8593,8617,8633,8650,8658,8670,8670,8696,8724,8840,9095,9186,9263,9275,9367,9518,9535,9646,10373,10391,10408,10555,10650,10766,10821,10967,11234,11557,12712,12893,12991,13468,13707,14235,14898,14980,15365,15663,16530,16567,16685,16911,16966,16973,17077,17400,17512,17544,17909,18052,18471,18490,18565,18725,19049,19176,19530,20191,21317,23155,23826,25883,25986,26114,26323,27269,27696,28257,28396,30534,33615,36393,36730,36937,38078,38486,39520,39638,39849,42797,46191,66561,67337,75770,86047,121076,133510,221019,254568

-----Encoded View---------------
312 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000041cdb40
Arg [1] : 000000000000000000000000617a2b689fd584ab7bf6ee914f6afcd3090dea4f
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [3] : 00000000000000000000000000000000000000000000000000000000000013c0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000099
Arg [5] : 000000000000000000000000c9a65a7561619d9e6e7e8c6d8a63ff5d4365aae0
Arg [6] : 000000000000000000000000056edab5ac58ff2f92c9ceb49fe9866ba034ebb1
Arg [7] : 0000000000000000000000006ddce6089d4ab0dc90204e92071031c0c80ddc76
Arg [8] : 0000000000000000000000004cfda5b63e80e309882e52971132cb035a25b4e2
Arg [9] : 000000000000000000000000973a0c43f17ad37421bbcd272a8d2ee0b4c61a87
Arg [10] : 000000000000000000000000d3027794e08bb744a6640ef3e39694c7c840899c
Arg [11] : 00000000000000000000000001feac78015114371251e79ec564e8bfd23214a1
Arg [12] : 00000000000000000000000053615db874a51bf22089e6677f56d1812c6a4150
Arg [13] : 0000000000000000000000006867c340f17cb63f243d9062b31144c2a692fbd1
Arg [14] : 0000000000000000000000000f1b8176466695875a421893333455a2d5016362
Arg [15] : 0000000000000000000000009888eddf5cc6c5bda466a994f0ebd8efb5ee90d1
Arg [16] : 000000000000000000000000977e302b1554c970e9f0ea88a63fa78fe4d7afe4
Arg [17] : 000000000000000000000000b2e0f4dee26cccf1f3a267ad185f212dd3e7a6b1
Arg [18] : 0000000000000000000000004eb59146668537fb4c0fe35c0d1a2aebccb53272
Arg [19] : 000000000000000000000000bb13c0560c8a8354e6a914f1f2b873cefe0df9f7
Arg [20] : 0000000000000000000000001df3810db24b44aeb62242fc5011fe6671135389
Arg [21] : 00000000000000000000000093ce5486824c3e5bea5561ce7e7dacd51f924526
Arg [22] : 000000000000000000000000d11baa5966e266396e9ed723c96b613b9c39620c
Arg [23] : 000000000000000000000000ba52c4b1bf0a3a2788c87f4d785b7b0b59f79169
Arg [24] : 000000000000000000000000854969544408fcefb326464b0787227eb767bdde
Arg [25] : 0000000000000000000000001fd0847d0d2cd41c18caf7f755779a7cf92b6394
Arg [26] : 0000000000000000000000009232355dba7473a47887abb6df1ab76e1bb7b456
Arg [27] : 00000000000000000000000043f78f7cdd066427b9d0b8fe19220b3325a0e1f1
Arg [28] : 0000000000000000000000009275198560df5215440565c6bd0b9d2e99b6aa9c
Arg [29] : 00000000000000000000000024343b73379831d7a200968b9d69e98d2c2f4fd2
Arg [30] : 000000000000000000000000f8a06c01b8aba37204e15c03c5a2b351c3e284fe
Arg [31] : 0000000000000000000000003a327eaafd07a8f4f5001481943e69d8c618e2fb
Arg [32] : 000000000000000000000000ea98c541cb125e42bfb23d35331a49df59f22b05
Arg [33] : 0000000000000000000000000b363d91e9455333e0ce12ae9c25356cd5ff9602
Arg [34] : 00000000000000000000000064db6ff0d04ddd8a1ad693df6709e6c1b61c1365
Arg [35] : 000000000000000000000000535d3e92df5f3d51da66021aa5c3896b688b8076
Arg [36] : 00000000000000000000000031a5b6b433f30fd55ea147c1be2b6c7e0389cee0
Arg [37] : 0000000000000000000000006719b8a3d44777d5f43d96de0f0f91a57aed7a3a
Arg [38] : 000000000000000000000000015ee97544a8b44460f51860efbdd769cfcb20e3
Arg [39] : 0000000000000000000000003d52b45278e81985bd5733c645a7a21b0912bbfa
Arg [40] : 000000000000000000000000d7147d3ef653abcafb13035b6aaeabf68032f5ad
Arg [41] : 000000000000000000000000c4eff7bd089a515355b23b0cd79eb5ef08e6fefe
Arg [42] : 0000000000000000000000008ad400c7a6db13159bae9c2bea879501e981788d
Arg [43] : 00000000000000000000000088815cee9d678b6e288fb48da3abbd4514ff06c3
Arg [44] : 0000000000000000000000008d2501c2efe7daff638ce9145b36040b3f1cb6f6
Arg [45] : 0000000000000000000000007cd175bf2d10cda21130b2255413b294bdce970b
Arg [46] : 0000000000000000000000008209a0f91fe84e756a624f079e51e9e29fdc252a
Arg [47] : 00000000000000000000000073d90db79da0ee77c42cd6014180cb69602a3a22
Arg [48] : 000000000000000000000000dab0f4c7db6e55b29b4ccd9471a60740573e23b4
Arg [49] : 000000000000000000000000b9833c4e67212e560855cc15c2746fa14e9337ac
Arg [50] : 0000000000000000000000008d114068e90845ad5fd9eb91157802b9e4b36ce4
Arg [51] : 00000000000000000000000041009b7eacd96b01687ec633962256ed1c433229
Arg [52] : 0000000000000000000000004de76a2d2a4decfd68566889e63d571173f930e4
Arg [53] : 0000000000000000000000005381315a97df70fc1f47fe8489efb12ad48fc187
Arg [54] : 000000000000000000000000aaf851270b5fd32baec366bf56161cff6cb97fb9
Arg [55] : 000000000000000000000000bde56c3feb1da63a6759d8a34c74f8602a0b2731
Arg [56] : 000000000000000000000000ab66ec57d13429d59038c119544041f09f2b16be
Arg [57] : 000000000000000000000000c541bc01c71d83f10f42f5040094cdffed5741b1
Arg [58] : 0000000000000000000000009f6cdd213bc4bcd29921264a86eda57a339a43b3
Arg [59] : 0000000000000000000000003ea5faf6b9a05876128b50b52db6f2c25b30b32b
Arg [60] : 00000000000000000000000047b8cc37d6128122585ab7fa6f6f02f25c958b59
Arg [61] : 0000000000000000000000005ef25c9e0e0c17257f437087a1fc629c1151c5e9
Arg [62] : 000000000000000000000000973ee618bfd3fb0e49c8a1a0ca2e2e6aeb930af3
Arg [63] : 0000000000000000000000009fe7d6fb7e14f0cfa8cda7bf539ad1b021f6bd2a
Arg [64] : 000000000000000000000000b53cd2295012a31efc99d278596ce7c963f7bae5
Arg [65] : 000000000000000000000000b9fe1e88622e712546ef7d0d9dc00dba25282a93
Arg [66] : 0000000000000000000000006d621ae05e58f3216e783b619dc9ccd81d5db9f6
Arg [67] : 00000000000000000000000082b1e570e4dd0b87c1cca4b22c500fe6956cedb0
Arg [68] : 0000000000000000000000006b7e9bf25cebcfa5c782fb5a6b0bab5abe3c100a
Arg [69] : 00000000000000000000000092c5b356e99d12dac31d8e1e9fa84735132386da
Arg [70] : 000000000000000000000000f866b5b53ea94f640b19e7550fe4fd2c18bfaffb
Arg [71] : 00000000000000000000000030e7b25175cd2d8ea54e22df246b1562ccd258df
Arg [72] : 000000000000000000000000b7e1789d7dcc6e0e40b35796fff1516ce9d794fd
Arg [73] : 000000000000000000000000a56f58b68d196ac01849f6f95dfef644520730ad
Arg [74] : 000000000000000000000000c2f259b7d529357d207dfbe74540f4430605d3ea
Arg [75] : 000000000000000000000000d5454f9505f2374d5f1f1ed81528d6d26fae9322
Arg [76] : 00000000000000000000000077b2f25816450fd70cc1854fc5767b061de54173
Arg [77] : 000000000000000000000000a22aa948e131f1b98c710cbbdec57db7ba027ffb
Arg [78] : 0000000000000000000000002da791359933011b4f74042a241fbbf09f6cbcab
Arg [79] : 000000000000000000000000301392a1d8c68bb21a91ecbd3f67237d87d8bfac
Arg [80] : 000000000000000000000000845bdc128ea511ccdf38b3fe47201195b689b123
Arg [81] : 000000000000000000000000ed3d39bb918500b520e601df4f1efc14feae3872
Arg [82] : 00000000000000000000000047c3c798d5a906f5aabee62b1cbc6368ed1c8898
Arg [83] : 000000000000000000000000ab9c177023a3a212948cdaee64b1e8654fecadea
Arg [84] : 000000000000000000000000f202223e1903b3baab3574b89febc576052a16ea
Arg [85] : 0000000000000000000000001925f489bf876e2f218a5d5d9b48f50469cb4220
Arg [86] : 00000000000000000000000053fa7673371d5c3f033265671f67434e023512f6
Arg [87] : 0000000000000000000000009e38c367ca5dbebaa449f6ade17a2a895342e260
Arg [88] : 0000000000000000000000007c5ce57d179f51ab5043ce9b897fca4ad500ad63
Arg [89] : 0000000000000000000000001d79a3770b3598d25fa10682b35626b237011074
Arg [90] : 000000000000000000000000559b07afdf937c8ff425cc506735c93015b341dd
Arg [91] : 00000000000000000000000034e667710c5f5fbf366023fa1664bfc71e4bb2ae
Arg [92] : 000000000000000000000000909c31560db77c1ab9e7f2e23fc6ffc2f16d1bfc
Arg [93] : 0000000000000000000000001a5389caa12792eecdb8651312a346773778e52d
Arg [94] : 00000000000000000000000071866ffb7e700e0832ad51f230b75668305493ff
Arg [95] : 0000000000000000000000002935c4d9cfe50413870a592d1ec368bb691de2d7
Arg [96] : 00000000000000000000000026d9c8aca64882a05c43a59ad5b59cc5e6ce20be
Arg [97] : 0000000000000000000000002248bf80865f89ae6d029c080b344d1b66acd8c8
Arg [98] : 000000000000000000000000f692ec3d930d26a0287ba28f75dc718330558168
Arg [99] : 000000000000000000000000d001a432318c1eb228c5e9ac9a55c24f2f32ef2a
Arg [100] : 0000000000000000000000001a7c37ae22a75ad0e428b75e4c8311ba82a75105
Arg [101] : 0000000000000000000000002c64da7097533db7a585ee62cde17cae0bcb2046
Arg [102] : 0000000000000000000000000196cbc6c7b1506c2385c8d29850dfe2a317fe00
Arg [103] : 0000000000000000000000009fe2ab08d8a63b1d6dd6c9e55561149bded65fd9
Arg [104] : 00000000000000000000000086883dad25cef1ace4bbbbd40807e710bdf435c0
Arg [105] : 000000000000000000000000d965667ba11a3c20caa64b6edddd5379e98f0eb8
Arg [106] : 000000000000000000000000ab1632d51237d6d3d605b9a90bdb7af6f2b79e78
Arg [107] : 000000000000000000000000ac2dd8a732d6ce49bab1cd48a5672ce076bbb5e4
Arg [108] : 0000000000000000000000006c4fd511973a0097d235f1d11f7ce18edd0e9f63
Arg [109] : 000000000000000000000000906a485bbdd9260219bf9a385254de0cfcbf650b
Arg [110] : 000000000000000000000000940ec171090e4920f3adb90d52c66ff1dfbe7037
Arg [111] : 000000000000000000000000110a413472687d3ff215a5793bedf24e7e16251f
Arg [112] : 0000000000000000000000006c6499802a591b6d25d916e5984ac9db34b96108
Arg [113] : 000000000000000000000000224bd2edfc38c3b6fa7e615c58908d803a4b770e
Arg [114] : 000000000000000000000000f6dd849a1c72e4fbd9c8c1d06de5660c0af3e67e
Arg [115] : 0000000000000000000000006d31ea580f7de23518f074ff5d32e87c0b577880
Arg [116] : 00000000000000000000000007c4a05a8e9f038fa2e708a2cbabbc79d065cd58
Arg [117] : 0000000000000000000000009ef46a791ecb0199e59cd4b1a549307fb52bf919
Arg [118] : 000000000000000000000000406d7bc28b3e226e89803212ad979f90eecfd525
Arg [119] : 000000000000000000000000a0fe2486b4a9d860b9b246980a07f790e8fefd77
Arg [120] : 0000000000000000000000007458e69a5b3f33c56c77c0bfdb5b30f6e6afa452
Arg [121] : 0000000000000000000000008c63625afa43d517f50712c50989a3fd87b5ed4c
Arg [122] : 0000000000000000000000001c9ea0bb36a9fa526f76b51dd55ce1f23d352c26
Arg [123] : 000000000000000000000000b2e1462847e6244f9931915ea2294005643b4861
Arg [124] : 000000000000000000000000a159ab70dfcb10f4b3714317070a8625ecb9895b
Arg [125] : 000000000000000000000000d3a5247ae8e4d6038f55b103d5f5cafd2efd8e92
Arg [126] : 000000000000000000000000317444472b04374dfd63494bacf41d9d23edbb71
Arg [127] : 00000000000000000000000064e55c710550a89d00f39e38dfd07548b51b4943
Arg [128] : 00000000000000000000000019a23bda7c6c09e691454e1be07faa54c4b9d9da
Arg [129] : 000000000000000000000000b161b69cec2fc8af7f146f19d02f9e86806e9cdc
Arg [130] : 0000000000000000000000009af99903aec634a8060d511a896cde774623d7aa
Arg [131] : 00000000000000000000000015ef6067cb7f8aa57c8a3cc51175ec0298752567
Arg [132] : 0000000000000000000000006f9cfacca63145c906fae462433aa1d1f147eec9
Arg [133] : 0000000000000000000000005836e12ec2ccd5e43ae27aef8804a0281e7876eb
Arg [134] : 0000000000000000000000008e0879fd2e8b499e86c60706e518fc1aeaa2abab
Arg [135] : 000000000000000000000000c1a0c3980e9df32ea752ab673351008287b7f6a5
Arg [136] : 00000000000000000000000053971185820c818351c90c51b8b358eea400b5b4
Arg [137] : 000000000000000000000000bdc90db179f44668bbecdaa62333207bbdb350ee
Arg [138] : 00000000000000000000000003ff18d6f1a9f90e7a37cd228629a159d6576598
Arg [139] : 000000000000000000000000ff8cba42f41f6736c236a22ef565a6884e705eff
Arg [140] : 000000000000000000000000d8fef6a115d444cbd283ebc80567851c1f28767c
Arg [141] : 000000000000000000000000e218115537e73023486bcabc23f5315677ab2055
Arg [142] : 0000000000000000000000004e35554e4065d9c8352cb076fb4b2e0e5aab4564
Arg [143] : 0000000000000000000000003c12ba2b6d6a1f1bc754315d30ebd65f954a7530
Arg [144] : 0000000000000000000000009be99d014990d0da6c96c7ff97ef915ce24aef83
Arg [145] : 0000000000000000000000008187098b10f95ee29c8c244699744f95c84d6305
Arg [146] : 000000000000000000000000cada0879e545d046eddc16838a69c8e6aab7d72c
Arg [147] : 0000000000000000000000008a5a03ca4391ea37970cd3f18f30578effa0f699
Arg [148] : 0000000000000000000000006a75cf98bcbc78e204c2a8733cdd62027acbf92f
Arg [149] : 000000000000000000000000ec959f0d95793cc120c09034cc9f10212656a952
Arg [150] : 000000000000000000000000d4c39f36fb7ad8d7ff491885f19d905415b81267
Arg [151] : 00000000000000000000000051510cf446db43068507b6d9efd9b33ab5238451
Arg [152] : 000000000000000000000000084195e5ed377212dbeebc1a8615bfd77c744790
Arg [153] : 000000000000000000000000af2564e7fba89f16942c798ebaec2653049e33ce
Arg [154] : 000000000000000000000000c500a3d9a20086a559f55a616587a9192e201751
Arg [155] : 000000000000000000000000793260f70fdbc74840502f936e6b1e09a2daa6bb
Arg [156] : 000000000000000000000000543ab56119496b81580d42b134f4061ed4b7619e
Arg [157] : 0000000000000000000000000d9d8be1f3494e0228646f92e7c2f0ab4af67d7b
Arg [158] : 0000000000000000000000000000000000000000000000000000000000000099
Arg [159] : 00000000000000000000000000000000000000000000000000000000000006a8
Arg [160] : 0000000000000000000000000000000000000000000000000000000000000808
Arg [161] : 0000000000000000000000000000000000000000000000000000000000000808
Arg [162] : 0000000000000000000000000000000000000000000000000000000000000902
Arg [163] : 0000000000000000000000000000000000000000000000000000000000000902
Arg [164] : 0000000000000000000000000000000000000000000000000000000000000b5c
Arg [165] : 0000000000000000000000000000000000000000000000000000000000000c48
Arg [166] : 0000000000000000000000000000000000000000000000000000000000000c71
Arg [167] : 0000000000000000000000000000000000000000000000000000000000000d42
Arg [168] : 0000000000000000000000000000000000000000000000000000000000000dd1
Arg [169] : 0000000000000000000000000000000000000000000000000000000000000e1d
Arg [170] : 0000000000000000000000000000000000000000000000000000000000000fac
Arg [171] : 0000000000000000000000000000000000000000000000000000000000001010
Arg [172] : 00000000000000000000000000000000000000000000000000000000000010d2
Arg [173] : 00000000000000000000000000000000000000000000000000000000000011cc
Arg [174] : 0000000000000000000000000000000000000000000000000000000000001256
Arg [175] : 00000000000000000000000000000000000000000000000000000000000012f4
Arg [176] : 00000000000000000000000000000000000000000000000000000000000012f4
Arg [177] : 00000000000000000000000000000000000000000000000000000000000014d2
Arg [178] : 00000000000000000000000000000000000000000000000000000000000014d5
Arg [179] : 00000000000000000000000000000000000000000000000000000000000014e6
Arg [180] : 00000000000000000000000000000000000000000000000000000000000014f3
Arg [181] : 0000000000000000000000000000000000000000000000000000000000001617
Arg [182] : 000000000000000000000000000000000000000000000000000000000000163f
Arg [183] : 000000000000000000000000000000000000000000000000000000000000165e
Arg [184] : 0000000000000000000000000000000000000000000000000000000000001672
Arg [185] : 0000000000000000000000000000000000000000000000000000000000001679
Arg [186] : 0000000000000000000000000000000000000000000000000000000000001850
Arg [187] : 0000000000000000000000000000000000000000000000000000000000001863
Arg [188] : 0000000000000000000000000000000000000000000000000000000000001917
Arg [189] : 000000000000000000000000000000000000000000000000000000000000192c
Arg [190] : 0000000000000000000000000000000000000000000000000000000000001956
Arg [191] : 00000000000000000000000000000000000000000000000000000000000019bb
Arg [192] : 00000000000000000000000000000000000000000000000000000000000019c3
Arg [193] : 00000000000000000000000000000000000000000000000000000000000019cd
Arg [194] : 0000000000000000000000000000000000000000000000000000000000001ae5
Arg [195] : 0000000000000000000000000000000000000000000000000000000000001af2
Arg [196] : 0000000000000000000000000000000000000000000000000000000000001b19
Arg [197] : 0000000000000000000000000000000000000000000000000000000000001b34
Arg [198] : 0000000000000000000000000000000000000000000000000000000000001b76
Arg [199] : 0000000000000000000000000000000000000000000000000000000000001bbe
Arg [200] : 0000000000000000000000000000000000000000000000000000000000001bc2
Arg [201] : 0000000000000000000000000000000000000000000000000000000000001bd9
Arg [202] : 0000000000000000000000000000000000000000000000000000000000001caa
Arg [203] : 0000000000000000000000000000000000000000000000000000000000001df2
Arg [204] : 0000000000000000000000000000000000000000000000000000000000001e23
Arg [205] : 0000000000000000000000000000000000000000000000000000000000001e2c
Arg [206] : 0000000000000000000000000000000000000000000000000000000000001f3f
Arg [207] : 0000000000000000000000000000000000000000000000000000000000001fb7
Arg [208] : 0000000000000000000000000000000000000000000000000000000000001fba
Arg [209] : 0000000000000000000000000000000000000000000000000000000000001fe8
Arg [210] : 000000000000000000000000000000000000000000000000000000000000204d
Arg [211] : 0000000000000000000000000000000000000000000000000000000000002070
Arg [212] : 000000000000000000000000000000000000000000000000000000000000209a
Arg [213] : 00000000000000000000000000000000000000000000000000000000000020bc
Arg [214] : 00000000000000000000000000000000000000000000000000000000000020d8
Arg [215] : 00000000000000000000000000000000000000000000000000000000000020da
Arg [216] : 00000000000000000000000000000000000000000000000000000000000020ea
Arg [217] : 00000000000000000000000000000000000000000000000000000000000020ec
Arg [218] : 00000000000000000000000000000000000000000000000000000000000020f6
Arg [219] : 00000000000000000000000000000000000000000000000000000000000020f6
Arg [220] : 0000000000000000000000000000000000000000000000000000000000002171
Arg [221] : 0000000000000000000000000000000000000000000000000000000000002178
Arg [222] : 0000000000000000000000000000000000000000000000000000000000002183
Arg [223] : 0000000000000000000000000000000000000000000000000000000000002191
Arg [224] : 00000000000000000000000000000000000000000000000000000000000021a9
Arg [225] : 00000000000000000000000000000000000000000000000000000000000021b9
Arg [226] : 00000000000000000000000000000000000000000000000000000000000021ca
Arg [227] : 00000000000000000000000000000000000000000000000000000000000021d2
Arg [228] : 00000000000000000000000000000000000000000000000000000000000021de
Arg [229] : 00000000000000000000000000000000000000000000000000000000000021de
Arg [230] : 00000000000000000000000000000000000000000000000000000000000021f8
Arg [231] : 0000000000000000000000000000000000000000000000000000000000002214
Arg [232] : 0000000000000000000000000000000000000000000000000000000000002288
Arg [233] : 0000000000000000000000000000000000000000000000000000000000002387
Arg [234] : 00000000000000000000000000000000000000000000000000000000000023e2
Arg [235] : 000000000000000000000000000000000000000000000000000000000000242f
Arg [236] : 000000000000000000000000000000000000000000000000000000000000243b
Arg [237] : 0000000000000000000000000000000000000000000000000000000000002497
Arg [238] : 000000000000000000000000000000000000000000000000000000000000252e
Arg [239] : 000000000000000000000000000000000000000000000000000000000000253f
Arg [240] : 00000000000000000000000000000000000000000000000000000000000025ae
Arg [241] : 0000000000000000000000000000000000000000000000000000000000002885
Arg [242] : 0000000000000000000000000000000000000000000000000000000000002897
Arg [243] : 00000000000000000000000000000000000000000000000000000000000028a8
Arg [244] : 000000000000000000000000000000000000000000000000000000000000293b
Arg [245] : 000000000000000000000000000000000000000000000000000000000000299a
Arg [246] : 0000000000000000000000000000000000000000000000000000000000002a0e
Arg [247] : 0000000000000000000000000000000000000000000000000000000000002a45
Arg [248] : 0000000000000000000000000000000000000000000000000000000000002ad7
Arg [249] : 0000000000000000000000000000000000000000000000000000000000002be2
Arg [250] : 0000000000000000000000000000000000000000000000000000000000002d25
Arg [251] : 00000000000000000000000000000000000000000000000000000000000031a8
Arg [252] : 000000000000000000000000000000000000000000000000000000000000325d
Arg [253] : 00000000000000000000000000000000000000000000000000000000000032bf
Arg [254] : 000000000000000000000000000000000000000000000000000000000000349c
Arg [255] : 000000000000000000000000000000000000000000000000000000000000358b
Arg [256] : 000000000000000000000000000000000000000000000000000000000000379b
Arg [257] : 0000000000000000000000000000000000000000000000000000000000003a32
Arg [258] : 0000000000000000000000000000000000000000000000000000000000003a84
Arg [259] : 0000000000000000000000000000000000000000000000000000000000003c05
Arg [260] : 0000000000000000000000000000000000000000000000000000000000003d2f
Arg [261] : 0000000000000000000000000000000000000000000000000000000000004092
Arg [262] : 00000000000000000000000000000000000000000000000000000000000040b7
Arg [263] : 000000000000000000000000000000000000000000000000000000000000412d
Arg [264] : 000000000000000000000000000000000000000000000000000000000000420f
Arg [265] : 0000000000000000000000000000000000000000000000000000000000004246
Arg [266] : 000000000000000000000000000000000000000000000000000000000000424d
Arg [267] : 00000000000000000000000000000000000000000000000000000000000042b5
Arg [268] : 00000000000000000000000000000000000000000000000000000000000043f8
Arg [269] : 0000000000000000000000000000000000000000000000000000000000004468
Arg [270] : 0000000000000000000000000000000000000000000000000000000000004488
Arg [271] : 00000000000000000000000000000000000000000000000000000000000045f5
Arg [272] : 0000000000000000000000000000000000000000000000000000000000004684
Arg [273] : 0000000000000000000000000000000000000000000000000000000000004827
Arg [274] : 000000000000000000000000000000000000000000000000000000000000483a
Arg [275] : 0000000000000000000000000000000000000000000000000000000000004885
Arg [276] : 0000000000000000000000000000000000000000000000000000000000004925
Arg [277] : 0000000000000000000000000000000000000000000000000000000000004a69
Arg [278] : 0000000000000000000000000000000000000000000000000000000000004ae8
Arg [279] : 0000000000000000000000000000000000000000000000000000000000004c4a
Arg [280] : 0000000000000000000000000000000000000000000000000000000000004edf
Arg [281] : 0000000000000000000000000000000000000000000000000000000000005345
Arg [282] : 0000000000000000000000000000000000000000000000000000000000005a73
Arg [283] : 0000000000000000000000000000000000000000000000000000000000005d12
Arg [284] : 000000000000000000000000000000000000000000000000000000000000651b
Arg [285] : 0000000000000000000000000000000000000000000000000000000000006582
Arg [286] : 0000000000000000000000000000000000000000000000000000000000006602
Arg [287] : 00000000000000000000000000000000000000000000000000000000000066d3
Arg [288] : 0000000000000000000000000000000000000000000000000000000000006a85
Arg [289] : 0000000000000000000000000000000000000000000000000000000000006c30
Arg [290] : 0000000000000000000000000000000000000000000000000000000000006e61
Arg [291] : 0000000000000000000000000000000000000000000000000000000000006eec
Arg [292] : 0000000000000000000000000000000000000000000000000000000000007746
Arg [293] : 000000000000000000000000000000000000000000000000000000000000834f
Arg [294] : 0000000000000000000000000000000000000000000000000000000000008e29
Arg [295] : 0000000000000000000000000000000000000000000000000000000000008f7a
Arg [296] : 0000000000000000000000000000000000000000000000000000000000009049
Arg [297] : 00000000000000000000000000000000000000000000000000000000000094be
Arg [298] : 0000000000000000000000000000000000000000000000000000000000009656
Arg [299] : 0000000000000000000000000000000000000000000000000000000000009a60
Arg [300] : 0000000000000000000000000000000000000000000000000000000000009ad6
Arg [301] : 0000000000000000000000000000000000000000000000000000000000009ba9
Arg [302] : 000000000000000000000000000000000000000000000000000000000000a72d
Arg [303] : 000000000000000000000000000000000000000000000000000000000000b46f
Arg [304] : 0000000000000000000000000000000000000000000000000000000000010401
Arg [305] : 0000000000000000000000000000000000000000000000000000000000010709
Arg [306] : 00000000000000000000000000000000000000000000000000000000000127fa
Arg [307] : 000000000000000000000000000000000000000000000000000000000001501f
Arg [308] : 000000000000000000000000000000000000000000000000000000000001d8f4
Arg [309] : 0000000000000000000000000000000000000000000000000000000000020986
Arg [310] : 0000000000000000000000000000000000000000000000000000000000035f5b
Arg [311] : 000000000000000000000000000000000000000000000000000000000003e268