Token

Kevamigos V2 (KEVSv2)

ERC-721

Overview

Max Total Supply

206 KEVSv2

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x29721a0ac3729c48ebb5b746c3ef5b2fb9abd28a

Filtered by Token Holder

0x7C97eeD47Ca019F5356595B8135fBa7Acd72A914

Balance

5 KEVSv2

0x7c97eed47ca019f5356595b8135fba7acd72a914

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

NFT

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-04-13
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

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

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

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

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

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

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// File: contracts/IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;


interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}
// File: contracts/OperatorFilterer.sol


pragma solidity ^0.8.13;


contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry constant operatorFilterRegistry =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(operatorFilterRegistry).code.length > 0) {
            if (subscribe) {
                operatorFilterRegistry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    operatorFilterRegistry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    operatorFilterRegistry.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator() virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(operatorFilterRegistry).code.length > 0) {
            if (!operatorFilterRegistry.isOperatorAllowed(address(this), msg.sender)) {
                revert OperatorNotAllowed(msg.sender);
            }
        }
        _;
    }
}
// File: contracts/DefaultOperatorFilterer.sol


pragma solidity ^0.8.13;


contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}
// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(
        uint256 x,
        uint256 y,
        uint256 denominator,
        Rounding rounding
    ) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10**64) {
                value /= 10**64;
                result += 64;
            }
            if (value >= 10**32) {
                value /= 10**32;
                result += 32;
            }
            if (value >= 10**16) {
                value /= 10**16;
                result += 16;
            }
            if (value >= 10**8) {
                value /= 10**8;
                result += 8;
            }
            if (value >= 10**4) {
                value /= 10**4;
                result += 4;
            }
            if (value >= 10**2) {
                value /= 10**2;
                result += 2;
            }
            if (value >= 10**1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @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] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

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


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

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * 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;

    /**
     * @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 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: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * 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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

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


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

pragma solidity ^0.8.0;


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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;








/**
 * @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: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        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) {
        _requireMinted(tokenId);

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

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

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

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

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

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or 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: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @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 _ownerOf(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) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == 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, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

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

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

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

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

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

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

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

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

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

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

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

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    /// @solidity memory-safe-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. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual {}

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant
     * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such
     * that `ownerOf(tokenId)` is `a`.
     */
    // solhint-disable-next-line func-name-mixedcase
    function __unsafe_increaseBalance(address account, uint256 amount) internal {
        _balances[account] += amount;
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

// File: contracts/Kevamigos V2.sol


pragma solidity ^0.8.9;




contract NFT is ERC721, Ownable, DefaultOperatorFilterer {
    using Strings for uint256;

    uint public constant MAX_TOKENS = 555;
    uint private constant TOKENS_RESERVED = 5;
    uint public price = 1000000000000000;
    uint256 public constant MAX_MINT_PER_TX = 10;

    bool public isSaleActive;
    uint256 public totalSupply;
    mapping(address => uint256) private mintedPerWallet;

    string public baseUri;
    string public baseExtension = ".json";

    constructor() ERC721("Kevamigos V2", "KEVSv2") {
        baseUri = "ipfs://QmeFPTTA7QjCiQVihWNaXmgtWLFvEoriz558u1ubf5uHQ8/";
        for(uint256 i = 1; i <= TOKENS_RESERVED; ++i) {
            _safeMint(msg.sender, i);
        }
        totalSupply = TOKENS_RESERVED;
    }

    // Public Functions
    function mint(uint256 _numTokens) external payable {
        require(isSaleActive, "The sale is paused.");
        require(_numTokens <= MAX_MINT_PER_TX, "You cannot mint that many in one transaction.");
        require(mintedPerWallet[msg.sender] + _numTokens <= MAX_MINT_PER_TX, "You cannot mint that many total.");
        uint256 curTotalSupply = totalSupply;
        require(curTotalSupply + _numTokens <= MAX_TOKENS, "Exceeds total supply.");
        require(_numTokens * price <= msg.value, "Insufficient funds.");

        for(uint256 i = 1; i <= _numTokens; ++i) {
            _safeMint(msg.sender, curTotalSupply + i);
        }
        mintedPerWallet[msg.sender] += _numTokens;
        totalSupply += _numTokens;
    }

    // Owner-only functions
    function flipSaleState() external onlyOwner {
        isSaleActive = !isSaleActive;
    }

    function setBaseUri(string memory _baseUri) external onlyOwner {
        baseUri = _baseUri;
    }

    function setPrice(uint256 _price) external onlyOwner {
        price = _price;
    }

    function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator {
        super.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
        public
        override
        onlyAllowedOperator
    {
        super.safeTransferFrom(from, to, tokenId, data);
    }

    function withdrawAll() external payable onlyOwner {
    uint256 balance = address(this).balance;
    uint256 balanceOne = balance * 100 / 100;
    uint256 balanceTwo = balance * 0 / 100;
    ( bool transferOne, ) = payable(0x7a92a9cD2f78aBe6E3716eb5cc2eD762aE90c88A).call{value: balanceOne}("");
    ( bool transferTwo, ) = payable(0xD9625e685E52D09C6B191b92D89314A33Be9d529).call{value: balanceTwo}("");
    require(transferOne && transferTwo, "Transfer failed.");
}

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
 
        string memory currentBaseURI = _baseURI();
        return bytes(currentBaseURI).length > 0
            ? string(abi.encodePacked(currentBaseURI, tokenId.toString(), baseExtension))
            : "";
    }
 
    function _baseURI() internal view virtual override returns (string memory) {
        return baseUri;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MAX_MINT_PER_TX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TOKENS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isSaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numTokens","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"_price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

72288:3444:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53319:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54247:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55759:171;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55277:416;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72605:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74165:157;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73864:91;;;;;;;;;;;;;:::i;:::-;;74330:165;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72574:24;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53957:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53688:207;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71397:103;;;;;;;;;;;;;:::i;:::-;;74733:474;;;:::i;:::-;;70749:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72521:44;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74071:86;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54416:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72698:21;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;72478:36;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73084:743;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73963:100;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56002:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74503:222;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72726:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75215:397;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56228:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71655:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;72386:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53319:305;53421:4;53473:25;53458:40;;;:11;:40;;;;:105;;;;53530:33;53515:48;;;:11;:48;;;;53458:105;:158;;;;53580:36;53604:11;53580:23;:36::i;:::-;53458:158;53438:178;;53319:305;;;:::o;54247:100::-;54301:13;54334:5;54327:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54247:100;:::o;55759:171::-;55835:7;55855:23;55870:7;55855:14;:23::i;:::-;55898:15;:24;55914:7;55898:24;;;;;;;;;;;;;;;;;;;;;55891:31;;55759:171;;;:::o;55277:416::-;55358:13;55374:23;55389:7;55374:14;:23::i;:::-;55358:39;;55422:5;55416:11;;:2;:11;;;55408:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;55516:5;55500:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;55525:37;55542:5;55549:12;:10;:12::i;:::-;55525:16;:37::i;:::-;55500:62;55478:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;55664:21;55673:2;55677:7;55664:8;:21::i;:::-;55347:346;55277:416;;:::o;72605:26::-;;;;:::o;74165:157::-;16968:1;15794:42;16922:43;;;:47;16918:225;;;15794:42;16991:40;;;17040:4;17047:10;16991:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16986:146;;17105:10;17086:30;;;;;;;;;;;:::i;:::-;;;;;;;;16986:146;16918:225;74277:37:::1;74296:4;74302:2;74306:7;74277:18;:37::i;:::-;74165:157:::0;;;:::o;73864:91::-;70635:13;:11;:13::i;:::-;73935:12:::1;;;;;;;;;;;73934:13;73919:12;;:28;;;;;;;;;;;;;;;;;;73864:91::o:0;74330:165::-;16968:1;15794:42;16922:43;;;:47;16918:225;;;15794:42;16991:40;;;17040:4;17047:10;16991:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16986:146;;17105:10;17086:30;;;;;;;;;;;:::i;:::-;;;;;;;;16986:146;16918:225;74446:41:::1;74469:4;74475:2;74479:7;74446:22;:41::i;:::-;74330:165:::0;;;:::o;72574:24::-;;;;;;;;;;;;;:::o;53957:223::-;54029:7;54049:13;54065:17;54074:7;54065:8;:17::i;:::-;54049:33;;54118:1;54101:19;;:5;:19;;;54093:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;54167:5;54160:12;;;53957:223;;;:::o;53688:207::-;53760:7;53805:1;53788:19;;:5;:19;;;53780:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;53871:9;:16;53881:5;53871:16;;;;;;;;;;;;;;;;53864:23;;53688:207;;;:::o;71397:103::-;70635:13;:11;:13::i;:::-;71462:30:::1;71489:1;71462:18;:30::i;:::-;71397:103::o:0;74733:474::-;70635:13;:11;:13::i;:::-;74790:15:::1;74808:21;74790:39;;74836:18;74873:3;74867::::0;74857:7:::1;:13;;;;:::i;:::-;:19;;;;:::i;:::-;74836:40;;74883:18;74918:3;74914:1;74904:7;:11;;;;:::i;:::-;:17;;;;:::i;:::-;74883:38;;74930:16;74960:42;74952:56;;75016:10;74952:79;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74928:103;;;75040:16;75070:42;75062:56;;75126:10;75062:79;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75038:103;;;75156:11;:26;;;;;75171:11;75156:26;75148:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;74783:424;;;;;74733:474::o:0;70749:87::-;70795:7;70822:6;;;;;;;;;;;70815:13;;70749:87;:::o;72521:44::-;72563:2;72521:44;:::o;74071:86::-;70635:13;:11;:13::i;:::-;74143:6:::1;74135:5;:14;;;;74071:86:::0;:::o;54416:104::-;54472:13;54505:7;54498:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54416:104;:::o;72698:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;72478:36::-;;;;:::o;73084:743::-;73154:12;;;;;;;;;;;73146:44;;;;;;;;;;;;:::i;:::-;;;;;;;;;72563:2;73209:10;:29;;73201:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;72563:2;73337:10;73307:15;:27;73323:10;73307:27;;;;;;;;;;;;;;;;:40;;;;:::i;:::-;:59;;73299:104;;;;;;;;;;;;:::i;:::-;;;;;;;;;73414:22;73439:11;;73414:36;;72420:3;73486:10;73469:14;:27;;;;:::i;:::-;:41;;73461:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;73577:9;73568:5;;73555:10;:18;;;;:::i;:::-;:31;;73547:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;73627:9;73639:1;73627:13;;73623:109;73647:10;73642:1;:15;73623:109;;73679:41;73689:10;73718:1;73701:14;:18;;;;:::i;:::-;73679:9;:41::i;:::-;73659:3;;;;:::i;:::-;;;73623:109;;;;73773:10;73742:15;:27;73758:10;73742:27;;;;;;;;;;;;;;;;:41;;;;;;;:::i;:::-;;;;;;;;73809:10;73794:11;;:25;;;;;;;:::i;:::-;;;;;;;;73135:692;73084:743;:::o;73963:100::-;70635:13;:11;:13::i;:::-;74047:8:::1;74037:7;:18;;;;;;;;;;;;:::i;:::-;;73963:100:::0;:::o;56002:155::-;56097:52;56116:12;:10;:12::i;:::-;56130:8;56140;56097:18;:52::i;:::-;56002:155;;:::o;74503:222::-;16968:1;15794:42;16922:43;;;:47;16918:225;;;15794:42;16991:40;;;17040:4;17047:10;16991:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16986:146;;17105:10;17086:30;;;;;;;;;;;:::i;:::-;;;;;;;;16986:146;16918:225;74670:47:::1;74693:4;74699:2;74703:7;74712:4;74670:22;:47::i;:::-;74503:222:::0;;;;:::o;72726:37::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;75215:397::-;75288:13;75322:16;75330:7;75322;:16::i;:::-;75314:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;75404:28;75435:10;:8;:10::i;:::-;75404:41;;75494:1;75469:14;75463:28;:32;:141;;;;;;;;;;;;;;;;;75535:14;75551:18;:7;:16;:18::i;:::-;75571:13;75518:67;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;75463:141;75456:148;;;75215:397;;;:::o;56228:164::-;56325:4;56349:18;:25;56368:5;56349:25;;;;;;;;;;;;;;;:35;56375:8;56349:35;;;;;;;;;;;;;;;;;;;;;;;;;56342:42;;56228:164;;;;:::o;71655:201::-;70635:13;:11;:13::i;:::-;71764:1:::1;71744:22;;:8;:22;;::::0;71736:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;71820:28;71839:8;71820:18;:28::i;:::-;71655:201:::0;:::o;72386:37::-;72420:3;72386:37;:::o;33907:326::-;33967:4;34224:1;34202:7;:19;;;:23;34195:30;;33907:326;;;:::o;44938:157::-;45023:4;45062:25;45047:40;;;:11;:40;;;;45040:47;;44938:157;;;:::o;65578:135::-;65660:16;65668:7;65660;:16::i;:::-;65652:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;65578:135;:::o;51698:98::-;51751:7;51778:10;51771:17;;51698:98;:::o;64857:174::-;64959:2;64932:15;:24;64948:7;64932:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;65015:7;65011:2;64977:46;;64986:23;65001:7;64986:14;:23::i;:::-;64977:46;;;;;;;;;;;;64857:174;;:::o;56459:335::-;56654:41;56673:12;:10;:12::i;:::-;56687:7;56654:18;:41::i;:::-;56646:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;56758:28;56768:4;56774:2;56778:7;56758:9;:28::i;:::-;56459:335;;;:::o;70914:132::-;70989:12;:10;:12::i;:::-;70978:23;;:7;:5;:7::i;:::-;:23;;;70970:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70914:132::o;56865:185::-;57003:39;57020:4;57026:2;57030:7;57003:39;;;;;;;;;;;;:16;:39::i;:::-;56865:185;;;:::o;58751:117::-;58817:7;58844;:16;58852:7;58844:16;;;;;;;;;;;;;;;;;;;;;58837:23;;58751:117;;;:::o;72016:191::-;72090:16;72109:6;;;;;;;;;;;72090:25;;72135:8;72126:6;;:17;;;;;;;;;;;;;;;;;;72190:8;72159:40;;72180:8;72159:40;;;;;;;;;;;;72079:128;72016:191;:::o;60082:110::-;60158:26;60168:2;60172:7;60158:26;;;;;;;;;;;;:9;:26::i;:::-;60082:110;;:::o;65174:315::-;65329:8;65320:17;;:5;:17;;;65312:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;65416:8;65378:18;:25;65397:5;65378:25;;;;;;;;;;;;;;;:35;65404:8;65378:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;65462:8;65440:41;;65455:5;65440:41;;;65472:8;65440:41;;;;;;:::i;:::-;;;;;;;;65174:315;;;:::o;57121:322::-;57295:41;57314:12;:10;:12::i;:::-;57328:7;57295:18;:41::i;:::-;57287:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;57397:38;57411:4;57417:2;57421:7;57430:4;57397:13;:38::i;:::-;57121:322;;;;:::o;59181:128::-;59246:4;59299:1;59270:31;;:17;59279:7;59270:8;:17::i;:::-;:31;;;;59263:38;;59181:128;;;:::o;75621:108::-;75681:13;75714:7;75707:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75621:108;:::o;30780:716::-;30836:13;30887:14;30924:1;30904:17;30915:5;30904:10;:17::i;:::-;:21;30887:38;;30940:20;30974:6;30963:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30940:41;;30996:11;31125:6;31121:2;31117:15;31109:6;31105:28;31098:35;;31162:288;31169:4;31162:288;;;31194:5;;;;;;;;31336:8;31331:2;31324:5;31320:14;31315:30;31310:3;31302:44;31392:2;31383:11;;;;;;:::i;:::-;;;;;31426:1;31417:5;:10;31162:288;31413:21;31162:288;31471:6;31464:13;;;;;30780:716;;;:::o;59476:264::-;59569:4;59586:13;59602:23;59617:7;59602:14;:23::i;:::-;59586:39;;59655:5;59644:16;;:7;:16;;;:52;;;;59664:32;59681:5;59688:7;59664:16;:32::i;:::-;59644:52;:87;;;;59724:7;59700:31;;:20;59712:7;59700:11;:20::i;:::-;:31;;;59644:87;59636:96;;;59476:264;;;;:::o;63475:1263::-;63634:4;63607:31;;:23;63622:7;63607:14;:23::i;:::-;:31;;;63599:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;63713:1;63699:16;;:2;:16;;;63691:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;63769:42;63790:4;63796:2;63800:7;63809:1;63769:20;:42::i;:::-;63941:4;63914:31;;:23;63929:7;63914:14;:23::i;:::-;:31;;;63906:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;64059:15;:24;64075:7;64059:24;;;;;;;;;;;;64052:31;;;;;;;;;;;64554:1;64535:9;:15;64545:4;64535:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;64587:1;64570:9;:13;64580:2;64570:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;64629:2;64610:7;:16;64618:7;64610:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;64668:7;64664:2;64649:27;;64658:4;64649:27;;;;;;;;;;;;64689:41;64709:4;64715:2;64719:7;64728:1;64689:19;:41::i;:::-;63475:1263;;;:::o;60419:319::-;60548:18;60554:2;60558:7;60548:5;:18::i;:::-;60599:53;60630:1;60634:2;60638:7;60647:4;60599:22;:53::i;:::-;60577:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;60419:319;;;:::o;58324:313::-;58480:28;58490:4;58496:2;58500:7;58480:9;:28::i;:::-;58527:47;58550:4;58556:2;58560:7;58569:4;58527:22;:47::i;:::-;58519:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;58324:313;;;;:::o;27646:922::-;27699:7;27719:14;27736:1;27719:18;;27786:6;27777:5;:15;27773:102;;27822:6;27813:15;;;;;;:::i;:::-;;;;;27857:2;27847:12;;;;27773:102;27902:6;27893:5;:15;27889:102;;27938:6;27929:15;;;;;;:::i;:::-;;;;;27973:2;27963:12;;;;27889:102;28018:6;28009:5;:15;28005:102;;28054:6;28045:15;;;;;;:::i;:::-;;;;;28089:2;28079:12;;;;28005:102;28134:5;28125;:14;28121:99;;28169:5;28160:14;;;;;;:::i;:::-;;;;;28203:1;28193:11;;;;28121:99;28247:5;28238;:14;28234:99;;28282:5;28273:14;;;;;;:::i;:::-;;;;;28316:1;28306:11;;;;28234:99;28360:5;28351;:14;28347:99;;28395:5;28386:14;;;;;;:::i;:::-;;;;;28429:1;28419:11;;;;28347:99;28473:5;28464;:14;28460:66;;28509:1;28499:11;;;;28460:66;28554:6;28547:13;;;27646:922;;;:::o;67862:159::-;;;;;:::o;68743:158::-;;;;;:::o;61074:942::-;61168:1;61154:16;;:2;:16;;;61146:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;61227:16;61235:7;61227;:16::i;:::-;61226:17;61218:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;61289:48;61318:1;61322:2;61326:7;61335:1;61289:20;:48::i;:::-;61436:16;61444:7;61436;:16::i;:::-;61435:17;61427:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;61851:1;61834:9;:13;61844:2;61834:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;61895:2;61876:7;:16;61884:7;61876:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;61940:7;61936:2;61915:33;;61932:1;61915:33;;;;;;;;;;;;61961:47;61989:1;61993:2;61997:7;62006:1;61961:19;:47::i;:::-;61074:942;;:::o;66277:853::-;66431:4;66452:15;:2;:13;;;:15::i;:::-;66448:675;;;66504:2;66488:36;;;66525:12;:10;:12::i;:::-;66539:4;66545:7;66554:4;66488:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;66484:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66746:1;66729:6;:13;:18;66725:328;;66772:60;;;;;;;;;;:::i;:::-;;;;;;;;66725:328;67003:6;66997:13;66988:6;66984:2;66980:15;66973:38;66484:584;66620:41;;;66610:51;;;:6;:51;;;;66603:58;;;;;66448:675;67107:4;67100:11;;66277:853;;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:307::-;1866:1;1876:113;1890:6;1887:1;1884:13;1876:113;;;1975:1;1970:3;1966:11;1960:18;1956:1;1951:3;1947:11;1940:39;1912:2;1909:1;1905:10;1900:15;;1876:113;;;2007:6;2004:1;2001:13;1998:101;;;2087:1;2078:6;2073:3;2069:16;2062:27;1998:101;1847:258;1798:307;;;:::o;2111:102::-;2152:6;2203:2;2199:7;2194:2;2187:5;2183:14;2179:28;2169:38;;2111:102;;;:::o;2219:364::-;2307:3;2335:39;2368:5;2335:39;:::i;:::-;2390:71;2454:6;2449:3;2390:71;:::i;:::-;2383:78;;2470:52;2515:6;2510:3;2503:4;2496:5;2492:16;2470:52;:::i;:::-;2547:29;2569:6;2547:29;:::i;:::-;2542:3;2538:39;2531:46;;2311:272;2219:364;;;;:::o;2589:313::-;2702:4;2740:2;2729:9;2725:18;2717:26;;2789:9;2783:4;2779:20;2775:1;2764:9;2760:17;2753:47;2817:78;2890:4;2881:6;2817:78;:::i;:::-;2809:86;;2589:313;;;;:::o;2908:77::-;2945:7;2974:5;2963:16;;2908:77;;;:::o;2991:122::-;3064:24;3082:5;3064:24;:::i;:::-;3057:5;3054:35;3044:63;;3103:1;3100;3093:12;3044:63;2991:122;:::o;3119:139::-;3165:5;3203:6;3190:20;3181:29;;3219:33;3246:5;3219:33;:::i;:::-;3119:139;;;;:::o;3264:329::-;3323:6;3372:2;3360:9;3351:7;3347:23;3343:32;3340:119;;;3378:79;;:::i;:::-;3340:119;3498:1;3523:53;3568:7;3559:6;3548:9;3544:22;3523:53;:::i;:::-;3513:63;;3469:117;3264:329;;;;:::o;3599:126::-;3636:7;3676:42;3669:5;3665:54;3654:65;;3599:126;;;:::o;3731:96::-;3768:7;3797:24;3815:5;3797:24;:::i;:::-;3786:35;;3731:96;;;:::o;3833:118::-;3920:24;3938:5;3920:24;:::i;:::-;3915:3;3908:37;3833:118;;:::o;3957:222::-;4050:4;4088:2;4077:9;4073:18;4065:26;;4101:71;4169:1;4158:9;4154:17;4145:6;4101:71;:::i;:::-;3957:222;;;;:::o;4185:122::-;4258:24;4276:5;4258:24;:::i;:::-;4251:5;4248:35;4238:63;;4297:1;4294;4287:12;4238:63;4185:122;:::o;4313:139::-;4359:5;4397:6;4384:20;4375:29;;4413:33;4440:5;4413:33;:::i;:::-;4313:139;;;;:::o;4458:474::-;4526:6;4534;4583:2;4571:9;4562:7;4558:23;4554:32;4551:119;;;4589:79;;:::i;:::-;4551:119;4709:1;4734:53;4779:7;4770:6;4759:9;4755:22;4734:53;:::i;:::-;4724:63;;4680:117;4836:2;4862:53;4907:7;4898:6;4887:9;4883:22;4862:53;:::i;:::-;4852:63;;4807:118;4458:474;;;;;:::o;4938:118::-;5025:24;5043:5;5025:24;:::i;:::-;5020:3;5013:37;4938:118;;:::o;5062:222::-;5155:4;5193:2;5182:9;5178:18;5170:26;;5206:71;5274:1;5263:9;5259:17;5250:6;5206:71;:::i;:::-;5062:222;;;;:::o;5290:619::-;5367:6;5375;5383;5432:2;5420:9;5411:7;5407:23;5403:32;5400:119;;;5438:79;;:::i;:::-;5400:119;5558:1;5583:53;5628:7;5619:6;5608:9;5604:22;5583:53;:::i;:::-;5573:63;;5529:117;5685:2;5711:53;5756:7;5747:6;5736:9;5732:22;5711:53;:::i;:::-;5701:63;;5656:118;5813:2;5839:53;5884:7;5875:6;5864:9;5860:22;5839:53;:::i;:::-;5829:63;;5784:118;5290:619;;;;;:::o;5915:329::-;5974:6;6023:2;6011:9;6002:7;5998:23;5994:32;5991:119;;;6029:79;;:::i;:::-;5991:119;6149:1;6174:53;6219:7;6210:6;6199:9;6195:22;6174:53;:::i;:::-;6164:63;;6120:117;5915:329;;;;:::o;6250:117::-;6359:1;6356;6349:12;6373:117;6482:1;6479;6472:12;6496:180;6544:77;6541:1;6534:88;6641:4;6638:1;6631:15;6665:4;6662:1;6655:15;6682:281;6765:27;6787:4;6765:27;:::i;:::-;6757:6;6753:40;6895:6;6883:10;6880:22;6859:18;6847:10;6844:34;6841:62;6838:88;;;6906:18;;:::i;:::-;6838:88;6946:10;6942:2;6935:22;6725:238;6682:281;;:::o;6969:129::-;7003:6;7030:20;;:::i;:::-;7020:30;;7059:33;7087:4;7079:6;7059:33;:::i;:::-;6969:129;;;:::o;7104:308::-;7166:4;7256:18;7248:6;7245:30;7242:56;;;7278:18;;:::i;:::-;7242:56;7316:29;7338:6;7316:29;:::i;:::-;7308:37;;7400:4;7394;7390:15;7382:23;;7104:308;;;:::o;7418:154::-;7502:6;7497:3;7492;7479:30;7564:1;7555:6;7550:3;7546:16;7539:27;7418:154;;;:::o;7578:412::-;7656:5;7681:66;7697:49;7739:6;7697:49;:::i;:::-;7681:66;:::i;:::-;7672:75;;7770:6;7763:5;7756:21;7808:4;7801:5;7797:16;7846:3;7837:6;7832:3;7828:16;7825:25;7822:112;;;7853:79;;:::i;:::-;7822:112;7943:41;7977:6;7972:3;7967;7943:41;:::i;:::-;7662:328;7578:412;;;;;:::o;8010:340::-;8066:5;8115:3;8108:4;8100:6;8096:17;8092:27;8082:122;;8123:79;;:::i;:::-;8082:122;8240:6;8227:20;8265:79;8340:3;8332:6;8325:4;8317:6;8313:17;8265:79;:::i;:::-;8256:88;;8072:278;8010:340;;;;:::o;8356:509::-;8425:6;8474:2;8462:9;8453:7;8449:23;8445:32;8442:119;;;8480:79;;:::i;:::-;8442:119;8628:1;8617:9;8613:17;8600:31;8658:18;8650:6;8647:30;8644:117;;;8680:79;;:::i;:::-;8644:117;8785:63;8840:7;8831:6;8820:9;8816:22;8785:63;:::i;:::-;8775:73;;8571:287;8356:509;;;;:::o;8871:116::-;8941:21;8956:5;8941:21;:::i;:::-;8934:5;8931:32;8921:60;;8977:1;8974;8967:12;8921:60;8871:116;:::o;8993:133::-;9036:5;9074:6;9061:20;9052:29;;9090:30;9114:5;9090:30;:::i;:::-;8993:133;;;;:::o;9132:468::-;9197:6;9205;9254:2;9242:9;9233:7;9229:23;9225:32;9222:119;;;9260:79;;:::i;:::-;9222:119;9380:1;9405:53;9450:7;9441:6;9430:9;9426:22;9405:53;:::i;:::-;9395:63;;9351:117;9507:2;9533:50;9575:7;9566:6;9555:9;9551:22;9533:50;:::i;:::-;9523:60;;9478:115;9132:468;;;;;:::o;9606:307::-;9667:4;9757:18;9749:6;9746:30;9743:56;;;9779:18;;:::i;:::-;9743:56;9817:29;9839:6;9817:29;:::i;:::-;9809:37;;9901:4;9895;9891:15;9883:23;;9606:307;;;:::o;9919:410::-;9996:5;10021:65;10037:48;10078:6;10037:48;:::i;:::-;10021:65;:::i;:::-;10012:74;;10109:6;10102:5;10095:21;10147:4;10140:5;10136:16;10185:3;10176:6;10171:3;10167:16;10164:25;10161:112;;;10192:79;;:::i;:::-;10161:112;10282:41;10316:6;10311:3;10306;10282:41;:::i;:::-;10002:327;9919:410;;;;;:::o;10348:338::-;10403:5;10452:3;10445:4;10437:6;10433:17;10429:27;10419:122;;10460:79;;:::i;:::-;10419:122;10577:6;10564:20;10602:78;10676:3;10668:6;10661:4;10653:6;10649:17;10602:78;:::i;:::-;10593:87;;10409:277;10348:338;;;;:::o;10692:943::-;10787:6;10795;10803;10811;10860:3;10848:9;10839:7;10835:23;10831:33;10828:120;;;10867:79;;:::i;:::-;10828:120;10987:1;11012:53;11057:7;11048:6;11037:9;11033:22;11012:53;:::i;:::-;11002:63;;10958:117;11114:2;11140:53;11185:7;11176:6;11165:9;11161:22;11140:53;:::i;:::-;11130:63;;11085:118;11242:2;11268:53;11313:7;11304:6;11293:9;11289:22;11268:53;:::i;:::-;11258:63;;11213:118;11398:2;11387:9;11383:18;11370:32;11429:18;11421:6;11418:30;11415:117;;;11451:79;;:::i;:::-;11415:117;11556:62;11610:7;11601:6;11590:9;11586:22;11556:62;:::i;:::-;11546:72;;11341:287;10692:943;;;;;;;:::o;11641:474::-;11709:6;11717;11766:2;11754:9;11745:7;11741:23;11737:32;11734:119;;;11772:79;;:::i;:::-;11734:119;11892:1;11917:53;11962:7;11953:6;11942:9;11938:22;11917:53;:::i;:::-;11907:63;;11863:117;12019:2;12045:53;12090:7;12081:6;12070:9;12066:22;12045:53;:::i;:::-;12035:63;;11990:118;11641:474;;;;;:::o;12121:180::-;12169:77;12166:1;12159:88;12266:4;12263:1;12256:15;12290:4;12287:1;12280:15;12307:320;12351:6;12388:1;12382:4;12378:12;12368:22;;12435:1;12429:4;12425:12;12456:18;12446:81;;12512:4;12504:6;12500:17;12490:27;;12446:81;12574:2;12566:6;12563:14;12543:18;12540:38;12537:84;;12593:18;;:::i;:::-;12537:84;12358:269;12307:320;;;:::o;12633:220::-;12773:34;12769:1;12761:6;12757:14;12750:58;12842:3;12837:2;12829:6;12825:15;12818:28;12633:220;:::o;12859:366::-;13001:3;13022:67;13086:2;13081:3;13022:67;:::i;:::-;13015:74;;13098:93;13187:3;13098:93;:::i;:::-;13216:2;13211:3;13207:12;13200:19;;12859:366;;;:::o;13231:419::-;13397:4;13435:2;13424:9;13420:18;13412:26;;13484:9;13478:4;13474:20;13470:1;13459:9;13455:17;13448:47;13512:131;13638:4;13512:131;:::i;:::-;13504:139;;13231:419;;;:::o;13656:248::-;13796:34;13792:1;13784:6;13780:14;13773:58;13865:31;13860:2;13852:6;13848:15;13841:56;13656:248;:::o;13910:366::-;14052:3;14073:67;14137:2;14132:3;14073:67;:::i;:::-;14066:74;;14149:93;14238:3;14149:93;:::i;:::-;14267:2;14262:3;14258:12;14251:19;;13910:366;;;:::o;14282:419::-;14448:4;14486:2;14475:9;14471:18;14463:26;;14535:9;14529:4;14525:20;14521:1;14510:9;14506:17;14499:47;14563:131;14689:4;14563:131;:::i;:::-;14555:139;;14282:419;;;:::o;14707:332::-;14828:4;14866:2;14855:9;14851:18;14843:26;;14879:71;14947:1;14936:9;14932:17;14923:6;14879:71;:::i;:::-;14960:72;15028:2;15017:9;15013:18;15004:6;14960:72;:::i;:::-;14707:332;;;;;:::o;15045:137::-;15099:5;15130:6;15124:13;15115:22;;15146:30;15170:5;15146:30;:::i;:::-;15045:137;;;;:::o;15188:345::-;15255:6;15304:2;15292:9;15283:7;15279:23;15275:32;15272:119;;;15310:79;;:::i;:::-;15272:119;15430:1;15455:61;15508:7;15499:6;15488:9;15484:22;15455:61;:::i;:::-;15445:71;;15401:125;15188:345;;;;:::o;15539:174::-;15679:26;15675:1;15667:6;15663:14;15656:50;15539:174;:::o;15719:366::-;15861:3;15882:67;15946:2;15941:3;15882:67;:::i;:::-;15875:74;;15958:93;16047:3;15958:93;:::i;:::-;16076:2;16071:3;16067:12;16060:19;;15719:366;;;:::o;16091:419::-;16257:4;16295:2;16284:9;16280:18;16272:26;;16344:9;16338:4;16334:20;16330:1;16319:9;16315:17;16308:47;16372:131;16498:4;16372:131;:::i;:::-;16364:139;;16091:419;;;:::o;16516:228::-;16656:34;16652:1;16644:6;16640:14;16633:58;16725:11;16720:2;16712:6;16708:15;16701:36;16516:228;:::o;16750:366::-;16892:3;16913:67;16977:2;16972:3;16913:67;:::i;:::-;16906:74;;16989:93;17078:3;16989:93;:::i;:::-;17107:2;17102:3;17098:12;17091:19;;16750:366;;;:::o;17122:419::-;17288:4;17326:2;17315:9;17311:18;17303:26;;17375:9;17369:4;17365:20;17361:1;17350:9;17346:17;17339:47;17403:131;17529:4;17403:131;:::i;:::-;17395:139;;17122:419;;;:::o;17547:180::-;17595:77;17592:1;17585:88;17692:4;17689:1;17682:15;17716:4;17713:1;17706:15;17733:348;17773:7;17796:20;17814:1;17796:20;:::i;:::-;17791:25;;17830:20;17848:1;17830:20;:::i;:::-;17825:25;;18018:1;17950:66;17946:74;17943:1;17940:81;17935:1;17928:9;17921:17;17917:105;17914:131;;;18025:18;;:::i;:::-;17914:131;18073:1;18070;18066:9;18055:20;;17733:348;;;;:::o;18087:180::-;18135:77;18132:1;18125:88;18232:4;18229:1;18222:15;18256:4;18253:1;18246:15;18273:185;18313:1;18330:20;18348:1;18330:20;:::i;:::-;18325:25;;18364:20;18382:1;18364:20;:::i;:::-;18359:25;;18403:1;18393:35;;18408:18;;:::i;:::-;18393:35;18450:1;18447;18443:9;18438:14;;18273:185;;;;:::o;18464:147::-;18565:11;18602:3;18587:18;;18464:147;;;;:::o;18617:114::-;;:::o;18737:398::-;18896:3;18917:83;18998:1;18993:3;18917:83;:::i;:::-;18910:90;;19009:93;19098:3;19009:93;:::i;:::-;19127:1;19122:3;19118:11;19111:18;;18737:398;;;:::o;19141:379::-;19325:3;19347:147;19490:3;19347:147;:::i;:::-;19340:154;;19511:3;19504:10;;19141:379;;;:::o;19526:166::-;19666:18;19662:1;19654:6;19650:14;19643:42;19526:166;:::o;19698:366::-;19840:3;19861:67;19925:2;19920:3;19861:67;:::i;:::-;19854:74;;19937:93;20026:3;19937:93;:::i;:::-;20055:2;20050:3;20046:12;20039:19;;19698:366;;;:::o;20070:419::-;20236:4;20274:2;20263:9;20259:18;20251:26;;20323:9;20317:4;20313:20;20309:1;20298:9;20294:17;20287:47;20351:131;20477:4;20351:131;:::i;:::-;20343:139;;20070:419;;;:::o;20495:169::-;20635:21;20631:1;20623:6;20619:14;20612:45;20495:169;:::o;20670:366::-;20812:3;20833:67;20897:2;20892:3;20833:67;:::i;:::-;20826:74;;20909:93;20998:3;20909:93;:::i;:::-;21027:2;21022:3;21018:12;21011:19;;20670:366;;;:::o;21042:419::-;21208:4;21246:2;21235:9;21231:18;21223:26;;21295:9;21289:4;21285:20;21281:1;21270:9;21266:17;21259:47;21323:131;21449:4;21323:131;:::i;:::-;21315:139;;21042:419;;;:::o;21467:232::-;21607:34;21603:1;21595:6;21591:14;21584:58;21676:15;21671:2;21663:6;21659:15;21652:40;21467:232;:::o;21705:366::-;21847:3;21868:67;21932:2;21927:3;21868:67;:::i;:::-;21861:74;;21944:93;22033:3;21944:93;:::i;:::-;22062:2;22057:3;22053:12;22046:19;;21705:366;;;:::o;22077:419::-;22243:4;22281:2;22270:9;22266:18;22258:26;;22330:9;22324:4;22320:20;22316:1;22305:9;22301:17;22294:47;22358:131;22484:4;22358:131;:::i;:::-;22350:139;;22077:419;;;:::o;22502:305::-;22542:3;22561:20;22579:1;22561:20;:::i;:::-;22556:25;;22595:20;22613:1;22595:20;:::i;:::-;22590:25;;22749:1;22681:66;22677:74;22674:1;22671:81;22668:107;;;22755:18;;:::i;:::-;22668:107;22799:1;22796;22792:9;22785:16;;22502:305;;;;:::o;22813:182::-;22953:34;22949:1;22941:6;22937:14;22930:58;22813:182;:::o;23001:366::-;23143:3;23164:67;23228:2;23223:3;23164:67;:::i;:::-;23157:74;;23240:93;23329:3;23240:93;:::i;:::-;23358:2;23353:3;23349:12;23342:19;;23001:366;;;:::o;23373:419::-;23539:4;23577:2;23566:9;23562:18;23554:26;;23626:9;23620:4;23616:20;23612:1;23601:9;23597:17;23590:47;23654:131;23780:4;23654:131;:::i;:::-;23646:139;;23373:419;;;:::o;23798:171::-;23938:23;23934:1;23926:6;23922:14;23915:47;23798:171;:::o;23975:366::-;24117:3;24138:67;24202:2;24197:3;24138:67;:::i;:::-;24131:74;;24214:93;24303:3;24214:93;:::i;:::-;24332:2;24327:3;24323:12;24316:19;;23975:366;;;:::o;24347:419::-;24513:4;24551:2;24540:9;24536:18;24528:26;;24600:9;24594:4;24590:20;24586:1;24575:9;24571:17;24564:47;24628:131;24754:4;24628:131;:::i;:::-;24620:139;;24347:419;;;:::o;24772:169::-;24912:21;24908:1;24900:6;24896:14;24889:45;24772:169;:::o;24947:366::-;25089:3;25110:67;25174:2;25169:3;25110:67;:::i;:::-;25103:74;;25186:93;25275:3;25186:93;:::i;:::-;25304:2;25299:3;25295:12;25288:19;;24947:366;;;:::o;25319:419::-;25485:4;25523:2;25512:9;25508:18;25500:26;;25572:9;25566:4;25562:20;25558:1;25547:9;25543:17;25536:47;25600:131;25726:4;25600:131;:::i;:::-;25592:139;;25319:419;;;:::o;25744:233::-;25783:3;25806:24;25824:5;25806:24;:::i;:::-;25797:33;;25852:66;25845:5;25842:77;25839:103;;25922:18;;:::i;:::-;25839:103;25969:1;25962:5;25958:13;25951:20;;25744:233;;;:::o;25983:234::-;26123:34;26119:1;26111:6;26107:14;26100:58;26192:17;26187:2;26179:6;26175:15;26168:42;25983:234;:::o;26223:366::-;26365:3;26386:67;26450:2;26445:3;26386:67;:::i;:::-;26379:74;;26462:93;26551:3;26462:93;:::i;:::-;26580:2;26575:3;26571:12;26564:19;;26223:366;;;:::o;26595:419::-;26761:4;26799:2;26788:9;26784:18;26776:26;;26848:9;26842:4;26838:20;26834:1;26823:9;26819:17;26812:47;26876:131;27002:4;26876:131;:::i;:::-;26868:139;;26595:419;;;:::o;27020:148::-;27122:11;27159:3;27144:18;;27020:148;;;;:::o;27174:377::-;27280:3;27308:39;27341:5;27308:39;:::i;:::-;27363:89;27445:6;27440:3;27363:89;:::i;:::-;27356:96;;27461:52;27506:6;27501:3;27494:4;27487:5;27483:16;27461:52;:::i;:::-;27538:6;27533:3;27529:16;27522:23;;27284:267;27174:377;;;;:::o;27557:141::-;27606:4;27629:3;27621:11;;27652:3;27649:1;27642:14;27686:4;27683:1;27673:18;27665:26;;27557:141;;;:::o;27728:845::-;27831:3;27868:5;27862:12;27897:36;27923:9;27897:36;:::i;:::-;27949:89;28031:6;28026:3;27949:89;:::i;:::-;27942:96;;28069:1;28058:9;28054:17;28085:1;28080:137;;;;28231:1;28226:341;;;;28047:520;;28080:137;28164:4;28160:9;28149;28145:25;28140:3;28133:38;28200:6;28195:3;28191:16;28184:23;;28080:137;;28226:341;28293:38;28325:5;28293:38;:::i;:::-;28353:1;28367:154;28381:6;28378:1;28375:13;28367:154;;;28455:7;28449:14;28445:1;28440:3;28436:11;28429:35;28505:1;28496:7;28492:15;28481:26;;28403:4;28400:1;28396:12;28391:17;;28367:154;;;28550:6;28545:3;28541:16;28534:23;;28233:334;;28047:520;;27835:738;;27728:845;;;;:::o;28579:589::-;28804:3;28826:95;28917:3;28908:6;28826:95;:::i;:::-;28819:102;;28938:95;29029:3;29020:6;28938:95;:::i;:::-;28931:102;;29050:92;29138:3;29129:6;29050:92;:::i;:::-;29043:99;;29159:3;29152:10;;28579:589;;;;;;:::o;29174:225::-;29314:34;29310:1;29302:6;29298:14;29291:58;29383:8;29378:2;29370:6;29366:15;29359:33;29174:225;:::o;29405:366::-;29547:3;29568:67;29632:2;29627:3;29568:67;:::i;:::-;29561:74;;29644:93;29733:3;29644:93;:::i;:::-;29762:2;29757:3;29753:12;29746:19;;29405:366;;;:::o;29777:419::-;29943:4;29981:2;29970:9;29966:18;29958:26;;30030:9;30024:4;30020:20;30016:1;30005:9;30001:17;29994:47;30058:131;30184:4;30058:131;:::i;:::-;30050:139;;29777:419;;;:::o;30202:232::-;30342:34;30338:1;30330:6;30326:14;30319:58;30411:15;30406:2;30398:6;30394:15;30387:40;30202:232;:::o;30440:366::-;30582:3;30603:67;30667:2;30662:3;30603:67;:::i;:::-;30596:74;;30679:93;30768:3;30679:93;:::i;:::-;30797:2;30792:3;30788:12;30781:19;;30440:366;;;:::o;30812:419::-;30978:4;31016:2;31005:9;31001:18;30993:26;;31065:9;31059:4;31055:20;31051:1;31040:9;31036:17;31029:47;31093:131;31219:4;31093:131;:::i;:::-;31085:139;;30812:419;;;:::o;31237:182::-;31377:34;31373:1;31365:6;31361:14;31354:58;31237:182;:::o;31425:366::-;31567:3;31588:67;31652:2;31647:3;31588:67;:::i;:::-;31581:74;;31664:93;31753:3;31664:93;:::i;:::-;31782:2;31777:3;31773:12;31766:19;;31425:366;;;:::o;31797:419::-;31963:4;32001:2;31990:9;31986:18;31978:26;;32050:9;32044:4;32040:20;32036:1;32025:9;32021:17;32014:47;32078:131;32204:4;32078:131;:::i;:::-;32070:139;;31797:419;;;:::o;32222:175::-;32362:27;32358:1;32350:6;32346:14;32339:51;32222:175;:::o;32403:366::-;32545:3;32566:67;32630:2;32625:3;32566:67;:::i;:::-;32559:74;;32642:93;32731:3;32642:93;:::i;:::-;32760:2;32755:3;32751:12;32744:19;;32403:366;;;:::o;32775:419::-;32941:4;32979:2;32968:9;32964:18;32956:26;;33028:9;33022:4;33018:20;33014:1;33003:9;32999:17;32992:47;33056:131;33182:4;33056:131;:::i;:::-;33048:139;;32775:419;;;:::o;33200:224::-;33340:34;33336:1;33328:6;33324:14;33317:58;33409:7;33404:2;33396:6;33392:15;33385:32;33200:224;:::o;33430:366::-;33572:3;33593:67;33657:2;33652:3;33593:67;:::i;:::-;33586:74;;33669:93;33758:3;33669:93;:::i;:::-;33787:2;33782:3;33778:12;33771:19;;33430:366;;;:::o;33802:419::-;33968:4;34006:2;33995:9;33991:18;33983:26;;34055:9;34049:4;34045:20;34041:1;34030:9;34026:17;34019:47;34083:131;34209:4;34083:131;:::i;:::-;34075:139;;33802:419;;;:::o;34227:223::-;34367:34;34363:1;34355:6;34351:14;34344:58;34436:6;34431:2;34423:6;34419:15;34412:31;34227:223;:::o;34456:366::-;34598:3;34619:67;34683:2;34678:3;34619:67;:::i;:::-;34612:74;;34695:93;34784:3;34695:93;:::i;:::-;34813:2;34808:3;34804:12;34797:19;;34456:366;;;:::o;34828:419::-;34994:4;35032:2;35021:9;35017:18;35009:26;;35081:9;35075:4;35071:20;35067:1;35056:9;35052:17;35045:47;35109:131;35235:4;35109:131;:::i;:::-;35101:139;;34828:419;;;:::o;35253:237::-;35393:34;35389:1;35381:6;35377:14;35370:58;35462:20;35457:2;35449:6;35445:15;35438:45;35253:237;:::o;35496:366::-;35638:3;35659:67;35723:2;35718:3;35659:67;:::i;:::-;35652:74;;35735:93;35824:3;35735:93;:::i;:::-;35853:2;35848:3;35844:12;35837:19;;35496:366;;;:::o;35868:419::-;36034:4;36072:2;36061:9;36057:18;36049:26;;36121:9;36115:4;36111:20;36107:1;36096:9;36092:17;36085:47;36149:131;36275:4;36149:131;:::i;:::-;36141:139;;35868:419;;;:::o;36293:182::-;36433:34;36429:1;36421:6;36417:14;36410:58;36293:182;:::o;36481:366::-;36623:3;36644:67;36708:2;36703:3;36644:67;:::i;:::-;36637:74;;36720:93;36809:3;36720:93;:::i;:::-;36838:2;36833:3;36829:12;36822:19;;36481:366;;;:::o;36853:419::-;37019:4;37057:2;37046:9;37042:18;37034:26;;37106:9;37100:4;37096:20;37092:1;37081:9;37077:17;37070:47;37134:131;37260:4;37134:131;:::i;:::-;37126:139;;36853:419;;;:::o;37278:178::-;37418:30;37414:1;37406:6;37402:14;37395:54;37278:178;:::o;37462:366::-;37604:3;37625:67;37689:2;37684:3;37625:67;:::i;:::-;37618:74;;37701:93;37790:3;37701:93;:::i;:::-;37819:2;37814:3;37810:12;37803:19;;37462:366;;;:::o;37834:419::-;38000:4;38038:2;38027:9;38023:18;38015:26;;38087:9;38081:4;38077:20;38073:1;38062:9;38058:17;38051:47;38115:131;38241:4;38115:131;:::i;:::-;38107:139;;37834:419;;;:::o;38259:98::-;38310:6;38344:5;38338:12;38328:22;;38259:98;;;:::o;38363:168::-;38446:11;38480:6;38475:3;38468:19;38520:4;38515:3;38511:14;38496:29;;38363:168;;;;:::o;38537:360::-;38623:3;38651:38;38683:5;38651:38;:::i;:::-;38705:70;38768:6;38763:3;38705:70;:::i;:::-;38698:77;;38784:52;38829:6;38824:3;38817:4;38810:5;38806:16;38784:52;:::i;:::-;38861:29;38883:6;38861:29;:::i;:::-;38856:3;38852:39;38845:46;;38627:270;38537:360;;;;:::o;38903:640::-;39098:4;39136:3;39125:9;39121:19;39113:27;;39150:71;39218:1;39207:9;39203:17;39194:6;39150:71;:::i;:::-;39231:72;39299:2;39288:9;39284:18;39275:6;39231:72;:::i;:::-;39313;39381:2;39370:9;39366:18;39357:6;39313:72;:::i;:::-;39432:9;39426:4;39422:20;39417:2;39406:9;39402:18;39395:48;39460:76;39531:4;39522:6;39460:76;:::i;:::-;39452:84;;38903:640;;;;;;;:::o;39549:141::-;39605:5;39636:6;39630:13;39621:22;;39652:32;39678:5;39652:32;:::i;:::-;39549:141;;;;:::o;39696:349::-;39765:6;39814:2;39802:9;39793:7;39789:23;39785:32;39782:119;;;39820:79;;:::i;:::-;39782:119;39940:1;39965:63;40020:7;40011:6;40000:9;39996:22;39965:63;:::i;:::-;39955:73;;39911:127;39696:349;;;;:::o

Swarm Source

ipfs://c2d966f15378e3d5cf860f59670c5f32249d37b952474a13571735716a7568c6

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