Token THUGLAND

 

Overview [ERC-721]

Max Total Supply:
0 THUGLAND

Holders:
0

Transfers:
-

 
Loading
[ Download CSV Export  ] 
Loading
Loading

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

Contract Source Code Verified (Exact Match)

Contract Name:
THUGLAND

Compiler Version
v0.8.0+commit.c7dfd78e

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-02-28
*/

// File: https://github.com/ProjectOpenSea/opensea-creatures/blob/master/contracts/common/meta-transactions/Initializable.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        _;
        inited = true;
    }
}

// File: https://github.com/ProjectOpenSea/opensea-creatures/blob/master/contracts/common/meta-transactions/EIP712Base.sol



pragma solidity ^0.8.0;


contract EIP712Base is Initializable {
    struct EIP712Domain {
        string name;
        string version;
        address verifyingContract;
        bytes32 salt;
    }

    string constant public ERC712_VERSION = "1";

    bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(
        bytes(
            "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
        )
    );
    bytes32 internal domainSeperator;

    // supposed to be called once while initializing.
    // one of the contracts that inherits this contract follows proxy pattern
    // so it is not possible to do this in a constructor
    function _initializeEIP712(
        string memory name
    )
        internal
        initializer
    {
        _setDomainSeperator(name);
    }

    function _setDomainSeperator(string memory name) internal {
        domainSeperator = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                keccak256(bytes(ERC712_VERSION)),
                address(this),
                bytes32(getChainId())
            )
        );
    }

    function getDomainSeperator() public view returns (bytes32) {
        return domainSeperator;
    }

    function getChainId() public view returns (uint256) {
        uint256 id;
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * Accept message hash and returns hash message in EIP712 compatible form
     * So that it can be used to recover signer from signature signed using EIP712 formatted data
     * https://eips.ethereum.org/EIPS/eip-712
     * "\\x19" makes the encoding deterministic
     * "\\x01" is the version byte to make it compatible to EIP-191
     */
    function toTypedMessageHash(bytes32 messageHash)
        internal
        view
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
            );
    }
}
// File: https://github.com/ProjectOpenSea/opensea-creatures/blob/master/contracts/common/meta-transactions/ContentMixin.sol



pragma solidity ^0.8.0;

abstract contract ContextMixin {
    function msgSender()
        internal
        view
        returns (address payable sender)
    {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
                // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
                sender := and(
                    mload(add(array, index)),
                    0xffffffffffffffffffffffffffffffffffffffff
                )
            }
        } else {
            sender = payable(msg.sender);
        }
        return sender;
    }
}

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


// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @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 a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * 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) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: https://github.com/ProjectOpenSea/opensea-creatures/blob/master/contracts/common/meta-transactions/NativeMetaTransaction.sol



pragma solidity ^0.8.0;



contract NativeMetaTransaction is EIP712Base {
    using SafeMath for uint256;
    bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(
        bytes(
            "MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
        )
    );
    event MetaTransactionExecuted(
        address userAddress,
        address payable relayerAddress,
        bytes functionSignature
    );
    mapping(address => uint256) nonces;

    /*
     * Meta transaction structure.
     * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
     * He should call the desired function directly in that case.
     */
    struct MetaTransaction {
        uint256 nonce;
        address from;
        bytes functionSignature;
    }

    function executeMetaTransaction(
        address userAddress,
        bytes memory functionSignature,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) public payable returns (bytes memory) {
        MetaTransaction memory metaTx = MetaTransaction({
            nonce: nonces[userAddress],
            from: userAddress,
            functionSignature: functionSignature
        });

        require(
            verify(userAddress, metaTx, sigR, sigS, sigV),
            "Signer and signature do not match"
        );

        // increase nonce for user (to avoid re-use)
        nonces[userAddress] = nonces[userAddress].add(1);

        emit MetaTransactionExecuted(
            userAddress,
            payable(msg.sender),
            functionSignature
        );

        // Append userAddress and relayer address at the end to extract it from calling context
        (bool success, bytes memory returnData) = address(this).call(
            abi.encodePacked(functionSignature, userAddress)
        );
        require(success, "Function call not successful");

        return returnData;
    }

    function hashMetaTransaction(MetaTransaction memory metaTx)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encode(
                    META_TRANSACTION_TYPEHASH,
                    metaTx.nonce,
                    metaTx.from,
                    keccak256(metaTx.functionSignature)
                )
            );
    }

    function getNonce(address user) public view returns (uint256 nonce) {
        nonce = nonces[user];
    }

    function verify(
        address signer,
        MetaTransaction memory metaTx,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) internal view returns (bool) {
        require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
        return
            signer ==
            ecrecover(
                toTypedMessageHash(hashMetaTransaction(metaTx)),
                sigV,
                sigR,
                sigS
            );
    }
}

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


// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

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

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

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


// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

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

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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


// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

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


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

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

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


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;



// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)

