Token

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

ERC-1155

Overview

Max Total Supply

201,481

Holders

1,015

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x0411f0ff4105fdc075e5e1bfdab47183c1b9df78

Filtered by Token Holder

0xB3eE451C411A5E5b39100964EA16a9B8b74A9918

0xb3ee451c411a5e5b39100964ea16a9b8b74a9918

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ShiryoCards

Compiler Version

v0.8.6+commit.11564f7e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-03-14
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;


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

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

// File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.0;


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

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


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.0;







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

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

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

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

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

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

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

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

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

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

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

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _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 owner nor 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: transfer caller is not owner nor 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();

        _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), 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);

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * 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();

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

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

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * 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);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "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 `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.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;
    }
}

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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



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

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

// File: contracts/ShiryoCards1155.sol


interface IShiryoRandomCards {
      function randomCards(uint256 _amount, uint256 _deck) external returns (uint8[] memory);
}

pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;

contract ShiryoCards is Ownable, ERC1155 {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    modifier onlyClevel() {
        require(msg.sender == walletA || msg.sender == walletB || msg.sender == owner());
    _;
    }

    address walletA;
    address walletB;
    uint256 walletBPercentage = 15;

    uint256 public constant TOTAL_BASE_CARDS = 150;
    uint256 public constant TOTAL_FOUNDER_CARDS = 25;

    uint256 public constant MAX_AMOUNT_OPEN = 10;
    uint256 public constant MAX_AMOUNT_SWAP = 10;

    uint256 public swapFee = 0.01 ether;

    address public founderPackAddress;
    address public normalPackAddress;
    uint256 public cardsPerNormalPack = 5;
    uint256 public activeDeck = 1;


    address public nftAddress = address(0x0);

    mapping(address => uint256[]) public lastUnpackedByAddress;


    IShiryoRandomCards cardDealer;

    constructor(address _founder, address _normal, address _cardDealer, address _walletA, address _walletB)
        ERC1155("https://api.cards.shiryo.com/card/{id}.json")
    {
        founderPackAddress = _founder;
        normalPackAddress = _normal;
        cardDealer = IShiryoRandomCards(_cardDealer);
        walletA = _walletA;
        walletB = _walletB;
    }

    function openPacks(address packContract, uint256 _amount) public {
        require(_amount > 0, "Can't open zero packs.");
        require(_amount <= MAX_AMOUNT_OPEN, "Can't open zero packs.");

        // opening a pack means
        // transfer the pack(s) to this address
        // the balance of this address on the pack contracts = number opened
        IERC20(packContract).safeTransferFrom(
            msg.sender,
            address(this),
            _amount
        );

       
        uint256 amountBaseCards = _amount * cardsPerNormalPack;
        uint256 amountFounderCards = 0;

        if (packContract==founderPackAddress){
            amountFounderCards = _amount; // 1 additional founder card per founder pack
        }

        lastUnpackedByAddress[msg.sender] = new uint8[](amountBaseCards+amountFounderCards);

        uint8  [] memory baseCards = cardDealer.randomCards(amountBaseCards, activeDeck);
      
    
        for (uint256 c = 0; c < baseCards.length; c++) {
            _mint(msg.sender, uint256(baseCards[c]), 1, "");
            lastUnpackedByAddress[msg.sender][c] = baseCards[c];
        }

        for (uint256 f = 0; f < amountFounderCards; f++) {
            uint256 Fcard = TOTAL_BASE_CARDS+random(TOTAL_FOUNDER_CARDS)+1;
            _mint(msg.sender, Fcard, 1, "");
            lastUnpackedByAddress[msg.sender][amountBaseCards+f] = Fcard;
        }

    }

    function swapCards(uint256[] memory _cardsToSwap) public payable {
        require(_cardsToSwap.length <= MAX_AMOUNT_SWAP, "Too many to swap");

        // NFT holders don't have a fee for swapping cards.
        if (
            !(nftAddress != address(0x0) &&
                IERC721(nftAddress).balanceOf(msg.sender) > 0)
        ) {
            require(msg.value >= swapFee, "Swap fee not met");
        }

        uint8  [] memory newCards  = cardDealer.randomCards(_cardsToSwap.length, activeDeck);

        for (uint256 c = 0; c < _cardsToSwap.length; c++) {
            _burn(msg.sender, _cardsToSwap[c], 1); // burn the old first
            _mint(msg.sender, uint256(newCards[c]), 1, "");
        }
        lastUnpackedByAddress[msg.sender] = newCards;
    }

    function lastUnpackedCards(address _user)
        public
        view
        returns (uint256[] memory)
    {
        return lastUnpackedByAddress[_user];
    }

    function totalCards() public pure returns (uint256){
        return TOTAL_BASE_CARDS+TOTAL_FOUNDER_CARDS;
    }

    function balancesOf(address _user) public view returns (uint256[] memory) {
        uint256[] memory balances = new uint256[](totalCards());
        for (uint256 i = 1; i <= totalCards(); i++) {
            balances[i - 1] = balanceOf(_user, i);
        }
        return balances;
    }

    function totalCardsOf(address _user) public view returns (uint256) {
        uint256 total = 0;
        for (uint256 i = 1; i <= totalCards(); i++) {
            total+= balanceOf(_user, i);
        }
        return total;
    }

    // pseudo random selection of integer in range
    uint256 nonce;

    function random(uint256 _range) internal returns (uint256) {
        uint256 rnd = uint256(
            keccak256(abi.encodePacked(block.timestamp, msg.sender, nonce))
        ) % _range;
        nonce++;
        return rnd;
    }

    // owner functions
    function setNFTAddress(address _nft) external onlyOwner {
        nftAddress = _nft;
    }

   function setSwapFee(uint256 _fee) external onlyOwner {
           swapFee = _fee;
    }

    function withdraw_all() external onlyClevel {
        require (address(this).balance > 0);
        uint256 amountB = SafeMath.div(address(this).balance,100).mul(walletBPercentage);
        uint256 amountA = address(this).balance.sub(amountB);
        payable(walletA).transfer(amountA);
        payable(walletB).transfer(amountB);
    }

    function setWalletA(address _walletA) external {
        require (msg.sender == walletA, "Who are you?");
        require (_walletA != address(0x0), "Invalid wallet");
        walletA = _walletA;
    }

    function setWalletB(address _walletB) external {
        require (msg.sender == walletB, "Who are you?");
        require (_walletB != address(0x0), "Invalid wallet.");
        walletB = _walletB;
    }

    function setWalletBPercentage(uint256 _percentage) external onlyOwner {
        require (_percentage>walletBPercentage && _percentage<=100, "Invalid new slice.");
        walletBPercentage = _percentage;
    }

}

