Token

VOXVOT (VXVT)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

198 VXVT

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x8a74ea55e6aca0a356c2e9f0ea6f6c60d4b1313c

Filtered by Token Holder

0x886B1627a6D5A1074DabbCE9f5Ec0C267aC6Ec5B

liquiditywen.eth

Balance

1 VXVT

0x886B1627a6D5A1074DabbCE9f5Ec0C267aC6Ec5B

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

VOXVOT

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

//SPDX-License-Identifier: MIT
// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/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: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/Pausable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// File: contracts/VOXOVTNFT.sol


// File: @maticnetwork/fx-portal/contracts/lib/Merkle.sol


pragma solidity ^0.8.0;

library Merkle {
    function checkMembership(
        bytes32 leaf,
        uint256 index,
        bytes32 rootHash,
        bytes memory proof
    ) internal pure returns (bool) {
        require(proof.length % 32 == 0, "Invalid proof length");
        uint256 proofHeight = proof.length / 32;
        // Proof of size n means, height of the tree is n+1.
        // In a tree of height n+1, max #leafs possible is 2 ^ n
        require(index < 2 ** proofHeight, "Leaf index is too big");

        bytes32 proofElement;
        bytes32 computedHash = leaf;
        for (uint256 i = 32; i <= proof.length; i += 32) {
            assembly {
                proofElement := mload(add(proof, i))
            }

            if (index % 2 == 0) {
                computedHash = keccak256(
                    abi.encodePacked(computedHash, proofElement)
                );
            } else {
                computedHash = keccak256(
                    abi.encodePacked(proofElement, computedHash)
                );
            }

            index = index / 2;
        }
        return computedHash == rootHash;
    }
}

// File: @maticnetwork/fx-portal/contracts/lib/RLPReader.sol


/*
* @author Hamdi Allam [email protected]
* Please reach out with any questions or concerns
*/
pragma solidity ^0.8.0;

library RLPReader {
    uint8 constant STRING_SHORT_START = 0x80;
    uint8 constant STRING_LONG_START  = 0xb8;
    uint8 constant LIST_SHORT_START   = 0xc0;
    uint8 constant LIST_LONG_START    = 0xf8;
    uint8 constant WORD_SIZE = 32;

    struct RLPItem {
        uint len;
        uint memPtr;
    }

    struct Iterator {
        RLPItem item;   // Item that's being iterated over.
        uint nextPtr;   // Position of the next item in the list.
    }

    /*
    * @dev Returns the next element in the iteration. Reverts if it has not next element.
    * @param self The iterator.
    * @return The next element in the iteration.
    */
    function next(Iterator memory self) internal pure returns (RLPItem memory) {
        require(hasNext(self));

        uint ptr = self.nextPtr;
        uint itemLength = _itemLength(ptr);
        self.nextPtr = ptr + itemLength;

        return RLPItem(itemLength, ptr);
    }

    /*
    * @dev Returns true if the iteration has more elements.
    * @param self The iterator.
    * @return true if the iteration has more elements.
    */
    function hasNext(Iterator memory self) internal pure returns (bool) {
        RLPItem memory item = self.item;
        return self.nextPtr < item.memPtr + item.len;
    }

    /*
    * @param item RLP encoded bytes
    */
    function toRlpItem(bytes memory item) internal pure returns (RLPItem memory) {
        uint memPtr;
        assembly {
            memPtr := add(item, 0x20)
        }

        return RLPItem(item.length, memPtr);
    }

    /*
    * @dev Create an iterator. Reverts if item is not a list.
    * @param self The RLP item.
    * @return An 'Iterator' over the item.
    */
    function iterator(RLPItem memory self) internal pure returns (Iterator memory) {
        require(isList(self));

        uint ptr = self.memPtr + _payloadOffset(self.memPtr);
        return Iterator(self, ptr);
    }

    /*
    * @param item RLP encoded bytes
    */
    function rlpLen(RLPItem memory item) internal pure returns (uint) {
        return item.len;
    }

    /*
    * @param item RLP encoded bytes
    */
    function payloadLen(RLPItem memory item) internal pure returns (uint) {
        return item.len - _payloadOffset(item.memPtr);
    }

    /*
    * @param item RLP encoded list in bytes
    */
    function toList(RLPItem memory item) internal pure returns (RLPItem[] memory) {
        require(isList(item));

        uint items = numItems(item);
        RLPItem[] memory result = new RLPItem[](items);

        uint memPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint dataLen;
        for (uint i = 0; i < items; i++) {
            dataLen = _itemLength(memPtr);
            result[i] = RLPItem(dataLen, memPtr); 
            memPtr = memPtr + dataLen;
        }

        return result;
    }

    // @return indicator whether encoded payload is a list. negate this function call for isData.
    function isList(RLPItem memory item) internal pure returns (bool) {
        if (item.len == 0) return false;

        uint8 byte0;
        uint memPtr = item.memPtr;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < LIST_SHORT_START)
            return false;
        return true;
    }

    /*
     * @dev A cheaper version of keccak256(toRlpBytes(item)) that avoids copying memory.
     * @return keccak256 hash of RLP encoded bytes.
     */
    function rlpBytesKeccak256(RLPItem memory item) internal pure returns (bytes32) {
        uint256 ptr = item.memPtr;
        uint256 len = item.len;
        bytes32 result;
        assembly {
            result := keccak256(ptr, len)
        }
        return result;
    }

    function payloadLocation(RLPItem memory item) internal pure returns (uint, uint) {
        uint offset = _payloadOffset(item.memPtr);
        uint memPtr = item.memPtr + offset;
        uint len = item.len - offset; // data length
        return (memPtr, len);
    }

    /*
     * @dev A cheaper version of keccak256(toBytes(item)) that avoids copying memory.
     * @return keccak256 hash of the item payload.
     */
    function payloadKeccak256(RLPItem memory item) internal pure returns (bytes32) {
        (uint memPtr, uint len) = payloadLocation(item);
        bytes32 result;
        assembly {
            result := keccak256(memPtr, len)
        }
        return result;
    }

    /** RLPItem conversions into data types **/

    // @returns raw rlp encoding in bytes
    function toRlpBytes(RLPItem memory item) internal pure returns (bytes memory) {
        bytes memory result = new bytes(item.len);
        if (result.length == 0) return result;
        
        uint ptr;
        assembly {
            ptr := add(0x20, result)
        }

        copy(item.memPtr, ptr, item.len);
        return result;
    }

    // any non-zero byte is considered true
    function toBoolean(RLPItem memory item) internal pure returns (bool) {
        require(item.len == 1);
        uint result;
        uint memPtr = item.memPtr;
        assembly {
            result := byte(0, mload(memPtr))
        }

        return result == 0 ? false : true;
    }

    function toAddress(RLPItem memory item) internal pure returns (address) {
        // 1 byte for the length prefix
        require(item.len == 21);

        return address(uint160(toUint(item)));
    }

    function toUint(RLPItem memory item) internal pure returns (uint) {
        require(item.len > 0 && item.len <= 33);

        uint offset = _payloadOffset(item.memPtr);
        uint len = item.len - offset;

        uint result;
        uint memPtr = item.memPtr + offset;
        assembly {
            result := mload(memPtr)

            // shfit to the correct location if neccesary
            if lt(len, 32) {
                result := div(result, exp(256, sub(32, len)))
            }
        }

        return result;
    }

    // enforces 32 byte length
    function toUintStrict(RLPItem memory item) internal pure returns (uint) {
        // one byte prefix
        require(item.len == 33);

        uint result;
        uint memPtr = item.memPtr + 1;
        assembly {
            result := mload(memPtr)
        }

        return result;
    }

    function toBytes(RLPItem memory item) internal pure returns (bytes memory) {
        require(item.len > 0);

        uint offset = _payloadOffset(item.memPtr);
        uint len = item.len - offset; // data length
        bytes memory result = new bytes(len);

        uint destPtr;
        assembly {
            destPtr := add(0x20, result)
        }

        copy(item.memPtr + offset, destPtr, len);
        return result;
    }

    /*
    * Private Helpers
    */

    // @return number of payload items inside an encoded list.
    function numItems(RLPItem memory item) private pure returns (uint) {
        if (item.len == 0) return 0;

        uint count = 0;
        uint currPtr = item.memPtr + _payloadOffset(item.memPtr);
        uint endPtr = item.memPtr + item.len;
        while (currPtr < endPtr) {
           currPtr = currPtr + _itemLength(currPtr); // skip over an item
           count++;
        }

        return count;
    }

    // @return entire rlp item byte length
    function _itemLength(uint memPtr) private pure returns (uint) {
        uint itemLen;
        uint byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START)
            itemLen = 1;
        
        else if (byte0 < STRING_LONG_START)
            itemLen = byte0 - STRING_SHORT_START + 1;

        else if (byte0 < LIST_SHORT_START) {
            assembly {
                let byteLen := sub(byte0, 0xb7) // # of bytes the actual length is
                memPtr := add(memPtr, 1) // skip over the first byte
                /* 32 byte word size */
                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to get the len
                itemLen := add(dataLen, add(byteLen, 1))
            }
        }

        else if (byte0 < LIST_LONG_START) {
            itemLen = byte0 - LIST_SHORT_START + 1;
        } 

        else {
            assembly {
                let byteLen := sub(byte0, 0xf7)
                memPtr := add(memPtr, 1)

                let dataLen := div(mload(memPtr), exp(256, sub(32, byteLen))) // right shifting to the correct length
                itemLen := add(dataLen, add(byteLen, 1))
            }
        }

        return itemLen;
    }

    // @return number of bytes until the data
    function _payloadOffset(uint memPtr) private pure returns (uint) {
        uint byte0;
        assembly {
            byte0 := byte(0, mload(memPtr))
        }

        if (byte0 < STRING_SHORT_START) 
            return 0;
        else if (byte0 < STRING_LONG_START || (byte0 >= LIST_SHORT_START && byte0 < LIST_LONG_START))
            return 1;
        else if (byte0 < LIST_SHORT_START)  // being explicit
            return byte0 - (STRING_LONG_START - 1) + 1;
        else
            return byte0 - (LIST_LONG_START - 1) + 1;
    }

    /*
    * @param src Pointer to source
    * @param dest Pointer to destination
    * @param len Amount of memory to copy from the source
    */
    function copy(uint src, uint dest, uint len) private pure {
        if (len == 0) return;

        // copy as many word sizes as possible
        for (; len >= WORD_SIZE; len -= WORD_SIZE) {
            assembly {
                mstore(dest, mload(src))
            }

            src += WORD_SIZE;
            dest += WORD_SIZE;
        }

        if (len == 0) return;

        // left over bytes. Mask is used to remove unwanted bytes from the word
        uint mask = 256 ** (WORD_SIZE - len) - 1;

        assembly {
            let srcpart := and(mload(src), not(mask)) // zero out src
            let destpart := and(mload(dest), mask) // retrieve the bytes
            mstore(dest, or(destpart, srcpart))
        }
    }
}

// File: @maticnetwork/fx-portal/contracts/lib/ExitPayloadReader.sol


pragma solidity ^0.8.0;


