Token

Eva (EVA)

ERC-721

NFT

Overview

Max Total Supply

1,500 EVA

Holders

162

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x5f72e6238df6fc003f3f8679ea680c582d7aa67a

Filtered by Token Holder

0xAB12D9a5b0Fd55BCB9Cfb034875ac7300F5641dc

Balance

1 EVA

0xab12d9a5b0fd55bcb9cfb034875ac7300f5641dc

OVERVIEW

1500 powerful Eva’s from the Mandox universe to unite all communities and bring women to the front in the amazing world of web3. Embrace. Empower. Uplift.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

EvaTribe

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *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

Contract ABI

[{"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

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

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

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services