Contract 0xc25Eb1a9eD37BB1AA5C7156dB46507df939116Fc 1

Contract Overview

Balance:
0 BNB
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xf5733a72f3c9b98d8ff4731e6887d0b953695c9ee383fa121285b48472c4dabbApprove157825562022-01-11 22:53:306 days 2 hrs ago0x7805fa0360110ea6deb508b00e3d19290c9fd0e5 IN  0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB0.0004584
0xe43d07784cfa39962e73647a1043c4dad5cd07f7b51c14af3fc41af9551ef313Set Admin127603692021-09-28 13:25:13111 days 12 hrs ago0x0014d8a0c42e5ec5d69b2b9190186c494e2a6905 IN  0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB0.00028434
0x2004150dca3f9b407d86520916b32d80b67c59d5136126ee42c1b6ca99a62f720x60806040127597582021-09-28 12:54:40111 days 12 hrs ago0x0014d8a0c42e5ec5d69b2b9190186c494e2a6905 IN  Create: VaultNFT0 BNB0.01710048
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x381004d23db0347443b92c7ed72d2891e0b4b7a7d521606fc8e8b3a87dc39fc8158821542022-01-15 10:03:532 days 15 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x381004d23db0347443b92c7ed72d2891e0b4b7a7d521606fc8e8b3a87dc39fc8158821542022-01-15 10:03:532 days 15 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x381004d23db0347443b92c7ed72d2891e0b4b7a7d521606fc8e8b3a87dc39fc8158821542022-01-15 10:03:532 days 15 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x381004d23db0347443b92c7ed72d2891e0b4b7a7d521606fc8e8b3a87dc39fc8158821542022-01-15 10:03:532 days 15 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x8d1af409f954851e4d0119853894b339852661896c80ef0bfe14d8f862b13976158665752022-01-14 21:04:563 days 4 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0xd4eefbafd3caca5be0933d0f5bd7cc0aaaed572f950d650f05b139af1cdaf494158585912022-01-14 14:25:193 days 11 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0xd4eefbafd3caca5be0933d0f5bd7cc0aaaed572f950d650f05b139af1cdaf494158585912022-01-14 14:25:193 days 11 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0xd4eefbafd3caca5be0933d0f5bd7cc0aaaed572f950d650f05b139af1cdaf494158585912022-01-14 14:25:193 days 11 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0xd4eefbafd3caca5be0933d0f5bd7cc0aaaed572f950d650f05b139af1cdaf494158585912022-01-14 14:25:193 days 11 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0xfc1a8a45378b608641a0bd9bc1b6390ebb1d24bcd508dd49d84d4bf36f5624ee158392152022-01-13 22:16:314 days 3 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x4e2489404d459d15223fb2eed9183d4e744b2321a8812e64238a3ed38301e4be158246622022-01-13 9:58:484 days 15 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x9a7d5f14b1eeaf588d8c7743a7735dd60bd8f2b771a0b45efc53959945b78376158236622022-01-13 9:08:484 days 16 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0xc457aad9fdf029d063bc7ab8f8600c73a2d79fd40f36edd64facaf08f7e29702158229772022-01-13 8:34:334 days 16 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x01f9b950e9fd39ea9196dc2b6182e8dce5e4e5af870b4cbd3b126d56fc6fa77c158229122022-01-13 8:31:184 days 16 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x0d6c2fe0fe6a801b5bb1f60cf551585ca25b05cdd94592059d4353ab1e7351cd158228302022-01-13 8:27:124 days 16 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x2c45504c43e546d2354637c2d2a84a9c64b8b9a24620d685f762f13c25274b15158226662022-01-13 8:19:004 days 17 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0xdb244d2edb7674ee702b9d4535cf21dd03dac482be4fbacfdb20d53d9cee486d158226412022-01-13 8:17:454 days 17 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x58709331b4aca59ae4f252b3245d0bfa366b19bfbfe6213344a59a92ea1f31d9158197352022-01-13 5:52:274 days 19 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x39e58a9116bf8b8e64ef5ea79be345ba74aca775295c6184955f5efc7198cc08157554242022-01-11 0:16:547 days 1 hr ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0xf3567664f47266aa775a8d93e92cafadd1886207a4b2b0568ecef4b9ecfd8740157402172022-01-10 11:35:577 days 13 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0xf3567664f47266aa775a8d93e92cafadd1886207a4b2b0568ecef4b9ecfd8740157402172022-01-10 11:35:577 days 13 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x656721a8897c3e6edf845efcb7e03b22a474aa56be4aa5d3a6894851153068a7157401402022-01-10 11:32:067 days 13 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x656721a8897c3e6edf845efcb7e03b22a474aa56be4aa5d3a6894851153068a7157401402022-01-10 11:32:067 days 13 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0x8e68ae609fb0fee4dd6ac066eb177f4ea7b198098cb421befb6d269a1121c909155563392022-01-04 2:20:4413 days 23 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
0xe1bcbf4c1c813842e62968fd518c805a051bbb3c9cf4f967c0e186c55fe8c44f155496832022-01-03 20:47:5614 days 4 hrs ago 0xc9f654d481e79d01448030b08516b7f9fcf71e13 0xc25eb1a9ed37bb1aa5c7156db46507df939116fc0 BNB
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
VaultNFT