library ExitPayloadReader {
  using RLPReader for bytes;
  using RLPReader for RLPReader.RLPItem;

  uint8 constant WORD_SIZE = 32;

  struct ExitPayload {
    RLPReader.RLPItem[] data;
  }

  struct Receipt {
    RLPReader.RLPItem[] data;
    bytes raw;
    uint256 logIndex;
  }

  struct Log {
    RLPReader.RLPItem data;
    RLPReader.RLPItem[] list;
  }

  struct LogTopics {
    RLPReader.RLPItem[] data;
  }

  // copy paste of private copy() from RLPReader to avoid changing of existing contracts
  function copy(uint src, uint dest, uint len) private pure {
        if (len == 0) return;

        // copy as many word sizes as possible
        for (; len >= WORD_SIZE; len -= WORD_SIZE) {
            assembly {
                mstore(dest, mload(src))
            }

            src += WORD_SIZE;
            dest += WORD_SIZE;
        }

        // left over bytes. Mask is used to remove unwanted bytes from the word
        uint mask = 256 ** (WORD_SIZE - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask)) // zero out src
            let destpart := and(mload(dest), mask) // retrieve the bytes
            mstore(dest, or(destpart, srcpart))
        }
    }

  function toExitPayload(bytes memory data)
        internal
        pure
        returns (ExitPayload memory)
    {
        RLPReader.RLPItem[] memory payloadData = data
            .toRlpItem()
            .toList();

        return ExitPayload(payloadData);
    }

    function getHeaderNumber(ExitPayload memory payload) internal pure returns(uint256) {
      return payload.data[0].toUint();
    }

    function getBlockProof(ExitPayload memory payload) internal pure returns(bytes memory) {
      return payload.data[1].toBytes();
    }

    function getBlockNumber(ExitPayload memory payload) internal pure returns(uint256) {
      return payload.data[2].toUint();
    }

    function getBlockTime(ExitPayload memory payload) internal pure returns(uint256) {
      return payload.data[3].toUint();
    }

    function getTxRoot(ExitPayload memory payload) internal pure returns(bytes32) {
      return bytes32(payload.data[4].toUint());
    }

    function getReceiptRoot(ExitPayload memory payload) internal pure returns(bytes32) {
      return bytes32(payload.data[5].toUint());
    }

    function getReceipt(ExitPayload memory payload) internal pure returns(Receipt memory receipt) {
      receipt.raw = payload.data[6].toBytes();
      RLPReader.RLPItem memory receiptItem = receipt.raw.toRlpItem();

      if (receiptItem.isList()) {
          // legacy tx
          receipt.data = receiptItem.toList();
      } else {
          // pop first byte before parsting receipt
          bytes memory typedBytes = receipt.raw;
          bytes memory result = new bytes(typedBytes.length - 1);
          uint256 srcPtr;
          uint256 destPtr;
          assembly {
              srcPtr := add(33, typedBytes)
              destPtr := add(0x20, result)
          }

          copy(srcPtr, destPtr, result.length);
          receipt.data = result.toRlpItem().toList();
      }

      receipt.logIndex = getReceiptLogIndex(payload);
      return receipt;
    }

    function getReceiptProof(ExitPayload memory payload) internal pure returns(bytes memory) {
      return payload.data[7].toBytes();
    }

    function getBranchMaskAsBytes(ExitPayload memory payload) internal pure returns(bytes memory) {
      return payload.data[8].toBytes();
    }

    function getBranchMaskAsUint(ExitPayload memory payload) internal pure returns(uint256) {
      return payload.data[8].toUint();
    }

    function getReceiptLogIndex(ExitPayload memory payload) internal pure returns(uint256) {
      return payload.data[9].toUint();
    }
    
    // Receipt methods
    function toBytes(Receipt memory receipt) internal pure returns(bytes memory) {
        return receipt.raw;
    }

    function getLog(Receipt memory receipt) internal pure returns(Log memory) {
        RLPReader.RLPItem memory logData = receipt.data[3].toList()[receipt.logIndex];
        return Log(logData, logData.toList());
    }

    // Log methods
    function getEmitter(Log memory log) internal pure returns(address) {
      return RLPReader.toAddress(log.list[0]);
    }

    function getTopics(Log memory log) internal pure returns(LogTopics memory) {
        return LogTopics(log.list[1].toList());
    }

    function getData(Log memory log) internal pure returns(bytes memory) {
        return log.list[2].toBytes();
    }

    function toRlpBytes(Log memory log) internal pure returns(bytes memory) {
      return log.data.toRlpBytes();
    }

    // LogTopics methods
    function getField(LogTopics memory topics, uint256 index) internal pure returns(RLPReader.RLPItem memory) {
      return topics.data[index];
    }
}

// File: @maticnetwork/fx-portal/contracts/lib/MerklePatriciaProof.sol


pragma solidity ^0.8.0;


library MerklePatriciaProof {
    /*
     * @dev Verifies a merkle patricia proof.
     * @param value The terminating value in the trie.
     * @param encodedPath The path in the trie leading to value.
     * @param rlpParentNodes The rlp encoded stack of nodes.
     * @param root The root hash of the trie.
     * @return The boolean validity of the proof.
     */
    function verify(
        bytes memory value,
        bytes memory encodedPath,
        bytes memory rlpParentNodes,
        bytes32 root
    ) internal pure returns (bool _bool) {
        RLPReader.RLPItem memory item = RLPReader.toRlpItem(rlpParentNodes);
        RLPReader.RLPItem[] memory parentNodes = RLPReader.toList(item);

        bytes memory currentNode;
        RLPReader.RLPItem[] memory currentNodeList;

        bytes32 nodeKey = root;
        uint256 pathPtr = 0;

        bytes memory path = _getNibbleArray(encodedPath);
        if (path.length == 0) {
            _bool =  false;
        }

        for (uint256 i = 0; i < parentNodes.length; i++) {
            if (pathPtr > path.length) {
                _bool = false;
            }

            currentNode = RLPReader.toRlpBytes(parentNodes[i]);
            if (nodeKey != keccak256(currentNode)) {
                _bool = false;
            }
            currentNodeList = RLPReader.toList(parentNodes[i]);

            if (currentNodeList.length == 17) {
                if (pathPtr == path.length) {
                    if (
                        keccak256(RLPReader.toBytes(currentNodeList[16])) ==
                        keccak256(value)
                    ) {
                        _bool = true;
                    } else {
                        _bool = false;
                    }
                }

                uint8 nextPathNibble = uint8(path[pathPtr]);
                if (nextPathNibble > 16) {
                    _bool = false;
                }
                nodeKey = bytes32(
                    RLPReader.toUintStrict(currentNodeList[nextPathNibble])
                );
                pathPtr += 1;
            } else if (currentNodeList.length == 2) {
                uint256 traversed = _nibblesToTraverse(
                    RLPReader.toBytes(currentNodeList[0]),
                    path,
                    pathPtr
                );
                if (pathPtr + traversed == path.length) {
                    //leaf node
                    if (
                        keccak256(RLPReader.toBytes(currentNodeList[1])) ==
                        keccak256(value)
                    ) {
                        _bool = true;
                    } else {
                        _bool = false;
                    }
                }

                //extension node
                if (traversed == 0) {
                    _bool = false;
                }

                pathPtr += traversed;
                nodeKey = bytes32(RLPReader.toUintStrict(currentNodeList[1]));
            } else {
                _bool = false;
            }
        }
    }

    function _nibblesToTraverse(
        bytes memory encodedPartialPath,
        bytes memory path,
        uint256 pathPtr
    ) private pure returns (uint256) {
        uint256 len = 0;
        // encodedPartialPath has elements that are each two hex characters (1 byte), but partialPath
        // and slicedPath have elements that are each one hex character (1 nibble)
        bytes memory partialPath = _getNibbleArray(encodedPartialPath);
        bytes memory slicedPath = new bytes(partialPath.length);

        // pathPtr counts nibbles in path
        // partialPath.length is a number of nibbles
        for (uint256 i = pathPtr; i < pathPtr + partialPath.length; i++) {
            bytes1 pathNibble = path[i];
            slicedPath[i - pathPtr] = pathNibble;
        }

        if (keccak256(partialPath) == keccak256(slicedPath)) {
            len = partialPath.length;
        } else {
            len = 0;
        }
        return len;
    }

    // bytes b must be hp encoded
    function _getNibbleArray(bytes memory b)
        internal
        pure
        returns (bytes memory)
    {
        bytes memory nibbles = "";
        if (b.length > 0) {
            uint8 offset;
            uint8 hpNibble = uint8(_getNthNibbleOfBytes(0, b));
            if (hpNibble == 1 || hpNibble == 3) {
                nibbles = new bytes(b.length * 2 - 1);
                bytes1 oddNibble = _getNthNibbleOfBytes(1, b);
                nibbles[0] = oddNibble;
                offset = 1;
            } else {
                nibbles = new bytes(b.length * 2 - 2);
                offset = 0;
            }

            for (uint256 i = offset; i < nibbles.length; i++) {
                nibbles[i] = _getNthNibbleOfBytes(i - offset + 2, b);
            }
        }
        return nibbles;
    }

    function _getNthNibbleOfBytes(uint256 n, bytes memory str)
        private
        pure
        returns (bytes1)
    {
        return
            bytes1(
                n % 2 == 0 ? uint8(str[n / 2]) / 0x10 : uint8(str[n / 2]) % 0x10
            );
    }
}
// File: @maticnetwork/fx-portal/contracts/tunnel/FxBaseRootTunnel.sol


pragma solidity ^0.8.0;






interface IFxStateSender {
    function sendMessageToChild(address _receiver, bytes calldata _data) external;
}

contract ICheckpointManager {
    struct HeaderBlock {
        bytes32 root;
        uint256 start;
        uint256 end;
        uint256 createdAt;
        address proposer;
    }

    /**
     * @notice mapping of checkpoint header numbers to block details
     * @dev These checkpoints are submited by plasma contracts
     */
    mapping(uint256 => HeaderBlock) public headerBlocks;
}

abstract contract FxBaseRootTunnel {
    using RLPReader for RLPReader.RLPItem;
    using Merkle for bytes32;
    using ExitPayloadReader for bytes;
    using ExitPayloadReader for ExitPayloadReader.ExitPayload;
    using ExitPayloadReader for ExitPayloadReader.Log;
    using ExitPayloadReader for ExitPayloadReader.LogTopics;
    using ExitPayloadReader for ExitPayloadReader.Receipt;

    // keccak256(MessageSent(bytes))
    bytes32 public constant SEND_MESSAGE_EVENT_SIG = 0x8c5261668696ce22758910d05bab8f186d6eb247ceac2af2e82c7dc17669b036;

    // state sender contract
    IFxStateSender public fxRoot;
    // root chain manager
    ICheckpointManager public checkpointManager;
    // child tunnel contract which receives and sends messages 
    address public fxChildTunnel;

    // storage to avoid duplicate exits
    mapping(bytes32 => bool) public processedExits;

    constructor(address _checkpointManager, address _fxRoot) {
        checkpointManager = ICheckpointManager(_checkpointManager);
        fxRoot = IFxStateSender(_fxRoot);
    }

    // set fxChildTunnel if not set already
    function setFxChildTunnel(address _fxChildTunnel) public {
        require(fxChildTunnel == address(0x0), "FxBaseRootTunnel: CHILD_TUNNEL_ALREADY_SET");
        fxChildTunnel = _fxChildTunnel;
    }

    /**
     * @notice Send bytes message to Child Tunnel
     * @param message bytes message that will be sent to Child Tunnel
     * some message examples -
     *   abi.encode(tokenId);
     *   abi.encode(tokenId, tokenMetadata);
     *   abi.encode(messageType, messageData);
     */
    function _sendMessageToChild(bytes memory message) internal {
        fxRoot.sendMessageToChild(fxChildTunnel, message);
    }

    function _validateAndExtractMessage(bytes memory inputData) internal returns (bytes memory) {
        ExitPayloadReader.ExitPayload memory payload = inputData.toExitPayload();

        bytes memory branchMaskBytes = payload.getBranchMaskAsBytes();
        uint256 blockNumber = payload.getBlockNumber();
        // checking if exit has already been processed
        // unique exit is identified using hash of (blockNumber, branchMask, receiptLogIndex)
        bytes32 exitHash = keccak256(
            abi.encodePacked(
                blockNumber,
                // first 2 nibbles are dropped while generating nibble array
                // this allows branch masks that are valid but bypass exitHash check (changing first 2 nibbles only)
                // so converting to nibble array and then hashing it
                MerklePatriciaProof._getNibbleArray(branchMaskBytes),
                payload.getReceiptLogIndex()
            )
        );
        require(
            processedExits[exitHash] == false,
            "FxRootTunnel: EXIT_ALREADY_PROCESSED"
        );
        processedExits[exitHash] = true;

        ExitPayloadReader.Receipt memory receipt = payload.getReceipt();
        ExitPayloadReader.Log memory log = receipt.getLog();

        // check child tunnel
        require(fxChildTunnel == log.getEmitter(), "FxRootTunnel: INVALID_FX_CHILD_TUNNEL");

        bytes32 receiptRoot = payload.getReceiptRoot();
        // verify receipt inclusion
        require(
            MerklePatriciaProof.verify(
                receipt.toBytes(), 
                branchMaskBytes, 
                payload.getReceiptProof(), 
                receiptRoot
            ),
            "FxRootTunnel: INVALID_RECEIPT_PROOF"
        );

        // verify checkpoint inclusion
        _checkBlockMembershipInCheckpoint(
            blockNumber,
            payload.getBlockTime(),
            payload.getTxRoot(),
            receiptRoot,
            payload.getHeaderNumber(),
            payload.getBlockProof()
        );

        ExitPayloadReader.LogTopics memory topics = log.getTopics();

        require(
            bytes32(topics.getField(0).toUint()) == SEND_MESSAGE_EVENT_SIG, // topic0 is event sig
            "FxRootTunnel: INVALID_SIGNATURE"
        );

        // received message data
        (bytes memory message) = abi.decode(log.getData(), (bytes)); // event decodes params again, so decoding bytes to get message
        return message;
    }

    function _checkBlockMembershipInCheckpoint(
        uint256 blockNumber,
        uint256 blockTime,
        bytes32 txRoot,
        bytes32 receiptRoot,
        uint256 headerNumber,
        bytes memory blockProof
    ) private view returns (uint256) {
        (
            bytes32 headerRoot,
            uint256 startBlock,
            ,
            uint256 createdAt,

        ) = checkpointManager.headerBlocks(headerNumber);

        require(
            keccak256(
                abi.encodePacked(blockNumber, blockTime, txRoot, receiptRoot)
            )
                .checkMembership(
                blockNumber-startBlock,
                headerRoot,
                blockProof
            ),
            "FxRootTunnel: INVALID_HEADER"
        );
        return createdAt;
    }

    /**
     * @notice receive message from  L2 to L1, validated by proof
     * @dev This function verifies if the transaction actually happened on child chain
     *
     * @param inputData RLP encoded data of the reference tx containing following list of fields
     *  0 - headerNumber - Checkpoint header block number containing the reference tx
     *  1 - blockProof - Proof that the block header (in the child chain) is a leaf in the submitted merkle root
     *  2 - blockNumber - Block number containing the reference tx on child chain
     *  3 - blockTime - Reference tx block time
     *  4 - txRoot - Transactions root of block
     *  5 - receiptRoot - Receipts root of block
     *  6 - receipt - Receipt of the reference transaction
     *  7 - receiptProof - Merkle proof of the reference receipt
     *  8 - branchMask - 32 bits denoting the path of receipt in merkle tree
     *  9 - receiptLogIndex - Log Index to read from the receipt
     */
    function receiveMessage(bytes memory inputData) public virtual {
        bytes memory message = _validateAndExtractMessage(inputData);
        _processMessageFromChild(message);
    }

    /**
     * @notice Process message received from Child Tunnel
     * @dev function needs to be implemented to handle message as per requirement
     * This is called by onStateReceive function.
     * Since it is called via a system call, any event will not be emitted during its execution.
     * @param message bytes message that was sent from Child Tunnel
     */
    function _processMessageFromChild(bytes memory message) virtual internal;
}