// File: @openzeppelin/contracts/math/SafeMath.sol
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when an
* operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
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) {
      uint256 c = a + b;
      if (c < a) return (false, 0);
      return (true, c);
  }
  /**
   * @dev Returns the substraction of two unsigned integers, with an overflow flag.
   *
   * _Available since v3.4._
   */
  function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
      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) {
      // 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) {
      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) {
      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) {
      uint256 c = a + b;
      require(c >= a, "SafeMath: addition overflow");
      return c;
  }
  /**
   * @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) {
      require(b <= a, "SafeMath: subtraction overflow");
      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) {
      if (a == 0) return 0;
      uint256 c = a * b;
      require(c / a == b, "SafeMath: multiplication overflow");
      return c;
  }
  /**
   * @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. 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) internal pure returns (uint256) {
      require(b > 0, "SafeMath: division by zero");
      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) {
      require(b > 0, "SafeMath: modulo by zero");
      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) {
      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.
   *
   * CAUTION: This function is deprecated because it requires allocating memory for the error
   * message unnecessarily. For custom revert reasons use {tryDiv}.
   *
   * 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) {
      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) {
      require(b > 0, errorMessage);
      return a % b;
  }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"_founder","type":"address"},{"internalType":"address","name":"_normal","type":"address"},{"internalType":"address","name":"_cardDealer","type":"address"},{"internalType":"address","name":"_walletA","type":"address"},{"internalType":"address","name":"_walletB","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"MAX_AMOUNT_OPEN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_AMOUNT_SWAP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_BASE_CARDS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_FOUNDER_CARDS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activeDeck","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"balancesOf","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cardsPerNormalPack","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"founderPackAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"lastUnpackedByAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"lastUnpackedCards","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"normalPackAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"packContract","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"openPacks","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nft","type":"address"}],"name":"setNFTAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"setSwapFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_walletA","type":"address"}],"name":"setWalletA","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_walletB","type":"address"}],"name":"setWalletB","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_percentage","type":"uint256"}],"name":"setWalletBPercentage","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":[{"internalType":"uint256[]","name":"_cardsToSwap","type":"uint256[]"}],"name":"swapCards","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"swapFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalCards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"totalCardsOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw_all","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

00000000000000000000000023427dea2dd52b13630f2757ff2cd734c5c42174000000000000000000000000773d6e3e85ed29d2c40c42f7cbc8ad3d4ddbeef0000000000000000000000000b03e3183be84aa7349f87c8e48632db14a3dc44f000000000000000000000000bc3e416a2dfb162153c50b2601353cbe3dffaab90000000000000000000000006df08c7b0ce433e29a77281b6e776487730ee900

-----Decoded View---------------
Arg [0] : _founder (address): 0x23427Dea2dd52B13630f2757FF2cD734C5C42174
Arg [1] : _normal (address): 0x773D6E3e85Ed29D2C40C42f7cbc8aD3d4dDBeef0
Arg [2] : _cardDealer (address): 0xB03e3183bE84Aa7349F87c8e48632dB14a3dc44f
Arg [3] : _walletA (address): 0xBc3e416a2DfB162153C50B2601353cbE3dfFAAB9
Arg [4] : _walletB (address): 0x6Df08c7B0CE433e29A77281b6E776487730ee900

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 00000000000000000000000023427dea2dd52b13630f2757ff2cd734c5c42174
Arg [1] : 000000000000000000000000773d6e3e85ed29d2c40c42f7cbc8ad3d4ddbeef0
Arg [2] : 000000000000000000000000b03e3183be84aa7349f87c8e48632db14a3dc44f
Arg [3] : 000000000000000000000000bc3e416a2dfb162153c50b2601353cbe3dffaab9
Arg [4] : 0000000000000000000000006df08c7b0ce433e29a77281b6e776487730ee900

Deployed Bytecode Sourcemap

48503:5903:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27873:231;;;;;;;;;;-1:-1:-1;27873:231:0;;;;;:::i;:::-;;:::i;:::-;;;23305:25:1;;;23293:2;23278:18;27873:231:0;;;;;;;;26896:310;;;;;;;;;;-1:-1:-1;26896:310:0;;;;;:::i;:::-;;:::i;:::-;;;12104:14:1;;12097:22;12079:41;;12067:2;12052:18;26896:310:0;12034:92:1;49220:29:0;;;;;;;;;;;;;;;;27617:105;;;;;;;;;;-1:-1:-1;27617:105:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;49309:58::-;;;;;;;;;;-1:-1:-1;49309:58:0;;;;;:::i;:::-;;:::i;54189:212::-;;;;;;;;;;-1:-1:-1;54189:212:0;;;;;:::i;:::-;;:::i;:::-;;29812:442;;;;;;;;;;-1:-1:-1;29812:442:0;;;;;:::i;:::-;;:::i;53315:89::-;;;;;;;;;;-1:-1:-1;53315:89:0;;;;;:::i;:::-;;:::i;52036:167::-;;;;;;;;;;-1:-1:-1;52036:167:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;49000:44::-;;;;;;;;;;;;49042:2;49000:44;;53762:205;;;;;;;;;;-1:-1:-1;53762:205:0;;;;;:::i;:::-;;:::i;28270:524::-;;;;;;;;;;-1:-1:-1;28270:524:0;;;;;:::i;:::-;;:::i;49097:33::-;;;;;;;;;;-1:-1:-1;49097:33:0;;;;-1:-1:-1;;;;;49097:33:0;;;;;;-1:-1:-1;;;;;9383:32:1;;;9365:51;;9353:2;9338:18;49097:33:0;9320:102:1;49137:32:0;;;;;;;;;;-1:-1:-1;49137:32:0;;;;-1:-1:-1;;;;;49137:32:0;;;49053:35;;;;;;;;;;;;;;;;49260:40;;;;;;;;;;-1:-1:-1;49260:40:0;;;;-1:-1:-1;;;;;49260:40:0;;;49796:1438;;;;;;;;;;-1:-1:-1;49796:1438:0;;;;;:::i;:::-;;:::i;52332:292::-;;;;;;;;;;-1:-1:-1;52332:292:0;;;;;:::i;:::-;;:::i;53216:92::-;;;;;;;;;;-1:-1:-1;53216:92:0;;;;;:::i;:::-;;:::i;16851:103::-;;;;;;;;;;;;;:::i;16200:87::-;;;;;;;;;;-1:-1:-1;16246:7:0;16273:6;-1:-1:-1;;;;;16273:6:0;16200:87;;53975:206;;;;;;;;;;-1:-1:-1;53975:206:0;;;;;:::i;:::-;;:::i;28867:155::-;;;;;;;;;;-1:-1:-1;28867:155:0;;;;;:::i;:::-;;:::i;51242:786::-;;;;;;:::i;:::-;;:::i;52632:234::-;;;;;;;;;;-1:-1:-1;52632:234:0;;;;;:::i;:::-;;:::i;48892:48::-;;;;;;;;;;;;48938:2;48892:48;;53412:342;;;;;;;;;;;;;:::i;29094:168::-;;;;;;;;;;-1:-1:-1;29094:168:0;;;;;:::i;:::-;-1:-1:-1;;;;;29217:27:0;;;29193:4;29217:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;29094:168;52211:113;;;;;;;;;;;;;:::i;48839:46::-;;;;;;;;;;;;48882:3;48839:46;;29334:401;;;;;;;;;;-1:-1:-1;29334:401:0;;;;;:::i;:::-;;:::i;17109:201::-;;;;;;;;;;-1:-1:-1;17109:201:0;;;;;:::i;:::-;;:::i;49176:37::-;;;;;;;;;;;;;;;;27873:231;27959:7;-1:-1:-1;;;;;27987:21:0;;27979:77;;;;-1:-1:-1;;;27979:77:0;;13387:2:1;27979:77:0;;;13369:21:1;13426:2;13406:18;;;13399:30;13465:34;13445:18;;;13438:62;-1:-1:-1;;;13516:18:1;;;13509:41;13567:19;;27979:77:0;;;;;;;;;-1:-1:-1;28074:13:0;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;28074:22:0;;;;;;;;;;27873:231;;;;;:::o;26896:310::-;26998:4;-1:-1:-1;;;;;;27035:41:0;;-1:-1:-1;;;27035:41:0;;:110;;-1:-1:-1;;;;;;;27093:52:0;;-1:-1:-1;;;27093:52:0;27035:110;:163;;;-1:-1:-1;;;;;;;;;;6786:40:0;;;27162:36;6677:157;27617:105;27677:13;27710:4;27703:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27617:105;;;:::o;49309:58::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;54189:212::-;16246:7;16273:6;-1:-1:-1;;;;;16273:6:0;15004:10;16420:23;16412:68;;;;-1:-1:-1;;;16412:68:0;;;;;;;:::i;:::-;54291:17:::1;;54279:11;:29;:49;;;;;54325:3;54312:11;:16;;54279:49;54270:81;;;::::0;-1:-1:-1;;;54270:81:0;;16483:2:1;54270:81:0::1;::::0;::::1;16465:21:1::0;16522:2;16502:18;;;16495:30;-1:-1:-1;;;16541:18:1;;;16534:48;16599:18;;54270:81:0::1;16455:168:1::0;54270:81:0::1;54362:17;:31:::0;54189:212::o;29812:442::-;-1:-1:-1;;;;;30045:20:0;;15004:10;30045:20;;:60;;-1:-1:-1;30069:36:0;30086:4;15004:10;29094:168;:::i;30069:36::-;30023:160;;;;-1:-1:-1;;;30023:160:0;;17581:2:1;30023:160:0;;;17563:21:1;17620:2;17600:18;;;17593:30;17659:34;17639:18;;;17632:62;-1:-1:-1;;;17710:18:1;;;17703:48;17768:19;;30023:160:0;17553:240:1;30023:160:0;30194:52;30217:4;30223:2;30227:3;30232:7;30241:4;30194:22;:52::i;:::-;29812:442;;;;;:::o;53315:89::-;16246:7;16273:6;-1:-1:-1;;;;;16273:6:0;15004:10;16420:23;16412:68;;;;-1:-1:-1;;;16412:68:0;;;;;;;:::i;:::-;53382:7:::1;:14:::0;53315:89::o;52036:167::-;-1:-1:-1;;;;;52167:28:0;;;;;;:21;:28;;;;;;;;;52160:35;;;;;;;;;;;;;;;;;52126:16;;52160:35;;;52167:28;52160:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52036:167;;;:::o;53762:205::-;53843:7;;-1:-1:-1;;;;;53843:7:0;53829:10;:21;53820:47;;;;-1:-1:-1;;;53820:47:0;;15021:2:1;53820:47:0;;;15003:21:1;15060:2;15040:18;;;15033:30;-1:-1:-1;;;15079:18:1;;;15072:42;15131:18;;53820:47:0;14993:162:1;53820:47:0;-1:-1:-1;;;;;53887:24:0;;53878:52;;;;-1:-1:-1;;;53878:52:0;;23018:2:1;53878:52:0;;;23000:21:1;23057:2;23037:18;;;23030:30;-1:-1:-1;;;23076:18:1;;;23069:44;23130:18;;53878:52:0;22990:164:1;53878:52:0;53941:7;:18;;-1:-1:-1;;;;;;53941:18:0;-1:-1:-1;;;;;53941:18:0;;;;;;;;;;53762:205::o;28270:524::-;28426:16;28487:3;:10;28468:8;:15;:29;28460:83;;;;-1:-1:-1;;;28460:83:0;;21452:2:1;28460:83:0;;;21434:21:1;21491:2;21471:18;;;21464:30;21530:34;21510:18;;;21503:62;-1:-1:-1;;;21581:18:1;;;21574:39;21630:19;;28460:83:0;21424:231:1;28460:83:0;28556:30;28603:8;:15;28589:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28589:30:0;;28556:63;;28637:9;28632:122;28656:8;:15;28652:1;:19;28632:122;;;28712:30;28722:8;28731:1;28722:11;;;;;;;;:::i;:::-;;;;;;;28735:3;28739:1;28735:6;;;;;;;;:::i;:::-;;;;;;;28712:9;:30::i;:::-;28693:13;28707:1;28693:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;28673:3;;;:::i;:::-;;;28632:122;;;-1:-1:-1;28773:13:0;28270:524;-1:-1:-1;;;28270:524:0:o;49796:1438::-;49890:1;49880:7;:11;49872:46;;;;-1:-1:-1;;;49872:46:0;;19561:2:1;49872:46:0;;;19543:21:1;19600:2;19580:18;;;19573:30;-1:-1:-1;;;19619:18:1;;;19612:52;19681:18;;49872:46:0;19533:172:1;49872:46:0;48991:2;49937:7;:26;;49929:61;;;;-1:-1:-1;;;49929:61:0;;19561:2:1;49929:61:0;;;19543:21:1;19600:2;19580:18;;;19573:30;-1:-1:-1;;;19619:18:1;;;19612:52;19681:18;;49929:61:0;19533:172:1;49929:61:0;50163:123;-1:-1:-1;;;;;50163:37:0;;50215:10;50248:4;50268:7;50163:37;:123::i;:::-;50308:23;50344:18;;50334:7;:28;;;;:::i;:::-;50434:18;;50308:54;;-1:-1:-1;50373:26:0;;-1:-1:-1;;;;;50420:32:0;;;50434:18;;50420:32;50416:138;;;-1:-1:-1;50489:7:0;50416:138;50614:34;50630:18;50614:15;:34;:::i;:::-;50602:47;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50602:47:0;-1:-1:-1;50588:10:0;50566:33;;;;:21;:33;;;;;;;;:83;;;;:33;;:83;;;;;;:::i;:::-;-1:-1:-1;50691:10:0;;50731;;50691:51;;-1:-1:-1;;;50691:51:0;;50662:26;;-1:-1:-1;;;;;50691:10:0;;:22;;:51;;50714:15;;50691:51;;23515:25:1;;;23571:2;23556:18;;23549:34;23503:2;23488:18;;23470:119;50691:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;50691:51:0;;;;;;;;;;;;:::i;:::-;50662:80;;50772:9;50767:187;50791:9;:16;50787:1;:20;50767:187;;;50829:47;50835:10;50855:9;50865:1;50855:12;;;;;;;;:::i;:::-;;;;;;;50847:21;;50870:1;50829:47;;;;;;;;;;;;:5;:47::i;:::-;50930:9;50940:1;50930:12;;;;;;;;:::i;:::-;;;;;;;50891:51;;:21;:33;50913:10;-1:-1:-1;;;;;50891:33:0;-1:-1:-1;;;;;50891:33:0;;;;;;;;;;;;50925:1;50891:36;;;;;;;;:::i;:::-;;;;;;;;;;:51;50809:3;;;;:::i;:::-;;;;50767:187;;;;50971:9;50966:259;50990:18;50986:1;:22;50966:259;;;51030:13;51063:27;48938:2;51063:6;:27::i;:::-;51046:44;;48882:3;51046:44;:::i;:::-;:46;;51091:1;51046:46;:::i;:::-;51030:62;;51107:31;51113:10;51125:5;51132:1;51107:31;;;;;;;;;;;;:5;:31::i;:::-;51175:10;51153:33;;;;:21;:33;;;;;51208:5;;51187:17;51203:1;51187:15;:17;:::i;:::-;51153:52;;;;;;;;:::i;:::-;;;;;;;;;;:60;-1:-1:-1;51010:3:0;;;;:::i;:::-;;;;50966:259;;;;49861:1373;;;49796:1438;;:::o;52332:292::-;52388:16;52417:25;52459:12;:10;:12::i;:::-;52445:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52445:27:0;-1:-1:-1;52417:55:0;-1:-1:-1;52500:1:0;52483:108;52508:12;:10;:12::i;:::-;52503:1;:17;52483:108;;52560:19;52570:5;52577:1;52560:9;:19::i;:::-;52542:8;52551:5;52555:1;52551;:5;:::i;:::-;52542:15;;;;;;;;:::i;:::-;;;;;;;;;;:37;52522:3;;;;:::i;:::-;;;;52483:108;;;-1:-1:-1;52608:8:0;52332:292;-1:-1:-1;;52332:292:0:o;53216:92::-;16246:7;16273:6;-1:-1:-1;;;;;16273:6:0;15004:10;16420:23;16412:68;;;;-1:-1:-1;;;16412:68:0;;;;;;;:::i;:::-;53283:10:::1;:17:::0;;-1:-1:-1;;;;;;53283:17:0::1;-1:-1:-1::0;;;;;53283:17:0;;;::::1;::::0;;;::::1;::::0;;53216:92::o;16851:103::-;16246:7;16273:6;-1:-1:-1;;;;;16273:6:0;15004:10;16420:23;16412:68;;;;-1:-1:-1;;;16412:68:0;;;;;;;:::i;:::-;16916:30:::1;16943:1;16916:18;:30::i;:::-;16851:103::o:0;53975:206::-;54056:7;;-1:-1:-1;;;;;54056:7:0;54042:10;:21;54033:47;;;;-1:-1:-1;;;54033:47:0;;15021:2:1;54033:47:0;;;15003:21:1;15060:2;15040:18;;;15033:30;-1:-1:-1;;;15079:18:1;;;15072:42;15131:18;;54033:47:0;14993:162:1;54033:47:0;-1:-1:-1;;;;;54100:24:0;;54091:53;;;;-1:-1:-1;;;54091:53:0;;18000:2:1;54091:53:0;;;17982:21:1;18039:2;18019:18;;;18012:30;-1:-1:-1;;;18058:18:1;;;18051:45;18113:18;;54091:53:0;17972:165:1;54091:53:0;54155:7;:18;;-1:-1:-1;;;;;;54155:18:0;-1:-1:-1;;;;;54155:18:0;;;;;;;;;;53975:206::o;28867:155::-;28962:52;15004:10;28995:8;29005;28962:18;:52::i;:::-;28867:155;;:::o;51242:786::-;49042:2;51326:12;:19;:38;;51318:67;;;;-1:-1:-1;;;51318:67:0;;22673:2:1;51318:67:0;;;22655:21:1;22712:2;22692:18;;;22685:30;-1:-1:-1;;;22731:18:1;;;22724:46;22787:18;;51318:67:0;22645:166:1;51318:67:0;51479:10;;-1:-1:-1;;;;;51479:10:0;:26;;;;:92;;-1:-1:-1;51534:10:0;;51526:41;;-1:-1:-1;;;51526:41:0;;51556:10;51526:41;;;9365:51:1;51570:1:0;;-1:-1:-1;;;;;51534:10:0;;51526:29;;9338:18:1;;51526:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:45;51479:92;51459:201;;51620:7;;51607:9;:20;;51599:49;;;;-1:-1:-1;;;51599:49:0;;16830:2:1;51599:49:0;;;16812:21:1;16869:2;16849:18;;;16842:30;-1:-1:-1;;;16888:18:1;;;16881:46;16944:18;;51599:49:0;16802:166:1;51599:49:0;51701:10;;51724:19;;51745:10;;51701:55;;-1:-1:-1;;;51701:55:0;;51672:25;;-1:-1:-1;;;;;51701:10:0;;:22;;:55;;;;23515:25:1;;;23571:2;23556:18;;23549:34;23503:2;23488:18;;23470:119;51701:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;51701:55:0;;;;;;;;;;;;:::i;:::-;51672:84;;51774:9;51769:197;51793:12;:19;51789:1;:23;51769:197;;;51834:37;51840:10;51852:12;51865:1;51852:15;;;;;;;;:::i;:::-;;;;;;;51869:1;51834:5;:37::i;:::-;51908:46;51914:10;51934:8;51943:1;51934:11;;;;;;;;:::i;51908:46::-;51814:3;;;;:::i;:::-;;;;51769:197;;;-1:-1:-1;51998:10:0;51976:33;;;;:21;:33;;;;;;;;:44;;;;;;;;:::i;:::-;;51307:721;51242:786;:::o;52632:234::-;52690:7;;52755:1;52738:98;52763:12;:10;:12::i;:::-;52758:1;:17;52738:98;;52805:19;52815:5;52822:1;52805:9;:19::i;:::-;52797:27;;;;:::i;:::-;;-1:-1:-1;52777:3:0;;;;:::i;:::-;;;;52738:98;;53412:342;48674:7;;-1:-1:-1;;;;;48674:7:0;48660:10;:21;;:46;;-1:-1:-1;48699:7:0;;-1:-1:-1;;;;;48699:7:0;48685:10;:21;48660:46;:71;;;-1:-1:-1;16246:7:0;16273:6;-1:-1:-1;;;;;16273:6:0;48710:10;:21;48660:71;48652:80;;;;;;53500:1:::1;53476:21;:25;53467:35;;;::::0;::::1;;53513:15;53531:62;53575:17;;53531:39;53544:21;53566:3;53531:12;:39::i;:::-;:43:::0;::::1;:62::i;:::-;53513:80:::0;-1:-1:-1;53604:15:0::1;53622:34;:21;53513:80:::0;53622:25:::1;:34::i;:::-;53675:7;::::0;53667:34:::1;::::0;53604:52;;-1:-1:-1;;;;;;53675:7:0::1;::::0;53667:34;::::1;;;::::0;53604:52;;53675:7:::1;53667:34:::0;53675:7;53667:34;53604:52;53675:7;53667:34;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;53720:7:0::1;::::0;53712:34:::1;::::0;-1:-1:-1;;;;;53720:7:0;;::::1;::::0;53712:34;::::1;;;::::0;53738:7;;53720::::1;53712:34:::0;53720:7;53712:34;53738:7;53720;53712:34;::::1;;;;;;;;;;;;;::::0;::::1;;;;52211:113:::0;52254:7;52280:36;48938:2;48882:3;52280:36;:::i;:::-;52273:43;;52211:113;:::o;29334:401::-;-1:-1:-1;;;;;29542:20:0;;15004:10;29542:20;;:60;;-1:-1:-1;29566:36:0;29583:4;15004:10;29094:168;:::i;29566:36::-;29520:151;;;;-1:-1:-1;;;29520:151:0;;14611:2:1;29520:151:0;;;14593:21:1;14650:2;14630:18;;;14623:30;14689:34;14669:18;;;14662:62;-1:-1:-1;;;14740:18:1;;;14733:39;14789:19;;29520:151:0;14583:231:1;29520:151:0;29682:45;29700:4;29706:2;29710;29714:6;29722:4;29682:17;:45::i;17109:201::-;16246:7;16273:6;-1:-1:-1;;;;;16273:6:0;15004:10;16420:23;16412:68;;;;-1:-1:-1;;;16412:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;17198:22:0;::::1;17190:73;;;::::0;-1:-1:-1;;;17190:73:0;;13799:2:1;17190:73:0::1;::::0;::::1;13781:21:1::0;13838:2;13818:18;;;13811:30;13877:34;13857:18;;;13850:62;-1:-1:-1;;;13928:18:1;;;13921:36;13974:19;;17190:73:0::1;13771:228:1::0;17190:73:0::1;17274:28;17293:8;17274:18;:28::i;:::-;17109:201:::0;:::o;31896:1074::-;32123:7;:14;32109:3;:10;:28;32101:81;;;;-1:-1:-1;;;32101:81:0;;21862:2:1;32101:81:0;;;21844:21:1;21901:2;21881:18;;;21874:30;21940:34;21920:18;;;21913:62;-1:-1:-1;;;21991:18:1;;;21984:38;22039:19;;32101:81:0;21834:230:1;32101:81:0;-1:-1:-1;;;;;32201:16:0;;32193:66;;;;-1:-1:-1;;;32193:66:0;;;;;;;:::i;:::-;15004:10;32272:16;32389:421;32413:3;:10;32409:1;:14;32389:421;;;32445:10;32458:3;32462:1;32458:6;;;;;;;;:::i;:::-;;;;;;;32445:19;;32479:14;32496:7;32504:1;32496:10;;;;;;;;:::i;:::-;;;;;;;;;;;;32523:19;32545:13;;;:9;:13;;;;;;-1:-1:-1;;;;;32545:19:0;;;;;;;;;;;;32496:10;;-1:-1:-1;32587:21:0;;;;32579:76;;;;-1:-1:-1;;;32579:76:0;;;;;;;:::i;:::-;32699:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;32699:19:0;;;;;;;;;;32721:20;;;32699:42;;32771:17;;;;;;;:27;;32721:20;;32699:13;32771:27;;32721:20;;32771:27;:::i;:::-;;;;;;;;32430:380;;;32425:3;;;;:::i;:::-;;;32389:421;;;;32857:2;-1:-1:-1;;;;;32827:47:0;32851:4;-1:-1:-1;;;;;32827:47:0;32841:8;-1:-1:-1;;;;;32827:47:0;;32861:3;32866:7;32827:47;;;;;;;:::i;:::-;;;;;;;;32887:75;32923:8;32933:4;32939:2;32943:3;32948:7;32957:4;32887:35;:75::i;45188:248::-;45359:68;;;-1:-1:-1;;;;;10516:15:1;;;45359:68:0;;;10498:34:1;10568:15;;10548:18;;;10541:43;10600:18;;;;10593:34;;;45359:68:0;;;;;;;;;;10433:18:1;;;;45359:68:0;;;;;;;;-1:-1:-1;;;;;45359:68:0;-1:-1:-1;;;45359:68:0;;;45332:96;;45352:5;;45332:19;:96::i;:::-;45188:248;;;;:::o;34288:569::-;-1:-1:-1;;;;;34441:16:0;;34433:62;;;;-1:-1:-1;;;34433:62:0;;22271:2:1;34433:62:0;;;22253:21:1;22310:2;22290:18;;;22283:30;22349:34;22329:18;;;22322:62;-1:-1:-1;;;22400:18:1;;;22393:31;22441:19;;34433:62:0;22243:223:1;34433:62:0;15004:10;34552:102;15004:10;34508:16;34595:2;34599:21;34617:2;34599:17;:21::i;:::-;34622:25;34640:6;34622:17;:25::i;34552:102::-;34667:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;34667:17:0;;;;;;;;;:27;;34688:6;;34667:13;:27;;34688:6;;34667:27;:::i;:::-;;;;-1:-1:-1;;34710:52:0;;;23515:25:1;;;23571:2;23556:18;;23549:34;;;-1:-1:-1;;;;;34710:52:0;;;;34743:1;;34710:52;;;;;;23488:18:1;34710:52:0;;;;;;;34775:74;34806:8;34824:1;34828:2;34832;34836:6;34844:4;34775:30;:74::i;52948:236::-;52998:7;53018:11;53131:6;53081:15;53098:10;53110:5;;53064:52;;;;;;;;;9040:19:1;;;9097:2;9093:15;;;;-1:-1:-1;;9089:53:1;9084:2;9075:12;;9068:75;9168:2;9159:12;;9152:28;9205:2;9196:12;;9030:184;53064:52:0;;;;;;;;;;;;;53054:63;;;;;;53032:96;;:105;;;;:::i;:::-;53148:5;:7;;53018:119;;-1:-1:-1;53148:5:0;:7;;;:::i;:::-;;;;-1:-1:-1;53173:3:0;;52948:236;-1:-1:-1;;;52948:236:0:o;17470:191::-;17544:16;17563:6;;-1:-1:-1;;;;;17580:17:0;;;-1:-1:-1;;;;;;17580:17:0;;;;;;17613:40;;17563:6;;;;;;;17613:40;;17544:16;17613:40;17533:128;17470:191;:::o;38082:331::-;38237:8;-1:-1:-1;;;;;38228:17:0;:5;-1:-1:-1;;;;;38228:17:0;;;38220:71;;;;-1:-1:-1;;;38220:71:0;;20631:2:1;38220:71:0;;;20613:21:1;20670:2;20650:18;;;20643:30;20709:34;20689:18;;;20682:62;-1:-1:-1;;;20760:18:1;;;20753:39;20809:19;;38220:71:0;20603:231:1;38220:71:0;-1:-1:-1;;;;;38302:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;38302:46:0;;;;;;;;;;38364:41;;12079::1;;;38364::0;;12052:18:1;38364:41:0;;;;;;;38082:331;;;:::o;36198:648::-;-1:-1:-1;;;;;36325:18:0;;36317:66;;;;-1:-1:-1;;;36317:66:0;;18344:2:1;36317:66:0;;;18326:21:1;18383:2;18363:18;;;18356:30;18422:34;18402:18;;;18395:62;-1:-1:-1;;;18473:18:1;;;18466:33;18516:19;;36317:66:0;18316:225:1;36317:66:0;15004:10;36440:102;15004:10;36471:4;36396:16;36489:21;36507:2;36489:17;:21::i;:::-;36512:25;36530:6;36512:17;:25::i;:::-;-1:-1:-1;;36440:102:0;;;;;;;;;-1:-1:-1;36440:102:0;;-1:-1:-1;;;49796:1438:0;36440:102;36555:19;36577:13;;;:9;:13;;;;;;;;-1:-1:-1;;;;;36577:19:0;;;;;;;;;;36615:21;;;;36607:70;;;;-1:-1:-1;;;36607:70:0;;14206:2:1;36607:70:0;;;14188:21:1;14245:2;14225:18;;;14218:30;14284:34;14264:18;;;14257:62;-1:-1:-1;;;14335:18:1;;;14328:34;14379:19;;36607:70:0;14178:226:1;36607:70:0;36713:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;36713:19:0;;;;;;;;;;;;36735:20;;;36713:42;;36784:54;;23515:25:1;;;23556:18;;;23549:34;;;36713:19:0;;36784:54;;;;;;23488:18:1;36784:54:0;;;;;;;36306:540;;36198:648;;;:::o;58497:147::-;58555:7;58585:1;58581;:5;58573:44;;;;-1:-1:-1;;;58573:44:0;;16128:2:1;58573:44:0;;;16110:21:1;16167:2;16147:18;;;16140:30;16206:28;16186:18;;;16179:56;16252:18;;58573:44:0;16100:176:1;58573:44:0;58633:5;58637:1;58633;:5;:::i;:::-;58626:12;58497:147;-1:-1:-1;;;58497:147:0:o;57837:210::-;57895:7;57917:6;57913:20;;-1:-1:-1;57932:1:0;57925:8;;57913:20;57942:9;57954:5;57958:1;57954;:5;:::i;:::-;57942:17;-1:-1:-1;57985:1:0;57976:5;57980:1;57942:17;57976:5;:::i;:::-;:10;57968:56;;;;-1:-1:-1;;;57968:56:0;;19159:2:1;57968:56:0;;;19141:21:1;19198:2;19178:18;;;19171:30;19237:34;19217:18;;;19210:62;-1:-1:-1;;;19288:18:1;;;19281:31;19329:19;;57968:56:0;19131:223:1;57450:152:0;57508:7;57539:1;57534;:6;;57526:49;;;;-1:-1:-1;;;57526:49:0;;15362:2:1;57526:49:0;;;15344:21:1;15401:2;15381:18;;;15374:30;15440:32;15420:18;;;15413:60;15490:18;;57526:49:0;15334:180:1;57526:49:0;57591:5;57595:1;57591;:5;:::i;30718:820::-;-1:-1:-1;;;;;30906:16:0;;30898:66;;;;-1:-1:-1;;;30898:66:0;;;;;;;:::i;:::-;15004:10;31021:96;15004:10;31052:4;31058:2;31062:21;31080:2;31062:17;:21::i;31021:96::-;31130:19;31152:13;;;:9;:13;;;;;;;;-1:-1:-1;;;;;31152:19:0;;;;;;;;;;31190:21;;;;31182:76;;;;-1:-1:-1;;;31182:76:0;;;;;;;:::i;:::-;31294:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;31294:19:0;;;;;;;;;;31316:20;;;31294:42;;31358:17;;;;;;;:27;;31316:20;;31294:13;31358:27;;31316:20;;31358:27;:::i;:::-;;;;-1:-1:-1;;31403:46:0;;;23515:25:1;;;23571:2;23556:18;;23549:34;;;-1:-1:-1;;;;;31403:46:0;;;;;;;;;;;;;;23488:18:1;31403:46:0;;;;;;;31462:68;31493:8;31503:4;31509:2;31513;31517:6;31525:4;31462:30;:68::i;:::-;30887:651;;30718:820;;;;;:::o;40350:813::-;-1:-1:-1;;;;;40590:13:0;;18811:20;18859:8;40586:570;;40626:79;;-1:-1:-1;;;40626:79:0;;-1:-1:-1;;;;;40626:43:0;;;;;:79;;40670:8;;40680:4;;40686:3;;40691:7;;40700:4;;40626:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40626:79:0;;;;;;;;-1:-1:-1;;40626:79:0;;;;;;;;;;;;:::i;:::-;;;40622:523;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;41018:6;41011:14;;-1:-1:-1;;;41011:14:0;;;;;;;;:::i;40622:523::-;;;41067:62;;-1:-1:-1;;;41067:62:0;;12557:2:1;41067:62:0;;;12539:21:1;12596:2;12576:18;;;12569:30;12635:34;12615:18;;;12608:62;-1:-1:-1;;;12686:18:1;;;12679:50;12746:19;;41067:62:0;12529:242:1;40622:523:0;-1:-1:-1;;;;;;40787:60:0;;-1:-1:-1;;;40787:60:0;40783:159;;40872:50;;-1:-1:-1;;;40872:50:0;;;;;;;:::i;47542:716::-;47966:23;47992:69;48020:4;47992:69;;;;;;;;;;;;;;;;;48000:5;-1:-1:-1;;;;;47992:27:0;;;:69;;;;;:::i;:::-;48076:17;;47966:95;;-1:-1:-1;48076:21:0;48072:179;;48173:10;48162:30;;;;;;;;;;;;:::i;:::-;48154:85;;;;-1:-1:-1;;;48154:85:0;;21041:2:1;48154:85:0;;;21023:21:1;21080:2;21060:18;;;21053:30;21119:34;21099:18;;;21092:62;-1:-1:-1;;;21170:18:1;;;21163:40;21220:19;;48154:85:0;21013:232:1;41171:198:0;41291:16;;;41305:1;41291:16;;;;;;;;;41237;;41266:22;;41291:16;;;;;;;;;;;;-1:-1:-1;41291:16:0;41266:41;;41329:7;41318:5;41324:1;41318:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;41356:5;41171:198;-1:-1:-1;;41171:198:0:o;39598:744::-;-1:-1:-1;;;;;39813:13:0;;18811:20;18859:8;39809:526;;39849:72;;-1:-1:-1;;;39849:72:0;;-1:-1:-1;;;;;39849:38:0;;;;;:72;;39888:8;;39898:4;;39904:2;;39908:6;;39916:4;;39849:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39849:72:0;;;;;;;;-1:-1:-1;;39849:72:0;;;;;;;;;;;;:::i;:::-;;;39845:479;;;;:::i;:::-;-1:-1:-1;;;;;;39971:55:0;;-1:-1:-1;;;39971:55:0;39967:154;;40051:50;;-1:-1:-1;;;40051:50:0;;;;;;;:::i;21294:229::-;21431:12;21463:52;21485:6;21493:4;21499:1;21502:12;21463:21;:52::i;:::-;21456:59;21294:229;-1:-1:-1;;;;21294:229:0:o;22414:510::-;22584:12;22642:5;22617:21;:30;;22609:81;;;;-1:-1:-1;;;22609:81:0;;15721:2:1;22609:81:0;;;15703:21:1;15760:2;15740:18;;;15733:30;15799:34;15779:18;;;15772:62;-1:-1:-1;;;15850:18:1;;;15843:36;15896:19;;22609:81:0;15693:228:1;22609:81:0;18811:20;;22701:60;;;;-1:-1:-1;;;22701:60:0;;20273:2:1;22701:60:0;;;20255:21:1;20312:2;20292:18;;;20285:30;20351:31;20331:18;;;20324:59;20400:18;;22701:60:0;20245:179:1;22701:60:0;22775:12;22789:23;22816:6;-1:-1:-1;;;;;22816:11:0;22835:5;22842:4;22816:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22774:73;;;;22865:51;22882:7;22891:10;22903:12;22865:16;:51::i;:::-;22858:58;22414:510;-1:-1:-1;;;;;;;22414:510:0:o;25100:712::-;25250:12;25279:7;25275:530;;;-1:-1:-1;25310:10:0;25303:17;;25275:530;25424:17;;:21;25420:374;;25622:10;25616:17;25683:15;25670:10;25666:2;25662:19;25655:44;25420:374;25765:12;25758:20;;-1:-1:-1;;;25758:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;111:2;63:124;;;:::o;192:735::-;246:5;299:3;292:4;284:6;280:17;276:27;266:2;;317:1;314;307:12;266:2;353:6;340:20;379:4;402:43;442:2;402:43;:::i;:::-;474:2;468:9;486:31;514:2;506:6;486:31;:::i;:::-;552:18;;;586:15;;;;-1:-1:-1;621:15:1;;;671:1;667:10;;;655:23;;651:32;;648:41;-1:-1:-1;645:2:1;;;702:1;699;692:12;645:2;724:1;734:163;748:2;745:1;742:9;734:163;;;805:17;;793:30;;843:12;;;;875;;;;766:1;759:9;734:163;;;-1:-1:-1;915:6:1;;256:671;-1:-1:-1;;;;;;;256:671:1:o;932:555::-;974:5;1027:3;1020:4;1012:6;1008:17;1004:27;994:2;;1045:1;1042;1035:12;994:2;1081:6;1068:20;1107:18;1103:2;1100:26;1097:2;;;1129:18;;:::i;:::-;1178:2;1172:9;1190:67;1245:2;1226:13;;-1:-1:-1;;1222:27:1;1251:4;1218:38;1172:9;1190:67;:::i;:::-;1281:2;1273:6;1266:18;1327:3;1320:4;1315:2;1307:6;1303:15;1299:26;1296:35;1293:2;;;1344:1;1341;1334:12;1293:2;1408;1401:4;1393:6;1389:17;1382:4;1374:6;1370:17;1357:54;1455:1;1431:15;;;1448:4;1427:26;1420:37;;;;1435:6;984:503;-1:-1:-1;;;984:503:1:o;1492:186::-;1551:6;1604:2;1592:9;1583:7;1579:23;1575:32;1572:2;;;1620:1;1617;1610:12;1572:2;1643:29;1662:9;1643:29;:::i;1683:260::-;1751:6;1759;1812:2;1800:9;1791:7;1787:23;1783:32;1780:2;;;1828:1;1825;1818:12;1780:2;1851:29;1870:9;1851:29;:::i;:::-;1841:39;;1899:38;1933:2;1922:9;1918:18;1899:38;:::i;:::-;1889:48;;1770:173;;;;;:::o;1948:943::-;2102:6;2110;2118;2126;2134;2187:3;2175:9;2166:7;2162:23;2158:33;2155:2;;;2204:1;2201;2194:12;2155:2;2227:29;2246:9;2227:29;:::i;:::-;2217:39;;2275:38;2309:2;2298:9;2294:18;2275:38;:::i;:::-;2265:48;;2364:2;2353:9;2349:18;2336:32;2387:18;2428:2;2420:6;2417:14;2414:2;;;2444:1;2441;2434:12;2414:2;2467:61;2520:7;2511:6;2500:9;2496:22;2467:61;:::i;:::-;2457:71;;2581:2;2570:9;2566:18;2553:32;2537:48;;2610:2;2600:8;2597:16;2594:2;;;2626:1;2623;2616:12;2594:2;2649:63;2704:7;2693:8;2682:9;2678:24;2649:63;:::i;:::-;2639:73;;2765:3;2754:9;2750:19;2737:33;2721:49;;2795:2;2785:8;2782:16;2779:2;;;2811:1;2808;2801:12;2779:2;;2834:51;2877:7;2866:8;2855:9;2851:24;2834:51;:::i;:::-;2824:61;;;2145:746;;;;;;;;:::o;2896:606::-;3000:6;3008;3016;3024;3032;3085:3;3073:9;3064:7;3060:23;3056:33;3053:2;;;3102:1;3099;3092:12;3053:2;3125:29;3144:9;3125:29;:::i;:::-;3115:39;;3173:38;3207:2;3196:9;3192:18;3173:38;:::i;:::-;3163:48;;3258:2;3247:9;3243:18;3230:32;3220:42;;3309:2;3298:9;3294:18;3281:32;3271:42;;3364:3;3353:9;3349:19;3336:33;3392:18;3384:6;3381:30;3378:2;;;3424:1;3421;3414:12;3378:2;3447:49;3488:7;3479:6;3468:9;3464:22;3447:49;:::i;3507:315::-;3572:6;3580;3633:2;3621:9;3612:7;3608:23;3604:32;3601:2;;;3649:1;3646;3639:12;3601:2;3672:29;3691:9;3672:29;:::i;:::-;3662:39;;3751:2;3740:9;3736:18;3723:32;3764:28;3786:5;3764:28;:::i;:::-;3811:5;3801:15;;;3591:231;;;;;:::o;3827:254::-;3895:6;3903;3956:2;3944:9;3935:7;3931:23;3927:32;3924:2;;;3972:1;3969;3962:12;3924:2;3995:29;4014:9;3995:29;:::i;:::-;3985:39;4071:2;4056:18;;;;4043:32;;-1:-1:-1;;;3914:167:1:o;4086:1219::-;4204:6;4212;4265:2;4253:9;4244:7;4240:23;4236:32;4233:2;;;4281:1;4278;4271:12;4233:2;4321:9;4308:23;4350:18;4391:2;4383:6;4380:14;4377:2;;;4407:1;4404;4397:12;4377:2;4445:6;4434:9;4430:22;4420:32;;4490:7;4483:4;4479:2;4475:13;4471:27;4461:2;;4512:1;4509;4502:12;4461:2;4548;4535:16;4570:4;4593:43;4633:2;4593:43;:::i;:::-;4665:2;4659:9;4677:31;4705:2;4697:6;4677:31;:::i;:::-;4743:18;;;4777:15;;;;-1:-1:-1;4812:11:1;;;4854:1;4850:10;;;4842:19;;4838:28;;4835:41;-1:-1:-1;4832:2:1;;;4889:1;4886;4879:12;4832:2;4911:1;4902:10;;4921:169;4935:2;4932:1;4929:9;4921:169;;;4992:23;5011:3;4992:23;:::i;:::-;4980:36;;4953:1;4946:9;;;;;5036:12;;;;5068;;4921:169;;;-1:-1:-1;5109:6:1;-1:-1:-1;;5153:18:1;;5140:32;;-1:-1:-1;;5184:16:1;;;5181:2;;;5213:1;5210;5203:12;5181:2;;5236:63;5291:7;5280:8;5269:9;5265:24;5236:63;:::i;:::-;5226:73;;;4223:1082;;;;;:::o;5310:348::-;5394:6;5447:2;5435:9;5426:7;5422:23;5418:32;5415:2;;;5463:1;5460;5453:12;5415:2;5503:9;5490:23;5536:18;5528:6;5525:30;5522:2;;;5568:1;5565;5558:12;5522:2;5591:61;5644:7;5635:6;5624:9;5620:22;5591:61;:::i;5663:1078::-;5756:6;5787:2;5830;5818:9;5809:7;5805:23;5801:32;5798:2;;;5846:1;5843;5836:12;5798:2;5879:9;5873:16;5912:18;5904:6;5901:30;5898:2;;;5944:1;5941;5934:12;5898:2;5967:22;;6020:4;6012:13;;6008:27;-1:-1:-1;5998:2:1;;6049:1;6046;6039:12;5998:2;6078;6072:9;6100:43;6140:2;6100:43;:::i;:::-;6172:2;6166:9;6184:31;6212:2;6204:6;6184:31;:::i;:::-;6250:18;;;6284:15;;;;-1:-1:-1;6319:11:1;;;6361:1;6357:10;;;6349:19;;6345:28;;6342:41;-1:-1:-1;6339:2:1;;;6396:1;6393;6386:12;6339:2;6418:1;6409:10;;6439:1;6449:261;6465:2;6460:3;6457:11;6449:261;;;6533:3;6527:10;6581:4;6574:5;6570:16;6563:5;6560:27;6550:2;;6601:1;6598;6591:12;6550:2;6618:18;;6656:12;;;;6688;;;;6487:1;6478:11;6449:261;;;-1:-1:-1;6729:6:1;;5767:974;-1:-1:-1;;;;;;;;5767:974:1:o;6746:245::-;6813:6;6866:2;6854:9;6845:7;6841:23;6837:32;6834:2;;;6882:1;6879;6872:12;6834:2;6914:9;6908:16;6933:28;6955:5;6933:28;:::i;6996:245::-;7054:6;7107:2;7095:9;7086:7;7082:23;7078:32;7075:2;;;7123:1;7120;7113:12;7075:2;7162:9;7149:23;7181:30;7205:5;7181:30;:::i;7246:249::-;7315:6;7368:2;7356:9;7347:7;7343:23;7339:32;7336:2;;;7384:1;7381;7374:12;7336:2;7416:9;7410:16;7435:30;7459:5;7435:30;:::i;7500:180::-;7559:6;7612:2;7600:9;7591:7;7587:23;7583:32;7580:2;;;7628:1;7625;7618:12;7580:2;-1:-1:-1;7651:23:1;;7570:110;-1:-1:-1;7570:110:1:o;7685:184::-;7755:6;7808:2;7796:9;7787:7;7783:23;7779:32;7776:2;;;7824:1;7821;7814:12;7776:2;-1:-1:-1;7847:16:1;;7766:103;-1:-1:-1;7766:103:1:o;7874:435::-;7927:3;7965:5;7959:12;7992:6;7987:3;7980:19;8018:4;8047:2;8042:3;8038:12;8031:19;;8084:2;8077:5;8073:14;8105:1;8115:169;8129:6;8126:1;8123:13;8115:169;;;8190:13;;8178:26;;8224:12;;;;8259:15;;;;8151:1;8144:9;8115:169;;;-1:-1:-1;8300:3:1;;7935:374;-1:-1:-1;;;;;7935:374:1:o;8314:257::-;8355:3;8393:5;8387:12;8420:6;8415:3;8408:19;8436:63;8492:6;8485:4;8480:3;8476:14;8469:4;8462:5;8458:16;8436:63;:::i;:::-;8553:2;8532:15;-1:-1:-1;;8528:29:1;8519:39;;;;8560:4;8515:50;;8363:208;-1:-1:-1;;8363:208:1:o;8576:274::-;8705:3;8743:6;8737:13;8759:53;8805:6;8800:3;8793:4;8785:6;8781:17;8759:53;:::i;:::-;8828:16;;;;;8713:137;-1:-1:-1;;8713:137:1:o;9427:826::-;-1:-1:-1;;;;;9824:15:1;;;9806:34;;9876:15;;9871:2;9856:18;;9849:43;9786:3;9923:2;9908:18;;9901:31;;;9749:4;;9955:57;;9992:19;;9984:6;9955:57;:::i;:::-;10060:9;10052:6;10048:22;10043:2;10032:9;10028:18;10021:50;10094:44;10131:6;10123;10094:44;:::i;:::-;10080:58;;10187:9;10179:6;10175:22;10169:3;10158:9;10154:19;10147:51;10215:32;10240:6;10232;10215:32;:::i;:::-;10207:40;9758:495;-1:-1:-1;;;;;;;;9758:495:1:o;10638:560::-;-1:-1:-1;;;;;10935:15:1;;;10917:34;;10987:15;;10982:2;10967:18;;10960:43;11034:2;11019:18;;11012:34;;;11077:2;11062:18;;11055:34;;;10897:3;11120;11105:19;;11098:32;;;10860:4;;11147:45;;11172:19;;11164:6;11147:45;:::i;11203:261::-;11382:2;11371:9;11364:21;11345:4;11402:56;11454:2;11443:9;11439:18;11431:6;11402:56;:::i;11469:465::-;11726:2;11715:9;11708:21;11689:4;11752:56;11804:2;11793:9;11789:18;11781:6;11752:56;:::i;:::-;11856:9;11848:6;11844:22;11839:2;11828:9;11824:18;11817:50;11884:44;11921:6;11913;11884:44;:::i;:::-;11876:52;11698:236;-1:-1:-1;;;;;11698:236:1:o;12131:219::-;12280:2;12269:9;12262:21;12243:4;12300:44;12340:2;12329:9;12325:18;12317:6;12300:44;:::i;12776:404::-;12978:2;12960:21;;;13017:2;12997:18;;;12990:30;13056:34;13051:2;13036:18;;13029:62;-1:-1:-1;;;13122:2:1;13107:18;;13100:38;13170:3;13155:19;;12950:230::o;16973:401::-;17175:2;17157:21;;;17214:2;17194:18;;;17187:30;17253:34;17248:2;17233:18;;17226:62;-1:-1:-1;;;17319:2:1;17304:18;;17297:35;17364:3;17349:19;;17147:227::o;18546:406::-;18748:2;18730:21;;;18787:2;18767:18;;;18760:30;18826:34;18821:2;18806:18;;18799:62;-1:-1:-1;;;18892:2:1;18877:18;;18870:40;18942:3;18927:19;;18720:232::o;19710:356::-;19912:2;19894:21;;;19931:18;;;19924:30;19990:34;19985:2;19970:18;;19963:62;20057:2;20042:18;;19884:182::o;23594:183::-;23654:4;23687:18;23679:6;23676:30;23673:2;;;23709:18;;:::i;:::-;-1:-1:-1;23754:1:1;23750:14;23766:4;23746:25;;23663:114::o;23782:128::-;23822:3;23853:1;23849:6;23846:1;23843:13;23840:2;;;23859:18;;:::i;:::-;-1:-1:-1;23895:9:1;;23830:80::o;23915:120::-;23955:1;23981;23971:2;;23986:18;;:::i;:::-;-1:-1:-1;24020:9:1;;23961:74::o;24040:168::-;24080:7;24146:1;24142;24138:6;24134:14;24131:1;24128:21;24123:1;24116:9;24109:17;24105:45;24102:2;;;24153:18;;:::i;:::-;-1:-1:-1;24193:9:1;;24092:116::o;24213:125::-;24253:4;24281:1;24278;24275:8;24272:2;;;24286:18;;:::i;:::-;-1:-1:-1;24323:9:1;;24262:76::o;24343:258::-;24415:1;24425:113;24439:6;24436:1;24433:13;24425:113;;;24515:11;;;24509:18;24496:11;;;24489:39;24461:2;24454:10;24425:113;;;24556:6;24553:1;24550:13;24547:2;;;-1:-1:-1;;24591:1:1;24573:16;;24566:27;24396:205::o;24606:380::-;24685:1;24681:12;;;;24728;;;24749:2;;24803:4;24795:6;24791:17;24781:27;;24749:2;24856;24848:6;24845:14;24825:18;24822:38;24819:2;;;24902:10;24897:3;24893:20;24890:1;24883:31;24937:4;24934:1;24927:15;24965:4;24962:1;24955:15;24819:2;;24661:325;;;:::o;24991:249::-;25101:2;25082:13;;-1:-1:-1;;25078:27:1;25066:40;;25136:18;25121:34;;25157:22;;;25118:62;25115:2;;;25183:18;;:::i;:::-;25219:2;25212:22;-1:-1:-1;;25038:202:1:o;25245:135::-;25284:3;-1:-1:-1;;25305:17:1;;25302:2;;;25325:18;;:::i;:::-;-1:-1:-1;25372:1:1;25361:13;;25292:88::o;25385:112::-;25417:1;25443;25433:2;;25448:18;;:::i;:::-;-1:-1:-1;25482:9:1;;25423:74::o;25502:127::-;25563:10;25558:3;25554:20;25551:1;25544:31;25594:4;25591:1;25584:15;25618:4;25615:1;25608:15;25634:127;25695:10;25690:3;25686:20;25683:1;25676:31;25726:4;25723:1;25716:15;25750:4;25747:1;25740:15;25766:127;25827:10;25822:3;25818:20;25815:1;25808:31;25858:4;25855:1;25848:15;25882:4;25879:1;25872:15;25898:127;25959:10;25954:3;25950:20;25947:1;25940:31;25990:4;25987:1;25980:15;26014:4;26011:1;26004:15;26030:179;26065:3;26107:1;26089:16;26086:23;26083:2;;;26153:1;26150;26147;26132:23;-1:-1:-1;26190:1:1;26184:8;26179:3;26175:18;26083:2;26073:136;:::o;26214:671::-;26253:3;26295:4;26277:16;26274:26;26271:2;;;26261:624;:::o;26271:2::-;26337;26331:9;-1:-1:-1;;26402:16:1;26398:25;;26395:1;26331:9;26374:50;26453:4;26447:11;26477:16;26512:18;26583:2;26576:4;26568:6;26564:17;26561:25;26556:2;26548:6;26545:14;26542:45;26539:2;;;26590:5;;;;;26261:624;:::o;26539:2::-;26627:6;26621:4;26617:17;26606:28;;26663:3;26657:10;26690:2;26682:6;26679:14;26676:2;;;26696:5;;;;;;26261:624;:::o;26676:2::-;26780;26761:16;26755:4;26751:27;26747:36;26740:4;26731:6;26726:3;26722:16;26718:27;26715:69;26712:2;;;26787:5;;;;;;26261:624;:::o;26712:2::-;26803:57;26854:4;26845:6;26837;26833:19;26829:30;26823:4;26803:57;:::i;:::-;-1:-1:-1;26876:3:1;;26261:624;-1:-1:-1;;;;;26261:624:1:o;26890:118::-;26976:5;26969:13;26962:21;26955:5;26952:32;26942:2;;26998:1;26995;26988:12;27013:131;-1:-1:-1;;;;;;27087:32:1;;27077:43;;27067:2;;27134:1;27131;27124:12

Swarm Source

ipfs://9ccaf5da6f730a83a5dc125290f88efc687c5de3d0063dc528bcff5fae0db9ed

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