Token

Iscariot Market v1 (BLZM)

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

ERC-20

Overview

Max Total Supply

0 BLZM

Holders

Total Transfers

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 0 Decimals)

0x72a89f4d8d92f11c81ec55a3acef4e92447ef336

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

IscariotMarket

Compiler Version

v0.8.16+commit.07a7930e

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

pragma solidity ^0.8.4;



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

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


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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
/**
 * @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);
}


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)
/**
 * @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 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;
}


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
/**
 * @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.
     *
     * NOTE: 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.
     *
     * NOTE: 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);
}


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)
/**
 * @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);
}


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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


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


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/ERC1155.sol)
/**
 * @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: address zero is not a valid owner");
        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 {
        _setApprovalForAll(_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(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );
        _safeTransferFrom(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(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner or approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `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 memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

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

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

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

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

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - 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[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
        require(to != address(0), "ERC1155: transfer to the zero address");

        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");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
            _balances[id][to] += amount;
        }

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

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

        _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 `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

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

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

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

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * 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 _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 (uint256 i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

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

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

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

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

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }

        emit TransferSingle(operator, from, address(0), id, amount);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

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

        address operator = _msgSender();

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

        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: burn amount exceeds balance");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
        }

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

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC1155: setting approval status for self");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @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 `ids` and `amounts` 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 {}

    /**
     * @dev Hook that is called after 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 _afterTokenTransfer(
        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.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.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;
    }
}


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/utils/ERC1155Receiver.sol)
/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }
}


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/utils/ERC1155Holder.sol)
/**
 * Simple implementation of `ERC1155Receiver` that will allow a contract to hold ERC1155 tokens.
 *
 * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be
 * stuck.
 *
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}


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

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

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

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

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

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

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

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


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

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

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


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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

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

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

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

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


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

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}


// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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


contract IscariotMarket is ERC1155Holder, Ownable {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    event TokenPurchased (
        address wallet,
        uint256 tokenId,
        uint256 amount
    );
    event FundsWithdrawn (
        address wallet
    );
    event TokenWithdrawn (
        address wallet,
        uint256 tokenId,
        uint256 amount
    );
    event PriceUpdated (
        uint256 ethPrice,
        uint256 erc20Price,
        uint256 erc1155Item0Price
    );

    address constant public ierc20ContractAddress = 0x62450755160E9347DcF947da31AcC841E9668443;
    address constant public ierc1155ContractAddress = 0x761f6216895c9AC9b37B773337dFE6bBAd0e3730;

    IERC1155 constant private _ierc1155 = IERC1155(ierc1155ContractAddress);
    IERC20 constant private _ierc20 = IERC20(ierc20ContractAddress);

    string public name = "Iscariot Market v1";
    string public symbol = "BLZM";
    uint256 public _ethPrice = 50000000 gwei;
    uint256 public _erc20Price = 1000000 ether;
    uint256 public _erc1155Item0Price = 20;

    receive() external payable { }

    function _transferToken(uint256 tokenId, uint256 amount) 
        private 
    {
        require(tokenId >= 0, ""); // Token must have 0 or positive identifier.
        require(amount > 0, ""); // Amount requested must be greater than zero.
        require(_ierc1155.balanceOf(address(this), tokenId) >= amount, "Insufficient tokens available to complete transaction.");
        _ierc1155.safeTransferFrom(address(this), msg.sender, tokenId, amount, "");
    }

    function _transferPurchase(uint256 tokenId, uint256 amount) 
        private 
    {
        require(_ierc1155.balanceOf(address(this), tokenId) >= amount, "Insufficient tokens available to complete transaction.");
        _ierc1155.safeTransferFrom(address(this), msg.sender, tokenId, amount, "");
    }

    function purchaseToken(uint256 tokenId, uint256 amount) 
        external 
        payable
    {
        // make sure an appropriate amount of eth was sent
        // msg.value contains the amount of wei (ether / 1e18) sent in the transaction.
        require(msg.value == _ethPrice.mul(amount), ""); // Funds must equal price times amount.
        _transferPurchase(tokenId, amount);
        emit TokenPurchased(msg.sender, tokenId, amount);
    }

    function purchaseTokenErc20(uint256 tokenId, uint256 amount) 
        external 
        payable
    {
        uint256 erc20PurchasePrice = _erc20Price.mul(amount);
        uint256 erc20Balance = _ierc20.balanceOf(msg.sender);
        require(erc20Balance >= erc20PurchasePrice, "Inadequate funds.");
        _transferPurchase(tokenId, amount);
        _ierc20.safeTransferFrom(msg.sender, address(this), erc20PurchasePrice);
        emit TokenPurchased(msg.sender, tokenId, amount);
    }

    function purchaseTokenErc1155Item0(uint256 tokenId, uint256 amount) 
        external 
        payable
    {
        uint256 erc1155PurchasePrice = _erc1155Item0Price.mul(amount);
        uint256 erc1155Item0Id = 0;
        uint256 senderErc1155Item0Balance = _ierc1155.balanceOf(msg.sender, erc1155Item0Id);
        require(senderErc1155Item0Balance >= erc1155PurchasePrice, "Insufficient balance.");
        _transferPurchase(tokenId, amount);
        // transfer item0s back to contract
        _ierc1155.safeTransferFrom(msg.sender, address(this), erc1155Item0Id, erc1155PurchasePrice, ""); // what is this?
        emit TokenPurchased(msg.sender, tokenId, amount);
    }

    function withdrawToken(uint256 tokenId, uint256 amount) 
        external 
        onlyOwner 
    { 
        address payable owner = payable(msg.sender);
        _ierc1155.safeTransferFrom(address(this), owner, tokenId, amount, "");
        emit TokenWithdrawn(owner, tokenId, amount);
    }

    function withdrawFunds() 
        external 
        onlyOwner 
    { 
        address payable owner = payable(msg.sender);
        owner.transfer(address(this).balance); // return eth to owner
        _ierc20.safeTransfer(owner, _ierc20.balanceOf(address(this))); // return erc20 to owner
        emit FundsWithdrawn(owner);
    }

    function setEthPrice(uint256 amount)
        external
        onlyOwner
    {
        _ethPrice = amount;
        emit PriceUpdated(_ethPrice, _erc20Price, _erc1155Item0Price);
    }

    function setErc20Price(uint256 amount)
        external
        onlyOwner
    {
        _erc20Price = amount;
        emit PriceUpdated(_ethPrice, _erc20Price, _erc1155Item0Price);
    }
    function setErc1155Item0Price(uint256 amount)
        external
        onlyOwner
    {
        _erc1155Item0Price = amount;
        emit PriceUpdated(_ethPrice, _erc20Price, _erc1155Item0Price);
    }

    function getEthPrice ()
        external
        view
        returns (uint256)
    {
        return _ethPrice;
    }

    function getErc20Price ()
        external
        view
        returns (uint256)
    {
        return _erc20Price;
    }

    function getErc1155Item0Price ()
        external
        view
        returns (uint256)
    {
        return _erc1155Item0Price;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"wallet","type":"address"}],"name":"FundsWithdrawn","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":false,"internalType":"uint256","name":"ethPrice","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"erc20Price","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"erc1155Item0Price","type":"uint256"}],"name":"PriceUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"wallet","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenPurchased","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"wallet","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenWithdrawn","type":"event"},{"inputs":[],"name":"_erc1155Item0Price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_erc20Price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_ethPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getErc1155Item0Price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getErc20Price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getEthPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ierc1155ContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ierc20ContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"purchaseToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"purchaseTokenErc1155Item0","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"purchaseTokenErc20","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setErc1155Item0Price","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setErc20Price","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setEthPrice","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":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

70855:5274:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75111:188;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39445:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71737:41;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71821:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74765:338;;;;;;;;;;;;;:::i;:::-;;75307:192;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72793:457;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75985:141;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73258:498;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75719:123;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2636:103;;;;;;;;;;;;;:::i;:::-;;71389:90;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1988:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75850:127;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71785:29;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71486:92;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71868:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73764:687;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40330:255;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75505:206;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71917:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40095:227;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2894:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74459:298;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75111:188;1874:13;:11;:13::i;:::-;75213:6:::1;75201:9;:18;;;;75235:56;75248:9;;75259:11;;75272:18;;75235:56;;;;;;;;:::i;:::-;;;;;;;;75111:188:::0;:::o;39445:223::-;39547:4;39586:34;39571:49;;;:11;:49;;;;:89;;;;39624:36;39648:11;39624:23;:36::i;:::-;39571:89;39564:96;;39445:223;;;:::o;71737:41::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;71821:40::-;;;;:::o;74765:338::-;1874:13;:11;:13::i;:::-;74847:21:::1;74879:10;74847:43;;74901:5;:14;;:37;74916:21;74901:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;74972:61;74993:5;71437:42;75000:17;;;75026:4;75000:32;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;71437:42;74972:20;;;;:61;;;;;:::i;:::-;75074:21;75089:5;75074:21;;;;;;:::i;:::-;;;;;;;;74835:268;74765:338::o:0;75307:192::-;1874:13;:11;:13::i;:::-;75413:6:::1;75399:11;:20;;;;75435:56;75448:9;;75459:11;;75472:18;;75435:56;;;;;;;;:::i;:::-;;;;;;;;75307:192:::0;:::o;72793:457::-;73072:21;73086:6;73072:9;;:13;;:21;;;;:::i;:::-;73059:9;:34;73051:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;73149:34;73167:7;73176:6;73149:17;:34::i;:::-;73199:43;73214:10;73226:7;73235:6;73199:43;;;;;;;;:::i;:::-;;;;;;;;72793:457;;:::o;75985:141::-;76068:7;76100:18;;76093:25;;75985:141;:::o;73258:498::-;73372:26;73401:23;73417:6;73401:11;;:15;;:23;;;;:::i;:::-;73372:52;;73435:20;71437:42;73458:17;;;73476:10;73458:29;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73435:52;;73522:18;73506:12;:34;;73498:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;73573:34;73591:7;73600:6;73573:17;:34::i;:::-;73618:71;73643:10;73663:4;73670:18;71437:42;73618:24;;;;:71;;;;;;:::i;:::-;73705:43;73720:10;73732:7;73741:6;73705:43;;;;;;;;:::i;:::-;;;;;;;;73361:395;;73258:498;;:::o;75719:123::-;75793:7;75825:9;;75818:16;;75719:123;:::o;2636:103::-;1874:13;:11;:13::i;:::-;2701:30:::1;2728:1;2701:18;:30::i;:::-;2636:103::o:0;71389:90::-;71437:42;71389:90;:::o;1988:87::-;2034:7;2061:6;;;;;;;;;;;2054:13;;1988:87;:::o;75850:127::-;75926:7;75958:11;;75951:18;;75850:127;:::o;71785:29::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;71486:92::-;71536:42;71486:92;:::o;71868:42::-;;;;:::o;73764:687::-;73885:28;73916:30;73939:6;73916:18;;:22;;:30;;;;:::i;:::-;73885:61;;73957:22;73994:33;71536:42;74030:19;;;74050:10;74062:14;74030:47;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;73994:83;;74125:20;74096:25;:49;;74088:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;74182:34;74200:7;74209:6;74182:17;:34::i;:::-;71536:42;74272:26;;;74299:10;74319:4;74326:14;74342:20;74272:95;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74400:43;74415:10;74427:7;74436:6;74400:43;;;;;;;;:::i;:::-;;;;;;;;73874:577;;;73764:687;;:::o;40330:255::-;40515:6;40541:36;;;40534:43;;40330:255;;;;;;;:::o;75505:206::-;1874:13;:11;:13::i;:::-;75625:6:::1;75604:18;:27;;;;75647:56;75660:9;;75671:11;;75684:18;;75647:56;;;;;;;;:::i;:::-;;;;;;;;75505:206:::0;:::o;71917:38::-;;;;:::o;40095:227::-;40257:6;40283:31;;;40276:38;;40095:227;;;;;;;:::o;2894:201::-;1874:13;:11;:13::i;:::-;3003:1:::1;2983:22;;:8;:22;;::::0;2975:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;3059:28;3078:8;3059:18;:28::i;:::-;2894:201:::0;:::o;74459:298::-;1874:13;:11;:13::i;:::-;74572:21:::1;74604:10;74572:43;;71536:42;74626:26;;;74661:4;74668:5;74675:7;74684:6;74626:69;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;74711:38;74726:5;74733:7;74742:6;74711:38;;;;;;;;:::i;:::-;;;;;;;;74560:197;74459:298:::0;;:::o;2153:132::-;2228:12;:10;:12::i;:::-;2217:23;;:7;:5;:7::i;:::-;:23;;;2209:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2153:132::o;21536:157::-;21621:4;21660:25;21645:40;;;:11;:40;;;;21638:47;;21536:157;;;:::o;60113:211::-;60230:86;60250:5;60280:23;;;60305:2;60309:5;60257:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60230:19;:86::i;:::-;60113:211;;;:::o;67426:98::-;67484:7;67515:1;67511;:5;;;;:::i;:::-;67504:12;;67426:98;;;;:::o;72477:308::-;72627:6;71536:42;72580:19;;;72608:4;72615:7;72580:43;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;;72572:120;;;;;;;;;;;;:::i;:::-;;;;;;;;;71536:42;72703:26;;;72738:4;72745:10;72757:7;72766:6;72703:74;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72477:308;;:::o;60332:248::-;60476:96;60496:5;60526:27;;;60555:4;60561:2;60565:5;60503:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60476:19;:96::i;:::-;60332:248;;;;:::o;3255:191::-;3329:16;3348:6;;;;;;;;;;;3329:25;;3374:8;3365:6;;:17;;;;;;;;;;;;;;;;;;3429:8;3398:40;;3419:8;3398:40;;;;;;;;;;;;3318:128;3255:191;:::o;625:98::-;678:7;705:10;698:17;;625:98;:::o;63180:716::-;63604:23;63630:69;63658:4;63630:69;;;;;;;;;;;;;;;;;63638:5;63630:27;;;;:69;;;;;:::i;:::-;63604:95;;63734:1;63714:10;:17;:21;63710:179;;;63811:10;63800:30;;;;;;;;;;;;:::i;:::-;63792:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;63710:179;63250:646;63180:716;;:::o;15331:229::-;15468:12;15500:52;15522:6;15530:4;15536:1;15539:12;15500:21;:52::i;:::-;15493:59;;15331:229;;;;;:::o;16451:455::-;16621:12;16679:5;16654:21;:30;;16646:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;16739:12;16753:23;16780:6;:11;;16799:5;16806:4;16780:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16738:73;;;;16829:69;16856:6;16864:7;16873:10;16885:12;16829:26;:69::i;:::-;16822:76;;;;16451:455;;;;;;:::o;19024:644::-;19209:12;19238:7;19234:427;;;19287:1;19266:10;:17;:22;19262:290;;19484:18;19495:6;19484:10;:18::i;:::-;19476:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;19262:290;19573:10;19566:17;;;;19234:427;19616:33;19624:10;19636:12;19616:7;:33::i;:::-;19024:644;;;;;;;:::o;12574:326::-;12634:4;12891:1;12869:7;:19;;;:23;12862:30;;12574:326;;;:::o;20210:552::-;20391:1;20371:10;:17;:21;20367:388;;;20603:10;20597:17;20660:15;20647:10;20643:2;20639:19;20632:44;20367:388;20730:12;20723:20;;;;;;;;;;;:::i;:::-;;;;;;;;7:75:1;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:77;371:7;400:5;389:16;;334:77;;;:::o;417:122::-;490:24;508:5;490:24;:::i;:::-;483:5;480:35;470:63;;529:1;526;519:12;470:63;417:122;:::o;545:139::-;591:5;629:6;616:20;607:29;;645:33;672:5;645:33;:::i;:::-;545:139;;;;:::o;690:329::-;749:6;798:2;786:9;777:7;773:23;769:32;766:119;;;804:79;;:::i;:::-;766:119;924:1;949:53;994:7;985:6;974:9;970:22;949:53;:::i;:::-;939:63;;895:117;690:329;;;;:::o;1025:149::-;1061:7;1101:66;1094:5;1090:78;1079:89;;1025:149;;;:::o;1180:120::-;1252:23;1269:5;1252:23;:::i;:::-;1245:5;1242:34;1232:62;;1290:1;1287;1280:12;1232:62;1180:120;:::o;1306:137::-;1351:5;1389:6;1376:20;1367:29;;1405:32;1431:5;1405:32;:::i;:::-;1306:137;;;;:::o;1449:327::-;1507:6;1556:2;1544:9;1535:7;1531:23;1527:32;1524:119;;;1562:79;;:::i;:::-;1524:119;1682:1;1707:52;1751:7;1742:6;1731:9;1727:22;1707:52;:::i;:::-;1697:62;;1653:116;1449:327;;;;:::o;1782:90::-;1816:7;1859:5;1852:13;1845:21;1834:32;;1782:90;;;:::o;1878:109::-;1959:21;1974:5;1959:21;:::i;:::-;1954:3;1947:34;1878:109;;:::o;1993:210::-;2080:4;2118:2;2107:9;2103:18;2095:26;;2131:65;2193:1;2182:9;2178:17;2169:6;2131:65;:::i;:::-;1993:210;;;;:::o;2209:99::-;2261:6;2295:5;2289:12;2279:22;;2209:99;;;:::o;2314:169::-;2398:11;2432:6;2427:3;2420:19;2472:4;2467:3;2463:14;2448:29;;2314:169;;;;:::o;2489:246::-;2570:1;2580:113;2594:6;2591:1;2588:13;2580:113;;;2679:1;2674:3;2670:11;2664:18;2660:1;2655:3;2651:11;2644:39;2616:2;2613:1;2609:10;2604:15;;2580:113;;;2727:1;2718:6;2713:3;2709:16;2702:27;2551:184;2489:246;;;:::o;2741:102::-;2782:6;2833:2;2829:7;2824:2;2817:5;2813:14;2809:28;2799:38;;2741:102;;;:::o;2849:377::-;2937:3;2965:39;2998:5;2965:39;:::i;:::-;3020:71;3084:6;3079:3;3020:71;:::i;:::-;3013:78;;3100:65;3158:6;3153:3;3146:4;3139:5;3135:16;3100:65;:::i;:::-;3190:29;3212:6;3190:29;:::i;:::-;3185:3;3181:39;3174:46;;2941:285;2849:377;;;;:::o;3232:313::-;3345:4;3383:2;3372:9;3368:18;3360:26;;3432:9;3426:4;3422:20;3418:1;3407:9;3403:17;3396:47;3460:78;3533:4;3524:6;3460:78;:::i;:::-;3452:86;;3232:313;;;;:::o;3551:118::-;3638:24;3656:5;3638:24;:::i;:::-;3633:3;3626:37;3551:118;;:::o;3675:222::-;3768:4;3806:2;3795:9;3791:18;3783:26;;3819:71;3887:1;3876:9;3872:17;3863:6;3819:71;:::i;:::-;3675:222;;;;:::o;3903:474::-;3971:6;3979;4028:2;4016:9;4007:7;4003:23;3999:32;3996:119;;;4034:79;;:::i;:::-;3996:119;4154:1;4179:53;4224:7;4215:6;4204:9;4200:22;4179:53;:::i;:::-;4169:63;;4125:117;4281:2;4307:53;4352:7;4343:6;4332:9;4328:22;4307:53;:::i;:::-;4297:63;;4252:118;3903:474;;;;;:::o;4383:126::-;4420:7;4460:42;4453:5;4449:54;4438:65;;4383:126;;;:::o;4515:96::-;4552:7;4581:24;4599:5;4581:24;:::i;:::-;4570:35;;4515:96;;;:::o;4617:118::-;4704:24;4722:5;4704:24;:::i;:::-;4699:3;4692:37;4617:118;;:::o;4741:222::-;4834:4;4872:2;4861:9;4857:18;4849:26;;4885:71;4953:1;4942:9;4938:17;4929:6;4885:71;:::i;:::-;4741:222;;;;:::o;4969:122::-;5042:24;5060:5;5042:24;:::i;:::-;5035:5;5032:35;5022:63;;5081:1;5078;5071:12;5022:63;4969:122;:::o;5097:139::-;5143:5;5181:6;5168:20;5159:29;;5197:33;5224:5;5197:33;:::i;:::-;5097:139;;;;:::o;5242:117::-;5351:1;5348;5341:12;5365:180;5413:77;5410:1;5403:88;5510:4;5507:1;5500:15;5534:4;5531:1;5524:15;5551:281;5634:27;5656:4;5634:27;:::i;:::-;5626:6;5622:40;5764:6;5752:10;5749:22;5728:18;5716:10;5713:34;5710:62;5707:88;;;5775:18;;:::i;:::-;5707:88;5815:10;5811:2;5804:22;5594:238;5551:281;;:::o;5838:129::-;5872:6;5899:20;;:::i;:::-;5889:30;;5928:33;5956:4;5948:6;5928:33;:::i;:::-;5838:129;;;:::o;5973:311::-;6050:4;6140:18;6132:6;6129:30;6126:56;;;6162:18;;:::i;:::-;6126:56;6212:4;6204:6;6200:17;6192:25;;6272:4;6266;6262:15;6254:23;;5973:311;;;:::o;6290:117::-;6399:1;6396;6389:12;6430:710;6526:5;6551:81;6567:64;6624:6;6567:64;:::i;:::-;6551:81;:::i;:::-;6542:90;;6652:5;6681:6;6674:5;6667:21;6715:4;6708:5;6704:16;6697:23;;6768:4;6760:6;6756:17;6748:6;6744:30;6797:3;6789:6;6786:15;6783:122;;;6816:79;;:::i;:::-;6783:122;6931:6;6914:220;6948:6;6943:3;6940:15;6914:220;;;7023:3;7052:37;7085:3;7073:10;7052:37;:::i;:::-;7047:3;7040:50;7119:4;7114:3;7110:14;7103:21;;6990:144;6974:4;6969:3;6965:14;6958:21;;6914:220;;;6918:21;6532:608;;6430:710;;;;;:::o;7163:370::-;7234:5;7283:3;7276:4;7268:6;7264:17;7260:27;7250:122;;7291:79;;:::i;:::-;7250:122;7408:6;7395:20;7433:94;7523:3;7515:6;7508:4;7500:6;7496:17;7433:94;:::i;:::-;7424:103;;7240:293;7163:370;;;;:::o;7539:117::-;7648:1;7645;7638:12;7662:307;7723:4;7813:18;7805:6;7802:30;7799:56;;;7835:18;;:::i;:::-;7799:56;7873:29;7895:6;7873:29;:::i;:::-;7865:37;;7957:4;7951;7947:15;7939:23;;7662:307;;;:::o;7975:146::-;8072:6;8067:3;8062;8049:30;8113:1;8104:6;8099:3;8095:16;8088:27;7975:146;;;:::o;8127:423::-;8204:5;8229:65;8245:48;8286:6;8245:48;:::i;:::-;8229:65;:::i;:::-;8220:74;;8317:6;8310:5;8303:21;8355:4;8348:5;8344:16;8393:3;8384:6;8379:3;8375:16;8372:25;8369:112;;;8400:79;;:::i;:::-;8369:112;8490:54;8537:6;8532:3;8527;8490:54;:::i;:::-;8210:340;8127:423;;;;;:::o;8569:338::-;8624:5;8673:3;8666:4;8658:6;8654:17;8650:27;8640:122;;8681:79;;:::i;:::-;8640:122;8798:6;8785:20;8823:78;8897:3;8889:6;8882:4;8874:6;8870:17;8823:78;:::i;:::-;8814:87;;8630:277;8569:338;;;;:::o;8913:1509::-;9067:6;9075;9083;9091;9099;9148:3;9136:9;9127:7;9123:23;9119:33;9116:120;;;9155:79;;:::i;:::-;9116:120;9275:1;9300:53;9345:7;9336:6;9325:9;9321:22;9300:53;:::i;:::-;9290:63;;9246:117;9402:2;9428:53;9473:7;9464:6;9453:9;9449:22;9428:53;:::i;:::-;9418:63;;9373:118;9558:2;9547:9;9543:18;9530:32;9589:18;9581:6;9578:30;9575:117;;;9611:79;;:::i;:::-;9575:117;9716:78;9786:7;9777:6;9766:9;9762:22;9716:78;:::i;:::-;9706:88;;9501:303;9871:2;9860:9;9856:18;9843:32;9902:18;9894:6;9891:30;9888:117;;;9924:79;;:::i;:::-;9888:117;10029:78;10099:7;10090:6;10079:9;10075:22;10029:78;:::i;:::-;10019:88;;9814:303;10184:3;10173:9;10169:19;10156:33;10216:18;10208:6;10205:30;10202:117;;;10238:79;;:::i;:::-;10202:117;10343:62;10397:7;10388:6;10377:9;10373:22;10343:62;:::i;:::-;10333:72;;10127:288;8913:1509;;;;;;;;:::o;10428:115::-;10513:23;10530:5;10513:23;:::i;:::-;10508:3;10501:36;10428:115;;:::o;10549:218::-;10640:4;10678:2;10667:9;10663:18;10655:26;;10691:69;10757:1;10746:9;10742:17;10733:6;10691:69;:::i;:::-;10549:218;;;;:::o;10773:1089::-;10877:6;10885;10893;10901;10909;10958:3;10946:9;10937:7;10933:23;10929:33;10926:120;;;10965:79;;:::i;:::-;10926:120;11085:1;11110:53;11155:7;11146:6;11135:9;11131:22;11110:53;:::i;:::-;11100:63;;11056:117;11212:2;11238:53;11283:7;11274:6;11263:9;11259:22;11238:53;:::i;:::-;11228:63;;11183:118;11340:2;11366:53;11411:7;11402:6;11391:9;11387:22;11366:53;:::i;:::-;11356:63;;11311:118;11468:2;11494:53;11539:7;11530:6;11519:9;11515:22;11494:53;:::i;:::-;11484:63;;11439:118;11624:3;11613:9;11609:19;11596:33;11656:18;11648:6;11645:30;11642:117;;;11678:79;;:::i;:::-;11642:117;11783:62;11837:7;11828:6;11817:9;11813:22;11783:62;:::i;:::-;11773:72;;11567:288;10773:1089;;;;;;;;:::o;11868:329::-;11927:6;11976:2;11964:9;11955:7;11951:23;11947:32;11944:119;;;11982:79;;:::i;:::-;11944:119;12102:1;12127:53;12172:7;12163:6;12152:9;12148:22;12127:53;:::i;:::-;12117:63;;12073:117;11868:329;;;;:::o;12203:442::-;12352:4;12390:2;12379:9;12375:18;12367:26;;12403:71;12471:1;12460:9;12456:17;12447:6;12403:71;:::i;:::-;12484:72;12552:2;12541:9;12537:18;12528:6;12484:72;:::i;:::-;12566;12634:2;12623:9;12619:18;12610:6;12566:72;:::i;:::-;12203:442;;;;;;:::o;12651:180::-;12699:77;12696:1;12689:88;12796:4;12793:1;12786:15;12820:4;12817:1;12810:15;12837:320;12881:6;12918:1;12912:4;12908:12;12898:22;;12965:1;12959:4;12955:12;12986:18;12976:81;;13042:4;13034:6;13030:17;13020:27;;12976:81;13104:2;13096:6;13093:14;13073:18;13070:38;13067:84;;13123:18;;:::i;:::-;13067:84;12888:269;12837:320;;;:::o;13163:143::-;13220:5;13251:6;13245:13;13236:22;;13267:33;13294:5;13267:33;:::i;:::-;13163:143;;;;:::o;13312:351::-;13382:6;13431:2;13419:9;13410:7;13406:23;13402:32;13399:119;;;13437:79;;:::i;:::-;13399:119;13557:1;13582:64;13638:7;13629:6;13618:9;13614:22;13582:64;:::i;:::-;13572:74;;13528:128;13312:351;;;;:::o;13669:60::-;13697:3;13718:5;13711:12;;13669:60;;;:::o;13735:142::-;13785:9;13818:53;13836:34;13845:24;13863:5;13845:24;:::i;:::-;13836:34;:::i;:::-;13818:53;:::i;:::-;13805:66;;13735:142;;;:::o;13883:126::-;13933:9;13966:37;13997:5;13966:37;:::i;:::-;13953:50;;13883:126;;;:::o;14015:134::-;14073:9;14106:37;14137:5;14106:37;:::i;:::-;14093:50;;14015:134;;;:::o;14155:147::-;14250:45;14289:5;14250:45;:::i;:::-;14245:3;14238:58;14155:147;;:::o;14308:238::-;14409:4;14447:2;14436:9;14432:18;14424:26;;14460:79;14536:1;14525:9;14521:17;14512:6;14460:79;:::i;:::-;14308:238;;;;:::o;14552:114::-;;:::o;14672:364::-;14814:3;14835:66;14899:1;14894:3;14835:66;:::i;:::-;14828:73;;14910:93;14999:3;14910:93;:::i;:::-;15028:1;15023:3;15019:11;15012:18;;14672:364;;;:::o;15042:419::-;15208:4;15246:2;15235:9;15231:18;15223:26;;15295:9;15289:4;15285:20;15281:1;15270:9;15266:17;15259:47;15323:131;15449:4;15323:131;:::i;:::-;15315:139;;15042:419;;;:::o;15467:442::-;15616:4;15654:2;15643:9;15639:18;15631:26;;15667:71;15735:1;15724:9;15720:17;15711:6;15667:71;:::i;:::-;15748:72;15816:2;15805:9;15801:18;15792:6;15748:72;:::i;:::-;15830;15898:2;15887:9;15883:18;15874:6;15830:72;:::i;:::-;15467:442;;;;;;:::o;15915:167::-;16055:19;16051:1;16043:6;16039:14;16032:43;15915:167;:::o;16088:366::-;16230:3;16251:67;16315:2;16310:3;16251:67;:::i;:::-;16244:74;;16327:93;16416:3;16327:93;:::i;:::-;16445:2;16440:3;16436:12;16429:19;;16088:366;;;:::o;16460:419::-;16626:4;16664:2;16653:9;16649:18;16641:26;;16713:9;16707:4;16703:20;16699:1;16688:9;16684:17;16677:47;16741:131;16867:4;16741:131;:::i;:::-;16733:139;;16460:419;;;:::o;16885:332::-;17006:4;17044:2;17033:9;17029:18;17021:26;;17057:71;17125:1;17114:9;17110:17;17101:6;17057:71;:::i;:::-;17138:72;17206:2;17195:9;17191:18;17182:6;17138:72;:::i;:::-;16885:332;;;;;:::o;17223:171::-;17363:23;17359:1;17351:6;17347:14;17340:47;17223:171;:::o;17400:366::-;17542:3;17563:67;17627:2;17622:3;17563:67;:::i;:::-;17556:74;;17639:93;17728:3;17639:93;:::i;:::-;17757:2;17752:3;17748:12;17741:19;;17400:366;;;:::o;17772:419::-;17938:4;17976:2;17965:9;17961:18;17953:26;;18025:9;18019:4;18015:20;18011:1;18000:9;17996:17;17989:47;18053:131;18179:4;18053:131;:::i;:::-;18045:139;;17772:419;;;:::o;18197:168::-;18280:11;18314:6;18309:3;18302:19;18354:4;18349:3;18345:14;18330:29;;18197:168;;;;:::o;18371:362::-;18512:3;18533:65;18596:1;18591:3;18533:65;:::i;:::-;18526:72;;18607:93;18696:3;18607:93;:::i;:::-;18725:1;18720:3;18716:11;18709:18;;18371:362;;;:::o;18739:859::-;19016:4;19054:3;19043:9;19039:19;19031:27;;19068:71;19136:1;19125:9;19121:17;19112:6;19068:71;:::i;:::-;19149:72;19217:2;19206:9;19202:18;19193:6;19149:72;:::i;:::-;19231;19299:2;19288:9;19284:18;19275:6;19231:72;:::i;:::-;19313;19381:2;19370:9;19366:18;19357:6;19313:72;:::i;:::-;19433:9;19427:4;19423:20;19417:3;19406:9;19402:19;19395:49;19461:130;19586:4;19461:130;:::i;:::-;19453:138;;18739:859;;;;;;;:::o;19604:225::-;19744:34;19740:1;19732:6;19728:14;19721:58;19813:8;19808:2;19800:6;19796:15;19789:33;19604:225;:::o;19835:366::-;19977:3;19998:67;20062:2;20057:3;19998:67;:::i;:::-;19991:74;;20074:93;20163:3;20074:93;:::i;:::-;20192:2;20187:3;20183:12;20176:19;;19835:366;;;:::o;20207:419::-;20373:4;20411:2;20400:9;20396:18;20388:26;;20460:9;20454:4;20450:20;20446:1;20435:9;20431:17;20424:47;20488:131;20614:4;20488:131;:::i;:::-;20480:139;;20207:419;;;:::o;20632:875::-;20917:4;20955:3;20944:9;20940:19;20932:27;;20969:71;21037:1;21026:9;21022:17;21013:6;20969:71;:::i;:::-;21050:80;21126:2;21115:9;21111:18;21102:6;21050:80;:::i;:::-;21140:72;21208:2;21197:9;21193:18;21184:6;21140:72;:::i;:::-;21222;21290:2;21279:9;21275:18;21266:6;21222:72;:::i;:::-;21342:9;21336:4;21332:20;21326:3;21315:9;21311:19;21304:49;21370:130;21495:4;21370:130;:::i;:::-;21362:138;;20632:875;;;;;;;:::o;21513:458::-;21670:4;21708:2;21697:9;21693:18;21685:26;;21721:79;21797:1;21786:9;21782:17;21773:6;21721:79;:::i;:::-;21810:72;21878:2;21867:9;21863:18;21854:6;21810:72;:::i;:::-;21892;21960:2;21949:9;21945:18;21936:6;21892:72;:::i;:::-;21513:458;;;;;;:::o;21977:182::-;22117:34;22113:1;22105:6;22101:14;22094:58;21977:182;:::o;22165:366::-;22307:3;22328:67;22392:2;22387:3;22328:67;:::i;:::-;22321:74;;22404:93;22493:3;22404:93;:::i;:::-;22522:2;22517:3;22513:12;22506:19;;22165:366;;;:::o;22537:419::-;22703:4;22741:2;22730:9;22726:18;22718:26;;22790:9;22784:4;22780:20;22776:1;22765:9;22761:17;22754:47;22818:131;22944:4;22818:131;:::i;:::-;22810:139;;22537:419;;;:::o;22962:180::-;23010:77;23007:1;23000:88;23107:4;23104:1;23097:15;23131:4;23128:1;23121:15;23148:348;23188:7;23211:20;23229:1;23211:20;:::i;:::-;23206:25;;23245:20;23263:1;23245:20;:::i;:::-;23240:25;;23433:1;23365:66;23361:74;23358:1;23355:81;23350:1;23343:9;23336:17;23332:105;23329:131;;;23440:18;;:::i;:::-;23329:131;23488:1;23485;23481:9;23470:20;;23148:348;;;;:::o;23502:241::-;23642:34;23638:1;23630:6;23626:14;23619:58;23711:24;23706:2;23698:6;23694:15;23687:49;23502:241;:::o;23749:366::-;23891:3;23912:67;23976:2;23971:3;23912:67;:::i;:::-;23905:74;;23988:93;24077:3;23988:93;:::i;:::-;24106:2;24101:3;24097:12;24090:19;;23749:366;;;:::o;24121:419::-;24287:4;24325:2;24314:9;24310:18;24302:26;;24374:9;24368:4;24364:20;24360:1;24349:9;24345:17;24338:47;24402:131;24528:4;24402:131;:::i;:::-;24394:139;;24121:419;;;:::o;24546:442::-;24695:4;24733:2;24722:9;24718:18;24710:26;;24746:71;24814:1;24803:9;24799:17;24790:6;24746:71;:::i;:::-;24827:72;24895:2;24884:9;24880:18;24871:6;24827:72;:::i;:::-;24909;24977:2;24966:9;24962:18;24953:6;24909:72;:::i;:::-;24546:442;;;;;;:::o;24994:116::-;25064:21;25079:5;25064:21;:::i;:::-;25057:5;25054:32;25044:60;;25100:1;25097;25090:12;25044:60;24994:116;:::o;25116:137::-;25170:5;25201:6;25195:13;25186:22;;25217:30;25241:5;25217:30;:::i;:::-;25116:137;;;;:::o;25259:345::-;25326:6;25375:2;25363:9;25354:7;25350:23;25346:32;25343:119;;;25381:79;;:::i;:::-;25343:119;25501:1;25526:61;25579:7;25570:6;25559:9;25555:22;25526:61;:::i;:::-;25516:71;;25472:125;25259:345;;;;:::o;25610:229::-;25750:34;25746:1;25738:6;25734:14;25727:58;25819:12;25814:2;25806:6;25802:15;25795:37;25610:229;:::o;25845:366::-;25987:3;26008:67;26072:2;26067:3;26008:67;:::i;:::-;26001:74;;26084:93;26173:3;26084:93;:::i;:::-;26202:2;26197:3;26193:12;26186:19;;25845:366;;;:::o;26217:419::-;26383:4;26421:2;26410:9;26406:18;26398:26;;26470:9;26464:4;26460:20;26456:1;26445:9;26441:17;26434:47;26498:131;26624:4;26498:131;:::i;:::-;26490:139;;26217:419;;;:::o;26642:225::-;26782:34;26778:1;26770:6;26766:14;26759:58;26851:8;26846:2;26838:6;26834:15;26827:33;26642:225;:::o;26873:366::-;27015:3;27036:67;27100:2;27095:3;27036:67;:::i;:::-;27029:74;;27112:93;27201:3;27112:93;:::i;:::-;27230:2;27225:3;27221:12;27214:19;;26873:366;;;:::o;27245:419::-;27411:4;27449:2;27438:9;27434:18;27426:26;;27498:9;27492:4;27488:20;27484:1;27473:9;27469:17;27462:47;27526:131;27652:4;27526:131;:::i;:::-;27518:139;;27245:419;;;:::o;27670:98::-;27721:6;27755:5;27749:12;27739:22;;27670:98;;;:::o;27774:147::-;27875:11;27912:3;27897:18;;27774:147;;;;:::o;27927:386::-;28031:3;28059:38;28091:5;28059:38;:::i;:::-;28113:88;28194:6;28189:3;28113:88;:::i;:::-;28106:95;;28210:65;28268:6;28263:3;28256:4;28249:5;28245:16;28210:65;:::i;:::-;28300:6;28295:3;28291:16;28284:23;;28035:278;27927:386;;;;:::o;28319:271::-;28449:3;28471:93;28560:3;28551:6;28471:93;:::i;:::-;28464:100;;28581:3;28574:10;;28319:271;;;;:::o;28596:179::-;28736:31;28732:1;28724:6;28720:14;28713:55;28596:179;:::o;28781:366::-;28923:3;28944:67;29008:2;29003:3;28944:67;:::i;:::-;28937:74;;29020:93;29109:3;29020:93;:::i;:::-;29138:2;29133:3;29129:12;29122:19;;28781:366;;;:::o;29153:419::-;29319:4;29357:2;29346:9;29342:18;29334:26;;29406:9;29400:4;29396:20;29392:1;29381:9;29377:17;29370:47;29434:131;29560:4;29434:131;:::i;:::-;29426:139;;29153:419;;;:::o

Swarm Source

ipfs://7ac94e02765d12316b60dc9c4aa3b3ceb7258c7980c73c545df1c3ef76724cb9

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