Token

Live at Fin's (LIVE)

ERC-1155

Overview

Max Total Supply

396 LIVE

Holders

378

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x8f297ed868fe6d0333d8511ed2bf6d7e3ce36d23

Filtered by Token Holder

0x4F6414199F04013BE1408Eb6D3e1df2713A66093

mir80.eth

0x4F6414199F04013BE1408Eb6D3e1df2713A66093

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

LIVEAtFins

Compiler Version

v0.8.18+commit.87f61d96

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-02-08
*/

// File: contracts/IDelegationRegistry.sol


pragma solidity ^0.8.17;

/**
 * @title An immutable registry contract to be deployed as a standalone primitive
 * @dev See EIP-5639, new project launches can read previous cold wallet -> hot wallet delegations
 * from here and integrate those permissions into their flow
 */
interface IDelegationRegistry {
    /// @notice Delegation type
    enum DelegationType {
        NONE,
        ALL,
        CONTRACT,
        TOKEN
    }

    /// @notice Info about a single delegation, used for onchain enumeration
    struct DelegationInfo {
        DelegationType type_;
        address vault;
        address delegate;
        address contract_;
        uint256 tokenId;
    }

    /// @notice Info about a single contract-level delegation
    struct ContractDelegation {
        address contract_;
        address delegate;
    }

    /// @notice Info about a single token-level delegation
    struct TokenDelegation {
        address contract_;
        uint256 tokenId;
        address delegate;
    }

    /// @notice Emitted when a user delegates their entire wallet
    event DelegateForAll(address vault, address delegate, bool value);

    /// @notice Emitted when a user delegates a specific contract
    event DelegateForContract(address vault, address delegate, address contract_, bool value);

    /// @notice Emitted when a user delegates a specific token
    event DelegateForToken(address vault, address delegate, address contract_, uint256 tokenId, bool value);

    /// @notice Emitted when a user revokes all delegations
    event RevokeAllDelegates(address vault);

    /// @notice Emitted when a user revoes all delegations for a given delegate
    event RevokeDelegate(address vault, address delegate);

    /**
     * -----------  WRITE -----------
     */

    /**
     * @notice Allow the delegate to act on your behalf for all contracts
     * @param delegate The hotwallet to act on your behalf
     * @param value Whether to enable or disable delegation for this address, true for setting and false for revoking
     */
    function delegateForAll(address delegate, bool value) external;

    /**
     * @notice Allow the delegate to act on your behalf for a specific contract
     * @param delegate The hotwallet to act on your behalf
     * @param contract_ The address for the contract you're delegating
     * @param value Whether to enable or disable delegation for this address, true for setting and false for revoking
     */
    function delegateForContract(address delegate, address contract_, bool value) external;

    /**
     * @notice Allow the delegate to act on your behalf for a specific token
     * @param delegate The hotwallet to act on your behalf
     * @param contract_ The address for the contract you're delegating
     * @param tokenId The token id for the token you're delegating
     * @param value Whether to enable or disable delegation for this address, true for setting and false for revoking
     */
    function delegateForToken(address delegate, address contract_, uint256 tokenId, bool value) external;

    /**
     * @notice Revoke all delegates
     */
    function revokeAllDelegates() external;

    /**
     * @notice Revoke a specific delegate for all their permissions
     * @param delegate The hotwallet to revoke
     */
    function revokeDelegate(address delegate) external;

    /**
     * @notice Remove yourself as a delegate for a specific vault
     * @param vault The vault which delegated to the msg.sender, and should be removed
     */
    function revokeSelf(address vault) external;

    /**
     * -----------  READ -----------
     */

    /**
     * @notice Returns all active delegations a given delegate is able to claim on behalf of
     * @param delegate The delegate that you would like to retrieve delegations for
     * @return info Array of DelegationInfo structs
     */
    function getDelegationsByDelegate(address delegate) external view returns (DelegationInfo[] memory);

    /**
     * @notice Returns an array of wallet-level delegates for a given vault
     * @param vault The cold wallet who issued the delegation
     * @return addresses Array of wallet-level delegates for a given vault
     */
    function getDelegatesForAll(address vault) external view returns (address[] memory);

    /**
     * @notice Returns an array of contract-level delegates for a given vault and contract
     * @param vault The cold wallet who issued the delegation
     * @param contract_ The address for the contract you're delegating
     * @return addresses Array of contract-level delegates for a given vault and contract
     */
    function getDelegatesForContract(address vault, address contract_) external view returns (address[] memory);

    /**
     * @notice Returns an array of contract-level delegates for a given vault's token
     * @param vault The cold wallet who issued the delegation
     * @param contract_ The address for the contract holding the token
     * @param tokenId The token id for the token you're delegating
     * @return addresses Array of contract-level delegates for a given vault's token
     */
    function getDelegatesForToken(address vault, address contract_, uint256 tokenId)
        external
        view
        returns (address[] memory);

    /**
     * @notice Returns all contract-level delegations for a given vault
     * @param vault The cold wallet who issued the delegations
     * @return delegations Array of ContractDelegation structs
     */
    function getContractLevelDelegations(address vault)
        external
        view
        returns (ContractDelegation[] memory delegations);

    /**
     * @notice Returns all token-level delegations for a given vault
     * @param vault The cold wallet who issued the delegations
     * @return delegations Array of TokenDelegation structs
     */
    function getTokenLevelDelegations(address vault) external view returns (TokenDelegation[] memory delegations);

    /**
     * @notice Returns true if the address is delegated to act on the entire vault
     * @param delegate The hotwallet to act on your behalf
     * @param vault The cold wallet who issued the delegation
     */
    function checkDelegateForAll(address delegate, address vault) external view returns (bool);

    /**
     * @notice Returns true if the address is delegated to act on your behalf for a token contract or an entire vault
     * @param delegate The hotwallet to act on your behalf
     * @param contract_ The address for the contract you're delegating
     * @param vault The cold wallet who issued the delegation
     */
    function checkDelegateForContract(address delegate, address vault, address contract_)
        external
        view
        returns (bool);

    /**
     * @notice Returns true if the address is delegated to act on your behalf for a specific token, the token's contract or an entire vault
     * @param delegate The hotwallet to act on your behalf
     * @param contract_ The address for the contract you're delegating
     * @param tokenId The token id for the token you're delegating
     * @param vault The cold wallet who issued the delegation
     */
    function checkDelegateForToken(address delegate, address vault, address contract_, uint256 tokenId)
        external
        view
        returns (bool);
}

// File: contracts/filter/IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function unregister(address addr) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}
// File: contracts/filter/OperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}
// File: contracts/filter/DefaultOperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 */
abstract contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * 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.
 * OpenZeppelin's JavaScript library generates merkle trees that are safe
 * against this attack out of the box.
 */
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 Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(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++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// File: contracts/lib/MerkleDistributor.sol



pragma solidity ^0.8.0;


contract MerkleDistributor {
    bytes32 public merkleRoot;
    bool public allowListActive = false;

    mapping(address => uint256) private _allowListNumMinted;

    /**
     * @dev emitted when an account has claimed some tokens
     */
    event Claimed(address indexed account, uint256 amount);

    /**
     * @dev emitted when the merkle root has changed
     */
    event MerkleRootChanged(bytes32 merkleRoot);

    /**
     * @dev throws when allow list is not active
     */
    modifier isAllowListActive() {
        require(allowListActive, 'Allow list is not active');
        _;
    }

    /**
     * @dev throws when number of tokens exceeds total token amount
     */
    modifier tokensAvailable(
        address to,
        uint256 numberOfTokens,
        uint256 totalTokenAmount
    ) {
        uint256 claimed = getAllowListMinted(to);
        require(claimed + numberOfTokens <= totalTokenAmount, 'Purchase would exceed number of tokens allotted');
        _;
    }

    /**
     * @dev throws when parameters sent by claimer is incorrect
     */
    modifier ableToClaim(address claimer, bytes32[] memory proof) {
        require(onAllowList(claimer, proof), 'Not on allow list');
        _;
    }

    /**
     * @dev sets the state of the allow list
     */
    function _setAllowListActive(bool allowListActive_) internal virtual {
        allowListActive = allowListActive_;
    }

    /**
     * @dev sets the merkle root
     */
    function _setAllowList(bytes32 merkleRoot_) internal virtual {
        merkleRoot = merkleRoot_;

        emit MerkleRootChanged(merkleRoot);
    }

    /**
     * @dev adds the number of tokens to the incoming address
     */
    function _setAllowListMinted(address to, uint256 numberOfTokens) internal virtual {
        _allowListNumMinted[to] += numberOfTokens;

        emit Claimed(to, numberOfTokens);
    }

    /**
     * @dev gets the number of tokens from the address
     */
    function getAllowListMinted(address from) public view virtual returns (uint256) {
        return _allowListNumMinted[from];
    }

    /**
     * @dev checks if the claimer has a valid proof
     */
    function onAllowList(address claimer, bytes32[] memory proof) public view returns (bool) {
        bytes32 leaf = keccak256(abi.encodePacked(claimer));
        return MerkleProof.verify(proof, merkleRoot, leaf);
    }
}
// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

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() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

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


// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

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


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;


/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * 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);
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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


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

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.0;







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

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

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

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

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

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

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

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

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

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

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

        return batchBalances;
    }

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not token owner 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: caller is not token 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}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

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

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

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

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

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

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

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

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

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

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

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

        return array;
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/extensions/ERC1155Burnable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Extension of {ERC1155} that allows token holders to destroy both their
 * own tokens and those that they have been approved to use.
 *
 * _Available since v3.1._
 */
