Token

Buidlverse (BUIDL)

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

ERC-721

Overview

Max Total Supply

2,811 BUIDL

Holders

289

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x15ca60265bc8eb8adab416954053cd9661ebd3ca

Filtered by Token Holder

0x30202cc3d9593f3511924C0192cD101bD393738E

Balance

1 BUIDL

0x30202cc3d9593f3511924c0192cd101bd393738e

OVERVIEW

A collection of NFTs, inspired by the world’s most iconic architecture marvels – called BUIDLs. Each BUIDL NFT has a unique use case in the Buidlverse, an upcoming P2E game.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Buidlverse

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 20000 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-12-17
*/

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

pragma solidity 0.8.7;

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

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


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




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

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

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

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

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

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

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

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

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

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

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

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

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


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



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

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


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




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

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

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

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


// OpenZeppelin Contracts v4.4.0 (utils/Address.sol)



/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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



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

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

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


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



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

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

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

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

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

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


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




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

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


// OpenZeppelin Contracts v4.4.0 (token/ERC721/ERC721.sol)










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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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

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

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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)




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

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

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

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

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

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

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

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

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


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



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

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

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

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

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

// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts v4.4.0 (utils/cryptography/MerkleProof.sol)



/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merklee tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }
        return computedHash;
    }
}

// File: @openzeppelin/contracts/utils/cryptography/ECDSA.sol


// OpenZeppelin Contracts v4.4.0 (utils/cryptography/ECDSA.sol)




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

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

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

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

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

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

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

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

        return (signer, RecoverError.NoError);
    }

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

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

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

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

// File: contracts/Buidlverse.sol











/**
 * @title Buidlverse ERC721 contract
 * @dev This contract inherits from ERC721, but does not have the ERC721Enumerable extension.
 * ERC721Enumerable was deemed not worthwhile for the added mint and transfer costs
 */
contract Buidlverse is ERC721, Ownable {
  using MerkleProof for bytes32[];
  using ECDSA for bytes32;
  using Strings for uint256;
  using Counters for Counters.Counter;

  Counters.Counter private idCounter;

  string public provenanceHash = "";

  string public baseURI;
  string public baseExtension = ".json";

  uint256 public maxSupply;
  uint256 public cost = 0;
  uint256 public maxMintAmount = 20;

  bool public paused = false;

  uint256 public whitelistIndex = 1; // if 0, no whitelist is active, if >0, use Merkle whitelist
  mapping (uint256 => mapping (address => bool)) public whitelistClaimed; // index -> user -> claimed or not
  bytes32 public whitelistMerkleRoot;

  constructor(
    string memory _name,
    string memory _symbol,
    string memory _newBaseURI,
    uint256 _maxSupply
  ) ERC721(_name, _symbol) {
    baseURI = _newBaseURI;
    maxSupply = _maxSupply;
  }

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

  /**
  * @dev internally mints new tokenIds to target. tokenIds are incremented and minted in sequential order.
  * @param _to address to mint new tokenIds to
  * @param _mintAmount amount of new tokenIds to mint
  */
  function _mintInternal(address _to, uint256 _mintAmount) internal {
    require(!paused, "the contract is paused");

    require(_mintAmount > 0, "need to mint at least 1");
    require(_mintAmount <= maxMintAmount, "cannot mint more than maxMintAmount per call");
    require(totalSupply() + _mintAmount <= maxSupply, "exceeded max token limit");
    require(msg.value >= cost * _mintAmount, "insufficient funds");

    for (uint256 i = 0; i < _mintAmount; i++) {
      idCounter.increment();
      _safeMint(_to, idCounter.current());
    }
  }

  // public
  /**
  * @notice get metadata URI for a given tokenId
  */
  function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
    require(
      _exists(tokenId),
      "ERC721Metadata: URI query for nonexistent token"
    );
    
    string memory currentBaseURI = _baseURI();
    return bytes(currentBaseURI).length > 0
        ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension))
        : "";
  }

  /**
  * @notice get base metadata URI for all tokenIds and the collection
  */
  function baseTokenURI() public view returns (string memory) {
    return _baseURI();
  }

  /**
  * @notice get the latest tokenId
  */
  function currentId() public view returns (uint) {
    return idCounter.current();
  }

  /**
  * @notice get the total number of minted tokenIds
  */
  function totalSupply() public view returns (uint256) {
    return idCounter.current();
  }

  /**
  * @notice get the tokenId at a given index in the collection
  */
  function tokenByIndex(uint256 _index) public view returns (uint256) {
    require(_index < totalSupply(), "Global index out of bounds");
    return _index + 1;
  }

  /**
  * @notice check if the provided proof proves that the sender is whitelisted in the current Merkle tree
  */
  function verifyMerkleProof(address _sender, bytes32[] memory _proof) public view returns (bool) {
    bytes32 leaf = keccak256(abi.encodePacked(_sender));
    return _proof.verify(whitelistMerkleRoot,leaf);
  }

  // external
  /**
  * @notice when minting is open to public, mint given amount of tokenIds to an address
  * @param _to address to mint tokenId to
  * @param _mintAmount amount of new tokenIds to mint
  */
  function mint(address _to, uint256 _mintAmount) external payable {
    require(whitelistIndex == 0, "mint is whitelist-only right now");

    _mintInternal(_to, _mintAmount);
  }
  
  /**
  * @notice when minting is whitelist-only, mint 1 tokenId to an address specified by the whitelisted sender
  * @param _to address to mint tokenId to
  * @param _proof the Merkle proof to prove the sender is whitelisted in the Merkle tree
  */
  function mintWithWhitelist(address _to, bytes32[] memory _proof) external payable {
    require(whitelistIndex > 0, "mint is not in whitelist mode right now");
    require(!whitelistClaimed[whitelistIndex][msg.sender], "whitelist spot already claimed");

    require(whitelistMerkleRoot != "", "whitelist merkleRoot missing");
    require(verifyMerkleProof(msg.sender, _proof), "failed to verify merkle proof");

    whitelistClaimed[whitelistIndex][msg.sender] = true;
    _mintInternal(_to, 1);
  }
  
  /**
  * @dev admin sets the cost to mint 1 tokenId
  */
  function setCost(uint256 _newCost) external onlyOwner {
    cost = _newCost;
  }

  /**
  * @dev admin sets the maximum number of tokenIds that can be minted in a single call to the mint function
  */
  function setMaxMintAmount(uint256 _newmaxMintAmount) external onlyOwner {
    maxMintAmount = _newmaxMintAmount;
  }

  /**
  * @dev admin sets base metadata URI for all tokenIds and the collection
  */
  function setBaseURI(string memory _newBaseURI) external onlyOwner {
    baseURI = _newBaseURI;
  }

  /**
  * @dev admin sets the file extension for metadata objects
  */
  function setBaseExtension(string memory _newBaseExtension) external onlyOwner {
    baseExtension = _newBaseExtension;
  }
  
  /**
  * @dev admin pauses or unpauses minting of new tokenIds
  */
  function pause(bool _paused) external onlyOwner {
    paused = _paused;
  }

  /**
  * @dev admin uploads a new whitelist or removes current whitelist
  * @param _newIndex new index of the whitelist
  * @param _newRoot new Merkle root of the whitelist
  */
  function setWhitelist(uint256 _newIndex, bytes32 _newRoot) external onlyOwner {
    whitelistIndex = _newIndex;
    whitelistMerkleRoot = _newRoot;
  }

  /**
  * @dev admin sets the provenance hash once it is generated or updated
  */
  function setProvenanceHash(string memory _newHash) external onlyOwner {
    provenanceHash = _newHash;
  }

  /**
  * @dev admin sets maximum number of tokenIds that can be minted in this collection
  */
  function setMaxSupply(uint256 _maxSupply) external onlyOwner {
    require(_maxSupply >= totalSupply(), "max supply cannot be lower than current supply");
    maxSupply = _maxSupply;
  }
   
  /**
  * @dev admin withdraws all Ether that is available in this contract to the given address
  */
  function withdraw(address _payee) external payable onlyOwner {
    // This is the latest recommended way to withdraw funds in Solidity 0.8
    // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
    (bool success, ) = payable(_payee).call{value: address(this).balance}("");
    require(success, "transfer failed");
  }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"string","name":"_newBaseURI","type":"string"},{"internalType":"uint256","name":"_maxSupply","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"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":[{"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":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"mintWithWhitelist","outputs":[],"stateMutability":"payable","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":[{"internalType":"bool","name":"_paused","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"provenanceHash","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"_newBaseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newmaxMintAmount","type":"uint256"}],"name":"setMaxMintAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxSupply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newHash","type":"string"}],"name":"setProvenanceHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newIndex","type":"uint256"},{"internalType":"bytes32","name":"_newRoot","type":"bytes32"}],"name":"setWhitelist","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":"_index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"verifyMerkleProof","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"whitelistClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistMerkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_payee","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000001f9b000000000000000000000000000000000000000000000000000000000000000a427569646c7665727365000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005425549444c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d5643686d41326d6f5233335a536250387061373469766365444d48725742454b5558645a3977374d415642712f00000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Buidlverse
Arg [1] : _symbol (string): BUIDL
Arg [2] : _newBaseURI (string): ipfs://QmVChmA2moR33ZSbP8pa74ivceDMHrWBEKUXdZ9w7MAVBq/
Arg [3] : _maxSupply (uint256): 8091

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [3] : 0000000000000000000000000000000000000000000000000000000000001f9b
Arg [4] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [5] : 427569646c766572736500000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [7] : 425549444c000000000000000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [9] : 697066733a2f2f516d5643686d41326d6f5233335a5362503870613734697663
Arg [10] : 65444d48725742454b5558645a3977374d415642712f00000000000000000000

Deployed Bytecode Sourcemap

49352:6814:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20990:305;;;;;;;;;;-1:-1:-1;20990:305:0;;;;;:::i;:::-;;:::i;:::-;;;9316:14:1;;9309:22;9291:41;;9279:2;9264:18;20990:305:0;;;;;;;;54793:77;;;;;;;;;;-1:-1:-1;54793:77:0;;;;;:::i;:::-;;:::i;:::-;;21935:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;23494:221::-;;;;;;;;;;-1:-1:-1;23494:221:0;;;;;:::i;:::-;;:::i;:::-;;;8580:42:1;8568:55;;;8550:74;;8538:2;8523:18;23494:221:0;8404:226:1;54197:118:0;;;;;;;;;;-1:-1:-1;54197:118:0;;;;;:::i;:::-;;:::i;23017:411::-;;;;;;;;;;-1:-1:-1;23017:411:0;;;;;:::i;:::-;;:::i;55307:108::-;;;;;;;;;;-1:-1:-1;55307:108:0;;;;;:::i;:::-;;:::i;49712:23::-;;;;;;;;;;;;;;;;;;;9489:25:1;;;9477:2;9462:18;49712:23:0;9343:177:1;52063:92:0;;;;;;;;;;;;;:::i;49740:33::-;;;;;;;;;;;;;;;;24244:339;;;;;;;;;;-1:-1:-1;24244:339:0;;;;;:::i;:::-;;:::i;52963:182::-;;;;;;:::i;:::-;;:::i;24654:185::-;;;;;;;;;;-1:-1:-1;24654:185:0;;;;;:::i;:::-;;:::i;53987:82::-;;;;;;;;;;-1:-1:-1;53987:82:0;;;;;:::i;:::-;;:::i;52238:166::-;;;;;;;;;;-1:-1:-1;52238:166:0;;;;;:::i;:::-;;:::i;55823:340::-;;;;;;:::i;:::-;;:::i;54409:100::-;;;;;;;;;;-1:-1:-1;54409:100:0;;;;;:::i;:::-;;:::i;49780:26::-;;;;;;;;;;-1:-1:-1;49780:26:0;;;;;;;;52529:213;;;;;;;;;;-1:-1:-1;52529:213:0;;;;;:::i;:::-;;:::i;21629:239::-;;;;;;;;;;-1:-1:-1;21629:239:0;;;;;:::i;:::-;;:::i;49613:21::-;;;;;;;;;;;;;:::i;55520:189::-;;;;;;;;;;-1:-1:-1;55520:189:0;;;;;:::i;:::-;;:::i;21359:208::-;;;;;;;;;;-1:-1:-1;21359:208:0;;;;;:::i;:::-;;:::i;35120:103::-;;;;;;;;;;;;;:::i;34469:87::-;;;;;;;;;;-1:-1:-1;34542:6:0;;;;34469:87;;53409:509;;;;;;:::i;:::-;;:::i;22104:104::-;;;;;;;;;;;;;:::i;23787:155::-;;;;;;;;;;-1:-1:-1;23787:155:0;;;;;:::i;:::-;;:::i;49813:33::-;;;;;;;;;;;;;;;;50022:34;;;;;;;;;;;;;;;;24910:328;;;;;;;;;;-1:-1:-1;24910:328:0;;;;;:::i;:::-;;:::i;49639:37::-;;;;;;;;;;;;;:::i;49573:33::-;;;;;;;;;;;;;:::i;51270:399::-;;;;;;;;;;-1:-1:-1;51270:399:0;;;;;:::i;:::-;;:::i;49912:70::-;;;;;;;;;;-1:-1:-1;49912:70:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;51759:90;;;;;;;;;;;;;:::i;49683:24::-;;;;;;;;;;;;;;;;54589:124;;;;;;;;;;-1:-1:-1;54589:124:0;;;;;:::i;:::-;;:::i;24013:164::-;;;;;;;;;;-1:-1:-1;24013:164:0;;;;;:::i;:::-;24134:25;;;;24110:4;24134:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;24013:164;35378:201;;;;;;;;;;-1:-1:-1;35378:201:0;;;;;:::i;:::-;;:::i;55061:154::-;;;;;;;;;;-1:-1:-1;55061:154:0;;;;;:::i;:::-;;:::i;20990:305::-;21092:4;21129:40;;;21144:25;21129:40;;:105;;-1:-1:-1;21186:48:0;;;21201:33;21186:48;21129:105;:158;;;-1:-1:-1;19581:25:0;19566:40;;;;21251:36;21109:178;20990:305;-1:-1:-1;;20990:305:0:o;54793:77::-;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;;;;;;;;;54848:6:::1;:16:::0;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;54793:77::o;21935:100::-;21989:13;22022:5;22015:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21935:100;:::o;23494:221::-;23570:7;26837:16;;;:7;:16;;;;;;:30;:16;23590:73;;;;-1:-1:-1;;;23590:73:0;;15396:2:1;23590:73:0;;;15378:21:1;15435:2;15415:18;;;15408:30;15474:34;15454:18;;;15447:62;15545:14;15525:18;;;15518:42;15577:19;;23590:73:0;15194:408:1;23590:73:0;-1:-1:-1;23683:24:0;;;;:15;:24;;;;;;;;;23494:221::o;54197:118::-;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;15607:356:1;34681:68:0;54276:13:::1;:33:::0;54197:118::o;23017:411::-;23098:13;23114:23;23129:7;23114:14;:23::i;:::-;23098:39;;23162:5;23156:11;;:2;:11;;;;23148:57;;;;-1:-1:-1;;;23148:57:0;;17347:2:1;23148:57:0;;;17329:21:1;17386:2;17366:18;;;17359:30;17425:34;17405:18;;;17398:62;17496:3;17476:18;;;17469:31;17517:19;;23148:57:0;17145:397:1;23148:57:0;16380:10;23240:21;;;;;:62;;-1:-1:-1;23265:37:0;23282:5;16380:10;24013:164;:::i;23265:37::-;23218:168;;;;-1:-1:-1;;;23218:168:0;;13023:2:1;23218:168:0;;;13005:21:1;13062:2;13042:18;;;13035:30;13101:34;13081:18;;;13074:62;13172:26;13152:18;;;13145:54;13216:19;;23218:168:0;12821:420:1;23218:168:0;23399:21;23408:2;23412:7;23399:8;:21::i;:::-;23087:341;23017:411;;:::o;55307:108::-;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;15607:356:1;34681:68:0;55384:25;;::::1;::::0;:14:::1;::::0;:25:::1;::::0;::::1;::::0;::::1;:::i;:::-;;55307:108:::0;:::o;52063:92::-;52107:7;52130:19;:9;36878:14;;36786:114;52130:19;52123:26;;52063:92;:::o;24244:339::-;24439:41;16380:10;24472:7;24439:18;:41::i;:::-;24431:103;;;;-1:-1:-1;;;24431:103:0;;19218:2:1;24431:103:0;;;19200:21:1;19257:2;19237:18;;;19230:30;19296:34;19276:18;;;19269:62;19367:19;19347:18;;;19340:47;19404:19;;24431:103:0;19016:413:1;24431:103:0;24547:28;24557:4;24563:2;24567:7;24547:9;:28::i;52963:182::-;53043:14;;:19;53035:64;;;;-1:-1:-1;;;53035:64:0;;20388:2:1;53035:64:0;;;20370:21:1;;;20407:18;;;20400:30;20466:34;20446:18;;;20439:62;20518:18;;53035:64:0;20186:356:1;53035:64:0;53108:31;53122:3;53127:11;53108:13;:31::i;24654:185::-;24792:39;24809:4;24815:2;24819:7;24792:39;;;;;;;;;;;;:16;:39::i;53987:82::-;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;15607:356:1;34681:68:0;54048:4:::1;:15:::0;53987:82::o;52238:166::-;52297:7;52330:13;:11;:13::i;:::-;52321:6;:22;52313:61;;;;-1:-1:-1;;;52313:61:0;;18164:2:1;52313:61:0;;;18146:21:1;18203:2;18183:18;;;18176:30;18242:28;18222:18;;;18215:56;18288:18;;52313:61:0;17962:350:1;52313:61:0;52388:10;:6;52397:1;52388:10;:::i;55823:340::-;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;15607:356:1;34681:68:0;56043:12:::1;56069:6;56061:20;;56089:21;56061:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56042:73;;;56130:7;56122:35;;;::::0;-1:-1:-1;;;56122:35:0;;19636:2:1;56122:35:0::1;::::0;::::1;19618:21:1::0;19675:2;19655:18;;;19648:30;19714:17;19694:18;;;19687:45;19749:18;;56122:35:0::1;19434:339:1::0;54409:100:0;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;15607:356:1;34681:68:0;54482:21;;::::1;::::0;:7:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;52529:213::-:0;52657:25;;6188:66:1;6175:2;6171:15;;;6167:88;52657:25:0;;;6155:101:1;52619:4:0;;;;6272:12:1;;52657:25:0;;;;;;;;;;;;52647:36;;;;;;52632:51;;52697:39;52711:19;;52731:4;52697:6;:13;;:39;;;;;:::i;:::-;52690:46;52529:213;-1:-1:-1;;;;52529:213:0:o;21629:239::-;21701:7;21737:16;;;:7;:16;;;;;;;;21772:19;21764:73;;;;-1:-1:-1;;;21764:73:0;;14212:2:1;21764:73:0;;;14194:21:1;14251:2;14231:18;;;14224:30;14290:34;14270:18;;;14263:62;14361:11;14341:18;;;14334:39;14390:19;;21764:73:0;14010:405:1;49613:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55520:189::-;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;15607:356:1;34681:68:0;55610:13:::1;:11;:13::i;:::-;55596:10;:27;;55588:86;;;::::0;-1:-1:-1;;;55588:86:0;;17749:2:1;55588:86:0::1;::::0;::::1;17731:21:1::0;17788:2;17768:18;;;17761:30;17827:34;17807:18;;;17800:62;17898:16;17878:18;;;17871:44;17932:19;;55588:86:0::1;17547:410:1::0;55588:86:0::1;55681:9;:22:::0;55520:189::o;21359:208::-;21431:7;21459:19;;;21451:74;;;;-1:-1:-1;;;21451:74:0;;13801:2:1;21451:74:0;;;13783:21:1;13840:2;13820:18;;;13813:30;13879:34;13859:18;;;13852:62;13950:12;13930:18;;;13923:40;13980:19;;21451:74:0;13599:406:1;21451:74:0;-1:-1:-1;21543:16:0;;;;;;:9;:16;;;;;;;21359:208::o;35120:103::-;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;15607:356:1;34681:68:0;35185:30:::1;35212:1;35185:18;:30::i;:::-;35120:103::o:0;53409:509::-;53523:1;53506:14;;:18;53498:70;;;;-1:-1:-1;;;53498:70:0;;19980:2:1;53498:70:0;;;19962:21:1;20019:2;19999:18;;;19992:30;20058:34;20038:18;;;20031:62;20129:9;20109:18;;;20102:37;20156:19;;53498:70:0;19778:403:1;53498:70:0;53601:14;;53584:32;;;;:16;:32;;;;;;;;53617:10;53584:44;;;;;;;;;;53583:45;53575:88;;;;-1:-1:-1;;;53575:88:0;;12664:2:1;53575:88:0;;;12646:21:1;12703:2;12683:18;;;12676:30;12742:32;12722:18;;;12715:60;12792:18;;53575:88:0;12462:354:1;53575:88:0;53680:19;;53672:66;;;;-1:-1:-1;;;53672:66:0;;20749:2:1;53672:66:0;;;20731:21:1;20788:2;20768:18;;;20761:30;20827;20807:18;;;20800:58;20875:18;;53672:66:0;20547:352:1;53672:66:0;53753:37;53771:10;53783:6;53753:17;:37::i;:::-;53745:79;;;;-1:-1:-1;;;53745:79:0;;12306:2:1;53745:79:0;;;12288:21:1;12345:2;12325:18;;;12318:30;12384:31;12364:18;;;12357:59;12433:18;;53745:79:0;12104:353:1;53745:79:0;53850:14;;53833:32;;;;:16;:32;;;;;;;;53866:10;53833:44;;;;;;;:51;;;;53880:4;53833:51;;;;;;53891:21;;53905:3;;53891:13;:21::i;22104:104::-;22160:13;22193:7;22186:14;;;;;:::i;23787:155::-;23882:52;16380:10;23915:8;23925;23882:18;:52::i;24910:328::-;25085:41;16380:10;25118:7;25085:18;:41::i;:::-;25077:103;;;;-1:-1:-1;;;25077:103:0;;19218:2:1;25077:103:0;;;19200:21:1;19257:2;19237:18;;;19230:30;19296:34;19276:18;;;19269:62;19367:19;19347:18;;;19340:47;19404:19;;25077:103:0;19016:413:1;25077:103:0;25191:39;25205:4;25211:2;25215:7;25224:5;25191:13;:39::i;:::-;24910:328;;;;:::o;49639:37::-;;;;;;;:::i;49573:33::-;;;;;;;:::i;51270:399::-;26813:4;26837:16;;;:7;:16;;;;;;51343:13;;26837:30;:16;51365:97;;;;-1:-1:-1;;;51365:97:0;;16931:2:1;51365:97:0;;;16913:21:1;16970:2;16950:18;;;16943:30;17009:34;16989:18;;;16982:62;17080:17;17060:18;;;17053:45;17115:19;;51365:97:0;16729:411:1;51365:97:0;51475:28;51506:10;:8;:10::i;:::-;51475:41;;51561:1;51536:14;51530:28;:32;:133;;;;;;;;;;;;;;;;;51598:14;51614:18;:7;:16;:18::i;:::-;51634:13;51581:67;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;51530:133;51523:140;51270:399;-1:-1:-1;;;51270:399:0:o;51759:90::-;51804:13;51833:10;:8;:10::i;54589:124::-;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;15607:356:1;34681:68:0;54674:33;;::::1;::::0;:13:::1;::::0;:33:::1;::::0;::::1;::::0;::::1;:::i;35378:201::-:0;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;15607:356:1;34681:68:0;35467:22:::1;::::0;::::1;35459:73;;;::::0;-1:-1:-1;;;35459:73:0;;10370:2:1;35459:73:0::1;::::0;::::1;10352:21:1::0;10409:2;10389:18;;;10382:30;10448:34;10428:18;;;10421:62;10519:8;10499:18;;;10492:36;10545:19;;35459:73:0::1;10168:402:1::0;35459:73:0::1;35543:28;35562:8;35543:18;:28::i;:::-;35378:201:::0;:::o;55061:154::-;34542:6;;34689:23;34542:6;16380:10;34689:23;34681:68;;;;-1:-1:-1;;;34681:68:0;;15809:2:1;34681:68:0;;;15791:21:1;;;15828:18;;;15821:30;15887:34;15867:18;;;15860:62;15939:18;;34681:68:0;15607:356:1;34681:68:0;55146:14:::1;:26:::0;;;;55179:19:::1;:30:::0;55061:154::o;30730:174::-;30805:24;;;;:15;:24;;;;;:29;;;;;;;;;;;;;:24;;30859:23;30805:24;30859:14;:23::i;:::-;30850:46;;;;;;;;;;;;30730:174;;:::o;27042:348::-;27135:4;26837:16;;;:7;:16;;;;;;:30;:16;27152:73;;;;-1:-1:-1;;;27152:73:0;;11893:2:1;27152:73:0;;;11875:21:1;11932:2;11912:18;;;11905:30;11971:34;11951:18;;;11944:62;12042:14;12022:18;;;12015:42;12074:19;;27152:73:0;11691:408:1;27152:73:0;27236:13;27252:23;27267:7;27252:14;:23::i;:::-;27236:39;;27305:5;27294:16;;:7;:16;;;:51;;;;27338:7;27314:31;;:20;27326:7;27314:11;:20::i;:::-;:31;;;27294:51;:87;;;-1:-1:-1;24134:25:0;;;;24110:4;24134:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;27349:32;24013:164;30034:578;30193:4;30166:31;;:23;30181:7;30166:14;:23::i;:::-;:31;;;30158:85;;;;-1:-1:-1;;;30158:85:0;;16521:2:1;30158:85:0;;;16503:21:1;16560:2;16540:18;;;16533:30;16599:34;16579:18;;;16572:62;16670:11;16650:18;;;16643:39;16699:19;;30158:85:0;16319:405:1;30158:85:0;30262:16;;;30254:65;;;;-1:-1:-1;;;30254:65:0;;11134:2:1;30254:65:0;;;11116:21:1;11173:2;11153:18;;;11146:30;11212:34;11192:18;;;11185:62;11283:6;11263:18;;;11256:34;11307:19;;30254:65:0;10932:400:1;30254:65:0;30436:29;30453:1;30457:7;30436:8;:29::i;:::-;30478:15;;;;;;;:9;:15;;;;;:20;;30497:1;;30478:15;:20;;30497:1;;30478:20;:::i;:::-;;;;-1:-1:-1;;30509:13:0;;;;;;;:9;:13;;;;;:18;;30526:1;;30509:13;:18;;30526:1;;30509:18;:::i;:::-;;;;-1:-1:-1;;30538:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;;30577:27;;30538:16;;30577:27;;;;;;;30034:578;;;:::o;50630:558::-;50712:6;;;;50711:7;50703:42;;;;-1:-1:-1;;;50703:42:0;;16170:2:1;50703:42:0;;;16152:21:1;16209:2;16189:18;;;16182:30;16248:24;16228:18;;;16221:52;16290:18;;50703:42:0;15968:346:1;50703:42:0;50776:1;50762:11;:15;50754:51;;;;-1:-1:-1;;;50754:51:0;;18866:2:1;50754:51:0;;;18848:21:1;18905:2;18885:18;;;18878:30;18944:25;18924:18;;;18917:53;18987:18;;50754:51:0;18664:347:1;50754:51:0;50835:13;;50820:11;:28;;50812:85;;;;-1:-1:-1;;;50812:85:0;;14622:2:1;50812:85:0;;;14604:21:1;14661:2;14641:18;;;14634:30;14700:34;14680:18;;;14673:62;14771:14;14751:18;;;14744:42;14803:19;;50812:85:0;14420:408:1;50812:85:0;50943:9;;50928:11;50912:13;:11;:13::i;:::-;:27;;;;:::i;:::-;:40;;50904:77;;;;-1:-1:-1;;;50904:77:0;;13448:2:1;50904:77:0;;;13430:21:1;13487:2;13467:18;;;13460:30;13526:26;13506:18;;;13499:54;13570:18;;50904:77:0;13246:348:1;50904:77:0;51016:11;51009:4;;:18;;;;:::i;:::-;50996:9;:31;;50988:62;;;;-1:-1:-1;;;50988:62:0;;18519:2:1;50988:62:0;;;18501:21:1;18558:2;18538:18;;;18531:30;18597:20;18577:18;;;18570:48;18635:18;;50988:62:0;18317:342:1;50988:62:0;51064:9;51059:124;51083:11;51079:1;:15;51059:124;;;51110:21;:9;36997:19;;37015:1;36997:19;;;36908:127;51110:21;51140:35;51150:3;51155:19;:9;36878:14;;36786:114;51155:19;51140:9;:35::i;:::-;51096:3;;;;:::i;:::-;;;;51059:124;;38264:190;38389:4;38442;38413:25;38426:5;38433:4;38413:12;:25::i;:::-;:33;;38264:190;-1:-1:-1;;;;38264:190:0:o;35739:191::-;35832:6;;;;35849:17;;;;;;;;;;;35882:40;;35832:6;;;35849:17;35832:6;;35882:40;;35813:16;;35882:40;35802:128;35739:191;:::o;31046:315::-;31201:8;31192:17;;:5;:17;;;;31184:55;;;;-1:-1:-1;;;31184:55:0;;11539:2:1;31184:55:0;;;11521:21:1;11578:2;11558:18;;;11551:30;11617:27;11597:18;;;11590:55;11662:18;;31184:55:0;11337:349:1;31184:55:0;31250:25;;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;;;;;;;;;;;;31312:41;;9291::1;;;31312::0;;9264:18:1;31312:41:0;;;;;;;31046:315;;;:::o;26120:::-;26277:28;26287:4;26293:2;26297:7;26277:9;:28::i;:::-;26324:48;26347:4;26353:2;26357:7;26366:5;26324:22;:48::i;:::-;26316:111;;;;-1:-1:-1;;;26316:111:0;;9951:2:1;26316:111:0;;;9933:21:1;9990:2;9970:18;;;9963:30;10029:34;10009:18;;;10002:62;10100:20;10080:18;;;10073:48;10138:19;;26316:111:0;9749:414:1;50298:102:0;50358:13;50387:7;50380:14;;;;;:::i;16856:723::-;16912:13;17133:10;17129:53;;-1:-1:-1;;17160:10:0;;;;;;;;;;;;;;;;;;16856:723::o;17129:53::-;17207:5;17192:12;17248:78;17255:9;;17248:78;;17281:8;;;;:::i;:::-;;-1:-1:-1;17304:10:0;;-1:-1:-1;17312:2:0;17304:10;;:::i;:::-;;;17248:78;;;17336:19;17368:6;17358:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17358:17:0;;17336:39;;17386:154;17393:10;;17386:154;;17420:11;17430:1;17420:11;;:::i;:::-;;-1:-1:-1;17489:10:0;17497:2;17489:5;:10;:::i;:::-;17476:24;;:2;:24;:::i;:::-;17463:39;;17446:6;17453;17446:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;17517:11:0;17526:2;17517:11;;:::i;:::-;;;17386:154;;27732:110;27808:26;27818:2;27822:7;27808:26;;;;;;;;;;;;:9;:26::i;38816:701::-;38899:7;38942:4;38899:7;38957:523;38981:5;:12;38977:1;:16;38957:523;;;39015:20;39038:5;39044:1;39038:8;;;;;;;;:::i;:::-;;;;;;;39015:31;;39081:12;39065;:28;39061:408;;39218:44;;;;;;6452:19:1;;;6487:12;;;6480:28;;;6524:12;;39218:44:0;;;;;;;;;;;;39208:55;;;;;;39193:70;;39061:408;;;39408:44;;;;;;6452:19:1;;;6487:12;;;6480:28;;;6524:12;;39408:44:0;;;;;;;;;;;;39398:55;;;;;;39383:70;;39061:408;-1:-1:-1;38995:3:0;;;;:::i;:::-;;;;38957:523;;;-1:-1:-1;39497:12:0;38816:701;-1:-1:-1;;;38816:701:0:o;31926:799::-;32081:4;32102:13;;;8636:20;8684:8;32098:620;;32138:72;;;;;:36;;;;;;:72;;16380:10;;32189:4;;32195:7;;32204:5;;32138:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32138:72:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;32134:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32380:13:0;;32376:272;;32423:60;;-1:-1:-1;;;32423:60:0;;9951:2:1;32423:60:0;;;9933:21:1;9990:2;9970:18;;;9963:30;10029:34;10009:18;;;10002:62;10100:20;10080:18;;;10073:48;10138:19;;32423:60:0;9749:414:1;32376:272:0;32598:6;32592:13;32583:6;32579:2;32575:15;32568:38;32134:529;32261:51;;32271:41;32261:51;;-1:-1:-1;32254:58:0;;32098:620;-1:-1:-1;32702:4:0;31926:799;;;;;;:::o;28069:321::-;28199:18;28205:2;28209:7;28199:5;:18::i;:::-;28250:54;28281:1;28285:2;28289:7;28298:5;28250:22;:54::i;:::-;28228:154;;;;-1:-1:-1;;;28228:154:0;;9951:2:1;28228:154:0;;;9933:21:1;9990:2;9970:18;;;9963:30;10029:34;10009:18;;;10002:62;10100:20;10080:18;;;10073:48;10138:19;;28228:154:0;9749:414:1;28726:382:0;28806:16;;;28798:61;;;;-1:-1:-1;;;28798:61:0;;15035:2:1;28798:61:0;;;15017:21:1;;;15054:18;;;15047:30;15113:34;15093:18;;;15086:62;15165:18;;28798:61:0;14833:356:1;28798:61:0;26813:4;26837:16;;;:7;:16;;;;;;:30;:16;:30;28870:58;;;;-1:-1:-1;;;28870:58:0;;10777:2:1;28870:58:0;;;10759:21:1;10816:2;10796:18;;;10789:30;10855;10835:18;;;10828:58;10903:18;;28870:58:0;10575:352:1;28870:58:0;28999:13;;;;;;;:9;:13;;;;;:18;;29016:1;;28999:13;:18;;29016:1;;28999:18;:::i;:::-;;;;-1:-1:-1;;29028:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;29067:33;;29028:16;;;29067:33;;29028:16;;29067:33;28726:382;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:465:1;78:5;112:18;104:6;101:30;98:56;;;134:18;;:::i;:::-;172:116;282:4;213:66;208:2;200:6;196:15;192:88;188:99;172:116;:::i;:::-;163:125;;311:6;304:5;297:21;351:3;342:6;337:3;333:16;330:25;327:45;;;368:1;365;358:12;327:45;417:6;412:3;405:4;398:5;394:16;381:43;471:1;464:4;455:6;448:5;444:18;440:29;433:40;14:465;;;;;:::o;484:196::-;552:20;;612:42;601:54;;591:65;;581:93;;670:1;667;660:12;581:93;484:196;;;:::o;685:160::-;750:20;;806:13;;799:21;789:32;;779:60;;835:1;832;825:12;850:186;909:6;962:2;950:9;941:7;937:23;933:32;930:52;;;978:1;975;968:12;930:52;1001:29;1020:9;1001:29;:::i;1041:260::-;1109:6;1117;1170:2;1158:9;1149:7;1145:23;1141:32;1138:52;;;1186:1;1183;1176:12;1138:52;1209:29;1228:9;1209:29;:::i;:::-;1199:39;;1257:38;1291:2;1280:9;1276:18;1257:38;:::i;:::-;1247:48;;1041:260;;;;;:::o;1306:328::-;1383:6;1391;1399;1452:2;1440:9;1431:7;1427:23;1423:32;1420:52;;;1468:1;1465;1458:12;1420:52;1491:29;1510:9;1491:29;:::i;:::-;1481:39;;1539:38;1573:2;1562:9;1558:18;1539:38;:::i;:::-;1529:48;;1624:2;1613:9;1609:18;1596:32;1586:42;;1306:328;;;;;:::o;1639:666::-;1734:6;1742;1750;1758;1811:3;1799:9;1790:7;1786:23;1782:33;1779:53;;;1828:1;1825;1818:12;1779:53;1851:29;1870:9;1851:29;:::i;:::-;1841:39;;1899:38;1933:2;1922:9;1918:18;1899:38;:::i;:::-;1889:48;;1984:2;1973:9;1969:18;1956:32;1946:42;;2039:2;2028:9;2024:18;2011:32;2066:18;2058:6;2055:30;2052:50;;;2098:1;2095;2088:12;2052:50;2121:22;;2174:4;2166:13;;2162:27;-1:-1:-1;2152:55:1;;2203:1;2200;2193:12;2152:55;2226:73;2291:7;2286:2;2273:16;2268:2;2264;2260:11;2226:73;:::i;:::-;2216:83;;;1639:666;;;;;;;:::o;2310:1031::-;2403:6;2411;2464:2;2452:9;2443:7;2439:23;2435:32;2432:52;;;2480:1;2477;2470:12;2432:52;2503:29;2522:9;2503:29;:::i;:::-;2493:39;;2551:2;2604;2593:9;2589:18;2576:32;2627:18;2668:2;2660:6;2657:14;2654:34;;;2684:1;2681;2674:12;2654:34;2722:6;2711:9;2707:22;2697:32;;2767:7;2760:4;2756:2;2752:13;2748:27;2738:55;;2789:1;2786;2779:12;2738:55;2825:2;2812:16;2847:2;2843;2840:10;2837:36;;;2853:18;;:::i;:::-;2899:2;2896:1;2892:10;2882:20;;2922:28;2946:2;2942;2938:11;2922:28;:::i;:::-;2984:15;;;3015:12;;;;3047:11;;;3077;;;3073:20;;3070:33;-1:-1:-1;3067:53:1;;;3116:1;3113;3106:12;3067:53;3138:1;3129:10;;3148:163;3162:2;3159:1;3156:9;3148:163;;;3219:17;;3207:30;;3180:1;3173:9;;;;;3257:12;;;;3289;;3148:163;;;3152:3;3330:5;3320:15;;;;;;;;2310:1031;;;;;:::o;3346:254::-;3411:6;3419;3472:2;3460:9;3451:7;3447:23;3443:32;3440:52;;;3488:1;3485;3478:12;3440:52;3511:29;3530:9;3511:29;:::i;:::-;3501:39;;3559:35;3590:2;3579:9;3575:18;3559:35;:::i;3605:254::-;3673:6;3681;3734:2;3722:9;3713:7;3709:23;3705:32;3702:52;;;3750:1;3747;3740:12;3702:52;3773:29;3792:9;3773:29;:::i;:::-;3763:39;3849:2;3834:18;;;;3821:32;;-1:-1:-1;;;3605:254:1:o;3864:180::-;3920:6;3973:2;3961:9;3952:7;3948:23;3944:32;3941:52;;;3989:1;3986;3979:12;3941:52;4012:26;4028:9;4012:26;:::i;4049:245::-;4107:6;4160:2;4148:9;4139:7;4135:23;4131:32;4128:52;;;4176:1;4173;4166:12;4128:52;4215:9;4202:23;4234:30;4258:5;4234:30;:::i;4299:249::-;4368:6;4421:2;4409:9;4400:7;4396:23;4392:32;4389:52;;;4437:1;4434;4427:12;4389:52;4469:9;4463:16;4488:30;4512:5;4488:30;:::i;4553:450::-;4622:6;4675:2;4663:9;4654:7;4650:23;4646:32;4643:52;;;4691:1;4688;4681:12;4643:52;4731:9;4718:23;4764:18;4756:6;4753:30;4750:50;;;4796:1;4793;4786:12;4750:50;4819:22;;4872:4;4864:13;;4860:27;-1:-1:-1;4850:55:1;;4901:1;4898;4891:12;4850:55;4924:73;4989:7;4984:2;4971:16;4966:2;4962;4958:11;4924:73;:::i;5008:180::-;5067:6;5120:2;5108:9;5099:7;5095:23;5091:32;5088:52;;;5136:1;5133;5126:12;5088:52;-1:-1:-1;5159:23:1;;5008:180;-1:-1:-1;5008:180:1:o;5193:254::-;5261:6;5269;5322:2;5310:9;5301:7;5297:23;5293:32;5290:52;;;5338:1;5335;5328:12;5290:52;5374:9;5361:23;5351:33;;5403:38;5437:2;5426:9;5422:18;5403:38;:::i;5452:248::-;5520:6;5528;5581:2;5569:9;5560:7;5556:23;5552:32;5549:52;;;5597:1;5594;5587:12;5549:52;-1:-1:-1;;5620:23:1;;;5690:2;5675:18;;;5662:32;;-1:-1:-1;5452:248:1:o;5705:316::-;5746:3;5784:5;5778:12;5811:6;5806:3;5799:19;5827:63;5883:6;5876:4;5871:3;5867:14;5860:4;5853:5;5849:16;5827:63;:::i;:::-;5935:2;5923:15;5940:66;5919:88;5910:98;;;;6010:4;5906:109;;5705:316;-1:-1:-1;;5705:316:1:o;6547:1642::-;6771:3;6809:6;6803:13;6835:4;6848:51;6892:6;6887:3;6882:2;6874:6;6870:15;6848:51;:::i;:::-;6962:13;;6921:16;;;;6984:55;6962:13;6921:16;7006:15;;;6984:55;:::i;:::-;7128:13;;7061:20;;;7101:1;;7188;7210:18;;;;7263;;;;7290:93;;7368:4;7358:8;7354:19;7342:31;;7290:93;7431:2;7421:8;7418:16;7398:18;7395:40;7392:224;;;7470:77;7465:3;7458:90;7571:4;7568:1;7561:15;7601:4;7596:3;7589:17;7392:224;7632:18;7659:168;;;;7841:1;7836:328;;;;7625:539;;7659:168;7709:66;7698:9;7694:82;7687:5;7680:97;7808:8;7801:5;7797:20;7790:27;;7659:168;;7836:328;21498:1;21491:14;;;21535:4;21522:18;;7931:1;7945:169;7959:8;7956:1;7953:15;7945:169;;;8041:14;;8026:13;;;8019:37;8084:16;;;;7976:10;;7945:169;;;7949:3;;8145:8;8138:5;8134:20;8127:27;;7625:539;-1:-1:-1;8180:3:1;;6547:1642;-1:-1:-1;;;;;;;;;;;6547:1642:1:o;8635:511::-;8829:4;8858:42;8939:2;8931:6;8927:15;8916:9;8909:34;8991:2;8983:6;8979:15;8974:2;8963:9;8959:18;8952:43;;9031:6;9026:2;9015:9;9011:18;9004:34;9074:3;9069:2;9058:9;9054:18;9047:31;9095:45;9135:3;9124:9;9120:19;9112:6;9095:45;:::i;:::-;9087:53;8635:511;-1:-1:-1;;;;;;8635:511:1:o;9525:219::-;9674:2;9663:9;9656:21;9637:4;9694:44;9734:2;9723:9;9719:18;9711:6;9694:44;:::i;21086:334::-;21157:2;21151:9;21213:2;21203:13;;21218:66;21199:86;21187:99;;21316:18;21301:34;;21337:22;;;21298:62;21295:88;;;21363:18;;:::i;:::-;21399:2;21392:22;21086:334;;-1:-1:-1;21086:334:1:o;21551:128::-;21591:3;21622:1;21618:6;21615:1;21612:13;21609:39;;;21628:18;;:::i;:::-;-1:-1:-1;21664:9:1;;21551:128::o;21684:120::-;21724:1;21750;21740:35;;21755:18;;:::i;:::-;-1:-1:-1;21789:9:1;;21684:120::o;21809:228::-;21849:7;21975:1;21907:66;21903:74;21900:1;21897:81;21892:1;21885:9;21878:17;21874:105;21871:131;;;21982:18;;:::i;:::-;-1:-1:-1;22022:9:1;;21809:228::o;22042:125::-;22082:4;22110:1;22107;22104:8;22101:34;;;22115:18;;:::i;:::-;-1:-1:-1;22152:9:1;;22042:125::o;22172:258::-;22244:1;22254:113;22268:6;22265:1;22262:13;22254:113;;;22344:11;;;22338:18;22325:11;;;22318:39;22290:2;22283:10;22254:113;;;22385:6;22382:1;22379:13;22376:48;;;-1:-1:-1;;22420:1:1;22402:16;;22395:27;22172:258::o;22435:437::-;22514:1;22510:12;;;;22557;;;22578:61;;22632:4;22624:6;22620:17;22610:27;;22578:61;22685:2;22677:6;22674:14;22654:18;22651:38;22648:218;;;22722:77;22719:1;22712:88;22823:4;22820:1;22813:15;22851:4;22848:1;22841:15;22648:218;;22435:437;;;:::o;22877:195::-;22916:3;22947:66;22940:5;22937:77;22934:103;;;23017:18;;:::i;:::-;-1:-1:-1;23064:1:1;23053:13;;22877:195::o;23077:112::-;23109:1;23135;23125:35;;23140:18;;:::i;:::-;-1:-1:-1;23174:9:1;;23077:112::o;23194:184::-;23246:77;23243:1;23236:88;23343:4;23340:1;23333:15;23367:4;23364:1;23357:15;23383:184;23435:77;23432:1;23425:88;23532:4;23529:1;23522:15;23556:4;23553:1;23546:15;23572:184;23624:77;23621:1;23614:88;23721:4;23718:1;23711:15;23745:4;23742:1;23735:15;23761:184;23813:77;23810:1;23803:88;23910:4;23907:1;23900:15;23934:4;23931:1;23924:15;23950:177;24035:66;24028:5;24024:78;24017:5;24014:89;24004:117;;24117:1;24114;24107:12

Swarm Source

ipfs://e286ca529e135aaa77b7ac2ac8b3cef588d1f7ec747c7dc3b190d0e6b8e78765

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