Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "./ERC721Enumerable.sol";
import "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";

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 IlluminatiDAO is ERC1155, Ownable {
	using Strings for string;

	mapping(uint256 => bool) public claimTracker;

	ILLUMINATI private illuminati;

	uint256 constant nft1 = 1;
	uint constant maxSupply = 8128;

	string public _baseURI;
	string public _contractURI;

	bool public claimLive = false;

	constructor(address illuminatiContractAddress) 
		ERC1155(_baseURI) {
		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
	
		//owner 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
		}
		//mint + store claim
        for(uint256 i = 0; i < illuminatiIDs.length; i++) {
            _mint(msg.sender, nft1, 1, ""); //mint 1 per
			claimTracker[illuminatiIDs[i]] = true; //track claims
        }
    }

	// admin claim (token 0)
    function claim(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
    }

	//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];
	}

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

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

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC1155.sol";
import "./IERC1155Receiver.sol";
import "./IERC1155MetadataURI.sol";
import "./Address.sol";
import "./Context.sol";
import "./ERC165.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./IERC721Metadata.sol";
import "./Address.sol";
import "./Context.sol";
import "./ERC165.sol";

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 {}
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import "./ERC721.sol";
import "./IERC721Enumerable.sol";
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;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC1155.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC721.sol";

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

// SPDX-License-Identifier: MIT

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"illuminatiContractAddress","type":"address"}],"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":"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":"illuminatiID","type":"uint256"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","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":"","type":"uint256"}],"name":"claimTracker","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"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":[{"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"}]

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

00000000000000000000000026badf693f2b103b021c670c852262b379bbbe8a

-----Decoded View---------------
Arg [0] : illuminatiContractAddress (address): 0x26BAdF693F2b103B021c670c852262b379bBBE8A

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000026badf693f2b103b021c670c852262b379bbbe8a