Compiler Version
v0.5.17+commit.d19bba13

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-09-28
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.5.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 GSN 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.
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// File: @openzeppelin/contracts/introspection/IERC165.sol



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




/**
 * @dev Required interface of an ERC721 compliant contract.
 */
contract IERC721 is IERC165 {
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

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

    /**
     * @dev Returns the owner of the NFT specified by `tokenId`.
     */
    function ownerOf(uint256 tokenId) public view returns (address owner);

    /**
     * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
     * another (`to`).
     *
     *
     *
     * Requirements:
     * - `from`, `to` cannot be zero.
     * - `tokenId` must be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this
     * NFT by either {approve} or {setApprovalForAll}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public;
    /**
     * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
     * another (`to`).
     *
     * Requirements:
     * - If the caller is not `from`, it must be approved to move this NFT by
     * either {approve} or {setApprovalForAll}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public;
    function approve(address to, uint256 tokenId) public;
    function getApproved(uint256 tokenId) public view returns (address operator);

    function setApprovalForAll(address operator, bool _approved) public;
    function isApprovedForAll(address owner, address operator) public view returns (bool);


    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
contract IERC721Receiver {
    /**
     * @notice Handle the receipt of an NFT
     * @dev The ERC721 smart contract calls this function on the recipient
     * after a {IERC721-safeTransferFrom}. This function MUST return the function selector,
     * otherwise the caller will revert the transaction. The selector to be
     * returned can be obtained as `this.onERC721Received.selector`. This
     * function MAY throw to revert and reject the transfer.
     * Note: the ERC721 contract address is always the message sender.
     * @param operator The address which called `safeTransferFrom` function
     * @param from The address which previously owned the token
     * @param tokenId The NFT identifier which is being transferred
     * @param data Additional data with no specified format
     * @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
    public returns (bytes4);
}

// File: @openzeppelin/contracts/math/SafeMath.sol

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     *
     * _Available since v2.4.0._
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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


/**
 * @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) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Converts an `address` into `address payable`. Note that this is
     * simply a type cast: the actual underlying value is not changed.
     *
     * _Available since v2.4.0._
     */
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

    /**
     * @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].
     *
     * _Available since v2.4.0._
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-call-value
        (bool success, ) = recipient.call.value(amount)("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
}

// File: @openzeppelin/contracts/drafts/Counters.sol




/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath}
 * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
 * directly accessed.
 */
library Counters {
    using SafeMath for uint256;

    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        // The {SafeMath} overflow check can be skipped here, see the comment at the top
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value.sub(1);
    }
}

// File: @openzeppelin/contracts/introspection/ERC165.sol



