Token WigoSwap Wiggies

NFT  
 

Overview ERC-721

Total Supply:
2,485 WIGGY

Holders:
389 addresses

Transfers:
-

Loading
[ Download CSV Export  ] 
Loading
Loading

OVERVIEW

Mint your desired Wiggy NFT and become a resident on WigoGalaxy virtual planets.


Update? Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Wiggies

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 999999 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-07-01
*/

// File contracts/OpenZeppelin/GSN/Context.sol

// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <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 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.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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

// File contracts/OpenZeppelin/access/Ownable.sol

pragma solidity >=0.4.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.
 */
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() internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view 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 onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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 onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     */
    function _transferOwnership(address newOwner) internal {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File contracts/OpenZeppelin/math/SafeMath.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @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.
     */
    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.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        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.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File contracts/OpenZeppelin/utils/Counters.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @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 contracts/OpenZeppelin/utils/Address.sol

pragma solidity >=0.6.2 <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;
        // solhint-disable-next-line no-inline-assembly
        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"
        );

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File contracts/OpenZeppelin/utils/EnumerableSet.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value)
        private
        view
        returns (bool)
    {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index)
        private
        view
        returns (bytes32)
    {
        require(
            set._values.length > index,
            "EnumerableSet: index out of bounds"
        );
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index)
        internal
        view
        returns (bytes32)
    {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _add(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index)
        internal
        view
        returns (address)
    {
        return address(uint256(_at(set._inner, index)));
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value)
        internal
        returns (bool)
    {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value)
        internal
        view
        returns (bool)
    {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index)
        internal
        view
        returns (uint256)
    {
        return uint256(_at(set._inner, index));
    }
}

// File contracts/OpenZeppelin/utils/EnumerableMap.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;
        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(
        Map storage map,
        bytes32 key,
        bytes32 value
    ) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) {
            // Equivalent to !contains(map, key)
            map._entries.push(MapEntry({_key: key, _value: value}));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function _remove(Map storage map, bytes32 key) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex != 0) {
            // Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

            // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function _contains(Map storage map, bytes32 key)
        private
        view
        returns (bool)
    {
        return map._indexes[key] != 0;
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

    /**
     * @dev Returns the key-value pair stored at position `index` in the map. O(1).
     *
     * Note that there are no guarantees on the ordering of entries inside the
     * array, and it may change when more entries are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Map storage map, uint256 index)
        private
        view
        returns (bytes32, bytes32)
    {
        require(
            map._entries.length > index,
            "EnumerableMap: index out of bounds"
        );

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        return _get(map, key, "EnumerableMap: nonexistent key");
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     */
    function _get(
        Map storage map,
        bytes32 key,
        string memory errorMessage
    ) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(
        UintToAddressMap storage map,
        uint256 key,
        address value
    ) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToAddressMap storage map, uint256 key)
        internal
        returns (bool)
    {
        return _remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToAddressMap storage map, uint256 key)
        internal
        view
        returns (bool)
    {
        return _contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToAddressMap storage map)
        internal
        view
        returns (uint256)
    {
        return _length(map._inner);
    }

    /**
     * @dev Returns the element stored at position `index` in the set. O(1).
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintToAddressMap storage map, uint256 index)
        internal
        view
        returns (uint256, address)
    {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (uint256(key), address(uint256(value)));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key)
        internal
        view
        returns (address)
    {
        return address(uint256(_get(map._inner, bytes32(key))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     */
    function get(
        UintToAddressMap storage map,
        uint256 key,
        string memory errorMessage
    ) internal view returns (address) {
        return address(uint256(_get(map._inner, bytes32(key), errorMessage)));
    }
}

// File contracts/OpenZeppelin/utils/Strings.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` 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);
        uint256 index = digits - 1;
        temp = value;
        while (temp != 0) {
            buffer[index--] = bytes1(uint8(48 + (temp % 10)));
            temp /= 10;
        }
        return string(buffer);
    }
}