586:3175:14:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2122:231:2;;;;;;:::i;:::-;;:::i;:::-;;;639:25:17;;;627:2;612:18;2122:231:2;;;;;;;;1145:310;;;;;;:::i;:::-;;:::i;:::-;;;1272:14:17;;1265:22;1247:41;;1235:2;1220:18;1145:310:2;1107:187:17;2327:145:14;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;4217:442:2:-;;;;;;:::i;:::-;;:::i;:::-;;871:29:14;;;;;;;;;3134:104;;;;;;:::i;:::-;3194:4;3212:21;;;:12;:21;;;;;;;;;3134:104;1872:247;;;;;;:::i;:::-;;:::i;3651:107::-;;;:::i;663:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;2519:524:2;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2137:86:14:-;;;;;;:::i;:::-;;:::i;1063:774::-;;;;;;:::i;:::-;;:::i;1650:94:15:-;;;:::i;3271:352:14:-;;;;;;:::i;:::-;;:::i;813:22::-;;;:::i;3024:80::-;;;;;;:::i;:::-;;:::i;999:87:15:-;1072:6;;999:87;;1072:6;;;;9379:74:17;;9367:2;9352:18;999:87:15;9233:226:17;2228:94:14;;;;;;:::i;:::-;;:::i;3116:311:2:-;;;;;;:::i;:::-;;:::i;839:26:14:-;;;:::i;2477:88::-;;;:::i;3499:168:2:-;;;;;;:::i;:::-;3622:27;;;;3598:4;3622:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;3499:168;3739:401;;;;;;:::i;:::-;;:::i;1899:192:15:-;;;;;;:::i;:::-;;:::i;2122:231:2:-;2208:7;2236:21;;;2228:77;;;;-1:-1:-1;;;2228:77:2;;11118:2:17;2228:77:2;;;11100:21:17;11157:2;11137:18;;;11130:30;11196:34;11176:18;;;11169:62;11267:13;11247:18;;;11240:41;11298:19;;2228:77:2;;;;;;;;;-1:-1:-1;2323:9:2;:13;;;;;;;;;;;:22;;;;;;;;;;;;;2122:231::o;1145:310::-;1247:4;1284:41;;;1299:26;1284:41;;:110;;-1:-1:-1;1342:52:2;;;1357:37;1342:52;1284:110;:163;;;-1:-1:-1;911:25:3;896:40;;;;1411:36:2;1264:183;1145:310;-1:-1:-1;;1145:310:2:o;2327:145:14:-;2387:13;2438:8;2448:17;2457:7;2448:8;:17::i;:::-;2421:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2407:60;;2327:145;;;:::o;4217:442:2:-;4450:20;;;681:10:1;4450:20:2;;:60;;-1:-1:-1;4474:36:2;4491:4;681:10:1;3499:168:2;:::i;4474:36::-;4428:160;;;;-1:-1:-1;;;4428:160:2;;13582:2:17;4428:160:2;;;13564:21:17;13621:2;13601:18;;;13594:30;13660:34;13640:18;;;13633:62;13731:20;13711:18;;;13704:48;13769:19;;4428:160:2;13380:414:17;4428:160:2;4599:52;4622:4;4628:2;4632:3;4637:7;4646:4;4599:22;:52::i;:::-;4217:442;;;;;:::o;1872:247:14:-;1072:6:15;;1219:23;1072:6;681:10:1;1219:23:15;1211:68;;;;-1:-1:-1;;;1211:68:15;;14001:2:17;1211:68:15;;;13983:21:17;;;14020:18;;;14013:30;14079:34;14059:18;;;14052:62;14131:18;;1211:68:15;13799:356:17;1211:68:15;1943:17:14;;1935:50:::1;;;::::0;-1:-1:-1;;;1935:50:14;;14362:2:17;1935:50:14::1;::::0;::::1;14344:21:17::0;14401:2;14381:18;;;14374:30;14440:23;14420:18;;;14413:51;14481:18;;1935:50:14::1;14160:345:17::0;1935:50:14::1;2015:30;2021:10;772:1;2039::::0;2015:30:::1;;;;;;;;;;;::::0;:5:::1;:30::i;:::-;2063:26;::::0;;;:12:::1;:26;::::0;;;;:33;;;::::1;2092:4;2063:33;::::0;;1872:247::o;3651:107::-;1072:6:15;;1219:23;1072:6;681:10:1;1219:23:15;1211:68;;;;-1:-1:-1;;;1211:68:15;;14001:2:17;1211:68:15;;;13983:21:17;;;14020:18;;;14013:30;14079:34;14059:18;;;14052:62;14131:18;;1211:68:15;13799:356:17;1211:68:15;3702:51:14::1;::::0;3710:10:::1;::::0;3731:21:::1;3702:51:::0;::::1;;;::::0;::::1;::::0;;;3731:21;3710:10;3702:51;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;3651:107::o:0;2519:524:2:-;2675:16;2736:3;:10;2717:8;:15;:29;2709:83;;;;-1:-1:-1;;;2709:83:2;;14712:2:17;2709:83:2;;;14694:21:17;14751:2;14731:18;;;14724:30;14790:34;14770:18;;;14763:62;14861:11;14841:18;;;14834:39;14890:19;;2709:83:2;14510:405:17;2709:83:2;2805:30;2852:8;:15;2838:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2838:30:2;;2805:63;;2886:9;2881:122;2905:8;:15;2901:1;:19;2881:122;;;2961:30;2971:8;2980:1;2971:11;;;;;;;;:::i;:::-;;;;;;;2984:3;2988:1;2984:6;;;;;;;;:::i;:::-;;;;;;;2961:9;:30::i;:::-;2942:13;2956:1;2942:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;2922:3;;;:::i;:::-;;;2881:122;;;-1:-1:-1;3022:13:2;2519:524;-1:-1:-1;;;2519:524:2:o;2137:86:14:-;1072:6:15;;1219:23;1072:6;681:10:1;1219:23:15;1211:68;;;;-1:-1:-1;;;1211:68:15;;14001:2:17;1211:68:15;;;13983:21:17;;;14020:18;;;14013:30;14079:34;14059:18;;;14052:62;14131:18;;1211:68:15;13799:356:17;1211:68:15;2201:17:14;;::::1;::::0;:8:::1;::::0;:17:::1;::::0;::::1;::::0;::::1;:::i;:::-;;2137:86:::0;:::o;1063:774::-;1158:9;;;;1150:45;;;;-1:-1:-1;;;1150:45:14;;15700:2:17;1150:45:14;;;15682:21:17;15739:2;15719:18;;;15712:30;15778:26;15758:18;;;15751:54;15822:18;;1150:45:14;15498:348:17;1150:45:14;1208:24;1200:67;;;;-1:-1:-1;;;1200:67:14;;16053:2:17;1200:67:14;;;16035:21:17;16092:2;16072:18;;;16065:30;16131:33;16111:18;;;16104:61;16182:18;;1200:67:14;15851:355:17;1200:67:14;1315:9;1311:307;1330:24;;;1311:307;;;1374:10;;1414;;1374:50;:10;:18;1393:13;;1407:1;1393:16;;;;;;;:::i;:::-;;;;;;;1374:36;;;;;;;;;;;;;639:25:17;;627:2;612:18;;493:177;1374:36:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:50;;;1366:93;;;;-1:-1:-1;;;1366:93:14;;16669:2:17;1366:93:14;;;16651:21:17;16708:2;16688:18;;;16681:30;16747:33;16727:18;;;16720:61;16798:18;;1366:93:14;16467:355:17;1366:93:14;1497:12;:30;1510:13;;1524:1;1510:16;;;;;;;:::i;:::-;;;;;;;;;;1497:30;;-1:-1:-1;1497:30:14;;;;;;;;-1:-1:-1;1497:30:14;;;;:39;1489:88;;;;-1:-1:-1;;;1489:88:14;;17029:2:17;1489:88:14;;;17011:21:17;17068:2;17048:18;;;17041:30;17107:34;17087:18;;;17080:62;17178:7;17158:18;;;17151:35;17203:19;;1489:88:14;16827:401:17;1489:88:14;1356:3;;;;:::i;:::-;;;;1311:307;;;;1656:9;1652:178;1671:24;;;1652:178;;;1717:30;1723:10;772:1;1741;1717:30;;;;;;;;;;;;:5;:30::i;:::-;1799:4;1766:12;:30;1779:13;;1793:1;1779:16;;;;;;;:::i;:::-;;;;;;;1766:30;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;1697:3;;;;;:::i;:::-;;;;1652:178;;;;1063:774;;:::o;1650:94:15:-;1072:6;;1219:23;1072:6;681:10:1;1219:23:15;1211:68;;;;-1:-1:-1;;;1211:68:15;;14001:2:17;1211:68:15;;;13983:21:17;;;14020:18;;;14013:30;14079:34;14059:18;;;14052:62;14131:18;;1211:68:15;13799:356:17;1211:68:15;1715:21:::1;1733:1;1715:9;:21::i;:::-;1650:94::o:0;3271:352:14:-;3381:10;;:27;;;;;:10;9397:55:17;;;3381:27:14;;;9379:74:17;3338:16:14;;3360:18;;3381:10;;;:20;;9352:18:17;;3381:27:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3360:48;;3413:25;3455:10;3441:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3441:25:14;;3413:53;;3482:9;3477:122;3501:10;3497:1;:14;3477:122;;;3547:10;;:40;;;;;:10;17614:55:17;;;3547:40:14;;;17596:74:17;17686:18;;;17679:34;;;3547:10:14;;;;:30;;17569:18:17;;3547:40:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3533:8;3542:1;3533:11;;;;;;;;:::i;:::-;;;;;;;;;;:54;3513:3;;;;:::i;:::-;;;;3477:122;;813:22;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3024:80::-;1072:6:15;;1219:23;1072:6;681:10:1;1219:23:15;1211:68;;;;-1:-1:-1;;;1211:68:15;;14001:2:17;1211:68:15;;;13983:21:17;;;14020:18;;;14013:30;14079:34;14059:18;;;14052:62;14131:18;;1211:68:15;13799:356:17;1211:68:15;3082:9:14::1;:17:::0;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;3024:80::o;2228:94::-;1072:6:15;;1219:23;1072:6;681:10:1;1219:23:15;1211:68;;;;-1:-1:-1;;;1211:68:15;;14001:2:17;1211:68:15;;;13983:21:17;;;14020:18;;;14013:30;14079:34;14059:18;;;14052:62;14131:18;;1211:68:15;13799:356:17;1211:68:15;2296:21:14;;::::1;::::0;:12:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;3116:311:2:-:0;3219:24;;;681:10:1;3219:24:2;3211:78;;;;-1:-1:-1;;;3211:78:2;;17926:2:17;3211:78:2;;;17908:21:17;17965:2;17945:18;;;17938:30;18004:34;17984:18;;;17977:62;18075:11;18055:18;;;18048:39;18104:19;;3211:78:2;17724:405:17;3211:78:2;681:10:1;3302:32:2;;;;:18;:32;;;;;;;;;:42;;;;;;;;;;;;:53;;;;;;;;;;;;;3371:48;;1247:41:17;;;3302:42:2;;681:10:1;3371:48:2;;1220:18:17;3371:48:2;;;;;;;3116:311;;:::o;839:26:14:-;;;;;;;:::i;2477:88::-;2521:13;2548:12;2541:19;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2477:88;:::o;3739:401:2:-;3947:20;;;681:10:1;3947:20:2;;:60;;-1:-1:-1;3971:36:2;3988:4;681:10:1;3499:168:2;:::i;3971:36::-;3925:151;;;;-1:-1:-1;;;3925:151:2;;18336:2:17;3925:151:2;;;18318:21:17;18375:2;18355:18;;;18348:30;18414:34;18394:18;;;18387:62;18485:11;18465:18;;;18458:39;18514:19;;3925:151:2;18134:405:17;3925:151:2;4087:45;4105:4;4111:2;4115;4119:6;4127:4;4087:17;:45::i;1899:192:15:-;1072:6;;1219:23;1072:6;681:10:1;1219:23:15;1211:68;;;;-1:-1:-1;;;1211:68:15;;14001:2:17;1211:68:15;;;13983:21:17;;;14020:18;;;14013:30;14079:34;14059:18;;;14052:62;14131:18;;1211:68:15;13799:356:17;1211:68:15;1988:22:::1;::::0;::::1;1980:73;;;::::0;-1:-1:-1;;;1980:73:15;;18746:2:17;1980:73:15::1;::::0;::::1;18728:21:17::0;18785:2;18765:18;;;18758:30;18824:34;18804:18;;;18797:62;18895:8;18875:18;;;18868:36;18921:19;;1980:73:15::1;18544:402:17::0;1980:73:15::1;2064:19;2074:8;2064:9;:19::i;2570:430:14:-:0;2623:27;2661:2;2667:1;2661:7;2657:26;;-1:-1:-1;;2671:10:14;;;;;;;;;;;;;;;;;;2570:430::o;2657:26::-;2700:2;2688:9;2724:32;2731:6;;2724:32;;2740:5;;;;:::i;:::-;;-1:-1:-1;2747:7:14;;-1:-1:-1;2752:2:14;2747:7;;:::i;:::-;;;2724:32;;;2761:17;2791:3;2781:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2781:14:14;-1:-1:-1;2761:34:14;-1:-1:-1;2813:3:14;2821:151;2828:7;;2821:151;;2847:5;2851:1;2847;:5;:::i;:::-;2843:9;-1:-1:-1;2858:10:14;2889:7;2894:2;2889;:7;:::i;:::-;2888:14;;2900:2;2888:14;:::i;:::-;2883:19;;:2;:19;:::i;:::-;2872:31;;:2;:31;:::i;:::-;2858:46;;2910:9;2929:4;2922:12;;2910:24;;2950:2;2940:4;2945:1;2940:7;;;;;;;;:::i;:::-;;;;:12;;;;;;;;;;-1:-1:-1;2958:8:14;2964:2;2958:8;;:::i;:::-;;;2837:135;;2821:151;;;-1:-1:-1;2990:4:14;2570:430;-1:-1:-1;;;;2570:430:14:o;6301:1074:2:-;6528:7;:14;6514:3;:10;:28;6506:81;;;;-1:-1:-1;;;6506:81:2;;20004:2:17;6506:81:2;;;19986:21:17;20043:2;20023:18;;;20016:30;20082:34;20062:18;;;20055:62;20153:10;20133:18;;;20126:38;20181:19;;6506:81:2;19802:404:17;6506:81:2;6606:16;;;6598:66;;;;-1:-1:-1;;;6598:66:2;;20413:2:17;6598:66:2;;;20395:21:17;20452:2;20432:18;;;20425:30;20491:34;20471:18;;;20464:62;20562:7;20542:18;;;20535:35;20587:19;;6598:66:2;20211:401:17;6598:66:2;681:10:1;6677:16:2;6794:421;6818:3;:10;6814:1;:14;6794:421;;;6850:10;6863:3;6867:1;6863:6;;;;;;;;:::i;:::-;;;;;;;6850:19;;6884:14;6901:7;6909:1;6901:10;;;;;;;;:::i;:::-;;;;;;;;;;;;6928:19;6950:13;;;;;;;;;;:19;;;;;;;;;;;;;6901:10;;-1:-1:-1;6992:21:2;;;;6984:76;;;;-1:-1:-1;;;6984:76:2;;20819:2:17;6984:76:2;;;20801:21:17;20858:2;20838:18;;;20831:30;20897:34;20877:18;;;20870:62;20968:12;20948:18;;;20941:40;20998:19;;6984:76:2;20617:406:17;6984:76:2;7104:9;:13;;;;;;;;;;;:19;;;;;;;;;;;7126:20;;;7104:42;;7176:17;;;;;;;:27;;7126:20;;7104:9;7176:27;;7126:20;;7176:27;:::i;:::-;;;;;;;;6835:380;;;6830:3;;;;:::i;:::-;;;6794:421;;;;7262:2;7232:47;;7256:4;7232:47;;7246:8;7232:47;;;7266:3;7271:7;7232:47;;;;;;;:::i;:::-;;;;;;;;7292:75;7328:8;7338:4;7344:2;7348:3;7353:7;7362:4;7292:35;:75::i;:::-;6495:880;6301:1074;;;;;:::o;8708:599::-;8866:21;;;8858:67;;;;-1:-1:-1;;;8858:67:2;;21833:2:17;8858:67:2;;;21815:21:17;21872:2;21852:18;;;21845:30;21911:34;21891:18;;;21884:62;21982:3;21962:18;;;21955:31;22003:19;;8858:67:2;21631:397:17;8858:67:2;681:10:1;8982:107:2;681:10:1;8938:16:2;9025:7;9034:21;9052:2;9034:17;:21::i;:::-;9057:25;9075:6;9057:17;:25::i;8982:107::-;9102:9;:13;;;;;;;;;;;:22;;;;;;;;;;:32;;9128:6;;9102:9;:32;;9128:6;;9102:32;:::i;:::-;;;;-1:-1:-1;;9150:57:2;;;22207:25:17;;;22263:2;22248:18;;22241:34;;;9150:57:2;;;;;9183:1;;9150:57;;;;;;22180:18:17;9150:57:2;;;;;;;9220:79;9251:8;9269:1;9273:7;9282:2;9286:6;9294:4;9220:30;:79::i;2099:173:15:-;2174:6;;;;2191:17;;;;;;;;;;;2224:40;;2174:6;;;2191:17;2174:6;;2224:40;;2155:16;;2224:40;2144:128;2099:173;:::o;5123:820:2:-;5311:16;;;5303:66;;;;-1:-1:-1;;;5303:66:2;;20413:2:17;5303:66:2;;;20395:21:17;20452:2;20432:18;;;20425:30;20491:34;20471:18;;;20464:62;20562:7;20542:18;;;20535:35;20587:19;;5303:66:2;20211:401:17;5303:66:2;681:10:1;5426:96:2;681:10:1;5457:4:2;5463:2;5467:21;5485:2;5467:17;:21::i;5426:96::-;5535:19;5557:13;;;;;;;;;;;:19;;;;;;;;;;;5595:21;;;;5587:76;;;;-1:-1:-1;;;5587:76:2;;20819:2:17;5587:76:2;;;20801:21:17;20858:2;20838:18;;;20831:30;20897:34;20877:18;;;20870:62;20968:12;20948:18;;;20941:40;20998:19;;5587:76:2;20617:406:17;5587:76:2;5699:9;:13;;;;;;;;;;;:19;;;;;;;;;;;5721:20;;;5699:42;;5763:17;;;;;;;:27;;5721:20;;5699:9;5763:27;;5721:20;;5763:27;:::i;:::-;;;;-1:-1:-1;;5808:46:2;;;22207:25:17;;;22263:2;22248:18;;22241:34;;;5808:46:2;;;;;;;;;;;;;;;22180:18:17;5808:46:2;;;;;;;5867:68;5898:8;5908:4;5914:2;5918;5922:6;5930:4;5867:30;:68::i;:::-;5292:651;;5123:820;;;;;:::o;14394:817::-;14634:13;;;1066:20:0;1114:8;14630:574:2;;14670:79;;;;;:43;;;;;;:79;;14714:8;;14724:4;;14730:3;;14735:7;;14744:4;;14670:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14670:79:2;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;14666:527;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;15066:6;15059:14;;-1:-1:-1;;;15059:14:2;;;;;;;;:::i;14666:527::-;;;15115:62;;-1:-1:-1;;;15115:62:2;;24528:2:17;15115:62:2;;;24510:21:17;24567:2;24547:18;;;24540:30;24606:34;24586:18;;;24579:62;24677:22;24657:18;;;24650:50;24717:19;;15115:62:2;24326:416:17;14666:527:2;14831:64;;;14843:52;14831:64;14827:163;;14920:50;;-1:-1:-1;;;14920:50:2;;24949:2:17;14920:50:2;;;24931:21:17;24988:2;24968:18;;;24961:30;25027:34;25007:18;;;25000:62;25098:10;25078:18;;;25071:38;25126:19;;14920:50:2;24747:404:17;15219:198:2;15339:16;;;15353:1;15339:16;;;;;;;;;15285;;15314:22;;15339:16;;;;;;;;;;;;-1:-1:-1;15339:16:2;15314:41;;15377:7;15366:5;15372:1;15366:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;15404:5;15219:198;-1:-1:-1;;15219:198:2:o;13638:748::-;13853:13;;;1066:20:0;1114:8;13849:530:2;;13889:72;;;;;:38;;;;;;:72;;13928:8;;13938:4;;13944:2;;13948:6;;13956:4;;13889:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13889:72:2;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;13885:483;;;;:::i;:::-;14011:59;;;14023:47;14011:59;14007:158;;14095:50;;-1:-1:-1;;;14095:50:2;;24949:2:17;14095:50:2;;;24931:21:17;24988:2;24968:18;;;24961:30;25027:34;25007:18;;;25000:62;25098:10;25078:18;;;25071:38;25126:19;;14095:50:2;24747:404:17;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:154:17;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:17: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:17:o;1299:180::-;1358:6;1411:2;1399:9;1390:7;1386:23;1382:32;1379:52;;;1427:1;1424;1417:12;1379:52;-1:-1:-1;1450:23:17;;1299:180;-1:-1:-1;1299:180:17:o;1484:258::-;1556:1;1566:113;1580:6;1577:1;1574:13;1566:113;;;1656:11;;;1650:18;1637:11;;;1630:39;1602:2;1595:10;1566:113;;;1697:6;1694:1;1691:13;1688:48;;;1732:1;1723:6;1718:3;1714:16;1707:27;1688:48;;1484:258;;;:::o;1747:328::-;1800:3;1838:5;1832:12;1865:6;1860:3;1853:19;1881:63;1937:6;1930:4;1925:3;1921:14;1914:4;1907:5;1903:16;1881:63;:::i;:::-;1989:2;1977:15;1994:66;1973:88;1964:98;;;;2064:4;1960:109;;1747:328;-1:-1:-1;;1747:328:17:o;2080:231::-;2229:2;2218:9;2211:21;2192:4;2249:56;2301:2;2290:9;2286:18;2278:6;2249:56;:::i;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:17:o;2818:183::-;2878:4;2911:18;2903:6;2900:30;2897:56;;;2933:18;;:::i;:::-;-1:-1:-1;2978:1:17;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:17;;;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:17;3006:724;-1:-1:-1;;;;;;3006:724:17: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:17;4898:18;;4885:32;4926:33;4885:32;4926:33;:::i;:::-;4978:7;-1:-1:-1;5036:2:17;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:1277::-;5686:6;5694;5747:2;5735:9;5726:7;5722:23;5718:32;5715:52;;;5763:1;5760;5753:12;5715:52;5803:9;5790:23;5832:18;5873:2;5865:6;5862:14;5859:34;;;5889:1;5886;5879:12;5859:34;5927:6;5916:9;5912:22;5902:32;;5972:7;5965:4;5961:2;5957:13;5953:27;5943:55;;5994:1;5991;5984:12;5943:55;6030:2;6017:16;6052:4;6075:43;6115:2;6075:43;:::i;:::-;6147:2;6141:9;6159:31;6187:2;6179:6;6159:31;:::i;:::-;6225:18;;;6313:1;6309:10;;;;6301:19;;6297:28;;;6259:15;;;;-1:-1:-1;6337:19:17;;;6334:39;;;6369:1;6366;6359:12;6334:39;6393:11;;;;6413:217;6429:6;6424:3;6421:15;6413:217;;;6509:3;6496:17;6526:31;6551:5;6526:31;:::i;:::-;6570:18;;6446:12;;;;6608;;;;6413:217;;;6649:6;-1:-1:-1;;6693:18:17;;6680:32;;-1:-1:-1;;6724:16:17;;;6721:36;;;6753:1;6750;6743:12;6721:36;;6776:63;6831:7;6820:8;6809:9;6805:24;6776:63;:::i;:::-;6766:73;;;5568:1277;;;;;:::o;6850:435::-;6903:3;6941:5;6935:12;6968:6;6963:3;6956:19;6994:4;7023:2;7018:3;7014:12;7007:19;;7060:2;7053:5;7049:14;7081:1;7091:169;7105:6;7102:1;7099:13;7091:169;;;7166:13;;7154:26;;7200:12;;;;7235:15;;;;7127:1;7120:9;7091:169;;;-1:-1:-1;7276:3:17;;6850:435;-1:-1:-1;;;;;6850:435:17:o;7290:261::-;7469:2;7458:9;7451:21;7432:4;7489:56;7541:2;7530:9;7526:18;7518:6;7489:56;:::i;7556:450::-;7625:6;7678:2;7666:9;7657:7;7653:23;7649:32;7646:52;;;7694:1;7691;7684:12;7646:52;7734:9;7721:23;7767:18;7759:6;7756:30;7753:50;;;7799:1;7796;7789:12;7753:50;7822:22;;7875:4;7867:13;;7863:27;-1:-1:-1;7853:55:17;;7904:1;7901;7894:12;7853:55;7927:73;7992:7;7987:2;7974:16;7969:2;7965;7961:11;7927:73;:::i;:::-;7917:83;7556:450;-1:-1:-1;;;;7556:450:17:o;8011:615::-;8097:6;8105;8158:2;8146:9;8137:7;8133:23;8129:32;8126:52;;;8174:1;8171;8164:12;8126:52;8214:9;8201:23;8243:18;8284:2;8276:6;8273:14;8270:34;;;8300:1;8297;8290:12;8270:34;8338:6;8327:9;8323:22;8313:32;;8383:7;8376:4;8372:2;8368:13;8364:27;8354:55;;8405:1;8402;8395:12;8354:55;8445:2;8432:16;8471:2;8463:6;8460:14;8457:34;;;8487:1;8484;8477:12;8457:34;8540:7;8535:2;8525:6;8522:1;8518:14;8514:2;8510:23;8506:32;8503:45;8500:65;;;8561:1;8558;8551:12;8500:65;8592:2;8584:11;;;;;8614:6;;-1:-1:-1;8011:615:17;;-1:-1:-1;;;;8011:615:17:o;8631:247::-;8690:6;8743:2;8731:9;8722:7;8718:23;8714:32;8711:52;;;8759:1;8756;8749:12;8711:52;8798:9;8785:23;8817:31;8842:5;8817:31;:::i;8883:160::-;8948:20;;9004:13;;8997:21;8987:32;;8977:60;;9033:1;9030;9023:12;8977:60;8883:160;;;:::o;9048:180::-;9104:6;9157:2;9145:9;9136:7;9132:23;9128:32;9125:52;;;9173:1;9170;9163:12;9125:52;9196:26;9212:9;9196:26;:::i;9464:315::-;9529:6;9537;9590:2;9578:9;9569:7;9565:23;9561:32;9558:52;;;9606:1;9603;9596:12;9558:52;9645:9;9632:23;9664:31;9689:5;9664:31;:::i;:::-;9714:5;-1:-1:-1;9738:35:17;9769:2;9754:18;;9738:35;:::i;:::-;9728:45;;9464:315;;;;;:::o;9784:388::-;9852:6;9860;9913:2;9901:9;9892:7;9888:23;9884:32;9881:52;;;9929:1;9926;9919:12;9881:52;9968:9;9955:23;9987:31;10012:5;9987:31;:::i;:::-;10037:5;-1:-1:-1;10094:2:17;10079:18;;10066:32;10107:33;10066:32;10107:33;:::i;:::-;10159:7;10149:17;;;9784:388;;;;;:::o;10177:734::-;10281:6;10289;10297;10305;10313;10366:3;10354:9;10345:7;10341:23;10337:33;10334:53;;;10383:1;10380;10373:12;10334:53;10422:9;10409:23;10441:31;10466:5;10441:31;:::i;:::-;10491:5;-1:-1:-1;10548:2:17;10533:18;;10520:32;10561:33;10520:32;10561:33;:::i;:::-;10613:7;-1:-1:-1;10667:2:17;10652:18;;10639:32;;-1:-1:-1;10718:2:17;10703:18;;10690:32;;-1:-1:-1;10773:3:17;10758:19;;10745:33;10801:18;10790:30;;10787:50;;;10833:1;10830;10823:12;10787:50;10856:49;10897:7;10888:6;10877:9;10873:22;10856:49;:::i;11328:437::-;11407:1;11403:12;;;;11450;;;11471:61;;11525:4;11517:6;11513:17;11503:27;;11471:61;11578:2;11570:6;11567:14;11547:18;11544:38;11541:218;;11615:77;11612:1;11605:88;11716:4;11713:1;11706:15;11744:4;11741:1;11734:15;11541:218;;11328:437;;;:::o;11896:185::-;11938:3;11976:5;11970:12;11991:52;12036:6;12031:3;12024:4;12017:5;12013:16;11991:52;:::i;:::-;12059:16;;;;;11896:185;-1:-1:-1;;11896:185:17:o;12086:1289::-;12262:3;12291:1;12324:6;12318:13;12354:3;12376:1;12404:9;12400:2;12396:18;12386:28;;12464:2;12453:9;12449:18;12486;12476:61;;12530:4;12522:6;12518:17;12508:27;;12476:61;12556:2;12604;12596:6;12593:14;12573:18;12570:38;12567:222;;12643:77;12638:3;12631:90;12744:4;12741:1;12734:15;12774:4;12769:3;12762:17;12567:222;12805:18;12832:162;;;;13008:1;13003:320;;;;12798:525;;12832:162;12880:66;12869:9;12865:82;12860:3;12853:95;12977:6;12972:3;12968:16;12961:23;;12832:162;;13003:320;11843:1;11836:14;;;11880:4;11867:18;;13098:1;13112:165;13126:6;13123:1;13120:13;13112:165;;;13204:14;;13191:11;;;13184:35;13247:16;;;;13141:10;;13112:165;;;13116:3;;13306:6;13301:3;13297:16;13290:23;;12798:525;;;;;;;13339:30;13365:3;13357:6;13339:30;:::i;:::-;13332:37;12086:1289;-1:-1:-1;;;;;12086:1289:17:o;14920:184::-;14972:77;14969:1;14962:88;15069:4;15066:1;15059:15;15093:4;15090:1;15083:15;15109:184;15161:77;15158:1;15151:88;15258:4;15255:1;15248:15;15282:4;15279:1;15272:15;15298:195;15337:3;15368:66;15361:5;15358:77;15355:103;;15438:18;;:::i;:::-;-1:-1:-1;15485:1:17;15474:13;;15298:195::o;16211:251::-;16281:6;16334:2;16322:9;16313:7;16309:23;16305:32;16302:52;;;16350:1;16347;16340:12;16302:52;16382:9;16376:16;16401:31;16426:5;16401:31;:::i;17233:184::-;17303:6;17356:2;17344:9;17335:7;17331:23;17327:32;17324:52;;;17372:1;17369;17362:12;17324:52;-1:-1:-1;17395:16:17;;17233:184;-1:-1:-1;17233:184:17:o;18951:274::-;18991:1;19017;19007:189;;19052:77;19049:1;19042:88;19153:4;19150:1;19143:15;19181:4;19178:1;19171:15;19007:189;-1:-1:-1;19210:9:17;;18951:274::o;19230:125::-;19270:4;19298:1;19295;19292:8;19289:34;;;19303:18;;:::i;:::-;-1:-1:-1;19340:9:17;;19230:125::o;19360:228::-;19400:7;19526:1;19458:66;19454:74;19451:1;19448:81;19443:1;19436:9;19429:17;19425:105;19422:131;;;19533:18;;:::i;:::-;-1:-1:-1;19573:9:17;;19360:228::o;19593:204::-;19631:3;19667:4;19664:1;19660:12;19699:4;19696:1;19692:12;19734:3;19728:4;19724:14;19719:3;19716:23;19713:49;;;19742:18;;:::i;:::-;19778:13;;19593:204;-1:-1:-1;;;19593:204:17:o;21028:128::-;21068:3;21099:1;21095:6;21092:1;21089:13;21086:39;;;21105:18;;:::i;:::-;-1:-1:-1;21141:9:17;;21028:128::o;21161:465::-;21418:2;21407:9;21400:21;21381:4;21444:56;21496:2;21485:9;21481:18;21473:6;21444:56;:::i;:::-;21548:9;21540:6;21536:22;21531:2;21520:9;21516:18;21509:50;21576:44;21613:6;21605;21576:44;:::i;22286:861::-;22608:4;22637:42;22718:2;22710:6;22706:15;22695:9;22688:34;22770:2;22762:6;22758:15;22753:2;22742:9;22738:18;22731:43;;22810:3;22805:2;22794:9;22790:18;22783:31;22837:57;22889:3;22878:9;22874:19;22866:6;22837:57;:::i;:::-;22942:9;22934:6;22930:22;22925:2;22914:9;22910:18;22903:50;22976:44;23013:6;23005;22976:44;:::i;:::-;22962:58;;23069:9;23061:6;23057:22;23051:3;23040:9;23036:19;23029:51;23097:44;23134:6;23126;23097:44;:::i;:::-;23089:52;22286:861;-1:-1:-1;;;;;;;;22286:861:17:o;23152:249::-;23221:6;23274:2;23262:9;23253:7;23249:23;23245:32;23242:52;;;23290:1;23287;23280:12;23242:52;23322:9;23316:16;23341:30;23365:5;23341:30;:::i;23406:179::-;23441:3;23483:1;23465:16;23462:23;23459:120;;;23529:1;23526;23523;23508:23;-1:-1:-1;23566:1:17;23560:8;23555:3;23551:18;23459:120;23406:179;:::o;23590:731::-;23629:3;23671:4;23653:16;23650:26;23647:39;;;23590:731;:::o;23647:39::-;23713:2;23707:9;23735:66;23856:2;23838:16;23834:25;23831:1;23825:4;23810:50;23889:4;23883:11;23913:16;23948:18;24019:2;24012:4;24004:6;24000:17;23997:25;23992:2;23984:6;23981:14;23978:45;23975:58;;;24026:5;;;;;23590:731;:::o;23975:58::-;24063:6;24057:4;24053:17;24042:28;;24099:3;24093:10;24126:2;24118:6;24115:14;24112:27;;;24132:5;;;;;;23590:731;:::o;24112:27::-;24216:2;24197:16;24191:4;24187:27;24183:36;24176:4;24167:6;24162:3;24158:16;24154:27;24151:69;24148:82;;;24223:5;;;;;;23590:731;:::o;24148:82::-;24239:57;24290:4;24281:6;24273;24269:19;24265:30;24259:4;24239:57;:::i;:::-;-1:-1:-1;24312:3:17;;23590:731;-1:-1:-1;;;;;23590:731:17:o;25156:595::-;25378:4;25407:42;25488:2;25480:6;25476:15;25465:9;25458:34;25540:2;25532:6;25528:15;25523:2;25512:9;25508:18;25501:43;;25580:6;25575:2;25564:9;25560:18;25553:34;25623:6;25618:2;25607:9;25603:18;25596:34;25667:3;25661;25650:9;25646:19;25639:32;25688:57;25740:3;25729:9;25725:19;25717:6;25688:57;:::i;:::-;25680:65;25156:595;-1:-1:-1;;;;;;;25156:595:17:o

ipfs://da92ac45c28d4ca5f2a9112b1466d0541106f350917adcaafa9bece4d1d6fe23