/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () internal {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

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










/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721 is Context, ERC165, IERC721 {
    using SafeMath for uint256;
    using Address for address;
    using Counters for Counters.Counter;

    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

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

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

    // Mapping from owner to number of owned token
    mapping (address => Counters.Counter) private _ownedTokensCount;

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

    /*
     *     bytes4(keccak256('balanceOf(address)')) == 0x70a08231
     *     bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
     *     bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
     *     bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
     *     bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
     *
     *     => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
     *        0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    constructor () public {
        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
    }

    /**
     * @dev Gets the balance of the specified address.
     * @param owner address to query the balance of
     * @return uint256 representing the amount owned by the passed address
     */
    function balanceOf(address owner) public view returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");

        return _ownedTokensCount[owner].current();
    }

    /**
     * @dev Gets the owner of the specified token ID.
     * @param tokenId uint256 ID of the token to query the owner of
     * @return address currently marked as the owner of the given token ID
     */
    function ownerOf(uint256 tokenId) public view returns (address) {
        address owner = _tokenOwner[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");

        return owner;
    }

    /**
     * @dev Approves another address to transfer the given token ID
     * The zero address indicates there is no approved address.
     * There can only be one approved address per token at a given time.
     * Can only be called by the token owner or an approved operator.
     * @param to address to be approved for the given token ID
     * @param tokenId uint256 ID of the token to be approved
     */
    function approve(address to, uint256 tokenId) public {
        address owner = 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"
        );

        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Gets the approved address for a token ID, or zero if no address set
     * Reverts if the token ID does not exist.
     * @param tokenId uint256 ID of the token to query the approval of
     * @return address currently approved for the given token ID
     */
    function getApproved(uint256 tokenId) public view returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Sets or unsets the approval of a given operator
     * An operator is allowed to transfer all tokens of the sender on their behalf.
     * @param to operator address to set the approval
     * @param approved representing the status of the approval to be set
     */
    function setApprovalForAll(address to, bool approved) public {
        require(to != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][to] = approved;
        emit ApprovalForAll(_msgSender(), to, approved);
    }

    /**
     * @dev Tells whether an operator is approved by a given owner.
     * @param owner owner address which you want to query the approval of
     * @param operator operator address which you want to query the approval of
     * @return bool whether the given operator is approved by the given owner
     */
    function isApprovedForAll(address owner, address operator) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev Transfers the ownership of a given token ID to another address.
     * Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     * Requires the msg.sender to be the owner, approved, or operator.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function transferFrom(address from, address to, uint256 tokenId) public {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transferFrom(from, to, tokenId);
    }

    /**
     * @dev Safely transfers the ownership of a given token ID to another address
     * If the target address is a contract, it must implement {IERC721Receiver-onERC721Received},
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * Requires the msg.sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev Safely transfers the ownership of a given token ID to another address
     * If the target address is a contract, it must implement {IERC721Receiver-onERC721Received},
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * Requires the _msgSender() to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes data to send along with a safe transfer check
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransferFrom(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers the ownership of a given token ID to another address
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * Requires the msg.sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes data to send along with a safe transfer check
     */
    function _safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) internal {
        _transferFrom(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether the specified token exists.
     * @param tokenId uint256 ID of the token to query the existence of
     * @return bool whether the token exists
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        address owner = _tokenOwner[tokenId];
        return owner != address(0);
    }

    /**
     * @dev Returns whether the given spender can transfer a given token ID.
     * @param spender address of the spender to query
     * @param tokenId uint256 ID of the token to be transferred
     * @return bool whether the msg.sender is approved for the given token ID,
     * is an operator of the owner, or is the owner of the token
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Internal function to safely mint a new token.
     * Reverts if the given token ID already exists.
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * @param to The address that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     */
    function _safeMint(address to, uint256 tokenId) internal {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Internal function to safely mint a new token.
     * Reverts if the given token ID already exists.
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * @param to The address that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     * @param _data bytes data to send along with a safe transfer check
     */
    function _safeMint(address to, uint256 tokenId, bytes memory _data) internal {
        _mint(to, tokenId);
        require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Internal function to mint a new token.
     * Reverts if the given token ID already exists.
     * @param to The address that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     */
    function _mint(address to, uint256 tokenId) internal {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _tokenOwner[tokenId] = to;
        _ownedTokensCount[to].increment();

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

    /**
     * @dev Internal function to burn a specific token.
     * Reverts if the token does not exist.
     * Deprecated, use {_burn} instead.
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(address owner, uint256 tokenId) internal {
        require(ownerOf(tokenId) == owner, "ERC721: burn of token that is not own");

        _clearApproval(tokenId);

        _ownedTokensCount[owner].decrement();
        _tokenOwner[tokenId] = address(0);

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

    /**
     * @dev Internal function to burn a specific token.
     * Reverts if the token does not exist.
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(uint256 tokenId) internal {
        _burn(ownerOf(tokenId), tokenId);
    }

    /**
     * @dev Internal function to transfer ownership of a given token ID to another address.
     * As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function _transferFrom(address from, address to, uint256 tokenId) internal {
        require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _clearApproval(tokenId);

        _ownedTokensCount[from].decrement();
        _ownedTokensCount[to].increment();

        _tokenOwner[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * This is an internal detail of the `ERC721` contract and its use is deprecated.
     * @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)
        internal returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }
        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = to.call(abi.encodeWithSelector(
            IERC721Receiver(to).onERC721Received.selector,
            _msgSender(),
            from,
            tokenId,
            _data
        ));
        if (!success) {
            if (returndata.length > 0) {
                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert("ERC721: transfer to non ERC721Receiver implementer");
            }
        } else {
            bytes4 retval = abi.decode(returndata, (bytes4));
            return (retval == _ERC721_RECEIVED);
        }
    }

    /**
     * @dev Private function to clear current approval of a given token ID.
     * @param tokenId uint256 ID of the token to be transferred
     */
    function _clearApproval(uint256 tokenId) private {
        if (_tokenApprovals[tokenId] != address(0)) {
            _tokenApprovals[tokenId] = address(0);
        }
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol



/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
contract IERC721Enumerable is IERC721 {
    function totalSupply() public view returns (uint256);
    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);

    function tokenByIndex(uint256 index) public view returns (uint256);
}

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







/**
 * @title ERC-721 Non-Fungible Token with optional enumeration extension logic
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721Enumerable is Context, ERC165, ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => uint256[]) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /*
     *     bytes4(keccak256('totalSupply()')) == 0x18160ddd
     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
     *     bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
     *
     *     => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
     */
    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;

    /**
     * @dev Constructor function.
     */
    constructor () public {
        // register the supported interface to conform to ERC721Enumerable via ERC165
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

    /**
     * @dev Gets the token ID at a given index of the tokens list of the requested owner.
     * @param owner address owning the tokens list to be accessed
     * @param index uint256 representing the index to be accessed of the requested tokens list
     * @return uint256 token ID at the given index of the tokens list owned by the requested address
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
        require(index < balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev Gets the total amount of tokens stored by the contract.
     * @return uint256 representing the total amount of tokens
     */
    function totalSupply() public view returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev Gets the token ID at a given index of all the tokens in this contract
     * Reverts if the index is greater or equal to the total number of tokens.
     * @param index uint256 representing the index to be accessed of the tokens list
     * @return uint256 token ID at the given index of the tokens list
     */
    function tokenByIndex(uint256 index) public view returns (uint256) {
        require(index < totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev Internal function to transfer ownership of a given token ID to another address.
     * As opposed to transferFrom, this imposes no restrictions on msg.sender.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function _transferFrom(address from, address to, uint256 tokenId) internal {
        super._transferFrom(from, to, tokenId);

        _removeTokenFromOwnerEnumeration(from, tokenId);

        _addTokenToOwnerEnumeration(to, tokenId);
    }

    /**
     * @dev Internal function to mint a new token.
     * Reverts if the given token ID already exists.
     * @param to address the beneficiary that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     */
    function _mint(address to, uint256 tokenId) internal {
        super._mint(to, tokenId);

        _addTokenToOwnerEnumeration(to, tokenId);

        _addTokenToAllTokensEnumeration(tokenId);
    }

    /**
     * @dev Internal function to burn a specific token.
     * Reverts if the token does not exist.
     * Deprecated, use {ERC721-_burn} instead.
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(address owner, uint256 tokenId) internal {
        super._burn(owner, tokenId);

        _removeTokenFromOwnerEnumeration(owner, tokenId);
        // Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
        _ownedTokensIndex[tokenId] = 0;

        _removeTokenFromAllTokensEnumeration(tokenId);
    }

    /**
     * @dev Gets the list of token IDs of the requested owner.
     * @param owner address owning the tokens
     * @return uint256[] List of token IDs owned by the requested address
     */
    function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
        return _ownedTokens[owner];
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        _ownedTokensIndex[tokenId] = _ownedTokens[to].length;
        _ownedTokens[to].push(tokenId);
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        _ownedTokens[from].length--;

        // Note that _ownedTokensIndex[tokenId] hasn't been cleared: it still points to the old slot (now occupied by
        // lastTokenId, or just over the end of the array if the token was the last one).
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length.sub(1);
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        _allTokens.length--;
        _allTokensIndex[tokenId] = 0;
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Metadata.sol



/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
contract IERC721Metadata is IERC721 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/token/ERC721/ERC721Metadata.sol






contract ERC721Metadata is Context, ERC165, ERC721, IERC721Metadata {
    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Base URI
    string private _baseURI;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

    /*
     *     bytes4(keccak256('name()')) == 0x06fdde03
     *     bytes4(keccak256('symbol()')) == 0x95d89b41
     *     bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
     *
     *     => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
     */
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

    /**
     * @dev Constructor function
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
    }

    /**
     * @dev Gets the token name.
     * @return string representing the token name
     */
    function name() external view returns (string memory) {
        return _name;
    }

    /**
     * @dev Gets the token symbol.
     * @return string representing the token symbol
     */
    function symbol() external view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the URI for a given token ID. May return an empty string.
     *
     * If the token's URI is non-empty and a base URI was set (via
     * {_setBaseURI}), it will be added to the token ID's URI as a prefix.
     *
     * Reverts if the token ID does not exist.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];

        // Even if there is a base URI, it is only appended to non-empty token-specific URIs
        if (bytes(_tokenURI).length == 0) {
            return "";
        } else {
            // abi.encodePacked is being used to concatenate strings
            return string(abi.encodePacked(_baseURI, _tokenURI));
        }
    }

    /**
     * @dev Internal function to set the token URI for a given token.
     *
     * Reverts if the token ID does not exist.
     *
     * TIP: if all token IDs share a prefix (e.g. if your URIs look like
     * `http://api.myproject.com/token/<id>`), use {_setBaseURI} to store
     * it and save gas.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI}.
     *
     * _Available since v2.5.0._
     */
    function _setBaseURI(string memory baseURI) internal {
        _baseURI = baseURI;
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a preffix in {tokenURI} to each token's URI, when
    * they are non-empty.
    *
    * _Available since v2.5.0._
    */
    function baseURI() external view returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev Internal function to burn a specific token.
     * Reverts if the token does not exist.
     * Deprecated, use _burn(uint256) instead.
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned by the msg.sender
     */
    function _burn(address owner, uint256 tokenId) internal {
        super._burn(owner, tokenId);

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }
}

// File: @openzeppelin/contracts/token/ERC721/ERC721Full.sol





/**
 * @title Full ERC721 Token
 * @dev This implementation includes all the required and some optional functionality of the ERC721 standard
 * Moreover, it includes approve all functionality using operator terminology.
 *
 * See https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
    constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
        // solhint-disable-previous-line no-empty-blocks
    }
}

// File: contracts/MyVault.sol

// contracts/MyVaultNFT.sol
// SPDX-License-Identifier: MIT



contract VaultNFT is ERC721Full {
        
    address admin;
    
    constructor() public ERC721Full("ghostDai Vault", "GDV") {
        admin = msg.sender;
    }
    
    function setAdmin(address _admin) public {
        require(admin==msg.sender);
        admin=_admin;
    }

    function _transferFrom(address from, address to, uint256 tokenId) internal {
        
    }
    
    function burn(uint256 tokenId) public {
        require(
            msg.sender == admin,
            "Token: account does not have burn role"
        );
        _burn(tokenId);
    }
    
    function mint(address to, uint256 tokenId) public {
        require(
            msg.sender == admin,
            "Token: account does not have minter role"
        );
        _mint(to, tokenId);
    }
}

Contract ABI

[{"inputs":[],"payable":false,"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":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"constant":false,"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"mint","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"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":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_admin","type":"address"}],"name":"setAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

47563:814:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47563:814:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16298:135;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;16298:135:0;-1:-1:-1;;;;;;16298:135:0;;:::i;:::-;;;;;;;;;;;;;;;;;;43974:85;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;43974:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21237:204;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;21237:204:0;;:::i;:::-;;;;-1:-1:-1;;;;;21237:204:0;;;;;;;;;;;;;;20519:425;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;20519:425:0;;;;;;;;:::i;:::-;;35616:96;;;:::i;:::-;;;;;;;;;;;;;;;;22920:292;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;22920:292:0;;;;;;;;;;;;;;;;;:::i;35225:232::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;35225:232:0;;;;;;;;:::i;48167:207::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;48167:207:0;;;;;;;;:::i;23874:134::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;23874:134:0;;;;;;;;;;;;;;;;;:::i;47966:189::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47966:189:0;;:::i;36058:199::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;36058:199:0;;:::i;19860:228::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19860:228:0;;:::i;46227:91::-;;;:::i;47744:109::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47744:109:0;-1:-1:-1;;;;;47744:109:0;;:::i;19423:211::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19423:211:0;-1:-1:-1;;;;;19423:211:0;;:::i;44174:89::-;;;:::i;21742:254::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;21742:254:0;;;;;;;;;;:::i;24745:272::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;24745:272:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;24745:272:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;24745:272:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;24745:272:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;24745:272:0;;-1:-1:-1;24745:272:0;;-1:-1:-1;;;;;24745:272:0:i;44576:557::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44576:557:0;;:::i;22326:147::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;22326:147:0;;;;;;;;;;:::i;16298:135::-;-1:-1:-1;;;;;;16392:33:0;;16368:4;16392:33;;;;;;;;;;;;;16298:135;;;;:::o;43974:85::-;44046:5;44039:12;;;;;;;;-1:-1:-1;;44039:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44013:13;;44039:12;;44046:5;;44039:12;;44046:5;44039:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43974:85;;:::o;21237:204::-;21296:7;21324:16;21332:7;21324;:16::i;:::-;21316:73;;;;-1:-1:-1;;;21316:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21409:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;21409:24:0;;21237:204::o;20519:425::-;20583:13;20599:16;20607:7;20599;:16::i;:::-;20583:32;;20640:5;-1:-1:-1;;;;;20634:11:0;:2;-1:-1:-1;;;;;20634:11:0;;;20626:57;;;;-1:-1:-1;;;20626:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20720:5;-1:-1:-1;;;;;20704:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;20704:21:0;;:62;;;;20729:37;20746:5;20753:12;:10;:12::i;:::-;20729:16;:37::i;:::-;20696:154;;;;-1:-1:-1;;;20696:154:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20863:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;20863:29:0;-1:-1:-1;;;;;20863:29:0;;;;;;;;;20908:28;;20863:24;;20908:28;;;;;;;20519:425;;;:::o;35616:96::-;35687:10;:17;35616:96;:::o;22920:292::-;23064:41;23083:12;:10;:12::i;:::-;23097:7;23064:18;:41::i;:::-;23056:103;;;;-1:-1:-1;;;23056:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23172:32;23186:4;23192:2;23196:7;23172:32;22920:292;;;:::o;35225:232::-;35305:7;35341:16;35351:5;35341:9;:16::i;:::-;35333:5;:24;35325:80;;;;-1:-1:-1;;;35325:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;35423:19:0;;;;;;:12;:19;;;;;:26;;35443:5;;35423:26;;;;;;;;;;;;;;35416:33;;35225:232;;;;:::o;48167:207::-;48264:5;;-1:-1:-1;;;;;48264:5:0;48250:10;:19;48228:109;;;;-1:-1:-1;;;48228:109:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48348:18;48354:2;48358:7;48348:5;:18::i;:::-;48167:207;;:::o;23874:134::-;23961:39;23978:4;23984:2;23988:7;23961:39;;;;;;;;;;;;:16;:39::i;47966:189::-;48051:5;;-1:-1:-1;;;;;48051:5:0;48037:10;:19;48015:107;;;;-1:-1:-1;;;48015:107:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48133:14;48139:7;48133:5;:14::i;:::-;47966:189;:::o;36058:199::-;36116:7;36152:13;:11;:13::i;:::-;36144:5;:21;36136:78;;;;-1:-1:-1;;;36136:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36232:10;36243:5;36232:17;;;;;;;;;;;;;;;;36225:24;;36058:199;;;:::o;19860:228::-;19915:7;19951:20;;;:11;:20;;;;;;-1:-1:-1;;;;;19951:20:0;19990:19;19982:73;;;;-1:-1:-1;;;19982:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20075:5;19860:228;-1:-1:-1;;19860:228:0:o;46227:91::-;46302:8;46295:15;;;;;;;;-1:-1:-1;;46295:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46269:13;;46295:15;;46302:8;;46295:15;;46302:8;46295:15;;;;;;;;;;;;;;;;;;;;;;;;47744:109;47804:5;;-1:-1:-1;;;;;47804:5:0;47811:10;47804:17;47796:26;;;;;;47833:5;:12;;-1:-1:-1;;;;;;47833:12:0;-1:-1:-1;;;;;47833:12:0;;;;;;;;;;47744:109::o;19423:211::-;19478:7;-1:-1:-1;;;;;19506:19:0;;19498:74;;;;-1:-1:-1;;;19498:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19592:24:0;;;;;;:17;:24;;;;;:34;;:32;:34::i;44174:89::-;44248:7;44241:14;;;;;;;;-1:-1:-1;;44241:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44215:13;;44241:14;;44248:7;;44241:14;;44248:7;44241:14;;;;;;;;;;;;;;;;;;;;;;;;21742:254;21828:12;:10;:12::i;:::-;-1:-1:-1;;;;;21822:18:0;:2;-1:-1:-1;;;;;21822:18:0;;;21814:56;;;;;-1:-1:-1;;;21814:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;21922:8;21883:18;:32;21902:12;:10;:12::i;:::-;-1:-1:-1;;;;;21883:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;21883:32:0;;;:36;;;;;;;;;;;;:47;;-1:-1:-1;;21883:47:0;;;;;;;;;;;21961:12;:10;:12::i;:::-;21946:42;;;;;;;;;;-1:-1:-1;;;;;21946:42:0;;;;;;;;;;;;;;21742:254;;:::o;24745:272::-;24860:41;24879:12;:10;:12::i;:::-;24893:7;24860:18;:41::i;:::-;24852:103;;;;-1:-1:-1;;;24852:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24966:43;24984:4;24990:2;24994:7;25003:5;24966:17;:43::i;:::-;24745:272;;;;:::o;44576:557::-;44634:13;44668:16;44676:7;44668;:16::i;:::-;44660:76;;;;-1:-1:-1;;;44660:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44775:19;;;;:10;:19;;;;;;;;;44749:45;;;;;;-1:-1:-1;;44749:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:23;;:45;;;44775:19;44749:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44911:9;44905:23;44932:1;44905:28;44901:225;;;-1:-1:-1;;44950:9:0;;;;;;;;;-1:-1:-1;44950:9:0;;;;44901:225;45093:8;45103:9;45076:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;45076:37:0;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;45076:37:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;45076:37:0;;;45062:52;;;;;22326:147;-1:-1:-1;;;;;22430:25:0;;;22406:4;22430:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;22326:147::o;26210:155::-;26267:4;26300:20;;;:11;:20;;;;;;-1:-1:-1;;;;;26300:20:0;26338:19;;;26210:155::o;839:98::-;919:10;839:98;:::o;26735:333::-;26820:4;26845:16;26853:7;26845;:16::i;:::-;26837:73;;;;-1:-1:-1;;;26837:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26921:13;26937:16;26945:7;26937;:16::i;:::-;26921:32;;26983:5;-1:-1:-1;;;;;26972:16:0;:7;-1:-1:-1;;;;;26972:16:0;;:51;;;;27016:7;-1:-1:-1;;;;;26992:31:0;:20;27004:7;26992:11;:20::i;:::-;-1:-1:-1;;;;;26992:31:0;;26972:51;:87;;;;27027:32;27044:5;27051:7;27027:16;:32::i;:::-;26964:96;26735:333;-1:-1:-1;;;;26735:333:0:o;37151:202::-;37215:24;37227:2;37231:7;37215:11;:24::i;:::-;37252:40;37280:2;37284:7;37252:27;:40::i;:::-;37305;37337:7;37305:31;:40::i;29953:92::-;30005:32;30011:16;30019:7;30011;:16::i;:::-;30029:7;30005:5;:32::i;14912:114::-;15004:14;;14912:114::o;25736:272::-;25846:32;25860:4;25866:2;25870:7;25846:13;:32::i;:::-;25897:48;25920:4;25926:2;25930:7;25939:5;25897:22;:48::i;:::-;25889:111;;;;-1:-1:-1;;;25889:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28820:335;-1:-1:-1;;;;;28892:16:0;;28884:61;;;;;-1:-1:-1;;;28884:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28965:16;28973:7;28965;:16::i;:::-;28964:17;28956:58;;;;;-1:-1:-1;;;28956:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;29027:20;;;;:11;:20;;;;;;;;:25;;-1:-1:-1;;;;;;29027:25:0;-1:-1:-1;;;;;29027:25:0;;;;;;;;29063:21;;:17;:21;;;;;:33;;:31;:33::i;:::-;29114;;29139:7;;-1:-1:-1;;;;;29114:33:0;;;29131:1;;29114:33;;29131:1;;29114:33;28820:335;;:::o;38648:186::-;-1:-1:-1;;;;;38762:16:0;;;;;;;:12;:16;;;;;;;;:23;;38733:26;;;:17;:26;;;;;:52;;;38796:16;;;39:1:-1;23:18;;45:23;;38796:30:0;;;;;;;;38648:186::o;39035:164::-;39139:10;:17;;39112:24;;;;:15;:24;;;;;:44;;;39:1:-1;23:18;;45:23;;39167:24:0;;;;;;;39035:164::o;46620:247::-;46687:27;46699:5;46706:7;46687:11;:27::i;:::-;46773:19;;;;:10;:19;;;;;46767:33;;-1:-1:-1;;46767:33:0;;;;;;;;;;;:38;46763:97;;46829:19;;;;:10;:19;;;;;46822:26;;;:::i;31542:1079::-;31664:4;31691:15;:2;-1:-1:-1;;;;;31691:13:0;;:15::i;:::-;31686:60;;-1:-1:-1;31730:4:0;31723:11;;31686:60;31817:12;31831:23;-1:-1:-1;;;;;31858:7:0;;-1:-1:-1;;;31963:12:0;:10;:12::i;:::-;31990:4;32009:7;32031:5;31866:181;;;;;;-1:-1:-1;;;;;31866:181:0;-1:-1:-1;;;;;31866:181:0;;;;;;-1:-1:-1;;;;;31866:181:0;-1:-1:-1;;;;;31866:181:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;31866:181:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31866:181:0;;;-1:-1:-1;;26:21;;;22:32;6:49;;31866:181:0;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;31866:181:0;;;179:29:-1;;;;160:49;;31858:190:0;;;31866:181;;31858:190;;-1:-1:-1;31858:190:0;;-1:-1:-1;25:18;-1:-1;31858:190:0;-1:-1:-1;31858:190:0;;-1:-1:-1;31858:190:0;;-1:-1:-1;25:18;36:153;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;31858:190:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;31816:232:0;;;;32064:7;32059:555;;32092:17;;:21;32088:384;;32260:10;32254:17;32321:15;32308:10;32304:2;32300:19;32293:44;32208:148;32396:60;;-1:-1:-1;;;32396:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32059:555;32504:13;32531:10;32520:32;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32520:32:0;-1:-1:-1;;;;;;32575:26:0;-1:-1:-1;;;32575:26:0;;-1:-1:-1;32567:35:0;;-1:-1:-1;;;32567:35:0;15034:181;15188:19;;15206:1;15188:19;;;15034:181::o;37637:372::-;37704:27;37716:5;37723:7;37704:11;:27::i;:::-;37744:48;37777:5;37784:7;37744:32;:48::i;:::-;37942:1;37913:26;;;:17;:26;;;;;:30;37956:45;37931:7;37956:36;:45::i;11503:619::-;11563:4;12031:20;;11874:66;12071:23;;;;;;:42;;-1:-1:-1;;12098:15:0;;;12063:51;-1:-1:-1;;11503:619:0:o;29432:333::-;29527:5;-1:-1:-1;;;;;29507:25:0;:16;29515:7;29507;:16::i;:::-;-1:-1:-1;;;;;29507:25:0;;29499:75;;;;-1:-1:-1;;;29499:75:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29587:23;29602:7;29587:14;:23::i;:::-;-1:-1:-1;;;;;29623:24:0;;;;;;:17;:24;;;;;:36;;:34;:36::i;:::-;29701:1;29670:20;;;:11;:20;;;;;;:33;;-1:-1:-1;;;;;;29670:33:0;;;29721:36;29682:7;;29701:1;-1:-1:-1;;;;;29721:36:0;;;;;29701:1;;29721:36;29432:333;;:::o;39826:1148::-;-1:-1:-1;;;;;40117:18:0;;40092:22;40117:18;;;:12;:18;;;;;:25;:32;;40147:1;40117:32;:29;:32;:::i;:::-;40160:18;40181:26;;;:17;:26;;;;;;40092:57;;-1:-1:-1;40314:28:0;;;40310:328;;-1:-1:-1;;;;;40381:18:0;;40359:19;40381:18;;;:12;:18;;;;;:34;;40400:14;;40381:34;;;;;;;;;;;;;;40359:56;;40465:11;40432:12;:18;40445:4;-1:-1:-1;;;;;40432:18:0;-1:-1:-1;;;;;40432:18:0;;;;;;;;;;;;40451:10;40432:30;;;;;;;;;;;;;;;;;;;:44;;;;40549:30;;;:17;:30;;;;;:43;;;40310:328;-1:-1:-1;;;;;40727:18:0;;;;;;:12;:18;;;;;:27;;;;;-1:-1:-1;;40727:27:0;;;:::i;:::-;;39826:1148;;;;:::o;41269:1082::-;41547:10;:17;41522:22;;41547:24;;41569:1;41547:24;:21;:24;:::i;:::-;41582:18;41603:24;;;:15;:24;;;;;;41976:10;:26;;41522:49;;-1:-1:-1;41603:24:0;;41522:49;;41976:26;;;;;;;;;;;;;;41954:48;;42040:11;42015:10;42026;42015:22;;;;;;;;;;;;;;;;;;;:36;;;;42120:28;;;:15;:28;;;;;;:41;;;42285:10;:19;;;;;-1:-1:-1;;42285:19:0;;;:::i;:::-;-1:-1:-1;;;42342:1:0;42315:24;;;-1:-1:-1;42315:15:0;:24;;;;;:28;41269:1082::o;32789:175::-;32889:1;32853:24;;;:15;:24;;;;;;-1:-1:-1;;;;;32853:24:0;:38;32849:108;;32943:1;32908:24;;;:15;:24;;;;;:37;;-1:-1:-1;;;;;;32908:37:0;;;32789:175::o;15223:110::-;15304:14;;:21;;15323:1;15304:21;:18;:21;:::i;:::-;15287:38;;15223:110::o;6624:136::-;6682:7;6709:43;6713:1;6716;6709:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;6702:50;6624:136;-1:-1:-1;;;6624:136:0:o;7097:192::-;7183:7;7219:12;7211:6;;;;7203:29;;;;-1:-1:-1;;;7203:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;7203:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;7255:5:0;;;7097:192::o;47563:814::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Swarm Source

bzzr://7b6f3c8877349adfb6c102c041839412589cfa0527b8838491a7e3dc4dca24a7
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading