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 "./ERC1155.sol";
import "./IERC1155.sol";
import "./Ownable.sol";
import "./Strings.sol";

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

	mapping(uint256 => uint256) private _totalSupply;

	//constants	
	uint256 public burnedCounter;
	uint256 public totalMinted;

	uint256 constant level1 = 1;
	uint256 constant level2 = 2;
	uint256 constant level3 = 3;
	uint256 constant puzzler = 4;

	event Redeemed(address indexed from, uint256 id, uint256 uuid);

	string public _baseURI;
	string public _contractURI;

	bool saleLive = false;
	bool burnLive = false;

	constructor() ERC1155(_baseURI) 
	{}

	   // airdrop function
    function airdropLevel1(uint256[] calldata qty, address[] calldata addr) public onlyOwner {
        for(uint256 i = 0; i < addr.length; i++) {
            _mint(addr[i], level1, qty[i], "");
        }
    }
		function airdropLevel2(uint256[] calldata qty, address[] calldata addr) public onlyOwner {
        for(uint256 i = 0; i < addr.length; i++) {
            _mint(addr[i], level2, qty[i], "");
        }
    }
	function airdropLevel2Batch(uint256[] calldata qty, address[] calldata addr) public onlyOwner {
        for(uint256 i = 0; i < addr.length; i++) {
            _mint(addr[i], level1, qty[i], "");
            _mint(addr[i], level2, qty[i], "");
        }
    }
	function airdropLevel3(uint256[] calldata qty, address[] calldata addr) public onlyOwner {
        for(uint256 i = 0; i < addr.length; i++) {
            _mint(addr[i], level3, qty[i], "");
        }
    }
	function airdropLevel3Batch(uint256[] calldata qty, address[] calldata addr) public onlyOwner {
        for(uint256 i = 0; i < addr.length; i++) {
            _mint(addr[i], level1, qty[i], "");
            _mint(addr[i], level2, qty[i], "");
            _mint(addr[i], level3, qty[i], "");
        }
    }
	function airdropPuzzler(uint256[] calldata qty, address[] calldata addr) public onlyOwner {
        for(uint256 i = 0; i < addr.length; i++) {
            _mint(addr[i], puzzler, qty[i], "");
        }
    }

	//redeem function
	function burn(
		address account,
		uint256 id,
		uint256 qty,
		uint256 uuid
	) public virtual {
		require(burnLive, "burn is not enabled");
		require(
			account == _msgSender() || isApprovedForAll(account, _msgSender()),
			"ERC1155: caller is not owner nor approved"
		);
		require(balanceOf(account, id) >= qty, "balance too low");

		burnedCounter = burnedCounter + qty;
		_burn(account, id, qty);
		emit Redeemed(account, id, uuid);
	}

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

	function totalSupply(uint256 id) public view virtual returns (uint256) {
		return _totalSupply[id];
	}

	function exists(uint256 id) public view virtual returns (bool) {
		return totalSupply(id) > 0;
	}

	// enables burn
	function setBurnLive(bool _burnLive) external onlyOwner {
		burnLive = _burnLive;
	}

	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
// OpenZeppelin Contracts v4.4.1 (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "./Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;

import "./ECDSA.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;
    address private immutable _CACHED_THIS;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    bytes32 private immutable _TYPE_HASH;

    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        bytes32 typeHash = keccak256(
            "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
        );
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = block.chainid;
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
        _CACHED_THIS = address(this);
        _TYPE_HASH = typeHash;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(
        bytes32 typeHash,
        bytes32 nameHash,
        bytes32 versionHash
    ) private view returns (bytes32) {
        return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }
}

