ERC-721
Overview
Max Total Supply
3,666 TIP
Holders
1
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
21 TIPLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
Tipz
Compiler Version
v0.8.1+commit.df193b15
Contract Source Code (Solidity Multiple files format)
//Contract based on https://docs.openzeppelin.com/contracts/3.x/erc721 // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./ERC721.sol"; import "./Counters.sol"; import "./Address.sol"; import "./Ownable.sol"; import "./SafeMath.sol"; import "./ECDSA.sol"; contract Tipz is ERC721, Ownable { using Strings for uint256; using SafeMath for uint256; using Counters for Counters.Counter; Counters.Counter private _tokenIdTracker; mapping (uint256 => string) private _tokenURIs; mapping (string => address) private _tokenIDs; address private constant KoalaMintDevAddress = 0xD17237307b93b104c50d6F83CF1e2dB99f7a348a; address private constant CreatorAddress = 0xD142f0a480B2f9E1934a02226e54Efc83C36467B; address private constant SignerAddress = 0x4AeA7b69ABb482e34BDd1D8C7A6B8dcA44F65775; string private baseURIextended; uint256 private min_price = 0 ether; uint256 private maxSupply = 3666; bool private pause = false; event KoalaMintMinted(uint256 indexed tokenId, address owner, address to, string tokenURI); event KoalaMintTransfered(address to, uint value); constructor(string memory _baseURIextended) ERC721("Tipz", "TIP"){ baseURIextended = _baseURIextended; } function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } function revealCollection(string memory _baseURIextended) public onlyOwner { require(keccak256(bytes(baseURIextended)) != keccak256(bytes(_baseURIextended)), "Collection already revealed"); setBaseURI(_baseURIextended); } function setBaseURI(string memory _baseURIextended) private onlyOwner { baseURIextended = _baseURIextended; } function totalSupply() external view returns (uint256) { return maxSupply; } function setMaxSupply(uint256 _maxSupply) public onlyOwner { maxSupply = _maxSupply; } function setMinPrice(uint256 _minPrice) public onlyOwner { min_price = _minPrice; } function getMinPrice() public view virtual returns (uint256) { return min_price; } function setPause(bool _pause) public onlyOwner { pause = _pause; } function getPause() public view virtual returns (bool) { return pause; } function _baseURI() internal view virtual override returns (string memory) { return baseURIextended; } function burn(uint256 tokenId) public onlyOwner { require(_exists(tokenId), "URI query for nonexistent token"); _tokenIDs[_tokenURIs[tokenId]] = address(0); _tokenURIs[tokenId] = ""; _burn(tokenId); } function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "URI query for nonexistent token"); string memory _tokenURI = _tokenURIs[tokenId]; string memory base = _baseURI(); return string(abi.encodePacked(base, _tokenURI)); } function signatureSignerMint(address _to, string[] memory _tokensURI, uint256 _timestamp, uint value, uint8 v, bytes32 r, bytes32 s) public view virtual returns (address){ return ECDSA.recover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", keccak256(abi.encode(_to, _tokensURI[0], _timestamp, value, _tokensURI.length)))), v, r, s); } function mint(address _to, string[] memory _tokensURI, uint256 _timestamp, uint8 v, bytes32 r, bytes32 s) public payable { require(!pause, "Sales paused"); require(msg.value >= min_price.mul(_tokensURI.length), "Value below price"); require(maxSupply >= _tokenIdTracker.current() + _tokensURI.length, "SoldOut"); require(_tokensURI.length > 0, "Minimum count"); address signerMint = signatureSignerMint(_to, _tokensURI, _timestamp, msg.value, v, r, s); require(signerMint == SignerAddress, "Not authorized to mint"); require(_timestamp >= block.timestamp - 300, "Out of time"); for (uint8 i = 0; i < _tokensURI.length; i++){ require(_tokenIDs[_tokensURI[i]] == address(0), "Token already minted"); _mintAnElement(_to, _tokensURI[i]); } uint256 _feeCreator = msg.value.mul(5).div(100); transfer(KoalaMintDevAddress, _feeCreator); transfer(CreatorAddress, msg.value - _feeCreator); } function _mintAnElement(address _to, string memory _tokenURI) private { uint256 _tokenId = _tokenIdTracker.current(); _tokenIdTracker.increment(); _tokenId = _tokenId + 1; _mint(_to, _tokenId); _setTokenURI(_tokenId, _tokenURI); _tokenIDs[_tokenURI] = _to; emit KoalaMintMinted(_tokenId, CreatorAddress, _to, _tokenURI); } function transfer(address to, uint256 value) private { (bool success, ) = to.call{value: value}(""); require(success, "Transfer failed."); emit KoalaMintTransfered(to, value); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @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 * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) pragma solidity ^0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.3) (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) { 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. /// @solidity memory-safe-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 { 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/introspection/ERC165.sol) 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 // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; import "./IERC721.sol"; import "./IERC721Receiver.sol"; import "./IERC721Metadata.sol"; import "./Address.sol"; import "./Context.sol"; import "./Strings.sol"; import "./ERC165.sol"; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _owners[tokenId]; require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory data ) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved"); _safeTransfer(from, to, tokenId, data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory data ) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _owners[tokenId] != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _balances[to] += 1; _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); _balances[owner] -= 1; delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _balances[from] -= 1; _balances[to] += 1; _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; import "./IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) 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() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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 { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol) pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @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); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_baseURIextended","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","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":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"string","name":"tokenURI","type":"string"}],"name":"KoalaMintMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"KoalaMintTransfered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPause","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"string[]","name":"_tokensURI","type":"string[]"},{"internalType":"uint256","name":"_timestamp","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURIextended","type":"string"}],"name":"revealCollection","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","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":"uint256","name":"_maxSupply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minPrice","type":"uint256"}],"name":"setMinPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_pause","type":"bool"}],"name":"setPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"string[]","name":"_tokensURI","type":"string[]"},{"internalType":"uint256","name":"_timestamp","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"signatureSignerMint","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000005b68747470733a2f2f6170692e6b6f616c616d696e742e636f6d2f636366626435383336623430643161613134333065613737336137663437653466633966653630633032313537636132366437386435623235646662303839302f0000000000
-----Decoded View---------------
Arg [0] : _baseURIextended (string): https://api.koalamint.com/ccfbd5836b40d1aa1430ea773a7f47e4fc9fe60c02157ca26d78d5b25dfb0890/
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 000000000000000000000000000000000000000000000000000000000000005b
Arg [2] : 68747470733a2f2f6170692e6b6f616c616d696e742e636f6d2f636366626435
Arg [3] : 3833366234306431616131343330656137373361376634376534666339666536
Arg [4] : 30633032313537636132366437386435623235646662303839302f0000000000
Deployed Bytecode Sourcemap
272:4852:13:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1505:300:5;;;;;;;;;;-1:-1:-1;1505:300:5;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2405:98;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3870:167::-;;;;;;;;;;-1:-1:-1;3870:167:5;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3402:407::-;;;;;;;;;;-1:-1:-1;3402:407:5;;;;;:::i;:::-;;:::i;:::-;;1852:88:13;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;4547:327:5:-;;;;;;;;;;-1:-1:-1;4547:327:5;;;;;:::i;:::-;;:::i;2340:84:13:-;;;;;;;;;;;;;:::i;3495:1018::-;;;;;;:::i;:::-;;:::i;4940:179:5:-;;;;;;;;;;-1:-1:-1;4940:179:5;;;;;:::i;:::-;;:::i;2554:236:13:-;;;;;;;;;;-1:-1:-1;2554:236:13;;;;;:::i;:::-;;:::i;1478:241::-;;;;;;;;;;-1:-1:-1;1478:241:13;;;;;:::i;:::-;;:::i;2050:95::-;;;;;;;;;;-1:-1:-1;2050:95:13;;;;;:::i;:::-;;:::i;2125:218:5:-;;;;;;;;;;-1:-1:-1;2125:218:5;;;;;:::i;:::-;;:::i;1946:98:13:-;;;;;;;;;;-1:-1:-1;1946:98:13;;;;;:::i;:::-;;:::i;1864:204:5:-;;;;;;;;;;-1:-1:-1;1864:204:5;;;;;:::i;:::-;;:::i;1824:101:10:-;;;;;;;;;;;;;:::i;1194:85::-;;;;;;;;;;;;;:::i;2567:102:5:-;;;;;;;;;;;;;:::i;4104:153::-;;;;;;;;;;-1:-1:-1;4104:153:5;;;;;:::i;:::-;;:::i;5185:315::-;;;;;;;;;;-1:-1:-1;5185:315:5;;;;;:::i;:::-;;:::i;2255:79:13:-;;;;;;;;;;-1:-1:-1;2255:79:13;;;;;:::i;:::-;;:::i;2800:321::-;;;;;;;;;;-1:-1:-1;2800:321:13;;;;;:::i;:::-;;:::i;2151:94::-;;;;;;;;;;;;;:::i;4323:162:5:-;;;;;;;;;;-1:-1:-1;4323:162:5;;;;;:::i;:::-;;:::i;2074:198:10:-;;;;;;;;;;-1:-1:-1;2074:198:10;;;;;:::i;:::-;;:::i;3127:362:13:-;;;;;;;;;;-1:-1:-1;3127:362:13;;;;;:::i;:::-;;:::i;1505:300:5:-;1607:4;-1:-1:-1;;;;;;1642:40:5;;-1:-1:-1;;;1642:40:5;;:104;;-1:-1:-1;;;;;;;1698:48:5;;-1:-1:-1;;;1698:48:5;1642:104;:156;;;;1762:36;1786:11;1762:23;:36::i;:::-;1623:175;;1505:300;;;;:::o;2405:98::-;2459:13;2491:5;2484:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2405:98;:::o;3870:167::-;3946:7;3965:23;3980:7;3965:14;:23::i;:::-;-1:-1:-1;4006:24:5;;;;:15;:24;;;;;;-1:-1:-1;;;;;4006:24:5;;3870:167::o;3402:407::-;3482:13;3498:23;3513:7;3498:14;:23::i;:::-;3482:39;;3545:5;-1:-1:-1;;;;;3539:11:5;:2;-1:-1:-1;;;;;3539:11:5;;;3531:57;;;;-1:-1:-1;;;3531:57:5;;;;;;;:::i;:::-;;;;;;;;;3636:5;-1:-1:-1;;;;;3620:21:5;:12;:10;:12::i;:::-;-1:-1:-1;;;;;3620:21:5;;:62;;;;3645:37;3662:5;3669:12;:10;:12::i;3645:37::-;3599:171;;;;-1:-1:-1;;;3599:171:5;;;;;;;:::i;:::-;3781:21;3790:2;3794:7;3781:8;:21::i;:::-;3402:407;;;:::o;1852:88:13:-;1924:9;;1852:88;:::o;4547:327:5:-;4736:41;4755:12;:10;:12::i;:::-;4769:7;4736:18;:41::i;:::-;4728:100;;;;-1:-1:-1;;;4728:100:5;;;;;;;:::i;:::-;4839:28;4849:4;4855:2;4859:7;4839:9;:28::i;2340:84:13:-;2412:5;;;;2340:84;:::o;3495:1018::-;3635:5;;;;3634:6;3626:31;;;;-1:-1:-1;;;3626:31:13;;;;;;;:::i;:::-;3702:17;;3688:9;;:32;;:13;:32::i;:::-;3675:9;:45;;3667:75;;;;-1:-1:-1;;;3667:75:13;;;;;;;:::i;:::-;3801:10;:17;3773:25;:15;:23;:25::i;:::-;:45;;;;:::i;:::-;3760:9;;:58;;3752:78;;;;-1:-1:-1;;;3752:78:13;;;;;;;:::i;:::-;3868:1;3848:10;:17;:21;3840:47;;;;-1:-1:-1;;;3840:47:13;;;;;;;:::i;:::-;3898:18;3919:68;3939:3;3944:10;3956;3968:9;3979:1;3982;3985;3919:19;:68::i;:::-;3898:89;-1:-1:-1;;;;;;4005:27:13;;796:42;4005:27;3997:62;;;;-1:-1:-1;;;3997:62:13;;;;;;;:::i;:::-;4092:21;4110:3;4092:15;:21;:::i;:::-;4078:10;:35;;4070:59;;;;-1:-1:-1;;;4070:59:13;;;;;;;:::i;:::-;4145:7;4140:189;4162:10;:17;4158:1;:21;;;4140:189;;;4243:1;-1:-1:-1;;;;;4207:38:13;:9;4217:10;4228:1;4217:13;;;;;;;;-1:-1:-1;;;4217:13:13;;;;;;;;;;;;;;;4207:24;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;4207:24:13;:38;4199:71;;;;-1:-1:-1;;;4199:71:13;;;;;;;:::i;:::-;4284:34;4299:3;4304:10;4315:1;4304:13;;;;;;;;-1:-1:-1;;;4304:13:13;;;;;;;;;;;;;;;4284:14;:34::i;:::-;4181:3;;;;:::i;:::-;;;;4140:189;;;-1:-1:-1;4347:19:13;4369:25;4390:3;4369:16;:9;4383:1;4369:13;:16::i;:::-;:20;;:25::i;:::-;4347:47;;4405:42;617;4435:11;4405:8;:42::i;:::-;4457:49;707:42;4482:23;4494:11;4482:9;:23;:::i;:::-;4457:8;:49::i;:::-;3495:1018;;;;;;;;:::o;4940:179:5:-;5073:39;5090:4;5096:2;5100:7;5073:39;;;;;;;;;;;;:16;:39::i;2554:236:13:-;1087:13:10;:11;:13::i;:::-;2620:16:13::1;2628:7;2620;:16::i;:::-;2612:60;;;;-1:-1:-1::0;;;2612:60:13::1;;;;;;;:::i;:::-;2723:1;2692:19:::0;;;:10:::1;:19;::::0;;;;;2682:30;;:9:::1;::::0;:30:::1;::::0;::::1;:::i;:::-;::::0;;;::::1;::::0;;::::1;::::0;;;;;;;;:43;;-1:-1:-1;;;;;;2682:43:13::1;-1:-1:-1::0;;;;;2682:43:13;;;::::1;::::0;;;::::1;::::0;;;2735:24;;::::1;::::0;;;-1:-1:-1;2735:24:13;;;:19;;;:10:::1;:19:::0;;;;;:24;;::::1;::::0;:19;:24;::::1;:::i;:::-;;2769:14;2775:7;2769:5;:14::i;:::-;2554:236:::0;:::o;1478:241::-;1087:13:10;:11;:13::i;:::-;1608:34:13;;::::1;::::0;::::1;::::0;1571:33:::1;::::0;::::1;::::0;1587:15:::1;::::0;1571:33:::1;:::i;:::-;;;;;;;;:71;;1563:111;;;;-1:-1:-1::0;;;1563:111:13::1;;;;;;;:::i;:::-;1684:28;1695:16;1684:10;:28::i;2050:95::-:0;1087:13:10;:11;:13::i;:::-;2117:9:13::1;:21:::0;2050:95::o;2125:218:5:-;2197:7;2232:16;;;:7;:16;;;;;;-1:-1:-1;;;;;2232:16:5;2266:19;2258:56;;;;-1:-1:-1;;;2258:56:5;;;;;;;:::i;1946:98:13:-;1087:13:10;:11;:13::i;:::-;2015:9:13::1;:22:::0;1946:98::o;1864:204:5:-;1936:7;-1:-1:-1;;;;;1963:19:5;;1955:73;;;;-1:-1:-1;;;1955:73:5;;;;;;;:::i;:::-;-1:-1:-1;;;;;;2045:16:5;;;;;:9;:16;;;;;;;1864:204::o;1824:101:10:-;1087:13;:11;:13::i;:::-;1888:30:::1;1915:1;1888:18;:30::i;:::-;1824:101::o:0;1194:85::-;1266:6;;-1:-1:-1;;;;;1266:6:10;1194:85;:::o;2567:102:5:-;2623:13;2655:7;2648:14;;;;;:::i;4104:153::-;4198:52;4217:12;:10;:12::i;:::-;4231:8;4241;4198:18;:52::i;:::-;4104:153;;:::o;5185:315::-;5353:41;5372:12;:10;:12::i;:::-;5386:7;5353:18;:41::i;:::-;5345:100;;;;-1:-1:-1;;;5345:100:5;;;;;;;:::i;:::-;5455:38;5469:4;5475:2;5479:7;5488:4;5455:13;:38::i;:::-;5185:315;;;;:::o;2255:79:13:-;1087:13:10;:11;:13::i;:::-;2313:5:13::1;:14:::0;;-1:-1:-1;;2313:14:13::1;::::0;::::1;;::::0;;;::::1;::::0;;2255:79::o;2800:321::-;2873:13;2906:16;2914:7;2906;:16::i;:::-;2898:60;;;;-1:-1:-1;;;2898:60:13;;;;;;;:::i;:::-;2969:23;2995:19;;;:10;:19;;;;;2969:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3024:18;3045:10;:8;:10::i;:::-;3024:31;;3097:4;3103:9;3080:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3066:48;;;;2800:321;;;:::o;2151:94::-;2229:9;;2151:94;:::o;4323:162:5:-;-1:-1:-1;;;;;4443:25:5;;;4420:4;4443:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;4323:162::o;2074:198:10:-;1087:13;:11;:13::i;:::-;-1:-1:-1;;;;;2162:22:10;::::1;2154:73;;;;-1:-1:-1::0;;;2154:73:10::1;;;;;;;:::i;:::-;2237:28;2256:8;2237:18;:28::i;3127:362:13:-:0;3289:7;3314:168;3412:3;3417:10;3428:1;3417:13;;;;;;-1:-1:-1;;;3417:13:13;;;;;;;;;;;;;;;3432:10;3444:5;3451:10;:17;3401:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;3391:79;;;;;;3338:133;;;;;;;;:::i;:::-;;;;;;;;;;;;;3328:144;;;;;;3474:1;3477;3480;3314:13;:168::i;:::-;3307:175;3127:362;-1:-1:-1;;;;;;;;3127:362:13:o;829:155:4:-;-1:-1:-1;;;;;;937:40:4;;-1:-1:-1;;;937:40:4;829:155;;;:::o;11592:133:5:-;11673:16;11681:7;11673;:16::i;:::-;11665:53;;;;-1:-1:-1;;;11665:53:5;;;;;;;:::i;640:96:1:-;719:10;640:96;:::o;10894:171:5:-;10968:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;10968:29:5;-1:-1:-1;;;;;10968:29:5;;;;;;;;:24;;11021:23;10968:24;11021:14;:23::i;:::-;-1:-1:-1;;;;;11012:46:5;;;;;;;;;;;10894:171;;:::o;7252:261::-;7345:4;7361:13;7377:23;7392:7;7377:14;:23::i;:::-;7361:39;;7429:5;-1:-1:-1;;;;;7418:16:5;:7;-1:-1:-1;;;;;7418:16:5;;:52;;;;7438:32;7455:5;7462:7;7438:16;:32::i;:::-;7418:87;;;;7498:7;-1:-1:-1;;;;;7474:31:5;:20;7486:7;7474:11;:20::i;:::-;-1:-1:-1;;;;;7474:31:5;;7418:87;7410:96;7252:261;-1:-1:-1;;;;7252:261:5:o;10177:605::-;10331:4;-1:-1:-1;;;;;10304:31:5;:23;10319:7;10304:14;:23::i;:::-;-1:-1:-1;;;;;10304:31:5;;10296:81;;;;-1:-1:-1;;;10296:81:5;;;;;;;:::i;:::-;-1:-1:-1;;;;;10395:16:5;;10387:65;;;;-1:-1:-1;;;10387:65:5;;;;;;;:::i;:::-;10463:39;10484:4;10490:2;10494:7;10463:20;:39::i;:::-;10564:29;10581:1;10585:7;10564:8;:29::i;:::-;-1:-1:-1;;;;;10604:15:5;;;;;;:9;:15;;;;;:20;;10623:1;;10604:15;:20;;10623:1;;10604:20;:::i;:::-;;;;-1:-1:-1;;;;;;;10634:13:5;;;;;;:9;:13;;;;;:18;;10651:1;;10634:13;:18;;10651:1;;10634:18;:::i;:::-;;;;-1:-1:-1;;10662:16:5;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;10662:21:5;-1:-1:-1;;;;;10662:21:5;;;;;;;;;10699:27;;10662:16;;10699:27;;;;;;;10737:38;10757:4;10763:2;10767:7;10737:19;:38::i;3465:96:11:-;3523:7;3549:5;3553:1;3549;:5;:::i;:::-;3542:12;3465:96;-1:-1:-1;;;3465:96:11:o;827:112:2:-;918:14;;827:112::o;4519:392:13:-;4599:16;4618:25;:15;:23;:25::i;:::-;4599:44;;4662:27;:15;:25;:27::i;:::-;4710:12;:8;4721:1;4710:12;:::i;:::-;4699:23;;4732:20;4738:3;4743:8;4732:5;:20::i;:::-;4762:33;4775:8;4785:9;4762:12;:33::i;:::-;4828:3;4805:9;4815;4805:20;;;;;;:::i;:::-;;;;;;;;;;;;;;:26;;;;;-1:-1:-1;;;;;4805:26:13;;;;;-1:-1:-1;;;;;4805:26:13;;;;;;4863:8;4847:57;707:42;4889:3;4894:9;4847:57;;;;;;;;:::i;:::-;;;;;;;;4519:392;;;:::o;3850:96:11:-;3908:7;3934:5;3938:1;3934;:5;:::i;4917:205:13:-;4981:12;4999:2;-1:-1:-1;;;;;4999:7:13;5014:5;4999:25;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4980:44;;;5042:7;5034:36;;;;-1:-1:-1;;;5034:36:13;;;;;;;:::i;:::-;5085:30;5105:2;5109:5;5085:30;;;;;;;:::i;:::-;;;;;;;;4917:205;;;:::o;1352:130:10:-;1426:12;:10;:12::i;:::-;-1:-1:-1;;;;;1415:23:10;:7;:5;:7::i;:::-;-1:-1:-1;;;;;1415:23:10;;1407:68;;;;-1:-1:-1;;;1407:68:10;;;;;;;:::i;6969:125:5:-;7034:4;7057:16;;;:7;:16;;;;;;-1:-1:-1;;;;;7057:16:5;:30;;;6969:125::o;9447:406::-;9506:13;9522:23;9537:7;9522:14;:23::i;:::-;9506:39;;9556:48;9577:5;9592:1;9596:7;9556:20;:48::i;:::-;9642:29;9659:1;9663:7;9642:8;:29::i;:::-;-1:-1:-1;;;;;9682:16:5;;;;;;:9;:16;;;;;:21;;9702:1;;9682:16;:21;;9702:1;;9682:21;:::i;:::-;;;;-1:-1:-1;;9720:16:5;;;;:7;:16;;;;;;9713:23;;-1:-1:-1;;;;;;9713:23:5;;;9752:36;9728:7;;9720:16;-1:-1:-1;;;;;9752:36:5;;;;;9720:16;;9752:36;9799:47;9819:5;9834:1;9838:7;9799:19;:47::i;1725:121:13:-;1087:13:10;:11;:13::i;:::-;1805:34:13;;::::1;::::0;:15:::1;::::0;:34:::1;::::0;::::1;::::0;::::1;:::i;2426:187:10:-:0;2518:6;;;-1:-1:-1;;;;;2534:17:10;;;-1:-1:-1;;;;;;2534:17:10;;;;;;;2566:40;;2518:6;;;2534:17;2518:6;;2566:40;;2499:16;;2566:40;2426:187;;:::o;11201:307:5:-;11351:8;-1:-1:-1;;;;;11342:17:5;:5;-1:-1:-1;;;;;11342:17:5;;;11334:55;;;;-1:-1:-1;;;11334:55:5;;;;;;;:::i;:::-;-1:-1:-1;;;;;11399:25:5;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;:46;;-1:-1:-1;;11399:46:5;;;;;;;11460:41;;;;;11399:46;;11460:41;:::i;:::-;;;;;;;;11201:307;;;:::o;6361:305::-;6511:28;6521:4;6527:2;6531:7;6511:9;:28::i;:::-;6557:47;6580:4;6586:2;6590:7;6599:4;6557:22;:47::i;:::-;6549:110;;;;-1:-1:-1;;;6549:110:5;;;;;;;:::i;2434:114:13:-;2494:13;2526:15;2519:22;;;;;:::i;6902:270:3:-;7025:7;7045:17;7064:18;7086:25;7097:4;7103:1;7106;7109;7086:10;:25::i;:::-;7044:67;;;;7121:18;7133:5;7121:11;:18::i;:::-;-1:-1:-1;7156:9:3;6902:270;-1:-1:-1;;;;;6902:270:3:o;945:123:2:-;1032:19;;1050:1;1032:19;;;945:123::o;8803:427:5:-;-1:-1:-1;;;;;8882:16:5;;8874:61;;;;-1:-1:-1;;;8874:61:5;;;;;;;:::i;:::-;8954:16;8962:7;8954;:16::i;:::-;8953:17;8945:58;;;;-1:-1:-1;;;8945:58:5;;;;;;;:::i;:::-;9014:45;9043:1;9047:2;9051:7;9014:20;:45::i;:::-;-1:-1:-1;;;;;9070:13:5;;;;;;:9;:13;;;;;:18;;9087:1;;9070:13;:18;;9087:1;;9070:18;:::i;:::-;;;;-1:-1:-1;;9098:16:5;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;9098:21:5;-1:-1:-1;;;;;9098:21:5;;;;;;;;9135:33;;9098:16;;;9135:33;;9098:16;;9135:33;9179:44;9207:1;9211:2;9215:7;9179:19;:44::i;1272:196:13:-;1371:16;1379:7;1371;:16::i;:::-;1363:57;;;;-1:-1:-1;;;1363:57:13;;;;;;;:::i;:::-;1430:19;;;;:10;:19;;;;;;;;:31;;;;;;;;:::i;12277:831:5:-;12426:4;12446:15;:2;-1:-1:-1;;;;;12446:13:5;;:15::i;:::-;12442:660;;;12497:2;-1:-1:-1;;;;;12481:36:5;;12518:12;:10;:12::i;:::-;12532:4;12538:7;12547:4;12481:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12481:71:5;;;;;;;;-1:-1:-1;;12481:71:5;;;;;;;;;;;;:::i;:::-;;;12477:573;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12719:13:5;;12715:321;;12761:60;;-1:-1:-1;;;12761:60:5;;;;;;;:::i;12715:321::-;12988:6;12982:13;12973:6;12969:2;12965:15;12958:38;12477:573;-1:-1:-1;;;;;;12602:51:5;-1:-1:-1;;;12602:51:5;;-1:-1:-1;12595:58:5;;12442:660;-1:-1:-1;13087:4:5;13080:11;;5166:1603:3;5292:7;;6216:66;6203:79;;6199:161;;;-1:-1:-1;6314:1:3;;-1:-1:-1;6318:30:3;6298:51;;6199:161;6373:1;:7;;6378:2;6373:7;;:18;;;;;6384:1;:7;;6389:2;6384:7;;6373:18;6369:100;;;-1:-1:-1;6423:1:3;;-1:-1:-1;6427:30:3;6407:51;;6369:100;6563:14;6580:24;6590:4;6596:1;6599;6602;6580:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6580:24:3;;-1:-1:-1;;6580:24:3;;;-1:-1:-1;;;;;;;6618:20:3;;6614:101;;6670:1;6674:29;6654:50;;;;;;;6614:101;6733:6;-1:-1:-1;6741:20:3;;-1:-1:-1;5166:1603:3;;;;;;;;:::o;547:631::-;624:20;615:5;:29;;;;;;-1:-1:-1;;;615:29:3;;;;;;;;;;611:561;;;660:7;;611:561;720:29;711:5;:38;;;;;;-1:-1:-1;;;711:38:3;;;;;;;;;;707:465;;;765:34;;-1:-1:-1;;;765:34:3;;;;;;;:::i;707:465::-;829:35;820:5;:44;;;;;;-1:-1:-1;;;820:44:3;;;;;;;;;;816:356;;;880:41;;-1:-1:-1;;;880:41:3;;;;;;;:::i;816:356::-;951:30;942:5;:39;;;;;;-1:-1:-1;;;942:39:3;;;;;;;;;;938:234;;;997:44;;-1:-1:-1;;;997:44:3;;;;;;;:::i;938:234::-;1071:30;1062:5;:39;;;;;;-1:-1:-1;;;1062:39:3;;;;;;;;;;1058:114;;;1117:44;;-1:-1:-1;;;1117:44:3;;;;;;;:::i;1175:320:0:-;-1:-1:-1;;;;;1465:19:0;;:23;;;1175:320::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:408:14;;114:18;106:6;103:30;100:2;;;136:18;;:::i;:::-;174:57;219:2;198:15;;-1:-1:-1;;194:29:14;225:4;190:40;174:57;:::i;:::-;165:66;;254:6;247:5;240:21;294:3;285:6;280:3;276:16;273:25;270:2;;;311:1;308;301:12;270:2;360:6;355:3;348:4;341:5;337:16;324:43;414:1;407:4;398:6;391:5;387:18;383:29;376:40;90:332;;;;;:::o;427:175::-;497:20;;-1:-1:-1;;;;;546:31:14;;536:42;;526:2;;592:1;589;582:12;607:706;;719:3;712:4;704:6;700:17;696:27;686:2;;741:5;734;727:20;686:2;781:6;768:20;807:4;830:18;826:2;823:26;820:2;;;852:18;;:::i;:::-;892:37;925:2;920;916;912:11;908:20;892:37;:::i;:::-;963:15;;;994:12;;;;1026:15;;;1059:5;1073:211;1087:2;1084:1;1081:9;1073:211;;;1144:65;1205:3;1200:2;1193:3;1180:17;1172:6;1168:30;1164:39;1144:65;:::i;:::-;1132:78;;1230:12;;;;1262;;;;1105:1;1098:9;1073:211;;;-1:-1:-1;1302:5:14;;676:637;-1:-1:-1;;;;;;;676:637:14:o;1318:162::-;1385:20;;1441:13;;1434:21;1424:32;;1414:2;;1470:1;1467;1460:12;1485:233;;1583:3;1576:4;1568:6;1564:17;1560:27;1550:2;;1605:5;1598;1591:20;1550:2;1631:81;1708:3;1699:6;1686:20;1679:4;1671:6;1667:17;1631:81;:::i;1723:158::-;1791:20;;1851:4;1840:16;;1830:27;;1820:2;;1871:1;1868;1861:12;1886:198;;1998:2;1986:9;1977:7;1973:23;1969:32;1966:2;;;2019:6;2011;2004:22;1966:2;2047:31;2068:9;2047:31;:::i;2089:274::-;;;2218:2;2206:9;2197:7;2193:23;2189:32;2186:2;;;2239:6;2231;2224:22;2186:2;2267:31;2288:9;2267:31;:::i;:::-;2257:41;;2317:40;2353:2;2342:9;2338:18;2317:40;:::i;:::-;2307:50;;2176:187;;;;;:::o;2368:342::-;;;;2514:2;2502:9;2493:7;2489:23;2485:32;2482:2;;;2535:6;2527;2520:22;2482:2;2563:31;2584:9;2563:31;:::i;:::-;2553:41;;2613:40;2649:2;2638:9;2634:18;2613:40;:::i;:::-;2603:50;;2700:2;2689:9;2685:18;2672:32;2662:42;;2472:238;;;;;:::o;2715:702::-;;;;;2887:3;2875:9;2866:7;2862:23;2858:33;2855:2;;;2909:6;2901;2894:22;2855:2;2937:31;2958:9;2937:31;:::i;:::-;2927:41;;2987:40;3023:2;3012:9;3008:18;2987:40;:::i;:::-;2977:50;;3074:2;3063:9;3059:18;3046:32;3036:42;;3129:2;3118:9;3114:18;3101:32;3156:18;3148:6;3145:30;3142:2;;;3193:6;3185;3178:22;3142:2;3221:22;;3274:4;3266:13;;3262:27;-1:-1:-1;3252:2:14;;3308:6;3300;3293:22;3252:2;3336:75;3403:7;3398:2;3385:16;3380:2;3376;3372:11;3336:75;:::i;:::-;3326:85;;;2845:572;;;;;;;:::o;3422:807::-;;;;;;;;3669:3;3657:9;3648:7;3644:23;3640:33;3637:2;;;3691:6;3683;3676:22;3637:2;3719:31;3740:9;3719:31;:::i;:::-;3709:41;;3801:2;3790:9;3786:18;3773:32;3828:18;3820:6;3817:30;3814:2;;;3865:6;3857;3850:22;3814:2;3893:66;3951:7;3942:6;3931:9;3927:22;3893:66;:::i;:::-;3883:76;;;4006:2;3995:9;3991:18;3978:32;3968:42;;4057:2;4046:9;4042:18;4029:32;4019:42;;4080:39;4114:3;4103:9;4099:19;4080:39;:::i;:::-;4070:49;;4166:3;4155:9;4151:19;4138:33;4128:43;;4218:3;4207:9;4203:19;4190:33;4180:43;;3627:602;;;;;;;;;;:::o;4234:738::-;;;;;;;4464:3;4452:9;4443:7;4439:23;4435:33;4432:2;;;4486:6;4478;4471:22;4432:2;4514:31;4535:9;4514:31;:::i;:::-;4504:41;;4596:2;4585:9;4581:18;4568:32;4623:18;4615:6;4612:30;4609:2;;;4660:6;4652;4645:22;4609:2;4688:66;4746:7;4737:6;4726:9;4722:22;4688:66;:::i;:::-;4678:76;;;4801:2;4790:9;4786:18;4773:32;4763:42;;4824:38;4858:2;4847:9;4843:18;4824:38;:::i;:::-;4814:48;;4909:3;4898:9;4894:19;4881:33;4871:43;;4961:3;4950:9;4946:19;4933:33;4923:43;;4422:550;;;;;;;;:::o;4977:268::-;;;5103:2;5091:9;5082:7;5078:23;5074:32;5071:2;;;5124:6;5116;5109:22;5071:2;5152:31;5173:9;5152:31;:::i;:::-;5142:41;;5202:37;5235:2;5224:9;5220:18;5202:37;:::i;5250:266::-;;;5379:2;5367:9;5358:7;5354:23;5350:32;5347:2;;;5400:6;5392;5385:22;5347:2;5428:31;5449:9;5428:31;:::i;:::-;5418:41;5506:2;5491:18;;;;5478:32;;-1:-1:-1;;;5337:179:14:o;5521:192::-;;5630:2;5618:9;5609:7;5605:23;5601:32;5598:2;;;5651:6;5643;5636:22;5598:2;5679:28;5697:9;5679:28;:::i;5718:257::-;;5829:2;5817:9;5808:7;5804:23;5800:32;5797:2;;;5850:6;5842;5835:22;5797:2;5894:9;5881:23;5913:32;5939:5;5913:32;:::i;5980:261::-;;6102:2;6090:9;6081:7;6077:23;6073:32;6070:2;;;6123:6;6115;6108:22;6070:2;6160:9;6154:16;6179:32;6205:5;6179:32;:::i;6246:344::-;;6368:2;6356:9;6347:7;6343:23;6339:32;6336:2;;;6389:6;6381;6374:22;6336:2;6434:9;6421:23;6467:18;6459:6;6456:30;6453:2;;;6504:6;6496;6489:22;6453:2;6532:52;6576:7;6567:6;6556:9;6552:22;6532:52;:::i;6595:190::-;;6707:2;6695:9;6686:7;6682:23;6678:32;6675:2;;;6728:6;6720;6713:22;6675:2;-1:-1:-1;6756:23:14;;6665:120;-1:-1:-1;6665:120:14:o;6790:259::-;;6871:5;6865:12;6898:6;6893:3;6886:19;6914:63;6970:6;6963:4;6958:3;6954:14;6947:4;6940:5;6936:16;6914:63;:::i;:::-;7031:2;7010:15;-1:-1:-1;;7006:29:14;6997:39;;;;7038:4;6993:50;;6841:208;-1:-1:-1;;6841:208:14:o;7054:992::-;7144:12;;7054:992;;7216:1;7201:17;;7237:1;7273:18;;;;7300:2;;7354:4;7346:6;7342:17;7332:27;;7300:2;7380;7428;7420:6;7417:14;7397:18;7394:38;7391:2;;;-1:-1:-1;;;7455:33:14;;7511:4;7508:1;7501:15;7541:4;7462:3;7529:17;7391:2;7572:18;7599:104;;;;7717:1;7712:328;;;;7565:475;;7599:104;-1:-1:-1;;7632:24:14;;7620:37;;7677:16;;;;-1:-1:-1;7599:104:14;;7712:328;7743:5;7740:1;7733:16;7790:2;7787:1;7777:16;7815:1;7829:165;7843:6;7840:1;7837:13;7829:165;;;7921:14;;7908:11;;;7901:35;7964:16;;;;7858:10;;7829:165;;;7833:3;;8023:6;8018:3;8014:16;8007:23;;7565:475;;;;;;;7117:929;;;;:::o;8051:204::-;;8206:43;8245:3;8237:6;8206:43;:::i;8260:276::-;;8429:6;8423:13;8445:53;8491:6;8486:3;8479:4;8471:6;8467:17;8445:53;:::i;:::-;8514:16;;;;;8399:137;-1:-1:-1;;8399:137:14:o;8541:470::-;;8758:6;8752:13;8774:53;8820:6;8815:3;8808:4;8800:6;8796:17;8774:53;:::i;:::-;8890:13;;8849:16;;;;8912:57;8890:13;8849:16;8946:4;8934:17;;8912:57;:::i;:::-;8985:20;;8728:283;-1:-1:-1;;;;8728:283:14:o;9223:380::-;9465:66;9453:79;;9557:2;9548:12;;9541:28;;;;9594:2;9585:12;;9443:160::o;9608:205::-;9808:3;9799:14::o;9818:203::-;-1:-1:-1;;;;;9982:32:14;;;;9964:51;;9952:2;9937:18;;9919:102::o;10026:419::-;-1:-1:-1;;;;;10269:15:14;;;10251:34;;10321:15;;10316:2;10301:18;;10294:43;10373:2;10368;10353:18;;10346:30;;;10026:419;;10393:46;;10420:18;;10412:6;10393:46;:::i;:::-;10385:54;10203:242;-1:-1:-1;;;;;10203:242:14:o;10450:490::-;-1:-1:-1;;;;;10719:15:14;;;10701:34;;10771:15;;10766:2;10751:18;;10744:43;10818:2;10803:18;;10796:34;;;10866:3;10861:2;10846:18;;10839:31;;;10450:490;;10887:47;;10914:19;;10906:6;10887:47;:::i;:::-;10879:55;10653:287;-1:-1:-1;;;;;;10653:287:14:o;10945:534::-;-1:-1:-1;;;;;11206:32:14;;11188:51;;11226:3;11270:2;11255:18;;11248:31;;;10945:534;;11296:47;;11323:19;;11315:6;11296:47;:::i;:::-;11374:2;11359:18;;11352:34;;;;-1:-1:-1;11417:2:14;11402:18;;11395:34;;;;11460:3;11445:19;;;11438:35;11288:55;11178:301;-1:-1:-1;;11178:301:14:o;11484:274::-;-1:-1:-1;;;;;11676:32:14;;;;11658:51;;11740:2;11725:18;;11718:34;11646:2;11631:18;;11613:145::o;11763:187::-;11928:14;;11921:22;11903:41;;11891:2;11876:18;;11858:92::o;11955:398::-;12182:25;;;12255:4;12243:17;;;;12238:2;12223:18;;12216:45;12292:2;12277:18;;12270:34;12335:2;12320:18;;12313:34;12169:3;12154:19;;12136:217::o;12358:221::-;;12507:2;12496:9;12489:21;12527:46;12569:2;12558:9;12554:18;12546:6;12527:46;:::i;12584:348::-;12786:2;12768:21;;;12825:2;12805:18;;;12798:30;12864:26;12859:2;12844:18;;12837:54;12923:2;12908:18;;12758:174::o;12937:330::-;13139:2;13121:21;;;13178:1;13158:18;;;13151:29;-1:-1:-1;;;13211:2:14;13196:18;;13189:37;13258:2;13243:18;;13111:156::o;13272:355::-;13474:2;13456:21;;;13513:2;13493:18;;;13486:30;13552:33;13547:2;13532:18;;13525:61;13618:2;13603:18;;13446:181::o;13632:344::-;13834:2;13816:21;;;13873:2;13853:18;;;13846:30;-1:-1:-1;;;13907:2:14;13892:18;;13885:50;13967:2;13952:18;;13806:170::o;13981:355::-;14183:2;14165:21;;;14222:2;14202:18;;;14195:30;14261:33;14256:2;14241:18;;14234:61;14327:2;14312:18;;14155:181::o;14341:414::-;14543:2;14525:21;;;14582:2;14562:18;;;14555:30;14621:34;14616:2;14601:18;;14594:62;-1:-1:-1;;;14687:2:14;14672:18;;14665:48;14745:3;14730:19;;14515:240::o;14760:402::-;14962:2;14944:21;;;15001:2;14981:18;;;14974:30;15040:34;15035:2;15020:18;;15013:62;-1:-1:-1;;;15106:2:14;15091:18;;15084:36;15152:3;15137:19;;14934:228::o;15167:401::-;15369:2;15351:21;;;15408:2;15388:18;;;15381:30;15447:34;15442:2;15427:18;;15420:62;-1:-1:-1;;;15513:2:14;15498:18;;15491:35;15558:3;15543:19;;15341:227::o;15573:352::-;15775:2;15757:21;;;15814:2;15794:18;;;15787:30;15853;15848:2;15833:18;;15826:58;15916:2;15901:18;;15747:178::o;15930:400::-;16132:2;16114:21;;;16171:2;16151:18;;;16144:30;16210:34;16205:2;16190:18;;16183:62;-1:-1:-1;;;16276:2:14;16261:18;;16254:34;16320:3;16305:19;;16104:226::o;16335:349::-;16537:2;16519:21;;;16576:2;16556:18;;;16549:30;16615:27;16610:2;16595:18;;16588:55;16675:2;16660:18;;16509:175::o;16689:398::-;16891:2;16873:21;;;16930:2;16910:18;;;16903:30;16969:34;16964:2;16949:18;;16942:62;-1:-1:-1;;;17035:2:14;17020:18;;17013:32;17077:3;17062:19;;16863:224::o;17092:346::-;17294:2;17276:21;;;17333:2;17313:18;;;17306:30;-1:-1:-1;;;17367:2:14;17352:18;;17345:52;17429:2;17414:18;;17266:172::o;17443:405::-;17645:2;17627:21;;;17684:2;17664:18;;;17657:30;17723:34;17718:2;17703:18;;17696:62;-1:-1:-1;;;17789:2:14;17774:18;;17767:39;17838:3;17823:19;;17617:231::o;17853:398::-;18055:2;18037:21;;;18094:2;18074:18;;;18067:30;18133:34;18128:2;18113:18;;18106:62;-1:-1:-1;;;18199:2:14;18184:18;;18177:32;18241:3;18226:19;;18027:224::o;18256:426::-;18458:2;18440:21;;;18497:2;18477:18;;;18470:30;18536:34;18531:2;18516:18;;18509:62;18607:32;18602:2;18587:18;;18580:60;18672:3;18657:19;;18430:252::o;18687:356::-;18889:2;18871:21;;;18908:18;;;18901:30;18967:34;18962:2;18947:18;;18940:62;19034:2;19019:18;;18861:182::o;19048:356::-;19250:2;19232:21;;;19269:18;;;19262:30;19328:34;19323:2;19308:18;;19301:62;19395:2;19380:18;;19222:182::o;19409:341::-;19611:2;19593:21;;;19650:2;19630:18;;;19623:30;-1:-1:-1;;;19684:2:14;19669:18;;19662:47;19741:2;19726:18;;19583:167::o;19755:352::-;19957:2;19939:21;;;19996:2;19976:18;;;19969:30;20035;20030:2;20015:18;;20008:58;20098:2;20083:18;;19929:178::o;20112:348::-;20314:2;20296:21;;;20353:2;20333:18;;;20326:30;20392:26;20387:2;20372:18;;20365:54;20451:2;20436:18;;20286:174::o;20465:397::-;20667:2;20649:21;;;20706:2;20686:18;;;20679:30;20745:34;20740:2;20725:18;;20718:62;-1:-1:-1;;;20811:2:14;20796:18;;20789:31;20852:3;20837:19;;20639:223::o;20867:351::-;21069:2;21051:21;;;21108:2;21088:18;;;21081:30;21147:29;21142:2;21127:18;;21120:57;21209:2;21194:18;;21041:177::o;21223:335::-;21425:2;21407:21;;;21464:2;21444:18;;;21437:30;-1:-1:-1;;;21498:2:14;21483:18;;21476:41;21549:2;21534:18;;21397:161::o;21563:340::-;21765:2;21747:21;;;21804:2;21784:18;;;21777:30;-1:-1:-1;;;21838:2:14;21823:18;;21816:46;21894:2;21879:18;;21737:166::o;21908:336::-;22110:2;22092:21;;;22149:2;22129:18;;;22122:30;-1:-1:-1;;;22183:2:14;22168:18;;22161:42;22235:2;22220:18;;22082:162::o;22249:410::-;22451:2;22433:21;;;22490:2;22470:18;;;22463:30;22529:34;22524:2;22509:18;;22502:62;-1:-1:-1;;;22595:2:14;22580:18;;22573:44;22649:3;22634:19;;22423:236::o;22664:337::-;22866:2;22848:21;;;22905:2;22885:18;;;22878:30;-1:-1:-1;;;22939:2:14;22924:18;;22917:43;22992:2;22977:18;;22838:163::o;23006:177::-;23152:25;;;23140:2;23125:18;;23107:76::o;23188:275::-;23259:2;23253:9;23324:2;23305:13;;-1:-1:-1;;23301:27:14;23289:40;;23359:18;23344:34;;23380:22;;;23341:62;23338:2;;;23406:18;;:::i;:::-;23442:2;23435:22;23233:230;;-1:-1:-1;23233:230:14:o;23468:128::-;;23539:1;23535:6;23532:1;23529:13;23526:2;;;23545:18;;:::i;:::-;-1:-1:-1;23581:9:14;;23516:80::o;23601:217::-;;23667:1;23657:2;;-1:-1:-1;;;23692:31:14;;23746:4;23743:1;23736:15;23774:4;23699:1;23764:15;23657:2;-1:-1:-1;23803:9:14;;23647:171::o;23823:168::-;;23929:1;23925;23921:6;23917:14;23914:1;23911:21;23906:1;23899:9;23892:17;23888:45;23885:2;;;23936:18;;:::i;:::-;-1:-1:-1;23976:9:14;;23875:116::o;23996:125::-;;24064:1;24061;24058:8;24055:2;;;24069:18;;:::i;:::-;-1:-1:-1;24106:9:14;;24045:76::o;24126:258::-;24198:1;24208:113;24222:6;24219:1;24216:13;24208:113;;;24298:11;;;24292:18;24279:11;;;24272:39;24244:2;24237:10;24208:113;;;24339:6;24336:1;24333:13;24330:2;;;-1:-1:-1;;24374:1:14;24356:16;;24349:27;24179:205::o;24389:380::-;24474:1;24464:12;;24521:1;24511:12;;;24532:2;;24586:4;24578:6;24574:17;24564:27;;24532:2;24639;24631:6;24628:14;24608:18;24605:38;24602:2;;;24685:10;24680:3;24676:20;24673:1;24666:31;24720:4;24717:1;24710:15;24748:4;24745:1;24738:15;24602:2;;24444:325;;;:::o;24774:175::-;;24855:4;24848:5;24844:16;24884:4;24875:7;24872:17;24869:2;;;24892:18;;:::i;:::-;24941:1;24928:15;;24819:130;-1:-1:-1;;24819:130:14:o;24954:127::-;25015:10;25010:3;25006:20;25003:1;24996:31;25046:4;25043:1;25036:15;25070:4;25067:1;25060:15;25086:127;25147:10;25142:3;25138:20;25135:1;25128:31;25178:4;25175:1;25168:15;25202:4;25199:1;25192:15;25218:133;-1:-1:-1;;;;;;25294:32:14;;25284:43;;25274:2;;25341:1;25338;25331:12
Swarm Source
ipfs://c7fef7bcf140e13f9ec461122f412ff9c568f622b554f1cfc3a4ded4afb218aa
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.