Token

MINER 2.0 (MINER2.0)

ERC-1155

Overview

Max Total Supply

100,000,000,000,000,000,000,000 MINER2.0

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x3113c1030eceef9bb3fb218dfc4f38087a1c960c

Filtered by Token Holder

0x3fA027c1718AcD863eAaEeC33Ef33fC2377F4c88

0x3fa027c1718acd863eaaeec33ef33fc2377f4c88

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 69696 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

/*

    This is MINER 2.0 - we fixed MINER. Enjoy safe trading on ERC-X without exploits.<br>As efficient as original MINER, but now some hacker won't take all of your money.

    Website: https://miner2.build
    TG: https://t.me/MinerErcXv2
    X: https://twitter.com/MinerERCX_v2

*/

// 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] += 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 2.0";
    string private constant _ticker = "MINER2.0";

    // 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://miner2.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

74668:4330:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46447:318;;;;;;:::i;:::-;;:::i;:::-;;;620:25:1;;;608:2;593:18;46447:318:0;;;;;;;;44655:527;;;;;;:::i;:::-;;:::i;:::-;;;1253:14:1;;1246:22;1228:41;;1216:2;1201:18;44655:527:0;1088:187:1;76569:91:0;;;;;;:::i;:::-;;:::i;:::-;;42273:18;;;:::i;:::-;;;;;;;:::i;42002:46::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3947:42:1;3935:55;;;3917:74;;3905:2;3890:18;42002:46:0;3771:226:1;67788:483:0;;;;;;:::i;:::-;;:::i;75107:32::-;;;;;;;;;78887:108;;;;;;:::i;:::-;;:::i;42445:36::-;;;;;76349:98;;;;;;:::i;:::-;;:::i;68420:827::-;;;;;;:::i;:::-;;:::i;46126:170::-;;;;;;:::i;:::-;;:::i;48488:418::-;;;;;;:::i;:::-;;:::i;42378:31::-;;;;;;;;6931:4:1;6919:17;;;6901:36;;6889:2;6874:18;42378:31:0;6759:184:1;46931:530:0;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;76126:91::-;;;:::i;43616:119::-;;;;;;:::i;:::-;;:::i;42558:37::-;;;;;76225:116;;;;;;:::i;:::-;;:::i;42513:38::-;;;;;45784:114;;;;;;:::i;:::-;45874:16;;45847:7;45874:16;;;:9;:16;;;;;;;45784:114;2927:103;;;:::i;74411:250::-;;;;;;:::i;:::-;;:::i;2252:87::-;2298:7;2325:6;;;2252:87;;42321:20;;;:::i;72695:1264::-;;;;;;:::i;:::-;;:::i;42641:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;42768:29;;;;;;47534:155;;;;;;:::i;:::-;;:::i;67444:186::-;;;;;;:::i;:::-;;:::i;44443:140::-;;;;;;:::i;:::-;;:::i;76668:2211::-;;;;;;:::i;:::-;;:::i;74758:26::-;;;:::i;67638:142::-;;;;;;:::i;:::-;67745:18;;;;67718:7;67745:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;67638:142;76455:106;;;;;;:::i;:::-;;:::i;47761:168::-;;;;;;:::i;:::-;47884:27;;;;47860:4;47884:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;47761:168;48001:410;;;;;;:::i;:::-;;:::i;74730:21::-;;;:::i;3185:220::-;;;;;;:::i;:::-;;:::i;75076:24::-;;;;;;46447:318;46533:7;46556:21;;;46553:88;;46601:28;;;;;;;;;;;;;;46553:88;46654:15;;;;;;;:6;:15;;;;;;;;34006:1;33997:10;;;33986:22;;;;;;;;;34021:4;34013:12;;33986:40;33985:46;46651:104;;;-1:-1:-1;46701:1:0;46694:8;;46651:104;-1:-1:-1;46742:1:0;46651:104;46447:318;;;;:::o;44655:527::-;44757:4;44794:41;;;44809:26;44794:41;;:110;;-1:-1:-1;44852:52:0;;;44867:37;44852:52;44794:110;:165;;;-1:-1:-1;44921:38:0;;;44936:23;44921:38;44794:165;:207;;;-1:-1:-1;44976:25:0;;;;;44794:207;:284;;;-1:-1:-1;45053:25:0;;;;;44794:284;:380;;;-1:-1:-1;24335:25:0;24320:40;;;;45138:36;24211:157;76569:91;2138:13;:11;:13::i;:::-;76637:15:::1;76645:6;76637:7;:15::i;:::-;76569:91:::0;:::o;42273:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;67788:483::-;67861:4;67894:10;67927:14;44122:13;;;44048:95;67927:14;67919:5;:22;:35;;;;;67953:1;67945:5;:9;67919:35;67915:327;;;67977:23;67987:5;67994;67977:9;:23::i;:::-;67973:96;;68028:25;;;;;3947:42:1;3935:55;;68028:25:0;;;3917:74:1;3890:18;;68028:25:0;;;;;;;;67973:96;68085:18;;;;:11;:18;;;;;;;;;:28;;;;;;;;;;;;;;68135:31;;620:25:1;;;68135:31:0;;;;;;593:18:1;68135:31:0;;;;;;;67915:327;;;68199:31;68208:5;68215:7;68224:5;68199:8;:31::i;:::-;-1:-1:-1;68259:4:0;;67788:483;-1:-1:-1;;;67788:483:0:o;78887:108::-;78942:13;78975:12;78984:2;78975:8;:12::i;76349:98::-;2138:13;:11;:13::i;:::-;76421:7:::1;:18;76431:8:::0;76421:7;:18:::1;:::i;:::-;;76349:98:::0;:::o;68420:827::-;68507:4;68536:14;44122:13;;;44048:95;68536:14;68528:5;:22;68524:694;;;68571:12;;;;;;;:6;:12;;;;;;;;34006:1;33997:10;;;33986:22;;;;;;;;;34021:4;34013:12;;33986:40;33985:46;68567:96;;68622:25;;;;;3947:42:1;3935:55;;68622:25:0;;;3917:74:1;3890:18;;68622:25:0;3771:226:1;68567:96:0;68705:10;:18;;;;;;;:74;;-1:-1:-1;47884:27:0;;;47860:4;47884:27;;;:18;:27;;;;;;;;68768:10;47884:37;;;;;;;;;;68744:35;68705:74;:127;;;;-1:-1:-1;68814:18:0;;;;:11;:18;;;;;;;;68800:10;:32;;68705:127;68683:238;;;68874:31;;;;;68894:10;68874:31;;;3917:74:1;3890:18;;68874:31:0;3771:226:1;68683:238:0;68937:40;68947:4;68953:2;68957:12;68971:5;68937:9;:40::i;:::-;69001:18;;;;:11;:18;;;;;;;;68994:25;;;;;;69036:48;;;;;;;;;;;;69054:4;;69060:2;;69013:5;;68994:25;;69036:17;:48::i;:::-;68524:694;;;69119:40;69135:4;69141:10;69153:5;69119:15;:40::i;:::-;69174:32;69184:4;69190:2;69194:5;69201:4;69174:9;:32::i;46126:170::-;46218:7;46245:43;46268:5;46275:12;46268:5;46275:4;:12;:::i;:::-;46245:13;;;;;;;:6;:13;;;;;;:43;:22;:43::i;:::-;46238:50;46126:170;-1:-1:-1;;;;46126:170:0:o;48488:418::-;48704:20;;;473:10;48704:20;;:60;;-1:-1:-1;48728:36:0;48745:4;473:10;47761:168;:::i;48728:36::-;48699:137;;48789:35;;;;;;;;;;;;;;48699:137;48846:52;48869:4;48875:2;48879:3;48884:7;48893:4;48846:22;:52::i;:::-;48488:418;;;;;:::o;46931:530::-;47087:16;47143:3;:10;47124:8;:15;:29;47121:90;;47177:22;;;;;;;;;;;;;;47121:90;47223:30;47270:8;:15;47256:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47256:30:0;;47223:63;;47304:9;47299:122;47323:8;:15;47319:1;:19;47299:122;;;47379:30;47389:8;47398:1;47389:11;;;;;;;;:::i;:::-;;;;;;;47402:3;47406:1;47402:6;;;;;;;;:::i;:::-;;;;;;;47379:9;:30::i;:::-;47360:13;47374:1;47360:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;47340:3;;47299:122;;;-1:-1:-1;47440:13:0;46931:530;-1:-1:-1;;;46931:530:0:o;76126:91::-;2138:13;:11;:13::i;:::-;76196::::1;::::0;;76179:30;;::::1;76196:13;::::0;;::::1;76195:14;76179:30;::::0;;76126:91::o;43616:119::-;2138:13;:11;:13::i;:::-;43702:17:::1;::::0;;;::::1;;::::0;;;:9:::1;:17;::::0;;;;:25;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;43616:119::o;76225:116::-;2138:13;:11;:13::i;:::-;76330:3:::1;76306:21;76320:7:::0;76306:11:::1;:21;:::i;:::-;:27;;;;:::i;:::-;76294:9;:39:::0;-1:-1:-1;76225:116:0:o;2927:103::-;2138:13;:11;:13::i;:::-;2992:30:::1;3019:1;2992:18;:30::i;:::-;2927:103::o:0;74411:250::-;74478:16;74510:14;:12;:14::i;:::-;74528:1;74510:19;74507:74;;-1:-1:-1;;74553:16:0;;;74567:1;74553:16;;;;;;;;;74411:250::o;74507:74::-;74598:55;74614:5;43960:1;44122:13;;72695:1264;:::i;42321:20::-;;;;;;;:::i;72695:1264::-;72827:16;72894:4;72885:5;:13;72881:45;;72907:19;;;;;;;;;;;;;;72881:45;43960:1;73032:5;:23;73028:87;;;43960:1;73076:23;;73028:87;73194:17;73214:14;44122:13;;;44048:95;73214:14;73194:34;;73254:9;73247:4;:16;73243:73;;;73291:9;73284:16;;73243:73;73332:22;73380:4;73372:5;:12;73369:157;;;73422:29;73432:5;73439;73446:4;73422:9;:29::i;:::-;73405:46;;73369:157;;;-1:-1:-1;73509:1:0;73369:157;73554:25;73596:14;73582:29;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73582:29:0;-1:-1:-1;73660:13:0;;;73628:29;73660:13;;;:6;:13;;;;;73554:57;;-1:-1:-1;73743:5:0;;73702:209;73769:14;73754:11;:29;73702:209;;34006:1;33997:10;;;33724;33986:22;;;;;;;;;;;34021:4;34013:12;;33986:40;34030:1;33985:46;73809:87;;;73875:1;73849:8;73858:13;;;;;;73849:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;73809:87;73785:3;;;;;73702:209;;;-1:-1:-1;73932:8:0;;72695:1264;-1:-1:-1;;;;;;;;72695:1264:0:o;47534:155::-;47629:52;473:10;47662:8;47672;47629:18;:52::i;67444:186::-;67513:4;67546:10;67567:33;67546:10;67584:2;67588:5;67595:4;67567:9;:33::i;44443:140::-;44552:15;;;44528:4;44552:15;;;:6;:15;;;;;;;;34006:1;33997:10;;;33986:22;;;;;;;;34021:4;34013:12;;33986:40;33985:46;44552:23;44545:30;44443:140;-1:-1:-1;;;44443:140:0:o;76668:2211::-;76719:13;76754:14;44122:13;;;44048:95;76754:14;76748:2;:20;76745:54;;76777:22;;;;;;;;;;;;;;76745:54;76846:1;76822:13;76832:2;76822:9;:13::i;:::-;76816:27;:31;76812:70;;;76869:13;76879:2;76869:9;:13::i;76812:70::-;76926:1;76903:12;76897:26;;;;;:::i;:::-;;;:30;76893:1979;;;76973:12;76987:13;:2;:11;:13::i;:::-;76956:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;76942:60;;76668:2211;;;:::o;76893:1979::-;77033:10;77086:2;77069:20;;;;;;15479:19:1;;15523:2;15514:12;;15350:182;77069:20:0;;;;;;;;;;;;;77059:31;;;;;;77046:46;;77033:59;;77109:19;77143;77177:25;77231:2;77223:4;:10;;;77219:1276;;77254:29;;;;;;;;;;;;;;;;;;;77302:17;;;;;;;;;;;;;;;;;;;77338:206;;;;;;;;;;;;;;;;;;;77219:1276;;;77578:3;77570:4;:11;;;77566:929;;77602:26;;;;;;;;;;;;;;;;;;;77647:14;;;;;;;;;;;;;;;;;;;77680:216;;;;;;;;;;;;;;;;;;;77566:929;;;77930:3;77922:4;:11;;;77918:577;;77954:28;;;;;;;;;;;;;;;;;;;78001:16;;;;;;;;;;;;;;;;;;;78036:158;;;;;;;;;;;;;;;;;;;77918:577;;;78228:3;78220:4;:11;;;78216:279;;78252:28;;;;;;;;;;;;;;;;;;;78299:16;;;;;;;;;;;;;;;;;;;78334:145;;;;;;;;;;;;;;;;;;;78216:279;78511:26;78585:13;:2;:11;:13::i;:::-;78621:11;78687:7;78696:5;78547:155;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78511:192;;78780:12;78845:5;78732:127;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78718:142;;;;;;;76668:2211;;;:::o;76893:1979::-;76668:2211;;;:::o;74758:26::-;;;;;;;:::i;76455:106::-;2138:13;:11;:13::i;:::-;76529:12:::1;:24;76544:9:::0;76529:12;:24:::1;:::i;48001:410::-:0;48190:20;;;473:10;48190:20;;:60;;-1:-1:-1;48214:36:0;48231:4;473:10;47761:168;:::i;48214:36::-;48187:217;;;48266:51;48284:4;48290:2;48294;48298:6;48306:4;48312;48266:17;:51::i;:::-;48187:217;;;48357:35;;;;;;;;;;;;;;74730:21;;;;;;;:::i;3185:220::-;2138:13;:11;:13::i;:::-;3270:22:::1;::::0;::::1;3266:93;;3316:31;::::0;::::1;::::0;;3344:1:::1;3316:31;::::0;::::1;3917:74:1::0;3890:18;;3316:31:0::1;3771:226:1::0;3266:93:0::1;3369:28;3388:8;3369:18;:28::i;2417:166::-:0;2298:7;2325:6;2477:23;2325:6;473:10;2477:23;2473:103;;2524:40;;;;;473:10;2524:40;;;3917:74:1;3890:18;;2524:40:0;3771:226:1;54970:88:0;55037:4;:13;55044:6;55037:4;:13;:::i;71225:130::-;71310:37;71319:5;71326:7;71335:5;71342:4;71310:8;:37::i;:::-;71225:130;;;:::o;69255:325::-;69350:18;;;69346:88;;69392:30;;;;;69419:1;69392:30;;;3917:74:1;3890:18;;69392:30:0;3771:226:1;69346:88:0;69448:16;;;69444:88;;69488:32;;;;;69517:1;69488:32;;;3917:74:1;3890:18;;69488:32:0;3771:226:1;69444:88:0;69542:30;69550:4;69556:2;69560:5;69567:4;69542:7;:30::i;:::-;69255:325;;;;:::o;49405:1590::-;49609:16;;;49606:78;;49649:23;;;;;;;;;;;;;;49606:78;473:10;49696:16;49761:21;49779:2;49761:17;:21::i;:::-;49738:44;;49856:6;49866:1;49856:11;:35;;;;-1:-1:-1;49871:12:0;;;;;;;:6;:12;;;;;;;;34006:1;33997:10;;;33986:22;;;;;;;;;34021:4;34013:12;;33986:40;33985:46;49871:20;49853:260;;;49908:12;;;;;;;;:6;:12;;;;;;;;34498:1;34489:10;;;34478:22;;;;;;;;;:48;;34520:4;34512:12;;34506:19;;;34504:22;;34478:48;;;;;;49945:10;;;;;;;;;;;34279:22;;;;;;;;:47;;;;;;;;49978:40;;49908:12;;49945:10;;49998:12;;49978:9;:40::i;:::-;49853:260;;;50058:43;;;;;;;;;;;;;;49853:260;50319:16;50311:25;;;;50364:27;;50717:6;50311:25;50364:27;50583:25;50125:16;;50448:304;50811:2;50780:46;;50805:4;50780:46;;50795:8;50780:46;;;50815:2;50819:6;50780:46;;;;;;18390:25:1;;;18446:2;18431:18;;18424:34;18378:2;18363:18;;18216:248;50780:46:0;;;;;;;;50839:44;50859:8;50869:4;50875:2;50879:3;50839:19;:44::i;:::-;50899:5;50896:91;;;50919:68;50950:8;50960:4;50966:2;50970;50974:6;50982:4;50919:30;:68::i;:::-;49595:1400;;;;49405:1590;;;;;;:::o;71814:487::-;67745:18;;;;71914:24;67745:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;72001:17;71981:37;;71977:317;;72058:5;72039:16;:24;72035:132;;;72091:60;;;;;18701:42:1;18689:55;;72091:60:0;;;18671:74:1;18761:18;;;18754:34;;;18804:18;;;18797:34;;;18644:18;;72091:60:0;18469:368:1;72035:132:0;72210:57;72219:5;72226:7;72254:5;72235:16;:24;72261:5;72210:8;:57::i;38749:786::-;38871:13;38953:1;38944:10;;;38993:4;38985:12;;39035:3;39018:14;;;:20;39012:417;;39084:10;:18;;;;;;;;;;;28118:12;27991:11;39084:27;;;27984:1;27980:9;;;27976:27;;;;27969:35;;28056:1;28052:9;;;28063:11;28048:27;;;28027:19;;28023:53;28110:1;28106:9;;;28099:17;28095:36;28184:13;28177:21;28172:3;28168:31;27907:6;27940:10;;;28157:1;28153:13;28150:50;39162:14;;39230:4;39211:23;;;39162:14;-1:-1:-1;39286:8:0;;;;39131:17;;39181:1;39161:21;39151:32;39281:133;39306:9;39296:6;:19;39281:133;;39375:10;:18;;;;;;;;;;;28118:12;27991:11;27984:1;27980:9;;;27976:27;27969:35;;28056:1;28052:9;;;28063:11;28048:27;;;28027:19;;28023:53;28110:1;28106:9;;;28099:17;28095:36;28184:13;28177:21;28172:3;28168:31;27907:6;27940:10;;;28157:1;28153:13;28150:50;39350:44;;;;39317:8;;;;;39281:133;;;39041:388;39012:417;39469:10;:18;;;;;;;;;;;28118:12;27991:11;39469:27;;;39502:3;:12;;;39468:47;27984:1;27980:9;;;27976:27;;;;27969:35;;28056:1;28052:9;;;28063:11;28048:27;;;28027:19;;28023:53;28110:1;28106:9;;;28099:17;28095:36;28184:13;28177:21;28172:3;28168:31;27907:6;27940:10;;;28157:1;28153:13;28150:50;39443:73;;;;38749:786;-1:-1:-1;;;;;38749:786:0:o;51353:2773::-;51575:7;:14;51561:3;:10;:28;51558:89;;51613:22;;;;;;;;;;;;;;51558:89;51662:16;;;51659:78;;51702:23;;;;;;;;;;;;;;51659:78;473:10;51747:16;51849:370;51873:3;:10;51869:1;:14;51849:370;;;51905:10;51918:3;51922:1;51918:6;;;;;;;;:::i;:::-;;;;;;;51905:19;;51939:14;51956:7;51964:1;51956:10;;;;;;;;:::i;:::-;;;;;;;51939:27;;51986:6;51996:1;51986:11;:35;;;;-1:-1:-1;52001:12:0;;;;;;;:6;:12;;;;;;;;34006:1;33997:10;;;33986:22;;;;;;;;;34021:4;34013:12;;33986:40;33985:46;52001:20;51983:225;;;-1:-1:-1;52042:12:0;;;;;;;;:6;:12;;;;;;;;34498:1;34489:10;;;34478:22;;;;;;;;;:48;;34520:4;34512:12;;;34506:19;;;34504:22;;34478:48;;;;;52083:10;;;;;;;;;;;34279:22;;;;;;;;;:47;;;;;;;;51885:3;51849:370;;;;52229:53;52239:4;52245:2;52264:3;:10;52249:12;:25;;;;:::i;:::-;52276:5;52229:9;:53::i;:::-;52295:16;52322:18;52351:11;52365:3;:10;52378:1;52365:14;;;;:::i;:::-;52351:28;;52868:16;52862:4;52858:27;52844:41;;52919:16;52915:2;52911:25;52899:37;;53277:4;53272:3;53268:14;53262:21;53226:8;53186:10;53128:25;53073:1;53016;52993:319;53600:1;53562:336;53636:3;53627:7;53624:16;53562:336;;53872:7;53866:4;53862:18;53857:3;53853:28;53847:35;53837:8;53825:10;53798:25;53795:1;53792;53787:96;53685:1;53672:15;53562:336;;;53566:50;53956:2;53926:47;;53950:4;53926:47;;53940:8;53926:47;;;53960:3;53965:7;53926:47;;;;;;;:::i;:::-;;;;;;;;53986:44;54006:8;54016:4;54022:2;54026:3;53986:19;:44::i;:::-;54043:75;54079:8;54089:4;54095:2;54099:3;54104:7;54113:4;54043:35;:75::i;:::-;51547:2579;;;;51353:2773;;;;;:::o;3565:191::-;3639:16;3658:6;;;3675:17;;;;;;;;;;3708:40;;3658:6;;;;;;;3708:40;;3639:16;3708:40;3628:128;3565:191;:::o;44241:114::-;44288:7;43960:1;44122:13;;44315:32;;;;:::i;:::-;44308:39;;44241:114;:::o;62505:331::-;62660:8;62651:17;;:5;:17;;;62643:71;;;;;;;19644:2:1;62643: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;;62643:71:0;19442:405:1;62643:71:0;62725:25;;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;;;;;;;;;;;;62787:41;;1228::1;;;62787::0;;1201:18:1;62787:41:0;;;;;;;62505:331;;;:::o;45593:105::-;45653:13;45686:4;45679:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45593:105;;;:::o;13288:723::-;13344:13;13565:5;13574:1;13565:10;13561:53;;-1:-1:-1;;13592:10:0;;;;;;;;;;;;;;;;;;13288:723::o;13561:53::-;13639:5;13624:12;13680:78;13687:9;;13680:78;;13713:8;;;;:::i;:::-;;-1:-1:-1;13736:10:0;;-1:-1:-1;13744:2:0;13736:10;;:::i;:::-;;;13680:78;;;13768:19;13800:6;13790:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13790:17:0;;13768:39;;13818:154;13825:10;;13818:154;;13852:11;13862:1;13852:11;;:::i;:::-;;-1:-1:-1;13921:10:0;13929:2;13921:5;:10;:::i;:::-;13908:24;;:2;:24;:::i;:::-;13895:39;;13878:6;13885;13878:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;13949:11:0;13958:2;13949:11;;:::i;:::-;;;13818:154;;71363:443;71476:19;;;71472:91;;71519:32;;;;;71548:1;71519:32;;;3917:74:1;3890:18;;71519:32:0;3771:226:1;71472:91:0;71577:21;;;71573:92;;71622:31;;;;;71650:1;71622:31;;;3917:74:1;3890:18;;71622:31:0;3771:226:1;71573:92:0;71675:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;71721:78;;;;71772:7;71756:31;;71765:5;71756:31;;;71781:5;71756:31;;;;620:25:1;;608:2;593:18;;474:177;71756:31:0;;;;;;;;71363:443;;;;:::o;69588:1629::-;69707:15;;;;69685:19;69707:15;;;:9;:15;;;;;;;69753:13;;;;;;;;69781:19;;;69777:109;;;69824:50;;;;;18701:42:1;18689:55;;69824:50:0;;;18671:74:1;18761:18;;;18754:34;;;18804:18;;;18797:34;;;18644:18;;69824:50:0;18469:368:1;69777:109:0;69999:15;;;;;;;;:9;:15;;;;;;70017:19;;;69999:37;;70167:13;;;;;;;;;;:22;;;;;;70218:25;;;;;;70031:5;620:25:1;;608:2;593:18;;474:177;70218:25:0;;;;;;;;70259:4;70256:954;;;70351:15;;;70340:8;70351:15;;;:9;:15;;;;;;;;;70381:234;;70410:22;70491:12;70468:19;70482:5;70468:11;:19;:::i;:::-;70467:36;;;;:::i;:::-;70436:26;70450:12;70436:11;:26;:::i;:::-;70435:69;;;;:::i;:::-;70410:94;-1:-1:-1;70526:18:0;;70523:76;;70567:32;70578:4;70584:14;70567:10;:32::i;:::-;70391:224;70381:234;70699:13;;;;;;;:9;:13;;;;;;;;70694:505;;70736:10;;70750:1;70736:15;:22;;;;;70755:3;70736:22;:41;;;;-1:-1:-1;2298:7:0;2325:6;;70762:15;;;2325:6;;70762:15;70736:41;70733:451;;;70860:13;;;;;;;:9;:13;;;;;:20;;;;70876:4;70860:20;;;70916:1;70903:10;:14;70733:451;;;70966:22;71031:24;71043:12;71031:9;:24;:::i;:::-;71014:12;70993:17;71005:5;70993:9;:17;:::i;:::-;70992:34;;;;:::i;:::-;70991:65;;;;:::i;:::-;70966:90;-1:-1:-1;71082:18:0;;71079:85;;71127:37;71145:2;71149:14;71127:17;:37::i;71079:85::-;70943:241;70733:451;70265:945;70256:954;69674:1543;;69588:1629;;;;:::o;67274:162::-;67383:16;;;67397:1;67383:16;;;;;;;;;67340:22;;67383:16;;;;;;;;;;;-1:-1:-1;67383:16:0;67375:24;;67421:7;67410:5;67416:1;67410:8;;;;;;;;:::i;:::-;;;;;;:18;;;;;67274:162;;;:::o;75402:716::-;75573:13;;;;;;;:9;:13;;;;;;;;75569:461;;75628:9;;75611:13;;;;;;;:9;:13;;;;;;:26;;75603:70;;;;;;;20371:2:1;75603:70:0;;;20353:21:1;20410:2;20390:18;;;20383:30;20449:33;20429:18;;;20422:61;20500:18;;75603:70:0;20169:355:1;75603:70:0;75692:13;;;;75688:331;;;75745:9;75734:21;;;;:10;:21;;;;;;75758:12;-1:-1:-1;75726:84:0;;;;;;;20731:2:1;75726: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;;75726:84:0;20529:400:1;75726:84:0;75840:9;75829:21;;;;:10;:21;;;;;75853:12;75829:36;;:21;75894:23;;;:28;:67;;;;-1:-1:-1;75934:9:0;75926:30;:35;75894:67;75886:117;;;;;;;21136:2:1;75886: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;;75886:117:0;20934:401:1;75886:117:0;76060:50;69255:325;65072:1389;65287:13;;;6052:20;6100:8;65283:1171;;65323:57;;;;;65353:26;65323:57;;;21484:98:1;65323:29:0;;;;;;21457:18:1;;65323:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65319:1124;;;65405:72;;;;;:38;;;;;;:72;;65444:8;;65454:4;;65460:2;;65464:6;;65472:4;;65405:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65405:72:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;65401:495;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;65771:6;65764:14;;;;;;;;;;;:::i;65401:495::-;;;65835:41;;;;;;;;;;;;;;65401:495;65531:55;;;65543:43;65531:55;65527:160;;65622:41;;;;;;;;;;;;;;65527:160;65478:228;65319:1124;;;65953:61;;;;;:35;;;;;;:61;;65989:8;;65999:4;;66005:2;;66009:4;;65953:61;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65953:61:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;65949:479;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;66368:40;;;;;;;;;;;;;;65949:479;66068:52;;;66080:40;66068:52;66064:156;;66156:40;;;;;;;;;;;;;;66469:797;66709:13;;;6052:20;6100:8;66705:554;;66745:79;;;;;:43;;;;;;:79;;66789:8;;66799:4;;66805:3;;66810:7;;66819:4;;66745:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66745:79:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;66741:507;;;;:::i;:::-;66906:60;;;66918:48;66906:60;66902:157;;66998:41;;;;;;;;;;;;;;60624:1735;60730:18;;;60727:77;;60771:21;;;;;;;;;;;;;;60727:77;44122:13;;473:10;;60908:24;60949:6;60935:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60935:21:0;;60908:48;;60967:20;61004:6;60990:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60990:21:0;;60967:44;;61053:9;61049:258;61072:6;61068:1;:10;61049:258;;;61117:1;61104:7;61112:1;61104:10;;;;;;;;:::i;:::-;;;;;;;;;;;:14;;;;61150:12;;;61137:10;61150:12;;;:6;:12;;;;;;:36;;61175:10;61150:24;:36::i;:::-;61137:49;;61214:2;61205:3;61209:1;61205:6;;;;;;;;:::i;:::-;;;;;;;;;;;:11;;;;61235:12;;;;;;;:6;:12;;;;;;;34498:1;34489:10;;;34478:22;;;;;;;;:48;;34520:4;34512:12;;34506:19;;;34504:22;34478:48;;;34489:10;;-1:-1:-1;61080:3:0;61049:258;;;;61458:18;;61501:10;:6;61510:1;61501:10;:::i;:::-;61487:24;;61572:16;61566:4;61562:27;61548:41;;61774:4;61769:3;61765:14;61759:21;61739:1;61710:10;61666:25;61646:1;61626;61603:192;61849:1;61811:264;61885:3;61876:7;61873:16;61811:264;;62049:7;62043:4;62039:18;62034:3;62030:28;62024:35;62021:1;62009:10;61982:25;61979:1;61976;61971:89;61934:1;61921:15;61811:264;;;61815:50;62101:6;62111:1;62101:11;62098:176;;62171:1;62132:53;;62157:4;62132:53;;62147:8;62132:53;;;62175:3;62179:1;62175:6;;;;;;;;:::i;:::-;;;;;;;62183:1;62132:53;;;;;;18390:25:1;;;18446:2;18431:18;;18424:34;18378:2;18363:18;;18216:248;62132:53:0;;;;;;;;62098:176;;;62257:1;62219:55;;62243:4;62219:55;;62233:8;62219:55;;;62261:3;62266:7;62219:55;;;;;;;:::i;:::-;;;;;;;;62098:176;62297:52;62317:8;62327:4;62341:1;62345:3;62297:19;:52::i;55993:1661::-;56098:20;;56162:16;;;56159:74;;56202:19;;;;;;;;;;;;;;56159:74;56246:6;56256:1;56246:11;56243:68;;56281:18;;;;;;;;;;;;;;56243:68;473:10;56387:6;56373:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56373:21:0;;56367:27;;56429:6;56415:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56415:21:0;;56405:31;;56447:20;56470:14;44122:13;;;44048:95;56470:14;56447:37;;56560:12;56550:6;56530:17;:26;:42;;56522:51;;;;;;56592:9;56588:129;56611:6;56607:1;:10;56588:129;;;56667:1;56652:12;:16;56643:3;56647:1;56643:6;;;;;;;;:::i;:::-;;;;;;:25;;;;;56700:1;56687:7;56695:1;56687:10;;;;;;;;:::i;:::-;;;;;;;;;;:14;56619:3;;56588:129;;;;56812:10;;;;;;;:6;:10;;;;;:41;;56832:12;56846:6;56812:19;:41::i;:::-;56881:6;56864:13;;:23;;;;;;;:::i;:::-;;;;-1:-1:-1;56900:16:0;;-1:-1:-1;56900:16:0;56941:21;56956:6;56941:12;:21;:::i;:::-;56927:35;;57019:16;57015:2;57011:25;56999:37;;57204:12;57177:8;57157:1;57113:25;57093:1;57073;57050:181;57303:1;57289:12;57285:20;57247:253;57340:3;57331:7;57328:16;57247:253;;57477:7;57467:8;57464:1;57437:25;57434:1;57431;57426:59;57389:1;57376:15;57247:253;;;57251:69;57564:2;57528:53;;57560:1;57528:53;;57542:8;57528:53;;;57568:3;57573:7;57528:53;;;;;;;:::i;:::-;;;;;;;;57594:50;57614:8;57632:1;57636:2;57640:3;57594:19;:50::i;:::-;56146:1508;;;;55993:1661;;;;;:::o;39689:1230::-;40007:1;40003:14;;;39799:19;40031:20;;;40072:4;40065:25;;;40245:4;40229:21;;40223:28;39973:6;;40003:14;40122:4;40128:11;;40118:22;40211:41;;;40199:54;;40292:14;;40277:30;;40267:356;;40328:280;-1:-1:-1;40373:24:0;;40447:4;40440:20;;;40518:4;40502:21;;40496:28;40564:14;;40549:30;;40546:43;40328:280;40546:43;40328:280;40648:15;;40644:268;;40710:22;40721:10;25710:66;25634:4;25655:34;25260:9;;25257:1;25253:17;25282:34;25279:41;-1:-1:-1;25276:1:0;25272:49;25250:72;25377:9;;;25357:18;25354:33;25351:1;25347:41;25341:48;25436:9;;;25424:10;25421:25;25418:1;25414:33;25408:40;25491:9;;;25483:6;25480:21;25477:1;25473:29;25467:36;25544:9;;;25538:4;25535:19;25532:1;25528:27;25522:34;25644:9;;;25640:50;25630:61;25625:152;25619:159;;25108:688;40710:22;40705:1;40695:11;;;40694:38;40861:23;;;40858:1;40854:31;40838:48;;-1:-1:-1;40644:268:0;39825:1094;;39689:1230;;;;:::o;36242:1129::-;36417:1;36413:6;36457:4;36450:5;36446:16;36489:11;36483:4;36476:25;36535:5;36532:1;36528:13;36522:4;36515:27;36589:3;36580:6;36573:5;36569:18;36566:27;36556:646;;36643:4;36633:21;;36649:4;36633:21;;36695:18;;36715:15;;;36692:39;36672:60;;36842:18;;;;36914:4;36890:29;;;-1:-1:-1;36764:19:0;;;36839:1;36835:26;36818:44;36965:184;36990:9;36982:6;36979:21;36965:184;;37067:6;37061:4;37054:20;37126:3;37119:4;37113;37103:21;37096:34;37026:1;37018:6;37014:14;37004:24;;36965:184;;;-1:-1:-1;37174:4:0;37167:20;36556:646;37251:4;37245;37235:21;37346:3;37337:6;37332:3;37328:16;37324:26;37317:5;37313:38;37299:11;37293:18;37290:62;37277:11;37270:83;;;;36242: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://4897ac9dc389ae31b7835283dc098a73297df37826247e13c96840d0a4004fa6

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