// File: contracts/vvotOMMP.sol



// File: @openzeppelin/contracts/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/token/ERC721/IERC721.sol
pragma solidity ^0.8.0;
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
/**
 * @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
    );

    event fxcall(
        address indexed to
    );

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId)
        external
        view
        returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator)
        external
        view
        returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}


// File: @openzeppelin/contracts/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/utils/Strings.sol



pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// File: @openzeppelin/contracts/utils/Address.sol



pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/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: @openzeppelin/contracts/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 `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


// File: @openzeppelin/contracts/token/ERC721/ERC721.sol
pragma solidity ^0.8.0;

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata{

    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(
        string memory name_, 
        string memory symbol_
        ) {
        _name = name_;
        _symbol = symbol_;

    }

    

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC165, IERC165)
        returns (bool)
    {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner)
        public
        view
        virtual
        override
        returns (uint256)
    {
        require(
            owner != address(0),
            "ERC721: balance query for the zero address"
        );
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        address owner = _owners[tokenId];
        require(
            owner != address(0),
            "ERC721: owner query for nonexistent token"
        );
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: 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 = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        require(
            _exists(tokenId),
            "ERC721: approved query for nonexistent token"
        );

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved)
        public
        virtual
        override
    {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator)
        public
        view
        virtual
        override
        returns (bool)
    {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: 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),
            "ERC721: 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, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId)
        internal
        view
        virtual
        returns (bool)
    {
        require(
            _exists(tokenId),
            "ERC721: operator query for nonexistent token"
        );
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner ||
            getApproved(tokenId) == spender ||
            isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(
            ERC721.ownerOf(tokenId) == from,
            "ERC721: transfer of token that is not own"
        );
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;
        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try
                IERC721Receiver(to).onERC721Received(
                    _msgSender(),
                    from,
                    tokenId,
                    _data
                )
            returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert(
                        "ERC721: transfer to non ERC721Receiver implementer"
                    );
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol






// File: @openzeppelin/contracts/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() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}



pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if a `leafs` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, `proofs` for each leaf must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Then
     * 'proofFlag' designates the nodes needed for the multi proof.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32 root,
        bytes32[] memory leafs,
        bytes32[] memory proofs,
        bool[] memory proofFlag
    ) internal pure returns (bool) {
        return processMultiProof(leafs, proofs, proofFlag) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using the multi proof as `proofFlag`. A multi proof is
     * valid if the final hash matches the root of the tree.
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory leafs,
        bytes32[] memory proofs,
        bool[] memory proofFlag
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leafs` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leafsLen = leafs.length;
        uint256 proofsLen = proofs.length;
        uint256 totalHashes = proofFlag.length;

        // Check proof validity.
        require(leafsLen + proofsLen - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proofs` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leafsLen ? leafs[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlag[i] ? leafPos < leafsLen ? leafs[leafPos++] : hashes[hashPos++] : proofs[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        return hashes[totalHashes - 1];
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

pragma solidity >=0.7.0 <0.9.0;

abstract contract ownerdataInterface {
    function setChildPurpose(address _from, address _to, uint256 _tokenID, address _owner) public virtual;
}

//tested contract
contract VOXVOT is ERC721, Ownable, Pausable{
  using Strings for uint256;

  string baseURI;
  string public baseExtension = ".json";
  uint256 public cost = 0.08 ether;
  uint256 public maxSupply = 6666;
  uint256 public totalSupply;


  
  bool public revealable = false;
  bool public isForceReveal = false;
  string public notRevealedUri;
  
  //mint state
  bool public isWhitelistMint = false;
  bool public isPublicMint = false;

  //FXportal
  ownerdataInterface public ownerdatainterface;
  address mintFromAddress = address(0);
  address private stakingContract;

  //merkle proof
  bytes32 private _rootHash;


  //mapping (address => uint256) public publicMintCount;
  mapping (uint256 => bool) public isRevealed;
  mapping (address => uint256)[3] public WLMintList;

  uint256 public wave;

  constructor(
    string memory _name,
    string memory _symbol,
    string memory _initBaseURI,
    string memory _initNotRevealedUri,
    address _fxRootAddress
  ) ERC721(_name, _symbol) {
    setBaseURI(_initBaseURI);
    setNotRevealedURI(_initNotRevealedUri);
    ownerdatainterface = ownerdataInterface(_fxRootAddress);
  }

  // internal
  function _baseURI() internal view virtual override returns (string memory) {
    return baseURI;
  }

  function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override
  {
    if(msg.sender == stakingContract){
          ownerdatainterface.setChildPurpose(from,to,tokenId, from);
    } else {
          ownerdatainterface.setChildPurpose(from,to,tokenId, to);
    }
    super._beforeTokenTransfer(from, to, tokenId);
  }


  // public
  function publicMint(uint256 amount) public payable whenNotPaused {
    require(msg.sender == tx.origin);
    require(isPublicMint, "Now only WL mint");

    //require zero mint
    require(amount > 0, "Do not zero mint");
    
    require(msg.value == cost * amount, "Value is not enough.");
    //uint256 supply = totalSupply;
    require(amount + totalSupply <= maxSupply, "Requests have exceeded the number in stock.");

    for (uint256 i = 0; i < amount; i++) {
      totalSupply += 1;
      _safeMint(msg.sender, totalSupply);
    }
  }

  function whitelistMint(bytes32[] calldata proof) public payable whenNotPaused {
    require(isWhitelistMint, "Now only public mint");

    if(wave < 2){
        require(WLMintList[wave][msg.sender] < 2, "Minted.");
    }
    
    require(msg.value == cost, "Value is not enough.");
    require(totalSupply < maxSupply, "Sold out");

    //merkle proof
    bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
    require(MerkleProof.verify(proof, _rootHash, leaf), "Invalid addr");
    WLMintList[wave][msg.sender] += 1;
    totalSupply += 1;
    _mint(msg.sender, totalSupply);
  }

  function tokenURI(uint256 tokenId) public view virtual override returns (string memory)
  {
    require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

    if(isForceReveal == true) {
        string memory _currentBaseURI = _baseURI();
        return bytes(_currentBaseURI).length > 0
        ? string(abi.encodePacked(_currentBaseURI, tokenId.toString(), baseExtension))
        : "";
    }
    
    if(isRevealed[tokenId] == false) {
        return bytes(notRevealedUri).length > 0
        ? string(abi.encodePacked(notRevealedUri, tokenId.toString(), baseExtension))
        : "";
    }

    string memory currentBaseURI = _baseURI();
    return bytes(currentBaseURI).length > 0
        ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension))
        : "";
  }

  function revealToken (uint256 _tokenId) public {
      require(revealable, "can not reveal");
      require(ownerOf(_tokenId) == msg.sender, "You are not owner this TokenID");
      require(isRevealed[_tokenId] == false, "TokenID already revealed");
      isRevealed[_tokenId] = true;
  }

  function revealTokens (uint256[] calldata ownedTokens) public {
      uint256 ownerTokenCount = ownedTokens.length;
      for (uint256 i = 0; i < ownerTokenCount; i++) {
        revealToken(ownedTokens[i]);
      }
  }

  //only owner
  function setRootHash (bytes32 root) public onlyOwner {
      _rootHash = root;
  }

  function setRevealable(bool _isRevealable) public onlyOwner {
      revealable = _isRevealable;
  }
  
  function setCost(uint256 _newCost) public onlyOwner() {
    cost = _newCost;
  }
  
  function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
    notRevealedUri = _notRevealedURI;
  }

  function setBaseURI(string memory _newBaseURI) public onlyOwner {
    baseURI = _newBaseURI;
  }

  function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
    baseExtension = _newBaseExtension;
  }

  function setMaxSupply (uint256 _newSupply) public onlyOwner {
      require(maxSupply > _newSupply, "Enter a value smaller than the current value");
      maxSupply = _newSupply;
  }



  //state management
  function setWave(uint256 _newWave) public onlyOwner {
      wave = _newWave;
  }

  function setIsPublicMint(bool _isPublic) public onlyOwner {
      isPublicMint = _isPublic;
  }

  function setIsWhiteListMint (bool _isWhiteList) public onlyOwner {
      isWhitelistMint = _isWhiteList;
  }
 
  function withdraw() public payable onlyOwner {
    (bool success, ) = payable(msg.sender).call{value: address(this).balance}("");
    require(success);
  }

  function ownerMint (uint256 amount) public onlyOwner
  {
      require(amount > 0);
      require(totalSupply + amount <= maxSupply);
      
      for (uint256 i = 0; i < amount; i++) {
      totalSupply += 1;
      _mint(msg.sender, totalSupply);
    }
  }

  function setIsForceReveal (bool _newBool) public onlyOwner {
      isForceReveal = _newBool;
  }

  function pause() external onlyOwner 
  {
	_pause();
  }

	function unpause() external onlyOwner 
  {
	_unpause();
  }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"string","name":"_initBaseURI","type":"string"},{"internalType":"string","name":"_initNotRevealedUri","type":"string"},{"internalType":"address","name":"_fxRootAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"fxcall","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"WLMintList","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"isForceReveal","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPublicMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"isRevealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isWhitelistMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","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":"amount","type":"uint256"}],"name":"ownerMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownerdatainterface","outputs":[{"internalType":"contract ownerdataInterface","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"revealToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"ownedTokens","type":"uint256[]"}],"name":"revealTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealable","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":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_newBool","type":"bool"}],"name":"setIsForceReveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isPublic","type":"bool"}],"name":"setIsPublicMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isWhiteList","type":"bool"}],"name":"setIsWhiteListMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newSupply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_notRevealedURI","type":"string"}],"name":"setNotRevealedURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isRevealable","type":"bool"}],"name":"setRevealable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"root","type":"bytes32"}],"name":"setRootHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newWave","type":"uint256"}],"name":"setWave","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":"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":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wave","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

0x6080604052600436106102ae5760003560e01c80636f8b44b011610175578063b06194d3116100dc578063d5abeb0111610095578063f19e75d41161006f578063f19e75d414610824578063f2c4ce1e14610844578063f2fde38b14610864578063f4377ede1461088457600080fd5b8063d5abeb01146107a5578063da3ef23f146107bb578063e985e9c5146107db57600080fd5b8063b06194d3146106f6578063b88d4fde14610716578063ba1f877014610736578063c668286214610756578063c754da331461076b578063c87b56dd1461078557600080fd5b80638da5cb5b1161012e5780638da5cb5b1461064357806395d89b4114610661578063a22cb46514610676578063a671bede14610696578063aadd6034146106b6578063ac6e4439146106d657600080fd5b80636f8b44b0146105a45780636fe15b44146105c457806370a08231146105da578063715018a6146105fa578063735fcef11461060f5780638456cb591461062e57600080fd5b80632db115441161021957806344a0d68a116101d257806344a0d68a146104d55780635055fbc3146104f557806355f804b3146105255780635a46cf3d146105455780635c975abb146105655780636352211e1461058457600080fd5b80632db11544146104535780633057931f14610466578063372f657c146104855780633ccfd60b146104985780633f4ba83a146104a057806342842e0e146104b557600080fd5b806313faede61161026b57806313faede614610393578063148e7f1a146103b757806318160ddd146103dd578063203c4ed7146103f357806323b872dd146104135780632d7eae661461043357600080fd5b806301ffc9a7146102b357806303d16985146102e857806306fdde0314610302578063081812fc14610324578063081c8c441461035c578063095ea7b314610371575b600080fd5b3480156102bf57600080fd5b506102d36102ce3660046127b7565b6108a4565b60405190151581526020015b60405180910390f35b3480156102f457600080fd5b50600c546102d39060ff1681565b34801561030e57600080fd5b506103176108f6565b6040516102df91906129b9565b34801561033057600080fd5b5061034461033f36600461279e565b610988565b6040516001600160a01b0390911681526020016102df565b34801561036857600080fd5b50610317610a22565b34801561037d57600080fd5b5061039161038c366004612717565b610ab0565b005b34801561039f57600080fd5b506103a960095481565b6040519081526020016102df565b3480156103c357600080fd5b50600e54610344906201000090046001600160a01b031681565b3480156103e957600080fd5b506103a9600b5481565b3480156103ff57600080fd5b5061039161040e366004612783565b610bc6565b34801561041f57600080fd5b5061039161042e366004612635565b610c0a565b34801561043f57600080fd5b5061039161044e36600461279e565b610c3b565b61039161046136600461279e565b610c6a565b34801561047257600080fd5b50600e546102d390610100900460ff1681565b610391610493366004612741565b610e17565b61039161106f565b3480156104ac57600080fd5b506103916110f1565b3480156104c157600080fd5b506103916104d0366004612635565b611125565b3480156104e157600080fd5b506103916104f036600461279e565b611140565b34801561050157600080fd5b506102d361051036600461279e565b60126020526000908152604090205460ff1681565b34801561053157600080fd5b506103916105403660046127f1565b61116f565b34801561055157600080fd5b5061039161056036600461279e565b6111ac565b34801561057157600080fd5b50600654600160a01b900460ff166102d3565b34801561059057600080fd5b5061034461059f36600461279e565b6112c9565b3480156105b057600080fd5b506103916105bf36600461279e565b611340565b3480156105d057600080fd5b506103a960165481565b3480156105e657600080fd5b506103a96105f53660046125e7565b6113d5565b34801561060657600080fd5b5061039161145c565b34801561061b57600080fd5b50600c546102d390610100900460ff1681565b34801561063a57600080fd5b50610391611490565b34801561064f57600080fd5b506006546001600160a01b0316610344565b34801561066d57600080fd5b506103176114c2565b34801561068257600080fd5b506103916106913660046126ed565b6114d1565b3480156106a257600080fd5b506103a96106b136600461283a565b6114dc565b3480156106c257600080fd5b506103916106d1366004612783565b6114ff565b3480156106e257600080fd5b506103916106f1366004612741565b61153c565b34801561070257600080fd5b50610391610711366004612783565b611581565b34801561072257600080fd5b50610391610731366004612671565b6115be565b34801561074257600080fd5b5061039161075136600461279e565b6115f0565b34801561076257600080fd5b5061031761161f565b34801561077757600080fd5b50600e546102d39060ff1681565b34801561079157600080fd5b506103176107a036600461279e565b61162c565b3480156107b157600080fd5b506103a9600a5481565b3480156107c757600080fd5b506103916107d63660046127f1565b61179f565b3480156107e757600080fd5b506102d36107f6366004612602565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b34801561083057600080fd5b5061039161083f36600461279e565b6117dc565b34801561085057600080fd5b5061039161085f3660046127f1565b611872565b34801561087057600080fd5b5061039161087f3660046125e7565b6118af565b34801561089057600080fd5b5061039161089f366004612783565b611947565b60006001600160e01b031982166380ac58cd60e01b14806108d557506001600160e01b03198216635b5e139f60e01b145b806108f057506301ffc9a760e01b6001600160e01b03198316145b92915050565b60606000805461090590612b32565b80601f016020809104026020016040519081016040528092919081815260200182805461093190612b32565b801561097e5780601f106109535761010080835404028352916020019161097e565b820191906000526020600020905b81548152906001019060200180831161096157829003601f168201915b5050505050905090565b6000818152600260205260408120546001600160a01b0316610a065760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b60648201526084015b60405180910390fd5b506000908152600460205260409020546001600160a01b031690565b600d8054610a2f90612b32565b80601f0160208091040260200160405190810160405280929190818152602001828054610a5b90612b32565b8015610aa85780601f10610a7d57610100808354040283529160200191610aa8565b820191906000526020600020905b815481529060010190602001808311610a8b57829003601f168201915b505050505081565b6000610abb826112c9565b9050806001600160a01b0316836001600160a01b03161415610b295760405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656044820152603960f91b60648201526084016109fd565b336001600160a01b0382161480610b455750610b4581336107f6565b610bb75760405162461bcd60e51b815260206004820152603860248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656420666f7220616c6c000000000000000060648201526084016109fd565b610bc1838361198b565b505050565b6006546001600160a01b03163314610bf05760405162461bcd60e51b81526004016109fd90612a1e565b600e80549115156101000261ff0019909216919091179055565b610c1433826119f9565b610c305760405162461bcd60e51b81526004016109fd90612a53565b610bc1838383611af0565b6006546001600160a01b03163314610c655760405162461bcd60e51b81526004016109fd90612a1e565b601155565b610c72611c9b565b333214610c7e57600080fd5b600e54610100900460ff16610cc85760405162461bcd60e51b815260206004820152601060248201526f139bddc81bdb9b1e4815d3081b5a5b9d60821b60448201526064016109fd565b60008111610d0b5760405162461bcd60e51b815260206004820152601060248201526f111bc81b9bdd081e995c9bc81b5a5b9d60821b60448201526064016109fd565b80600954610d199190612ad0565b3414610d5e5760405162461bcd60e51b81526020600482015260146024820152732b30b63ab29034b9903737ba1032b737bab3b41760611b60448201526064016109fd565b600a54600b54610d6e9083612aa4565b1115610dd05760405162461bcd60e51b815260206004820152602b60248201527f5265717565737473206861766520657863656564656420746865206e756d626560448201526a391034b71039ba37b1b59760a91b60648201526084016109fd565b60005b81811015610e13576001600b6000828254610dee9190612aa4565b92505081905550610e0133600b54611ce8565b80610e0b81612b6d565b915050610dd3565b5050565b610e1f611c9b565b600e5460ff16610e685760405162461bcd60e51b8152602060048201526014602482015273139bddc81bdb9b1e481c1d589b1a58c81b5a5b9d60621b60448201526064016109fd565b60026016541015610ed1576002601360165460038110610e8a57610e8a612bc8565b3360009081529101602052604090205410610ed15760405162461bcd60e51b815260206004820152600760248201526626b4b73a32b21760c91b60448201526064016109fd565b6009543414610f195760405162461bcd60e51b81526020600482015260146024820152732b30b63ab29034b9903737ba1032b737bab3b41760611b60448201526064016109fd565b600a54600b5410610f575760405162461bcd60e51b815260206004820152600860248201526714dbdb19081bdd5d60c21b60448201526064016109fd565b6040516bffffffffffffffffffffffff193360601b166020820152600090603401604051602081830303815290604052805190602001209050610fd1838380806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250506011549150849050611d02565b61100c5760405162461bcd60e51b815260206004820152600c60248201526b24b73b30b634b21030b2323960a11b60448201526064016109fd565b600160136016546003811061102357611023612bc8565b3360009081529101602052604081208054909190611042908490612aa4565b925050819055506001600b600082825461105c9190612aa4565b92505081905550610bc133600b54611d18565b6006546001600160a01b031633146110995760405162461bcd60e51b81526004016109fd90612a1e565b604051600090339047908381818185875af1925050503d80600081146110db576040519150601f19603f3d011682016040523d82523d6000602084013e6110e0565b606091505b50509050806110ee57600080fd5b50565b6006546001600160a01b0316331461111b5760405162461bcd60e51b81526004016109fd90612a1e565b611123611e66565b565b610bc1838383604051806020016040528060008152506115be565b6006546001600160a01b0316331461116a5760405162461bcd60e51b81526004016109fd90612a1e565b600955565b6006546001600160a01b031633146111995760405162461bcd60e51b81526004016109fd90612a1e565b8051610e13906007906020840190612460565b600c5460ff166111ef5760405162461bcd60e51b815260206004820152600e60248201526d18d85b881b9bdd081c995d99585b60921b60448201526064016109fd565b336111f9826112c9565b6001600160a01b03161461124f5760405162461bcd60e51b815260206004820152601e60248201527f596f7520617265206e6f74206f776e6572207468697320546f6b656e4944000060448201526064016109fd565b60008181526012602052604090205460ff16156112ae5760405162461bcd60e51b815260206004820152601860248201527f546f6b656e494420616c72656164792072657665616c6564000000000000000060448201526064016109fd565b6000908152601260205260409020805460ff19166001179055565b6000818152600260205260408120546001600160a01b0316806108f05760405162461bcd60e51b815260206004820152602960248201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460448201526832b73a103a37b5b2b760b91b60648201526084016109fd565b6006546001600160a01b0316331461136a5760405162461bcd60e51b81526004016109fd90612a1e565b80600a54116113d05760405162461bcd60e51b815260206004820152602c60248201527f456e74657220612076616c756520736d616c6c6572207468616e20746865206360448201526b757272656e742076616c756560a01b60648201526084016109fd565b600a55565b60006001600160a01b0382166114405760405162461bcd60e51b815260206004820152602a60248201527f4552433732313a2062616c616e636520717565727920666f7220746865207a65604482015269726f206164647265737360b01b60648201526084016109fd565b506001600160a01b031660009081526003602052604090205490565b6006546001600160a01b031633146114865760405162461bcd60e51b81526004016109fd90612a1e565b6111236000611ebb565b6006546001600160a01b031633146114ba5760405162461bcd60e51b81526004016109fd90612a1e565b611123611f0d565b60606001805461090590612b32565b610e13338383611f50565b601382600381106114ec57600080fd5b0160205260009081526040902054905081565b6006546001600160a01b031633146115295760405162461bcd60e51b81526004016109fd90612a1e565b600e805460ff1916911515919091179055565b8060005b8181101561157b5761156984848381811061155d5761155d612bc8565b905060200201356111ac565b8061157381612b6d565b915050611540565b50505050565b6006546001600160a01b031633146115ab5760405162461bcd60e51b81526004016109fd90612a1e565b600c805460ff1916911515919091179055565b6115c833836119f9565b6115e45760405162461bcd60e51b81526004016109fd90612a53565b61157b8484848461201f565b6006546001600160a01b0316331461161a5760405162461bcd60e51b81526004016109fd90612a1e565b601655565b60088054610a2f90612b32565b6000818152600260205260409020546060906001600160a01b03166116ab5760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b60648201526084016109fd565b600c5460ff610100909104161515600114156117205760006116cb612052565b905060008151116116eb5760405180602001604052806000815250611719565b806116f584612061565b600860405160200161170993929190612923565b6040516020818303038152906040525b9392505050565b60008281526012602052604090205460ff16611795576000600d805461174590612b32565b90501161176157604051806020016040528060008152506108f0565b600d61176c83612061565b600860405160200161178093929190612960565b60405160208183030381529060405292915050565b60006116cb612052565b6006546001600160a01b031633146117c95760405162461bcd60e51b81526004016109fd90612a1e565b8051610e13906008906020840190612460565b6006546001600160a01b031633146118065760405162461bcd60e51b81526004016109fd90612a1e565b6000811161181357600080fd5b600a5481600b546118249190612aa4565b111561182f57600080fd5b60005b81811015610e13576001600b600082825461184d9190612aa4565b9250508190555061186033600b54611d18565b8061186a81612b6d565b915050611832565b6006546001600160a01b0316331461189c5760405162461bcd60e51b81526004016109fd90612a1e565b8051610e1390600d906020840190612460565b6006546001600160a01b031633146118d95760405162461bcd60e51b81526004016109fd90612a1e565b6001600160a01b03811661193e5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016109fd565b6110ee81611ebb565b6006546001600160a01b031633146119715760405162461bcd60e51b81526004016109fd90612a1e565b600c80549115156101000261ff0019909216919091179055565b600081815260046020526040902080546001600160a01b0319166001600160a01b03841690811790915581906119c0826112c9565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b6000818152600260205260408120546001600160a01b0316611a725760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b60648201526084016109fd565b6000611a7d836112c9565b9050806001600160a01b0316846001600160a01b03161480611ab85750836001600160a01b0316611aad84610988565b6001600160a01b0316145b80611ae857506001600160a01b0380821660009081526005602090815260408083209388168352929052205460ff165b949350505050565b826001600160a01b0316611b03826112c9565b6001600160a01b031614611b6b5760405162461bcd60e51b815260206004820152602960248201527f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960448201526839903737ba1037bbb760b91b60648201526084016109fd565b6001600160a01b038216611bcd5760405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646044820152637265737360e01b60648201526084016109fd565b611bd883838361215f565b611be360008261198b565b6001600160a01b0383166000908152600360205260408120805460019290611c0c908490612aef565b90915550506001600160a01b0382166000908152600360205260408120805460019290611c3a908490612aa4565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b0386811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b600654600160a01b900460ff16156111235760405162461bcd60e51b815260206004820152601060248201526f14185d5cd8589b194e881c185d5cd95960821b60448201526064016109fd565b610e13828260405180602001604052806000815250612257565b600082611d0f858461228a565b14949350505050565b6001600160a01b038216611d6e5760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f206164647265737360448201526064016109fd565b6000818152600260205260409020546001600160a01b031615611dd35760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e7465640000000060448201526064016109fd565b611ddf6000838361215f565b6001600160a01b0382166000908152600360205260408120805460019290611e08908490612aa4565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b03861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b611e6e6122d7565b6006805460ff60a01b191690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa335b6040516001600160a01b03909116815260200160405180910390a1565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b611f15611c9b565b6006805460ff60a01b1916600160a01b1790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258611e9e3390565b816001600160a01b0316836001600160a01b03161415611fb25760405162461bcd60e51b815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c65720000000000000060448201526064016109fd565b6001600160a01b03838116600081815260056020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b61202a848484611af0565b61203684848484612327565b61157b5760405162461bcd60e51b81526004016109fd906129cc565b60606007805461090590612b32565b6060816120855750506040805180820190915260018152600360fc1b602082015290565b8160005b81156120af578061209981612b6d565b91506120a89050600a83612abc565b9150612089565b60008167ffffffffffffffff8111156120ca576120ca612bde565b6040519080825280601f01601f1916602001820160405280156120f4576020820181803683370190505b5090505b8415611ae857612109600183612aef565b9150612116600a86612b88565b612121906030612aa4565b60f81b81838151811061213657612136612bc8565b60200101906001600160f81b031916908160001a905350612158600a86612abc565b94506120f8565b6010546001600160a01b03163314156121f357600e5460405163e3e5d8b160e01b81526001600160a01b03858116600483018190528582166024840152604483018590526064830152620100009092049091169063e3e5d8b190608401600060405180830381600087803b1580156121d657600080fd5b505af11580156121ea573d6000803e3d6000fd5b50505050505050565b600e5460405163e3e5d8b160e01b81526001600160a01b03858116600483015284811660248301819052604483018590526064830152620100009092049091169063e3e5d8b190608401600060405180830381600087803b1580156121d657600080fd5b6122618383611d18565b61226e6000848484612327565b610bc15760405162461bcd60e51b81526004016109fd906129cc565b600081815b84518110156122cf576122bb828683815181106122ae576122ae612bc8565b6020026020010151612434565b9150806122c781612b6d565b91505061228f565b509392505050565b600654600160a01b900460ff166111235760405162461bcd60e51b815260206004820152601460248201527314185d5cd8589b194e881b9bdd081c185d5cd95960621b60448201526064016109fd565b60006001600160a01b0384163b1561242957604051630a85bd0160e11b81526001600160a01b0385169063150b7a029061236b90339089908890889060040161297c565b602060405180830381600087803b15801561238557600080fd5b505af19250505080156123b5575060408051601f3d908101601f191682019092526123b2918101906127d4565b60015b61240f573d8080156123e3576040519150601f19603f3d011682016040523d82523d6000602084013e6123e8565b606091505b5080516124075760405162461bcd60e51b81526004016109fd906129cc565b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050611ae8565b506001949350505050565b6000818310612450576000828152602084905260409020611719565b5060009182526020526040902090565b82805461246c90612b32565b90600052602060002090601f01602090048101928261248e57600085556124d4565b82601f106124a757805160ff19168380011785556124d4565b828001600101855582156124d4579182015b828111156124d45782518255916020019190600101906124b9565b506124e09291506124e4565b5090565b5b808211156124e057600081556001016124e5565b600067ffffffffffffffff8084111561251457612514612bde565b604051601f8501601f19908116603f0116810190828211818310171561253c5761253c612bde565b8160405280935085815286868601111561255557600080fd5b858560208301376000602087830101525050509392505050565b80356001600160a01b038116811461258657600080fd5b919050565b60008083601f84011261259d57600080fd5b50813567ffffffffffffffff8111156125b557600080fd5b6020830191508360208260051b85010111156125d057600080fd5b9250929050565b8035801515811461258657600080fd5b6000602082840312156125f957600080fd5b6117198261256f565b6000806040838503121561261557600080fd5b61261e8361256f565b915061262c6020840161256f565b90509250929050565b60008060006060848603121561264a57600080fd5b6126538461256f565b92506126616020850161256f565b9150604084013590509250925092565b6000806000806080858703121561268757600080fd5b6126908561256f565b935061269e6020860161256f565b925060408501359150606085013567ffffffffffffffff8111156126c157600080fd5b8501601f810187136126d257600080fd5b6126e1878235602084016124f9565b91505092959194509250565b6000806040838503121561270057600080fd5b6127098361256f565b915061262c602084016125d7565b6000806040838503121561272a57600080fd5b6127338361256f565b946020939093013593505050565b6000806020838503121561275457600080fd5b823567ffffffffffffffff81111561276b57600080fd5b6127778582860161258b565b90969095509350505050565b60006020828403121561279557600080fd5b611719826125d7565b6000602082840312156127b057600080fd5b5035919050565b6000602082840312156127c957600080fd5b813561171981612bf4565b6000602082840312156127e657600080fd5b815161171981612bf4565b60006020828403121561280357600080fd5b813567ffffffffffffffff81111561281a57600080fd5b8201601f8101841361282b57600080fd5b611ae8848235602084016124f9565b6000806040838503121561284d57600080fd5b8235915061262c6020840161256f565b60008151808452612875816020860160208601612b06565b601f01601f19169290920160200192915050565b8054600090600181811c90808316806128a357607f831692505b60208084108214156128c557634e487b7160e01b600052602260045260246000fd5b8180156128d957600181146128ea57612917565b60ff19861689528489019650612917565b60008881526020902060005b8681101561290f5781548b8201529085019083016128f6565b505084890196505b50505050505092915050565b60008451612935818460208901612b06565b845190830190612949818360208901612b06565b61295581830186612889565b979650505050505050565b600061296c8286612889565b8451612949818360208901612b06565b6001600160a01b03858116825284166020820152604081018390526080606082018190526000906129af9083018461285d565b9695505050505050565b602081526000611719602083018461285d565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f6040820152701ddb995c881b9bdc88185c1c1c9bdd9959607a1b606082015260800190565b60008219821115612ab757612ab7612b9c565b500190565b600082612acb57612acb612bb2565b500490565b6000816000190483118215151615612aea57612aea612b9c565b500290565b600082821015612b0157612b01612b9c565b500390565b60005b83811015612b21578181015183820152602001612b09565b8381111561157b5750506000910152565b600181811c90821680612b4657607f821691505b60208210811415612b6757634e487b7160e01b600052602260045260246000fd5b50919050565b6000600019821415612b8157612b81612b9c565b5060010190565b600082612b9757612b97612bb2565b500690565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052601260045260246000fd5b634e487b7160e01b600052603260045260246000fd5b634e487b7160e01b600052604160045260246000fd5b6001600160e01b0319811681146110ee57600080fdfea264697066735822122036aee17437c0aea42938545f19f89bc882f68444b02ac12f156655c384ce68ab64736f6c63430008070033

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

00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000018000000000000000000000000094f5c2bf267784a3504ef80cb85cbb06ded7a8f90000000000000000000000000000000000000000000000000000000000000006564f58564f540000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000456585654000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d575a65547a36735474794e784a46544632314b4e637279666e315441376435466e4653343163696a4e7a6a622f000000000000000000000000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d65387157746642344377477a566234713171473268614345355273636933637a6d6e5967716f6f41425053452f00000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): VOXVOT
Arg [1] : _symbol (string): VXVT
Arg [2] : _initBaseURI (string): ipfs://QmWZeTz6sTtyNxJFTF21KNcryfn1TA7d5FnFS41cijNzjb/
Arg [3] : _initNotRevealedUri (string): ipfs://Qme8qWtfB4CwGzVb4q1qG2haCE5Rsci3czmnYgqooABPSE/
Arg [4] : _fxRootAddress (address): 0x94F5C2bF267784A3504EF80cB85cBb06DeD7a8f9

-----Encoded View---------------
15 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [4] : 00000000000000000000000094f5c2bf267784a3504ef80cb85cbb06ded7a8f9
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [6] : 564f58564f540000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [8] : 5658565400000000000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [10] : 697066733a2f2f516d575a65547a36735474794e784a46544632314b4e637279
Arg [11] : 666e315441376435466e4653343163696a4e7a6a622f00000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [13] : 697066733a2f2f516d65387157746642344377477a5662347131714732686143
Arg [14] : 45355273636933637a6d6e5967716f6f41425053452f00000000000000000000

Deployed Bytecode Sourcemap

74671:6071:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53482:355;;;;;;;;;;-1:-1:-1;53482:355:0;;;;;:::i;:::-;;:::i;:::-;;;10027:14:1;;10020:22;10002:41;;9990:2;9975:18;53482:355:0;;;;;;;;74925:30;;;;;;;;;;-1:-1:-1;74925:30:0;;;;;;;;54651:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;56344:308::-;;;;;;;;;;-1:-1:-1;56344:308:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;8864:32:1;;;8846:51;;8834:2;8819:18;56344:308:0;8700:203:1;74998:28:0;;;;;;;;;;;;;:::i;55867:411::-;;;;;;;;;;-1:-1:-1;55867:411:0;;;;;:::i;:::-;;:::i;:::-;;74813:32;;;;;;;;;;;;;;;;;;;22015:25:1;;;22003:2;21988:18;74813:32:0;21869:177:1;75144:44:0;;;;;;;;;;-1:-1:-1;75144:44:0;;;;;;;-1:-1:-1;;;;;75144:44:0;;;74886:26;;;;;;;;;;;;;;;;79854:97;;;;;;;;;;-1:-1:-1;79854:97:0;;;;;:::i;:::-;;:::i;57263:376::-;;;;;;;;;;-1:-1:-1;57263:376:0;;;;;:::i;:::-;;:::i;78902:84::-;;;;;;;;;;-1:-1:-1;78902:84:0;;;;;:::i;:::-;;:::i;76353:557::-;;;;;;:::i;:::-;;:::i;75091:32::-;;;;;;;;;;-1:-1:-1;75091:32:0;;;;;;;;;;;76916:601;;;;;;:::i;:::-;;:::i;80074:158::-;;;:::i;80677:62::-;;;;;;;;;;;;;:::i;57710:185::-;;;;;;;;;;-1:-1:-1;57710:185:0;;;;;:::i;:::-;;:::i;79101:82::-;;;;;;;;;;-1:-1:-1;79101:82:0;;;;;:::i;:::-;;:::i;75382:43::-;;;;;;;;;;-1:-1:-1;75382:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;79317:98;;;;;;;;;;-1:-1:-1;79317:98:0;;;;;:::i;:::-;;:::i;78358:293::-;;;;;;;;;;-1:-1:-1;78358:293:0;;;;;:::i;:::-;;:::i;2704:86::-;;;;;;;;;;-1:-1:-1;2775:7:0;;-1:-1:-1;;;2775:7:0;;;;2704:86;;54258:326;;;;;;;;;;-1:-1:-1;54258:326:0;;;;;:::i;:::-;;:::i;79549:185::-;;;;;;;;;;-1:-1:-1;79549:185:0;;;;;:::i;:::-;;:::i;75486:19::-;;;;;;;;;;;;;;;;53901:295;;;;;;;;;;-1:-1:-1;53901:295:0;;;;;:::i;:::-;;:::i;68610:94::-;;;;;;;;;;;;;:::i;74960:33::-;;;;;;;;;;-1:-1:-1;74960:33:0;;;;;;;;;;;80614:58;;;;;;;;;;;;;:::i;67959:87::-;;;;;;;;;;-1:-1:-1;68032:6:0;;-1:-1:-1;;;;;68032:6:0;67959:87;;54820:104;;;;;;;;;;;;;:::i;56724:187::-;;;;;;;;;;-1:-1:-1;56724:187:0;;;;;:::i;:::-;;:::i;75430:49::-;;;;;;;;;;-1:-1:-1;75430:49:0;;;;;:::i;:::-;;:::i;79957:110::-;;;;;;;;;;-1:-1:-1;79957:110:0;;;;;:::i;:::-;;:::i;78657:223::-;;;;;;;;;;-1:-1:-1;78657:223:0;;;;;:::i;:::-;;:::i;78992:101::-;;;;;;;;;;-1:-1:-1;78992:101:0;;;;;:::i;:::-;;:::i;57966:365::-;;;;;;;;;;-1:-1:-1;57966:365:0;;;;;:::i;:::-;;:::i;79766:82::-;;;;;;;;;;-1:-1:-1;79766:82:0;;;;;:::i;:::-;;:::i;74771:37::-;;;;;;;;;;;;;:::i;75051:35::-;;;;;;;;;;-1:-1:-1;75051:35:0;;;;;;;;77523:829;;;;;;;;;;-1:-1:-1;77523:829:0;;;;;:::i;:::-;;:::i;74850:31::-;;;;;;;;;;;;;;;;79421:122;;;;;;;;;;-1:-1:-1;79421:122:0;;;;;:::i;:::-;;:::i;56982:214::-;;;;;;;;;;-1:-1:-1;56982:214:0;;;;;:::i;:::-;-1:-1:-1;;;;;57153:25:0;;;57124:4;57153:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;56982:214;80238:266;;;;;;;;;;-1:-1:-1;80238:266:0;;;;;:::i;:::-;;:::i;79191:120::-;;;;;;;;;;-1:-1:-1;79191:120:0;;;;;:::i;:::-;;:::i;68859:192::-;;;;;;;;;;-1:-1:-1;68859:192:0;;;;;:::i;:::-;;:::i;80510:98::-;;;;;;;;;;-1:-1:-1;80510:98:0;;;;;:::i;:::-;;:::i;53482:355::-;53629:4;-1:-1:-1;;;;;;53671:40:0;;-1:-1:-1;;;53671:40:0;;:105;;-1:-1:-1;;;;;;;53728:48:0;;-1:-1:-1;;;53728:48:0;53671:105;:158;;;-1:-1:-1;;;;;;;;;;40210:40:0;;;53793:36;53651:178;53482:355;-1:-1:-1;;53482:355:0:o;54651:100::-;54705:13;54738:5;54731:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54651:100;:::o;56344:308::-;56465:7;59967:16;;;:7;:16;;;;;;-1:-1:-1;;;;;59967:16:0;56490:110;;;;-1:-1:-1;;;56490:110:0;;17866:2:1;56490:110:0;;;17848:21:1;17905:2;17885:18;;;17878:30;17944:34;17924:18;;;17917:62;-1:-1:-1;;;17995:18:1;;;17988:42;18047:19;;56490:110:0;;;;;;;;;-1:-1:-1;56620:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;56620:24:0;;56344:308::o;74998:28::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55867:411::-;55948:13;55964:23;55979:7;55964:14;:23::i;:::-;55948:39;;56012:5;-1:-1:-1;;;;;56006:11:0;:2;-1:-1:-1;;;;;56006:11:0;;;55998:57;;;;-1:-1:-1;;;55998:57:0;;20572:2:1;55998:57:0;;;20554:21:1;20611:2;20591:18;;;20584:30;20650:34;20630:18;;;20623:62;-1:-1:-1;;;20701:18:1;;;20694:31;20742:19;;55998:57:0;20370:397:1;55998:57:0;844:10;-1:-1:-1;;;;;56090:21:0;;;;:62;;-1:-1:-1;56115:37:0;56132:5;844:10;56982:214;:::i;56115:37::-;56068:168;;;;-1:-1:-1;;;56068:168:0;;16259:2:1;56068:168:0;;;16241:21:1;16298:2;16278:18;;;16271:30;16337:34;16317:18;;;16310:62;16408:26;16388:18;;;16381:54;16452:19;;56068:168:0;16057:420:1;56068:168:0;56249:21;56258:2;56262:7;56249:8;:21::i;:::-;55937:341;55867:411;;:::o;79854:97::-;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;79921:12:::1;:24:::0;;;::::1;;;;-1:-1:-1::0;;79921:24:0;;::::1;::::0;;;::::1;::::0;;79854:97::o;57263:376::-;57472:41;844:10;57505:7;57472:18;:41::i;:::-;57450:140;;;;-1:-1:-1;;;57450:140:0;;;;;;;:::i;:::-;57603:28;57613:4;57619:2;57623:7;57603:9;:28::i;78902:84::-;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;78964:9:::1;:16:::0;78902:84::o;76353:557::-;2309:19;:17;:19::i;:::-;76433:10:::1;76447:9;76433:23;76425:32;;;::::0;::::1;;76472:12;::::0;::::1;::::0;::::1;;;76464:41;;;::::0;-1:-1:-1;;;76464:41:0;;12249:2:1;76464:41:0::1;::::0;::::1;12231:21:1::0;12288:2;12268:18;;;12261:30;-1:-1:-1;;;12307:18:1;;;12300:46;12363:18;;76464:41:0::1;12047:340:1::0;76464:41:0::1;76556:1;76547:6;:10;76539:39;;;::::0;-1:-1:-1;;;76539:39:0;;19466:2:1;76539:39:0::1;::::0;::::1;19448:21:1::0;19505:2;19485:18;;;19478:30;-1:-1:-1;;;19524:18:1;;;19517:46;19580:18;;76539:39:0::1;19264:340:1::0;76539:39:0::1;76619:6;76612:4;;:13;;;;:::i;:::-;76599:9;:26;76591:59;;;::::0;-1:-1:-1;;;76591:59:0;;19811:2:1;76591:59:0::1;::::0;::::1;19793:21:1::0;19850:2;19830:18;;;19823:30;-1:-1:-1;;;19869:18:1;;;19862:50;19929:18;;76591:59:0::1;19609:344:1::0;76591:59:0::1;76726:9;::::0;76711:11:::1;::::0;76702:20:::1;::::0;:6;:20:::1;:::i;:::-;:33;;76694:89;;;::::0;-1:-1:-1;;;76694:89:0;;20160:2:1;76694:89:0::1;::::0;::::1;20142:21:1::0;20199:2;20179:18;;;20172:30;20238:34;20218:18;;;20211:62;-1:-1:-1;;;20289:18:1;;;20282:41;20340:19;;76694:89:0::1;19958:407:1::0;76694:89:0::1;76797:9;76792:113;76816:6;76812:1;:10;76792:113;;;76853:1;76838:11;;:16;;;;;;;:::i;:::-;;;;;;;;76863:34;76873:10;76885:11;;76863:9;:34::i;:::-;76824:3:::0;::::1;::::0;::::1;:::i;:::-;;;;76792:113;;;;76353:557:::0;:::o;76916:601::-;2309:19;:17;:19::i;:::-;77009:15:::1;::::0;::::1;;77001:48;;;::::0;-1:-1:-1;;;77001:48:0;;13304:2:1;77001:48:0::1;::::0;::::1;13286:21:1::0;13343:2;13323:18;;;13316:30;-1:-1:-1;;;13362:18:1;;;13355:50;13422:18;;77001:48:0::1;13102:344:1::0;77001:48:0::1;77068:1;77061:4;;:8;77058:83;;;77120:1;77089:10;77100:4;;77089:16;;;;;;;:::i;:::-;77106:10;77089:28;::::0;;;:16;::::1;:28;::::0;;;;;:32:::1;77081:52;;;::::0;-1:-1:-1;;;77081:52:0;;13994:2:1;77081:52:0::1;::::0;::::1;13976:21:1::0;14033:1;14013:18;;;14006:29;-1:-1:-1;;;14051:18:1;;;14044:37;14098:18;;77081:52:0::1;13792:330:1::0;77081:52:0::1;77174:4;;77161:9;:17;77153:50;;;::::0;-1:-1:-1;;;77153:50:0;;19811:2:1;77153:50:0::1;::::0;::::1;19793:21:1::0;19850:2;19830:18;;;19823:30;-1:-1:-1;;;19869:18:1;;;19862:50;19929:18;;77153:50:0::1;19609:344:1::0;77153:50:0::1;77232:9;;77218:11;;:23;77210:44;;;::::0;-1:-1:-1;;;77210:44:0;;21392:2:1;77210:44:0::1;::::0;::::1;21374:21:1::0;21431:1;21411:18;;;21404:29;-1:-1:-1;;;21449:18:1;;;21442:38;21497:18;;77210:44:0::1;21190:331:1::0;77210:44:0::1;77308:28;::::0;-1:-1:-1;;77325:10:0::1;7389:2:1::0;7385:15;7381:53;77308:28:0::1;::::0;::::1;7369:66:1::0;77283:12:0::1;::::0;7451::1;;77308:28:0::1;;;;;;;;;;;;77298:39;;;;;;77283:54;;77352:42;77371:5;;77352:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;77378:9:0::1;::::0;;-1:-1:-1;77389:4:0;;-1:-1:-1;77352:18:0::1;:42::i;:::-;77344:67;;;::::0;-1:-1:-1;;;77344:67:0;;13653:2:1;77344:67:0::1;::::0;::::1;13635:21:1::0;13692:2;13672:18;;;13665:30;-1:-1:-1;;;13711:18:1;;;13704:42;13763:18;;77344:67:0::1;13451:336:1::0;77344:67:0::1;77450:1;77418:10;77429:4;;77418:16;;;;;;;:::i;:::-;77435:10;77418:28;::::0;;;:16;::::1;:28;::::0;;;;:33;;:28;;;:33:::1;::::0;;;::::1;:::i;:::-;;;;;;;;77473:1;77458:11;;:16;;;;;;;:::i;:::-;;;;;;;;77481:30;77487:10;77499:11;;77481:5;:30::i;80074:158::-:0;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;80145:58:::1;::::0;80127:12:::1;::::0;80153:10:::1;::::0;80177:21:::1;::::0;80127:12;80145:58;80127:12;80145:58;80177:21;80153:10;80145:58:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80126:77;;;80218:7;80210:16;;;::::0;::::1;;80119:113;80074:158::o:0;80677:62::-;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;80723:10:::1;:8;:10::i;:::-;80677:62::o:0;57710:185::-;57848:39;57865:4;57871:2;57875:7;57848:39;;;;;;;;;;;;:16;:39::i;79101:82::-;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;79162:4:::1;:15:::0;79101:82::o;79317:98::-;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;79388:21;;::::1;::::0;:7:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;78358:293::-:0;78422:10;;;;78414:37;;;;-1:-1:-1;;;78414:37:0;;21728:2:1;78414:37:0;;;21710:21:1;21767:2;21747:18;;;21740:30;-1:-1:-1;;;21786:18:1;;;21779:44;21840:18;;78414:37:0;21526:338:1;78414:37:0;78489:10;78468:17;78476:8;78468:7;:17::i;:::-;-1:-1:-1;;;;;78468:31:0;;78460:74;;;;-1:-1:-1;;;78460:74:0;;10715:2:1;78460:74:0;;;10697:21:1;10754:2;10734:18;;;10727:30;10793:32;10773:18;;;10766:60;10843:18;;78460:74:0;10513:354:1;78460:74:0;78551:20;;;;:10;:20;;;;;;;;:29;78543:66;;;;-1:-1:-1;;;78543:66:0;;12951:2:1;78543:66:0;;;12933:21:1;12990:2;12970:18;;;12963:30;13029:26;13009:18;;;13002:54;13073:18;;78543:66:0;12749:348:1;78543:66:0;78618:20;;;;:10;:20;;;;;:27;;-1:-1:-1;;78618:27:0;78641:4;78618:27;;;78358:293::o;54258:326::-;54375:7;54416:16;;;:7;:16;;;;;;-1:-1:-1;;;;;54416:16:0;54465:19;54443:110;;;;-1:-1:-1;;;54443:110:0;;17095:2:1;54443:110:0;;;17077:21:1;17134:2;17114:18;;;17107:30;17173:34;17153:18;;;17146:62;-1:-1:-1;;;17224:18:1;;;17217:39;17273:19;;54443:110:0;16893:405:1;79549:185:0;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;79638:10:::1;79626:9;;:22;79618:79;;;::::0;-1:-1:-1;;;79618:79:0;;15088:2:1;79618:79:0::1;::::0;::::1;15070:21:1::0;15127:2;15107:18;;;15100:30;15166:34;15146:18;;;15139:62;-1:-1:-1;;;15217:18:1;;;15210:42;15269:19;;79618:79:0::1;14886:408:1::0;79618:79:0::1;79706:9;:22:::0;79549:185::o;53901:295::-;54018:7;-1:-1:-1;;;;;54065:19:0;;54043:111;;;;-1:-1:-1;;;54043:111:0;;16684:2:1;54043:111:0;;;16666:21:1;16723:2;16703:18;;;16696:30;16762:34;16742:18;;;16735:62;-1:-1:-1;;;16813:18:1;;;16806:40;16863:19;;54043:111:0;16482:406:1;54043:111:0;-1:-1:-1;;;;;;54172:16:0;;;;;:9;:16;;;;;;;53901:295::o;68610:94::-;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;68675:21:::1;68693:1;68675:9;:21::i;80614:58::-:0;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;80658:8:::1;:6;:8::i;54820:104::-:0;54876:13;54909:7;54902:14;;;;;:::i;56724:187::-;56851:52;844:10;56884:8;56894;56851:18;:52::i;75430:49::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75430:49:0;:::o;79957:110::-;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;80031:15:::1;:30:::0;;-1:-1:-1;;80031:30:0::1;::::0;::::1;;::::0;;;::::1;::::0;;79957:110::o;78657:223::-;78754:11;78728:23;78781:94;78805:15;78801:1;:19;78781:94;;;78838:27;78850:11;;78862:1;78850:14;;;;;;;:::i;:::-;;;;;;;78838:11;:27::i;:::-;78822:3;;;;:::i;:::-;;;;78781:94;;;;78719:161;78657:223;;:::o;78992:101::-;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;79061:10:::1;:26:::0;;-1:-1:-1;;79061:26:0::1;::::0;::::1;;::::0;;;::::1;::::0;;78992:101::o;57966:365::-;58155:41;844:10;58188:7;58155:18;:41::i;:::-;58133:140;;;;-1:-1:-1;;;58133:140:0;;;;;;;:::i;:::-;58284:39;58298:4;58304:2;58308:7;58317:5;58284:13;:39::i;79766:82::-;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;79827:4:::1;:15:::0;79766:82::o;74771:37::-;;;;;;;:::i;77523:829::-;59943:4;59967:16;;;:7;:16;;;;;;77596:13;;-1:-1:-1;;;;;59967:16:0;77621:76;;;;-1:-1:-1;;;77621:76:0;;19050:2:1;77621:76:0;;;19032:21:1;19089:2;19069:18;;;19062:30;19128:34;19108:18;;;19101:62;-1:-1:-1;;;19179:18:1;;;19172:45;19234:19;;77621:76:0;18848:411:1;77621:76:0;77709:13;;;;;;;;:21;;:13;:21;77706:240;;;77743:29;77775:10;:8;:10::i;:::-;77743:42;;77835:1;77809:15;77803:29;:33;:135;;;;;;;;;;;;;;;;;77872:15;77889:18;:7;:16;:18::i;:::-;77909:13;77855:68;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;77803:135;77796:142;77523:829;-1:-1:-1;;;77523:829:0:o;77706:240::-;77961:19;;;;:10;:19;;;;;;;;77958:192;;78040:1;78015:14;78009:28;;;;;:::i;:::-;;;:32;:133;;;;;;;;;;;;;;;;;78077:14;78093:18;:7;:16;:18::i;:::-;78113:13;78060:67;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;78002:140;77523:829;-1:-1:-1;;77523:829:0:o;77958:192::-;78158:28;78189:10;:8;:10::i;79421:122::-;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;79504:33;;::::1;::::0;:13:::1;::::0;:33:::1;::::0;::::1;::::0;::::1;:::i;80238:266::-:0;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;80320:1:::1;80311:6;:10;80303:19;;;::::0;::::1;;80363:9;;80353:6;80339:11;;:20;;;;:::i;:::-;:33;;80331:42;;;::::0;::::1;;80395:9;80390:109;80414:6;80410:1;:10;80390:109;;;80451:1;80436:11;;:16;;;;;;;:::i;:::-;;;;;;;;80461:30;80467:10;80479:11;;80461:5;:30::i;:::-;80422:3:::0;::::1;::::0;::::1;:::i;:::-;;;;80390:109;;79191:120:::0;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;79273:32;;::::1;::::0;:14:::1;::::0;:32:::1;::::0;::::1;::::0;::::1;:::i;68859:192::-:0;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;68948:22:0;::::1;68940:73;;;::::0;-1:-1:-1;;;68940:73:0;;11842:2:1;68940:73:0::1;::::0;::::1;11824:21:1::0;11881:2;11861:18;;;11854:30;11920:34;11900:18;;;11893:62;-1:-1:-1;;;11971:18:1;;;11964:36;12017:19;;68940:73:0::1;11640:402:1::0;68940:73:0::1;69024:19;69034:8;69024:9;:19::i;80510:98::-:0;68032:6;;-1:-1:-1;;;;;68032:6:0;844:10;68179:23;68171:68;;;;-1:-1:-1;;;68171:68:0;;;;;;;:::i;:::-;80578:13:::1;:24:::0;;;::::1;;;;-1:-1:-1::0;;80578:24:0;;::::1;::::0;;;::::1;::::0;;80510:98::o;63999:174::-;64074:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;64074:29:0;-1:-1:-1;;;;;64074:29:0;;;;;;;;:24;;64128:23;64074:24;64128:14;:23::i;:::-;-1:-1:-1;;;;;64119:46:0;;;;;;;;;;;63999:174;;:::o;60172:452::-;60301:4;59967:16;;;:7;:16;;;;;;-1:-1:-1;;;;;59967:16:0;60323:110;;;;-1:-1:-1;;;60323:110:0;;15501:2:1;60323:110:0;;;15483:21:1;15540:2;15520:18;;;15513:30;15579:34;15559:18;;;15552:62;-1:-1:-1;;;15630:18:1;;;15623:42;15682:19;;60323:110:0;15299:408:1;60323:110:0;60444:13;60460:23;60475:7;60460:14;:23::i;:::-;60444:39;;60513:5;-1:-1:-1;;;;;60502:16:0;:7;-1:-1:-1;;;;;60502:16:0;;:64;;;;60559:7;-1:-1:-1;;;;;60535:31:0;:20;60547:7;60535:11;:20::i;:::-;-1:-1:-1;;;;;60535:31:0;;60502:64;:113;;;-1:-1:-1;;;;;;57153:25:0;;;57124:4;57153:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;60583:32;60494:122;60172:452;-1:-1:-1;;;;60172:452:0:o;63268:613::-;63441:4;-1:-1:-1;;;;;63414:31:0;:23;63429:7;63414:14;:23::i;:::-;-1:-1:-1;;;;;63414:31:0;;63392:122;;;;-1:-1:-1;;;63392:122:0;;18640:2:1;63392:122:0;;;18622:21:1;18679:2;18659:18;;;18652:30;18718:34;18698:18;;;18691:62;-1:-1:-1;;;18769:18:1;;;18762:39;18818:19;;63392:122:0;18438:405:1;63392:122:0;-1:-1:-1;;;;;63533:16:0;;63525:65;;;;-1:-1:-1;;;63525:65:0;;14329:2:1;63525:65:0;;;14311:21:1;14368:2;14348:18;;;14341:30;14407:34;14387:18;;;14380:62;-1:-1:-1;;;14458:18:1;;;14451:34;14502:19;;63525:65:0;14127:400:1;63525:65:0;63603:39;63624:4;63630:2;63634:7;63603:20;:39::i;:::-;63707:29;63724:1;63728:7;63707:8;:29::i;:::-;-1:-1:-1;;;;;63749:15:0;;;;;;:9;:15;;;;;:20;;63768:1;;63749:15;:20;;63768:1;;63749:20;:::i;:::-;;;;-1:-1:-1;;;;;;;63780:13:0;;;;;;:9;:13;;;;;:18;;63797:1;;63780:13;:18;;63797:1;;63780:18;:::i;:::-;;;;-1:-1:-1;;63809:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;63809:21:0;-1:-1:-1;;;;;63809:21:0;;;;;;;;;63846:27;;63809:16;;63846:27;;;;;;;63268:613;;;:::o;2863:108::-;2775:7;;-1:-1:-1;;;2775:7:0;;;;2933:9;2925:38;;;;-1:-1:-1;;;2925:38:0;;15914:2:1;2925:38:0;;;15896:21:1;15953:2;15933:18;;;15926:30;-1:-1:-1;;;15972:18:1;;;15965:46;16028:18;;2925:38:0;15712:340:1;60966:110:0;61042:26;61052:2;61056:7;61042:26;;;;;;;;;;;;:9;:26::i;70302:190::-;70427:4;70480;70451:25;70464:5;70471:4;70451:12;:25::i;:::-;:33;;70302:190;-1:-1:-1;;;;70302:190:0:o;61960:382::-;-1:-1:-1;;;;;62040:16:0;;62032:61;;;;-1:-1:-1;;;62032:61:0;;17505:2:1;62032:61:0;;;17487:21:1;;;17524:18;;;17517:30;17583:34;17563:18;;;17556:62;17635:18;;62032:61:0;17303:356:1;62032:61:0;59943:4;59967:16;;;:7;:16;;;;;;-1:-1:-1;;;;;59967:16:0;:30;62104:58;;;;-1:-1:-1;;;62104:58:0;;12594:2:1;62104:58:0;;;12576:21:1;12633:2;12613:18;;;12606:30;12672;12652:18;;;12645:58;12720:18;;62104:58:0;12392:352:1;62104:58:0;62175:45;62204:1;62208:2;62212:7;62175:20;:45::i;:::-;-1:-1:-1;;;;;62233:13:0;;;;;;:9;:13;;;;;:18;;62250:1;;62233:13;:18;;62250:1;;62233:18;:::i;:::-;;;;-1:-1:-1;;62262:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;62262:21:0;-1:-1:-1;;;;;62262:21:0;;;;;;;;62301:33;;62262:16;;;62301:33;;62262:16;;62301:33;61960:382;;:::o;3559:120::-;2568:16;:14;:16::i;:::-;3618:7:::1;:15:::0;;-1:-1:-1;;;;3618:15:0::1;::::0;;3649:22:::1;844:10:::0;3658:12:::1;3649:22;::::0;-1:-1:-1;;;;;8864:32:1;;;8846:51;;8834:2;8819:18;3649:22:0::1;;;;;;;3559:120::o:0;69059:173::-;69134:6;;;-1:-1:-1;;;;;69151:17:0;;;-1:-1:-1;;;;;;69151:17:0;;;;;;;69184:40;;69134:6;;;69151:17;69134:6;;69184:40;;69115:16;;69184:40;69104:128;69059:173;:::o;3300:118::-;2309:19;:17;:19::i;:::-;3360:7:::1;:14:::0;;-1:-1:-1;;;;3360:14:0::1;-1:-1:-1::0;;;3360:14:0::1;::::0;;3390:20:::1;3397:12;844:10:::0;;764:98;64315:315;64470:8;-1:-1:-1;;;;;64461:17:0;:5;-1:-1:-1;;;;;64461:17:0;;;64453:55;;;;-1:-1:-1;;;64453:55:0;;14734:2:1;64453:55:0;;;14716:21:1;14773:2;14753:18;;;14746:30;14812:27;14792:18;;;14785:55;14857:18;;64453:55:0;14532:349:1;64453:55:0;-1:-1:-1;;;;;64519:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;64519:46:0;;;;;;;;;;64581:41;;10002::1;;;64581::0;;9975:18:1;64581:41:0;;;;;;;64315:315;;;:::o;59213:352::-;59370:28;59380:4;59386:2;59390:7;59370:9;:28::i;:::-;59431:48;59454:4;59460:2;59464:7;59473:5;59431:22;:48::i;:::-;59409:148;;;;-1:-1:-1;;;59409:148:0;;;;;;;:::i;75873:102::-;75933:13;75962:7;75955:14;;;;;:::i;40576:723::-;40632:13;40853:10;40849:53;;-1:-1:-1;;40880:10:0;;;;;;;;;;;;-1:-1:-1;;;40880:10:0;;;;;40576:723::o;40849:53::-;40927:5;40912:12;40968:78;40975:9;;40968:78;;41001:8;;;;:::i;:::-;;-1:-1:-1;41024:10:0;;-1:-1:-1;41032:2:0;41024:10;;:::i;:::-;;;40968:78;;;41056:19;41088:6;41078:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41078:17:0;;41056:39;;41106:154;41113:10;;41106:154;;41140:11;41150:1;41140:11;;:::i;:::-;;-1:-1:-1;41209:10:0;41217:2;41209:5;:10;:::i;:::-;41196:24;;:2;:24;:::i;:::-;41183:39;;41166:6;41173;41166:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;41166:56:0;;;;;;;;-1:-1:-1;41237:11:0;41246:2;41237:11;;:::i;:::-;;;41106:154;;75981:351;76099:15;;-1:-1:-1;;;;;76099:15:0;76085:10;:29;76082:193;;;76128:18;;:57;;-1:-1:-1;;;76128:57:0;;-1:-1:-1;;;;;9195:15:1;;;76128:57:0;;;9177:34:1;;;9247:15;;;9227:18;;;9220:43;9279:18;;;9272:34;;;9322:18;;;9315:43;76128:18:0;;;;;;;;:34;;9111:19:1;;76128:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55937:341;55867:411;;:::o;76082:193::-;76212:18;;:55;;-1:-1:-1;;;76212:55:0;;-1:-1:-1;;;;;9195:15:1;;;76212:55:0;;;9177:34:1;9247:15;;;9227:18;;;9220:43;;;9279:18;;;9272:34;;;9322:18;;;9315:43;76212:18:0;;;;;;;;:34;;9111:19:1;;76212:55:0;;;;;;;;;;;;;;;;;;;61303:321;61433:18;61439:2;61443:7;61433:5;:18::i;:::-;61484:54;61515:1;61519:2;61523:7;61532:5;61484:22;:54::i;:::-;61462:154;;;;-1:-1:-1;;;61462:154:0;;;;;;;:::i;70853:296::-;70936:7;70979:4;70936:7;70994:118;71018:5;:12;71014:1;:16;70994:118;;;71067:33;71077:12;71091:5;71097:1;71091:8;;;;;;;;:::i;:::-;;;;;;;71067:9;:33::i;:::-;71052:48;-1:-1:-1;71032:3:0;;;;:::i;:::-;;;;70994:118;;;-1:-1:-1;71129:12:0;70853:296;-1:-1:-1;;;70853:296:0:o;3048:108::-;2775:7;;-1:-1:-1;;;2775:7:0;;;;3107:41;;;;-1:-1:-1;;;3107:41:0;;11074:2:1;3107:41:0;;;11056:21:1;11113:2;11093:18;;;11086:30;-1:-1:-1;;;11132:18:1;;;11125:50;11192:18;;3107:41:0;10872:344:1;65195:980:0;65350:4;-1:-1:-1;;;;;65371:13:0;;43424:20;43472:8;65367:801;;65424:175;;-1:-1:-1;;;65424:175:0;;-1:-1:-1;;;;;65424:36:0;;;;;:175;;844:10;;65518:4;;65545:7;;65575:5;;65424:175;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65424:175:0;;;;;;;;-1:-1:-1;;65424:175:0;;;;;;;;;;;;:::i;:::-;;;65403:710;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65782:13:0;;65778:320;;65825:108;;-1:-1:-1;;;65825:108:0;;;;;;;:::i;65778:320::-;66048:6;66042:13;66033:6;66029:2;66025:15;66018:38;65403:710;-1:-1:-1;;;;;;65663:51:0;-1:-1:-1;;;65663:51:0;;-1:-1:-1;65656:58:0;;65367:801;-1:-1:-1;66152:4:0;65195:980;;;;;;:::o;74032:149::-;74095:7;74126:1;74122;:5;:51;;74257:13;74351:15;;;74387:4;74380:15;;;74434:4;74418:21;;74122:51;;;-1:-1:-1;74257:13:0;74351:15;;;74387:4;74380:15;74434:4;74418:21;;;74032:149::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;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:173::-;718:20;;-1:-1:-1;;;;;767:31:1;;757:42;;747:70;;813:1;810;803:12;747:70;650:173;;;:::o;828:367::-;891:8;901:6;955:3;948:4;940:6;936:17;932:27;922:55;;973:1;970;963:12;922:55;-1:-1:-1;996:20:1;;1039:18;1028:30;;1025:50;;;1071:1;1068;1061:12;1025:50;1108:4;1100:6;1096:17;1084:29;;1168:3;1161:4;1151:6;1148:1;1144:14;1136:6;1132:27;1128:38;1125:47;1122:67;;;1185:1;1182;1175:12;1122:67;828:367;;;;;:::o;1200:160::-;1265:20;;1321:13;;1314:21;1304:32;;1294:60;;1350:1;1347;1340:12;1365:186;1424:6;1477:2;1465:9;1456:7;1452:23;1448:32;1445:52;;;1493:1;1490;1483:12;1445:52;1516:29;1535:9;1516:29;:::i;1556:260::-;1624:6;1632;1685:2;1673:9;1664:7;1660:23;1656:32;1653:52;;;1701:1;1698;1691:12;1653:52;1724:29;1743:9;1724:29;:::i;:::-;1714:39;;1772:38;1806:2;1795:9;1791:18;1772:38;:::i;:::-;1762:48;;1556:260;;;;;:::o;1821:328::-;1898:6;1906;1914;1967:2;1955:9;1946:7;1942:23;1938:32;1935:52;;;1983:1;1980;1973:12;1935:52;2006:29;2025:9;2006:29;:::i;:::-;1996:39;;2054:38;2088:2;2077:9;2073:18;2054:38;:::i;:::-;2044:48;;2139:2;2128:9;2124:18;2111:32;2101:42;;1821:328;;;;;:::o;2154:666::-;2249:6;2257;2265;2273;2326:3;2314:9;2305:7;2301:23;2297:33;2294:53;;;2343:1;2340;2333:12;2294:53;2366:29;2385:9;2366:29;:::i;:::-;2356:39;;2414:38;2448:2;2437:9;2433:18;2414:38;:::i;:::-;2404:48;;2499:2;2488:9;2484:18;2471:32;2461:42;;2554:2;2543:9;2539:18;2526:32;2581:18;2573:6;2570:30;2567:50;;;2613:1;2610;2603:12;2567:50;2636:22;;2689:4;2681:13;;2677:27;-1:-1:-1;2667:55:1;;2718:1;2715;2708:12;2667:55;2741:73;2806:7;2801:2;2788:16;2783:2;2779;2775:11;2741:73;:::i;:::-;2731:83;;;2154:666;;;;;;;:::o;2825:254::-;2890:6;2898;2951:2;2939:9;2930:7;2926:23;2922:32;2919:52;;;2967:1;2964;2957:12;2919:52;2990:29;3009:9;2990:29;:::i;:::-;2980:39;;3038:35;3069:2;3058:9;3054:18;3038:35;:::i;3084:254::-;3152:6;3160;3213:2;3201:9;3192:7;3188:23;3184:32;3181:52;;;3229:1;3226;3219:12;3181:52;3252:29;3271:9;3252:29;:::i;:::-;3242:39;3328:2;3313:18;;;;3300:32;;-1:-1:-1;;;3084:254:1:o;3343:437::-;3429:6;3437;3490:2;3478:9;3469:7;3465:23;3461:32;3458:52;;;3506:1;3503;3496:12;3458:52;3546:9;3533:23;3579:18;3571:6;3568:30;3565:50;;;3611:1;3608;3601:12;3565:50;3650:70;3712:7;3703:6;3692:9;3688:22;3650:70;:::i;:::-;3739:8;;3624:96;;-1:-1:-1;3343:437:1;-1:-1:-1;;;;3343:437:1:o;4227:180::-;4283:6;4336:2;4324:9;4315:7;4311:23;4307:32;4304:52;;;4352:1;4349;4342:12;4304:52;4375:26;4391:9;4375:26;:::i;4412:180::-;4471:6;4524:2;4512:9;4503:7;4499:23;4495:32;4492:52;;;4540:1;4537;4530:12;4492:52;-1:-1:-1;4563:23:1;;4412:180;-1:-1:-1;4412:180:1:o;4597:245::-;4655:6;4708:2;4696:9;4687:7;4683:23;4679:32;4676:52;;;4724:1;4721;4714:12;4676:52;4763:9;4750:23;4782:30;4806:5;4782:30;:::i;4847:249::-;4916:6;4969:2;4957:9;4948:7;4944:23;4940:32;4937:52;;;4985:1;4982;4975:12;4937:52;5017:9;5011:16;5036:30;5060:5;5036:30;:::i;5101:450::-;5170:6;5223:2;5211:9;5202:7;5198:23;5194:32;5191:52;;;5239:1;5236;5229:12;5191:52;5279:9;5266:23;5312:18;5304:6;5301:30;5298:50;;;5344:1;5341;5334:12;5298:50;5367:22;;5420:4;5412:13;;5408:27;-1:-1:-1;5398:55:1;;5449:1;5446;5439:12;5398:55;5472:73;5537:7;5532:2;5519:16;5514:2;5510;5506:11;5472:73;:::i;5741:254::-;5809:6;5817;5870:2;5858:9;5849:7;5845:23;5841:32;5838:52;;;5886:1;5883;5876:12;5838:52;5922:9;5909:23;5899:33;;5951:38;5985:2;5974:9;5970:18;5951:38;:::i;6000:257::-;6041:3;6079:5;6073:12;6106:6;6101:3;6094:19;6122:63;6178:6;6171:4;6166:3;6162:14;6155:4;6148:5;6144:16;6122:63;:::i;:::-;6239:2;6218:15;-1:-1:-1;;6214:29:1;6205:39;;;;6246:4;6201:50;;6000:257;-1:-1:-1;;6000:257:1:o;6262:973::-;6347:12;;6312:3;;6402:1;6422:18;;;;6475;;;;6502:61;;6556:4;6548:6;6544:17;6534:27;;6502:61;6582:2;6630;6622:6;6619:14;6599:18;6596:38;6593:161;;;6676:10;6671:3;6667:20;6664:1;6657:31;6711:4;6708:1;6701:15;6739:4;6736:1;6729:15;6593:161;6770:18;6797:104;;;;6915:1;6910:319;;;;6763:466;;6797:104;-1:-1:-1;;6830:24:1;;6818:37;;6875:16;;;;-1:-1:-1;6797:104:1;;6910:319;22124:1;22117:14;;;22161:4;22148:18;;7004:1;7018:165;7032:6;7029:1;7026:13;7018:165;;;7110:14;;7097:11;;;7090:35;7153:16;;;;7047:10;;7018:165;;;7022:3;;7212:6;7207:3;7203:16;7196:23;;6763:466;;;;;;;6262:973;;;;:::o;7474:550::-;7698:3;7736:6;7730:13;7752:53;7798:6;7793:3;7786:4;7778:6;7774:17;7752:53;:::i;:::-;7868:13;;7827:16;;;;7890:57;7868:13;7827:16;7924:4;7912:17;;7890:57;:::i;:::-;7963:55;8008:8;8001:5;7997:20;7989:6;7963:55;:::i;:::-;7956:62;7474:550;-1:-1:-1;;;;;;;7474:550:1:o;8029:456::-;8250:3;8278:38;8312:3;8304:6;8278:38;:::i;:::-;8345:6;8339:13;8361:52;8406:6;8402:2;8395:4;8387:6;8383:17;8361:52;:::i;9369:488::-;-1:-1:-1;;;;;9638:15:1;;;9620:34;;9690:15;;9685:2;9670:18;;9663:43;9737:2;9722:18;;9715:34;;;9785:3;9780:2;9765:18;;9758:31;;;9563:4;;9806:45;;9831:19;;9823:6;9806:45;:::i;:::-;9798:53;9369:488;-1:-1:-1;;;;;;9369:488:1:o;10289:219::-;10438:2;10427:9;10420:21;10401:4;10458:44;10498:2;10487:9;10483:18;10475:6;10458:44;:::i;11221:414::-;11423:2;11405:21;;;11462:2;11442:18;;;11435:30;11501:34;11496:2;11481:18;;11474:62;-1:-1:-1;;;11567:2:1;11552:18;;11545:48;11625:3;11610:19;;11221:414::o;18077:356::-;18279:2;18261:21;;;18298:18;;;18291:30;18357:34;18352:2;18337:18;;18330:62;18424:2;18409:18;;18077:356::o;20772:413::-;20974:2;20956:21;;;21013:2;20993:18;;;20986:30;21052:34;21047:2;21032:18;;21025:62;-1:-1:-1;;;21118:2:1;21103:18;;21096:47;21175:3;21160:19;;20772:413::o;22177:128::-;22217:3;22248:1;22244:6;22241:1;22238:13;22235:39;;;22254:18;;:::i;:::-;-1:-1:-1;22290:9:1;;22177:128::o;22310:120::-;22350:1;22376;22366:35;;22381:18;;:::i;:::-;-1:-1:-1;22415:9:1;;22310:120::o;22435:168::-;22475:7;22541:1;22537;22533:6;22529:14;22526:1;22523:21;22518:1;22511:9;22504:17;22500:45;22497:71;;;22548:18;;:::i;:::-;-1:-1:-1;22588:9:1;;22435:168::o;22608:125::-;22648:4;22676:1;22673;22670:8;22667:34;;;22681:18;;:::i;:::-;-1:-1:-1;22718:9:1;;22608:125::o;22738:258::-;22810:1;22820:113;22834:6;22831:1;22828:13;22820:113;;;22910:11;;;22904:18;22891:11;;;22884:39;22856:2;22849:10;22820:113;;;22951:6;22948:1;22945:13;22942:48;;;-1:-1:-1;;22986:1:1;22968:16;;22961:27;22738:258::o;23001:380::-;23080:1;23076:12;;;;23123;;;23144:61;;23198:4;23190:6;23186:17;23176:27;;23144:61;23251:2;23243:6;23240:14;23220:18;23217:38;23214:161;;;23297:10;23292:3;23288:20;23285:1;23278:31;23332:4;23329:1;23322:15;23360:4;23357:1;23350:15;23214:161;;23001:380;;;:::o;23386:135::-;23425:3;-1:-1:-1;;23446:17:1;;23443:43;;;23466:18;;:::i;:::-;-1:-1:-1;23513:1:1;23502:13;;23386:135::o;23526:112::-;23558:1;23584;23574:35;;23589:18;;:::i;:::-;-1:-1:-1;23623:9:1;;23526:112::o;23643:127::-;23704:10;23699:3;23695:20;23692:1;23685:31;23735:4;23732:1;23725:15;23759:4;23756:1;23749:15;23775:127;23836:10;23831:3;23827:20;23824:1;23817:31;23867:4;23864:1;23857:15;23891:4;23888:1;23881:15;23907:127;23968:10;23963:3;23959:20;23956:1;23949:31;23999:4;23996:1;23989:15;24023:4;24020:1;24013:15;24039:127;24100:10;24095:3;24091:20;24088:1;24081:31;24131:4;24128:1;24121:15;24155:4;24152:1;24145:15;24171:131;-1:-1:-1;;;;;;24245:32:1;;24235:43;;24225:71;;24292:1;24289;24282:12

Swarm Source

ipfs://36aee17437c0aea42938545f19f89bc882f68444b02ac12f156655c384ce68ab

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