Token

Robonomics Pioneer Set (Robo)

ERC-1155

Overview

Max Total Supply

992 Robo

Holders

481

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xdc9fe731ce957c14a7b055a34270b2400b0905ec

Filtered by Token Holder

0x4367Cc270D68925d9bA89CAe2A9c2877f3acD69C

jcomper.eth

0x4367cc270d68925d9ba89cae2a9c2877f3acd69c

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ERC1155Tradable

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 20 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @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 () {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), 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 {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}


pragma solidity ^0.8.0;


pragma solidity ^0.8.0;


pragma solidity ^0.8.0;

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


/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values);

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data) external;
}


pragma solidity ^0.8.0;



/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {

    /**
        @dev Handles the receipt of a single ERC1155 token type. This function is
        called at the end of a `safeTransferFrom` after the balance has been updated.
        To accept the transfer, this must return
        `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
        (i.e. 0xf23a6e61, or its own function selector).
        @param operator The address which initiated the transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param id The ID of the token being transferred
        @param value The amount of tokens being transferred
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
    */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    )
        external
        returns(bytes4);

    /**
        @dev Handles the receipt of a multiple ERC1155 token types. This function
        is called at the end of a `safeBatchTransferFrom` after the balances have
        been updated. To accept the transfer(s), this must return
        `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
        (i.e. 0xbc197c81, or its own function selector).
        @param operator The address which initiated the batch transfer (i.e. msg.sender)
        @param from The address which previously owned the token
        @param ids An array containing ids of each token being transferred (order and length must match values array)
        @param values An array containing amounts of each token being transferred (order and length must match ids array)
        @param data Additional data with no specified format
        @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
    */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    )
        external
        returns(bytes4);
}


pragma solidity ^0.8.0;



/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}


pragma solidity ^0.8.0;

/**
 * @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;
        // solhint-disable-next-line no-inline-assembly
        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");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


pragma solidity ^0.8.0;



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


/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    // Mapping from token ID to account balances
    mapping (uint256 => mapping(address => uint256)) private _balances;

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

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor (string memory uri_) {
        _setURI(uri_);
    }

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

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: balance query for the zero address");
        return _balances[id][account];
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] memory accounts,
        uint256[] memory ids
    )
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(_msgSender() != operator, "ERC1155: setting approval status for self");

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    )
        public
        virtual
        override
    {
        require(to != address(0), "ERC1155: transfer to the zero address");
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
        _balances[id][from] = fromBalance - amount;
        _balances[id][to] += amount;

        emit TransferSingle(operator, from, to, id, amount);

        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    )
        public
        virtual
        override
    {
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
        require(to != address(0), "ERC1155: transfer to the zero address");
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: transfer caller is not owner nor approved"
        );

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
            _balances[id][from] = fromBalance - amount;
            _balances[id][to] += amount;
        }

        emit TransferBatch(operator, from, to, ids, amounts);

        _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `account`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - If `account` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(address account, uint256 id, uint256 amount, bytes memory data) internal virtual {
        require(account != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), account, _asSingletonArray(id), _asSingletonArray(amount), data);

        _balances[id][account] += amount;
        emit TransferSingle(operator, address(0), account, id, amount);

        _doSafeTransferAcceptanceCheck(operator, address(0), account, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        for (uint i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `account`
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens of token type `id`.
     */
    function _burn(address account, uint256 id, uint256 amount) internal virtual {
        require(account != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, account, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");

        uint256 accountBalance = _balances[id][account];
        require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
        _balances[id][account] = accountBalance - amount;

        emit TransferSingle(operator, account, address(0), id, amount);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(address account, uint256[] memory ids, uint256[] memory amounts) internal virtual {
        require(account != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, account, address(0), ids, amounts, "");

        for (uint i = 0; i < ids.length; i++) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            uint256 accountBalance = _balances[id][account];
            require(accountBalance >= amount, "ERC1155: burn amount exceeds balance");
            _balances[id][account] = accountBalance - amount;
        }

        emit TransferBatch(operator, account, address(0), ids, amounts);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    )
        internal
        virtual
    { }

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    )
        private
    {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver(to).onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    )
        private
    {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) {
                if (response != IERC1155Receiver(to).onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }
}


pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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


pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant alphabet = "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] = alphabet[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

}



pragma solidity ^0.8.0;

abstract contract ContextMixin {
    function msgSender()
        internal
        view
        returns (address payable sender)
    {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
                // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
                sender := and(
                    mload(add(array, index)),
                    0xffffffffffffffffffffffffffffffffffffffff
                )
            }
        } else {
            sender = payable(msg.sender);
        }
        return sender;
    }
}


pragma solidity ^0.8.0;



pragma solidity ^0.8.0;


pragma solidity ^0.8.0;

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        _;
        inited = true;
    }
}


contract EIP712Base is Initializable {
    struct EIP712Domain {
        string name;
        string version;
        address verifyingContract;
        bytes32 salt;
    }

    string constant public ERC712_VERSION = "1";

    bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(
        bytes(
            "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
        )
    );
    bytes32 internal domainSeperator;

    // supposed to be called once while initializing.
    // one of the contracts that inherits this contract follows proxy pattern
    // so it is not possible to do this in a constructor
    function _initializeEIP712(
        string memory name
    )
        internal
        initializer
    {
        _setDomainSeperator(name);
    }

    function _setDomainSeperator(string memory name) internal {
        domainSeperator = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                keccak256(bytes(ERC712_VERSION)),
                address(this),
                bytes32(getChainId())
            )
        );
    }

    function getDomainSeperator() public view returns (bytes32) {
        return domainSeperator;
    }

    function getChainId() public view returns (uint256) {
        uint256 id;
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * Accept message hash and returns hash message in EIP712 compatible form
     * So that it can be used to recover signer from signature signed using EIP712 formatted data
     * https://eips.ethereum.org/EIPS/eip-712
     * "\\x19" makes the encoding deterministic
     * "\\x01" is the version byte to make it compatible to EIP-191
     */
    function toTypedMessageHash(bytes32 messageHash)
        internal
        view
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
            );
    }
}

contract NativeMetaTransaction is EIP712Base {
    using SafeMath for uint256;
    bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(
        bytes(
            "MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
        )
    );
    event MetaTransactionExecuted(
        address userAddress,
        address payable relayerAddress,
        bytes functionSignature
    );
    mapping(address => uint256) nonces;

    /*
     * Meta transaction structure.
     * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
     * He should call the desired function directly in that case.
     */
    struct MetaTransaction {
        uint256 nonce;
        address from;
        bytes functionSignature;
    }

    function executeMetaTransaction(
        address userAddress,
        bytes memory functionSignature,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) public payable returns (bytes memory) {
        MetaTransaction memory metaTx = MetaTransaction({
            nonce: nonces[userAddress],
            from: userAddress,
            functionSignature: functionSignature
        });

        require(
            verify(userAddress, metaTx, sigR, sigS, sigV),
            "Signer and signature do not match"
        );

        // increase nonce for user (to avoid re-use)
        nonces[userAddress] = nonces[userAddress].add(1);

        emit MetaTransactionExecuted(
            userAddress,
            payable(msg.sender),
            functionSignature
        );

        // Append userAddress and relayer address at the end to extract it from calling context
        (bool success, bytes memory returnData) = address(this).call(
            abi.encodePacked(functionSignature, userAddress)
        );
        require(success, "Function call not successful");

        return returnData;
    }

    function hashMetaTransaction(MetaTransaction memory metaTx)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encode(
                    META_TRANSACTION_TYPEHASH,
                    metaTx.nonce,
                    metaTx.from,
                    keccak256(metaTx.functionSignature)
                )
            );
    }

    function getNonce(address user) public view returns (uint256 nonce) {
        nonce = nonces[user];
    }

    function verify(
        address signer,
        MetaTransaction memory metaTx,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) internal view returns (bool) {
        require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
        return
            signer ==
            ecrecover(
                toTypedMessageHash(hashMetaTransaction(metaTx)),
                sigV,
                sigR,
                sigS
            );
    }
}


contract OwnableDelegateProxy { }

contract ProxyRegistry {
  mapping(address => OwnableDelegateProxy) public proxies;
}

/**
 * @title ERC1155Tradable
 * ERC1155Tradable - ERC1155 contract that whitelists an operator address, has create and mint functionality, and supports useful standards from OpenZeppelin,
  like _exists(), name(), symbol(), and totalSupply()
 */
contract ERC1155Tradable is ContextMixin, ERC1155, NativeMetaTransaction, Ownable {
  using Strings for string;
  using SafeMath for uint256;

  address proxyRegistryAddress;
  mapping (uint256 => address) public creators;
  mapping (uint256 => uint256) public tokenSupply;
  mapping (uint256 => string) customUri;
  // Contract name
  string public name;
  // Contract symbol
  string public symbol;

  /**
   * @dev Require _msgSender() to be the creator of the token id
   */
  modifier creatorOnly(uint256 _id) {
    require(creators[_id] == _msgSender(), "ERC1155Tradable#creatorOnly: ONLY_CREATOR_ALLOWED");
    _;
  }

  /**
   * @dev Require _msgSender() to own more than 0 of the token id
   */
  modifier ownersOnly(uint256 _id) {
    require(balanceOf(_msgSender(), _id) > 0, "ERC1155Tradable#ownersOnly: ONLY_OWNERS_ALLOWED");
    _;
  }

  constructor(
    string memory _name,
    string memory _symbol,
    string memory _uri,
    address _proxyRegistryAddress
  ) ERC1155(_uri) {
    name = _name;
    symbol = _symbol;
    proxyRegistryAddress = _proxyRegistryAddress;
    _initializeEIP712(name);
  }

  function uri(
    uint256 _id
  ) override public view returns (string memory) {
    require(_exists(_id), "ERC1155Tradable#uri: NONEXISTENT_TOKEN");
    // We have to convert string to bytes to check for existence
    bytes memory customUriBytes = bytes(customUri[_id]);
    if (customUriBytes.length > 0) {
        return customUri[_id];
    } else {
        return super.uri(_id);
    }
  }

  /**
    * @dev Returns the total quantity for a token ID
    * @param _id uint256 ID of the token to query
    * @return amount of token in existence
    */
  function totalSupply(
    uint256 _id
  ) public view returns (uint256) {
    return tokenSupply[_id];
  }

  /**
   * @dev Sets a new URI for all token types, by relying on the token type ID
    * substitution mechanism
    * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
   * @param _newURI New URI for all tokens
   */
  function setURI(
    string memory _newURI
  ) public onlyOwner {
    _setURI(_newURI);
  }

  /**
   * @dev Will update the base URI for the token
   * @param _tokenId The token to update. _msgSender() must be its creator.
   * @param _newURI New URI for the token.
   */
  function setCustomURI(
    uint256 _tokenId,
    string memory _newURI
  ) public creatorOnly(_tokenId) {
    customUri[_tokenId] = _newURI;
    emit URI(_newURI, _tokenId);
  }

  /**
    * @dev Creates a new token type and assigns _initialSupply to an address
    * NOTE: remove onlyOwner if you want third parties to create new tokens on
    *       your contract (which may change your IDs)
    * NOTE: The token id must be passed. This allows lazy creation of tokens or
    *       creating NFTs by setting the id's high bits with the method
    *       described in ERC1155 or to use ids representing values other than
    *       successive small integers. If you wish to create ids as successive
    *       small integers you can either subclass this class to count onchain
    *       or maintain the offchain cache of identifiers recommended in
    *       ERC1155 and calculate successive ids from that.
    * @param _initialOwner address of the first owner of the token
    * @param _id The id of the token to create (must not currenty exist).
    * @param _initialSupply amount to supply the first owner
    * @param _uri Optional URI for this token type
    * @param _data Data to pass if receiver is contract
    * @return The newly created token ID
    */
  function create(
    address _initialOwner,
    uint256 _id,
    uint256 _initialSupply,
    string memory _uri,
    bytes memory _data
  ) public onlyOwner returns (uint256) {
    require(!_exists(_id), "token _id already exists");
    creators[_id] = _msgSender();

    if (bytes(_uri).length > 0) {
      customUri[_id] = _uri;
      emit URI(_uri, _id);
    }

    _mint(_initialOwner, _id, _initialSupply, _data);

    tokenSupply[_id] = _initialSupply;
    return _id;
  }

  /**
    * @dev Mints some amount of tokens to an address
    * @param _to          Address of the future owner of the token
    * @param _id          Token ID to mint
    * @param _quantity    Amount of tokens to mint
    * @param _data        Data to pass if receiver is contract
    */
  function mint(
    address _to,
    uint256 _id,
    uint256 _quantity,
    bytes memory _data
  ) virtual public creatorOnly(_id) {
    _mint(_to, _id, _quantity, _data);
    tokenSupply[_id] = tokenSupply[_id].add(_quantity);
  }

  /**
    * @dev Mint tokens for each id in _ids
    * @param _to          The address to mint tokens to
    * @param _ids         Array of ids to mint
    * @param _quantities  Array of amounts of tokens to mint per id
    * @param _data        Data to pass if receiver is contract
    */
  function batchMint(
    address _to,
    uint256[] memory _ids,
    uint256[] memory _quantities,
    bytes memory _data
  ) public {
    for (uint256 i = 0; i < _ids.length; i++) {
      uint256 _id = _ids[i];
      require(creators[_id] == _msgSender(), "ERC1155Tradable#batchMint: ONLY_CREATOR_ALLOWED");
      uint256 quantity = _quantities[i];
      tokenSupply[_id] = tokenSupply[_id].add(quantity);
    }
    _mintBatch(_to, _ids, _quantities, _data);
  }

  /**
    * @dev Change the creator address for given tokens
    * @param _to   Address of the new creator
    * @param _ids  Array of Token IDs to change creator
    */
  function setCreator(
    address _to,
    uint256[] memory _ids
  ) public {
    require(_to != address(0), "ERC1155Tradable#setCreator: INVALID_ADDRESS.");
    for (uint256 i = 0; i < _ids.length; i++) {
      uint256 id = _ids[i];
      _setCreator(_to, id);
    }
  }

  /**
   * Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-free listings.
   */
  function isApprovedForAll(
    address _owner,
    address _operator
  ) override public view returns (bool isOperator) {
    // Whitelist OpenSea proxy contract for easy trading.
    ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
    if (address(proxyRegistry.proxies(_owner)) == _operator) {
      return true;
    }

    return ERC1155.isApprovedForAll(_owner, _operator);
  }

  /**
    * @dev Change the creator address for given token
    * @param _to   Address of the new creator
    * @param _id  Token IDs to change creator of
    */
  function _setCreator(address _to, uint256 _id) internal creatorOnly(_id)
  {
      creators[_id] = _to;
  }

  /**
    * @dev Returns whether the specified token exists by checking to see if it has a creator
    * @param _id uint256 ID of the token to query the existence of
    * @return bool whether the token exists
    */
  function _exists(
    uint256 _id
  ) internal view returns (bool) {
    return creators[_id] != address(0);
  }

  function exists(
    uint256 _id
  ) external view returns (bool) {
    return _exists(_id);
  }

    /**
     * This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
     */
    function _msgSender()
        internal
        override
        view
        returns (address sender)
    {
        return ContextMixin.msgSender();
    }
}

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":"_uri","type":"string"},{"internalType":"address","name":"_proxyRegistryAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","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":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"},{"internalType":"uint256[]","name":"_quantities","type":"uint256[]"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"batchMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_initialOwner","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_initialSupply","type":"uint256"},{"internalType":"string","name":"_uri","type":"string"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"create","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"creators","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"isOperator","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_quantity","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","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":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"}],"name":"setCreator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"string","name":"_newURI","type":"string"}],"name":"setCustomURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newURI","type":"string"}],"name":"setURI","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":"","type":"uint256"}],"name":"tokenSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","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)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c10000000000000000000000000000000000000000000000000000000000000016526f626f6e6f6d6963732050696f6e65657220536574000000000000000000000000000000000000000000000000000000000000000000000000000000000004526f626f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Robonomics Pioneer Set
Arg [1] : _symbol (string): Robo
Arg [2] : _uri (string): 
Arg [3] : _proxyRegistryAddress (address): 0xa5409ec958C83C3f309868babACA7c86DCB077c1

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [3] : 000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c1
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000016
Arg [5] : 526f626f6e6f6d6963732050696f6e6565722053657400000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [7] : 526f626f00000000000000000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

48811:7536:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21530:231;;;;;;;;;;-1:-1:-1;21530:231:0;;;;;:::i;:::-;;:::i;:::-;;;16006:25:1;;;15994:2;15979:18;21530:231:0;;;;;;;;20566:297;;;;;;;;;;-1:-1:-1;20566:297:0;;;;;:::i;:::-;;:::i;:::-;;;15833:14:1;;15826:22;15808:41;;15796:2;15781:18;20566:297:0;15668:187:1;50908:95:0;;;;;;;;;;-1:-1:-1;50908:95:0;;;;;:::i;:::-;;:::i;:::-;;49156:18;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;46244:1151::-;;;;;;:::i;:::-;;:::i;49974:404::-;;;;;;;;;;-1:-1:-1;49974:404:0;;;;;:::i;:::-;;:::i;43509:43::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;43509:43:0;;;;;44518:101;;;;;;;;;;-1:-1:-1;44596:15:0;;44518:101;;49042:47;;;;;;;;;;-1:-1:-1;49042:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;47821:107;;;;;;;;;;-1:-1:-1;47821:107:0;;;;;:::i;:::-;-1:-1:-1;;;;;47908:12:0;47874:13;47908:12;;;:6;:12;;;;;;;47821:107;24233:1239;;;;;;;;;;-1:-1:-1;24233:1239:0;;;;;:::i;:::-;;:::i;44627:161::-;;;;;;;;;;-1:-1:-1;44741:9:0;44627:161;;52495:497;;;;;;;;;;-1:-1:-1;52495:497:0;;;;;:::i;:::-;;:::i;51194:183::-;;;;;;;;;;-1:-1:-1;51194:183:0;;;;;:::i;:::-;;:::i;21927:549::-;;;;;;;;;;-1:-1:-1;21927:549:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;55939:100::-;;;;;;;;;;-1:-1:-1;55939:100:0;;;;;:::i;:::-;;:::i;2608:148::-;;;;;;;;;;;;;:::i;53295:239::-;;;;;;;;;;-1:-1:-1;53295:239:0;;;;;:::i;:::-;;:::i;1957:87::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;49201:20::-;;;;;;;;;;;;;:::i;22549:311::-;;;;;;;;;;-1:-1:-1;22549:311:0;;;;;:::i;:::-;;:::i;53837:475::-;;;;;;;;;;-1:-1:-1;53837:475:0;;;;;:::i;:::-;;:::i;50548:110::-;;;;;;;;;;-1:-1:-1;50548:110:0;;;;;:::i;:::-;50613:7;50636:16;;;:11;:16;;;;;;;50548:110;48993:44;;;;;;;;;;-1:-1:-1;48993:44:0;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;48993:44:0;;;54493:279;;;;;;;;;;-1:-1:-1;54493:279:0;;;;;:::i;:::-;;:::i;54896:410::-;;;;;;;;;;-1:-1:-1;54896:410:0;;;;;:::i;:::-;;:::i;23172:984::-;;;;;;;;;;-1:-1:-1;23172:984:0;;;;;:::i;:::-;;:::i;2911:244::-;;;;;;;;;;-1:-1:-1;2911:244:0;;;;;:::i;:::-;;:::i;21530:231::-;21616:7;-1:-1:-1;;;;;21644:21:0;;21636:77;;;;-1:-1:-1;;;21636:77:0;;19114:2:1;21636:77:0;;;19096:21:1;19153:2;19133:18;;;19126:30;19192:34;19172:18;;;19165:62;-1:-1:-1;;;19243:18:1;;;19236:41;19294:19;;21636:77:0;;;;;;;;;-1:-1:-1;21731:9:0;:13;;;;;;;;;;;-1:-1:-1;;;;;21731:22:0;;;;;;;;;;21530:231;;;;;:::o;20566:297::-;20668:4;-1:-1:-1;;;;;;20692:41:0;;-1:-1:-1;;;20692:41:0;;:110;;-1:-1:-1;;;;;;;20750:52:0;;-1:-1:-1;;;20750:52:0;20692:110;:163;;;-1:-1:-1;;;;;;;;;;19596:40:0;;;20819:36;19487:157;50908:95;2188:12;:10;:12::i;:::-;-1:-1:-1;;;;;2177:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2177:23:0;;2169:68;;;;-1:-1:-1;;;2169:68:0;;;;;;;:::i;:::-;50981:16:::1;50989:7;50981;:16::i;:::-;50908:95:::0;:::o;49156:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;46244:1151::-;46502:152;;;46445:12;46502:152;;;;;-1:-1:-1;;;;;46540:19:0;;46470:29;46540:19;;;:6;:19;;;;;;;;;46502:152;;;;;;;;;;;46689:45;46547:11;46502:152;46717:4;46723;46729;46689:6;:45::i;:::-;46667:128;;;;-1:-1:-1;;;46667:128:0;;23110:2:1;46667:128:0;;;23092:21:1;23149:2;23129:18;;;23122:30;23188:34;23168:18;;;23161:62;-1:-1:-1;;;23239:18:1;;;23232:31;23280:19;;46667:128:0;22908:397:1;46667:128:0;-1:-1:-1;;;;;46884:19:0;;;;;;:6;:19;;;;;;:26;;46908:1;46884:23;:26::i;:::-;-1:-1:-1;;;;;46862:19:0;;;;;;:6;:19;;;;;;;:48;;;;46928:126;;;;;46869:11;;47000:10;;47026:17;;46928:126;:::i;:::-;;;;;;;;47165:12;47179:23;47214:4;-1:-1:-1;;;;;47206:18:0;47256:17;47275:11;47239:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;47239:48:0;;;;;;;;;;47206:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47164:134;;;;47317:7;47309:48;;;;-1:-1:-1;;;47309:48:0;;19933:2:1;47309:48:0;;;19915:21:1;19972:2;19952:18;;;19945:30;-1:-1:-1;;;19991:18:1;;;19984:58;20059:18;;47309:48:0;19731:352:1;47309:48:0;47377:10;46244:1151;-1:-1:-1;;;;;;;;46244:1151:0:o;49974:404::-;50040:13;50070:12;50078:3;50070:7;:12::i;:::-;50062:63;;;;-1:-1:-1;;;50062:63:0;;21931:2:1;50062:63:0;;;21913:21:1;21970:2;21950:18;;;21943:30;22009:34;21989:18;;;21982:62;-1:-1:-1;;;22060:18:1;;;22053:36;22106:19;;50062:63:0;21729:402:1;50062:63:0;50198:27;50234:14;;;:9;:14;;;;;50198:51;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50284:1;50260:14;:21;:25;50256:117;;;50305:14;;;;:9;:14;;;;;50298:21;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49974:404;;;:::o;50256:117::-;50351:14;50361:3;50351:9;:14::i;:::-;50344:21;49974:404;-1:-1:-1;;;49974:404:0:o;50256:117::-;50055:323;49974:404;;;:::o;24233:1239::-;24498:7;:14;24484:3;:10;:28;24476:81;;;;-1:-1:-1;;;24476:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;24576:16:0;;24568:66;;;;-1:-1:-1;;;24568:66:0;;;;;;;:::i;:::-;24675:12;:10;:12::i;:::-;-1:-1:-1;;;;;24667:20:0;:4;-1:-1:-1;;;;;24667:20:0;;:60;;;;24691:36;24708:4;24714:12;:10;:12::i;24691:36::-;24645:160;;;;-1:-1:-1;;;24645:160:0;;21512:2:1;24645:160:0;;;21494:21:1;21551:2;21531:18;;;21524:30;21590:34;21570:18;;;21563:62;-1:-1:-1;;;21641:18:1;;;21634:48;21699:19;;24645:160:0;21310:414:1;24645:160:0;24818:16;24837:12;:10;:12::i;:::-;24818:31;;24940:9;24935:377;24959:3;:10;24955:1;:14;24935:377;;;24991:10;25004:3;25008:1;25004:6;;;;;;;;:::i;:::-;;;;;;;24991:19;;25025:14;25042:7;25050:1;25042:10;;;;;;;;:::i;:::-;;;;;;;;;;;;25069:19;25091:13;;;;;;;;;;-1:-1:-1;;;;;25091:19:0;;;;;;;;;;;;25042:10;;-1:-1:-1;25133:21:0;;;;25125:76;;;;-1:-1:-1;;;25125:76:0;;;;;;;:::i;:::-;25238:20;25252:6;25238:11;:20;:::i;:::-;25216:9;:13;25226:2;25216:13;;;;;;;;;;;:19;25230:4;-1:-1:-1;;;;;25216:19:0;-1:-1:-1;;;;;25216:19:0;;;;;;;;;;;;:42;;;;25294:6;25273:9;:13;25283:2;25273:13;;;;;;;;;;;:17;25287:2;-1:-1:-1;;;;;25273:17:0;-1:-1:-1;;;;;25273:17:0;;;;;;;;;;;;;:27;;;;;;;:::i;:::-;;;;;;;;24976:336;;;24971:3;;;;:::i;:::-;;;24935:377;;;;25359:2;-1:-1:-1;;;;;25329:47:0;25353:4;-1:-1:-1;;;;;25329:47:0;25343:8;-1:-1:-1;;;;;25329:47:0;;25363:3;25368:7;25329:47;;;;;;;:::i;:::-;;;;;;;;25389:75;25425:8;25435:4;25441:2;25445:3;25450:7;25459:4;25389:35;:75::i;:::-;24465:1007;24233:1239;;;;;:::o;52495:497::-;52667:7;2188:12;:10;:12::i;:::-;-1:-1:-1;;;;;2177:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2177:23:0;;2169:68;;;;-1:-1:-1;;;2169:68:0;;;;;;;:::i;:::-;52692:12:::1;52700:3;52692:7;:12::i;:::-;52691:13;52683:50;;;::::0;-1:-1:-1;;;52683:50:0;;17936:2:1;52683:50:0::1;::::0;::::1;17918:21:1::0;17975:2;17955:18;;;17948:30;-1:-1:-1;;;17994:18:1;;;17987:54;18058:18;;52683:50:0::1;17734:348:1::0;52683:50:0::1;52756:12;:10;:12::i;:::-;52740:13;::::0;;;:8:::1;:13;::::0;;;;:28;;-1:-1:-1;;;;;;52740:28:0::1;-1:-1:-1::0;;;;;52740:28:0;;;::::1;::::0;;;::::1;::::0;;52781:18;;:22;52777:94:::1;;52814:14;::::0;;;:9:::1;:14;::::0;;;;;;;:21;;::::1;::::0;;::::1;::::0;::::1;:::i;:::-;;52859:3;52849:14;52853:4;52849:14;;;;;;:::i;:::-;;;;;;;;52777:94;52879:48;52885:13;52900:3;52905:14;52921:5;52879;:48::i;:::-;-1:-1:-1::0;;;52936:16:0::1;::::0;;;:11:::1;:16;::::0;;;;:33;:16;52495:497;-1:-1:-1;52495:497:0:o;51194:183::-;51291:8;49374:12;:10;:12::i;:::-;49357:13;;;;:8;:13;;;;;;-1:-1:-1;;;;;49357:13:0;;;:29;;;49349:91;;;;-1:-1:-1;;;49349:91:0;;;;;;;:::i;:::-;51308:19:::1;::::0;;;:9:::1;:19;::::0;;;;;;;:29;;::::1;::::0;;::::1;::::0;::::1;:::i;:::-;;51362:8;51349:22;51353:7;51349:22;;;;;;:::i;:::-;;;;;;;;51194:183:::0;;;:::o;21927:549::-;22108:16;22169:3;:10;22150:8;:15;:29;22142:83;;;;-1:-1:-1;;;22142:83:0;;24335:2:1;22142:83:0;;;24317:21:1;24374:2;24354:18;;;24347:30;24413:34;24393:18;;;24386:62;-1:-1:-1;;;24464:18:1;;;24457:39;24513:19;;22142:83:0;24133:405:1;22142:83:0;22238:30;22285:8;:15;-1:-1:-1;;;;;22271:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22271:30:0;;22238:63;;22319:9;22314:122;22338:8;:15;22334:1;:19;22314:122;;;22394:30;22404:8;22413:1;22404:11;;;;;;;;:::i;:::-;;;;;;;22417:3;22421:1;22417:6;;;;;;;;:::i;:::-;;;;;;;22394:9;:30::i;:::-;22375:13;22389:1;22375:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;22355:3;;;:::i;:::-;;;22314:122;;;-1:-1:-1;22455:13:0;21927:549;-1:-1:-1;;;21927:549:0:o;55939:100::-;56001:4;56021:12;56029:3;56021:7;:12::i;2608:148::-;2188:12;:10;:12::i;:::-;-1:-1:-1;;;;;2177:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2177:23:0;;2169:68;;;;-1:-1:-1;;;2169:68:0;;;;;;;:::i;:::-;2699:6:::1;::::0;2678:40:::1;::::0;2715:1:::1;::::0;-1:-1:-1;;;;;2699:6:0::1;::::0;2678:40:::1;::::0;2715:1;;2678:40:::1;2729:6;:19:::0;;-1:-1:-1;;;;;;2729:19:0::1;::::0;;2608:148::o;53295:239::-;53426:3;49374:12;:10;:12::i;:::-;49357:13;;;;:8;:13;;;;;;-1:-1:-1;;;;;49357:13:0;;;:29;;;49349:91;;;;-1:-1:-1;;;49349:91:0;;;;;;;:::i;:::-;53438:33:::1;53444:3;53449;53454:9;53465:5;53438;:33::i;:::-;53497:16;::::0;;;:11:::1;:16;::::0;;;;;:31:::1;::::0;53518:9;53497:20:::1;:31::i;:::-;53478:16;::::0;;;:11:::1;:16;::::0;;;;;:50;;;;-1:-1:-1;;;;53295:239:0:o;1957:87::-;2030:6;;-1:-1:-1;;;;;2030:6:0;;1957:87::o;49201:20::-;;;;;;;:::i;22549:311::-;22668:8;-1:-1:-1;;;;;22652:24:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;22652:24:0;;;22644:78;;;;-1:-1:-1;;;22644:78:0;;23925:2:1;22644:78:0;;;23907:21:1;23964:2;23944:18;;;23937:30;24003:34;23983:18;;;23976:62;-1:-1:-1;;;24054:18:1;;;24047:39;24103:19;;22644:78:0;23723:405:1;22644:78:0;22780:8;22735:18;:32;22754:12;:10;:12::i;:::-;-1:-1:-1;;;;;22735:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;22735:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;22735:53:0;;;;;;;;;;;22819:12;:10;:12::i;:::-;-1:-1:-1;;;;;22804:48:0;;22843:8;22804:48;;;;15833:14:1;15826:22;15808:41;;15796:2;15781:18;;15668:187;22804:48:0;;;;;;;;22549:311;;:::o;53837:475::-;53986:9;53981:278;54005:4;:11;54001:1;:15;53981:278;;;54032:11;54046:4;54051:1;54046:7;;;;;;;;:::i;:::-;;;;;;;54032:21;;54087:12;:10;:12::i;:::-;54070:13;;;;:8;:13;;;;;;-1:-1:-1;;;;;54070:13:0;;;:29;;;54062:89;;;;-1:-1:-1;;;54062:89:0;;18698:2:1;54062:89:0;;;18680:21:1;18737:2;18717:18;;;18710:30;18776:34;18756:18;;;18749:62;-1:-1:-1;;;18827:18:1;;;18820:45;18882:19;;54062:89:0;18496:411:1;54062:89:0;54160:16;54179:11;54191:1;54179:14;;;;;;;;:::i;:::-;;;;;;;54160:33;;54221:30;54242:8;54221:11;:16;54233:3;54221:16;;;;;;;;;;;;:20;;:30;;;;:::i;:::-;54202:16;;;;:11;:16;;;;;;:49;;;;-1:-1:-1;54018:3:0;;;;:::i;:::-;;;;53981:278;;;;54265:41;54276:3;54281:4;54287:11;54300:5;54265:10;:41::i;:::-;53837:475;;;;:::o;54493:279::-;-1:-1:-1;;;;;54586:17:0;;54578:74;;;;-1:-1:-1;;;54578:74:0;;23512:2:1;54578:74:0;;;23494:21:1;23551:2;23531:18;;;23524:30;23590:34;23570:18;;;23563:62;-1:-1:-1;;;23641:18:1;;;23634:42;23693:19;;54578:74:0;23310:408:1;54578:74:0;54664:9;54659:108;54683:4;:11;54679:1;:15;54659:108;;;54710:10;54723:4;54728:1;54723:7;;;;;;;;:::i;:::-;;;;;;;54710:20;;54739;54751:3;54756:2;54739:11;:20::i;:::-;-1:-1:-1;54696:3:0;;;;:::i;:::-;;;;54659:108;;;;54493:279;;:::o;54896:410::-;55129:20;;55169:29;;-1:-1:-1;;;55169:29:0;;55002:15;;-1:-1:-1;;;;;55129:20:0;;;;55161:51;;;;55129:20;;55169:21;;:29;;55191:6;;55169:29;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;55161:51:0;;55157:85;;;55230:4;55223:11;;;;;55157:85;-1:-1:-1;;;;;23055:27:0;;;23031:4;23055:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;55257:43;55250:50;54896:410;-1:-1:-1;;;;54896:410:0:o;23172:984::-;-1:-1:-1;;;;;23398:16:0;;23390:66;;;;-1:-1:-1;;;23390:66:0;;;;;;;:::i;:::-;23497:12;:10;:12::i;:::-;-1:-1:-1;;;;;23489:20:0;:4;-1:-1:-1;;;;;23489:20:0;;:60;;;;23513:36;23530:4;23536:12;:10;:12::i;23513:36::-;23467:151;;;;-1:-1:-1;;;23467:151:0;;20290:2:1;23467:151:0;;;20272:21:1;20329:2;20309:18;;;20302:30;20368:34;20348:18;;;20341:62;-1:-1:-1;;;20419:18:1;;;20412:39;20468:19;;23467:151:0;20088:405:1;23467:151:0;23631:16;23650:12;:10;:12::i;:::-;23631:31;;23675:96;23696:8;23706:4;23712:2;23716:21;23734:2;23716:17;:21::i;:::-;23739:25;23757:6;23739:17;:25::i;:::-;24233:1239;;;;;;23675:96;23784:19;23806:13;;;;;;;;;;;-1:-1:-1;;;;;23806:19:0;;;;;;;;;;23844:21;;;;23836:76;;;;-1:-1:-1;;;23836:76:0;;;;;;;:::i;:::-;23945:20;23959:6;23945:11;:20;:::i;:::-;23923:9;:13;;;;;;;;;;;-1:-1:-1;;;;;23923:19:0;;;;;;;;;;:42;;;;23976:17;;;;;;;:27;;23997:6;;23923:9;23976:27;;23997:6;;23976:27;:::i;:::-;;;;-1:-1:-1;;24021:46:0;;;26128:25:1;;;26184:2;26169:18;;26162:34;;;-1:-1:-1;;;;;24021:46:0;;;;;;;;;;;;;;26101:18:1;24021:46:0;;;;;;;24080:68;24111:8;24121:4;24127:2;24131;24135:6;24143:4;24080:30;:68::i;:::-;23379:777;;23172:984;;;;;:::o;2911:244::-;2188:12;:10;:12::i;:::-;-1:-1:-1;;;;;2177:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2177:23:0;;2169:68;;;;-1:-1:-1;;;2169:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3000:22:0;::::1;2992:73;;;::::0;-1:-1:-1;;;2992:73:0;;19526:2:1;2992:73:0::1;::::0;::::1;19508:21:1::0;19565:2;19545:18;;;19538:30;19604:34;19584:18;;;19577:62;-1:-1:-1;;;19655:18:1;;;19648:36;19701:19;;2992:73:0::1;19324:402:1::0;2992:73:0::1;3102:6;::::0;3081:38:::1;::::0;-1:-1:-1;;;;;3081:38:0;;::::1;::::0;3102:6:::1;::::0;3081:38:::1;::::0;3102:6:::1;::::0;3081:38:::1;3130:6;:17:::0;;-1:-1:-1;;;;;;3130:17:0::1;-1:-1:-1::0;;;;;3130:17:0;;;::::1;::::0;;;::::1;::::0;;2911:244::o;42398:650::-;42469:22;42513:10;42535:4;42513:27;42509:508;;;42557:18;42578:8;;42557:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;42617:8:0;42828:17;42822:24;-1:-1:-1;;;;;42796:134:0;;-1:-1:-1;42509:508:0;;-1:-1:-1;42509:508:0;;-1:-1:-1;42994:10:0;42509:508;42398:650;:::o;56183:161::-;56273:14;56312:24;:22;:24::i;:::-;56305:31;;56183:161;:::o;26316:88::-;26383:13;;;;:4;;:13;;;;;:::i;:::-;;26316:88;:::o;47936:486::-;48114:4;-1:-1:-1;;;;;48139:20:0;;48131:70;;;;-1:-1:-1;;;48131:70:0;;20700:2:1;48131:70:0;;;20682:21:1;20739:2;20719:18;;;20712:30;20778:34;20758:18;;;20751:62;-1:-1:-1;;;20829:18:1;;;20822:35;20874:19;;48131:70:0;20498:401:1;48131:70:0;48255:159;48283:47;48302:27;48322:6;48302:19;:27::i;:::-;48283:18;:47::i;:::-;48255:159;;;;;;;;;;;;16691:25:1;;;;16764:4;16752:17;;16732:18;;;16725:45;16786:18;;;16779:34;;;16829:18;;;16822:34;;;16663:19;;48255:159:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48232:182:0;:6;-1:-1:-1;;;;;48232:182:0;;48212:202;;47936:486;;;;;;;:::o;36031:98::-;36089:7;36116:5;36120:1;36116;:5;:::i;55817:116::-;55880:4;55900:13;;;:8;:13;;;;;;-1:-1:-1;;;;;55900:13:0;:27;;;55817:116::o;21274:105::-;21334:13;21367:4;21360:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21274:105;;;:::o;32289:799::-;-1:-1:-1;;;;;32543:13:0;;11864:20;11903:8;32539:542;;32579:79;;-1:-1:-1;;;32579:79:0;;-1:-1:-1;;;;;32579:43:0;;;;;:79;;32623:8;;32633:4;;32639:3;;32644:7;;32653:4;;32579:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32579:79:0;;;;;;;;-1:-1:-1;;32579:79:0;;;;;;;;;;;;:::i;:::-;;;32575:495;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;32943:6;32936:14;;-1:-1:-1;;;32936:14:0;;;;;;;;:::i;32575:495::-;;;32992:62;;-1:-1:-1;;;32992:62:0;;17515:2:1;32992:62:0;;;17497:21:1;17554:2;17534:18;;;17527:30;17593:34;17573:18;;;17566:62;-1:-1:-1;;;17644:18:1;;;17637:50;17704:19;;32992:62:0;17313:416:1;32575:495:0;-1:-1:-1;;;;;;32708:64:0;;-1:-1:-1;;;32708:64:0;32704:163;;32797:50;;-1:-1:-1;;;32797:50:0;;;;;;;:::i;26805:556::-;-1:-1:-1;;;;;26920:21:0;;26912:67;;;;-1:-1:-1;;;26912:67:0;;;;;;;:::i;:::-;26992:16;27011:12;:10;:12::i;:::-;26992:31;;27036:107;27057:8;27075:1;27079:7;27088:21;27106:2;27088:17;:21::i;27036:107::-;27156:9;:13;;;;;;;;;;;-1:-1:-1;;;;;27156:22:0;;;;;;;;;:32;;27182:6;;27156:9;:32;;27182:6;;27156:32;:::i;:::-;;;;-1:-1:-1;;27204:57:0;;;26128:25:1;;;26184:2;26169:18;;26162:34;;;-1:-1:-1;;;;;27204:57:0;;;;27237:1;;27204:57;;;;;;26101:18:1;27204:57:0;;;;;;;27274:79;27305:8;27323:1;27327:7;27336:2;27340:6;27348:4;27274:30;:79::i;27717:689::-;-1:-1:-1;;;;;27852:16:0;;27844:62;;;;-1:-1:-1;;;27844:62:0;;;;;;;:::i;:::-;27939:7;:14;27925:3;:10;:28;27917:81;;;;-1:-1:-1;;;27917:81:0;;;;;;;:::i;:::-;28011:16;28030:12;:10;:12::i;:::-;28011:31;;28139:6;28134:100;28155:3;:10;28151:1;:14;28134:100;;;28212:7;28220:1;28212:10;;;;;;;;:::i;:::-;;;;;;;28187:9;:17;28197:3;28201:1;28197:6;;;;;;;;:::i;:::-;;;;;;;28187:17;;;;;;;;;;;:21;28205:2;-1:-1:-1;;;;;28187:21:0;-1:-1:-1;;;;;28187:21:0;;;;;;;;;;;;;:35;;;;;;;:::i;:::-;;;;-1:-1:-1;28167:3:0;;-1:-1:-1;28167:3:0;;;:::i;:::-;;;;28134:100;;;;28287:2;-1:-1:-1;;;;;28251:53:0;28283:1;-1:-1:-1;;;;;28251:53:0;28265:8;-1:-1:-1;;;;;28251:53:0;;28291:3;28296:7;28251:53;;;;;;;:::i;:::-;;;;;;;;28317:81;28353:8;28371:1;28375:2;28379:3;28384:7;28393:4;28317:35;:81::i;55479:110::-;55547:3;49374:12;:10;:12::i;:::-;49357:13;;;;:8;:13;;;;;;-1:-1:-1;;;;;49357:13:0;;;:29;;;49349:91;;;;-1:-1:-1;;;49349:91:0;;;;;;;:::i;:::-;-1:-1:-1;55564:13:0::1;::::0;;;:8:::1;:13;::::0;;;;:19;;-1:-1:-1;;;;;;55564:19:0::1;-1:-1:-1::0;;;;;55564:19:0;;;::::1;::::0;;;::::1;::::0;;55479:110::o;33096:198::-;33216:16;;;33230:1;33216:16;;;;;;;;;33162;;33191:22;;33216:16;;;;;;;;;;;;-1:-1:-1;33216:16:0;33191:41;;33254:7;33243:5;33249:1;33243:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;33281:5;33096:198;-1:-1:-1;;33096:198:0:o;31519:762::-;-1:-1:-1;;;;;31748:13:0;;11864:20;11903:8;31744:530;;31784:72;;-1:-1:-1;;;31784:72:0;;-1:-1:-1;;;;;31784:38:0;;;;;:72;;31823:8;;31833:4;;31839:2;;31843:6;;31851:4;;31784:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31784:72:0;;;;;;;;-1:-1:-1;;31784:72:0;;;;;;;;;;;;:::i;:::-;;;31780:483;;;;:::i;:::-;-1:-1:-1;;;;;;31906:59:0;;-1:-1:-1;;;31906:59:0;31902:158;;31990:50;;-1:-1:-1;;;31990:50:0;;;;;;;:::i;47403:410::-;47513:7;45580:100;;;;;;;;;;;;;;;;;45560:127;;;;;;;47667:12;;47702:11;;;;47746:24;;;;;47736:35;;;;;;47586:204;;;;;16273:25:1;;;16329:2;16314:18;;16307:34;;;;-1:-1:-1;;;;;16377:32:1;16372:2;16357:18;;16350:60;16441:2;16426:18;;16419:34;16260:3;16245:19;;16042:417;47586:204:0;;;;;;;;;;;;;47558:247;;;;;;47538:267;;47403:410;;;:::o;45157:258::-;45256:7;45358:20;44596:15;;;44518:101;45358:20;45329:63;;-1:-1:-1;;;45329:63:0;;;12753:27:1;12796:11;;;12789:27;;;;12832:12;;;12825:28;;;12869:12;;45329:63:0;12495:392:1;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:735:1;68:5;121:3;114:4;106:6;102:17;98:27;88:55;;139:1;136;129:12;88:55;175:6;162:20;201:4;224:43;264:2;224:43;:::i;:::-;296:2;290:9;308:31;336:2;328:6;308:31;:::i;:::-;374:18;;;408:15;;;;-1:-1:-1;443:15:1;;;493:1;489:10;;;477:23;;473:32;;470:41;-1:-1:-1;467:61:1;;;524:1;521;514:12;467:61;546:1;556:163;570:2;567:1;564:9;556:163;;;627:17;;615:30;;665:12;;;;697;;;;588:1;581:9;556:163;;;-1:-1:-1;737:6:1;;14:735;-1:-1:-1;;;;;;;14:735:1:o;754:555::-;796:5;849:3;842:4;834:6;830:17;826:27;816:55;;867:1;864;857:12;816:55;903:6;890:20;-1:-1:-1;;;;;925:2:1;922:26;919:52;;;951:18;;:::i;:::-;1000:2;994:9;1012:67;1067:2;1048:13;;-1:-1:-1;;1044:27:1;1073:4;1040:38;994:9;1012:67;:::i;:::-;1103:2;1095:6;1088:18;1149:3;1142:4;1137:2;1129:6;1125:15;1121:26;1118:35;1115:55;;;1166:1;1163;1156:12;1115:55;1230:2;1223:4;1215:6;1211:17;1204:4;1196:6;1192:17;1179:54;1277:1;1253:15;;;1270:4;1249:26;1242:37;;;;1257:6;754:555;-1:-1:-1;;;754:555:1:o;1314:247::-;1373:6;1426:2;1414:9;1405:7;1401:23;1397:32;1394:52;;;1442:1;1439;1432:12;1394:52;1481:9;1468:23;1500:31;1525:5;1500:31;:::i;1566:388::-;1634:6;1642;1695:2;1683:9;1674:7;1670:23;1666:32;1663:52;;;1711:1;1708;1701:12;1663:52;1750:9;1737:23;1769:31;1794:5;1769:31;:::i;:::-;1819:5;-1:-1:-1;1876:2:1;1861:18;;1848:32;1889:33;1848:32;1889:33;:::i;:::-;1941:7;1931:17;;;1566:388;;;;;:::o;1959:1071::-;2113:6;2121;2129;2137;2145;2198:3;2186:9;2177:7;2173:23;2169:33;2166:53;;;2215:1;2212;2205:12;2166:53;2254:9;2241:23;2273:31;2298:5;2273:31;:::i;:::-;2323:5;-1:-1:-1;2380:2:1;2365:18;;2352:32;2393:33;2352:32;2393:33;:::i;:::-;2445:7;-1:-1:-1;2503:2:1;2488:18;;2475:32;-1:-1:-1;;;;;2556:14:1;;;2553:34;;;2583:1;2580;2573:12;2553:34;2606:61;2659:7;2650:6;2639:9;2635:22;2606:61;:::i;:::-;2596:71;;2720:2;2709:9;2705:18;2692:32;2676:48;;2749:2;2739:8;2736:16;2733:36;;;2765:1;2762;2755:12;2733:36;2788:63;2843:7;2832:8;2821:9;2817:24;2788:63;:::i;:::-;2778:73;;2904:3;2893:9;2889:19;2876:33;2860:49;;2934:2;2924:8;2921:16;2918:36;;;2950:1;2947;2940:12;2918:36;;2973:51;3016:7;3005:8;2994:9;2990:24;2973:51;:::i;:::-;2963:61;;;1959:1071;;;;;;;;:::o;3035:734::-;3139:6;3147;3155;3163;3171;3224:3;3212:9;3203:7;3199:23;3195:33;3192:53;;;3241:1;3238;3231:12;3192:53;3280:9;3267:23;3299:31;3324:5;3299:31;:::i;:::-;3349:5;-1:-1:-1;3406:2:1;3391:18;;3378:32;3419:33;3378:32;3419:33;:::i;:::-;3471:7;-1:-1:-1;3525:2:1;3510:18;;3497:32;;-1:-1:-1;3576:2:1;3561:18;;3548:32;;-1:-1:-1;3631:3:1;3616:19;;3603:33;-1:-1:-1;;;;;3648:30:1;;3645:50;;;3691:1;3688;3681:12;3645:50;3714:49;3755:7;3746:6;3735:9;3731:22;3714:49;:::i;3774:483::-;3867:6;3875;3928:2;3916:9;3907:7;3903:23;3899:32;3896:52;;;3944:1;3941;3934:12;3896:52;3983:9;3970:23;4002:31;4027:5;4002:31;:::i;:::-;4052:5;-1:-1:-1;4108:2:1;4093:18;;4080:32;-1:-1:-1;;;;;4124:30:1;;4121:50;;;4167:1;4164;4157:12;4121:50;4190:61;4243:7;4234:6;4223:9;4219:22;4190:61;:::i;:::-;4180:71;;;3774:483;;;;;:::o;4262:929::-;4407:6;4415;4423;4431;4484:3;4472:9;4463:7;4459:23;4455:33;4452:53;;;4501:1;4498;4491:12;4452:53;4540:9;4527:23;4559:31;4584:5;4559:31;:::i;:::-;4609:5;-1:-1:-1;4665:2:1;4650:18;;4637:32;-1:-1:-1;;;;;4718:14:1;;;4715:34;;;4745:1;4742;4735:12;4715:34;4768:61;4821:7;4812:6;4801:9;4797:22;4768:61;:::i;:::-;4758:71;;4882:2;4871:9;4867:18;4854:32;4838:48;;4911:2;4901:8;4898:16;4895:36;;;4927:1;4924;4917:12;4895:36;4950:63;5005:7;4994:8;4983:9;4979:24;4950:63;:::i;:::-;4940:73;;5066:2;5055:9;5051:18;5038:32;5022:48;;5095:2;5085:8;5082:16;5079:36;;;5111:1;5108;5101:12;5079:36;;5134:51;5177:7;5166:8;5155:9;5151:24;5134:51;:::i;:::-;5124:61;;;4262:929;;;;;;;:::o;5196:416::-;5261:6;5269;5322:2;5310:9;5301:7;5297:23;5293:32;5290:52;;;5338:1;5335;5328:12;5290:52;5377:9;5364:23;5396:31;5421:5;5396:31;:::i;:::-;5446:5;-1:-1:-1;5503:2:1;5488:18;;5475:32;5545:15;;5538:23;5526:36;;5516:64;;5576:1;5573;5566:12;5617:758;5719:6;5727;5735;5743;5751;5804:3;5792:9;5783:7;5779:23;5775:33;5772:53;;;5821:1;5818;5811:12;5772:53;5860:9;5847:23;5879:31;5904:5;5879:31;:::i;:::-;5929:5;-1:-1:-1;5985:2:1;5970:18;;5957:32;-1:-1:-1;;;;;6001:30:1;;5998:50;;;6044:1;6041;6034:12;5998:50;6067:49;6108:7;6099:6;6088:9;6084:22;6067:49;:::i;:::-;6057:59;;;6163:2;6152:9;6148:18;6135:32;6125:42;;6214:2;6203:9;6199:18;6186:32;6176:42;;6270:3;6259:9;6255:19;6242:33;6319:4;6310:7;6306:18;6297:7;6294:31;6284:59;;6339:1;6336;6329:12;6284:59;6362:7;6352:17;;;5617:758;;;;;;;;:::o;6380:315::-;6448:6;6456;6509:2;6497:9;6488:7;6484:23;6480:32;6477:52;;;6525:1;6522;6515:12;6477:52;6564:9;6551:23;6583:31;6608:5;6583:31;:::i;:::-;6633:5;6685:2;6670:18;;;;6657:32;;-1:-1:-1;;;6380:315:1:o;6700:592::-;6795:6;6803;6811;6819;6872:3;6860:9;6851:7;6847:23;6843:33;6840:53;;;6889:1;6886;6879:12;6840:53;6928:9;6915:23;6947:31;6972:5;6947:31;:::i;:::-;6997:5;-1:-1:-1;7049:2:1;7034:18;;7021:32;;-1:-1:-1;7100:2:1;7085:18;;7072:32;;-1:-1:-1;7155:2:1;7140:18;;7127:32;-1:-1:-1;;;;;7171:30:1;;7168:50;;;7214:1;7211;7204:12;7168:50;7237:49;7278:7;7269:6;7258:9;7254:22;7237:49;:::i;7297:813::-;7411:6;7419;7427;7435;7443;7496:3;7484:9;7475:7;7471:23;7467:33;7464:53;;;7513:1;7510;7503:12;7464:53;7552:9;7539:23;7571:31;7596:5;7571:31;:::i;:::-;7621:5;-1:-1:-1;7673:2:1;7658:18;;7645:32;;-1:-1:-1;7724:2:1;7709:18;;7696:32;;-1:-1:-1;7779:2:1;7764:18;;7751:32;-1:-1:-1;;;;;7832:14:1;;;7829:34;;;7859:1;7856;7849:12;7829:34;7882:49;7923:7;7914:6;7903:9;7899:22;7882:49;:::i;8115:1288::-;8233:6;8241;8294:2;8282:9;8273:7;8269:23;8265:32;8262:52;;;8310:1;8307;8300:12;8262:52;8350:9;8337:23;-1:-1:-1;;;;;8420:2:1;8412:6;8409:14;8406:34;;;8436:1;8433;8426:12;8406:34;8474:6;8463:9;8459:22;8449:32;;8519:7;8512:4;8508:2;8504:13;8500:27;8490:55;;8541:1;8538;8531:12;8490:55;8577:2;8564:16;8599:4;8622:43;8662:2;8622:43;:::i;:::-;8694:2;8688:9;8706:31;8734:2;8726:6;8706:31;:::i;:::-;8772:18;;;8806:15;;;;-1:-1:-1;8841:11:1;;;8883:1;8879:10;;;8871:19;;8867:28;;8864:41;-1:-1:-1;8861:61:1;;;8918:1;8915;8908:12;8861:61;8940:1;8931:10;;8950:238;8964:2;8961:1;8958:9;8950:238;;;9035:3;9022:17;9052:31;9077:5;9052:31;:::i;:::-;9096:18;;8982:1;8975:9;;;;;9134:12;;;;9166;;8950:238;;;-1:-1:-1;9207:6:1;-1:-1:-1;;9251:18:1;;9238:32;;-1:-1:-1;;9282:16:1;;;9279:36;;;9311:1;9308;9301:12;9279:36;;9334:63;9389:7;9378:8;9367:9;9363:24;9334:63;:::i;9408:245::-;9466:6;9519:2;9507:9;9498:7;9494:23;9490:32;9487:52;;;9535:1;9532;9525:12;9487:52;9574:9;9561:23;9593:30;9617:5;9593:30;:::i;9658:249::-;9727:6;9780:2;9768:9;9759:7;9755:23;9751:32;9748:52;;;9796:1;9793;9786:12;9748:52;9828:9;9822:16;9847:30;9871:5;9847:30;:::i;9912:280::-;10011:6;10064:2;10052:9;10043:7;10039:23;10035:32;10032:52;;;10080:1;10077;10070:12;10032:52;10112:9;10106:16;10131:31;10156:5;10131:31;:::i;10197:321::-;10266:6;10319:2;10307:9;10298:7;10294:23;10290:32;10287:52;;;10335:1;10332;10325:12;10287:52;10375:9;10362:23;-1:-1:-1;;;;;10400:6:1;10397:30;10394:50;;;10440:1;10437;10430:12;10394:50;10463:49;10504:7;10495:6;10484:9;10480:22;10463:49;:::i;10523:180::-;10582:6;10635:2;10623:9;10614:7;10610:23;10606:32;10603:52;;;10651:1;10648;10641:12;10603:52;-1:-1:-1;10674:23:1;;10523:180;-1:-1:-1;10523:180:1:o;10708:389::-;10786:6;10794;10847:2;10835:9;10826:7;10822:23;10818:32;10815:52;;;10863:1;10860;10853:12;10815:52;10899:9;10886:23;10876:33;;10960:2;10949:9;10945:18;10932:32;-1:-1:-1;;;;;10979:6:1;10976:30;10973:50;;;11019:1;11016;11009:12;10973:50;11042:49;11083:7;11074:6;11063:9;11059:22;11042:49;:::i;11102:435::-;11155:3;11193:5;11187:12;11220:6;11215:3;11208:19;11246:4;11275:2;11270:3;11266:12;11259:19;;11312:2;11305:5;11301:14;11333:1;11343:169;11357:6;11354:1;11351:13;11343:169;;;11418:13;;11406:26;;11452:12;;;;11487:15;;;;11379:1;11372:9;11343:169;;;-1:-1:-1;11528:3:1;;11102:435;-1:-1:-1;;;;;11102:435:1:o;11542:257::-;11583:3;11621:5;11615:12;11648:6;11643:3;11636:19;11664:63;11720:6;11713:4;11708:3;11704:14;11697:4;11690:5;11686:16;11664:63;:::i;:::-;11781:2;11760:15;-1:-1:-1;;11756:29:1;11747:39;;;;11788:4;11743:50;;11542:257;-1:-1:-1;;11542:257:1:o;11804:274::-;11933:3;11971:6;11965:13;11987:53;12033:6;12028:3;12021:4;12013:6;12009:17;11987:53;:::i;:::-;12056:16;;;;;11804:274;-1:-1:-1;;11804:274:1:o;12083:407::-;12240:3;12278:6;12272:13;12294:53;12340:6;12335:3;12328:4;12320:6;12316:17;12294:53;:::i;:::-;12441:2;12412:15;;;;-1:-1:-1;;;;;;12408:45:1;12369:16;;;;12394:60;;;12481:2;12470:14;;12083:407;-1:-1:-1;;12083:407:1:o;12892:203::-;-1:-1:-1;;;;;13056:32:1;;;;13038:51;;13026:2;13011:18;;12892:203::o;13100:431::-;-1:-1:-1;;;;;13357:15:1;;;13339:34;;13409:15;;13404:2;13389:18;;13382:43;13461:2;13456;13441:18;;13434:30;;;13282:4;;13481:44;;13506:18;;13498:6;13481:44;:::i;:::-;13473:52;13100:431;-1:-1:-1;;;;;13100:431:1:o;13536:826::-;-1:-1:-1;;;;;13933:15:1;;;13915:34;;13985:15;;13980:2;13965:18;;13958:43;13895:3;14032:2;14017:18;;14010:31;;;13858:4;;14064:57;;14101:19;;14093:6;14064:57;:::i;:::-;14169:9;14161:6;14157:22;14152:2;14141:9;14137:18;14130:50;14203:44;14240:6;14232;14203:44;:::i;:::-;14189:58;;14296:9;14288:6;14284:22;14278:3;14267:9;14263:19;14256:51;14324:32;14349:6;14341;14324:32;:::i;14367:560::-;-1:-1:-1;;;;;14664:15:1;;;14646:34;;14716:15;;14711:2;14696:18;;14689:43;14763:2;14748:18;;14741:34;;;14806:2;14791:18;;14784:34;;;14626:3;14849;14834:19;;14827:32;;;14589:4;;14876:45;;14901:19;;14893:6;14876:45;:::i;:::-;14868:53;14367:560;-1:-1:-1;;;;;;;14367:560:1:o;14932:261::-;15111:2;15100:9;15093:21;15074:4;15131:56;15183:2;15172:9;15168:18;15160:6;15131:56;:::i;15198:465::-;15455:2;15444:9;15437:21;15418:4;15481:56;15533:2;15522:9;15518:18;15510:6;15481:56;:::i;:::-;15585:9;15577:6;15573:22;15568:2;15557:9;15553:18;15546:50;15613:44;15650:6;15642;15613:44;:::i;16867:217::-;17014:2;17003:9;16996:21;16977:4;17034:44;17074:2;17063:9;17059:18;17051:6;17034:44;:::i;18087:404::-;18289:2;18271:21;;;18328:2;18308:18;;;18301:30;18367:34;18362:2;18347:18;;18340:62;-1:-1:-1;;;18433:2:1;18418:18;;18411:38;18481:3;18466:19;;18087:404::o;20904:401::-;21106:2;21088:21;;;21145:2;21125:18;;;21118:30;21184:34;21179:2;21164:18;;21157:62;-1:-1:-1;;;21250:2:1;21235:18;;21228:35;21295:3;21280:19;;20904:401::o;22136:406::-;22338:2;22320:21;;;22377:2;22357:18;;;22350:30;22416:34;22411:2;22396:18;;22389:62;-1:-1:-1;;;22482:2:1;22467:18;;22460:40;22532:3;22517:19;;22136:406::o;22547:356::-;22749:2;22731:21;;;22768:18;;;22761:30;22827:34;22822:2;22807:18;;22800:62;22894:2;22879:18;;22547:356::o;24543:404::-;24745:2;24727:21;;;24784:2;24764:18;;;24757:30;24823:34;24818:2;24803:18;;24796:62;-1:-1:-1;;;24889:2:1;24874:18;;24867:38;24937:3;24922:19;;24543:404::o;24952:397::-;25154:2;25136:21;;;25193:2;25173:18;;;25166:30;25232:34;25227:2;25212:18;;25205:62;-1:-1:-1;;;25298:2:1;25283:18;;25276:31;25339:3;25324:19;;24952:397::o;25354:413::-;25556:2;25538:21;;;25595:2;25575:18;;;25568:30;25634:34;25629:2;25614:18;;25607:62;-1:-1:-1;;;25700:2:1;25685:18;;25678:47;25757:3;25742:19;;25354:413::o;26207:183::-;26267:4;-1:-1:-1;;;;;26292:6:1;26289:30;26286:56;;;26322:18;;:::i;:::-;-1:-1:-1;26367:1:1;26363:14;26379:4;26359:25;;26207:183::o;26395:128::-;26435:3;26466:1;26462:6;26459:1;26456:13;26453:39;;;26472:18;;:::i;:::-;-1:-1:-1;26508:9:1;;26395:128::o;26528:125::-;26568:4;26596:1;26593;26590:8;26587:34;;;26601:18;;:::i;:::-;-1:-1:-1;26638:9:1;;26528:125::o;26658:258::-;26730:1;26740:113;26754:6;26751:1;26748:13;26740:113;;;26830:11;;;26824:18;26811:11;;;26804:39;26776:2;26769:10;26740:113;;;26871:6;26868:1;26865:13;26862:48;;;-1:-1:-1;;26906:1:1;26888:16;;26881:27;26658:258::o;26921:380::-;27000:1;26996:12;;;;27043;;;27064:61;;27118:4;27110:6;27106:17;27096:27;;27064:61;27171:2;27163:6;27160:14;27140:18;27137:38;27134:161;;;27217:10;27212:3;27208:20;27205:1;27198:31;27252:4;27249:1;27242:15;27280:4;27277:1;27270:15;27306:249;27416:2;27397:13;;-1:-1:-1;;27393:27:1;27381:40;;-1:-1:-1;;;;;27436:34:1;;27472:22;;;27433:62;27430:88;;;27498:18;;:::i;:::-;27534:2;27527:22;-1:-1:-1;;27306:249:1:o;27560:135::-;27599:3;-1:-1:-1;;27620:17:1;;27617:43;;;27640:18;;:::i;:::-;-1:-1:-1;27687:1:1;27676:13;;27560:135::o;27700:127::-;27761:10;27756:3;27752:20;27749:1;27742:31;27792:4;27789:1;27782:15;27816:4;27813:1;27806:15;27832:127;27893:10;27888:3;27884:20;27881:1;27874:31;27924:4;27921:1;27914:15;27948:4;27945:1;27938:15;27964:127;28025:10;28020:3;28016:20;28013:1;28006:31;28056:4;28053:1;28046:15;28080:4;28077:1;28070:15;28096:179;28131:3;28173:1;28155:16;28152:23;28149:120;;;28219:1;28216;28213;28198:23;-1:-1:-1;28256:1:1;28250:8;28245:3;28241:18;28096:179;:::o;28280:671::-;28319:3;28361:4;28343:16;28340:26;28337:39;;;28280:671;:::o;28337:39::-;28403:2;28397:9;-1:-1:-1;;28468:16:1;28464:25;;28461:1;28397:9;28440:50;28519:4;28513:11;28543:16;-1:-1:-1;;;;;28649:2:1;28642:4;28634:6;28630:17;28627:25;28622:2;28614:6;28611:14;28608:45;28605:58;;;28656:5;;;;;28280:671;:::o;28605:58::-;28693:6;28687:4;28683:17;28672:28;;28729:3;28723:10;28756:2;28748:6;28745:14;28742:27;;;28762:5;;;;;;28280:671;:::o;28742:27::-;28846:2;28827:16;28821:4;28817:27;28813:36;28806:4;28797:6;28792:3;28788:16;28784:27;28781:69;28778:82;;;28853:5;;;;;;28280:671;:::o;28778:82::-;28869:57;28920:4;28911:6;28903;28899:19;28895:30;28889:4;28869:57;:::i;:::-;-1:-1:-1;28942:3:1;;28280:671;-1:-1:-1;;;;;28280:671:1:o;28956:131::-;-1:-1:-1;;;;;29031:31:1;;29021:42;;29011:70;;29077:1;29074;29067:12;29092:131;-1:-1:-1;;;;;;29166:32:1;;29156:43;;29146:71;;29213:1;29210;29203:12

Swarm Source

ipfs://f7edf43b50fe03e930992faaab27e6e8271506a205abdd787ef299ecadae3027

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