Token

MINER (MINER)

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

Token migration announcement. MINER token contract has migrated to a new address.

ERC-1155

Old Contract

Overview

Max Total Supply

100,000 MINER

Holders

2,147 (0.00%)

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xe77ec1bf3a5c95bfe3be7bdbacfe3ac1c7e454cd

Filtered by Token Holder

0x44fFD26d1545f46eeD9DF5a5587129e64f5E2389

0x44ffd26d1545f46eed9df5a5587129e64f5e2389

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ERC_X

Compiler Version

v0.8.24+commit.e11b9ed9

Optimization Enabled:

Yes with 100000 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-02-11
*/

//Inspired by all the great work out there from ERC20, 404, 721, 721a, 721Psi, 1155, 1155Delta

// SPDX-License-Identifier: MIT

pragma solidity 0.8.24;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling 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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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);
    }
}

interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 value) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
}

interface IERC20Errors {
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
    error ERC20InvalidSender(address sender);
    error ERC20InvalidReceiver(address receiver);
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
    error ERC20InvalidApprover(address approver);
    error ERC20InvalidSpender(address spender);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }
}

interface IERCX {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * Cannot burn from the zero address.
     */
    error BurnFromZeroAddress();

    /**
     * Cannot burn from the address that doesn't owne the token.
     */
    error BurnFromNonOnwerAddress();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from` or the `amount` is not 1.
     */
    error TransferFromIncorrectOwnerOrInvalidAmount();

    /**
     * Cannot safely transfer to a contract that does not implement the
     * ERC1155Receiver interface.
     */
    error TransferToNonERC1155ReceiverImplementer();
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The length of input arraies is not matching.
     */
    error InputLengthMistmatch();

    function isOwnerOf(address account, uint256 id) external view returns(bool);
}

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

/**
 * @dev Interface that must be implemented by smart contracts in order to receive
 * ERC-1155 token transfers.
 */
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);
}


abstract contract ERC721Receiver {
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external virtual returns (bytes4) {
        return ERC721Receiver.onERC721Received.selector;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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


/// @notice Library for bit twiddling and boolean operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibBit.sol)
/// @author Inspired by (https://graphics.stanford.edu/~seander/bithacks.html)
library LibBit {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  BIT TWIDDLING OPERATIONS                  */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Find last set.
    /// Returns the index of the most significant bit of `x`,
    /// counting from the least significant bit position.
    /// If `x` is zero, returns 256.
    function fls(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            r := or(shl(8, iszero(x)), shl(7, lt(0xffffffffffffffffffffffffffffffff, x)))
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            // forgefmt: disable-next-item
            r := or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
                0x0706060506020504060203020504030106050205030304010505030400000000))
        }
    }

    /// @dev Count leading zeros.
    /// Returns the number of zeros preceding the most significant one bit.
    /// If `x` is zero, returns 256.
    function clz(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            // forgefmt: disable-next-item
            r := add(xor(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
                0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff)), iszero(x))
        }
    }

    /// @dev Find first set.
    /// Returns the index of the least significant bit of `x`,
    /// counting from the least significant bit position.
    /// If `x` is zero, returns 256.
    /// Equivalent to `ctz` (count trailing zeros), which gives
    /// the number of zeros following the least significant one bit.
    function ffs(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            // Isolate the least significant bit.
            let b := and(x, add(not(x), 1))

            r := or(shl(8, iszero(x)), shl(7, lt(0xffffffffffffffffffffffffffffffff, b)))
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, b))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, b))))

            // For the remaining 32 bits, use a De Bruijn lookup.
            // forgefmt: disable-next-item
            r := or(r, byte(and(div(0xd76453e0, shr(r, b)), 0x1f),
                0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405))
        }
    }

    /// @dev Returns the number of set bits in `x`.
    function popCount(uint256 x) internal pure returns (uint256 c) {
        /// @solidity memory-safe-assembly
        assembly {
            let max := not(0)
            let isMax := eq(x, max)
            x := sub(x, and(shr(1, x), div(max, 3)))
            x := add(and(x, div(max, 5)), and(shr(2, x), div(max, 5)))
            x := and(add(x, shr(4, x)), div(max, 17))
            c := or(shl(8, isMax), shr(248, mul(x, div(max, 255))))
        }
    }

    /// @dev Returns whether `x` is a power of 2.
    function isPo2(uint256 x) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to `x && !(x & (x - 1))`.
            result := iszero(add(and(x, sub(x, 1)), iszero(x)))
        }
    }

    /// @dev Returns `x` reversed at the bit level.
    function reverseBits(uint256 x) internal pure returns (uint256 r) {
        uint256 m0 = 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f;
        uint256 m1 = m0 ^ (m0 << 2);
        uint256 m2 = m1 ^ (m1 << 1);
        r = reverseBytes(x);
        r = (m2 & (r >> 1)) | ((m2 & r) << 1);
        r = (m1 & (r >> 2)) | ((m1 & r) << 2);
        r = (m0 & (r >> 4)) | ((m0 & r) << 4);
    }

    /// @dev Returns `x` reversed at the byte level.
    function reverseBytes(uint256 x) internal pure returns (uint256 r) {
        unchecked {
            // Computing masks on-the-fly reduces bytecode size by about 200 bytes.
            uint256 m0 = 0x100000000000000000000000000000001 * (~toUint(x == 0) >> 192);
            uint256 m1 = m0 ^ (m0 << 32);
            uint256 m2 = m1 ^ (m1 << 16);
            uint256 m3 = m2 ^ (m2 << 8);
            r = (m3 & (x >> 8)) | ((m3 & x) << 8);
            r = (m2 & (r >> 16)) | ((m2 & r) << 16);
            r = (m1 & (r >> 32)) | ((m1 & r) << 32);
            r = (m0 & (r >> 64)) | ((m0 & r) << 64);
            r = (r >> 128) | (r << 128);
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     BOOLEAN OPERATIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // A Solidity bool on the stack or memory is represented as a 256-bit word.
    // Non-zero values are true, zero is false.
    // A clean bool is either 0 (false) or 1 (true) under the hood.
    // Usually, if not always, the bool result of a regular Solidity expression,
    // or the argument of a public/external function will be a clean bool.
    // You can usually use the raw variants for more performance.
    // If uncertain, test (best with exact compiler settings).
    // Or use the non-raw variants (compiler can sometimes optimize out the double `iszero`s).

    /// @dev Returns `x & y`. Inputs must be clean.
    function rawAnd(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := and(x, y)
        }
    }

    /// @dev Returns `x & y`.
    function and(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := and(iszero(iszero(x)), iszero(iszero(y)))
        }
    }

    /// @dev Returns `x | y`. Inputs must be clean.
    function rawOr(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := or(x, y)
        }
    }

    /// @dev Returns `x | y`.
    function or(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := or(iszero(iszero(x)), iszero(iszero(y)))
        }
    }

    /// @dev Returns 1 if `b` is true, else 0. Input must be clean.
    function rawToUint(bool b) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := b
        }
    }

    /// @dev Returns 1 if `b` is true, else 0.
    function toUint(bool b) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := iszero(iszero(b))
        }
    }
}

/// @notice Library for storage of packed unsigned booleans.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibBitmap.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibBitmap.sol)
/// @author Modified from Solidity-Bits (https://github.com/estarriolvetch/solidity-bits/blob/main/contracts/BitMaps.sol)
library LibBitmap {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The constant returned when a bitmap scan does not find a result.
    uint256 internal constant NOT_FOUND = type(uint256).max;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev A bitmap in storage.
    struct Bitmap {
        mapping(uint256 => uint256) map;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         OPERATIONS                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the boolean value of the bit at `index` in `bitmap`.
    function get(Bitmap storage bitmap, uint256 index) internal view returns (bool isSet) {
        // It is better to set `isSet` to either 0 or 1, than zero vs non-zero.
        // Both cost the same amount of gas, but the former allows the returned value
        // to be reused without cleaning the upper bits.
        uint256 b = (bitmap.map[index >> 8] >> (index & 0xff)) & 1;
        /// @solidity memory-safe-assembly
        assembly {
            isSet := b
        }
    }

    /// @dev Updates the bit at `index` in `bitmap` to true.
    function set(Bitmap storage bitmap, uint256 index) internal {
        bitmap.map[index >> 8] |= (1 << (index & 0xff));
    }

    /// @dev Updates the bit at `index` in `bitmap` to false.
    function unset(Bitmap storage bitmap, uint256 index) internal {
        bitmap.map[index >> 8] &= ~(1 << (index & 0xff));
    }

    /// @dev Flips the bit at `index` in `bitmap`.
    /// Returns the boolean result of the flipped bit.
    function toggle(Bitmap storage bitmap, uint256 index) internal returns (bool newIsSet) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, index))
            let storageSlot := keccak256(0x00, 0x40)
            let shift := and(index, 0xff)
            let storageValue := xor(sload(storageSlot), shl(shift, 1))
            // It makes sense to return the `newIsSet`,
            // as it allow us to skip an additional warm `sload`,
            // and it costs minimal gas (about 15),
            // which may be optimized away if the returned value is unused.
            newIsSet := and(1, shr(shift, storageValue))
            sstore(storageSlot, storageValue)
        }
    }

    /// @dev Updates the bit at `index` in `bitmap` to `shouldSet`.
    function setTo(Bitmap storage bitmap, uint256 index, bool shouldSet) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, index))
            let storageSlot := keccak256(0x00, 0x40)
            let storageValue := sload(storageSlot)
            let shift := and(index, 0xff)
            sstore(
                storageSlot,
                // Unsets the bit at `shift` via `and`, then sets its new value via `or`.
                or(and(storageValue, not(shl(shift, 1))), shl(shift, iszero(iszero(shouldSet))))
            )
        }
    }

    /// @dev Consecutively sets `amount` of bits starting from the bit at `start`.
    function setBatch(Bitmap storage bitmap, uint256 start, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let max := not(0)
            let shift := and(start, 0xff)
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, start))
            if iszero(lt(add(shift, amount), 257)) {
                let storageSlot := keccak256(0x00, 0x40)
                sstore(storageSlot, or(sload(storageSlot), shl(shift, max)))
                let bucket := add(mload(0x00), 1)
                let bucketEnd := add(mload(0x00), shr(8, add(amount, shift)))
                amount := and(add(amount, shift), 0xff)
                shift := 0
                for {} iszero(eq(bucket, bucketEnd)) { bucket := add(bucket, 1) } {
                    mstore(0x00, bucket)
                    sstore(keccak256(0x00, 0x40), max)
                }
                mstore(0x00, bucket)
            }
            let storageSlot := keccak256(0x00, 0x40)
            sstore(storageSlot, or(sload(storageSlot), shl(shift, shr(sub(256, amount), max))))
        }
    }

    /// @dev Consecutively unsets `amount` of bits starting from the bit at `start`.
    function unsetBatch(Bitmap storage bitmap, uint256 start, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let shift := and(start, 0xff)
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, start))
            if iszero(lt(add(shift, amount), 257)) {
                let storageSlot := keccak256(0x00, 0x40)
                sstore(storageSlot, and(sload(storageSlot), not(shl(shift, not(0)))))
                let bucket := add(mload(0x00), 1)
                let bucketEnd := add(mload(0x00), shr(8, add(amount, shift)))
                amount := and(add(amount, shift), 0xff)
                shift := 0
                for {} iszero(eq(bucket, bucketEnd)) { bucket := add(bucket, 1) } {
                    mstore(0x00, bucket)
                    sstore(keccak256(0x00, 0x40), 0)
                }
                mstore(0x00, bucket)
            }
            let storageSlot := keccak256(0x00, 0x40)
            sstore(
                storageSlot, and(sload(storageSlot), not(shl(shift, shr(sub(256, amount), not(0)))))
            )
        }
    }

    /// @dev Returns number of set bits within a range by
    /// scanning `amount` of bits starting from the bit at `start`.
    function popCount(Bitmap storage bitmap, uint256 start, uint256 amount)
        internal
        view
        returns (uint256 count)
    {
        unchecked {
            uint256 bucket = start >> 8;
            uint256 shift = start & 0xff;
            if (!(amount + shift < 257)) {
                count = LibBit.popCount(bitmap.map[bucket] >> shift);
                uint256 bucketEnd = bucket + ((amount + shift) >> 8);
                amount = (amount + shift) & 0xff;
                shift = 0;
                for (++bucket; bucket != bucketEnd; ++bucket) {
                    count += LibBit.popCount(bitmap.map[bucket]);
                }
            }
            count += LibBit.popCount((bitmap.map[bucket] >> shift) << (256 - amount));
        }
    }

    /// @dev Returns the index of the most significant set bit before the bit at `before`.
    /// If no set bit is found, returns `NOT_FOUND`.
    function findLastSet(Bitmap storage bitmap, uint256 before)
        internal
        view
        returns (uint256 setBitIndex)
    {
        uint256 bucket;
        uint256 bucketBits;
        /// @solidity memory-safe-assembly
        assembly {
            setBitIndex := not(0)
            bucket := shr(8, before)
            mstore(0x00, bucket)
            mstore(0x20, bitmap.slot)
            let offset := and(0xff, not(before)) // `256 - (255 & before) - 1`.
            bucketBits := shr(offset, shl(offset, sload(keccak256(0x00, 0x40))))
            if iszero(or(bucketBits, iszero(bucket))) {
                for {} 1 {} {
                    bucket := add(bucket, setBitIndex) // `sub(bucket, 1)`.
                    mstore(0x00, bucket)
                    bucketBits := sload(keccak256(0x00, 0x40))
                    if or(bucketBits, iszero(bucket)) { break }
                }
            }
        }
        if (bucketBits != 0) {
            setBitIndex = (bucket << 8) | LibBit.fls(bucketBits);
            /// @solidity memory-safe-assembly
            assembly {
                setBitIndex := or(setBitIndex, sub(0, gt(setBitIndex, before)))
            }
        }
    }
}

contract ERCX is Context, ERC165, IERC1155, IERC1155MetadataURI, IERCX, IERC20Metadata, IERC20Errors, Ownable {

    using Address for address;
    using LibBitmap for LibBitmap.Bitmap;

    error InvalidQueryRange();

    // The mask of the lower 160 bits for addresses.
    uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;
    // The `Transfer` event signature is given by:
    // `keccak256(bytes("Transfer(address,address,uint256)"))`.
    bytes32 private constant _TRANSFER_EVENT_SIGNATURE = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    // Mapping from accout to owned tokens
    mapping(address => LibBitmap.Bitmap) internal _owned;
    
    // 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;

    // The next token ID to be minted.
    uint256 private _currentIndex;

    // NFT Approval
    mapping(uint256 => address) public getApproved;

    //Token balances
    mapping(address => uint256) internal _balances;

    //Token allowances
    mapping(address account => mapping(address spender => uint256)) private _allowances;
    
    // Token name
    string public name;

    // Token symbol
    string public symbol;

    // Decimals for supply
    uint8 public immutable decimals;

    // Total ERC20 supply
    uint256 public immutable totalSupply;

    // Tokens Per NFT
    uint256 public immutable decimalFactor;
    uint256 public immutable tokensPerNFT;

    // Don't mint for these wallets
    mapping(address => bool) public whitelist;

    // Easy Launch - auto-whitelist first transfer which is probably the LP
    uint256 public easyLaunch = 1;

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_, string memory _name, string memory _symbol, uint8 _decimals, uint256 _totalNativeSupply, uint256 _tokensPerNFT) Ownable(msg.sender) {
        _setURI(uri_);
        _currentIndex = _startTokenId();
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        decimalFactor = 10 ** decimals;
        tokensPerNFT = _tokensPerNFT * decimalFactor;
        totalSupply = _totalNativeSupply * decimalFactor;
        whitelist[msg.sender] = true;
        _balances[msg.sender] = totalSupply;
        emit Transfer(address(0), msg.sender, totalSupply);
    }

    /** @notice Initialization function to set pairs / etc
     *  saving gas by avoiding mint / burn on unnecessary targets
     */
    function setWhitelist(address target, bool state) public virtual onlyOwner {
        whitelist[target] = state;
    }

    /**
     * @dev Returns the starting token ID.
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal pure virtual returns (uint256) {
        return 1;
    }

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view returns (uint256) {
        return _currentIndex;
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        return _nextTokenId() - _startTokenId();
    }

    /**
     * @dev Returns true if the account owns the `id` token.
     */
    function isOwnerOf(address account, uint256 id) public view virtual override returns(bool) {
        return _owned[account].get(id);
    }

    /**
     * @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 ||
            interfaceId == type(IERCX).interfaceId ||
            interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
            interfaceId == 0x5b5e139f || // ERC165 interface ID for ERC721Metadata.
            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 Returns the number of tokens owned by `owner`.
     */
    function balanceOf(address owner) public view virtual returns (uint256) {
        return _balances[owner];
    }

    /**
     * @dev Returns the number of nfts owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * Requirements:
     *
     * - `start < stop`
     */
    function balanceOf(address owner, uint256 start, uint256 stop) public view virtual returns (uint256) {
        return _owned[owner].popCount(start, stop - start);
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        if(account == address(0)) {
            revert BalanceQueryForZeroAddress();
        }
        if(_owned[account].get(id)) {
            return 1;
        } else {
            return 0;
        }   
    }

    /**
     * @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)
    {
        if(accounts.length != ids.length) {
            revert InputLengthMistmatch();
        }

        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 {
        if(from == _msgSender() || isApprovedForAll(from, _msgSender())){
            _safeTransferFrom(from, to, id, amount, data, true);
        } else {
            revert TransferCallerNotOwnerNorApproved();
        }
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        if(!(from == _msgSender() || isApprovedForAll(from, _msgSender()))) {
            revert TransferCallerNotOwnerNorApproved();
        }
        _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.
     * - `amount` cannot be zero.
     * - `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,
        bool check
    ) internal virtual {
        if(to == address(0)) {
            revert TransferToZeroAddress();
        }

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

        _beforeTokenTransfer(operator, from, to, ids);

        if(amount == 1 && _owned[from].get(id)) {
            _owned[from].unset(id);
            _owned[to].set(id);
            _transfer(from, to, tokensPerNFT, false);
        } else {
            revert TransferFromIncorrectOwnerOrInvalidAmount();
        }

        uint256 toMasked;
        uint256 fromMasked;
        assembly {
            // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
            toMasked := and(to, _BITMASK_ADDRESS)
            fromMasked := and(from, _BITMASK_ADDRESS)
            // Emit the `Transfer` event.
            log4(
                0, // Start of data (0, since no data).
                0, // End of data (0, since no data).
                _TRANSFER_EVENT_SIGNATURE, // Signature.
                fromMasked, // `from`.
                toMasked, // `to`.
                amount // `tokenId`.
            )
        }

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

        _afterTokenTransfer(operator, from, to, ids);

        if(check)
            _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 {
        if(ids.length != amounts.length) {
            revert InputLengthMistmatch();
        }

        if(to == address(0)) {
            revert TransferToZeroAddress();
        }
        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids);

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

            if(amount == 1 && _owned[from].get(id)) {
                _owned[from].unset(id);
                _owned[to].set(id);
            } else {
                revert TransferFromIncorrectOwnerOrInvalidAmount();
            }
        }
        _transfer(from, to, tokensPerNFT * ids.length, false);

        uint256 toMasked;
        uint256 fromMasked;
        uint256 end = ids.length + 1;

        // Use assembly to loop and emit the `Transfer` event for gas savings.
        // The duplicated `log4` removes an extra check and reduces stack juggling.
        // The assembly, together with the surrounding Solidity code, have been
        // delicately arranged to nudge the compiler into producing optimized opcodes.
        assembly {
            // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
            fromMasked := and(from, _BITMASK_ADDRESS)
            toMasked := and(to, _BITMASK_ADDRESS)
            // Emit the `Transfer` event.
            log4(
                0, // Start of data (0, since no data).
                0, // End of data (0, since no data).
                _TRANSFER_EVENT_SIGNATURE, // Signature.
                fromMasked, // `from`.
                toMasked, // `to`.
                mload(add(ids, 0x20)) // `tokenId`.
            )

            // The `iszero(eq(,))` check ensures that large values of `quantity`
            // that overflows uint256 will make the loop run out of gas.
            // The compiler will optimize the `iszero` away for performance.
            for {
                let arrayId := 2
            } iszero(eq(arrayId, end)) {
                arrayId := add(arrayId, 1)
            } {
                // Emit the `Transfer` event. Similar to above.
                log4(0, 0, _TRANSFER_EVENT_SIGNATURE, fromMasked, toMasked, mload(add(ids, mul(0x20, arrayId))))
            }
        }

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

        _afterTokenTransfer(operator, from, to, ids);

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

    function _mint(
        address to,
        uint256 amount
    ) internal virtual {
        _mint(to, amount, "");
    }

    /**
     * @dev Creates `amount` tokens, and assigns them to `to`.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `amount` cannot be zero.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 amount,
        bytes memory data
    ) internal virtual {
       (uint256[] memory ids, uint256[] memory amounts) =  _mintWithoutCheck(to, amount);

        uint256 end = _currentIndex;
        _doSafeBatchTransferAcceptanceCheck(_msgSender(), address(0), to, ids, amounts, data);
        if (_currentIndex != end) revert();
    }

    function _mintWithoutCheck(
        address to,
        uint256 amount
    ) internal virtual returns(uint256[] memory ids, uint256[] memory amounts) {

        if(to == address(0)) {
            revert MintToZeroAddress();
        }
        if(amount == 0) {
            revert MintZeroQuantity();
        }

        address operator = _msgSender();

        ids = new uint256[](amount);
        amounts = new uint256[](amount);
        uint256 startTokenId = _nextTokenId();

        unchecked {
            require(type(uint256).max - amount >= startTokenId);
            for(uint256 i = 0; i < amount; i++) {
                ids[i] = startTokenId + i;
                amounts[i] = 1;
            }
        }
        
        _beforeTokenTransfer(operator, address(0), to, ids);

        _owned[to].setBatch(startTokenId, amount);
        _currentIndex += amount;

        uint256 toMasked;
        uint256 end = startTokenId + amount;

        assembly {
            toMasked := and(to, _BITMASK_ADDRESS)
            log4(
                0,
                0,
                _TRANSFER_EVENT_SIGNATURE,
                0,
                toMasked,
                startTokenId
            )

            for {
                let tokenId := add(startTokenId, 1)
            } iszero(eq(tokenId, end)) {
                tokenId := add(tokenId, 1)
            } {
                log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
            }
        }

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

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

    }

    /**
     * @dev Destroys token of token type `id` from `from`
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have the token of token type `id`.
     */
    function _burn(
        address from,
        uint256 id
    ) internal virtual {
        if(from == address(0)){
            revert BurnFromZeroAddress();
        }

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

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

        if(!_owned[from].get(id)) {
            revert BurnFromNonOnwerAddress();
        }

        _owned[from].unset(id);

        uint256 fromMasked;
        assembly {
            fromMasked := and(from, _BITMASK_ADDRESS)
            log4(
                0,
                0,
                _TRANSFER_EVENT_SIGNATURE,
                fromMasked,
                0,
                id
            )
        }

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

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

    /**
     * @dev Destroys tokens of token types in `ids` from `from`
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have the token of token types in `ids`.
     */
    function _burnBatch(
        address from,
        uint256[] memory ids
    ) internal virtual {
        if(from == address(0)){
            revert BurnFromZeroAddress();
        }

        address operator = _msgSender();

        uint256[] memory amounts = new uint256[](ids.length);

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

        unchecked {
            for(uint256 i = 0; i < ids.length; i++) {
                amounts[i] = 1;
                uint256 id = ids[i];
                if(!_owned[from].get(id)) {
                    revert BurnFromNonOnwerAddress();
                }
                _owned[from].unset(id);
            }
        }

        uint256 fromMasked;
        uint256 end = ids.length + 1;

        assembly {
            fromMasked := and(from, _BITMASK_ADDRESS)
            log4(
                0,
                0,
                _TRANSFER_EVENT_SIGNATURE,
                fromMasked,
                0,
                mload(add(ids, 0x20))
            )

            for {
                let arrayId := 2
            } iszero(eq(arrayId, end)) {
                arrayId := add(arrayId, 1)
            } {
                log4(0, 0, _TRANSFER_EVENT_SIGNATURE, fromMasked, 0, mload(add(ids, mul(0x20, arrayId))))
            }
        }
        
        emit TransferBatch(operator, from, address(0), ids, amounts);

        _afterTokenTransfer(operator, from, address(0), ids);

    }

    function _burnBatch(
        address from,
        uint256 amount
    ) internal virtual {
        if(from == address(0)){
            revert BurnFromZeroAddress();
        }

        address operator = _msgSender();

        uint256 searchFrom = _nextTokenId();

        uint256[] memory amounts = new uint256[](amount);
        uint256[] memory ids = new uint256[](amount);

        unchecked {
            for(uint256 i = 0; i < amount; i++) {
                amounts[i] = 1;
                uint256 id = _owned[from].findLastSet(searchFrom);
                ids[i] = id;
                _owned[from].unset(id);
                searchFrom = id;
            }
        }

        //technically after, but we didn't have the IDs then
        _beforeTokenTransfer(operator, from, address(0), ids);

        uint256 fromMasked;
        uint256 end = amount + 1;

        assembly {
            fromMasked := and(from, _BITMASK_ADDRESS)
            log4(
                0,
                0,
                _TRANSFER_EVENT_SIGNATURE,
                fromMasked,
                0,
                mload(add(ids, 0x20))
            )

            for {
                let arrayId := 2
            } iszero(eq(arrayId, end)) {
                arrayId := add(arrayId, 1)
            } {
                log4(0, 0, _TRANSFER_EVENT_SIGNATURE, fromMasked, 0, mload(add(ids, mul(0x20, arrayId))))
            }
        }

        if(amount == 1)
            emit TransferSingle(operator, from, address(0), ids[0], 1);
        else
            emit TransferBatch(operator, from, address(0), ids, amounts);
        

        _afterTokenTransfer(operator, from, address(0), ids);

    }


     /**
     * @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
    ) 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
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            if (IERC165(to).supportsInterface(type(IERC1155).interfaceId)) {
                try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                    if (response != IERC1155Receiver.onERC1155Received.selector) {
                        revert TransferToNonERC1155ReceiverImplementer();
                    }
                } catch Error(string memory reason) {
                    revert(reason);
                } catch {
                    revert TransferToNonERC1155ReceiverImplementer();
                }
            }
            else {
                try ERC721Receiver(to).onERC721Received(operator, from, id, data) returns (bytes4 response) {
                    if (response != ERC721Receiver.onERC721Received.selector) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } catch Error(string memory reason) {
                    revert(reason);
                } catch {
                    revert TransferToNonERC721ReceiverImplementer();
                }
            }
        }
    }

    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 TransferToNonERC1155ReceiverImplementer();
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert TransferToNonERC1155ReceiverImplementer();
            }
        }
    }

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

    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = msg.sender;
        _transfer(owner, to, value, true);
        return true;
    }

    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = msg.sender;
        if (value < _nextTokenId() && value > 0) {

            if(!isOwnerOf(owner, value)) {
                revert ERC20InvalidSender(owner);
            }

            getApproved[value] = spender;

            emit Approval(owner, spender, value);
        } else {
            _approve(owner, spender, value);
        }
        return true;
    }

    /// @notice Function for mixed transfers
    /// @dev This function assumes id / native if amount less than or equal to current max id
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        if (value < _nextTokenId()) {
            if(!_owned[from].get(value)) {
                revert ERC20InvalidSpender(from);
            }    

            if (
                msg.sender != from &&
                !isApprovedForAll(from, msg.sender) &&
                msg.sender != getApproved[value]
            ) {
                revert ERC20InvalidSpender(msg.sender);
            }

            _transfer(from, to, tokensPerNFT, false);

            delete getApproved[value];

            _safeTransferFrom(from, to, value, 1, "", false);

        } else {
            _spendAllowance(from, msg.sender, value);
            _transfer(from, to, value, true);
        }
        return true;
    }

    function _transfer(address from, address to, uint256 value, bool mint) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value, mint);
    }

    function _update(address from, address to, uint256 value, bool mint) internal virtual {
        uint256 fromBalance = _balances[from];
        uint256 toBalance = _balances[to];
        if (fromBalance < value) {
            revert ERC20InsufficientBalance(from, fromBalance, value);
        }

        unchecked {
            // Overflow not possible: value <= fromBalance <= totalSupply.
            _balances[from] = fromBalance - value;

            // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
            _balances[to] = toBalance + value;
        }

        emit Transfer(from, to, value);

        if(mint) {
            // Skip burn for certain addresses to save gas
            bool wlf = whitelist[from];
            if (!wlf) {
                uint256 tokens_to_burn = (fromBalance / tokensPerNFT) - ((fromBalance - value) / tokensPerNFT);
                if(tokens_to_burn > 0)
                    _burnBatch(from, tokens_to_burn);
            }

            // Skip minting for certain addresses to save gas
            if (!whitelist[to]) {
                if(easyLaunch == 1 && wlf && from == owner()) {
                    //auto-initialize first (assumed) LP
                    whitelist[to] = true;
                    easyLaunch = 2;
                } else {
                    uint256 tokens_to_mint = ((toBalance + value) / tokensPerNFT) - (toBalance / tokensPerNFT);
                    if(tokens_to_mint > 0)
                        _mintWithoutCheck(to, tokens_to_mint);
                }
            }
        }
    }

    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC1155DelataQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start < stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) public view virtual returns (uint256[] memory) {
        unchecked {
            if (start >= stop) revert InvalidQueryRange();
            
            
            // Set `start = max(start, _startTokenId())`.
            if (start < _startTokenId()) {
                start = _startTokenId();
            }
            
            // Set `stop = min(stop, stopLimit)`.
            uint256 stopLimit = _nextTokenId();
            if (stop > stopLimit) {
                stop = stopLimit;
            }

            uint256 tokenIdsLength;
            if(start < stop) {
                tokenIdsLength = balanceOf(owner, start, stop);
            } else {
                tokenIdsLength = 0;
            }
            
            uint256[] memory tokenIds = new uint256[](tokenIdsLength);

            LibBitmap.Bitmap storage bmap = _owned[owner];
            
            for ((uint256 i, uint256 tokenIdsIdx) = (start, 0); tokenIdsIdx != tokenIdsLength; ++i) {
                if(bmap.get(i) ) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            return tokenIds;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC1155DeltaQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K collections should be fine).
     */
    function tokensOfOwner(address owner) public view virtual returns (uint256[] memory) {
        if(_totalMinted() == 0) {
            return new uint256[](0);
        }
        return tokensOfOwnerIn(owner, _startTokenId(), _nextTokenId());
    }
}

