Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Context
•    - function _msgSender()
•    - function _msgData()
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(address fro ...
•    - function transferFrom(address from, a ...
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(address fro ...
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
•    - function onERC721Received(address ope ...
•  contract ERC165 is IERC165
•    - function supportsInterface(bytes4 int ...
•    - function _registerInterface(bytes4 in ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
• library EnumerableRandomMapSimple
•    - function _set(Map storage map, bytes3 ...
•    - function _remove(Map storage /*map*/, ...
•    - function _contains(Map storage map, b ...
•    - function _length(Map storage map)
•    - function _at(Map storage map, uint256 ...
•    - function _get(Map storage map, bytes3 ...
•    - function _get(Map storage map, bytes3 ...
•    - function set(UintToAddressMap storage ...
•    - function remove(UintToAddressMap stor ...
•    - function contains(UintToAddressMap st ...
•    - function length(UintToAddressMap stor ...
•    - function at(UintToAddressMap storage ...
•    - function get(UintToAddressMap storage ...
•    - function get(UintToAddressMap storage ...
• library Strings
•    - function toString(uint256 value)
•  contract ERC721 is Context, ERC165 ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function baseURI()
•    - function tokenOfOwnerByIndex(address ...
•    - function totalSupply()
•    - function tokenByIndex(uint256 index)
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(address from, a ...
•    - function safeTransferFrom(address fro ...
•    - function safeTransferFrom(address fro ...
•    - function _safeTransfer(address from, ...
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(address to, uint25 ...
•    - function _mint(address to, uint256 to ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(address from, addr ...
•    - function _setTokenURI(uint256 tokenId ...
•    - function _setBaseURI(string memory ba ...
•    - function _checkOnERC721Received(addre ...
•    - function _approve(address to, uint256 ...
•    - function _beforeTokenTransfer(address ...
•  contract ERC721SimpleMapsURI is ER ...
•    - function _setBaseURI(string memory ba ...
• interface ENSRegistryOwnerI
•    - function owner(bytes32 node)
• interface ENSReverseRegistrarI
•    - function setName(string calldata name ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library ECDSA
•    - function recover(bytes32 hash, bytes ...
•    - function toEthSignedMessageHash(bytes ...
• library MerkleProof
•    - function verify(bytes32[] memory proo ...
•  contract CryptostampGoldenUnicorn ... *
•    - function transferTokenAssignmentContr ...
•    - function transferCreateControl(addres ...
•    - function transferShippingControl(addr ...
•    - function totalSupply()
•    - function mintedSupply()
•    - function create(uint256 _tokenId, add ...
•    - function createMulti(uint256 _tokenId ...
•    - function mintingFinished()
•    - function setBaseURI(string memory _ne ...
•    - function exists(uint256 tokenId)
•    - function sourceSale(uint256 _tokenId)
•    - function sourceRaffle(uint256 _tokenI ...
•    - function sourceOnChainRaffle(uint256 ...
•    - function isLastUnicorn(uint256 _token ...
•    - function signedTransfer(uint256 _toke ...
•    - function signedTransferWithOperator(u ...
•    - function _signedTransferInternal(addr ...
•    - function registerReverseENS(address _ ...
•    - function rescueToken(IERC20 _foreignT ...
•    - function approveNFTrescue(IERC721 _fo ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-07-22
*/

/*
 * Crypto stamp Golden Unicorn
 * digital-physical collectible postage stamp
 *
 * Developed by Capacity Blockchain Solutions GmbH <capacity.at>
 * for Österreichische Post AG <post.at>
 */


// File: @openzeppelin/contracts/GSN/Context.sol

pragma solidity ^0.6.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 { }

    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: @openzeppelin/contracts/introspection/IERC165.sol

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

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

pragma solidity ^0.6.2;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transfered 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`, `to` cannot be zero.
     * - `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`, `to` cannot be zero.
     * - `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`, `to` cannot be zero.
      * - `tokenId` token must exist and be owned by `from`.
      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
      *
      * Emits a {Transfer} event.
      */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}

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

pragma solidity ^0.6.2;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

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

pragma solidity ^0.6.2;


/**
 * @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: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol

pragma solidity ^0.6.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
abstract 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 virtual returns (bytes4);
}

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

pragma solidity ^0.6.0;


/**
 * @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) 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: @openzeppelin/contracts/math/SafeMath.sol

pragma solidity ^0.6.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) {
        // 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.
     */
    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

pragma solidity ^0.6.2;

/**
 * @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 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");
    }
}

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

pragma solidity ^0.6.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.0.0, only sets of type `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];
    }

    // 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/EnumerableRandomMapSimple.sol

pragma solidity ^0.6.0;

library EnumerableRandomMapSimple {
    // 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 Map {
        // Storage of map keys and values
        mapping(bytes32 => bytes32) _entries;
        uint256 _length;
    }

    /**
     * @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) {
        bool newVal;
        if (map._entries[key] == bytes32("")) { // add new entry
            map._length++;
            newVal = true;
        }
        else if (value == bytes32("")) { // remove entry
            map._length--;
            newVal = false;
        }
        else {
            newVal = false;
        }
        map._entries[key] = value;
        return newVal;
    }

    /**
     * @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 pure returns (bool) {
        revert("No removal supported");
    }

    /**
     * @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._entries[key] != bytes32("");
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._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) {
        bytes32 key = bytes32(index);
        require(_contains(map, key), "EnumerableMap: index out of bounds");
        return (key, map._entries[key]);
    }

    /**
     * @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) {
        require(_contains(map, key), errorMessage); // Equivalent to contains(map, key)
        return map._entries[key];
    }

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

pragma solidity ^0.6.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--] = byte(uint8(48 + temp % 10));
            temp /= 10;
        }
        return string(buffer);
    }
}

// File: contracts/OZ_Clone/ERC721_simplemaps.sol

pragma solidity ^0.6.0;

// Clone of OpenZeppelin 3.0.0 token/ERC721/ERC721.sol with just imports adapted and EnumerableMap exchanged for EnumerableMapSimple,
// and totalSupply() marked as virtual.












/**
 * @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 EnumerableRandomMapSimple for EnumerableRandomMapSimple.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
    EnumerableRandomMapSimple.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 ^ 0xe985e9c ^ 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;

    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 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 override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");

        return _holderTokens[owner].length();
    }

    /**
     * @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 override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

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

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

    /**
     * @dev Returns the URI for a given token ID. May return an empty string.
     *
     * If a base URI is set (via {_setBaseURI}), it is added as a prefix to the
     * token's own URI (via {_setTokenURI}).
     *
     * If there is a base URI but no token URI, the token's ID will be used as
     * its URI when appending it to the base URI. This pattern for autogenerated
     * token URIs can lead to large gas savings.
     *
     * .Examples
     * |===
     * |`_setBaseURI()` |`_setTokenURI()` |`tokenURI()`
     * | ""
     * | ""
     * | ""
     * | ""
     * | "token.uri/123"
     * | "token.uri/123"
     * | "token.uri/"
     * | "123"
     * | "token.uri/123"
     * | "token.uri/"
     * | ""
     * | "token.uri/<tokenId>"
     * |===
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    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 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 override returns (uint256) {
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev Gets the total amount of tokens stored by the contract.
     * @return uint256 representing the total amount of tokens
     */
    function totalSupply() public view override virtual returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.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 override returns (uint256) {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

    /**
     * @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 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 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 override 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 operator operator address to set the approval
     * @param approved representing the status of the approval to be set
     */
    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 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 override 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 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 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 virtual override {
        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 virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(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 _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 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) {
        return _tokenOwners.contains(tokenId);
    }

    /**
     * @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 virtual {
        _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 virtual {
        _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 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 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 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 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 _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 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 (for example, if your URIs look like
     * `https://api.myproject.com/token/<id>`), use {_setBaseURI} to store
     * it and save gas.
     */
    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;
        }
        // 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);
        }
    }

    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` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}

// File: contracts/ERC721SimpleMapsURI.sol

pragma solidity ^0.6.0;


/**
 * @title ERC721 With a nicer simple token URI
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721SimpleMapsURI is ERC721 {

    // Similar to ERC1155 URI() event, but without a token ID.
    event BaseURI(string value);

    constructor (string memory name, string memory symbol, string memory baseURI)
    ERC721(name, symbol)
    public
    {
        _setBaseURI(baseURI);
    }

    /**
     * @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}.
     */
    function _setBaseURI(string memory baseURI_) internal override virtual {
        super._setBaseURI(baseURI_);
        emit BaseURI(baseURI());
    }

}

// File: contracts/ENSReverseRegistrarI.sol

/*
 * Interfaces for ENS Reverse Registrar
 * See https://github.com/ensdomains/ens/blob/master/contracts/ReverseRegistrar.sol for full impl
 * Also see https://github.com/wealdtech/wealdtech-solidity/blob/master/contracts/ens/ENSReverseRegister.sol
 *
 * Use this as follows (registryAddress is the address of the ENS registry to use):
 * -----
 * // This hex value is caclulated by namehash('addr.reverse')
 * bytes32 public constant ENS_ADDR_REVERSE_NODE = 0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2;
 * function registerReverseENS(address registryAddress, string memory calldata) external {
 *     require(registryAddress != address(0), "need a valid registry");
 *     address reverseRegistrarAddress = ENSRegistryOwnerI(registryAddress).owner(ENS_ADDR_REVERSE_NODE)
 *     require(reverseRegistrarAddress != address(0), "need a valid reverse registrar");
 *     ENSReverseRegistrarI(reverseRegistrarAddress).setName(name);
 * }
 * -----
 * or
 * -----
 * function registerReverseENS(address reverseRegistrarAddress, string memory calldata) external {
 *    require(reverseRegistrarAddress != address(0), "need a valid reverse registrar");
 *     ENSReverseRegistrarI(reverseRegistrarAddress).setName(name);
 * }
 * -----
 * ENS deployments can be found at https://docs.ens.domains/ens-deployments
 * E.g. Etherscan can be used to look up that owner on those contracts.
 * namehash.hash("addr.reverse") == "0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2"
 * Ropsten: ens.owner(namehash.hash("addr.reverse")) == "0x6F628b68b30Dc3c17f345c9dbBb1E483c2b7aE5c"
 * Mainnet: ens.owner(namehash.hash("addr.reverse")) == "0x084b1c3C81545d370f3634392De611CaaBFf8148"
 */
pragma solidity ^0.6.0;

interface ENSRegistryOwnerI {
    function owner(bytes32 node) external view returns (address);
}

interface ENSReverseRegistrarI {
    function setName(string calldata name) external returns (bytes32 node);
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/cryptography/ECDSA.sol

pragma solidity ^0.6.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        // Check the signature length
        if (signature.length != 65) {
            revert("ECDSA: invalid signature length");
        }

        // Divide the signature in r, s and v variables
        bytes32 r;
        bytes32 s;
        uint8 v;

        // ecrecover takes the signature parameters, and the only way to get them
        // currently is to use assembly.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := byte(0, mload(add(signature, 0x60)))
        }

        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            revert("ECDSA: invalid signature 's' value");
        }

        if (v != 27 && v != 28) {
            revert("ECDSA: invalid signature 'v' value");
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        require(signer != address(0), "ECDSA: invalid signature");

        return signer;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * replicates the behavior of the
     * https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`]
     * JSON-RPC method.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }
}

// File: @openzeppelin/contracts/cryptography/MerkleProof.sol

pragma solidity ^0.6.0;

/**
 * @dev These functions deal with verification of Merkle trees (hash trees),
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}

// File: contracts/CryptostampGoldenUnicorn.sol

/*
Implements ERC 721 Token standard: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
*/
pragma solidity ^0.6.0;






/* The inheritance is very much the same as OpenZeppelin's ERC721Full,
 * but using simplified (and cheaper) versions of ERC721Enumerable and ERC721Metadata */
contract CryptostampGoldenUnicorn is ERC721SimpleMapsURI {
    using SafeMath for uint256;

    address public createControl;
    address public shippingControl;
    address public tokenAssignmentControl;

    uint256 immutable finalSupply;

    mapping(address => uint256) public signedTransferNonce;

    event CreateControlTransferred(address indexed previousCreateControl, address indexed newCreateControl);
    event ShippingControlTransferred(address indexed previousShippingControl, address indexed newShippingControl);
    event TokenAssignmentControlTransferred(address indexed previousTokenAssignmentControl, address indexed newTokenAssignmentControl);
    event SignedTransfer(address operator, address indexed from, address indexed to, uint256 indexed tokenId, uint256 signedTransferNonce);

    constructor(address _createControl, address _shippingControl, address _tokenAssignmentControl, uint256 _finalSupply)
    ERC721SimpleMapsURI("Crypto stamp Golden Unicorn", "CSGU", "https://test.crypto.post.at/CSGU/meta/")
    public
    {
        createControl = _createControl;
        require(address(createControl) != address(0x0), "You need to provide an actual createControl address.");
        shippingControl = _shippingControl;
        require(address(shippingControl) != address(0x0), "You need to provide an actual shippingControl address.");
        tokenAssignmentControl = _tokenAssignmentControl;
        require(address(tokenAssignmentControl) != address(0x0), "You need to provide an actual tokenAssignmentControl address.");
        finalSupply = _finalSupply;
    }

    modifier onlyCreateControl()
    {
        require(msg.sender == createControl, "createControl key required for this function.");
        _;
    }

    modifier onlyShippingControl() {
        require(msg.sender == shippingControl, "shippingControl key required for this function.");
        _;
    }

    modifier onlyTokenAssignmentControl() {
        require(msg.sender == tokenAssignmentControl, "tokenAssignmentControl key required for this function.");
        _;
    }

    modifier onlyMinter()
    {
        // Both the actual create control key and the shipping control key that delivers the on-chain raffle can mint Golden Unicorns.
        require(msg.sender == createControl || msg.sender == shippingControl, "createControl or shippingControl key required for this function.");
        _;
    }

    modifier requireMinting() {
        require(mintingFinished() == false, "This call only works when minting is not finished.");
        _;
    }

    /*** Enable adjusting variables after deployment ***/

    function transferTokenAssignmentControl(address _newTokenAssignmentControl)
    public
    onlyTokenAssignmentControl
    {
        require(_newTokenAssignmentControl != address(0), "tokenAssignmentControl cannot be the zero address.");
        emit TokenAssignmentControlTransferred(tokenAssignmentControl, _newTokenAssignmentControl);
        tokenAssignmentControl = _newTokenAssignmentControl;
    }

    function transferCreateControl(address _newCreateControl)
    public
    onlyCreateControl
    {
        require(_newCreateControl != address(0), "createControl cannot be the zero address.");
        emit CreateControlTransferred(createControl, _newCreateControl);
        createControl = _newCreateControl;
    }

    function transferShippingControl(address _newShippingControl)
    public
    onlyShippingControl
    {
        require(_newShippingControl != address(0), "shippingControl cannot be the zero address.");
        emit ShippingControlTransferred(shippingControl, _newShippingControl);
        shippingControl = _newShippingControl;
    }

    /*** Base functionality: minting, URI, property getters, etc. ***/

    // Override totalSupply() so it reports the target final supply.
    /**
     * @dev Gets the total amount of tokens stored by the contract.
     * @return uint256 representing the total amount of tokens
     */
    function totalSupply()
    public view override
    returns (uint256) {
        return finalSupply;
    }

    /**
     * @dev Gets the actually minted amount of tokens in the contract.
     * @return uint256 representing the minted amount of tokens
     */
    function mintedSupply()
    public view
    returns (uint256) {
        return super.totalSupply();
    }

    // Issue a new crypto stamp asset, giving it to a specific owner address.
    // As appending the ID into a URI in Solidity is complicated, generate both
    // externally and hand them over to the asset here.
    function create(uint256 _tokenId, address _owner)
    public
    onlyMinter
    requireMinting
    {
        require(_tokenId < finalSupply, "Cannot mint token with too high ID");
        // _mint already ends up checking if owner != 0 and that tokenId doesn't exist yet.
        _mint(_owner, _tokenId);
    }

    // Batch-issue multiple crypto stamps with adjacent IDs.
    function createMulti(uint256 _tokenIdStart, address[] memory _owners)
    public
    onlyMinter
    requireMinting
    {
        uint256 addrcount = _owners.length;
        require(_tokenIdStart + addrcount - 1 < finalSupply, "Cannot mint token with too high ID");
        for (uint256 i = 0; i < addrcount; i++) {
            // Make sure this is in sync with what create() does.
            _mint(_owners[i], _tokenIdStart + i);
        }
    }

    // Determine if the creation/minting process is done.
    function mintingFinished()
    public view
    returns (bool)
    {
        return (super.totalSupply() >= finalSupply);
    }

    // Set new base for the token URI.
    function setBaseURI(string memory _newBaseURI)
    public
    onlyMinter
    {
        super._setBaseURI(_newBaseURI);
    }

    // Returns whether the specified token exists
    function exists(uint256 tokenId)
    public view
    returns (bool) {
        return _exists(tokenId);
    }

    /*** Special properties of Golden Unicorns ***/

    function sourceSale(uint256 _tokenId)
    public view
    returns (bool) {
        require(_tokenId < finalSupply, "Property query for nonexistent token");
        return _tokenId >= finalSupply / 2 - 1 && _tokenId < finalSupply - 1;
    }

    function sourceRaffle(uint256 _tokenId)
    public view
    returns (bool) {
        return !sourceSale(_tokenId);
    }

    function sourceOnChainRaffle(uint256 _tokenId)
    public view
    returns (bool) {
        require(_tokenId < finalSupply, "Property query for nonexistent token");
        return _tokenId <= finalSupply * 3 / 10 - 2;
    }

    function isLastUnicorn(uint256 _tokenId)
    public view
    returns (bool) {
        require(_tokenId < finalSupply, "Property query for nonexistent token");
        return _tokenId == finalSupply - 1;
    }

    /*** Allows any user to initiate a transfer with the signature of the current stamp owner  ***/

    // Outward-facing function for signed transfer: assembles the expected data and then calls the internal function to do the rest.
    // Can called by anyone knowing about the right signature, but can only transfer to the given specific target.
    function signedTransfer(uint256 _tokenId, address _to, bytes memory _signature)
    public
    {
        address currentOwner = ownerOf(_tokenId);
        // The signed data contains the token ID, the transfer target and a nonce.
        bytes32 data = keccak256(abi.encodePacked(address(this), this.signedTransfer.selector, currentOwner, _to, _tokenId, signedTransferNonce[currentOwner]));
        _signedTransferInternal(currentOwner, data, _tokenId, _to, _signature);
    }

    // Outward-facing function for operator-driven signed transfer: assembles the expected data and then calls the internal function to do the rest.
    // Can transfer to any target, but only be called by the trusted operator contained in the signature.
    function signedTransferWithOperator(uint256 _tokenId, address _to, bytes memory _signature)
    public
    {
        address currentOwner = ownerOf(_tokenId);
        // The signed data contains the operator, the token ID, and a nonce. Note that we use the selector of the external function here!
        bytes32 data = keccak256(abi.encodePacked(address(this), this.signedTransferWithOperator.selector, msg.sender, currentOwner, _tokenId, signedTransferNonce[currentOwner]));
        _signedTransferInternal(currentOwner, data, _tokenId, _to, _signature);
    }

    // Actually check the signature and perform a signed transfer.
    function _signedTransferInternal(address _currentOwner, bytes32 _data, uint256 _tokenId, address _to, bytes memory _signature)
    internal
    {
        bytes32 hash = ECDSA.toEthSignedMessageHash(_data);
        address signer = ECDSA.recover(hash, _signature);
        require(signer == _currentOwner, "Signature needs to match parameters, nonce, and current owner.");
        // Now that we checked that the signature is correct, do the actual transfer and increase the nonce.
        emit SignedTransfer(msg.sender, _currentOwner, _to, _tokenId, signedTransferNonce[_currentOwner]);
        signedTransferNonce[_currentOwner] = signedTransferNonce[_currentOwner].add(1);
        _safeTransfer(_currentOwner, _to, _tokenId, "");
    }

    /*** Enable reverse ENS registration ***/

    // Call this with the address of the reverse registrar for the respecitve network and the ENS name to register.
    // The reverse registrar can be found as the owner of 'addr.reverse' in the ENS system.
    // See https://docs.ens.domains/ens-deployments for address of ENS deployments, e.g. Etherscan can be used to look up that owner on those.
    // namehash.hash("addr.reverse") == "0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2"
    // Ropsten: ens.owner(namehash.hash("addr.reverse")) == "0x6F628b68b30Dc3c17f345c9dbBb1E483c2b7aE5c"
    // Mainnet: ens.owner(namehash.hash("addr.reverse")) == "0x084b1c3C81545d370f3634392De611CaaBFf8148"
    function registerReverseENS(address _reverseRegistrarAddress, string calldata _name)
    external
    onlyTokenAssignmentControl
    {
       require(_reverseRegistrarAddress != address(0), "need a valid reverse registrar");
       ENSReverseRegistrarI(_reverseRegistrarAddress).setName(_name);
    }

    /*** Make sure currency doesn't get stranded in this contract ***/

    // If this contract gets a balance in some ERC20 contract after it's finished, then we can rescue it.
    function rescueToken(IERC20 _foreignToken, address _to)
    external
    onlyTokenAssignmentControl
    {
        _foreignToken.transfer(_to, _foreignToken.balanceOf(address(this)));
    }

    // If this contract gets a balance in some ERC721 contract after it's finished, then we can rescue it.
    function approveNFTrescue(IERC721 _foreignNFT, address _to)
    external
    onlyTokenAssignmentControl
    {
        _foreignNFT.setApprovalForAll(_to, true);
    }

    // Make sure this contract cannot receive ETH.
    receive()
    external payable
    {
        revert("The contract cannot receive ETH payments.");
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_createControl","type":"address"},{"internalType":"address","name":"_shippingControl","type":"address"},{"internalType":"address","name":"_tokenAssignmentControl","type":"address"},{"internalType":"uint256","name":"_finalSupply","type":"uint256"}],"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":false,"internalType":"string","name":"value","type":"string"}],"name":"BaseURI","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousCreateControl","type":"address"},{"indexed":true,"internalType":"address","name":"newCreateControl","type":"address"}],"name":"CreateControlTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousShippingControl","type":"address"},{"indexed":true,"internalType":"address","name":"newShippingControl","type":"address"}],"name":"ShippingControlTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"signedTransferNonce","type":"uint256"}],"name":"SignedTransfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousTokenAssignmentControl","type":"address"},{"indexed":true,"internalType":"address","name":"newTokenAssignmentControl","type":"address"}],"name":"TokenAssignmentControlTransferred","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":"contract IERC721","name":"_foreignNFT","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"approveNFTrescue","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"},{"internalType":"address","name":"_owner","type":"address"}],"name":"create","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"createControl","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenIdStart","type":"uint256"},{"internalType":"address[]","name":"_owners","type":"address[]"}],"name":"createMulti","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"isLastUnicorn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintingFinished","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_reverseRegistrarAddress","type":"address"},{"internalType":"string","name":"_name","type":"string"}],"name":"registerReverseENS","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_foreignToken","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"rescueToken","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":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shippingControl","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"signedTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"signedTransferNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"bytes","name":"_signature","type":"bytes"}],"name":"signedTransferWithOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"sourceOnChainRaffle","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"sourceRaffle","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"sourceSale","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":[],"name":"tokenAssignmentControl","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"_newCreateControl","type":"address"}],"name":"transferCreateControl","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":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newShippingControl","type":"address"}],"name":"transferShippingControl","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newTokenAssignmentControl","type":"address"}],"name":"transferTokenAssignmentControl","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000d39a7ad8ebe8c57aab85f868fe0d454e1aa5349e0000000000000000000000009a5be4f89d483e445716dc1abb7668e56deaa909000000000000000000000000596e620e175c2c37a5f35a41d9f2305a991ffc8900000000000000000000000000000000000000000000000000000000000003e8

-----Decoded View---------------
Arg [0] : _createControl (address): 0xd39a7ad8ebE8C57aaB85f868fE0d454e1Aa5349E
Arg [1] : _shippingControl (address): 0x9a5Be4f89D483e445716dc1abb7668e56dEAA909
Arg [2] : _tokenAssignmentControl (address): 0x596E620E175C2C37A5f35A41d9F2305A991fFc89
Arg [3] : _finalSupply (uint256): 1000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000d39a7ad8ebe8c57aab85f868fe0d454e1aa5349e
Arg [1] : 0000000000000000000000009a5be4f89d483e445716dc1abb7668e56deaa909
Arg [2] : 000000000000000000000000596e620e175c2c37a5f35a41d9f2305a991ffc89
Arg [3] : 00000000000000000000000000000000000000000000000000000000000003e8

68303:11338:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79579:51;;-1:-1:-1;;;79579:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68303:11338;;;;68437:30;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;68437:30:0;;;;;;;;;;;;;;10749:142;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;10749:142:0;-1:-1:-1;;;;;;10749:142:0;;:::i;:::-;;;;;;;;;;;;;;;;;;74429:244;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74429:244:0;;:::i;73887:131::-;;;;;;;;;;;;;:::i;39263:92::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44055:213;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;44055:213:0;;:::i;43372:390::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;43372:390:0;;;;;;;;:::i;:::-;;75049:213;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75049:213:0;;:::i;76371:569::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;76371:569:0;;;;;;;;;;;;;;;;-1:-1:-1;;;76371:569:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;76371:569:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76371:569:0;;-1:-1:-1;76371:569:0;;-1:-1:-1;;;;;76371:569:0:i;72369:109::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;45803:305;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;45803:305:0;;;;;;;;;;;;;;;;;:::i;41907:154::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;41907:154:0;;;;;;;;:::i;46770:151::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;46770:151:0;;;;;;;;;;;;;;;;;:::i;78992:193::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;78992:193:0;;;;;;;;;;:::i;74254:112::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74254:112:0;;:::i;42777:164::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42777:164:0;;:::i;68558:54::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68558:54:0;-1:-1:-1;;;;;68558:54:0;;:::i;74066:129::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;74066:129:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;74066:129:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74066:129:0;;-1:-1:-1;74066:129:0;;-1:-1:-1;;;;;74066:129:0:i;73363:457::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;73363:457:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;73363:457:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73363:457:0;;-1:-1:-1;73363:457:0;;-1:-1:-1;;;;;73363:457:0:i;38983:169::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38983:169:0;;:::i;71398:320::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71398:320:0;-1:-1:-1;;;;;71398:320:0;;:::i;41436:89::-;;;;;;;;;;;;;:::i;38542:215::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38542:215:0;-1:-1:-1;;;;;38542:215:0;;:::i;75623:483::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;75623:483:0;;;;;;;;;;;;;;;;-1:-1:-1;;;75623:483:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;75623:483:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75623:483:0;;-1:-1:-1;75623:483:0;;-1:-1:-1;;;;;75623:483:0:i;74813:228::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74813:228:0;;:::i;74681:124::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74681:124:0;;:::i;78497:306::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;78497:306:0;;;;;;;;;;;;;;;-1:-1:-1;;;78497:306:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;78497:306:0;;;;;;;;;;-1:-1:-1;78497:306:0;;-1:-1:-1;78497:306:0;-1:-1:-1;78497:306:0;:::i;39470:96::-;;;;;;;;;;;;;:::i;44575:295::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;44575:295:0;;;;;;;;;;:::i;47658:285::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;47658:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;47658:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;47658:285:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47658:285:0;;-1:-1:-1;47658:285:0;;-1:-1:-1;;;;;47658:285:0:i;72641:109::-;;;;;;;;;;;;;:::i;40442:755::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40442:755:0;;:::i;68474:37::-;;;;;;;;;;;;;:::i;70980:410::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70980:410:0;-1:-1:-1;;;;;70980:410:0;;:::i;79301:170::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;79301:170:0;;;;;;;;;;:::i;68402:28::-;;;;;;;;;;;;;:::i;45200:156::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;45200:156:0;;;;;;;;;;:::i;72975:318::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72975:318:0;;;;;;-1:-1:-1;;;;;72975:318:0;;:::i;71726:340::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71726:340:0;-1:-1:-1;;;;;71726:340:0;;:::i;68437:30::-;;;-1:-1:-1;;;;;68437:30:0;;:::o;10749:142::-;-1:-1:-1;;;;;;10850:33:0;;10826:4;10850:33;;;;;;;;;;;;;10749:142;;;;:::o;74429:244::-;74498:4;74534:11;74523:8;:22;74515:71;;;;-1:-1:-1;;;74515:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74634:1;74630;74616:11;:15;:19;74604:8;:31;;:61;;;;;74664:1;74650:11;:15;74639:8;:26;74604:61;74597:68;74429:244;-1:-1:-1;;74429:244:0:o;73887:131::-;73945:4;73998:11;73975:19;:17;:19::i;:::-;:34;;73967:43;;73887:131;;:::o;39263:92::-;39342:5;39335:12;;;;;;;;-1:-1:-1;;39335:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39309:13;;39335:12;;39342:5;;39335:12;;39342:5;39335:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39263:92;:::o;44055:213::-;44123:7;44151:16;44159:7;44151;:16::i;:::-;44143:73;;;;-1:-1:-1;;;44143:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;44236:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;44236:24:0;;44055:213::o;43372:390::-;43453:13;43469:16;43477:7;43469;:16::i;:::-;43453:32;;43510:5;-1:-1:-1;;;;;43504:11:0;:2;-1:-1:-1;;;;;43504:11:0;;;43496:57;;;;-1:-1:-1;;;43496:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43590:5;-1:-1:-1;;;;;43574:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;43574:21:0;;:62;;;;43599:37;43616:5;43623:12;:10;:12::i;:::-;43599:16;:37::i;:::-;43566:154;;;;-1:-1:-1;;;43566:154:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43733:21;43742:2;43746:7;43733:8;:21::i;:::-;43372:390;;;:::o;75049:213::-;75121:4;75157:11;75146:8;:22;75138:71;;;;-1:-1:-1;;;75138:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75239:11:0;-1:-1:-1;;75239:15:0;75227:27;;75049:213::o;76371:569::-;76491:20;76514:17;76522:8;76514:7;:17::i;:::-;-1:-1:-1;;;;;76816:33:0;;76681:12;76816:33;;;:19;:33;;;;;;;;;;76706:144;;76731:4;76706:144;;;;;;;;-1:-1:-1;;;76706:144:0;;;;76780:10;76706:144;;;;;;-1:-1:-1;;76706:144:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76696:155;;;;;76491:40;;-1:-1:-1;76862:70:0;76491:40;76696:155;76806:8;76916:3;76921:10;76862:23;:70::i;:::-;76371:569;;;;;:::o;72369:109::-;72459:11;72369:109;:::o;45803:305::-;45964:41;45983:12;:10;:12::i;:::-;45997:7;45964:18;:41::i;:::-;45956:103;;;;-1:-1:-1;;;45956:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46072:28;46082:4;46088:2;46092:7;46072:9;:28::i;41907:154::-;-1:-1:-1;;;;;42023:20:0;;41996:7;42023:20;;;:13;:20;;;;;:30;;42047:5;42023:30;:23;:30;:::i;:::-;42016:37;41907:154;-1:-1:-1;;;41907:154:0:o;46770:151::-;46874:39;46891:4;46897:2;46901:7;46874:39;;;;;;;;;;;;:16;:39::i;78992:193::-;70317:22;;-1:-1:-1;;;;;70317:22:0;70303:10;:36;70295:103;;;;-1:-1:-1;;;70295:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79138:38:::1;::::0;;-1:-1:-1;;;79138:38:0;;79170:4:::1;79138:38;::::0;::::1;::::0;;;-1:-1:-1;;;;;79110:22:0;::::1;::::0;::::1;::::0;79133:3;;79110:22;;79138:23:::1;::::0;:38;;;;;::::1;::::0;;;;;;;;;79110:22;79138:38;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;79138:38:0;79110:67:::1;::::0;;-1:-1:-1;;;;;;79110:67:0::1;::::0;;;;;;-1:-1:-1;;;;;79110:67:0;;::::1;;::::0;::::1;::::0;;;;;;;;;;;;;;79138:38:::1;::::0;79110:67;;;;;;;-1:-1:-1;79110:67:0;;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;;;78992:193:0:o;74254:112::-;74318:4;74342:16;74350:7;74342;:16::i;42777:164::-;42844:7;;42886:22;:12;42902:5;42886:22;:15;:22;:::i;:::-;-1:-1:-1;42864:44:0;42777:164;-1:-1:-1;;;42777:164:0:o;68558:54::-;;;;;;;;;;;;;:::o;74066:129::-;70622:13;;-1:-1:-1;;;;;70622:13:0;70608:10;:27;;:60;;-1:-1:-1;70653:15:0;;-1:-1:-1;;;;;70653:15:0;70639:10;:29;70608:60;70600:137;;;;-1:-1:-1;;;70600:137:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74157:30:::1;74175:11;74157:17;:30::i;:::-;74066:129:::0;:::o;73363:457::-;70622:13;;-1:-1:-1;;;;;70622:13:0;70608:10;:27;;:60;;-1:-1:-1;70653:15:0;;-1:-1:-1;;;;;70653:15:0;70639:10;:29;70608:60;70600:137;;;;-1:-1:-1;;;70600:137:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70810:17:::1;:15;:17::i;:::-;:26;70802:89;;;;-1:-1:-1::0;;;70802:89:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73517:14:::0;;73582:11:::2;-1:-1:-1::0;;73550:25:0;;::::2;:29:::0;:43:::2;73542:90;;;;-1:-1:-1::0;;;73542:90:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73648:9;73643:170;73667:9;73663:1;:13;73643:170;;;73765:36;73771:7;73779:1;73771:10;;;;;;;;;;;;;;73799:1;73783:13;:17;73765:5;:36::i;:::-;73678:3;;73643:170;;38983:169:::0;39047:7;39074:70;39091:7;39074:70;;;;;;;;;;;;;;;;;:12;;:70;;:16;:70;:::i;71398:320::-;69996:13;;-1:-1:-1;;;;;69996:13:0;69982:10;:27;69974:85;;;;-1:-1:-1;;;69974:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;71515:31:0;::::1;71507:85;;;;-1:-1:-1::0;;;71507:85:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71633:13;::::0;71608:58:::1;::::0;-1:-1:-1;;;;;71608:58:0;;::::1;::::0;71633:13:::1;::::0;71608:58:::1;::::0;71633:13:::1;::::0;71608:58:::1;71677:13;:33:::0;;-1:-1:-1;;;;;;71677:33:0::1;-1:-1:-1::0;;;;;71677:33:0;;;::::1;::::0;;;::::1;::::0;;71398:320::o;41436:89::-;41509:8;41502:15;;;;;;;;-1:-1:-1;;41502:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41476:13;;41502:15;;41509:8;;41502:15;;41509:8;41502:15;;;;;;;;;;;;;;;;;;;;;;;;38542:215;38606:7;-1:-1:-1;;;;;38634:19:0;;38626:74;;;;-1:-1:-1;;;38626:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;38720:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;75623:483::-;75731:20;75754:17;75762:8;75754:7;:17::i;:::-;-1:-1:-1;;;;;75982:33:0;;75866:12;75982:33;;;:19;:33;;;;;;;;;;75891:125;;75916:4;75891:125;;;;;;;;-1:-1:-1;;;75891:125:0;;;;-1:-1:-1;;75891:125:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75881:136;;;;;75731:40;;-1:-1:-1;76028:70:0;75731:40;75881:136;75972:8;75967:3;76087:10;76028:23;:70::i;74813:228::-;74891:4;74927:11;74916:8;:22;74908:71;;;;-1:-1:-1;;;74908:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;75027:2:0;75009:11;75023:1;75009:15;:20;:24;-1:-1:-1;74997:36:0;;74813:228::o;74681:124::-;74752:4;74777:20;74788:8;74777:10;:20::i;:::-;74776:21;;74681:124;-1:-1:-1;;74681:124:0:o;78497:306::-;70317:22;;-1:-1:-1;;;;;70317:22:0;70303:10;:36;70295:103;;;;-1:-1:-1;;;70295:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;78651:38:0;::::1;78643:81;;;::::0;;-1:-1:-1;;;78643:81:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;78734:61;::::0;-1:-1:-1;;;78734:61:0;;::::1;;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;;;;;78734:54:0;::::1;::::0;::::1;::::0;78789:5;;;;78734:61;;;;;78789:5;;;;78734:61;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;39470:96:::0;39551:7;39544:14;;;;;;;;-1:-1:-1;;39544:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39518:13;;39544:14;;39551:7;;39544:14;;39551:7;39544:14;;;;;;;;;;;;;;;;;;;;;;;;44575:295;44690:12;:10;:12::i;:::-;-1:-1:-1;;;;;44678:24:0;:8;-1:-1:-1;;;;;44678:24:0;;;44670:62;;;;;-1:-1:-1;;;44670:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;44790:8;44745:18;:32;44764:12;:10;:12::i;:::-;-1:-1:-1;;;;;44745:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;44745:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;44745:53:0;;;;;;;;;;;44829:12;:10;:12::i;:::-;44814:48;;;;;;;;;;-1:-1:-1;;;;;44814:48:0;;;;;;;;;;;;;;44575:295;;:::o;47658:285::-;47790:41;47809:12;:10;:12::i;:::-;47823:7;47790:18;:41::i;:::-;47782:103;;;;-1:-1:-1;;;47782:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47896:39;47910:4;47916:2;47920:7;47929:5;47896:13;:39::i;72641:109::-;72696:7;72723:19;:17;:19::i;:::-;72716:26;;72641:109;:::o;40442:755::-;40507:13;40541:16;40549:7;40541;:16::i;:::-;40533:76;;;;-1:-1:-1;;;40533:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40648:19;;;;:10;:19;;;;;;;;;40622:45;;;;;;-1:-1:-1;;40622:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:23;;:45;;;40648:19;40622:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;40749:8:0;40743:22;40622:45;;-1:-1:-1;;;;40743:22:0;-1:-1:-1;;40743:22:0;;;;;;;;;;;40739:76;;40794:9;-1:-1:-1;40787:16:0;;40739:76;40919:23;;:27;40915:112;;40994:8;41004:9;40977:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;40977:37:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;40977:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40963:52;;;;;40915:112;41159:8;41169:18;:7;:16;:18::i;:::-;41142:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;41142:46:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;41142:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41128:61;;;40442:755;;;:::o;68474:37::-;;;-1:-1:-1;;;;;68474:37:0;;:::o;70980:410::-;70317:22;;-1:-1:-1;;;;;70317:22:0;70303:10;:36;70295:103;;;;-1:-1:-1;;;70295:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;71124:40:0;::::1;71116:103;;;;-1:-1:-1::0;;;71116:103:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71269:22;::::0;71235:85:::1;::::0;-1:-1:-1;;;;;71235:85:0;;::::1;::::0;71269:22:::1;::::0;71235:85:::1;::::0;71269:22:::1;::::0;71235:85:::1;71331:22;:51:::0;;-1:-1:-1;;;;;;71331:51:0::1;-1:-1:-1::0;;;;;71331:51:0;;;::::1;::::0;;;::::1;::::0;;70980:410::o;79301:170::-;70317:22;;-1:-1:-1;;;;;70317:22:0;70303:10;:36;70295:103;;;;-1:-1:-1;;;70295:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79423:40:::1;::::0;;-1:-1:-1;;;79423:40:0;;-1:-1:-1;;;;;79423:40:0;;::::1;;::::0;::::1;::::0;79458:4:::1;79423:40:::0;;;;;;:29;;::::1;::::0;::::1;::::0;:40;;;;;-1:-1:-1;;79423:40:0;;;;;;;;-1:-1:-1;79423:29:0;:40;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;79301:170:::0;;:::o;68402:28::-;;;-1:-1:-1;;;;;68402:28:0;;:::o;45200:156::-;-1:-1:-1;;;;;45313:25:0;;;45289:4;45313:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;45200:156::o;72975:318::-;70622:13;;-1:-1:-1;;;;;70622:13:0;70608:10;:27;;:60;;-1:-1:-1;70653:15:0;;-1:-1:-1;;;;;70653:15:0;70639:10;:29;70608:60;70600:137;;;;-1:-1:-1;;;70600:137:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70810:17:::1;:15;:17::i;:::-;:26;70802:89;;;;-1:-1:-1::0;;;70802:89:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73108:11:::2;73097:8;:22;73089:69;;;;-1:-1:-1::0;;;73089:69:0::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73262:23;73268:6;73276:8;73262:5;:23::i;:::-;72975:318:::0;;:::o;71726:340::-;70151:15;;-1:-1:-1;;;;;70151:15:0;70137:10;:29;70129:89;;;;-1:-1:-1;;;70129:89:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;71849:33:0;::::1;71841:89;;;;-1:-1:-1::0;;;71841:89:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71973:15;::::0;71946:64:::1;::::0;-1:-1:-1;;;;;71946:64:0;;::::1;::::0;71973:15:::1;::::0;71946:64:::1;::::0;71973:15:::1;::::0;71946:64:::1;72021:15;:37:::0;;-1:-1:-1;;;;;;72021:37:0::1;-1:-1:-1::0;;;;;72021:37:0;;;::::1;::::0;;;::::1;::::0;;71726:340::o;54587:100::-;54660:19;;;;:8;;:19;;;;;:::i;42220:211::-;42281:7;42402:21;:12;:19;:21::i;49136:119::-;49193:4;49217:30;:12;49239:7;49217:30;:21;:30;:::i;1009:106::-;1097:10;1009:106;:::o;56338:158::-;56404:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;56404:29:0;-1:-1:-1;;;;;56404:29:0;;;;;;;;:24;;56458:16;56404:24;56458:7;:16::i;:::-;-1:-1:-1;;;;;56449:39:0;;;;;;;;;;;56338:158;;:::o;77016:748::-;77173:12;77188:35;77217:5;77188:28;:35::i;:::-;77173:50;;77234:14;77251:31;77265:4;77271:10;77251:13;:31::i;:::-;77234:48;;77311:13;-1:-1:-1;;;;;77301:23:0;:6;-1:-1:-1;;;;;77301:23:0;;77293:98;;;;-1:-1:-1;;;77293:98:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;77517:92:0;;;77574:34;;;;:19;:34;;;;;;;;;;77517:92;;77532:10;77517:92;;;;;;;;77564:8;;77517:92;;;;;;;;;;;;-1:-1:-1;;;;;77657:34:0;;;;;;:19;:34;;;;;;:41;;77696:1;77657:41;:38;:41;:::i;:::-;77620:19;:34;77640:13;-1:-1:-1;;;;;77620:34:0;-1:-1:-1;;;;;77620:34:0;;;;;;;;;;;;:78;;;;77709:47;77723:13;77738:3;77743:8;77709:47;;;;;;;;;;;;:13;:47::i;:::-;77016:748;;;;;;;:::o;49625:333::-;49710:4;49735:16;49743:7;49735;:16::i;:::-;49727:73;;;;-1:-1:-1;;;49727:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49811:13;49827:16;49835:7;49827;:16::i;:::-;49811:32;;49873:5;-1:-1:-1;;;;;49862:16:0;:7;-1:-1:-1;;;;;49862:16:0;;:51;;;;49906:7;-1:-1:-1;;;;;49882:31:0;:20;49894:7;49882:11;:20::i;:::-;-1:-1:-1;;;;;49882:31:0;;49862:51;:87;;;;49917:32;49934:5;49941:7;49917:16;:32::i;:::-;49854:96;49625:333;-1:-1:-1;;;;49625:333:0:o;53224:574::-;53342:4;-1:-1:-1;;;;;53322:24:0;:16;53330:7;53322;:16::i;:::-;-1:-1:-1;;;;;53322:24:0;;53314:78;;;;-1:-1:-1;;;53314:78:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;53411:16:0;;53403:65;;;;-1:-1:-1;;;53403:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53481:39;53502:4;53508:2;53512:7;53481:20;:39::i;:::-;53585:29;53602:1;53606:7;53585:8;:29::i;:::-;-1:-1:-1;;;;;53627:19:0;;;;;;:13;:19;;;;;:35;;53654:7;53627:35;:26;:35;:::i;:::-;-1:-1:-1;;;;;;53673:17:0;;;;;;:13;:17;;;;;:30;;53695:7;53673:30;:21;:30;:::i;:::-;-1:-1:-1;53716:29:0;:12;53733:7;53742:2;53716:29;:16;:29;:::i;:::-;;53782:7;53778:2;-1:-1:-1;;;;;53763:27:0;53772:4;-1:-1:-1;;;;;53763:27:0;;;;;;;;;;;53224:574;;;:::o;27523:137::-;27594:7;27629:22;27633:3;27645:5;27629:3;:22::i;32697:227::-;32777:7;;;;32837:22;32841:3;32853:5;32837:3;:22::i;:::-;32806:53;;;;-1:-1:-1;32697:227:0;-1:-1:-1;;;;;32697:227:0:o;57840:151::-;57922:27;57940:8;57922:17;:27::i;:::-;57965:18;57973:9;:7;:9::i;:::-;57965:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57840:151;:::o;51726:404::-;-1:-1:-1;;;;;51806:16:0;;51798:61;;;;;-1:-1:-1;;;51798:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51879:16;51887:7;51879;:16::i;:::-;51878:17;51870:58;;;;;-1:-1:-1;;;51870:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;51941:45;51970:1;51974:2;51978:7;51941:20;:45::i;:::-;-1:-1:-1;;;;;51999:17:0;;;;;;:13;:17;;;;;:30;;52021:7;51999:30;:21;:30;:::i;:::-;-1:-1:-1;52042:29:0;:12;52059:7;52068:2;52042:29;:16;:29;:::i;:::-;-1:-1:-1;52089:33:0;;52114:7;;-1:-1:-1;;;;;52089:33:0;;;52106:1;;52089:33;;52106:1;;52089:33;51726:404;;:::o;33359:204::-;33466:7;33509:44;33514:3;33534;33540:12;33509:4;:44::i;27065:114::-;27125:7;27152:19;27160:3;27152:7;:19::i;48662:272::-;48776:28;48786:4;48792:2;48796:7;48776:9;:28::i;:::-;48823:48;48846:4;48852:2;48856:7;48865:5;48823:22;:48::i;:::-;48815:111;;;;-1:-1:-1;;;48815:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33802:744;33858:13;34079:10;34075:53;;-1:-1:-1;34106:10:0;;;;;;;;;;;;-1:-1:-1;;;34106:10:0;;;;;;34075:53;34153:5;34138:12;34194:78;34201:9;;34194:78;;34227:8;;34258:2;34250:10;;;;34194:78;;;34282:19;34314:6;34304:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34304:17:0;-1:-1:-1;34376:5:0;;-1:-1:-1;34282:39:0;-1:-1:-1;;;34348:10:0;;34392:115;34399:9;;34392:115;;34466:2;34459:4;:9;34454:2;:14;34443:27;;34425:6;34432:7;;;;;;;34425:15;;;;;;;;;;;:45;-1:-1:-1;;;;;34425:45:0;;;;;;;;-1:-1:-1;34493:2:0;34485:10;;;;34392:115;;;-1:-1:-1;34531:6:0;33802:744;-1:-1:-1;;;;33802:744:0:o;32235:123::-;32304:7;32331:19;32339:3;32331:7;:19::i;31996:151::-;32080:4;32104:35;32114:3;32134;32104:9;:35::i;66328:269::-;66530:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66520:69;;;;;;66328:269::o;63944:2110::-;64022:7;64085:9;:16;64105:2;64085:22;64081:96;;64124:41;;;-1:-1:-1;;;64124:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;64081:96;64538:4;64523:20;;64517:27;64584:4;64569:20;;64563:27;64638:4;64623:20;;64617:27;64246:9;64609:36;65568:66;65555:79;;65551:156;;;65651:44;;-1:-1:-1;;;65651:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65551:156;65723:1;:7;;65728:2;65723:7;;:18;;;;;65734:1;:7;;65739:2;65734:7;;65723:18;65719:95;;;65758:44;;-1:-1:-1;;;65758:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65719:95;65928:24;;;65911:14;65928:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65911:14;;65928:24;;;;;;;-1:-1:-1;;65928:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;65928:24:0;;-1:-1:-1;;65928:24:0;;;-1:-1:-1;;;;;;;65971:20:0;;65963:57;;;;;-1:-1:-1;;;65963:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;66040:6;63944:2110;-1:-1:-1;;;;;;63944:2110:0:o;12419:181::-;12477:7;12509:5;;;12533:6;;;;12525:46;;;;;-1:-1:-1;;;12525:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;26610:137;26680:4;26704:35;26712:3;26732:5;26704:7;:35::i;26303:131::-;26370:4;26394:32;26399:3;26419:5;26394:4;:32::i;31423:176::-;31512:4;31536:55;31541:3;31561;-1:-1:-1;;;;;31575:14:0;;31536:4;:55::i;24187:204::-;24282:18;;24254:7;;24282:26;-1:-1:-1;24274:73:0;;;;-1:-1:-1;;;24274:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24365:3;:11;;24377:5;24365:18;;;;;;;;;;;;;;;;24358:25;;24187:204;;;;:::o;30190:251::-;30257:7;;30308:5;30333:19;30343:3;30308:5;30333:9;:19::i;:::-;30325:66;;;;-1:-1:-1;;;30325:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30415:12;:17;;;;;;;;;;;;;;;30190:251;-1:-1:-1;;;30190:251:0:o;30864:235::-;30958:7;30986:19;30996:3;31001;30986:9;:19::i;:::-;31007:12;30978:42;;;;;-1:-1:-1;;;30978:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;31074:12:0;:17;;;;;;;;;;;;;30864:235::o;23734:109::-;23817:18;;23734:109::o;55252:1078::-;55373:4;55400:15;:2;-1:-1:-1;;;;;55400:13:0;;:15::i;:::-;55395:60;;-1:-1:-1;55439:4:0;55432:11;;55395:60;55526:12;55540:23;-1:-1:-1;;;;;55567:7:0;;-1:-1:-1;;;55672:12:0;:10;:12::i;:::-;55699:4;55718:7;55740:5;55575:181;;;;;;-1:-1:-1;;;;;55575:181:0;-1:-1:-1;;;;;55575:181:0;;;;;;-1:-1:-1;;;;;55575:181:0;-1:-1:-1;;;;;55575:181:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55575:181:0;;;-1:-1:-1;;55575:181:0;;;;;;;;;;;;;;-1:-1:-1;;;;;55575:181:0;-1:-1:-1;;;;;;55575:181:0;;;;;;;;;55567:190;;;55575:181;;55567:190;;-1:-1:-1;55567:190:0;;-1:-1:-1;55575:181:0;-1:-1:-1;55567:190:0;-1:-1:-1;55567:190:0;;-1:-1:-1;55567:190:0;;-1:-1:-1;55575:181:0;55567:190;;;;;;;;;;-1:-1:-1;;55567:190:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55525:232;;;;55773:7;55768:555;;55801:17;;:21;55797:384;;55969:10;55963:17;56030:15;56017:10;56013:2;56009:19;56002:44;55917:148;56105:60;;-1:-1:-1;;;56105:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55768:555;56213:13;56240:10;56229:32;;;;;;;;;;;;;;;-1:-1:-1;56229:32:0;-1:-1:-1;;;;;;56284:26:0;-1:-1:-1;;;56284:26:0;;-1:-1:-1;56276:35:0;;-1:-1:-1;;;56276:35:0;29733:102;29816:11;;;;29733:102::o;29503:135::-;29574:4;29598:17;;;;;;;;;;;;:32;;;29503:135::o;21889:1544::-;21955:4;22094:19;;;:12;;;:19;;;;;;22130:15;;22126:1300;;22565:18;;-1:-1:-1;;22516:14:0;;;;22565:22;;;;22492:21;;22565:3;;:22;;22852;;;;;;;;;;;;;;22832:42;;22998:9;22969:3;:11;;22981:13;22969:26;;;;;;;;;;;;;;;;;;;:38;;;;23075:23;;;23117:1;23075:12;;;:23;;;;;;23101:17;;;23075:43;;23227:17;;23075:3;;23227:17;;;;;;;;;;;;;;;;;;;;;;23322:3;:12;;:19;23335:5;23322:19;;;;;;;;;;;23315:26;;;23365:4;23358:11;;;;;;;;22126:1300;23409:5;23402:12;;;;;21299:414;21362:4;21384:21;21394:3;21399:5;21384:9;:21::i;:::-;21379:327;;-1:-1:-1;21422:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;21605:18;;21583:19;;;:12;;;:19;;;;;;:40;;;;21638:11;;21379:327;-1:-1:-1;21689:5:0;21682:12;;28625:487;28701:4;28744:17;;;;;;;;;;;28701:4;;28740:305;;-1:-1:-1;28810:11:0;;;;:13;;;;;;28740:305;;;28882:20;28878:167;;-1:-1:-1;28935:11:0;;;:13;;-1:-1:-1;;28935:13:0;;;:11;28878:167;;;-1:-1:-1;29028:5:0;28878:167;29055:12;:17;;;;;;;;-1:-1:-1;29055:17:0;;;;:25;29098:6;28625:487::o;17652:619::-;17712:4;18180:20;;18023:66;18220:23;;;;;;:42;;-1:-1:-1;;18247:15:0;;;18212:51;-1:-1:-1;;17652:619:0:o;23519:129::-;23592:4;23616:19;;;:12;;;;;:19;;;;;;:24;;;23519:129::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;

ipfs://4e21a723aeeec86673361688b89a805386b7a7a35ec7617ecb8766402639ef8e