Token

DOGGOID (DOGGOID)

ERC-721

Overview

Max Total Supply

21 DOGGOID

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xb922d483baa99b9e3c9c716de7d7a33a54016980

Filtered by Token Holder

0x36c10892950a35464ea82F750bE14a137DC5442B

Balance

1 DOGGOID

0x36c10892950a35464ea82f750be14a137dc5442b

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

DOGGOID

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-11-05
*/

//SPDX-License-Identifier: MIT
pragma solidity 0.8.13;

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

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

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

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

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

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

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

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

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

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

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

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

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

/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
    bytes internal constant TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /// @notice Encodes some bytes to the base64 representation
    function encode(bytes memory data) internal pure returns (string memory) {
        uint256 len = data.length;
        if (len == 0) return "";

        // multiply by 4/3 rounded up
        uint256 encodedLen = 4 * ((len + 2) / 3);

        // Add some extra buffer at the end
        bytes memory result = new bytes(encodedLen + 32);

        bytes memory table = TABLE;

        assembly {
            let tablePtr := add(table, 1)
            let resultPtr := add(result, 32)

            for {
                let i := 0
            } lt(i, len) {

            } {
                i := add(i, 3)
                let input := and(mload(add(data, i)), 0xffffff)

                let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
                out := shl(8, out)
                out := add(out, and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF))
                out := shl(8, out)
                out := add(out, and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF))
                out := shl(8, out)
                out := add(out, and(mload(add(tablePtr, and(input, 0x3F))), 0xFF))
                out := shl(224, out)

                mstore(resultPtr, out)

                resultPtr := add(resultPtr, 4)
            }

            switch mod(len, 3)
            case 1 {
                mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
            }
            case 2 {
                mstore(sub(resultPtr, 1), shl(248, 0x3d))
            }

            mstore(result, encodedLen)
        }

        return string(result);
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant alphabet = "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] = alphabet[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

}

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

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

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

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

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

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

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

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

            bytes32 lastvalue = set._values[lastIndex];

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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


    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

// helper methods for interacting with ERC20 tokens and sending BONE that do not consistently return true/false
library TransferHelper {
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::safeApprove: approve failed'
        );
    }

    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::safeTransfer: transfer failed'
        );
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            'TransferHelper::transferFrom: transferFrom failed'
        );
    }

    function safeTransferBONE(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'TransferHelper::safeTransferBOHR: BONE transfer failed');
    }
}

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

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

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

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

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

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

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


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

/*
 * @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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
    uint256 private locked = 1;

    modifier nonReentrant() virtual {
        require(locked == 1, "REENTRANCY");

        locked = 2;

        _;

        locked = 1;
    }
}

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

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

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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden
     * in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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

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

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

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

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

/**
 * @dev ERC721 token with storage based token uri management.
 */
abstract contract ERC721URIStorage is ERC721 {
    using Strings for uint256;

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

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

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

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

        return super.tokenURI(tokenId);
    }

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

}

contract DOGGOID is Ownable, ReentrancyGuard, ERC721Enumerable, ERC721URIStorage{
    using SafeMath for uint256;
    using Strings for uint256;

    string public _baseTokenURI;

    uint256 public mintBlock;

    address public doggo;

    uint256 public nftPrice;

    uint256 public ethPrice;

    mapping(string => bool) public namesMinted;

    mapping(string => bool) public namesMintedLower;

    mapping(uint => string) public nameByTokenId;

    event Minted(address indexed minter, uint tokenId, string name);

    constructor(uint256 _nftPrice, address _addr) ERC721("DOGGOID", "DOGGOID") {

        doggo = _addr;

        nftPrice = _nftPrice;

        mintBlock = 1;
    }

    function setdoggo(address _doggo) external onlyOwner {
        doggo = _doggo;
    }

    function setNftPrice(uint256 _nftPrice) external onlyOwner {
        nftPrice = _nftPrice;
    }

    function setEthPrice(uint256 _ethPrice) external onlyOwner {
        ethPrice = _ethPrice;
    }

    function setBaseURI(string memory baseURI) external onlyOwner{
        _baseTokenURI = baseURI;
    }

    function mint(string calldata _doggoName) public payable nonReentrant {
        string memory _par = _doggoName;

        string memory lowerName = toLower(_par);

        require(!namesMintedLower[lowerName], 'Name Error');

        require(tx.origin == _msgSender(), "Contract not allowed");

        if (nftPrice > 0) {
            TransferHelper.safeTransferFrom(doggo, _msgSender(), address(this), nftPrice);
        }

        _mint(_msgSender(), mintBlock);

        namesMinted[_doggoName] = true;

        namesMintedLower[lowerName] = true;

        nameByTokenId[mintBlock] = _doggoName;

        emit Minted(_msgSender(), mintBlock, string(string.concat(_doggoName, ".doggo")));

        mintBlock++;

    }

    function mintEth(string calldata _doggoName) public payable nonReentrant {
        string memory _par = _doggoName;

        string memory lowerName = toLower(_par);

        require(!namesMintedLower[lowerName], 'Name Error');

        require(tx.origin == _msgSender(), "Contract not allowed");

        if (ethPrice > 0) {
            require(ethPrice == msg.value, "eth amount not correct");
        }

        _mint(_msgSender(), mintBlock);

        namesMinted[_doggoName] = true;

        namesMintedLower[lowerName] = true;

        nameByTokenId[mintBlock] = _doggoName;

        emit Minted(_msgSender(), mintBlock, string(string.concat(_doggoName, ".doggo")));

        mintBlock++;

    }

    function tokenNames(uint256 tokenId) public view returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        return string(string.concat(nameByTokenId[tokenId], ".doggo"));

    }

    function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory output = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 300 300" width="300" height="300"><rect width="100%" height="100%" fill="black" /><text x="150" y="132" fill="#fff" style="dominant-baseline:middle;text-anchor:middle;font-size: 20px;">';

        bytes memory data;

        data = abi.encodePacked(
            output,
            bytes(nameByTokenId[tokenId]),
            '.doggo</text></svg>'
        );

        string memory json = Base64.encode(
            bytes(
                string(
                    abi.encodePacked(
                        '{"description": "doggo NAMES", "image": "data:image/svg+xml;base64,',
                        Base64.encode(data),
                        '"}'
                    )
                )
            )
        );
        output = string(abi.encodePacked("data:application/json;base64,", json));
        return output;
    }

    /**
      * @dev See {IERC165-supportsInterface}.
      */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

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

    function toLower(string memory _self) internal pure returns (string memory _ret) {
        for (uint i=0; i<bytes(_self).length; ++i) {
            if (bytes(_self)[i] >= 'A' && bytes(_self)[i] <= 'Z') {
                bytes(_self)[i] |= 0x20;
            }
        }

        _ret = _self;
    }

    function withdrawEth(uint256 amount) public onlyOwner {
        TransferHelper.safeTransferBONE(_msgSender(), amount);
    }

    function withdrawToken(address _token,uint256 amount) public onlyOwner {
        TransferHelper.safeTransfer(_token, _msgSender(), amount);
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"uint256","name":"_nftPrice","type":"uint256"},{"internalType":"address","name":"_addr","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"string","name":"name","type":"string"}],"name":"Minted","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":"_baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"doggo","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ethPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_doggoName","type":"string"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_doggoName","type":"string"}],"name":"mintEth","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"nameByTokenId","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"namesMinted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"","type":"string"}],"name":"namesMintedLower","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nftPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_ethPrice","type":"uint256"}],"name":"setEthPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_nftPrice","type":"uint256"}],"name":"setNftPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_doggo","type":"address"}],"name":"setdoggo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenNames","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