contract ERC_X is ERCX {
    using Strings for uint256;
    string public dataURI;
    string public baseTokenURI;
    
    uint8 private constant _decimals = 18;
    uint256 private constant _totalTokens = 100000;
    uint256 private constant _tokensPerNFT = 1;
    string private constant _name = "MINER";
    string private constant _ticker = "MINER";

    // Snipe reduction tools
    uint256 public maxWallet;
    bool public transferDelay = true;
    mapping (address => uint256) private delayTimer;

    constructor() ERCX("", _name, _ticker, _decimals, _totalTokens, _tokensPerNFT) {
        dataURI = "https://i.ibb.co/";
        maxWallet = (_totalTokens * 10 ** _decimals) * 2 / 100;
    }

    function _afterTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids
    ) internal override {
        if(!whitelist[to]) {
            require(_balances[to] <= maxWallet, "Transfer exceeds maximum wallet");
            if (transferDelay) {
                require(delayTimer[tx.origin] < block.number,"Only one transfer per block allowed.");
                delayTimer[tx.origin] = block.number;

                require(address(to).code.length == 0 && address(tx.origin).code.length == 0, "Contract trading restricted at launch");
            }
        }
        
        
        super._afterTokenTransfer(operator, from, to, ids);
    }

    function toggleDelay() external onlyOwner {
        transferDelay = !transferDelay;
    }

    function setMaxWallet(uint256 percent) external onlyOwner {
        maxWallet = totalSupply * percent / 100;
    }

    function setDataURI(string memory _dataURI) public onlyOwner {
        dataURI = _dataURI;
    }

    function setTokenURI(string memory _tokenURI) public onlyOwner {
        baseTokenURI = _tokenURI;
    }

    function setURI(string memory newuri) external onlyOwner {
        _setURI(newuri);
    }

    function tokenURI(uint256 id) public view returns (string memory) {
        if(id >= _nextTokenId()) revert InputLengthMistmatch();

        if (bytes(super.uri(id)).length > 0)
            return super.uri(id);
        if (bytes(baseTokenURI).length > 0)
            return string(abi.encodePacked(baseTokenURI, id.toString()));
        else {
            uint8 seed = uint8(bytes1(keccak256(abi.encodePacked(id))));

            string memory image;
            string memory color;
            string memory description;

            if (seed <= 63) {
                image = "GQRhWyF/Diamond.jpg";
                color = "Diamond";
                description = "Legendary NFTs powered by ERC1155. The Diamond NFTs are meticulously mined by industry elites and crafted with unparalleled precision, representing the zenith of luxury and digital artistry.";
            } else if (seed <= 127) {
                image = "gwdLf3f/Gold.jpg";
                color = "Gold";
                description = "Prestigious NFTs powered by ERC1155. The gold NFTs are carefully mined by expert collectors and meticulously crafted with golden excellence, symbolizing the pinnacle of digital rarity and exclusivity.";
            } else if (seed <= 191) {
                image = "FJmdrdm/Silver.jpg";
                color = "Silver";
                description = "Refined NFTs powered by ERC1155. The silver NFTs are mined by seasoned enthusiasts, adding an extra layer of sophistication to your portfolio.";
            } else if (seed <= 255) {
                image = "YLG3Jvc/Bronze.jpg";
                color = "Bronze";
                description = "Entry level NFTs powered by ERC1155. The silver NFTs are mined by aspiring collectors and meticulously crafted for accessibility.";
            }

            string memory jsonPreImage = string(abi.encodePacked('{"name": "MINER #', id.toString(), '","description":"', description, '","external_url":"https://miner.build","image":"', dataURI, image));
            return string(abi.encodePacked("data:application/json;utf8,", jsonPreImage, '","attributes":[{"trait_type":"Color","value":"', color, '"}]}'));
        }
    }

    function uri(uint256 id) public view override returns (string memory) {
        return tokenURI(id);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"BurnFromNonOnwerAddress","type":"error"},{"inputs":[],"name":"BurnFromZeroAddress","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"InputLengthMistmatch","type":"error"},{"inputs":[],"name":"InvalidQueryRange","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwnerOrInvalidAmount","type":"error"},{"inputs":[],"name":"TransferToNonERC1155ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","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":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"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":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dataURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimalFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"easyLaunch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"isOwnerOf","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_dataURI","type":"string"}],"name":"setDataURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"percent","type":"uint256"}],"name":"setMaxWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newuri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"setWhitelist","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":[],"name":"toggleDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"tokensOfOwnerIn","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokensPerNFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"transferDelay","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