abstract contract ERC1155Burnable is ERC1155 {
    function burn(
        address account,
        uint256 id,
        uint256 value
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: caller is not token owner nor approved"
        );

        _burn(account, id, value);
    }

    function burnBatch(
        address account,
        uint256[] memory ids,
        uint256[] memory values
    ) public virtual {
        require(
            account == _msgSender() || isApprovedForAll(account, _msgSender()),
            "ERC1155: caller is not token owner nor approved"
        );

        _burnBatch(account, ids, values);
    }
}

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


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC1155/extensions/ERC1155Supply.sol)

pragma solidity ^0.8.0;


/**
 * @dev Extension of ERC1155 that adds tracking of total supply per id.
 *
 * Useful for scenarios where Fungible and Non-fungible tokens have to be
 * clearly identified. Note: While a totalSupply of 1 might mean the
 * corresponding is an NFT, there is no guarantees that no other token with the
 * same id are not going to be minted.
 */
abstract contract ERC1155Supply is ERC1155 {
    mapping(uint256 => uint256) private _totalSupply;

    /**
     * @dev Total amount of tokens in with a given id.
     */
    function totalSupply(uint256 id) public view virtual returns (uint256) {
        return _totalSupply[id];
    }

    /**
     * @dev Indicates whether any token exist with a given id, or not.
     */
    function exists(uint256 id) public view virtual returns (bool) {
        return ERC1155Supply.totalSupply(id) > 0;
    }

    /**
     * @dev See {ERC1155-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual override {
        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);

        if (from == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                _totalSupply[ids[i]] += amounts[i];
            }
        }

        if (to == address(0)) {
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 id = ids[i];
                uint256 amount = amounts[i];
                uint256 supply = _totalSupply[id];
                require(supply >= amount, "ERC1155: burn amount exceeds totalSupply");
                unchecked {
                    _totalSupply[id] = supply - amount;
                }
            }
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

// File: contracts/LIVE.sol


pragma solidity ^0.8.17;








interface IFinsBeachBar {
    function balanceOf(address _address) external returns (uint256);
    function supportsInterface(bytes4 interfaceId) external returns (bool);
}

contract LIVEAtFins is MerkleDistributor, ReentrancyGuard, DefaultOperatorFilterer, ERC1155, ERC1155Supply, ERC1155Burnable, Ownable {

    string public name = "Live at Fin's";
    string public symbol = "LIVE";

    /// Allow us to cap supply for specific tokens if we want
    mapping (uint256 => uint256) public maxSupplyOfTokenByID;

    /// Keep track of which tokens the address has minted
    mapping (address => bool[1000]) public addressMintedTokenID;

    /// Fin's Beach Bar contract so we can interface with it
    address public finsContractAddress;

    /// delegate.cash registry
    address public delegationContractAddress;

    /// Require membership to call a function
    bool public onlyFins;

    /// Turn on/off minting
    bool public mintIsActive;

    /// Set the current token to mint
    uint256 public currentToken;

    constructor(string memory _uri) ERC1155(_uri) {
        /// Set the token uri
        _setURI(_uri);
    }

    /// @dev Set the URI to your base URI here, don't forget the {id} param.
    function setURI(string memory newuri) external onlyOwner {
        _setURI(newuri);
    }

    function setAllowList(bytes32 _merkleRoot) external onlyOwner {
        _setAllowList(_merkleRoot);
    }

    function setAllowListActive(bool _allowListActive) external onlyOwner {
        _setAllowListActive(_allowListActive);
    }

    function setMintActive(bool _mintIsActive) external onlyOwner {
        mintIsActive = _mintIsActive;
    }

    function setCurrentToken(uint256 _tokenId) external onlyOwner {
        /// Toggle on/off minting for the specific token
        currentToken = _tokenId;
    }

    function setTokenMaxSupply(uint256 _tokenId, uint256 _maxSupply) external onlyOwner {
        /// Toggle on/off minting for the specific token
        maxSupplyOfTokenByID[_tokenId] = _maxSupply;
    }

    function setDelegationContract(address _address) external onlyOwner {
        // Set the new contract address
        delegationContractAddress = _address;
    }

    function setFinsBeachBarContract(address _address) external onlyOwner {
        /// Validate that the candidate contract is 721
        require(
            IFinsBeachBar(_address).supportsInterface(0x780e9d63),
            "Contract address does not support ERC721Enumerable"
        );

        // Set the new contract address
        finsContractAddress = _address;
    }

    function setOnlyFinsRequirement(bool _require) external onlyOwner {
        onlyFins = _require;
    }

    /// check to see if the address is a Fin's member
    function isFinsMember(address _mintAddress) public returns (bool) {
        if (IFinsBeachBar(finsContractAddress).balanceOf(_mintAddress) > 0) { 
            return true;
        }
        return false;
    }

    function airdrop(uint256 _tokenID, address _recipient, uint256 _quantity) external onlyOwner {
         /// if a max supply is set, enforce supply limits
        if (maxSupplyOfTokenByID[_tokenID] > 0){
            require(
                totalSupply(_tokenID) + _quantity <= maxSupplyOfTokenByID[_tokenID],
                "Token mint would exceed max supply."
            );
        }

        _mint(_recipient, _tokenID, _quantity, "");

    }

    function mint(address _vault, bytes32[] memory _merkleProof) external nonReentrant {
        address delegate = msg.sender;

        require(mintIsActive, "mint is not active");

        /// if a max supply is set, enforce supply limits
        if (maxSupplyOfTokenByID[currentToken] > 0){
            require(
                totalSupply(currentToken) < maxSupplyOfTokenByID[currentToken],
                "Token mint would exceed max supply."
            );
        }

        /// check to see if this is a hot wallet designated to a vault
        if (_vault != address(0)) { 
            bool isDelegateValid = IDelegationRegistry(delegationContractAddress).checkDelegateForContract(msg.sender, _vault, finsContractAddress);
            require(isDelegateValid, "invalid delegate-vault pairing");
            delegate = _vault;
        }

        /// if the allowlist is active, require them to be on it
        if (allowListActive){
            require(onAllowList(delegate, _merkleProof), "Not on allow list");
        }

        /// if we're restricting it to fin's, check to ensure they have a fin's pass
        if (onlyFins){
            require(isFinsMember(delegate), "Not a Fin's holder");
        }

        /// make sure the address has not minted a token during the current round
        require(!addressMintedTokenID[delegate][currentToken], "This address already minted this token");

        /// mark the token as claimed by the current minter
        addressMintedTokenID[delegate][currentToken] = true;

        _mint(msg.sender, currentToken, 1, "");
    }

    /// @dev allows the owner to withdraw the funds in this contract
    function withdrawBalance(address payable _address) external onlyOwner {
        (bool success, ) = _address.call{value: address(this).balance}("");
        require(success, "Withdraw failed");
    }

    function setApprovalForAll(
        address _operator, 
        bool _approved
    ) public override onlyAllowedOperatorApproval(_operator) {
        super.setApprovalForAll(_operator, _approved);
    }

    function safeTransferFrom(
        address _from, 
        address _to, 
        uint256 _tokenId, 
        uint256 _amount, 
        bytes memory _data
    ) public override onlyAllowedOperator(_from) {
        super.safeTransferFrom(_from, _to, _tokenId, _amount, _data);
    }

    function safeBatchTransferFrom(
        address _from,
        address _to,
        uint256[] memory _ids,
        uint256[] memory _amounts,
        bytes memory _data
    ) public virtual override onlyAllowedOperator(_from) {
        super.safeBatchTransferFrom(_from, _to, _ids, _amounts, _data);
    }

    function _beforeTokenTransfer(
        address _operator,
        address _from,
        address _to,
        uint256[] memory _ids,
        uint256[] memory _amounts,
        bytes memory _data
    ) internal override(ERC1155, ERC1155Supply) {
        super._beforeTokenTransfer(_operator, _from, _to, _ids, _amounts, _data);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"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":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"merkleRoot","type":"bytes32"}],"name":"MerkleRootChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"addressMintedTokenID","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenID","type":"uint256"},{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"allowListActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"burnBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"delegationContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"finsContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"}],"name":"getAllowListMinted","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":[{"internalType":"address","name":"_mintAddress","type":"address"}],"name":"isFinsMember","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"maxSupplyOfTokenByID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_vault","type":"address"},{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"claimer","type":"address"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"onAllowList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"onlyFins","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setAllowList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_allowListActive","type":"bool"}],"name":"setAllowListActive","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":"uint256","name":"_tokenId","type":"uint256"}],"name":"setCurrentToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setDelegationContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"setFinsBeachBarContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_mintIsActive","type":"bool"}],"name":"setMintActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_require","type":"bool"}],"name":"setOnlyFinsRequirement","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_maxSupply","type":"uint256"}],"name":"setTokenMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newuri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"_address","type":"address"}],"name":"withdrawBalance","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)

0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000004568747470733a2f2f6d657461646174612e6172746c61622e78797a2f30313836326365652d323839322d383335352d386566342d6530356432383836363534662f7b69647d000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _uri (string): https://metadata.artlab.xyz/01862cee-2892-8355-8ef4-e05d2886654f/{id}

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000045
Arg [2] : 68747470733a2f2f6d657461646174612e6172746c61622e78797a2f30313836
Arg [3] : 326365652d323839322d383335352d386566342d653035643238383636353466
Arg [4] : 2f7b69647d000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

70625:6413:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48911:230;;;;;;:::i;:::-;;:::i;:::-;;;616:25:1;;;604:2;589:18;48911:230:0;;;;;;;;47934:310;;;;;;:::i;:::-;;:::i;:::-;;;1203:14:1;;1196:22;1178:41;;1166:2;1151:18;47934:310:0;1038:187:1;71697:91:0;;;;;;:::i;:::-;;:::i;:::-;;70767:36;;;:::i;:::-;;;;;;;:::i;48655:105::-;;;;;;:::i;:::-;;:::i;72716:383::-;;;;;;:::i;:::-;;:::i;76373:313::-;;;;;;:::i;:::-;;:::i;22614:25::-;;;;;;71911:126;;;;;;:::i;:::-;;:::i;10456:143::-;;10556:42;10456:143;;;;;-1:-1:-1;;;;;6601:32:1;;;6583:51;;6571:2;6556:18;10456:143:0;6406:234:1;71336:20:0;;;;;-1:-1:-1;;;71336:20:0;;;;;;22646:35;;;;;;;;;71394:24;;;;;-1:-1:-1;;;71394:24:0;;;;;;49307:524;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;66536:122::-;;;;;;:::i;:::-;66593:4;66414:16;;;:12;:16;;;;;;-1:-1:-1;;;66536:122:0;71035:59;;;;;;:::i;:::-;;:::i;24606:131::-;;;;;;:::i;:::-;-1:-1:-1;;;;;24704:25:0;24677:7;24704:25;;;:19;:25;;;;;;;24606:131;71165:34;;;;;-1:-1:-1;;;;;71165:34:0;;;65219:359;;;;;;:::i;:::-;;:::i;69554:103::-;;;:::i;75654:201::-;;;;;;:::i;:::-;;:::i;73107:104::-;;;;;;:::i;:::-;;:::i;73962:1614::-;;;;;;:::i;:::-;;:::i;71466:27::-;;;;;;71796:107;;;;;;:::i;:::-;;:::i;70911:56::-;;;;;;:::i;:::-;;;;;;;;;;;;;;71240:40;;;;;-1:-1:-1;;;;;71240:40:0;;;68906:87;68979:6;;-1:-1:-1;;;;;68979:6:0;68906:87;;70810:29;;;:::i;75863:207::-;;;;;;:::i;:::-;;:::i;24816:220::-;;;;;;:::i;:::-;;:::i;72332:204::-;;;;;;:::i;:::-;;:::i;66325:113::-;;;;;;:::i;:::-;66387:7;66414:16;;;:12;:16;;;;;;;66325:113;72544:164;;;;;;:::i;:::-;;:::i;73274:214::-;;;;;;:::i;:::-;;:::i;50131:168::-;;;;;;:::i;:::-;-1:-1:-1;;;;;50254:27:0;;;50230:4;50254:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;50131:168;72045:109;;;;;;:::i;:::-;;:::i;73496:458::-;;;;;;:::i;:::-;;:::i;76078:287::-;;;;;;:::i;:::-;;:::i;69812:201::-;;;;;;:::i;:::-;;:::i;64884:327::-;;;;;;:::i;:::-;;:::i;72162:162::-;;;;;;:::i;:::-;;:::i;48911:230::-;48997:7;-1:-1:-1;;;;;49025:21:0;;49017:76;;;;-1:-1:-1;;;49017:76:0;;13864:2:1;49017:76:0;;;13846:21:1;13903:2;13883:18;;;13876:30;13942:34;13922:18;;;13915:62;-1:-1:-1;;;13993:18:1;;;13986:40;14043:19;;49017:76:0;;;;;;;;;-1:-1:-1;49111:13:0;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;49111:22:0;;;;;;;;;;48911:230;;;;;:::o;47934:310::-;48036:4;-1:-1:-1;;;;;;48073:41:0;;-1:-1:-1;;;48073:41:0;;:110;;-1:-1:-1;;;;;;;48131:52:0;;-1:-1:-1;;;48131:52:0;48073:110;:163;;;-1:-1:-1;;;;;;;;;;38431:40:0;;;48200:36;38322:157;71697:91;68792:13;:11;:13::i;:::-;71765:15:::1;71773:6;71765:7;:15::i;:::-;71697:91:::0;:::o;70767:36::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;48655:105::-;48715:13;48748:4;48741:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48655:105;;;:::o;72716:383::-;68792:13;:11;:13::i;:::-;72876:53:::1;::::0;-1:-1:-1;;;72876:53:0;;-1:-1:-1;;;72876:53:0::1;::::0;::::1;14620:62:1::0;-1:-1:-1;;;;;72876:41:0;::::1;::::0;::::1;::::0;14593:18:1;;72876:53:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72854:153;;;::::0;-1:-1:-1;;;72854:153:0;;15145:2:1;72854:153:0::1;::::0;::::1;15127:21:1::0;15184:2;15164:18;;;15157:30;15223:34;15203:18;;;15196:62;-1:-1:-1;;;15274:18:1;;;15267:48;15332:19;;72854:153:0::1;14943:414:1::0;72854:153:0::1;73061:19;:30:::0;;-1:-1:-1;;;;;;73061:30:0::1;-1:-1:-1::0;;;;;73061:30:0;;;::::1;::::0;;;::::1;::::0;;72716:383::o;76373:313::-;76598:5;-1:-1:-1;;;;;11797:18:0;;11805:10;11797:18;11793:83;;11832:32;11853:10;11832:20;:32::i;:::-;76616:62:::1;76644:5;76651:3;76656:4;76662:8;76672:5;76616:27;:62::i;:::-;76373:313:::0;;;;;;:::o;71911:126::-;68792:13;:11;:13::i;:::-;23995:15;:34;;-1:-1:-1;;23995:34:0;;;;;;;71697:91;:::o;49307:524::-;49463:16;49524:3;:10;49505:8;:15;:29;49497:83;;;;-1:-1:-1;;;49497:83:0;;15564:2:1;49497:83:0;;;15546:21:1;15603:2;15583:18;;;15576:30;15642:34;15622:18;;;15615:62;-1:-1:-1;;;15693:18:1;;;15686:39;15742:19;;49497:83:0;15362:405:1;49497:83:0;49593:30;49640:8;:15;49626:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49626:30:0;;49593:63;;49674:9;49669:122;49693:8;:15;49689:1;:19;49669:122;;;49749:30;49759:8;49768:1;49759:11;;;;;;;;:::i;:::-;;;;;;;49772:3;49776:1;49772:6;;;;;;;;:::i;:::-;;;;;;;49749:9;:30::i;:::-;49730:13;49744:1;49730:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;49710:3;;;:::i;:::-;;;49669:122;;;-1:-1:-1;49810:13:0;49307:524;-1:-1:-1;;;49307:524:0:o;71035:59::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71035:59:0;;-1:-1:-1;71035:59:0:o;65219:359::-;-1:-1:-1;;;;;65384:23:0;;46708:10;65384:23;;:66;;-1:-1:-1;65411:39:0;65428:7;46708:10;50131:168;:::i;65411:39::-;65362:163;;;;-1:-1:-1;;;65362:163:0;;;;;;;:::i;:::-;65538:32;65549:7;65558:3;65563:6;65538:10;:32::i;:::-;65219:359;;;:::o;69554:103::-;68792:13;:11;:13::i;:::-;69619:30:::1;69646:1;69619:18;:30::i;:::-;69554:103::o:0;75654:201::-;68792:13;:11;:13::i;:::-;75736:12:::1;75754:8;-1:-1:-1::0;;;;;75754:13:0::1;75775:21;75754:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75735:66;;;75820:7;75812:35;;;::::0;-1:-1:-1;;;75812:35:0;;17004:2:1;75812:35:0::1;::::0;::::1;16986:21:1::0;17043:2;17023:18;;;17016:30;-1:-1:-1;;;17062:18:1;;;17055:45;17117:18;;75812:35:0::1;16802:339:1::0;75812:35:0::1;75724:131;75654:201:::0;:::o;73107:104::-;68792:13;:11;:13::i;:::-;73184:8:::1;:19:::0;;;::::1;;-1:-1:-1::0;;;73184:19:0::1;-1:-1:-1::0;;;;73184:19:0;;::::1;::::0;;;::::1;::::0;;73107:104::o;73962:1614::-;27386:21;:19;:21::i;:::-;74106:12:::1;::::0;74075:10:::1;::::0;-1:-1:-1;;;74106:12:0;::::1;;;74098:43;;;::::0;-1:-1:-1;;;74098:43:0;;17348:2:1;74098:43:0::1;::::0;::::1;17330:21:1::0;17387:2;17367:18;;;17360:30;-1:-1:-1;;;17406:18:1;;;17399:48;17464:18;;74098:43:0::1;17146:342:1::0;74098:43:0::1;74238:12;::::0;74254:1:::1;74217:34:::0;;;:20:::1;:34;::::0;;;;;:38;74213:229:::1;;74346:12;::::0;74325:34:::1;::::0;;;:20:::1;:34;::::0;;;;;;;;66414:12;:16;;;;;;;74297:62:::1;74271:159;;;;-1:-1:-1::0;;;74271:159:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;74530:20:0;::::1;::::0;74526:294:::1;;74611:25;::::0;74683:19:::1;::::0;74591:112:::1;::::0;-1:-1:-1;;;74591:112:0;;74663:10:::1;74591:112;::::0;::::1;18137:34:1::0;-1:-1:-1;;;;;18207:15:1;;;18187:18;;;18180:43;74683:19:0;;::::1;18239:18:1::0;;;18232:43;74568:20:0::1;::::0;74611:25;;;::::1;::::0;74591:71:::1;::::0;18072:18:1;;74591:112:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;74568:135;;74726:15;74718:58;;;::::0;-1:-1:-1;;;74718:58:0;;18488:2:1;74718:58:0::1;::::0;::::1;18470:21:1::0;18527:2;18507:18;;;18500:30;18566:32;18546:18;;;18539:60;18616:18;;74718:58:0::1;18286:354:1::0;74718:58:0::1;74802:6;74791:17;;74552:268;74526:294;74902:15;::::0;::::1;;74898:112;;;74941:35;74953:8;74963:12;74941:11;:35::i;:::-;74933:65;;;::::0;-1:-1:-1;;;74933:65:0;;18847:2:1;74933:65:0::1;::::0;::::1;18829:21:1::0;18886:2;18866:18;;;18859:30;-1:-1:-1;;;18905:18:1;;;18898:47;18962:18;;74933:65:0::1;18645:341:1::0;74933:65:0::1;75112:8;::::0;-1:-1:-1;;;75112:8:0;::::1;;;75108:93;;;75144:22;75157:8;75144:12;:22::i;:::-;75136:53;;;::::0;-1:-1:-1;;;75136:53:0;;19193:2:1;75136:53:0::1;::::0;::::1;19175:21:1::0;19232:2;19212:18;;;19205:30;-1:-1:-1;;;19251:18:1;;;19244:48;19309:18;;75136:53:0::1;18991:342:1::0;75136:53:0::1;-1:-1:-1::0;;;;;75305:30:0;::::1;;::::0;;;:20:::1;:30;::::0;;;;75336:12:::1;::::0;75305:44:::1;::::0;::::1;;;;;:::i;:::-;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;::::1;;::::0;::::1;;75304:45;75296:96;;;::::0;-1:-1:-1;;;75296:96:0;;19540:2:1;75296:96:0::1;::::0;::::1;19522:21:1::0;19579:2;19559:18;;;19552:30;19618:34;19598:18;;;19591:62;-1:-1:-1;;;19669:18:1;;;19662:36;19715:19;;75296:96:0::1;19338:402:1::0;75296:96:0::1;-1:-1:-1::0;;;;;75466:30:0;::::1;;::::0;;;:20:::1;:30;::::0;;;;75497:12:::1;::::0;75513:4:::1;::::0;75466:30;:44:::1;::::0;::::1;;;;;:::i;:::-;;;;;;;;;;:51;;;;;;;;;;;;;;;;;;75530:38;75536:10;75548:12;;75562:1;75530:38;;;;;;;;;;;::::0;:5:::1;:38::i;:::-;74045:1531;27430:20:::0;26824:1;27950:7;:22;27767:213;71796:107;68792:13;:11;:13::i;:::-;71869:26:::1;71883:11;71869:13;:26::i;70810:29::-:0;;;;;;;:::i;75863:207::-;75995:9;11977:30;11998:8;11977:20;:30::i;:::-;76017:45:::1;76041:9;76052;76017:23;:45::i;24816:220::-:0;24941:25;;-1:-1:-1;;19894:2:1;19890:15;;;19886:53;24941:25:0;;;19874:66:1;24899:4:0;;;;19956:12:1;;24941:25:0;;;;;;;;;;;;24931:36;;;;;;24916:51;;24985:43;25004:5;25011:10;;25023:4;24985:18;:43::i;:::-;24978:50;24816:220;-1:-1:-1;;;;24816:220:0:o;72332:204::-;68792:13;:11;:13::i;:::-;72485:30:::1;::::0;;;:20:::1;:30;::::0;;;;;:43;72332:204::o;72544:164::-;68792:13;:11;:13::i;:::-;72664:25:::1;:36:::0;;-1:-1:-1;;;;;;72664:36:0::1;-1:-1:-1::0;;;;;72664:36:0;;;::::1;::::0;;;::::1;::::0;;72544:164::o;73274:214::-;73369:19;;73355:58;;-1:-1:-1;;;73355:58:0;;-1:-1:-1;;;;;6601:32:1;;;73355:58:0;;;6583:51:1;73334:4:0;;;;73369:19;;;73355:44;;6556:18:1;;73355:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:62;73351:107;;;-1:-1:-1;73442:4:0;;73274:214;-1:-1:-1;73274:214:0:o;73351:107::-;-1:-1:-1;73475:5:0;;73274:214;-1:-1:-1;73274:214:0:o;72045:109::-;68792:13;:11;:13::i;:::-;72118:12:::1;:28:::0;;;::::1;;-1:-1:-1::0;;;72118:28:0::1;-1:-1:-1::0;;;;72118:28:0;;::::1;::::0;;;::::1;::::0;;72045:109::o;73496:458::-;68792:13;:11;:13::i;:::-;73697:1:::1;73664:30:::0;;;:20:::1;:30;::::0;;;;;:34;73660:230:::1;;73777:30;::::0;;;:20:::1;:30;::::0;;;;;;;;66414:12;:16;;;;;;;73740:33:::1;::::0;73764:9;;73740:33:::1;:::i;:::-;:67;;73714:164;;;;-1:-1:-1::0;;;73714:164:0::1;;;;;;;:::i;:::-;73902:42;73908:10;73920:8;73930:9;73902:42;;;;;;;;;;;::::0;:5:::1;:42::i;76078:287::-:0;76279:5;-1:-1:-1;;;;;11797:18:0;;11805:10;11797:18;11793:83;;11832:32;11853:10;11832:20;:32::i;:::-;76297:60:::1;76320:5;76327:3;76332:8;76342:7;76351:5;76297:22;:60::i;69812:201::-:0;68792:13;:11;:13::i;:::-;-1:-1:-1;;;;;69901:22:0;::::1;69893:73;;;::::0;-1:-1:-1;;;69893:73:0;;20500:2:1;69893:73:0::1;::::0;::::1;20482:21:1::0;20539:2;20519:18;;;20512:30;20578:34;20558:18;;;20551:62;-1:-1:-1;;;20629:18:1;;;20622:36;20675:19;;69893:73:0::1;20298:402:1::0;69893:73:0::1;69977:28;69996:8;69977:18;:28::i;64884:327::-:0;-1:-1:-1;;;;;65024:23:0;;46708:10;65024:23;;:66;;-1:-1:-1;65051:39:0;65068:7;46708:10;50131:168;:::i;65051:39::-;65002:163;;;;-1:-1:-1;;;65002:163:0;;;;;;;:::i;:::-;65178:25;65184:7;65193:2;65197:5;65178;:25::i;72162:162::-;68792:13;:11;:13::i;:::-;72293:12:::1;:23:::0;72162:162::o;69071:132::-;68979:6;;-1:-1:-1;;;;;68979:6:0;46708:10;69135:23;69127:68;;;;-1:-1:-1;;;69127:68:0;;20907:2:1;69127:68:0;;;20889:21:1;;;20926:18;;;20919:30;20985:34;20965:18;;;20958:62;21037:18;;69127:68:0;20705:356:1;55080:88:0;55147:4;:13;55154:6;55147:4;:13;:::i;12035:419::-;10556:42;12226:45;:49;12222:225;;12297:67;;-1:-1:-1;;;12297:67:0;;12348:4;12297:67;;;23482:34:1;-1:-1:-1;;;;;23552:15:1;;23532:18;;;23525:43;10556:42:0;;12297;;23417:18:1;;12297:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;12292:144;;12392:28;;-1:-1:-1;;;12392:28:0;;-1:-1:-1;;;;;6601:32:1;;12392:28:0;;;6583:51:1;6556:18;;12392:28:0;6406:234:1;50855:439:0;-1:-1:-1;;;;;51088:20:0;;46708:10;51088:20;;:60;;-1:-1:-1;51112:36:0;51129:4;46708:10;50131:168;:::i;51112:36::-;51066:157;;;;-1:-1:-1;;;51066:157:0;;;;;;;:::i;:::-;51234:52;51257:4;51263:2;51267:3;51272:7;51281:4;51234:22;:52::i;:::-;50855:439;;;;;:::o;58855:969::-;-1:-1:-1;;;;;59007:18:0;;58999:66;;;;-1:-1:-1;;;58999:66:0;;;;;;;:::i;:::-;59098:7;:14;59084:3;:10;:28;59076:81;;;;-1:-1:-1;;;59076:81:0;;;;;;;:::i;:::-;59170:16;46708:10;59170:31;;59214:66;59235:8;59245:4;59259:1;59263:3;59268:7;59214:66;;;;;;;;;;;;:20;:66::i;:::-;59298:9;59293:373;59317:3;:10;59313:1;:14;59293:373;;;59349:10;59362:3;59366:1;59362:6;;;;;;;;:::i;:::-;;;;;;;59349:19;;59383:14;59400:7;59408:1;59400:10;;;;;;;;:::i;:::-;;;;;;;;;;;;59427:19;59449:13;;;:9;:13;;;;;;-1:-1:-1;;;;;59449:19:0;;;;;;;;;;;;59400:10;;-1:-1:-1;59491:21:0;;;;59483:70;;;;-1:-1:-1;;;59483:70:0;;;;;;;:::i;:::-;59597:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;59597:19:0;;;;;;;;;;59619:20;;59597:42;;59329:3;;;;:::i;:::-;;;;59293:373;;;;59721:1;-1:-1:-1;;;;;59683:55:0;59707:4;-1:-1:-1;;;;;59683:55:0;59697:8;-1:-1:-1;;;;;59683:55:0;;59725:3;59730:7;59683:55;;;;;;;:::i;:::-;;;;;;;;59751:65;;;;;;;;;59795:1;59751:65;;58988:836;58855:969;;;:::o;70173:191::-;70266:6;;;-1:-1:-1;;;;;70283:17:0;;;-1:-1:-1;;;;;;70283:17:0;;;;;;;70316:40;;70266:6;;;70283:17;70266:6;;70316:40;;70247:16;;70316:40;70236:128;70173:191;:::o;27466:293::-;26868:1;27600:7;;:19;27592:63;;;;-1:-1:-1;;;27592:63:0;;25469:2:1;27592:63:0;;;25451:21:1;25508:2;25488:18;;;25481:30;25547:33;25527:18;;;25520:61;25598:18;;27592:63:0;25267:355:1;27592:63:0;26868:1;27733:7;:18;27466:293::o;55554:729::-;-1:-1:-1;;;;;55707:16:0;;55699:62;;;;-1:-1:-1;;;55699:62:0;;25829:2:1;55699:62:0;;;25811:21:1;25868:2;25848:18;;;25841:30;25907:34;25887:18;;;25880:62;-1:-1:-1;;;25958:18:1;;;25951:31;25999:19;;55699:62:0;25627:397:1;55699:62:0;46708:10;55774:16;55839:21;55857:2;55839:17;:21::i;:::-;55816:44;;55871:24;55898:25;55916:6;55898:17;:25::i;:::-;55871:52;;55936:66;55957:8;55975:1;55979:2;55983:3;55988:7;55997:4;55936:20;:66::i;:::-;56015:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;56015:17:0;;;;;;;;;:27;;56036:6;;56015:13;:27;;56036:6;;56015:27;:::i;:::-;;;;-1:-1:-1;;56058:52:0;;;26203:25:1;;;26259:2;26244:18;;26237:34;;;-1:-1:-1;;;;;56058:52:0;;;;56091:1;;56058:52;;;;;;26176:18:1;56058:52:0;;;;;;;56201:74;56232:8;56250:1;56254:2;56258;56262:6;56270:4;56201:30;:74::i;:::-;55688:595;;;55554:729;;;;:::o;24097:151::-;24169:10;:24;;;24211:29;;616:25:1;;;24211:29:0;;604:2:1;589:18;24211:29:0;;;;;;;24097:151;:::o;49904:155::-;49999:52;46708:10;50032:8;50042;49999:18;:52::i;14160:190::-;14285:4;14338;14309:25;14322:5;14329:4;14309:12;:25::i;:::-;:33;;14160:190;-1:-1:-1;;;;14160:190:0:o;50371:407::-;-1:-1:-1;;;;;50579:20:0;;46708:10;50579:20;;:60;;-1:-1:-1;50603:36:0;50620:4;46708:10;50131:168;:::i;50603:36::-;50557:157;;;;-1:-1:-1;;;50557:157:0;;;;;;;:::i;:::-;50725:45;50743:4;50749:2;50753;50757:6;50765:4;50725:17;:45::i;57797:808::-;-1:-1:-1;;;;;57924:18:0;;57916:66;;;;-1:-1:-1;;;57916:66:0;;;;;;;:::i;:::-;46708:10;57995:16;58060:21;58078:2;58060:17;:21::i;:::-;58037:44;;58092:24;58119:25;58137:6;58119:17;:25::i;:::-;58092:52;;58157:66;58178:8;58188:4;58202:1;58206:3;58211:7;58157:66;;;;;;;;;;;;:20;:66::i;:::-;58236:19;58258:13;;;:9;:13;;;;;;;;-1:-1:-1;;;;;58258:19:0;;;;;;;;;;58296:21;;;;58288:70;;;;-1:-1:-1;;;58288:70:0;;;;;;;:::i;:::-;58394:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;58394:19:0;;;;;;;;;;;;58416:20;;;58394:42;;58465:54;;26203:25:1;;;26244:18;;;26237:34;;;58394:19:0;;58465:54;;;;;;26176:18:1;58465:54:0;;;;;;;58532:65;;;;;;;;;58576:1;58532:65;;;76373:313;53090:1146;53317:7;:14;53303:3;:10;:28;53295:81;;;;-1:-1:-1;;;53295:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;53395:16:0;;53387:66;;;;-1:-1:-1;;;53387:66:0;;;;;;;:::i;:::-;46708:10;53510:60;46708:10;53541:4;53547:2;53551:3;53556:7;53565:4;53510:20;:60::i;:::-;53588:9;53583:421;53607:3;:10;53603:1;:14;53583:421;;;53639:10;53652:3;53656:1;53652:6;;;;;;;;:::i;:::-;;;;;;;53639:19;;53673:14;53690:7;53698:1;53690:10;;;;;;;;:::i;:::-;;;;;;;;;;;;53717:19;53739:13;;;:9;:13;;;;;;-1:-1:-1;;;;;53739:19:0;;;;;;;;;;;;53690:10;;-1:-1:-1;53781:21:0;;;;53773:76;;;;-1:-1:-1;;;53773:76:0;;;;;;;:::i;:::-;53893:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;53893:19:0;;;;;;;;;;53915:20;;;53893:42;;53965:17;;;;;;;:27;;53915:20;;53893:13;53965:27;;53915:20;;53965:27;:::i;:::-;;;;;;;;53624:380;;;53619:3;;;;:::i;:::-;;;53583:421;;;;54051:2;-1:-1:-1;;;;;54021:47:0;54045:4;-1:-1:-1;;;;;54021:47:0;54035:8;-1:-1:-1;;;;;54021:47:0;;54055:3;54060:7;54021:47;;;;;;;:::i;:::-;;;;;;;;54153:75;54189:8;54199:4;54205:2;54209:3;54214:7;54223:4;54153:35;:75::i;76694:341::-;76955:72;76982:9;76993:5;77000:3;77005:4;77011:8;77021:5;76955:26;:72::i;64233:198::-;64353:16;;;64367:1;64353:16;;;;;;;;;64299;;64328:22;;64353:16;;;;;;;;;;;;-1:-1:-1;64353:16:0;64328:41;;64391:7;64380:5;64386:1;64380:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;64418:5;64233:198;-1:-1:-1;;64233:198:0:o;62660:744::-;-1:-1:-1;;;;;62875:13:0;;29515:19;:23;62871:526;;62911:72;;-1:-1:-1;;;62911:72:0;;-1:-1:-1;;;;;62911:38:0;;;;;:72;;62950:8;;62960:4;;62966:2;;62970:6;;62978:4;;62911:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62911:72:0;;;;;;;;-1:-1:-1;;62911:72:0;;;;;;;;;;;;:::i;:::-;;;62907:479;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;63259:6;63252:14;;-1:-1:-1;;;63252:14:0;;;;;;;;:::i;62907:479::-;;;63308:62;;-1:-1:-1;;;63308:62:0;;28981:2:1;63308:62:0;;;28963:21:1;29020:2;29000:18;;;28993:30;29059:34;29039:18;;;29032:62;-1:-1:-1;;;29110:18:1;;;29103:50;29170:19;;63308:62:0;28779:416:1;62907:479:0;-1:-1:-1;;;;;;63033:55:0;;-1:-1:-1;;;63033:55:0;63029:154;;63113:50;;-1:-1:-1;;;63113:50:0;;;;;;;:::i;59967:331::-;60122:8;-1:-1:-1;;;;;60113:17:0;:5;-1:-1:-1;;;;;60113:17:0;;60105:71;;;;-1:-1:-1;;;60105:71:0;;29811:2:1;60105:71:0;;;29793:21:1;29850:2;29830:18;;;29823:30;29889:34;29869:18;;;29862:62;-1:-1:-1;;;29940:18:1;;;29933:39;29989:19;;60105:71:0;29609:405:1;60105:71:0;-1:-1:-1;;;;;60187:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;60187:46:0;;;;;;;;;;60249:41;;1178::1;;;60249::0;;1151:18:1;60249:41:0;;;;;;;59967:331;;;:::o;15027:296::-;15110:7;15153:4;15110:7;15168:118;15192:5;:12;15188:1;:16;15168:118;;;15241:33;15251:12;15265:5;15271:1;15265:8;;;;;;;;:::i;:::-;;;;;;;15241:9;:33::i;:::-;15226:48;-1:-1:-1;15206:3:0;;;;:::i;:::-;;;;15168:118;;51758:974;-1:-1:-1;;;;;51946:16:0;;51938:66;;;;-1:-1:-1;;;51938:66:0;;;;;;;:::i;:::-;46708:10;52017:16;52082:21;52100:2;52082:17;:21::i;:::-;52059:44;;52114:24;52141:25;52159:6;52141:17;:25::i;:::-;52114:52;;52179:60;52200:8;52210:4;52216:2;52220:3;52225:7;52234:4;52179:20;:60::i;:::-;52252:19;52274:13;;;:9;:13;;;;;;;;-1:-1:-1;;;;;52274:19:0;;;;;;;;;;52312:21;;;;52304:76;;;;-1:-1:-1;;;52304:76:0;;;;;;;:::i;:::-;52416:13;;;;:9;:13;;;;;;;;-1:-1:-1;;;;;52416:19:0;;;;;;;;;;52438:20;;;52416:42;;52480:17;;;;;;;:27;;52438:20;;52416:13;52480:27;;52438:20;;52480:27;:::i;:::-;;;;-1:-1:-1;;52525:46:0;;;26203:25:1;;;26259:2;26244:18;;26237:34;;;-1:-1:-1;;;;;52525:46:0;;;;;;;;;;;;;;26176:18:1;52525:46:0;;;;;;;52656:68;52687:8;52697:4;52703:2;52707;52711:6;52719:4;52656:30;:68::i;:::-;51927:805;;;;51758:974;;;;;:::o;63412:813::-;-1:-1:-1;;;;;63652:13:0;;29515:19;:23;63648:570;;63688:79;;-1:-1:-1;;;63688:79:0;;-1:-1:-1;;;;;63688:43:0;;;;;:79;;63732:8;;63742:4;;63748:3;;63753:7;;63762:4;;63688:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;63688:79:0;;;;;;;;-1:-1:-1;;63688:79:0;;;;;;;;;;;;:::i;:::-;;;63684:523;;;;:::i;:::-;-1:-1:-1;;;;;;63849:60:0;;-1:-1:-1;;;63849:60:0;63845:159;;63934:50;;-1:-1:-1;;;63934:50:0;;;;;;;:::i;66733:931::-;-1:-1:-1;;;;;67055:18:0;;67051:160;;67095:9;67090:110;67114:3;:10;67110:1;:14;67090:110;;;67174:7;67182:1;67174:10;;;;;;;;:::i;:::-;;;;;;;67150:12;:20;67163:3;67167:1;67163:6;;;;;;;;:::i;:::-;;;;;;;67150:20;;;;;;;;;;;;:34;;;;;;;:::i;:::-;;;;-1:-1:-1;67126:3:0;;-1:-1:-1;67126:3:0;;:::i;:::-;;;67090:110;;;;67051:160;-1:-1:-1;;;;;67227:16:0;;67223:434;;67265:9;67260:386;67284:3;:10;67280:1;:14;67260:386;;;67320:10;67333:3;67337:1;67333:6;;;;;;;;:::i;:::-;;;;;;;67320:19;;67358:14;67375:7;67383:1;67375:10;;;;;;;;:::i;:::-;;;;;;;67358:27;;67404:14;67421:12;:16;67434:2;67421:16;;;;;;;;;;;;67404:33;;67474:6;67464;:16;;67456:69;;;;-1:-1:-1;;;67456:69:0;;31053:2:1;67456:69:0;;;31035:21:1;31092:2;31072:18;;;31065:30;31131:34;31111:18;;;31104:62;-1:-1:-1;;;31182:18:1;;;31175:38;31230:19;;67456:69:0;30851:404:1;67456:69:0;67577:16;;;;:12;:16;;;;;;67596:15;;67577:34;;67296:3;;;:::i;:::-;;;67260:386;;22067:149;22130:7;22161:1;22157;:5;:51;;22292:13;22386:15;;;22422:4;22415:15;;;22469:4;22453:21;;22157:51;;;22292:13;22386:15;;;22422:4;22415:15;;;22469:4;22453:21;;22165:20;22150:58;22067:149;-1:-1:-1;;;22067:149:0: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;1230:127::-;1291:10;1286:3;1282:20;1279:1;1272:31;1322:4;1319:1;1312:15;1346:4;1343:1;1336:15;1362:249;1472:2;1453:13;;-1:-1:-1;;1449:27:1;1437:40;;1507:18;1492:34;;1528:22;;;1489:62;1486:88;;;1554:18;;:::i;:::-;1590:2;1583:22;-1:-1:-1;;1362:249:1:o;1616:469::-;1681:5;1715:18;1707:6;1704:30;1701:56;;;1737:18;;:::i;:::-;1786:2;1780:9;1798:69;1855:2;1834:15;;-1:-1:-1;;1830:29:1;1861:4;1826:40;1780:9;1798:69;:::i;:::-;1885:6;1876:15;;1915:6;1907;1900:22;1955:3;1946:6;1941:3;1937:16;1934:25;1931:45;;;1972:1;1969;1962:12;1931:45;2022:6;2017:3;2010:4;2002:6;1998:17;1985:44;2077:1;2070:4;2061:6;2053;2049:19;2045:30;2038:41;;1616:469;;;;;:::o;2090:451::-;2159:6;2212:2;2200:9;2191:7;2187:23;2183:32;2180:52;;;2228:1;2225;2218:12;2180:52;2268:9;2255:23;2301:18;2293:6;2290:30;2287:50;;;2333:1;2330;2323:12;2287:50;2356:22;;2409:4;2401:13;;2397:27;-1:-1:-1;2387:55:1;;2438:1;2435;2428:12;2387:55;2461:74;2527:7;2522:2;2509:16;2504:2;2500;2496:11;2461:74;:::i;2546:423::-;2588:3;2626:5;2620:12;2653:6;2648:3;2641:19;2678:1;2688:162;2702:6;2699:1;2696:13;2688:162;;;2764:4;2820:13;;;2816:22;;2810:29;2792:11;;;2788:20;;2781:59;2717:12;2688:162;;;2692:3;2895:1;2888:4;2879:6;2874:3;2870:16;2866:27;2859:38;2958:4;2951:2;2947:7;2942:2;2934:6;2930:15;2926:29;2921:3;2917:39;2913:50;2906:57;;;2546:423;;;;:::o;2974:220::-;3123:2;3112:9;3105:21;3086:4;3143:45;3184:2;3173:9;3169:18;3161:6;3143:45;:::i;3199:180::-;3258:6;3311:2;3299:9;3290:7;3286:23;3282:32;3279:52;;;3327:1;3324;3317:12;3279:52;-1:-1:-1;3350:23:1;;3199:180;-1:-1:-1;3199:180:1:o;3384:247::-;3443:6;3496:2;3484:9;3475:7;3471:23;3467:32;3464:52;;;3512:1;3509;3502:12;3464:52;3551:9;3538:23;3570:31;3595:5;3570:31;:::i;3636:183::-;3696:4;3729:18;3721:6;3718:30;3715:56;;;3751:18;;:::i;:::-;-1:-1:-1;3796:1:1;3792:14;3808:4;3788:25;;3636:183::o;3824:724::-;3878:5;3931:3;3924:4;3916:6;3912:17;3908:27;3898:55;;3949:1;3946;3939:12;3898:55;3985:6;3972:20;4011:4;4034:43;4074:2;4034:43;:::i;:::-;4106:2;4100:9;4118:31;4146:2;4138:6;4118:31;:::i;:::-;4184:18;;;4276:1;4272:10;;;;4260:23;;4256:32;;;4218:15;;;;-1:-1:-1;4300:15:1;;;4297:35;;;4328:1;4325;4318:12;4297:35;4364:2;4356:6;4352:15;4376:142;4392:6;4387:3;4384:15;4376:142;;;4458:17;;4446:30;;4496:12;;;;4409;;4376:142;;;-1:-1:-1;4536:6:1;3824:724;-1:-1:-1;;;;;;3824:724:1:o;4553:221::-;4595:5;4648:3;4641:4;4633:6;4629:17;4625:27;4615:55;;4666:1;4663;4656:12;4615:55;4688:80;4764:3;4755:6;4742:20;4735:4;4727:6;4723:17;4688:80;:::i;4779:1071::-;4933:6;4941;4949;4957;4965;5018:3;5006:9;4997:7;4993:23;4989:33;4986:53;;;5035:1;5032;5025:12;4986:53;5074:9;5061:23;5093:31;5118:5;5093:31;:::i;:::-;5143:5;-1:-1:-1;5200:2:1;5185:18;;5172:32;5213:33;5172:32;5213:33;:::i;:::-;5265:7;-1:-1:-1;5323:2:1;5308:18;;5295:32;5346:18;5376:14;;;5373:34;;;5403:1;5400;5393:12;5373:34;5426:61;5479:7;5470:6;5459:9;5455:22;5426:61;:::i;:::-;5416:71;;5540:2;5529:9;5525:18;5512:32;5496:48;;5569:2;5559:8;5556:16;5553:36;;;5585:1;5582;5575:12;5553:36;5608:63;5663:7;5652:8;5641:9;5637:24;5608:63;:::i;:::-;5598:73;;5724:3;5713:9;5709:19;5696:33;5680:49;;5754:2;5744:8;5741:16;5738:36;;;5770:1;5767;5760:12;5738:36;;5793:51;5836:7;5825:8;5814:9;5810:24;5793:51;:::i;:::-;5783:61;;;4779:1071;;;;;;;;:::o;6037:118::-;6123:5;6116:13;6109:21;6102:5;6099:32;6089:60;;6145:1;6142;6135:12;6160:241;6216:6;6269:2;6257:9;6248:7;6244:23;6240:32;6237:52;;;6285:1;6282;6275:12;6237:52;6324:9;6311:23;6343:28;6365:5;6343:28;:::i;6645:1277::-;6763:6;6771;6824:2;6812:9;6803:7;6799:23;6795:32;6792:52;;;6840:1;6837;6830:12;6792:52;6880:9;6867:23;6909:18;6950:2;6942:6;6939:14;6936:34;;;6966:1;6963;6956:12;6936:34;7004:6;6993:9;6989:22;6979:32;;7049:7;7042:4;7038:2;7034:13;7030:27;7020:55;;7071:1;7068;7061:12;7020:55;7107:2;7094:16;7129:4;7152:43;7192:2;7152:43;:::i;:::-;7224:2;7218:9;7236:31;7264:2;7256:6;7236:31;:::i;:::-;7302:18;;;7390:1;7386:10;;;;7378:19;;7374:28;;;7336:15;;;;-1:-1:-1;7414:19:1;;;7411:39;;;7446:1;7443;7436:12;7411:39;7470:11;;;;7490:217;7506:6;7501:3;7498:15;7490:217;;;7586:3;7573:17;7603:31;7628:5;7603:31;:::i;:::-;7647:18;;7523:12;;;;7685;;;;7490:217;;;7726:6;-1:-1:-1;;7770:18:1;;7757:32;;-1:-1:-1;;7801:16:1;;;7798:36;;;7830:1;7827;7820:12;7798:36;;7853:63;7908:7;7897:8;7886:9;7882:24;7853:63;:::i;:::-;7843:73;;;6645:1277;;;;;:::o;7927:435::-;7980:3;8018:5;8012:12;8045:6;8040:3;8033:19;8071:4;8100:2;8095:3;8091:12;8084:19;;8137:2;8130:5;8126:14;8158:1;8168:169;8182:6;8179:1;8176:13;8168:169;;;8243:13;;8231:26;;8277:12;;;;8312:15;;;;8204:1;8197:9;8168:169;;;-1:-1:-1;8353:3:1;;7927:435;-1:-1:-1;;;;;7927:435:1:o;8367:261::-;8546:2;8535:9;8528:21;8509:4;8566:56;8618:2;8607:9;8603:18;8595:6;8566:56;:::i;8841:730::-;8968:6;8976;8984;9037:2;9025:9;9016:7;9012:23;9008:32;9005:52;;;9053:1;9050;9043:12;9005:52;9092:9;9079:23;9111:31;9136:5;9111:31;:::i;:::-;9161:5;-1:-1:-1;9217:2:1;9202:18;;9189:32;9240:18;9270:14;;;9267:34;;;9297:1;9294;9287:12;9267:34;9320:61;9373:7;9364:6;9353:9;9349:22;9320:61;:::i;:::-;9310:71;;9434:2;9423:9;9419:18;9406:32;9390:48;;9463:2;9453:8;9450:16;9447:36;;;9479:1;9476;9469:12;9447:36;;9502:63;9557:7;9546:8;9535:9;9531:24;9502:63;:::i;:::-;9492:73;;;8841:730;;;;;:::o;9836:1088::-;9929:6;9937;9990:2;9978:9;9969:7;9965:23;9961:32;9958:52;;;10006:1;10003;9996:12;9958:52;10045:9;10032:23;10064:31;10089:5;10064:31;:::i;:::-;10114:5;-1:-1:-1;10138:2:1;10176:18;;;10163:32;10218:18;10207:30;;10204:50;;;10250:1;10247;10240:12;10204:50;10273:22;;10326:4;10318:13;;10314:27;-1:-1:-1;10304:55:1;;10355:1;10352;10345:12;10304:55;10391:2;10378:16;10413:43;10453:2;10413:43;:::i;:::-;10485:2;10479:9;10497:31;10525:2;10517:6;10497:31;:::i;:::-;10563:18;;;10651:1;10647:10;;;;10639:19;;10635:28;;;10597:15;;;;-1:-1:-1;10675:19:1;;;10672:39;;;10707:1;10704;10697:12;10672:39;10731:11;;;;10751:142;10767:6;10762:3;10759:15;10751:142;;;10833:17;;10821:30;;10784:12;;;;10871;;;;10751:142;;;10912:6;10902:16;;;;;;;9836:1088;;;;;:::o;11114:382::-;11179:6;11187;11240:2;11228:9;11219:7;11215:23;11211:32;11208:52;;;11256:1;11253;11246:12;11208:52;11295:9;11282:23;11314:31;11339:5;11314:31;:::i;:::-;11364:5;-1:-1:-1;11421:2:1;11406:18;;11393:32;11434:30;11393:32;11434:30;:::i;:::-;11483:7;11473:17;;;11114:382;;;;;:::o;11501:248::-;11569:6;11577;11630:2;11618:9;11609:7;11605:23;11601:32;11598:52;;;11646:1;11643;11636:12;11598:52;-1:-1:-1;;11669:23:1;;;11739:2;11724:18;;;11711:32;;-1:-1:-1;11501:248:1:o;11754:388::-;11822:6;11830;11883:2;11871:9;11862:7;11858:23;11854:32;11851:52;;;11899:1;11896;11889:12;11851:52;11938:9;11925:23;11957:31;11982:5;11957:31;:::i;:::-;12007:5;-1:-1:-1;12064:2:1;12049:18;;12036:32;12077:33;12036:32;12077:33;:::i;12147:383::-;12224:6;12232;12240;12293:2;12281:9;12272:7;12268:23;12264:32;12261:52;;;12309:1;12306;12299:12;12261:52;12345:9;12332:23;12322:33;;12405:2;12394:9;12390:18;12377:32;12418:31;12443:5;12418:31;:::i;:::-;12147:383;;12468:5;;-1:-1:-1;;;12520:2:1;12505:18;;;;12492:32;;12147:383::o;12535:734::-;12639:6;12647;12655;12663;12671;12724:3;12712:9;12703:7;12699:23;12695:33;12692:53;;;12741:1;12738;12731:12;12692:53;12780:9;12767:23;12799:31;12824:5;12799:31;:::i;:::-;12849:5;-1:-1:-1;12906:2:1;12891:18;;12878:32;12919:33;12878:32;12919:33;:::i;:::-;12971:7;-1:-1:-1;13025:2:1;13010:18;;12997:32;;-1:-1:-1;13076:2:1;13061:18;;13048:32;;-1:-1:-1;13131:3:1;13116:19;;13103:33;13159:18;13148:30;;13145:50;;;13191:1;13188;13181:12;13145:50;13214:49;13255:7;13246:6;13235:9;13231:22;13214:49;:::i;13274:383::-;13351:6;13359;13367;13420:2;13408:9;13399:7;13395:23;13391:32;13388:52;;;13436:1;13433;13426:12;13388:52;13475:9;13462:23;13494:31;13519:5;13494:31;:::i;:::-;13544:5;13596:2;13581:18;;13568:32;;-1:-1:-1;13647:2:1;13632:18;;;13619:32;;13274:383;-1:-1:-1;;;13274:383:1:o;14073:380::-;14152:1;14148:12;;;;14195;;;14216:61;;14270:4;14262:6;14258:17;14248:27;;14216:61;14323:2;14315:6;14312:14;14292:18;14289:38;14286:161;;14369:10;14364:3;14360:20;14357:1;14350:31;14404:4;14401:1;14394:15;14432:4;14429:1;14422:15;14286:161;;14073:380;;;:::o;14693:245::-;14760:6;14813:2;14801:9;14792:7;14788:23;14784:32;14781:52;;;14829:1;14826;14819:12;14781:52;14861:9;14855:16;14880:28;14902:5;14880:28;:::i;15772:127::-;15833:10;15828:3;15824:20;15821:1;15814:31;15864:4;15861:1;15854:15;15888:4;15885:1;15878:15;15904:127;15965:10;15960:3;15956:20;15953:1;15946:31;15996:4;15993:1;15986:15;16020:4;16017:1;16010:15;16036:135;16075:3;16096:17;;;16093:43;;16116:18;;:::i;:::-;-1:-1:-1;16163:1:1;16152:13;;16036:135::o;16176:411::-;16378:2;16360:21;;;16417:2;16397:18;;;16390:30;16456:34;16451:2;16436:18;;16429:62;-1:-1:-1;;;16522:2:1;16507:18;;16500:45;16577:3;16562:19;;16176:411::o;17493:399::-;17695:2;17677:21;;;17734:2;17714:18;;;17707:30;17773:34;17768:2;17753:18;;17746:62;-1:-1:-1;;;17839:2:1;17824:18;;17817:33;17882:3;17867:19;;17493:399::o;19979:184::-;20049:6;20102:2;20090:9;20081:7;20077:23;20073:32;20070:52;;;20118:1;20115;20108:12;20070:52;-1:-1:-1;20141:16:1;;19979:184;-1:-1:-1;19979:184:1:o;20168:125::-;20233:9;;;20254:10;;;20251:36;;;20267:18;;:::i;21192:545::-;21294:2;21289:3;21286:11;21283:448;;;21330:1;21355:5;21351:2;21344:17;21400:4;21396:2;21386:19;21470:2;21458:10;21454:19;21451:1;21447:27;21441:4;21437:38;21506:4;21494:10;21491:20;21488:47;;;-1:-1:-1;21529:4:1;21488:47;21584:2;21579:3;21575:12;21572:1;21568:20;21562:4;21558:31;21548:41;;21639:82;21657:2;21650:5;21647:13;21639:82;;;21702:17;;;21683:1;21672:13;21639:82;;21913:1352;22039:3;22033:10;22066:18;22058:6;22055:30;22052:56;;;22088:18;;:::i;:::-;22117:97;22207:6;22167:38;22199:4;22193:11;22167:38;:::i;:::-;22161:4;22117:97;:::i;:::-;22269:4;;22333:2;22322:14;;22350:1;22345:663;;;;23052:1;23069:6;23066:89;;;-1:-1:-1;23121:19:1;;;23115:26;23066:89;-1:-1:-1;;21870:1:1;21866:11;;;21862:24;21858:29;21848:40;21894:1;21890:11;;;21845:57;23168:81;;22315:944;;22345:663;21139:1;21132:14;;;21176:4;21163:18;;-1:-1:-1;;22381:20:1;;;22499:236;22513:7;22510:1;22507:14;22499:236;;;22602:19;;;22596:26;22581:42;;22694:27;;;;22662:1;22650:14;;;;22529:19;;22499:236;;;22503:3;22763:6;22754:7;22751:19;22748:201;;;22824:19;;;22818:26;-1:-1:-1;;22907:1:1;22903:14;;;22919:3;22899:24;22895:37;22891:42;22876:58;22861:74;;22748:201;-1:-1:-1;;;;;22995:1:1;22979:14;;;22975:22;22962:36;;-1:-1:-1;21913:1352:1:o;23579:399::-;23781:2;23763:21;;;23820:2;23800:18;;;23793:30;23859:34;23854:2;23839:18;;23832:62;-1:-1:-1;;;23925:2:1;23910:18;;23903:33;23968:3;23953:19;;23579:399::o;23983:404::-;24185:2;24167:21;;;24224:2;24204:18;;;24197:30;24263:34;24258:2;24243:18;;24236:62;-1:-1:-1;;;24329:2:1;24314:18;;24307:38;24377:3;24362:19;;23983:404::o;24392:400::-;24594:2;24576:21;;;24633:2;24613:18;;;24606:30;24672:34;24667:2;24652:18;;24645:62;-1:-1:-1;;;24738:2:1;24723:18;;24716:34;24782:3;24767:19;;24392:400::o;24797:465::-;25054:2;25043:9;25036:21;25017:4;25080:56;25132:2;25121:9;25117:18;25109:6;25080:56;:::i;:::-;25184:9;25176:6;25172:22;25167:2;25156:9;25152:18;25145:50;25212:44;25249:6;25241;25212:44;:::i;:::-;25204:52;24797:465;-1:-1:-1;;;;;24797:465:1:o;26282:401::-;26484:2;26466:21;;;26523:2;26503:18;;;26496:30;26562:34;26557:2;26542:18;;26535:62;-1:-1:-1;;;26628:2:1;26613:18;;26606:35;26673:3;26658:19;;26282:401::o;26688:406::-;26890:2;26872:21;;;26929:2;26909:18;;;26902:30;26968:34;26963:2;26948:18;;26941:62;-1:-1:-1;;;27034:2:1;27019:18;;27012:40;27084:3;27069:19;;26688:406::o;27099:561::-;-1:-1:-1;;;;;27396:15:1;;;27378:34;;27448:15;;27443:2;27428:18;;27421:43;27495:2;27480:18;;27473:34;;;27538:2;27523:18;;27516:34;;;27358:3;27581;27566:19;;27559:32;;;27321:4;;27608:46;;27634:19;;27626:6;27608:46;:::i;:::-;27600:54;27099:561;-1:-1:-1;;;;;;;27099:561:1:o;27665:249::-;27734:6;27787:2;27775:9;27766:7;27762:23;27758:32;27755:52;;;27803:1;27800;27793:12;27755:52;27835:9;27829:16;27854:30;27878:5;27854:30;:::i;27919:179::-;27954:3;27996:1;27978:16;27975:23;27972:120;;;28042:1;28039;28036;28021:23;-1:-1:-1;28079:1:1;28073:8;28068:3;28064:18;27972:120;27919:179;:::o;28103:671::-;28142:3;28184:4;28166:16;28163:26;28160:39;;;28103:671;:::o;28160:39::-;28226:2;28220:9;-1:-1:-1;;28291:16:1;28287:25;;28284:1;28220:9;28263:50;28342:4;28336:11;28366:16;28401:18;28472:2;28465:4;28457:6;28453:17;28450:25;28445:2;28437:6;28434:14;28431:45;28428:58;;;28479:5;;;;;28103:671;:::o;28428:58::-;28516:6;28510:4;28506:17;28495:28;;28552:3;28546:10;28579:2;28571:6;28568:14;28565:27;;;28585:5;;;;;;28103:671;:::o;28565:27::-;28669:2;28650:16;28644:4;28640:27;28636:36;28629:4;28620:6;28615:3;28611:16;28607:27;28604:69;28601:82;;;28676:5;;;;;;28103:671;:::o;28601:82::-;28692:57;28743:4;28734:6;28726;28722:19;28718:30;28712:4;28692:57;:::i;:::-;-1:-1:-1;28765:3:1;;28103:671;-1:-1:-1;;;;;28103:671:1:o;29200:404::-;29402:2;29384:21;;;29441:2;29421:18;;;29414:30;29480:34;29475:2;29460:18;;29453:62;-1:-1:-1;;;29546:2:1;29531:18;;29524:38;29594:3;29579:19;;29200:404::o;30019:827::-;-1:-1:-1;;;;;30416:15:1;;;30398:34;;30468:15;;30463:2;30448:18;;30441:43;30378:3;30515:2;30500:18;;30493:31;;;30341:4;;30547:57;;30584:19;;30576:6;30547:57;:::i;:::-;30652:9;30644:6;30640:22;30635:2;30624:9;30620:18;30613:50;30686:44;30723:6;30715;30686:44;:::i;:::-;30672:58;;30779:9;30771:6;30767:22;30761:3;30750:9;30746:19;30739:51;30807:33;30833:6;30825;30807:33;:::i;:::-;30799:41;30019:827;-1:-1:-1;;;;;;;;30019:827:1:o

Swarm Source

ipfs://679ea2b944dc7e482ed76a2b64d35782b8ac9746b6438b5fde02faebe84adfdd

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