Token

rabbidrabbits (RBR)

ERC-721

Overview

Max Total Supply

91 RBR

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x4389738340eac4ea9425d373da3c1faaddc7ce57

Filtered by Token Holder

0x7bDBB59655E2800363a5DC26efBF26Da29eD9626

Balance

1 RBR

0x7bdbb59655e2800363a5dc26efbf26da29ed9626

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

RabbidRabbits

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-08-29
*/

/**
 *Submitted for verification at Etherscan.io on 2021-08-28
*/

// SPDX-License-Identifier: MIT

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

pragma solidity >=0.6.0 <0.8.0;

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

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

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



pragma solidity >=0.6.0 <0.8.0;

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

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



pragma solidity >=0.6.2 <0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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



pragma solidity >=0.6.2 <0.8.0;


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

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

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

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

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



pragma solidity >=0.6.2 <0.8.0;


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

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

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

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

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



pragma solidity >=0.6.0 <0.8.0;

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

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



pragma solidity >=0.6.0 <0.8.0;


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

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

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

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

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

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



pragma solidity >=0.6.0 <0.8.0;

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

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



pragma solidity >=0.6.2 <0.8.0;

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

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

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



pragma solidity >=0.6.0 <0.8.0;

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

    struct Set {
        // Storage of set values
        bytes32[] _values;

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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



pragma solidity >=0.6.0 <0.8.0;

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

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping (bytes32 => uint256) _indexes;
    }

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

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

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

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

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

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

            MapEntry storage lastEntry = map._entries[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        uint256 keyIndex = map._indexes[key];
        if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key)
        return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

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

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

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

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

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

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

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

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
    }
}

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



pragma solidity >=0.6.0 <0.8.0;

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

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

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



pragma solidity >=0.6.0 <0.8.0;

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */

contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

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

    // Mapping from holder address to their (enumerable) set of owned tokens
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

    // Base URI
    string private _baseURI;

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

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

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

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

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

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

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

    /**
     * @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 _tokenURI = _tokenURIs[tokenId];
        string memory base = baseURI();

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

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

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

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

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

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

        require(_msgSender() == owner || ERC721.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 {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

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

    /**
     * @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 || ERC721.isApprovedForAll(owner, spender));
    }

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

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

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

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

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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

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

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

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

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

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

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

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

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

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

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

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

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

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



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

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




// website (https://rabbidrabbits.io)




pragma solidity ^0.7.0;
pragma abicoder v2;

contract RabbidRabbits is ERC721, Ownable {
    using SafeMath for uint256;
    uint256 public rabbidRabbitsPrice = 30000000000000000; // 0.03 ETH
    uint public constant maxRabbidRabbitsPurchase = 10;
    uint256 public constant MaxRabbidRabbits = 9999;
    bool public saleIsActive = false;
    mapping(uint => string) public rabbidRabbitsNames;
    uint public rabbidRabbitsReserve = 100; // for events and giveaways
    event rabbidRabbitsNameChange(address _by, uint _tokenId, string _name);
    constructor() ERC721("rabbidrabbits", "RBR") {}
    function withdraw() public onlyOwner {
        uint balance = address(this).balance;
        msg.sender.transfer(balance);
    }

    function _Price(uint256 newPrice) public onlyOwner {
        rabbidRabbitsPrice = newPrice;
    }

    function mintRabbidRabbits(uint numberOfTokens) public payable {
        require(saleIsActive, "Sale must be active to mint Rabbid Rabbits");
        require(numberOfTokens > 0 && numberOfTokens <= maxRabbidRabbitsPurchase, "Can only mint 10 tokens at a time");
        require(totalSupply().add(numberOfTokens) <= MaxRabbidRabbits, "Purchase would exceed max supply of Rabbid Rabbits");
        require(msg.value >= rabbidRabbitsPrice.mul(numberOfTokens), "Ether value sent is not correct");
        for(uint i = 0; i < numberOfTokens; i++) {
            uint mintIndex = totalSupply();
            if (totalSupply() < MaxRabbidRabbits) {
                _safeMint(msg.sender, mintIndex);
            }
        }
    }

    function changeRabbidRabbitName(uint _tokenId, string memory _name) public {
        require(ownerOf(_tokenId) == msg.sender, "Hey, your wallet doesn't own this Rabbid Rabbit!");
        require(sha256(bytes(_name)) != sha256(bytes(rabbidRabbitsNames[_tokenId])), "New name is same as the current one");
        rabbidRabbitsNames[_tokenId] = _name;
        emit rabbidRabbitsNameChange(msg.sender, _tokenId, _name);
    }

    function viewRabbidRabbitName(uint _tokenId) public view returns( string memory ){
        require( _tokenId < totalSupply(), "Choose a Rabbid Rabbit within range" );
        return rabbidRabbitsNames[_tokenId];
    }

    function rabbidRabbitsNamesOfOwner(address _owner) external view returns(string[] memory ) {
        uint256 tokenCount = balanceOf(_owner);
        if (tokenCount == 0) {
            // Return an empty array
            return new string[](0);
        } else {
            string[] memory result = new string[](tokenCount);
            uint256 index;
            for (index = 0; index < tokenCount; index++) {
                result[index] = rabbidRabbitsNames[ tokenOfOwnerByIndex(_owner, index) ] ;
            }
            return result;
        }
    }

    function reserveRabbidRabbits(address _to, uint256 _reserveAmount) public onlyOwner {
        uint supply = totalSupply();
        require(_reserveAmount > 0 && _reserveAmount <= rabbidRabbitsReserve, "Not enough reserve left for team");
        for (uint i = 0; i < _reserveAmount; i++) {
            _safeMint(_to, supply + i);
        }
        rabbidRabbitsReserve = rabbidRabbitsReserve.sub(_reserveAmount);
    }

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

    function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
        uint256 tokenCount = balanceOf(_owner);
        if (tokenCount == 0) {
            return new uint256[](0);
        } else {
            uint256[] memory result = new uint256[](tokenCount);
            uint256 index;
            for (index = 0; index < tokenCount; index++) {
                result[index] = tokenOfOwnerByIndex(_owner, index);
            }
            return result;
        }
    }

    function flipSaleState() public onlyOwner {
        saleIsActive = !saleIsActive;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_by","type":"address"},{"indexed":false,"internalType":"uint256","name":"_tokenId","type":"uint256"},{"indexed":false,"internalType":"string","name":"_name","type":"string"}],"name":"rabbidRabbitsNameChange","type":"event"},{"inputs":[],"name":"MaxRabbidRabbits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"_Price","outputs":[],"stateMutability":"nonpayable","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":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"string","name":"_name","type":"string"}],"name":"changeRabbidRabbitName","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"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":"maxRabbidRabbitsPurchase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mintRabbidRabbits","outputs":[],"stateMutability":"payable","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":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rabbidRabbitsNames","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"rabbidRabbitsNamesOfOwner","outputs":[{"internalType":"string[]","name":"","type":"string[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rabbidRabbitsPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rabbidRabbitsReserve","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_reserveAmount","type":"uint256"}],"name":"reserveRabbidRabbits","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":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"viewRabbidRabbitName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

6080604052666a94d74f430000600b55600c805460ff191690556064600e553480156200002b57600080fd5b50604080518082018252600d81526c7261626269647261626269747360981b6020808301919091528251808401909352600383526229212960e91b90830152906200007d6301ffc9a760e01b62000142565b815162000092906006906020850190620001a1565b508051620000a8906007906020840190620001a1565b50620000bb6380ac58cd60e01b62000142565b620000cd635b5e139f60e01b62000142565b620000df63780e9d6360e01b62000142565b5060009050620000ee6200019d565b600a80546001600160a01b0319166001600160a01b038316908117909155604051919250906000907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a35062000284565b6001600160e01b03198082161415620001785760405162461bcd60e51b81526004016200016f906200024d565b60405180910390fd5b6001600160e01b0319166000908152602081905260409020805460ff19166001179055565b3390565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282620001d9576000855562000224565b82601f10620001f457805160ff191683800117855562000224565b8280016001018555821562000224579182015b828111156200022457825182559160200191906001019062000207565b506200023292915062000236565b5090565b5b8082111562000232576000815560010162000237565b6020808252601c908201527f4552433136353a20696e76616c696420696e7465726661636520696400000000604082015260600190565b612d8580620002946000396000f3fe60806040526004361061020f5760003560e01c8063715018a611610118578063b9481eb8116100a0578063e499e6401161006f578063e499e640146105c7578063e985e9c5146105dc578063eb8d2444146105fc578063f2fde38b14610611578063f80b3476146106315761020f565b8063b9481eb81461053a578063c5bdec341461055a578063c87b56dd1461057a578063cae0b8011461059a5761020f565b80638da5cb5b116100e75780638da5cb5b146104bb5780639491557e146104d057806395d89b41146104e5578063a22cb465146104fa578063b88d4fde1461051a5761020f565b8063715018a614610444578063725da359146104595780637dbb93ca1461046e5780638462151c1461048e5761020f565b806334fee8c71161019b57806355f804b31161016a57806355f804b3146103bc5780635dd98951146103dc5780636352211e146103ef5780636c0360eb1461040f57806370a08231146104245761020f565b806334fee8c7146103525780633ccfd60b1461036757806342842e0e1461037c5780634f6ccce71461039c5761020f565b80631049b6d2116101e25780631049b6d2146102bb57806318160ddd146102db57806323b872dd146102fd5780632f745c591461031d57806334918dfd1461033d5761020f565b806301ffc9a71461021457806306fdde031461024a578063081812fc1461026c578063095ea7b314610299575b600080fd5b34801561022057600080fd5b5061023461022f366004612211565b610651565b60405161024191906124e5565b60405180910390f35b34801561025657600080fd5b5061025f610674565b60405161024191906124f0565b34801561027857600080fd5b5061028c61028736600461227c565b61070a565b60405161024191906123c0565b3480156102a557600080fd5b506102b96102b43660046121d0565b610756565b005b3480156102c757600080fd5b5061025f6102d636600461227c565b6107ee565b3480156102e757600080fd5b506102f0610889565b6040516102419190612ca9565b34801561030957600080fd5b506102b96103183660046120e2565b61089a565b34801561032957600080fd5b506102f06103383660046121d0565b6108d2565b34801561034957600080fd5b506102b96108fd565b34801561035e57600080fd5b506102f0610950565b34801561037357600080fd5b506102b9610956565b34801561038857600080fd5b506102b96103973660046120e2565b6109c8565b3480156103a857600080fd5b506102f06103b736600461227c565b6109e3565b3480156103c857600080fd5b506102b96103d7366004612249565b6109f9565b6102b96103ea36600461227c565b610a44565b3480156103fb57600080fd5b5061028c61040a36600461227c565b610b2d565b34801561041b57600080fd5b5061025f610b55565b34801561043057600080fd5b506102f061043f366004612096565b610bb6565b34801561045057600080fd5b506102b9610bff565b34801561046557600080fd5b506102f0610c88565b34801561047a57600080fd5b506102b9610489366004612294565b610c8e565b34801561049a57600080fd5b506104ae6104a9366004612096565b610de9565b60405161024191906124a1565b3480156104c757600080fd5b5061028c610e9c565b3480156104dc57600080fd5b506102f0610eab565b3480156104f157600080fd5b5061025f610eb0565b34801561050657600080fd5b506102b9610515366004612196565b610f11565b34801561052657600080fd5b506102b961053536600461211d565b610fdf565b34801561054657600080fd5b506102b96105553660046121d0565b61101e565b34801561056657600080fd5b506102b961057536600461227c565b6110cc565b34801561058657600080fd5b5061025f61059536600461227c565b611110565b3480156105a657600080fd5b506105ba6105b5366004612096565b611254565b6040516102419190612441565b3480156105d357600080fd5b506102f06113bd565b3480156105e857600080fd5b506102346105f73660046120b0565b6113c3565b34801561060857600080fd5b506102346113f1565b34801561061d57600080fd5b506102b961062c366004612096565b6113fa565b34801561063d57600080fd5b5061025f61064c36600461227c565b6114bb565b6001600160e01b0319811660009081526020819052604090205460ff165b919050565b60068054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156107005780601f106106d557610100808354040283529160200191610700565b820191906000526020600020905b8154815290600101906020018083116106e357829003601f168201915b5050505050905090565b600061071582611582565b61073a5760405162461bcd60e51b815260040161073190612a00565b60405180910390fd5b506000908152600460205260409020546001600160a01b031690565b600061076182610b2d565b9050806001600160a01b0316836001600160a01b031614156107955760405162461bcd60e51b815260040161073190612b5c565b806001600160a01b03166107a761158f565b6001600160a01b031614806107c357506107c3816105f761158f565b6107df5760405162461bcd60e51b815260040161073190612857565b6107e98383611593565b505050565b600d6020908152600091825260409182902080548351601f6002600019610100600186161502019093169290920491820184900484028101840190945280845290918301828280156108815780601f1061085657610100808354040283529160200191610881565b820191906000526020600020905b81548152906001019060200180831161086457829003601f168201915b505050505081565b60006108956002611601565b905090565b6108ab6108a561158f565b8261160c565b6108c75760405162461bcd60e51b815260040161073190612b9d565b6107e9838383611691565b6001600160a01b03821660009081526001602052604081206108f4908361179f565b90505b92915050565b61090561158f565b6001600160a01b0316610916610e9c565b6001600160a01b03161461093c5760405162461bcd60e51b815260040161073190612a4c565b600c805460ff19811660ff90911615179055565b600e5481565b61095e61158f565b6001600160a01b031661096f610e9c565b6001600160a01b0316146109955760405162461bcd60e51b815260040161073190612a4c565b6040514790339082156108fc029083906000818181858888f193505050501580156109c4573d6000803e3d6000fd5b5050565b6107e983838360405180602001604052806000815250610fdf565b6000806109f16002846117ab565b509392505050565b610a0161158f565b6001600160a01b0316610a12610e9c565b6001600160a01b031614610a385760405162461bcd60e51b815260040161073190612a4c565b610a41816117c7565b50565b600c5460ff16610a665760405162461bcd60e51b8152600401610731906128fe565b600081118015610a775750600a8111155b610a935760405162461bcd60e51b815260040161073190612c68565b61270f610aa882610aa2610889565b906117da565b1115610ac65760405162461bcd60e51b8152600401610731906125e7565b600b54610ad390826117ff565b341015610af25760405162461bcd60e51b81526004016107319061279d565b60005b818110156109c4576000610b07610889565b905061270f610b14610889565b1015610b2457610b243382611839565b50600101610af5565b60006108f782604051806060016040528060298152602001612d276029913960029190611853565b60098054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156107005780601f106106d557610100808354040283529160200191610700565b60006001600160a01b038216610bde5760405162461bcd60e51b8152600401610731906128b4565b6001600160a01b03821660009081526001602052604090206108f790611601565b610c0761158f565b6001600160a01b0316610c18610e9c565b6001600160a01b031614610c3e5760405162461bcd60e51b815260040161073190612a4c565b600a546040516000916001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600a80546001600160a01b0319169055565b600b5481565b33610c9883610b2d565b6001600160a01b031614610cbe5760405162461bcd60e51b815260040161073190612545565b6000828152600d6020526040908190209051600291610cdc91612321565b602060405180830381855afa158015610cf9573d6000803e3d6000fd5b5050506040513d601f19601f82011682018060405250810190610d1c91906121f9565b600282604051610d2c9190612305565b602060405180830381855afa158015610d49573d6000803e3d6000fd5b5050506040513d601f19601f82011682018060405250810190610d6c91906121f9565b1415610d8a5760405162461bcd60e51b815260040161073190612b19565b6000828152600d602090815260409091208251610da992840190611f5b565b507fcb866f53962bb61282203cbee1f0fefe40910947706c3a7a9d4199d25f4d3079338383604051610ddd93929190612411565b60405180910390a15050565b60606000610df683610bb6565b905080610e185760408051600080825260208201909252905b5091505061066f565b60008167ffffffffffffffff81118015610e3157600080fd5b50604051908082528060200260200182016040528015610e5b578160200160208202803683370190505b50905060005b82811015610e9257610e7385826108d2565b828281518110610e7f57fe5b6020908102919091010152600101610e61565b50915061066f9050565b600a546001600160a01b031690565b600a81565b60078054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156107005780601f106106d557610100808354040283529160200191610700565b610f1961158f565b6001600160a01b0316826001600160a01b03161415610f4a5760405162461bcd60e51b815260040161073190612766565b8060056000610f5761158f565b6001600160a01b03908116825260208083019390935260409182016000908120918716808252919093529120805460ff191692151592909217909155610f9b61158f565b6001600160a01b03167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3183604051610fd391906124e5565b60405180910390a35050565b610ff0610fea61158f565b8361160c565b61100c5760405162461bcd60e51b815260040161073190612b9d565b6110188484848461186a565b50505050565b61102661158f565b6001600160a01b0316611037610e9c565b6001600160a01b03161461105d5760405162461bcd60e51b815260040161073190612a4c565b6000611067610889565b905060008211801561107b5750600e548211155b6110975760405162461bcd60e51b8152600401610731906126ed565b60005b828110156110b6576110ae84828401611839565b60010161109a565b50600e546110c4908361189d565b600e55505050565b6110d461158f565b6001600160a01b03166110e5610e9c565b6001600160a01b03161461110b5760405162461bcd60e51b815260040161073190612a4c565b600b55565b606061111b82611582565b6111375760405162461bcd60e51b815260040161073190612aca565b60008281526008602090815260408083208054825160026001831615610100026000190190921691909104601f8101859004850282018501909352828152929091908301828280156111ca5780601f1061119f576101008083540402835291602001916111ca565b820191906000526020600020905b8154815290600101906020018083116111ad57829003601f168201915b5050505050905060006111db610b55565b90508051600014156111ef5750905061066f565b815115611221578082604051602001611209929190612391565b6040516020818303038152906040529250505061066f565b8061122b856118c5565b60405160200161123c929190612391565b60405160208183030381529060405292505050919050565b6060600061126183610bb6565b90508061129b576040805160008082526020820190925290610e0f565b606081526020019060019003908161127e5790505091505061066f565b60008167ffffffffffffffff811180156112b457600080fd5b506040519080825280602002602001820160405280156112e857816020015b60608152602001906001900390816112d35790505b50905060005b82811015610e9257600d600061130487846108d2565b815260208082019290925260409081016000208054825160026001831615610100026000190190921691909104601f8101859004850282018501909352828152929091908301828280156113995780601f1061136e57610100808354040283529160200191611399565b820191906000526020600020905b81548152906001019060200180831161137c57829003601f168201915b50505050508282815181106113aa57fe5b60209081029190910101526001016112ee565b61270f81565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b600c5460ff1681565b61140261158f565b6001600160a01b0316611413610e9c565b6001600160a01b0316146114395760405162461bcd60e51b815260040161073190612a4c565b6001600160a01b03811661145f5760405162461bcd60e51b815260040161073190612639565b600a546040516001600160a01b038084169216907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3600a80546001600160a01b0319166001600160a01b0392909216919091179055565b60606114c5610889565b82106114e35760405162461bcd60e51b815260040161073190612c25565b6000828152600d602090815260409182902080548351601f6002600019610100600186161502019093169290920491820184900484028101840190945280845290918301828280156115765780601f1061154b57610100808354040283529160200191611576565b820191906000526020600020905b81548152906001019060200180831161155957829003601f168201915b50505050509050919050565b60006108f76002836119a0565b3390565b600081815260046020526040902080546001600160a01b0319166001600160a01b03841690811790915581906115c882610b2d565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b60006108f7826119ac565b600061161782611582565b6116335760405162461bcd60e51b81526004016107319061280b565b600061163e83610b2d565b9050806001600160a01b0316846001600160a01b031614806116795750836001600160a01b031661166e8461070a565b6001600160a01b0316145b80611689575061168981856113c3565b949350505050565b826001600160a01b03166116a482610b2d565b6001600160a01b0316146116ca5760405162461bcd60e51b815260040161073190612a81565b6001600160a01b0382166116f05760405162461bcd60e51b815260040161073190612722565b6116fb8383836107e9565b611706600082611593565b6001600160a01b038316600090815260016020526040902061172890826119b0565b506001600160a01b038216600090815260016020526040902061174b90826119bc565b50611758600282846119c8565b5080826001600160a01b0316846001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4505050565b60006108f483836119de565b60008080806117ba8686611a23565b9097909650945050505050565b80516109c4906009906020840190611f5b565b6000828201838110156108f45760405162461bcd60e51b8152600401610731906126b6565b60008261180e575060006108f7565b8282028284828161181b57fe5b04146108f45760405162461bcd60e51b8152600401610731906129bf565b6109c4828260405180602001604052806000815250611a7f565b6000611860848484611ab2565b90505b9392505050565b611875848484611691565b61188184848484611b11565b6110185760405162461bcd60e51b815260040161073190612595565b6000828211156118bf5760405162461bcd60e51b8152600401610731906127d4565b50900390565b6060816118ea57506040805180820190915260018152600360fc1b602082015261066f565b8160005b811561190257600101600a820491506118ee565b60008167ffffffffffffffff8111801561191b57600080fd5b506040519080825280601f01601f191660200182016040528015611946576020820181803683370190505b50859350905060001982015b831561199757600a840660300160f81b8282806001900393508151811061197557fe5b60200101906001600160f81b031916908160001a905350600a84049350611952565b50949350505050565b60006108f48383611bf0565b5490565b60006108f48383611c08565b60006108f48383611cce565b600061186084846001600160a01b038516611d18565b81546000908210611a015760405162461bcd60e51b815260040161073190612503565b826000018281548110611a1057fe5b9060005260206000200154905092915050565b815460009081908310611a485760405162461bcd60e51b815260040161073190612948565b6000846000018481548110611a5957fe5b906000526020600020906002020190508060000154816001015492509250509250929050565b611a898383611daf565b611a966000848484611b11565b6107e95760405162461bcd60e51b815260040161073190612595565b60008281526001840160205260408120548281611ae25760405162461bcd60e51b815260040161073191906124f0565b50846000016001820381548110611af557fe5b9060005260206000209060020201600101549150509392505050565b6000611b25846001600160a01b0316611e73565b611b3157506001611689565b6000611bb9630a85bd0160e11b611b4661158f565b888787604051602401611b5c94939291906123d4565b604051602081830303815290604052906001600160e01b0319166020820180516001600160e01b038381831617835250505050604051806060016040528060328152602001612cf5603291396001600160a01b0388169190611e79565b9050600081806020019051810190611bd1919061222d565b6001600160e01b031916630a85bd0160e11b1492505050949350505050565b60009081526001919091016020526040902054151590565b60008181526001830160205260408120548015611cc45783546000198083019190810190600090879083908110611c3b57fe5b9060005260206000200154905080876000018481548110611c5857fe5b600091825260208083209091019290925582815260018981019092526040902090840190558654879080611c8857fe5b600190038181906000526020600020016000905590558660010160008781526020019081526020016000206000905560019450505050506108f7565b60009150506108f7565b6000611cda8383611bf0565b611d10575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556108f7565b5060006108f7565b600082815260018401602052604081205480611d7d575050604080518082018252838152602080820184815286546001818101895560008981528481209551600290930290950191825591519082015586548684528188019092529290912055611863565b82856000016001830381548110611d9057fe5b9060005260206000209060020201600101819055506000915050611863565b6001600160a01b038216611dd55760405162461bcd60e51b81526004016107319061298a565b611dde81611582565b15611dfb5760405162461bcd60e51b81526004016107319061267f565b611e07600083836107e9565b6001600160a01b0382166000908152600160205260409020611e2990826119bc565b50611e36600282846119c8565b5060405181906001600160a01b038416906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b3b151590565b6060611860848460008585611e8d85611e73565b611ea95760405162461bcd60e51b815260040161073190612bee565b600080866001600160a01b03168587604051611ec59190612305565b60006040518083038185875af1925050503d8060008114611f02576040519150601f19603f3d011682016040523d82523d6000602084013e611f07565b606091505b5091509150611f17828286611f22565b979650505050505050565b60608315611f31575081611863565b825115611f415782518084602001fd5b8160405162461bcd60e51b815260040161073191906124f0565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282611f915760008555611fd7565b82601f10611faa57805160ff1916838001178555611fd7565b82800160010185558215611fd7579182015b82811115611fd7578251825591602001919060010190611fbc565b50611fe3929150611fe7565b5090565b5b80821115611fe35760008155600101611fe8565b600067ffffffffffffffff8084111561201157fe5b604051601f8501601f19168101602001828111828210171561202f57fe5b60405284815291508183850186101561204757600080fd5b8484602083013760006020868301015250509392505050565b80356001600160a01b038116811461066f57600080fd5b600082601f830112612087578081fd5b6108f483833560208501611ffc565b6000602082840312156120a7578081fd5b6108f482612060565b600080604083850312156120c2578081fd5b6120cb83612060565b91506120d960208401612060565b90509250929050565b6000806000606084860312156120f6578081fd5b6120ff84612060565b925061210d60208501612060565b9150604084013590509250925092565b60008060008060808587031215612132578081fd5b61213b85612060565b935061214960208601612060565b925060408501359150606085013567ffffffffffffffff81111561216b578182fd5b8501601f8101871361217b578182fd5b61218a87823560208401611ffc565b91505092959194509250565b600080604083850312156121a8578182fd5b6121b183612060565b9150602083013580151581146121c5578182fd5b809150509250929050565b600080604083850312156121e2578182fd5b6121eb83612060565b946020939093013593505050565b60006020828403121561220a578081fd5b5051919050565b600060208284031215612222578081fd5b81356108f481612cde565b60006020828403121561223e578081fd5b81516108f481612cde565b60006020828403121561225a578081fd5b813567ffffffffffffffff811115612270578182fd5b61168984828501612077565b60006020828403121561228d578081fd5b5035919050565b600080604083850312156122a6578182fd5b82359150602083013567ffffffffffffffff8111156122c3578182fd5b6122cf85828601612077565b9150509250929050565b600081518084526122f1816020860160208601612cb2565b601f01601f19169290920160200192915050565b60008251612317818460208701612cb2565b9190910192915050565b6000808354600180821660008114612340576001811461235757612386565b60ff198316865260028304607f1686019350612386565b600283048786526020808720875b8381101561237e5781548a820152908501908201612365565b505050860193505b509195945050505050565b600083516123a3818460208801612cb2565b8351908301906123b7818360208801612cb2565b01949350505050565b6001600160a01b0391909116815260200190565b6001600160a01b0385811682528416602082015260408101839052608060608201819052600090612407908301846122d9565b9695505050505050565b600060018060a01b03851682528360208301526060604083015261243860608301846122d9565b95945050505050565b6000602080830181845280855180835260408601915060408482028701019250838701855b8281101561249457603f198886030184526124828583516122d9565b94509285019290850190600101612466565b5092979650505050505050565b6020808252825182820181905260009190848201906040850190845b818110156124d9578351835292840192918401916001016124bd565b50909695505050505050565b901515815260200190565b6000602082526108f460208301846122d9565b60208082526022908201527f456e756d657261626c655365743a20696e646578206f7574206f6620626f756e604082015261647360f01b606082015260800190565b60208082526030908201527f4865792c20796f75722077616c6c657420646f65736e2774206f776e2074686960408201526f7320526162626964205261626269742160801b606082015260800190565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b60208082526032908201527f507572636861736520776f756c6420657863656564206d617820737570706c79604082015271206f6620526162626964205261626269747360701b606082015260800190565b60208082526026908201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160408201526564647265737360d01b606082015260800190565b6020808252601c908201527f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000604082015260600190565b6020808252601b908201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604082015260600190565b6020808252818101527f4e6f7420656e6f7567682072657365727665206c65667420666f72207465616d604082015260600190565b60208082526024908201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646040820152637265737360e01b606082015260800190565b60208082526019908201527f4552433732313a20617070726f766520746f2063616c6c657200000000000000604082015260600190565b6020808252601f908201527f45746865722076616c75652073656e74206973206e6f7420636f727265637400604082015260600190565b6020808252601e908201527f536166654d6174683a207375627472616374696f6e206f766572666c6f770000604082015260600190565b6020808252602c908201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860408201526b34b9ba32b73a103a37b5b2b760a11b606082015260800190565b60208082526038908201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760408201527f6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000606082015260800190565b6020808252602a908201527f4552433732313a2062616c616e636520717565727920666f7220746865207a65604082015269726f206164647265737360b01b606082015260800190565b6020808252602a908201527f53616c65206d7573742062652061637469766520746f206d696e7420526162626040820152696964205261626269747360b01b606082015260800190565b60208082526022908201527f456e756d657261626c654d61703a20696e646578206f7574206f6620626f756e604082015261647360f01b606082015260800190565b6020808252818101527f4552433732313a206d696e7420746f20746865207a65726f2061646472657373604082015260600190565b60208082526021908201527f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f6040820152607760f81b606082015260800190565b6020808252602c908201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860408201526b34b9ba32b73a103a37b5b2b760a11b606082015260800190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526029908201527f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960408201526839903737ba1037bbb760b91b606082015260800190565b6020808252602f908201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60408201526e3732bc34b9ba32b73a103a37b5b2b760891b606082015260800190565b60208082526023908201527f4e6577206e616d652069732073616d65206173207468652063757272656e74206040820152626f6e6560e81b606082015260800190565b60208082526021908201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656040820152603960f91b606082015260800190565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f6040820152701ddb995c881b9bdc88185c1c1c9bdd9959607a1b606082015260800190565b6020808252601d908201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604082015260600190565b60208082526023908201527f43686f6f7365206120526162626964205261626269742077697468696e2072616040820152626e676560e81b606082015260800190565b60208082526021908201527f43616e206f6e6c79206d696e7420313020746f6b656e7320617420612074696d6040820152606560f81b606082015260800190565b90815260200190565b60005b83811015612ccd578181015183820152602001612cb5565b838111156110185750506000910152565b6001600160e01b031981168114610a4157600080fdfe4552433732313a207472616e7366657220746f206e6f6e20455243373231526563656976657220696d706c656d656e7465724552433732313a206f776e657220717565727920666f72206e6f6e6578697374656e7420746f6b656ea2646970667358221220dbb33c94e3117fdd620079752eb3939017e2117409038f0e891bfd9c661527f464736f6c63430007060033

Deployed Bytecode

0x60806040526004361061020f5760003560e01c8063715018a611610118578063b9481eb8116100a0578063e499e6401161006f578063e499e640146105c7578063e985e9c5146105dc578063eb8d2444146105fc578063f2fde38b14610611578063f80b3476146106315761020f565b8063b9481eb81461053a578063c5bdec341461055a578063c87b56dd1461057a578063cae0b8011461059a5761020f565b80638da5cb5b116100e75780638da5cb5b146104bb5780639491557e146104d057806395d89b41146104e5578063a22cb465146104fa578063b88d4fde1461051a5761020f565b8063715018a614610444578063725da359146104595780637dbb93ca1461046e5780638462151c1461048e5761020f565b806334fee8c71161019b57806355f804b31161016a57806355f804b3146103bc5780635dd98951146103dc5780636352211e146103ef5780636c0360eb1461040f57806370a08231146104245761020f565b806334fee8c7146103525780633ccfd60b1461036757806342842e0e1461037c5780634f6ccce71461039c5761020f565b80631049b6d2116101e25780631049b6d2146102bb57806318160ddd146102db57806323b872dd146102fd5780632f745c591461031d57806334918dfd1461033d5761020f565b806301ffc9a71461021457806306fdde031461024a578063081812fc1461026c578063095ea7b314610299575b600080fd5b34801561022057600080fd5b5061023461022f366004612211565b610651565b60405161024191906124e5565b60405180910390f35b34801561025657600080fd5b5061025f610674565b60405161024191906124f0565b34801561027857600080fd5b5061028c61028736600461227c565b61070a565b60405161024191906123c0565b3480156102a557600080fd5b506102b96102b43660046121d0565b610756565b005b3480156102c757600080fd5b5061025f6102d636600461227c565b6107ee565b3480156102e757600080fd5b506102f0610889565b6040516102419190612ca9565b34801561030957600080fd5b506102b96103183660046120e2565b61089a565b34801561032957600080fd5b506102f06103383660046121d0565b6108d2565b34801561034957600080fd5b506102b96108fd565b34801561035e57600080fd5b506102f0610950565b34801561037357600080fd5b506102b9610956565b34801561038857600080fd5b506102b96103973660046120e2565b6109c8565b3480156103a857600080fd5b506102f06103b736600461227c565b6109e3565b3480156103c857600080fd5b506102b96103d7366004612249565b6109f9565b6102b96103ea36600461227c565b610a44565b3480156103fb57600080fd5b5061028c61040a36600461227c565b610b2d565b34801561041b57600080fd5b5061025f610b55565b34801561043057600080fd5b506102f061043f366004612096565b610bb6565b34801561045057600080fd5b506102b9610bff565b34801561046557600080fd5b506102f0610c88565b34801561047a57600080fd5b506102b9610489366004612294565b610c8e565b34801561049a57600080fd5b506104ae6104a9366004612096565b610de9565b60405161024191906124a1565b3480156104c757600080fd5b5061028c610e9c565b3480156104dc57600080fd5b506102f0610eab565b3480156104f157600080fd5b5061025f610eb0565b34801561050657600080fd5b506102b9610515366004612196565b610f11565b34801561052657600080fd5b506102b961053536600461211d565b610fdf565b34801561054657600080fd5b506102b96105553660046121d0565b61101e565b34801561056657600080fd5b506102b961057536600461227c565b6110cc565b34801561058657600080fd5b5061025f61059536600461227c565b611110565b3480156105a657600080fd5b506105ba6105b5366004612096565b611254565b6040516102419190612441565b3480156105d357600080fd5b506102f06113bd565b3480156105e857600080fd5b506102346105f73660046120b0565b6113c3565b34801561060857600080fd5b506102346113f1565b34801561061d57600080fd5b506102b961062c366004612096565b6113fa565b34801561063d57600080fd5b5061025f61064c36600461227c565b6114bb565b6001600160e01b0319811660009081526020819052604090205460ff165b919050565b60068054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156107005780601f106106d557610100808354040283529160200191610700565b820191906000526020600020905b8154815290600101906020018083116106e357829003601f168201915b5050505050905090565b600061071582611582565b61073a5760405162461bcd60e51b815260040161073190612a00565b60405180910390fd5b506000908152600460205260409020546001600160a01b031690565b600061076182610b2d565b9050806001600160a01b0316836001600160a01b031614156107955760405162461bcd60e51b815260040161073190612b5c565b806001600160a01b03166107a761158f565b6001600160a01b031614806107c357506107c3816105f761158f565b6107df5760405162461bcd60e51b815260040161073190612857565b6107e98383611593565b505050565b600d6020908152600091825260409182902080548351601f6002600019610100600186161502019093169290920491820184900484028101840190945280845290918301828280156108815780601f1061085657610100808354040283529160200191610881565b820191906000526020600020905b81548152906001019060200180831161086457829003601f168201915b505050505081565b60006108956002611601565b905090565b6108ab6108a561158f565b8261160c565b6108c75760405162461bcd60e51b815260040161073190612b9d565b6107e9838383611691565b6001600160a01b03821660009081526001602052604081206108f4908361179f565b90505b92915050565b61090561158f565b6001600160a01b0316610916610e9c565b6001600160a01b03161461093c5760405162461bcd60e51b815260040161073190612a4c565b600c805460ff19811660ff90911615179055565b600e5481565b61095e61158f565b6001600160a01b031661096f610e9c565b6001600160a01b0316146109955760405162461bcd60e51b815260040161073190612a4c565b6040514790339082156108fc029083906000818181858888f193505050501580156109c4573d6000803e3d6000fd5b5050565b6107e983838360405180602001604052806000815250610fdf565b6000806109f16002846117ab565b509392505050565b610a0161158f565b6001600160a01b0316610a12610e9c565b6001600160a01b031614610a385760405162461bcd60e51b815260040161073190612a4c565b610a41816117c7565b50565b600c5460ff16610a665760405162461bcd60e51b8152600401610731906128fe565b600081118015610a775750600a8111155b610a935760405162461bcd60e51b815260040161073190612c68565b61270f610aa882610aa2610889565b906117da565b1115610ac65760405162461bcd60e51b8152600401610731906125e7565b600b54610ad390826117ff565b341015610af25760405162461bcd60e51b81526004016107319061279d565b60005b818110156109c4576000610b07610889565b905061270f610b14610889565b1015610b2457610b243382611839565b50600101610af5565b60006108f782604051806060016040528060298152602001612d276029913960029190611853565b60098054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156107005780601f106106d557610100808354040283529160200191610700565b60006001600160a01b038216610bde5760405162461bcd60e51b8152600401610731906128b4565b6001600160a01b03821660009081526001602052604090206108f790611601565b610c0761158f565b6001600160a01b0316610c18610e9c565b6001600160a01b031614610c3e5760405162461bcd60e51b815260040161073190612a4c565b600a546040516000916001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600a80546001600160a01b0319169055565b600b5481565b33610c9883610b2d565b6001600160a01b031614610cbe5760405162461bcd60e51b815260040161073190612545565b6000828152600d6020526040908190209051600291610cdc91612321565b602060405180830381855afa158015610cf9573d6000803e3d6000fd5b5050506040513d601f19601f82011682018060405250810190610d1c91906121f9565b600282604051610d2c9190612305565b602060405180830381855afa158015610d49573d6000803e3d6000fd5b5050506040513d601f19601f82011682018060405250810190610d6c91906121f9565b1415610d8a5760405162461bcd60e51b815260040161073190612b19565b6000828152600d602090815260409091208251610da992840190611f5b565b507fcb866f53962bb61282203cbee1f0fefe40910947706c3a7a9d4199d25f4d3079338383604051610ddd93929190612411565b60405180910390a15050565b60606000610df683610bb6565b905080610e185760408051600080825260208201909252905b5091505061066f565b60008167ffffffffffffffff81118015610e3157600080fd5b50604051908082528060200260200182016040528015610e5b578160200160208202803683370190505b50905060005b82811015610e9257610e7385826108d2565b828281518110610e7f57fe5b6020908102919091010152600101610e61565b50915061066f9050565b600a546001600160a01b031690565b600a81565b60078054604080516020601f60026000196101006001881615020190951694909404938401819004810282018101909252828152606093909290918301828280156107005780601f106106d557610100808354040283529160200191610700565b610f1961158f565b6001600160a01b0316826001600160a01b03161415610f4a5760405162461bcd60e51b815260040161073190612766565b8060056000610f5761158f565b6001600160a01b03908116825260208083019390935260409182016000908120918716808252919093529120805460ff191692151592909217909155610f9b61158f565b6001600160a01b03167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3183604051610fd391906124e5565b60405180910390a35050565b610ff0610fea61158f565b8361160c565b61100c5760405162461bcd60e51b815260040161073190612b9d565b6110188484848461186a565b50505050565b61102661158f565b6001600160a01b0316611037610e9c565b6001600160a01b03161461105d5760405162461bcd60e51b815260040161073190612a4c565b6000611067610889565b905060008211801561107b5750600e548211155b6110975760405162461bcd60e51b8152600401610731906126ed565b60005b828110156110b6576110ae84828401611839565b60010161109a565b50600e546110c4908361189d565b600e55505050565b6110d461158f565b6001600160a01b03166110e5610e9c565b6001600160a01b03161461110b5760405162461bcd60e51b815260040161073190612a4c565b600b55565b606061111b82611582565b6111375760405162461bcd60e51b815260040161073190612aca565b60008281526008602090815260408083208054825160026001831615610100026000190190921691909104601f8101859004850282018501909352828152929091908301828280156111ca5780601f1061119f576101008083540402835291602001916111ca565b820191906000526020600020905b8154815290600101906020018083116111ad57829003601f168201915b5050505050905060006111db610b55565b90508051600014156111ef5750905061066f565b815115611221578082604051602001611209929190612391565b6040516020818303038152906040529250505061066f565b8061122b856118c5565b60405160200161123c929190612391565b60405160208183030381529060405292505050919050565b6060600061126183610bb6565b90508061129b576040805160008082526020820190925290610e0f565b606081526020019060019003908161127e5790505091505061066f565b60008167ffffffffffffffff811180156112b457600080fd5b506040519080825280602002602001820160405280156112e857816020015b60608152602001906001900390816112d35790505b50905060005b82811015610e9257600d600061130487846108d2565b815260208082019290925260409081016000208054825160026001831615610100026000190190921691909104601f8101859004850282018501909352828152929091908301828280156113995780601f1061136e57610100808354040283529160200191611399565b820191906000526020600020905b81548152906001019060200180831161137c57829003601f168201915b50505050508282815181106113aa57fe5b60209081029190910101526001016112ee565b61270f81565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b600c5460ff1681565b61140261158f565b6001600160a01b0316611413610e9c565b6001600160a01b0316146114395760405162461bcd60e51b815260040161073190612a4c565b6001600160a01b03811661145f5760405162461bcd60e51b815260040161073190612639565b600a546040516001600160a01b038084169216907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3600a80546001600160a01b0319166001600160a01b0392909216919091179055565b60606114c5610889565b82106114e35760405162461bcd60e51b815260040161073190612c25565b6000828152600d602090815260409182902080548351601f6002600019610100600186161502019093169290920491820184900484028101840190945280845290918301828280156115765780601f1061154b57610100808354040283529160200191611576565b820191906000526020600020905b81548152906001019060200180831161155957829003601f168201915b50505050509050919050565b60006108f76002836119a0565b3390565b600081815260046020526040902080546001600160a01b0319166001600160a01b03841690811790915581906115c882610b2d565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b60006108f7826119ac565b600061161782611582565b6116335760405162461bcd60e51b81526004016107319061280b565b600061163e83610b2d565b9050806001600160a01b0316846001600160a01b031614806116795750836001600160a01b031661166e8461070a565b6001600160a01b0316145b80611689575061168981856113c3565b949350505050565b826001600160a01b03166116a482610b2d565b6001600160a01b0316146116ca5760405162461bcd60e51b815260040161073190612a81565b6001600160a01b0382166116f05760405162461bcd60e51b815260040161073190612722565b6116fb8383836107e9565b611706600082611593565b6001600160a01b038316600090815260016020526040902061172890826119b0565b506001600160a01b038216600090815260016020526040902061174b90826119bc565b50611758600282846119c8565b5080826001600160a01b0316846001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4505050565b60006108f483836119de565b60008080806117ba8686611a23565b9097909650945050505050565b80516109c4906009906020840190611f5b565b6000828201838110156108f45760405162461bcd60e51b8152600401610731906126b6565b60008261180e575060006108f7565b8282028284828161181b57fe5b04146108f45760405162461bcd60e51b8152600401610731906129bf565b6109c4828260405180602001604052806000815250611a7f565b6000611860848484611ab2565b90505b9392505050565b611875848484611691565b61188184848484611b11565b6110185760405162461bcd60e51b815260040161073190612595565b6000828211156118bf5760405162461bcd60e51b8152600401610731906127d4565b50900390565b6060816118ea57506040805180820190915260018152600360fc1b602082015261066f565b8160005b811561190257600101600a820491506118ee565b60008167ffffffffffffffff8111801561191b57600080fd5b506040519080825280601f01601f191660200182016040528015611946576020820181803683370190505b50859350905060001982015b831561199757600a840660300160f81b8282806001900393508151811061197557fe5b60200101906001600160f81b031916908160001a905350600a84049350611952565b50949350505050565b60006108f48383611bf0565b5490565b60006108f48383611c08565b60006108f48383611cce565b600061186084846001600160a01b038516611d18565b81546000908210611a015760405162461bcd60e51b815260040161073190612503565b826000018281548110611a1057fe5b9060005260206000200154905092915050565b815460009081908310611a485760405162461bcd60e51b815260040161073190612948565b6000846000018481548110611a5957fe5b906000526020600020906002020190508060000154816001015492509250509250929050565b611a898383611daf565b611a966000848484611b11565b6107e95760405162461bcd60e51b815260040161073190612595565b60008281526001840160205260408120548281611ae25760405162461bcd60e51b815260040161073191906124f0565b50846000016001820381548110611af557fe5b9060005260206000209060020201600101549150509392505050565b6000611b25846001600160a01b0316611e73565b611b3157506001611689565b6000611bb9630a85bd0160e11b611b4661158f565b888787604051602401611b5c94939291906123d4565b604051602081830303815290604052906001600160e01b0319166020820180516001600160e01b038381831617835250505050604051806060016040528060328152602001612cf5603291396001600160a01b0388169190611e79565b9050600081806020019051810190611bd1919061222d565b6001600160e01b031916630a85bd0160e11b1492505050949350505050565b60009081526001919091016020526040902054151590565b60008181526001830160205260408120548015611cc45783546000198083019190810190600090879083908110611c3b57fe5b9060005260206000200154905080876000018481548110611c5857fe5b600091825260208083209091019290925582815260018981019092526040902090840190558654879080611c8857fe5b600190038181906000526020600020016000905590558660010160008781526020019081526020016000206000905560019450505050506108f7565b60009150506108f7565b6000611cda8383611bf0565b611d10575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556108f7565b5060006108f7565b600082815260018401602052604081205480611d7d575050604080518082018252838152602080820184815286546001818101895560008981528481209551600290930290950191825591519082015586548684528188019092529290912055611863565b82856000016001830381548110611d9057fe5b9060005260206000209060020201600101819055506000915050611863565b6001600160a01b038216611dd55760405162461bcd60e51b81526004016107319061298a565b611dde81611582565b15611dfb5760405162461bcd60e51b81526004016107319061267f565b611e07600083836107e9565b6001600160a01b0382166000908152600160205260409020611e2990826119bc565b50611e36600282846119c8565b5060405181906001600160a01b038416906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b3b151590565b6060611860848460008585611e8d85611e73565b611ea95760405162461bcd60e51b815260040161073190612bee565b600080866001600160a01b03168587604051611ec59190612305565b60006040518083038185875af1925050503d8060008114611f02576040519150601f19603f3d011682016040523d82523d6000602084013e611f07565b606091505b5091509150611f17828286611f22565b979650505050505050565b60608315611f31575081611863565b825115611f415782518084602001fd5b8160405162461bcd60e51b815260040161073191906124f0565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282611f915760008555611fd7565b82601f10611faa57805160ff1916838001178555611fd7565b82800160010185558215611fd7579182015b82811115611fd7578251825591602001919060010190611fbc565b50611fe3929150611fe7565b5090565b5b80821115611fe35760008155600101611fe8565b600067ffffffffffffffff8084111561201157fe5b604051601f8501601f19168101602001828111828210171561202f57fe5b60405284815291508183850186101561204757600080fd5b8484602083013760006020868301015250509392505050565b80356001600160a01b038116811461066f57600080fd5b600082601f830112612087578081fd5b6108f483833560208501611ffc565b6000602082840312156120a7578081fd5b6108f482612060565b600080604083850312156120c2578081fd5b6120cb83612060565b91506120d960208401612060565b90509250929050565b6000806000606084860312156120f6578081fd5b6120ff84612060565b925061210d60208501612060565b9150604084013590509250925092565b60008060008060808587031215612132578081fd5b61213b85612060565b935061214960208601612060565b925060408501359150606085013567ffffffffffffffff81111561216b578182fd5b8501601f8101871361217b578182fd5b61218a87823560208401611ffc565b91505092959194509250565b600080604083850312156121a8578182fd5b6121b183612060565b9150602083013580151581146121c5578182fd5b809150509250929050565b600080604083850312156121e2578182fd5b6121eb83612060565b946020939093013593505050565b60006020828403121561220a578081fd5b5051919050565b600060208284031215612222578081fd5b81356108f481612cde565b60006020828403121561223e578081fd5b81516108f481612cde565b60006020828403121561225a578081fd5b813567ffffffffffffffff811115612270578182fd5b61168984828501612077565b60006020828403121561228d578081fd5b5035919050565b600080604083850312156122a6578182fd5b82359150602083013567ffffffffffffffff8111156122c3578182fd5b6122cf85828601612077565b9150509250929050565b600081518084526122f1816020860160208601612cb2565b601f01601f19169290920160200192915050565b60008251612317818460208701612cb2565b9190910192915050565b6000808354600180821660008114612340576001811461235757612386565b60ff198316865260028304607f1686019350612386565b600283048786526020808720875b8381101561237e5781548a820152908501908201612365565b505050860193505b509195945050505050565b600083516123a3818460208801612cb2565b8351908301906123b7818360208801612cb2565b01949350505050565b6001600160a01b0391909116815260200190565b6001600160a01b0385811682528416602082015260408101839052608060608201819052600090612407908301846122d9565b9695505050505050565b600060018060a01b03851682528360208301526060604083015261243860608301846122d9565b95945050505050565b6000602080830181845280855180835260408601915060408482028701019250838701855b8281101561249457603f198886030184526124828583516122d9565b94509285019290850190600101612466565b5092979650505050505050565b6020808252825182820181905260009190848201906040850190845b818110156124d9578351835292840192918401916001016124bd565b50909695505050505050565b901515815260200190565b6000602082526108f460208301846122d9565b60208082526022908201527f456e756d657261626c655365743a20696e646578206f7574206f6620626f756e604082015261647360f01b606082015260800190565b60208082526030908201527f4865792c20796f75722077616c6c657420646f65736e2774206f776e2074686960408201526f7320526162626964205261626269742160801b606082015260800190565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b60208082526032908201527f507572636861736520776f756c6420657863656564206d617820737570706c79604082015271206f6620526162626964205261626269747360701b606082015260800190565b60208082526026908201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160408201526564647265737360d01b606082015260800190565b6020808252601c908201527f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000604082015260600190565b6020808252601b908201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604082015260600190565b6020808252818101527f4e6f7420656e6f7567682072657365727665206c65667420666f72207465616d604082015260600190565b60208082526024908201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646040820152637265737360e01b606082015260800190565b60208082526019908201527f4552433732313a20617070726f766520746f2063616c6c657200000000000000604082015260600190565b6020808252601f908201527f45746865722076616c75652073656e74206973206e6f7420636f727265637400604082015260600190565b6020808252601e908201527f536166654d6174683a207375627472616374696f6e206f766572666c6f770000604082015260600190565b6020808252602c908201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860408201526b34b9ba32b73a103a37b5b2b760a11b606082015260800190565b60208082526038908201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760408201527f6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000606082015260800190565b6020808252602a908201527f4552433732313a2062616c616e636520717565727920666f7220746865207a65604082015269726f206164647265737360b01b606082015260800190565b6020808252602a908201527f53616c65206d7573742062652061637469766520746f206d696e7420526162626040820152696964205261626269747360b01b606082015260800190565b60208082526022908201527f456e756d657261626c654d61703a20696e646578206f7574206f6620626f756e604082015261647360f01b606082015260800190565b6020808252818101527f4552433732313a206d696e7420746f20746865207a65726f2061646472657373604082015260600190565b60208082526021908201527f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f6040820152607760f81b606082015260800190565b6020808252602c908201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860408201526b34b9ba32b73a103a37b5b2b760a11b606082015260800190565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b60208082526029908201527f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960408201526839903737ba1037bbb760b91b606082015260800190565b6020808252602f908201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60408201526e3732bc34b9ba32b73a103a37b5b2b760891b606082015260800190565b60208082526023908201527f4e6577206e616d652069732073616d65206173207468652063757272656e74206040820152626f6e6560e81b606082015260800190565b60208082526021908201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656040820152603960f91b606082015260800190565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f6040820152701ddb995c881b9bdc88185c1c1c9bdd9959607a1b606082015260800190565b6020808252601d908201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604082015260600190565b60208082526023908201527f43686f6f7365206120526162626964205261626269742077697468696e2072616040820152626e676560e81b606082015260800190565b60208082526021908201527f43616e206f6e6c79206d696e7420313020746f6b656e7320617420612074696d6040820152606560f81b606082015260800190565b90815260200190565b60005b83811015612ccd578181015183820152602001612cb5565b838111156110185750506000910152565b6001600160e01b031981168114610a4157600080fdfe4552433732313a207472616e7366657220746f206e6f6e20455243373231526563656976657220696d706c656d656e7465724552433732313a206f776e657220717565727920666f72206e6f6e6578697374656e7420746f6b656ea2646970667358221220dbb33c94e3117fdd620079752eb3939017e2117409038f0e891bfd9c661527f464736f6c63430007060033

Deployed Bytecode Sourcemap

66956:3932:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10306:150;;;;;;;;;;-1:-1:-1;10306:150:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51590:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;54376:221::-;;;;;;;;;;-1:-1:-1;54376:221:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;53906:404::-;;;;;;;;;;-1:-1:-1;53906:404:0;;;;;:::i;:::-;;:::i;:::-;;67260:49;;;;;;;;;;-1:-1:-1;67260:49:0;;;;;:::i;:::-;;:::i;53384:211::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;55266:305::-;;;;;;;;;;-1:-1:-1;55266:305:0;;;;;:::i;:::-;;:::i;53146:162::-;;;;;;;;;;-1:-1:-1;53146:162:0;;;;;:::i;:::-;;:::i;70796:89::-;;;;;;;;;;;;;:::i;67316:38::-;;;;;;;;;;;;;:::i;67520:131::-;;;;;;;;;;;;;:::i;55642:151::-;;;;;;;;;;-1:-1:-1;55642:151:0;;;;;:::i;:::-;;:::i;53672:172::-;;;;;;;;;;-1:-1:-1;53672:172:0;;;;;:::i;:::-;;:::i;70179:99::-;;;;;;;;;;-1:-1:-1;70179:99:0;;;;;:::i;:::-;;:::i;67766:730::-;;;;;;:::i;:::-;;:::i;51346:177::-;;;;;;;;;;-1:-1:-1;51346:177:0;;;;;:::i;:::-;;:::i;52965:97::-;;;;;;;;;;;;;:::i;51063:221::-;;;;;;;;;;-1:-1:-1;51063:221:0;;;;;:::i;:::-;;:::i;66301:148::-;;;;;;;;;;;;;:::i;67038:53::-;;;;;;;;;;;;;:::i;68504:427::-;;;;;;;;;;-1:-1:-1;68504:427:0;;;;;:::i;:::-;;:::i;70286:502::-;;;;;;;;;;-1:-1:-1;70286:502:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;65650:87::-;;;;;;;;;;;;;:::i;67110:50::-;;;;;;;;;;;;;:::i;51759:104::-;;;;;;;;;;;;;:::i;54669:295::-;;;;;;;;;;-1:-1:-1;54669:295:0;;;;;:::i;:::-;;:::i;55864:285::-;;;;;;;;;;-1:-1:-1;55864:285:0;;;;;:::i;:::-;;:::i;69746:425::-;;;;;;;;;;-1:-1:-1;69746:425:0;;;;;:::i;:::-;;:::i;67659:99::-;;;;;;;;;;-1:-1:-1;67659:99:0;;;;;:::i;:::-;;:::i;51934:792::-;;;;;;;;;;-1:-1:-1;51934:792:0;;;;;:::i;:::-;;:::i;69167:571::-;;;;;;;;;;-1:-1:-1;69167:571:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;67167:47::-;;;;;;;;;;;;;:::i;55035:164::-;;;;;;;;;;-1:-1:-1;55035:164:0;;;;;:::i;:::-;;:::i;67221:32::-;;;;;;;;;;;;;:::i;66604:244::-;;;;;;;;;;-1:-1:-1;66604:244:0;;;;;:::i;:::-;;:::i;68939:220::-;;;;;;;;;;-1:-1:-1;68939:220:0;;;;;:::i;:::-;;:::i;10306:150::-;-1:-1:-1;;;;;;10415:33:0;;10391:4;10415:33;;;;;;;;;;;;;10306:150;;;;:::o;51590:100::-;51677:5;51670:12;;;;;;;;-1:-1:-1;;51670:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51644:13;;51670:12;;51677:5;;51670:12;;51677:5;51670:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51590:100;:::o;54376:221::-;54452:7;54480:16;54488:7;54480;:16::i;:::-;54472:73;;;;-1:-1:-1;;;54472:73:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;54565:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;54565:24:0;;54376:221::o;53906:404::-;53987:13;54003:23;54018:7;54003:14;:23::i;:::-;53987:39;;54051:5;-1:-1:-1;;;;;54045:11:0;:2;-1:-1:-1;;;;;54045:11:0;;;54037:57;;;;-1:-1:-1;;;54037:57:0;;;;;;;:::i;:::-;54131:5;-1:-1:-1;;;;;54115:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;54115:21:0;;:69;;;;54140:44;54164:5;54171:12;:10;:12::i;54140:44::-;54107:161;;;;-1:-1:-1;;;54107:161:0;;;;;;;:::i;:::-;54281:21;54290:2;54294:7;54281:8;:21::i;:::-;53906:404;;;:::o;67260:49::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;67260:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;53384:211::-;53445:7;53566:21;:12;:19;:21::i;:::-;53559:28;;53384:211;:::o;55266:305::-;55427:41;55446:12;:10;:12::i;:::-;55460:7;55427:18;:41::i;:::-;55419:103;;;;-1:-1:-1;;;55419:103:0;;;;;;;:::i;:::-;55535:28;55545:4;55551:2;55555:7;55535:9;:28::i;53146:162::-;-1:-1:-1;;;;;53270:20:0;;53243:7;53270:20;;;:13;:20;;;;;:30;;53294:5;53270:23;:30::i;:::-;53263:37;;53146:162;;;;;:::o;70796:89::-;65881:12;:10;:12::i;:::-;-1:-1:-1;;;;;65870:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65870:23:0;;65862:68;;;;-1:-1:-1;;;65862:68:0;;;;;;;:::i;:::-;70865:12:::1;::::0;;-1:-1:-1;;70849:28:0;::::1;70865:12;::::0;;::::1;70864:13;70849:28;::::0;;70796:89::o;67316:38::-;;;;:::o;67520:131::-;65881:12;:10;:12::i;:::-;-1:-1:-1;;;;;65870:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65870:23:0;;65862:68;;;;-1:-1:-1;;;65862:68:0;;;;;;;:::i;:::-;67615:28:::1;::::0;67583:21:::1;::::0;67615:10:::1;::::0;:28;::::1;;;::::0;67583:21;;67568:12:::1;67615:28:::0;67568:12;67615:28;67583:21;67615:10;:28;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;65941:1;67520:131::o:0;55642:151::-;55746:39;55763:4;55769:2;55773:7;55746:39;;;;;;;;;;;;:16;:39::i;53672:172::-;53747:7;;53789:22;:12;53805:5;53789:15;:22::i;:::-;-1:-1:-1;53767:44:0;53672:172;-1:-1:-1;;;53672:172:0:o;70179:99::-;65881:12;:10;:12::i;:::-;-1:-1:-1;;;;;65870:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65870:23:0;;65862:68;;;;-1:-1:-1;;;65862:68:0;;;;;;;:::i;:::-;70250:20:::1;70262:7;70250:11;:20::i;:::-;70179:99:::0;:::o;67766:730::-;67848:12;;;;67840:67;;;;-1:-1:-1;;;67840:67:0;;;;;;;:::i;:::-;67943:1;67926:14;:18;:64;;;;;67158:2;67948:14;:42;;67926:64;67918:110;;;;-1:-1:-1;;;67918:110:0;;;;;;;:::i;:::-;67210:4;68047:33;68065:14;68047:13;:11;:13::i;:::-;:17;;:33::i;:::-;:53;;68039:116;;;;-1:-1:-1;;;68039:116:0;;;;;;;:::i;:::-;68187:18;;:38;;68210:14;68187:22;:38::i;:::-;68174:9;:51;;68166:95;;;;-1:-1:-1;;;68166:95:0;;;;;;;:::i;:::-;68276:6;68272:217;68292:14;68288:1;:18;68272:217;;;68328:14;68345:13;:11;:13::i;:::-;68328:30;;67210:4;68377:13;:11;:13::i;:::-;:32;68373:105;;;68430:32;68440:10;68452:9;68430;:32::i;:::-;-1:-1:-1;68308:3:0;;68272:217;;51346:177;51418:7;51445:70;51462:7;51445:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;52965:97::-;53046:8;53039:15;;;;;;;;-1:-1:-1;;53039:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53013:13;;53039:15;;53046:8;;53039:15;;53046:8;53039:15;;;;;;;;;;;;;;;;;;;;;;;;51063:221;51135:7;-1:-1:-1;;;;;51163:19:0;;51155:74;;;;-1:-1:-1;;;51155:74:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;51247:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;66301:148::-;65881:12;:10;:12::i;:::-;-1:-1:-1;;;;;65870:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65870:23:0;;65862:68;;;;-1:-1:-1;;;65862:68:0;;;;;;;:::i;:::-;66392:6:::1;::::0;66371:40:::1;::::0;66408:1:::1;::::0;-1:-1:-1;;;;;66392:6:0::1;::::0;66371:40:::1;::::0;66408:1;;66371:40:::1;66422:6;:19:::0;;-1:-1:-1;;;;;;66422:19:0::1;::::0;;66301:148::o;67038:53::-;;;;:::o;68504:427::-;68619:10;68598:17;68606:8;68598:7;:17::i;:::-;-1:-1:-1;;;;;68598:31:0;;68590:92;;;;-1:-1:-1;;;68590:92:0;;;;;;;:::i;:::-;68738:28;;;;:18;:28;;;;;;;68725:43;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68701:20;68714:5;68701:20;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:67;;68693:115;;;;-1:-1:-1;;;68693:115:0;;;;;;;:::i;:::-;68819:28;;;;:18;:28;;;;;;;;:36;;;;;;;;:::i;:::-;;68871:52;68895:10;68907:8;68917:5;68871:52;;;;;;;;:::i;:::-;;;;;;;;68504:427;;:::o;70286:502::-;70347:16;70377:18;70398:17;70408:6;70398:9;:17::i;:::-;70377:38;-1:-1:-1;70430:15:0;70426:355;;70469:16;;;70483:1;70469:16;;;;;;;;;;;;70462:23;;;;;70426:355;70518:23;70558:10;70544:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70544:25:0;;70518:51;;70584:13;70612:130;70636:10;70628:5;:18;70612:130;;;70692:34;70712:6;70720:5;70692:19;:34::i;:::-;70676:6;70683:5;70676:13;;;;;;;;;;;;;;;;;:50;70648:7;;70612:130;;;-1:-1:-1;70763:6:0;-1:-1:-1;70756:13:0;;-1:-1:-1;70756:13:0;65650:87;65723:6;;-1:-1:-1;;;;;65723:6:0;65650:87;:::o;67110:50::-;67158:2;67110:50;:::o;51759:104::-;51848:7;51841:14;;;;;;;;-1:-1:-1;;51841:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51815:13;;51841:14;;51848:7;;51841:14;;51848:7;51841:14;;;;;;;;;;;;;;;;;;;;;;;;54669:295;54784:12;:10;:12::i;:::-;-1:-1:-1;;;;;54772:24:0;:8;-1:-1:-1;;;;;54772:24:0;;;54764:62;;;;-1:-1:-1;;;54764:62:0;;;;;;;:::i;:::-;54884:8;54839:18;:32;54858:12;:10;:12::i;:::-;-1:-1:-1;;;;;54839:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;54839:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;54839:53:0;;;;;;;;;;;54923:12;:10;:12::i;:::-;-1:-1:-1;;;;;54908:48:0;;54947:8;54908:48;;;;;;:::i;:::-;;;;;;;;54669:295;;:::o;55864:285::-;55996:41;56015:12;:10;:12::i;:::-;56029:7;55996:18;:41::i;:::-;55988:103;;;;-1:-1:-1;;;55988:103:0;;;;;;;:::i;:::-;56102:39;56116:4;56122:2;56126:7;56135:5;56102:13;:39::i;:::-;55864:285;;;;:::o;69746:425::-;65881:12;:10;:12::i;:::-;-1:-1:-1;;;;;65870:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65870:23:0;;65862:68;;;;-1:-1:-1;;;65862:68:0;;;;;;;:::i;:::-;69841:11:::1;69855:13;:11;:13::i;:::-;69841:27;;69904:1;69887:14;:18;:60;;;;;69927:20;;69909:14;:38;;69887:60;69879:105;;;;-1:-1:-1::0;;;69879:105:0::1;;;;;;;:::i;:::-;70000:6;69995:95;70016:14;70012:1;:18;69995:95;;;70052:26;70062:3;70076:1;70067:6;:10;70052:9;:26::i;:::-;70032:3;;69995:95;;;-1:-1:-1::0;70123:20:0::1;::::0;:40:::1;::::0;70148:14;70123:24:::1;:40::i;:::-;70100:20;:63:::0;-1:-1:-1;;;69746:425:0:o;67659:99::-;65881:12;:10;:12::i;:::-;-1:-1:-1;;;;;65870:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65870:23:0;;65862:68;;;;-1:-1:-1;;;65862:68:0;;;;;;;:::i;:::-;67721:18:::1;:29:::0;67659:99::o;51934:792::-;52007:13;52041:16;52049:7;52041;:16::i;:::-;52033:76;;;;-1:-1:-1;;;52033:76:0;;;;;;;:::i;:::-;52122:23;52148:19;;;:10;:19;;;;;;;;52122:45;;;;;;;;;;;-1:-1:-1;;52122:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;52148:19;;52122:45;;;52148:19;52122:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52178:18;52199:9;:7;:9::i;:::-;52178:30;;52290:4;52284:18;52306:1;52284:23;52280:72;;;-1:-1:-1;52331:9:0;-1:-1:-1;52324:16:0;;52280:72;52456:23;;:27;52452:108;;52531:4;52537:9;52514:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52500:48;;;;;;52452:108;52692:4;52698:18;:7;:16;:18::i;:::-;52675:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52661:57;;;;51934:792;;;:::o;69167:571::-;69240:15;69269:18;69290:17;69300:6;69290:9;:17::i;:::-;69269:38;-1:-1:-1;69322:15:0;69318:413;;69399:15;;;69412:1;69399:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69392:22;;;;;69318:413;69447:22;69485:10;69472:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69447:49;;69511:13;69539:153;69563:10;69555:5;:18;69539:153;;;69619:18;:56;69639:34;69659:6;69667:5;69639:19;:34::i;:::-;69619:56;;;;;;;;;;;;;;-1:-1:-1;69619:56:0;69603:72;;;;;;;;;;;-1:-1:-1;;69603:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;69619:56;;69603:72;;;69619:56;69603:72;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:6;69610:5;69603:13;;;;;;;;;;;;;;;;;:72;69575:7;;69539:153;;67167:47;67210:4;67167:47;:::o;55035:164::-;-1:-1:-1;;;;;55156:25:0;;;55132:4;55156:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;55035:164::o;67221:32::-;;;;;;:::o;66604:244::-;65881:12;:10;:12::i;:::-;-1:-1:-1;;;;;65870:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;65870:23:0;;65862:68;;;;-1:-1:-1;;;65862:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;66693:22:0;::::1;66685:73;;;;-1:-1:-1::0;;;66685:73:0::1;;;;;;;:::i;:::-;66795:6;::::0;66774:38:::1;::::0;-1:-1:-1;;;;;66774:38:0;;::::1;::::0;66795:6:::1;::::0;66774:38:::1;::::0;66795:6:::1;::::0;66774:38:::1;66823:6;:17:::0;;-1:-1:-1;;;;;;66823:17:0::1;-1:-1:-1::0;;;;;66823:17:0;;;::::1;::::0;;;::::1;::::0;;66604:244::o;68939:220::-;69005:13;69051;:11;:13::i;:::-;69040:8;:24;69031:74;;;;-1:-1:-1;;;69031:74:0;;;;;;;:::i;:::-;69123:28;;;;:18;:28;;;;;;;;;69116:35;;;;;;-1:-1:-1;;69116:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69123:28;;69116:35;;69123:28;69116:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68939:220;;;:::o;57616:127::-;57681:4;57705:30;:12;57727:7;57705:21;:30::i;738:106::-;826:10;738:106;:::o;63634:192::-;63709:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;63709:29:0;-1:-1:-1;;;;;63709:29:0;;;;;;;;:24;;63763:23;63709:24;63763:14;:23::i;:::-;-1:-1:-1;;;;;63754:46:0;;;;;;;;;;;63634:192;;:::o;44349:123::-;44418:7;44445:19;44453:3;44445:7;:19::i;57910:355::-;58003:4;58028:16;58036:7;58028;:16::i;:::-;58020:73;;;;-1:-1:-1;;;58020:73:0;;;;;;;:::i;:::-;58104:13;58120:23;58135:7;58120:14;:23::i;:::-;58104:39;;58173:5;-1:-1:-1;;;;;58162:16:0;:7;-1:-1:-1;;;;;58162:16:0;;:51;;;;58206:7;-1:-1:-1;;;;;58182:31:0;:20;58194:7;58182:11;:20::i;:::-;-1:-1:-1;;;;;58182:31:0;;58162:51;:94;;;;58217:39;58241:5;58248:7;58217:23;:39::i;:::-;58154:103;57910:355;-1:-1:-1;;;;57910:355:0:o;61046:599::-;61171:4;-1:-1:-1;;;;;61144:31:0;:23;61159:7;61144:14;:23::i;:::-;-1:-1:-1;;;;;61144:31:0;;61136:85;;;;-1:-1:-1;;;61136:85:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;61258:16:0;;61250:65;;;;-1:-1:-1;;;61250:65:0;;;;;;;:::i;:::-;61328:39;61349:4;61355:2;61359:7;61328:20;:39::i;:::-;61432:29;61449:1;61453:7;61432:8;:29::i;:::-;-1:-1:-1;;;;;61474:19:0;;;;;;:13;:19;;;;;:35;;61501:7;61474:26;:35::i;:::-;-1:-1:-1;;;;;;61520:17:0;;;;;;:13;:17;;;;;:30;;61542:7;61520:21;:30::i;:::-;-1:-1:-1;61563:29:0;:12;61580:7;61589:2;61563:16;:29::i;:::-;;61629:7;61625:2;-1:-1:-1;;;;;61610:27:0;61619:4;-1:-1:-1;;;;;61610:27:0;;;;;;;;;;;61046:599;;;:::o;36140:137::-;36211:7;36246:22;36250:3;36262:5;36246:3;:22::i;44811:236::-;44891:7;;;;44951:22;44955:3;44967:5;44951:3;:22::i;:::-;44920:53;;;;-1:-1:-1;44811:236:0;-1:-1:-1;;;;;44811:236:0:o;62246:100::-;62319:19;;;;:8;;:19;;;;;:::i;13868:179::-;13926:7;13958:5;;;13982:6;;;;13974:46;;;;-1:-1:-1;;;13974:46:0;;;;;;;:::i;14747:220::-;14805:7;14829:6;14825:20;;-1:-1:-1;14844:1:0;14837:8;;14825:20;14868:5;;;14872:1;14868;:5;:1;14892:5;;;;;:10;14884:56;;;;-1:-1:-1;;;14884:56:0;;;;;;;:::i;58608:110::-;58684:26;58694:2;58698:7;58684:26;;;;;;;;;;;;:9;:26::i;46097:213::-;46204:7;46255:44;46260:3;46280;46286:12;46255:4;:44::i;:::-;46247:53;-1:-1:-1;46097:213:0;;;;;;:::o;57031:272::-;57145:28;57155:4;57161:2;57165:7;57145:9;:28::i;:::-;57192:48;57215:4;57221:2;57225:7;57234:5;57192:22;:48::i;:::-;57184:111;;;;-1:-1:-1;;;57184:111:0;;;;;;;:::i;14330:158::-;14388:7;14421:1;14416;:6;;14408:49;;;;-1:-1:-1;;;14408:49:0;;;;;;;:::i;:::-;-1:-1:-1;14475:5:0;;;14330:158::o;46561:746::-;46617:13;46838:10;46834:53;;-1:-1:-1;46865:10:0;;;;;;;;;;;;-1:-1:-1;;;46865:10:0;;;;;;46834:53;46912:5;46897:12;46953:78;46960:9;;46953:78;;46986:8;;47017:2;47009:10;;;;46953:78;;;47041:19;47073:6;47063:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47063:17:0;-1:-1:-1;47135:5:0;;-1:-1:-1;47041:39:0;-1:-1:-1;;;47107:10:0;;47151:117;47158:9;;47151:117;;47227:2;47220:4;:9;47215:2;:14;47202:29;;47184:6;47191:7;;;;;;;47184:15;;;;;;;;;;;:47;-1:-1:-1;;;;;47184:47:0;;;;;;;;-1:-1:-1;47254:2:0;47246:10;;;;47151:117;;;-1:-1:-1;47292:6:0;46561:746;-1:-1:-1;;;;46561:746:0:o;44110:151::-;44194:4;44218:35;44228:3;44248;44218:9;:35::i;40928:110::-;41011:19;;40928:110::o;35227:137::-;35297:4;35321:35;35329:3;35349:5;35321:7;:35::i;34920:131::-;34987:4;35011:32;35016:3;35036:5;35011:4;:32::i;43533:185::-;43622:4;43646:64;43651:3;43671;-1:-1:-1;;;;;43685:23:0;;43646:4;:64::i;31178:204::-;31273:18;;31245:7;;31273:26;-1:-1:-1;31265:73:0;;;;-1:-1:-1;;;31265:73:0;;;;;;;:::i;:::-;31356:3;:11;;31368:5;31356:18;;;;;;;;;;;;;;;;31349:25;;31178:204;;;;:::o;41393:279::-;41497:19;;41460:7;;;;41497:27;-1:-1:-1;41489:74:0;;;;-1:-1:-1;;;41489:74:0;;;;;;;:::i;:::-;41576:22;41601:3;:12;;41614:5;41601:19;;;;;;;;;;;;;;;;;;41576:44;;41639:5;:10;;;41651:5;:12;;;41631:33;;;;;41393:279;;;;;:::o;58945:250::-;59041:18;59047:2;59051:7;59041:5;:18::i;:::-;59078:54;59109:1;59113:2;59117:7;59126:5;59078:22;:54::i;:::-;59070:117;;;;-1:-1:-1;;;59070:117:0;;;;;;;:::i;42890:319::-;42984:7;43023:17;;;:12;;;:17;;;;;;43074:12;43059:13;43051:36;;;;-1:-1:-1;;;43051:36:0;;;;;;;;:::i;:::-;;43141:3;:12;;43165:1;43154:8;:12;43141:26;;;;;;;;;;;;;;;;;;:33;;;43134:40;;;42890:319;;;;;:::o;62911:604::-;63032:4;63059:15;:2;-1:-1:-1;;;;;63059:13:0;;:15::i;:::-;63054:60;;-1:-1:-1;63098:4:0;63091:11;;63054:60;63124:23;63150:252;-1:-1:-1;;;63263:12:0;:10;:12::i;:::-;63290:4;63309:7;63331:5;63166:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;63166:181:0;;;;;;;-1:-1:-1;;;;;63166:181:0;;;;;;;;;;;63150:252;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;63150:15:0;;;:252;:15;:252::i;:::-;63124:278;;63413:13;63440:10;63429:32;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;63480:26:0;-1:-1:-1;;;63480:26:0;;-1:-1:-1;;;62911:604:0;;;;;;:::o;40708:125::-;40779:4;40803:17;;;:12;;;;;:17;;;;;;:22;;;40708:125::o;28880:1544::-;28946:4;29085:19;;;:12;;;:19;;;;;;29121:15;;29117:1300;;29556:18;;-1:-1:-1;;29507:14:0;;;;29556:22;;;;29483:21;;29556:3;;:22;;29843;;;;;;;;;;;;;;29823:42;;29989:9;29960:3;:11;;29972:13;29960:26;;;;;;;;;;;;;;;;;;;:38;;;;30066:23;;;30108:1;30066:12;;;:23;;;;;;30092:17;;;30066:43;;30218:17;;30066:3;;30218:17;;;;;;;;;;;;;;;;;;;;;;30313:3;:12;;:19;30326:5;30313:19;;;;;;;;;;;30306:26;;;30356:4;30349:11;;;;;;;;29117:1300;30400:5;30393:12;;;;;28290:414;28353:4;28375:21;28385:3;28390:5;28375:9;:21::i;:::-;28370:327;;-1:-1:-1;28413:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;28596:18;;28574:19;;;:12;;;:19;;;;;;:40;;;;28629:11;;28370:327;-1:-1:-1;28680:5:0;28673:12;;38208:692;38284:4;38419:17;;;:12;;;:17;;;;;;38453:13;38449:444;;-1:-1:-1;;38538:38:0;;;;;;;;;;;;;;;;;;38520:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;38735:19;;38715:17;;;:12;;;:17;;;;;;;:39;38769:11;;38449:444;38849:5;38813:3;:12;;38837:1;38826:8;:12;38813:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;38876:5;38869:12;;;;;59531:404;-1:-1:-1;;;;;59611:16:0;;59603:61;;;;-1:-1:-1;;;59603:61:0;;;;;;;:::i;:::-;59684:16;59692:7;59684;:16::i;:::-;59683:17;59675:58;;;;-1:-1:-1;;;59675:58:0;;;;;;;:::i;:::-;59746:45;59775:1;59779:2;59783:7;59746:20;:45::i;:::-;-1:-1:-1;;;;;59804:17:0;;;;;;:13;:17;;;;;:30;;59826:7;59804:21;:30::i;:::-;-1:-1:-1;59847:29:0;:12;59864:7;59873:2;59847:16;:29::i;:::-;-1:-1:-1;59894:33:0;;59919:7;;-1:-1:-1;;;;;59894:33:0;;;59911:1;;59894:33;;59911:1;;59894:33;59531:404;;:::o;19309:422::-;19676:20;19715:8;;;19309:422::o;22227:195::-;22330:12;22362:52;22384:6;22392:4;22398:1;22401:12;22330;23531:18;23542:6;23531:10;:18::i;:::-;23523:60;;;;-1:-1:-1;;;23523:60:0;;;;;;;:::i;:::-;23657:12;23671:23;23698:6;-1:-1:-1;;;;;23698:11:0;23718:5;23726:4;23698:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23656:75;;;;23749:52;23767:7;23776:10;23788:12;23749:17;:52::i;:::-;23742:59;23279:530;-1:-1:-1;;;;;;;23279:530:0:o;25819:742::-;25934:12;25963:7;25959:595;;;-1:-1:-1;25994:10:0;25987:17;;25959:595;26108:17;;:21;26104:439;;26371:10;26365:17;26432:15;26419:10;26415:2;26411:19;26404:44;26319:148;26514:12;26507:20;;-1:-1:-1;;;26507:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:589:1;;110:18;151:2;143:6;140:14;137:2;;;157:9;137:2;197;191:9;270:2;247:17;;-1:-1:-1;;243:31:1;231:44;;277:4;227:55;297:18;;;317:22;;;294:46;291:2;;;343:9;291:2;370;363:22;418;;;403:6;-1:-1:-1;403:6:1;455:16;;;452:25;-1:-1:-1;449:2:1;;;490:1;487;480:12;449:2;540:6;535:3;528:4;520:6;516:17;503:44;595:1;588:4;579:6;571;567:19;563:30;556:41;;;90:513;;;;;:::o;608:175::-;678:20;;-1:-1:-1;;;;;727:31:1;;717:42;;707:2;;773:1;770;763:12;788:233;;886:3;879:4;871:6;867:17;863:27;853:2;;908:5;901;894:20;853:2;934:81;1011:3;1002:6;989:20;982:4;974:6;970:17;934:81;:::i;1026:198::-;;1138:2;1126:9;1117:7;1113:23;1109:32;1106:2;;;1159:6;1151;1144:22;1106:2;1187:31;1208:9;1187:31;:::i;1229:274::-;;;1358:2;1346:9;1337:7;1333:23;1329:32;1326:2;;;1379:6;1371;1364:22;1326:2;1407:31;1428:9;1407:31;:::i;:::-;1397:41;;1457:40;1493:2;1482:9;1478:18;1457:40;:::i;:::-;1447:50;;1316:187;;;;;:::o;1508:342::-;;;;1654:2;1642:9;1633:7;1629:23;1625:32;1622:2;;;1675:6;1667;1660:22;1622:2;1703:31;1724:9;1703:31;:::i;:::-;1693:41;;1753:40;1789:2;1778:9;1774:18;1753:40;:::i;:::-;1743:50;;1840:2;1829:9;1825:18;1812:32;1802:42;;1612:238;;;;;:::o;1855:702::-;;;;;2027:3;2015:9;2006:7;2002:23;1998:33;1995:2;;;2049:6;2041;2034:22;1995:2;2077:31;2098:9;2077:31;:::i;:::-;2067:41;;2127:40;2163:2;2152:9;2148:18;2127:40;:::i;:::-;2117:50;;2214:2;2203:9;2199:18;2186:32;2176:42;;2269:2;2258:9;2254:18;2241:32;2296:18;2288:6;2285:30;2282:2;;;2333:6;2325;2318:22;2282:2;2361:22;;2414:4;2406:13;;2402:27;-1:-1:-1;2392:2:1;;2448:6;2440;2433:22;2392:2;2476:75;2543:7;2538:2;2525:16;2520:2;2516;2512:11;2476:75;:::i;:::-;2466:85;;;1985:572;;;;;;;:::o;2562:369::-;;;2688:2;2676:9;2667:7;2663:23;2659:32;2656:2;;;2709:6;2701;2694:22;2656:2;2737:31;2758:9;2737:31;:::i;:::-;2727:41;;2818:2;2807:9;2803:18;2790:32;2865:5;2858:13;2851:21;2844:5;2841:32;2831:2;;2892:6;2884;2877:22;2831:2;2920:5;2910:15;;;2646:285;;;;;:::o;2936:266::-;;;3065:2;3053:9;3044:7;3040:23;3036:32;3033:2;;;3086:6;3078;3071:22;3033:2;3114:31;3135:9;3114:31;:::i;:::-;3104:41;3192:2;3177:18;;;;3164:32;;-1:-1:-1;;;3023:179:1:o;3207:194::-;;3330:2;3318:9;3309:7;3305:23;3301:32;3298:2;;;3351:6;3343;3336:22;3298:2;-1:-1:-1;3379:16:1;;3288:113;-1:-1:-1;3288:113:1:o;3406:257::-;;3517:2;3505:9;3496:7;3492:23;3488:32;3485:2;;;3538:6;3530;3523:22;3485:2;3582:9;3569:23;3601:32;3627:5;3601:32;:::i;3668:261::-;;3790:2;3778:9;3769:7;3765:23;3761:32;3758:2;;;3811:6;3803;3796:22;3758:2;3848:9;3842:16;3867:32;3893:5;3867:32;:::i;3934:344::-;;4056:2;4044:9;4035:7;4031:23;4027:32;4024:2;;;4077:6;4069;4062:22;4024:2;4122:9;4109:23;4155:18;4147:6;4144:30;4141:2;;;4192:6;4184;4177:22;4141:2;4220:52;4264:7;4255:6;4244:9;4240:22;4220:52;:::i;4283:190::-;;4395:2;4383:9;4374:7;4370:23;4366:32;4363:2;;;4416:6;4408;4401:22;4363:2;-1:-1:-1;4444:23:1;;4353:120;-1:-1:-1;4353:120:1:o;4478:412::-;;;4617:2;4605:9;4596:7;4592:23;4588:32;4585:2;;;4638:6;4630;4623:22;4585:2;4679:9;4666:23;4656:33;;4740:2;4729:9;4725:18;4712:32;4767:18;4759:6;4756:30;4753:2;;;4804:6;4796;4789:22;4753:2;4832:52;4876:7;4867:6;4856:9;4852:22;4832:52;:::i;:::-;4822:62;;;4575:315;;;;;:::o;4895:259::-;;4976:5;4970:12;5003:6;4998:3;4991:19;5019:63;5075:6;5068:4;5063:3;5059:14;5052:4;5045:5;5041:16;5019:63;:::i;:::-;5136:2;5115:15;-1:-1:-1;;5111:29:1;5102:39;;;;5143:4;5098:50;;4946:208;-1:-1:-1;;4946:208:1:o;5159:274::-;;5326:6;5320:13;5342:53;5388:6;5383:3;5376:4;5368:6;5364:17;5342:53;:::i;:::-;5411:16;;;;;5296:137;-1:-1:-1;;5296:137:1:o;5438:830::-;;5597:3;5632:6;5626:13;5658:1;5690:2;5679:9;5675:18;5707:1;5702:126;;;;5842:1;5837:406;;;;5668:575;;5702:126;-1:-1:-1;;5735:24:1;;5723:37;;5808:1;5793:17;;5812:4;5789:28;5780:38;;;-1:-1:-1;5702:126:1;;5837:406;5887:1;5876:9;5872:17;5914:6;5909:3;5902:19;5944:4;5991:2;5986:3;5976:18;6016:3;6032:165;6046:6;6043:1;6040:13;6032:165;;;6124:14;;6111:11;;;6104:35;6167:16;;;;6061:10;;6032:165;;;-1:-1:-1;;;6217:16:1;;;-1:-1:-1;5668:575:1;-1:-1:-1;6259:3:1;;5576:692;-1:-1:-1;;;;;5576:692:1:o;6273:470::-;;6490:6;6484:13;6506:53;6552:6;6547:3;6540:4;6532:6;6528:17;6506:53;:::i;:::-;6622:13;;6581:16;;;;6644:57;6622:13;6581:16;6678:4;6666:17;;6644:57;:::i;:::-;6717:20;;6460:283;-1:-1:-1;;;;6460:283:1:o;6748:203::-;-1:-1:-1;;;;;6912:32:1;;;;6894:51;;6882:2;6867:18;;6849:102::o;6956:506::-;-1:-1:-1;;;;;7241:15:1;;;7223:34;;7293:15;;7288:2;7273:18;;7266:43;7340:2;7325:18;;7318:34;;;7388:3;7383:2;7368:18;;7361:31;;;6956:506;;7409:47;;7436:19;;7428:6;7409:47;:::i;:::-;7401:55;7175:287;-1:-1:-1;;;;;;7175:287:1:o;7467:397::-;;7709:1;7705;7700:3;7696:11;7692:19;7684:6;7680:32;7669:9;7662:51;7749:6;7744:2;7733:9;7729:18;7722:34;7792:2;7787;7776:9;7772:18;7765:30;7812:46;7854:2;7843:9;7839:18;7831:6;7812:46;:::i;:::-;7804:54;7652:212;-1:-1:-1;;;;;7652:212:1:o;7869:808::-;;8060:2;8100;8089:9;8085:18;8130:2;8119:9;8112:21;8153:6;8188;8182:13;8219:6;8211;8204:22;8257:2;8246:9;8242:18;8235:25;;8320:2;8314;8306:6;8302:15;8291:9;8287:31;8283:40;8269:54;;8358:2;8350:6;8346:15;8379:4;8392:256;8406:6;8403:1;8400:13;8392:256;;;8499:2;8495:7;8483:9;8475:6;8471:22;8467:36;8462:3;8455:49;8527:41;8561:6;8552;8546:13;8527:41;:::i;:::-;8517:51;-1:-1:-1;8626:12:1;;;;8591:15;;;;8428:1;8421:9;8392:256;;;-1:-1:-1;8665:6:1;;8040:637;-1:-1:-1;;;;;;;8040:637:1:o;8682:635::-;8853:2;8905:21;;;8975:13;;8878:18;;;8997:22;;;8682:635;;8853:2;9076:15;;;;9050:2;9035:18;;;8682:635;9122:169;9136:6;9133:1;9130:13;9122:169;;;9197:13;;9185:26;;9266:15;;;;9231:12;;;;9158:1;9151:9;9122:169;;;-1:-1:-1;9308:3:1;;8833:484;-1:-1:-1;;;;;;8833:484:1:o;9322:187::-;9487:14;;9480:22;9462:41;;9450:2;9435:18;;9417:92::o;9514:221::-;;9663:2;9652:9;9645:21;9683:46;9725:2;9714:9;9710:18;9702:6;9683:46;:::i;9740:398::-;9942:2;9924:21;;;9981:2;9961:18;;;9954:30;10020:34;10015:2;10000:18;;9993:62;-1:-1:-1;;;10086:2:1;10071:18;;10064:32;10128:3;10113:19;;9914:224::o;10143:412::-;10345:2;10327:21;;;10384:2;10364:18;;;10357:30;10423:34;10418:2;10403:18;;10396:62;-1:-1:-1;;;10489:2:1;10474:18;;10467:46;10545:3;10530:19;;10317:238::o;10560:414::-;10762:2;10744:21;;;10801:2;10781:18;;;10774:30;10840:34;10835:2;10820:18;;10813:62;-1:-1:-1;;;10906:2:1;10891:18;;10884:48;10964:3;10949:19;;10734:240::o;10979:414::-;11181:2;11163:21;;;11220:2;11200:18;;;11193:30;11259:34;11254:2;11239:18;;11232:62;-1:-1:-1;;;11325:2:1;11310:18;;11303:48;11383:3;11368:19;;11153:240::o;11398:402::-;11600:2;11582:21;;;11639:2;11619:18;;;11612:30;11678:34;11673:2;11658:18;;11651:62;-1:-1:-1;;;11744:2:1;11729:18;;11722:36;11790:3;11775:19;;11572:228::o;11805:352::-;12007:2;11989:21;;;12046:2;12026:18;;;12019:30;12085;12080:2;12065:18;;12058:58;12148:2;12133:18;;11979:178::o;12162:351::-;12364:2;12346:21;;;12403:2;12383:18;;;12376:30;12442:29;12437:2;12422:18;;12415:57;12504:2;12489:18;;12336:177::o;12518:356::-;12720:2;12702:21;;;12739:18;;;12732:30;12798:34;12793:2;12778:18;;12771:62;12865:2;12850:18;;12692:182::o;12879:400::-;13081:2;13063:21;;;13120:2;13100:18;;;13093:30;13159:34;13154:2;13139:18;;13132:62;-1:-1:-1;;;13225:2:1;13210:18;;13203:34;13269:3;13254:19;;13053:226::o;13284:349::-;13486:2;13468:21;;;13525:2;13505:18;;;13498:30;13564:27;13559:2;13544:18;;13537:55;13624:2;13609:18;;13458:175::o;13638:355::-;13840:2;13822:21;;;13879:2;13859:18;;;13852:30;13918:33;13913:2;13898:18;;13891:61;13984:2;13969:18;;13812:181::o;13998:354::-;14200:2;14182:21;;;14239:2;14219:18;;;14212:30;14278:32;14273:2;14258:18;;14251:60;14343:2;14328:18;;14172:180::o;14764:408::-;14966:2;14948:21;;;15005:2;14985:18;;;14978:30;15044:34;15039:2;15024:18;;15017:62;-1:-1:-1;;;15110:2:1;15095:18;;15088:42;15162:3;15147:19;;14938:234::o;15177:420::-;15379:2;15361:21;;;15418:2;15398:18;;;15391:30;15457:34;15452:2;15437:18;;15430:62;15528:26;15523:2;15508:18;;15501:54;15587:3;15572:19;;15351:246::o;15602:406::-;15804:2;15786:21;;;15843:2;15823:18;;;15816:30;15882:34;15877:2;15862:18;;15855:62;-1:-1:-1;;;15948:2:1;15933:18;;15926:40;15998:3;15983:19;;15776:232::o;16013:406::-;16215:2;16197:21;;;16254:2;16234:18;;;16227:30;16293:34;16288:2;16273:18;;16266:62;-1:-1:-1;;;16359:2:1;16344:18;;16337:40;16409:3;16394:19;;16187:232::o;16424:398::-;16626:2;16608:21;;;16665:2;16645:18;;;16638:30;16704:34;16699:2;16684:18;;16677:62;-1:-1:-1;;;16770:2:1;16755:18;;16748:32;16812:3;16797:19;;16598:224::o;16827:356::-;17029:2;17011:21;;;17048:18;;;17041:30;17107:34;17102:2;17087:18;;17080:62;17174:2;17159:18;;17001:182::o;17188:397::-;17390:2;17372:21;;;17429:2;17409:18;;;17402:30;17468:34;17463:2;17448:18;;17441:62;-1:-1:-1;;;17534:2:1;17519:18;;17512:31;17575:3;17560:19;;17362:223::o;17590:408::-;17792:2;17774:21;;;17831:2;17811:18;;;17804:30;17870:34;17865:2;17850:18;;17843:62;-1:-1:-1;;;17936:2:1;17921:18;;17914:42;17988:3;17973:19;;17764:234::o;18003:356::-;18205:2;18187:21;;;18224:18;;;18217:30;18283:34;18278:2;18263:18;;18256:62;18350:2;18335:18;;18177:182::o;18364:405::-;18566:2;18548:21;;;18605:2;18585:18;;;18578:30;18644:34;18639:2;18624:18;;18617:62;-1:-1:-1;;;18710:2:1;18695:18;;18688:39;18759:3;18744:19;;18538:231::o;18774:411::-;18976:2;18958:21;;;19015:2;18995:18;;;18988:30;19054:34;19049:2;19034:18;;19027:62;-1:-1:-1;;;19120:2:1;19105:18;;19098:45;19175:3;19160:19;;18948:237::o;19190:399::-;19392:2;19374:21;;;19431:2;19411:18;;;19404:30;19470:34;19465:2;19450:18;;19443:62;-1:-1:-1;;;19536:2:1;19521:18;;19514:33;19579:3;19564:19;;19364:225::o;19594:397::-;19796:2;19778:21;;;19835:2;19815:18;;;19808:30;19874:34;19869:2;19854:18;;19847:62;-1:-1:-1;;;19940:2:1;19925:18;;19918:31;19981:3;19966:19;;19768:223::o;19996:413::-;20198:2;20180:21;;;20237:2;20217:18;;;20210:30;20276:34;20271:2;20256:18;;20249:62;-1:-1:-1;;;20342:2:1;20327:18;;20320:47;20399:3;20384:19;;20170:239::o;20414:353::-;20616:2;20598:21;;;20655:2;20635:18;;;20628:30;20694:31;20689:2;20674:18;;20667:59;20758:2;20743:18;;20588:179::o;20772:399::-;20974:2;20956:21;;;21013:2;20993:18;;;20986:30;21052:34;21047:2;21032:18;;21025:62;-1:-1:-1;;;21118:2:1;21103:18;;21096:33;21161:3;21146:19;;20946:225::o;21176:397::-;21378:2;21360:21;;;21417:2;21397:18;;;21390:30;21456:34;21451:2;21436:18;;21429:62;-1:-1:-1;;;21522:2:1;21507:18;;21500:31;21563:3;21548:19;;21350:223::o;21578:177::-;21724:25;;;21712:2;21697:18;;21679:76::o;21760:258::-;21832:1;21842:113;21856:6;21853:1;21850:13;21842:113;;;21932:11;;;21926:18;21913:11;;;21906:39;21878:2;21871:10;21842:113;;;21973:6;21970:1;21967:13;21964:2;;;-1:-1:-1;;22008:1:1;21990:16;;21983:27;21813:205::o;22023:133::-;-1:-1:-1;;;;;;22099:32:1;;22089:43;;22079:2;;22146:1;22143;22136:12

Swarm Source

ipfs://dbb33c94e3117fdd620079752eb3939017e2117409038f0e891bfd9c661527f4

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

Tools & Services