74479:4322:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46247:318;;;;;;:::i;:::-;;:::i;:::-;;;620:25:1;;;608:2;593:18;46247:318:0;;;;;;;;44455:527;;;;;;:::i;:::-;;:::i;:::-;;;1253:14:1;;1246:22;1228:41;;1216:2;1201:18;44455:527:0;1088:187:1;76373:91:0;;;;;;:::i;:::-;;:::i;:::-;;42073:18;;;:::i;:::-;;;;;;;:::i;41802:46::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3947:42:1;3935:55;;;3917:74;;3905:2;3890:18;41802:46:0;3771:226:1;67588:483:0;;;;;;:::i;:::-;;:::i;74911:32::-;;;;;;;;;78690:108;;;;;;:::i;:::-;;:::i;42245:36::-;;;;;76153:98;;;;;;:::i;:::-;;:::i;68220:827::-;;;;;;:::i;:::-;;:::i;45926:170::-;;;;;;:::i;:::-;;:::i;48288:418::-;;;;;;:::i;:::-;;:::i;42178:31::-;;;;;;;;6931:4:1;6919:17;;;6901:36;;6889:2;6874:18;42178:31:0;6759:184:1;46731:530:0;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;75930:91::-;;;:::i;43416:119::-;;;;;;:::i;:::-;;:::i;42358:37::-;;;;;76029:116;;;;;;:::i;:::-;;:::i;42313:38::-;;;;;45584:114;;;;;;:::i;:::-;45674:16;;45647:7;45674:16;;;:9;:16;;;;;;;45584:114;2727:103;;;:::i;74222:250::-;;;;;;:::i;:::-;;:::i;2052:87::-;2098:7;2125:6;;;2052:87;;42121:20;;;:::i;72506:1264::-;;;;;;:::i;:::-;;:::i;42441:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;42568:29;;;;;;47334:155;;;;;;:::i;:::-;;:::i;67244:186::-;;;;;;:::i;:::-;;:::i;44243:140::-;;;;;;:::i;:::-;;:::i;76472:2210::-;;;;;;:::i;:::-;;:::i;74569:26::-;;;:::i;67438:142::-;;;;;;:::i;:::-;67545:18;;;;67518:7;67545:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;67438:142;76259:106;;;;;;:::i;:::-;;:::i;47561:168::-;;;;;;:::i;:::-;47684:27;;;;47660:4;47684:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;47561:168;47801:410;;;;;;:::i;:::-;;:::i;74541:21::-;;;:::i;2985:220::-;;;;;;:::i;:::-;;:::i;74880:24::-;;;;;;46247:318;46333:7;46356:21;;;46353:88;;46401:28;;;;;;;;;;;;;;46353:88;46454:15;;;;;;;:6;:15;;;;;;;;33806:1;33797:10;;;33786:22;;;;;;;;;33821:4;33813:12;;33786:40;33785:46;46451:104;;;-1:-1:-1;46501:1:0;46494:8;;46451:104;-1:-1:-1;46542:1:0;46451:104;46247:318;;;;:::o;44455:527::-;44557:4;44594:41;;;44609:26;44594:41;;:110;;-1:-1:-1;44652:52:0;;;44667:37;44652:52;44594:110;:165;;;-1:-1:-1;44721:38:0;;;44736:23;44721:38;44594:165;:207;;;-1:-1:-1;44776:25:0;;;;;44594:207;:284;;;-1:-1:-1;44853:25:0;;;;;44594:284;:380;;;-1:-1:-1;24135:25:0;24120:40;;;;44938:36;24011:157;76373:91;1938:13;:11;:13::i;:::-;76441:15:::1;76449:6;76441:7;:15::i;:::-;76373:91:::0;:::o;42073:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;67588:483::-;67661:4;67694:10;67727:14;43922:13;;;43848:95;67727:14;67719:5;:22;:35;;;;;67753:1;67745:5;:9;67719:35;67715:327;;;67777:23;67787:5;67794;67777:9;:23::i;:::-;67773:96;;67828:25;;;;;3947:42:1;3935:55;;67828:25:0;;;3917:74:1;3890:18;;67828:25:0;;;;;;;;67773:96;67885:18;;;;:11;:18;;;;;;;;;:28;;;;;;;;;;;;;;67935:31;;620:25:1;;;67935:31:0;;;;;;593:18:1;67935:31:0;;;;;;;67715:327;;;67999:31;68008:5;68015:7;68024:5;67999:8;:31::i;:::-;-1:-1:-1;68059:4:0;;67588:483;-1:-1:-1;;;67588:483:0:o;78690:108::-;78745:13;78778:12;78787:2;78778:8;:12::i;76153:98::-;1938:13;:11;:13::i;:::-;76225:7:::1;:18;76235:8:::0;76225:7;:18:::1;:::i;:::-;;76153:98:::0;:::o;68220:827::-;68307:4;68336:14;43922:13;;;43848:95;68336:14;68328:5;:22;68324:694;;;68371:12;;;;;;;:6;:12;;;;;;;;33806:1;33797:10;;;33786:22;;;;;;;;;33821:4;33813:12;;33786:40;33785:46;68367:96;;68422:25;;;;;3947:42:1;3935:55;;68422:25:0;;;3917:74:1;3890:18;;68422:25:0;3771:226:1;68367:96:0;68505:10;:18;;;;;;;:74;;-1:-1:-1;47684:27:0;;;47660:4;47684:27;;;:18;:27;;;;;;;;68568:10;47684:37;;;;;;;;;;68544:35;68505:74;:127;;;;-1:-1:-1;68614:18:0;;;;:11;:18;;;;;;;;68600:10;:32;;68505:127;68483:238;;;68674:31;;;;;68694:10;68674:31;;;3917:74:1;3890:18;;68674:31:0;3771:226:1;68483:238:0;68737:40;68747:4;68753:2;68757:12;68771:5;68737:9;:40::i;:::-;68801:18;;;;:11;:18;;;;;;;;68794:25;;;;;;68836:48;;;;;;;;;;;;68854:4;;68860:2;;68813:5;;68794:25;;68836:17;:48::i;:::-;68324:694;;;68919:40;68935:4;68941:10;68953:5;68919:15;:40::i;:::-;68974:32;68984:4;68990:2;68994:5;69001:4;68974:9;:32::i;45926:170::-;46018:7;46045:43;46068:5;46075:12;46068:5;46075:4;:12;:::i;:::-;46045:13;;;;;;;:6;:13;;;;;;:43;:22;:43::i;:::-;46038:50;45926:170;-1:-1:-1;;;;45926:170:0:o;48288:418::-;48504:20;;;273:10;48504:20;;:60;;-1:-1:-1;48528:36:0;48545:4;273:10;47561:168;:::i;48528:36::-;48499:137;;48589:35;;;;;;;;;;;;;;48499:137;48646:52;48669:4;48675:2;48679:3;48684:7;48693:4;48646:22;:52::i;:::-;48288:418;;;;;:::o;46731:530::-;46887:16;46943:3;:10;46924:8;:15;:29;46921:90;;46977:22;;;;;;;;;;;;;;46921:90;47023:30;47070:8;:15;47056:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47056:30:0;;47023:63;;47104:9;47099:122;47123:8;:15;47119:1;:19;47099:122;;;47179:30;47189:8;47198:1;47189:11;;;;;;;;:::i;:::-;;;;;;;47202:3;47206:1;47202:6;;;;;;;;:::i;:::-;;;;;;;47179:9;:30::i;:::-;47160:13;47174:1;47160:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;47140:3;;47099:122;;;-1:-1:-1;47240:13:0;46731:530;-1:-1:-1;;;46731:530:0:o;75930:91::-;1938:13;:11;:13::i;:::-;76000::::1;::::0;;75983:30;;::::1;76000:13;::::0;;::::1;75999:14;75983:30;::::0;;75930:91::o;43416:119::-;1938:13;:11;:13::i;:::-;43502:17:::1;::::0;;;::::1;;::::0;;;:9:::1;:17;::::0;;;;:25;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;43416:119::o;76029:116::-;1938:13;:11;:13::i;:::-;76134:3:::1;76110:21;76124:7:::0;76110:11:::1;:21;:::i;:::-;:27;;;;:::i;:::-;76098:9;:39:::0;-1:-1:-1;76029:116:0:o;2727:103::-;1938:13;:11;:13::i;:::-;2792:30:::1;2819:1;2792:18;:30::i;:::-;2727:103::o:0;74222:250::-;74289:16;74321:14;:12;:14::i;:::-;74339:1;74321:19;74318:74;;-1:-1:-1;;74364:16:0;;;74378:1;74364:16;;;;;;;;;74222:250::o;74318:74::-;74409:55;74425:5;43760:1;43922:13;;72506:1264;:::i;42121:20::-;;;;;;;:::i;72506:1264::-;72638:16;72705:4;72696:5;:13;72692:45;;72718:19;;;;;;;;;;;;;;72692:45;43760:1;72843:5;:23;72839:87;;;43760:1;72887:23;;72839:87;73005:17;73025:14;43922:13;;;43848:95;73025:14;73005:34;;73065:9;73058:4;:16;73054:73;;;73102:9;73095:16;;73054:73;73143:22;73191:4;73183:5;:12;73180:157;;;73233:29;73243:5;73250;73257:4;73233:9;:29::i;:::-;73216:46;;73180:157;;;-1:-1:-1;73320:1:0;73180:157;73365:25;73407:14;73393:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73393:29:0;-1:-1:-1;73471:13:0;;;73439:29;73471:13;;;:6;:13;;;;;73365:57;;-1:-1:-1;73554:5:0;;73513:209;73580:14;73565:11;:29;73513:209;;33806:1;33797:10;;;33524;33786:22;;;;;;;;;;;33821:4;33813:12;;33786:40;33830:1;33785:46;73620:87;;;73686:1;73660:8;73669:13;;;;;;73660:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;73620:87;73596:3;;;;;73513:209;;;-1:-1:-1;73743:8:0;;72506:1264;-1:-1:-1;;;;;;;;72506:1264:0:o;47334:155::-;47429:52;273:10;47462:8;47472;47429:18;:52::i;67244:186::-;67313:4;67346:10;67367:33;67346:10;67384:2;67388:5;67395:4;67367:9;:33::i;44243:140::-;44352:15;;;44328:4;44352:15;;;:6;:15;;;;;;;;33806:1;33797:10;;;33786:22;;;;;;;;33821:4;33813:12;;33786:40;33785:46;44352:23;44345:30;44243:140;-1:-1:-1;;;44243:140:0:o;76472:2210::-;76523:13;76558:14;43922:13;;;43848:95;76558:14;76552:2;:20;76549:54;;76581:22;;;;;;;;;;;;;;76549:54;76650:1;76626:13;76636:2;76626:9;:13::i;:::-;76620:27;:31;76616:70;;;76673:13;76683:2;76673:9;:13::i;76616:70::-;76730:1;76707:12;76701:26;;;;;:::i;:::-;;;:30;76697:1978;;;76777:12;76791:13;:2;:11;:13::i;:::-;76760:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;76746:60;;76472:2210;;;:::o;76697:1978::-;76837:10;76890:2;76873:20;;;;;;15479:19:1;;15523:2;15514:12;;15350:182;76873:20:0;;;;;;;;;;;;;76863:31;;;;;;76850:46;;76837:59;;76913:19;76947;76981:25;77035:2;77027:4;:10;;;77023:1276;;77058:29;;;;;;;;;;;;;;;;;;;77106:17;;;;;;;;;;;;;;;;;;;77142:206;;;;;;;;;;;;;;;;;;;77023:1276;;;77382:3;77374:4;:11;;;77370:929;;77406:26;;;;;;;;;;;;;;;;;;;77451:14;;;;;;;;;;;;;;;;;;;77484:216;;;;;;;;;;;;;;;;;;;77370:929;;;77734:3;77726:4;:11;;;77722:577;;77758:28;;;;;;;;;;;;;;;;;;;77805:16;;;;;;;;;;;;;;;;;;;77840:158;;;;;;;;;;;;;;;;;;;77722:577;;;78032:3;78024:4;:11;;;78020:279;;78056:28;;;;;;;;;;;;;;;;;;;78103:16;;;;;;;;;;;;;;;;;;;78138:145;;;;;;;;;;;;;;;;;;;78020:279;78315:26;78389:13;:2;:11;:13::i;:::-;78425:11;78490:7;78499:5;78351:154;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78315:191;;78583:12;78648:5;78535:127;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78521:142;;;;;;;76472:2210;;;:::o;76697:1978::-;76472:2210;;;:::o;74569:26::-;;;;;;;:::i;76259:106::-;1938:13;:11;:13::i;:::-;76333:12:::1;:24;76348:9:::0;76333:12;:24:::1;:::i;47801:410::-:0;47990:20;;;273:10;47990:20;;:60;;-1:-1:-1;48014:36:0;48031:4;273:10;47561:168;:::i;48014:36::-;47987:217;;;48066:51;48084:4;48090:2;48094;48098:6;48106:4;48112;48066:17;:51::i;:::-;47987:217;;;48157:35;;;;;;;;;;;;;;74541:21;;;;;;;:::i;2985:220::-;1938:13;:11;:13::i;:::-;3070:22:::1;::::0;::::1;3066:93;;3116:31;::::0;::::1;::::0;;3144:1:::1;3116:31;::::0;::::1;3917:74:1::0;3890:18;;3116:31:0::1;3771:226:1::0;3066:93:0::1;3169:28;3188:8;3169:18;:28::i;2217:166::-:0;2098:7;2125:6;2277:23;2125:6;273:10;2277:23;2273:103;;2324:40;;;;;273:10;2324:40;;;3917:74:1;3890:18;;2324:40:0;3771:226:1;54770:88:0;54837:4;:13;54844:6;54837:4;:13;:::i;71036:130::-;71121:37;71130:5;71137:7;71146:5;71153:4;71121:8;:37::i;:::-;71036:130;;;:::o;69055:325::-;69150:18;;;69146:88;;69192:30;;;;;69219:1;69192:30;;;3917:74:1;3890:18;;69192:30:0;3771:226:1;69146:88:0;69248:16;;;69244:88;;69288:32;;;;;69317:1;69288:32;;;3917:74:1;3890:18;;69288:32:0;3771:226:1;69244:88:0;69342:30;69350:4;69356:2;69360:5;69367:4;69342:7;:30::i;:::-;69055:325;;;;:::o;49205:1590::-;49409:16;;;49406:78;;49449:23;;;;;;;;;;;;;;49406:78;273:10;49496:16;49561:21;49579:2;49561:17;:21::i;:::-;49538:44;;49656:6;49666:1;49656:11;:35;;;;-1:-1:-1;49671:12:0;;;;;;;:6;:12;;;;;;;;33806:1;33797:10;;;33786:22;;;;;;;;;33821:4;33813:12;;33786:40;33785:46;49671:20;49653:260;;;49708:12;;;;;;;;:6;:12;;;;;;;;34298:1;34289:10;;;34278:22;;;;;;;;;:48;;34320:4;34312:12;;34306:19;;;34304:22;;34278:48;;;;;;49745:10;;;;;;;;;;;34079:22;;;;;;;;:47;;;;;;;;49778:40;;49708:12;;49745:10;;49798:12;;49778:9;:40::i;:::-;49653:260;;;49858:43;;;;;;;;;;;;;;49653:260;50119:16;50111:25;;;;50164:27;;50517:6;50111:25;50164:27;50383:25;49925:16;;50248:304;50611:2;50580:46;;50605:4;50580:46;;50595:8;50580:46;;;50615:2;50619:6;50580:46;;;;;;18390:25:1;;;18446:2;18431:18;;18424:34;18378:2;18363:18;;18216:248;50580:46:0;;;;;;;;50639:44;50659:8;50669:4;50675:2;50679:3;50639:19;:44::i;:::-;50699:5;50696:91;;;50719:68;50750:8;50760:4;50766:2;50770;50774:6;50782:4;50719:30;:68::i;:::-;49395:1400;;;;49205:1590;;;;;;:::o;71625:487::-;67545:18;;;;71725:24;67545:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;71812:17;71792:37;;71788:317;;71869:5;71850:16;:24;71846:132;;;71902:60;;;;;18701:42:1;18689:55;;71902:60:0;;;18671:74:1;18761:18;;;18754:34;;;18804:18;;;18797:34;;;18644:18;;71902:60:0;18469:368:1;71846:132:0;72021:57;72030:5;72037:7;72065:5;72046:16;:24;72072:5;72021:8;:57::i;38549:786::-;38671:13;38753:1;38744:10;;;38793:4;38785:12;;38835:3;38818:14;;;:20;38812:417;;38884:10;:18;;;;;;;;;;;27918:12;27791:11;38884:27;;;27784:1;27780:9;;;27776:27;;;;27769:35;;27856:1;27852:9;;;27863:11;27848:27;;;27827:19;;27823:53;27910:1;27906:9;;;27899:17;27895:36;27984:13;27977:21;27972:3;27968:31;27707:6;27740:10;;;27957:1;27953:13;27950:50;38962:14;;39030:4;39011:23;;;38962:14;-1:-1:-1;39086:8:0;;;;38931:17;;38981:1;38961:21;38951:32;39081:133;39106:9;39096:6;:19;39081:133;;39175:10;:18;;;;;;;;;;;27918:12;27791:11;27784:1;27780:9;;;27776:27;27769:35;;27856:1;27852:9;;;27863:11;27848:27;;;27827:19;;27823:53;27910:1;27906:9;;;27899:17;27895:36;27984:13;27977:21;27972:3;27968:31;27707:6;27740:10;;;27957:1;27953:13;27950:50;39150:44;;;;39117:8;;;;;39081:133;;;38841:388;38812:417;39269:10;:18;;;;;;;;;;;27918:12;27791:11;39269:27;;;39302:3;:12;;;39268:47;27784:1;27780:9;;;27776:27;;;;27769:35;;27856:1;27852:9;;;27863:11;27848:27;;;27827:19;;27823:53;27910:1;27906:9;;;27899:17;27895:36;27984:13;27977:21;27972:3;27968:31;27707:6;27740:10;;;27957:1;27953:13;27950:50;39243:73;;;;38549:786;-1:-1:-1;;;;;38549:786:0:o;51153:2773::-;51375:7;:14;51361:3;:10;:28;51358:89;;51413:22;;;;;;;;;;;;;;51358:89;51462:16;;;51459:78;;51502:23;;;;;;;;;;;;;;51459:78;273:10;51547:16;51649:370;51673:3;:10;51669:1;:14;51649:370;;;51705:10;51718:3;51722:1;51718:6;;;;;;;;:::i;:::-;;;;;;;51705:19;;51739:14;51756:7;51764:1;51756:10;;;;;;;;:::i;:::-;;;;;;;51739:27;;51786:6;51796:1;51786:11;:35;;;;-1:-1:-1;51801:12:0;;;;;;;:6;:12;;;;;;;;33806:1;33797:10;;;33786:22;;;;;;;;;33821:4;33813:12;;33786:40;33785:46;51801:20;51783:225;;;-1:-1:-1;51842:12:0;;;;;;;;:6;:12;;;;;;;;34298:1;34289:10;;;34278:22;;;;;;;;;:48;;34320:4;34312:12;;;34306:19;;;34304:22;;34278:48;;;;;51883:10;;;;;;;;;;;34079:22;;;;;;;;;:47;;;;;;;;51685:3;51649:370;;;;52029:53;52039:4;52045:2;52064:3;:10;52049:12;:25;;;;:::i;:::-;52076:5;52029:9;:53::i;:::-;52095:16;52122:18;52151:11;52165:3;:10;52178:1;52165:14;;;;:::i;:::-;52151:28;;52668:16;52662:4;52658:27;52644:41;;52719:16;52715:2;52711:25;52699:37;;53077:4;53072:3;53068:14;53062:21;53026:8;52986:10;52928:25;52873:1;52816;52793:319;53400:1;53362:336;53436:3;53427:7;53424:16;53362:336;;53672:7;53666:4;53662:18;53657:3;53653:28;53647:35;53637:8;53625:10;53598:25;53595:1;53592;53587:96;53485:1;53472:15;53362:336;;;53366:50;53756:2;53726:47;;53750:4;53726:47;;53740:8;53726:47;;;53760:3;53765:7;53726:47;;;;;;;:::i;:::-;;;;;;;;53786:44;53806:8;53816:4;53822:2;53826:3;53786:19;:44::i;:::-;53843:75;53879:8;53889:4;53895:2;53899:3;53904:7;53913:4;53843:35;:75::i;:::-;51347:2579;;;;51153:2773;;;;;:::o;3365:191::-;3439:16;3458:6;;;3475:17;;;;;;;;;;3508:40;;3458:6;;;;;;;3508:40;;3439:16;3508:40;3428:128;3365:191;:::o;44041:114::-;44088:7;43760:1;43922:13;;44115:32;;;;:::i;:::-;44108:39;;44041:114;:::o;62305:331::-;62460:8;62451:17;;:5;:17;;;62443:71;;;;;;;19644:2:1;62443:71:0;;;19626:21:1;19683:2;19663:18;;;19656:30;19722:34;19702:18;;;19695:62;19793:11;19773:18;;;19766:39;19822:19;;62443:71:0;19442:405:1;62443:71:0;62525:25;;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;;;;;;;;;;;;62587:41;;1228::1;;;62587::0;;1201:18:1;62587:41:0;;;;;;;62305:331;;;:::o;45393:105::-;45453:13;45486:4;45479:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45393:105;;;:::o;13088:723::-;13144:13;13365:5;13374:1;13365:10;13361:53;;-1:-1:-1;;13392:10:0;;;;;;;;;;;;;;;;;;13088:723::o;13361:53::-;13439:5;13424:12;13480:78;13487:9;;13480:78;;13513:8;;;;:::i;:::-;;-1:-1:-1;13536:10:0;;-1:-1:-1;13544:2:0;13536:10;;:::i;:::-;;;13480:78;;;13568:19;13600:6;13590:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13590:17:0;;13568:39;;13618:154;13625:10;;13618:154;;13652:11;13662:1;13652:11;;:::i;:::-;;-1:-1:-1;13721:10:0;13729:2;13721:5;:10;:::i;:::-;13708:24;;:2;:24;:::i;:::-;13695:39;;13678:6;13685;13678:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;13749:11:0;13758:2;13749:11;;:::i;:::-;;;13618:154;;71174:443;71287:19;;;71283:91;;71330:32;;;;;71359:1;71330:32;;;3917:74:1;3890:18;;71330:32:0;3771:226:1;71283:91:0;71388:21;;;71384:92;;71433:31;;;;;71461:1;71433:31;;;3917:74:1;3890:18;;71433:31:0;3771:226:1;71384:92:0;71486:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;71532:78;;;;71583:7;71567:31;;71576:5;71567:31;;;71592:5;71567:31;;;;620:25:1;;608:2;593:18;;474:177;71567:31:0;;;;;;;;71174:443;;;;:::o;69388:1640::-;69507:15;;;;69485:19;69507:15;;;:9;:15;;;;;;;69553:13;;;;;;;;69581:19;;;69577:109;;;69624:50;;;;;18701:42:1;18689:55;;69624:50:0;;;18671:74:1;18761:18;;;18754:34;;;18804:18;;;18797:34;;;18644:18;;69624:50:0;18469:368:1;69577:109:0;69799:15;;;;;;;;:9;:15;;;;;;69817:19;;;69799:37;;69967:13;;;;;;;;;;69983:17;;;69967:33;;70029:25;;;;;;69831:5;620:25:1;;608:2;593:18;;474:177;70029:25:0;;;;;;;;70070:4;70067:954;;;70162:15;;;70151:8;70162:15;;;:9;:15;;;;;;;;;70192:234;;70221:22;70302:12;70279:19;70293:5;70279:11;:19;:::i;:::-;70278:36;;;;:::i;:::-;70247:26;70261:12;70247:11;:26;:::i;:::-;70246:69;;;;:::i;:::-;70221:94;-1:-1:-1;70337:18:0;;70334:76;;70378:32;70389:4;70395:14;70378:10;:32::i;:::-;70202:224;70192:234;70510:13;;;;;;;:9;:13;;;;;;;;70505:505;;70547:10;;70561:1;70547:15;:22;;;;;70566:3;70547:22;:41;;;;-1:-1:-1;2098:7:0;2125:6;;70573:15;;;2125:6;;70573:15;70547:41;70544:451;;;70671:13;;;;;;;:9;:13;;;;;:20;;;;70687:4;70671:20;;;70727:1;70714:10;:14;70544:451;;;70777:22;70842:24;70854:12;70842:9;:24;:::i;:::-;70825:12;70804:17;70816:5;70804:9;:17;:::i;:::-;70803:34;;;;:::i;:::-;70802:65;;;;:::i;:::-;70777:90;-1:-1:-1;70893:18:0;;70890:85;;70938:37;70956:2;70960:14;70938:17;:37::i;70890:85::-;70754:241;70544:451;70076:945;70067:954;69474:1554;;69388:1640;;;;:::o;67074:162::-;67183:16;;;67197:1;67183:16;;;;;;;;;67140:22;;67183:16;;;;;;;;;;;-1:-1:-1;67183:16:0;67175:24;;67221:7;67210:5;67216:1;67210:8;;;;;;;;:::i;:::-;;;;;;:18;;;;;67074:162;;;:::o;75206:716::-;75377:13;;;;;;;:9;:13;;;;;;;;75373:461;;75432:9;;75415:13;;;;;;;:9;:13;;;;;;:26;;75407:70;;;;;;;20371:2:1;75407:70:0;;;20353:21:1;20410:2;20390:18;;;20383:30;20449:33;20429:18;;;20422:61;20500:18;;75407:70:0;20169:355:1;75407:70:0;75496:13;;;;75492:331;;;75549:9;75538:21;;;;:10;:21;;;;;;75562:12;-1:-1:-1;75530:84:0;;;;;;;20731:2:1;75530:84:0;;;20713:21:1;20770:2;20750:18;;;20743:30;20809:34;20789:18;;;20782:62;20880:6;20860:18;;;20853:34;20904:19;;75530:84:0;20529:400:1;75530:84:0;75644:9;75633:21;;;;:10;:21;;;;;75657:12;75633:36;;:21;75698:23;;;:28;:67;;;;-1:-1:-1;75738:9:0;75730:30;:35;75698:67;75690:117;;;;;;;21136:2:1;75690:117:0;;;21118:21:1;21175:2;21155:18;;;21148:30;21214:34;21194:18;;;21187:62;21285:7;21265:18;;;21258:35;21310:19;;75690:117:0;20934:401:1;75690:117:0;75864:50;69055:325;64872:1389;65087:13;;;5852:20;5900:8;65083:1171;;65123:57;;;;;65153:26;65123:57;;;21484:98:1;65123:29:0;;;;;;21457:18:1;;65123:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65119:1124;;;65205:72;;;;;:38;;;;;;:72;;65244:8;;65254:4;;65260:2;;65264:6;;65272:4;;65205:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65205:72:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;65201:495;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;65571:6;65564:14;;;;;;;;;;;:::i;65201:495::-;;;65635:41;;;;;;;;;;;;;;65201:495;65331:55;;;65343:43;65331:55;65327:160;;65422:41;;;;;;;;;;;;;;65327:160;65278:228;65119:1124;;;65753:61;;;;;:35;;;;;;:61;;65789:8;;65799:4;;65805:2;;65809:4;;65753:61;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65753:61:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;65749:479;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;66168:40;;;;;;;;;;;;;;65749:479;65868:52;;;65880:40;65868:52;65864:156;;65956:40;;;;;;;;;;;;;;66269:797;66509:13;;;5852:20;5900:8;66505:554;;66545:79;;;;;:43;;;;;;:79;;66589:8;;66599:4;;66605:3;;66610:7;;66619:4;;66545:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66545:79:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;66541:507;;;;:::i;:::-;66706:60;;;66718:48;66706:60;66702:157;;66798:41;;;;;;;;;;;;;;60424:1735;60530:18;;;60527:77;;60571:21;;;;;;;;;;;;;;60527:77;43922:13;;273:10;;60708:24;60749:6;60735:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60735:21:0;;60708:48;;60767:20;60804:6;60790:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60790:21:0;;60767:44;;60853:9;60849:258;60872:6;60868:1;:10;60849:258;;;60917:1;60904:7;60912:1;60904:10;;;;;;;;:::i;:::-;;;;;;;;;;;:14;;;;60950:12;;;60937:10;60950:12;;;:6;:12;;;;;;:36;;60975:10;60950:24;:36::i;:::-;60937:49;;61014:2;61005:3;61009:1;61005:6;;;;;;;;:::i;:::-;;;;;;;;;;;:11;;;;61035:12;;;;;;;:6;:12;;;;;;;34298:1;34289:10;;;34278:22;;;;;;;;:48;;34320:4;34312:12;;34306:19;;;34304:22;34278:48;;;34289:10;;-1:-1:-1;60880:3:0;60849:258;;;;61258:18;;61301:10;:6;61310:1;61301:10;:::i;:::-;61287:24;;61372:16;61366:4;61362:27;61348:41;;61574:4;61569:3;61565:14;61559:21;61539:1;61510:10;61466:25;61446:1;61426;61403:192;61649:1;61611:264;61685:3;61676:7;61673:16;61611:264;;61849:7;61843:4;61839:18;61834:3;61830:28;61824:35;61821:1;61809:10;61782:25;61779:1;61776;61771:89;61734:1;61721:15;61611:264;;;61615:50;61901:6;61911:1;61901:11;61898:176;;61971:1;61932:53;;61957:4;61932:53;;61947:8;61932:53;;;61975:3;61979:1;61975:6;;;;;;;;:::i;:::-;;;;;;;61983:1;61932:53;;;;;;18390:25:1;;;18446:2;18431:18;;18424:34;18378:2;18363:18;;18216:248;61932:53:0;;;;;;;;61898:176;;;62057:1;62019:55;;62043:4;62019:55;;62033:8;62019:55;;;62061:3;62066:7;62019:55;;;;;;;:::i;:::-;;;;;;;;61898:176;62097:52;62117:8;62127:4;62141:1;62145:3;62097:19;:52::i;55793:1661::-;55898:20;;55962:16;;;55959:74;;56002:19;;;;;;;;;;;;;;55959:74;56046:6;56056:1;56046:11;56043:68;;56081:18;;;;;;;;;;;;;;56043:68;273:10;56187:6;56173:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56173:21:0;;56167:27;;56229:6;56215:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56215:21:0;;56205:31;;56247:20;56270:14;43922:13;;;43848:95;56270:14;56247:37;;56360:12;56350:6;56330:17;:26;:42;;56322:51;;;;;;56392:9;56388:129;56411:6;56407:1;:10;56388:129;;;56467:1;56452:12;:16;56443:3;56447:1;56443:6;;;;;;;;:::i;:::-;;;;;;:25;;;;;56500:1;56487:7;56495:1;56487:10;;;;;;;;:::i;:::-;;;;;;;;;;:14;56419:3;;56388:129;;;;56612:10;;;;;;;:6;:10;;;;;:41;;56632:12;56646:6;56612:19;:41::i;:::-;56681:6;56664:13;;:23;;;;;;;:::i;:::-;;;;-1:-1:-1;56700:16:0;;-1:-1:-1;56700:16:0;56741:21;56756:6;56741:12;:21;:::i;:::-;56727:35;;56819:16;56815:2;56811:25;56799:37;;57004:12;56977:8;56957:1;56913:25;56893:1;56873;56850:181;57103:1;57089:12;57085:20;57047:253;57140:3;57131:7;57128:16;57047:253;;57277:7;57267:8;57264:1;57237:25;57234:1;57231;57226:59;57189:1;57176:15;57047:253;;;57051:69;57364:2;57328:53;;57360:1;57328:53;;57342:8;57328:53;;;57368:3;57373:7;57328:53;;;;;;;:::i;:::-;;;;;;;;57394:50;57414:8;57432:1;57436:2;57440:3;57394:19;:50::i;:::-;55946:1508;;;;55793:1661;;;;;:::o;39489:1230::-;39807:1;39803:14;;;39599:19;39831:20;;;39872:4;39865:25;;;40045:4;40029:21;;40023:28;39773:6;;39803:14;39922:4;39928:11;;39918:22;40011:41;;;39999:54;;40092:14;;40077:30;;40067:356;;40128:280;-1:-1:-1;40173:24:0;;40247:4;40240:20;;;40318:4;40302:21;;40296:28;40364:14;;40349:30;;40346:43;40128:280;40346:43;40128:280;40448:15;;40444:268;;40510:22;40521:10;25510:66;25434:4;25455:34;25060:9;;25057:1;25053:17;25082:34;25079:41;-1:-1:-1;25076:1:0;25072:49;25050:72;25177:9;;;25157:18;25154:33;25151:1;25147:41;25141:48;25236:9;;;25224:10;25221:25;25218:1;25214:33;25208:40;25291:9;;;25283:6;25280:21;25277:1;25273:29;25267:36;25344:9;;;25338:4;25335:19;25332:1;25328:27;25322:34;25444:9;;;25440:50;25430:61;25425:152;25419:159;;24908:688;40510:22;40505:1;40495:11;;;40494:38;40661:23;;;40658:1;40654:31;40638:48;;-1:-1:-1;40444:268:0;39625:1094;;39489:1230;;;;:::o;36042:1129::-;36217:1;36213:6;36257:4;36250:5;36246:16;36289:11;36283:4;36276:25;36335:5;36332:1;36328:13;36322:4;36315:27;36389:3;36380:6;36373:5;36369:18;36366:27;36356:646;;36443:4;36433:21;;36449:4;36433:21;;36495:18;;36515:15;;;36492:39;36472:60;;36642:18;;;;36714:4;36690:29;;;-1:-1:-1;36564:19:0;;;36639:1;36635:26;36618:44;36765:184;36790:9;36782:6;36779:21;36765:184;;36867:6;36861:4;36854:20;36926:3;36919:4;36913;36903:21;36896:34;36826:1;36818:6;36814:14;36804:24;;36765:184;;;-1:-1:-1;36974:4:0;36967:20;36356:646;37051:4;37045;37035:21;37146:3;37137:6;37132:3;37128:16;37124:26;37117:5;37113:38;37099:11;37093:18;37090:62;37077:11;37070:83;;;;36042:1129;;;:::o;14:196:1:-;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;215:254;283:6;291;344:2;332:9;323:7;319:23;315:32;312:52;;;360:1;357;350:12;312:52;383:29;402:9;383:29;:::i;:::-;373:39;459:2;444:18;;;;431:32;;-1:-1:-1;;;215:254:1:o;656:177::-;741:66;734:5;730:78;723:5;720:89;710:117;;823:1;820;813:12;838:245;896:6;949:2;937:9;928:7;924:23;920:32;917:52;;;965:1;962;955:12;917:52;1004:9;991:23;1023:30;1047:5;1023:30;:::i;1280:184::-;1332:77;1329:1;1322:88;1429:4;1426:1;1419:15;1453:4;1450:1;1443:15;1469:308;1575:66;1570:2;1564:4;1560:13;1556:86;1548:6;1544:99;1709:6;1697:10;1694:22;1673:18;1661:10;1658:34;1655:62;1652:88;;;1720:18;;:::i;:::-;1756:2;1749:22;-1:-1:-1;;1469:308:1:o;1782:528::-;1847:5;1881:18;1873:6;1870:30;1867:56;;;1903:18;;:::i;:::-;1952:2;1946:9;1964:128;2086:4;2017:66;2012:2;2004:6;2000:15;1996:88;1992:99;1984:6;1964:128;:::i;:::-;2110:6;2101:15;;2140:6;2132;2125:22;2180:3;2171:6;2166:3;2162:16;2159:25;2156:45;;;2197:1;2194;2187:12;2156:45;2247:6;2242:3;2235:4;2227:6;2223:17;2210:44;2302:1;2295:4;2286:6;2278;2274:19;2270:30;2263:41;;1782:528;;;;;:::o;2315:451::-;2384:6;2437:2;2425:9;2416:7;2412:23;2408:32;2405:52;;;2453:1;2450;2443:12;2405:52;2493:9;2480:23;2526:18;2518:6;2515:30;2512:50;;;2558:1;2555;2548:12;2512:50;2581:22;;2634:4;2626:13;;2622:27;-1:-1:-1;2612:55:1;;2663:1;2660;2653:12;2612:55;2686:74;2752:7;2747:2;2734:16;2729:2;2725;2721:11;2686:74;:::i;2771:250::-;2856:1;2866:113;2880:6;2877:1;2874:13;2866:113;;;2956:11;;;2950:18;2937:11;;;2930:39;2902:2;2895:10;2866:113;;;-1:-1:-1;;3013:1:1;2995:16;;2988:27;2771:250::o;3026:330::-;3068:3;3106:5;3100:12;3133:6;3128:3;3121:19;3149:76;3218:6;3211:4;3206:3;3202:14;3195:4;3188:5;3184:16;3149:76;:::i;:::-;3270:2;3258:15;3275:66;3254:88;3245:98;;;;3345:4;3241:109;;3026:330;-1:-1:-1;;3026:330:1:o;3361:220::-;3510:2;3499:9;3492:21;3473:4;3530:45;3571:2;3560:9;3556:18;3548:6;3530:45;:::i;3586:180::-;3645:6;3698:2;3686:9;3677:7;3673:23;3669:32;3666:52;;;3714:1;3711;3704:12;3666:52;-1:-1:-1;3737:23:1;;3586:180;-1:-1:-1;3586:180:1:o;4002:328::-;4079:6;4087;4095;4148:2;4136:9;4127:7;4123:23;4119:32;4116:52;;;4164:1;4161;4154:12;4116:52;4187:29;4206:9;4187:29;:::i;:::-;4177:39;;4235:38;4269:2;4258:9;4254:18;4235:38;:::i;:::-;4225:48;;4320:2;4309:9;4305:18;4292:32;4282:42;;4002:328;;;;;:::o;4335:322::-;4412:6;4420;4428;4481:2;4469:9;4460:7;4456:23;4452:32;4449:52;;;4497:1;4494;4487:12;4449:52;4520:29;4539:9;4520:29;:::i;:::-;4510:39;4596:2;4581:18;;4568:32;;-1:-1:-1;4647:2:1;4632:18;;;4619:32;;4335:322;-1:-1:-1;;;4335:322:1:o;4662:183::-;4722:4;4755:18;4747:6;4744:30;4741:56;;;4777:18;;:::i;:::-;-1:-1:-1;4822:1:1;4818:14;4834:4;4814:25;;4662:183::o;4850:730::-;4904:5;4957:3;4950:4;4942:6;4938:17;4934:27;4924:55;;4975:1;4972;4965:12;4924:55;5011:6;4998:20;5037:4;5060:43;5100:2;5060:43;:::i;:::-;5132:2;5126:9;5144:31;5172:2;5164:6;5144:31;:::i;:::-;5195:6;5184:17;;5225:2;5217:6;5210:18;5256:4;5248:6;5244:17;5237:24;;5313:4;5307:2;5304:1;5300:10;5292:6;5288:23;5284:34;5270:48;;5341:3;5333:6;5330:15;5327:35;;;5358:1;5355;5348:12;5327:35;5394:4;5386:6;5382:17;5408:142;5424:6;5419:3;5416:15;5408:142;;;5490:17;;5478:30;;5528:12;;;;5441;;5408:142;;;-1:-1:-1;5568:6:1;4850:730;-1:-1:-1;;;;;;4850:730:1:o;5585:221::-;5627:5;5680:3;5673:4;5665:6;5661:17;5657:27;5647:55;;5698:1;5695;5688:12;5647:55;5720:80;5796:3;5787:6;5774:20;5767:4;5759:6;5755:17;5720:80;:::i;5811:943::-;5965:6;5973;5981;5989;5997;6050:3;6038:9;6029:7;6025:23;6021:33;6018:53;;;6067:1;6064;6057:12;6018:53;6090:29;6109:9;6090:29;:::i;:::-;6080:39;;6138:38;6172:2;6161:9;6157:18;6138:38;:::i;:::-;6128:48;;6227:2;6216:9;6212:18;6199:32;6250:18;6291:2;6283:6;6280:14;6277:34;;;6307:1;6304;6297:12;6277:34;6330:61;6383:7;6374:6;6363:9;6359:22;6330:61;:::i;:::-;6320:71;;6444:2;6433:9;6429:18;6416:32;6400:48;;6473:2;6463:8;6460:16;6457:36;;;6489:1;6486;6479:12;6457:36;6512:63;6567:7;6556:8;6545:9;6541:24;6512:63;:::i;:::-;6502:73;;6628:3;6617:9;6613:19;6600:33;6584:49;;6658:2;6648:8;6645:16;6642:36;;;6674:1;6671;6664:12;6642:36;;6697:51;6740:7;6729:8;6718:9;6714:24;6697:51;:::i;:::-;6687:61;;;5811:943;;;;;;;;:::o;6948:1208::-;7066:6;7074;7127:2;7115:9;7106:7;7102:23;7098:32;7095:52;;;7143:1;7140;7133:12;7095:52;7183:9;7170:23;7212:18;7253:2;7245:6;7242:14;7239:34;;;7269:1;7266;7259:12;7239:34;7307:6;7296:9;7292:22;7282:32;;7352:7;7345:4;7341:2;7337:13;7333:27;7323:55;;7374:1;7371;7364:12;7323:55;7410:2;7397:16;7432:4;7455:43;7495:2;7455:43;:::i;:::-;7527:2;7521:9;7539:31;7567:2;7559:6;7539:31;:::i;:::-;7605:18;;;7693:1;7689:10;;;;7681:19;;7677:28;;;7639:15;;;;-1:-1:-1;7717:19:1;;;7714:39;;;7749:1;7746;7739:12;7714:39;7773:11;;;;7793:148;7809:6;7804:3;7801:15;7793:148;;;7875:23;7894:3;7875:23;:::i;:::-;7863:36;;7826:12;;;;7919;;;;7793:148;;;7960:6;-1:-1:-1;;8004:18:1;;7991:32;;-1:-1:-1;;8035:16:1;;;8032:36;;;8064:1;8061;8054:12;8032:36;;8087:63;8142:7;8131:8;8120:9;8116:24;8087:63;:::i;:::-;8077:73;;;6948:1208;;;;;:::o;8161:439::-;8214:3;8252:5;8246:12;8279:6;8274:3;8267:19;8305:4;8334;8329:3;8325:14;8318:21;;8373:4;8366:5;8362:16;8396:1;8406:169;8420:6;8417:1;8414:13;8406:169;;;8481:13;;8469:26;;8515:12;;;;8550:15;;;;8442:1;8435:9;8406:169;;;-1:-1:-1;8591:3:1;;8161:439;-1:-1:-1;;;;;8161:439:1:o;8605:261::-;8784:2;8773:9;8766:21;8747:4;8804:56;8856:2;8845:9;8841:18;8833:6;8804:56;:::i;8871:118::-;8957:5;8950:13;8943:21;8936:5;8933:32;8923:60;;8979:1;8976;8969:12;8994:315;9059:6;9067;9120:2;9108:9;9099:7;9095:23;9091:32;9088:52;;;9136:1;9133;9126:12;9088:52;9159:29;9178:9;9159:29;:::i;:::-;9149:39;;9238:2;9227:9;9223:18;9210:32;9251:28;9273:5;9251:28;:::i;:::-;9298:5;9288:15;;;8994:315;;;;;:::o;9314:186::-;9373:6;9426:2;9414:9;9405:7;9401:23;9397:32;9394:52;;;9442:1;9439;9432:12;9394:52;9465:29;9484:9;9465:29;:::i;9505:260::-;9573:6;9581;9634:2;9622:9;9613:7;9609:23;9605:32;9602:52;;;9650:1;9647;9640:12;9602:52;9673:29;9692:9;9673:29;:::i;:::-;9663:39;;9721:38;9755:2;9744:9;9740:18;9721:38;:::i;:::-;9711:48;;9505:260;;;;;:::o;9770:606::-;9874:6;9882;9890;9898;9906;9959:3;9947:9;9938:7;9934:23;9930:33;9927:53;;;9976:1;9973;9966:12;9927:53;9999:29;10018:9;9999:29;:::i;:::-;9989:39;;10047:38;10081:2;10070:9;10066:18;10047:38;:::i;:::-;10037:48;;10132:2;10121:9;10117:18;10104:32;10094:42;;10183:2;10172:9;10168:18;10155:32;10145:42;;10238:3;10227:9;10223:19;10210:33;10266:18;10258:6;10255:30;10252:50;;;10298:1;10295;10288:12;10252:50;10321:49;10362:7;10353:6;10342:9;10338:22;10321:49;:::i;10381:437::-;10460:1;10456:12;;;;10503;;;10524:61;;10578:4;10570:6;10566:17;10556:27;;10524:61;10631:2;10623:6;10620:14;10600:18;10597:38;10594:218;;10668:77;10665:1;10658:88;10769:4;10766:1;10759:15;10797:4;10794:1;10787:15;10594:218;;10381:437;;;:::o;10949:518::-;11051:2;11046:3;11043:11;11040:421;;;11087:5;11084:1;11077:16;11131:4;11128:1;11118:18;11201:2;11189:10;11185:19;11182:1;11178:27;11172:4;11168:38;11237:4;11225:10;11222:20;11219:47;;;-1:-1:-1;11260:4:1;11219:47;11315:2;11310:3;11306:12;11303:1;11299:20;11293:4;11289:31;11279:41;;11370:81;11388:2;11381:5;11378:13;11370:81;;;11447:1;11433:16;;11414:1;11403:13;11370:81;;11703:1464;11829:3;11823:10;11856:18;11848:6;11845:30;11842:56;;;11878:18;;:::i;:::-;11907:97;11997:6;11957:38;11989:4;11983:11;11957:38;:::i;:::-;11951:4;11907:97;:::i;:::-;12059:4;;12116:2;12105:14;;12133:1;12128:782;;;;12954:1;12971:6;12968:89;;;-1:-1:-1;13023:19:1;;;13017:26;12968:89;11609:66;11600:1;11596:11;;;11592:84;11588:89;11578:100;11684:1;11680:11;;;11575:117;13070:81;;12098:1063;;12128:782;10896:1;10889:14;;;10933:4;10920:18;;12176:66;12164:79;;;12341:236;12355:7;12352:1;12349:14;12341:236;;;12444:19;;;12438:26;12423:42;;12536:27;;;;12504:1;12492:14;;;;12371:19;;12341:236;;;12345:3;12605:6;12596:7;12593:19;12590:261;;;12666:19;;;12660:26;12767:66;12749:1;12745:14;;;12761:3;12741:24;12737:97;12733:102;12718:118;12703:134;;12590:261;-1:-1:-1;;;;;12897:1:1;12881:14;;;12877:22;12864:36;;-1:-1:-1;11703:1464:1:o;13172:184::-;13224:77;13221:1;13214:88;13321:4;13318:1;13311:15;13345:4;13342:1;13335:15;13361:128;13428:9;;;13449:11;;;13446:37;;;13463:18;;:::i;13494:184::-;13546:77;13543:1;13536:88;13643:4;13640:1;13633:15;13667:4;13664:1;13657:15;13683:168;13756:9;;;13787;;13804:15;;;13798:22;;13784:37;13774:71;;13825:18;;:::i;13856:184::-;13908:77;13905:1;13898:88;14005:4;14002:1;13995:15;14029:4;14026:1;14019:15;14045:120;14085:1;14111;14101:35;;14116:18;;:::i;:::-;-1:-1:-1;14150:9:1;;14045:120::o;14170:781::-;14220:3;14261:5;14255:12;14290:36;14316:9;14290:36;:::i;:::-;14345:1;14362:17;;;14388:191;;;;14593:1;14588:357;;;;14355:590;;14388:191;14436:66;14425:9;14421:82;14416:3;14409:95;14559:6;14552:14;14545:22;14537:6;14533:35;14528:3;14524:45;14517:52;;14388:191;;14588:357;14619:5;14616:1;14609:16;14648:4;14693;14690:1;14680:18;14720:1;14734:165;14748:6;14745:1;14742:13;14734:165;;;14826:14;;14813:11;;;14806:35;14869:16;;;;14763:10;;14734:165;;;14738:3;;;14928:6;14923:3;14919:16;14912:23;;14355:590;;;;;14170:781;;;;:::o;14956:389::-;15132:3;15160:38;15194:3;15186:6;15160:38;:::i;:::-;15227:6;15221:13;15243:65;15301:6;15297:2;15290:4;15282:6;15278:17;15243:65;:::i;:::-;15324:15;;14956:389;-1:-1:-1;;;;14956:389:1:o;15537:1492::-;16142:66;16137:3;16130:79;16112:3;16238:6;16232:13;16254:75;16322:6;16317:2;16312:3;16308:12;16301:4;16293:6;16289:17;16254:75;:::i;:::-;16393:66;16388:2;16348:16;;;16380:11;;;16373:87;16485:13;;16507:76;16485:13;16569:2;16561:11;;16554:4;16542:17;;16507:76;:::i;:::-;16648:66;16643:2;16602:17;;;;16635:11;;;16628:87;16744:66;16739:2;16731:11;;16724:87;16830:46;16872:2;16864:11;;16856:6;16830:46;:::i;:::-;16820:56;;16907:6;16901:13;16923:67;16981:8;16977:2;16970:4;16962:6;16958:17;16923:67;:::i;:::-;17006:17;;15537:1492;-1:-1:-1;;;;;;15537:1492:1:o;17034:1177::-;17546:29;17541:3;17534:42;17516:3;17605:6;17599:13;17621:75;17689:6;17684:2;17679:3;17675:12;17668:4;17660:6;17656:17;17621:75;:::i;:::-;17760:66;17755:2;17715:16;;;17747:11;;;17740:87;17856:66;17851:2;17843:11;;17836:87;17948:13;;17970:76;17948:13;18032:2;18024:11;;18017:4;18005:17;;17970:76;:::i;:::-;18111:66;18106:2;18065:17;;;;18098:11;;;18091:87;18202:2;18194:11;;17034:1177;-1:-1:-1;;;;17034:1177:1:o;18842:125::-;18907:9;;;18928:10;;;18925:36;;;18941:18;;:::i;18972:465::-;19229:2;19218:9;19211:21;19192:4;19255:56;19307:2;19296:9;19292:18;19284:6;19255:56;:::i;:::-;19359:9;19351:6;19347:22;19342:2;19331:9;19327:18;19320:50;19387:44;19424:6;19416;19387:44;:::i;:::-;19379:52;18972:465;-1:-1:-1;;;;;18972:465:1:o;19852:195::-;19891:3;19922:66;19915:5;19912:77;19909:103;;19992:18;;:::i;:::-;-1:-1:-1;20039:1:1;20028:13;;19852:195::o;20052:112::-;20084:1;20110;20100:35;;20115:18;;:::i;:::-;-1:-1:-1;20149:9:1;;20052:112::o;21593:245::-;21660:6;21713:2;21701:9;21692:7;21688:23;21684:32;21681:52;;;21729:1;21726;21719:12;21681:52;21761:9;21755:16;21780:28;21802:5;21780:28;:::i;21843:584::-;22065:4;22094:42;22175:2;22167:6;22163:15;22152:9;22145:34;22227:2;22219:6;22215:15;22210:2;22199:9;22195:18;22188:43;;22267:6;22262:2;22251:9;22247:18;22240:34;22310:6;22305:2;22294:9;22290:18;22283:34;22354:3;22348;22337:9;22333:19;22326:32;22375:46;22416:3;22405:9;22401:19;22393:6;22375:46;:::i;:::-;22367:54;21843:584;-1:-1:-1;;;;;;;21843:584:1:o;22432:249::-;22501:6;22554:2;22542:9;22533:7;22529:23;22525:32;22522:52;;;22570:1;22567;22560:12;22522:52;22602:9;22596:16;22621:30;22645:5;22621:30;:::i;22686:179::-;22721:3;22763:1;22745:16;22742:23;22739:120;;;22809:1;22806;22803;22788:23;-1:-1:-1;22846:1:1;22840:8;22835:3;22831:18;22739:120;22686:179;:::o;22870:731::-;22909:3;22951:4;22933:16;22930:26;22927:39;;;22870:731;:::o;22927:39::-;22993:2;22987:9;23015:66;23136:2;23118:16;23114:25;23111:1;23105:4;23090:50;23169:4;23163:11;23193:16;23228:18;23299:2;23292:4;23284:6;23280:17;23277:25;23272:2;23264:6;23261:14;23258:45;23255:58;;;23306:5;;;;;22870:731;:::o;23255:58::-;23343:6;23337:4;23333:17;23322:28;;23379:3;23373:10;23406:2;23398:6;23395:14;23392:27;;;23412:5;;;;;;22870:731;:::o;23392:27::-;23496:2;23477:16;23471:4;23467:27;23463:36;23456:4;23447:6;23442:3;23438:16;23434:27;23431:69;23428:82;;;23503:5;;;;;;22870:731;:::o;23428:82::-;23519:57;23570:4;23561:6;23553;23549:19;23545:30;23539:4;23519:57;:::i;:::-;-1:-1:-1;23592:3:1;;22870:731;-1:-1:-1;;;;;22870:731:1:o;23606:512::-;23800:4;23829:42;23910:2;23902:6;23898:15;23887:9;23880:34;23962:2;23954:6;23950:15;23945:2;23934:9;23930:18;23923:43;;24002:6;23997:2;23986:9;23982:18;23975:34;24045:3;24040:2;24029:9;24025:18;24018:31;24066:46;24107:3;24096:9;24092:19;24084:6;24066:46;:::i;:::-;24058:54;23606:512;-1:-1:-1;;;;;;23606:512:1:o;24123:850::-;24445:4;24474:42;24555:2;24547:6;24543:15;24532:9;24525:34;24607:2;24599:6;24595:15;24590:2;24579:9;24575:18;24568:43;;24647:3;24642:2;24631:9;24627:18;24620:31;24674:57;24726:3;24715:9;24711:19;24703:6;24674:57;:::i;:::-;24779:9;24771:6;24767:22;24762:2;24751:9;24747:18;24740:50;24813:44;24850:6;24842;24813:44;:::i;:::-;24799:58;;24906:9;24898:6;24894:22;24888:3;24877:9;24873:19;24866:51;24934:33;24960:6;24952;24934:33;:::i;:::-;24926:41;24123:850;-1:-1:-1;;;;;;;;24123:850:1:o

Swarm Source

ipfs://bb83e3b9fb7053fe39dc96c43c01db6c09817a3152ff75d88efd310afd50d25f

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