// File contracts/OpenZeppelin/introspection/IERC165.sol

pragma solidity >=0.6.0 <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 contracts/OpenZeppelin/token/ERC721/IERC721.sol

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(
        address indexed owner,
        address indexed approved,
        uint256 indexed tokenId
    );

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(
        address indexed owner,
        address indexed operator,
        bool approved
    );

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, 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 contracts/OpenZeppelin/token/ERC721/IERC721Metadata.sol

pragma solidity >=0.6.2 <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 contracts/OpenZeppelin/token/ERC721/IERC721Enumerable.sol

pragma solidity >=0.6.2 <0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index)
        external
        view
        returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// File contracts/OpenZeppelin/token/ERC721/IERC721Receiver.sol

pragma solidity >=0.6.0 <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 contracts/OpenZeppelin/introspection/ERC165.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract 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)
        public
        view
        override
        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 virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

// File contracts/OpenZeppelin/token/ERC721/ERC721.sol

pragma solidity >=0.6.0 <0.8.0;

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

    // 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 holder address to their (enumerable) set of owned tokens
    mapping(address => EnumerableSet.UintSet) private _holderTokens;

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

    // Base URI
    string private _baseURI;

    /*
     *     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 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

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

    /*
     *     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 Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    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);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

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

        return _holderTokens[owner].length();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return
            _tokenOwners.get(
                tokenId,
                "ERC721: owner query for nonexistent token"
            );
    }

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId)
        public
        view
        override
        returns (string memory)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );

        string memory _tokenURI = _tokenURIs[tokenId];

        // If there is no base URI, return the token URI.
        if (bytes(_baseURI).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(_baseURI, _tokenURI));
        }
        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(_baseURI, tokenId.toString()));
    }

    /**
     * @dev Returns the base URI set via {_setBaseURI}. This will be
     * automatically added as a prefix in {tokenURI} to each token's URI, or
     * to the token ID if no specific URI is set for that token ID.
     */
    function baseURI() public view returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index)
        public
        view
        override
        returns (uint256)
    {
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index)
        public
        view
        override
        returns (uint256)
    {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        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"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId)
        public
        view
        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
    {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator)
        public
        view
        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 returns (bool) {
        return _tokenOwners.contains(tokenId);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    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 Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     d*
     * - `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);

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(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 = ownerOf(tokenId);

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(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(
            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);

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI)
        internal
        virtual
    {
        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},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

    /**
     * @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()) {
            return true;
        }
        bytes memory returndata = to.functionCall(
            abi.encodeWithSelector(
                IERC721Receiver(to).onERC721Received.selector,
                _msgSender(),
                from,
                tokenId,
                _data
            ),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
        bytes4 retval = abi.decode(returndata, (bytes4));
        return (retval == _ERC721_RECEIVED);
    }

    function _approve(address to, uint256 tokenId) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(ownerOf(tokenId), to, tokenId);
    }

    /**
     * @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` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * 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 contracts/Wiggies.sol

pragma solidity 0.6.12;

/** @title Wiggies
 * @notice It is the contracts for Wiggy NFTs.
 */
contract Wiggies is ERC721, Ownable {
    using Counters for Counters.Counter;

    // Map the number of tokens per wiggyId
    mapping(uint8 => uint256) public wiggyCount;

    // Map the number of tokens burnt per wiggyId
    mapping(uint8 => uint256) public wiggyBurnCount;

    // Used for generating the tokenId of new NFT minted
    Counters.Counter private _tokenIds;

    // Map the wiggyId for each tokenId
    mapping(uint256 => uint8) private wiggyIds;

    // Map the wiggyName for a tokenId
    mapping(uint8 => string) private wiggyNames;

    constructor(string memory _baseURI)
        public
        ERC721("WigoSwap Wiggies", "WIGGY")
    {
        _setBaseURI(_baseURI);
    }

    /**
     * @dev Get wiggyId for a specific tokenId.
     */
    function getWiggyId(uint256 _tokenId) external view returns (uint8) {
        return wiggyIds[_tokenId];
    }

    /**
     * @dev Get the associated wiggyName for a specific wiggyId.
     */
    function getWiggyName(uint8 _wiggyId)
        external
        view
        returns (string memory)
    {
        return wiggyNames[_wiggyId];
    }

    /**
     * @dev Get the associated wiggyName for a unique tokenId.
     */
    function getWiggyNameOfTokenId(uint256 _tokenId)
        external
        view
        returns (string memory)
    {
        uint8 wiggyId = wiggyIds[_tokenId];
        return wiggyNames[wiggyId];
    }

    /**
     * @dev Mint NFTs. Only the owner can execute it.
     */
    function mint(
        address _to,
        string calldata _tokenURI,
        uint8 _wiggyId
    ) external onlyOwner returns (uint256) {
        uint256 newId = _tokenIds.current();
        _tokenIds.increment();
        wiggyIds[newId] = _wiggyId;
        wiggyCount[_wiggyId] = wiggyCount[_wiggyId].add(1);
        _mint(_to, newId);
        _setTokenURI(newId, _tokenURI);
        return newId;
    }

    /**
     * @dev Set a unique name for each wiggyId. It is supposed to be called once.
     */
    function setWiggyName(uint8 _wiggyId, string calldata _name)
        external
        onlyOwner
    {
        wiggyNames[_wiggyId] = _name;
    }

    /**
     * @dev Burn a NFT token. Callable by owner only.
     */
    function burn(uint256 _tokenId) external onlyOwner {
        uint8 wiggyIdBurnt = wiggyIds[_tokenId];
        wiggyCount[wiggyIdBurnt] = wiggyCount[wiggyIdBurnt].sub(1);
        wiggyBurnCount[wiggyIdBurnt] = wiggyBurnCount[wiggyIdBurnt].add(1);
        _burn(_tokenId);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getWiggyId","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"_wiggyId","type":"uint8"}],"name":"getWiggyName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getWiggyNameOfTokenId","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"string","name":"_tokenURI","type":"string"},{"internalType":"uint8","name":"_wiggyId","type":"uint8"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"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":"uint8","name":"_wiggyId","type":"uint8"},{"internalType":"string","name":"_name","type":"string"}],"name":"setWiggyName","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"wiggyBurnCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"wiggyCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

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

00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000007697066733a2f2f00000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _baseURI (string): ipfs://

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [2] : 697066733a2f2f00000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

66733:2572:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47806:183;;;;;;;;;;;;;;;;-1:-1:-1;47806:183:0;;;;:::i;:::-;;;;;;;;;;;;;;;;;;52977:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55842:291;;;;;;;;;;;;;;;;-1:-1:-1;55842:291:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;55372:404;;;;;;;;;;;;;;;;-1:-1:-1;55372:404:0;;;;;;;;;:::i;:::-;;68790:150;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68790:150:0;;-1:-1:-1;68790:150:0;-1:-1:-1;68790:150:0;:::i;54825:203::-;;;:::i;:::-;;;;;;;;;;;;;;;;56867:376;;;;;;;;;;;;;;;;-1:-1:-1;56867:376:0;;;;;;;;;;;;;;;;;;:::i;67526:112::-;;;;;;;;;;;;;;;;-1:-1:-1;67526:112:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;54554:195;;;;;;;;;;;;;;;;-1:-1:-1;54554:195:0;;;;;;;;;:::i;57314:185::-;;;;;;;;;;;;;;;;-1:-1:-1;57314:185:0;;;;;;;;;;;;;;;;;;:::i;69021:281::-;;;;;;;;;;;;;;;;-1:-1:-1;69021:281:0;;:::i;55105:205::-;;;;;;;;;;;;;;;;-1:-1:-1;55105:205:0;;:::i;52679:231::-;;;;;;;;;;;;;;;;-1:-1:-1;52679:231:0;;:::i;68264:417::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68264:417:0;-1:-1:-1;68264:417:0;;;;:::i;54381:89::-;;;:::i;52365:252::-;;;;;;;;;;;;;;;;-1:-1:-1;52365:252:0;;;;:::i;2770:140::-;;;:::i;66865:43::-;;;;;;;;;;;;;;;;-1:-1:-1;66865:43:0;;;;:::i;2128:79::-;;;:::i;53138:96::-;;;:::i;66968:47::-;;;;;;;;;;;;;;;;-1:-1:-1;66968:47:0;;;;:::i;56205:327::-;;;;;;;;;;;;;;;;-1:-1:-1;56205:327:0;;;;;;;;;;;:::i;57570:365::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57570:365:0;;-1:-1:-1;57570:365:0;;-1:-1:-1;;;;;57570:365:0:i;53305:833::-;;;;;;;;;;;;;;;;-1:-1:-1;53305:833:0;;:::i;67974:209::-;;;;;;;;;;;;;;;;-1:-1:-1;67974:209:0;;:::i;56603:197::-;;;;;;;;;;;;;;;;-1:-1:-1;56603:197:0;;;;;;;;;;;:::i;3065:109::-;;;;;;;;;;;;;;;;-1:-1:-1;3065:109:0;;;;:::i;67730:154::-;;;;;;;;;;;;;;;;-1:-1:-1;67730:154:0;;;;:::i;47806:183::-;47948:33;;;47919:4;47948:33;;;;;;;;;;;;;47806:183;;;;:::o;52977:92::-;53056:5;53049:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53023:13;;53049:12;;53056:5;;53049:12;;53056:5;53049:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52977:92;:::o;55842:291::-;55946:7;55993:16;56001:7;55993;:16::i;:::-;55971:110;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56101:24:0;;;;:15;:24;;;;;;;;;55842:291::o;55372:404::-;55453:13;55469:16;55477:7;55469;:16::i;:::-;55453:32;;55510:5;55504:11;;:2;:11;;;;55496:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55604:5;55588:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;55613:37;55630:5;55637:12;:10;:12::i;:::-;55613:16;:37::i;:::-;55566:168;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55747:21;55756:2;55760:7;55747:8;:21::i;:::-;55372:404;;;:::o;68790:150::-;2350:12;:10;:12::i;:::-;2340:6;;:22;:6;;;:22;;;2332:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68904:20:::1;::::0;::::1;;::::0;;;:10:::1;:20;::::0;;;;:28:::1;::::0;68927:5;;68904:28:::1;:::i;:::-;;68790:150:::0;;;:::o;54825:203::-;54878:7;54999:21;:12;:19;:21::i;:::-;54992:28;;54825:203;:::o;56867:376::-;57076:41;57095:12;:10;:12::i;:::-;57109:7;57076:18;:41::i;:::-;57054:140;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57207:28;57217:4;57223:2;57227:7;57207:9;:28::i;67526:112::-;67587:5;67612:18;;;:8;:18;;;;;;;;;67526:112::o;54554:195::-;54711:20;;;54679:7;54711:20;;;:13;:20;;;;;:30;;54735:5;54711:23;:30::i;:::-;54704:37;;54554:195;;;;;:::o;57314:185::-;57452:39;57469:4;57475:2;57479:7;57452:39;;;;;;;;;;;;:16;:39::i;69021:281::-;2350:12;:10;:12::i;:::-;2340:6;;:22;:6;;;:22;;;2332:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69083:18:::1;69104::::0;;;:8:::1;:18;::::0;;;;;;;;::::1;;69160:24:::0;;;:10:::1;:24:::0;;;;;;;:31:::1;::::0;69104:18;69160:28:::1;:31::i;:::-;69133:24;::::0;::::1;;::::0;;;:10:::1;:24;::::0;;;;;;;:58;;;;69233:14:::1;:28:::0;;;;:35:::1;::::0;69266:1:::1;69233:32;:35::i;:::-;69202:28;::::0;::::1;;::::0;;;:14:::1;:28;::::0;;;;:66;69279:15:::1;69285:8:::0;69279:5:::1;:15::i;:::-;2410:1;69021:281:::0;:::o;55105:205::-;55208:7;;55255:22;:12;55271:5;55255:15;:22::i;:::-;-1:-1:-1;55233:44:0;55105:205;-1:-1:-1;;;55105:205:0:o;52679:231::-;52743:7;52783:119;52818:7;52783:119;;;;;;;;;;;;;;;;;:12;;:119;:16;:119::i;68264:417::-;68396:7;2350:12;:10;:12::i;:::-;2340:6;;:22;:6;;;:22;;;2332:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68416:13:::1;68432:19;:9;:17;:19::i;:::-;68416:35;;68462:21;:9;:19;:21::i;:::-;68494:15;::::0;;;:8:::1;:15;::::0;;;;;;;:26;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;68554:20;;:10:::1;:20:::0;;;;;;:27:::1;::::0;-1:-1:-1;68554:24:0::1;:27::i;:::-;68531:20;::::0;::::1;;::::0;;;:10:::1;:20;::::0;;;;:50;68592:17:::1;68598:3:::0;68603:5;68592::::1;:17::i;:::-;68620:30;68633:5;68640:9;;68620:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;68620:12:0::1;::::0;-1:-1:-1;;;68620:30:0:i:1;:::-;68668:5:::0;-1:-1:-1;2410:1:0::1;68264:417:::0;;;;;;:::o;54381:89::-;54454:8;54447:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54421:13;;54447:15;;54454:8;;54447:15;;54454:8;54447:15;;;;;;;;;;;;;;;;;;;;;;;;52365:252;52429:7;52471:19;;;52449:111;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52580:20;;;;;;;:13;:20;;;;;:29;;:27;:29::i;2770:140::-;2350:12;:10;:12::i;:::-;2340:6;;:22;:6;;;:22;;;2332:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2853:6:::1;::::0;2832:40:::1;::::0;2869:1:::1;::::0;2832:40:::1;2853:6;::::0;2832:40:::1;::::0;2869:1;;2832:40:::1;2883:6;:19:::0;;;::::1;::::0;;2770:140::o;66865:43::-;;;;;;;;;;;;;:::o;2128:79::-;2193:6;;;;2128:79;:::o;53138:96::-;53219:7;53212:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53186:13;;53212:14;;53219:7;;53212:14;;53219:7;53212:14;;;;;;;;;;;;;;;;;;;;;;;;66968:47;;;;;;;;;;;;;:::o;56205:327::-;56352:12;:10;:12::i;:::-;56340:24;;:8;:24;;;;56332:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56452:8;56407:18;:32;56426:12;:10;:12::i;:::-;56407:32;;;;;;;;;;;;;;;;;;-1:-1:-1;56407:32:0;;;:42;;;;;;;;;;;;:53;;;;;;;;;;;;;;56491:12;:10;:12::i;:::-;56476:48;;;56515:8;56476:48;;;;;;;;;;;;;;;;;;;;56205:327;;:::o;57570:365::-;57759:41;57778:12;:10;:12::i;:::-;57792:7;57759:18;:41::i;:::-;57737:140;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57888:39;57902:4;57908:2;57912:7;57921:5;57888:13;:39::i;53305:833::-;53406:13;53459:16;53467:7;53459;:16::i;:::-;53437:113;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53589:19;;;;:10;:19;;;;;;;;;53563:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:23;;:45;;;53589:19;53563:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;53690:8:0;53684:22;53563:45;;-1:-1:-1;;;;53684:22:0;;;;;;;;;;;;;53680:76;;53735:9;-1:-1:-1;53728:16:0;;53680:76;53860:23;;:27;53856:112;;53935:8;53945:9;53918:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;53918:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53904:52;;;;;53856:112;54100:8;54110:18;:7;:16;:18::i;:::-;54083:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;54083:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54069:61;;;53305:833;;;:::o;67974:209::-;68104:13;68120:18;;;:8;:18;;;;;;;;;;;68156:19;;;:10;:19;;;;;;68149:26;;;;;;;68120:18;68149:26;;;68120:18;68149:26;;;;;;;;;;;;;;;;;;;;;;;;;;;68073:13;;68120:18;68149:26;;68156:19;68149:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67974:209;;;:::o;56603:197::-;56757:25;;;;56728:4;56757:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;56603:197::o;3065:109::-;2350:12;:10;:12::i;:::-;2340:6;;:22;:6;;;:22;;;2332:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3138:28:::1;3157:8;3138:18;:28::i;:::-;3065:109:::0;:::o;67730:154::-;67856:20;;;;;;;:10;:20;;;;;;;;;67849:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67818:13;;67849:27;;;67856:20;67849:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67730:154;;;:::o;59482:119::-;59539:4;59563:30;:12;59585:7;59563:21;:30::i;661:106::-;749:10;661:106;:::o;65696:158::-;65762:24;;;;:15;:24;;;;;:29;;;;;;;;;;;;;:24;;65816:16;65762:24;65816:7;:16::i;:::-;65807:39;;;;;;;;;;;;65696:158;;:::o;35849:155::-;35945:7;35977:19;35985:3;35977:7;:19::i;59768:428::-;59880:4;59924:16;59932:7;59924;:16::i;:::-;59902:110;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60023:13;60039:16;60047:7;60039;:16::i;:::-;60023:32;;60085:5;60074:16;;:7;:16;;;:64;;;;60131:7;60107:31;;:20;60119:7;60107:11;:20::i;:::-;:31;;;60074:64;:113;;;;60155:32;60172:5;60179:7;60155:16;:32::i;63023:645::-;63189:4;63169:24;;:16;63177:7;63169;:16::i;:::-;:24;;;63147:115;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63281:16;;;63273:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63351:39;63372:4;63378:2;63382:7;63351:20;:39::i;:::-;63455:29;63472:1;63476:7;63455:8;:29::i;:::-;63497:19;;;;;;;:13;:19;;;;;:35;;63524:7;63497:26;:35::i;:::-;-1:-1:-1;63543:17:0;;;;;;;:13;:17;;;;;:30;;63565:7;63543:21;:30::i;:::-;-1:-1:-1;63586:29:0;:12;63603:7;63612:2;63586:16;:29::i;:::-;;63652:7;63648:2;63633:27;;63642:4;63633:27;;;;;;;;;;;;63023:645;;;:::o;28129:169::-;28227:7;28267:22;28271:3;28283:5;28267:3;:22::i;4944:136::-;5002:7;5029:43;5033:1;5036;5029:43;;;;;;;;;;;;;;;;;:3;:43::i;4480:181::-;4538:7;4570:5;;;4594:6;;;;4586:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62166:520;62226:13;62242:16;62250:7;62242;:16::i;:::-;62226:32;;62271:48;62292:5;62307:1;62311:7;62271:20;:48::i;:::-;62360:29;62377:1;62381:7;62360:8;:29::i;:::-;62448:19;;;;:10;:19;;;;;62442:33;;;;;;;;;;;;;;:38;62438:97;;62504:19;;;;:10;:19;;;;;62497:26;;;:::i;:::-;62547:20;;;;;;;:13;:20;;;;;:36;;62575:7;62547:27;:36::i;:::-;-1:-1:-1;62596:28:0;:12;62616:7;62596:19;:28::i;:::-;-1:-1:-1;62642:36:0;;62670:7;;62666:1;;62642:36;;;;;;62666:1;;62642:36;62166:520;;:::o;36352:259::-;36459:7;;;;36524:22;36528:3;36540:5;36524:3;:22::i;:::-;36493:53;;;;-1:-1:-1;36352:259:0;-1:-1:-1;;;;;36352:259:0:o;37078:238::-;37219:7;37262:44;37267:3;37287;37293:12;37262:4;:44::i;:::-;37254:53;-1:-1:-1;37078:238:0;;;;;;:::o;10159:114::-;10251:14;;10159:114::o;10281:181::-;10435:19;;10453:1;10435:19;;;10281:181::o;61533:404::-;61613:16;;;61605:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61686:16;61694:7;61686;:16::i;:::-;61685:17;61677:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61748:45;61777:1;61781:2;61785:7;61748:20;:45::i;:::-;61806:17;;;;;;;:13;:17;;;;;:30;;61828:7;61806:21;:30::i;:::-;-1:-1:-1;61849:29:0;:12;61866:7;61875:2;61849:16;:29::i;:::-;-1:-1:-1;61896:33:0;;61921:7;;61896:33;;;;61913:1;;61896:33;;61913:1;;61896:33;61533:404;;:::o;63824:275::-;63961:16;63969:7;63961;:16::i;:::-;63939:110;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64060:19;;;;:10;:19;;;;;;;;:31;;;;;;;;:::i;58817:352::-;58974:28;58984:4;58990:2;58994:7;58974:9;:28::i;:::-;59035:48;59058:4;59064:2;59068:7;59077:5;59035:22;:48::i;:::-;59013:148;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37561:748;37617:13;37838:10;37834:53;;-1:-1:-1;37865:10:0;;;;;;;;;;;;;;;;;;;37834:53;37912:5;37897:12;37953:78;37960:9;;37953:78;;37986:8;;38017:2;38009:10;;;;37953:78;;;38041:19;38073:6;38063:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38063:17:0;-1:-1:-1;38135:5:0;;-1:-1:-1;38041:39:0;-1:-1:-1;38107:10:0;;;38151:119;38158:9;;38151:119;;38228:2;38221:4;:9;38215:2;:16;38202:31;;38184:6;38191:7;;;;;;;38184:15;;;;;;;;;;;:49;;;;;;;;;;-1:-1:-1;38256:2:0;38248:10;;;;38151:119;;;-1:-1:-1;38294:6:0;37561:748;-1:-1:-1;;;;37561:748:0:o;3280:266::-;3368:22;;;3346:110;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3493:6;;3472:38;;;;;;;3493:6;;3472:38;;3493:6;;3472:38;3521:6;:17;;;;;;;;;;;;;;;3280:266::o;35578:183::-;35689:4;35718:35;35728:3;35748;35718:9;:35::i;27151:160::-;27239:4;27268:35;27276:3;27296:5;27268:7;:35::i;26844:131::-;26911:4;26935:32;26940:3;26960:5;26935:4;:32::i;34953:210::-;35076:4;35100:55;35105:3;35125;35139:14;;;35100:4;:55::i;22831:273::-;22972:18;;22925:7;;22972:26;-1:-1:-1;22950:110:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23078:3;:11;;23090:5;23078:18;;;;;;;;;;;;;;;;23071:25;;22831:273;;;;:::o;5383:226::-;5503:7;5539:12;5531:6;;;;5523:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5575:5:0;;;5383:226::o;35329:165::-;35424:4;35453:33;35461:3;35481;35453:7;:33::i;33505:348::-;33655:19;;33599:7;;;;33655:27;-1:-1:-1;33633:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33757:22;33782:3;:12;;33795:5;33782:19;;;;;;;;;;;;;;;;;;33757:44;;33820:5;:10;;;33832:5;:12;;;33812:33;;;;;33505:348;;;;;:::o;34276:353::-;34404:7;34443:17;;;:12;;;:17;;;;;;34494:12;34479:13;34471:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34561:3;:12;;34585:1;34574:8;:12;34561:26;;;;;;;;;;;;;;;;;;:33;;;34554:40;;;34276:353;;;;;:::o;64994:694::-;65149:4;65171:15;:2;:13;;;:15::i;:::-;65166:60;;-1:-1:-1;65210:4:0;65203:11;;65166:60;65236:23;65262:313;65333:45;65397:12;:10;:12::i;:::-;65428:4;65451:7;65477:5;65292:205;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65262:313;;;;;;;;;;;;;;;;;:15;;;;:313;:15;:313::i;:::-;65236:339;;65586:13;65613:10;65602:32;;;;;;;;;;;;;;;-1:-1:-1;65602:32:0;65653:26;;65663:16;65653:26;;-1:-1:-1;;;64994:694:0;;;;;;:::o;32778:157::-;32876:4;32905:17;;;:12;;;;;:17;;;;;;:22;;;32778:157::o;20478:1557::-;20544:4;20683:19;;;:12;;;:19;;;;;;20719:15;;20715:1313;;21167:18;;21118:14;;;;;21167:22;;;;21094:21;;21167:3;;:22;;21454;;;;;;;;;;;;;;21434:42;;21600:9;21571:3;:11;;21583:13;21571:26;;;;;;;;;;;;;;;;;;;:38;;;;21677:23;;;21719:1;21677:12;;;:23;;;;;;21703:17;;;21677:43;;21829:17;;21677:3;;21829:17;;;;;;;;;;;;;;;;;;;;;;21924:3;:12;;:19;21937:5;21924:19;;;;;;;;;;;21917:26;;;21967:4;21960:11;;;;;;;;20715:1313;22011:5;22004:12;;;;;19888:414;19951:4;19973:21;19983:3;19988:5;19973:9;:21::i;:::-;19968:327;;-1:-1:-1;20011:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;20194:18;;20172:19;;;:12;;;:19;;;;;;:40;;;;20227:11;;19968:327;-1:-1:-1;20278:5:0;20271:12;;30220:737;30330:4;30465:17;;;:12;;;:17;;;;;;30499:13;30495:455;;-1:-1:-1;;30597:36:0;;;;;;;;;;;;;;;;;;30579:55;;;;;;;;:12;:55;;;;;;;;;;;;;;;;;;;;;;;;30792:19;;30772:17;;;:12;;;:17;;;;;;;:39;30826:11;;30495:455;30906:5;30870:3;:12;;30894:1;30883:8;:12;30870:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;30933:5;30926:12;;;;;31132:1562;31196:4;31331:17;;;:12;;;:17;;;;;;31365:13;;31361:1326;;31810:19;;31763:12;;;;;31810:23;;;;31739:21;;31810:3;;:23;;32107;;;;;;;;;;;;;;;;32078:52;;32255:9;32225:3;:12;;32238:13;32225:27;;;;;;;;;;;;;;;;:39;;:27;;;;;:39;;;;;;;;;;;;;;;32345:14;;32332:28;;:12;;;:28;;;;;32363:17;;;32332:48;;32489:18;;32332:3;;32489:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32585:17;;;:12;;;:17;;;;;;32578:24;;;;32489:18;-1:-1:-1;32619:11:0;;-1:-1:-1;;;;32619:11:0;11355:444;11735:20;11783:8;;;11355:444::o;14392:229::-;14529:12;14561:52;14583:6;14591:4;14597:1;14600:12;14529;15940:18;15951:6;15940:10;:18::i;:::-;15932:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16066:12;16080:23;16107:6;:11;;16126:5;16147:4;16107:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16065:97;;;;16180:52;16198:7;16207:10;16219:12;16180:17;:52::i;:::-;16173:59;15608:632;-1:-1:-1;;;;;;;15608:632:0:o;17391:777::-;17541:12;17570:7;17566:595;;;-1:-1:-1;17601:10:0;17594:17;;17566:595;17715:17;;:21;17711:439;;17978:10;17972:17;18039:15;18026:10;18022:2;18018:19;18011:44;17926:148;18114:20;;;;;;;;;;;;;;;;;;;;18121:12;;18114:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Swarm Source

ipfs://b4feaa1272dc4c5829f135d328f04886483aea46b30b94ab0c444c4371bf92e6
Loading