ERC-721
NFT
Overview
Max Total Supply
1,500 EVA
Holders
160
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
56 EVALoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
EvaTribe
Compiler Version
v0.8.7+commit.e28d00a7
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-10-07 */ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; /* * EVA Tribe by MANDOX * www.twitter.com/officialmandox * www.mandoxglobal.com * www.mandoxmint.com * t.me/officialmandox */ // File: solidity-bits/contracts/Popcount.sol /** _____ ___ ___ __ ____ _ __ / ___/____ / (_)___/ (_) /___ __ / __ )(_) /______ \__ \/ __ \/ / / __ / / __/ / / / / __ / / __/ ___/ ___/ / /_/ / / / /_/ / / /_/ /_/ / / /_/ / / /_(__ ) /____/\____/_/_/\__,_/_/\__/\__, / /_____/_/\__/____/ /____/ - npm: https://www.npmjs.com/package/solidity-bits - github: https://github.com/estarriolvetch/solidity-bits */ //pragma solidity ^0.8.0; library Popcount { uint256 private constant m1 = 0x5555555555555555555555555555555555555555555555555555555555555555; uint256 private constant m2 = 0x3333333333333333333333333333333333333333333333333333333333333333; uint256 private constant m4 = 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f; uint256 private constant h01 = 0x0101010101010101010101010101010101010101010101010101010101010101; function popcount256A(uint256 x) internal pure returns (uint256 count) { unchecked{ for (count=0; x!=0; count++) x &= x - 1; } } function popcount256B(uint256 x) internal pure returns (uint256) { if (x == type(uint256).max) { return 256; } unchecked { x -= (x >> 1) & m1; //put count of each 2 bits into those 2 bits x = (x & m2) + ((x >> 2) & m2); //put count of each 4 bits into those 4 bits x = (x + (x >> 4)) & m4; //put count of each 8 bits into those 8 bits x = (x * h01) >> 248; //returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... } return x; } } // File: solidity-bits/contracts/BitScan.sol /** _____ ___ ___ __ ____ _ __ / ___/____ / (_)___/ (_) /___ __ / __ )(_) /______ \__ \/ __ \/ / / __ / / __/ / / / / __ / / __/ ___/ ___/ / /_/ / / / /_/ / / /_/ /_/ / / /_/ / / /_(__ ) /____/\____/_/_/\__,_/_/\__/\__, / /_____/_/\__/____/ /____/ - npm: https://www.npmjs.com/package/solidity-bits - github: https://github.com/estarriolvetch/solidity-bits */ //pragma solidity ^0.8.0; library BitScan { uint256 constant private DEBRUIJN_256 = 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff; bytes constant private LOOKUP_TABLE_256 = hex"0001020903110a19042112290b311a3905412245134d2a550c5d32651b6d3a7506264262237d468514804e8d2b95569d0d495ea533a966b11c886eb93bc176c9071727374353637324837e9b47af86c7155181ad4fd18ed32c9096db57d59ee30e2e4a6a5f92a6be3498aae067ddb2eb1d5989b56fd7baf33ca0c2ee77e5caf7ff0810182028303840444c545c646c7425617c847f8c949c48a4a8b087b8c0c816365272829aaec650acd0d28fdad4e22d6991bd97dfdcea58b4d6f29fede4f6fe0f1f2f3f4b5b6b607b8b93a3a7b7bf357199c5abcfd9e168bcdee9b3f1ecf5fd1e3e5a7a8aa2b670c4ced8bbe8f0f4fc3d79a1c3cde7effb78cce6facbf9f8"; /** @dev Isolate the least significant set bit. */ function isolateLS1B256(uint256 bb) pure internal returns (uint256) { require(bb > 0); unchecked { return bb & (0 - bb); } } /** @dev Isolate the most significant set bit. */ function isolateMS1B256(uint256 bb) pure internal returns (uint256) { require(bb > 0); unchecked { bb |= bb >> 128; bb |= bb >> 64; bb |= bb >> 32; bb |= bb >> 16; bb |= bb >> 8; bb |= bb >> 4; bb |= bb >> 2; bb |= bb >> 1; return (bb >> 1) + 1; } } /** @dev Find the index of the lest significant set bit. (trailing zero count) */ function bitScanForward256(uint256 bb) pure internal returns (uint8) { unchecked { return uint8(LOOKUP_TABLE_256[(isolateLS1B256(bb) * DEBRUIJN_256) >> 248]); } } /** @dev Find the index of the most significant set bit. */ function bitScanReverse256(uint256 bb) pure internal returns (uint8) { unchecked { return 255 - uint8(LOOKUP_TABLE_256[((isolateMS1B256(bb) * DEBRUIJN_256) >> 248)]); } } function log2(uint256 bb) pure internal returns (uint8) { unchecked { return uint8(LOOKUP_TABLE_256[(isolateMS1B256(bb) * DEBRUIJN_256) >> 248]); } } } // File: solidity-bits/contracts/BitMaps.sol /** _____ ___ ___ __ ____ _ __ / ___/____ / (_)___/ (_) /___ __ / __ )(_) /______ \__ \/ __ \/ / / __ / / __/ / / / / __ / / __/ ___/ ___/ / /_/ / / / /_/ / / /_/ /_/ / / /_/ / / /_(__ ) /____/\____/_/_/\__,_/_/\__/\__, / /_____/_/\__/____/ /____/ - npm: https://www.npmjs.com/package/solidity-bits - github: https://github.com/estarriolvetch/solidity-bits */ //pragma solidity ^0.8.0; /** * @dev This Library is a modified version of Openzeppelin's BitMaps library with extra features. * * 1. Functions of finding the index of the closest set bit from a given index are added. * The indexing of each bucket is modifed to count from the MSB to the LSB instead of from the LSB to the MSB. * The modification of indexing makes finding the closest previous set bit more efficient in gas usage. * 2. Setting and unsetting the bitmap consecutively. * 3. Accounting number of set bits within a given range. * */ /** * @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential. * Largelly inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor]. */ library BitMaps { using BitScan for uint256; uint256 private constant MASK_INDEX_ZERO = (1 << 255); uint256 private constant MASK_FULL = type(uint256).max; struct BitMap { mapping(uint256 => uint256) _data; } /** * @dev Returns whether the bit at `index` is set. */ function get(BitMap storage bitmap, uint256 index) internal view returns (bool) { uint256 bucket = index >> 8; uint256 mask = MASK_INDEX_ZERO >> (index & 0xff); return bitmap._data[bucket] & mask != 0; } /** * @dev Sets the bit at `index` to the boolean `value`. */ function setTo( BitMap storage bitmap, uint256 index, bool value ) internal { if (value) { set(bitmap, index); } else { unset(bitmap, index); } } /** * @dev Sets the bit at `index`. */ function set(BitMap storage bitmap, uint256 index) internal { uint256 bucket = index >> 8; uint256 mask = MASK_INDEX_ZERO >> (index & 0xff); bitmap._data[bucket] |= mask; } /** * @dev Unsets the bit at `index`. */ function unset(BitMap storage bitmap, uint256 index) internal { uint256 bucket = index >> 8; uint256 mask = MASK_INDEX_ZERO >> (index & 0xff); bitmap._data[bucket] &= ~mask; } /** * @dev Consecutively sets `amount` of bits starting from the bit at `startIndex`. */ function setBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal { uint256 bucket = startIndex >> 8; uint256 bucketStartIndex = (startIndex & 0xff); unchecked { if(bucketStartIndex + amount < 256) { bitmap._data[bucket] |= MASK_FULL << (256 - amount) >> bucketStartIndex; } else { bitmap._data[bucket] |= MASK_FULL >> bucketStartIndex; amount -= (256 - bucketStartIndex); bucket++; while(amount > 256) { bitmap._data[bucket] = MASK_FULL; amount -= 256; bucket++; } bitmap._data[bucket] |= MASK_FULL << (256 - amount); } } } /** * @dev Consecutively unsets `amount` of bits starting from the bit at `startIndex`. */ function unsetBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal { uint256 bucket = startIndex >> 8; uint256 bucketStartIndex = (startIndex & 0xff); unchecked { if(bucketStartIndex + amount < 256) { bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount) >> bucketStartIndex); } else { bitmap._data[bucket] &= ~(MASK_FULL >> bucketStartIndex); amount -= (256 - bucketStartIndex); bucket++; while(amount > 256) { bitmap._data[bucket] = 0; amount -= 256; bucket++; } bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount)); } } } /** * @dev Returns number of set bits within a range. */ function popcountA(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) { uint256 bucket = startIndex >> 8; uint256 bucketStartIndex = (startIndex & 0xff); unchecked { if(bucketStartIndex + amount < 256) { count += Popcount.popcount256A( bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex) ); } else { count += Popcount.popcount256A( bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex) ); amount -= (256 - bucketStartIndex); bucket++; while(amount > 256) { count += Popcount.popcount256A(bitmap._data[bucket]); amount -= 256; bucket++; } count += Popcount.popcount256A( bitmap._data[bucket] & (MASK_FULL << (256 - amount)) ); } } } /** * @dev Returns number of set bits within a range. */ function popcountB(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) { uint256 bucket = startIndex >> 8; uint256 bucketStartIndex = (startIndex & 0xff); unchecked { if(bucketStartIndex + amount < 256) { count += Popcount.popcount256B( bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex) ); } else { count += Popcount.popcount256B( bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex) ); amount -= (256 - bucketStartIndex); bucket++; while(amount > 256) { count += Popcount.popcount256B(bitmap._data[bucket]); amount -= 256; bucket++; } count += Popcount.popcount256B( bitmap._data[bucket] & (MASK_FULL << (256 - amount)) ); } } } /** * @dev Find the closest index of the set bit before `index`. */ function scanForward(BitMap storage bitmap, uint256 index) internal view returns (uint256 setBitIndex) { uint256 bucket = index >> 8; // index within the bucket uint256 bucketIndex = (index & 0xff); // load a bitboard from the bitmap. uint256 bb = bitmap._data[bucket]; // offset the bitboard to scan from `bucketIndex`. bb = bb >> (0xff ^ bucketIndex); // bb >> (255 - bucketIndex) if(bb > 0) { unchecked { setBitIndex = (bucket << 8) | (bucketIndex - bb.bitScanForward256()); } } else { while(true) { require(bucket > 0, "BitMaps: The set bit before the index doesn't exist."); unchecked { bucket--; } // No offset. Always scan from the least significiant bit now. bb = bitmap._data[bucket]; if(bb > 0) { unchecked { setBitIndex = (bucket << 8) | (255 - bb.bitScanForward256()); break; } } } } } function getBucket(BitMap storage bitmap, uint256 bucket) internal view returns (uint256) { return bitmap._data[bucket]; } } // File: @openzeppelin/contracts/utils/StorageSlot.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol) //pragma solidity ^0.8.0; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ``` * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._ */ library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } } // File: @openzeppelin/contracts/utils/Address.sol // 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); } } } } // File: @openzeppelin/contracts/utils/Strings.sol // 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); } } // File: @openzeppelin/contracts/utils/Context.sol // 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; } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) //pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _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); } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // 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); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // 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); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) //pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol) //pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * 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); } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol) //pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) //pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: docs.chain.link/EVAKeepersAutomationPsi.sol /** ______ _____ _____ ______ ___ __ _ _ _ | ____| __ \ / ____|____ |__ \/_ | || || | | |__ | |__) | | / / ) || | \| |/ | | __| | _ /| | / / / / | |\_ _/ | |____| | \ \| |____ / / / /_ | | | | |______|_| \_\\_____|/_/ |____||_| |_| - github: https://github.com/estarriolvetch/ERC721Psi - npm: https://www.npmjs.com/package/erc721psi */ //pragma solidity ^0.8.0; interface KeeperCompatibleInterface { /** * @notice method that is simulated by the keepers to see if any work actually * needs to be performed. This method does does not actually need to be * executable, and since it is only ever simulated it can consume lots of gas. * @dev To ensure that it is never called, you may want to add the * cannotExecute modifier from KeeperBase to your implementation of this * method. * @param checkData specified in the upkeep registration so it is always the * same for a registered upkeep. This can easily be broken down into specific * arguments using `abi.decode`, so multiple upkeeps can be registered on the * same contract and easily differentiated by the contract. * @return upkeepNeeded boolean to indicate whether the keeper should call * performUpkeep or not. * @return performData bytes that the keeper should call performUpkeep with, if * upkeep is needed. If you would like to encode data to decode later, try * `abi.encode`. */ function checkUpkeep(bytes calldata checkData) external returns (bool upkeepNeeded, bytes memory performData); /** * @notice method that is actually executed by the keepers, via the registry. * The data returned by the checkUpkeep simulation will be passed into * this method to actually be executed. * @dev The input to this method should not be trusted, and the caller of the * method should not even be restricted to any single registry. Anyone should * be able call it, and the input should be validated, there is no guarantee * that the data passed in is the performData returned from checkUpkeep. This * could happen due to malicious keepers, racing keepers, or simply a state * change while the performUpkeep transaction is waiting for confirmation. * Always validate the data passed in. * @param performData is the data which was passed back from the checkData * simulation. If it is encoded, it can easily be decoded into other types by * calling `abi.decode`. This data should not be trusted, and should be * validated against the contract's current state. */ function performUpkeep(bytes calldata performData) external; } // File: @chainlink/contracts/src/v0.8/KeeperBase.sol contract KeeperBase { error OnlySimulatedBackend(); /** * @notice method that allows it to be simulated via eth_call by checking that * the sender is the zero address. */ function preventExecution() internal view { if (tx.origin != address(0)) { revert OnlySimulatedBackend(); } } /** * @notice modifier that allows it to be simulated via eth_call by checking * that the sender is the zero address. */ modifier cannotExecute() { preventExecution(); _; } } // File: @chainlink/contracts/src/v0.8/KeeperCompatible.sol abstract contract KeeperCompatible is KeeperBase, KeeperCompatibleInterface {} // File: SafeMath.sol /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ 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) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { 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) { // 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) { 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) { 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) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @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) { require(b <= a, "SafeMath: subtraction overflow"); 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) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @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. 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) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); 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) { require(b > 0, "SafeMath: modulo by zero"); 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) { 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. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * 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) { 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) { require(b > 0, errorMessage); return a % b; } } contract ERC721Psi is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable { using Address for address; using Strings for uint256; using BitMaps for BitMaps.BitMap; BitMaps.BitMap private _batchHead; string private _name; string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) internal _owners; uint256 internal _minted; mapping(uint256 => address) private _tokenApprovals; 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 || interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint) { require(owner != address(0), "ERC721Psi: balance query for the zero address"); uint count; for( uint i; i < _minted; ++i ){ if(_exists(i)){ if( owner == ownerOf(i)){ ++count; } } } return count; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { (address owner, ) = _ownerAndBatchHeadOf(tokenId); return owner; } function _ownerAndBatchHeadOf(uint256 tokenId) internal view returns (address owner, uint256 tokenIdBatchHead){ require(_exists(tokenId), "ERC721Psi: owner query for nonexistent token"); tokenIdBatchHead = _getBatchHead(tokenId); owner = _owners[tokenIdBatchHead]; } /** * @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) { require(_exists(tokenId), "ERC721Psi: URI query for nonexistent token"); 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 overriden 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 = ownerOf(tokenId); require(to != owner, "ERC721Psi: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721Psi: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { require( _exists(tokenId), "ERC721Psi: approved query for nonexistent token" ); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721Psi: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_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), "ERC721Psi: transfer caller is not 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), "ERC721Psi: transfer caller is not 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, 1,_data), "ERC721Psi: 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`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return tokenId < _minted; } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require( _exists(tokenId), "ERC721Psi: operator query for nonexistent token" ); address owner = ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } /** * @dev Safely mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 quantity) internal virtual { _safeMint(to, quantity, ""); } function _safeMint( address to, uint256 quantity, bytes memory _data ) internal virtual { uint256 startTokenId = _minted; _mint(to, quantity); require( _checkOnERC721Received(address(0), to, startTokenId, quantity, _data), "ERC721Psi: transfer to non ERC721Receiver implementer" ); } function _mint( address to, uint256 quantity ) internal virtual { uint256 tokenIdBatchHead = _minted; require(quantity > 0, "ERC721Psi: quantity must be greater 0"); require(to != address(0), "ERC721Psi: mint to the zero address"); _beforeTokenTransfers(address(0), to, tokenIdBatchHead, quantity); _minted += quantity; _owners[tokenIdBatchHead] = to; _batchHead.set(tokenIdBatchHead); _afterTokenTransfers(address(0), to, tokenIdBatchHead, quantity); // Emit events for(uint256 tokenId=tokenIdBatchHead;tokenId < tokenIdBatchHead + quantity; tokenId++){ emit Transfer(address(0), to, 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 { (address owner, uint256 tokenIdBatchHead) = _ownerAndBatchHeadOf(tokenId); require( owner == from, "ERC721Psi: transfer of token that is not own" ); require(to != address(0), "ERC721Psi: transfer to the zero address"); _beforeTokenTransfers(from, to, tokenId, 1); // Clear approvals from the previous owner _approve(address(0), tokenId); uint256 nextTokenId = tokenId + 1; if(!_batchHead.get(nextTokenId) && nextTokenId < _minted ) { _owners[nextTokenId] = from; _batchHead.set(nextTokenId); } _owners[tokenId] = to; if(tokenId != tokenIdBatchHead) { _batchHead.set(tokenId); } emit Transfer(from, to, tokenId); _afterTokenTransfers(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ownerOf(tokenId), to, tokenId); } /** * @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 startTokenId uint256 the first ID of the tokens to be transferred * @param quantity uint256 amount of the tokens to be transfered. * @param _data bytes optional data to send along with the call * @return r bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 startTokenId, uint256 quantity, bytes memory _data ) private returns (bool r) { if (to.isContract()) { r = true; for(uint256 tokenId = startTokenId; tokenId < startTokenId + quantity; tokenId++){ try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) { r = r && retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721Psi: transfer to non ERC721Receiver implementer"); } else { assembly { revert(add(32, reason), mload(reason)) } } } } return r; } else { return true; } } function _getBatchHead(uint256 tokenId) internal view returns (uint256 tokenIdBatchHead) { tokenIdBatchHead = _batchHead.scanForward(tokenId); } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _minted; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256 tokenId) { require(index < totalSupply(), "ERC721Psi: global index out of bounds"); uint count; for(uint i; i < _minted; i++){ if(_exists(i)){ if(count == index) return i; else count++; } } } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256 tokenId) { uint count; for(uint i; i < _minted; i++){ if(_exists(i) && owner == ownerOf(i)){ if(count == index) return i; else count++; } } revert("ERC721Psi: owner index out of bounds"); } /** * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * 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`. */ function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} /** * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes * minting. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - when `from` and `to` are both non-zero. * - `from` and `to` are never both zero. */ function _afterTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} } error ApprovalCallerNotOwnerNorApproved(); error ApprovalQueryForNonexistentToken(); error ApproveToCaller(); error ApprovalToCurrentOwner(); error BalanceQueryForZeroAddress(); error MintedQueryForZeroAddress(); error BurnedQueryForZeroAddress(); error MintToZeroAddress(); error MintZeroQuantity(); error OwnerIndexOutOfBounds(); error OwnerQueryForNonexistentToken(); error TokenIndexOutOfBounds(); error TransferCallerNotOwnerNorApproved(); error TransferFromIncorrectOwner(); error TransferToNonERC721ReceiverImplementer(); error TransferToZeroAddress(); error URIQueryForNonexistentToken(); contract EvaTribe is ERC721Psi, Ownable, KeeperCompatibleInterface { using SafeMath for uint256; using Strings for uint; /* * @dev Set Initial Parameters Before deployment * settings are still fully updateable after deployment */ uint256 public maxSupply = 1500; uint256 public mintRate = 0.08 ether; /* * @Dev Booleans for sale states. * salesIsActive must be true in any case to mint */ bool public saleIsActive = false; /* * @dev Set base URI, Make sure when dpeloying if you plan to Have an * Unrevealed Sale or Period you Do not Deploy with your Revealed * base URI here or they will mint With your revealed Images Showing */ string private baseURI; string private imgEnd; string public notRevealedUri; bool public revealed = false; /* * @dev Set Collection/Contract name and Token Ticker * below. Constructor Parameter cannot be changed after * contract deployment. */ constructor(string memory _baseUri, string memory _notRevealedUri, string memory _imgEnd) ERC721Psi("Eva", "EVA") { baseURI = _baseUri; notRevealedUri = _notRevealedUri; imgEnd = _imgEnd; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { if (!_exists(tokenId)) revert URIQueryForNonexistentToken(); if (revealed == false) { return notRevealedUri; } return string(abi.encodePacked(baseURI, imgEnd, "/", tokenId.toString(), "")); } function devReveal() public onlyOwner { revealed = true; } function keepersReveal() public { require (totalSupply() == maxSupply); require (revealed == false); revealed = true; } function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner { notRevealedUri = _notRevealedURI; } function checkUpkeep(bytes calldata /* checkData */) external view override returns (bool upkeepNeeded, bytes memory /* performData */) { upkeepNeeded = address(this).balance > 1000000000000000000 || totalSupply() == maxSupply && revealed == false; } function performUpkeep(bytes calldata /* performData */) external override { //We highly recommend revalidating the upkeep in the performUpkeep function if (address(this).balance > 1000000000000000000) { withdraw(); } if (totalSupply() == maxSupply && revealed == false){ keepersReveal(); } } /* *@dev * Set publicsale price to mint per NFT */ function setPublicMintPrice(uint256 _price) external onlyOwner { mintRate = _price; } /* * @dev mint funtion with _to address. no cost mint * by contract owner/deployer */ function Devmint(uint256 quantity, address _to) external onlyOwner { require(totalSupply() + quantity <= maxSupply, "Not enough tokens left"); _safeMint(_to, quantity); } /* * @dev mint function and checks for saleState and mint quantity */ function mint(uint256 quantity) external payable { require(saleIsActive, "Sale must be active to mint"); // _safeMint's second argument now takes in a quantity, not a tokenId. require(totalSupply() + quantity <= maxSupply, "Not enough tokens left to Mint"); require((mintRate * quantity) <= msg.value, "Value below price"); if (totalSupply() < maxSupply){ _safeMint(msg.sender, quantity); } } /* * @dev Set new Base URI * useful for setting unrevealed uri to revealed Base URI * same as a reveal switch/state but not the extraness */ function setBaseURI(string calldata newBaseURI) external onlyOwner { baseURI = newBaseURI; } //Set imgEnd Funtion.. function setImgEnd(string calldata newImgEnd) external onlyOwner { imgEnd = newImgEnd; } /* * @dev internal baseUri function */ function _baseURI() internal view override returns (string memory) { return baseURI; } /* * @dev Pause sale if active, make active if paused */ function setSaleActive() public onlyOwner { saleIsActive = !saleIsActive; } /* * @dev Public Keepers or to Owner wallet Withdrawl function, Contract ETH balance * to owner wallet address. */ function withdraw() public { payable(owner()).transfer(address(this).balance); } /* * @dev Alternative withdrawl * mint funs to a specified address * */ function altWithdraw(uint256 _amount, address payable _to) external onlyOwner { require(_amount > 0, "Withdraw must be greater than 0"); require(_amount <= address(this).balance, "Amount too high"); (bool success, ) = _to.call{value: _amount}(""); require(success); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_baseUri","type":"string"},{"internalType":"string","name":"_notRevealedUri","type":"string"},{"internalType":"string","name":"_imgEnd","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"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":"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":"uint256","name":"quantity","type":"uint256"},{"internalType":"address","name":"_to","type":"address"}],"name":"Devmint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address payable","name":"_to","type":"address"}],"name":"altWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"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":"bytes","name":"","type":"bytes"}],"name":"checkUpkeep","outputs":[{"internalType":"bool","name":"upkeepNeeded","type":"bool"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"devReveal","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":[{"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":[],"name":"keepersReveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notRevealedUri","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":[{"internalType":"bytes","name":"","type":"bytes"}],"name":"performUpkeep","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"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":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newImgEnd","type":"string"}],"name":"setImgEnd","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_notRevealedURI","type":"string"}],"name":"setNotRevealedURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPublicMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setSaleActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"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"},{"inputs":[],"name":"withdraw","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)
000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000012697066733a2f2f446f4e6f744578706f736500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d52776657517475626e61313470337a644371644e48416b72455046684c50356a36534d775962394145357a5a000000000000000000000000000000000000000000000000000000000000000000000000000000000000073836373533303900000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _baseUri (string): ipfs://DoNotExpose
Arg [1] : _notRevealedUri (string): ipfs://QmRwfWQtubna14p3zdCqdNHAkrEPFhLP5j6SMwYb9AE5zZ
Arg [2] : _imgEnd (string): 8675309
-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000012
Arg [4] : 697066733a2f2f446f4e6f744578706f73650000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [6] : 697066733a2f2f516d52776657517475626e61313470337a644371644e48416b
Arg [7] : 72455046684c50356a36534d775962394145357a5a0000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [9] : 3836373533303900000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
68181:5240:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52536:422;;;;;;;;;;-1:-1:-1;52536:422:0;;;;;:::i;:::-;;:::i;:::-;;;9288:14:1;;9281:22;9263:41;;9251:2;9236:18;52536:422:0;;;;;;;;54144:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;55699:311::-;;;;;;;;;;-1:-1:-1;55699:311:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;8586:32:1;;;8568:51;;8556:2;8541:18;55699:311:0;8422:203:1;68987:28:0;;;;;;;;;;;;;:::i;55223:410::-;;;;;;;;;;-1:-1:-1;55223:410:0;;;;;:::i;:::-;;:::i;:::-;;65291:103;;;;;;;;;;-1:-1:-1;65379:7:0;;65291:103;;;19427:25:1;;;19415:2;19400:18;65291:103:0;19281:177:1;56764:379:0;;;;;;;;;;-1:-1:-1;56764:379:0;;;;;:::i;:::-;;:::i;72646:89::-;;;;;;;;;;;;;:::i;65940:397::-;;;;;;;;;;-1:-1:-1;65940:397:0;;;;;:::i;:::-;;:::i;72881:94::-;;;;;;;;;;;;;:::i;57214:185::-;;;;;;;;;;-1:-1:-1;57214:185:0;;;;;:::i;:::-;;:::i;70555:372::-;;;;;;;;;;-1:-1:-1;70555:372:0;;;;;:::i;:::-;;:::i;65471:385::-;;;;;;;;;;-1:-1:-1;65471:385:0;;;;;:::i;:::-;;:::i;69024:28::-;;;;;;;;;;-1:-1:-1;69024:28:0;;;;;;;;71223:193;;;;;;;;;;-1:-1:-1;71223:193:0;;;;;:::i;:::-;;:::i;72152:106::-;;;;;;;;;;-1:-1:-1;72152:106:0;;;;;:::i;:::-;;:::i;71009:99::-;;;;;;;;;;-1:-1:-1;71009:99:0;;;;;:::i;:::-;;:::i;53549:222::-;;;;;;;;;;-1:-1:-1;53549:222:0;;;;;:::i;:::-;;:::i;69910:72::-;;;;;;;;;;;;;:::i;70283:264::-;;;;;;;;;;-1:-1:-1;70283:264:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;53022:465::-;;;;;;;;;;-1:-1:-1;53022:465:0;;;;;:::i;:::-;;:::i;29873:103::-;;;;;;;;;;;;;:::i;73085:331::-;;;;;;;;;;-1:-1:-1;73085:331:0;;;;;:::i;:::-;;:::i;29225:87::-;;;;;;;;;;-1:-1:-1;29298:6:0;;-1:-1:-1;;;;;29298:6:0;29225:87;;54313:104;;;;;;;;;;;;;:::i;71512:462::-;;;;;;:::i;:::-;;:::i;56082:330::-;;;;;;;;;;-1:-1:-1;56082:330:0;;;;;:::i;:::-;;:::i;57470:368::-;;;;;;;;;;-1:-1:-1;57470:368:0;;;;;:::i;:::-;;:::i;72296:102::-;;;;;;;;;;-1:-1:-1;72296:102:0;;;;;:::i;:::-;;:::i;69529:373::-;;;;;;;;;;-1:-1:-1;69529:373:0;;;;;:::i;:::-;;:::i;68491:36::-;;;;;;;;;;;;;;;;68453:31;;;;;;;;;;;;;;;;56483:214;;;;;;;;;;-1:-1:-1;56483:214:0;;;;;:::i;:::-;-1:-1:-1;;;;;56654:25:0;;;56625:4;56654:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;56483:214;68645:32;;;;;;;;;;-1:-1:-1;68645:32:0;;;;;;;;70149:126;;;;;;;;;;-1:-1:-1;70149:126:0;;;;;:::i;:::-;;:::i;30131:201::-;;;;;;;;;;-1:-1:-1;30131:201:0;;;;;:::i;:::-;;:::i;69990:151::-;;;;;;;;;;;;;:::i;52536:422::-;52683:4;-1:-1:-1;;;;;;52725:40:0;;-1:-1:-1;;;52725:40:0;;:105;;-1:-1:-1;;;;;;;52782:48:0;;-1:-1:-1;;;52782:48:0;52725:105;:172;;;-1:-1:-1;;;;;;;52847:50:0;;-1:-1:-1;;;52847:50:0;52725:172;:225;;;-1:-1:-1;;;;;;;;;;33641:40:0;;;52914:36;52705:245;52536:422;-1:-1:-1;;52536:422:0:o;54144:100::-;54198:13;54231:5;54224:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54144:100;:::o;55699:311::-;55820:7;55867:16;55875:7;59431;;-1:-1:-1;59421:17:0;59332:114;55867:16;55845:113;;;;-1:-1:-1;;;55845:113:0;;11216:2:1;55845:113:0;;;11198:21:1;11255:2;11235:18;;;11228:30;11294:34;11274:18;;;11267:62;-1:-1:-1;;;11345:18:1;;;11338:45;11400:19;;55845:113:0;;;;;;;;;-1:-1:-1;55978:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;55978:24:0;;55699:311::o;68987:28::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55223:410::-;55304:13;55320:16;55328:7;55320;:16::i;:::-;55304:32;;55361:5;-1:-1:-1;;;;;55355:11:0;:2;-1:-1:-1;;;;;55355:11:0;;;55347:60;;;;-1:-1:-1;;;55347:60:0;;15453:2:1;55347:60:0;;;15435:21:1;15492:2;15472:18;;;15465:30;15531:34;15511:18;;;15504:62;-1:-1:-1;;;15582:18:1;;;15575:34;15626:19;;55347:60:0;15251:400:1;55347:60:0;27854:10;-1:-1:-1;;;;;55442:21:0;;;;:62;;-1:-1:-1;55467:37:0;55484:5;27854:10;56483:214;:::i;55467:37::-;55420:171;;;;-1:-1:-1;;;55420:171:0;;18642:2:1;55420:171:0;;;18624:21:1;18681:2;18661:18;;;18654:30;18720:34;18700:18;;;18693:62;18791:29;18771:18;;;18764:57;18838:19;;55420:171:0;18440:423:1;55420:171:0;55604:21;55613:2;55617:7;55604:8;:21::i;:::-;55293:340;55223:410;;:::o;56764:379::-;56973:41;27854:10;57006:7;56973:18;:41::i;:::-;56951:143;;;;-1:-1:-1;;;56951:143:0;;;;;;;:::i;:::-;57107:28;57117:4;57123:2;57127:7;57107:9;:28::i;72646:89::-;29111:13;:11;:13::i;:::-;72715:12:::1;::::0;;-1:-1:-1;;72699:28:0;::::1;72715:12;::::0;;::::1;72714:13;72699:28;::::0;;72646:89::o;65940:397::-;66037:15;66065:10;66090:6;66086:185;66102:7;;66098:1;:11;66086:185;;;66133:10;66141:1;59431:7;;-1:-1:-1;59421:17:0;59332:114;66133:10;:33;;;;;66156:10;66164:1;66156:7;:10::i;:::-;-1:-1:-1;;;;;66147:19:0;:5;-1:-1:-1;;;;;66147:19:0;;66133:33;66130:130;;;66198:5;66189;:14;66186:58;;;66212:1;-1:-1:-1;66205:8:0;;-1:-1:-1;66205:8:0;66186:58;66237:7;;;;:::i;:::-;;;;66186:58;66111:3;;;;:::i;:::-;;;;66086:185;;;-1:-1:-1;66283:46:0;;-1:-1:-1;;;66283:46:0;;13945:2:1;66283:46:0;;;13927:21:1;13984:2;13964:18;;;13957:30;14023:34;14003:18;;;13996:62;-1:-1:-1;;;14074:18:1;;;14067:34;14118:19;;66283:46:0;13743:400:1;72881:94:0;29298:6;;72919:48;;-1:-1:-1;;;;;29298:6:0;;;;72945:21;72919:48;;;;;;;;;72945:21;29298:6;72919:48;;;;;;;;;;;;;;;;;;;;;72881:94::o;57214:185::-;57352:39;57369:4;57375:2;57379:7;57352:39;;;;;;;;;;;;:16;:39::i;70555:372::-;70754:19;70730:21;:43;70726:89;;;70790:10;:8;:10::i;:::-;70847:9;;65379:7;;70830:26;:47;;;;-1:-1:-1;70860:8:0;;;;:17;70830:47;70826:94;;;70893:15;:13;:15::i;:::-;70555:372;;:::o;65471:385::-;65546:15;65590:13;65379:7;;;65291:103;65590:13;65582:5;:21;65574:71;;;;-1:-1:-1;;;65574:71:0;;10403:2:1;65574:71:0;;;10385:21:1;10442:2;10422:18;;;10415:30;10481:34;10461:18;;;10454:62;-1:-1:-1;;;10532:18:1;;;10525:35;10577:19;;65574:71:0;10201:401:1;65574:71:0;65666:10;65691:6;65687:162;65703:7;;65699:1;:11;65687:162;;;65734:10;65742:1;59431:7;;-1:-1:-1;59421:17:0;59332:114;65734:10;65731:107;;;65776:5;65767;:14;65764:58;;;65790:1;65471:385;-1:-1:-1;;;65471:385:0:o;65764:58::-;65815:7;;;;:::i;:::-;;;;65764:58;65712:3;;;;:::i;:::-;;;;65687:162;;;;65563:293;65471:385;;;:::o;71223:193::-;29111:13;:11;:13::i;:::-;71337:9:::1;;71325:8;71309:13;65379:7:::0;;;65291:103;71309:13:::1;:24;;;;:::i;:::-;:37;;71301:72;;;::::0;-1:-1:-1;;;71301:72:0;;14694:2:1;71301:72:0::1;::::0;::::1;14676:21:1::0;14733:2;14713:18;;;14706:30;-1:-1:-1;;;14752:18:1;;;14745:52;14814:18;;71301:72:0::1;14492:346:1::0;71301:72:0::1;71384:24;71394:3;71399:8;71384:9;:24::i;72152:106::-:0;29111:13;:11;:13::i;:::-;72230:20:::1;:7;72240:10:::0;;72230:20:::1;:::i;71009:99::-:0;29111:13;:11;:13::i;:::-;71083:8:::1;:17:::0;71009:99::o;53549:222::-;53666:7;53692:13;53711:29;53732:7;53711:20;:29::i;:::-;-1:-1:-1;53691:49:0;53549:222;-1:-1:-1;;;53549:222:0:o;69910:72::-;29111:13;:11;:13::i;:::-;69959:8:::1;:15:::0;;-1:-1:-1;;69959:15:0::1;69970:4;69959:15;::::0;;69910:72::o;70283:264::-;70368:17;70387:12;70469:19;70445:21;:43;:94;;;-1:-1:-1;70509:9:0;;65379:7;;70492:26;:47;;;;-1:-1:-1;70522:8:0;;;;:17;70492:47;70430:109;;70283:264;;;;;:::o;53022:465::-;53144:4;-1:-1:-1;;;;;53175:19:0;;53167:77;;;;-1:-1:-1;;;53167:77:0;;11632:2:1;53167:77:0;;;11614:21:1;11671:2;11651:18;;;11644:30;11710:34;11690:18;;;11683:62;-1:-1:-1;;;11761:18:1;;;11754:43;11814:19;;53167:77:0;11430:409:1;53167:77:0;53257:10;53283:6;53278:179;53295:7;;53291:1;:11;53278:179;;;53327:10;53335:1;59431:7;;-1:-1:-1;59421:17:0;59332:114;53327:10;53324:122;;;53370:10;53378:1;53370:7;:10::i;:::-;-1:-1:-1;;;;;53361:19:0;:5;-1:-1:-1;;;;;53361:19:0;;53357:74;;;53404:7;;;:::i;:::-;;;53357:74;53304:3;;;:::i;:::-;;;53278:179;;;-1:-1:-1;53474:5:0;53022:465;-1:-1:-1;;53022:465:0:o;29873:103::-;29111:13;:11;:13::i;:::-;29938:30:::1;29965:1;29938:18;:30::i;:::-;29873:103::o:0;73085:331::-;29111:13;:11;:13::i;:::-;73215:1:::1;73205:7;:11;73197:55;;;::::0;-1:-1:-1;;;73197:55:0;;13181:2:1;73197:55:0::1;::::0;::::1;13163:21:1::0;13220:2;13200:18;;;13193:30;13259:33;13239:18;;;13232:61;13310:18;;73197:55:0::1;12979:355:1::0;73197:55:0::1;73282:21;73271:7;:32;;73263:60;;;::::0;-1:-1:-1;;;73263:60:0;;14350:2:1;73263:60:0::1;::::0;::::1;14332:21:1::0;14389:2;14369:18;;;14362:30;-1:-1:-1;;;14408:18:1;;;14401:45;14463:18;;73263:60:0::1;14148:339:1::0;73263:60:0::1;73335:12;73353:3;-1:-1:-1::0;;;;;73353:8:0::1;73369:7;73353:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73334:47;;;73400:7;73392:16;;;::::0;::::1;54313:104:::0;54369:13;54402:7;54395:14;;;;;:::i;71512:462::-;71580:12;;;;71572:52;;;;-1:-1:-1;;;71572:52:0;;12046:2:1;71572:52:0;;;12028:21:1;12085:2;12065:18;;;12058:30;12124:29;12104:18;;;12097:57;12171:18;;71572:52:0;11844:351:1;71572:52:0;71751:9;;71739:8;71723:13;65379:7;;;65291:103;71723:13;:24;;;;:::i;:::-;:37;;71715:80;;;;-1:-1:-1;;;71715:80:0;;10044:2:1;71715:80:0;;;10026:21:1;10083:2;10063:18;;;10056:30;10122:32;10102:18;;;10095:60;10172:18;;71715:80:0;9842:354:1;71715:80:0;71839:9;71826:8;71815;;:19;;;;:::i;:::-;71814:34;;71806:64;;;;-1:-1:-1;;;71806:64:0;;16640:2:1;71806:64:0;;;16622:21:1;16679:2;16659:18;;;16652:30;-1:-1:-1;;;16698:18:1;;;16691:47;16755:18;;71806:64:0;16438:341:1;71806:64:0;71903:9;;65379:7;;71887:25;71883:84;;;71924:31;71934:10;71946:8;71924:9;:31::i;56082:330::-;-1:-1:-1;;;;;56217:24:0;;27854:10;56217:24;;56209:65;;;;-1:-1:-1;;;56209:65:0;;12402:2:1;56209:65:0;;;12384:21:1;12441:2;12421:18;;;12414:30;12480;12460:18;;;12453:58;12528:18;;56209:65:0;12200:352:1;56209:65:0;27854:10;56287:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;56287:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;56287:53:0;;;;;;;;;;56356:48;;9263:41:1;;;56287:42:0;;27854:10;56356:48;;9236:18:1;56356:48:0;;;;;;;56082:330;;:::o;57470:368::-;57659:41;27854:10;57692:7;57659:18;:41::i;:::-;57637:143;;;;-1:-1:-1;;;57637:143:0;;;;;;;:::i;:::-;57791:39;57805:4;57811:2;57815:7;57824:5;57791:13;:39::i;:::-;57470:368;;;;:::o;72296:102::-;29111:13;:11;:13::i;:::-;72372:18:::1;:6;72381:9:::0;;72372:18:::1;:::i;69529:373::-:0;69632:13;69663:16;69671:7;59431;;-1:-1:-1;59421:17:0;59332:114;69663:16;69658:59;;69688:29;;-1:-1:-1;;;69688:29:0;;;;;;;;;;;69658:59;69732:8;;;;69728:71;;69773:14;69766:21;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69529:373;;;:::o;69728:71::-;69848:7;69857:6;69870:18;:7;:16;:18::i;:::-;69831:62;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;69817:77;;69529:373;;;:::o;70149:126::-;29111:13;:11;:13::i;:::-;70235:32;;::::1;::::0;:14:::1;::::0;:32:::1;::::0;::::1;::::0;::::1;:::i;30131:201::-:0;29111:13;:11;:13::i;:::-;-1:-1:-1;;;;;30220:22:0;::::1;30212:73;;;::::0;-1:-1:-1;;;30212:73:0;;10809:2:1;30212:73:0::1;::::0;::::1;10791:21:1::0;10848:2;10828:18;;;10821:30;10887:34;10867:18;;;10860:62;-1:-1:-1;;;10938:18:1;;;10931:36;10984:19;;30212:73:0::1;10607:402:1::0;30212:73:0::1;30296:28;30315:8;30296:18;:28::i;69990:151::-:0;70059:9;;65379:7;;70042:26;70033:36;;;;;;70089:8;;;;:17;70080:27;;;;;63188:167;63263:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;63263:29:0;-1:-1:-1;;;;;63263:29:0;;;;;;;;:24;;63317:16;63263:24;63317:7;:16::i;:::-;-1:-1:-1;;;;;63308:39:0;;;;;;;;;;;63188:167;;:::o;59613:448::-;59742:4;59786:16;59794:7;59431;;-1:-1:-1;59421:17:0;59332:114;59786:16;59764:113;;;;-1:-1:-1;;;59764:113:0;;18226:2:1;59764:113:0;;;18208:21:1;18265:2;18245:18;;;18238:30;18304:34;18284:18;;;18277:62;-1:-1:-1;;;18355:18:1;;;18348:45;18410:19;;59764:113:0;18024:411:1;59764:113:0;59888:13;59904:16;59912:7;59904;:16::i;:::-;59888:32;;59950:5;-1:-1:-1;;;;;59939:16:0;:7;-1:-1:-1;;;;;59939:16:0;;:64;;;;59996:7;-1:-1:-1;;;;;59972:31:0;:20;59984:7;59972:11;:20::i;:::-;-1:-1:-1;;;;;59972:31:0;;59939:64;:113;;;-1:-1:-1;;;;;;56654:25:0;;;56625:4;56654:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;60020:32;59931:122;59613:448;-1:-1:-1;;;;59613:448:0:o;62050:1020::-;62175:13;62190:24;62218:29;62239:7;62218:20;:29::i;:::-;62174:73;;;;62291:4;-1:-1:-1;;;;;62282:13:0;:5;-1:-1:-1;;;;;62282:13:0;;62260:107;;;;-1:-1:-1;;;62260:107:0;;17813:2:1;62260:107:0;;;17795:21:1;17852:2;17832:18;;;17825:30;17891:34;17871:18;;;17864:62;-1:-1:-1;;;17942:18:1;;;17935:42;17994:19;;62260:107:0;17611:408:1;62260:107:0;-1:-1:-1;;;;;62386:16:0;;62378:68;;;;-1:-1:-1;;;62378:68:0;;15045:2:1;62378:68:0;;;15027:21:1;15084:2;15064:18;;;15057:30;15123:34;15103:18;;;15096:62;-1:-1:-1;;;15174:18:1;;;15167:37;15221:19;;62378:68:0;14843:403:1;62378:68:0;62567:29;62584:1;62588:7;62567:8;:29::i;:::-;62612:19;62634:11;:7;62644:1;62634:11;:::i;:::-;6589:1;6580:10;;;62662;6667:20;;;;;;;;;;;6580:10;;-1:-1:-1;;;;6644:4:0;6636:12;;6616:33;6667:27;:32;;;62661:68;;;62722:7;;62708:11;:21;62661:68;62658:179;;;62756:20;;;;:7;:20;;;;;:27;;-1:-1:-1;;;;;;62756:27:0;-1:-1:-1;;;;;62756:27:0;;;;;62798;;62756:20;62798:14;:27::i;:::-;62849:16;;;;:7;:16;;;;;:21;;-1:-1:-1;;;;;;62849:21:0;-1:-1:-1;;;;;62849:21:0;;;;;62884:27;;;62881:82;;62928:23;:10;62943:7;62928:14;:23::i;:::-;62999:7;62995:2;-1:-1:-1;;;;;62980:27:0;62989:4;-1:-1:-1;;;;;62980:27:0;;;;;;;;;;;62163:907;;;62050:1020;;;:::o;29390:132::-;29298:6;;-1:-1:-1;;;;;29298:6:0;27854:10;29454:23;29446:68;;;;-1:-1:-1;;;29446:68:0;;15858:2:1;29446:68:0;;;15840:21:1;;;15877:18;;;15870:30;15936:34;15916:18;;;15909:62;15988:18;;29446:68:0;15656:356:1;60424:112:0;60501:27;60511:2;60515:8;60501:27;;;;;;;;;;;;:9;:27::i;53779:298::-;53849:13;53864:24;53908:16;53916:7;59431;;-1:-1:-1;59421:17:0;59332:114;53908:16;53900:73;;;;-1:-1:-1;;;53900:73:0;;19070:2:1;53900:73:0;;;19052:21:1;19109:2;19089:18;;;19082:30;19148:34;19128:18;;;19121:62;-1:-1:-1;;;19199:18:1;;;19192:42;19251:19;;53900:73:0;18868:408:1;53900:73:0;54003:22;54017:7;54003:13;:22::i;:::-;54044:25;;;;:7;:25;;;;;;-1:-1:-1;;;;;54044:25:0;;53984:41;;-1:-1:-1;53779:298:0;-1:-1:-1;;53779:298:0:o;30492:191::-;30585:6;;;-1:-1:-1;;;;;30602:17:0;;;-1:-1:-1;;;;;;30602:17:0;;;;;;;30635:40;;30585:6;;;30602:17;30585:6;;30635:40;;30566:16;;30635:40;30555:128;30492:191;:::o;58720:357::-;58877:28;58887:4;58893:2;58897:7;58877:9;:28::i;:::-;58938:50;58961:4;58967:2;58971:7;58980:1;58982:5;58938:22;:50::i;:::-;58916:153;;;;-1:-1:-1;;;58916:153:0;;;;;;;:::i;25026:723::-;25082:13;25303:10;25299:53;;-1:-1:-1;;25330:10:0;;;;;;;;;;;;-1:-1:-1;;;25330:10:0;;;;;25026:723::o;25299:53::-;25377:5;25362:12;25418:78;25425:9;;25418:78;;25451:8;;;;:::i;:::-;;-1:-1:-1;25474:10:0;;-1:-1:-1;25482:2:0;25474:10;;:::i;:::-;;;25418:78;;;25506:19;25538:6;25528:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25528:17:0;;25506:39;;25556:154;25563:10;;25556:154;;25590:11;25600:1;25590:11;;:::i;:::-;;-1:-1:-1;25659:10:0;25667:2;25659:5;:10;:::i;:::-;25646:24;;:2;:24;:::i;:::-;25633:39;;25616:6;25623;25616:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;25616:56:0;;;;;;;;-1:-1:-1;25687:11:0;25696:2;25687:11;;:::i;:::-;;;25556:154;;7093:204;7190:1;7181:10;;;7164:14;7261:20;;;;;;;;;;;;:28;;-1:-1:-1;;;7245:4:0;7237:12;;;7217:33;;;;7261:28;;;;;7093:204::o;60550:382::-;60704:7;;60722:19;60728:2;60732:8;60722:5;:19::i;:::-;60774:69;60805:1;60809:2;60813:12;60827:8;60837:5;60774:22;:69::i;65056:159::-;65119:24;65175:31;65119:24;65198:7;65175:22;:31::i;64009:1039::-;64196:6;-1:-1:-1;;;;;64219:13:0;;17569:19;:23;64215:826;;-1:-1:-1;64255:4:0;64296:12;64274:689;64320:23;64335:8;64320:12;:23;:::i;:::-;64310:7;:33;64274:689;;;64378:72;;-1:-1:-1;;;64378:72:0;;-1:-1:-1;;;;;64378:36:0;;;;;:72;;27854:10;;64429:4;;64435:7;;64444:5;;64378:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64378:72:0;;;;;;;;-1:-1:-1;;64378:72:0;;;;;;;;;;;;:::i;:::-;;;64374:574;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64634:13:0;;64630:299;;64681:63;;-1:-1:-1;;;64681:63:0;;;;;;;:::i;64630:299::-;64871:6;64865:13;64856:6;64852:2;64848:15;64841:38;64374:574;64502:1;:56;;;;-1:-1:-1;;;;;;;64507:51:0;;-1:-1:-1;;;64507:51:0;64502:56;64498:60;;64451:127;64345:9;;;;:::i;:::-;;;;64274:689;;;;64977:8;;64215:826;-1:-1:-1;65025:4:0;64215:826;64009:1039;;;;;;;:::o;60942:769::-;61067:7;;61103:12;61095:62;;;;-1:-1:-1;;;61095:62:0;;17407:2:1;61095:62:0;;;17389:21:1;17446:2;17426:18;;;17419:30;17485:34;17465:18;;;17458:62;-1:-1:-1;;;17536:18:1;;;17529:35;17581:19;;61095:62:0;17205:401:1;61095:62:0;-1:-1:-1;;;;;61176:16:0;;61168:64;;;;-1:-1:-1;;;61168:64:0;;13541:2:1;61168:64:0;;;13523:21:1;13580:2;13560:18;;;13553:30;13619:34;13599:18;;;13592:62;-1:-1:-1;;;13670:18:1;;;13663:33;13713:19;;61168:64:0;13339:399:1;61168:64:0;61340:8;61329:7;;:19;;;;;;;:::i;:::-;;;;-1:-1:-1;;61359:25:0;;;;:7;:25;;;;;:30;;-1:-1:-1;;;;;;61359:30:0;-1:-1:-1;;;;;61359:30:0;;;;;61400:32;;61359:25;61400:14;:32::i;:::-;61572:16;61552:151;61599:27;61618:8;61599:16;:27;:::i;:::-;61589:7;:37;61552:151;;;61658:33;;61683:7;;-1:-1:-1;;;;;61658:33:0;;;61675:1;;61658:33;;61675:1;;61658:33;61628:9;;;;:::i;:::-;;;;61552:151;;11864:1234;12004:1;11995:10;;;11946:19;12161:20;;;;;;;;;;;11946:19;;11995:10;12085:4;12077:12;;;;12266:18;;;12259:26;12338:6;;12335:756;;12436:22;:2;:20;:22::i;:::-;12421:37;;:11;:37;12415:1;12405:6;:11;;12404:55;12390:69;;12335:756;;;12559:1;12550:6;:10;12542:75;;;;-1:-1:-1;;;12542:75:0;;16219:2:1;12542:75:0;;;16201:21:1;16258:2;16238:18;;;16231:30;16297:34;16277:18;;;16270:62;-1:-1:-1;;;16348:18:1;;;16341:50;16408:19;;12542:75:0;16017:416:1;12542:75:0;-1:-1:-1;;;12669:8:0;;;12800:12;:20;;;;;;;;;;;12669:8;;-1:-1:-1;12860:6:0;;12857:207;;12966:22;:2;:20;:22::i;:::-;12959:3;:29;12942:47;;12953:1;12943:6;:11;;12942:47;12928:61;;13016:5;;12857:207;12511:569;;;11967:1131;;;11864:1234;;;;:::o;4061:201::-;4123:5;4179:16;;;;;;;;;;;;;;;;;4235:3;2577:64;4197:18;4212:2;4197:14;:18::i;:::-;:33;4196:42;;4179:60;;;;;;;;:::i;:::-;;;;;;;;4061:201;-1:-1:-1;;4061:201:0:o;3288:169::-;3347:7;3380:1;3375:2;:6;3367:15;;;;;;-1:-1:-1;3431:1:0;:6;;;3425:13;;3288:169::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:72;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:45;;;532:1;529;522:12;491:45;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;14:631;;;;;:::o;650:347::-;701:8;711:6;765:3;758:4;750:6;746:17;742:27;732:55;;783:1;780;773:12;732:55;-1:-1:-1;806:20:1;;849:18;838:30;;835:50;;;881:1;878;871:12;835:50;918:4;910:6;906:17;894:29;;970:3;963:4;954:6;946;942:19;938:30;935:39;932:59;;;987:1;984;977:12;932:59;650:347;;;;;:::o;1002:247::-;1061:6;1114:2;1102:9;1093:7;1089:23;1085:32;1082:52;;;1130:1;1127;1120:12;1082:52;1169:9;1156:23;1188:31;1213:5;1188:31;:::i;:::-;1238:5;1002:247;-1:-1:-1;;;1002:247:1:o;1254:388::-;1322:6;1330;1383:2;1371:9;1362:7;1358:23;1354:32;1351:52;;;1399:1;1396;1389:12;1351:52;1438:9;1425:23;1457:31;1482:5;1457:31;:::i;:::-;1507:5;-1:-1:-1;1564:2:1;1549:18;;1536:32;1577:33;1536:32;1577:33;:::i;:::-;1629:7;1619:17;;;1254:388;;;;;:::o;1647:456::-;1724:6;1732;1740;1793:2;1781:9;1772:7;1768:23;1764:32;1761:52;;;1809:1;1806;1799:12;1761:52;1848:9;1835:23;1867:31;1892:5;1867:31;:::i;:::-;1917:5;-1:-1:-1;1974:2:1;1959:18;;1946:32;1987:33;1946:32;1987:33;:::i;:::-;1647:456;;2039:7;;-1:-1:-1;;;2093:2:1;2078:18;;;;2065:32;;1647:456::o;2108:794::-;2203:6;2211;2219;2227;2280:3;2268:9;2259:7;2255:23;2251:33;2248:53;;;2297:1;2294;2287:12;2248:53;2336:9;2323:23;2355:31;2380:5;2355:31;:::i;:::-;2405:5;-1:-1:-1;2462:2:1;2447:18;;2434:32;2475:33;2434:32;2475:33;:::i;:::-;2527:7;-1:-1:-1;2581:2:1;2566:18;;2553:32;;-1:-1:-1;2636:2:1;2621:18;;2608:32;2663:18;2652:30;;2649:50;;;2695:1;2692;2685:12;2649:50;2718:22;;2771:4;2763:13;;2759:27;-1:-1:-1;2749:55:1;;2800:1;2797;2790:12;2749:55;2823:73;2888:7;2883:2;2870:16;2865:2;2861;2857:11;2823:73;:::i;:::-;2813:83;;;2108:794;;;;;;;:::o;2907:416::-;2972:6;2980;3033:2;3021:9;3012:7;3008:23;3004:32;3001:52;;;3049:1;3046;3039:12;3001:52;3088:9;3075:23;3107:31;3132:5;3107:31;:::i;:::-;3157:5;-1:-1:-1;3214:2:1;3199:18;;3186:32;3256:15;;3249:23;3237:36;;3227:64;;3287:1;3284;3277:12;3328:315;3396:6;3404;3457:2;3445:9;3436:7;3432:23;3428:32;3425:52;;;3473:1;3470;3463:12;3425:52;3512:9;3499:23;3531:31;3556:5;3531:31;:::i;:::-;3581:5;3633:2;3618:18;;;;3605:32;;-1:-1:-1;;;3328:315:1:o;3648:245::-;3706:6;3759:2;3747:9;3738:7;3734:23;3730:32;3727:52;;;3775:1;3772;3765:12;3727:52;3814:9;3801:23;3833:30;3857:5;3833:30;:::i;3898:249::-;3967:6;4020:2;4008:9;3999:7;3995:23;3991:32;3988:52;;;4036:1;4033;4026:12;3988:52;4068:9;4062:16;4087:30;4111:5;4087:30;:::i;4152:409::-;4222:6;4230;4283:2;4271:9;4262:7;4258:23;4254:32;4251:52;;;4299:1;4296;4289:12;4251:52;4339:9;4326:23;4372:18;4364:6;4361:30;4358:50;;;4404:1;4401;4394:12;4358:50;4443:58;4493:7;4484:6;4473:9;4469:22;4443:58;:::i;:::-;4520:8;;4417:84;;-1:-1:-1;4152:409:1;-1:-1:-1;;;;4152:409:1:o;4981:450::-;5050:6;5103:2;5091:9;5082:7;5078:23;5074:32;5071:52;;;5119:1;5116;5109:12;5071:52;5159:9;5146:23;5192:18;5184:6;5181:30;5178:50;;;5224:1;5221;5214:12;5178:50;5247:22;;5300:4;5292:13;;5288:27;-1:-1:-1;5278:55:1;;5329:1;5326;5319:12;5278:55;5352:73;5417:7;5412:2;5399:16;5394:2;5390;5386:11;5352:73;:::i;5436:180::-;5495:6;5548:2;5536:9;5527:7;5523:23;5519:32;5516:52;;;5564:1;5561;5554:12;5516:52;-1:-1:-1;5587:23:1;;5436:180;-1:-1:-1;5436:180:1:o;5621:315::-;5689:6;5697;5750:2;5738:9;5729:7;5725:23;5721:32;5718:52;;;5766:1;5763;5756:12;5718:52;5802:9;5789:23;5779:33;;5862:2;5851:9;5847:18;5834:32;5875:31;5900:5;5875:31;:::i;6269:257::-;6310:3;6348:5;6342:12;6375:6;6370:3;6363:19;6391:63;6447:6;6440:4;6435:3;6431:14;6424:4;6417:5;6413:16;6391:63;:::i;:::-;6508:2;6487:15;-1:-1:-1;;6483:29:1;6474:39;;;;6515:4;6470:50;;6269:257;-1:-1:-1;;6269:257:1:o;6531:973::-;6616:12;;6581:3;;6671:1;6691:18;;;;6744;;;;6771:61;;6825:4;6817:6;6813:17;6803:27;;6771:61;6851:2;6899;6891:6;6888:14;6868:18;6865:38;6862:161;;;6945:10;6940:3;6936:20;6933:1;6926:31;6980:4;6977:1;6970:15;7008:4;7005:1;6998:15;6862:161;7039:18;7066:104;;;;7184:1;7179:319;;;;7032:466;;7066:104;-1:-1:-1;;7099:24:1;;7087:37;;7144:16;;;;-1:-1:-1;7066:104:1;;7179:319;19536:1;19529:14;;;19573:4;19560:18;;7273:1;7287:165;7301:6;7298:1;7295:13;7287:165;;;7379:14;;7366:11;;;7359:35;7422:16;;;;7316:10;;7287:165;;;7291:3;;7481:6;7476:3;7472:16;7465:23;;7032:466;;;;;;;6531:973;;;;:::o;7509:698::-;7932:3;7960:73;7994:38;8028:3;8020:6;7994:38;:::i;:::-;7986:6;7960:73;:::i;:::-;-1:-1:-1;;;8049:2:1;8042:15;8086:6;8080:13;8102:60;8155:6;8151:1;8147:2;8143:10;8136:4;8128:6;8124:17;8102:60;:::i;:::-;8182:15;8199:1;8178:23;;7509:698;-1:-1:-1;;;;;7509:698:1:o;8630:488::-;-1:-1:-1;;;;;8899:15:1;;;8881:34;;8951:15;;8946:2;8931:18;;8924:43;8998:2;8983:18;;8976:34;;;9046:3;9041:2;9026:18;;9019:31;;;8824:4;;9067:45;;9092:19;;9084:6;9067:45;:::i;:::-;9059:53;8630:488;-1:-1:-1;;;;;;8630:488:1:o;9315:298::-;9498:6;9491:14;9484:22;9473:9;9466:41;9543:2;9538;9527:9;9523:18;9516:30;9447:4;9563:44;9603:2;9592:9;9588:18;9580:6;9563:44;:::i;9618:219::-;9767:2;9756:9;9749:21;9730:4;9787:44;9827:2;9816:9;9812:18;9804:6;9787:44;:::i;12557:417::-;12759:2;12741:21;;;12798:2;12778:18;;;12771:30;12837:34;12832:2;12817:18;;12810:62;-1:-1:-1;;;12903:2:1;12888:18;;12881:51;12964:3;12949:19;;12557:417::o;16784:416::-;16986:2;16968:21;;;17025:2;17005:18;;;16998:30;17064:34;17059:2;17044:18;;17037:62;-1:-1:-1;;;17130:2:1;17115:18;;17108:50;17190:3;17175:19;;16784:416::o;19589:128::-;19629:3;19660:1;19656:6;19653:1;19650:13;19647:39;;;19666:18;;:::i;:::-;-1:-1:-1;19702:9:1;;19589:128::o;19722:120::-;19762:1;19788;19778:35;;19793:18;;:::i;:::-;-1:-1:-1;19827:9:1;;19722:120::o;19847:168::-;19887:7;19953:1;19949;19945:6;19941:14;19938:1;19935:21;19930:1;19923:9;19916:17;19912:45;19909:71;;;19960:18;;:::i;:::-;-1:-1:-1;20000:9:1;;19847:168::o;20020:125::-;20060:4;20088:1;20085;20082:8;20079:34;;;20093:18;;:::i;:::-;-1:-1:-1;20130:9:1;;20020:125::o;20150:258::-;20222:1;20232:113;20246:6;20243:1;20240:13;20232:113;;;20322:11;;;20316:18;20303:11;;;20296:39;20268:2;20261:10;20232:113;;;20363:6;20360:1;20357:13;20354:48;;;-1:-1:-1;;20398:1:1;20380:16;;20373:27;20150:258::o;20413:380::-;20492:1;20488:12;;;;20535;;;20556:61;;20610:4;20602:6;20598:17;20588:27;;20556:61;20663:2;20655:6;20652:14;20632:18;20629:38;20626:161;;;20709:10;20704:3;20700:20;20697:1;20690:31;20744:4;20741:1;20734:15;20772:4;20769:1;20762:15;20626:161;;20413:380;;;:::o;20798:135::-;20837:3;-1:-1:-1;;20858:17:1;;20855:43;;;20878:18;;:::i;:::-;-1:-1:-1;20925:1:1;20914:13;;20798:135::o;20938:112::-;20970:1;20996;20986:35;;21001:18;;:::i;:::-;-1:-1:-1;21035:9:1;;20938:112::o;21055:127::-;21116:10;21111:3;21107:20;21104:1;21097:31;21147:4;21144:1;21137:15;21171:4;21168:1;21161:15;21187:127;21248:10;21243:3;21239:20;21236:1;21229:31;21279:4;21276:1;21269:15;21303:4;21300:1;21293:15;21319:127;21380:10;21375:3;21371:20;21368:1;21361:31;21411:4;21408:1;21401:15;21435:4;21432:1;21425:15;21451:127;21512:10;21507:3;21503:20;21500:1;21493:31;21543:4;21540:1;21533:15;21567:4;21564:1;21557:15;21583:131;-1:-1:-1;;;;;21658:31:1;;21648:42;;21638:70;;21704:1;21701;21694:12;21719:131;-1:-1:-1;;;;;;21793:32:1;;21783:43;;21773:71;;21840:1;21837;21830:12
Swarm Source
ipfs://403f3322f937561b98af3f53e6338672868cbcd8577c703c35dfcdcf77f5ffd3
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.