// 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: 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 "./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":[],"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":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"uuid","type":"uint256"}],"name":"Redeemed","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":"qty","type":"uint256[]"},{"internalType":"address[]","name":"addr","type":"address[]"}],"name":"airdropLevel1","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"qty","type":"uint256[]"},{"internalType":"address[]","name":"addr","type":"address[]"}],"name":"airdropLevel2","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"qty","type":"uint256[]"},{"internalType":"address[]","name":"addr","type":"address[]"}],"name":"airdropLevel2Batch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"qty","type":"uint256[]"},{"internalType":"address[]","name":"addr","type":"address[]"}],"name":"airdropLevel3","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"qty","type":"uint256[]"},{"internalType":"address[]","name":"addr","type":"address[]"}],"name":"airdropLevel3Batch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"qty","type":"uint256[]"},{"internalType":"address[]","name":"addr","type":"address[]"}],"name":"airdropPuzzler","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"qty","type":"uint256"},{"internalType":"uint256","name":"uuid","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burnedCounter","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":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"_burnLive","type":"bool"}],"name":"setBurnLive","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":"totalMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawToOwner","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040526009805461ffff191690553480156200001c57600080fd5b50600780546200002c90620001e4565b80601f01602080910402602001604051908101604052809291908181526020018280546200005a90620001e4565b8015620000ab5780601f106200007f57610100808354040283529160200191620000ab565b820191906000526020600020905b8154815290600101906020018083116200008d57829003601f168201915b5050505050620000c181620000d360201b60201c565b50620000cd33620000ec565b62000221565b8051620000e89060029060208401906200013e565b5050565b600380546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b8280546200014c90620001e4565b90600052602060002090601f016020900481019282620001705760008555620001bb565b82601f106200018b57805160ff1916838001178555620001bb565b82800160010185558215620001bb579182015b82811115620001bb5782518255916020019190600101906200019e565b50620001c9929150620001cd565b5090565b5b80821115620001c95760008155600101620001ce565b600181811c90821680620001f957607f821691505b602082108114156200021b57634e487b7160e01b600052602260045260246000fd5b50919050565b612f5c80620002316000396000f3fe608060405234801561001057600080fd5b50600436106101ce5760003560e01c80638da5cb5b11610104578063cdb712d8116100a2578063f242432a11610071578063f242432a14610409578063f2fde38b1461041c578063f41a6c8e1461042f578063f83a56591461044257600080fd5b8063cdb712d81461039c578063de7bf0a2146103a5578063e8a3d485146103b8578063e985e9c5146103c057600080fd5b8063a2309ff8116100de578063a2309ff814610358578063bd85b03914610361578063c0e7274014610381578063c19d509d1461038957600080fd5b80638da5cb5b1461030a578063938e3d7b14610332578063a22cb4651461034557600080fd5b80634e1273f4116101715780636731d6b21161014b5780636731d6b2146102d4578063715018a6146102e7578063743976a0146102ef5780638b987f72146102f757600080fd5b80634e1273f41461027f5780634f558e791461029f57806355f804b3146102c157600080fd5b80631a17e6ed116101ad5780631a17e6ed1461023c5780632eb2c2d6146102515780633708a2e5146102645780633cb40e161461027757600080fd5b8062fdd58e146101d357806301ffc9a7146101f95780630e89341c1461021c575b600080fd5b6101e66101e13660046123da565b610455565b6040519081526020015b60405180910390f35b61020c610207366004612432565b610518565b60405190151581526020016101f0565b61022f61022a366004612456565b6105fd565b6040516101f091906124e9565b61024f61024a366004612548565b610631565b005b61024f61025f36600461275f565b610716565b61024f610272366004612819565b6107be565b61024f61085c565b61029261028d366004612834565b6108f2565b6040516101f0919061293a565b61020c6102ad366004612456565b600090815260046020526040902054151590565b61024f6102cf36600461294d565b610a30565b61024f6102e2366004612548565b610aae565b61024f610b70565b61022f610be3565b61024f610305366004612548565b610c71565b60035460405173ffffffffffffffffffffffffffffffffffffffff90911681526020016101f0565b61024f61034036600461294d565b610d5d565b61024f61035336600461299e565b610dd7565b6101e660065481565b6101e661036f366004612456565b60009081526004602052604090205490565b61022f610efa565b61024f610397366004612548565b610f07565b6101e660055481565b61024f6103b33660046129d1565b610fb5565b61022f611173565b61020c6103ce366004612a0a565b73ffffffffffffffffffffffffffffffffffffffff918216600090815260016020908152604080832093909416825291909152205460ff1690565b61024f610417366004612a34565b611205565b61024f61042a366004612a99565b6112ad565b61024f61043d366004612548565b6113a6565b61024f610450366004612548565b611468565b600073ffffffffffffffffffffffffffffffffffffffff83166104e55760405162461bcd60e51b815260206004820152602b60248201527f455243313135353a2062616c616e636520717565727920666f7220746865207a60448201527f65726f206164647265737300000000000000000000000000000000000000000060648201526084015b60405180910390fd5b5060009081526020818152604080832073ffffffffffffffffffffffffffffffffffffffff949094168352929052205490565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167fd9b67a260000000000000000000000000000000000000000000000000000000014806105ab57507fffffffff0000000000000000000000000000000000000000000000000000000082167f0e89341c00000000000000000000000000000000000000000000000000000000145b806105f757507f01ffc9a7000000000000000000000000000000000000000000000000000000007fffffffff000000000000000000000000000000000000000000000000000000008316145b92915050565b6060600761060a83611501565b60405160200161061b929190612b24565b6040516020818303038152906040529050919050565b60035473ffffffffffffffffffffffffffffffffffffffff1633146106985760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b60005b8181101561070f576106fd8383838181106106b8576106b8612c02565b90506020020160208101906106cd9190612a99565b60028787858181106106e1576106e1612c02565b905060200201356040518060200160405280600081525061165e565b8061070781612c60565b91505061069b565b5050505050565b73ffffffffffffffffffffffffffffffffffffffff851633148061073f575061073f85336103ce565b6107b15760405162461bcd60e51b815260206004820152603260248201527f455243313135353a207472616e736665722063616c6c6572206973206e6f742060448201527f6f776e6572206e6f7220617070726f766564000000000000000000000000000060648201526084016104dc565b61070f85858585856117ab565b60035473ffffffffffffffffffffffffffffffffffffffff1633146108255760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b60098054911515610100027fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff909216919091179055565b60035473ffffffffffffffffffffffffffffffffffffffff1633146108c35760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b60405133904780156108fc02916000818181858888f193505050501580156108ef573d6000803e3d6000fd5b50565b6060815183511461096b5760405162461bcd60e51b815260206004820152602960248201527f455243313135353a206163636f756e747320616e6420696473206c656e67746860448201527f206d69736d61746368000000000000000000000000000000000000000000000060648201526084016104dc565b6000835167ffffffffffffffff811115610987576109876125b4565b6040519080825280602002602001820160405280156109b0578160200160208202803683370190505b50905060005b8451811015610a28576109fb8582815181106109d4576109d4612c02565b60200260200101518583815181106109ee576109ee612c02565b6020026020010151610455565b828281518110610a0d57610a0d612c02565b6020908102919091010152610a2181612c60565b90506109b6565b509392505050565b60035473ffffffffffffffffffffffffffffffffffffffff163314610a975760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b8051610aaa906007906020840190612318565b5050565b60035473ffffffffffffffffffffffffffffffffffffffff163314610b155760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b60005b8181101561070f57610b5e838383818110610b3557610b35612c02565b9050602002016020810190610b4a9190612a99565b60018787858181106106e1576106e1612c02565b80610b6881612c60565b915050610b18565b60035473ffffffffffffffffffffffffffffffffffffffff163314610bd75760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b610be16000611a97565b565b60078054610bf090612ab4565b80601f0160208091040260200160405190810160405280929190818152602001828054610c1c90612ab4565b8015610c695780601f10610c3e57610100808354040283529160200191610c69565b820191906000526020600020905b815481529060010190602001808311610c4c57829003601f168201915b505050505081565b60035473ffffffffffffffffffffffffffffffffffffffff163314610cd85760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b60005b8181101561070f57610cf8838383818110610b3557610b35612c02565b610d0d8383838181106106b8576106b8612c02565b610d4b838383818110610d2257610d22612c02565b9050602002016020810190610d379190612a99565b60038787858181106106e1576106e1612c02565b80610d5581612c60565b915050610cdb565b60035473ffffffffffffffffffffffffffffffffffffffff163314610dc45760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b8051610aaa906008906020840190612318565b3373ffffffffffffffffffffffffffffffffffffffff83161415610e635760405162461bcd60e51b815260206004820152602960248201527f455243313135353a2073657474696e6720617070726f76616c2073746174757360448201527f20666f722073656c66000000000000000000000000000000000000000000000060648201526084016104dc565b33600081815260016020908152604080832073ffffffffffffffffffffffffffffffffffffffff87168085529083529281902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b60088054610bf090612ab4565b60035473ffffffffffffffffffffffffffffffffffffffff163314610f6e5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b60005b8181101561070f57610f8e838383818110610b3557610b35612c02565b610fa38383838181106106b8576106b8612c02565b80610fad81612c60565b915050610f71565b600954610100900460ff1661100c5760405162461bcd60e51b815260206004820152601360248201527f6275726e206973206e6f7420656e61626c65640000000000000000000000000060448201526064016104dc565b73ffffffffffffffffffffffffffffffffffffffff8416331480611035575061103584336103ce565b6110a75760405162461bcd60e51b815260206004820152602960248201527f455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f7260448201527f20617070726f766564000000000000000000000000000000000000000000000060648201526084016104dc565b816110b28585610455565b10156111005760405162461bcd60e51b815260206004820152600f60248201527f62616c616e636520746f6f206c6f77000000000000000000000000000000000060448201526064016104dc565b8160055461110e9190612c99565b60055561111c848484611b0e565b604080518481526020810183905273ffffffffffffffffffffffffffffffffffffffff8616917ff3a670cd3af7d64b488926880889d08a8585a138ff455227af6737339a1ec262910160405180910390a250505050565b60606008805461118290612ab4565b80601f01602080910402602001604051908101604052809291908181526020018280546111ae90612ab4565b80156111fb5780601f106111d0576101008083540402835291602001916111fb565b820191906000526020600020905b8154815290600101906020018083116111de57829003601f168201915b5050505050905090565b73ffffffffffffffffffffffffffffffffffffffff851633148061122e575061122e85336103ce565b6112a05760405162461bcd60e51b815260206004820152602960248201527f455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f7260448201527f20617070726f766564000000000000000000000000000000000000000000000060648201526084016104dc565b61070f8585858585611ce2565b60035473ffffffffffffffffffffffffffffffffffffffff1633146113145760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b73ffffffffffffffffffffffffffffffffffffffff811661139d5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084016104dc565b6108ef81611a97565b60035473ffffffffffffffffffffffffffffffffffffffff16331461140d5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b60005b8181101561070f5761145683838381811061142d5761142d612c02565b90506020020160208101906114429190612a99565b60048787858181106106e1576106e1612c02565b8061146081612c60565b915050611410565b60035473ffffffffffffffffffffffffffffffffffffffff1633146114cf5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016104dc565b60005b8181101561070f576114ef838383818110610d2257610d22612c02565b806114f981612c60565b9150506114d2565b60608161154157505060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015290565b8160005b811561156b578061155581612c60565b91506115649050600a83612cb1565b9150611545565b60008167ffffffffffffffff811115611586576115866125b4565b6040519080825280601f01601f1916602001820160405280156115b0576020820181803683370190505b509050815b8515611655576115c6600182612cec565b905060006115d5600a88612cb1565b6115e090600a612d03565b6115ea9088612cec565b6115f5906030612d40565b905060008160f81b90508084848151811061161257611612612c02565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a90535061164c600a89612cb1565b975050506115b5565b50949350505050565b73ffffffffffffffffffffffffffffffffffffffff84166116e75760405162461bcd60e51b815260206004820152602160248201527f455243313135353a206d696e7420746f20746865207a65726f2061646472657360448201527f730000000000000000000000000000000000000000000000000000000000000060648201526084016104dc565b33611701816000876116f888611edf565b61070f88611edf565b60008481526020818152604080832073ffffffffffffffffffffffffffffffffffffffff891684529091528120805485929061173e908490612c99565b9091555050604080518581526020810185905273ffffffffffffffffffffffffffffffffffffffff80881692600092918516917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a461070f81600087878787611f2a565b81518351146118225760405162461bcd60e51b815260206004820152602860248201527f455243313135353a2069647320616e6420616d6f756e7473206c656e6774682060448201527f6d69736d6174636800000000000000000000000000000000000000000000000060648201526084016104dc565b73ffffffffffffffffffffffffffffffffffffffff84166118ab5760405162461bcd60e51b815260206004820152602560248201527f455243313135353a207472616e7366657220746f20746865207a65726f20616460448201527f647265737300000000000000000000000000000000000000000000000000000060648201526084016104dc565b3360005b8451811015611a025760008582815181106118cc576118cc612c02565b6020026020010151905060008583815181106118ea576118ea612c02565b6020908102919091018101516000848152808352604080822073ffffffffffffffffffffffffffffffffffffffff8e16835290935291909120549091508181101561199d5760405162461bcd60e51b815260206004820152602a60248201527f455243313135353a20696e73756666696369656e742062616c616e636520666f60448201527f72207472616e736665720000000000000000000000000000000000000000000060648201526084016104dc565b60008381526020818152604080832073ffffffffffffffffffffffffffffffffffffffff8e8116855292528083208585039055908b168252812080548492906119e7908490612c99565b92505081905550505050806119fb90612c60565b90506118af565b508473ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb8787604051611a79929190612d65565b60405180910390a4611a8f818787878787612176565b505050505050565b6003805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b73ffffffffffffffffffffffffffffffffffffffff8316611b975760405162461bcd60e51b815260206004820152602360248201527f455243313135353a206275726e2066726f6d20746865207a65726f206164647260448201527f657373000000000000000000000000000000000000000000000000000000000060648201526084016104dc565b33611bc781856000611ba887611edf565b611bb187611edf565b5050604080516020810190915260009052505050565b60008381526020818152604080832073ffffffffffffffffffffffffffffffffffffffff8816845290915290205482811015611c6a5760405162461bcd60e51b8152602060048201526024808201527f455243313135353a206275726e20616d6f756e7420657863656564732062616c60448201527f616e63650000000000000000000000000000000000000000000000000000000060648201526084016104dc565b60008481526020818152604080832073ffffffffffffffffffffffffffffffffffffffff898116808652918452828520888703905582518981529384018890529092908616917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a45050505050565b73ffffffffffffffffffffffffffffffffffffffff8416611d6b5760405162461bcd60e51b815260206004820152602560248201527f455243313135353a207472616e7366657220746f20746865207a65726f20616460448201527f647265737300000000000000000000000000000000000000000000000000000060648201526084016104dc565b33611d7b8187876116f888611edf565b60008481526020818152604080832073ffffffffffffffffffffffffffffffffffffffff8a16845290915290205483811015611e1f5760405162461bcd60e51b815260206004820152602a60248201527f455243313135353a20696e73756666696369656e742062616c616e636520666f60448201527f72207472616e736665720000000000000000000000000000000000000000000060648201526084016104dc565b60008581526020818152604080832073ffffffffffffffffffffffffffffffffffffffff8b8116855292528083208785039055908816825281208054869290611e69908490612c99565b9091555050604080518681526020810186905273ffffffffffffffffffffffffffffffffffffffff808916928a821692918616917fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62910160405180910390a4611ed6828888888888611f2a565b50505050505050565b60408051600180825281830190925260609160009190602080830190803683370190505090508281600081518110611f1957611f19612c02565b602090810291909101015292915050565b73ffffffffffffffffffffffffffffffffffffffff84163b15611a8f576040517ff23a6e6100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85169063f23a6e6190611fa19089908990889088908890600401612d8a565b602060405180830381600087803b158015611fbb57600080fd5b505af1925050508015612009575060408051601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016820190925261200691810190612dda565b60015b6120bf57612015612df7565b806308c379a0141561204f575061202a612e13565b806120355750612051565b8060405162461bcd60e51b81526004016104dc91906124e9565b505b60405162461bcd60e51b815260206004820152603460248201527f455243313135353a207472616e7366657220746f206e6f6e204552433131353560448201527f526563656976657220696d706c656d656e74657200000000000000000000000060648201526084016104dc565b7fffffffff0000000000000000000000000000000000000000000000000000000081167ff23a6e610000000000000000000000000000000000000000000000000000000014611ed65760405162461bcd60e51b815260206004820152602860248201527f455243313135353a204552433131353552656365697665722072656a6563746560448201527f6420746f6b656e7300000000000000000000000000000000000000000000000060648201526084016104dc565b73ffffffffffffffffffffffffffffffffffffffff84163b15611a8f576040517fbc197c8100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85169063bc197c81906121ed9089908990889088908890600401612ebb565b602060405180830381600087803b15801561220757600080fd5b505af1925050508015612255575060408051601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016820190925261225291810190612dda565b60015b61226157612015612df7565b7fffffffff0000000000000000000000000000000000000000000000000000000081167fbc197c810000000000000000000000000000000000000000000000000000000014611ed65760405162461bcd60e51b815260206004820152602860248201527f455243313135353a204552433131353552656365697665722072656a6563746560448201527f6420746f6b656e7300000000000000000000000000000000000000000000000060648201526084016104dc565b82805461232490612ab4565b90600052602060002090601f016020900481019282612346576000855561238c565b82601f1061235f57805160ff191683800117855561238c565b8280016001018555821561238c579182015b8281111561238c578251825591602001919060010190612371565b5061239892915061239c565b5090565b5b80821115612398576000815560010161239d565b803573ffffffffffffffffffffffffffffffffffffffff811681146123d557600080fd5b919050565b600080604083850312156123ed57600080fd5b6123f6836123b1565b946020939093013593505050565b7fffffffff00000000000000000000000000000000000000000000000000000000811681146108ef57600080fd5b60006020828403121561244457600080fd5b813561244f81612404565b9392505050565b60006020828403121561246857600080fd5b5035919050565b60005b8381101561248a578181015183820152602001612472565b83811115612499576000848401525b50505050565b600081518084526124b781602086016020860161246f565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b60208152600061244f602083018461249f565b60008083601f84011261250e57600080fd5b50813567ffffffffffffffff81111561252657600080fd5b6020830191508360208260051b850101111561254157600080fd5b9250929050565b6000806000806040858703121561255e57600080fd5b843567ffffffffffffffff8082111561257657600080fd5b612582888389016124fc565b9096509450602087013591508082111561259b57600080fd5b506125a8878288016124fc565b95989497509550505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f830116810181811067ffffffffffffffff82111715612627576126276125b4565b6040525050565b600067ffffffffffffffff821115612648576126486125b4565b5060051b60200190565b600082601f83011261266357600080fd5b813560206126708261262e565b60405161267d82826125e3565b83815260059390931b850182019282810191508684111561269d57600080fd5b8286015b848110156126b857803583529183019183016126a1565b509695505050505050565b600067ffffffffffffffff8311156126dd576126dd6125b4565b60405161271260207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f87011601826125e3565b80915083815284848401111561272757600080fd5b83836020830137600060208583010152509392505050565b600082601f83011261275057600080fd5b61244f838335602085016126c3565b600080600080600060a0868803121561277757600080fd5b612780866123b1565b945061278e602087016123b1565b9350604086013567ffffffffffffffff808211156127ab57600080fd5b6127b789838a01612652565b945060608801359150808211156127cd57600080fd5b6127d989838a01612652565b935060808801359150808211156127ef57600080fd5b506127fc8882890161273f565b9150509295509295909350565b803580151581146123d557600080fd5b60006020828403121561282b57600080fd5b61244f82612809565b6000806040838503121561284757600080fd5b823567ffffffffffffffff8082111561285f57600080fd5b818501915085601f83011261287357600080fd5b813560206128808261262e565b60405161288d82826125e3565b83815260059390931b85018201928281019150898411156128ad57600080fd5b948201945b838610156128d2576128c3866123b1565b825294820194908201906128b2565b965050860135925050808211156128e857600080fd5b506128f585828601612652565b9150509250929050565b600081518084526020808501945080840160005b8381101561292f57815187529582019590820190600101612913565b509495945050505050565b60208152600061244f60208301846128ff565b60006020828403121561295f57600080fd5b813567ffffffffffffffff81111561297657600080fd5b8201601f8101841361298757600080fd5b612996848235602084016126c3565b949350505050565b600080604083850312156129b157600080fd5b6129ba836123b1565b91506129c860208401612809565b90509250929050565b600080600080608085870312156129e757600080fd5b6129f0856123b1565b966020860135965060408601359560600135945092505050565b60008060408385031215612a1d57600080fd5b612a26836123b1565b91506129c8602084016123b1565b600080600080600060a08688031215612a4c57600080fd5b612a55866123b1565b9450612a63602087016123b1565b93506040860135925060608601359150608086013567ffffffffffffffff811115612a8d57600080fd5b6127fc8882890161273f565b600060208284031215612aab57600080fd5b61244f826123b1565b600181811c90821680612ac857607f821691505b60208210811415612b02577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b60008151612b1a81856020860161246f565b9290920192915050565b600080845481600182811c915080831680612b4057607f831692505b6020808410821415612b79577f4e487b710000000000000000000000000000000000000000000000000000000086526022600452602486fd5b818015612b8d5760018114612bbc57612be9565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00861689528489019650612be9565b60008b81526020902060005b86811015612be15781548b820152908501908301612bc8565b505084890196505b505050505050612bf98185612b08565b95945050505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff821415612c9257612c92612c31565b5060010190565b60008219821115612cac57612cac612c31565b500190565b600082612ce7577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b600082821015612cfe57612cfe612c31565b500390565b6000817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615612d3b57612d3b612c31565b500290565b600060ff821660ff84168060ff03821115612d5d57612d5d612c31565b019392505050565b604081526000612d7860408301856128ff565b8281036020840152612bf981856128ff565b600073ffffffffffffffffffffffffffffffffffffffff808816835280871660208401525084604083015283606083015260a06080830152612dcf60a083018461249f565b979650505050505050565b600060208284031215612dec57600080fd5b815161244f81612404565b600060033d1115612e105760046000803e5060005160e01c5b90565b600060443d1015612e215790565b6040517ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc803d016004833e81513d67ffffffffffffffff8160248401118184111715612e6f57505050505090565b8285019150815181811115612e875750505050505090565b843d8701016020828501011115612ea15750505050505090565b612eb0602082860101876125e3565b509095945050505050565b600073ffffffffffffffffffffffffffffffffffffffff808816835280871660208401525060a06040830152612ef460a08301866128ff565b8281036060840152612f0681866128ff565b90508281036080840152612f1a818561249f565b9897505050505050505056fea2646970667358221220524ae26a13bfd52d1b22c62afe3ef8544c7e0a79af150c14d5f191da4700f43064736f6c63430008090033

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

162:3804:10:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2122:231:4;;;;;;:::i;:::-;;:::i;:::-;;;620:25:13;;;608:2;593:18;2122:231:4;;;;;;;;1145:310;;;;;;:::i;:::-;;:::i;:::-;;;1253:14:13;;1246:22;1228:41;;1216:2;1201:18;1145:310:4;1088:187:13;2860:145:10;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;968:209::-;;;;;;:::i;:::-;;:::i;:::-;;4217:442:4;;;;;;:::i;:::-;;:::i;3765:86:10:-;;;;;;:::i;:::-;;:::i;3856:107::-;;;:::i;2519:524:4:-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3643:99:10:-;;;;;;:::i;:::-;3700:4;3617:16;;;:12;:16;;;;;;-1:-1:-1;;;3643:99:10;2672:86;;;;;;:::i;:::-;;:::i;755:209::-;;;;;;:::i;:::-;;:::i;1650:94:11:-;;;:::i;575:22:10:-;;;:::i;1658:312::-;;;;;;:::i;:::-;;:::i;999:87:11:-;1072:6;;999:87;;1072:6;;;;9441:74:13;;9429:2;9414:18;999:87:11;9295:226:13;2761:94:10;;;;;;:::i;:::-;;:::i;3116:311:4:-;;;;;;:::i;:::-;;:::i;348:26:10:-;;;;;;3534:104;;;;;;:::i;:::-;3596:7;3617:16;;;:12;:16;;;;;;;3534:104;601:26;;;:::i;1180:263::-;;;;;;:::i;:::-;;:::i;316:28::-;;;;;;2209:458;;;;;;:::i;:::-;;:::i;3008:88::-;;;:::i;3499:168:4:-;;;;;;:::i;:::-;3622:27;;;;3598:4;3622:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;3499:168;3739:401;;;;;;:::i;:::-;;:::i;1899:192:11:-;;;;;;:::i;:::-;;:::i;1973:211:10:-;;;;;;:::i;:::-;;:::i;1446:209::-;;;;;;:::i;:::-;;:::i;2122:231:4:-;2208:7;2236:21;;;2228:77;;;;-1:-1:-1;;;2228:77:4;;11450:2:13;2228:77:4;;;11432:21:13;11489:2;11469:18;;;11462:30;11528:34;11508:18;;;11501:62;11599:13;11579:18;;;11572:41;11630:19;;2228:77:4;;;;;;;;;-1:-1:-1;2323:9:4;:13;;;;;;;;;;;:22;;;;;;;;;;;;;2122:231::o;1145:310::-;1247:4;1284:41;;;1299:26;1284:41;;:110;;-1:-1:-1;1342:52:4;;;1357:37;1342:52;1284:110;:163;;;-1:-1:-1;911:25:5;896:40;;;;1411:36:4;1264:183;1145:310;-1:-1:-1;;1145:310:4:o;2860:145:10:-;2920:13;2971:8;2981:17;2990:7;2981:8;:17::i;:::-;2954:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2940:60;;2860:145;;;:::o;968:209::-;1072:6:11;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;1072:9:10::1;1068:102;1087:15:::0;;::::1;1068:102;;;1124:34;1130:4;;1135:1;1130:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;437:1;1147:3;;1151:1;1147:6;;;;;;;:::i;:::-;;;;;;;1124:34;;;;;;;;;;;::::0;:5:::1;:34::i;:::-;1104:3:::0;::::1;::::0;::::1;:::i;:::-;;;;1068:102;;;;968:209:::0;;;;:::o;4217:442:4:-;4450:20;;;681:10:1;4450:20:4;;:60;;-1:-1:-1;4474:36:4;4491:4;681:10:1;3499:168:4;:::i;4474:36::-;4428:160;;;;-1:-1:-1;;;4428:160:4;;14853:2:13;4428:160:4;;;14835:21:13;14892:2;14872:18;;;14865:30;14931:34;14911:18;;;14904:62;15002:20;14982:18;;;14975:48;15040:19;;4428:160:4;14651:414:13;4428:160:4;4599:52;4622:4;4628:2;4632:3;4637:7;4646:4;4599:22;:52::i;3765:86:10:-;1072:6:11;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;3826:8:10::1;:20:::0;;;::::1;;;;::::0;;;::::1;::::0;;;::::1;::::0;;3765:86::o;3856:107::-;1072:6:11;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;3907:51:10::1;::::0;3915:10:::1;::::0;3936:21:::1;3907:51:::0;::::1;;;::::0;::::1;::::0;;;3936:21;3915:10;3907:51;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;3856:107::o:0;2519:524:4:-;2675:16;2736:3;:10;2717:8;:15;:29;2709:83;;;;-1:-1:-1;;;2709:83:4;;15272:2:13;2709:83:4;;;15254:21:13;15311:2;15291:18;;;15284:30;15350:34;15330:18;;;15323:62;15421:11;15401:18;;;15394:39;15450:19;;2709:83:4;15070:405:13;2709:83:4;2805:30;2852:8;:15;2838:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2838:30:4;;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:4;2519:524;-1:-1:-1;;;2519:524:4:o;2672:86:10:-;1072:6:11;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;2736:17:10;;::::1;::::0;:8:::1;::::0;:17:::1;::::0;::::1;::::0;::::1;:::i;:::-;;2672:86:::0;:::o;755:209::-;1072:6:11;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;859:9:10::1;855:102;874:15:::0;;::::1;855:102;;;911:34;917:4;;922:1;917:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;406:1;934:3;;938:1;934:6;;;;;;;:::i;911:34::-;891:3:::0;::::1;::::0;::::1;:::i;:::-;;;;855:102;;1650:94:11::0;1072:6;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;1715:21:::1;1733:1;1715:9;:21::i;:::-;1650:94::o:0;575:22:10:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1658:312::-;1072:6:11;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;1767:9:10::1;1763:200;1782:15:::0;;::::1;1763:200;;;1819:34;1825:4;;1830:1;1825:7;;;;;;;:::i;1819:34::-;1868;1874:4;;1879:1;1874:7;;;;;;;:::i;1868:34::-;1917;1923:4;;1928:1;1923:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;468:1;1940:3;;1944:1;1940:6;;;;;;;:::i;1917:34::-;1799:3:::0;::::1;::::0;::::1;:::i;:::-;;;;1763:200;;2761:94:::0;1072:6:11;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;2829:21:10;;::::1;::::0;:12:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;3116:311:4:-:0;681:10:1;3219:24:4;;;;;3211:78;;;;-1:-1:-1;;;3211:78:4;;15682:2:13;3211:78:4;;;15664:21:13;15721:2;15701:18;;;15694:30;15760:34;15740:18;;;15733:62;15831:11;15811:18;;;15804:39;15860:19;;3211:78:4;15480:405:13;3211:78:4;681:10:1;3302:32:4;;;;:18;:32;;;;;;;;;:42;;;;;;;;;;;;:53;;;;;;;;;;;;;3371:48;;1228:41:13;;;3302:42:4;;681:10:1;3371:48:4;;1201:18:13;3371:48:4;;;;;;;3116:311;;:::o;601:26:10:-;;;;;;;:::i;1180:263::-;1072:6:11;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;1289:9:10::1;1285:151;1304:15:::0;;::::1;1285:151;;;1341:34;1347:4;;1352:1;1347:7;;;;;;;:::i;1341:34::-;1390;1396:4;;1401:1;1396:7;;;;;;;:::i;1390:34::-;1321:3:::0;::::1;::::0;::::1;:::i;:::-;;;;1285:151;;2209:458:::0;2323:8;;;;;;;2315:40;;;;-1:-1:-1;;;2315:40:10;;16092:2:13;2315:40:10;;;16074:21:13;16131:2;16111:18;;;16104:30;16170:21;16150:18;;;16143:49;16209:18;;2315:40:10;15890:343:13;2315:40:10;2373:23;;;681:10:1;2373:23:10;;:66;;-1:-1:-1;2400:39:10;2417:7;681:10:1;3499:168:4;:::i;2400:39:10:-;2360:133;;;;-1:-1:-1;;;2360:133:10;;16440:2:13;2360:133:10;;;16422:21:13;16479:2;16459:18;;;16452:30;16518:34;16498:18;;;16491:62;16589:11;16569:18;;;16562:39;16618:19;;2360:133:10;16238:405:13;2360:133:10;2532:3;2506:22;2516:7;2525:2;2506:9;:22::i;:::-;:29;;2498:57;;;;-1:-1:-1;;;2498:57:10;;16850:2:13;2498:57:10;;;16832:21:13;16889:2;16869:18;;;16862:30;16928:17;16908:18;;;16901:45;16963:18;;2498:57:10;16648:339:13;2498:57:10;2594:3;2578:13;;:19;;;;:::i;:::-;2562:13;:35;2602:23;2608:7;2617:2;2621:3;2602:5;:23::i;:::-;2635:27;;;17299:25:13;;;17355:2;17340:18;;17333:34;;;2635:27:10;;;;;;17272:18:13;2635:27:10;;;;;;;2209:458;;;;:::o;3008:88::-;3052:13;3079:12;3072:19;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3008:88;:::o;3739:401:4:-;3947:20;;;681:10:1;3947:20:4;;:60;;-1:-1:-1;3971:36:4;3988:4;681:10:1;3499:168:4;:::i;3971:36::-;3925:151;;;;-1:-1:-1;;;3925:151:4;;16440:2:13;3925:151:4;;;16422:21:13;16479:2;16459:18;;;16452:30;16518:34;16498:18;;;16491:62;16589:11;16569:18;;;16562:39;16618:19;;3925:151:4;16238:405:13;3925:151:4;4087:45;4105:4;4111:2;4115;4119:6;4127:4;4087:17;:45::i;1899:192:11:-;1072:6;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;1988:22:::1;::::0;::::1;1980:73;;;::::0;-1:-1:-1;;;1980:73:11;;17580:2:13;1980:73:11::1;::::0;::::1;17562:21:13::0;17619:2;17599:18;;;17592:30;17658:34;17638:18;;;17631:62;17729:8;17709:18;;;17702:36;17755:19;;1980:73:11::1;17378:402:13::0;1980:73:11::1;2064:19;2074:8;2064:9;:19::i;1973:211:10:-:0;1072:6:11;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;2078:9:10::1;2074:103;2093:15:::0;;::::1;2074:103;;;2130:35;2136:4;;2141:1;2136:7;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;500:1;2154:3;;2158:1;2154:6;;;;;;;:::i;2130:35::-;2110:3:::0;::::1;::::0;::::1;:::i;:::-;;;;2074:103;;1446:209:::0;1072:6:11;;1219:23;1072:6;681:10:1;1219:23:11;1211:68;;;;-1:-1:-1;;;1211:68:11;;13914:2:13;1211:68:11;;;13896:21:13;;;13933:18;;;13926:30;13992:34;13972:18;;;13965:62;14044:18;;1211:68:11;13712:356:13;1211:68:11;1550:9:10::1;1546:102;1565:15:::0;;::::1;1546:102;;;1602:34;1608:4;;1613:1;1608:7;;;;;;;:::i;1602:34::-;1582:3:::0;::::1;::::0;::::1;:::i;:::-;;;;1546:102;;3099:430:::0;3152:27;3190:7;3186:26;;-1:-1:-1;;3200:10:10;;;;;;;;;;;;;;;;;;3099:430::o;3186:26::-;3229:2;3217:9;3253:32;3260:6;;3253:32;;3269:5;;;;:::i;:::-;;-1:-1:-1;3276:7:10;;-1:-1:-1;3281:2:10;3276:7;;:::i;:::-;;;3253:32;;;3290:17;3320:3;3310:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3310:14:10;-1:-1:-1;3290:34:10;-1:-1:-1;3342:3:10;3350:151;3357:7;;3350:151;;3376:5;3380:1;3376;:5;:::i;:::-;3372:9;-1:-1:-1;3387:10:10;3418:7;3423:2;3418;:7;:::i;:::-;3417:14;;3429:2;3417:14;:::i;:::-;3412:19;;:2;:19;:::i;:::-;3401:31;;:2;:31;:::i;:::-;3387:46;;3439:9;3458:4;3451:12;;3439:24;;3479:2;3469:4;3474:1;3469:7;;;;;;;;:::i;:::-;;;;:12;;;;;;;;;;-1:-1:-1;3487:8:10;3493:2;3487:8;;:::i;:::-;;;3366:135;;3350:151;;;-1:-1:-1;3519:4:10;3099:430;-1:-1:-1;;;;3099:430:10:o;8708:599:4:-;8866:21;;;8858:67;;;;-1:-1:-1;;;8858:67:4;;18838:2:13;8858:67:4;;;18820:21:13;18877:2;18857:18;;;18850:30;18916:34;18896:18;;;18889:62;18987:3;18967:18;;;18960:31;19008:19;;8858:67:4;18636:397:13;8858:67:4;681:10:1;8982:107:4;681:10:1;8938:16:4;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:4;;;17299:25:13;;;17355:2;17340:18;;17333:34;;;9150:57:4;;;;;9183:1;;9150:57;;;;;;17272:18:13;9150:57:4;;;;;;;9220:79;9251:8;9269:1;9273:7;9282:2;9286:6;9294:4;9220:30;:79::i;6301:1074::-;6528:7;:14;6514:3;:10;:28;6506:81;;;;-1:-1:-1;;;6506:81:4;;19240:2:13;6506:81:4;;;19222:21:13;19279:2;19259:18;;;19252:30;19318:34;19298:18;;;19291:62;19389:10;19369:18;;;19362:38;19417:19;;6506:81:4;19038:404:13;6506:81:4;6606:16;;;6598:66;;;;-1:-1:-1;;;6598:66:4;;19649:2:13;6598:66:4;;;19631:21:13;19688:2;19668:18;;;19661:30;19727:34;19707:18;;;19700:62;19798:7;19778:18;;;19771:35;19823:19;;6598:66:4;19447:401:13;6598:66:4;681:10:1;6677:16:4;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:4;;;;6984:76;;;;-1:-1:-1;;;6984:76:4;;20055:2:13;6984:76:4;;;20037:21:13;20094:2;20074:18;;;20067:30;20133:34;20113:18;;;20106:62;20204:12;20184:18;;;20177:40;20234:19;;6984:76:4;19853:406:13;6984:76:4;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;2099:173:11:-;2174:6;;;;2191:17;;;;;;;;;;;2224:40;;2174:6;;;2191:17;2174:6;;2224:40;;2155:16;;2224:40;2144:128;2099:173;:::o;10657:675:4:-;10787:21;;;10779:69;;;;-1:-1:-1;;;10779:69:4;;20936:2:13;10779:69:4;;;20918:21:13;20975:2;20955:18;;;20948:30;21014:34;20994:18;;;20987:62;21085:5;21065:18;;;21058:33;21108:19;;10779:69:4;20734:399:13;10779:69:4;681:10:1;10905:105:4;681:10:1;10936:7:4;10861:16;10957:21;10975:2;10957:17;:21::i;:::-;10980:25;10998:6;10980:17;:25::i;:::-;-1:-1:-1;;10905:105:4;;;;;;;;;-1:-1:-1;10905:105:4;;-1:-1:-1;;;6301:1074:4;10905:105;11023:22;11048:13;;;;;;;;;;;:22;;;;;;;;;;;11089:24;;;;11081:73;;;;-1:-1:-1;;;11081:73:4;;21340:2:13;11081:73:4;;;21322:21:13;21379:2;21359:18;;;21352:30;21418:34;21398:18;;;21391:62;21489:6;21469:18;;;21462:34;21513:19;;11081:73:4;21138:400:13;11081:73:4;11190:9;:13;;;;;;;;;;;:22;;;;;;;;;;;;;11215:23;;;11190:48;;11267:57;;17299:25:13;;;17340:18;;;17333:34;;;11190:22:4;;11267:57;;;;;;17272:18:13;11267:57:4;;;;;;;10768:564;;10657:675;;;:::o;5123:820::-;5311:16;;;5303:66;;;;-1:-1:-1;;;5303:66:4;;19649:2:13;5303:66:4;;;19631:21:13;19688:2;19668:18;;;19661:30;19727:34;19707:18;;;19700:62;19798:7;19778:18;;;19771:35;19823:19;;5303:66:4;19447:401:13;5303:66:4;681:10:1;5426:96:4;681:10:1;5457:4:4;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:4;;20055:2:13;5587:76:4;;;20037:21:13;20094:2;20074:18;;;20067:30;20133:34;20113:18;;;20106:62;20204:12;20184:18;;;20177:40;20234:19;;5587:76:4;19853:406:13;5587:76:4;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:4;;;17299:25:13;;;17355:2;17340:18;;17333:34;;;5808:46:4;;;;;;;;;;;;;;;17272:18:13;5808:46:4;;;;;;;5867:68;5898:8;5908:4;5914:2;5918;5922:6;5930:4;5867:30;:68::i;:::-;5292:651;;5123:820;;;;;:::o;15219:198::-;15339:16;;;15353:1;15339:16;;;;;;;;;15285;;15314:22;;15339:16;;;;;;;;;;;;-1:-1:-1;15339:16:4;15314:41;;15377:7;15366:5;15372:1;15366:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;15404:5;15219:198;-1:-1:-1;;15219:198:4:o;13638:748::-;13853:13;;;1066:20:0;1114:8;13849:530:4;;13889:72;;;;;:38;;;;;;:72;;13928:8;;13938:4;;13944:2;;13948:6;;13956:4;;13889:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13889:72:4;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;13885:483;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;14241:6;14234:14;;-1:-1:-1;;;14234:14:4;;;;;;;;:::i;13885:483::-;;;14290:62;;-1:-1:-1;;;14290:62:4;;23519:2:13;14290:62:4;;;23501:21:13;23558:2;23538:18;;;23531:30;23597:34;23577:18;;;23570:62;23668:22;23648:18;;;23641:50;23708:19;;14290:62:4;23317:416:13;13885:483:4;14011:59;;;14023:47;14011:59;14007:158;;14095:50;;-1:-1:-1;;;14095:50:4;;23940:2:13;14095:50:4;;;23922:21:13;23979:2;23959:18;;;23952:30;24018:34;23998:18;;;23991:62;24089:10;24069:18;;;24062:38;24117:19;;14095:50:4;23738:404:13;14394:817:4;14634:13;;;1066:20:0;1114:8;14630:574:4;;14670:79;;;;;:43;;;;;;:79;;14714:8;;14724:4;;14730:3;;14735:7;;14744:4;;14670:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14670:79:4;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;14666:527;;;;:::i;:::-;14831:64;;;14843:52;14831:64;14827:163;;14920:50;;-1:-1:-1;;;14920:50:4;;23940:2:13;14920:50:4;;;23922:21:13;23979:2;23959:18;;;23952:30;24018:34;23998:18;;;23991:62;24089:10;24069:18;;;24062:38;24117:19;;14920:50:4;23738:404:13;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:196:13;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:254::-;283:6;291;344:2;332:9;323:7;319:23;315:32;312:52;;;360:1;357;350:12;312:52;383:29;402:9;383:29;:::i;:::-;373:39;459:2;444:18;;;;431:32;;-1:-1:-1;;;215:254:13:o;656:177::-;741:66;734:5;730:78;723:5;720:89;710:117;;823:1;820;813:12;838:245;896:6;949:2;937:9;928:7;924:23;920:32;917:52;;;965:1;962;955:12;917:52;1004:9;991:23;1023:30;1047:5;1023:30;:::i;:::-;1072:5;838:245;-1:-1:-1;;;838:245:13:o;1280:180::-;1339:6;1392:2;1380:9;1371:7;1367:23;1363:32;1360:52;;;1408:1;1405;1398:12;1360:52;-1:-1:-1;1431:23:13;;1280:180;-1:-1:-1;1280:180:13:o;1465:258::-;1537:1;1547:113;1561:6;1558:1;1555:13;1547:113;;;1637:11;;;1631:18;1618:11;;;1611:39;1583:2;1576:10;1547:113;;;1678:6;1675:1;1672:13;1669:48;;;1713:1;1704:6;1699:3;1695:16;1688:27;1669:48;;1465:258;;;:::o;1728:328::-;1781:3;1819:5;1813:12;1846:6;1841:3;1834:19;1862:63;1918:6;1911:4;1906:3;1902:14;1895:4;1888:5;1884:16;1862:63;:::i;:::-;1970:2;1958:15;1975:66;1954:88;1945:98;;;;2045:4;1941:109;;1728:328;-1:-1:-1;;1728:328:13:o;2061:231::-;2210:2;2199:9;2192:21;2173:4;2230:56;2282:2;2271:9;2267:18;2259:6;2230:56;:::i;2297:367::-;2360:8;2370:6;2424:3;2417:4;2409:6;2405:17;2401:27;2391:55;;2442:1;2439;2432:12;2391:55;-1:-1:-1;2465:20:13;;2508:18;2497:30;;2494:50;;;2540:1;2537;2530:12;2494:50;2577:4;2569:6;2565:17;2553:29;;2637:3;2630:4;2620:6;2617:1;2613:14;2605:6;2601:27;2597:38;2594:47;2591:67;;;2654:1;2651;2644:12;2591:67;2297:367;;;;;:::o;2669:773::-;2791:6;2799;2807;2815;2868:2;2856:9;2847:7;2843:23;2839:32;2836:52;;;2884:1;2881;2874:12;2836:52;2924:9;2911:23;2953:18;2994:2;2986:6;2983:14;2980:34;;;3010:1;3007;3000:12;2980:34;3049:70;3111:7;3102:6;3091:9;3087:22;3049:70;:::i;:::-;3138:8;;-1:-1:-1;3023:96:13;-1:-1:-1;3226:2:13;3211:18;;3198:32;;-1:-1:-1;3242:16:13;;;3239:36;;;3271:1;3268;3261:12;3239:36;;3310:72;3374:7;3363:8;3352:9;3348:24;3310:72;:::i;:::-;2669:773;;;;-1:-1:-1;3401:8:13;-1:-1:-1;;;;2669:773:13:o;3447:184::-;3499:77;3496:1;3489:88;3596:4;3593:1;3586:15;3620:4;3617:1;3610:15;3636:308;3742:66;3737:2;3731:4;3727:13;3723:86;3715:6;3711:99;3876:6;3864:10;3861:22;3840:18;3828:10;3825:34;3822:62;3819:88;;;3887:18;;:::i;:::-;3923:2;3916:22;-1:-1:-1;;3636:308:13:o;3949:183::-;4009:4;4042:18;4034:6;4031:30;4028:56;;;4064:18;;:::i;:::-;-1:-1:-1;4109:1:13;4105:14;4121:4;4101:25;;3949:183::o;4137:724::-;4191:5;4244:3;4237:4;4229:6;4225:17;4221:27;4211:55;;4262:1;4259;4252:12;4211:55;4298:6;4285:20;4324:4;4347:43;4387:2;4347:43;:::i;:::-;4419:2;4413:9;4431:31;4459:2;4451:6;4431:31;:::i;:::-;4497:18;;;4589:1;4585:10;;;;4573:23;;4569:32;;;4531:15;;;;-1:-1:-1;4613:15:13;;;4610:35;;;4641:1;4638;4631:12;4610:35;4677:2;4669:6;4665:15;4689:142;4705:6;4700:3;4697:15;4689:142;;;4771:17;;4759:30;;4809:12;;;;4722;;4689:142;;;-1:-1:-1;4849:6:13;4137:724;-1:-1:-1;;;;;;4137:724:13:o;4866:527::-;4930:5;4964:18;4956:6;4953:30;4950:56;;;4986:18;;:::i;:::-;5035:2;5029:9;5047:128;5169:4;5100:66;5095:2;5087:6;5083:15;5079:88;5075:99;5067:6;5047:128;:::i;:::-;5193:6;5184:15;;5223:6;5215;5208:22;5263:3;5254:6;5249:3;5245:16;5242:25;5239:45;;;5280:1;5277;5270:12;5239:45;5330:6;5325:3;5318:4;5310:6;5306:17;5293:44;5385:1;5378:4;5369:6;5361;5357:19;5353:30;5346:41;;4866:527;;;;;:::o;5398:220::-;5440:5;5493:3;5486:4;5478:6;5474:17;5470:27;5460:55;;5511:1;5508;5501:12;5460:55;5533:79;5608:3;5599:6;5586:20;5579:4;5571:6;5567:17;5533:79;:::i;5623:943::-;5777:6;5785;5793;5801;5809;5862:3;5850:9;5841:7;5837:23;5833:33;5830:53;;;5879:1;5876;5869:12;5830:53;5902:29;5921:9;5902:29;:::i;:::-;5892:39;;5950:38;5984:2;5973:9;5969:18;5950:38;:::i;:::-;5940:48;;6039:2;6028:9;6024:18;6011:32;6062:18;6103:2;6095:6;6092:14;6089:34;;;6119:1;6116;6109:12;6089:34;6142:61;6195:7;6186:6;6175:9;6171:22;6142:61;:::i;:::-;6132:71;;6256:2;6245:9;6241:18;6228:32;6212:48;;6285:2;6275:8;6272:16;6269:36;;;6301:1;6298;6291:12;6269:36;6324:63;6379:7;6368:8;6357:9;6353:24;6324:63;:::i;:::-;6314:73;;6440:3;6429:9;6425:19;6412:33;6396:49;;6470:2;6460:8;6457:16;6454:36;;;6486:1;6483;6476:12;6454:36;;6509:51;6552:7;6541:8;6530:9;6526:24;6509:51;:::i;:::-;6499:61;;;5623:943;;;;;;;;:::o;6571:160::-;6636:20;;6692:13;;6685:21;6675:32;;6665:60;;6721:1;6718;6711:12;6736:180;6792:6;6845:2;6833:9;6824:7;6820:23;6816:32;6813:52;;;6861:1;6858;6851:12;6813:52;6884:26;6900:9;6884:26;:::i;6921:1208::-;7039:6;7047;7100:2;7088:9;7079:7;7075:23;7071:32;7068:52;;;7116:1;7113;7106:12;7068:52;7156:9;7143:23;7185:18;7226:2;7218:6;7215:14;7212:34;;;7242:1;7239;7232:12;7212:34;7280:6;7269:9;7265:22;7255:32;;7325:7;7318:4;7314:2;7310:13;7306:27;7296:55;;7347:1;7344;7337:12;7296:55;7383:2;7370:16;7405:4;7428:43;7468:2;7428:43;:::i;:::-;7500:2;7494:9;7512:31;7540:2;7532:6;7512:31;:::i;:::-;7578:18;;;7666:1;7662:10;;;;7654:19;;7650:28;;;7612:15;;;;-1:-1:-1;7690:19:13;;;7687:39;;;7722:1;7719;7712:12;7687:39;7746:11;;;;7766:148;7782:6;7777:3;7774:15;7766:148;;;7848:23;7867:3;7848:23;:::i;:::-;7836:36;;7799:12;;;;7892;;;;7766:148;;;7933:6;-1:-1:-1;;7977:18:13;;7964:32;;-1:-1:-1;;8008:16:13;;;8005:36;;;8037:1;8034;8027:12;8005:36;;8060:63;8115:7;8104:8;8093:9;8089:24;8060:63;:::i;:::-;8050:73;;;6921:1208;;;;;:::o;8134:435::-;8187:3;8225:5;8219:12;8252:6;8247:3;8240:19;8278:4;8307:2;8302:3;8298:12;8291:19;;8344:2;8337:5;8333:14;8365:1;8375:169;8389:6;8386:1;8383:13;8375:169;;;8450:13;;8438:26;;8484:12;;;;8519:15;;;;8411:1;8404:9;8375:169;;;-1:-1:-1;8560:3:13;;8134:435;-1:-1:-1;;;;;8134:435:13:o;8574:261::-;8753:2;8742:9;8735:21;8716:4;8773:56;8825:2;8814:9;8810:18;8802:6;8773:56;:::i;8840:450::-;8909:6;8962:2;8950:9;8941:7;8937:23;8933:32;8930:52;;;8978:1;8975;8968:12;8930:52;9018:9;9005:23;9051:18;9043:6;9040:30;9037:50;;;9083:1;9080;9073:12;9037:50;9106:22;;9159:4;9151:13;;9147:27;-1:-1:-1;9137:55:13;;9188:1;9185;9178:12;9137:55;9211:73;9276:7;9271:2;9258:16;9253:2;9249;9245:11;9211:73;:::i;:::-;9201:83;8840:450;-1:-1:-1;;;;8840:450:13:o;9526:254::-;9591:6;9599;9652:2;9640:9;9631:7;9627:23;9623:32;9620:52;;;9668:1;9665;9658:12;9620:52;9691:29;9710:9;9691:29;:::i;:::-;9681:39;;9739:35;9770:2;9759:9;9755:18;9739:35;:::i;:::-;9729:45;;9526:254;;;;;:::o;9785:391::-;9871:6;9879;9887;9895;9948:3;9936:9;9927:7;9923:23;9919:33;9916:53;;;9965:1;9962;9955:12;9916:53;9988:29;10007:9;9988:29;:::i;:::-;9978:39;10064:2;10049:18;;10036:32;;-1:-1:-1;10115:2:13;10100:18;;10087:32;;10166:2;10151:18;10138:32;;-1:-1:-1;9785:391:13;-1:-1:-1;;;9785:391:13:o;10181:260::-;10249:6;10257;10310:2;10298:9;10289:7;10285:23;10281:32;10278:52;;;10326:1;10323;10316:12;10278:52;10349:29;10368:9;10349:29;:::i;:::-;10339:39;;10397:38;10431:2;10420:9;10416:18;10397:38;:::i;10446:606::-;10550:6;10558;10566;10574;10582;10635:3;10623:9;10614:7;10610:23;10606:33;10603:53;;;10652:1;10649;10642:12;10603:53;10675:29;10694:9;10675:29;:::i;:::-;10665:39;;10723:38;10757:2;10746:9;10742:18;10723:38;:::i;:::-;10713:48;;10808:2;10797:9;10793:18;10780:32;10770:42;;10859:2;10848:9;10844:18;10831:32;10821:42;;10914:3;10903:9;10899:19;10886:33;10942:18;10934:6;10931:30;10928:50;;;10974:1;10971;10964:12;10928:50;10997:49;11038:7;11029:6;11018:9;11014:22;10997:49;:::i;11057:186::-;11116:6;11169:2;11157:9;11148:7;11144:23;11140:32;11137:52;;;11185:1;11182;11175:12;11137:52;11208:29;11227:9;11208:29;:::i;11660:437::-;11739:1;11735:12;;;;11782;;;11803:61;;11857:4;11849:6;11845:17;11835:27;;11803:61;11910:2;11902:6;11899:14;11879:18;11876:38;11873:218;;;11947:77;11944:1;11937:88;12048:4;12045:1;12038:15;12076:4;12073:1;12066:15;11873:218;;11660:437;;;:::o;12228:185::-;12270:3;12308:5;12302:12;12323:52;12368:6;12363:3;12356:4;12349:5;12345:16;12323:52;:::i;:::-;12391:16;;;;;12228:185;-1:-1:-1;;12228:185:13:o;12418:1289::-;12594:3;12623:1;12656:6;12650:13;12686:3;12708:1;12736:9;12732:2;12728:18;12718:28;;12796:2;12785:9;12781:18;12818;12808:61;;12862:4;12854:6;12850:17;12840:27;;12808:61;12888:2;12936;12928:6;12925:14;12905:18;12902:38;12899:222;;;12975:77;12970:3;12963:90;13076:4;13073:1;13066:15;13106:4;13101:3;13094:17;12899:222;13137:18;13164:162;;;;13340:1;13335:320;;;;13130:525;;13164:162;13212:66;13201:9;13197:82;13192:3;13185:95;13309:6;13304:3;13300:16;13293:23;;13164:162;;13335:320;12175:1;12168:14;;;12212:4;12199:18;;13430:1;13444:165;13458:6;13455:1;13452:13;13444:165;;;13536:14;;13523:11;;;13516:35;13579:16;;;;13473:10;;13444:165;;;13448:3;;13638:6;13633:3;13629:16;13622:23;;13130:525;;;;;;;13671:30;13697:3;13689:6;13671:30;:::i;:::-;13664:37;12418:1289;-1:-1:-1;;;;;12418:1289:13:o;14073:184::-;14125:77;14122:1;14115:88;14222:4;14219:1;14212:15;14246:4;14243:1;14236:15;14262:184;14314:77;14311:1;14304:88;14411:4;14408:1;14401:15;14435:4;14432:1;14425:15;14451:195;14490:3;14521:66;14514:5;14511:77;14508:103;;;14591:18;;:::i;:::-;-1:-1:-1;14638:1:13;14627:13;;14451:195::o;16992:128::-;17032:3;17063:1;17059:6;17056:1;17053:13;17050:39;;;17069:18;;:::i;:::-;-1:-1:-1;17105:9:13;;16992:128::o;17785:274::-;17825:1;17851;17841:189;;17886:77;17883:1;17876:88;17987:4;17984:1;17977:15;18015:4;18012:1;18005:15;17841:189;-1:-1:-1;18044:9:13;;17785:274::o;18064:125::-;18104:4;18132:1;18129;18126:8;18123:34;;;18137:18;;:::i;:::-;-1:-1:-1;18174:9:13;;18064:125::o;18194:228::-;18234:7;18360:1;18292:66;18288:74;18285:1;18282:81;18277:1;18270:9;18263:17;18259:105;18256:131;;;18367:18;;:::i;:::-;-1:-1:-1;18407:9:13;;18194:228::o;18427:204::-;18465:3;18501:4;18498:1;18494:12;18533:4;18530:1;18526:12;18568:3;18562:4;18558:14;18553:3;18550:23;18547:49;;;18576:18;;:::i;:::-;18612:13;;18427:204;-1:-1:-1;;;18427:204:13:o;20264:465::-;20521:2;20510:9;20503:21;20484:4;20547:56;20599:2;20588:9;20584:18;20576:6;20547:56;:::i;:::-;20651:9;20643:6;20639:22;20634:2;20623:9;20619:18;20612:50;20679:44;20716:6;20708;20679:44;:::i;21543:595::-;21765:4;21794:42;21875:2;21867:6;21863:15;21852:9;21845:34;21927:2;21919:6;21915:15;21910:2;21899:9;21895:18;21888:43;;21967:6;21962:2;21951:9;21947:18;21940:34;22010:6;22005:2;21994:9;21990:18;21983:34;22054:3;22048;22037:9;22033:19;22026:32;22075:57;22127:3;22116:9;22112:19;22104:6;22075:57;:::i;:::-;22067:65;21543:595;-1:-1:-1;;;;;;;21543:595:13:o;22143:249::-;22212:6;22265:2;22253:9;22244:7;22240:23;22236:32;22233:52;;;22281:1;22278;22271:12;22233:52;22313:9;22307:16;22332:30;22356:5;22332:30;:::i;22397:179::-;22432:3;22474:1;22456:16;22453:23;22450:120;;;22520:1;22517;22514;22499:23;-1:-1:-1;22557:1:13;22551:8;22546:3;22542:18;22450:120;22397:179;:::o;22581:731::-;22620:3;22662:4;22644:16;22641:26;22638:39;;;22581:731;:::o;22638:39::-;22704:2;22698:9;22726:66;22847:2;22829:16;22825:25;22822:1;22816:4;22801:50;22880:4;22874:11;22904:16;22939:18;23010:2;23003:4;22995:6;22991:17;22988:25;22983:2;22975:6;22972:14;22969:45;22966:58;;;23017:5;;;;;22581:731;:::o;22966:58::-;23054:6;23048:4;23044:17;23033:28;;23090:3;23084:10;23117:2;23109:6;23106:14;23103:27;;;23123:5;;;;;;22581:731;:::o;23103:27::-;23207:2;23188:16;23182:4;23178:27;23174:36;23167:4;23158:6;23153:3;23149:16;23145:27;23142:69;23139:82;;;23214:5;;;;;;22581:731;:::o;23139:82::-;23230:57;23281:4;23272:6;23264;23260:19;23256:30;23250:4;23230:57;:::i;:::-;-1:-1:-1;23303:3:13;;22581:731;-1:-1:-1;;;;;22581:731:13:o;24147:861::-;24469:4;24498:42;24579:2;24571:6;24567:15;24556:9;24549:34;24631:2;24623:6;24619:15;24614:2;24603:9;24599:18;24592:43;;24671:3;24666:2;24655:9;24651:18;24644:31;24698:57;24750:3;24739:9;24735:19;24727:6;24698:57;:::i;:::-;24803:9;24795:6;24791:22;24786:2;24775:9;24771:18;24764:50;24837:44;24874:6;24866;24837:44;:::i;:::-;24823:58;;24930:9;24922:6;24918:22;24912:3;24901:9;24897:19;24890:51;24958:44;24995:6;24987;24958:44;:::i;:::-;24950:52;24147:861;-1:-1:-1;;;;;;;;24147:861:13:o

ipfs://524ae26a13bfd52d1b22c62afe3ef8544c7e0a79af150c14d5f191da4700f430