0000000000000000000000000000000000000000000000000002738d24e52000000000000000000000000000240cd7b53d364a208ed41f8ced4965d11f571b7a

-----Decoded View---------------
Arg [0] : _nftPrice (uint256): 690000000000000
Arg [1] : _addr (address): 0x240Cd7b53d364a208eD41f8cEd4965D11F571B7a

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000002738d24e52000
Arg [1] : 000000000000000000000000240cd7b53d364a208ed41f8ced4965d11f571b7a

Deployed Bytecode Sourcemap

64268:5071:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65192:98;;;;;;;;;;-1:-1:-1;65192:98:0;;;;;:::i;:::-;;:::i;:::-;;68356:179;;;;;;;;;;-1:-1:-1;68356:179:0;;;;;:::i;:::-;;:::i;:::-;;;750:14:1;;743:22;725:41;;713:2;698:18;68356:179:0;;;;;;;;45067:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;46534:221::-;;;;;;;;;;-1:-1:-1;46534:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:1;;;1674:51;;1662:2;1647:18;46534:221:0;1528:203:1;46064:404:0;;;;;;;;;;-1:-1:-1;46064:404:0;;;;;:::i;:::-;;:::i;66161:726::-;;;;;;:::i;:::-;;:::i;64520:23::-;;;;;;;;;;;;;;;;;;;2916:25:1;;;2904:2;2889:18;64520:23:0;2770:177:1;57416:113:0;;;;;;;;;;-1:-1:-1;57504:10:0;:17;57416:113;;47424:305;;;;;;;;;;-1:-1:-1;47424:305:0;;;;;:::i;:::-;;:::i;57084:256::-;;;;;;;;;;-1:-1:-1;57084:256:0;;;;;:::i;:::-;;:::i;66895:245::-;;;;;;;;;;-1:-1:-1;66895:245:0;;;;;:::i;:::-;;:::i;47800:151::-;;;;;;;;;;-1:-1:-1;47800:151:0;;;;;:::i;:::-;;:::i;57606:233::-;;;;;;;;;;-1:-1:-1;57606:233:0;;;;;:::i;:::-;;:::i;65298:103::-;;;;;;;;;;-1:-1:-1;65298:103:0;;;;;:::i;:::-;;:::i;44761:239::-;;;;;;;;;;-1:-1:-1;44761:239:0;;;;;:::i;:::-;;:::i;44491:208::-;;;;;;;;;;-1:-1:-1;44491:208:0;;;;;:::i;:::-;;:::i;64458:24::-;;;;;;;;;;;;;;;;41415:94;;;;;;;;;;;;;:::i;65086:98::-;;;;;;;;;;-1:-1:-1;65086:98:0;;;;;:::i;:::-;;:::i;40764:87::-;;;;;;;;;;-1:-1:-1;40810:7:0;40837:6;-1:-1:-1;;;;;40837:6:0;40764:87;;64491:20;;;;;;;;;;-1:-1:-1;64491:20:0;;;;-1:-1:-1;;;;;64491:20:0;;;45236:104;;;;;;;;;;;;;:::i;69187:147::-;;;;;;;;;;-1:-1:-1;69187:147:0;;;;;:::i;:::-;;:::i;46827:295::-;;;;;;;;;;-1:-1:-1;46827:295:0;;;;;:::i;:::-;;:::i;64691:44::-;;;;;;;;;;-1:-1:-1;64691:44:0;;;;;:::i;:::-;;:::i;64992:86::-;;;;;;;;;;-1:-1:-1;64992:86:0;;;;;:::i;:::-;;:::i;64584:42::-;;;;;;;;;;-1:-1:-1;64584:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48022:285;;;;;;;;;;-1:-1:-1;48022:285:0;;;;;:::i;:::-;;:::i;69053:126::-;;;;;;;;;;-1:-1:-1;69053:126:0;;;;;:::i;:::-;;:::i;67148:1134::-;;;;;;;;;;-1:-1:-1;67148:1134:0;;;;;:::i;:::-;;:::i;64635:47::-;;;;;;;;;;-1:-1:-1;64635:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64422:27;;;;;;;;;;;;;:::i;65409:744::-;;;;;;:::i;:::-;;:::i;47193:164::-;;;;;;;;;;-1:-1:-1;47193:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;47314:25:0;;;47290:4;47314:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;47193:164;41664:192;;;;;;;;;;-1:-1:-1;41664:192:0;;;;;:::i;:::-;;:::i;64552:23::-;;;;;;;;;;;;;;;;65192:98;40810:7;40837:6;-1:-1:-1;;;;;40837:6:0;39034:10;40984:23;40976:68;;;;-1:-1:-1;;;40976:68:0;;;;;;;:::i;:::-;;;;;;;;;65262:8:::1;:20:::0;65192:98::o;68356:179::-;68467:4;68491:36;68515:11;68491:23;:36::i;:::-;68484:43;68356:179;-1:-1:-1;;68356:179:0:o;45067:100::-;45121:13;45154:5;45147:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45067:100;:::o;46534:221::-;46610:7;49863:16;;;:7;:16;;;;;;-1:-1:-1;;;;;49863:16:0;46630:73;;;;-1:-1:-1;;;46630:73:0;;7029:2:1;46630:73:0;;;7011:21:1;7068:2;7048:18;;;7041:30;7107:34;7087:18;;;7080:62;-1:-1:-1;;;7158:18:1;;;7151:42;7210:19;;46630:73:0;6827:408:1;46630:73:0;-1:-1:-1;46723:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;46723:24:0;;46534:221::o;46064:404::-;46145:13;46161:23;46176:7;46161:14;:23::i;:::-;46145:39;;46209:5;-1:-1:-1;;;;;46203:11:0;:2;-1:-1:-1;;;;;46203:11:0;;46195:57;;;;-1:-1:-1;;;46195:57:0;;7442:2:1;46195:57:0;;;7424:21:1;7481:2;7461:18;;;7454:30;7520:34;7500:18;;;7493:62;-1:-1:-1;;;7571:18:1;;;7564:31;7612:19;;46195:57:0;7240:397:1;46195:57:0;39034:10;-1:-1:-1;;;;;46273:21:0;;;;:69;;-1:-1:-1;46298:44:0;46322:5;39034:10;47193:164;:::i;46298:44::-;46265:161;;;;-1:-1:-1;;;46265:161:0;;7844:2:1;46265:161:0;;;7826:21:1;7883:2;7863:18;;;7856:30;7922:34;7902:18;;;7895:62;7993:26;7973:18;;;7966:54;8037:19;;46265:161:0;7642:420:1;46265:161:0;46439:21;46448:2;46452:7;46439:8;:21::i;:::-;46134:334;46064:404;;:::o;66161:726::-;39753:6;;39763:1;39753:11;39745:34;;;;-1:-1:-1;;;39745:34:0;;8269:2:1;39745:34:0;;;8251:21:1;8308:2;8288:18;;;8281:30;-1:-1:-1;;;8327:18:1;;;8320:40;8377:18;;39745:34:0;8067:334:1;39745:34:0;39801:1;39792:6;:10;66245:31:::1;::::0;;::::1;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;;:18:::1;::::0;66266:10;;;;;;66245:31;::::1;66266:10:::0;;;;66245:31;::::1;;::::0;::::1;::::0;;;-1:-1:-1;66245:31:0;;-1:-1:-1;66315:13:0::1;::::0;-1:-1:-1;66245:31:0;;-1:-1:-1;66315:7:0::1;::::0;-1:-1:-1;66315:13:0:i:1;:::-;66289:39;;66350:16;66367:9;66350:27;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;;::::1;;66349:28;66341:51;;;::::0;-1:-1:-1;;;66341:51:0;;8889:2:1;66341:51:0::1;::::0;::::1;8871:21:1::0;8928:2;8908:18;;;8901:30;-1:-1:-1;;;8947:18:1;;;8940:40;8997:18;;66341:51:0::1;8687:334:1::0;66341:51:0::1;66413:9;39034:10:::0;66413:25:::1;66405:58;;;::::0;-1:-1:-1;;;66405:58:0;;9228:2:1;66405:58:0::1;::::0;::::1;9210:21:1::0;9267:2;9247:18;;;9240:30;-1:-1:-1;;;9286:18:1;;;9279:50;9346:18;;66405:58:0::1;9026:344:1::0;66405:58:0::1;66480:8;::::0;:12;66476:101:::1;;66529:9;66517:8;;:21;66509:56;;;::::0;-1:-1:-1;;;66509:56:0;;9577:2:1;66509:56:0::1;::::0;::::1;9559:21:1::0;9616:2;9596:18;;;9589:30;-1:-1:-1;;;9635:18:1;;;9628:52;9697:18;;66509:56:0::1;9375:346:1::0;66509:56:0::1;66589:30;39034:10:::0;66609:9:::1;;66589:5;:30::i;:::-;66658:4;66632:11;66644:10;;66632:23;;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;:30;;;::::1;;-1:-1:-1::0;;66632:30:0;;::::1;::::0;;;::::1;::::0;;;;;66675:16:::1;::::0;:27:::1;::::0;66692:9;;66675:27:::1;:::i;:::-;::::0;;;::::1;::::0;;::::1;::::0;;;;;;;;:34;;-1:-1:-1;;66675:34:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;66736:9:::1;::::0;-1:-1:-1;66722:24:0;;;:13:::1;:24:::0;;;;:37:::1;::::0;66749:10;;66722:37:::1;:::i;:::-;-1:-1:-1::0;39034:10:0;-1:-1:-1;;;;;66777:76:0::1;;66798:9;;66830:10;;66816:35;;;;;;;;;:::i;:::-;;::::0;;-1:-1:-1;;66816:35:0;;::::1;::::0;;;;;;;66777:76:::1;::::0;;::::1;:::i;:::-;;;;;;;;66866:9;:11:::0;;;:9:::1;:11;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;39838:1:0;39829:10;;-1:-1:-1;;;;66161:726:0:o;47424:305::-;47585:41;39034:10;47618:7;47585:18;:41::i;:::-;47577:103;;;;-1:-1:-1;;;47577:103:0;;;;;;;:::i;:::-;47693:28;47703:4;47709:2;47713:7;47693:9;:28::i;57084:256::-;57181:7;57217:23;57234:5;57217:16;:23::i;:::-;57209:5;:31;57201:87;;;;-1:-1:-1;;;57201:87:0;;11575:2:1;57201:87:0;;;11557:21:1;11614:2;11594:18;;;11587:30;11653:34;11633:18;;;11626:62;-1:-1:-1;;;11704:18:1;;;11697:41;11755:19;;57201:87:0;11373:407:1;57201:87:0;-1:-1:-1;;;;;;57306:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;57084:256::o;66895:245::-;49839:4;49863:16;;;:7;:16;;;;;;66953:13;;-1:-1:-1;;;;;49863:16:0;66979:76;;;;-1:-1:-1;;;66979:76:0;;;;;;;:::i;:::-;67096:22;;;;:13;:22;;;;;;;;;67082:47;;;;67096:22;67082:47;;:::i;:::-;;;;;;;;;;;;;67068:62;;66895:245;;;:::o;47800:151::-;47904:39;47921:4;47927:2;47931:7;47904:39;;;;;;;;;;;;:16;:39::i;57606:233::-;57681:7;57717:30;57504:10;:17;;57416:113;57717:30;57709:5;:38;57701:95;;;;-1:-1:-1;;;57701:95:0;;13749:2:1;57701:95:0;;;13731:21:1;13788:2;13768:18;;;13761:30;13827:34;13807:18;;;13800:62;-1:-1:-1;;;13878:18:1;;;13871:42;13930:19;;57701:95:0;13547:408:1;57701:95:0;57814:10;57825:5;57814:17;;;;;;;;:::i;:::-;;;;;;;;;57807:24;;57606:233;;;:::o;65298:103::-;40810:7;40837:6;-1:-1:-1;;;;;40837:6:0;39034:10;40984:23;40976:68;;;;-1:-1:-1;;;40976:68:0;;;;;;;:::i;:::-;65370:23;;::::1;::::0;:13:::1;::::0;:23:::1;::::0;::::1;::::0;::::1;:::i;:::-;;65298:103:::0;:::o;44761:239::-;44833:7;44869:16;;;:7;:16;;;;;;-1:-1:-1;;;;;44869:16:0;;44896:73;;;;-1:-1:-1;;;44896:73:0;;14294:2:1;44896:73:0;;;14276:21:1;14333:2;14313:18;;;14306:30;14372:34;14352:18;;;14345:62;-1:-1:-1;;;14423:18:1;;;14416:39;14472:19;;44896:73:0;14092:405:1;44491:208:0;44563:7;-1:-1:-1;;;;;44591:19:0;;44583:74;;;;-1:-1:-1;;;44583:74:0;;14704:2:1;44583:74:0;;;14686:21:1;14743:2;14723:18;;;14716:30;14782:34;14762:18;;;14755:62;-1:-1:-1;;;14833:18:1;;;14826:40;14883:19;;44583:74:0;14502:406:1;44583:74:0;-1:-1:-1;;;;;;44675:16:0;;;;;:9;:16;;;;;;;44491:208::o;41415:94::-;40810:7;40837:6;-1:-1:-1;;;;;40837:6:0;39034:10;40984:23;40976:68;;;;-1:-1:-1;;;40976:68:0;;;;;;;:::i;:::-;41480:21:::1;41498:1;41480:9;:21::i;:::-;41415:94::o:0;65086:98::-;40810:7;40837:6;-1:-1:-1;;;;;40837:6:0;39034:10;40984:23;40976:68;;;;-1:-1:-1;;;40976:68:0;;;;;;;:::i;:::-;65156:8:::1;:20:::0;65086:98::o;45236:104::-;45292:13;45325:7;45318:14;;;;;:::i;69187:147::-;40810:7;40837:6;-1:-1:-1;;;;;40837:6:0;39034:10;40984:23;40976:68;;;;-1:-1:-1;;;40976:68:0;;;;;;;:::i;:::-;69269:57:::1;69297:6:::0;39034:10;69319:6:::1;69269:27;:57::i;46827:295::-:0;39034:10;-1:-1:-1;;;;;46930:24:0;;;46922:62;;;;-1:-1:-1;;;46922:62:0;;15115:2:1;46922:62:0;;;15097:21:1;15154:2;15134:18;;;15127:30;15193:27;15173:18;;;15166:55;15238:18;;46922:62:0;14913:349:1;46922:62:0;39034:10;46997:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;46997:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;46997:53:0;;;;;;;;;;47066:48;;725:41:1;;;46997:42:0;;39034:10;47066:48;;698:18:1;47066:48:0;;;;;;;46827:295;;:::o;64691:44::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;64992:86::-;40810:7;40837:6;-1:-1:-1;;;;;40837:6:0;39034:10;40984:23;40976:68;;;;-1:-1:-1;;;40976:68:0;;;;;;;:::i;:::-;65056:5:::1;:14:::0;;-1:-1:-1;;;;;;65056:14:0::1;-1:-1:-1::0;;;;;65056:14:0;;;::::1;::::0;;;::::1;::::0;;64992:86::o;48022:285::-;48154:41;39034:10;48187:7;48154:18;:41::i;:::-;48146:103;;;;-1:-1:-1;;;48146:103:0;;;;;;;:::i;:::-;48260:39;48274:4;48280:2;48284:7;48293:5;48260:13;:39::i;:::-;48022:285;;;;:::o;69053:126::-;40810:7;40837:6;-1:-1:-1;;;;;40837:6:0;39034:10;40984:23;40976:68;;;;-1:-1:-1;;;40976:68:0;;;;;;;:::i;:::-;69118:53:::1;39034:10:::0;69164:6:::1;69118:31;:53::i;:::-;69053:126:::0;:::o;67148:1134::-;49839:4;49863:16;;;:7;:16;;;;;;67239:13;;-1:-1:-1;;;;;49863:16:0;67265:76;;;;-1:-1:-1;;;67265:76:0;;;;;;;:::i;:::-;67354:20;:263;;;;;;;;;;;;;;;;;;;67630:17;67698:6;67725:13;:22;67739:7;67725:22;;;;;;;;;;;67667:128;;;;;;;;;:::i;:::-;;;;;;;;;;;;;67660:135;;67808:18;67829:338;68049:19;68063:4;68049:13;:19::i;:::-;67910:212;;;;;;;;:::i;:::-;;;;;;;;;;;;;67829:13;:338::i;:::-;67808:359;;68244:4;68194:55;;;;;;;;:::i;:::-;;;;-1:-1:-1;;68194:55:0;;;;;;;;;;67148:1134;-1:-1:-1;;;;;67148:1134:0:o;64422:27::-;;;;;;;:::i;65409:744::-;39753:6;;39763:1;39753:11;39745:34;;;;-1:-1:-1;;;39745:34:0;;8269:2:1;39745:34:0;;;8251:21:1;8308:2;8288:18;;;8281:30;-1:-1:-1;;;8327:18:1;;;8320:40;8377:18;;39745:34:0;8067:334:1;39745:34:0;39801:1;39792:6;:10;65490:31:::1;::::0;;::::1;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;;:18:::1;::::0;65511:10;;;;;;65490:31;::::1;65511:10:::0;;;;65490:31;::::1;;::::0;::::1;::::0;;;-1:-1:-1;65490:31:0;;-1:-1:-1;65560:13:0::1;::::0;-1:-1:-1;65490:31:0;;-1:-1:-1;65560:7:0::1;::::0;-1:-1:-1;65560:13:0:i:1;:::-;65534:39;;65595:16;65612:9;65595:27;;;;;;:::i;:::-;::::0;;;::::1;::::0;;;;;::::1;::::0;;;;::::1;;65594:28;65586:51;;;::::0;-1:-1:-1;;;65586:51:0;;8889:2:1;65586:51:0::1;::::0;::::1;8871:21:1::0;8928:2;8908:18;;;8901:30;-1:-1:-1;;;8947:18:1;;;8940:40;8997:18;;65586:51:0::1;8687:334:1::0;65586:51:0::1;65658:9;39034:10:::0;65658:25:::1;65650:58;;;::::0;-1:-1:-1;;;65650:58:0;;9228:2:1;65650:58:0::1;::::0;::::1;9210:21:1::0;9267:2;9247:18;;;9240:30;-1:-1:-1;;;9286:18:1;;;9279:50;9346:18;;65650:58:0::1;9026:344:1::0;65650:58:0::1;65725:8;::::0;:12;65721:122:::1;;65786:5;::::0;65754:77:::1;::::0;-1:-1:-1;;;;;65786:5:0::1;39034:10:::0;65815:4:::1;65822:8;;65754:31;:77::i;41664:192::-:0;40810:7;40837:6;-1:-1:-1;;;;;40837:6:0;39034:10;40984:23;40976:68;;;;-1:-1:-1;;;40976:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;41753:22:0;::::1;41745:73;;;::::0;-1:-1:-1;;;41745:73:0;;17243:2:1;41745:73:0::1;::::0;::::1;17225:21:1::0;17282:2;17262:18;;;17255:30;17321:34;17301:18;;;17294:62;-1:-1:-1;;;17372:18:1;;;17365:36;17418:19;;41745:73:0::1;17041:402:1::0;41745:73:0::1;41829:19;41839:8;41829:9;:19::i;56763:237::-:0;56865:4;-1:-1:-1;;;;;;56889:50:0;;-1:-1:-1;;;56889:50:0;;:103;;;56956:36;56980:11;56956:23;:36::i;53658:174::-;53733:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;53733:29:0;-1:-1:-1;;;;;53733:29:0;;;;;;;;:24;;53787:23;53733:24;53787:14;:23::i;:::-;-1:-1:-1;;;;;53778:46:0;;;;;;;;;;;53658:174;;:::o;68740:305::-;68801:18;68837:6;68832:181;68855:5;68849:19;68847:1;:21;68832:181;;;-1:-1:-1;;;68900:5:0;68907:1;68894:15;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;68894:15:0;:22;;;;:48;;;-1:-1:-1;;;68926:5:0;68933:1;68920:15;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;68920:15:0;:22;;68894:48;68890:112;;;68982:4;68963:23;;68969:5;68976:1;68963:15;;;;;;;;:::i;:::-;;;;:23;;-1:-1:-1;;;;;;68963:23:0;;;;;;;;;;;;;;;;;68890:112;68870:3;;;:::i;:::-;;;68832:181;;;-1:-1:-1;69032:5:0;;68740:305;-1:-1:-1;68740:305:0:o;51688:382::-;-1:-1:-1;;;;;51768:16:0;;51760:61;;;;-1:-1:-1;;;51760:61:0;;17650:2:1;51760:61:0;;;17632:21:1;;;17669:18;;;17662:30;17728:34;17708:18;;;17701:62;17780:18;;51760:61:0;17448:356:1;51760:61:0;49839:4;49863:16;;;:7;:16;;;;;;-1:-1:-1;;;;;49863:16:0;:30;51832:58;;;;-1:-1:-1;;;51832:58:0;;18011:2:1;51832:58:0;;;17993:21:1;18050:2;18030:18;;;18023:30;18089;18069:18;;;18062:58;18137:18;;51832:58:0;17809:352:1;51832:58:0;51903:45;51932:1;51936:2;51940:7;51903:20;:45::i;:::-;-1:-1:-1;;;;;51961:13:0;;;;;;:9;:13;;;;;:18;;51978:1;;51961:13;:18;;51978:1;;51961:18;:::i;:::-;;;;-1:-1:-1;;51990:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;51990:21:0;-1:-1:-1;;;;;51990:21:0;;;;;;;;52029:33;;51990:16;;;52029:33;;51990:16;;52029:33;51688:382;;:::o;50068:355::-;50161:4;49863:16;;;:7;:16;;;;;;-1:-1:-1;;;;;49863:16:0;50178:73;;;;-1:-1:-1;;;50178:73:0;;18501:2:1;50178:73:0;;;18483:21:1;18540:2;18520:18;;;18513:30;18579:34;18559:18;;;18552:62;-1:-1:-1;;;18630:18:1;;;18623:42;18682:19;;50178:73:0;18299:408:1;50178:73:0;50262:13;50278:23;50293:7;50278:14;:23::i;:::-;50262:39;;50331:5;-1:-1:-1;;;;;50320:16:0;:7;-1:-1:-1;;;;;50320:16:0;;:51;;;;50364:7;-1:-1:-1;;;;;50340:31:0;:20;50352:7;50340:11;:20::i;:::-;-1:-1:-1;;;;;50340:31:0;;50320:51;:94;;;-1:-1:-1;;;;;;47314:25:0;;;47290:4;47314:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;50375:39;50312:103;50068:355;-1:-1:-1;;;;50068:355:0:o;52996:544::-;53121:4;-1:-1:-1;;;;;53094:31:0;:23;53109:7;53094:14;:23::i;:::-;-1:-1:-1;;;;;53094:31:0;;53086:85;;;;-1:-1:-1;;;53086:85:0;;18914:2:1;53086:85:0;;;18896:21:1;18953:2;18933:18;;;18926:30;18992:34;18972:18;;;18965:62;-1:-1:-1;;;19043:18:1;;;19036:39;19092:19;;53086:85:0;18712:405:1;53086:85:0;-1:-1:-1;;;;;53190:16:0;;53182:65;;;;-1:-1:-1;;;53182:65:0;;19324:2:1;53182:65:0;;;19306:21:1;19363:2;19343:18;;;19336:30;19402:34;19382:18;;;19375:62;-1:-1:-1;;;19453:18:1;;;19446:34;19497:19;;53182:65:0;19122:400:1;53182:65:0;53260:39;53281:4;53287:2;53291:7;53260:20;:39::i;:::-;53364:29;53381:1;53385:7;53364:8;:29::i;:::-;-1:-1:-1;;;;;53406:15:0;;;;;;:9;:15;;;;;:20;;53425:1;;53406:15;:20;;53425:1;;53406:20;:::i;:::-;;;;-1:-1:-1;;;;;;;53437:13:0;;;;;;:9;:13;;;;;:18;;53454:1;;53437:13;:18;;53454:1;;53437:18;:::i;:::-;;;;-1:-1:-1;;53466:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;53466:21:0;-1:-1:-1;;;;;53466:21:0;;;;;;;;;53505:27;;53466:16;;53505:27;;;;;;;52996:544;;;:::o;41864:173::-;41920:16;41939:6;;-1:-1:-1;;;;;41956:17:0;;;-1:-1:-1;;;;;;41956:17:0;;;;;;41989:40;;41939:6;;;;;;;41989:40;;41920:16;41989:40;41909:128;41864:173;:::o;29546:449::-;29778:45;;;-1:-1:-1;;;;;19849:32:1;;;29778:45:0;;;19831:51:1;19898:18;;;;19891:34;;;29778:45:0;;;;;;;;;;19804:18:1;;;;29778:45:0;;;;;;;-1:-1:-1;;;;;29778:45:0;-1:-1:-1;;;29778:45:0;;;29767:57;;-1:-1:-1;;;;29767:10:0;;;;:57;;29778:45;29767:57;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29731:93;;;;29857:7;:57;;;;-1:-1:-1;29869:11:0;;:16;;:44;;;29900:4;29889:24;;;;;;;;;;;;:::i;:::-;29835:152;;;;-1:-1:-1;;;29835:152:0;;20667:2:1;29835:152:0;;;20649:21:1;20706:2;20686:18;;;20679:30;20745:34;20725:18;;;20718:62;-1:-1:-1;;;20796:18:1;;;20789:43;20849:19;;29835:152:0;20465:409:1;29835:152:0;29653:342;;29546:449;;;:::o;49189:272::-;49303:28;49313:4;49319:2;49323:7;49303:9;:28::i;:::-;49350:48;49373:4;49379:2;49383:7;49392:5;49350:22;:48::i;:::-;49342:111;;;;-1:-1:-1;;;49342:111:0;;;;;;;:::i;30509:220::-;30623:12;;;30583;30623;;;;;;;;;-1:-1:-1;;;;;30601:7:0;;;30616:5;;30601:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30582:54;;;30655:7;30647:74;;;;-1:-1:-1;;;30647:74:0;;21500:2:1;30647:74:0;;;21482:21:1;21539:2;21519:18;;;21512:30;21578:34;21558:18;;;21551:62;-1:-1:-1;;;21629:18:1;;;21622:52;21691:19;;30647:74:0;21298:418:1;7758:1607:0;7856:11;;7816:13;;7842:11;7882:8;;;7878:23;;-1:-1:-1;;7892:9:0;;;;;;;;;-1:-1:-1;7892:9:0;;;7758:1607;-1:-1:-1;7758:1607:0:o;7878:23::-;7953:18;7991:1;7980:7;:3;7986:1;7980:7;:::i;:::-;7979:13;;;;:::i;:::-;7974:19;;:1;:19;:::i;:::-;7953:40;-1:-1:-1;8051:19:0;8083:15;7953:40;8096:2;8083:15;:::i;:::-;8073:26;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8073:26:0;;8051:48;;8112:18;8133:5;;;;;;;;;;;;;;;;;8112:26;;8202:1;8195:5;8191:13;8247:2;8239:6;8235:15;8298:1;8266:777;8321:3;8318:1;8315:10;8266:777;;;8376:1;8419:12;;;;;8413:19;8514:4;8502:2;8498:14;;;;;8480:40;;8474:47;8623:2;8619:14;;;8615:25;;8601:40;;8595:47;8752:1;8748:13;;;8744:24;;8730:39;;8724:46;8872:16;;;;8858:31;;8852:38;8550:1;8546:11;;;8644:4;8591:58;;;8582:68;8675:11;;8720:57;;;8711:67;;;;8803:11;;8848:49;;8839:59;8927:3;8923:13;8956:22;;9026:1;9011:17;;;;8369:9;8266:777;;;8270:44;9075:1;9070:3;9066:11;9096:1;9091:84;;;;9194:1;9189:82;;;;9059:212;;9091:84;-1:-1:-1;;;;;9124:17:0;;9117:43;9091:84;;9189:82;-1:-1:-1;;;;;9222:17:0;;9215:41;9059:212;-1:-1:-1;;;9287:26:0;;;9294:6;7758:1607;-1:-1:-1;;;;7758:1607:0:o;30003:498::-;30274:51;;;-1:-1:-1;;;;;22374:15:1;;;30274:51:0;;;22356:34:1;22426:15;;;22406:18;;;22399:43;22458:18;;;;22451:34;;;30274:51:0;;;;;;;;;;22291:18:1;;;;30274:51:0;;;;;;;-1:-1:-1;;;;;30274:51:0;-1:-1:-1;;;30274:51:0;;;30263:63;;-1:-1:-1;;;;30263:10:0;;;;:63;;30274:51;30263:63;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30227:99;;;;30359:7;:57;;;;-1:-1:-1;30371:11:0;;:16;;:44;;;30402:4;30391:24;;;;;;;;;;;;:::i;:::-;30337:156;;;;-1:-1:-1;;;30337:156:0;;22698:2:1;30337:156:0;;;22680:21:1;22737:2;22717:18;;;22710:30;22776:34;22756:18;;;22749:62;-1:-1:-1;;;22827:18:1;;;22820:47;22884:19;;30337:156:0;22496:413:1;30337:156:0;30137:364;;30003:498;;;;:::o;44139:288::-;44241:4;-1:-1:-1;;;;;;44265:40:0;;-1:-1:-1;;;44265:40:0;;:101;;-1:-1:-1;;;;;;;44318:48:0;;-1:-1:-1;;;44318:48:0;44265:101;:154;;;-1:-1:-1;;;;;;;;;;42851:40:0;;;44383:36;42742:157;68543:189;68679:45;68706:4;68712:2;68716:7;68679:26;:45::i;54397:839::-;54514:4;-1:-1:-1;;;;;54540:13:0;;10420:20;10459:8;54536:693;;54576:72;;-1:-1:-1;;;54576:72:0;;-1:-1:-1;;;;;54576:36:0;;;;;:72;;39034:10;;54627:4;;54633:7;;54642:5;;54576:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54576:72:0;;;;;;;;-1:-1:-1;;54576:72:0;;;;;;;;;;;;:::i;:::-;;;54572:602;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54822:6;:13;54839:1;54822:18;54818:341;;54865:60;;-1:-1:-1;;;54865:60:0;;;;;;;:::i;54818:341::-;55109:6;55103:13;55094:6;55090:2;55086:15;55079:38;54572:602;-1:-1:-1;;;;;;54699:55:0;-1:-1:-1;;;54699:55:0;;-1:-1:-1;54692:62:0;;54536:693;-1:-1:-1;55213:4:0;54397:839;;;;;;:::o;58452:555::-;-1:-1:-1;;;;;58624:18:0;;58620:187;;58659:40;58691:7;59834:10;:17;;59807:24;;;;:15;:24;;;;;:44;;;59862:24;;;;;;;;;;;;59730:164;58659:40;58620:187;;;58729:2;-1:-1:-1;;;;;58721:10:0;:4;-1:-1:-1;;;;;58721:10:0;;58717:90;;58748:47;58781:4;58787:7;58748:32;:47::i;:::-;-1:-1:-1;;;;;58821:16:0;;58817:183;;58854:45;58891:7;58854:36;:45::i;58817:183::-;58927:4;-1:-1:-1;;;;;58921:10:0;:2;-1:-1:-1;;;;;58921:10:0;;58917:83;;58948:40;58976:2;58980:7;58948:27;:40::i;60521:988::-;60787:22;60837:1;60812:22;60829:4;60812:16;:22::i;:::-;:26;;;;:::i;:::-;60849:18;60870:26;;;:17;:26;;;;;;60787:51;;-1:-1:-1;61003:28:0;;;60999:328;;-1:-1:-1;;;;;61070:18:0;;61048:19;61070:18;;;:12;:18;;;;;;;;:34;;;;;;;;;61121:30;;;;;;:44;;;61238:30;;:17;:30;;;;;:43;;;60999:328;-1:-1:-1;61423:26:0;;;;:17;:26;;;;;;;;61416:33;;;-1:-1:-1;;;;;61467:18:0;;;;;:12;:18;;;;;:34;;;;;;;61460:41;60521:988::o;61804:1079::-;62082:10;:17;62057:22;;62082:21;;62102:1;;62082:21;:::i;:::-;62114:18;62135:24;;;:15;:24;;;;;;62508:10;:26;;62057:46;;-1:-1:-1;62135:24:0;;62057:46;;62508:26;;;;;;:::i;:::-;;;;;;;;;62486:48;;62572:11;62547:10;62558;62547:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;62652:28;;;:15;:28;;;;;;;:41;;;62824:24;;;;;62817:31;62859:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;61875:1008;;;61804:1079;:::o;59308:221::-;59393:14;59410:20;59427:2;59410:16;:20::i;:::-;-1:-1:-1;;;;;59441:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;59486:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;59308:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:180:1;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;199:131::-;-1:-1:-1;;;;;;273:32:1;;263:43;;253:71;;320:1;317;310:12;335:245;393:6;446:2;434:9;425:7;421:23;417:32;414:52;;;462:1;459;452:12;414:52;501:9;488:23;520:30;544:5;520:30;:::i;:::-;569:5;335:245;-1:-1:-1;;;335:245:1:o;777:258::-;849:1;859:113;873:6;870:1;867:13;859:113;;;949:11;;;943:18;930:11;;;923:39;895:2;888:10;859:113;;;990:6;987:1;984:13;981:48;;;-1:-1:-1;;1025:1:1;1007:16;;1000:27;777:258::o;1040:::-;1082:3;1120:5;1114:12;1147:6;1142:3;1135:19;1163:63;1219:6;1212:4;1207:3;1203:14;1196:4;1189:5;1185:16;1163:63;:::i;:::-;1280:2;1259:15;-1:-1:-1;;1255:29:1;1246:39;;;;1287:4;1242:50;;1040:258;-1:-1:-1;;1040:258:1:o;1303:220::-;1452:2;1441:9;1434:21;1415:4;1472:45;1513:2;1502:9;1498:18;1490:6;1472:45;:::i;1736:173::-;1804:20;;-1:-1:-1;;;;;1853:31:1;;1843:42;;1833:70;;1899:1;1896;1889:12;1833:70;1736:173;;;:::o;1914:254::-;1982:6;1990;2043:2;2031:9;2022:7;2018:23;2014:32;2011:52;;;2059:1;2056;2049:12;2011:52;2082:29;2101:9;2082:29;:::i;:::-;2072:39;2158:2;2143:18;;;;2130:32;;-1:-1:-1;;;1914:254:1:o;2173:592::-;2244:6;2252;2305:2;2293:9;2284:7;2280:23;2276:32;2273:52;;;2321:1;2318;2311:12;2273:52;2361:9;2348:23;2390:18;2431:2;2423:6;2420:14;2417:34;;;2447:1;2444;2437:12;2417:34;2485:6;2474:9;2470:22;2460:32;;2530:7;2523:4;2519:2;2515:13;2511:27;2501:55;;2552:1;2549;2542:12;2501:55;2592:2;2579:16;2618:2;2610:6;2607:14;2604:34;;;2634:1;2631;2624:12;2604:34;2679:7;2674:2;2665:6;2661:2;2657:15;2653:24;2650:37;2647:57;;;2700:1;2697;2690:12;2647:57;2731:2;2723:11;;;;;2753:6;;-1:-1:-1;2173:592:1;;-1:-1:-1;;;;2173:592:1:o;2952:328::-;3029:6;3037;3045;3098:2;3086:9;3077:7;3073:23;3069:32;3066:52;;;3114:1;3111;3104:12;3066:52;3137:29;3156:9;3137:29;:::i;:::-;3127:39;;3185:38;3219:2;3208:9;3204:18;3185:38;:::i;:::-;3175:48;;3270:2;3259:9;3255:18;3242:32;3232:42;;2952:328;;;;;:::o;3285:127::-;3346:10;3341:3;3337:20;3334:1;3327:31;3377:4;3374:1;3367:15;3401:4;3398:1;3391:15;3417:632;3482:5;3512:18;3553:2;3545:6;3542:14;3539:40;;;3559:18;;:::i;:::-;3634:2;3628:9;3602:2;3688:15;;-1:-1:-1;;3684:24:1;;;3710:2;3680:33;3676:42;3664:55;;;3734:18;;;3754:22;;;3731:46;3728:72;;;3780:18;;:::i;:::-;3820:10;3816:2;3809:22;3849:6;3840:15;;3879:6;3871;3864:22;3919:3;3910:6;3905:3;3901:16;3898:25;3895:45;;;3936:1;3933;3926:12;3895:45;3986:6;3981:3;3974:4;3966:6;3962:17;3949:44;4041:1;4034:4;4025:6;4017;4013:19;4009:30;4002:41;;;;3417:632;;;;;:::o;4054:451::-;4123:6;4176:2;4164:9;4155:7;4151:23;4147:32;4144:52;;;4192:1;4189;4182:12;4144:52;4232:9;4219:23;4265:18;4257:6;4254:30;4251:50;;;4297:1;4294;4287:12;4251:50;4320:22;;4373:4;4365:13;;4361:27;-1:-1:-1;4351:55:1;;4402:1;4399;4392:12;4351:55;4425:74;4491:7;4486:2;4473:16;4468:2;4464;4460:11;4425:74;:::i;4510:186::-;4569:6;4622:2;4610:9;4601:7;4597:23;4593:32;4590:52;;;4638:1;4635;4628:12;4590:52;4661:29;4680:9;4661:29;:::i;4701:118::-;4787:5;4780:13;4773:21;4766:5;4763:32;4753:60;;4809:1;4806;4799:12;4824:315;4889:6;4897;4950:2;4938:9;4929:7;4925:23;4921:32;4918:52;;;4966:1;4963;4956:12;4918:52;4989:29;5008:9;4989:29;:::i;:::-;4979:39;;5068:2;5057:9;5053:18;5040:32;5081:28;5103:5;5081:28;:::i;:::-;5128:5;5118:15;;;4824:315;;;;;:::o;5144:667::-;5239:6;5247;5255;5263;5316:3;5304:9;5295:7;5291:23;5287:33;5284:53;;;5333:1;5330;5323:12;5284:53;5356:29;5375:9;5356:29;:::i;:::-;5346:39;;5404:38;5438:2;5427:9;5423:18;5404:38;:::i;:::-;5394:48;;5489:2;5478:9;5474:18;5461:32;5451:42;;5544:2;5533:9;5529:18;5516:32;5571:18;5563:6;5560:30;5557:50;;;5603:1;5600;5593:12;5557:50;5626:22;;5679:4;5671:13;;5667:27;-1:-1:-1;5657:55:1;;5708:1;5705;5698:12;5657:55;5731:74;5797:7;5792:2;5779:16;5774:2;5770;5766:11;5731:74;:::i;:::-;5721:84;;;5144:667;;;;;;;:::o;5816:260::-;5884:6;5892;5945:2;5933:9;5924:7;5920:23;5916:32;5913:52;;;5961:1;5958;5951:12;5913:52;5984:29;6003:9;5984:29;:::i;:::-;5974:39;;6032:38;6066:2;6055:9;6051:18;6032:38;:::i;:::-;6022:48;;5816:260;;;;;:::o;6081:356::-;6283:2;6265:21;;;6302:18;;;6295:30;6361:34;6356:2;6341:18;;6334:62;6428:2;6413:18;;6081:356::o;6442:380::-;6521:1;6517:12;;;;6564;;;6585:61;;6639:4;6631:6;6627:17;6617:27;;6585:61;6692:2;6684:6;6681:14;6661:18;6658:38;6655:161;;6738:10;6733:3;6729:20;6726:1;6719:31;6773:4;6770:1;6763:15;6801:4;6798:1;6791:15;6655:161;;6442:380;;;:::o;8406:276::-;8537:3;8575:6;8569:13;8591:53;8637:6;8632:3;8625:4;8617:6;8613:17;8591:53;:::i;:::-;8660:16;;;;;8406:276;-1:-1:-1;;8406:276:1:o;9726:273::-;9911:6;9903;9898:3;9885:33;9867:3;9937:16;;9962:13;;;9937:16;9726:273;-1:-1:-1;9726:273:1:o;10004:378::-;10279:6;10271;10266:3;10253:33;-1:-1:-1;;;10305:16:1;;10330:20;;;10374:1;10366:10;;10004:378;-1:-1:-1;10004:378:1:o;10387:291::-;10564:6;10553:9;10546:25;10607:2;10602;10591:9;10587:18;10580:30;10527:4;10627:45;10668:2;10657:9;10653:18;10645:6;10627:45;:::i;10683:127::-;10744:10;10739:3;10735:20;10732:1;10725:31;10775:4;10772:1;10765:15;10799:4;10796:1;10789:15;10815:135;10854:3;10875:17;;;10872:43;;10895:18;;:::i;:::-;-1:-1:-1;10942:1:1;10931:13;;10815:135::o;10955:413::-;11157:2;11139:21;;;11196:2;11176:18;;;11169:30;11235:34;11230:2;11215:18;;11208:62;-1:-1:-1;;;11301:2:1;11286:18;;11279:47;11358:3;11343:19;;10955:413::o;11785:411::-;11987:2;11969:21;;;12026:2;12006:18;;;11999:30;12065:34;12060:2;12045:18;;12038:62;-1:-1:-1;;;12131:2:1;12116:18;;12109:45;12186:3;12171:19;;11785:411::o;12201:982::-;12286:12;;12251:3;;12341:1;12361:18;;;;12414;;;;12441:61;;12495:4;12487:6;12483:17;12473:27;;12441:61;12521:2;12569;12561:6;12558:14;12538:18;12535:38;12532:161;;12615:10;12610:3;12606:20;12603:1;12596:31;12650:4;12647:1;12640:15;12678:4;12675:1;12668:15;12532:161;12709:18;12736:104;;;;12854:1;12849:328;;;;12702:475;;12736:104;-1:-1:-1;;12769:24:1;;12757:37;;12814:16;;;;-1:-1:-1;12736:104:1;;12849:328;12880:5;12877:1;12870:16;12927:2;12924:1;12914:16;12952:1;12966:165;12980:6;12977:1;12974:13;12966:165;;;13058:14;;13045:11;;;13038:35;13101:16;;;;12995:10;;12966:165;;;12970:3;;13160:6;13155:3;13151:16;13144:23;;12702:475;;;;;;;12201:982;;;;:::o;13188:354::-;13406:3;13437:38;13471:3;13463:6;13437:38;:::i;:::-;-1:-1:-1;;;13484:23:1;;13534:1;13523:13;;13188:354;-1:-1:-1;;;13188:354:1:o;13960:127::-;14021:10;14016:3;14012:20;14009:1;14002:31;14052:4;14049:1;14042:15;14076:4;14073:1;14066:15;15267:531;15546:3;15584:6;15578:13;15600:53;15646:6;15641:3;15634:4;15626:6;15622:17;15600:53;:::i;:::-;15672:51;15715:6;15710:3;15706:16;15698:6;15672:51;:::i;:::-;-1:-1:-1;;;15732:33:1;;15789:2;15781:11;;15267:531;-1:-1:-1;;;;;15267:531:1:o;15803:780::-;16166:66;16161:3;16154:79;16263:66;16258:2;16253:3;16249:12;16242:88;-1:-1:-1;;;16355:2:1;16350:3;16346:12;16339:27;16136:3;16395:6;16389:13;16411:60;16464:6;16459:2;16454:3;16450:12;16445:2;16437:6;16433:15;16411:60;:::i;:::-;-1:-1:-1;;;16530:2:1;16490:16;;;;16522:11;;;16515:35;-1:-1:-1;16574:2:1;16566:11;;15803:780;-1:-1:-1;15803:780:1:o;16588:448::-;16850:31;16845:3;16838:44;16820:3;16911:6;16905:13;16927:62;16982:6;16977:2;16972:3;16968:12;16961:4;16953:6;16949:17;16927:62;:::i;:::-;17009:16;;;;17027:2;17005:25;;16588:448;-1:-1:-1;;16588:448:1:o;18166:128::-;18206:3;18237:1;18233:6;18230:1;18227:13;18224:39;;;18243:18;;:::i;:::-;-1:-1:-1;18279:9:1;;18166:128::o;19527:125::-;19567:4;19595:1;19592;19589:8;19586:34;;;19600:18;;:::i;:::-;-1:-1:-1;19637:9:1;;19527:125::o;20215:245::-;20282:6;20335:2;20323:9;20314:7;20310:23;20306:32;20303:52;;;20351:1;20348;20341:12;20303:52;20383:9;20377:16;20402:28;20424:5;20402:28;:::i;20879:414::-;21081:2;21063:21;;;21120:2;21100:18;;;21093:30;21159:34;21154:2;21139:18;;21132:62;-1:-1:-1;;;21225:2:1;21210:18;;21203:48;21283:3;21268:19;;20879:414::o;21721:217::-;21761:1;21787;21777:132;;21831:10;21826:3;21822:20;21819:1;21812:31;21866:4;21863:1;21856:15;21894:4;21891:1;21884:15;21777:132;-1:-1:-1;21923:9:1;;21721:217::o;21943:168::-;21983:7;22049:1;22045;22041:6;22037:14;22034:1;22031:21;22026:1;22019:9;22012:17;22008:45;22005:71;;;22056:18;;:::i;:::-;-1:-1:-1;22096:9:1;;21943:168::o;22914:489::-;-1:-1:-1;;;;;23183:15:1;;;23165:34;;23235:15;;23230:2;23215:18;;23208:43;23282:2;23267:18;;23260:34;;;23330:3;23325:2;23310:18;;23303:31;;;23108:4;;23351:46;;23377:19;;23369:6;23351:46;:::i;:::-;23343:54;22914:489;-1:-1:-1;;;;;;22914:489:1:o;23408:249::-;23477:6;23530:2;23518:9;23509:7;23505:23;23501:32;23498:52;;;23546:1;23543;23536:12;23498:52;23578:9;23572:16;23597:30;23621:5;23597:30;:::i;23662:127::-;23723:10;23718:3;23714:20;23711:1;23704:31;23754:4;23751:1;23744:15;23778:4;23775:1;23768:15

Swarm Source

ipfs://373e54c93a457e0236c658acde3878e82f0b528bb6ce0902667c5f21f708f0f5

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