Token

DRRT (DRRT)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

NFT

Overview

Max Total Supply

2,021 DRRT

Holders

685

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xf506f1ab233c72a424f1b83e055cbfb0ca0dbca1

Filtered by Token Holder

0x79322e3d7133BF9d3b886e6adD1Fc65e0DcC60AF

Balance

3 DRRT

0x79322e3d7133bf9d3b886e6add1fc65e0dcc60af

OVERVIEW

DRRT is a collection of Unique Robots, each one representing a social token to a community powered record label.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Drrt

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-10-15
*/

// Sources flattened with hardhat v2.6.1 https://hardhat.org

// File @openzeppelin/contracts/utils/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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


// File @openzeppelin/contracts/access/[email protected]



pragma solidity ^0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/utils/[email protected]



pragma solidity ^0.8.0;

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

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

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

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

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


// File @openzeppelin/contracts/utils/[email protected]



pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    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;
        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");

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/utils/math/[email protected]



pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/utils/structs/[email protected]



pragma solidity ^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;

            if (lastIndex != toDeleteIndex) {
                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] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // 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) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}


// File @openzeppelin/contracts/utils/structs/[email protected]



pragma solidity ^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 {
    using EnumerableSet for EnumerableSet.Bytes32Set;

    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct Map {
        // Storage of keys
        EnumerableSet.Bytes32Set _keys;
        mapping(bytes32 => bytes32) _values;
    }

    /**
     * @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) {
        map._values[key] = value;
        return map._keys.add(key);
    }

    /**
     * @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) {
        delete map._values[key];
        return map._keys.remove(key);
    }

    /**
     * @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._keys.contains(key);
    }

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

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

    /**
     * @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) {
        bytes32 value = map._values[key];
        if (value == bytes32(0)) {
            return (_contains(map, key), bytes32(0));
        } else {
            return (true, value);
        }
    }

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

    /**
     * @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) {
        bytes32 value = map._values[key];
        require(value != 0 || _contains(map, key), errorMessage);
        return value;
    }

    // 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/introspection/[email protected]



pragma solidity ^0.8.0;

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


// File @openzeppelin/contracts/token/ERC721/[email protected]



pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]



pragma solidity ^0.8.0;

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

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

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


// File contracts/ERC165.sol



pragma solidity ^0.8.7;


contract ERC165 is IERC165 {
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () {
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}


// File contracts/Drrt.sol



pragma solidity ^0.8.7;








interface IERC721Metadata is IERC721 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
}

interface IERC721Receiver {
    function onERC721Received(address operator, address from, uint tokenIndex, bytes calldata data) external returns (bytes4);
}

contract Drrt is Context, ERC165, Ownable, IERC721Metadata {
    using SafeMath for uint;
    using Strings for uint;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;

    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x93254542;

    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;

    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

    uint public constant MAX_TOKENS_MINT_AT_ONCE = 10;

    uint public constant MAX_TOKENS_SUPPLY = 9090;

    uint public constant TOKEN_PRICE = 60000000000000000;

    uint public constant TOKEN_REDUCED_PRICE = 50000000000000000;

    uint private constant MAX_GIVEAWAY_TOKENS = 110;

    string private constant NAME = 'DRRT';

    string private constant SYMBOL = 'DRRT';

    uint private _saleStart;

    string private _baseURI;

    uint private _givenTokens;

    EnumerableMap.UintToAddressMap private _tokenOwners;

    mapping (address => EnumerableSet.UintSet) private _holderTokens;

    mapping (uint => address) private _tokenApprovals;

    mapping (address => mapping (address => bool)) private _operatorApprovals;

    constructor() {
        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

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

        return _holderTokens[tokenOowner].length();
    }

    /**
     * @dev Gets the owner of the specified token ID.
     * @param tokenIndex uint256 ID of the token to query the owner of
     * @return address currently marked as the owner of the given token ID
    */
    function ownerOf(uint tokenIndex) public view override returns (address) {
        return _tokenOwners.get(tokenIndex, "ERC721: owner query for nonexistent token");
    }

    /**
     * @dev A descriptive name for a collection of NFTs in this contract
     *
     * @return descriptive name.
    */
    function name() external pure override returns (string memory) {
        return NAME;
    }

    /**
     * @dev An abbreviated name for NFTs in this contract
     *
     * @return abbreviated name (symbol).
    */
    function symbol() external pure override returns (string memory) {
        return SYMBOL;
    }

    /**
     * @dev function to set the base URI of the collection
     *
     * @param baseURI base URI string.
    */
    function setBaseURI(string memory baseURI) external onlyOwner {
        _baseURI = baseURI;
    }

    /**
     * @dev Returns the NFT index owned by the user
     *
     * @param tokenOowner address.
     * @param index Index in the list of owned tokens by address.
     *
     * @return token index in the collection.
    */
    function tokenOfOwnerByIndex(address tokenOowner, uint index) external view returns (uint) {
        return _holderTokens[tokenOowner].at(index);
    }

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     *
     * @return total amount of tokens.
    */
    function totalSupply() public view returns (uint) {
        return _tokenOwners.length();
    }

    /**
     * @dev Starts the sale of NFTs
    */
    function startSale() external onlyOwner {
        require(_saleStart == 0, "Sale already started");

        _saleStart = block.timestamp;
    }

    /**
     * @dev Function checks if the sale already started
     *
     * @return true if sale started or false if sale not started.
    */
    function isSaleStarted() external view returns (bool) {
        return _saleStart > 0;
    }

    /**
     * @dev Function mints one giveaway NFT and sends to the address
     *
     * @param to address of NFT reciever.
    */
    function mintGiveaway(address to) external onlyOwner {
        require(_givenTokens <= MAX_GIVEAWAY_TOKENS, "Giveaway limit exceeded");

        _givenTokens++;

        _safeMint(to, totalSupply());
    }

    /**
     * @dev Function mints the amount of NFTs and sends them to the executor's address
     *
     * @param tokenAmount amount of NFTs for minting.
    */
    function mint(uint tokenAmount) external payable {
        require(_saleStart != 0, "Sale is not started");
        require(tokenAmount > 0, "Tokens amount cannot be 0");
        require(totalSupply().add(tokenAmount) - _givenTokens <= MAX_TOKENS_SUPPLY - MAX_GIVEAWAY_TOKENS, "Purchase would exceed max supply");
        require(tokenAmount <= MAX_TOKENS_MINT_AT_ONCE, "Can only mint 10 tokens per request");

        uint price;

        if (block.timestamp < _saleStart + 86400) {
            price = TOKEN_REDUCED_PRICE * tokenAmount;
        } else {
            price = TOKEN_PRICE * tokenAmount;
        }

        require(msg.value >= price, "Ether value sent is not correct");

        for (uint i = 0; i < tokenAmount; i++) {
            _safeMint(_msgSender(), totalSupply());
        }

        if (msg.value - price > 0) {
            payable(_msgSender()).transfer(msg.value - price);
        }
    }

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

        return bytes(_baseURI).length != 0 ? string(abi.encodePacked(_baseURI, tokenIndex.toString())) : "";
    }

    /**
     * @dev Transfers all founds to the owner's address
     * Can only be called by the owner of the contract.
    */
    function withdraw() onlyOwner external {
        uint balance = address(this).balance;
        if (balance > 0) {
            payable(_msgSender()).transfer(balance);
        }
    }

    /**
     * @dev Approves another address to transfer the given token ID
     * Can only be called by the token owner or an approved operator.
     * @param to address to be approved for the given token ID
     * @param tokenIndex uint256 ID of the token to be approved
    */
    function approve(address to, uint tokenIndex) external virtual override {
        address tokenOowner = ownerOf(tokenIndex);

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

        _approve(to, tokenIndex);
    }

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

        return _tokenApprovals[tokenIndex];
    }

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

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

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

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

        _transfer(from, to, tokenIndex);
    }

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

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

    /**
     * @dev Internal function for safe transfer
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenIndex uint256 ID of the token to be transferred
     * @param _data bytes data to send along with a safe transfer check
    */
    function _safeTransfer(address from, address to, uint tokenIndex, bytes memory _data) internal virtual {
        _transfer(from, to, tokenIndex);
        require(_checkOnERC721Received(from, to, tokenIndex, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether the specified token exists.
     * @param tokenIndex uint256 ID of the token to query the existence of
     * @return bool whether the token exists
    */
    function _exists(uint tokenIndex) internal view returns (bool) {
        return _tokenOwners.contains(tokenIndex);
    }

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

    /**
     * @dev Internal function to safely mint a new token.
     * Reverts if the given token ID already exists.
     * @param to The address that will own the minted token
     * @param tokenIndex uint256 ID of the token to be minted
     */
    function _safeMint(address to, uint tokenIndex) internal virtual {
        _safeMint(to, tokenIndex, "");
    }

    /**
     * @dev Internal function to safely mint a new token.
     * Reverts if the given token ID already exists.
     * @param to The address that will own the minted token
     * @param tokenIndex uint256 ID of the token to be minted
     * @param _data bytes data to send along with a safe transfer check
     */
    function _safeMint(address to, uint tokenIndex, bytes memory _data) internal virtual {
        _mint(to, tokenIndex);
        require(_checkOnERC721Received(address(0), to, tokenIndex, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

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

        _beforeTokenTransfer(address(0), to, tokenIndex);
        _holderTokens[to].add(tokenIndex);
        _tokenOwners.set(tokenIndex, to);

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

    /**
     * @dev Internal function for transfer
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenIndex uint256 ID of the token to be transferred
    */
    function _transfer(address from, address to, uint tokenIndex) internal virtual {
        require(ownerOf(tokenIndex) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenIndex);
        _approve(address(0), tokenIndex);
        _holderTokens[from].remove(tokenIndex);
        _holderTokens[to].add(tokenIndex);
        _tokenOwners.set(tokenIndex, to);

        emit Transfer(from, to, tokenIndex);
    }

    /**
     * @dev Internal function to invoke `onERC721Received` on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * This function is deprecated.
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenIndex 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, uint tokenIndex, bytes memory _data) private returns (bool) {
        if (!to.isContract()) return true;
        bytes memory returndata = to.functionCall(abi.encodeWithSelector(
                IERC721Receiver(to).onERC721Received.selector,
                _msgSender(),
                from,
                tokenIndex,
                _data
            ), "ERC721: transfer to non ERC721Receiver implementer");
        bytes4 retval = abi.decode(returndata, (bytes4));

        return (retval == _ERC721_RECEIVED);
    }

    /**
     * @dev Internal function for approve another address to transfer the given token ID
     * @param to address to be approved for the given token ID
     * @param tokenIndex uint256 ID of the token to be approved
    */
    function _approve(address to, uint tokenIndex) private {
        _tokenApprovals[tokenIndex] = to;
        emit Approval(ownerOf(tokenIndex), to, tokenIndex);
    }

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

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"},{"inputs":[],"name":"MAX_TOKENS_MINT_AT_ONCE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TOKENS_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN_REDUCED_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenIndex","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenOowner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenIndex","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenOowner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isSaleStarted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"mintGiveaway","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenIndex","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenIndex","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":"tokenIndex","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startSale","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":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"tokenOowner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenIndex","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenIndex","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

60806040523480156200001157600080fd5b506200002a6301ffc9a760e01b6200009860201b60201c565b6200004a6200003e6200017060201b60201c565b6200017860201b60201c565b620000626380ac58cd60e01b6200009860201b60201c565b6200007a639325454260e01b6200009860201b60201c565b6200009263780e9d6360e01b6200009860201b60201c565b620002c1565b63ffffffff60e01b817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916141562000104576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000fb9062000265565b60405180910390fd5b6001600080837bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190815260200160002060006101000a81548160ff02191690831515021790555050565b600033905090565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b60006200024d601c8362000287565b91506200025a8262000298565b602082019050919050565b6000602082019050818103600083015262000280816200023e565b9050919050565b600082825260208201905092915050565b7f4552433136353a20696e76616c696420696e7465726661636520696400000000600082015250565b613dac80620002d16000396000f3fe6080604052600436106101b75760003560e01c8063715018a6116100ec578063b66a0e5d1161008a578063c87b56dd11610064578063c87b56dd146105c5578063d2d8cb6714610602578063e985e9c51461062d578063f2fde38b1461066a576101b7565b8063b66a0e5d1461055a578063b88d4fde14610571578063c70a72221461059a576101b7565b806395d89b41116100c657806395d89b41146104c1578063a0712d68146104ec578063a22cb46514610508578063ab06350414610531576101b7565b8063715018a6146104545780637fa31b821461046b5780638da5cb5b14610496576101b7565b80632f745c591161015957806342842e0e1161013357806342842e0e1461038857806355f804b3146103b15780636352211e146103da57806370a0823114610417576101b7565b80632f745c59146103095780633b80b7d3146103465780633ccfd60b14610371576101b7565b8063095ea7b311610195578063095ea7b3146102615780631452cfa61461028a57806318160ddd146102b557806323b872dd146102e0576101b7565b806301ffc9a7146101bc57806306fdde03146101f9578063081812fc14610224575b600080fd5b3480156101c857600080fd5b506101e360048036038101906101de91906128bc565b610693565b6040516101f09190612ef6565b60405180910390f35b34801561020557600080fd5b5061020e6106fa565b60405161021b9190612f11565b60405180910390f35b34801561023057600080fd5b5061024b6004803603810190610246919061295f565b610737565b6040516102589190612e8f565b60405180910390f35b34801561026d57600080fd5b506102886004803603810190610283919061287c565b6107bc565b005b34801561029657600080fd5b5061029f6108d4565b6040516102ac9190613233565b60405180910390f35b3480156102c157600080fd5b506102ca6108df565b6040516102d79190613233565b60405180910390f35b3480156102ec57600080fd5b5061030760048036038101906103029190612766565b6108f0565b005b34801561031557600080fd5b50610330600480360381019061032b919061287c565b610950565b60405161033d9190613233565b60405180910390f35b34801561035257600080fd5b5061035b6109ab565b6040516103689190612ef6565b60405180910390f35b34801561037d57600080fd5b506103866109b7565b005b34801561039457600080fd5b506103af60048036038101906103aa9190612766565b610a93565b005b3480156103bd57600080fd5b506103d860048036038101906103d39190612916565b610ab3565b005b3480156103e657600080fd5b5061040160048036038101906103fc919061295f565b610b49565b60405161040e9190612e8f565b60405180910390f35b34801561042357600080fd5b5061043e600480360381019061043991906126f9565b610b80565b60405161044b9190613233565b60405180910390f35b34801561046057600080fd5b50610469610c3f565b005b34801561047757600080fd5b50610480610cc7565b60405161048d9190613233565b60405180910390f35b3480156104a257600080fd5b506104ab610ccd565b6040516104b89190612e8f565b60405180910390f35b3480156104cd57600080fd5b506104d6610cf7565b6040516104e39190612f11565b60405180910390f35b6105066004803603810190610501919061295f565b610d34565b005b34801561051457600080fd5b5061052f600480360381019061052a919061283c565b610fae565b005b34801561053d57600080fd5b50610558600480360381019061055391906126f9565b61112f565b005b34801561056657600080fd5b5061056f61121d565b005b34801561057d57600080fd5b50610598600480360381019061059391906127b9565b6112e7565b005b3480156105a657600080fd5b506105af611349565b6040516105bc9190613233565b60405180910390f35b3480156105d157600080fd5b506105ec60048036038101906105e7919061295f565b61134e565b6040516105f99190612f11565b60405180910390f35b34801561060e57600080fd5b506106176113f7565b6040516106249190613233565b60405180910390f35b34801561063957600080fd5b50610654600480360381019061064f9190612726565b611402565b6040516106619190612ef6565b60405180910390f35b34801561067657600080fd5b50610691600480360381019061068c91906126f9565b611496565b005b6000806000837bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19167bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190815260200160002060009054906101000a900460ff169050919050565b60606040518060400160405280600481526020017f4452525400000000000000000000000000000000000000000000000000000000815250905090565b60006107428261158e565b610781576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161077890613133565b60405180910390fd5b6009600083815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b60006107c782610b49565b90508073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610838576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161082f906131b3565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff166108576115ab565b73ffffffffffffffffffffffffffffffffffffffff1614806108865750610885816108806115ab565b611402565b5b6108c5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108bc906130b3565b60405180910390fd5b6108cf83836115b3565b505050565b66b1a2bc2ec5000081565b60006108eb600561166c565b905090565b6109016108fb6115ab565b82611681565b610940576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610937906131d3565b60405180910390fd5b61094b83838361175f565b505050565b60006109a382600860008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061197690919063ffffffff16565b905092915050565b60008060025411905090565b6109bf6115ab565b73ffffffffffffffffffffffffffffffffffffffff166109dd610ccd565b73ffffffffffffffffffffffffffffffffffffffff1614610a33576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a2a90613153565b60405180910390fd5b60004790506000811115610a9057610a496115ab565b73ffffffffffffffffffffffffffffffffffffffff166108fc829081150290604051600060405180830381858888f19350505050158015610a8e573d6000803e3d6000fd5b505b50565b610aae838383604051806020016040528060008152506112e7565b505050565b610abb6115ab565b73ffffffffffffffffffffffffffffffffffffffff16610ad9610ccd565b73ffffffffffffffffffffffffffffffffffffffff1614610b2f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b2690613153565b60405180910390fd5b8060039080519060200190610b4592919061250d565b5050565b6000610b7982604051806060016040528060298152602001613d4e6029913960056119909092919063ffffffff16565b9050919050565b60008073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610bf1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610be8906130d3565b60405180910390fd5b610c38600860008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206119af565b9050919050565b610c476115ab565b73ffffffffffffffffffffffffffffffffffffffff16610c65610ccd565b73ffffffffffffffffffffffffffffffffffffffff1614610cbb576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610cb290613153565b60405180910390fd5b610cc560006119c4565b565b61238281565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b60606040518060400160405280600481526020017f4452525400000000000000000000000000000000000000000000000000000000815250905090565b60006002541415610d7a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d7190613033565b60405180910390fd5b60008111610dbd576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610db490613193565b60405180910390fd5b606e612382610dcc9190613419565b600454610de983610ddb6108df565b611a8a90919063ffffffff16565b610df39190613419565b1115610e34576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e2b906130f3565b60405180910390fd5b600a811115610e78576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e6f90612f33565b60405180910390fd5b600062015180600254610e8b9190613338565b421015610eac578166b1a2bc2ec50000610ea591906133bf565b9050610ec2565b8166d529ae9e860000610ebf91906133bf565b90505b80341015610f05576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610efc90612ff3565b60405180910390fd5b60005b82811015610f3b57610f28610f1b6115ab565b610f236108df565b611aa0565b8080610f3390613566565b915050610f08565b5060008134610f4a9190613419565b1115610faa57610f586115ab565b73ffffffffffffffffffffffffffffffffffffffff166108fc8234610f7d9190613419565b9081150290604051600060405180830381858888f19350505050158015610fa8573d6000803e3d6000fd5b505b5050565b610fb66115ab565b73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611024576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161101b90612fd3565b60405180910390fd5b80600a60006110316115ab565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508173ffffffffffffffffffffffffffffffffffffffff166110de6115ab565b73ffffffffffffffffffffffffffffffffffffffff167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31836040516111239190612ef6565b60405180910390a35050565b6111376115ab565b73ffffffffffffffffffffffffffffffffffffffff16611155610ccd565b73ffffffffffffffffffffffffffffffffffffffff16146111ab576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016111a290613153565b60405180910390fd5b606e60045411156111f1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016111e890613053565b60405180910390fd5b6004600081548092919061120490613566565b919050555061121a816112156108df565b611aa0565b50565b6112256115ab565b73ffffffffffffffffffffffffffffffffffffffff16611243610ccd565b73ffffffffffffffffffffffffffffffffffffffff1614611299576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161129090613153565b60405180910390fd5b6000600254146112de576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112d590613213565b60405180910390fd5b42600281905550565b6112f86112f26115ab565b83611681565b611337576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161132e906131d3565b60405180910390fd5b61134384848484611abe565b50505050565b600a81565b60606113598261158e565b611398576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161138f90613013565b60405180910390fd5b6000600380546113a790613503565b905014156113c457604051806020016040528060008152506113f0565b60036113cf83611b1a565b6040516020016113e0929190612e6b565b6040516020818303038152906040525b9050919050565b66d529ae9e86000081565b6000600a60008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16905092915050565b61149e6115ab565b73ffffffffffffffffffffffffffffffffffffffff166114bc610ccd565b73ffffffffffffffffffffffffffffffffffffffff1614611512576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161150990613153565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611582576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161157990612f73565b60405180910390fd5b61158b816119c4565b50565b60006115a4826005611c7b90919063ffffffff16565b9050919050565b600033905090565b816009600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff1661162683610b49565b73ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b600061167a82600001611c95565b9050919050565b600061168c8261158e565b6116cb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116c290613093565b60405180910390fd5b60006116d683610b49565b90508073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16148061174557508373ffffffffffffffffffffffffffffffffffffffff1661172d84610737565b73ffffffffffffffffffffffffffffffffffffffff16145b8061175657506117558185611402565b5b91505092915050565b8273ffffffffffffffffffffffffffffffffffffffff1661177f82610b49565b73ffffffffffffffffffffffffffffffffffffffff16146117d5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117cc90613173565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611845576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161183c90612fb3565b60405180910390fd5b611850838383611caa565b61185b6000826115b3565b6118ac81600860008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020611caf90919063ffffffff16565b506118fe81600860008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020611cc990919063ffffffff16565b5061191581836005611ce39092919063ffffffff16565b50808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4505050565b60006119858360000183611d18565b60001c905092915050565b60006119a3846000018460001b84611d43565b60001c90509392505050565b60006119bd82600001611dc4565b9050919050565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b60008183611a989190613338565b905092915050565b611aba828260405180602001604052806000815250611dd5565b5050565b611ac984848461175f565b611ad584848484611e30565b611b14576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b0b90612f53565b60405180910390fd5b50505050565b60606000821415611b62576040518060400160405280600181526020017f30000000000000000000000000000000000000000000000000000000000000008152509050611c76565b600082905060005b60008214611b94578080611b7d90613566565b915050600a82611b8d919061338e565b9150611b6a565b60008167ffffffffffffffff811115611bb057611baf6136cb565b5b6040519080825280601f01601f191660200182016040528015611be25781602001600182028036833780820191505090505b5090505b60008514611c6f57600182611bfb9190613419565b9150600a85611c0a91906135af565b6030611c169190613338565b60f81b818381518110611c2c57611c2b61369c565b5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350600a85611c68919061338e565b9450611be6565b8093505050505b919050565b6000611c8d836000018360001b611f94565b905092915050565b6000611ca382600001611fb4565b9050919050565b505050565b6000611cc1836000018360001b611fc9565b905092915050565b6000611cdb836000018360001b6120dd565b905092915050565b6000611d0f846000018460001b8473ffffffffffffffffffffffffffffffffffffffff1660001b61214d565b90509392505050565b6000826000018281548110611d3057611d2f61369c565b5b9060005260206000200154905092915050565b6000808460020160008581526020019081526020016000205490506000801b81141580611d765750611d758585611f94565b5b8390611db8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611daf9190612f11565b60405180910390fd5b50809150509392505050565b600081600001805490509050919050565b611ddf8383612188565b611dec6000848484611e30565b611e2b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e2290612f53565b60405180910390fd5b505050565b6000611e518473ffffffffffffffffffffffffffffffffffffffff16612316565b611e5e5760019050611f8c565b6000611f2563150b7a0260e01b611e736115ab565b888787604051602401611e899493929190612eaa565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050604051806060016040528060328152602001613d1c603291398773ffffffffffffffffffffffffffffffffffffffff166123299092919063ffffffff16565b9050600081806020019051810190611f3d91906128e9565b905063150b7a0260e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191614925050505b949350505050565b6000611fac828460000161234190919063ffffffff16565b905092915050565b6000611fc282600001611dc4565b9050919050565b600080836001016000848152602001908152602001600020549050600081146120d1576000600182611ffb9190613419565b90506000600186600001805490506120139190613419565b90508181146120825760008660000182815481106120345761203361369c565b5b90600052602060002001549050808760000184815481106120585761205761369c565b5b90600052602060002001819055508387600101600083815260200190815260200160002081905550505b856000018054806120965761209561366d565b5b6001900381819060005260206000200160009055905585600101600086815260200190815260200160002060009055600193505050506120d7565b60009150505b92915050565b60006120e98383612358565b612142578260000182908060018154018082558091505060019003906000526020600020016000909190919091505582600001805490508360010160008481526020019081526020016000208190555060019050612147565b600090505b92915050565b6000818460020160008581526020019081526020016000208190555061217f838560000161237b90919063ffffffff16565b90509392505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156121f8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016121ef90613113565b60405180910390fd5b6122018161158e565b15612241576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161223890612f93565b60405180910390fd5b61224d60008383611caa565b61229e81600860008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020611cc990919063ffffffff16565b506122b581836005611ce39092919063ffffffff16565b50808273ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a45050565b600080823b905060008111915050919050565b60606123388484600085612392565b90509392505050565b60006123508360000183612358565b905092915050565b600080836001016000848152602001908152602001600020541415905092915050565b600061238a83600001836120dd565b905092915050565b6060824710156123d7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016123ce90613073565b60405180910390fd5b6123e085612316565b61241f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612416906131f3565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516124489190612e54565b60006040518083038185875af1925050503d8060008114612485576040519150601f19603f3d011682016040523d82523d6000602084013e61248a565b606091505b509150915061249a8282866124a6565b92505050949350505050565b606083156124b657829050612506565b6000835111156124c95782518084602001fd5b816040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016124fd9190612f11565b60405180910390fd5b9392505050565b82805461251990613503565b90600052602060002090601f01602090048101928261253b5760008555612582565b82601f1061255457805160ff1916838001178555612582565b82800160010185558215612582579182015b82811115612581578251825591602001919060010190612566565b5b50905061258f9190612593565b5090565b5b808211156125ac576000816000905550600101612594565b5090565b60006125c36125be84613273565b61324e565b9050828152602081018484840111156125df576125de6136ff565b5b6125ea8482856134c1565b509392505050565b6000612605612600846132a4565b61324e565b905082815260208101848484011115612621576126206136ff565b5b61262c8482856134c1565b509392505050565b60008135905061264381613cbf565b92915050565b60008135905061265881613cd6565b92915050565b60008135905061266d81613ced565b92915050565b60008151905061268281613ced565b92915050565b600082601f83011261269d5761269c6136fa565b5b81356126ad8482602086016125b0565b91505092915050565b600082601f8301126126cb576126ca6136fa565b5b81356126db8482602086016125f2565b91505092915050565b6000813590506126f381613d04565b92915050565b60006020828403121561270f5761270e613709565b5b600061271d84828501612634565b91505092915050565b6000806040838503121561273d5761273c613709565b5b600061274b85828601612634565b925050602061275c85828601612634565b9150509250929050565b60008060006060848603121561277f5761277e613709565b5b600061278d86828701612634565b935050602061279e86828701612634565b92505060406127af868287016126e4565b9150509250925092565b600080600080608085870312156127d3576127d2613709565b5b60006127e187828801612634565b94505060206127f287828801612634565b9350506040612803878288016126e4565b925050606085013567ffffffffffffffff81111561282457612823613704565b5b61283087828801612688565b91505092959194509250565b6000806040838503121561285357612852613709565b5b600061286185828601612634565b925050602061287285828601612649565b9150509250929050565b6000806040838503121561289357612892613709565b5b60006128a185828601612634565b92505060206128b2858286016126e4565b9150509250929050565b6000602082840312156128d2576128d1613709565b5b60006128e08482850161265e565b91505092915050565b6000602082840312156128ff576128fe613709565b5b600061290d84828501612673565b91505092915050565b60006020828403121561292c5761292b613709565b5b600082013567ffffffffffffffff81111561294a57612949613704565b5b612956848285016126b6565b91505092915050565b60006020828403121561297557612974613709565b5b6000612983848285016126e4565b91505092915050565b6129958161344d565b82525050565b6129a48161345f565b82525050565b60006129b5826132ea565b6129bf8185613300565b93506129cf8185602086016134d0565b6129d88161370e565b840191505092915050565b60006129ee826132ea565b6129f88185613311565b9350612a088185602086016134d0565b80840191505092915050565b6000612a1f826132f5565b612a29818561331c565b9350612a398185602086016134d0565b612a428161370e565b840191505092915050565b6000612a58826132f5565b612a62818561332d565b9350612a728185602086016134d0565b80840191505092915050565b60008154612a8b81613503565b612a95818661332d565b94506001821660008114612ab05760018114612ac157612af4565b60ff19831686528186019350612af4565b612aca856132d5565b60005b83811015612aec57815481890152600182019150602081019050612acd565b838801955050505b50505092915050565b6000612b0a60238361331c565b9150612b158261371f565b604082019050919050565b6000612b2d60328361331c565b9150612b388261376e565b604082019050919050565b6000612b5060268361331c565b9150612b5b826137bd565b604082019050919050565b6000612b73601c8361331c565b9150612b7e8261380c565b602082019050919050565b6000612b9660248361331c565b9150612ba182613835565b604082019050919050565b6000612bb960198361331c565b9150612bc482613884565b602082019050919050565b6000612bdc601f8361331c565b9150612be7826138ad565b602082019050919050565b6000612bff60148361331c565b9150612c0a826138d6565b602082019050919050565b6000612c2260138361331c565b9150612c2d826138ff565b602082019050919050565b6000612c4560178361331c565b9150612c5082613928565b602082019050919050565b6000612c6860268361331c565b9150612c7382613951565b604082019050919050565b6000612c8b602c8361331c565b9150612c96826139a0565b604082019050919050565b6000612cae60388361331c565b9150612cb9826139ef565b604082019050919050565b6000612cd1602a8361331c565b9150612cdc82613a3e565b604082019050919050565b6000612cf460208361331c565b9150612cff82613a8d565b602082019050919050565b6000612d1760208361331c565b9150612d2282613ab6565b602082019050919050565b6000612d3a602c8361331c565b9150612d4582613adf565b604082019050919050565b6000612d5d60208361331c565b9150612d6882613b2e565b602082019050919050565b6000612d8060298361331c565b9150612d8b82613b57565b604082019050919050565b6000612da360198361331c565b9150612dae82613ba6565b602082019050919050565b6000612dc660218361331c565b9150612dd182613bcf565b604082019050919050565b6000612de960318361331c565b9150612df482613c1e565b604082019050919050565b6000612e0c601d8361331c565b9150612e1782613c6d565b602082019050919050565b6000612e2f60148361331c565b9150612e3a82613c96565b602082019050919050565b612e4e816134b7565b82525050565b6000612e6082846129e3565b915081905092915050565b6000612e778285612a7e565b9150612e838284612a4d565b91508190509392505050565b6000602082019050612ea4600083018461298c565b92915050565b6000608082019050612ebf600083018761298c565b612ecc602083018661298c565b612ed96040830185612e45565b8181036060830152612eeb81846129aa565b905095945050505050565b6000602082019050612f0b600083018461299b565b92915050565b60006020820190508181036000830152612f2b8184612a14565b905092915050565b60006020820190508181036000830152612f4c81612afd565b9050919050565b60006020820190508181036000830152612f6c81612b20565b9050919050565b60006020820190508181036000830152612f8c81612b43565b9050919050565b60006020820190508181036000830152612fac81612b66565b9050919050565b60006020820190508181036000830152612fcc81612b89565b9050919050565b60006020820190508181036000830152612fec81612bac565b9050919050565b6000602082019050818103600083015261300c81612bcf565b9050919050565b6000602082019050818103600083015261302c81612bf2565b9050919050565b6000602082019050818103600083015261304c81612c15565b9050919050565b6000602082019050818103600083015261306c81612c38565b9050919050565b6000602082019050818103600083015261308c81612c5b565b9050919050565b600060208201905081810360008301526130ac81612c7e565b9050919050565b600060208201905081810360008301526130cc81612ca1565b9050919050565b600060208201905081810360008301526130ec81612cc4565b9050919050565b6000602082019050818103600083015261310c81612ce7565b9050919050565b6000602082019050818103600083015261312c81612d0a565b9050919050565b6000602082019050818103600083015261314c81612d2d565b9050919050565b6000602082019050818103600083015261316c81612d50565b9050919050565b6000602082019050818103600083015261318c81612d73565b9050919050565b600060208201905081810360008301526131ac81612d96565b9050919050565b600060208201905081810360008301526131cc81612db9565b9050919050565b600060208201905081810360008301526131ec81612ddc565b9050919050565b6000602082019050818103600083015261320c81612dff565b9050919050565b6000602082019050818103600083015261322c81612e22565b9050919050565b60006020820190506132486000830184612e45565b92915050565b6000613258613269565b90506132648282613535565b919050565b6000604051905090565b600067ffffffffffffffff82111561328e5761328d6136cb565b5b6132978261370e565b9050602081019050919050565b600067ffffffffffffffff8211156132bf576132be6136cb565b5b6132c88261370e565b9050602081019050919050565b60008190508160005260206000209050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b600081905092915050565b6000613343826134b7565b915061334e836134b7565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115613383576133826135e0565b5b828201905092915050565b6000613399826134b7565b91506133a4836134b7565b9250826133b4576133b361360f565b5b828204905092915050565b60006133ca826134b7565b91506133d5836134b7565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048311821515161561340e5761340d6135e0565b5b828202905092915050565b6000613424826134b7565b915061342f836134b7565b925082821015613442576134416135e0565b5b828203905092915050565b600061345882613497565b9050919050565b60008115159050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b838110156134ee5780820151818401526020810190506134d3565b838111156134fd576000848401525b50505050565b6000600282049050600182168061351b57607f821691505b6020821081141561352f5761352e61363e565b5b50919050565b61353e8261370e565b810181811067ffffffffffffffff8211171561355d5761355c6136cb565b5b80604052505050565b6000613571826134b7565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8214156135a4576135a36135e0565b5b600182019050919050565b60006135ba826134b7565b91506135c5836134b7565b9250826135d5576135d461360f565b5b828206905092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f43616e206f6e6c79206d696e7420313020746f6b656e7320706572207265717560008201527f6573740000000000000000000000000000000000000000000000000000000000602082015250565b7f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560008201527f63656976657220696d706c656d656e7465720000000000000000000000000000602082015250565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000600082015250565b7f4552433732313a207472616e7366657220746f20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b7f4552433732313a20617070726f766520746f2063616c6c657200000000000000600082015250565b7f45746865722076616c75652073656e74206973206e6f7420636f727265637400600082015250565b7f546f6b656e20646f6573206e6f74206578697374000000000000000000000000600082015250565b7f53616c65206973206e6f74207374617274656400000000000000000000000000600082015250565b7f4769766561776179206c696d6974206578636565646564000000000000000000600082015250565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860008201527f697374656e7420746f6b656e0000000000000000000000000000000000000000602082015250565b7f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760008201527f6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000602082015250565b7f4552433732313a2062616c616e636520717565727920666f7220746865207a6560008201527f726f206164647265737300000000000000000000000000000000000000000000602082015250565b7f507572636861736520776f756c6420657863656564206d617820737570706c79600082015250565b7f4552433732313a206d696e7420746f20746865207a65726f2061646472657373600082015250565b7f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860008201527f697374656e7420746f6b656e0000000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b7f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960008201527f73206e6f74206f776e0000000000000000000000000000000000000000000000602082015250565b7f546f6b656e7320616d6f756e742063616e6e6f74206265203000000000000000600082015250565b7f4552433732313a20617070726f76616c20746f2063757272656e74206f776e6560008201527f7200000000000000000000000000000000000000000000000000000000000000602082015250565b7f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f60008201527f776e6572206e6f7220617070726f766564000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f53616c6520616c72656164792073746172746564000000000000000000000000600082015250565b613cc88161344d565b8114613cd357600080fd5b50565b613cdf8161345f565b8114613cea57600080fd5b50565b613cf68161346b565b8114613d0157600080fd5b50565b613d0d816134b7565b8114613d1857600080fd5b5056fe4552433732313a207472616e7366657220746f206e6f6e20455243373231526563656976657220696d706c656d656e7465724552433732313a206f776e657220717565727920666f72206e6f6e6578697374656e7420746f6b656ea2646970667358221220262d6b05dea8af807aa9dc14e280b9eccb971113f1f8ea29bf5afc51de3084b664736f6c63430008070033

Deployed Bytecode

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

Deployed Bytecode Sourcemap

48450:17815:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47686:142;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50949:93;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56032:219;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55315:422;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49175:60;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52048:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57804:258;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51750:153;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52512:94;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54834:187;;;;;;;;;;;;;:::i;:::-;;58710:154;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51407:99;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50636:172;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50176:232;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2595:94;;;;;;;;;;;;;:::i;:::-;;49060:45;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1944:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51177:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53139:937;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56557:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52752:211;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52207:148;;;;;;;;;;;;;:::i;:::-;;59585:291;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;49002:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54439:256;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;49114:52;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57187:168;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2844:192;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47686:142;47763:4;47787:20;:33;47808:11;47787:33;;;;;;;;;;;;;;;;;;;;;;;;;;;47780:40;;47686:142;;;:::o;50949:93::-;50997:13;51030:4;;;;;;;;;;;;;;;;;51023:11;;50949:93;:::o;56032:219::-;56100:7;56128:19;56136:10;56128:7;:19::i;:::-;56120:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;56216:15;:27;56232:10;56216:27;;;;;;;;;;;;;;;;;;;;;56209:34;;56032:219;;;:::o;55315:422::-;55398:19;55420;55428:10;55420:7;:19::i;:::-;55398:41;;55466:11;55460:17;;:2;:17;;;;55452:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;55550:11;55534:27;;:12;:10;:12::i;:::-;:27;;;:74;;;;55565:43;55582:11;55595:12;:10;:12::i;:::-;55565:16;:43::i;:::-;55534:74;55526:166;;;;;;;;;;;;:::i;:::-;;;;;;;;;55705:24;55714:2;55718:10;55705:8;:24::i;:::-;55387:350;55315:422;;:::o;49175:60::-;49218:17;49175:60;:::o;52048:97::-;52092:4;52116:21;:12;:19;:21::i;:::-;52109:28;;52048:97;:::o;57804:258::-;57912:44;57931:12;:10;:12::i;:::-;57945:10;57912:18;:44::i;:::-;57904:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;58023:31;58033:4;58039:2;58043:10;58023:9;:31::i;:::-;57804:258;;;:::o;51750:153::-;51835:4;51859:36;51889:5;51859:13;:26;51873:11;51859:26;;;;;;;;;;;;;;;:29;;:36;;;;:::i;:::-;51852:43;;51750:153;;;;:::o;52512:94::-;52560:4;52597:1;52584:10;;:14;52577:21;;52512:94;:::o;54834:187::-;2175:12;:10;:12::i;:::-;2164:23;;:7;:5;:7::i;:::-;:23;;;2156:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54884:12:::1;54899:21;54884:36;;54945:1;54935:7;:11;54931:83;;;54971:12;:10;:12::i;:::-;54963:30;;:39;54994:7;54963:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;54931:83;54873:148;54834:187::o:0;58710:154::-;58814:42;58831:4;58837:2;58841:10;58814:42;;;;;;;;;;;;:16;:42::i;:::-;58710:154;;;:::o;51407:99::-;2175:12;:10;:12::i;:::-;2164:23;;:7;:5;:7::i;:::-;:23;;;2156:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;51491:7:::1;51480:8;:18;;;;;;;;;;;;:::i;:::-;;51407:99:::0;:::o;50636:172::-;50700:7;50727:73;50744:10;50727:73;;;;;;;;;;;;;;;;;:12;:16;;:73;;;;;:::i;:::-;50720:80;;50636:172;;;:::o;50176:232::-;50248:4;50296:1;50273:25;;:11;:25;;;;50265:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;50365:35;:13;:26;50379:11;50365:26;;;;;;;;;;;;;;;:33;:35::i;:::-;50358:42;;50176:232;;;:::o;2595:94::-;2175:12;:10;:12::i;:::-;2164:23;;:7;:5;:7::i;:::-;:23;;;2156:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2660:21:::1;2678:1;2660:9;:21::i;:::-;2595:94::o:0;49060:45::-;49101:4;49060:45;:::o;1944:87::-;1990:7;2017:6;;;;;;;;;;;2010:13;;1944:87;:::o;51177:97::-;51227:13;51260:6;;;;;;;;;;;;;;;;;51253:13;;51177:97;:::o;53139:937::-;53221:1;53207:10;;:15;;53199:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;53279:1;53265:11;:15;53257:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;49288:3;49101:4;53378:39;;;;:::i;:::-;53362:12;;53329:30;53347:11;53329:13;:11;:13::i;:::-;:17;;:30;;;;:::i;:::-;:45;;;;:::i;:::-;:88;;53321:133;;;;;;;;;;;;:::i;:::-;;;;;;;;;49049:2;53473:11;:38;;53465:86;;;;;;;;;;;;:::i;:::-;;;;;;;;;53564:10;53622:5;53609:10;;:18;;;;:::i;:::-;53591:15;:36;53587:176;;;53674:11;49218:17;53652:33;;;;:::i;:::-;53644:41;;53587:176;;;53740:11;49149:17;53726:25;;;;:::i;:::-;53718:33;;53587:176;53796:5;53783:9;:18;;53775:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;53855:6;53850:104;53871:11;53867:1;:15;53850:104;;;53904:38;53914:12;:10;:12::i;:::-;53928:13;:11;:13::i;:::-;53904:9;:38::i;:::-;53884:3;;;;;:::i;:::-;;;;53850:104;;;;53990:1;53982:5;53970:9;:17;;;;:::i;:::-;:21;53966:103;;;54016:12;:10;:12::i;:::-;54008:30;;:49;54051:5;54039:9;:17;;;;:::i;:::-;54008:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53966:103;53188:888;53139:937;:::o;56557:295::-;56672:12;:10;:12::i;:::-;56660:24;;:8;:24;;;;56652:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;56772:8;56727:18;:32;56746:12;:10;:12::i;:::-;56727:32;;;;;;;;;;;;;;;:42;56760:8;56727:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;56825:8;56796:48;;56811:12;:10;:12::i;:::-;56796:48;;;56835:8;56796:48;;;;;;:::i;:::-;;;;;;;;56557:295;;:::o;52752:211::-;2175:12;:10;:12::i;:::-;2164:23;;:7;:5;:7::i;:::-;:23;;;2156:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;49288:3:::1;52824:12;;:35;;52816:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;52900:12;;:14;;;;;;;;;:::i;:::-;;;;;;52927:28;52937:2;52941:13;:11;:13::i;:::-;52927:9;:28::i;:::-;52752:211:::0;:::o;52207:148::-;2175:12;:10;:12::i;:::-;2164:23;;:7;:5;:7::i;:::-;:23;;;2156:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;52280:1:::1;52266:10;;:15;52258:48;;;;;;;;;;;;:::i;:::-;;;;;;;;;52332:15;52319:10;:28;;;;52207:148::o:0;59585:291::-;59717:44;59736:12;:10;:12::i;:::-;59750:10;59717:18;:44::i;:::-;59709:106;;;;;;;;;;;;:::i;:::-;;;;;;;;;59826:42;59840:4;59846:2;59850:10;59862:5;59826:13;:42::i;:::-;59585:291;;;;:::o;49002:49::-;49049:2;49002:49;:::o;54439:256::-;54497:13;54531:19;54539:10;54531:7;:19::i;:::-;54523:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;54621:1;54601:8;54595:22;;;;;:::i;:::-;;;:27;;:92;;;;;;;;;;;;;;;;;54649:8;54659:21;:10;:19;:21::i;:::-;54632:49;;;;;;;;;:::i;:::-;;;;;;;;;;;;;54595:92;54588:99;;54439:256;;;:::o;49114:52::-;49149:17;49114:52;:::o;57187:168::-;57282:4;57306:18;:31;57325:11;57306:31;;;;;;;;;;;;;;;:41;57338:8;57306:41;;;;;;;;;;;;;;;;;;;;;;;;;57299:48;;57187:168;;;;:::o;2844:192::-;2175:12;:10;:12::i;:::-;2164:23;;:7;:5;:7::i;:::-;:23;;;2156:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2953:1:::1;2933:22;;:8;:22;;;;2925:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;3009:19;3019:8;3009:9;:19::i;:::-;2844:192:::0;:::o;60693:122::-;60750:4;60774:33;60796:10;60774:12;:21;;:33;;;;:::i;:::-;60767:40;;60693:122;;;:::o;726:98::-;779:7;806:10;799:17;;726:98;:::o;65404:167::-;65500:2;65470:15;:27;65486:10;65470:27;;;;;;;;;;;;:32;;;;;;;;;;;;;;;;;;65552:10;65548:2;65518:45;;65527:19;65535:10;65527:7;:19::i;:::-;65518:45;;;;;;;;;;;;65404:167;;:::o;38704:123::-;38773:7;38800:19;38808:3;:10;;38800:7;:19::i;:::-;38793:26;;38704:123;;;:::o;61187:360::-;61272:4;61297:19;61305:10;61297:7;:19::i;:::-;61289:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;61376:19;61398;61406:10;61398:7;:19::i;:::-;61376:41;;61447:11;61436:22;;:7;:22;;;:60;;;;61489:7;61462:34;;:23;61474:10;61462:11;:23::i;:::-;:34;;;61436:60;:102;;;;61500:38;61517:11;61530:7;61500:16;:38::i;:::-;61436:102;61428:111;;;61187:360;;;;:::o;63442:537::-;63563:4;63540:27;;:19;63548:10;63540:7;:19::i;:::-;:27;;;63532:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;63646:1;63632:16;;:2;:16;;;;63624:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;63702:42;63723:4;63729:2;63733:10;63702:20;:42::i;:::-;63755:32;63772:1;63776:10;63755:8;:32::i;:::-;63798:38;63825:10;63798:13;:19;63812:4;63798:19;;;;;;;;;;;;;;;:26;;:38;;;;:::i;:::-;;63847:33;63869:10;63847:13;:17;63861:2;63847:17;;;;;;;;;;;;;;;:21;;:33;;;;:::i;:::-;;63891:32;63908:10;63920:2;63891:12;:16;;:32;;;;;:::i;:::-;;63960:10;63956:2;63941:30;;63950:4;63941:30;;;;;;;;;;;;63442:537;;;:::o;31932:137::-;32003:7;32038:22;32042:3;:10;;32054:5;32038:3;:22::i;:::-;32030:31;;32023:38;;31932:137;;;;:::o;40461:247::-;40602:7;40653:44;40658:3;:10;;40678:3;40670:12;;40684;40653:4;:44::i;:::-;40645:53;;40622:78;;40461:247;;;;;:::o;31464:114::-;31524:7;31551:19;31559:3;:10;;31551:7;:19::i;:::-;31544:26;;31464:114;;;:::o;3044:173::-;3100:16;3119:6;;;;;;;;;;;3100:25;;3145:8;3136:6;;:17;;;;;;;;;;;;;;;;;;3200:8;3169:40;;3190:8;3169:40;;;;;;;;;;;;3089:128;3044:173;:::o;16207:98::-;16265:7;16296:1;16292;:5;;;;:::i;:::-;16285:12;;16207:98;;;;:::o;61810:113::-;61886:29;61896:2;61900:10;61886:29;;;;;;;;;;;;:9;:29::i;:::-;61810:113;;:::o;60211:278::-;60325:31;60335:4;60341:2;60345:10;60325:9;:31::i;:::-;60375:51;60398:4;60404:2;60408:10;60420:5;60375:22;:51::i;:::-;60367:114;;;;;;;;;;;;:::i;:::-;;;;;;;;;60211:278;;;;:::o;3543:723::-;3599:13;3829:1;3820:5;:10;3816:53;;;3847:10;;;;;;;;;;;;;;;;;;;;;3816:53;3879:12;3894:5;3879:20;;3910:14;3935:78;3950:1;3942:4;:9;3935:78;;3968:8;;;;;:::i;:::-;;;;3999:2;3991:10;;;;;:::i;:::-;;;3935:78;;;4023:19;4055:6;4045:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4023:39;;4073:154;4089:1;4080:5;:10;4073:154;;4117:1;4107:11;;;;;:::i;:::-;;;4184:2;4176:5;:10;;;;:::i;:::-;4163:2;:24;;;;:::i;:::-;4150:39;;4133:6;4140;4133:14;;;;;;;;:::i;:::-;;;;;:56;;;;;;;;;;;4213:2;4204:11;;;;;:::i;:::-;;;4073:154;;;4251:6;4237:21;;;;;3543:723;;;;:::o;38465:151::-;38549:4;38573:35;38583:3;:10;;38603:3;38595:12;;38573:9;:35::i;:::-;38566:42;;38465:151;;;;:::o;35475:109::-;35531:7;35558:18;:3;:9;;:16;:18::i;:::-;35551:25;;35475:109;;;:::o;66170:92::-;;;;:::o;31009:137::-;31079:4;31103:35;31111:3;:10;;31131:5;31123:14;;31103:7;:35::i;:::-;31096:42;;31009:137;;;;:::o;30702:131::-;30769:4;30793:32;30798:3;:10;;30818:5;30810:14;;30793:4;:32::i;:::-;30786:39;;30702:131;;;;:::o;37854:219::-;37977:4;38001:64;38006:3;:10;;38026:3;38018:12;;38056:5;38040:23;;38032:32;;38001:4;:64::i;:::-;37994:71;;37854:219;;;;;:::o;24873:120::-;24940:7;24967:3;:11;;24979:5;24967:18;;;;;;;;:::i;:::-;;;;;;;;;;24960:25;;24873:120;;;;:::o;37252:278::-;37380:7;37400:13;37416:3;:11;;:16;37428:3;37416:16;;;;;;;;;;;;37400:32;;37460:1;37451:10;;:5;:10;;:33;;;;37465:19;37475:3;37480;37465:9;:19::i;:::-;37451:33;37486:12;37443:56;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;37517:5;37510:12;;;37252:278;;;;;:::o;24410:109::-;24466:7;24493:3;:11;;:18;;;;24486:25;;24410:109;;;:::o;62259:256::-;62355:21;62361:2;62365:10;62355:5;:21::i;:::-;62395:57;62426:1;62430:2;62434:10;62446:5;62395:22;:57::i;:::-;62387:120;;;;;;;;;;;;:::i;:::-;;;;;;;;;62259:256;;;:::o;64567:593::-;64679:4;64701:15;:2;:13;;;:15::i;:::-;64696:33;;64725:4;64718:11;;;;64696:33;64740:23;64766:279;64823:45;;;64887:12;:10;:12::i;:::-;64918:4;64941:10;64970:5;64782:208;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64766:279;;;;;;;;;;;;;;;;;:2;:15;;;;:279;;;;;:::i;:::-;64740:305;;65056:13;65083:10;65072:32;;;;;;;;;;;;:::i;:::-;65056:48;;48983:10;65135:16;;65125:26;;;:6;:26;;;;65117:35;;;;64567:593;;;;;;;:::o;35254:126::-;35325:4;35349:23;35368:3;35349;:9;;:18;;:23;;;;:::i;:::-;35342:30;;35254:126;;;;:::o;26652:117::-;26715:7;26742:19;26750:3;:10;;26742:7;:19::i;:::-;26735:26;;26652:117;;;:::o;22689:1420::-;22755:4;22873:18;22894:3;:12;;:19;22907:5;22894:19;;;;;;;;;;;;22873:40;;22944:1;22930:10;:15;22926:1176;;23305:21;23342:1;23329:10;:14;;;;:::i;:::-;23305:38;;23358:17;23399:1;23378:3;:11;;:18;;;;:22;;;;:::i;:::-;23358:42;;23434:13;23421:9;:26;23417:405;;23468:17;23488:3;:11;;23500:9;23488:22;;;;;;;;:::i;:::-;;;;;;;;;;23468:42;;23642:9;23613:3;:11;;23625:13;23613:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;23753:10;23727:3;:12;;:23;23740:9;23727:23;;;;;;;;;;;:36;;;;23449:373;23417:405;23903:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;23998:3;:12;;:19;24011:5;23998:19;;;;;;;;;;;23991:26;;;24041:4;24034:11;;;;;;;22926:1176;24085:5;24078:12;;;22689:1420;;;;;:::o;22099:414::-;22162:4;22184:21;22194:3;22199:5;22184:9;:21::i;:::-;22179:327;;22222:3;:11;;22239:5;22222:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22405:3;:11;;:18;;;;22383:3;:12;;:19;22396:5;22383:19;;;;;;;;;;;:40;;;;22445:4;22438:11;;;;22179:327;22489:5;22482:12;;22099:414;;;;;:::o;34649:195::-;34759:4;34795:5;34776:3;:11;;:16;34788:3;34776:16;;;;;;;;;;;:24;;;;34818:18;34832:3;34818;:9;;:13;;:18;;;;:::i;:::-;34811:25;;34649:195;;;;;:::o;62770:415::-;62864:1;62850:16;;:2;:16;;;;62842:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;62923:19;62931:10;62923:7;:19::i;:::-;62922:20;62914:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;62988:48;63017:1;63021:2;63025:10;62988:20;:48::i;:::-;63047:33;63069:10;63047:13;:17;63061:2;63047:17;;;;;;;;;;;;;;;:21;;:33;;;;:::i;:::-;;63091:32;63108:10;63120:2;63091:12;:16;;:32;;;;;:::i;:::-;;63166:10;63162:2;63141:36;;63158:1;63141:36;;;;;;;;;;;;62770:415;;:::o;6076:387::-;6136:4;6344:12;6411:7;6399:20;6391:28;;6454:1;6447:4;:8;6440:15;;;6076:387;;;:::o;8882:229::-;9019:12;9051:52;9073:6;9081:4;9087:1;9090:12;9051:21;:52::i;:::-;9044:59;;8882:229;;;;;:::o;26426:140::-;26506:4;26530:28;26540:3;:10;;26552:5;26530:9;:28::i;:::-;26523:35;;26426:140;;;;:::o;24195:129::-;24268:4;24315:1;24292:3;:12;;:19;24305:5;24292:19;;;;;;;;;;;;:24;;24285:31;;24195:129;;;;:::o;25908:125::-;25978:4;26002:23;26007:3;:10;;26019:5;26002:4;:23::i;:::-;25995:30;;25908:125;;;;:::o;10002:510::-;10172:12;10230:5;10205:21;:30;;10197:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;10297:18;10308:6;10297:10;:18::i;:::-;10289:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;10363:12;10377:23;10404:6;:11;;10423:5;10430:4;10404:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10362:73;;;;10453:51;10470:7;10479:10;10491:12;10453:16;:51::i;:::-;10446:58;;;;10002:510;;;;;;:::o;12688:712::-;12838:12;12867:7;12863:530;;;12898:10;12891:17;;;;12863:530;13032:1;13012:10;:17;:21;13008:374;;;13210:10;13204:17;13271:15;13258:10;13254:2;13250:19;13243:44;13008:374;13353:12;13346:20;;;;;;;;;;;:::i;:::-;;;;;;;;12688:712;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:410:1:-;84:5;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:112;;;280:79;;:::i;:::-;249:112;370:41;404:6;399:3;394;370:41;:::i;:::-;90:327;7:410;;;;;:::o;423:412::-;501:5;526:66;542:49;584:6;542:49;:::i;:::-;526:66;:::i;:::-;517:75;;615:6;608:5;601:21;653:4;646:5;642:16;691:3;682:6;677:3;673:16;670:25;667:112;;;698:79;;:::i;:::-;667:112;788:41;822:6;817:3;812;788:41;:::i;:::-;507:328;423:412;;;;;:::o;841:139::-;887:5;925:6;912:20;903:29;;941:33;968:5;941:33;:::i;:::-;841:139;;;;:::o;986:133::-;1029:5;1067:6;1054:20;1045:29;;1083:30;1107:5;1083:30;:::i;:::-;986:133;;;;:::o;1125:137::-;1170:5;1208:6;1195:20;1186:29;;1224:32;1250:5;1224:32;:::i;:::-;1125:137;;;;:::o;1268:141::-;1324:5;1355:6;1349:13;1340:22;;1371:32;1397:5;1371:32;:::i;:::-;1268:141;;;;:::o;1428:338::-;1483:5;1532:3;1525:4;1517:6;1513:17;1509:27;1499:122;;1540:79;;:::i;:::-;1499:122;1657:6;1644:20;1682:78;1756:3;1748:6;1741:4;1733:6;1729:17;1682:78;:::i;:::-;1673:87;;1489:277;1428:338;;;;:::o;1786:340::-;1842:5;1891:3;1884:4;1876:6;1872:17;1868:27;1858:122;;1899:79;;:::i;:::-;1858:122;2016:6;2003:20;2041:79;2116:3;2108:6;2101:4;2093:6;2089:17;2041:79;:::i;:::-;2032:88;;1848:278;1786:340;;;;:::o;2132:139::-;2178:5;2216:6;2203:20;2194:29;;2232:33;2259:5;2232:33;:::i;:::-;2132:139;;;;:::o;2277:329::-;2336:6;2385:2;2373:9;2364:7;2360:23;2356:32;2353:119;;;2391:79;;:::i;:::-;2353:119;2511:1;2536:53;2581:7;2572:6;2561:9;2557:22;2536:53;:::i;:::-;2526:63;;2482:117;2277:329;;;;:::o;2612:474::-;2680:6;2688;2737:2;2725:9;2716:7;2712:23;2708:32;2705:119;;;2743:79;;:::i;:::-;2705:119;2863:1;2888:53;2933:7;2924:6;2913:9;2909:22;2888:53;:::i;:::-;2878:63;;2834:117;2990:2;3016:53;3061:7;3052:6;3041:9;3037:22;3016:53;:::i;:::-;3006:63;;2961:118;2612:474;;;;;:::o;3092:619::-;3169:6;3177;3185;3234:2;3222:9;3213:7;3209:23;3205:32;3202:119;;;3240:79;;:::i;:::-;3202:119;3360:1;3385:53;3430:7;3421:6;3410:9;3406:22;3385:53;:::i;:::-;3375:63;;3331:117;3487:2;3513:53;3558:7;3549:6;3538:9;3534:22;3513:53;:::i;:::-;3503:63;;3458:118;3615:2;3641:53;3686:7;3677:6;3666:9;3662:22;3641:53;:::i;:::-;3631:63;;3586:118;3092:619;;;;;:::o;3717:943::-;3812:6;3820;3828;3836;3885:3;3873:9;3864:7;3860:23;3856:33;3853:120;;;3892:79;;:::i;:::-;3853:120;4012:1;4037:53;4082:7;4073:6;4062:9;4058:22;4037:53;:::i;:::-;4027:63;;3983:117;4139:2;4165:53;4210:7;4201:6;4190:9;4186:22;4165:53;:::i;:::-;4155:63;;4110:118;4267:2;4293:53;4338:7;4329:6;4318:9;4314:22;4293:53;:::i;:::-;4283:63;;4238:118;4423:2;4412:9;4408:18;4395:32;4454:18;4446:6;4443:30;4440:117;;;4476:79;;:::i;:::-;4440:117;4581:62;4635:7;4626:6;4615:9;4611:22;4581:62;:::i;:::-;4571:72;;4366:287;3717:943;;;;;;;:::o;4666:468::-;4731:6;4739;4788:2;4776:9;4767:7;4763:23;4759:32;4756:119;;;4794:79;;:::i;:::-;4756:119;4914:1;4939:53;4984:7;4975:6;4964:9;4960:22;4939:53;:::i;:::-;4929:63;;4885:117;5041:2;5067:50;5109:7;5100:6;5089:9;5085:22;5067:50;:::i;:::-;5057:60;;5012:115;4666:468;;;;;:::o;5140:474::-;5208:6;5216;5265:2;5253:9;5244:7;5240:23;5236:32;5233:119;;;5271:79;;:::i;:::-;5233:119;5391:1;5416:53;5461:7;5452:6;5441:9;5437:22;5416:53;:::i;:::-;5406:63;;5362:117;5518:2;5544:53;5589:7;5580:6;5569:9;5565:22;5544:53;:::i;:::-;5534:63;;5489:118;5140:474;;;;;:::o;5620:327::-;5678:6;5727:2;5715:9;5706:7;5702:23;5698:32;5695:119;;;5733:79;;:::i;:::-;5695:119;5853:1;5878:52;5922:7;5913:6;5902:9;5898:22;5878:52;:::i;:::-;5868:62;;5824:116;5620:327;;;;:::o;5953:349::-;6022:6;6071:2;6059:9;6050:7;6046:23;6042:32;6039:119;;;6077:79;;:::i;:::-;6039:119;6197:1;6222:63;6277:7;6268:6;6257:9;6253:22;6222:63;:::i;:::-;6212:73;;6168:127;5953:349;;;;:::o;6308:509::-;6377:6;6426:2;6414:9;6405:7;6401:23;6397:32;6394:119;;;6432:79;;:::i;:::-;6394:119;6580:1;6569:9;6565:17;6552:31;6610:18;6602:6;6599:30;6596:117;;;6632:79;;:::i;:::-;6596:117;6737:63;6792:7;6783:6;6772:9;6768:22;6737:63;:::i;:::-;6727:73;;6523:287;6308:509;;;;:::o;6823:329::-;6882:6;6931:2;6919:9;6910:7;6906:23;6902:32;6899:119;;;6937:79;;:::i;:::-;6899:119;7057:1;7082:53;7127:7;7118:6;7107:9;7103:22;7082:53;:::i;:::-;7072:63;;7028:117;6823:329;;;;:::o;7158:118::-;7245:24;7263:5;7245:24;:::i;:::-;7240:3;7233:37;7158:118;;:::o;7282:109::-;7363:21;7378:5;7363:21;:::i;:::-;7358:3;7351:34;7282:109;;:::o;7397:360::-;7483:3;7511:38;7543:5;7511:38;:::i;:::-;7565:70;7628:6;7623:3;7565:70;:::i;:::-;7558:77;;7644:52;7689:6;7684:3;7677:4;7670:5;7666:16;7644:52;:::i;:::-;7721:29;7743:6;7721:29;:::i;:::-;7716:3;7712:39;7705:46;;7487:270;7397:360;;;;:::o;7763:373::-;7867:3;7895:38;7927:5;7895:38;:::i;:::-;7949:88;8030:6;8025:3;7949:88;:::i;:::-;7942:95;;8046:52;8091:6;8086:3;8079:4;8072:5;8068:16;8046:52;:::i;:::-;8123:6;8118:3;8114:16;8107:23;;7871:265;7763:373;;;;:::o;8142:364::-;8230:3;8258:39;8291:5;8258:39;:::i;:::-;8313:71;8377:6;8372:3;8313:71;:::i;:::-;8306:78;;8393:52;8438:6;8433:3;8426:4;8419:5;8415:16;8393:52;:::i;:::-;8470:29;8492:6;8470:29;:::i;:::-;8465:3;8461:39;8454:46;;8234:272;8142:364;;;;:::o;8512:377::-;8618:3;8646:39;8679:5;8646:39;:::i;:::-;8701:89;8783:6;8778:3;8701:89;:::i;:::-;8694:96;;8799:52;8844:6;8839:3;8832:4;8825:5;8821:16;8799:52;:::i;:::-;8876:6;8871:3;8867:16;8860:23;;8622:267;8512:377;;;;:::o;8919:845::-;9022:3;9059:5;9053:12;9088:36;9114:9;9088:36;:::i;:::-;9140:89;9222:6;9217:3;9140:89;:::i;:::-;9133:96;;9260:1;9249:9;9245:17;9276:1;9271:137;;;;9422:1;9417:341;;;;9238:520;;9271:137;9355:4;9351:9;9340;9336:25;9331:3;9324:38;9391:6;9386:3;9382:16;9375:23;;9271:137;;9417:341;9484:38;9516:5;9484:38;:::i;:::-;9544:1;9558:154;9572:6;9569:1;9566:13;9558:154;;;9646:7;9640:14;9636:1;9631:3;9627:11;9620:35;9696:1;9687:7;9683:15;9672:26;;9594:4;9591:1;9587:12;9582:17;;9558:154;;;9741:6;9736:3;9732:16;9725:23;;9424:334;;9238:520;;9026:738;;8919:845;;;;:::o;9770:366::-;9912:3;9933:67;9997:2;9992:3;9933:67;:::i;:::-;9926:74;;10009:93;10098:3;10009:93;:::i;:::-;10127:2;10122:3;10118:12;10111:19;;9770:366;;;:::o;10142:::-;10284:3;10305:67;10369:2;10364:3;10305:67;:::i;:::-;10298:74;;10381:93;10470:3;10381:93;:::i;:::-;10499:2;10494:3;10490:12;10483:19;;10142:366;;;:::o;10514:::-;10656:3;10677:67;10741:2;10736:3;10677:67;:::i;:::-;10670:74;;10753:93;10842:3;10753:93;:::i;:::-;10871:2;10866:3;10862:12;10855:19;;10514:366;;;:::o;10886:::-;11028:3;11049:67;11113:2;11108:3;11049:67;:::i;:::-;11042:74;;11125:93;11214:3;11125:93;:::i;:::-;11243:2;11238:3;11234:12;11227:19;;10886:366;;;:::o;11258:::-;11400:3;11421:67;11485:2;11480:3;11421:67;:::i;:::-;11414:74;;11497:93;11586:3;11497:93;:::i;:::-;11615:2;11610:3;11606:12;11599:19;;11258:366;;;:::o;11630:::-;11772:3;11793:67;11857:2;11852:3;11793:67;:::i;:::-;11786:74;;11869:93;11958:3;11869:93;:::i;:::-;11987:2;11982:3;11978:12;11971:19;;11630:366;;;:::o;12002:::-;12144:3;12165:67;12229:2;12224:3;12165:67;:::i;:::-;12158:74;;12241:93;12330:3;12241:93;:::i;:::-;12359:2;12354:3;12350:12;12343:19;;12002:366;;;:::o;12374:::-;12516:3;12537:67;12601:2;12596:3;12537:67;:::i;:::-;12530:74;;12613:93;12702:3;12613:93;:::i;:::-;12731:2;12726:3;12722:12;12715:19;;12374:366;;;:::o;12746:::-;12888:3;12909:67;12973:2;12968:3;12909:67;:::i;:::-;12902:74;;12985:93;13074:3;12985:93;:::i;:::-;13103:2;13098:3;13094:12;13087:19;;12746:366;;;:::o;13118:::-;13260:3;13281:67;13345:2;13340:3;13281:67;:::i;:::-;13274:74;;13357:93;13446:3;13357:93;:::i;:::-;13475:2;13470:3;13466:12;13459:19;;13118:366;;;:::o;13490:::-;13632:3;13653:67;13717:2;13712:3;13653:67;:::i;:::-;13646:74;;13729:93;13818:3;13729:93;:::i;:::-;13847:2;13842:3;13838:12;13831:19;;13490:366;;;:::o;13862:::-;14004:3;14025:67;14089:2;14084:3;14025:67;:::i;:::-;14018:74;;14101:93;14190:3;14101:93;:::i;:::-;14219:2;14214:3;14210:12;14203:19;;13862:366;;;:::o;14234:::-;14376:3;14397:67;14461:2;14456:3;14397:67;:::i;:::-;14390:74;;14473:93;14562:3;14473:93;:::i;:::-;14591:2;14586:3;14582:12;14575:19;;14234:366;;;:::o;14606:::-;14748:3;14769:67;14833:2;14828:3;14769:67;:::i;:::-;14762:74;;14845:93;14934:3;14845:93;:::i;:::-;14963:2;14958:3;14954:12;14947:19;;14606:366;;;:::o;14978:::-;15120:3;15141:67;15205:2;15200:3;15141:67;:::i;:::-;15134:74;;15217:93;15306:3;15217:93;:::i;:::-;15335:2;15330:3;15326:12;15319:19;;14978:366;;;:::o;15350:::-;15492:3;15513:67;15577:2;15572:3;15513:67;:::i;:::-;15506:74;;15589:93;15678:3;15589:93;:::i;:::-;15707:2;15702:3;15698:12;15691:19;;15350:366;;;:::o;15722:::-;15864:3;15885:67;15949:2;15944:3;15885:67;:::i;:::-;15878:74;;15961:93;16050:3;15961:93;:::i;:::-;16079:2;16074:3;16070:12;16063:19;;15722:366;;;:::o;16094:::-;16236:3;16257:67;16321:2;16316:3;16257:67;:::i;:::-;16250:74;;16333:93;16422:3;16333:93;:::i;:::-;16451:2;16446:3;16442:12;16435:19;;16094:366;;;:::o;16466:::-;16608:3;16629:67;16693:2;16688:3;16629:67;:::i;:::-;16622:74;;16705:93;16794:3;16705:93;:::i;:::-;16823:2;16818:3;16814:12;16807:19;;16466:366;;;:::o;16838:::-;16980:3;17001:67;17065:2;17060:3;17001:67;:::i;:::-;16994:74;;17077:93;17166:3;17077:93;:::i;:::-;17195:2;17190:3;17186:12;17179:19;;16838:366;;;:::o;17210:::-;17352:3;17373:67;17437:2;17432:3;17373:67;:::i;:::-;17366:74;;17449:93;17538:3;17449:93;:::i;:::-;17567:2;17562:3;17558:12;17551:19;;17210:366;;;:::o;17582:::-;17724:3;17745:67;17809:2;17804:3;17745:67;:::i;:::-;17738:74;;17821:93;17910:3;17821:93;:::i;:::-;17939:2;17934:3;17930:12;17923:19;;17582:366;;;:::o;17954:::-;18096:3;18117:67;18181:2;18176:3;18117:67;:::i;:::-;18110:74;;18193:93;18282:3;18193:93;:::i;:::-;18311:2;18306:3;18302:12;18295:19;;17954:366;;;:::o;18326:::-;18468:3;18489:67;18553:2;18548:3;18489:67;:::i;:::-;18482:74;;18565:93;18654:3;18565:93;:::i;:::-;18683:2;18678:3;18674:12;18667:19;;18326:366;;;:::o;18698:118::-;18785:24;18803:5;18785:24;:::i;:::-;18780:3;18773:37;18698:118;;:::o;18822:271::-;18952:3;18974:93;19063:3;19054:6;18974:93;:::i;:::-;18967:100;;19084:3;19077:10;;18822:271;;;;:::o;19099:429::-;19276:3;19298:92;19386:3;19377:6;19298:92;:::i;:::-;19291:99;;19407:95;19498:3;19489:6;19407:95;:::i;:::-;19400:102;;19519:3;19512:10;;19099:429;;;;;:::o;19534:222::-;19627:4;19665:2;19654:9;19650:18;19642:26;;19678:71;19746:1;19735:9;19731:17;19722:6;19678:71;:::i;:::-;19534:222;;;;:::o;19762:640::-;19957:4;19995:3;19984:9;19980:19;19972:27;;20009:71;20077:1;20066:9;20062:17;20053:6;20009:71;:::i;:::-;20090:72;20158:2;20147:9;20143:18;20134:6;20090:72;:::i;:::-;20172;20240:2;20229:9;20225:18;20216:6;20172:72;:::i;:::-;20291:9;20285:4;20281:20;20276:2;20265:9;20261:18;20254:48;20319:76;20390:4;20381:6;20319:76;:::i;:::-;20311:84;;19762:640;;;;;;;:::o;20408:210::-;20495:4;20533:2;20522:9;20518:18;20510:26;;20546:65;20608:1;20597:9;20593:17;20584:6;20546:65;:::i;:::-;20408:210;;;;:::o;20624:313::-;20737:4;20775:2;20764:9;20760:18;20752:26;;20824:9;20818:4;20814:20;20810:1;20799:9;20795:17;20788:47;20852:78;20925:4;20916:6;20852:78;:::i;:::-;20844:86;;20624:313;;;;:::o;20943:419::-;21109:4;21147:2;21136:9;21132:18;21124:26;;21196:9;21190:4;21186:20;21182:1;21171:9;21167:17;21160:47;21224:131;21350:4;21224:131;:::i;:::-;21216:139;;20943:419;;;:::o;21368:::-;21534:4;21572:2;21561:9;21557:18;21549:26;;21621:9;21615:4;21611:20;21607:1;21596:9;21592:17;21585:47;21649:131;21775:4;21649:131;:::i;:::-;21641:139;;21368:419;;;:::o;21793:::-;21959:4;21997:2;21986:9;21982:18;21974:26;;22046:9;22040:4;22036:20;22032:1;22021:9;22017:17;22010:47;22074:131;22200:4;22074:131;:::i;:::-;22066:139;;21793:419;;;:::o;22218:::-;22384:4;22422:2;22411:9;22407:18;22399:26;;22471:9;22465:4;22461:20;22457:1;22446:9;22442:17;22435:47;22499:131;22625:4;22499:131;:::i;:::-;22491:139;;22218:419;;;:::o;22643:::-;22809:4;22847:2;22836:9;22832:18;22824:26;;22896:9;22890:4;22886:20;22882:1;22871:9;22867:17;22860:47;22924:131;23050:4;22924:131;:::i;:::-;22916:139;;22643:419;;;:::o;23068:::-;23234:4;23272:2;23261:9;23257:18;23249:26;;23321:9;23315:4;23311:20;23307:1;23296:9;23292:17;23285:47;23349:131;23475:4;23349:131;:::i;:::-;23341:139;;23068:419;;;:::o;23493:::-;23659:4;23697:2;23686:9;23682:18;23674:26;;23746:9;23740:4;23736:20;23732:1;23721:9;23717:17;23710:47;23774:131;23900:4;23774:131;:::i;:::-;23766:139;;23493:419;;;:::o;23918:::-;24084:4;24122:2;24111:9;24107:18;24099:26;;24171:9;24165:4;24161:20;24157:1;24146:9;24142:17;24135:47;24199:131;24325:4;24199:131;:::i;:::-;24191:139;;23918:419;;;:::o;24343:::-;24509:4;24547:2;24536:9;24532:18;24524:26;;24596:9;24590:4;24586:20;24582:1;24571:9;24567:17;24560:47;24624:131;24750:4;24624:131;:::i;:::-;24616:139;;24343:419;;;:::o;24768:::-;24934:4;24972:2;24961:9;24957:18;24949:26;;25021:9;25015:4;25011:20;25007:1;24996:9;24992:17;24985:47;25049:131;25175:4;25049:131;:::i;:::-;25041:139;;24768:419;;;:::o;25193:::-;25359:4;25397:2;25386:9;25382:18;25374:26;;25446:9;25440:4;25436:20;25432:1;25421:9;25417:17;25410:47;25474:131;25600:4;25474:131;:::i;:::-;25466:139;;25193:419;;;:::o;25618:::-;25784:4;25822:2;25811:9;25807:18;25799:26;;25871:9;25865:4;25861:20;25857:1;25846:9;25842:17;25835:47;25899:131;26025:4;25899:131;:::i;:::-;25891:139;;25618:419;;;:::o;26043:::-;26209:4;26247:2;26236:9;26232:18;26224:26;;26296:9;26290:4;26286:20;26282:1;26271:9;26267:17;26260:47;26324:131;26450:4;26324:131;:::i;:::-;26316:139;;26043:419;;;:::o;26468:::-;26634:4;26672:2;26661:9;26657:18;26649:26;;26721:9;26715:4;26711:20;26707:1;26696:9;26692:17;26685:47;26749:131;26875:4;26749:131;:::i;:::-;26741:139;;26468:419;;;:::o;26893:::-;27059:4;27097:2;27086:9;27082:18;27074:26;;27146:9;27140:4;27136:20;27132:1;27121:9;27117:17;27110:47;27174:131;27300:4;27174:131;:::i;:::-;27166:139;;26893:419;;;:::o;27318:::-;27484:4;27522:2;27511:9;27507:18;27499:26;;27571:9;27565:4;27561:20;27557:1;27546:9;27542:17;27535:47;27599:131;27725:4;27599:131;:::i;:::-;27591:139;;27318:419;;;:::o;27743:::-;27909:4;27947:2;27936:9;27932:18;27924:26;;27996:9;27990:4;27986:20;27982:1;27971:9;27967:17;27960:47;28024:131;28150:4;28024:131;:::i;:::-;28016:139;;27743:419;;;:::o;28168:::-;28334:4;28372:2;28361:9;28357:18;28349:26;;28421:9;28415:4;28411:20;28407:1;28396:9;28392:17;28385:47;28449:131;28575:4;28449:131;:::i;:::-;28441:139;;28168:419;;;:::o;28593:::-;28759:4;28797:2;28786:9;28782:18;28774:26;;28846:9;28840:4;28836:20;28832:1;28821:9;28817:17;28810:47;28874:131;29000:4;28874:131;:::i;:::-;28866:139;;28593:419;;;:::o;29018:::-;29184:4;29222:2;29211:9;29207:18;29199:26;;29271:9;29265:4;29261:20;29257:1;29246:9;29242:17;29235:47;29299:131;29425:4;29299:131;:::i;:::-;29291:139;;29018:419;;;:::o;29443:::-;29609:4;29647:2;29636:9;29632:18;29624:26;;29696:9;29690:4;29686:20;29682:1;29671:9;29667:17;29660:47;29724:131;29850:4;29724:131;:::i;:::-;29716:139;;29443:419;;;:::o;29868:::-;30034:4;30072:2;30061:9;30057:18;30049:26;;30121:9;30115:4;30111:20;30107:1;30096:9;30092:17;30085:47;30149:131;30275:4;30149:131;:::i;:::-;30141:139;;29868:419;;;:::o;30293:::-;30459:4;30497:2;30486:9;30482:18;30474:26;;30546:9;30540:4;30536:20;30532:1;30521:9;30517:17;30510:47;30574:131;30700:4;30574:131;:::i;:::-;30566:139;;30293:419;;;:::o;30718:::-;30884:4;30922:2;30911:9;30907:18;30899:26;;30971:9;30965:4;30961:20;30957:1;30946:9;30942:17;30935:47;30999:131;31125:4;30999:131;:::i;:::-;30991:139;;30718:419;;;:::o;31143:222::-;31236:4;31274:2;31263:9;31259:18;31251:26;;31287:71;31355:1;31344:9;31340:17;31331:6;31287:71;:::i;:::-;31143:222;;;;:::o;31371:129::-;31405:6;31432:20;;:::i;:::-;31422:30;;31461:33;31489:4;31481:6;31461:33;:::i;:::-;31371:129;;;:::o;31506:75::-;31539:6;31572:2;31566:9;31556:19;;31506:75;:::o;31587:307::-;31648:4;31738:18;31730:6;31727:30;31724:56;;;31760:18;;:::i;:::-;31724:56;31798:29;31820:6;31798:29;:::i;:::-;31790:37;;31882:4;31876;31872:15;31864:23;;31587:307;;;:::o;31900:308::-;31962:4;32052:18;32044:6;32041:30;32038:56;;;32074:18;;:::i;:::-;32038:56;32112:29;32134:6;32112:29;:::i;:::-;32104:37;;32196:4;32190;32186:15;32178:23;;31900:308;;;:::o;32214:141::-;32263:4;32286:3;32278:11;;32309:3;32306:1;32299:14;32343:4;32340:1;32330:18;32322:26;;32214:141;;;:::o;32361:98::-;32412:6;32446:5;32440:12;32430:22;;32361:98;;;:::o;32465:99::-;32517:6;32551:5;32545:12;32535:22;;32465:99;;;:::o;32570:168::-;32653:11;32687:6;32682:3;32675:19;32727:4;32722:3;32718:14;32703:29;;32570:168;;;;:::o;32744:147::-;32845:11;32882:3;32867:18;;32744:147;;;;:::o;32897:169::-;32981:11;33015:6;33010:3;33003:19;33055:4;33050:3;33046:14;33031:29;;32897:169;;;;:::o;33072:148::-;33174:11;33211:3;33196:18;;33072:148;;;;:::o;33226:305::-;33266:3;33285:20;33303:1;33285:20;:::i;:::-;33280:25;;33319:20;33337:1;33319:20;:::i;:::-;33314:25;;33473:1;33405:66;33401:74;33398:1;33395:81;33392:107;;;33479:18;;:::i;:::-;33392:107;33523:1;33520;33516:9;33509:16;;33226:305;;;;:::o;33537:185::-;33577:1;33594:20;33612:1;33594:20;:::i;:::-;33589:25;;33628:20;33646:1;33628:20;:::i;:::-;33623:25;;33667:1;33657:35;;33672:18;;:::i;:::-;33657:35;33714:1;33711;33707:9;33702:14;;33537:185;;;;:::o;33728:348::-;33768:7;33791:20;33809:1;33791:20;:::i;:::-;33786:25;;33825:20;33843:1;33825:20;:::i;:::-;33820:25;;34013:1;33945:66;33941:74;33938:1;33935:81;33930:1;33923:9;33916:17;33912:105;33909:131;;;34020:18;;:::i;:::-;33909:131;34068:1;34065;34061:9;34050:20;;33728:348;;;;:::o;34082:191::-;34122:4;34142:20;34160:1;34142:20;:::i;:::-;34137:25;;34176:20;34194:1;34176:20;:::i;:::-;34171:25;;34215:1;34212;34209:8;34206:34;;;34220:18;;:::i;:::-;34206:34;34265:1;34262;34258:9;34250:17;;34082:191;;;;:::o;34279:96::-;34316:7;34345:24;34363:5;34345:24;:::i;:::-;34334:35;;34279:96;;;:::o;34381:90::-;34415:7;34458:5;34451:13;34444:21;34433:32;;34381:90;;;:::o;34477:149::-;34513:7;34553:66;34546:5;34542:78;34531:89;;34477:149;;;:::o;34632:126::-;34669:7;34709:42;34702:5;34698:54;34687:65;;34632:126;;;:::o;34764:77::-;34801:7;34830:5;34819:16;;34764:77;;;:::o;34847:154::-;34931:6;34926:3;34921;34908:30;34993:1;34984:6;34979:3;34975:16;34968:27;34847:154;;;:::o;35007:307::-;35075:1;35085:113;35099:6;35096:1;35093:13;35085:113;;;35184:1;35179:3;35175:11;35169:18;35165:1;35160:3;35156:11;35149:39;35121:2;35118:1;35114:10;35109:15;;35085:113;;;35216:6;35213:1;35210:13;35207:101;;;35296:1;35287:6;35282:3;35278:16;35271:27;35207:101;35056:258;35007:307;;;:::o;35320:320::-;35364:6;35401:1;35395:4;35391:12;35381:22;;35448:1;35442:4;35438:12;35469:18;35459:81;;35525:4;35517:6;35513:17;35503:27;;35459:81;35587:2;35579:6;35576:14;35556:18;35553:38;35550:84;;;35606:18;;:::i;:::-;35550:84;35371:269;35320:320;;;:::o;35646:281::-;35729:27;35751:4;35729:27;:::i;:::-;35721:6;35717:40;35859:6;35847:10;35844:22;35823:18;35811:10;35808:34;35805:62;35802:88;;;35870:18;;:::i;:::-;35802:88;35910:10;35906:2;35899:22;35689:238;35646:281;;:::o;35933:233::-;35972:3;35995:24;36013:5;35995:24;:::i;:::-;35986:33;;36041:66;36034:5;36031:77;36028:103;;;36111:18;;:::i;:::-;36028:103;36158:1;36151:5;36147:13;36140:20;;35933:233;;;:::o;36172:176::-;36204:1;36221:20;36239:1;36221:20;:::i;:::-;36216:25;;36255:20;36273:1;36255:20;:::i;:::-;36250:25;;36294:1;36284:35;;36299:18;;:::i;:::-;36284:35;36340:1;36337;36333:9;36328:14;;36172:176;;;;:::o;36354:180::-;36402:77;36399:1;36392:88;36499:4;36496:1;36489:15;36523:4;36520:1;36513:15;36540:180;36588:77;36585:1;36578:88;36685:4;36682:1;36675:15;36709:4;36706:1;36699:15;36726:180;36774:77;36771:1;36764:88;36871:4;36868:1;36861:15;36895:4;36892:1;36885:15;36912:180;36960:77;36957:1;36950:88;37057:4;37054:1;37047:15;37081:4;37078:1;37071:15;37098:180;37146:77;37143:1;37136:88;37243:4;37240:1;37233:15;37267:4;37264:1;37257:15;37284:180;37332:77;37329:1;37322:88;37429:4;37426:1;37419:15;37453:4;37450:1;37443:15;37470:117;37579:1;37576;37569:12;37593:117;37702:1;37699;37692:12;37716:117;37825:1;37822;37815:12;37839:117;37948:1;37945;37938:12;37962:102;38003:6;38054:2;38050:7;38045:2;38038:5;38034:14;38030:28;38020:38;;37962:102;;;:::o;38070:222::-;38210:34;38206:1;38198:6;38194:14;38187:58;38279:5;38274:2;38266:6;38262:15;38255:30;38070:222;:::o;38298:237::-;38438:34;38434:1;38426:6;38422:14;38415:58;38507:20;38502:2;38494:6;38490:15;38483:45;38298:237;:::o;38541:225::-;38681:34;38677:1;38669:6;38665:14;38658:58;38750:8;38745:2;38737:6;38733:15;38726:33;38541:225;:::o;38772:178::-;38912:30;38908:1;38900:6;38896:14;38889:54;38772:178;:::o;38956:223::-;39096:34;39092:1;39084:6;39080:14;39073:58;39165:6;39160:2;39152:6;39148:15;39141:31;38956:223;:::o;39185:175::-;39325:27;39321:1;39313:6;39309:14;39302:51;39185:175;:::o;39366:181::-;39506:33;39502:1;39494:6;39490:14;39483:57;39366:181;:::o;39553:170::-;39693:22;39689:1;39681:6;39677:14;39670:46;39553:170;:::o;39729:169::-;39869:21;39865:1;39857:6;39853:14;39846:45;39729:169;:::o;39904:173::-;40044:25;40040:1;40032:6;40028:14;40021:49;39904:173;:::o;40083:225::-;40223:34;40219:1;40211:6;40207:14;40200:58;40292:8;40287:2;40279:6;40275:15;40268:33;40083:225;:::o;40314:231::-;40454:34;40450:1;40442:6;40438:14;40431:58;40523:14;40518:2;40510:6;40506:15;40499:39;40314:231;:::o;40551:243::-;40691:34;40687:1;40679:6;40675:14;40668:58;40760:26;40755:2;40747:6;40743:15;40736:51;40551:243;:::o;40800:229::-;40940:34;40936:1;40928:6;40924:14;40917:58;41009:12;41004:2;40996:6;40992:15;40985:37;40800:229;:::o;41035:182::-;41175:34;41171:1;41163:6;41159:14;41152:58;41035:182;:::o;41223:::-;41363:34;41359:1;41351:6;41347:14;41340:58;41223:182;:::o;41411:231::-;41551:34;41547:1;41539:6;41535:14;41528:58;41620:14;41615:2;41607:6;41603:15;41596:39;41411:231;:::o;41648:182::-;41788:34;41784:1;41776:6;41772:14;41765:58;41648:182;:::o;41836:228::-;41976:34;41972:1;41964:6;41960:14;41953:58;42045:11;42040:2;42032:6;42028:15;42021:36;41836:228;:::o;42070:175::-;42210:27;42206:1;42198:6;42194:14;42187:51;42070:175;:::o;42251:220::-;42391:34;42387:1;42379:6;42375:14;42368:58;42460:3;42455:2;42447:6;42443:15;42436:28;42251:220;:::o;42477:236::-;42617:34;42613:1;42605:6;42601:14;42594:58;42686:19;42681:2;42673:6;42669:15;42662:44;42477:236;:::o;42719:179::-;42859:31;42855:1;42847:6;42843:14;42836:55;42719:179;:::o;42904:170::-;43044:22;43040:1;43032:6;43028:14;43021:46;42904:170;:::o;43080:122::-;43153:24;43171:5;43153:24;:::i;:::-;43146:5;43143:35;43133:63;;43192:1;43189;43182:12;43133:63;43080:122;:::o;43208:116::-;43278:21;43293:5;43278:21;:::i;:::-;43271:5;43268:32;43258:60;;43314:1;43311;43304:12;43258:60;43208:116;:::o;43330:120::-;43402:23;43419:5;43402:23;:::i;:::-;43395:5;43392:34;43382:62;;43440:1;43437;43430:12;43382:62;43330:120;:::o;43456:122::-;43529:24;43547:5;43529:24;:::i;:::-;43522:5;43519:35;43509:63;;43568:1;43565;43558:12;43509:63;43456:122;:::o

Swarm Source

ipfs://262d6b05dea8af807aa9dc14e280b9eccb971113f1f8ea29bf5afc51de3084b6

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