Token

Illuminati Association (TRUTH)

ERC-1155

NFT

Overview

Max Total Supply

6,066 TRUTH

Holders

1,905

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xe25f0fe686477f9df3c2876c4902d3b85f75f33a

Filtered by Token Holder

0x7667F9Bf30460286f3AF0c2F333e1A1ACEB8fD44

nft-pizza.eth

0x7667f9bf30460286f3af0c2f333e1a1aceb8fd44

OVERVIEW

This token grants you the privilege of joining the Illuminati DAO, unlocking voting access to the DAO’s Treasury. This is a power that is coveted by many, but that only a select few shall hold.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

TRUTH

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

Yes with 20000 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-04-19
*/

/**
 *Submitted for verification at Etherscan.io on 2022-04-19
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}
// File: Context.sol



pragma solidity ^0.8.0;

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

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}
// File: Ownable.sol



pragma solidity ^0.8.0;


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

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

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

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

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

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

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

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}
// File: Address.sol



pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}
// File: IERC721Receiver.sol



pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}
// File: IERC165.sol



pragma solidity ^0.8.0;

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



pragma solidity ^0.8.0;


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

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



pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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



pragma solidity ^0.8.0;


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



pragma solidity ^0.8.0;


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



pragma solidity ^0.8.0;







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

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

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

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

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

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

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

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

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

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

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

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(_msgSender() != operator, "ERC1155: setting approval status for self");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: transfer caller is not owner nor approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

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

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

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

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

        address operator = _msgSender();

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

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

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

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

        address operator = _msgSender();

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

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

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

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

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

        address operator = _msgSender();

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

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

        emit TransferSingle(operator, account, address(0), id, amount);
    }

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

        address operator = _msgSender();

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

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

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

        emit TransferBatch(operator, account, address(0), ids, amounts);
    }

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

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

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

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

        return array;
    }
}
// File: IERC721.sol



pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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



pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}
// File: IERC721Metadata.sol



pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}
// File: ERC721.sol


pragma solidity ^0.8.10;







abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    string private _name;
    string private _symbol;
    address[] internal _owners;
    mapping(uint256 => address) private _tokenApprovals;
    mapping(address => mapping(address => bool)) private _operatorApprovals;     
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }     
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        uint count = 0;
        uint length = _owners.length;
        for( uint i = 0; i < length; ++i ){
          if( owner == _owners[i] ){
            ++count;
          }
        }
        delete length;
        return count;
    }
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }
    function name() public view virtual override returns (string memory) {
        return _name;
    }
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }     
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }
	function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return tokenId < _owners.length && _owners[tokenId] != address(0);
    }
	function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }
	function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }
	function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }
	function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);
        _owners.push(to);

        emit Transfer(address(0), to, tokenId);
    }
	function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);
        _owners[tokenId] = address(0);

        emit Transfer(owner, address(0), tokenId);
    }
	function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }
	function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }
	function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }
	function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

pragma solidity ^0.8.0;

abstract contract ERC1155Supply is ERC1155 {
    mapping(uint256 => uint256) private _totalSupply;

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

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

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

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

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

// File: ERC721Enumerable.sol


pragma solidity ^0.8.10;


abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
        return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
    }
    function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256 tokenId) {
        require(index < ERC721.balanceOf(owner), "ERC721Enum: owner ioob");
        uint count;
        for( uint i; i < _owners.length; ++i ){
            if( owner == _owners[i] ){
                if( count == index )
                    return i;
                else
                    ++count;
            }
        }
        require(false, "ERC721Enum: owner ioob");
    }
    function tokensOfOwner(address owner) public view returns (uint256[] memory) {
        require(0 < ERC721.balanceOf(owner), "ERC721Enum: owner ioob");
        uint256 tokenCount = balanceOf(owner);
        uint256[] memory tokenIds = new uint256[](tokenCount);
        for (uint256 i = 0; i < tokenCount; i++) {
            tokenIds[i] = tokenOfOwnerByIndex(owner, i);
        }
        return tokenIds;
    }
    function totalSupply() public view virtual override returns (uint256) {
        return _owners.length;
    }
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enum: global ioob");
        return index;
    }
}

pragma solidity ^0.8.9;

abstract contract ILLUMINATI {
  function ownerOf(uint256 tokenId) public virtual view returns (address);
  function tokenOfOwnerByIndex(address owner, uint256 index) public virtual view returns (uint256);
  function balanceOf(address owner) external virtual view returns (uint256 balance);
  function tokensOfOwner(address owner) public virtual view returns (uint256[] memory);
}

contract TRUTH is ERC1155, Ownable {
	using Strings for string;

	mapping(uint256 => bool) public claimTracker;

	ILLUMINATI private illuminati;

	uint256 constant nft1 = 1;
	uint constant public maxSupply = 8128;
    uint public airdropped = 2210;
    uint  public claimedCount = airdropped; //start at airdropped

	string public _baseURI;
	string public _contractURI;

	bool public claimLive = false;

    string name_;
    string symbol_;   

	constructor(
        address illuminatiContractAddress,
        string memory _name,
        string memory _symbol
        ) 
		ERC1155(_baseURI)  {
        name_ = _name;
        symbol_ = _symbol;
		illuminati = ILLUMINATI(illuminatiContractAddress);
	}

	// claim function
    function claim(uint256[] calldata illuminatiIDs) external {		
		//initial checks
		require(claimLive,"Claim Window is not live");
		require(illuminatiIDs.length > 0,"You must claim at least 1 token"); // you must claim
	
		// checks
		for(uint256 x = 0; x < illuminatiIDs.length; x++) {
		require(illuminati.ownerOf(illuminatiIDs[x]) == msg.sender,"You do not own these Illuminati"); //check inputted balance
		require(claimTracker[illuminatiIDs[x]] == false,"An inputted token was already claimed"); //check if inputted tokens claimed
		claimTracker[illuminatiIDs[x]] = true; //track claims
        }
        _mint(msg.sender, nft1, illuminatiIDs.length, ""); //mint 1 per
        claimedCount += illuminatiIDs.length;
    }

	// aidrop function
    function aidrop(uint256[] calldata illuminatiIDs, address[] calldata addr) public onlyOwner {		
		for(uint256 x = 0; x < illuminatiIDs.length; x++) {
        _mint(addr[x], nft1, 1, ""); //mint 1 per
    	claimTracker[illuminatiIDs[x]] = true; //track claims
        }
    }

	// admin claim (token 0)
    function claimStartingToken(uint256 illuminatiID) external onlyOwner {		
		require(illuminatiID == 0,"You must claimtoken 0"); // you must claim
         _mint(msg.sender, nft1, 1, ""); //mint 1 per
		 claimTracker[illuminatiID] = true; //track claims
         claimedCount += 1;
    }

	//metadata
	function setBaseURI(string memory newuri) public onlyOwner {
		_baseURI = newuri;
	}

	function setContractURI(string memory newuri) public onlyOwner {
		_contractURI = newuri;
	}

	function uri(uint256 tokenId) public view override returns (string memory) {
		return string(abi.encodePacked(_baseURI, uint2str(tokenId)));
	}

	function contractURI() public view returns (string memory) {
		return _contractURI;
	}

	function uint2str(uint256 _i) internal pure returns (string memory _uintAsString) {
		if (_i == 0) {return "0";}
			uint256 j = _i;
			uint256 len;
		while (j != 0) {len++; j /= 10;}
			bytes memory bstr = new bytes(len);
			uint256 k = len;
		while (_i != 0) {
			k = k - 1;
			uint8 temp = (48 + uint8(_i - (_i / 10) * 10));
			bytes1 b1 = bytes1(temp);
			bstr[k] = b1;
			_i /= 10;
		}
		return string(bstr);
	}

	// enables claim
	function setClaimLive(bool _live) external onlyOwner {
		claimLive = _live;
	}

	//check claim by token
	function checkClaimed(uint256 tokenId) public view returns (bool) {
		return claimTracker[tokenId];
	}

    function totalSupply() public view returns (uint){
        return claimedCount;
    }

	//check Illuminati Tokens
	function checkIlluminatiTokens(address owner) public view returns (uint256[] memory){
		uint256 tokenCount = illuminati.balanceOf(owner);
		uint256[] memory tokenIds = new uint256[](tokenCount);
        for (uint256 i = 0; i < tokenCount; i++) {
            tokenIds[i] = illuminati.tokenOfOwnerByIndex(owner, i);
        }
		return tokenIds;
	}

    function name() public view returns (string memory) {
        return name_;
    }

    function symbol() public view returns (string memory) {
        return symbol_;
    }       

	//withdraw any funds
	function withdrawToOwner() external onlyOwner {
		payable(msg.sender).transfer(address(this).balance);
	}



}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"illuminatiContractAddress","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[],"name":"_baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"illuminatiIDs","type":"uint256[]"},{"internalType":"address[]","name":"addr","type":"address[]"}],"name":"aidrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"airdropped","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"checkClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"checkIlluminatiTokens","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"illuminatiIDs","type":"uint256[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimLive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"illuminatiID","type":"uint256"}],"name":"claimStartingToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"claimTracker","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimedCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","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":"newuri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_live","type":"bool"}],"name":"setClaimLive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newuri","type":"string"}],"name":"setContractURI","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":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawToOwner","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

00000000000000000000000026badf693f2b103b021c670c852262b379bbbe8a000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000016496c6c756d696e617469204173736f63696174696f6e0000000000000000000000000000000000000000000000000000000000000000000000000000000000055452555448000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : illuminatiContractAddress (address): 0x26BAdF693F2b103B021c670c852262b379bBBE8A
Arg [1] : _name (string): Illuminati Association
Arg [2] : _symbol (string): TRUTH

-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 00000000000000000000000026badf693f2b103b021c670c852262b379bbbe8a
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000016
Arg [4] : 496c6c756d696e617469204173736f63696174696f6e00000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [6] : 5452555448000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

54952:4066:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24663:231;;;;;;:::i;:::-;;:::i;:::-;;;639:25:1;;;627:2;612:18;24663:231:0;;;;;;;;23686:310;;;;;;:::i;:::-;;:::i;:::-;;;1272:14:1;;1265:22;1247:41;;1235:2;1220:18;23686:310:0;1107:187:1;58689:83:0;;;:::i;:::-;;;;;;;:::i;57290:145::-;;;;;;:::i;:::-;;:::i;58209:87::-;58276:12;;58209:87;;55179:29;;;;;;26758:442;;;;;;:::i;:::-;;:::i;:::-;;55339:29;;;;;;;;;58097:104;;;;;;:::i;:::-;58157:4;58175:21;;;:12;:21;;;;;;;;;58097:104;56478:279;;;;;;:::i;:::-;;:::i;58902:107::-;;;:::i;55021:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;25060:524;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;57100:86::-;;;;;;:::i;:::-;;:::i;55711:738::-;;;;;;:::i;:::-;;:::i;4538:94::-;;;:::i;58329:352::-;;;;;;:::i;:::-;;:::i;55281:22::-;;;:::i;57987:80::-;;;;;;:::i;:::-;;:::i;3887:87::-;3960:6;;3887:87;;3960:6;;;;10351:74:1;;10339:2;10324:18;3887:87:0;10205:226:1;57191:94:0;;;;;;:::i;:::-;;:::i;58780:87::-;;;:::i;25657:311::-;;;;;;:::i;:::-;;:::i;56792:290::-;;;;;;:::i;:::-;;:::i;55215:38::-;;;;;;55307:26;;;:::i;55135:37::-;;55168:4;55135:37;;57440:88;;;:::i;26040:168::-;;;;;;:::i;:::-;26163:27;;;;26139:4;26163:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;26040:168;26280:401;;;;;;:::i;:::-;;:::i;4787:192::-;;;;;;:::i;:::-;;:::i;24663:231::-;24749:7;24777:21;;;24769:77;;;;-1:-1:-1;;;24769:77:0;;12090:2:1;24769:77:0;;;12072:21:1;12129:2;12109:18;;;12102:30;12168:34;12148:18;;;12141:62;12239:13;12219:18;;;12212:41;12270:19;;24769:77:0;;;;;;;;;-1:-1:-1;24864:9:0;:13;;;;;;;;;;;:22;;;;;;;;;;;;;24663:231::o;23686:310::-;23788:4;23825:41;;;23840:26;23825:41;;:110;;-1:-1:-1;23883:52:0;;;23898:37;23883:52;23825:110;:163;;;-1:-1:-1;22671:25:0;22656:40;;;;23952:36;23805:183;23686:310;-1:-1:-1;;23686:310:0:o;58689:83::-;58726:13;58759:5;58752:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58689:83;:::o;57290:145::-;57350:13;57401:8;57411:17;57420:7;57411:8;:17::i;:::-;57384:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57370:60;;57290:145;;;:::o;26758:442::-;26991:20;;;2788:10;26991:20;;:60;;-1:-1:-1;27015:36:0;27032:4;2788:10;26040:168;:::i;27015:36::-;26969:160;;;;-1:-1:-1;;;26969:160:0;;14554:2:1;26969:160:0;;;14536:21:1;14593:2;14573:18;;;14566:30;14632:34;14612:18;;;14605:62;14703:20;14683:18;;;14676:48;14741:19;;26969:160:0;14352:414:1;26969:160:0;27140:52;27163:4;27169:2;27173:3;27178:7;27187:4;27140:22;:52::i;:::-;26758:442;;;;;:::o;56478:279::-;3960:6;;4107:23;3960:6;2788:10;4107:23;4099:68;;;;-1:-1:-1;;;4099:68:0;;14973:2:1;4099:68:0;;;14955:21:1;;;14992:18;;;14985:30;15051:34;15031:18;;;15024:62;15103:18;;4099:68:0;14771:356:1;4099:68:0;56581:9:::1;56577:173;56596:24:::0;;::::1;56577:173;;;56638:27;56644:4;;56649:1;56644:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;55130:1;56659::::0;56638:27:::1;;;;;;;;;;;::::0;:5:::1;:27::i;:::-;56719:4;56686:12;:30;56699:13;;56713:1;56699:16;;;;;;;:::i;:::-;;;;;;;56686:30;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;56622:3;;;;;:::i;:::-;;;;56577:173;;58902:107:::0;3960:6;;4107:23;3960:6;2788:10;4107:23;4099:68;;;;-1:-1:-1;;;4099:68:0;;14973:2:1;4099:68:0;;;14955:21:1;;;14992:18;;;14985:30;15051:34;15031:18;;;15024:62;15103:18;;4099:68:0;14771:356:1;4099:68:0;58953:51:::1;::::0;58961:10:::1;::::0;58982:21:::1;58953:51:::0;::::1;;;::::0;::::1;::::0;;;58982:21;58961:10;58953:51;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;58902:107::o:0;25060:524::-;25216:16;25277:3;:10;25258:8;:15;:29;25250:83;;;;-1:-1:-1;;;25250:83:0;;15912:2:1;25250:83:0;;;15894:21:1;15951:2;15931:18;;;15924:30;15990:34;15970:18;;;15963:62;16061:11;16041:18;;;16034:39;16090:19;;25250:83:0;15710:405:1;25250:83:0;25346:30;25393:8;:15;25379:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25379:30:0;;25346:63;;25427:9;25422:122;25446:8;:15;25442:1;:19;25422:122;;;25502:30;25512:8;25521:1;25512:11;;;;;;;;:::i;:::-;;;;;;;25525:3;25529:1;25525:6;;;;;;;;:::i;:::-;;;;;;;25502:9;:30::i;:::-;25483:13;25497:1;25483:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;25463:3;;;:::i;:::-;;;25422:122;;;-1:-1:-1;25563:13:0;25060:524;-1:-1:-1;;;25060:524:0:o;57100:86::-;3960:6;;4107:23;3960:6;2788:10;4107:23;4099:68;;;;-1:-1:-1;;;4099:68:0;;14973:2:1;4099:68:0;;;14955:21:1;;;14992:18;;;14985:30;15051:34;15031:18;;;15024:62;15103:18;;4099:68:0;14771:356:1;4099:68:0;57164:17;;::::1;::::0;:8:::1;::::0;:17:::1;::::0;::::1;::::0;::::1;:::i;:::-;;57100:86:::0;:::o;55711:738::-;55804:9;;;;55796:45;;;;-1:-1:-1;;;55796:45:0;;16322:2:1;55796:45:0;;;16304:21:1;16361:2;16341:18;;;16334:30;16400:26;16380:18;;;16373:54;16444:18;;55796:45:0;16120:348:1;55796:45:0;55854:24;55846:67;;;;-1:-1:-1;;;55846:67:0;;16675:2:1;55846:67:0;;;16657:21:1;16714:2;16694:18;;;16687:30;16753:33;16733:18;;;16726:61;16804:18;;55846:67:0;16473:355:1;55846:67:0;55956:9;55952:370;55971:24;;;55952:370;;;56015:10;;56055;;56015:50;:10;:18;56034:13;;56048:1;56034:16;;;;;;;:::i;:::-;;;;;;;56015:36;;;;;;;;;;;;;639:25:1;;627:2;612:18;;493:177;56015:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;;56007:93;;;;-1:-1:-1;;;56007:93:0;;17291:2:1;56007:93:0;;;17273:21:1;17330:2;17310:18;;;17303:30;17369:33;17349:18;;;17342:61;17420:18;;56007:93:0;17089:355:1;56007:93:0;56138:12;:30;56151:13;;56165:1;56151:16;;;;;;;:::i;:::-;;;;;;;;;;56138:30;;-1:-1:-1;56138:30:0;;;;;;;;-1:-1:-1;56138:30:0;;;;:39;56130:88;;;;-1:-1:-1;;;56130:88:0;;17651:2:1;56130:88:0;;;17633:21:1;17690:2;17670:18;;;17663:30;17729:34;17709:18;;;17702:62;17800:7;17780:18;;;17773:35;17825:19;;56130:88:0;17449:401:1;56130:88:0;56291:4;56258:12;:30;56271:13;;56285:1;56271:16;;;;;;;:::i;:::-;;;;;;;56258:30;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;55997:3;;;;;:::i;:::-;;;;55952:370;;;;56332:49;56338:10;55130:1;56356:13;;:20;;56332:49;;;;;;;;;;;;:5;:49::i;:::-;56421:13;;:20;;56405:12;;:36;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;55711:738:0:o;4538:94::-;3960:6;;4107:23;3960:6;2788:10;4107:23;4099:68;;;;-1:-1:-1;;;4099:68:0;;14973:2:1;4099:68:0;;;14955:21:1;;;14992:18;;;14985:30;15051:34;15031:18;;;15024:62;15103:18;;4099:68:0;14771:356:1;4099:68:0;4603:21:::1;4621:1;4603:9;:21::i;:::-;4538:94::o:0;58329:352::-;58439:10;;:27;;;;;:10;10369:55:1;;;58439:27:0;;;10351:74:1;58396:16:0;;58418:18;;58439:10;;;:20;;10324:18:1;;58439:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58418:48;;58471:25;58513:10;58499:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58499:25:0;;58471:53;;58540:9;58535:122;58559:10;58555:1;:14;58535:122;;;58605:10;;:40;;;;;:10;18369:55:1;;;58605:40:0;;;18351:74:1;18441:18;;;18434:34;;;58605:10:0;;;;:30;;18324:18:1;;58605:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58591:8;58600:1;58591:11;;;;;;;;:::i;:::-;;;;;;;;;;:54;58571:3;;;;:::i;:::-;;;;58535:122;;55281:22;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;57987:80::-;3960:6;;4107:23;3960:6;2788:10;4107:23;4099:68;;;;-1:-1:-1;;;4099:68:0;;14973:2:1;4099:68:0;;;14955:21:1;;;14992:18;;;14985:30;15051:34;15031:18;;;15024:62;15103:18;;4099:68:0;14771:356:1;4099:68:0;58045:9:::1;:17:::0;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;57987:80::o;57191:94::-;3960:6;;4107:23;3960:6;2788:10;4107:23;4099:68;;;;-1:-1:-1;;;4099:68:0;;14973:2:1;4099:68:0;;;14955:21:1;;;14992:18;;;14985:30;15051:34;15031:18;;;15024:62;15103:18;;4099:68:0;14771:356:1;4099:68:0;57259:21;;::::1;::::0;:12:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;58780:87::-:0;58819:13;58852:7;58845:14;;;;;:::i;25657:311::-;25760:24;;;2788:10;25760:24;25752:78;;;;-1:-1:-1;;;25752:78:0;;18681:2:1;25752:78:0;;;18663:21:1;18720:2;18700:18;;;18693:30;18759:34;18739:18;;;18732:62;18830:11;18810:18;;;18803:39;18859:19;;25752:78:0;18479:405:1;25752:78:0;2788:10;25843:32;;;;:18;:32;;;;;;;;;:42;;;;;;;;;;;;:53;;;;;;;;;;;;;25912:48;;1247:41:1;;;25843:42:0;;2788:10;25912:48;;1220:18:1;25912:48:0;;;;;;;25657:311;;:::o;56792:290::-;3960:6;;4107:23;3960:6;2788:10;4107:23;4099:68;;;;-1:-1:-1;;;4099:68:0;;14973:2:1;4099:68:0;;;14955:21:1;;;14992:18;;;14985:30;15051:34;15031:18;;;15024:62;15103:18;;4099:68:0;14771:356:1;4099:68:0;56876:17;;56868:50:::1;;;::::0;-1:-1:-1;;;56868:50:0;;19091:2:1;56868:50:0::1;::::0;::::1;19073:21:1::0;19130:2;19110:18;;;19103:30;19169:23;19149:18;;;19142:51;19210:18;;56868:50:0::1;18889:345:1::0;56868:50:0::1;56948:30;56954:10;55130:1;56972::::0;56948:30:::1;;;;;;;;;;;::::0;:5:::1;:30::i;:::-;56997:26;::::0;;;:12:::1;:26;::::0;;;;:33;;;::::1;57026:4;56997:33:::0;;::::1;::::0;;;57057:12:::1;:17:::0;;57026:4;;57057:12;;:17:::1;::::0;57026:4;;57057:17:::1;:::i;:::-;::::0;;;-1:-1:-1;;;56792:290:0:o;55307:26::-;;;;;;;:::i;57440:88::-;57484:13;57511:12;57504:19;;;;;:::i;26280:401::-;26488:20;;;2788:10;26488:20;;:60;;-1:-1:-1;26512:36:0;26529:4;2788:10;26040:168;:::i;26512:36::-;26466:151;;;;-1:-1:-1;;;26466:151:0;;19441:2:1;26466:151:0;;;19423:21:1;19480:2;19460:18;;;19453:30;19519:34;19499:18;;;19492:62;19590:11;19570:18;;;19563:39;19619:19;;26466:151:0;19239:405:1;26466:151:0;26628:45;26646:4;26652:2;26656;26660:6;26668:4;26628:17;:45::i;4787:192::-;3960:6;;4107:23;3960:6;2788:10;4107:23;4099:68;;;;-1:-1:-1;;;4099:68:0;;14973:2:1;4099:68:0;;;14955:21:1;;;14992:18;;;14985:30;15051:34;15031:18;;;15024:62;15103:18;;4099:68:0;14771:356:1;4099:68:0;4876:22:::1;::::0;::::1;4868:73;;;::::0;-1:-1:-1;;;4868:73:0;;19851:2:1;4868:73:0::1;::::0;::::1;19833:21:1::0;19890:2;19870:18;;;19863:30;19929:34;19909:18;;;19902:62;20000:8;19980:18;;;19973:36;20026:19;;4868:73:0::1;19649:402:1::0;4868:73:0::1;4952:19;4962:8;4952:9;:19::i;57533:430::-:0;57586:27;57624:2;57630:1;57624:7;57620:26;;-1:-1:-1;;57634:10:0;;;;;;;;;;;;;;;;;;57533:430::o;57620:26::-;57663:2;57651:9;57687:32;57694:6;;57687:32;;57703:5;;;;:::i;:::-;;-1:-1:-1;57710:7:0;;-1:-1:-1;57715:2:0;57710:7;;:::i;:::-;;;57687:32;;;57724:17;57754:3;57744:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57744:14:0;-1:-1:-1;57724:34:0;-1:-1:-1;57776:3:0;57784:151;57791:7;;57784:151;;57810:5;57814:1;57810;:5;:::i;:::-;57806:9;-1:-1:-1;57821:10:0;57852:7;57857:2;57852;:7;:::i;:::-;57851:14;;57863:2;57851:14;:::i;:::-;57846:19;;:2;:19;:::i;:::-;57835:31;;:2;:31;:::i;:::-;57821:46;;57873:9;57892:4;57885:12;;57873:24;;57913:2;57903:4;57908:1;57903:7;;;;;;;;:::i;:::-;;;;:12;;;;;;;;;;-1:-1:-1;57921:8:0;57927:2;57921:8;;:::i;:::-;;;57800:135;;57784:151;;;-1:-1:-1;57953:4:0;57533:430;-1:-1:-1;;;;57533:430:0:o;28842:1074::-;29069:7;:14;29055:3;:10;:28;29047:81;;;;-1:-1:-1;;;29047:81:0;;21109:2:1;29047:81:0;;;21091:21:1;21148:2;21128:18;;;21121:30;21187:34;21167:18;;;21160:62;21258:10;21238:18;;;21231:38;21286:19;;29047:81:0;20907:404:1;29047:81:0;29147:16;;;29139:66;;;;-1:-1:-1;;;29139:66:0;;21518:2:1;29139:66:0;;;21500:21:1;21557:2;21537:18;;;21530:30;21596:34;21576:18;;;21569:62;21667:7;21647:18;;;21640:35;21692:19;;29139:66:0;21316:401:1;29139:66:0;2788:10;29218:16;29335:421;29359:3;:10;29355:1;:14;29335:421;;;29391:10;29404:3;29408:1;29404:6;;;;;;;;:::i;:::-;;;;;;;29391:19;;29425:14;29442:7;29450:1;29442:10;;;;;;;;:::i;:::-;;;;;;;;;;;;29469:19;29491:13;;;;;;;;;;:19;;;;;;;;;;;;;29442:10;;-1:-1:-1;29533:21:0;;;;29525:76;;;;-1:-1:-1;;;29525:76:0;;21924:2:1;29525:76:0;;;21906:21:1;21963:2;21943:18;;;21936:30;22002:34;21982:18;;;21975:62;22073:12;22053:18;;;22046:40;22103:19;;29525:76:0;21722:406:1;29525:76:0;29645:9;:13;;;;;;;;;;;:19;;;;;;;;;;;29667:20;;;29645:42;;29717:17;;;;;;;:27;;29667:20;;29645:9;29717:27;;29667:20;;29717:27;:::i;:::-;;;;;;;;29376:380;;;29371:3;;;;:::i;:::-;;;29335:421;;;;29803:2;29773:47;;29797:4;29773:47;;29787:8;29773:47;;;29807:3;29812:7;29773:47;;;;;;;:::i;:::-;;;;;;;;29833:75;29869:8;29879:4;29885:2;29889:3;29894:7;29903:4;29833:35;:75::i;:::-;29036:880;28842:1074;;;;;:::o;31249:599::-;31407:21;;;31399:67;;;;-1:-1:-1;;;31399:67:0;;22805:2:1;31399:67:0;;;22787:21:1;22844:2;22824:18;;;22817:30;22883:34;22863:18;;;22856:62;22954:3;22934:18;;;22927:31;22975:19;;31399:67:0;22603:397:1;31399:67:0;2788:10;31523:107;2788:10;31479:16;31566:7;31575:21;31593:2;31575:17;:21::i;:::-;31598:25;31616:6;31598:17;:25::i;31523:107::-;31643:9;:13;;;;;;;;;;;:22;;;;;;;;;;:32;;31669:6;;31643:9;:32;;31669:6;;31643:32;:::i;:::-;;;;-1:-1:-1;;31691:57:0;;;23179:25:1;;;23235:2;23220:18;;23213:34;;;31691:57:0;;;;;31724:1;;31691:57;;;;;;23152:18:1;31691:57:0;;;;;;;31761:79;31792:8;31810:1;31814:7;31823:2;31827:6;31835:4;31761:30;:79::i;4987:173::-;5062:6;;;;5079:17;;;;;;;;;;;5112:40;;5062:6;;;5079:17;5062:6;;5112:40;;5043:16;;5112:40;5032:128;4987:173;:::o;27664:820::-;27852:16;;;27844:66;;;;-1:-1:-1;;;27844:66:0;;21518:2:1;27844:66:0;;;21500:21:1;21557:2;21537:18;;;21530:30;21596:34;21576:18;;;21569:62;21667:7;21647:18;;;21640:35;21692:19;;27844:66:0;21316:401:1;27844:66:0;2788:10;27967:96;2788:10;27998:4;28004:2;28008:21;28026:2;28008:17;:21::i;27967:96::-;28076:19;28098:13;;;;;;;;;;;:19;;;;;;;;;;;28136:21;;;;28128:76;;;;-1:-1:-1;;;28128:76:0;;21924:2:1;28128:76:0;;;21906:21:1;21963:2;21943:18;;;21936:30;22002:34;21982:18;;;21975:62;22073:12;22053:18;;;22046:40;22103:19;;28128:76:0;21722:406:1;28128:76:0;28240:9;:13;;;;;;;;;;;:19;;;;;;;;;;;28262:20;;;28240:42;;28304:17;;;;;;;:27;;28262:20;;28240:9;28304:27;;28262:20;;28304:27;:::i;:::-;;;;-1:-1:-1;;28349:46:0;;;23179:25:1;;;23235:2;23220:18;;23213:34;;;28349:46:0;;;;;;;;;;;;;;;23152:18:1;28349:46:0;;;;;;;28408:68;28439:8;28449:4;28455:2;28459;28463:6;28471:4;28408:30;:68::i;:::-;27833:651;;27664:820;;;;;:::o;36935:817::-;37175:13;;;6224:20;6272:8;37171:574;;37211:79;;;;;:43;;;;;;:79;;37255:8;;37265:4;;37271:3;;37276:7;;37285:4;;37211:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;37211:79:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;37207:527;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;37607:6;37600:14;;-1:-1:-1;;;37600:14:0;;;;;;;;:::i;37207:527::-;;;37656:62;;-1:-1:-1;;;37656:62:0;;25500:2:1;37656:62:0;;;25482:21:1;25539:2;25519:18;;;25512:30;25578:34;25558:18;;;25551:62;25649:22;25629:18;;;25622:50;25689:19;;37656:62:0;25298:416:1;37207:527:0;37372:64;;;37384:52;37372:64;37368:163;;37461:50;;-1:-1:-1;;;37461:50:0;;25921:2:1;37461:50:0;;;25903:21:1;25960:2;25940:18;;;25933:30;25999:34;25979:18;;;25972:62;26070:10;26050:18;;;26043:38;26098:19;;37461:50:0;25719:404:1;37760:198:0;37880:16;;;37894:1;37880:16;;;;;;;;;37826;;37855:22;;37880:16;;;;;;;;;;;;-1:-1:-1;37880:16:0;37855:41;;37918:7;37907:5;37913:1;37907:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;37945:5;37760:198;-1:-1:-1;;37760:198:0:o;36179:748::-;36394:13;;;6224:20;6272:8;36390:530;;36430:72;;;;;:38;;;;;;:72;;36469:8;;36479:4;;36485:2;;36489:6;;36497:4;;36430:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36430:72:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;36426:483;;;;:::i;:::-;36552:59;;;36564:47;36552:59;36548:158;;36636:50;;-1:-1:-1;;;36636:50:0;;25921:2:1;36636:50:0;;;25903:21:1;25960:2;25940:18;;;25933:30;25999:34;25979:18;;;25972:62;26070:10;26050:18;;;26043:38;26098:19;;36636:50:0;25719:404:1;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:154:1;100:42;93:5;89:54;82:5;79:65;69:93;;158:1;155;148:12;173:315;241:6;249;302:2;290:9;281:7;277:23;273:32;270:52;;;318:1;315;308:12;270:52;357:9;344:23;376:31;401:5;376:31;:::i;:::-;426:5;478:2;463:18;;;;450:32;;-1:-1:-1;;;173:315:1:o;675:177::-;760:66;753:5;749:78;742:5;739:89;729:117;;842:1;839;832:12;857:245;915:6;968:2;956:9;947:7;943:23;939:32;936:52;;;984:1;981;974:12;936:52;1023:9;1010:23;1042:30;1066:5;1042:30;:::i;:::-;1091:5;857:245;-1:-1:-1;;;857:245:1:o;1299:258::-;1371:1;1381:113;1395:6;1392:1;1389:13;1381:113;;;1471:11;;;1465:18;1452:11;;;1445:39;1417:2;1410:10;1381:113;;;1512:6;1509:1;1506:13;1503:48;;;1547:1;1538:6;1533:3;1529:16;1522:27;1503:48;;1299:258;;;:::o;1562:328::-;1615:3;1653:5;1647:12;1680:6;1675:3;1668:19;1696:63;1752:6;1745:4;1740:3;1736:14;1729:4;1722:5;1718:16;1696:63;:::i;:::-;1804:2;1792:15;1809:66;1788:88;1779:98;;;;1879:4;1775:109;;1562:328;-1:-1:-1;;1562:328:1:o;1895:231::-;2044:2;2033:9;2026:21;2007:4;2064:56;2116:2;2105:9;2101:18;2093:6;2064:56;:::i;2131:180::-;2190:6;2243:2;2231:9;2222:7;2218:23;2214:32;2211:52;;;2259:1;2256;2249:12;2211:52;-1:-1:-1;2282:23:1;;2131:180;-1:-1:-1;2131:180:1:o;2316:184::-;2368:77;2365:1;2358:88;2465:4;2462:1;2455:15;2489:4;2486:1;2479:15;2505:308;2611:66;2606:2;2600:4;2596:13;2592:86;2584:6;2580:99;2745:6;2733:10;2730:22;2709:18;2697:10;2694:34;2691:62;2688:88;;;2756:18;;:::i;:::-;2792:2;2785:22;-1:-1:-1;;2505:308:1:o;2818:183::-;2878:4;2911:18;2903:6;2900:30;2897:56;;;2933:18;;:::i;:::-;-1:-1:-1;2978:1:1;2974:14;2990:4;2970:25;;2818:183::o;3006:724::-;3060:5;3113:3;3106:4;3098:6;3094:17;3090:27;3080:55;;3131:1;3128;3121:12;3080:55;3167:6;3154:20;3193:4;3216:43;3256:2;3216:43;:::i;:::-;3288:2;3282:9;3300:31;3328:2;3320:6;3300:31;:::i;:::-;3366:18;;;3458:1;3454:10;;;;3442:23;;3438:32;;;3400:15;;;;-1:-1:-1;3482:15:1;;;3479:35;;;3510:1;3507;3500:12;3479:35;3546:2;3538:6;3534:15;3558:142;3574:6;3569:3;3566:15;3558:142;;;3640:17;;3628:30;;3678:12;;;;3591;;3558:142;;;-1:-1:-1;3718:6:1;3006:724;-1:-1:-1;;;;;;3006:724:1:o;3735:527::-;3799:5;3833:18;3825:6;3822:30;3819:56;;;3855:18;;:::i;:::-;3904:2;3898:9;3916:128;4038:4;3969:66;3964:2;3956:6;3952:15;3948:88;3944:99;3936:6;3916:128;:::i;:::-;4062:6;4053:15;;4092:6;4084;4077:22;4132:3;4123:6;4118:3;4114:16;4111:25;4108:45;;;4149:1;4146;4139:12;4108:45;4199:6;4194:3;4187:4;4179:6;4175:17;4162:44;4254:1;4247:4;4238:6;4230;4226:19;4222:30;4215:41;;3735:527;;;;;:::o;4267:220::-;4309:5;4362:3;4355:4;4347:6;4343:17;4339:27;4329:55;;4380:1;4377;4370:12;4329:55;4402:79;4477:3;4468:6;4455:20;4448:4;4440:6;4436:17;4402:79;:::i;4492:1071::-;4646:6;4654;4662;4670;4678;4731:3;4719:9;4710:7;4706:23;4702:33;4699:53;;;4748:1;4745;4738:12;4699:53;4787:9;4774:23;4806:31;4831:5;4806:31;:::i;:::-;4856:5;-1:-1:-1;4913:2:1;4898:18;;4885:32;4926:33;4885:32;4926:33;:::i;:::-;4978:7;-1:-1:-1;5036:2:1;5021:18;;5008:32;5059:18;5089:14;;;5086:34;;;5116:1;5113;5106:12;5086:34;5139:61;5192:7;5183:6;5172:9;5168:22;5139:61;:::i;:::-;5129:71;;5253:2;5242:9;5238:18;5225:32;5209:48;;5282:2;5272:8;5269:16;5266:36;;;5298:1;5295;5288:12;5266:36;5321:63;5376:7;5365:8;5354:9;5350:24;5321:63;:::i;:::-;5311:73;;5437:3;5426:9;5422:19;5409:33;5393:49;;5467:2;5457:8;5454:16;5451:36;;;5483:1;5480;5473:12;5451:36;;5506:51;5549:7;5538:8;5527:9;5523:24;5506:51;:::i;:::-;5496:61;;;4492:1071;;;;;;;;:::o;5568:367::-;5631:8;5641:6;5695:3;5688:4;5680:6;5676:17;5672:27;5662:55;;5713:1;5710;5703:12;5662:55;-1:-1:-1;5736:20:1;;5779:18;5768:30;;5765:50;;;5811:1;5808;5801:12;5765:50;5848:4;5840:6;5836:17;5824:29;;5908:3;5901:4;5891:6;5888:1;5884:14;5876:6;5872:27;5868:38;5865:47;5862:67;;;5925:1;5922;5915:12;5862:67;5568:367;;;;;:::o;5940:773::-;6062:6;6070;6078;6086;6139:2;6127:9;6118:7;6114:23;6110:32;6107:52;;;6155:1;6152;6145:12;6107:52;6195:9;6182:23;6224:18;6265:2;6257:6;6254:14;6251:34;;;6281:1;6278;6271:12;6251:34;6320:70;6382:7;6373:6;6362:9;6358:22;6320:70;:::i;:::-;6409:8;;-1:-1:-1;6294:96:1;-1:-1:-1;6497:2:1;6482:18;;6469:32;;-1:-1:-1;6513:16:1;;;6510:36;;;6542:1;6539;6532:12;6510:36;;6581:72;6645:7;6634:8;6623:9;6619:24;6581:72;:::i;:::-;5940:773;;;;-1:-1:-1;6672:8:1;-1:-1:-1;;;;5940:773:1:o;6718:1277::-;6836:6;6844;6897:2;6885:9;6876:7;6872:23;6868:32;6865:52;;;6913:1;6910;6903:12;6865:52;6953:9;6940:23;6982:18;7023:2;7015:6;7012:14;7009:34;;;7039:1;7036;7029:12;7009:34;7077:6;7066:9;7062:22;7052:32;;7122:7;7115:4;7111:2;7107:13;7103:27;7093:55;;7144:1;7141;7134:12;7093:55;7180:2;7167:16;7202:4;7225:43;7265:2;7225:43;:::i;:::-;7297:2;7291:9;7309:31;7337:2;7329:6;7309:31;:::i;:::-;7375:18;;;7463:1;7459:10;;;;7451:19;;7447:28;;;7409:15;;;;-1:-1:-1;7487:19:1;;;7484:39;;;7519:1;7516;7509:12;7484:39;7543:11;;;;7563:217;7579:6;7574:3;7571:15;7563:217;;;7659:3;7646:17;7676:31;7701:5;7676:31;:::i;:::-;7720:18;;7596:12;;;;7758;;;;7563:217;;;7799:6;-1:-1:-1;;7843:18:1;;7830:32;;-1:-1:-1;;7874:16:1;;;7871:36;;;7903:1;7900;7893:12;7871:36;;7926:63;7981:7;7970:8;7959:9;7955:24;7926:63;:::i;:::-;7916:73;;;6718:1277;;;;;:::o;8000:435::-;8053:3;8091:5;8085:12;8118:6;8113:3;8106:19;8144:4;8173:2;8168:3;8164:12;8157:19;;8210:2;8203:5;8199:14;8231:1;8241:169;8255:6;8252:1;8249:13;8241:169;;;8316:13;;8304:26;;8350:12;;;;8385:15;;;;8277:1;8270:9;8241:169;;;-1:-1:-1;8426:3:1;;8000:435;-1:-1:-1;;;;;8000:435:1:o;8440:261::-;8619:2;8608:9;8601:21;8582:4;8639:56;8691:2;8680:9;8676:18;8668:6;8639:56;:::i;8706:450::-;8775:6;8828:2;8816:9;8807:7;8803:23;8799:32;8796:52;;;8844:1;8841;8834:12;8796:52;8884:9;8871:23;8917:18;8909:6;8906:30;8903:50;;;8949:1;8946;8939:12;8903:50;8972:22;;9025:4;9017:13;;9013:27;-1:-1:-1;9003:55:1;;9054:1;9051;9044:12;9003:55;9077:73;9142:7;9137:2;9124:16;9119:2;9115;9111:11;9077:73;:::i;:::-;9067:83;8706:450;-1:-1:-1;;;;8706:450:1:o;9161:437::-;9247:6;9255;9308:2;9296:9;9287:7;9283:23;9279:32;9276:52;;;9324:1;9321;9314:12;9276:52;9364:9;9351:23;9397:18;9389:6;9386:30;9383:50;;;9429:1;9426;9419:12;9383:50;9468:70;9530:7;9521:6;9510:9;9506:22;9468:70;:::i;:::-;9557:8;;9442:96;;-1:-1:-1;9161:437:1;-1:-1:-1;;;;9161:437:1:o;9603:247::-;9662:6;9715:2;9703:9;9694:7;9690:23;9686:32;9683:52;;;9731:1;9728;9721:12;9683:52;9770:9;9757:23;9789:31;9814:5;9789:31;:::i;9855:160::-;9920:20;;9976:13;;9969:21;9959:32;;9949:60;;10005:1;10002;9995:12;9949:60;9855:160;;;:::o;10020:180::-;10076:6;10129:2;10117:9;10108:7;10104:23;10100:32;10097:52;;;10145:1;10142;10135:12;10097:52;10168:26;10184:9;10168:26;:::i;10436:315::-;10501:6;10509;10562:2;10550:9;10541:7;10537:23;10533:32;10530:52;;;10578:1;10575;10568:12;10530:52;10617:9;10604:23;10636:31;10661:5;10636:31;:::i;:::-;10686:5;-1:-1:-1;10710:35:1;10741:2;10726:18;;10710:35;:::i;:::-;10700:45;;10436:315;;;;;:::o;10756:388::-;10824:6;10832;10885:2;10873:9;10864:7;10860:23;10856:32;10853:52;;;10901:1;10898;10891:12;10853:52;10940:9;10927:23;10959:31;10984:5;10959:31;:::i;:::-;11009:5;-1:-1:-1;11066:2:1;11051:18;;11038:32;11079:33;11038:32;11079:33;:::i;:::-;11131:7;11121:17;;;10756:388;;;;;:::o;11149:734::-;11253:6;11261;11269;11277;11285;11338:3;11326:9;11317:7;11313:23;11309:33;11306:53;;;11355:1;11352;11345:12;11306:53;11394:9;11381:23;11413:31;11438:5;11413:31;:::i;:::-;11463:5;-1:-1:-1;11520:2:1;11505:18;;11492:32;11533:33;11492:32;11533:33;:::i;:::-;11585:7;-1:-1:-1;11639:2:1;11624:18;;11611:32;;-1:-1:-1;11690:2:1;11675:18;;11662:32;;-1:-1:-1;11745:3:1;11730:19;;11717:33;11773:18;11762:30;;11759:50;;;11805:1;11802;11795:12;11759:50;11828:49;11869:7;11860:6;11849:9;11845:22;11828:49;:::i;12300:437::-;12379:1;12375:12;;;;12422;;;12443:61;;12497:4;12489:6;12485:17;12475:27;;12443:61;12550:2;12542:6;12539:14;12519:18;12516:38;12513:218;;12587:77;12584:1;12577:88;12688:4;12685:1;12678:15;12716:4;12713:1;12706:15;12513:218;;12300:437;;;:::o;12868:185::-;12910:3;12948:5;12942:12;12963:52;13008:6;13003:3;12996:4;12989:5;12985:16;12963:52;:::i;:::-;13031:16;;;;;12868:185;-1:-1:-1;;12868:185:1:o;13058:1289::-;13234:3;13263:1;13296:6;13290:13;13326:3;13348:1;13376:9;13372:2;13368:18;13358:28;;13436:2;13425:9;13421:18;13458;13448:61;;13502:4;13494:6;13490:17;13480:27;;13448:61;13528:2;13576;13568:6;13565:14;13545:18;13542:38;13539:222;;13615:77;13610:3;13603:90;13716:4;13713:1;13706:15;13746:4;13741:3;13734:17;13539:222;13777:18;13804:162;;;;13980:1;13975:320;;;;13770:525;;13804:162;13852:66;13841:9;13837:82;13832:3;13825:95;13949:6;13944:3;13940:16;13933:23;;13804:162;;13975:320;12815:1;12808:14;;;12852:4;12839:18;;14070:1;14084:165;14098:6;14095:1;14092:13;14084:165;;;14176:14;;14163:11;;;14156:35;14219:16;;;;14113:10;;14084:165;;;14088:3;;14278:6;14273:3;14269:16;14262:23;;13770:525;;;;;;;14311:30;14337:3;14329:6;14311:30;:::i;:::-;14304:37;13058:1289;-1:-1:-1;;;;;13058:1289:1:o;15132:184::-;15184:77;15181:1;15174:88;15281:4;15278:1;15271:15;15305:4;15302:1;15295:15;15321:184;15373:77;15370:1;15363:88;15470:4;15467:1;15460:15;15494:4;15491:1;15484:15;15510:195;15549:3;15580:66;15573:5;15570:77;15567:103;;15650:18;;:::i;:::-;-1:-1:-1;15697:1:1;15686:13;;15510:195::o;16833:251::-;16903:6;16956:2;16944:9;16935:7;16931:23;16927:32;16924:52;;;16972:1;16969;16962:12;16924:52;17004:9;16998:16;17023:31;17048:5;17023:31;:::i;17855:128::-;17895:3;17926:1;17922:6;17919:1;17916:13;17913:39;;;17932:18;;:::i;:::-;-1:-1:-1;17968:9:1;;17855:128::o;17988:184::-;18058:6;18111:2;18099:9;18090:7;18086:23;18082:32;18079:52;;;18127:1;18124;18117:12;18079:52;-1:-1:-1;18150:16:1;;17988:184;-1:-1:-1;17988:184:1:o;20056:274::-;20096:1;20122;20112:189;;20157:77;20154:1;20147:88;20258:4;20255:1;20248:15;20286:4;20283:1;20276:15;20112:189;-1:-1:-1;20315:9:1;;20056:274::o;20335:125::-;20375:4;20403:1;20400;20397:8;20394:34;;;20408:18;;:::i;:::-;-1:-1:-1;20445:9:1;;20335:125::o;20465:228::-;20505:7;20631:1;20563:66;20559:74;20556:1;20553:81;20548:1;20541:9;20534:17;20530:105;20527:131;;;20638:18;;:::i;:::-;-1:-1:-1;20678:9:1;;20465:228::o;20698:204::-;20736:3;20772:4;20769:1;20765:12;20804:4;20801:1;20797:12;20839:3;20833:4;20829:14;20824:3;20821:23;20818:49;;;20847:18;;:::i;:::-;20883:13;;20698:204;-1:-1:-1;;;20698:204:1:o;22133:465::-;22390:2;22379:9;22372:21;22353:4;22416:56;22468:2;22457:9;22453:18;22445:6;22416:56;:::i;:::-;22520:9;22512:6;22508:22;22503:2;22492:9;22488:18;22481:50;22548:44;22585:6;22577;22548:44;:::i;23258:861::-;23580:4;23609:42;23690:2;23682:6;23678:15;23667:9;23660:34;23742:2;23734:6;23730:15;23725:2;23714:9;23710:18;23703:43;;23782:3;23777:2;23766:9;23762:18;23755:31;23809:57;23861:3;23850:9;23846:19;23838:6;23809:57;:::i;:::-;23914:9;23906:6;23902:22;23897:2;23886:9;23882:18;23875:50;23948:44;23985:6;23977;23948:44;:::i;:::-;23934:58;;24041:9;24033:6;24029:22;24023:3;24012:9;24008:19;24001:51;24069:44;24106:6;24098;24069:44;:::i;:::-;24061:52;23258:861;-1:-1:-1;;;;;;;;23258:861:1:o;24124:249::-;24193:6;24246:2;24234:9;24225:7;24221:23;24217:32;24214:52;;;24262:1;24259;24252:12;24214:52;24294:9;24288:16;24313:30;24337:5;24313:30;:::i;24378:179::-;24413:3;24455:1;24437:16;24434:23;24431:120;;;24501:1;24498;24495;24480:23;-1:-1:-1;24538:1:1;24532:8;24527:3;24523:18;24431:120;24378:179;:::o;24562:731::-;24601:3;24643:4;24625:16;24622:26;24619:39;;;24562:731;:::o;24619:39::-;24685:2;24679:9;24707:66;24828:2;24810:16;24806:25;24803:1;24797:4;24782:50;24861:4;24855:11;24885:16;24920:18;24991:2;24984:4;24976:6;24972:17;24969:25;24964:2;24956:6;24953:14;24950:45;24947:58;;;24998:5;;;;;24562:731;:::o;24947:58::-;25035:6;25029:4;25025:17;25014:28;;25071:3;25065:10;25098:2;25090:6;25087:14;25084:27;;;25104:5;;;;;;24562:731;:::o;25084:27::-;25188:2;25169:16;25163:4;25159:27;25155:36;25148:4;25139:6;25134:3;25130:16;25126:27;25123:69;25120:82;;;25195:5;;;;;;24562:731;:::o;25120:82::-;25211:57;25262:4;25253:6;25245;25241:19;25237:30;25231:4;25211:57;:::i;:::-;-1:-1:-1;25284:3:1;;24562:731;-1:-1:-1;;;;;24562:731:1:o;26128:595::-;26350:4;26379:42;26460:2;26452:6;26448:15;26437:9;26430:34;26512:2;26504:6;26500:15;26495:2;26484:9;26480:18;26473:43;;26552:6;26547:2;26536:9;26532:18;26525:34;26595:6;26590:2;26579:9;26575:18;26568:34;26639:3;26633;26622:9;26618:19;26611:32;26660:57;26712:3;26701:9;26697:19;26689:6;26660:57;:::i;:::-;26652:65;26128:595;-1:-1:-1;;;;;;;26128:595:1:o

Swarm Source

ipfs://f50d19950ab702cecc05ce20783d672e78a4b472d913b3abf24d1a85eb29d2f3

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