Token

Beat Foundry Season Pass (BFSP)

ERC-1155

Overview

Max Total Supply

125 BFSP

Holders

123

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x868e599deb9fe07a808638bc7d4f2dac16eed218

Filtered by Token Holder

0x3d9456Ad6463a77bD77123Cb4836e463030bfAb4

Song A Day: Deployer

0x3d9456ad6463a77bd77123cb4836e463030bfab4

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

SeasonPass

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

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

    function _efficientHash(bytes32 a, bytes32 b)
        private
        pure
        returns (bytes32 value)
    {
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

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

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

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

/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
        public
        view
        virtual
        override
        returns (address, uint256)
    {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) /
            _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator)
        internal
        virtual
    {
        require(
            feeNumerator <= _feeDenominator(),
            "ERC2981: royalty fee will exceed salePrice"
        );
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `tokenId` must be already minted.
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(
            feeNumerator <= _feeDenominator(),
            "ERC2981: royalty fee will exceed salePrice"
        );
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * Slightly adjusted version of PaymentSplitter by OpenZeppelin
 *
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
contract PaymentSplitter is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event ERC20PaymentReleased(
        IERC20 indexed token,
        address to,
        uint256 amount
    );
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    mapping(IERC20 => uint256) private _erc20TotalReleased;
    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;

    /**
     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    constructor(address[] memory payees, uint256[] memory shares_) payable {
        require(
            payees.length == shares_.length,
            "PaymentSplitter: payees and shares length mismatch"
        );
        require(payees.length > 0, "PaymentSplitter: no payees");

        for (uint256 i = 0; i < payees.length; i++) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() public view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() public view returns (uint256) {
        return _totalReleased;
    }

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    function totalReleased(IERC20 token) public view returns (uint256) {
        return _erc20TotalReleased[token];
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) public view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) public view returns (uint256) {
        return _released[account];
    }

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    function released(IERC20 token, address account)
        public
        view
        returns (uint256)
    {
        return _erc20Released[token][account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) public view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = address(this).balance + totalReleased();
        uint256 payment = _pendingPayment(
            account,
            totalReceived,
            released(account)
        );

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _released[account] += payment;
        _totalReleased += payment;

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
     * contract.
     */
    function release(IERC20 token, address account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 totalReceived = token.balanceOf(address(this)) +
            totalReleased(token);
        uint256 payment = _pendingPayment(
            account,
            totalReceived,
            released(token, account)
        );

        require(payment != 0, "PaymentSplitter: account is not due payment");

        _erc20Released[token][account] += payment;
        _erc20TotalReleased[token] += payment;

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) private view returns (uint256) {
        return
            (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) internal {
        require(
            account != address(0),
            "PaymentSplitter: account is the zero address"
        );
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(
            _shares[account] == 0,
            "PaymentSplitter: account already has shares"
        );

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }

    /**
     * @dev Update a payee on the contract.
     * @param index The array index of the payee to update.
     * @param shares_ The number of shares owned by the payee.
     */
    function _updatePayee(uint256 index, uint256 shares_) internal {
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        uint256 temp = _shares[payee(index)];
        _shares[payee(index)] = shares_;
        _totalShares = _totalShares - temp + shares_;
    }

    /**
     * @dev Remove a payee from the contract.
     * @param index The array index of the payee to update.
     */
    function _removePayee(uint256 index) internal {
        uint256 temp = _shares[payee(index)];
        _shares[payee(index)] = 0;
        _payees[index] = _payees[_payees.length - 1];
        _payees.pop();
        _totalShares = _totalShares - temp;
    }
}

contract Royalties_V1_1 is PaymentSplitter, Ownable {
    constructor(
        address[] memory payees_,
        uint256[] memory shares_,
        address owner_
    ) PaymentSplitter(payees_, shares_) {
        transferOwnership(owner_);
    }

    function addPayee(address payee, uint256 shares) public onlyOwner {
        _addPayee(payee, shares);
    }

    function updatePayee(uint256 payeeIndex, uint256 shares) public onlyOwner {
        _updatePayee(payeeIndex, shares);
    }

    function removePayee(uint256 payeeIndex) public onlyOwner {
        _removePayee(payeeIndex);
    }
}

/**
 * @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();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits 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 {}

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

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

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

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

        return array;
    }
}

contract SeasonPass is ERC1155, ERC2981, Ownable, ReentrancyGuard {
    using Address for address payable;

    struct TokenType {
        uint256 price;
        uint256 usedSupply;
        uint256 maxSupply;
        bytes32 allowListMerkleRoot;
        string uri;
    }

    bool public isMintingEnabled;

    Royalties_V1_1 public immutable royaltyContract;

    mapping(uint256 => TokenType) _tokenTypes;
    mapping(address => mapping(uint256 => bool)) private _hasMinted;

    string public constant name = "Beat Foundry Season Pass";
    string public constant symbol = "BFSP";

    constructor(
        address[] memory royaltyReceivers_,
        uint256[] memory royaltyShares_,
        uint256 royaltyPercent_
    ) ERC1155("") {
        Royalties_V1_1 p = new Royalties_V1_1(
            royaltyReceivers_,
            royaltyShares_,
            msg.sender
        );
        royaltyContract = p;
        _setDefaultRoyalty(address(p), uint96(royaltyPercent_));
    }

    function setTokenType(
        uint256 _id,
        uint256 _price,
        uint256 _usedSupply,
        uint256 _maxSupply,
        bytes32 _allowListMerkleRoot,
        string memory _uri
    ) public onlyOwner {
        _tokenTypes[_id] = TokenType(
            _price,
            _usedSupply,
            _maxSupply,
            _allowListMerkleRoot,
            _uri
        );
    }

    function getUsedSupply(uint256 _id) public view returns (uint256) {
        return _tokenTypes[_id].usedSupply;
    }

    function getMaxSupply(uint256 _id) public view returns (uint256) {
        return _tokenTypes[_id].maxSupply;
    }

    function getPrice(uint256 _id) public view returns (uint256) {
        return _tokenTypes[_id].price;
    }

    function uri(uint256 it)
        public
        view
        virtual
        override
        returns (string memory)
    {
        return _tokenTypes[it].uri;
    }

    function setMintingEnabled(bool _canMint) public onlyOwner {
        isMintingEnabled = _canMint;
    }

    function mintToMany(address[] calldata _to, uint256 _id)
        external
        onlyOwner
    {
        require(
            _tokenTypes[_id].usedSupply + _to.length <
                _tokenTypes[_id].maxSupply,
            "BFSP: total supply used up"
        );
        for (uint256 i = 0; i < _to.length; ++i) {
            address to = _to[i];
            require(
                !_hasMinted[to][_id] && balanceOf(to, _id) == 0,
                "BFSP: cannot own more than one of a General Card"
            );
            _tokenTypes[_id].usedSupply++;
            _hasMinted[to][_id] = true;
            _mint(to, _id, 1, "");
        }
    }

    function mint(
        address to,
        uint256 id,
        bytes32[] calldata merkleProof
    ) external payable nonReentrant {
        require(isMintingEnabled, "BFSP: minting is disabled");
        require(
            _tokenTypes[id].usedSupply < _tokenTypes[id].maxSupply,
            "BFSP: total supply used up"
        );
        require(
            balanceOf(to, id) == 0 && !_hasMinted[to][id],
            "BFSP: cannot mint when already owned"
        );

        bool allowlisted = MerkleProof.verify(
            merkleProof,
            _tokenTypes[id].allowListMerkleRoot,
            keccak256(abi.encodePacked(msg.sender))
        );

        require(
            _tokenTypes[id].allowListMerkleRoot == bytes32(0) || allowlisted,
            "BFSP: not approved to mint"
        );

        require(
            msg.value == _tokenTypes[id].price,
            "BFSP: incorrect price or not approved"
        );

        _tokenTypes[id].usedSupply++;
        _hasMinted[to][id] = true;
        _mint(to, id, 1, bytes(""));
    }

    function withdraw(address payable to, uint256 amount) public onlyOwner {
        require(address(this).balance >= amount, "BFSP: InsufficientBalance");

        if (amount == 0) {
            amount = address(this).balance;
        }
        if (to == address(0)) {
            to = payable(owner());
        }
        to.sendValue(amount);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC1155, ERC2981)
        returns (bool)
    {
        // IERC165: 0x01ffc9a7, IERC721: 0x80ac58cd, IERC721Metadata: 0x5b5e139f, IERC29081: 0x2a55205a
        return
            ERC1155.supportsInterface(interfaceId) ||
            ERC2981.supportsInterface(interfaceId);
    }

    function _feeDenominator() internal pure override returns (uint96) {
        return 100;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address[]","name":"royaltyReceivers_","type":"address[]"},{"internalType":"uint256[]","name":"royaltyShares_","type":"uint256[]"},{"internalType":"uint256","name":"royaltyPercent_","type":"uint256"}],"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":[{"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":"uint256","name":"_id","type":"uint256"}],"name":"getMaxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getUsedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"isMintingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_to","type":"address[]"},{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"mintToMany","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"royaltyContract","outputs":[{"internalType":"contract Royalties_V1_1","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"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":"bool","name":"_canMint","type":"bool"}],"name":"setMintingEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_price","type":"uint256"},{"internalType":"uint256","name":"_usedSupply","type":"uint256"},{"internalType":"uint256","name":"_maxSupply","type":"uint256"},{"internalType":"bytes32","name":"_allowListMerkleRoot","type":"bytes32"},{"internalType":"string","name":"_uri","type":"string"}],"name":"setTokenType","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"it","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","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)

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000b7327099300682e0b5562e3be7ce226e6f17f500000000000000000000000072ed814ddc5f44510eb00ca8da3552b0bad6f69a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000005a000000000000000000000000000000000000000000000000000000000000000a

-----Decoded View---------------
Arg [0] : royaltyReceivers_ (address[]): 0x00b7327099300682E0B5562e3be7Ce226e6F17F5,0x72eD814ddc5F44510EB00cA8Da3552B0BAd6f69a
Arg [1] : royaltyShares_ (uint256[]): 90,10
Arg [2] : royaltyPercent_ (uint256): 10

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [4] : 00000000000000000000000000b7327099300682e0b5562e3be7ce226e6f17f5
Arg [5] : 00000000000000000000000072ed814ddc5f44510eb00ca8da3552b0bad6f69a
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [7] : 000000000000000000000000000000000000000000000000000000000000005a
Arg [8] : 000000000000000000000000000000000000000000000000000000000000000a

Deployed Bytecode Sourcemap

70555:4731:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54108:318;;;;;;;;;;-1:-1:-1;54108:318:0;;;;;:::i;:::-;;:::i;:::-;;;616:25:1;;;604:2;589:18;54108:318:0;;;;;;;;74783:396;;;;;;;;;;-1:-1:-1;74783:396:0;;;;;:::i;:::-;;:::i;:::-;;;1203:14:1;;1196:22;1178:41;;1166:2;1151:18;74783:396:0;1038:187:1;71056:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;72356:173::-;;;;;;;;;;-1:-1:-1;72356:173:0;;;;;:::i;:::-;;:::i;70880:47::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2312:32:1;;;2294:51;;2282:2;2267:18;70880:47:0;2117:234:1;9173:505:0;;;;;;;;;;-1:-1:-1;9173:505:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;2801:32:1;;;2783:51;;2865:2;2850:18;;2843:34;;;;2756:18;9173:505:0;2609:274:1;71575:404:0;;;;;;;;;;-1:-1:-1;71575:404:0;;;;;:::i;:::-;;:::i;:::-;;56253:442;;;;;;;;;;-1:-1:-1;56253:442:0;;;;;:::i;:::-;;:::i;54592:561::-;;;;;;;;;;-1:-1:-1;54592:561:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;72537:105::-;;;;;;;;;;-1:-1:-1;72537:105:0;;;;;:::i;:::-;;:::i;70843:28::-;;;;;;;;;;-1:-1:-1;70843:28:0;;;;;;;;72114:117;;;;;;;;;;-1:-1:-1;72114:117:0;;;;;:::i;:::-;72170:7;72197:16;;;:11;:16;;;;;:26;;;;72114:117;73328:1083;;;;;;:::i;:::-;;:::i;42019:103::-;;;;;;;;;;;;;:::i;72650:670::-;;;;;;;;;;-1:-1:-1;72650:670:0;;;;;:::i;:::-;;:::i;41368:87::-;;;;;;;;;;-1:-1:-1;41441:6:0;;-1:-1:-1;;;;;41441:6:0;41368:87;;71119:38;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;71119:38:0;;;;;55226:187;;;;;;;;;;-1:-1:-1;55226:187:0;;;;;:::i;:::-;;:::i;71987:119::-;;;;;;;;;;-1:-1:-1;71987:119:0;;;;;:::i;:::-;72044:7;72071:16;;;:11;:16;;;;;:27;;;;71987:119;72239:109;;;;;;;;;;-1:-1:-1;72239:109:0;;;;;:::i;:::-;72291:7;72318:16;;;:11;:16;;;;;:22;;72239:109;55485:218;;;;;;;;;;-1:-1:-1;55485:218:0;;;;;:::i;:::-;-1:-1:-1;;;;;55658:27:0;;;55629:4;55658:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;55485:218;55775:401;;;;;;;;;;-1:-1:-1;55775:401:0;;;;;:::i;:::-;;:::i;42277:238::-;;;;;;;;;;-1:-1:-1;42277:238:0;;;;;:::i;:::-;;:::i;74419:356::-;;;;;;;;;;-1:-1:-1;74419:356:0;;;;;:::i;:::-;;:::i;54108:318::-;54239:7;-1:-1:-1;;;;;54286:21:0;;54264:114;;;;-1:-1:-1;;;54264:114:0;;13073:2:1;54264:114:0;;;13055:21:1;13112:2;13092:18;;;13085:30;13151:34;13131:18;;;13124:62;-1:-1:-1;;;13202:18:1;;;13195:41;13253:19;;54264:114:0;;;;;;;;;-1:-1:-1;54396:9:0;:13;;;;;;;;;;;-1:-1:-1;;;;;54396:22:0;;;;;;;;;;;;54108:318::o;74783:396::-;74931:4;75078:38;75104:11;75078:25;:38::i;:::-;:93;;;;75133:38;75159:11;75133:25;:38::i;:::-;75058:113;74783:396;-1:-1:-1;;74783:396:0:o;72356:173::-;72502:15;;;;:11;:15;;;;;:19;;72495:26;;72464:13;;72502:19;72495:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72356:173;;;:::o;9173:505::-;9315:7;9378:27;;;:17;:27;;;;;;;;9349:56;;;;;;;;;-1:-1:-1;;;;;9349:56:0;;;;;-1:-1:-1;;;9349:56:0;;;-1:-1:-1;;;;;9349:56:0;;;;;;;;9315:7;;9418:92;;-1:-1:-1;9469:29:0;;;;;;;;;9479:19;9469:29;-1:-1:-1;;;;;9469:29:0;;;;-1:-1:-1;;;9469:29:0;;-1:-1:-1;;;;;9469:29:0;;;;;9418:92;9560:23;;;;9522:21;;75272:3;;9547:36;;-1:-1:-1;;;;;9547:36:0;:10;:36;:::i;:::-;9546:71;;;;:::i;:::-;9638:16;;;-1:-1:-1;9522:95:0;;-1:-1:-1;;9173:505:0;;;;;;:::o;71575:404::-;41441:6;;-1:-1:-1;;;;;41441:6:0;24396:10;41588:23;41580:68;;;;-1:-1:-1;;;41580:68:0;;;;;;;:::i;:::-;71825:146:::1;::::0;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;::::1;::::0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71806:16:0;;;:11:::1;:16:::0;;;;;;:165;;;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;71825:146;;71806:16;:165:::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;:::i;:::-;-1:-1:-1::0;;;;;;;;;71575:404:0:o;56253:442::-;-1:-1:-1;;;;;56486:20:0;;24396:10;56486:20;;:60;;-1:-1:-1;56510:36:0;56527:4;24396:10;55485:218;:::i;56510:36::-;56464:160;;;;-1:-1:-1;;;56464:160:0;;14758:2:1;56464:160:0;;;14740:21:1;14797:2;14777:18;;;14770:30;14836:34;14816:18;;;14809:62;-1:-1:-1;;;14887:18:1;;;14880:48;14945:19;;56464:160:0;14556:414:1;56464:160:0;56635:52;56658:4;56664:2;56668:3;56673:7;56682:4;56635:22;:52::i;:::-;56253:442;;;;;:::o;54592:561::-;54748:16;54823:3;:10;54804:8;:15;:29;54782:120;;;;-1:-1:-1;;;54782:120:0;;15177:2:1;54782:120:0;;;15159:21:1;15216:2;15196:18;;;15189:30;15255:34;15235:18;;;15228:62;-1:-1:-1;;;15306:18:1;;;15299:39;15355:19;;54782:120:0;14975:405:1;54782:120:0;54915:30;54962:8;:15;54948:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54948:30:0;;54915:63;;54996:9;54991:122;55015:8;:15;55011:1;:19;54991:122;;;55071:30;55081:8;55090:1;55081:11;;;;;;;;:::i;:::-;;;;;;;55094:3;55098:1;55094:6;;;;;;;;:::i;:::-;;;;;;;55071:9;:30::i;:::-;55052:13;55066:1;55052:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;55032:3;;;:::i;:::-;;;54991:122;;;-1:-1:-1;55132:13:0;54592:561;-1:-1:-1;;;54592:561:0:o;72537:105::-;41441:6;;-1:-1:-1;;;;;41441:6:0;24396:10;41588:23;41580:68;;;;-1:-1:-1;;;41580:68:0;;;;;;;:::i;:::-;72607:16:::1;:27:::0;;-1:-1:-1;;72607:27:0::1;::::0;::::1;;::::0;;;::::1;::::0;;72537:105::o;73328:1083::-;1713:1;2311:7;;:19;2303:63;;;;-1:-1:-1;;;2303:63:0;;15859:2:1;2303:63:0;;;15841:21:1;15898:2;15878:18;;;15871:30;15937:33;15917:18;;;15910:61;15988:18;;2303:63:0;15657:355:1;2303:63:0;1713:1;2444:7;:18;73481:16:::1;::::0;::::1;;73473:54;;;::::0;-1:-1:-1;;;73473:54:0;;16219:2:1;73473:54:0::1;::::0;::::1;16201:21:1::0;16258:2;16238:18;;;16231:30;16297:27;16277:18;;;16270:55;16342:18;;73473:54:0::1;16017:349:1::0;73473:54:0::1;73589:15;::::0;;;:11:::1;:15;::::0;;;;:25:::1;::::0;::::1;::::0;73560:26:::1;::::0;;::::1;::::0;:54:::1;73538:130;;;::::0;-1:-1:-1;;;73538:130:0;;16573:2:1;73538:130:0::1;::::0;::::1;16555:21:1::0;16612:2;16592:18;;;16585:30;16651:28;16631:18;;;16624:56;16697:18;;73538:130:0::1;16371:350:1::0;73538:130:0::1;73701:17;73711:2;73715;73701:9;:17::i;:::-;:22:::0;:45;::::1;;;-1:-1:-1::0;;;;;;73728:14:0;::::1;;::::0;;;:10:::1;:14;::::0;;;;;;;:18;;;;;;;;;::::1;;73727:19;73701:45;73679:131;;;::::0;-1:-1:-1;;;73679:131:0;;16928:2:1;73679:131:0::1;::::0;::::1;16910:21:1::0;16967:2;16947:18;;;16940:30;17006:34;16986:18;;;16979:62;-1:-1:-1;;;17057:18:1;;;17050:34;17101:19;;73679:131:0::1;16726:400:1::0;73679:131:0::1;73823:16;73842:159;73875:11;;73842:159;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;-1:-1:-1;73901:15:0;;;:11:::1;:15;::::0;;;;;;;;:35:::1;;::::0;73961:28;;73901:35;;-1:-1:-1;73961:28:0::1;::::0;-1:-1:-1;73978:10:0::1;::::0;-1:-1:-1;73961:28:0::1;17280:2:1::0;17276:15;;;;-1:-1:-1;;17272:53:1;17260:66;;17351:2;17342:12;;17131:229;73961:28:0::1;;;;;;;;;;;;;73951:39;;;;;;73842:18;:159::i;:::-;74083:1;74036:15:::0;;;:11:::1;:15;::::0;;;;:35:::1;;::::0;73823:178;;-1:-1:-1;74036:49:0;;:64:::1;;;74089:11;74036:64;74014:140;;;::::0;-1:-1:-1;;;74014:140:0;;17567:2:1;74014:140:0::1;::::0;::::1;17549:21:1::0;17606:2;17586:18;;;17579:30;17645:28;17625:18;;;17618:56;17691:18;;74014:140:0::1;17365:350:1::0;74014:140:0::1;74202:15;::::0;;;:11:::1;:15;::::0;;;;:21;74189:9:::1;:34;74167:121;;;::::0;-1:-1:-1;;;74167:121:0;;17922:2:1;74167:121:0::1;::::0;::::1;17904:21:1::0;17961:2;17941:18;;;17934:30;18000:34;17980:18;;;17973:62;-1:-1:-1;;;18051:18:1;;;18044:35;18096:19;;74167:121:0::1;17720:401:1::0;74167:121:0::1;74301:15;::::0;;;:11:::1;:15;::::0;;;;:26:::1;;:28:::0;;;::::1;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;74340:14:0;::::1;;::::0;;;:10:::1;:14;::::0;;;;;;;:18;;;;;;;;:25;;-1:-1:-1;;74340:25:0::1;74361:4;74340:25:::0;;::::1;::::0;;;74393:9;;;;::::1;::::0;;;;;;74376:27:::1;::::0;74351:2;;74355;;74361:4;74376:5:::1;:27::i;:::-;-1:-1:-1::0;;1669:1:0;2623:7;:22;-1:-1:-1;;;73328:1083:0:o;42019:103::-;41441:6;;-1:-1:-1;;;;;41441:6:0;24396:10;41588:23;41580:68;;;;-1:-1:-1;;;41580:68:0;;;;;;;:::i;:::-;42084:30:::1;42111:1;42084:18;:30::i;:::-;42019:103::o:0;72650:670::-;41441:6;;-1:-1:-1;;;;;41441:6:0;24396:10;41588:23;41580:68;;;;-1:-1:-1;;;41580:68:0;;;;;;;:::i;:::-;72842:16:::1;::::0;;;:11:::1;:16;::::0;;;;:26:::1;::::0;::::1;::::0;72782:27:::1;::::0;;::::1;::::0;:40:::1;::::0;72812:3;;72782:40:::1;:::i;:::-;:86;72760:162;;;::::0;-1:-1:-1;;;72760:162:0;;16573:2:1;72760:162:0::1;::::0;::::1;16555:21:1::0;16612:2;16592:18;;;16585:30;16651:28;16631:18;;;16624:56;16697:18;;72760:162:0::1;16371:350:1::0;72760:162:0::1;72938:9;72933:380;72953:14:::0;;::::1;72933:380;;;72989:10;73002:3;;73006:1;73002:6;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;73050:14:0;::::1;;::::0;;;:10:::1;:14;::::0;;;;;;;:19;;;;;;;;;72989;;-1:-1:-1;73050:19:0::1;;73049:20;:47:::0;::::1;;;;73073:18;73083:2;73087:3;73073:9;:18::i;:::-;:23:::0;73049:47:::1;73023:157;;;::::0;-1:-1:-1;;;73023:157:0;;18461:2:1;73023:157:0::1;::::0;::::1;18443:21:1::0;18500:2;18480:18;;;18473:30;18539:34;18519:18;;;18512:62;-1:-1:-1;;;18590:18:1;;;18583:46;18646:19;;73023:157:0::1;18259:412:1::0;73023:157:0::1;73195:16;::::0;;;:11:::1;:16;::::0;;;;:27:::1;;:29:::0;;;::::1;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;;;;;;73239:14:0;::::1;;::::0;;;:10:::1;:14;::::0;;;;;;;:19;;;;;;;;:26;;-1:-1:-1;;73239:26:0::1;73261:4;73239:26:::0;;::::1;::::0;;;73280:21;;;;::::1;::::0;;;;;;::::1;::::0;73250:2;;73254:3;;73261:4;73280:5:::1;:21::i;:::-;-1:-1:-1::0;72969:3:0::1;::::0;::::1;:::i;:::-;;;72933:380;;;;72650:670:::0;;;:::o;55226:187::-;55353:52;24396:10;55386:8;55396;55353:18;:52::i;:::-;55226:187;;:::o;55775:401::-;-1:-1:-1;;;;;55983:20:0;;24396:10;55983:20;;:60;;-1:-1:-1;56007:36:0;56024:4;24396:10;55485:218;:::i;56007:36::-;55961:151;;;;-1:-1:-1;;;55961:151:0;;18878:2:1;55961:151:0;;;18860:21:1;18917:2;18897:18;;;18890:30;18956:34;18936:18;;;18929:62;-1:-1:-1;;;19007:18:1;;;19000:39;19056:19;;55961:151:0;18676:405:1;55961:151:0;56123:45;56141:4;56147:2;56151;56155:6;56163:4;56123:17;:45::i;42277:238::-;41441:6;;-1:-1:-1;;;;;41441:6:0;24396:10;41588:23;41580:68;;;;-1:-1:-1;;;41580:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;42380:22:0;::::1;42358:110;;;::::0;-1:-1:-1;;;42358:110:0;;19288:2:1;42358:110:0::1;::::0;::::1;19270:21:1::0;19327:2;19307:18;;;19300:30;19366:34;19346:18;;;19339:62;-1:-1:-1;;;19417:18:1;;;19410:36;19463:19;;42358:110:0::1;19086:402:1::0;42358:110:0::1;42479:28;42498:8;42479:18;:28::i;:::-;42277:238:::0;:::o;74419:356::-;41441:6;;-1:-1:-1;;;;;41441:6:0;24396:10;41588:23;41580:68;;;;-1:-1:-1;;;41580:68:0;;;;;;;:::i;:::-;74534:6:::1;74509:21;:31;;74501:69;;;::::0;-1:-1:-1;;;74501:69:0;;19695:2:1;74501:69:0::1;::::0;::::1;19677:21:1::0;19734:2;19714:18;;;19707:30;19773:27;19753:18;;;19746:55;19818:18;;74501:69:0::1;19493:349:1::0;74501:69:0::1;74587:6;74597:1;74587:11:::0;74583:74:::1;;-1:-1:-1::0;74624:21:0::1;74583:74;-1:-1:-1::0;;;;;74671:16:0;::::1;74667:70;;41441:6:::0;;-1:-1:-1;;;;;41441:6:0;74704:21:::1;;74667:70;74747:20;-1:-1:-1::0;;;;;74747:12:0;::::1;74760:6:::0;74747:12:::1;:20::i;53081:360::-:0;53228:4;-1:-1:-1;;;;;;53270:41:0;;-1:-1:-1;;;53270:41:0;;:110;;-1:-1:-1;;;;;;;53328:52:0;;-1:-1:-1;;;53328:52:0;53270:110;:163;;;-1:-1:-1;;;;;;;;;;7558:40:0;;;53397:36;7399:207;8827:291;8974:4;-1:-1:-1;;;;;;9016:41:0;;-1:-1:-1;;;9016:41:0;;:94;;;9074:36;9098:11;9074:23;:36::i;58528:1321::-;58769:7;:14;58755:3;:10;:28;58733:118;;;;-1:-1:-1;;;58733:118:0;;20049:2:1;58733:118:0;;;20031:21:1;20088:2;20068:18;;;20061:30;20127:34;20107:18;;;20100:62;-1:-1:-1;;;20178:18:1;;;20171:38;20226:19;;58733:118:0;19847:404:1;58733:118:0;-1:-1:-1;;;;;58870:16:0;;58862:66;;;;-1:-1:-1;;;58862:66:0;;;;;;;:::i;:::-;24396:10;58941:16;59058:470;59082:3;:10;59078:1;:14;59058:470;;;59114:10;59127:3;59131:1;59127:6;;;;;;;;:::i;:::-;;;;;;;59114:19;;59148:14;59165:7;59173:1;59165:10;;;;;;;;:::i;:::-;;;;;;;;;;;;59192:19;59214:13;;;;;;;;;;-1:-1:-1;;;;;59214:19:0;;;;;;;;;;;;59165:10;;-1:-1:-1;59274:21:0;;;;59248:125;;;;-1:-1:-1;;;59248:125:0;;;;;;;:::i;:::-;59417:9;:13;;;;;;;;;;;-1:-1:-1;;;;;59417:19:0;;;;;;;;;;59439:20;;;59417:42;;59489:17;;;;;;;:27;;59439:20;;59417:9;59489:27;;59439:20;;59489:27;:::i;:::-;;;;;;;;59099:429;;;59094:3;;;;:::i;:::-;;;59058:470;;;;59575:2;-1:-1:-1;;;;;59545:47:0;59569:4;-1:-1:-1;;;;;59545:47:0;59559:8;-1:-1:-1;;;;;59545:47:0;;59579:3;59584:7;59545:47;;;;;;;:::i;:::-;;;;;;;;59677:164;59727:8;59750:4;59769:2;59786:3;59804:7;59826:4;59677:35;:164::i;:::-;58722:1127;58528:1321;;;;;:::o;3692:190::-;3817:4;3870;3841:25;3854:5;3861:4;3841:12;:25::i;:::-;:33;;3692:190;-1:-1:-1;;;;3692:190:0:o;61167:818::-;-1:-1:-1;;;;;61320:16:0;;61312:62;;;;-1:-1:-1;;;61312:62:0;;21745:2:1;61312:62:0;;;21727:21:1;21784:2;21764:18;;;21757:30;21823:34;21803:18;;;21796:62;-1:-1:-1;;;21874:18:1;;;21867:31;21915:19;;61312:62:0;21543:397:1;61312:62:0;24396:10;61387:16;61452:21;61470:2;61452:17;:21::i;:::-;61429:44;;61484:24;61511:25;61529:6;61511:17;:25::i;:::-;61484:52;;61628:9;:13;;;;;;;;;;;-1:-1:-1;;;;;61628:17:0;;;;;;;;;:27;;61649:6;;61628:9;:27;;61649:6;;61628:27;:::i;:::-;;;;-1:-1:-1;;61671:52:0;;;22119:25:1;;;22175:2;22160:18;;22153:34;;;-1:-1:-1;;;;;61671:52:0;;;;61704:1;;61671:52;;;;;;22092:18:1;61671:52:0;;;;;;;61814:163;61859:8;61890:1;61907:2;61924;61941:6;61962:4;61814:30;:163::i;:::-;61301:684;;;61167:818;;;;:::o;42675:191::-;42768:6;;;-1:-1:-1;;;;;42785:17:0;;;-1:-1:-1;;;;;;42785:17:0;;;;;;;42818:40;;42768:6;;;42785:17;42768:6;;42818:40;;42749:16;;42818:40;42738:128;42675:191;:::o;65738:331::-;65893:8;-1:-1:-1;;;;;65884:17:0;:5;-1:-1:-1;;;;;65884:17:0;;65876:71;;;;-1:-1:-1;;;65876:71:0;;22400:2:1;65876:71:0;;;22382:21:1;22439:2;22419:18;;;22412:30;22478:34;22458:18;;;22451:62;-1:-1:-1;;;22529:18:1;;;22522:39;22578:19;;65876:71:0;22198:405:1;65876:71:0;-1:-1:-1;;;;;65958:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;65958:46:0;;;;;;;;;;66020:41;;1178::1;;;66020::0;;1151:18:1;66020:41:0;;;;;;;65738:331;;;:::o;57159:1011::-;-1:-1:-1;;;;;57347:16:0;;57339:66;;;;-1:-1:-1;;;57339:66:0;;;;;;;:::i;:::-;24396:10;57418:16;57483:21;57501:2;57483:17;:21::i;:::-;57460:44;;57515:24;57542:25;57560:6;57542:17;:25::i;:::-;57515:52;;57653:19;57675:13;;;;;;;;;;;-1:-1:-1;;;;;57675:19:0;;;;;;;;;;57727:21;;;;57705:113;;;;-1:-1:-1;;;57705:113:0;;;;;;;:::i;:::-;57854:9;:13;;;;;;;;;;;-1:-1:-1;;;;;57854:19:0;;;;;;;;;;57876:20;;;57854:42;;57918:17;;;;;;;:27;;57876:20;;57854:9;57918:27;;57876:20;;57918:27;:::i;:::-;;;;-1:-1:-1;;57963:46:0;;;22119:25:1;;;22175:2;22160:18;;22153:34;;;-1:-1:-1;;;;;57963:46:0;;;;;;;;;;;;;;22092:18:1;57963:46:0;;;;;;;58094:68;58125:8;58135:4;58141:2;58145;58149:6;58157:4;58094:30;:68::i;26870:391::-;26999:6;26974:21;:31;;26952:110;;;;-1:-1:-1;;;26952:110:0;;22810:2:1;26952:110:0;;;22792:21:1;22849:2;22829:18;;;22822:30;22888:31;22868:18;;;22861:59;22937:18;;26952:110:0;22608:353:1;26952:110:0;27076:12;27094:9;-1:-1:-1;;;;;27094:14:0;27116:6;27094:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27075:52;;;27160:7;27138:115;;;;-1:-1:-1;;;27138:115:0;;23378:2:1;27138:115:0;;;23360:21:1;23417:2;23397:18;;;23390:30;23456:34;23436:18;;;23429:62;23527:28;23507:18;;;23500:56;23573:19;;27138:115:0;23176:422:1;27138:115:0;26941:320;26870:391;;:::o;69335:975::-;-1:-1:-1;;;;;69575:13:0;;25904:19;:23;69571:732;;69628:203;;-1:-1:-1;;;69628:203:0;;-1:-1:-1;;;;;69628:43:0;;;;;:203;;69694:8;;69725:4;;69752:3;;69778:7;;69808:4;;69628:203;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69628:203:0;;;;;;;;-1:-1:-1;;69628:203:0;;;;;;;;;;;;:::i;:::-;;;69607:685;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;70165:6;70158:14;;-1:-1:-1;;;70158:14:0;;;;;;;;:::i;69607:685::-;;;70214:62;;-1:-1:-1;;;70214:62:0;;25751:2:1;70214:62:0;;;25733:21:1;25790:2;25770:18;;;25763:30;25829:34;25809:18;;;25802:62;-1:-1:-1;;;25880:18:1;;;25873:50;25940:19;;70214:62:0;25549:416:1;69607:685:0;-1:-1:-1;;;;;;69916:60:0;;-1:-1:-1;;;69916:60:0;69890:199;;70019:50;;-1:-1:-1;;;70019:50:0;;;;;;;:::i;4243:707::-;4353:7;4401:4;4353:7;4416:497;4440:5;:12;4436:1;:16;4416:497;;;4474:20;4497:5;4503:1;4497:8;;;;;;;;:::i;:::-;;;;;;;4474:31;;4540:12;4524;:28;4520:382;;5053:13;5108:15;;;5144:4;5137:15;;;5191:4;5175:21;;4652:57;;4520:382;;;5053:13;5108:15;;;5144:4;5137:15;;;5191:4;5175:21;;4829:57;;4520:382;-1:-1:-1;4454:3:0;;;;:::i;:::-;;;;4416:497;;70318:230;70470:16;;;70484:1;70470:16;;;;;;;;;70411;;70445:22;;70470:16;;;;;;;;;;;;-1:-1:-1;70470:16:0;70445:41;;70508:7;70497:5;70503:1;70497:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;70535:5;70318:230;-1:-1:-1;;70318:230:0:o;68429:898::-;-1:-1:-1;;;;;68644:13:0;;25904:19;:23;68640:680;;68697:196;;-1:-1:-1;;;68697:196:0;;-1:-1:-1;;;;;68697:38:0;;;;;:196;;68758:8;;68789:4;;68816:2;;68841:6;;68870:4;;68697:196;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68697:196:0;;;;;;;;-1:-1:-1;;68697:196:0;;;;;;;;;;;;:::i;:::-;;;68676:633;;;;:::i;:::-;-1:-1:-1;;;;;;68956:55:0;;-1:-1:-1;;;68956:55:0;68952:154;;69036:50;;-1:-1:-1;;;69036:50:0;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;150:315;218:6;226;279:2;267:9;258:7;254:23;250:32;247:52;;;295:1;292;285:12;247:52;334:9;321:23;353:31;378:5;353:31;:::i;:::-;403:5;455:2;440:18;;;;427:32;;-1:-1:-1;;;150:315:1:o;652:131::-;-1:-1:-1;;;;;;726:32:1;;716:43;;706:71;;773:1;770;763:12;788:245;846:6;899:2;887:9;878:7;874:23;870:32;867:52;;;915:1;912;905:12;867:52;954:9;941:23;973:30;997:5;973:30;:::i;:::-;1022:5;788:245;-1:-1:-1;;;788:245:1:o;1230:472::-;1272:3;1310:5;1304:12;1337:6;1332:3;1325:19;1362:1;1372:162;1386:6;1383:1;1380:13;1372:162;;;1448:4;1504:13;;;1500:22;;1494:29;1476:11;;;1472:20;;1465:59;1401:12;1372:162;;;1552:6;1549:1;1546:13;1543:87;;;1618:1;1611:4;1602:6;1597:3;1593:16;1589:27;1582:38;1543:87;-1:-1:-1;1684:2:1;1663:15;-1:-1:-1;;1659:29:1;1650:39;;;;1691:4;1646:50;;1230:472;-1:-1:-1;;1230:472:1:o;1707:220::-;1856:2;1845:9;1838:21;1819:4;1876:45;1917:2;1906:9;1902:18;1894:6;1876:45;:::i;1932:180::-;1991:6;2044:2;2032:9;2023:7;2019:23;2015:32;2012:52;;;2060:1;2057;2050:12;2012:52;-1:-1:-1;2083:23:1;;1932:180;-1:-1:-1;1932:180:1:o;2356:248::-;2424:6;2432;2485:2;2473:9;2464:7;2460:23;2456:32;2453:52;;;2501:1;2498;2491:12;2453:52;-1:-1:-1;;2524:23:1;;;2594:2;2579:18;;;2566:32;;-1:-1:-1;2356:248:1:o;2888:127::-;2949:10;2944:3;2940:20;2937:1;2930:31;2980:4;2977:1;2970:15;3004:4;3001:1;2994:15;3020:249;3130:2;3111:13;;-1:-1:-1;;3107:27:1;3095:40;;3165:18;3150:34;;3186:22;;;3147:62;3144:88;;;3212:18;;:::i;:::-;3248:2;3241:22;-1:-1:-1;;3020:249:1:o;3274:469::-;3339:5;3373:18;3365:6;3362:30;3359:56;;;3395:18;;:::i;:::-;3444:2;3438:9;3456:69;3513:2;3492:15;;-1:-1:-1;;3488:29:1;3519:4;3484:40;3438:9;3456:69;:::i;:::-;3543:6;3534:15;;3573:6;3565;3558:22;3613:3;3604:6;3599:3;3595:16;3592:25;3589:45;;;3630:1;3627;3620:12;3589:45;3680:6;3675:3;3668:4;3660:6;3656:17;3643:44;3735:1;3728:4;3719:6;3711;3707:19;3703:30;3696:41;;3274:469;;;;;:::o;3748:794::-;3862:6;3870;3878;3886;3894;3902;3955:3;3943:9;3934:7;3930:23;3926:33;3923:53;;;3972:1;3969;3962:12;3923:53;4008:9;3995:23;3985:33;;4065:2;4054:9;4050:18;4037:32;4027:42;;4116:2;4105:9;4101:18;4088:32;4078:42;;4167:2;4156:9;4152:18;4139:32;4129:42;;4218:3;4207:9;4203:19;4190:33;4180:43;;4274:3;4263:9;4259:19;4246:33;4302:18;4294:6;4291:30;4288:50;;;4334:1;4331;4324:12;4288:50;4357:22;;4410:4;4402:13;;4398:27;-1:-1:-1;4388:55:1;;4439:1;4436;4429:12;4388:55;4462:74;4528:7;4523:2;4510:16;4505:2;4501;4497:11;4462:74;:::i;:::-;4452:84;;;3748:794;;;;;;;;:::o;4547:183::-;4607:4;4640:18;4632:6;4629:30;4626:56;;;4662:18;;:::i;:::-;-1:-1:-1;4707:1:1;4703:14;4719:4;4699:25;;4547:183::o;4735:724::-;4789:5;4842:3;4835:4;4827:6;4823:17;4819:27;4809:55;;4860:1;4857;4850:12;4809:55;4896:6;4883:20;4922:4;4945:43;4985:2;4945:43;:::i;:::-;5017:2;5011:9;5029:31;5057:2;5049:6;5029:31;:::i;:::-;5095:18;;;5187:1;5183:10;;;;5171:23;;5167:32;;;5129:15;;;;-1:-1:-1;5211:15:1;;;5208:35;;;5239:1;5236;5229:12;5208:35;5275:2;5267:6;5263:15;5287:142;5303:6;5298:3;5295:15;5287:142;;;5369:17;;5357:30;;5407:12;;;;5320;;5287:142;;;-1:-1:-1;5447:6:1;4735:724;-1:-1:-1;;;;;;4735:724:1:o;5464:221::-;5506:5;5559:3;5552:4;5544:6;5540:17;5536:27;5526:55;;5577:1;5574;5567:12;5526:55;5599:80;5675:3;5666:6;5653:20;5646:4;5638:6;5634:17;5599:80;:::i;5690:1071::-;5844:6;5852;5860;5868;5876;5929:3;5917:9;5908:7;5904:23;5900:33;5897:53;;;5946:1;5943;5936:12;5897:53;5985:9;5972:23;6004:31;6029:5;6004:31;:::i;:::-;6054:5;-1:-1:-1;6111:2:1;6096:18;;6083:32;6124:33;6083:32;6124:33;:::i;:::-;6176:7;-1:-1:-1;6234:2:1;6219:18;;6206:32;6257:18;6287:14;;;6284:34;;;6314:1;6311;6304:12;6284:34;6337:61;6390:7;6381:6;6370:9;6366:22;6337:61;:::i;:::-;6327:71;;6451:2;6440:9;6436:18;6423:32;6407:48;;6480:2;6470:8;6467:16;6464:36;;;6496:1;6493;6486:12;6464:36;6519:63;6574:7;6563:8;6552:9;6548:24;6519:63;:::i;:::-;6509:73;;6635:3;6624:9;6620:19;6607:33;6591:49;;6665:2;6655:8;6652:16;6649:36;;;6681:1;6678;6671:12;6649:36;;6704:51;6747:7;6736:8;6725:9;6721:24;6704:51;:::i;:::-;6694:61;;;5690:1071;;;;;;;;:::o;6766:1277::-;6884:6;6892;6945:2;6933:9;6924:7;6920:23;6916:32;6913:52;;;6961:1;6958;6951:12;6913:52;7001:9;6988:23;7030:18;7071:2;7063:6;7060:14;7057:34;;;7087:1;7084;7077:12;7057:34;7125:6;7114:9;7110:22;7100:32;;7170:7;7163:4;7159:2;7155:13;7151:27;7141:55;;7192:1;7189;7182:12;7141:55;7228:2;7215:16;7250:4;7273:43;7313:2;7273:43;:::i;:::-;7345:2;7339:9;7357:31;7385:2;7377:6;7357:31;:::i;:::-;7423:18;;;7511:1;7507:10;;;;7499:19;;7495:28;;;7457:15;;;;-1:-1:-1;7535:19:1;;;7532:39;;;7567:1;7564;7557:12;7532:39;7591:11;;;;7611:217;7627:6;7622:3;7619:15;7611:217;;;7707:3;7694:17;7724:31;7749:5;7724:31;:::i;:::-;7768:18;;7644:12;;;;7806;;;;7611:217;;;7847:6;-1:-1:-1;;7891:18:1;;7878:32;;-1:-1:-1;;7922:16:1;;;7919:36;;;7951:1;7948;7941:12;7919:36;;7974:63;8029:7;8018:8;8007:9;8003:24;7974:63;:::i;:::-;7964:73;;;6766:1277;;;;;:::o;8048:435::-;8101:3;8139:5;8133:12;8166:6;8161:3;8154:19;8192:4;8221:2;8216:3;8212:12;8205:19;;8258:2;8251:5;8247:14;8279:1;8289:169;8303:6;8300:1;8297:13;8289:169;;;8364:13;;8352:26;;8398:12;;;;8433:15;;;;8325:1;8318:9;8289:169;;;-1:-1:-1;8474:3:1;;8048:435;-1:-1:-1;;;;;8048:435:1:o;8488:261::-;8667:2;8656:9;8649:21;8630:4;8687:56;8739:2;8728:9;8724:18;8716:6;8687:56;:::i;8754:160::-;8819:20;;8875:13;;8868:21;8858:32;;8848:60;;8904:1;8901;8894:12;8848:60;8754:160;;;:::o;8919:180::-;8975:6;9028:2;9016:9;9007:7;9003:23;8999:32;8996:52;;;9044:1;9041;9034:12;8996:52;9067:26;9083:9;9067:26;:::i;9104:367::-;9167:8;9177:6;9231:3;9224:4;9216:6;9212:17;9208:27;9198:55;;9249:1;9246;9239:12;9198:55;-1:-1:-1;9272:20:1;;9315:18;9304:30;;9301:50;;;9347:1;9344;9337:12;9301:50;9384:4;9376:6;9372:17;9360:29;;9444:3;9437:4;9427:6;9424:1;9420:14;9412:6;9408:27;9404:38;9401:47;9398:67;;;9461:1;9458;9451:12;9476:640;9580:6;9588;9596;9604;9657:2;9645:9;9636:7;9632:23;9628:32;9625:52;;;9673:1;9670;9663:12;9625:52;9712:9;9699:23;9731:31;9756:5;9731:31;:::i;:::-;9781:5;-1:-1:-1;9833:2:1;9818:18;;9805:32;;-1:-1:-1;9888:2:1;9873:18;;9860:32;9915:18;9904:30;;9901:50;;;9947:1;9944;9937:12;9901:50;9986:70;10048:7;10039:6;10028:9;10024:22;9986:70;:::i;:::-;9476:640;;;;-1:-1:-1;10075:8:1;-1:-1:-1;;;;9476:640:1:o;10121:505::-;10216:6;10224;10232;10285:2;10273:9;10264:7;10260:23;10256:32;10253:52;;;10301:1;10298;10291:12;10253:52;10341:9;10328:23;10374:18;10366:6;10363:30;10360:50;;;10406:1;10403;10396:12;10360:50;10445:70;10507:7;10498:6;10487:9;10483:22;10445:70;:::i;:::-;10534:8;;10419:96;;-1:-1:-1;10616:2:1;10601:18;;;;10588:32;;10121:505;-1:-1:-1;;;;10121:505:1:o;10839:315::-;10904:6;10912;10965:2;10953:9;10944:7;10940:23;10936:32;10933:52;;;10981:1;10978;10971:12;10933:52;11020:9;11007:23;11039:31;11064:5;11039:31;:::i;:::-;11089:5;-1:-1:-1;11113:35:1;11144:2;11129:18;;11113:35;:::i;:::-;11103:45;;10839:315;;;;;:::o;11159:388::-;11227:6;11235;11288:2;11276:9;11267:7;11263:23;11259:32;11256:52;;;11304:1;11301;11294:12;11256:52;11343:9;11330:23;11362:31;11387:5;11362:31;:::i;:::-;11412:5;-1:-1:-1;11469:2:1;11454:18;;11441:32;11482:33;11441:32;11482:33;:::i;:::-;11534:7;11524:17;;;11159:388;;;;;:::o;11552:734::-;11656:6;11664;11672;11680;11688;11741:3;11729:9;11720:7;11716:23;11712:33;11709:53;;;11758:1;11755;11748:12;11709:53;11797:9;11784:23;11816:31;11841:5;11816:31;:::i;:::-;11866:5;-1:-1:-1;11923:2:1;11908:18;;11895:32;11936:33;11895:32;11936:33;:::i;:::-;11988:7;-1:-1:-1;12042:2:1;12027:18;;12014:32;;-1:-1:-1;12093:2:1;12078:18;;12065:32;;-1:-1:-1;12148:3:1;12133:19;;12120:33;12176:18;12165:30;;12162:50;;;12208:1;12205;12198:12;12162:50;12231:49;12272:7;12263:6;12252:9;12248:22;12231:49;:::i;12291:247::-;12350:6;12403:2;12391:9;12382:7;12378:23;12374:32;12371:52;;;12419:1;12416;12409:12;12371:52;12458:9;12445:23;12477:31;12502:5;12477:31;:::i;13283:380::-;13362:1;13358:12;;;;13405;;;13426:61;;13480:4;13472:6;13468:17;13458:27;;13426:61;13533:2;13525:6;13522:14;13502:18;13499:38;13496:161;;13579:10;13574:3;13570:20;13567:1;13560:31;13614:4;13611:1;13604:15;13642:4;13639:1;13632:15;13496:161;;13283:380;;;:::o;13668:127::-;13729:10;13724:3;13720:20;13717:1;13710:31;13760:4;13757:1;13750:15;13784:4;13781:1;13774:15;13800:168;13840:7;13906:1;13902;13898:6;13894:14;13891:1;13888:21;13883:1;13876:9;13869:17;13865:45;13862:71;;;13913:18;;:::i;:::-;-1:-1:-1;13953:9:1;;13800:168::o;13973:217::-;14013:1;14039;14029:132;;14083:10;14078:3;14074:20;14071:1;14064:31;14118:4;14115:1;14108:15;14146:4;14143:1;14136:15;14029:132;-1:-1:-1;14175:9:1;;13973:217::o;14195:356::-;14397:2;14379:21;;;14416:18;;;14409:30;14475:34;14470:2;14455:18;;14448:62;14542:2;14527:18;;14195:356::o;15385:127::-;15446:10;15441:3;15437:20;15434:1;15427:31;15477:4;15474:1;15467:15;15501:4;15498:1;15491:15;15517:135;15556:3;15577:17;;;15574:43;;15597:18;;:::i;:::-;-1:-1:-1;15644:1:1;15633:13;;15517:135::o;18126:128::-;18166:3;18197:1;18193:6;18190:1;18187:13;18184:39;;;18203:18;;:::i;:::-;-1:-1:-1;18239:9:1;;18126:128::o;20256:401::-;20458:2;20440:21;;;20497:2;20477:18;;;20470:30;20536:34;20531:2;20516:18;;20509:62;-1:-1:-1;;;20602:2:1;20587:18;;20580:35;20647:3;20632:19;;20256:401::o;20662:406::-;20864:2;20846:21;;;20903:2;20883:18;;;20876:30;20942:34;20937:2;20922:18;;20915:62;-1:-1:-1;;;21008:2:1;20993:18;;20986:40;21058:3;21043:19;;20662:406::o;21073:465::-;21330:2;21319:9;21312:21;21293:4;21356:56;21408:2;21397:9;21393:18;21385:6;21356:56;:::i;:::-;21460:9;21452:6;21448:22;21443:2;21432:9;21428:18;21421:50;21488:44;21525:6;21517;21488:44;:::i;:::-;21480:52;21073:465;-1:-1:-1;;;;;21073:465:1:o;23603:827::-;-1:-1:-1;;;;;24000:15:1;;;23982:34;;24052:15;;24047:2;24032:18;;24025:43;23962:3;24099:2;24084:18;;24077:31;;;23925:4;;24131:57;;24168:19;;24160:6;24131:57;:::i;:::-;24236:9;24228:6;24224:22;24219:2;24208:9;24204:18;24197:50;24270:44;24307:6;24299;24270:44;:::i;:::-;24256:58;;24363:9;24355:6;24351:22;24345:3;24334:9;24330:19;24323:51;24391:33;24417:6;24409;24391:33;:::i;:::-;24383:41;23603:827;-1:-1:-1;;;;;;;;23603:827:1:o;24435:249::-;24504:6;24557:2;24545:9;24536:7;24532:23;24528:32;24525:52;;;24573:1;24570;24563:12;24525:52;24605:9;24599:16;24624:30;24648:5;24624:30;:::i;24689:179::-;24724:3;24766:1;24748:16;24745:23;24742:120;;;24812:1;24809;24806;24791:23;-1:-1:-1;24849:1:1;24843:8;24838:3;24834:18;24742:120;24689:179;:::o;24873:671::-;24912:3;24954:4;24936:16;24933:26;24930:39;;;24873:671;:::o;24930:39::-;24996:2;24990:9;-1:-1:-1;;25061:16:1;25057:25;;25054:1;24990:9;25033:50;25112:4;25106:11;25136:16;25171:18;25242:2;25235:4;25227:6;25223:17;25220:25;25215:2;25207:6;25204:14;25201:45;25198:58;;;25249:5;;;;;24873:671;:::o;25198:58::-;25286:6;25280:4;25276:17;25265:28;;25322:3;25316:10;25349:2;25341:6;25338:14;25335:27;;;25355:5;;;;;;24873:671;:::o;25335:27::-;25439:2;25420:16;25414:4;25410:27;25406:36;25399:4;25390:6;25385:3;25381:16;25377:27;25374:69;25371:82;;;25446:5;;;;;;24873:671;:::o;25371:82::-;25462:57;25513:4;25504:6;25496;25492:19;25488:30;25482:4;25462:57;:::i;:::-;-1:-1:-1;25535:3:1;;24873:671;-1:-1:-1;;;;;24873:671:1:o;25970:404::-;26172:2;26154:21;;;26211:2;26191:18;;;26184:30;26250:34;26245:2;26230:18;;26223:62;-1:-1:-1;;;26316:2:1;26301:18;;26294:38;26364:3;26349:19;;25970:404::o;26379:561::-;-1:-1:-1;;;;;26676:15:1;;;26658:34;;26728:15;;26723:2;26708:18;;26701:43;26775:2;26760:18;;26753:34;;;26818:2;26803:18;;26796:34;;;26638:3;26861;26846:19;;26839:32;;;26601:4;;26888:46;;26914:19;;26906:6;26888:46;:::i;:::-;26880:54;26379:561;-1:-1:-1;;;;;;;26379:561:1:o

Swarm Source

ipfs://48f242caf7b01229c96339e2a2d210e23f58499c5d8dab7cdb45c5295f7937ef

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