pragma solidity ^0.8.0;


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

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

    bool private _paused;

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

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

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

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

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

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




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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

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

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

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

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

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

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

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

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

        _afterTokenTransfer(address(0), to, tokenId);
    }

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

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

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

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

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

        _afterTokenTransfer(owner, address(0), tokenId);
    }

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

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

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

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

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Pausable.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC721 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract ERC721Pausable is ERC721, Pausable {
    /**
     * @dev See {ERC721-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        require(!paused(), "ERC721Pausable: token transfer while paused");
    }
}



// File: https://github.com/ProjectOpenSea/opensea-creatures/blob/master/contracts/ERC721Tradable.sol

pragma solidity ^0.8.0;


contract OwnableDelegateProxy {}

/**
 * Used to delegate ownership of a contract to another address, to save on unneeded transactions to approve contract use for users
 */
contract ProxyRegistry {
    mapping(address => OwnableDelegateProxy) public proxies;
}

/**
 * @title ERC721Tradable
 * ERC721Tradable - ERC721 contract that whitelists a trading address, and has minting functionality.
 */
abstract contract ERC721Tradable is ERC721, Pausable, ContextMixin, NativeMetaTransaction, Ownable {
    using SafeMath for uint256;
    using Counters for Counters.Counter;

    string TokenURI;
    string ContractURI;


    Counters.Counter private _nextTokenId;
    address proxyRegistryAddress;

    constructor(
        string memory _name,
        string memory _symbol,
        address _proxyRegistryAddress
    ) ERC721(_name, _symbol) {
        proxyRegistryAddress = _proxyRegistryAddress;
        // nextTokenId is initialized to 1, since starting at 0 leads to higher gas cost for the first minter
        _nextTokenId.increment();
        _initializeEIP712(_name);
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        require(!paused(), "ERC721Pausable: token transfer while paused");
    }

    function AdminPause() public onlyOwner {
        _pause();
    } 

    function AdminUnpause() public onlyOwner {
        _unpause();
    } 

    function AdminSetTokenURI(string memory TokenURIStr) public onlyOwner {
        TokenURI = TokenURIStr;
    } 

    function AdminSetContractURI(string memory ContractURIStr) public onlyOwner {
        ContractURI = ContractURIStr;
    } 

    function AdminSetProxyAddress(address _proxyRegistryAddress) public onlyOwner {
        proxyRegistryAddress = _proxyRegistryAddress;
    } 

    /**
     * @dev Mints a token to an address with a tokenURI.
     * @param _to address of the future owner of the token
     */
    function AdminMintTo(address _to) public onlyOwner {
        uint256 currentTokenId = _nextTokenId.current();
        _nextTokenId.increment();
        _safeMint(_to, currentTokenId);
    }

    function AdminBurn(uint256 tokenId) public onlyOwner {
        _burn(tokenId);
    }

    function AdminTransferFromTo(address _from, address _to, uint256 tokenId) public onlyOwner {
        _transfer(_from, _to, tokenId);
    }

    function AdminTransferFromToMultiple(address[] memory _from, address[] memory _to, uint256[] memory _tokenIds) public onlyOwner {
        for (uint256 i = 0; i < _tokenIds.length; i++) {
            _transfer(_from[i], _to[i], _tokenIds[i]);
        }
    }

    function AdminMintMultipleTo(address _to, uint256 amount) public onlyOwner {
        uint256 currentTokenId;
        currentTokenId = _nextTokenId.current();

        for (uint256 i = 0; i < amount; i++) {
            _safeMint(_to, currentTokenId);
            currentTokenId = currentTokenId + 1;
            _nextTokenId.increment();
        }
    }

    /**
        @dev Returns the total tokens minted so far.
        1 is always subtracted from the Counter since it tracks the next available tokenId.
     */
    function totalSupply() public view returns (uint256) {
        return _nextTokenId.current() - 1;
    }

    function baseTokenURI() virtual public view returns (string memory) {
        return TokenURI;
    }

    function ProxyAddress() virtual public view returns (address) {
        return proxyRegistryAddress;
    }

    function tokenURI(uint256 _tokenId) override public view returns (string memory) {
        return string(abi.encodePacked(baseTokenURI(), Strings.toString(_tokenId)));
    }

    /**
     * Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
     */
    function isApprovedForAll(address owner, address operator)
        override
        public
        view
        returns (bool)
    {
        // Whitelist OpenSea proxy contract for easy trading.
        ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
        if (address(proxyRegistry.proxies(owner)) == operator) {
            return true;
        }

        return super.isApprovedForAll(owner, operator);
    }

    /**
     * This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
     */
    function _msgSender()
        internal
        override
        view
        returns (address sender)
    {
        return ContextMixin.msgSender();
    }
}

// File: thugland.sol



pragma solidity ^0.8.0;


/**
 * @title Creature
 * Creature - a contract for my non-fungible creatures.
 */
contract THUGLAND is ERC721Tradable {
    constructor(address _proxyRegistryAddress)
        ERC721Tradable("THUGLAND", "THUGLAND", _proxyRegistryAddress)
    {
        TokenURI = "https://landcontractapi.thug.tv/contract/landtoken/";
        ContractURI = "https://landcontractapi.thug.tv/contract/landcontract";

    }


    function baseTokenURI() override public view returns (string memory) {
        return TokenURI;
    }

    function contractURI() public view returns (string memory) {
        return ContractURI;
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_proxyRegistryAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"AdminBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AdminMintMultipleTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"AdminMintTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"AdminPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"ContractURIStr","type":"string"}],"name":"AdminSetContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_proxyRegistryAddress","type":"address"}],"name":"AdminSetProxyAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"TokenURIStr","type":"string"}],"name":"AdminSetTokenURI","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":"AdminTransferFromTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_from","type":"address[]"},{"internalType":"address[]","name":"_to","type":"address[]"},{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"AdminTransferFromToMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"AdminUnpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ProxyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040526000600660016101000a81548160ff0219169083151502179055503480156200002c57600080fd5b50604051620052d6380380620052d68339818101604052810190620000529190620005b7565b6040518060400160405280600881526020017f544855474c414e440000000000000000000000000000000000000000000000008152506040518060400160405280600881526020017f544855474c414e440000000000000000000000000000000000000000000000008152508282828160009080519060200190620000d9929190620004f0565b508060019080519060200190620000f2929190620004f0565b5050506000600660006101000a81548160ff02191690831515021790555062000130620001246200020760201b60201c565b6200022360201b60201c565b80600d60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555062000188600c620002e960201b62001cae1760201c565b6200019983620002ff60201b60201c565b505050604051806060016040528060338152602001620052a360339139600a9080519060200190620001cd929190620004f0565b506040518060600160405280603581526020016200521f60359139600b9080519060200190620001ff929190620004f0565b505062000794565b60006200021e6200038160201b62001cc41760201c565b905090565b6000600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6001816000016000828254019250508190555050565b600660019054906101000a900460ff161562000352576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016200034990620006a4565b60405180910390fd5b62000363816200043460201b60201c565b6001600660016101000a81548160ff02191690831515021790555050565b60003073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156200042d57600080368080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050509050600080369050905073ffffffffffffffffffffffffffffffffffffffff81830151169250505062000431565b3390505b90565b6040518060800160405280604f815260200162005254604f91398051906020012081805190602001206040518060400160405280600181526020017f31000000000000000000000000000000000000000000000000000000000000008152508051906020012030620004ab620004e360201b60201c565b60001b604051602001620004c495949392919062000647565b6040516020818303038152906040528051906020012060078190555050565b6000804690508091505090565b828054620004fe9062000715565b90600052602060002090601f0160209004810192826200052257600085556200056e565b82601f106200053d57805160ff19168380011785556200056e565b828001600101855582156200056e579182015b828111156200056d57825182559160200191906001019062000550565b5b5090506200057d919062000581565b5090565b5b808211156200059c57600081600090555060010162000582565b5090565b600081519050620005b1816200077a565b92915050565b600060208284031215620005ca57600080fd5b6000620005da84828501620005a0565b91505092915050565b620005ee81620006d7565b82525050565b620005ff81620006eb565b82525050565b600062000614600e83620006c6565b91507f616c726561647920696e697465640000000000000000000000000000000000006000830152602082019050919050565b600060a0820190506200065e6000830188620005f4565b6200066d6020830187620005f4565b6200067c6040830186620005f4565b6200068b6060830185620005e3565b6200069a6080830184620005f4565b9695505050505050565b60006020820190508181036000830152620006bf8162000605565b9050919050565b600082825260208201905092915050565b6000620006e482620006f5565b9050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600060028204905060018216806200072e57607f821691505b602082108114156200074557620007446200074b565b5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b6200078581620006d7565b81146200079157600080fd5b50565b614a7b80620007a46000396000f3fe60806040526004361061020f5760003560e01c80636f14c5fb11610118578063b88d4fde116100a0578063dfe066af1161006f578063dfe066af1461078c578063e65ae8cd146107a3578063e8a3d485146107ba578063e985e9c5146107e5578063f2fde38b146108225761020f565b8063b88d4fde146106d0578063c87b56dd146106f9578063d547cfb714610736578063dc4250e3146107615761020f565b80637e5ee906116100e75780637e5ee906146105ff57806384ad866b146106285780638da5cb5b1461065157806395d89b411461067c578063a22cb465146106a75761020f565b80636f14c5fb1461055957806370a0823114610582578063715018a6146105bf5780637417a9e5146105d65761020f565b806318160ddd1161019b5780633408e4701161016a5780633408e4701461047457806342842e0e1461049f5780635c975abb146104c85780636352211e146104f35780636e3b3d09146105305761020f565b806318160ddd146103b857806320379ee5146103e357806323b872dd1461040e5780632d0335ab146104375761020f565b8063095ea7b3116101e2578063095ea7b3146102e25780630c53c51c1461030b5780630f7e59701461033b57806311e72fac1461036657806315d11d0c1461038f5761020f565b806301ffc9a7146102145780630617f7b91461025157806306fdde031461027a578063081812fc146102a5575b600080fd5b34801561022057600080fd5b5061023b600480360381019061023691906135f7565b61084b565b604051610248919061410b565b60405180910390f35b34801561025d57600080fd5b506102786004803603810190610273919061338f565b61092d565b005b34801561028657600080fd5b5061028f6109b9565b60405161029c91906141ed565b60405180910390f35b3480156102b157600080fd5b506102cc60048036038101906102c791906136b3565b610a4b565b6040516102d99190614066565b60405180910390f35b3480156102ee57600080fd5b5061030960048036038101906103049190613524565b610ad0565b005b61032560048036038101906103209190613495565b610be8565b60405161033291906141cb565b60405180910390f35b34801561034757600080fd5b50610350610e5a565b60405161035d91906141ed565b60405180910390f35b34801561037257600080fd5b5061038d6004803603810190610388919061332a565b610e93565b005b34801561039b57600080fd5b506103b660048036038101906103b191906136b3565b610f53565b005b3480156103c457600080fd5b506103cd610fdb565b6040516103da91906144af565b60405180910390f35b3480156103ef57600080fd5b506103f8610ff8565b6040516104059190614126565b60405180910390f35b34801561041a57600080fd5b506104356004803603810190610430919061338f565b611002565b005b34801561044357600080fd5b5061045e6004803603810190610459919061332a565b611062565b60405161046b91906144af565b60405180910390f35b34801561048057600080fd5b506104896110ab565b60405161049691906144af565b60405180910390f35b3480156104ab57600080fd5b506104c660048036038101906104c1919061338f565b6110b8565b005b3480156104d457600080fd5b506104dd6110d8565b6040516104ea919061410b565b60405180910390f35b3480156104ff57600080fd5b5061051a600480360381019061051591906136b3565b6110ef565b6040516105279190614066565b60405180910390f35b34801561053c57600080fd5b5061055760048036038101906105529190613672565b6111a1565b005b34801561056557600080fd5b50610580600480360381019061057b9190613524565b611237565b005b34801561058e57600080fd5b506105a960048036038101906105a4919061332a565b611308565b6040516105b691906144af565b60405180910390f35b3480156105cb57600080fd5b506105d46113c0565b005b3480156105e257600080fd5b506105fd60048036038101906105f89190613672565b611448565b005b34801561060b57600080fd5b506106266004803603810190610621919061332a565b6114de565b005b34801561063457600080fd5b5061064f600480360381019061064a9190613560565b611580565b005b34801561065d57600080fd5b506106666116ec565b6040516106739190614066565b60405180910390f35b34801561068857600080fd5b50610691611716565b60405161069e91906141ed565b60405180910390f35b3480156106b357600080fd5b506106ce60048036038101906106c99190613459565b6117a8565b005b3480156106dc57600080fd5b506106f760048036038101906106f291906133de565b6117be565b005b34801561070557600080fd5b50610720600480360381019061071b91906136b3565b611820565b60405161072d91906141ed565b60405180910390f35b34801561074257600080fd5b5061074b61185a565b60405161075891906141ed565b60405180910390f35b34801561076d57600080fd5b506107766118ec565b6040516107839190614066565b60405180910390f35b34801561079857600080fd5b506107a1611916565b005b3480156107af57600080fd5b506107b861199c565b005b3480156107c657600080fd5b506107cf611a22565b6040516107dc91906141ed565b60405180910390f35b3480156107f157600080fd5b5061080c60048036038101906108079190613353565b611ab4565b604051610819919061410b565b60405180910390f35b34801561082e57600080fd5b506108496004803603810190610844919061332a565b611bb6565b005b60007f80ac58cd000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916148061091657507f5b5e139f000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916145b80610926575061092582611d75565b5b9050919050565b610935611ddf565b73ffffffffffffffffffffffffffffffffffffffff166109536116ec565b73ffffffffffffffffffffffffffffffffffffffff16146109a9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016109a09061442f565b60405180910390fd5b6109b4838383611dee565b505050565b6060600080546109c8906147ad565b80601f01602080910402602001604051908101604052809291908181526020018280546109f4906147ad565b8015610a415780601f10610a1657610100808354040283529160200191610a41565b820191906000526020600020905b815481529060010190602001808311610a2457829003601f168201915b5050505050905090565b6000610a5682612055565b610a95576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a8c9061440f565b60405180910390fd5b6004600083815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b6000610adb826110ef565b90508073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610b4c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b439061446f565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff16610b6b611ddf565b73ffffffffffffffffffffffffffffffffffffffff161480610b9a5750610b9981610b94611ddf565b611ab4565b5b610bd9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610bd09061438f565b60405180910390fd5b610be383836120c1565b505050565b606060006040518060600160405280600860008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205481526020018873ffffffffffffffffffffffffffffffffffffffff168152602001878152509050610c6b878287878761217a565b610caa576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ca19061444f565b60405180910390fd5b610cfd6001600860008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461228390919063ffffffff16565b600860008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055507f5845892132946850460bff5a0083f71031bc5bf9aadcd40f1de79423eac9b10b873388604051610d7393929190614081565b60405180910390a16000803073ffffffffffffffffffffffffffffffffffffffff16888a604051602001610da8929190613fe3565b604051602081830303815290604052604051610dc49190613fcc565b6000604051808303816000865af19150503d8060008114610e01576040519150601f19603f3d011682016040523d82523d6000602084013e610e06565b606091505b509150915081610e4b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e429061428f565b60405180910390fd5b80935050505095945050505050565b6040518060400160405280600181526020017f310000000000000000000000000000000000000000000000000000000000000081525081565b610e9b611ddf565b73ffffffffffffffffffffffffffffffffffffffff16610eb96116ec565b73ffffffffffffffffffffffffffffffffffffffff1614610f0f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f069061442f565b60405180910390fd5b80600d60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b610f5b611ddf565b73ffffffffffffffffffffffffffffffffffffffff16610f796116ec565b73ffffffffffffffffffffffffffffffffffffffff1614610fcf576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610fc69061442f565b60405180910390fd5b610fd881612299565b50565b60006001610fe9600c6123b6565b610ff39190614688565b905090565b6000600754905090565b61101361100d611ddf565b826123c4565b611052576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110499061448f565b60405180910390fd5b61105d838383611dee565b505050565b6000600860008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b6000804690508091505090565b6110d3838383604051806020016040528060008152506117be565b505050565b6000600660009054906101000a900460ff16905090565b6000806002600084815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611198576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161118f906143cf565b60405180910390fd5b80915050919050565b6111a9611ddf565b73ffffffffffffffffffffffffffffffffffffffff166111c76116ec565b73ffffffffffffffffffffffffffffffffffffffff161461121d576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112149061442f565b60405180910390fd5b80600a9080519060200190611233929190612fe3565b5050565b61123f611ddf565b73ffffffffffffffffffffffffffffffffffffffff1661125d6116ec565b73ffffffffffffffffffffffffffffffffffffffff16146112b3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112aa9061442f565b60405180910390fd5b60006112bf600c6123b6565b905060005b82811015611302576112d684836124a2565b6001826112e39190614601565b91506112ef600c611cae565b80806112fa906147df565b9150506112c4565b50505050565b60008073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611379576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611370906143af565b60405180910390fd5b600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b6113c8611ddf565b73ffffffffffffffffffffffffffffffffffffffff166113e66116ec565b73ffffffffffffffffffffffffffffffffffffffff161461143c576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016114339061442f565b60405180910390fd5b61144660006124c0565b565b611450611ddf565b73ffffffffffffffffffffffffffffffffffffffff1661146e6116ec565b73ffffffffffffffffffffffffffffffffffffffff16146114c4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016114bb9061442f565b60405180910390fd5b80600b90805190602001906114da929190612fe3565b5050565b6114e6611ddf565b73ffffffffffffffffffffffffffffffffffffffff166115046116ec565b73ffffffffffffffffffffffffffffffffffffffff161461155a576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115519061442f565b60405180910390fd5b6000611566600c6123b6565b9050611572600c611cae565b61157c82826124a2565b5050565b611588611ddf565b73ffffffffffffffffffffffffffffffffffffffff166115a66116ec565b73ffffffffffffffffffffffffffffffffffffffff16146115fc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115f39061442f565b60405180910390fd5b60005b81518110156116e6576116d3848281518110611644577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b6020026020010151848381518110611685577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60200260200101518484815181106116c6577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b6020026020010151611dee565b80806116de906147df565b9150506115ff565b50505050565b6000600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b606060018054611725906147ad565b80601f0160208091040260200160405190810160405280929190818152602001828054611751906147ad565b801561179e5780601f106117735761010080835404028352916020019161179e565b820191906000526020600020905b81548152906001019060200180831161178157829003601f168201915b5050505050905090565b6117ba6117b3611ddf565b8383612586565b5050565b6117cf6117c9611ddf565b836123c4565b61180e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016118059061448f565b60405180910390fd5b61181a848484846126f3565b50505050565b606061182a61185a565b6118338361274f565b60405160200161184492919061400b565b6040516020818303038152906040529050919050565b6060600a8054611869906147ad565b80601f0160208091040260200160405190810160405280929190818152602001828054611895906147ad565b80156118e25780601f106118b7576101008083540402835291602001916118e2565b820191906000526020600020905b8154815290600101906020018083116118c557829003601f168201915b5050505050905090565b6000600d60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b61191e611ddf565b73ffffffffffffffffffffffffffffffffffffffff1661193c6116ec565b73ffffffffffffffffffffffffffffffffffffffff1614611992576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119899061442f565b60405180910390fd5b61199a6128fc565b565b6119a4611ddf565b73ffffffffffffffffffffffffffffffffffffffff166119c26116ec565b73ffffffffffffffffffffffffffffffffffffffff1614611a18576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a0f9061442f565b60405180910390fd5b611a2061299e565b565b6060600b8054611a31906147ad565b80601f0160208091040260200160405190810160405280929190818152602001828054611a5d906147ad565b8015611aaa5780601f10611a7f57610100808354040283529160200191611aaa565b820191906000526020600020905b815481529060010190602001808311611a8d57829003601f168201915b5050505050905090565b600080600d60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690508273ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1663c4552791866040518263ffffffff1660e01b8152600401611b2c9190614066565b60206040518083038186803b158015611b4457600080fd5b505afa158015611b58573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b7c9190613649565b73ffffffffffffffffffffffffffffffffffffffff161415611ba2576001915050611bb0565b611bac8484612a41565b9150505b92915050565b611bbe611ddf565b73ffffffffffffffffffffffffffffffffffffffff16611bdc6116ec565b73ffffffffffffffffffffffffffffffffffffffff1614611c32576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611c299061442f565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611ca2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611c999061426f565b60405180910390fd5b611cab816124c0565b50565b6001816000016000828254019250508190555050565b60003073ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415611d6e57600080368080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050509050600080369050905073ffffffffffffffffffffffffffffffffffffffff818301511692505050611d72565b3390505b90565b60007f01ffc9a7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916149050919050565b6000611de9611cc4565b905090565b8273ffffffffffffffffffffffffffffffffffffffff16611e0e826110ef565b73ffffffffffffffffffffffffffffffffffffffff1614611e64576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e5b906142af565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611ed4576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611ecb906142ef565b60405180910390fd5b611edf838383612ad5565b611eea6000826120c1565b6001600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000828254611f3a9190614688565b925050819055506001600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000828254611f919190614601565b92505081905550816002600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4612050838383612b2d565b505050565b60008073ffffffffffffffffffffffffffffffffffffffff166002600084815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614159050919050565b816004600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff16612134836110ef565b73ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b60008073ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff1614156121eb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016121e29061434f565b60405180910390fd5b60016121fe6121f987612b32565b612b9a565b8386866040516000815260200160405260405161221e9493929190614186565b6020604051602081039080840390855afa158015612240573d6000803e3d6000fd5b5050506020604051035173ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff1614905095945050505050565b600081836122919190614601565b905092915050565b60006122a4826110ef565b90506122b281600084612ad5565b6122bd6000836120c1565b6001600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825461230d9190614688565b925050819055506002600083815260200190815260200160002060006101000a81549073ffffffffffffffffffffffffffffffffffffffff021916905581600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a46123b281600084612b2d565b5050565b600081600001549050919050565b60006123cf82612055565b61240e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016124059061432f565b60405180910390fd5b6000612419836110ef565b90508073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16148061248857508373ffffffffffffffffffffffffffffffffffffffff1661247084610a4b565b73ffffffffffffffffffffffffffffffffffffffff16145b8061249957506124988185611ab4565b5b91505092915050565b6124bc828260405180602001604052806000815250612bd3565b5050565b6000600960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156125f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016125ec9061430f565b60405180910390fd5b80600560008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31836040516126e6919061410b565b60405180910390a3505050565b6126fe848484611dee565b61270a84848484612c2e565b612749576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016127409061424f565b60405180910390fd5b50505050565b60606000821415612797576040518060400160405280600181526020017f300000000000000000000000000000000000000000000000000000000000000081525090506128f7565b600082905060005b600082146127c95780806127b2906147df565b915050600a826127c29190614657565b915061279f565b60008167ffffffffffffffff81111561280b577f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6040519080825280601f01601f19166020018201604052801561283d5781602001600182028036833780820191505090505b5090505b600085146128f0576001826128569190614688565b9150600a856128659190614856565b60306128719190614601565b60f81b8183815181106128ad577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350600a856128e99190614657565b9450612841565b8093505050505b919050565b6129046110d8565b612943576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161293a9061422f565b60405180910390fd5b6000600660006101000a81548160ff0219169083151502179055507f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa612987611ddf565b6040516129949190614066565b60405180910390a1565b6129a66110d8565b156129e6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016129dd9061436f565b60405180910390fd5b6001600660006101000a81548160ff0219169083151502179055507f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258612a2a611ddf565b604051612a379190614066565b60405180910390a1565b6000600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16905092915050565b612ae0838383612dc5565b612ae86110d8565b15612b28576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612b1f9061420f565b60405180910390fd5b505050565b505050565b6000604051806080016040528060438152602001614a03604391398051906020012082600001518360200151846040015180519060200120604051602001612b7d9493929190614141565b604051602081830303815290604052805190602001209050919050565b6000612ba4610ff8565b82604051602001612bb692919061402f565b604051602081830303815290604052805190602001209050919050565b612bdd8383612dca565b612bea6000848484612c2e565b612c29576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612c209061424f565b60405180910390fd5b505050565b6000612c4f8473ffffffffffffffffffffffffffffffffffffffff16612fa4565b15612db8578373ffffffffffffffffffffffffffffffffffffffff1663150b7a02612c78611ddf565b8786866040518563ffffffff1660e01b8152600401612c9a94939291906140bf565b602060405180830381600087803b158015612cb457600080fd5b505af1925050508015612ce557506040513d601f19601f82011682018060405250810190612ce29190613620565b60015b612d68573d8060008114612d15576040519150601f19603f3d011682016040523d82523d6000602084013e612d1a565b606091505b50600081511415612d60576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612d579061424f565b60405180910390fd5b805181602001fd5b63150b7a0260e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191614915050612dbd565b600190505b949350505050565b505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415612e3a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612e31906143ef565b60405180910390fd5b612e4381612055565b15612e83576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612e7a906142cf565b60405180910390fd5b612e8f60008383612ad5565b6001600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000828254612edf9190614601565b92505081905550816002600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4612fa060008383612b2d565b5050565b6000808273ffffffffffffffffffffffffffffffffffffffff16803b806020016040519081016040528181526000908060200190933c51119050919050565b828054612fef906147ad565b90600052602060002090601f0160209004810192826130115760008555613058565b82601f1061302a57805160ff1916838001178555613058565b82800160010185558215613058579182015b8281111561305757825182559160200191906001019061303c565b5b5090506130659190613069565b5090565b5b8082111561308257600081600090555060010161306a565b5090565b6000613099613094846144fb565b6144ca565b905080838252602082019050828560208602820111156130b857600080fd5b60005b858110156130e857816130ce88826131da565b8452602084019350602083019250506001810190506130bb565b5050509392505050565b600061310561310084614527565b6144ca565b9050808382526020820190508285602086028201111561312457600080fd5b60005b85811015613154578161313a8882613300565b845260208401935060208301925050600181019050613127565b5050509392505050565b600061317161316c84614553565b6144ca565b90508281526020810184848401111561318957600080fd5b61319484828561476b565b509392505050565b60006131af6131aa84614583565b6144ca565b9050828152602081018484840111156131c757600080fd5b6131d284828561476b565b509392505050565b6000813590506131e981614961565b92915050565b600082601f83011261320057600080fd5b8135613210848260208601613086565b91505092915050565b600082601f83011261322a57600080fd5b813561323a8482602086016130f2565b91505092915050565b60008135905061325281614978565b92915050565b6000813590506132678161498f565b92915050565b60008135905061327c816149a6565b92915050565b600081519050613291816149a6565b92915050565b600082601f8301126132a857600080fd5b81356132b884826020860161315e565b91505092915050565b6000815190506132d0816149bd565b92915050565b600082601f8301126132e757600080fd5b81356132f784826020860161319c565b91505092915050565b60008135905061330f816149d4565b92915050565b600081359050613324816149eb565b92915050565b60006020828403121561333c57600080fd5b600061334a848285016131da565b91505092915050565b6000806040838503121561336657600080fd5b6000613374858286016131da565b9250506020613385858286016131da565b9150509250929050565b6000806000606084860312156133a457600080fd5b60006133b2868287016131da565b93505060206133c3868287016131da565b92505060406133d486828701613300565b9150509250925092565b600080600080608085870312156133f457600080fd5b6000613402878288016131da565b9450506020613413878288016131da565b935050604061342487828801613300565b925050606085013567ffffffffffffffff81111561344157600080fd5b61344d87828801613297565b91505092959194509250565b6000806040838503121561346c57600080fd5b600061347a858286016131da565b925050602061348b85828601613243565b9150509250929050565b600080600080600060a086880312156134ad57600080fd5b60006134bb888289016131da565b955050602086013567ffffffffffffffff8111156134d857600080fd5b6134e488828901613297565b94505060406134f588828901613258565b935050606061350688828901613258565b925050608061351788828901613315565b9150509295509295909350565b6000806040838503121561353757600080fd5b6000613545858286016131da565b925050602061355685828601613300565b9150509250929050565b60008060006060848603121561357557600080fd5b600084013567ffffffffffffffff81111561358f57600080fd5b61359b868287016131ef565b935050602084013567ffffffffffffffff8111156135b857600080fd5b6135c4868287016131ef565b925050604084013567ffffffffffffffff8111156135e157600080fd5b6135ed86828701613219565b9150509250925092565b60006020828403121561360957600080fd5b60006136178482850161326d565b91505092915050565b60006020828403121561363257600080fd5b600061364084828501613282565b91505092915050565b60006020828403121561365b57600080fd5b6000613669848285016132c1565b91505092915050565b60006020828403121561368457600080fd5b600082013567ffffffffffffffff81111561369e57600080fd5b6136aa848285016132d6565b91505092915050565b6000602082840312156136c557600080fd5b60006136d384828501613300565b91505092915050565b6136e5816146ce565b82525050565b6136f4816146bc565b82525050565b61370b613706826146bc565b614828565b82525050565b61371a816146e0565b82525050565b613729816146ec565b82525050565b61374061373b826146ec565b61483a565b82525050565b6000613751826145b3565b61375b81856145c9565b935061376b81856020860161477a565b61377481614943565b840191505092915050565b600061378a826145b3565b61379481856145da565b93506137a481856020860161477a565b80840191505092915050565b60006137bb826145be565b6137c581856145e5565b93506137d581856020860161477a565b6137de81614943565b840191505092915050565b60006137f4826145be565b6137fe81856145f6565b935061380e81856020860161477a565b80840191505092915050565b6000613827602b836145e5565b91507f4552433732315061757361626c653a20746f6b656e207472616e73666572207760008301527f68696c65207061757365640000000000000000000000000000000000000000006020830152604082019050919050565b600061388d6014836145e5565b91507f5061757361626c653a206e6f74207061757365640000000000000000000000006000830152602082019050919050565b60006138cd6032836145e5565b91507f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560008301527f63656976657220696d706c656d656e74657200000000000000000000000000006020830152604082019050919050565b60006139336026836145e5565b91507f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008301527f64647265737300000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000613999601c836145e5565b91507f46756e6374696f6e2063616c6c206e6f74207375636365737366756c000000006000830152602082019050919050565b60006139d96025836145e5565b91507f4552433732313a207472616e736665722066726f6d20696e636f72726563742060008301527f6f776e65720000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000613a3f601c836145e5565b91507f4552433732313a20746f6b656e20616c7265616479206d696e746564000000006000830152602082019050919050565b6000613a7f6002836145f6565b91507f19010000000000000000000000000000000000000000000000000000000000006000830152600282019050919050565b6000613abf6024836145e5565b91507f4552433732313a207472616e7366657220746f20746865207a65726f2061646460008301527f72657373000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000613b256019836145e5565b91507f4552433732313a20617070726f766520746f2063616c6c6572000000000000006000830152602082019050919050565b6000613b65602c836145e5565b91507f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860008301527f697374656e7420746f6b656e00000000000000000000000000000000000000006020830152604082019050919050565b6000613bcb6025836145e5565b91507f4e61746976654d6574615472616e73616374696f6e3a20494e56414c49445f5360008301527f49474e45520000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000613c316010836145e5565b91507f5061757361626c653a20706175736564000000000000000000000000000000006000830152602082019050919050565b6000613c716038836145e5565b91507f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760008301527f6e6572206e6f7220617070726f76656420666f7220616c6c00000000000000006020830152604082019050919050565b6000613cd7602a836145e5565b91507f4552433732313a2062616c616e636520717565727920666f7220746865207a6560008301527f726f2061646472657373000000000000000000000000000000000000000000006020830152604082019050919050565b6000613d3d6029836145e5565b91507f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460008301527f656e7420746f6b656e00000000000000000000000000000000000000000000006020830152604082019050919050565b6000613da36020836145e5565b91507f4552433732313a206d696e7420746f20746865207a65726f20616464726573736000830152602082019050919050565b6000613de3602c836145e5565b91507f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860008301527f697374656e7420746f6b656e00000000000000000000000000000000000000006020830152604082019050919050565b6000613e496020836145e5565b91507f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726000830152602082019050919050565b6000613e896021836145e5565b91507f5369676e657220616e64207369676e617475726520646f206e6f74206d61746360008301527f68000000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000613eef6021836145e5565b91507f4552433732313a20617070726f76616c20746f2063757272656e74206f776e6560008301527f72000000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000613f556031836145e5565b91507f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f60008301527f776e6572206e6f7220617070726f7665640000000000000000000000000000006020830152604082019050919050565b613fb781614754565b82525050565b613fc68161475e565b82525050565b6000613fd8828461377f565b915081905092915050565b6000613fef828561377f565b9150613ffb82846136fa565b6014820191508190509392505050565b600061401782856137e9565b915061402382846137e9565b91508190509392505050565b600061403a82613a72565b9150614046828561372f565b602082019150614056828461372f565b6020820191508190509392505050565b600060208201905061407b60008301846136eb565b92915050565b600060608201905061409660008301866136eb565b6140a360208301856136dc565b81810360408301526140b58184613746565b9050949350505050565b60006080820190506140d460008301876136eb565b6140e160208301866136eb565b6140ee6040830185613fae565b81810360608301526141008184613746565b905095945050505050565b60006020820190506141206000830184613711565b92915050565b600060208201905061413b6000830184613720565b92915050565b60006080820190506141566000830187613720565b6141636020830186613fae565b61417060408301856136eb565b61417d6060830184613720565b95945050505050565b600060808201905061419b6000830187613720565b6141a86020830186613fbd565b6141b56040830185613720565b6141c26060830184613720565b95945050505050565b600060208201905081810360008301526141e58184613746565b905092915050565b6000602082019050818103600083015261420781846137b0565b905092915050565b600060208201905081810360008301526142288161381a565b9050919050565b6000602082019050818103600083015261424881613880565b9050919050565b60006020820190508181036000830152614268816138c0565b9050919050565b6000602082019050818103600083015261428881613926565b9050919050565b600060208201905081810360008301526142a88161398c565b9050919050565b600060208201905081810360008301526142c8816139cc565b9050919050565b600060208201905081810360008301526142e881613a32565b9050919050565b6000602082019050818103600083015261430881613ab2565b9050919050565b6000602082019050818103600083015261432881613b18565b9050919050565b6000602082019050818103600083015261434881613b58565b9050919050565b6000602082019050818103600083015261436881613bbe565b9050919050565b6000602082019050818103600083015261438881613c24565b9050919050565b600060208201905081810360008301526143a881613c64565b9050919050565b600060208201905081810360008301526143c881613cca565b9050919050565b600060208201905081810360008301526143e881613d30565b9050919050565b6000602082019050818103600083015261440881613d96565b9050919050565b6000602082019050818103600083015261442881613dd6565b9050919050565b6000602082019050818103600083015261444881613e3c565b9050919050565b6000602082019050818103600083015261446881613e7c565b9050919050565b6000602082019050818103600083015261448881613ee2565b9050919050565b600060208201905081810360008301526144a881613f48565b9050919050565b60006020820190506144c46000830184613fae565b92915050565b6000604051905081810181811067ffffffffffffffff821117156144f1576144f0614914565b5b8060405250919050565b600067ffffffffffffffff82111561451657614515614914565b5b602082029050602081019050919050565b600067ffffffffffffffff82111561454257614541614914565b5b602082029050602081019050919050565b600067ffffffffffffffff82111561456e5761456d614914565b5b601f19601f8301169050602081019050919050565b600067ffffffffffffffff82111561459e5761459d614914565b5b601f19601f8301169050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b600081905092915050565b600061460c82614754565b915061461783614754565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561464c5761464b614887565b5b828201905092915050565b600061466282614754565b915061466d83614754565b92508261467d5761467c6148b6565b5b828204905092915050565b600061469382614754565b915061469e83614754565b9250828210156146b1576146b0614887565b5b828203905092915050565b60006146c782614734565b9050919050565b60006146d982614734565b9050919050565b60008115159050919050565b6000819050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b600061472d826146bc565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b82818337600083830152505050565b60005b8381101561479857808201518184015260208101905061477d565b838111156147a7576000848401525b50505050565b600060028204905060018216806147c557607f821691505b602082108114156147d9576147d86148e5565b5b50919050565b60006147ea82614754565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82141561481d5761481c614887565b5b600182019050919050565b600061483382614844565b9050919050565b6000819050919050565b600061484f82614954565b9050919050565b600061486182614754565b915061486c83614754565b92508261487c5761487b6148b6565b5b828206905092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b61496a816146bc565b811461497557600080fd5b50565b614981816146e0565b811461498c57600080fd5b50565b614998816146ec565b81146149a357600080fd5b50565b6149af816146f6565b81146149ba57600080fd5b50565b6149c681614722565b81146149d157600080fd5b50565b6149dd81614754565b81146149e857600080fd5b50565b6149f48161475e565b81146149ff57600080fd5b5056fe4d6574615472616e73616374696f6e2875696e74323536206e6f6e63652c616464726573732066726f6d2c62797465732066756e6374696f6e5369676e617475726529a2646970667358221220649bb3451d4f010255fe4776aa9b4fe3bd596195454bddce82f8575ec9da277464736f6c6343000800003368747470733a2f2f6c616e64636f6e74726163746170692e746875672e74762f636f6e74726163742f6c616e64636f6e7472616374454950373132446f6d61696e28737472696e67206e616d652c737472696e672076657273696f6e2c6164647265737320766572696679696e67436f6e74726163742c627974657333322073616c742968747470733a2f2f6c616e64636f6e74726163746170692e746875672e74762f636f6e74726163742f6c616e64746f6b656e2f000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c1

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

000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c1

-----Decoded View---------------
Arg [0] : _proxyRegistryAddress (address): 0xa5409ec958C83C3f309868babACA7c86DCB077c1

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c1


Deployed ByteCode Sourcemap

60584:547:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41565:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58085:140;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42510:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44069:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43592:411;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;11499:1151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;713:43;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57504:141;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57991:86;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59036:105;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1722:101;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44819:339;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;13076:107;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1831:161;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45229:185;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39146:86;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42204:239;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57252:111;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58502:361;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;41934:208;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19879:103;;;;;;;;;;;;;:::i;:::-;;57372:123;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57790:193;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58233:261;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;19228:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42679:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44362:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45485:328;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59375:175;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60921:103;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59259:108;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57173:70;;;;;;;;;;;;;:::i;:::-;;57098:66;;;;;;;;;;;;;:::i;:::-;;61032:96;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59682:445;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20137:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;41565:305;41667:4;41719:25;41704:40;;;:11;:40;;;;:105;;;;41776:33;41761:48;;;:11;:48;;;;41704:105;:158;;;;41826:36;41850:11;41826:23;:36::i;:::-;41704:158;41684:178;;41565:305;;;:::o;58085:140::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;58187:30:::1;58197:5;58204:3;58209:7;58187:9;:30::i;:::-;58085:140:::0;;;:::o;42510:100::-;42564:13;42597:5;42590:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42510:100;:::o;44069:221::-;44145:7;44173:16;44181:7;44173;:16::i;:::-;44165:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;44258:15;:24;44274:7;44258:24;;;;;;;;;;;;;;;;;;;;;44251:31;;44069:221;;;:::o;43592:411::-;43673:13;43689:23;43704:7;43689:14;:23::i;:::-;43673:39;;43737:5;43731:11;;:2;:11;;;;43723:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;43831:5;43815:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;43840:37;43857:5;43864:12;:10;:12::i;:::-;43840:16;:37::i;:::-;43815:62;43793:168;;;;;;;;;;;;:::i;:::-;;;;;;;;;43974:21;43983:2;43987:7;43974:8;:21::i;:::-;43592:411;;;:::o;11499:1151::-;11700:12;11725:29;11757:152;;;;;;;;11795:6;:19;11802:11;11795:19;;;;;;;;;;;;;;;;11757:152;;;;11835:11;11757:152;;;;;;11880:17;11757:152;;;11725:184;;11944:45;11951:11;11964:6;11972:4;11978;11984;11944:6;:45::i;:::-;11922:128;;;;;;;;;;;;:::i;:::-;;;;;;;;;12139:26;12163:1;12139:6;:19;12146:11;12139:19;;;;;;;;;;;;;;;;:23;;:26;;;;:::i;:::-;12117:6;:19;12124:11;12117:19;;;;;;;;;;;;;;;:48;;;;12183:126;12221:11;12255:10;12281:17;12183:126;;;;;;;;:::i;:::-;;;;;;;;12420:12;12434:23;12469:4;12461:18;;12511:17;12530:11;12494:48;;;;;;;;;:::i;:::-;;;;;;;;;;;;;12461:92;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12419:134;;;;12572:7;12564:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;12632:10;12625:17;;;;;11499:1151;;;;;;;:::o;713:43::-;;;;;;;;;;;;;;;;;;;:::o;57504:141::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57616:21:::1;57593:20;;:44;;;;;;;;;;;;;;;;;;57504:141:::0;:::o;57991:86::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;58055:14:::1;58061:7;58055:5;:14::i;:::-;57991:86:::0;:::o;59036:105::-;59080:7;59132:1;59107:22;:12;:20;:22::i;:::-;:26;;;;:::i;:::-;59100:33;;59036:105;:::o;1722:101::-;1773:7;1800:15;;1793:22;;1722:101;:::o;44819:339::-;45014:41;45033:12;:10;:12::i;:::-;45047:7;45014:18;:41::i;:::-;45006:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;45122:28;45132:4;45138:2;45142:7;45122:9;:28::i;:::-;44819:339;;;:::o;13076:107::-;13129:13;13163:6;:12;13170:4;13163:12;;;;;;;;;;;;;;;;13155:20;;13076:107;;;:::o;1831:161::-;1874:7;1894:10;1945:9;1939:15;;1982:2;1975:9;;;1831:161;:::o;45229:185::-;45367:39;45384:4;45390:2;45394:7;45367:39;;;;;;;;;;;;:16;:39::i;:::-;45229:185;;;:::o;39146:86::-;39193:4;39217:7;;;;;;;;;;;39210:14;;39146:86;:::o;42204:239::-;42276:7;42296:13;42312:7;:16;42320:7;42312:16;;;;;;;;;;;;;;;;;;;;;42296:32;;42364:1;42347:19;;:5;:19;;;;42339:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;42430:5;42423:12;;;42204:239;;;:::o;57252:111::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57344:11:::1;57333:8;:22;;;;;;;;;;;;:::i;:::-;;57252:111:::0;:::o;58502:361::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;58588:22:::1;58638;:12;:20;:22::i;:::-;58621:39;;58678:9;58673:183;58697:6;58693:1;:10;58673:183;;;58725:30;58735:3;58740:14;58725:9;:30::i;:::-;58804:1;58787:14;:18;;;;:::i;:::-;58770:35;;58820:24;:12;:22;:24::i;:::-;58705:3;;;;;:::i;:::-;;;;58673:183;;;;19519:1;58502:361:::0;;:::o;41934:208::-;42006:7;42051:1;42034:19;;:5;:19;;;;42026:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;42118:9;:16;42128:5;42118:16;;;;;;;;;;;;;;;;42111:23;;41934:208;;;:::o;19879:103::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;19944:30:::1;19971:1;19944:18;:30::i;:::-;19879:103::o:0;57372:123::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57473:14:::1;57459:11;:28;;;;;;;;;;;;:::i;:::-;;57372:123:::0;:::o;57790:193::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57852:22:::1;57877;:12;:20;:22::i;:::-;57852:47;;57910:24;:12;:22;:24::i;:::-;57945:30;57955:3;57960:14;57945:9;:30::i;:::-;19519:1;57790:193:::0;:::o;58233:261::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;58377:9:::1;58372:115;58396:9;:16;58392:1;:20;58372:115;;;58434:41;58444:5;58450:1;58444:8;;;;;;;;;;;;;;;;;;;;;;58454:3;58458:1;58454:6;;;;;;;;;;;;;;;;;;;;;;58462:9;58472:1;58462:12;;;;;;;;;;;;;;;;;;;;;;58434:9;:41::i;:::-;58414:3;;;;;:::i;:::-;;;;58372:115;;;;58233:261:::0;;;:::o;19228:87::-;19274:7;19301:6;;;;;;;;;;;19294:13;;19228:87;:::o;42679:104::-;42735:13;42768:7;42761:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42679:104;:::o;44362:155::-;44457:52;44476:12;:10;:12::i;:::-;44490:8;44500;44457:18;:52::i;:::-;44362:155;;:::o;45485:328::-;45660:41;45679:12;:10;:12::i;:::-;45693:7;45660:18;:41::i;:::-;45652:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;45766:39;45780:4;45786:2;45790:7;45799:5;45766:13;:39::i;:::-;45485:328;;;;:::o;59375:175::-;59441:13;59498:14;:12;:14::i;:::-;59514:26;59531:8;59514:16;:26::i;:::-;59481:60;;;;;;;;;:::i;:::-;;;;;;;;;;;;;59467:75;;59375:175;;;:::o;60921:103::-;60975:13;61008:8;61001:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60921:103;:::o;59259:108::-;59312:7;59339:20;;;;;;;;;;;59332:27;;59259:108;:::o;57173:70::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57225:10:::1;:8;:10::i;:::-;57173:70::o:0;57098:66::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57148:8:::1;:6;:8::i;:::-;57098:66::o:0;61032:96::-;61076:13;61109:11;61102:18;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61032:96;:::o;59682:445::-;59807:4;59892:27;59936:20;;;;;;;;;;;59892:65;;60013:8;59972:49;;59980:13;:21;;;60002:5;59980:28;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59972:49;;;59968:93;;;60045:4;60038:11;;;;;59968:93;60080:39;60103:5;60110:8;60080:22;:39::i;:::-;60073:46;;;59682:445;;;;;:::o;20137:201::-;19459:12;:10;:12::i;:::-;19448:23;;:7;:5;:7::i;:::-;:23;;;19440:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;20246:1:::1;20226:22;;:8;:22;;;;20218:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;20302:28;20321:8;20302:18;:28::i;:::-;20137:201:::0;:::o;14678:127::-;14785:1;14767:7;:14;;;:19;;;;;;;;;;;14678:127;:::o;2821:650::-;2892:22;2958:4;2936:27;;:10;:27;;;2932:508;;;2980:18;3001:8;;2980:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3024:13;3040:8;;:15;;3024:31;;3292:42;3262:5;3255;3251:17;3245:24;3219:134;3209:144;;3079:289;;;;;3417:10;3400:28;;2932:508;2821:650;:::o;32065:157::-;32150:4;32189:25;32174:40;;;:11;:40;;;;32167:47;;32065:157;;;:::o;60271:161::-;60361:14;60400:24;:22;:24::i;:::-;60393:31;;60271:161;:::o;50726:625::-;50885:4;50858:31;;:23;50873:7;50858:14;:23::i;:::-;:31;;;50850:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;50964:1;50950:16;;:2;:16;;;;50942:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;51020:39;51041:4;51047:2;51051:7;51020:20;:39::i;:::-;51124:29;51141:1;51145:7;51124:8;:29::i;:::-;51185:1;51166:9;:15;51176:4;51166:15;;;;;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;;;;;;51214:1;51197:9;:13;51207:2;51197:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;51245:2;51226:7;:16;51234:7;51226:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;51284:7;51280:2;51265:27;;51274:4;51265:27;;;;;;;;;;;;51305:38;51325:4;51331:2;51335:7;51305:19;:38::i;:::-;50726:625;;;:::o;47323:127::-;47388:4;47440:1;47412:30;;:7;:16;47420:7;47412:16;;;;;;;;;;;;;;;;;;;;;:30;;;;47405:37;;47323:127;;;:::o;51469:174::-;51571:2;51544:15;:24;51560:7;51544:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;51627:7;51623:2;51589:46;;51598:23;51613:7;51598:14;:23::i;:::-;51589:46;;;;;;;;;;;;51469:174;;:::o;13191:486::-;13369:4;13412:1;13394:20;;:6;:20;;;;13386:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;13510:159;13538:47;13557:27;13577:6;13557:19;:27::i;:::-;13538:18;:47::i;:::-;13604:4;13627;13650;13510:159;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13487:182;;:6;:182;;;13467:202;;13191:486;;;;;;;:::o;6340:98::-;6398:7;6429:1;6425;:5;;;;:::i;:::-;6418:12;;6340:98;;;;:::o;49969:420::-;50029:13;50045:23;50060:7;50045:14;:23::i;:::-;50029:39;;50081:48;50102:5;50117:1;50121:7;50081:20;:48::i;:::-;50170:29;50187:1;50191:7;50170:8;:29::i;:::-;50232:1;50212:9;:16;50222:5;50212:16;;;;;;;;;;;;;;;;:21;;;;;;;:::i;:::-;;;;;;;;50251:7;:16;50259:7;50251:16;;;;;;;;;;;;50244:23;;;;;;;;;;;50313:7;50309:1;50285:36;;50294:5;50285:36;;;;;;;;;;;;50334:47;50354:5;50369:1;50373:7;50334:19;:47::i;:::-;49969:420;;:::o;14556:114::-;14621:7;14648;:14;;;14641:21;;14556:114;;;:::o;47617:348::-;47710:4;47735:16;47743:7;47735;:16::i;:::-;47727:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;47811:13;47827:23;47842:7;47827:14;:23::i;:::-;47811:39;;47880:5;47869:16;;:7;:16;;;:51;;;;47913:7;47889:31;;:20;47901:7;47889:11;:20::i;:::-;:31;;;47869:51;:87;;;;47924:32;47941:5;47948:7;47924:16;:32::i;:::-;47869:87;47861:96;;;47617:348;;;;:::o;48307:110::-;48383:26;48393:2;48397:7;48383:26;;;;;;;;;;;;:9;:26::i;:::-;48307:110;;:::o;20498:191::-;20572:16;20591:6;;;;;;;;;;;20572:25;;20617:8;20608:6;;:17;;;;;;;;;;;;;;;;;;20672:8;20641:40;;20662:8;20641:40;;;;;;;;;;;;20498:191;;:::o;51785:315::-;51940:8;51931:17;;:5;:17;;;;51923:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;52027:8;51989:18;:25;52008:5;51989:25;;;;;;;;;;;;;;;:35;52015:8;51989:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;52073:8;52051:41;;52066:5;52051:41;;;52083:8;52051:41;;;;;;:::i;:::-;;;;;;;;51785:315;;;:::o;46695:::-;46852:28;46862:4;46868:2;46872:7;46852:9;:28::i;:::-;46899:48;46922:4;46928:2;46932:7;46941:5;46899:22;:48::i;:::-;46891:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;46695:315;;;;:::o;15514:723::-;15570:13;15800:1;15791:5;:10;15787:53;;;15818:10;;;;;;;;;;;;;;;;;;;;;15787:53;15850:12;15865:5;15850:20;;15881:14;15906:78;15921:1;15913:4;:9;15906:78;;15939:8;;;;;:::i;:::-;;;;15970:2;15962:10;;;;;:::i;:::-;;;15906:78;;;15994:19;16026:6;16016:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15994:39;;16044:154;16060:1;16051:5;:10;16044:154;;16088:1;16078:11;;;;;:::i;:::-;;;16155:2;16147:5;:10;;;;:::i;:::-;16134:2;:24;;;;:::i;:::-;16121:39;;16104:6;16111;16104:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;;16184:2;16175:11;;;;;:::i;:::-;;;16044:154;;;16222:6;16208:21;;;;;15514:723;;;;:::o;40205:120::-;39749:8;:6;:8::i;:::-;39741:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;40274:5:::1;40264:7;;:15;;;;;;;;;;;;;;;;;;40295:22;40304:12;:10;:12::i;:::-;40295:22;;;;;;:::i;:::-;;;;;;;;40205:120::o:0;39946:118::-;39472:8;:6;:8::i;:::-;39471:9;39463:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;40016:4:::1;40006:7;;:14;;;;;;;;;;;;;;;;;;40036:20;40043:12;:10;:12::i;:::-;40036:20;;;;;;:::i;:::-;;;;;;;;39946:118::o:0;44588:164::-;44685:4;44709:18;:25;44728:5;44709:25;;;;;;;;;;;;;;;:35;44735:8;44709:35;;;;;;;;;;;;;;;;;;;;;;;;;44702:42;;44588:164;;;;:::o;56815:275::-;56959:45;56986:4;56992:2;56996:7;56959:26;:45::i;:::-;57026:8;:6;:8::i;:::-;57025:9;57017:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;56815:275;;;:::o;54547:125::-;;;;:::o;12658:410::-;12768:7;10835:100;;;;;;;;;;;;;;;;;10815:127;;;;;;12922:6;:12;;;12957:6;:11;;;13001:6;:24;;;12991:35;;;;;;12841:204;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;12813:247;;;;;;12793:267;;12658:410;;;:::o;2361:258::-;2460:7;2562:20;:18;:20::i;:::-;2584:11;2533:63;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2505:106;;;;;;2485:126;;2361:258;;;:::o;48644:321::-;48774:18;48780:2;48784:7;48774:5;:18::i;:::-;48825:54;48856:1;48860:2;48864:7;48873:5;48825:22;:54::i;:::-;48803:154;;;;;;;;;;;;:::i;:::-;;;;;;;;;48644:321;;;:::o;52665:799::-;52820:4;52841:15;:2;:13;;;:15::i;:::-;52837:620;;;52893:2;52877:36;;;52914:12;:10;:12::i;:::-;52928:4;52934:7;52943:5;52877:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;52873:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53136:1;53119:6;:13;:18;53115:272;;;53162:60;;;;;;;;;;:::i;:::-;;;;;;;;53115:272;53337:6;53331:13;53322:6;53318:2;53314:15;53307:38;52873:529;53010:41;;;53000:51;;;:6;:51;;;;52993:58;;;;;52837:620;53441:4;53434:11;;52665:799;;;;;;;:::o;54036:126::-;;;;:::o;49301:439::-;49395:1;49381:16;;:2;:16;;;;49373:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;49454:16;49462:7;49454;:16::i;:::-;49453:17;49445:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;49516:45;49545:1;49549:2;49553:7;49516:20;:45::i;:::-;49591:1;49574:9;:13;49584:2;49574:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;49622:2;49603:7;:16;49611:7;49603:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;49667:7;49663:2;49642:33;;49659:1;49642:33;;;;;;;;;;;;49688:44;49716:1;49720:2;49724:7;49688:19;:44::i;:::-;49301:439;;:::o;21929:326::-;21989:4;22246:1;22224:7;:12;;;;;;;;;;;;;;;;;;;;;;;;;:19;:23;22217:30;;21929:326;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;24:622:1:-;;145:80;160:64;217:6;160:64;:::i;:::-;145:80;:::i;:::-;136:89;;245:5;273:6;266:5;259:21;299:4;292:5;288:16;281:23;;324:6;374:3;366:4;358:6;354:17;349:3;345:27;342:36;339:2;;;391:1;388;381:12;339:2;419:1;404:236;429:6;426:1;423:13;404:236;;;496:3;524:37;557:3;545:10;524:37;:::i;:::-;519:3;512:50;591:4;586:3;582:14;575:21;;625:4;620:3;616:14;609:21;;464:176;451:1;448;444:9;439:14;;404:236;;;408:14;126:520;;;;;;;:::o;669:622::-;;790:80;805:64;862:6;805:64;:::i;:::-;790:80;:::i;:::-;781:89;;890:5;918:6;911:5;904:21;944:4;937:5;933:16;926:23;;969:6;1019:3;1011:4;1003:6;999:17;994:3;990:27;987:36;984:2;;;1036:1;1033;1026:12;984:2;1064:1;1049:236;1074:6;1071:1;1068:13;1049:236;;;1141:3;1169:37;1202:3;1190:10;1169:37;:::i;:::-;1164:3;1157:50;1236:4;1231:3;1227:14;1220:21;;1270:4;1265:3;1261:14;1254:21;;1109:176;1096:1;1093;1089:9;1084:14;;1049:236;;;1053:14;771:520;;;;;;;:::o;1297:342::-;;1399:64;1414:48;1455:6;1414:48;:::i;:::-;1399:64;:::i;:::-;1390:73;;1486:6;1479:5;1472:21;1524:4;1517:5;1513:16;1562:3;1553:6;1548:3;1544:16;1541:25;1538:2;;;1579:1;1576;1569:12;1538:2;1592:41;1626:6;1621:3;1616;1592:41;:::i;:::-;1380:259;;;;;;:::o;1645:344::-;;1748:65;1763:49;1805:6;1763:49;:::i;:::-;1748:65;:::i;:::-;1739:74;;1836:6;1829:5;1822:21;1874:4;1867:5;1863:16;1912:3;1903:6;1898:3;1894:16;1891:25;1888:2;;;1929:1;1926;1919:12;1888:2;1942:41;1976:6;1971:3;1966;1942:41;:::i;:::-;1729:260;;;;;;:::o;1995:139::-;;2079:6;2066:20;2057:29;;2095:33;2122:5;2095:33;:::i;:::-;2047:87;;;;:::o;2157:303::-;;2277:3;2270:4;2262:6;2258:17;2254:27;2244:2;;2295:1;2292;2285:12;2244:2;2335:6;2322:20;2360:94;2450:3;2442:6;2435:4;2427:6;2423:17;2360:94;:::i;:::-;2351:103;;2234:226;;;;;:::o;2483:303::-;;2603:3;2596:4;2588:6;2584:17;2580:27;2570:2;;2621:1;2618;2611:12;2570:2;2661:6;2648:20;2686:94;2776:3;2768:6;2761:4;2753:6;2749:17;2686:94;:::i;:::-;2677:103;;2560:226;;;;;:::o;2792:133::-;;2873:6;2860:20;2851:29;;2889:30;2913:5;2889:30;:::i;:::-;2841:84;;;;:::o;2931:139::-;;3015:6;3002:20;2993:29;;3031:33;3058:5;3031:33;:::i;:::-;2983:87;;;;:::o;3076:137::-;;3159:6;3146:20;3137:29;;3175:32;3201:5;3175:32;:::i;:::-;3127:86;;;;:::o;3219:141::-;;3306:6;3300:13;3291:22;;3322:32;3348:5;3322:32;:::i;:::-;3281:79;;;;:::o;3379:271::-;;3483:3;3476:4;3468:6;3464:17;3460:27;3450:2;;3501:1;3498;3491:12;3450:2;3541:6;3528:20;3566:78;3640:3;3632:6;3625:4;3617:6;3613:17;3566:78;:::i;:::-;3557:87;;3440:210;;;;;:::o;3656:201::-;;3773:6;3767:13;3758:22;;3789:62;3845:5;3789:62;:::i;:::-;3748:109;;;;:::o;3877:273::-;;3982:3;3975:4;3967:6;3963:17;3959:27;3949:2;;4000:1;3997;3990:12;3949:2;4040:6;4027:20;4065:79;4140:3;4132:6;4125:4;4117:6;4113:17;4065:79;:::i;:::-;4056:88;;3939:211;;;;;:::o;4156:139::-;;4240:6;4227:20;4218:29;;4256:33;4283:5;4256:33;:::i;:::-;4208:87;;;;:::o;4301:135::-;;4383:6;4370:20;4361:29;;4399:31;4424:5;4399:31;:::i;:::-;4351:85;;;;:::o;4442:262::-;;4550:2;4538:9;4529:7;4525:23;4521:32;4518:2;;;4566:1;4563;4556:12;4518:2;4609:1;4634:53;4679:7;4670:6;4659:9;4655:22;4634:53;:::i;:::-;4624:63;;4580:117;4508:196;;;;:::o;4710:407::-;;;4835:2;4823:9;4814:7;4810:23;4806:32;4803:2;;;4851:1;4848;4841:12;4803:2;4894:1;4919:53;4964:7;4955:6;4944:9;4940:22;4919:53;:::i;:::-;4909:63;;4865:117;5021:2;5047:53;5092:7;5083:6;5072:9;5068:22;5047:53;:::i;:::-;5037:63;;4992:118;4793:324;;;;;:::o;5123:552::-;;;;5265:2;5253:9;5244:7;5240:23;5236:32;5233:2;;;5281:1;5278;5271:12;5233:2;5324:1;5349:53;5394:7;5385:6;5374:9;5370:22;5349:53;:::i;:::-;5339:63;;5295:117;5451:2;5477:53;5522:7;5513:6;5502:9;5498:22;5477:53;:::i;:::-;5467:63;;5422:118;5579:2;5605:53;5650:7;5641:6;5630:9;5626:22;5605:53;:::i;:::-;5595:63;;5550:118;5223:452;;;;;:::o;5681:809::-;;;;;5849:3;5837:9;5828:7;5824:23;5820:33;5817:2;;;5866:1;5863;5856:12;5817:2;5909:1;5934:53;5979:7;5970:6;5959:9;5955:22;5934:53;:::i;:::-;5924:63;;5880:117;6036:2;6062:53;6107:7;6098:6;6087:9;6083:22;6062:53;:::i;:::-;6052:63;;6007:118;6164:2;6190:53;6235:7;6226:6;6215:9;6211:22;6190:53;:::i;:::-;6180:63;;6135:118;6320:2;6309:9;6305:18;6292:32;6351:18;6343:6;6340:30;6337:2;;;6383:1;6380;6373:12;6337:2;6411:62;6465:7;6456:6;6445:9;6441:22;6411:62;:::i;:::-;6401:72;;6263:220;5807:683;;;;;;;:::o;6496:401::-;;;6618:2;6606:9;6597:7;6593:23;6589:32;6586:2;;;6634:1;6631;6624:12;6586:2;6677:1;6702:53;6747:7;6738:6;6727:9;6723:22;6702:53;:::i;:::-;6692:63;;6648:117;6804:2;6830:50;6872:7;6863:6;6852:9;6848:22;6830:50;:::i;:::-;6820:60;;6775:115;6576:321;;;;;:::o;6903:951::-;;;;;;7086:3;7074:9;7065:7;7061:23;7057:33;7054:2;;;7103:1;7100;7093:12;7054:2;7146:1;7171:53;7216:7;7207:6;7196:9;7192:22;7171:53;:::i;:::-;7161:63;;7117:117;7301:2;7290:9;7286:18;7273:32;7332:18;7324:6;7321:30;7318:2;;;7364:1;7361;7354:12;7318:2;7392:62;7446:7;7437:6;7426:9;7422:22;7392:62;:::i;:::-;7382:72;;7244:220;7503:2;7529:53;7574:7;7565:6;7554:9;7550:22;7529:53;:::i;:::-;7519:63;;7474:118;7631:2;7657:53;7702:7;7693:6;7682:9;7678:22;7657:53;:::i;:::-;7647:63;;7602:118;7759:3;7786:51;7829:7;7820:6;7809:9;7805:22;7786:51;:::i;:::-;7776:61;;7730:117;7044:810;;;;;;;;:::o;7860:407::-;;;7985:2;7973:9;7964:7;7960:23;7956:32;7953:2;;;8001:1;7998;7991:12;7953:2;8044:1;8069:53;8114:7;8105:6;8094:9;8090:22;8069:53;:::i;:::-;8059:63;;8015:117;8171:2;8197:53;8242:7;8233:6;8222:9;8218:22;8197:53;:::i;:::-;8187:63;;8142:118;7943:324;;;;;:::o;8273:981::-;;;;8490:2;8478:9;8469:7;8465:23;8461:32;8458:2;;;8506:1;8503;8496:12;8458:2;8577:1;8566:9;8562:17;8549:31;8607:18;8599:6;8596:30;8593:2;;;8639:1;8636;8629:12;8593:2;8667:78;8737:7;8728:6;8717:9;8713:22;8667:78;:::i;:::-;8657:88;;8520:235;8822:2;8811:9;8807:18;8794:32;8853:18;8845:6;8842:30;8839:2;;;8885:1;8882;8875:12;8839:2;8913:78;8983:7;8974:6;8963:9;8959:22;8913:78;:::i;:::-;8903:88;;8765:236;9068:2;9057:9;9053:18;9040:32;9099:18;9091:6;9088:30;9085:2;;;9131:1;9128;9121:12;9085:2;9159:78;9229:7;9220:6;9209:9;9205:22;9159:78;:::i;:::-;9149:88;;9011:236;8448:806;;;;;:::o;9260:260::-;;9367:2;9355:9;9346:7;9342:23;9338:32;9335:2;;;9383:1;9380;9373:12;9335:2;9426:1;9451:52;9495:7;9486:6;9475:9;9471:22;9451:52;:::i;:::-;9441:62;;9397:116;9325:195;;;;:::o;9526:282::-;;9644:2;9632:9;9623:7;9619:23;9615:32;9612:2;;;9660:1;9657;9650:12;9612:2;9703:1;9728:63;9783:7;9774:6;9763:9;9759:22;9728:63;:::i;:::-;9718:73;;9674:127;9602:206;;;;:::o;9814:342::-;;9962:2;9950:9;9941:7;9937:23;9933:32;9930:2;;;9978:1;9975;9968:12;9930:2;10021:1;10046:93;10131:7;10122:6;10111:9;10107:22;10046:93;:::i;:::-;10036:103;;9992:157;9920:236;;;;:::o;10162:375::-;;10280:2;10268:9;10259:7;10255:23;10251:32;10248:2;;;10296:1;10293;10286:12;10248:2;10367:1;10356:9;10352:17;10339:31;10397:18;10389:6;10386:30;10383:2;;;10429:1;10426;10419:12;10383:2;10457:63;10512:7;10503:6;10492:9;10488:22;10457:63;:::i;:::-;10447:73;;10310:220;10238:299;;;;:::o;10543:262::-;;10651:2;10639:9;10630:7;10626:23;10622:32;10619:2;;;10667:1;10664;10657:12;10619:2;10710:1;10735:53;10780:7;10771:6;10760:9;10756:22;10735:53;:::i;:::-;10725:63;;10681:117;10609:196;;;;:::o;10811:142::-;10914:32;10940:5;10914:32;:::i;:::-;10909:3;10902:45;10892:61;;:::o;10959:118::-;11046:24;11064:5;11046:24;:::i;:::-;11041:3;11034:37;11024:53;;:::o;11083:157::-;11188:45;11208:24;11226:5;11208:24;:::i;:::-;11188:45;:::i;:::-;11183:3;11176:58;11166:74;;:::o;11246:109::-;11327:21;11342:5;11327:21;:::i;:::-;11322:3;11315:34;11305:50;;:::o;11361:118::-;11448:24;11466:5;11448:24;:::i;:::-;11443:3;11436:37;11426:53;;:::o;11485:157::-;11590:45;11610:24;11628:5;11610:24;:::i;:::-;11590:45;:::i;:::-;11585:3;11578:58;11568:74;;:::o;11648:360::-;;11762:38;11794:5;11762:38;:::i;:::-;11816:70;11879:6;11874:3;11816:70;:::i;:::-;11809:77;;11895:52;11940:6;11935:3;11928:4;11921:5;11917:16;11895:52;:::i;:::-;11972:29;11994:6;11972:29;:::i;:::-;11967:3;11963:39;11956:46;;11738:270;;;;;:::o;12014:373::-;;12146:38;12178:5;12146:38;:::i;:::-;12200:88;12281:6;12276:3;12200:88;:::i;:::-;12193:95;;12297:52;12342:6;12337:3;12330:4;12323:5;12319:16;12297:52;:::i;:::-;12374:6;12369:3;12365:16;12358:23;;12122:265;;;;;:::o;12393:364::-;;12509:39;12542:5;12509:39;:::i;:::-;12564:71;12628:6;12623:3;12564:71;:::i;:::-;12557:78;;12644:52;12689:6;12684:3;12677:4;12670:5;12666:16;12644:52;:::i;:::-;12721:29;12743:6;12721:29;:::i;:::-;12716:3;12712:39;12705:46;;12485:272;;;;;:::o;12763:377::-;;12897:39;12930:5;12897:39;:::i;:::-;12952:89;13034:6;13029:3;12952:89;:::i;:::-;12945:96;;13050:52;13095:6;13090:3;13083:4;13076:5;13072:16;13050:52;:::i;:::-;13127:6;13122:3;13118:16;13111:23;;12873:267;;;;;:::o;13146:375::-;;13309:67;13373:2;13368:3;13309:67;:::i;:::-;13302:74;;13406:34;13402:1;13397:3;13393:11;13386:55;13472:13;13467:2;13462:3;13458:12;13451:35;13512:2;13507:3;13503:12;13496:19;;13292:229;;;:::o;13527:318::-;;13690:67;13754:2;13749:3;13690:67;:::i;:::-;13683:74;;13787:22;13783:1;13778:3;13774:11;13767:43;13836:2;13831:3;13827:12;13820:19;;13673:172;;;:::o;13851:382::-;;14014:67;14078:2;14073:3;14014:67;:::i;:::-;14007:74;;14111:34;14107:1;14102:3;14098:11;14091:55;14177:20;14172:2;14167:3;14163:12;14156:42;14224:2;14219:3;14215:12;14208:19;;13997:236;;;:::o;14239:370::-;;14402:67;14466:2;14461:3;14402:67;:::i;:::-;14395:74;;14499:34;14495:1;14490:3;14486:11;14479:55;14565:8;14560:2;14555:3;14551:12;14544:30;14600:2;14595:3;14591:12;14584:19;;14385:224;;;:::o;14615:326::-;;14778:67;14842:2;14837:3;14778:67;:::i;:::-;14771:74;;14875:30;14871:1;14866:3;14862:11;14855:51;14932:2;14927:3;14923:12;14916:19;;14761:180;;;:::o;14947:369::-;;15110:67;15174:2;15169:3;15110:67;:::i;:::-;15103:74;;15207:34;15203:1;15198:3;15194:11;15187:55;15273:7;15268:2;15263:3;15259:12;15252:29;15307:2;15302:3;15298:12;15291:19;;15093:223;;;:::o;15322:326::-;;15485:67;15549:2;15544:3;15485:67;:::i;:::-;15478:74;;15582:30;15578:1;15573:3;15569:11;15562:51;15639:2;15634:3;15630:12;15623:19;;15468:180;;;:::o;15654:396::-;;15835:84;15917:1;15912:3;15835:84;:::i;:::-;15828:91;;15949:66;15945:1;15940:3;15936:11;15929:87;16042:1;16037:3;16033:11;16026:18;;15818:232;;;:::o;16056:368::-;;16219:67;16283:2;16278:3;16219:67;:::i;:::-;16212:74;;16316:34;16312:1;16307:3;16303:11;16296:55;16382:6;16377:2;16372:3;16368:12;16361:28;16415:2;16410:3;16406:12;16399:19;;16202:222;;;:::o;16430:323::-;;16593:67;16657:2;16652:3;16593:67;:::i;:::-;16586:74;;16690:27;16686:1;16681:3;16677:11;16670:48;16744:2;16739:3;16735:12;16728:19;;16576:177;;;:::o;16759:376::-;;16922:67;16986:2;16981:3;16922:67;:::i;:::-;16915:74;;17019:34;17015:1;17010:3;17006:11;16999:55;17085:14;17080:2;17075:3;17071:12;17064:36;17126:2;17121:3;17117:12;17110:19;;16905:230;;;:::o;17141:369::-;;17304:67;17368:2;17363:3;17304:67;:::i;:::-;17297:74;;17401:34;17397:1;17392:3;17388:11;17381:55;17467:7;17462:2;17457:3;17453:12;17446:29;17501:2;17496:3;17492:12;17485:19;;17287:223;;;:::o;17516:314::-;;17679:67;17743:2;17738:3;17679:67;:::i;:::-;17672:74;;17776:18;17772:1;17767:3;17763:11;17756:39;17821:2;17816:3;17812:12;17805:19;;17662:168;;;:::o;17836:388::-;;17999:67;18063:2;18058:3;17999:67;:::i;:::-;17992:74;;18096:34;18092:1;18087:3;18083:11;18076:55;18162:26;18157:2;18152:3;18148:12;18141:48;18215:2;18210:3;18206:12;18199:19;;17982:242;;;:::o;18230:374::-;;18393:67;18457:2;18452:3;18393:67;:::i;:::-;18386:74;;18490:34;18486:1;18481:3;18477:11;18470:55;18556:12;18551:2;18546:3;18542:12;18535:34;18595:2;18590:3;18586:12;18579:19;;18376:228;;;:::o;18610:373::-;;18773:67;18837:2;18832:3;18773:67;:::i;:::-;18766:74;;18870:34;18866:1;18861:3;18857:11;18850:55;18936:11;18931:2;18926:3;18922:12;18915:33;18974:2;18969:3;18965:12;18958:19;;18756:227;;;:::o;18989:330::-;;19152:67;19216:2;19211:3;19152:67;:::i;:::-;19145:74;;19249:34;19245:1;19240:3;19236:11;19229:55;19310:2;19305:3;19301:12;19294:19;;19135:184;;;:::o;19325:376::-;;19488:67;19552:2;19547:3;19488:67;:::i;:::-;19481:74;;19585:34;19581:1;19576:3;19572:11;19565:55;19651:14;19646:2;19641:3;19637:12;19630:36;19692:2;19687:3;19683:12;19676:19;;19471:230;;;:::o;19707:330::-;;19870:67;19934:2;19929:3;19870:67;:::i;:::-;19863:74;;19967:34;19963:1;19958:3;19954:11;19947:55;20028:2;20023:3;20019:12;20012:19;;19853:184;;;:::o;20043:365::-;;20206:67;20270:2;20265:3;20206:67;:::i;:::-;20199:74;;20303:34;20299:1;20294:3;20290:11;20283:55;20369:3;20364:2;20359:3;20355:12;20348:25;20399:2;20394:3;20390:12;20383:19;;20189:219;;;:::o;20414:365::-;;20577:67;20641:2;20636:3;20577:67;:::i;:::-;20570:74;;20674:34;20670:1;20665:3;20661:11;20654:55;20740:3;20735:2;20730:3;20726:12;20719:25;20770:2;20765:3;20761:12;20754:19;;20560:219;;;:::o;20785:381::-;;20948:67;21012:2;21007:3;20948:67;:::i;:::-;20941:74;;21045:34;21041:1;21036:3;21032:11;21025:55;21111:19;21106:2;21101:3;21097:12;21090:41;21157:2;21152:3;21148:12;21141:19;;20931:235;;;:::o;21172:118::-;21259:24;21277:5;21259:24;:::i;:::-;21254:3;21247:37;21237:53;;:::o;21296:112::-;21379:22;21395:5;21379:22;:::i;:::-;21374:3;21367:35;21357:51;;:::o;21414:271::-;;21566:93;21655:3;21646:6;21566:93;:::i;:::-;21559:100;;21676:3;21669:10;;21548:137;;;;:::o;21691:412::-;;21871:93;21960:3;21951:6;21871:93;:::i;:::-;21864:100;;21974:75;22045:3;22036:6;21974:75;:::i;:::-;22074:2;22069:3;22065:12;22058:19;;22094:3;22087:10;;21853:250;;;;;:::o;22109:435::-;;22311:95;22402:3;22393:6;22311:95;:::i;:::-;22304:102;;22423:95;22514:3;22505:6;22423:95;:::i;:::-;22416:102;;22535:3;22528:10;;22293:251;;;;;:::o;22550:663::-;;22813:148;22957:3;22813:148;:::i;:::-;22806:155;;22971:75;23042:3;23033:6;22971:75;:::i;:::-;23071:2;23066:3;23062:12;23055:19;;23084:75;23155:3;23146:6;23084:75;:::i;:::-;23184:2;23179:3;23175:12;23168:19;;23204:3;23197:10;;22795:418;;;;;:::o;23219:222::-;;23350:2;23339:9;23335:18;23327:26;;23363:71;23431:1;23420:9;23416:17;23407:6;23363:71;:::i;:::-;23317:124;;;;:::o;23447:561::-;;23668:2;23657:9;23653:18;23645:26;;23681:71;23749:1;23738:9;23734:17;23725:6;23681:71;:::i;:::-;23762:88;23846:2;23835:9;23831:18;23822:6;23762:88;:::i;:::-;23897:9;23891:4;23887:20;23882:2;23871:9;23867:18;23860:48;23925:76;23996:4;23987:6;23925:76;:::i;:::-;23917:84;;23635:373;;;;;;:::o;24014:640::-;;24247:3;24236:9;24232:19;24224:27;;24261:71;24329:1;24318:9;24314:17;24305:6;24261:71;:::i;:::-;24342:72;24410:2;24399:9;24395:18;24386:6;24342:72;:::i;:::-;24424;24492:2;24481:9;24477:18;24468:6;24424:72;:::i;:::-;24543:9;24537:4;24533:20;24528:2;24517:9;24513:18;24506:48;24571:76;24642:4;24633:6;24571:76;:::i;:::-;24563:84;;24214:440;;;;;;;:::o;24660:210::-;;24785:2;24774:9;24770:18;24762:26;;24798:65;24860:1;24849:9;24845:17;24836:6;24798:65;:::i;:::-;24752:118;;;;:::o;24876:222::-;;25007:2;24996:9;24992:18;24984:26;;25020:71;25088:1;25077:9;25073:17;25064:6;25020:71;:::i;:::-;24974:124;;;;:::o;25104:553::-;;25319:3;25308:9;25304:19;25296:27;;25333:71;25401:1;25390:9;25386:17;25377:6;25333:71;:::i;:::-;25414:72;25482:2;25471:9;25467:18;25458:6;25414:72;:::i;:::-;25496;25564:2;25553:9;25549:18;25540:6;25496:72;:::i;:::-;25578;25646:2;25635:9;25631:18;25622:6;25578:72;:::i;:::-;25286:371;;;;;;;:::o;25663:545::-;;25874:3;25863:9;25859:19;25851:27;;25888:71;25956:1;25945:9;25941:17;25932:6;25888:71;:::i;:::-;25969:68;26033:2;26022:9;26018:18;26009:6;25969:68;:::i;:::-;26047:72;26115:2;26104:9;26100:18;26091:6;26047:72;:::i;:::-;26129;26197:2;26186:9;26182:18;26173:6;26129:72;:::i;:::-;25841:367;;;;;;;:::o;26214:309::-;;26363:2;26352:9;26348:18;26340:26;;26412:9;26406:4;26402:20;26398:1;26387:9;26383:17;26376:47;26440:76;26511:4;26502:6;26440:76;:::i;:::-;26432:84;;26330:193;;;;:::o;26529:313::-;;26680:2;26669:9;26665:18;26657:26;;26729:9;26723:4;26719:20;26715:1;26704:9;26700:17;26693:47;26757:78;26830:4;26821:6;26757:78;:::i;:::-;26749:86;;26647:195;;;;:::o;26848:419::-;;27052:2;27041:9;27037:18;27029:26;;27101:9;27095:4;27091:20;27087:1;27076:9;27072:17;27065:47;27129:131;27255:4;27129:131;:::i;:::-;27121:139;;27019:248;;;:::o;27273:419::-;;27477:2;27466:9;27462:18;27454:26;;27526:9;27520:4;27516:20;27512:1;27501:9;27497:17;27490:47;27554:131;27680:4;27554:131;:::i;:::-;27546:139;;27444:248;;;:::o;27698:419::-;;27902:2;27891:9;27887:18;27879:26;;27951:9;27945:4;27941:20;27937:1;27926:9;27922:17;27915:47;27979:131;28105:4;27979:131;:::i;:::-;27971:139;;27869:248;;;:::o;28123:419::-;;28327:2;28316:9;28312:18;28304:26;;28376:9;28370:4;28366:20;28362:1;28351:9;28347:17;28340:47;28404:131;28530:4;28404:131;:::i;:::-;28396:139;;28294:248;;;:::o;28548:419::-;;28752:2;28741:9;28737:18;28729:26;;28801:9;28795:4;28791:20;28787:1;28776:9;28772:17;28765:47;28829:131;28955:4;28829:131;:::i;:::-;28821:139;;28719:248;;;:::o;28973:419::-;;29177:2;29166:9;29162:18;29154:26;;29226:9;29220:4;29216:20;29212:1;29201:9;29197:17;29190:47;29254:131;29380:4;29254:131;:::i;:::-;29246:139;;29144:248;;;:::o;29398:419::-;;29602:2;29591:9;29587:18;29579:26;;29651:9;29645:4;29641:20;29637:1;29626:9;29622:17;29615:47;29679:131;29805:4;29679:131;:::i;:::-;29671:139;;29569:248;;;:::o;29823:419::-;;30027:2;30016:9;30012:18;30004:26;;30076:9;30070:4;30066:20;30062:1;30051:9;30047:17;30040:47;30104:131;30230:4;30104:131;:::i;:::-;30096:139;;29994:248;;;:::o;30248:419::-;;30452:2;30441:9;30437:18;30429:26;;30501:9;30495:4;30491:20;30487:1;30476:9;30472:17;30465:47;30529:131;30655:4;30529:131;:::i;:::-;30521:139;;30419:248;;;:::o;30673:419::-;;30877:2;30866:9;30862:18;30854:26;;30926:9;30920:4;30916:20;30912:1;30901:9;30897:17;30890:47;30954:131;31080:4;30954:131;:::i;:::-;30946:139;;30844:248;;;:::o;31098:419::-;;31302:2;31291:9;31287:18;31279:26;;31351:9;31345:4;31341:20;31337:1;31326:9;31322:17;31315:47;31379:131;31505:4;31379:131;:::i;:::-;31371:139;;31269:248;;;:::o;31523:419::-;;31727:2;31716:9;31712:18;31704:26;;31776:9;31770:4;31766:20;31762:1;31751:9;31747:17;31740:47;31804:131;31930:4;31804:131;:::i;:::-;31796:139;;31694:248;;;:::o;31948:419::-;;32152:2;32141:9;32137:18;32129:26;;32201:9;32195:4;32191:20;32187:1;32176:9;32172:17;32165:47;32229:131;32355:4;32229:131;:::i;:::-;32221:139;;32119:248;;;:::o;32373:419::-;;32577:2;32566:9;32562:18;32554:26;;32626:9;32620:4;32616:20;32612:1;32601:9;32597:17;32590:47;32654:131;32780:4;32654:131;:::i;:::-;32646:139;;32544:248;;;:::o;32798:419::-;;33002:2;32991:9;32987:18;32979:26;;33051:9;33045:4;33041:20;33037:1;33026:9;33022:17;33015:47;33079:131;33205:4;33079:131;:::i;:::-;33071:139;;32969:248;;;:::o;33223:419::-;;33427:2;33416:9;33412:18;33404:26;;33476:9;33470:4;33466:20;33462:1;33451:9;33447:17;33440:47;33504:131;33630:4;33504:131;:::i;:::-;33496:139;;33394:248;;;:::o;33648:419::-;;33852:2;33841:9;33837:18;33829:26;;33901:9;33895:4;33891:20;33887:1;33876:9;33872:17;33865:47;33929:131;34055:4;33929:131;:::i;:::-;33921:139;;33819:248;;;:::o;34073:419::-;;34277:2;34266:9;34262:18;34254:26;;34326:9;34320:4;34316:20;34312:1;34301:9;34297:17;34290:47;34354:131;34480:4;34354:131;:::i;:::-;34346:139;;34244:248;;;:::o;34498:419::-;;34702:2;34691:9;34687:18;34679:26;;34751:9;34745:4;34741:20;34737:1;34726:9;34722:17;34715:47;34779:131;34905:4;34779:131;:::i;:::-;34771:139;;34669:248;;;:::o;34923:419::-;;35127:2;35116:9;35112:18;35104:26;;35176:9;35170:4;35166:20;35162:1;35151:9;35147:17;35140:47;35204:131;35330:4;35204:131;:::i;:::-;35196:139;;35094:248;;;:::o;35348:419::-;;35552:2;35541:9;35537:18;35529:26;;35601:9;35595:4;35591:20;35587:1;35576:9;35572:17;35565:47;35629:131;35755:4;35629:131;:::i;:::-;35621:139;;35519:248;;;:::o;35773:222::-;;35904:2;35893:9;35889:18;35881:26;;35917:71;35985:1;35974:9;35970:17;35961:6;35917:71;:::i;:::-;35871:124;;;;:::o;36001:283::-;;36067:2;36061:9;36051:19;;36109:4;36101:6;36097:17;36216:6;36204:10;36201:22;36180:18;36168:10;36165:34;36162:62;36159:2;;;36227:18;;:::i;:::-;36159:2;36267:10;36263:2;36256:22;36041:243;;;;:::o;36290:311::-;;36457:18;36449:6;36446:30;36443:2;;;36479:18;;:::i;:::-;36443:2;36529:4;36521:6;36517:17;36509:25;;36589:4;36583;36579:15;36571:23;;36372:229;;;:::o;36607:311::-;;36774:18;36766:6;36763:30;36760:2;;;36796:18;;:::i;:::-;36760:2;36846:4;36838:6;36834:17;36826:25;;36906:4;36900;36896:15;36888:23;;36689:229;;;:::o;36924:331::-;;37075:18;37067:6;37064:30;37061:2;;;37097:18;;:::i;:::-;37061:2;37182:4;37178:9;37171:4;37163:6;37159:17;37155:33;37147:41;;37243:4;37237;37233:15;37225:23;;36990:265;;;:::o;37261:332::-;;37413:18;37405:6;37402:30;37399:2;;;37435:18;;:::i;:::-;37399:2;37520:4;37516:9;37509:4;37501:6;37497:17;37493:33;37485:41;;37581:4;37575;37571:15;37563:23;;37328:265;;;:::o;37599:98::-;;37684:5;37678:12;37668:22;;37657:40;;;:::o;37703:99::-;;37789:5;37783:12;37773:22;;37762:40;;;:::o;37808:168::-;;37925:6;37920:3;37913:19;37965:4;37960:3;37956:14;37941:29;;37903:73;;;;:::o;37982:147::-;;38120:3;38105:18;;38095:34;;;;:::o;38135:169::-;;38253:6;38248:3;38241:19;38293:4;38288:3;38284:14;38269:29;;38231:73;;;;:::o;38310:148::-;;38449:3;38434:18;;38424:34;;;;:::o;38464:305::-;;38523:20;38541:1;38523:20;:::i;:::-;38518:25;;38557:20;38575:1;38557:20;:::i;:::-;38552:25;;38711:1;38643:66;38639:74;38636:1;38633:81;38630:2;;;38717:18;;:::i;:::-;38630:2;38761:1;38758;38754:9;38747:16;;38508:261;;;;:::o;38775:185::-;;38832:20;38850:1;38832:20;:::i;:::-;38827:25;;38866:20;38884:1;38866:20;:::i;:::-;38861:25;;38905:1;38895:2;;38910:18;;:::i;:::-;38895:2;38952:1;38949;38945:9;38940:14;;38817:143;;;;:::o;38966:191::-;;39026:20;39044:1;39026:20;:::i;:::-;39021:25;;39060:20;39078:1;39060:20;:::i;:::-;39055:25;;39099:1;39096;39093:8;39090:2;;;39104:18;;:::i;:::-;39090:2;39149:1;39146;39142:9;39134:17;;39011:146;;;;:::o;39163:96::-;;39229:24;39247:5;39229:24;:::i;:::-;39218:35;;39208:51;;;:::o;39265:104::-;;39339:24;39357:5;39339:24;:::i;:::-;39328:35;;39318:51;;;:::o;39375:90::-;;39452:5;39445:13;39438:21;39427:32;;39417:48;;;:::o;39471:77::-;;39537:5;39526:16;;39516:32;;;:::o;39554:149::-;;39630:66;39623:5;39619:78;39608:89;;39598:105;;;:::o;39709:125::-;;39804:24;39822:5;39804:24;:::i;:::-;39793:35;;39783:51;;;:::o;39840:126::-;;39917:42;39910:5;39906:54;39895:65;;39885:81;;;:::o;39972:77::-;;40038:5;40027:16;;40017:32;;;:::o;40055:86::-;;40130:4;40123:5;40119:16;40108:27;;40098:43;;;:::o;40147:154::-;40231:6;40226:3;40221;40208:30;40293:1;40284:6;40279:3;40275:16;40268:27;40198:103;;;:::o;40307:307::-;40375:1;40385:113;40399:6;40396:1;40393:13;40385:113;;;40484:1;40479:3;40475:11;40469:18;40465:1;40460:3;40456:11;40449:39;40421:2;40418:1;40414:10;40409:15;;40385:113;;;40516:6;40513:1;40510:13;40507:2;;;40596:1;40587:6;40582:3;40578:16;40571:27;40507:2;40356:258;;;;:::o;40620:320::-;;40701:1;40695:4;40691:12;40681:22;;40748:1;40742:4;40738:12;40769:18;40759:2;;40825:4;40817:6;40813:17;40803:27;;40759:2;40887;40879:6;40876:14;40856:18;40853:38;40850:2;;;40906:18;;:::i;:::-;40850:2;40671:269;;;;:::o;40946:233::-;;41008:24;41026:5;41008:24;:::i;:::-;40999:33;;41054:66;41047:5;41044:77;41041:2;;;41124:18;;:::i;:::-;41041:2;41171:1;41164:5;41160:13;41153:20;;40989:190;;;:::o;41185:100::-;;41253:26;41273:5;41253:26;:::i;:::-;41242:37;;41232:53;;;:::o;41291:79::-;;41359:5;41348:16;;41338:32;;;:::o;41376:94::-;;41444:20;41458:5;41444:20;:::i;:::-;41433:31;;41423:47;;;:::o;41476:176::-;;41525:20;41543:1;41525:20;:::i;:::-;41520:25;;41559:20;41577:1;41559:20;:::i;:::-;41554:25;;41598:1;41588:2;;41603:18;;:::i;:::-;41588:2;41644:1;41641;41637:9;41632:14;;41510:142;;;;:::o;41658:180::-;41706:77;41703:1;41696:88;41803:4;41800:1;41793:15;41827:4;41824:1;41817:15;41844:180;41892:77;41889:1;41882:88;41989:4;41986:1;41979:15;42013:4;42010:1;42003:15;42030:180;42078:77;42075:1;42068:88;42175:4;42172:1;42165:15;42199:4;42196:1;42189:15;42216:180;42264:77;42261:1;42254:88;42361:4;42358:1;42351:15;42385:4;42382:1;42375:15;42402:102;;42494:2;42490:7;42485:2;42478:5;42474:14;42470:28;42460:38;;42450:54;;;:::o;42510:94::-;;42591:5;42587:2;42583:14;42562:35;;42552:52;;;:::o;42610:122::-;42683:24;42701:5;42683:24;:::i;:::-;42676:5;42673:35;42663:2;;42722:1;42719;42712:12;42663:2;42653:79;:::o;42738:116::-;42808:21;42823:5;42808:21;:::i;:::-;42801:5;42798:32;42788:2;;42844:1;42841;42834:12;42788:2;42778:76;:::o;42860:122::-;42933:24;42951:5;42933:24;:::i;:::-;42926:5;42923:35;42913:2;;42972:1;42969;42962:12;42913:2;42903:79;:::o;42988:120::-;43060:23;43077:5;43060:23;:::i;:::-;43053:5;43050:34;43040:2;;43098:1;43095;43088:12;43040:2;43030:78;:::o;43114:180::-;43216:53;43263:5;43216:53;:::i;:::-;43209:5;43206:64;43196:2;;43284:1;43281;43274:12;43196:2;43186:108;:::o;43300:122::-;43373:24;43391:5;43373:24;:::i;:::-;43366:5;43363:35;43353:2;;43412:1;43409;43402:12;43353:2;43343:79;:::o;43428:118::-;43499:22;43515:5;43499:22;:::i;:::-;43492:5;43489:33;43479:2;;43536:1;43533;43526:12;43479:2;43469:77;:::o

Swarm Source

ipfs://649bb3451d4f010255fe4776aa9b4fe3bd596195454bddce82f8575ec9da2774

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