Elysium (ELYSIUM) Token Tracker

Elysium (ELYSIUM)

Overview

TokenID

Total Transfers

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract

0xd3876647cd0fe954c4e7544cbd033eb01ffba99d

TokenID: 14

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Elysium

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 2022-11-17
*/

// 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/Counters.sol


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

pragma solidity ^0.8.0;

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

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

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

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

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

// File: @openzeppelin/contracts/utils/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/Context.sol


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

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts (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: @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/token/ERC721/ERC721.sol


// OpenZeppelin Contracts (last updated v4.8.0) (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 {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

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

// File: contracts/Elysium.sol



pragma solidity >=0.7.0 <0.9.0;



contract Elysium is ERC721, Ownable, DefaultOperatorFilterer {
  using Strings for uint256;
  using Counters for Counters.Counter;

  Counters.Counter private supply;

  string public uriPrefix = "";
  string public uriSuffix = ".json";
  string public hiddenMetadataUri;
  

  uint256 public maxSupply = 3655;
  uint256 public maxMintAmountPerTx = 1;

  bool public paused = false;
  bool public revealed = false;

  constructor() ERC721("Elysium", "ELYSIUM") {
    setHiddenMetadataUri("ipfs://Qmddh6swhzfdo8a1TcaowNQDUvbY58A9i4qQJasT6HD4eH/hidden.json");
  }

  modifier mintCompliance(uint256 _mintAmount) {
    require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount!");
    require(supply.current() + _mintAmount <= maxSupply, "Max supply exceeded!");
    _;
  }

  function totalSupply() public view returns (uint256) {
    return supply.current();
  }

  function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) {
    require(!paused, "The contract is paused!");

    _mintLoop(msg.sender, _mintAmount);
  }
  
  function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
    _mintLoop(_receiver, _mintAmount);
  }

  function walletOfOwner(address _owner)
    public
    view
    returns (uint256[] memory)
  {
    uint256 ownerTokenCount = balanceOf(_owner);
    uint256[] memory ownedTokenIds = new uint256[](ownerTokenCount);
    uint256 currentTokenId = 1;
    uint256 ownedTokenIndex = 0;

    while (ownedTokenIndex < ownerTokenCount && currentTokenId <= maxSupply) {
      address currentTokenOwner = ownerOf(currentTokenId);

      if (currentTokenOwner == _owner) {
        ownedTokenIds[ownedTokenIndex] = currentTokenId;

        ownedTokenIndex++;
      }

      currentTokenId++;
    }

    return ownedTokenIds;
  }

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

    if (revealed == false) {
      return hiddenMetadataUri;
    }

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

  function setRevealed(bool _state) public onlyOwner {
    revealed = _state;
  }


  function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
    maxMintAmountPerTx = _maxMintAmountPerTx;
  }

  function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
    hiddenMetadataUri = _hiddenMetadataUri;
  }

  function setUriPrefix(string memory _uriPrefix) public onlyOwner {
    uriPrefix = _uriPrefix;
  }

  function setUriSuffix(string memory _uriSuffix) public onlyOwner {
    uriSuffix = _uriSuffix;
  }

  function setPaused(bool _state) public onlyOwner {
    paused = _state;
  }

  function withdraw() public onlyOwner {


    // This will transfer the remaining contract balance to the owner.
    // Do not remove this otherwise you will not be able to withdraw the funds.
    // =============================================================================
    (bool os, ) = payable(owner()).call{value: address(this).balance}("");
    require(os);
    // =============================================================================
  }

  function _mintLoop(address _receiver, uint256 _mintAmount) internal {
    for (uint256 i = 0; i < _mintAmount; i++) {
      supply.increment();
      _safeMint(_receiver, supply.current());
    }
  }

  function _baseURI() internal view virtual override returns (string memory) {
    return uriPrefix;
  }
      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);
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

API

