Token

Roasting Firepit (Roasting Firepit)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

4,620 Roasting Firepit

Holders

519

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xb578f948df1f2e401522f8774229497c2bdddfff

Filtered by Token Holder

0x161181B1905845D5F6e1C610B1403abD0E7c4d37

Balance

1 Roasting Firepit

0x161181b1905845d5f6e1c610b1403abd0e7c4d37

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

RoastingFirepit

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

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

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: contracts/synthesisNFT.sol


pragma solidity ^0.8.0;



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


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

abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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 be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

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

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

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

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


abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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


abstract contract Ownable is Context {
    address private _owner;

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

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

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

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

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

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

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

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


interface IERC721A is IERC721, IERC721Metadata {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * The token does not exist.
     */
    error ApprovalQueryForNonexistentToken();

    /**
     * The caller cannot approve to their own address.
     */
    error ApproveToCaller();

    /**
     * The caller cannot approve to the current owner.
     */
    error ApprovalToCurrentOwner();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * The token does not exist.
     */
    error OwnerQueryForNonexistentToken();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from`.
     */
    error TransferFromIncorrectOwner();

    /**
     * Cannot safely transfer to a contract that does not implement the ERC721Receiver interface.
     */
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The token does not exist.
     */
    error URIQueryForNonexistentToken();

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     * 
     * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens.
     */
    function totalSupply() external view returns (uint256);
}

contract ERC721A is Context, ERC165, IERC721A {
    using Address for address;
    using Strings for uint256;

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // 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) internal _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;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view override returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr) if (curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @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) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        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);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner) if(!isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

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

        _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 virtual override {
        _transfer(from, to, tokenId);
    }

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract()) if(!_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @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 _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;
    }

    /**
     * @dev Equivalent to `_safeMint(to, quantity, '')`.
     */
    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement
     *   {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

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

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex < end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex < end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 quantity) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

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

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            do {
                emit Transfer(address(0), to, updatedIndex++);
            } while (updatedIndex < end);

            _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);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = to;
            currSlot.startTimestamp = 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;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

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

    /**
     * @dev Equivalent to `_burn(tokenId, false)`.
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
                isApprovedForAll(from, _msgSender()) ||
                getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            AddressData storage addressData = _addressData[from];
            addressData.balance -= 1;
            addressData.numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = from;
            currSlot.startTimestamp = uint64(block.timestamp);
            currSlot.burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        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 TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * 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`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    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.
     * And also called after one token has been burned.
     *
     * 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` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

error InvalidQueryRange();

/**
 * @title ERC721A Queryable
 * @dev ERC721A subclass with convenience query functions.
 */
abstract contract ERC721AQueryable is ERC721A {
    /**
     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
     *
     * If the `tokenId` is out of bounds:
     *   - `addr` = `address(0)`
     *   - `startTimestamp` = `0`
     *   - `burned` = `false`
     *
     * If the `tokenId` is burned:
     *   - `addr` = `<Address of owner before token was burned>`
     *   - `startTimestamp` = `<Timestamp when token was burned>`
     *   - `burned = `true`
     *
     * Otherwise:
     *   - `addr` = `<Address of owner>`
     *   - `startTimestamp` = `<Timestamp of start of ownership>`
     *   - `burned = `false`
     */
    function explicitOwnershipOf(uint256 tokenId)
        public
        view
        returns (TokenOwnership memory)
    {
        TokenOwnership memory ownership;
        if (tokenId < _startTokenId() || tokenId >= _currentIndex) {
            return ownership;
        }
        ownership = _ownerships[tokenId];
        if (ownership.burned) {
            return ownership;
        }
        return _ownershipOf(tokenId);
    }

    /**
     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
     * See {ERC721AQueryable-explicitOwnershipOf}
     */
    function explicitOwnershipsOf(uint256[] memory tokenIds)
        external
        view
        returns (TokenOwnership[] memory)
    {
        unchecked {
            uint256 tokenIdsLength = tokenIds.length;
            TokenOwnership[] memory ownerships = new TokenOwnership[](
                tokenIdsLength
            );
            for (uint256 i; i != tokenIdsLength; ++i) {
                ownerships[i] = explicitOwnershipOf(tokenIds[i]);
            }
            return ownerships;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start` < `stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) external view returns (uint256[] memory) {
        unchecked {
            if (start >= stop) revert InvalidQueryRange();
            uint256 tokenIdsIdx;
            uint256 stopLimit = _currentIndex;
            // Set `start = max(start, _startTokenId())`.
            if (start < _startTokenId()) {
                start = _startTokenId();
            }
            // Set `stop = min(stop, _currentIndex)`.
            if (stop > stopLimit) {
                stop = stopLimit;
            }
            uint256 tokenIdsMaxLength = balanceOf(owner);
            // Set `tokenIdsMaxLength = min(balanceOf(owner), stop - start)`,
            // to cater for cases where `balanceOf(owner)` is too big.
            if (start < stop) {
                uint256 rangeLength = stop - start;
                if (rangeLength < tokenIdsMaxLength) {
                    tokenIdsMaxLength = rangeLength;
                }
            } else {
                tokenIdsMaxLength = 0;
            }
            uint256[] memory tokenIds = new uint256[](tokenIdsMaxLength);
            if (tokenIdsMaxLength == 0) {
                return tokenIds;
            }
            // We need to call `explicitOwnershipOf(start)`,
            // because the slot at `start` may not be initialized.
            TokenOwnership memory ownership = explicitOwnershipOf(start);
            address currOwnershipAddr;
            // If the starting slot exists (i.e. not burned), initialize `currOwnershipAddr`.
            // `ownership.address` will not be zero, as `start` is clamped to the valid token ID range.
            if (!ownership.burned) {
                currOwnershipAddr = ownership.addr;
            }
            for (
                uint256 i = start;
                i != stop && tokenIdsIdx != tokenIdsMaxLength;
                ++i
            ) {
                ownership = _ownerships[i];
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            // Downsize the array to fit.
            assembly {
                mstore(tokenIds, tokenIdsIdx)
            }
            return tokenIds;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(totalSupply) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K pfp collections should be fine).
     */
    function tokensOfOwner(address owner)
        external
        view
        returns (uint256[] memory)
    {
        unchecked {
            uint256 tokenIdsIdx;
            address currOwnershipAddr;
            uint256 tokenIdsLength = balanceOf(owner);
            uint256[] memory tokenIds = new uint256[](tokenIdsLength);
            TokenOwnership memory ownership;
            for (
                uint256 i = _startTokenId();
                tokenIdsIdx != tokenIdsLength;
                ++i
            ) {
                ownership = _ownerships[i];
                if (ownership.burned) {
                    continue;
                }
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            return tokenIds;
        }
    }
}



contract RoastingFirepit is  Ownable, ERC721AQueryable {
    using SafeMath for uint256;
    using Strings for uint256;

    uint256 public MAX_SUPPLY = 5000;

    uint256 public initial = 100000000 ether;

    IERC721 private tokenA;

    IERC20 private tokenB;

    address public tokenAaddress =  0x6079EA481eBb901568E294E8dcdeCFf6AC451B1A;

    address public tokenBaddress =  0xd33B79F237508251e5740c5229f2c8Ea47Ee30C8;

    address public  blackHole = 0x000000000000000000000000000000000000dEaD;

    address public  START_ADDRESS = 0x52cf48eC3485c2F1312d9F1f1Ddd3fcA9CC232e3;

    string baseURI = "https://cdn.monstercave.wtf/meta/dc9f28b12dd1818ee42ffc92ecb940386/json/";

    string public baseExtension = ".json";

    constructor() ERC721A("Roasting Firepit", "Roasting Firepit") {
        tokenA = IERC721(tokenAaddress);
        tokenB = IERC20(tokenBaddress);
    }

    function setUpToken(address _tokenA) public onlyOwner {
        tokenA = IERC721(_tokenA);
    }

    function setUp20Token(address _tokenB) public onlyOwner {
        tokenB = IERC20(_tokenB);
    }
 
    function setUpstartAddress(address _addr) public onlyOwner {
        START_ADDRESS = _addr;
    }
    
    function synthesisMint(uint256[] memory _tokenId) public {
        uint256  tokenIdLength  = _tokenId.length;
        require(tokenIdLength > 1, "need two!");
        require(tokenIdLength.mod(2) == 0, "wrong quantity");

        for(uint i = 0;i < tokenIdLength;i++){
            require(tokenA.ownerOf(_tokenId[i]) ==  msg.sender, "Insufficient balance");
        }

        uint256 tokenQuantity = tokenIdLength.div(2);

        require(totalSupply() + tokenQuantity <= MAX_SUPPLY, "Exceeded maximum supply");

        for(uint i= 0;i < tokenIdLength;i++){
            tokenA.transferFrom(msg.sender,blackHole,_tokenId[i]);
        }
        uint256 number  =  initial.mul(tokenQuantity);
        tokenB.transferFrom(START_ADDRESS,msg.sender,number);

        _safeMint(msg.sender, tokenQuantity);
    }

    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        string memory base = _baseURI();
        return bytes(base).length != 0 ? string(abi.encodePacked(base, tokenId.toString() , baseExtension)) : '';
    }

    function setBaseURI(string memory _newBaseURI) public onlyOwner {
        baseURI = _newBaseURI;
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"InvalidQueryRange","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":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":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"START_ADDRESS","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"blackHole","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"explicitOwnershipOf","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"}],"internalType":"struct IERC721A.TokenOwnership","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"explicitOwnershipsOf","outputs":[{"components":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint64","name":"startTimestamp","type":"uint64"},{"internalType":"bool","name":"burned","type":"bool"}],"internalType":"struct IERC721A.TokenOwnership[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initial","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenB","type":"address"}],"name":"setUp20Token","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenA","type":"address"}],"name":"setUpToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"setUpstartAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenId","type":"uint256[]"}],"name":"synthesisMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tokenAaddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenBaddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"tokensOfOwnerIn","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

58915:2682:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33780:305;;;;;;:::i;:::-;;:::i;:::-;;;10726:14:1;;10719:22;10701:41;;10689:2;10674:18;33780:305:0;;;;;;;;36895:100;;;:::i;:::-;;;;;;;:::i;38399:204::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;8278:32:1;;;8260:51;;8248:2;8233:18;38399:204:0;8114:203:1;59278:74:0;;;;;-1:-1:-1;;;;;59278:74:0;;;37961:372;;;;;;:::i;:::-;;:::i;:::-;;33020:312;33283:12;;33267:13;;:28;33020:312;;;13544:25:1;;;13532:2;13517:18;33020:312:0;13398:177:1;59440:74:0;;;;;-1:-1:-1;;;;;59440:74:0;;;39264:170;;;;;;:::i;:::-;;:::i;59195:74::-;;;;;-1:-1:-1;;;;;59195:74:0;;;59044:32;;;;;;39505:185;;;;;;:::i;:::-;;:::i;61372:104::-;;;;;;:::i;:::-;;:::i;53998:523::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;36703:125::-;;;;;;:::i;:::-;;:::i;59830:98::-;;;;;;:::i;:::-;;:::i;34149:206::-;;;;;;:::i;:::-;;:::i;19711:103::-;;;:::i;57924:980::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;60155:826::-;;;;;;:::i;:::-;;:::i;59936:99::-;;;;;;:::i;:::-;;:::i;19060:87::-;19106:7;19133:6;-1:-1:-1;;;;;19133:6:0;19060:87;;37064:104;;;:::i;54911:2564::-;;;;;;:::i;:::-;;:::i;59361:70::-;;;;;-1:-1:-1;;;;;59361:70:0;;;38675:287;;;;;;:::i;:::-;;:::i;39761:370::-;;;;;;:::i;:::-;;:::i;59085:40::-;;;;;;53398:441;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;59623:37::-;;;:::i;60989:375::-;;;;;;:::i;:::-;;:::i;39033:164::-;;;;;;:::i;:::-;;:::i;19969:201::-;;;;;;:::i;:::-;;:::i;60044:99::-;;;;;;:::i;:::-;;:::i;33780:305::-;33882:4;-1:-1:-1;;;;;;33919:40:0;;-1:-1:-1;;;33919:40:0;;:105;;-1:-1:-1;;;;;;;33976:48:0;;-1:-1:-1;;;33976:48:0;33919:105;:158;;;-1:-1:-1;;;;;;;;;;11277:40:0;;;34041:36;33899:178;33780:305;-1:-1:-1;;33780:305:0:o;36895:100::-;36949:13;36982:5;36975:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36895:100;:::o;38399:204::-;38467:7;38492:16;38500:7;38492;:16::i;:::-;38487:64;;38517:34;;-1:-1:-1;;;38517:34:0;;;;;;;;;;;38487:64;-1:-1:-1;38571:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;38571:24:0;;38399:204::o;37961:372::-;38034:13;38050:24;38066:7;38050:15;:24::i;:::-;38034:40;;38095:5;-1:-1:-1;;;;;38089:11:0;:2;-1:-1:-1;;;;;38089:11:0;;38085:48;;;38109:24;;-1:-1:-1;;;38109:24:0;;;;;;;;;;;38085:48;18512:10;-1:-1:-1;;;;;38150:21:0;;;38146:139;;38177:37;38194:5;18512:10;39033:164;:::i;38177:37::-;38173:112;;38238:35;;-1:-1:-1;;;38238:35:0;;;;;;;;;;;38173:112;38297:28;38306:2;38310:7;38319:5;38297:8;:28::i;:::-;38023:310;37961:372;;:::o;39264:170::-;39398:28;39408:4;39414:2;39418:7;39398:9;:28::i;39505:185::-;39643:39;39660:4;39666:2;39670:7;39643:39;;;;;;;;;;;;:16;:39::i;61372:104::-;19106:7;19133:6;-1:-1:-1;;;;;19133:6:0;18512:10;19280:23;19272:68;;;;-1:-1:-1;;;19272:68:0;;;;;;;:::i;:::-;;;;;;;;;61447:21;;::::1;::::0;:7:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;:::-;;61372:104:::0;:::o;53998:523::-;54196:15;;54105:23;;54171:22;54196:15;-1:-1:-1;;;;;54263:68:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;54263:68:0;;-1:-1:-1;;54263:68:0;;;;;;;;;;;;54226:105;;54351:9;54346:125;54367:14;54362:1;:19;54346:125;;54423:32;54443:8;54452:1;54443:11;;;;;;;;:::i;:::-;;;;;;;54423:19;:32::i;:::-;54407:10;54418:1;54407:13;;;;;;;;:::i;:::-;;;;;;;;;;:48;54383:3;;54346:125;;;-1:-1:-1;54492:10:0;53998:523;-1:-1:-1;;;53998:523:0:o;36703:125::-;36767:7;36794:21;36807:7;36794:12;:21::i;:::-;:26;;36703:125;-1:-1:-1;;36703:125:0:o;59830:98::-;19106:7;19133:6;-1:-1:-1;;;;;19133:6:0;18512:10;19280:23;19272:68;;;;-1:-1:-1;;;19272:68:0;;;;;;;:::i;:::-;59895:6:::1;:25:::0;;-1:-1:-1;;;;;;59895:25:0::1;-1:-1:-1::0;;;;;59895:25:0;;;::::1;::::0;;;::::1;::::0;;59830:98::o;34149:206::-;34213:7;-1:-1:-1;;;;;34237:19:0;;34233:60;;34265:28;;-1:-1:-1;;;34265:28:0;;;;;;;;;;;34233:60;-1:-1:-1;;;;;;34319:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;34319:27:0;;34149:206::o;19711:103::-;19106:7;19133:6;-1:-1:-1;;;;;19133:6:0;18512:10;19280:23;19272:68;;;;-1:-1:-1;;;19272:68:0;;;;;;;:::i;:::-;19776:30:::1;19803:1;19776:18;:30::i;:::-;19711:103::o:0;57924:980::-;58012:16;58071:19;58105:25;58145:22;58170:16;58180:5;58170:9;:16::i;:::-;58145:41;;58201:25;58243:14;-1:-1:-1;;;;;58229:29:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58229:29:0;;58201:57;;58273:31;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;58273:31:0;58342:9;58319:537;58403:14;58388:11;:29;58319:537;;58486:14;;;;:11;:14;;;;;;;;;58474:26;;;;;;;;;-1:-1:-1;;;;;58474:26:0;;;;-1:-1:-1;;;58474:26:0;;-1:-1:-1;;;;;58474:26:0;;;;;;;;-1:-1:-1;;;58474:26:0;;;;;;;;;;;;;;;;-1:-1:-1;58519:73:0;;58564:8;;58519:73;58614:14;;-1:-1:-1;;;;;58614:28:0;;58610:111;;58687:14;;;-1:-1:-1;58610:111:0;58764:5;-1:-1:-1;;;;;58743:26:0;:17;-1:-1:-1;;;;;58743:26:0;;58739:102;;;58820:1;58794:8;58803:13;;;;;;58794:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;58739:102;58436:3;;58319:537;;;-1:-1:-1;58877:8:0;;57924:980;-1:-1:-1;;;;;;57924:980:0:o;60155:826::-;60249:15;;60299:1;60283:17;;60275:39;;;;-1:-1:-1;;;60275:39:0;;11935:2:1;60275:39:0;;;11917:21:1;11974:1;11954:18;;;11947:29;-1:-1:-1;;;11992:18:1;;;11985:39;12041:18;;60275:39:0;11733:332:1;60275:39:0;60333:20;:13;60351:1;60333:17;:20::i;:::-;:25;60325:52;;;;-1:-1:-1;;;60325:52:0;;12272:2:1;60325:52:0;;;12254:21:1;12311:2;12291:18;;;12284:30;-1:-1:-1;;;12330:18:1;;;12323:44;12384:18;;60325:52:0;12070:338:1;60325:52:0;60394:6;60390:139;60409:13;60405:1;:17;60390:139;;;60450:6;;60465:11;;60482:10;;-1:-1:-1;;;;;60450:6:0;;:14;;60465:8;;60474:1;;60465:11;;;;;;:::i;:::-;;;;;;;60450:27;;;;;;;;;;;;;13544:25:1;;13532:2;13517:18;;13398:177;60450:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;60450:42:0;;60442:75;;;;-1:-1:-1;;;60442:75:0;;11586:2:1;60442:75:0;;;11568:21:1;11625:2;11605:18;;;11598:30;-1:-1:-1;;;11644:18:1;;;11637:50;11704:18;;60442:75:0;11384:344:1;60442:75:0;60423:3;;;;:::i;:::-;;;;60390:139;;;-1:-1:-1;60541:21:0;60565:20;:13;60583:1;60565:17;:20::i;:::-;60541:44;;60639:10;;60622:13;60606;33283:12;;33267:13;;:28;;33020:312;60606:13;:29;;;;:::i;:::-;:43;;60598:79;;;;-1:-1:-1;;;60598:79:0;;12976:2:1;60598:79:0;;;12958:21:1;13015:2;12995:18;;;12988:30;13054:25;13034:18;;;13027:53;13097:18;;60598:79:0;12774:347:1;60598:79:0;60694:6;60690:116;60708:13;60704:1;:17;60690:116;;;60741:6;;60772:9;;60782:11;;-1:-1:-1;;;;;60741:6:0;;;;:19;;60761:10;;60772:9;;;60782:8;;60791:1;;60782:11;;;;;;:::i;:::-;;;;;;;;;;;60741:53;;-1:-1:-1;;;;;;60741:53:0;;;;;;;-1:-1:-1;;;;;8580:15:1;;;60741:53:0;;;8562:34:1;8632:15;;;;8612:18;;;8605:43;8664:18;;;8657:34;8497:18;;60741:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60722:3;;;;;:::i;:::-;;;;60690:116;;;-1:-1:-1;60835:7:0;;60816:14;;60835:26;;60847:13;60835:11;:26::i;:::-;60872:6;;60892:13;;60872:52;;-1:-1:-1;;;60872:52:0;;-1:-1:-1;;;;;60892:13:0;;;60872:52;;;8562:34:1;60906:10:0;8612:18:1;;;8605:43;8664:18;;;8657:34;;;60816:45:0;;-1:-1:-1;60872:6:0;;:19;;8497:18:1;;60872:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;60937:36;60947:10;60959:13;60937:9;:36::i;:::-;60212:769;;;60155:826;:::o;59936:99::-;19106:7;19133:6;-1:-1:-1;;;;;19133:6:0;18512:10;19280:23;19272:68;;;;-1:-1:-1;;;19272:68:0;;;;;;;:::i;:::-;60003:6:::1;:24:::0;;-1:-1:-1;;;;;;60003:24:0::1;-1:-1:-1::0;;;;;60003:24:0;;;::::1;::::0;;;::::1;::::0;;59936:99::o;37064:104::-;37120:13;37153:7;37146:14;;;;;:::i;54911:2564::-;55037:16;55104:4;55095:5;:13;55091:45;;55117:19;;-1:-1:-1;;;55117:19:0;;;;;;;;;;;55091:45;55205:13;;55151:19;;55459:9;55452:4;:16;55448:73;;;55496:9;55489:16;;55448:73;55535:25;55563:16;55573:5;55563:9;:16::i;:::-;55535:44;;55757:4;55749:5;:12;55745:278;;;55804:12;;;55839:31;;;55835:111;;;55915:11;55895:31;;55835:111;55763:198;55745:278;;;-1:-1:-1;56006:1:0;55745:278;56037:25;56079:17;-1:-1:-1;;;;;56065:32:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56065:32:0;-1:-1:-1;56037:60:0;-1:-1:-1;56116:22:0;56112:78;;56166:8;-1:-1:-1;56159:15:0;;-1:-1:-1;;;56159:15:0;56112:78;56334:31;56368:26;56388:5;56368:19;:26::i;:::-;56334:60;;56409:25;56654:9;:16;;;56649:92;;-1:-1:-1;56711:14:0;;56649:92;56790:5;56755:543;56819:4;56814:1;:9;;:45;;;;;56842:17;56827:11;:32;;56814:45;56755:543;;;56928:14;;;;:11;:14;;;;;;;;;56916:26;;;;;;;;;-1:-1:-1;;;;;56916:26:0;;;;-1:-1:-1;;;56916:26:0;;-1:-1:-1;;;;;56916:26:0;;;;;;;;-1:-1:-1;;;56916:26:0;;;;;;;;;;;;;;;;-1:-1:-1;56961:73:0;;57006:8;;56961:73;57056:14;;-1:-1:-1;;;;;57056:28:0;;57052:111;;57129:14;;;-1:-1:-1;57052:111:0;57206:5;-1:-1:-1;;;;;57185:26:0;:17;-1:-1:-1;;;;;57185:26:0;;57181:102;;;57262:1;57236:8;57245:13;;;;;;57236:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;57181:102;56878:3;;56755:543;;;-1:-1:-1;;;57383:29:0;;;-1:-1:-1;57390:8:0;;-1:-1:-1;;54911:2564:0;;;;;;:::o;38675:287::-;-1:-1:-1;;;;;38774:24:0;;18512:10;38774:24;38770:54;;;38807:17;;-1:-1:-1;;;38807:17:0;;;;;;;;;;;38770:54;18512:10;38837:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;38837:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;38837:53:0;;;;;;;;;;38906:48;;10701:41:1;;;38837:42:0;;18512:10;38906:48;;10674:18:1;38906:48:0;;;;;;;38675:287;;:::o;39761:370::-;39928:28;39938:4;39944:2;39948:7;39928:9;:28::i;:::-;-1:-1:-1;;;;;39971:13:0;;21831:19;:23;39967:157;;39992:56;40023:4;40029:2;40033:7;40042:5;39992:30;:56::i;:::-;39988:136;;40072:40;;-1:-1:-1;;;40072:40:0;;;;;;;;;;;53398:441;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53577:53:0;53617:13;;53606:7;:24;53573:102;;53654:9;53398:441;-1:-1:-1;;53398:441:0:o;53573:102::-;-1:-1:-1;53697:20:0;;;;:11;:20;;;;;;;;;53685:32;;;;;;;;;-1:-1:-1;;;;;53685:32:0;;;;-1:-1:-1;;;53685:32:0;;-1:-1:-1;;;;;53685:32:0;;;;;;;;-1:-1:-1;;;53685:32:0;;;;;;;;;;;;;;;;53728:65;;53772:9;53398:441;-1:-1:-1;;53398:441:0:o;53728:65::-;53810:21;53823:7;53810:12;:21::i;59623:37::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;60989:375::-;61107:13;61143:16;61151:7;61143;:16::i;:::-;61138:59;;61168:29;;-1:-1:-1;;;61168:29:0;;;;;;;;;;;61138:59;61210:18;61231:10;:8;:10::i;:::-;61210:31;;61265:4;61259:18;61281:1;61259:23;;:97;;;;;;;;;;;;;;;;;61309:4;61315:18;:7;:16;:18::i;:::-;61336:13;61292:58;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;61252:104;60989:375;-1:-1:-1;;;60989:375:0:o;39033:164::-;-1:-1:-1;;;;;39154:25:0;;;39130:4;39154:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;39033:164::o;19969:201::-;19106:7;19133:6;-1:-1:-1;;;;;19133:6:0;18512:10;19280:23;19272:68;;;;-1:-1:-1;;;19272:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;20058:22:0;::::1;20050:73;;;::::0;-1:-1:-1;;;20050:73:0;;11179:2:1;20050:73:0::1;::::0;::::1;11161:21:1::0;11218:2;11198:18;;;11191:30;11257:34;11237:18;;;11230:62;-1:-1:-1;;;11308:18:1;;;11301:36;11354:19;;20050:73:0::1;10977:402:1::0;20050:73:0::1;20134:28;20153:8;20134:18;:28::i;:::-;19969:201:::0;:::o;60044:99::-;19106:7;19133:6;-1:-1:-1;;;;;19133:6:0;18512:10;19280:23;19272:68;;;;-1:-1:-1;;;19272:68:0;;;;;;;:::i;:::-;60114:13:::1;:21:::0;;-1:-1:-1;;;;;;60114:21:0::1;-1:-1:-1::0;;;;;60114:21:0;;;::::1;::::0;;;::::1;::::0;;60044:99::o;40386:174::-;40443:4;40507:13;;40497:7;:23;40467:85;;;;-1:-1:-1;;40525:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;40525:27:0;;;;40524:28;;40386:174::o;49608:196::-;49723:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;49723:29:0;-1:-1:-1;;;;;49723:29:0;;;;;;;;;49768:28;;49723:24;;49768:28;;;;;;;49608:196;;;:::o;44556:2130::-;44671:35;44709:21;44722:7;44709:12;:21::i;:::-;44671:59;;44769:4;-1:-1:-1;;;;;44747:26:0;:13;:18;;;-1:-1:-1;;;;;44747:26:0;;44743:67;;44782:28;;-1:-1:-1;;;44782:28:0;;;;;;;;;;;44743:67;44823:22;18512:10;-1:-1:-1;;;;;44849:20:0;;;;:73;;-1:-1:-1;44886:36:0;44903:4;18512:10;39033:164;:::i;44886:36::-;44849:126;;;-1:-1:-1;18512:10:0;44939:20;44951:7;44939:11;:20::i;:::-;-1:-1:-1;;;;;44939:36:0;;44849:126;44823:153;;44994:17;44989:66;;45020:35;;-1:-1:-1;;;45020:35:0;;;;;;;;;;;44989:66;-1:-1:-1;;;;;45070:16:0;;45066:52;;45095:23;;-1:-1:-1;;;45095:23:0;;;;;;;;;;;45066:52;45239:35;45256:1;45260:7;45269:4;45239:8;:35::i;:::-;-1:-1:-1;;;;;45570:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;45570:31:0;;;-1:-1:-1;;;;;45570:31:0;;;-1:-1:-1;;45570:31:0;;;;;;;45616:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;45616:29:0;;;;;;;;;;;45696:20;;;:11;:20;;;;;;45731:18;;-1:-1:-1;;;;;;45764:49:0;;;;-1:-1:-1;;;45797:15:0;45764:49;;;;;;;;;;46087:11;;46147:24;;;;;46190:13;;45696:20;;46147:24;;46190:13;46186:384;;46400:13;;46385:11;:28;46381:174;;46438:20;;46507:28;;;;-1:-1:-1;;;;;46481:54:0;-1:-1:-1;;;46481:54:0;-1:-1:-1;;;;;;46481:54:0;;;-1:-1:-1;;;;;46438:20:0;;46481:54;;;;46381:174;45545:1036;;;46617:7;46613:2;-1:-1:-1;;;;;46598:27:0;46607:4;-1:-1:-1;;;;;46598:27:0;;;;;;;;;;;44660:2026;;44556:2130;;;:::o;35530:1111::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;35641:7:0;35726:13;;35719:4;:20;35715:859;;;35760:31;35794:17;;;:11;:17;;;;;;;;;35760:51;;;;;;;;;-1:-1:-1;;;;;35760:51:0;;;;-1:-1:-1;;;35760:51:0;;-1:-1:-1;;;;;35760:51:0;;;;;;;;-1:-1:-1;;;35760:51:0;;;;;;;;;;;;;;35830:729;;35880:14;;-1:-1:-1;;;;;35880:28:0;;35876:101;;35944:9;35530:1111;-1:-1:-1;;;35530:1111:0:o;35876:101::-;-1:-1:-1;;;36319:6:0;36364:17;;;;:11;:17;;;;;;;;;36352:29;;;;;;;;;-1:-1:-1;;;;;36352:29:0;;;;;-1:-1:-1;;;36352:29:0;;-1:-1:-1;;;;;36352:29:0;;;;;;;;-1:-1:-1;;;36352:29:0;;;;;;;;;;;;;36412:28;36408:109;;36480:9;35530:1111;-1:-1:-1;;;35530:1111:0:o;36408:109::-;36279:261;;;35741:833;35715:859;36602:31;;-1:-1:-1;;;36602:31:0;;;;;;;;;;;20330:191;20404:16;20423:6;;-1:-1:-1;;;;;20440:17:0;;;-1:-1:-1;;;;;;20440:17:0;;;;;;20473:40;;20423:6;;;;;;;20473:40;;20404:16;20473:40;20393:128;20330:191;:::o;4472:98::-;4530:7;4557:5;4561:1;4557;:5;:::i;3907:98::-;3965:7;3992:5;3996:1;3992;:5;:::i;3508:98::-;3566:7;3593:5;3597:1;3593;:5;:::i;40644:104::-;40713:27;40723:2;40727:8;40713:27;;;;;;;;;;;;:9;:27::i;50296:667::-;50480:72;;-1:-1:-1;;;50480:72:0;;50459:4;;-1:-1:-1;;;;;50480:36:0;;;;;:72;;18512:10;;50531:4;;50537:7;;50546:5;;50480:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50480:72:0;;;;;;;;-1:-1:-1;;50480:72:0;;;;;;;;;;;;:::i;:::-;;;50476:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50714:13:0;;50710:235;;50760:40;;-1:-1:-1;;;50760:40:0;;;;;;;;;;;50710:235;50903:6;50897:13;50888:6;50884:2;50880:15;50873:38;50476:480;-1:-1:-1;;;;;;50599:55:0;-1:-1:-1;;;50599:55:0;;-1:-1:-1;50476:480:0;50296:667;;;;;;:::o;61484:108::-;61544:13;61577:7;61570:14;;;;;:::i;16638:723::-;16694:13;16915:10;16911:53;;-1:-1:-1;;16942:10:0;;;;;;;;;;;;-1:-1:-1;;;16942:10:0;;;;;16638:723::o;16911:53::-;16989:5;16974:12;17030:78;17037:9;;17030:78;;17063:8;;;;:::i;:::-;;-1:-1:-1;17086:10:0;;-1:-1:-1;17094:2:0;17086:10;;:::i;:::-;;;17030:78;;;17118:19;17150:6;-1:-1:-1;;;;;17140:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17140:17:0;;17118:39;;17168:154;17175:10;;17168:154;;17202:11;17212:1;17202:11;;:::i;:::-;;-1:-1:-1;17271:10:0;17279:2;17271:5;:10;:::i;:::-;17258:24;;:2;:24;:::i;:::-;17245:39;;17228:6;17235;17228:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;17228:56:0;;;;;;;;-1:-1:-1;17299:11:0;17308:2;17299:11;;:::i;:::-;;;17168:154;;41121:1749;41267:13;;-1:-1:-1;;;;;41295:16:0;;41291:48;;41320:19;;-1:-1:-1;;;41320:19:0;;;;;;;;;;;41291:48;41354:13;41350:44;;41376:18;;-1:-1:-1;;;41376:18:0;;;;;;;;;;;41350:44;-1:-1:-1;;;;;41745:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;41804:49:0;;-1:-1:-1;;;;;41745:44:0;;;;;;;41804:49;;;;-1:-1:-1;;41745:44:0;;;;;;41804:49;;;;;;;;;;;;;;;;41870:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;41920:66:0;;;-1:-1:-1;;;41970:15:0;41920:66;;;;;;;;;;;;;41870:25;;42067:23;;;;21831:19;:23;42107:631;;42147:313;42178:38;;42203:12;;-1:-1:-1;;;;;42178:38:0;;;42195:1;;42178:38;;42195:1;;42178:38;42244:69;42283:1;42287:2;42291:14;;;;;;42307:5;42244:30;:69::i;:::-;42239:174;;42349:40;;-1:-1:-1;;;42349:40:0;;;;;;;;;;;42239:174;42455:3;42440:12;:18;42147:313;;42541:12;42524:13;;:29;42520:43;;42555:8;;;42520:43;42107:631;;;42604:119;42635:40;;42660:14;;;;;-1:-1:-1;;;;;42635:40:0;;;42652:1;;42635:40;;42652:1;;42635:40;42718:3;42703:12;:18;42604:119;;42107:631;-1:-1:-1;42752:13:0;:28;42802:60;42831:1;42835:2;42839:12;42853:8;42802:60;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:406:1;78:5;-1:-1:-1;;;;;104:6:1;101:30;98:56;;;134:18;;:::i;:::-;172:57;217:2;196:15;;-1:-1:-1;;192:29:1;223:4;188:40;172:57;:::i;:::-;163:66;;252:6;245:5;238:21;292:3;283:6;278:3;274:16;271:25;268:45;;;309:1;306;299:12;268:45;358:6;353:3;346:4;339:5;335:16;322:43;412:1;405:4;396:6;389:5;385:18;381:29;374:40;14:406;;;;;:::o;425:247::-;484:6;537:2;525:9;516:7;512:23;508:32;505:52;;;553:1;550;543:12;505:52;592:9;579:23;611:31;636:5;611:31;:::i;677:251::-;747:6;800:2;788:9;779:7;775:23;771:32;768:52;;;816:1;813;806:12;768:52;848:9;842:16;867:31;892:5;867:31;:::i;933:388::-;1001:6;1009;1062:2;1050:9;1041:7;1037:23;1033:32;1030:52;;;1078:1;1075;1068:12;1030:52;1117:9;1104:23;1136:31;1161:5;1136:31;:::i;:::-;1186:5;-1:-1:-1;1243:2:1;1228:18;;1215:32;1256:33;1215:32;1256:33;:::i;:::-;1308:7;1298:17;;;933:388;;;;;:::o;1326:456::-;1403:6;1411;1419;1472:2;1460:9;1451:7;1447:23;1443:32;1440:52;;;1488:1;1485;1478:12;1440:52;1527:9;1514:23;1546:31;1571:5;1546:31;:::i;:::-;1596:5;-1:-1:-1;1653:2:1;1638:18;;1625:32;1666:33;1625:32;1666:33;:::i;:::-;1326:456;;1718:7;;-1:-1:-1;;;1772:2:1;1757:18;;;;1744:32;;1326:456::o;1787:794::-;1882:6;1890;1898;1906;1959:3;1947:9;1938:7;1934:23;1930:33;1927:53;;;1976:1;1973;1966:12;1927:53;2015:9;2002:23;2034:31;2059:5;2034:31;:::i;:::-;2084:5;-1:-1:-1;2141:2:1;2126:18;;2113:32;2154:33;2113:32;2154:33;:::i;:::-;2206:7;-1:-1:-1;2260:2:1;2245:18;;2232:32;;-1:-1:-1;2315:2:1;2300:18;;2287:32;-1:-1:-1;;;;;2331:30:1;;2328:50;;;2374:1;2371;2364:12;2328:50;2397:22;;2450:4;2442:13;;2438:27;-1:-1:-1;2428:55:1;;2479:1;2476;2469:12;2428:55;2502:73;2567:7;2562:2;2549:16;2544:2;2540;2536:11;2502:73;:::i;:::-;2492:83;;;1787:794;;;;;;;:::o;2586:382::-;2651:6;2659;2712:2;2700:9;2691:7;2687:23;2683:32;2680:52;;;2728:1;2725;2718:12;2680:52;2767:9;2754:23;2786:31;2811:5;2786:31;:::i;:::-;2836:5;-1:-1:-1;2893:2:1;2878:18;;2865:32;2906:30;2865:32;2906:30;:::i;2973:315::-;3041:6;3049;3102:2;3090:9;3081:7;3077:23;3073:32;3070:52;;;3118:1;3115;3108:12;3070:52;3157:9;3144:23;3176:31;3201:5;3176:31;:::i;:::-;3226:5;3278:2;3263:18;;;;3250:32;;-1:-1:-1;;;2973:315:1:o;3293:383::-;3370:6;3378;3386;3439:2;3427:9;3418:7;3414:23;3410:32;3407:52;;;3455:1;3452;3445:12;3407:52;3494:9;3481:23;3513:31;3538:5;3513:31;:::i;:::-;3563:5;3615:2;3600:18;;3587:32;;-1:-1:-1;3666:2:1;3651:18;;;3638:32;;3293:383;-1:-1:-1;;;3293:383:1:o;3681:957::-;3765:6;3796:2;3839;3827:9;3818:7;3814:23;3810:32;3807:52;;;3855:1;3852;3845:12;3807:52;3895:9;3882:23;-1:-1:-1;;;;;3965:2:1;3957:6;3954:14;3951:34;;;3981:1;3978;3971:12;3951:34;4019:6;4008:9;4004:22;3994:32;;4064:7;4057:4;4053:2;4049:13;4045:27;4035:55;;4086:1;4083;4076:12;4035:55;4122:2;4109:16;4144:2;4140;4137:10;4134:36;;;4150:18;;:::i;:::-;4196:2;4193:1;4189:10;4179:20;;4219:28;4243:2;4239;4235:11;4219:28;:::i;:::-;4281:15;;;4312:12;;;;4344:11;;;4374;;;4370:20;;4367:33;-1:-1:-1;4364:53:1;;;4413:1;4410;4403:12;4364:53;4435:1;4426:10;;4445:163;4459:2;4456:1;4453:9;4445:163;;;4516:17;;4504:30;;4477:1;4470:9;;;;;4554:12;;;;4586;;4445:163;;;-1:-1:-1;4627:5:1;3681:957;-1:-1:-1;;;;;;;;3681:957:1:o;4643:245::-;4710:6;4763:2;4751:9;4742:7;4738:23;4734:32;4731:52;;;4779:1;4776;4769:12;4731:52;4811:9;4805:16;4830:28;4852:5;4830:28;:::i;4893:245::-;4951:6;5004:2;4992:9;4983:7;4979:23;4975:32;4972:52;;;5020:1;5017;5010:12;4972:52;5059:9;5046:23;5078:30;5102:5;5078:30;:::i;5143:249::-;5212:6;5265:2;5253:9;5244:7;5240:23;5236:32;5233:52;;;5281:1;5278;5271:12;5233:52;5313:9;5307:16;5332:30;5356:5;5332:30;:::i;5397:450::-;5466:6;5519:2;5507:9;5498:7;5494:23;5490:32;5487:52;;;5535:1;5532;5525:12;5487:52;5575:9;5562:23;-1:-1:-1;;;;;5600:6:1;5597:30;5594:50;;;5640:1;5637;5630:12;5594:50;5663:22;;5716:4;5708:13;;5704:27;-1:-1:-1;5694:55:1;;5745:1;5742;5735:12;5694:55;5768:73;5833:7;5828:2;5815:16;5810:2;5806;5802:11;5768:73;:::i;5852:180::-;5911:6;5964:2;5952:9;5943:7;5939:23;5935:32;5932:52;;;5980:1;5977;5970:12;5932:52;-1:-1:-1;6003:23:1;;5852:180;-1:-1:-1;5852:180:1:o;6037:257::-;6078:3;6116:5;6110:12;6143:6;6138:3;6131:19;6159:63;6215:6;6208:4;6203:3;6199:14;6192:4;6185:5;6181:16;6159:63;:::i;:::-;6276:2;6255:15;-1:-1:-1;;6251:29:1;6242:39;;;;6283:4;6238:50;;6037:257;-1:-1:-1;;6037:257:1:o;6582:1527::-;6806:3;6844:6;6838:13;6870:4;6883:51;6927:6;6922:3;6917:2;6909:6;6905:15;6883:51;:::i;:::-;6997:13;;6956:16;;;;7019:55;6997:13;6956:16;7041:15;;;7019:55;:::i;:::-;7163:13;;7096:20;;;7136:1;;7223;7245:18;;;;7298;;;;7325:93;;7403:4;7393:8;7389:19;7377:31;;7325:93;7466:2;7456:8;7453:16;7433:18;7430:40;7427:167;;;-1:-1:-1;;;7493:33:1;;7549:4;7546:1;7539:15;7579:4;7500:3;7567:17;7427:167;7610:18;7637:110;;;;7761:1;7756:328;;;;7603:481;;7637:110;-1:-1:-1;;7672:24:1;;7658:39;;7717:20;;;;-1:-1:-1;7637:110:1;;7756:328;13933:1;13926:14;;;13970:4;13957:18;;7851:1;7865:169;7879:8;7876:1;7873:15;7865:169;;;7961:14;;7946:13;;;7939:37;8004:16;;;;7896:10;;7865:169;;;7869:3;;8065:8;8058:5;8054:20;8047:27;;7603:481;-1:-1:-1;8100:3:1;;6582:1527;-1:-1:-1;;;;;;;;;;;6582:1527:1:o;8702:488::-;-1:-1:-1;;;;;8971:15:1;;;8953:34;;9023:15;;9018:2;9003:18;;8996:43;9070:2;9055:18;;9048:34;;;9118:3;9113:2;9098:18;;9091:31;;;8896:4;;9139:45;;9164:19;;9156:6;9139:45;:::i;:::-;9131:53;8702:488;-1:-1:-1;;;;;;8702:488:1:o;9195:724::-;9430:2;9482:21;;;9552:13;;9455:18;;;9574:22;;;9401:4;;9430:2;9653:15;;;;9627:2;9612:18;;;9401:4;9696:197;9710:6;9707:1;9704:13;9696:197;;;9759:52;9807:3;9798:6;9792:13;6383:12;;-1:-1:-1;;;;;6379:38:1;6367:51;;6471:4;6460:16;;;6454:23;-1:-1:-1;;;;;6450:48:1;6434:14;;;6427:72;6562:4;6551:16;;;6545:23;6538:31;6531:39;6515:14;;6508:63;6299:278;9759:52;9868:15;;;;9840:4;9831:14;;;;;9732:1;9725:9;9696:197;;9924:632;10095:2;10147:21;;;10217:13;;10120:18;;;10239:22;;;10066:4;;10095:2;10318:15;;;;10292:2;10277:18;;;10066:4;10361:169;10375:6;10372:1;10369:13;10361:169;;;10436:13;;10424:26;;10505:15;;;;10470:12;;;;10397:1;10390:9;10361:169;;10753:219;10902:2;10891:9;10884:21;10865:4;10922:44;10962:2;10951:9;10947:18;10939:6;10922:44;:::i;12413:356::-;12615:2;12597:21;;;12634:18;;;12627:30;12693:34;12688:2;12673:18;;12666:62;12760:2;12745:18;;12413:356::o;13126:267::-;6383:12;;-1:-1:-1;;;;;6379:38:1;6367:51;;6471:4;6460:16;;;6454:23;-1:-1:-1;;;;;6450:48:1;6434:14;;;6427:72;6562:4;6551:16;;;6545:23;6538:31;6531:39;6515:14;;;6508:63;13324:2;13309:18;;13336:51;6299:278;13580:275;13651:2;13645:9;13716:2;13697:13;;-1:-1:-1;;13693:27:1;13681:40;;-1:-1:-1;;;;;13736:34:1;;13772:22;;;13733:62;13730:88;;;13798:18;;:::i;:::-;13834:2;13827:22;13580:275;;-1:-1:-1;13580:275:1:o;13986:128::-;14026:3;14057:1;14053:6;14050:1;14047:13;14044:39;;;14063:18;;:::i;:::-;-1:-1:-1;14099:9:1;;13986:128::o;14119:120::-;14159:1;14185;14175:35;;14190:18;;:::i;:::-;-1:-1:-1;14224:9:1;;14119:120::o;14244:168::-;14284:7;14350:1;14346;14342:6;14338:14;14335:1;14332:21;14327:1;14320:9;14313:17;14309:45;14306:71;;;14357:18;;:::i;:::-;-1:-1:-1;14397:9:1;;14244:168::o;14417:125::-;14457:4;14485:1;14482;14479:8;14476:34;;;14490:18;;:::i;:::-;-1:-1:-1;14527:9:1;;14417:125::o;14547:258::-;14619:1;14629:113;14643:6;14640:1;14637:13;14629:113;;;14719:11;;;14713:18;14700:11;;;14693:39;14665:2;14658:10;14629:113;;;14760:6;14757:1;14754:13;14751:48;;;-1:-1:-1;;14795:1:1;14777:16;;14770:27;14547:258::o;14810:380::-;14889:1;14885:12;;;;14932;;;14953:61;;15007:4;14999:6;14995:17;14985:27;;14953:61;15060:2;15052:6;15049:14;15029:18;15026:38;15023:161;;;15106:10;15101:3;15097:20;15094:1;15087:31;15141:4;15138:1;15131:15;15169:4;15166:1;15159:15;15023:161;;14810:380;;;:::o;15195:135::-;15234:3;-1:-1:-1;;15255:17:1;;15252:43;;;15275:18;;:::i;:::-;-1:-1:-1;15322:1:1;15311:13;;15195:135::o;15335:112::-;15367:1;15393;15383:35;;15398:18;;:::i;:::-;-1:-1:-1;15432:9:1;;15335:112::o;15452:127::-;15513:10;15508:3;15504:20;15501:1;15494:31;15544:4;15541:1;15534:15;15568:4;15565:1;15558:15;15584:127;15645:10;15640:3;15636:20;15633:1;15626:31;15676:4;15673:1;15666:15;15700:4;15697:1;15690:15;15716:127;15777:10;15772:3;15768:20;15765:1;15758:31;15808:4;15805:1;15798:15;15832:4;15829:1;15822:15;15848:127;15909:10;15904:3;15900:20;15897:1;15890:31;15940:4;15937:1;15930:15;15964:4;15961:1;15954:15;15980:131;-1:-1:-1;;;;;16055:31:1;;16045:42;;16035:70;;16101:1;16098;16091:12;16116:118;16202:5;16195:13;16188:21;16181:5;16178:32;16168:60;;16224:1;16221;16214:12;16239:131;-1:-1:-1;;;;;;16313:32:1;;16303:43;;16293:71;;16360:1;16357;16350:12

Swarm Source

ipfs://1a860cbe32b9b2fc4c1a6865402030cd5ee351f8407a5a07d9a9612a9be9a8f8

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services