[{"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":[{"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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hiddenMetadataUri","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"maxMintAmountPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"mintForAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"_hiddenMetadataUri","type":"string"}],"name":"setHiddenMetadataUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxMintAmountPerTx","type":"uint256"}],"name":"setMaxMintAmountPerTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uriPrefix","type":"string"}],"name":"setUriPrefix","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uriSuffix","type":"string"}],"name":"setUriSuffix","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":"uriPrefix","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uriSuffix","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

608060405260405180602001604052806000815250600890805190602001906200002b9291906200057c565b506040518060400160405280600581526020017f2e6a736f6e00000000000000000000000000000000000000000000000000000081525060099080519060200190620000799291906200057c565b50610e47600b556001600c556000600d60006101000a81548160ff0219169083151502179055506000600d60016101000a81548160ff021916908315150217905550348015620000c857600080fd5b50733cc6cdda760b79bafa08df41ecfa224f810dceb660016040518060400160405280600781526020017f456c797369756d000000000000000000000000000000000000000000000000008152506040518060400160405280600781526020017f454c595349554d000000000000000000000000000000000000000000000000008152508160009080519060200190620001649291906200057c565b5080600190805190602001906200017d9291906200057c565b505050620001a062000194620003c760201b60201c565b620003cf60201b60201c565b60006daaeb6d7670e522a718067333cd4e73ffffffffffffffffffffffffffffffffffffffff163b1115620003955780156200025b576daaeb6d7670e522a718067333cd4e73ffffffffffffffffffffffffffffffffffffffff16637d3e3dbe30846040518363ffffffff1660e01b81526004016200022192919062000671565b600060405180830381600087803b1580156200023c57600080fd5b505af115801562000251573d6000803e3d6000fd5b5050505062000394565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161462000315576daaeb6d7670e522a718067333cd4e73ffffffffffffffffffffffffffffffffffffffff1663a0af290330846040518363ffffffff1660e01b8152600401620002db92919062000671565b600060405180830381600087803b158015620002f657600080fd5b505af11580156200030b573d6000803e3d6000fd5b5050505062000393565b6daaeb6d7670e522a718067333cd4e73ffffffffffffffffffffffffffffffffffffffff16634420e486306040518263ffffffff1660e01b81526004016200035e91906200069e565b600060405180830381600087803b1580156200037957600080fd5b505af11580156200038e573d6000803e3d6000fd5b505050505b5b5b5050620003c1604051806080016040528060418152602001620047c4604191396200049560201b60201c565b620007a2565b600033905090565b6000600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600660006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b620004a5620004c160201b60201c565b80600a9080519060200190620004bd9291906200057c565b5050565b620004d1620003c760201b60201c565b73ffffffffffffffffffffffffffffffffffffffff16620004f76200055260201b60201c565b73ffffffffffffffffffffffffffffffffffffffff161462000550576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040162000547906200071c565b60405180910390fd5b565b6000600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b8280546200058a906200076d565b90600052602060002090601f016020900481019282620005ae5760008555620005fa565b82601f10620005c957805160ff1916838001178555620005fa565b82800160010185558215620005fa579182015b82811115620005f9578251825591602001919060010190620005dc565b5b5090506200060991906200060d565b5090565b5b80821115620006285760008160009055506001016200060e565b5090565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600062000659826200062c565b9050919050565b6200066b816200064c565b82525050565b600060408201905062000688600083018562000660565b62000697602083018462000660565b9392505050565b6000602082019050620006b5600083018462000660565b92915050565b600082825260208201905092915050565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b600062000704602083620006bb565b91506200071182620006cc565b602082019050919050565b600060208201905081810360008301526200073781620006f5565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b600060028204905060018216806200078657607f821691505b6020821081036200079c576200079b6200073e565b5b50919050565b61401280620007b26000396000f3fe6080604052600436106101f95760003560e01c806370a082311161010d578063a45ba8e7116100a0578063d5abeb011161006f578063d5abeb01146106fe578063e0a8085314610729578063e985e9c514610752578063efbd73f41461078f578063f2fde38b146107b8576101f9565b8063a45ba8e714610644578063b071401b1461066f578063b88d4fde14610698578063c87b56dd146106c1576101f9565b806394354fd0116100dc57806394354fd0146105a957806395d89b41146105d4578063a0712d68146105ff578063a22cb4651461061b576101f9565b806370a0823114610501578063715018a61461053e5780637ec4a659146105555780638da5cb5b1461057e576101f9565b80633ccfd60b11610190578063518302271161015f57806351830227146104185780635503a0e8146104435780635c975abb1461046e57806362b99ad4146104995780636352211e146104c4576101f9565b80633ccfd60b1461037257806342842e0e14610389578063438b6300146103b25780634fdd43cb146103ef576101f9565b806316ba10e0116101cc57806316ba10e0146102cc57806316c38b3c146102f557806318160ddd1461031e57806323b872dd14610349576101f9565b806301ffc9a7146101fe57806306fdde031461023b578063081812fc14610266578063095ea7b3146102a3575b600080fd5b34801561020a57600080fd5b5061022560048036038101906102209190612b78565b6107e1565b6040516102329190612bc0565b60405180910390f35b34801561024757600080fd5b506102506108c3565b60405161025d9190612c74565b60405180910390f35b34801561027257600080fd5b5061028d60048036038101906102889190612ccc565b610955565b60405161029a9190612d3a565b60405180910390f35b3480156102af57600080fd5b506102ca60048036038101906102c59190612d81565b61099b565b005b3480156102d857600080fd5b506102f360048036038101906102ee9190612ef6565b610ab2565b005b34801561030157600080fd5b5061031c60048036038101906103179190612f6b565b610ad4565b005b34801561032a57600080fd5b50610333610af9565b6040516103409190612fa7565b60405180910390f35b34801561035557600080fd5b50610370600480360381019061036b9190612fc2565b610b0a565b005b34801561037e57600080fd5b50610387610c16565b005b34801561039557600080fd5b506103b060048036038101906103ab9190612fc2565b610c9e565b005b3480156103be57600080fd5b506103d960048036038101906103d49190613015565b610daa565b6040516103e69190613100565b60405180910390f35b3480156103fb57600080fd5b5061041660048036038101906104119190612ef6565b610eb4565b005b34801561042457600080fd5b5061042d610ed6565b60405161043a9190612bc0565b60405180910390f35b34801561044f57600080fd5b50610458610ee9565b6040516104659190612c74565b60405180910390f35b34801561047a57600080fd5b50610483610f77565b6040516104909190612bc0565b60405180910390f35b3480156104a557600080fd5b506104ae610f8a565b6040516104bb9190612c74565b60405180910390f35b3480156104d057600080fd5b506104eb60048036038101906104e69190612ccc565b611018565b6040516104f89190612d3a565b60405180910390f35b34801561050d57600080fd5b5061052860048036038101906105239190613015565b61109e565b6040516105359190612fa7565b60405180910390f35b34801561054a57600080fd5b50610553611155565b005b34801561056157600080fd5b5061057c60048036038101906105779190612ef6565b611169565b005b34801561058a57600080fd5b5061059361118b565b6040516105a09190612d3a565b60405180910390f35b3480156105b557600080fd5b506105be6111b5565b6040516105cb9190612fa7565b60405180910390f35b3480156105e057600080fd5b506105e96111bb565b6040516105f69190612c74565b60405180910390f35b61061960048036038101906106149190612ccc565b61124d565b005b34801561062757600080fd5b50610642600480360381019061063d9190613122565b611356565b005b34801561065057600080fd5b5061065961136c565b6040516106669190612c74565b60405180910390f35b34801561067b57600080fd5b5061069660048036038101906106919190612ccc565b6113fa565b005b3480156106a457600080fd5b506106bf60048036038101906106ba9190613203565b61140c565b005b3480156106cd57600080fd5b506106e860048036038101906106e39190612ccc565b61151a565b6040516106f59190612c74565b60405180910390f35b34801561070a57600080fd5b50610713611672565b6040516107209190612fa7565b60405180910390f35b34801561073557600080fd5b50610750600480360381019061074b9190612f6b565b611678565b005b34801561075e57600080fd5b5061077960048036038101906107749190613286565b61169d565b6040516107869190612bc0565b60405180910390f35b34801561079b57600080fd5b506107b660048036038101906107b191906132c6565b611731565b005b3480156107c457600080fd5b506107df60048036038101906107da9190613015565b6117f3565b005b60007f80ac58cd000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191614806108ac57507f5b5e139f000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916145b806108bc57506108bb82611876565b5b9050919050565b6060600080546108d290613335565b80601f01602080910402602001604051908101604052809291908181526020018280546108fe90613335565b801561094b5780601f106109205761010080835404028352916020019161094b565b820191906000526020600020905b81548152906001019060200180831161092e57829003601f168201915b5050505050905090565b6000610960826118e0565b6004600083815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b60006109a682611018565b90508073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1603610a16576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a0d906133d8565b60405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff16610a3561192b565b73ffffffffffffffffffffffffffffffffffffffff161480610a645750610a6381610a5e61192b565b61169d565b5b610aa3576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a9a9061346a565b60405180910390fd5b610aad8383611933565b505050565b610aba6119ec565b8060099080519060200190610ad0929190612a69565b5050565b610adc6119ec565b80600d60006101000a81548160ff02191690831515021790555050565b6000610b056007611a6a565b905090565b60006daaeb6d7670e522a718067333cd4e73ffffffffffffffffffffffffffffffffffffffff163b1115610c06576daaeb6d7670e522a718067333cd4e73ffffffffffffffffffffffffffffffffffffffff1663c617113430336040518363ffffffff1660e01b8152600401610b8192919061348a565b6020604051808303816000875af1158015610ba0573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bc491906134c8565b610c0557336040517fede71dcc000000000000000000000000000000000000000000000000000000008152600401610bfc9190612d3a565b60405180910390fd5b5b610c11838383611a78565b505050565b610c1e6119ec565b6000610c2861118b565b73ffffffffffffffffffffffffffffffffffffffff1647604051610c4b90613526565b60006040518083038185875af1925050503d8060008114610c88576040519150601f19603f3d011682016040523d82523d6000602084013e610c8d565b606091505b5050905080610c9b57600080fd5b50565b60006daaeb6d7670e522a718067333cd4e73ffffffffffffffffffffffffffffffffffffffff163b1115610d9a576daaeb6d7670e522a718067333cd4e73ffffffffffffffffffffffffffffffffffffffff1663c617113430336040518363ffffffff1660e01b8152600401610d1592919061348a565b6020604051808303816000875af1158015610d34573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d5891906134c8565b610d9957336040517fede71dcc000000000000000000000000000000000000000000000000000000008152600401610d909190612d3a565b60405180910390fd5b5b610da5838383611ad8565b505050565b60606000610db78361109e565b905060008167ffffffffffffffff811115610dd557610dd4612dcb565b5b604051908082528060200260200182016040528015610e035781602001602082028036833780820191505090505b50905060006001905060005b8381108015610e205750600b548211155b15610ea8576000610e3083611018565b90508673ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603610e945782848381518110610e7957610e7861353b565b5b6020026020010181815250508180610e9090613599565b9250505b8280610e9f90613599565b93505050610e0f565b82945050505050919050565b610ebc6119ec565b80600a9080519060200190610ed2929190612a69565b5050565b600d60019054906101000a900460ff1681565b60098054610ef690613335565b80601f0160208091040260200160405190810160405280929190818152602001828054610f2290613335565b8015610f6f5780601f10610f4457610100808354040283529160200191610f6f565b820191906000526020600020905b815481529060010190602001808311610f5257829003601f168201915b505050505081565b600d60009054906101000a900460ff1681565b60088054610f9790613335565b80601f0160208091040260200160405190810160405280929190818152602001828054610fc390613335565b80156110105780601f10610fe557610100808354040283529160200191611010565b820191906000526020600020905b815481529060010190602001808311610ff357829003601f168201915b505050505081565b60008061102483611af8565b9050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1603611095576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161108c9061362d565b60405180910390fd5b80915050919050565b60008073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff160361110e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611105906136bf565b60405180910390fd5b600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b61115d6119ec565b6111676000611b35565b565b6111716119ec565b8060089080519060200190611187929190612a69565b5050565b6000600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600c5481565b6060600180546111ca90613335565b80601f01602080910402602001604051908101604052809291908181526020018280546111f690613335565b80156112435780601f1061121857610100808354040283529160200191611243565b820191906000526020600020905b81548152906001019060200180831161122657829003601f168201915b5050505050905090565b806000811180156112605750600c548111155b61129f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112969061372b565b60405180910390fd5b600b54816112ad6007611a6a565b6112b7919061374b565b11156112f8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112ef906137ed565b60405180910390fd5b600d60009054906101000a900460ff1615611348576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161133f90613859565b60405180910390fd5b6113523383611bfb565b5050565b61136861136161192b565b8383611c3b565b5050565b600a805461137990613335565b80601f01602080910402602001604051908101604052809291908181526020018280546113a590613335565b80156113f25780601f106113c7576101008083540402835291602001916113f2565b820191906000526020600020905b8154815290600101906020018083116113d557829003601f168201915b505050505081565b6114026119ec565b80600c8190555050565b60006daaeb6d7670e522a718067333cd4e73ffffffffffffffffffffffffffffffffffffffff163b1115611508576daaeb6d7670e522a718067333cd4e73ffffffffffffffffffffffffffffffffffffffff1663c617113430336040518363ffffffff1660e01b815260040161148392919061348a565b6020604051808303816000875af11580156114a2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906114c691906134c8565b61150757336040517fede71dcc0000000000000000000000000000000000000000000000000000000081526004016114fe9190612d3a565b60405180910390fd5b5b61151484848484611da7565b50505050565b606061152582611e09565b611564576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161155b906138eb565b60405180910390fd5b60001515600d60019054906101000a900460ff1615150361161157600a805461158c90613335565b80601f01602080910402602001604051908101604052809291908181526020018280546115b890613335565b80156116055780601f106115da57610100808354040283529160200191611605565b820191906000526020600020905b8154815290600101906020018083116115e857829003601f168201915b5050505050905061166d565b600061161b611e4a565b9050600081511161163b5760405180602001604052806000815250611669565b8061164584611edc565b6009604051602001611659939291906139db565b6040516020818303038152906040525b9150505b919050565b600b5481565b6116806119ec565b80600d60016101000a81548160ff02191690831515021790555050565b6000600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16905092915050565b816000811180156117445750600c548111155b611783576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161177a9061372b565b60405180910390fd5b600b54816117916007611a6a565b61179b919061374b565b11156117dc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117d3906137ed565b60405180910390fd5b6117e46119ec565b6117ee8284611bfb565b505050565b6117fb6119ec565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff160361186a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161186190613a7e565b60405180910390fd5b61187381611b35565b50565b60007f01ffc9a7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916149050919050565b6118e981611e09565b611928576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161191f9061362d565b60405180910390fd5b50565b600033905090565b816004600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff166119a683611018565b73ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b6119f461192b565b73ffffffffffffffffffffffffffffffffffffffff16611a1261118b565b73ffffffffffffffffffffffffffffffffffffffff1614611a68576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a5f90613aea565b60405180910390fd5b565b600081600001549050919050565b611a89611a8361192b565b82611faa565b611ac8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611abf90613b7c565b60405180910390fd5b611ad383838361203f565b505050565b611af38383836040518060200160405280600081525061140c565b505050565b60006002600083815260200190815260200160002060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b6000600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081600660006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b60005b81811015611c3657611c106007612338565b611c2383611c1e6007611a6a565b61234e565b8080611c2e90613599565b915050611bfe565b505050565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1603611ca9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611ca090613be8565b60405180910390fd5b80600560008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3183604051611d9a9190612bc0565b60405180910390a3505050565b611db8611db261192b565b83611faa565b611df7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611dee90613b7c565b60405180910390fd5b611e038484848461236c565b50505050565b60008073ffffffffffffffffffffffffffffffffffffffff16611e2b83611af8565b73ffffffffffffffffffffffffffffffffffffffff1614159050919050565b606060088054611e5990613335565b80601f0160208091040260200160405190810160405280929190818152602001828054611e8590613335565b8015611ed25780601f10611ea757610100808354040283529160200191611ed2565b820191906000526020600020905b815481529060010190602001808311611eb557829003601f168201915b5050505050905090565b606060006001611eeb846123c8565b01905060008167ffffffffffffffff811115611f0a57611f09612dcb565b5b6040519080825280601f01601f191660200182016040528015611f3c5781602001600182028036833780820191505090505b509050600082602001820190505b600115611f9f578080600190039150507f3031323334353637383961626364656600000000000000000000000000000000600a86061a8153600a8581611f9357611f92613c08565b5b04945060008503611f4a575b819350505050919050565b600080611fb683611018565b90508073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161480611ff85750611ff7818561169d565b5b8061203657508373ffffffffffffffffffffffffffffffffffffffff1661201e84610955565b73ffffffffffffffffffffffffffffffffffffffff16145b91505092915050565b8273ffffffffffffffffffffffffffffffffffffffff1661205f82611018565b73ffffffffffffffffffffffffffffffffffffffff16146120b5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016120ac90613ca9565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603612124576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161211b90613d3b565b60405180910390fd5b612131838383600161251b565b8273ffffffffffffffffffffffffffffffffffffffff1661215182611018565b73ffffffffffffffffffffffffffffffffffffffff16146121a7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161219e90613ca9565b60405180910390fd5b6004600082815260200190815260200160002060006101000a81549073ffffffffffffffffffffffffffffffffffffffff02191690556001600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825403925050819055506001600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282540192505081905550816002600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a46123338383836001612641565b505050565b6001816000016000828254019250508190555050565b612368828260405180602001604052806000815250612647565b5050565b61237784848461203f565b612383848484846126a2565b6123c2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016123b990613dcd565b60405180910390fd5b50505050565b600080600090507a184f03e93ff9f4daa797ed6e38ed64bf6a1f0100000000000000008310612426577a184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000838161241c5761241b613c08565b5b0492506040810190505b6d04ee2d6d415b85acef81000000008310612463576d04ee2d6d415b85acef8100000000838161245957612458613c08565b5b0492506020810190505b662386f26fc10000831061249257662386f26fc10000838161248857612487613c08565b5b0492506010810190505b6305f5e10083106124bb576305f5e10083816124b1576124b0613c08565b5b0492506008810190505b61271083106124e05761271083816124d6576124d5613c08565b5b0492506004810190505b6064831061250357606483816124f9576124f8613c08565b5b0492506002810190505b600a8310612512576001810190505b80915050919050565b600181111561263b57600073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16146125af5780600360008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546125a79190613ded565b925050819055505b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161461263a5780600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000828254612632919061374b565b925050819055505b5b50505050565b50505050565b6126518383612829565b61265e60008484846126a2565b61269d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161269490613dcd565b60405180910390fd5b505050565b60006126c38473ffffffffffffffffffffffffffffffffffffffff16612a46565b1561281c578373ffffffffffffffffffffffffffffffffffffffff1663150b7a026126ec61192b565b8786866040518563ffffffff1660e01b815260040161270e9493929190613e76565b6020604051808303816000875af192505050801561274a57506040513d601f19601f820116820180604052508101906127479190613ed7565b60015b6127cc573d806000811461277a576040519150601f19603f3d011682016040523d82523d6000602084013e61277f565b606091505b5060008151036127c4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016127bb90613dcd565b60405180910390fd5b805181602001fd5b63150b7a0260e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916817bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191614915050612821565b600190505b949350505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1603612898576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161288f90613f50565b60405180910390fd5b6128a181611e09565b156128e1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016128d890613fbc565b60405180910390fd5b6128ef60008383600161251b565b6128f881611e09565b15612938576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161292f90613fbc565b60405180910390fd5b6001600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282540192505081905550816002600083815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550808273ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a4612a42600083836001612641565b5050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b828054612a7590613335565b90600052602060002090601f016020900481019282612a975760008555612ade565b82601f10612ab057805160ff1916838001178555612ade565b82800160010185558215612ade579182015b82811115612add578251825591602001919060010190612ac2565b5b509050612aeb9190612aef565b5090565b5b80821115612b08576000816000905550600101612af0565b5090565b6000604051905090565b600080fd5b600080fd5b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b612b5581612b20565b8114612b6057600080fd5b50565b600081359050612b7281612b4c565b92915050565b600060208284031215612b8e57612b8d612b16565b5b6000612b9c84828501612b63565b91505092915050565b60008115159050919050565b612bba81612ba5565b82525050565b6000602082019050612bd56000830184612bb1565b92915050565b600081519050919050565b600082825260208201905092915050565b60005b83811015612c15578082015181840152602081019050612bfa565b83811115612c24576000848401525b50505050565b6000601f19601f8301169050919050565b6000612c4682612bdb565b612c508185612be6565b9350612c60818560208601612bf7565b612c6981612c2a565b840191505092915050565b60006020820190508181036000830152612c8e8184612c3b565b905092915050565b6000819050919050565b612ca981612c96565b8114612cb457600080fd5b50565b600081359050612cc681612ca0565b92915050565b600060208284031215612ce257612ce1612b16565b5b6000612cf084828501612cb7565b91505092915050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000612d2482612cf9565b9050919050565b612d3481612d19565b82525050565b6000602082019050612d4f6000830184612d2b565b92915050565b612d5e81612d19565b8114612d6957600080fd5b50565b600081359050612d7b81612d55565b92915050565b60008060408385031215612d9857612d97612b16565b5b6000612da685828601612d6c565b9250506020612db785828601612cb7565b9150509250929050565b600080fd5b600080fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b612e0382612c2a565b810181811067ffffffffffffffff82111715612e2257612e21612dcb565b5b80604052505050565b6000612e35612b0c565b9050612e418282612dfa565b919050565b600067ffffffffffffffff821115612e6157612e60612dcb565b5b612e6a82612c2a565b9050602081019050919050565b82818337600083830152505050565b6000612e99612e9484612e46565b612e2b565b905082815260208101848484011115612eb557612eb4612dc6565b5b612ec0848285612e77565b509392505050565b600082601f830112612edd57612edc612dc1565b5b8135612eed848260208601612e86565b91505092915050565b600060208284031215612f0c57612f0b612b16565b5b600082013567ffffffffffffffff811115612f2a57612f29612b1b565b5b612f3684828501612ec8565b91505092915050565b612f4881612ba5565b8114612f5357600080fd5b50565b600081359050612f6581612f3f565b92915050565b600060208284031215612f8157612f80612b16565b5b6000612f8f84828501612f56565b91505092915050565b612fa181612c96565b82525050565b6000602082019050612fbc6000830184612f98565b92915050565b600080600060608486031215612fdb57612fda612b16565b5b6000612fe986828701612d6c565b9350506020612ffa86828701612d6c565b925050604061300b86828701612cb7565b9150509250925092565b60006020828403121561302b5761302a612b16565b5b600061303984828501612d6c565b91505092915050565b600081519050919050565b600082825260208201905092915050565b6000819050602082019050919050565b61307781612c96565b82525050565b6000613089838361306e565b60208301905092915050565b6000602082019050919050565b60006130ad82613042565b6130b7818561304d565b93506130c28361305e565b8060005b838110156130f35781516130da888261307d565b97506130e583613095565b9250506001810190506130c6565b5085935050505092915050565b6000602082019050818103600083015261311a81846130a2565b905092915050565b6000806040838503121561313957613138612b16565b5b600061314785828601612d6c565b925050602061315885828601612f56565b9150509250929050565b600067ffffffffffffffff82111561317d5761317c612dcb565b5b61318682612c2a565b9050602081019050919050565b60006131a66131a184613162565b612e2b565b9050828152602081018484840111156131c2576131c1612dc6565b5b6131cd848285612e77565b509392505050565b600082601f8301126131ea576131e9612dc1565b5b81356131fa848260208601613193565b91505092915050565b6000806000806080858703121561321d5761321c612b16565b5b600061322b87828801612d6c565b945050602061323c87828801612d6c565b935050604061324d87828801612cb7565b925050606085013567ffffffffffffffff81111561326e5761326d612b1b565b5b61327a878288016131d5565b91505092959194509250565b6000806040838503121561329d5761329c612b16565b5b60006132ab85828601612d6c565b92505060206132bc85828601612d6c565b9150509250929050565b600080604083850312156132dd576132dc612b16565b5b60006132eb85828601612cb7565b92505060206132fc85828601612d6c565b9150509250929050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b6000600282049050600182168061334d57607f821691505b6020821081036133605761335f613306565b5b50919050565b7f4552433732313a20617070726f76616c20746f2063757272656e74206f776e6560008201527f7200000000000000000000000000000000000000000000000000000000000000602082015250565b60006133c2602183612be6565b91506133cd82613366565b604082019050919050565b600060208201905081810360008301526133f1816133b5565b9050919050565b7f4552433732313a20617070726f76652063616c6c6572206973206e6f7420746f60008201527f6b656e206f776e6572206f7220617070726f76656420666f7220616c6c000000602082015250565b6000613454603d83612be6565b915061345f826133f8565b604082019050919050565b6000602082019050818103600083015261348381613447565b9050919050565b600060408201905061349f6000830185612d2b565b6134ac6020830184612d2b565b9392505050565b6000815190506134c281612f3f565b92915050565b6000602082840312156134de576134dd612b16565b5b60006134ec848285016134b3565b91505092915050565b600081905092915050565b50565b60006135106000836134f5565b915061351b82613500565b600082019050919050565b600061353182613503565b9150819050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60006135a482612c96565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036135d6576135d561356a565b5b600182019050919050565b7f4552433732313a20696e76616c696420746f6b656e2049440000000000000000600082015250565b6000613617601883612be6565b9150613622826135e1565b602082019050919050565b600060208201905081810360008301526136468161360a565b9050919050565b7f4552433732313a2061646472657373207a65726f206973206e6f74206120766160008201527f6c6964206f776e65720000000000000000000000000000000000000000000000602082015250565b60006136a9602983612be6565b91506136b48261364d565b604082019050919050565b600060208201905081810360008301526136d88161369c565b9050919050565b7f496e76616c6964206d696e7420616d6f756e7421000000000000000000000000600082015250565b6000613715601483612be6565b9150613720826136df565b602082019050919050565b6000602082019050818103600083015261374481613708565b9050919050565b600061375682612c96565b915061376183612c96565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156137965761379561356a565b5b828201905092915050565b7f4d617820737570706c7920657863656564656421000000000000000000000000600082015250565b60006137d7601483612be6565b91506137e2826137a1565b602082019050919050565b60006020820190508181036000830152613806816137ca565b9050919050565b7f54686520636f6e74726163742069732070617573656421000000000000000000600082015250565b6000613843601783612be6565b915061384e8261380d565b602082019050919050565b6000602082019050818103600083015261387281613836565b9050919050565b7f4552433732314d657461646174613a2055524920717565727920666f72206e6f60008201527f6e6578697374656e7420746f6b656e0000000000000000000000000000000000602082015250565b60006138d5602f83612be6565b91506138e082613879565b604082019050919050565b60006020820190508181036000830152613904816138c8565b9050919050565b600081905092915050565b600061392182612bdb565b61392b818561390b565b935061393b818560208601612bf7565b80840191505092915050565b60008190508160005260206000209050919050565b6000815461396981613335565b613973818661390b565b9450600182166000811461398e576001811461399f576139d2565b60ff198316865281860193506139d2565b6139a885613947565b60005b838110156139ca578154818901526001820191506020810190506139ab565b838801955050505b50505092915050565b60006139e78286613916565b91506139f38285613916565b91506139ff828461395c565b9150819050949350505050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b6000613a68602683612be6565b9150613a7382613a0c565b604082019050919050565b60006020820190508181036000830152613a9781613a5b565b9050919050565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b6000613ad4602083612be6565b9150613adf82613a9e565b602082019050919050565b60006020820190508181036000830152613b0381613ac7565b9050919050565b7f4552433732313a2063616c6c6572206973206e6f7420746f6b656e206f776e6560008201527f72206f7220617070726f76656400000000000000000000000000000000000000602082015250565b6000613b66602d83612be6565b9150613b7182613b0a565b604082019050919050565b60006020820190508181036000830152613b9581613b59565b9050919050565b7f4552433732313a20617070726f766520746f2063616c6c657200000000000000600082015250565b6000613bd2601983612be6565b9150613bdd82613b9c565b602082019050919050565b60006020820190508181036000830152613c0181613bc5565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4552433732313a207472616e736665722066726f6d20696e636f72726563742060008201527f6f776e6572000000000000000000000000000000000000000000000000000000602082015250565b6000613c93602583612be6565b9150613c9e82613c37565b604082019050919050565b60006020820190508181036000830152613cc281613c86565b9050919050565b7f4552433732313a207472616e7366657220746f20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b6000613d25602483612be6565b9150613d3082613cc9565b604082019050919050565b60006020820190508181036000830152613d5481613d18565b9050919050565b7f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560008201527f63656976657220696d706c656d656e7465720000000000000000000000000000602082015250565b6000613db7603283612be6565b9150613dc282613d5b565b604082019050919050565b60006020820190508181036000830152613de681613daa565b9050919050565b6000613df882612c96565b9150613e0383612c96565b925082821015613e1657613e1561356a565b5b828203905092915050565b600081519050919050565b600082825260208201905092915050565b6000613e4882613e21565b613e528185613e2c565b9350613e62818560208601612bf7565b613e6b81612c2a565b840191505092915050565b6000608082019050613e8b6000830187612d2b565b613e986020830186612d2b565b613ea56040830185612f98565b8181036060830152613eb78184613e3d565b905095945050505050565b600081519050613ed181612b4c565b92915050565b600060208284031215613eed57613eec612b16565b5b6000613efb84828501613ec2565b91505092915050565b7f4552433732313a206d696e7420746f20746865207a65726f2061646472657373600082015250565b6000613f3a602083612be6565b9150613f4582613f04565b602082019050919050565b60006020820190508181036000830152613f6981613f2d565b9050919050565b7f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000600082015250565b6000613fa6601c83612be6565b9150613fb182613f70565b602082019050919050565b60006020820190508181036000830152613fd581613f99565b905091905056fea2646970667358221220d3951b4a3533bb22f15edca0f284bf66714e99c0e703e34b1a6915cb7e0aeb3a64736f6c634300080d0033697066733a2f2f516d646468367377687a66646f3861315463616f774e51445576625935384139693471514a6173543648443465482f68696464656e2e6a736f6e

Deployed Bytecode

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

Deployed Bytecode Sourcemap

73401:4425:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57484:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58412:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59924:171;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59442:416;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;76278:100;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;76384:77;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74227:89;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;77261:157;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;76467:466;;;;;;;;;;;;;:::i;:::-;;77426:165;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;74668:635;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;76034:132;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73801:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73610:33;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73770:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73577:28;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58122:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57853:207;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36915:103;;;;;;;;;;;;;:::i;:::-;;76172:100;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;36267:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73726:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58581:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74322:177;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60167:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73648:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75898:130;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;77599:222;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75309:494;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73690:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75809:81;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60393:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74507:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37173:201;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57484:305;57586:4;57638:25;57623:40;;;:11;:40;;;;:105;;;;57695:33;57680:48;;;:11;:48;;;;57623:105;:158;;;;57745:36;57769:11;57745:23;:36::i;:::-;57623:158;57603:178;;57484:305;;;:::o;58412:100::-;58466:13;58499:5;58492:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58412:100;:::o;59924:171::-;60000:7;60020:23;60035:7;60020:14;:23::i;:::-;60063:15;:24;60079:7;60063:24;;;;;;;;;;;;;;;;;;;;;60056:31;;59924:171;;;:::o;59442:416::-;59523:13;59539:23;59554:7;59539:14;:23::i;:::-;59523:39;;59587:5;59581:11;;:2;:11;;;59573:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;59681:5;59665:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;59690:37;59707:5;59714:12;:10;:12::i;:::-;59690:16;:37::i;:::-;59665:62;59643:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;59829:21;59838:2;59842:7;59829:8;:21::i;:::-;59512:346;59442:416;;:::o;76278:100::-;36153:13;:11;:13::i;:::-;76362:10:::1;76350:9;:22;;;;;;;;;;;;:::i;:::-;;76278:100:::0;:::o;76384:77::-;36153:13;:11;:13::i;:::-;76449:6:::1;76440;;:15;;;;;;;;;;;;;;;;;;76384:77:::0;:::o;74227:89::-;74271:7;74294:16;:6;:14;:16::i;:::-;74287:23;;74227:89;:::o;77261: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;77373:37:::1;77392:4;77398:2;77402:7;77373:18;:37::i;:::-;77261:157:::0;;;:::o;76467:466::-;36153:13;:11;:13::i;:::-;76755:7:::1;76776;:5;:7::i;:::-;76768:21;;76797;76768:55;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76754:69;;;76838:2;76830:11;;;::::0;::::1;;76504:429;76467:466::o:0;77426: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;77542:41:::1;77565:4;77571:2;77575:7;77542:22;:41::i;:::-;77426:165:::0;;;:::o;74668:635::-;74743:16;74771:23;74797:17;74807:6;74797:9;:17::i;:::-;74771:43;;74821:30;74868:15;74854:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74821:63;;74891:22;74916:1;74891:26;;74924:23;74960:309;74985:15;74967;:33;:64;;;;;75022:9;;75004:14;:27;;74967:64;74960:309;;;75042:25;75070:23;75078:14;75070:7;:23::i;:::-;75042:51;;75129:6;75108:27;;:17;:27;;;75104:131;;75181:14;75148:13;75162:15;75148:30;;;;;;;;:::i;:::-;;;;;;;:47;;;;;75208:17;;;;;:::i;:::-;;;;75104:131;75245:16;;;;;:::i;:::-;;;;75033:236;74960:309;;;75284:13;75277:20;;;;;;74668:635;;;:::o;76034:132::-;36153:13;:11;:13::i;:::-;76142:18:::1;76122:17;:38;;;;;;;;;;;;:::i;:::-;;76034:132:::0;:::o;73801:28::-;;;;;;;;;;;;;:::o;73610:33::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;73770:26::-;;;;;;;;;;;;;:::o;73577:28::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;58122:223::-;58194:7;58214:13;58230:17;58239:7;58230:8;:17::i;:::-;58214:33;;58283:1;58266:19;;:5;:19;;;58258:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;58332:5;58325:12;;;58122:223;;;:::o;57853:207::-;57925:7;57970:1;57953:19;;:5;:19;;;57945:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;58036:9;:16;58046:5;58036:16;;;;;;;;;;;;;;;;58029:23;;57853:207;;;:::o;36915:103::-;36153:13;:11;:13::i;:::-;36980:30:::1;37007:1;36980:18;:30::i;:::-;36915:103::o:0;76172:100::-;36153:13;:11;:13::i;:::-;76256:10:::1;76244:9;:22;;;;;;;;;;;;:::i;:::-;;76172:100:::0;:::o;36267:87::-;36313:7;36340:6;;;;;;;;;;;36333:13;;36267:87;:::o;73726:37::-;;;;:::o;58581:104::-;58637:13;58670:7;58663:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58581:104;:::o;74322:177::-;74387:11;74061:1;74047:11;:15;:52;;;;;74081:18;;74066:11;:33;;74047:52;74039:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;74173:9;;74158:11;74139:16;:6;:14;:16::i;:::-;:30;;;;:::i;:::-;:43;;74131:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;74416:6:::1;;;;;;;;;;;74415:7;74407:43;;;;;;;;;;;;:::i;:::-;;;;;;;;;74459:34;74469:10;74481:11;74459:9;:34::i;:::-;74322:177:::0;;:::o;60167:155::-;60262:52;60281:12;:10;:12::i;:::-;60295:8;60305;60262:18;:52::i;:::-;60167:155;;:::o;73648:31::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;75898:130::-;36153:13;:11;:13::i;:::-;76003:19:::1;75982:18;:40;;;;75898:130:::0;:::o;77599: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;77766:47:::1;77789:4;77795:2;77799:7;77808:4;77766:22;:47::i;:::-;77599:222:::0;;;;:::o;75309:494::-;75408:13;75449:17;75457:8;75449:7;:17::i;:::-;75433:98;;;;;;;;;;;;:::i;:::-;;;;;;;;;75556:5;75544:17;;:8;;;;;;;;;;;:17;;;75540:64;;75579:17;75572:24;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75540:64;75612:28;75643:10;:8;:10::i;:::-;75612:41;;75698:1;75673:14;75667:28;:32;:130;;;;;;;;;;;;;;;;;75735:14;75751:19;:8;:17;:19::i;:::-;75772:9;75718:64;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;75667:130;75660:137;;;75309:494;;;;:::o;73690:31::-;;;;:::o;75809:81::-;36153:13;:11;:13::i;:::-;75878:6:::1;75867:8;;:17;;;;;;;;;;;;;;;;;;75809:81:::0;:::o;60393:164::-;60490:4;60514:18;:25;60533:5;60514:25;;;;;;;;;;;;;;;:35;60540:8;60514:35;;;;;;;;;;;;;;;;;;;;;;;;;60507:42;;60393:164;;;;:::o;74507:155::-;74593:11;74061:1;74047:11;:15;:52;;;;;74081:18;;74066:11;:33;;74047:52;74039:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;74173:9;;74158:11;74139:16;:6;:14;:16::i;:::-;:30;;;;:::i;:::-;:43;;74131:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;36153:13:::1;:11;:13::i;:::-;74623:33:::2;74633:9;74644:11;74623:9;:33::i;:::-;74507:155:::0;;;:::o;37173:201::-;36153:13;:11;:13::i;:::-;37282:1:::1;37262:22;;:8;:22;;::::0;37254:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;37338:28;37357:8;37338:18;:28::i;:::-;37173:201:::0;:::o;49996:157::-;50081:4;50120:25;50105:40;;;:11;:40;;;;50098:47;;49996:157;;;:::o;69743:135::-;69825:16;69833:7;69825;:16::i;:::-;69817:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;69743:135;:::o;34818:98::-;34871:7;34898:10;34891:17;;34818:98;:::o;69022:174::-;69124:2;69097:15;:24;69113:7;69097:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;69180:7;69176:2;69142:46;;69151:23;69166:7;69151:14;:23::i;:::-;69142:46;;;;;;;;;;;;69022:174;;:::o;36432:132::-;36507:12;:10;:12::i;:::-;36496:23;;:7;:5;:7::i;:::-;:23;;;36488:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;36432:132::o;18347:114::-;18412:7;18439;:14;;;18432:21;;18347:114;;;:::o;60624:335::-;60819:41;60838:12;:10;:12::i;:::-;60852:7;60819:18;:41::i;:::-;60811:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;60923:28;60933:4;60939:2;60943:7;60923:9;:28::i;:::-;60624:335;;;:::o;61030:185::-;61168:39;61185:4;61191:2;61195:7;61168:39;;;;;;;;;;;;:16;:39::i;:::-;61030:185;;;:::o;62916:117::-;62982:7;63009;:16;63017:7;63009:16;;;;;;;;;;;;;;;;;;;;;63002:23;;62916:117;;;:::o;37534:191::-;37608:16;37627:6;;;;;;;;;;;37608:25;;37653:8;37644:6;;:17;;;;;;;;;;;;;;;;;;37708:8;37677:40;;37698:8;37677:40;;;;;;;;;;;;37597:128;37534:191;:::o;76939:204::-;77019:9;77014:124;77038:11;77034:1;:15;77014:124;;;77065:18;:6;:16;:18::i;:::-;77092:38;77102:9;77113:16;:6;:14;:16::i;:::-;77092:9;:38::i;:::-;77051:3;;;;;:::i;:::-;;;;77014:124;;;;76939:204;;:::o;69339:315::-;69494:8;69485:17;;:5;:17;;;69477:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;69581:8;69543:18;:25;69562:5;69543:25;;;;;;;;;;;;;;;:35;69569:8;69543:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;69627:8;69605:41;;69620:5;69605:41;;;69637:8;69605:41;;;;;;:::i;:::-;;;;;;;;69339:315;;;:::o;61286:322::-;61460:41;61479:12;:10;:12::i;:::-;61493:7;61460:18;:41::i;:::-;61452:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;61562:38;61576:4;61582:2;61586:7;61595:4;61562:13;:38::i;:::-;61286:322;;;;:::o;63346:128::-;63411:4;63464:1;63435:31;;:17;63444:7;63435:8;:17::i;:::-;:31;;;;63428:38;;63346:128;;;:::o;77149:104::-;77209:13;77238:9;77231:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77149:104;:::o;32245:716::-;32301:13;32352:14;32389:1;32369:17;32380:5;32369:10;:17::i;:::-;:21;32352:38;;32405:20;32439:6;32428:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32405:41;;32461:11;32590:6;32586:2;32582:15;32574:6;32570:28;32563:35;;32627:288;32634:4;32627:288;;;32659:5;;;;;;;;32801:8;32796:2;32789:5;32785:14;32780:30;32775:3;32767:44;32857:2;32848:11;;;;;;:::i;:::-;;;;;32891:1;32882:5;:10;32627:288;32878:21;32627:288;32936:6;32929:13;;;;;32245:716;;;:::o;63641:264::-;63734:4;63751:13;63767:23;63782:7;63767:14;:23::i;:::-;63751:39;;63820:5;63809:16;;:7;:16;;;:52;;;;63829:32;63846:5;63853:7;63829:16;:32::i;:::-;63809:52;:87;;;;63889:7;63865:31;;:20;63877:7;63865:11;:20::i;:::-;:31;;;63809:87;63801:96;;;63641:264;;;;:::o;67640:1263::-;67799:4;67772:31;;:23;67787:7;67772:14;:23::i;:::-;:31;;;67764:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;67878:1;67864:16;;:2;:16;;;67856:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;67934:42;67955:4;67961:2;67965:7;67974:1;67934:20;:42::i;:::-;68106:4;68079:31;;:23;68094:7;68079:14;:23::i;:::-;:31;;;68071:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;68224:15;:24;68240:7;68224:24;;;;;;;;;;;;68217:31;;;;;;;;;;;68719:1;68700:9;:15;68710:4;68700:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;68752:1;68735:9;:13;68745:2;68735:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;68794:2;68775:7;:16;68783:7;68775:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;68833:7;68829:2;68814:27;;68823:4;68814:27;;;;;;;;;;;;68854:41;68874:4;68880:2;68884:7;68893:1;68854:19;:41::i;:::-;67640:1263;;;:::o;18469:127::-;18576:1;18558:7;:14;;;:19;;;;;;;;;;;18469:127;:::o;64247:110::-;64323:26;64333:2;64337:7;64323:26;;;;;;;;;;;;:9;:26::i;:::-;64247:110;;:::o;62489:313::-;62645:28;62655:4;62661:2;62665:7;62645:9;:28::i;:::-;62692:47;62715:4;62721:2;62725:7;62734:4;62692:22;:47::i;:::-;62684:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;62489:313;;;;:::o;29111:922::-;29164:7;29184:14;29201:1;29184:18;;29251:6;29242:5;:15;29238:102;;29287:6;29278:15;;;;;;:::i;:::-;;;;;29322:2;29312:12;;;;29238:102;29367:6;29358:5;:15;29354:102;;29403:6;29394:15;;;;;;:::i;:::-;;;;;29438:2;29428:12;;;;29354:102;29483:6;29474:5;:15;29470:102;;29519:6;29510:15;;;;;;:::i;:::-;;;;;29554:2;29544:12;;;;29470:102;29599:5;29590;:14;29586:99;;29634:5;29625:14;;;;;;:::i;:::-;;;;;29668:1;29658:11;;;;29586:99;29712:5;29703;:14;29699:99;;29747:5;29738:14;;;;;;:::i;:::-;;;;;29781:1;29771:11;;;;29699:99;29825:5;29816;:14;29812:99;;29860:5;29851:14;;;;;;:::i;:::-;;;;;29894:1;29884:11;;;;29812:99;29938:5;29929;:14;29925:66;;29974:1;29964:11;;;;29925:66;30019:6;30012:13;;;29111:922;;;:::o;72027:410::-;72217:1;72205:9;:13;72201:229;;;72255:1;72239:18;;:4;:18;;;72235:87;;72297:9;72278;:15;72288:4;72278:15;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;72235:87;72354:1;72340:16;;:2;:16;;;72336:83;;72394:9;72377;:13;72387:2;72377:13;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;72336:83;72201:229;72027:410;;;;:::o;73159:158::-;;;;;:::o;64584:319::-;64713:18;64719:2;64723:7;64713:5;:18::i;:::-;64764:53;64795:1;64799:2;64803:7;64812:4;64764:22;:53::i;:::-;64742:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;64584:319;;;:::o;70442:853::-;70596:4;70617:15;:2;:13;;;:15::i;:::-;70613:675;;;70669:2;70653:36;;;70690:12;:10;:12::i;:::-;70704:4;70710:7;70719:4;70653:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;70649:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70911:1;70894:6;:13;:18;70890:328;;70937:60;;;;;;;;;;:::i;:::-;;;;;;;;70890:328;71168:6;71162:13;71153:6;71149:2;71145:15;71138:38;70649:584;70785:41;;;70775:51;;;:6;:51;;;;70768:58;;;;;70613:675;71272:4;71265:11;;70442:853;;;;;;;:::o;65239:942::-;65333:1;65319:16;;:2;:16;;;65311:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;65392:16;65400:7;65392;:16::i;:::-;65391:17;65383:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;65454:48;65483:1;65487:2;65491:7;65500:1;65454:20;:48::i;:::-;65601:16;65609:7;65601;:16::i;:::-;65600:17;65592:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;66016:1;65999:9;:13;66009:2;65999:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;66060:2;66041:7;:16;66049:7;66041:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;66105:7;66101:2;66080:33;;66097:1;66080:33;;;;;;;;;;;;66126:47;66154:1;66158:2;66162:7;66171:1;66126:19;:47::i;:::-;65239:942;;:::o;38965:326::-;39025:4;39282:1;39260:7;:19;;;:23;39253:30;;38965:326;;;:::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:117::-;5047:1;5044;5037:12;5061:117;5170:1;5167;5160:12;5184:180;5232:77;5229:1;5222:88;5329:4;5326:1;5319:15;5353:4;5350:1;5343:15;5370:281;5453:27;5475:4;5453:27;:::i;:::-;5445:6;5441:40;5583:6;5571:10;5568:22;5547:18;5535:10;5532:34;5529:62;5526:88;;;5594:18;;:::i;:::-;5526:88;5634:10;5630:2;5623:22;5413:238;5370:281;;:::o;5657:129::-;5691:6;5718:20;;:::i;:::-;5708:30;;5747:33;5775:4;5767:6;5747:33;:::i;:::-;5657:129;;;:::o;5792:308::-;5854:4;5944:18;5936:6;5933:30;5930:56;;;5966:18;;:::i;:::-;5930:56;6004:29;6026:6;6004:29;:::i;:::-;5996:37;;6088:4;6082;6078:15;6070:23;;5792:308;;;:::o;6106:154::-;6190:6;6185:3;6180;6167:30;6252:1;6243:6;6238:3;6234:16;6227:27;6106:154;;;:::o;6266:412::-;6344:5;6369:66;6385:49;6427:6;6385:49;:::i;:::-;6369:66;:::i;:::-;6360:75;;6458:6;6451:5;6444:21;6496:4;6489:5;6485:16;6534:3;6525:6;6520:3;6516:16;6513:25;6510:112;;;6541:79;;:::i;:::-;6510:112;6631:41;6665:6;6660:3;6655;6631:41;:::i;:::-;6350:328;6266:412;;;;;:::o;6698:340::-;6754:5;6803:3;6796:4;6788:6;6784:17;6780:27;6770:122;;6811:79;;:::i;:::-;6770:122;6928:6;6915:20;6953:79;7028:3;7020:6;7013:4;7005:6;7001:17;6953:79;:::i;:::-;6944:88;;6760:278;6698:340;;;;:::o;7044:509::-;7113:6;7162:2;7150:9;7141:7;7137:23;7133:32;7130:119;;;7168:79;;:::i;:::-;7130:119;7316:1;7305:9;7301:17;7288:31;7346:18;7338:6;7335:30;7332:117;;;7368:79;;:::i;:::-;7332:117;7473:63;7528:7;7519:6;7508:9;7504:22;7473:63;:::i;:::-;7463:73;;7259:287;7044:509;;;;:::o;7559:116::-;7629:21;7644:5;7629:21;:::i;:::-;7622:5;7619:32;7609:60;;7665:1;7662;7655:12;7609:60;7559:116;:::o;7681:133::-;7724:5;7762:6;7749:20;7740:29;;7778:30;7802:5;7778:30;:::i;:::-;7681:133;;;;:::o;7820:323::-;7876:6;7925:2;7913:9;7904:7;7900:23;7896:32;7893:119;;;7931:79;;:::i;:::-;7893:119;8051:1;8076:50;8118:7;8109:6;8098:9;8094:22;8076:50;:::i;:::-;8066:60;;8022:114;7820:323;;;;:::o;8149:118::-;8236:24;8254:5;8236:24;:::i;:::-;8231:3;8224:37;8149:118;;:::o;8273:222::-;8366:4;8404:2;8393:9;8389:18;8381:26;;8417:71;8485:1;8474:9;8470:17;8461:6;8417:71;:::i;:::-;8273:222;;;;:::o;8501:619::-;8578:6;8586;8594;8643:2;8631:9;8622:7;8618:23;8614:32;8611:119;;;8649:79;;:::i;:::-;8611:119;8769:1;8794:53;8839:7;8830:6;8819:9;8815:22;8794:53;:::i;:::-;8784:63;;8740:117;8896:2;8922:53;8967:7;8958:6;8947:9;8943:22;8922:53;:::i;:::-;8912:63;;8867:118;9024:2;9050:53;9095:7;9086:6;9075:9;9071:22;9050:53;:::i;:::-;9040:63;;8995:118;8501:619;;;;;:::o;9126:329::-;9185:6;9234:2;9222:9;9213:7;9209:23;9205:32;9202:119;;;9240:79;;:::i;:::-;9202:119;9360:1;9385:53;9430:7;9421:6;9410:9;9406:22;9385:53;:::i;:::-;9375:63;;9331:117;9126:329;;;;:::o;9461:114::-;9528:6;9562:5;9556:12;9546:22;;9461:114;;;:::o;9581:184::-;9680:11;9714:6;9709:3;9702:19;9754:4;9749:3;9745:14;9730:29;;9581:184;;;;:::o;9771:132::-;9838:4;9861:3;9853:11;;9891:4;9886:3;9882:14;9874:22;;9771:132;;;:::o;9909:108::-;9986:24;10004:5;9986:24;:::i;:::-;9981:3;9974:37;9909:108;;:::o;10023:179::-;10092:10;10113:46;10155:3;10147:6;10113:46;:::i;:::-;10191:4;10186:3;10182:14;10168:28;;10023:179;;;;:::o;10208:113::-;10278:4;10310;10305:3;10301:14;10293:22;;10208:113;;;:::o;10357:732::-;10476:3;10505:54;10553:5;10505:54;:::i;:::-;10575:86;10654:6;10649:3;10575:86;:::i;:::-;10568:93;;10685:56;10735:5;10685:56;:::i;:::-;10764:7;10795:1;10780:284;10805:6;10802:1;10799:13;10780:284;;;10881:6;10875:13;10908:63;10967:3;10952:13;10908:63;:::i;:::-;10901:70;;10994:60;11047:6;10994:60;:::i;:::-;10984:70;;10840:224;10827:1;10824;10820:9;10815:14;;10780:284;;;10784:14;11080:3;11073:10;;10481:608;;;10357:732;;;;:::o;11095:373::-;11238:4;11276:2;11265:9;11261:18;11253:26;;11325:9;11319:4;11315:20;11311:1;11300:9;11296:17;11289:47;11353:108;11456:4;11447:6;11353:108;:::i;:::-;11345:116;;11095:373;;;;:::o;11474:468::-;11539:6;11547;11596:2;11584:9;11575:7;11571:23;11567:32;11564:119;;;11602:79;;:::i;:::-;11564:119;11722:1;11747:53;11792:7;11783:6;11772:9;11768:22;11747:53;:::i;:::-;11737:63;;11693:117;11849:2;11875:50;11917:7;11908:6;11897:9;11893:22;11875:50;:::i;:::-;11865:60;;11820:115;11474:468;;;;;:::o;11948:307::-;12009:4;12099:18;12091:6;12088:30;12085:56;;;12121:18;;:::i;:::-;12085:56;12159:29;12181:6;12159:29;:::i;:::-;12151:37;;12243:4;12237;12233:15;12225:23;;11948:307;;;:::o;12261:410::-;12338:5;12363:65;12379:48;12420:6;12379:48;:::i;:::-;12363:65;:::i;:::-;12354:74;;12451:6;12444:5;12437:21;12489:4;12482:5;12478:16;12527:3;12518:6;12513:3;12509:16;12506:25;12503:112;;;12534:79;;:::i;:::-;12503:112;12624:41;12658:6;12653:3;12648;12624:41;:::i;:::-;12344:327;12261:410;;;;;:::o;12690:338::-;12745:5;12794:3;12787:4;12779:6;12775:17;12771:27;12761:122;;12802:79;;:::i;:::-;12761:122;12919:6;12906:20;12944:78;13018:3;13010:6;13003:4;12995:6;12991:17;12944:78;:::i;:::-;12935:87;;12751:277;12690:338;;;;:::o;13034:943::-;13129:6;13137;13145;13153;13202:3;13190:9;13181:7;13177:23;13173:33;13170:120;;;13209:79;;:::i;:::-;13170:120;13329:1;13354:53;13399:7;13390:6;13379:9;13375:22;13354:53;:::i;:::-;13344:63;;13300:117;13456:2;13482:53;13527:7;13518:6;13507:9;13503:22;13482:53;:::i;:::-;13472:63;;13427:118;13584:2;13610:53;13655:7;13646:6;13635:9;13631:22;13610:53;:::i;:::-;13600:63;;13555:118;13740:2;13729:9;13725:18;13712:32;13771:18;13763:6;13760:30;13757:117;;;13793:79;;:::i;:::-;13757:117;13898:62;13952:7;13943:6;13932:9;13928:22;13898:62;:::i;:::-;13888:72;;13683:287;13034:943;;;;;;;:::o;13983:474::-;14051:6;14059;14108:2;14096:9;14087:7;14083:23;14079:32;14076:119;;;14114:79;;:::i;:::-;14076:119;14234:1;14259:53;14304:7;14295:6;14284:9;14280:22;14259:53;:::i;:::-;14249:63;;14205:117;14361:2;14387:53;14432:7;14423:6;14412:9;14408:22;14387:53;:::i;:::-;14377:63;;14332:118;13983:474;;;;;:::o;14463:::-;14531:6;14539;14588:2;14576:9;14567:7;14563:23;14559:32;14556:119;;;14594:79;;:::i;:::-;14556:119;14714:1;14739:53;14784:7;14775:6;14764:9;14760:22;14739:53;:::i;:::-;14729:63;;14685:117;14841:2;14867:53;14912:7;14903:6;14892:9;14888:22;14867:53;:::i;:::-;14857:63;;14812:118;14463:474;;;;;:::o;14943:180::-;14991:77;14988:1;14981:88;15088:4;15085:1;15078:15;15112:4;15109:1;15102:15;15129:320;15173:6;15210:1;15204:4;15200:12;15190:22;;15257:1;15251:4;15247:12;15278:18;15268:81;;15334:4;15326:6;15322:17;15312:27;;15268:81;15396:2;15388:6;15385:14;15365:18;15362:38;15359:84;;15415:18;;:::i;:::-;15359:84;15180:269;15129:320;;;:::o;15455:220::-;15595:34;15591:1;15583:6;15579:14;15572:58;15664:3;15659:2;15651:6;15647:15;15640:28;15455:220;:::o;15681:366::-;15823:3;15844:67;15908:2;15903:3;15844:67;:::i;:::-;15837:74;;15920:93;16009:3;15920:93;:::i;:::-;16038:2;16033:3;16029:12;16022:19;;15681:366;;;:::o;16053:419::-;16219:4;16257:2;16246:9;16242:18;16234:26;;16306:9;16300:4;16296:20;16292:1;16281:9;16277:17;16270:47;16334:131;16460:4;16334:131;:::i;:::-;16326:139;;16053:419;;;:::o;16478:248::-;16618:34;16614:1;16606:6;16602:14;16595:58;16687:31;16682:2;16674:6;16670:15;16663:56;16478:248;:::o;16732:366::-;16874:3;16895:67;16959:2;16954:3;16895:67;:::i;:::-;16888:74;;16971:93;17060:3;16971:93;:::i;:::-;17089:2;17084:3;17080:12;17073:19;;16732:366;;;:::o;17104:419::-;17270:4;17308:2;17297:9;17293:18;17285:26;;17357:9;17351:4;17347:20;17343:1;17332:9;17328:17;17321:47;17385:131;17511:4;17385:131;:::i;:::-;17377:139;;17104:419;;;:::o;17529:332::-;17650:4;17688:2;17677:9;17673:18;17665:26;;17701:71;17769:1;17758:9;17754:17;17745:6;17701:71;:::i;:::-;17782:72;17850:2;17839:9;17835:18;17826:6;17782:72;:::i;:::-;17529:332;;;;;:::o;17867:137::-;17921:5;17952:6;17946:13;17937:22;;17968:30;17992:5;17968:30;:::i;:::-;17867:137;;;;:::o;18010:345::-;18077:6;18126:2;18114:9;18105:7;18101:23;18097:32;18094:119;;;18132:79;;:::i;:::-;18094:119;18252:1;18277:61;18330:7;18321:6;18310:9;18306:22;18277:61;:::i;:::-;18267:71;;18223:125;18010:345;;;;:::o;18361:147::-;18462:11;18499:3;18484:18;;18361:147;;;;:::o;18514:114::-;;:::o;18634:398::-;18793:3;18814:83;18895:1;18890:3;18814:83;:::i;:::-;18807:90;;18906:93;18995:3;18906:93;:::i;:::-;19024:1;19019:3;19015:11;19008:18;;18634:398;;;:::o;19038:379::-;19222:3;19244:147;19387:3;19244:147;:::i;:::-;19237:154;;19408:3;19401:10;;19038:379;;;:::o;19423:180::-;19471:77;19468:1;19461:88;19568:4;19565:1;19558:15;19592:4;19589:1;19582:15;19609:180;19657:77;19654:1;19647:88;19754:4;19751:1;19744:15;19778:4;19775:1;19768:15;19795:233;19834:3;19857:24;19875:5;19857:24;:::i;:::-;19848:33;;19903:66;19896:5;19893:77;19890:103;;19973:18;;:::i;:::-;19890:103;20020:1;20013:5;20009:13;20002:20;;19795:233;;;:::o;20034:174::-;20174:26;20170:1;20162:6;20158:14;20151:50;20034:174;:::o;20214:366::-;20356:3;20377:67;20441:2;20436:3;20377:67;:::i;:::-;20370:74;;20453:93;20542:3;20453:93;:::i;:::-;20571:2;20566:3;20562:12;20555:19;;20214:366;;;:::o;20586:419::-;20752:4;20790:2;20779:9;20775:18;20767:26;;20839:9;20833:4;20829:20;20825:1;20814:9;20810:17;20803:47;20867:131;20993:4;20867:131;:::i;:::-;20859:139;;20586:419;;;:::o;21011:228::-;21151:34;21147:1;21139:6;21135:14;21128:58;21220:11;21215:2;21207:6;21203:15;21196:36;21011:228;:::o;21245:366::-;21387:3;21408:67;21472:2;21467:3;21408:67;:::i;:::-;21401:74;;21484:93;21573:3;21484:93;:::i;:::-;21602:2;21597:3;21593:12;21586:19;;21245:366;;;:::o;21617:419::-;21783:4;21821:2;21810:9;21806:18;21798:26;;21870:9;21864:4;21860:20;21856:1;21845:9;21841:17;21834:47;21898:131;22024:4;21898:131;:::i;:::-;21890:139;;21617:419;;;:::o;22042:170::-;22182:22;22178:1;22170:6;22166:14;22159:46;22042:170;:::o;22218:366::-;22360:3;22381:67;22445:2;22440:3;22381:67;:::i;:::-;22374:74;;22457:93;22546:3;22457:93;:::i;:::-;22575:2;22570:3;22566:12;22559:19;;22218:366;;;:::o;22590:419::-;22756:4;22794:2;22783:9;22779:18;22771:26;;22843:9;22837:4;22833:20;22829:1;22818:9;22814:17;22807:47;22871:131;22997:4;22871:131;:::i;:::-;22863:139;;22590:419;;;:::o;23015:305::-;23055:3;23074:20;23092:1;23074:20;:::i;:::-;23069:25;;23108:20;23126:1;23108:20;:::i;:::-;23103:25;;23262:1;23194:66;23190:74;23187:1;23184:81;23181:107;;;23268:18;;:::i;:::-;23181:107;23312:1;23309;23305:9;23298:16;;23015:305;;;;:::o;23326:170::-;23466:22;23462:1;23454:6;23450:14;23443:46;23326:170;:::o;23502:366::-;23644:3;23665:67;23729:2;23724:3;23665:67;:::i;:::-;23658:74;;23741:93;23830:3;23741:93;:::i;:::-;23859:2;23854:3;23850:12;23843:19;;23502:366;;;:::o;23874:419::-;24040:4;24078:2;24067:9;24063:18;24055:26;;24127:9;24121:4;24117:20;24113:1;24102:9;24098:17;24091:47;24155:131;24281:4;24155:131;:::i;:::-;24147:139;;23874:419;;;:::o;24299:173::-;24439:25;24435:1;24427:6;24423:14;24416:49;24299:173;:::o;24478:366::-;24620:3;24641:67;24705:2;24700:3;24641:67;:::i;:::-;24634:74;;24717:93;24806:3;24717:93;:::i;:::-;24835:2;24830:3;24826:12;24819:19;;24478:366;;;:::o;24850:419::-;25016:4;25054:2;25043:9;25039:18;25031:26;;25103:9;25097:4;25093:20;25089:1;25078:9;25074:17;25067:47;25131:131;25257:4;25131:131;:::i;:::-;25123:139;;24850:419;;;:::o;25275:234::-;25415:34;25411:1;25403:6;25399:14;25392:58;25484:17;25479:2;25471:6;25467:15;25460:42;25275:234;:::o;25515:366::-;25657:3;25678:67;25742:2;25737:3;25678:67;:::i;:::-;25671:74;;25754:93;25843:3;25754:93;:::i;:::-;25872:2;25867:3;25863:12;25856:19;;25515:366;;;:::o;25887:419::-;26053:4;26091:2;26080:9;26076:18;26068:26;;26140:9;26134:4;26130:20;26126:1;26115:9;26111:17;26104:47;26168:131;26294:4;26168:131;:::i;:::-;26160:139;;25887:419;;;:::o;26312:148::-;26414:11;26451:3;26436:18;;26312:148;;;;:::o;26466:377::-;26572:3;26600:39;26633:5;26600:39;:::i;:::-;26655:89;26737:6;26732:3;26655:89;:::i;:::-;26648:96;;26753:52;26798:6;26793:3;26786:4;26779:5;26775:16;26753:52;:::i;:::-;26830:6;26825:3;26821:16;26814:23;;26576:267;26466:377;;;;:::o;26849:141::-;26898:4;26921:3;26913:11;;26944:3;26941:1;26934:14;26978:4;26975:1;26965:18;26957:26;;26849:141;;;:::o;27020:845::-;27123:3;27160:5;27154:12;27189:36;27215:9;27189:36;:::i;:::-;27241:89;27323:6;27318:3;27241:89;:::i;:::-;27234:96;;27361:1;27350:9;27346:17;27377:1;27372:137;;;;27523:1;27518:341;;;;27339:520;;27372:137;27456:4;27452:9;27441;27437:25;27432:3;27425:38;27492:6;27487:3;27483:16;27476:23;;27372:137;;27518:341;27585:38;27617:5;27585:38;:::i;:::-;27645:1;27659:154;27673:6;27670:1;27667:13;27659:154;;;27747:7;27741:14;27737:1;27732:3;27728:11;27721:35;27797:1;27788:7;27784:15;27773:26;;27695:4;27692:1;27688:12;27683:17;;27659:154;;;27842:6;27837:3;27833:16;27826:23;;27525:334;;27339:520;;27127:738;;27020:845;;;;:::o;27871:589::-;28096:3;28118:95;28209:3;28200:6;28118:95;:::i;:::-;28111:102;;28230:95;28321:3;28312:6;28230:95;:::i;:::-;28223:102;;28342:92;28430:3;28421:6;28342:92;:::i;:::-;28335:99;;28451:3;28444:10;;27871:589;;;;;;:::o;28466:225::-;28606:34;28602:1;28594:6;28590:14;28583:58;28675:8;28670:2;28662:6;28658:15;28651:33;28466:225;:::o;28697:366::-;28839:3;28860:67;28924:2;28919:3;28860:67;:::i;:::-;28853:74;;28936:93;29025:3;28936:93;:::i;:::-;29054:2;29049:3;29045:12;29038:19;;28697:366;;;:::o;29069:419::-;29235:4;29273:2;29262:9;29258:18;29250:26;;29322:9;29316:4;29312:20;29308:1;29297:9;29293:17;29286:47;29350:131;29476:4;29350:131;:::i;:::-;29342:139;;29069:419;;;:::o;29494:182::-;29634:34;29630:1;29622:6;29618:14;29611:58;29494:182;:::o;29682:366::-;29824:3;29845:67;29909:2;29904:3;29845:67;:::i;:::-;29838:74;;29921:93;30010:3;29921:93;:::i;:::-;30039:2;30034:3;30030:12;30023:19;;29682:366;;;:::o;30054:419::-;30220:4;30258:2;30247:9;30243:18;30235:26;;30307:9;30301:4;30297:20;30293:1;30282:9;30278:17;30271:47;30335:131;30461:4;30335:131;:::i;:::-;30327:139;;30054:419;;;:::o;30479:232::-;30619:34;30615:1;30607:6;30603:14;30596:58;30688:15;30683:2;30675:6;30671:15;30664:40;30479:232;:::o;30717:366::-;30859:3;30880:67;30944:2;30939:3;30880:67;:::i;:::-;30873:74;;30956:93;31045:3;30956:93;:::i;:::-;31074:2;31069:3;31065:12;31058:19;;30717:366;;;:::o;31089:419::-;31255:4;31293:2;31282:9;31278:18;31270:26;;31342:9;31336:4;31332:20;31328:1;31317:9;31313:17;31306:47;31370:131;31496:4;31370:131;:::i;:::-;31362:139;;31089:419;;;:::o;31514:175::-;31654:27;31650:1;31642:6;31638:14;31631:51;31514:175;:::o;31695:366::-;31837:3;31858:67;31922:2;31917:3;31858:67;:::i;:::-;31851:74;;31934:93;32023:3;31934:93;:::i;:::-;32052:2;32047:3;32043:12;32036:19;;31695:366;;;:::o;32067:419::-;32233:4;32271:2;32260:9;32256:18;32248:26;;32320:9;32314:4;32310:20;32306:1;32295:9;32291:17;32284:47;32348:131;32474:4;32348:131;:::i;:::-;32340:139;;32067:419;;;:::o;32492:180::-;32540:77;32537:1;32530:88;32637:4;32634:1;32627:15;32661:4;32658:1;32651:15;32678:224;32818:34;32814:1;32806:6;32802:14;32795:58;32887:7;32882:2;32874:6;32870:15;32863:32;32678:224;:::o;32908:366::-;33050:3;33071:67;33135:2;33130:3;33071:67;:::i;:::-;33064:74;;33147:93;33236:3;33147:93;:::i;:::-;33265:2;33260:3;33256:12;33249:19;;32908:366;;;:::o;33280:419::-;33446:4;33484:2;33473:9;33469:18;33461:26;;33533:9;33527:4;33523:20;33519:1;33508:9;33504:17;33497:47;33561:131;33687:4;33561:131;:::i;:::-;33553:139;;33280:419;;;:::o;33705:223::-;33845:34;33841:1;33833:6;33829:14;33822:58;33914:6;33909:2;33901:6;33897:15;33890:31;33705:223;:::o;33934:366::-;34076:3;34097:67;34161:2;34156:3;34097:67;:::i;:::-;34090:74;;34173:93;34262:3;34173:93;:::i;:::-;34291:2;34286:3;34282:12;34275:19;;33934:366;;;:::o;34306:419::-;34472:4;34510:2;34499:9;34495:18;34487:26;;34559:9;34553:4;34549:20;34545:1;34534:9;34530:17;34523:47;34587:131;34713:4;34587:131;:::i;:::-;34579:139;;34306:419;;;:::o;34731:237::-;34871:34;34867:1;34859:6;34855:14;34848:58;34940:20;34935:2;34927:6;34923:15;34916:45;34731:237;:::o;34974:366::-;35116:3;35137:67;35201:2;35196:3;35137:67;:::i;:::-;35130:74;;35213:93;35302:3;35213:93;:::i;:::-;35331:2;35326:3;35322:12;35315:19;;34974:366;;;:::o;35346:419::-;35512:4;35550:2;35539:9;35535:18;35527:26;;35599:9;35593:4;35589:20;35585:1;35574:9;35570:17;35563:47;35627:131;35753:4;35627:131;:::i;:::-;35619:139;;35346:419;;;:::o;35771:191::-;35811:4;35831:20;35849:1;35831:20;:::i;:::-;35826:25;;35865:20;35883:1;35865:20;:::i;:::-;35860:25;;35904:1;35901;35898:8;35895:34;;;35909:18;;:::i;:::-;35895:34;35954:1;35951;35947:9;35939:17;;35771:191;;;;:::o;35968:98::-;36019:6;36053:5;36047:12;36037:22;;35968:98;;;:::o;36072:168::-;36155:11;36189:6;36184:3;36177:19;36229:4;36224:3;36220:14;36205:29;;36072:168;;;;:::o;36246:360::-;36332:3;36360:38;36392:5;36360:38;:::i;:::-;36414:70;36477:6;36472:3;36414:70;:::i;:::-;36407:77;;36493:52;36538:6;36533:3;36526:4;36519:5;36515:16;36493:52;:::i;:::-;36570:29;36592:6;36570:29;:::i;:::-;36565:3;36561:39;36554:46;;36336:270;36246:360;;;;:::o;36612:640::-;36807:4;36845:3;36834:9;36830:19;36822:27;;36859:71;36927:1;36916:9;36912:17;36903:6;36859:71;:::i;:::-;36940:72;37008:2;36997:9;36993:18;36984:6;36940:72;:::i;:::-;37022;37090:2;37079:9;37075:18;37066:6;37022:72;:::i;:::-;37141:9;37135:4;37131:20;37126:2;37115:9;37111:18;37104:48;37169:76;37240:4;37231:6;37169:76;:::i;:::-;37161:84;;36612:640;;;;;;;:::o;37258:141::-;37314:5;37345:6;37339:13;37330:22;;37361:32;37387:5;37361:32;:::i;:::-;37258:141;;;;:::o;37405:349::-;37474:6;37523:2;37511:9;37502:7;37498:23;37494:32;37491:119;;;37529:79;;:::i;:::-;37491:119;37649:1;37674:63;37729:7;37720:6;37709:9;37705:22;37674:63;:::i;:::-;37664:73;;37620:127;37405:349;;;;:::o;37760:182::-;37900:34;37896:1;37888:6;37884:14;37877:58;37760:182;:::o;37948:366::-;38090:3;38111:67;38175:2;38170:3;38111:67;:::i;:::-;38104:74;;38187:93;38276:3;38187:93;:::i;:::-;38305:2;38300:3;38296:12;38289:19;;37948:366;;;:::o;38320:419::-;38486:4;38524:2;38513:9;38509:18;38501:26;;38573:9;38567:4;38563:20;38559:1;38548:9;38544:17;38537:47;38601:131;38727:4;38601:131;:::i;:::-;38593:139;;38320:419;;;:::o;38745:178::-;38885:30;38881:1;38873:6;38869:14;38862:54;38745:178;:::o;38929:366::-;39071:3;39092:67;39156:2;39151:3;39092:67;:::i;:::-;39085:74;;39168:93;39257:3;39168:93;:::i;:::-;39286:2;39281:3;39277:12;39270:19;;38929:366;;;:::o;39301:419::-;39467:4;39505:2;39494:9;39490:18;39482:26;;39554:9;39548:4;39544:20;39540:1;39529:9;39525:17;39518:47;39582:131;39708:4;39582:131;:::i;:::-;39574:139;;39301:419;;;:::o

Swarm Source

ipfs://d3951b4a3533bb22f15edca0f284bf66714e99c0e703e34b1a6915cb7e0aeb3a

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