ERC-721
Overview
Max Total Supply
4 GOOD
Holders
4
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Balance
1 GOODLoading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
FortunateNFT
Compiler Version
v0.8.19+commit.7dd6d404
Contract Source Code (Solidity)
/** *Submitted for verification at ftmscan.com on 2023-04-27 */ // 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: @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/security/Pausable.sol // OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor() { _paused = false; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { _requireNotPaused(); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { _requirePaused(); _; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Throws if the contract is paused. */ function _requireNotPaused() internal view virtual { require(!paused(), "Pausable: paused"); } /** * @dev Throws if the contract is not paused. */ function _requirePaused() internal view virtual { require(paused(), "Pausable: not paused"); } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } } // 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/IERC721Enumerable.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File: @openzeppelin/contracts/token/ERC721/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.2) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _ownerOf(tokenId); require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner or approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory data ) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _safeTransfer(from, to, tokenId, data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory data ) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { return _owners[tokenId]; } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _ownerOf(tokenId) != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId, 1); // Check that tokenId was not minted by `_beforeTokenTransfer` hook require(!_exists(tokenId), "ERC721: token already minted"); unchecked { // Will not overflow unless all 2**256 token ids are minted to the same owner. // Given that tokens are minted one by one, it is impossible in practice that // this ever happens. Might change if we allow batch minting. // The ERC fails to describe this case. _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId, 1); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId, 1); // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook owner = ERC721.ownerOf(tokenId); // Clear approvals delete _tokenApprovals[tokenId]; unchecked { // Cannot overflow, as that would require more tokens to be burned/transferred // out than the owner initially received through minting and transferring in. _balances[owner] -= 1; } delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId, 1); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId, 1); // Check that tokenId was not transferred by `_beforeTokenTransfer` hook require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); // Clear approvals from the previous owner delete _tokenApprovals[tokenId]; unchecked { // `_balances[from]` cannot overflow for the same reason as described in `_burn`: // `from`'s balance is the number of token held, which is at least one before the current // transfer. // `_balances[to]` could overflow in the conditions described in `_mint`. That would require // all 2**256 token ids to be minted, which in practice is impossible. _balances[from] -= 1; _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`. * - When `from` is zero, the tokens will be minted for `to`. * - When `to` is zero, ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual {} /** * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`. * - When `from` is zero, the tokens were minted for `to`. * - When `to` is zero, ``from``'s tokens were burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual {} /** * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override. * * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such * that `ownerOf(tokenId)` is `a`. */ // solhint-disable-next-line func-name-mixedcase function __unsafe_increaseBalance(address account, uint256 amount) internal { _balances[account] += amount; } } // File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol) pragma solidity ^0.8.0; /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds * enumerability of all the token ids in the contract as well as all token ids owned by each * account. */ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable { // Mapping from owner to list of owned token IDs mapping(address => mapping(uint256 => uint256)) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds"); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds"); return _allTokens[index]; } /** * @dev See {ERC721-_beforeTokenTransfer}. */ function _beforeTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual override { super._beforeTokenTransfer(from, to, firstTokenId, batchSize); if (batchSize > 1) { // Will only trigger during construction. Batch transferring (minting) is not available afterwards. revert("ERC721Enumerable: consecutive transfers not supported"); } uint256 tokenId = firstTokenId; if (from == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (from != to) { _removeTokenFromOwnerEnumeration(from, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (to != from) { _addTokenToOwnerEnumeration(to, tokenId); } } /** * @dev Private function to add a token to this extension's ownership-tracking data structures. * @param to address representing the new owner of the given token ID * @param tokenId uint256 ID of the token to be added to the tokens list of the given address */ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = ERC721.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; } /** * @dev Private function to add a token to this extension's token tracking data structures. * @param tokenId uint256 ID of the token to be added to the tokens list */ function _addTokenToAllTokensEnumeration(uint256 tokenId) private { _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } /** * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for * gas optimizations e.g. when performing a transfer operation (avoiding double writes). * This has O(1) time complexity, but alters the order of the _ownedTokens array. * @param from address representing the previous owner of the given token ID * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = ERC721.balanceOf(from) - 1; uint256 tokenIndex = _ownedTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index } // This also deletes the contents at the last position of the array delete _ownedTokensIndex[tokenId]; delete _ownedTokens[from][lastTokenIndex]; } /** * @dev Private function to remove a token from this extension's token tracking data structures. * This has O(1) time complexity, but alters the order of the _allTokens array. * @param tokenId uint256 ID of the token to be removed from the tokens list */ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = _allTokens.length - 1; uint256 tokenIndex = _allTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding // an 'if' statement (like in _removeTokenFromOwnerEnumeration) uint256 lastTokenId = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index // This also deletes the contents at the last position of the array delete _allTokensIndex[tokenId]; _allTokens.pop(); } } // File: @openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/extensions/ERC721URIStorage.sol) pragma solidity ^0.8.0; /** * @dev ERC721 token with storage based token URI management. */ abstract contract ERC721URIStorage is ERC721 { using Strings for uint256; // Optional mapping for token URIs mapping(uint256 => string) private _tokenURIs; /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory _tokenURI = _tokenURIs[tokenId]; string memory base = _baseURI(); // If there is no base URI, return the token URI. if (bytes(base).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(base, _tokenURI)); } return super.tokenURI(tokenId); } /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } /** * @dev See {ERC721-_burn}. This override additionally checks to see if a * token-specific URI was set for the token, and if so, it deletes the token URI from * the storage mapping. */ function _burn(uint256 tokenId) internal virtual override { super._burn(tokenId); if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } } } // File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Pausable.sol // OpenZeppelin Contracts (last updated v4.8.2) (token/ERC721/extensions/ERC721Pausable.sol) pragma solidity ^0.8.0; /** * @dev ERC721 token with pausable token transfers, minting and burning. * * Useful for scenarios such as preventing trades until the end of an evaluation * period, or having an emergency switch for freezing all token transfers in the * event of a large bug. * * IMPORTANT: This contract does not include public pause and unpause functions. In * addition to inheriting this contract, you must define both functions, invoking the * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will * make the contract unpausable. */ abstract contract ERC721Pausable is ERC721, Pausable { /** * @dev See {ERC721-_beforeTokenTransfer}. * * Requirements: * * - the contract must not be paused. */ function _beforeTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual override { super._beforeTokenTransfer(from, to, firstTokenId, batchSize); require(!paused(), "ERC721Pausable: token transfer while paused"); } } // File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Burnable.sol) pragma solidity ^0.8.0; /** * @title ERC721 Burnable Token * @dev ERC721 Token that can be burned (destroyed). */ abstract contract ERC721Burnable is Context, ERC721 { /** * @dev Burns `tokenId`. See {ERC721-_burn}. * * Requirements: * * - The caller must own `tokenId` or be an approved operator. */ function burn(uint256 tokenId) public virtual { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _burn(tokenId); } } // File: contracts/FortunateNFT.sol pragma solidity 0.8.19; contract FortunateNFT is Ownable, ERC721URIStorage, ERC721Enumerable, ERC721Pausable { using EnumerableSet for EnumerableSet.AddressSet; using Strings for uint256; EnumerableSet.AddressSet private whitelist; mapping(address => bool) private hasMinted; bool public whitelistMintEnabled = true; string private baseURI; uint256 private tokenId; uint256 public constant maxSupply = 333; constructor(string memory _initBaseURI) ERC721("FortunateNFT", "GOOD") { setBaseURI(_initBaseURI); } function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) { return super.supportsInterface(interfaceId); } function _baseURI() internal view virtual override returns (string memory) { return baseURI; } function addToWhitelist(address[] calldata addresses) external onlyOwner { for (uint256 i = 0; i < addresses.length; i++) { whitelist.add(addresses[i]); } } function isWhitelisted(address user) public view returns (bool) { return whitelist.contains(user); } function toggleWhitelistMint() external onlyOwner { whitelistMintEnabled = !whitelistMintEnabled; } function mint() external whenNotPaused { require(totalSupply() < maxSupply, "All tokens have been minted."); require(!hasMinted[msg.sender],"You have already minted"); if (whitelistMintEnabled) { require(isWhitelisted(msg.sender), "You are not in the whitelist."); } _safeMint(msg.sender, tokenId); tokenId++; hasMinted[msg.sender] = true; } function pause() public onlyOwner { _pause(); } function unpause() public onlyOwner { _unpause(); } function setBaseURI(string memory _newURI) public onlyOwner { baseURI = _newURI; } function tokenURI(uint256 _tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) { require(_exists(_tokenId), "ERC721Metadata: URI query for nonexistent token"); string memory currentBaseURI = _baseURI(); return bytes(currentBaseURI).length > 0 ? string(abi.encodePacked(currentBaseURI, _tokenId.toString(), ".json")) : ""; } function _beforeTokenTransfer(address from, address to, uint256 _tokenId, uint256 batchSize) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) { batchSize = 1; super._beforeTokenTransfer(from, to, _tokenId, batchSize); } function _burn(uint256 _tokenId) internal override(ERC721, ERC721URIStorage) { super._burn(_tokenId); } function tokenOfOwner(address owner) public view returns (uint256[] memory) { uint256 tokenCount = balanceOf(owner); uint256[] memory result = new uint256[](tokenCount); for (uint256 i = 0; i < tokenCount; i++) { result[i] = tokenOfOwnerByIndex(owner, i); } return result; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_initBaseURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"}],"name":"addToWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","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":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleWhitelistMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokenOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"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":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"whitelistMintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _initBaseURI (string):
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
83067:3135:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83627:179;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56609:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58121:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57639:416;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;84371:406;;;:::i;:::-;;73542:113;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58821:335;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;85886:313;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;73210:256;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;84128:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;84858:65;;;:::i;:::-;;59227:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;73732:233;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;84931:96;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;33867:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56319:223;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;83348:39;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;84250:113;;;:::i;:::-;;56050:207;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31377:103;;;:::i;:::-;;83928:192;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;84789:61;;;:::i;:::-;;30729:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56778:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58364:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59483:322;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;85035:417;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;83455:39;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;58590:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31635:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;83627:179;83738:4;83762:36;83786:11;83762:23;:36::i;:::-;83755:43;;83627:179;;;:::o;56609:100::-;56663:13;56696:5;56689:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56609:100;:::o;58121:171::-;58197:7;58217:23;58232:7;58217:14;:23::i;:::-;58260:15;:24;58276:7;58260:24;;;;;;;;;;;;;;;;;;;;;58253:31;;58121:171;;;:::o;57639:416::-;57720:13;57736:23;57751:7;57736:14;:23::i;:::-;57720:39;;57784:5;57778:11;;:2;:11;;;57770:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;57878:5;57862:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;57887:37;57904:5;57911:12;:10;:12::i;:::-;57887:16;:37::i;:::-;57862:62;57840:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;58026:21;58035:2;58039:7;58026:8;:21::i;:::-;57709:346;57639:416;;:::o;84371:406::-;33472:19;:17;:19::i;:::-;83491:3:::1;84425:13;:11;:13::i;:::-;:25;84417:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;84499:9;:21;84509:10;84499:21;;;;;;;;;;;;;;;;;;;;;;;;;84498:22;84490:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;84558:20;;;;;;;;;;;84554:116;;;84599:25;84613:10;84599:13;:25::i;:::-;84591:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;84554:116;84680:30;84690:10;84702:7;;84680:9;:30::i;:::-;84721:7;;:9;;;;;;;;;:::i;:::-;;;;;;84765:4;84741:9;:21;84751:10;84741:21;;;;;;;;;;;;;;;;:28;;;;;;;;;;;;;;;;;;84371:406::o:0;73542:113::-;73603:7;73630:10;:17;;;;73623:24;;73542:113;:::o;58821:335::-;59016:41;59035:12;:10;:12::i;:::-;59049:7;59016:18;:41::i;:::-;59008:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;59120:28;59130:4;59136:2;59140:7;59120:9;:28::i;:::-;58821:335;;;:::o;85886:313::-;85944:16;85969:18;85990:16;86000:5;85990:9;:16::i;:::-;85969:37;;86013:23;86053:10;86039:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;86013:51;;86076:9;86071:101;86095:10;86091:1;:14;86071:101;;;86135:29;86155:5;86162:1;86135:19;:29::i;:::-;86123:6;86130:1;86123:9;;;;;;;;:::i;:::-;;;;;;;:41;;;;;86107:3;;;;;:::i;:::-;;;;86071:101;;;;86185:6;86178:13;;;;85886:313;;;:::o;73210:256::-;73307:7;73343:23;73360:5;73343:16;:23::i;:::-;73335:5;:31;73327:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;73432:12;:19;73445:5;73432:19;;;;;;;;;;;;;;;:26;73452:5;73432:26;;;;;;;;;;;;73425:33;;73210:256;;;;:::o;84128:114::-;84186:4;84210:24;84229:4;84210:9;:18;;:24;;;;:::i;:::-;84203:31;;84128:114;;;:::o;84858:65::-;30615:13;:11;:13::i;:::-;84905:10:::1;:8;:10::i;:::-;84858:65::o:0;59227:185::-;59365:39;59382:4;59388:2;59392:7;59365:39;;;;;;;;;;;;:16;:39::i;:::-;59227:185;;;:::o;73732:233::-;73807:7;73843:30;:28;:30::i;:::-;73835:5;:38;73827:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;73940:10;73951:5;73940:17;;;;;;;;:::i;:::-;;;;;;;;;;73933:24;;73732:233;;;:::o;84931:96::-;30615:13;:11;:13::i;:::-;85012:7:::1;85002;:17;;;;;;:::i;:::-;;84931:96:::0;:::o;33867:86::-;33914:4;33938:7;;;;;;;;;;;33931:14;;33867:86;:::o;56319:223::-;56391:7;56411:13;56427:17;56436:7;56427:8;:17::i;:::-;56411:33;;56480:1;56463:19;;:5;:19;;;56455:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;56529:5;56522:12;;;56319:223;;;:::o;83348:39::-;;;;;;;;;;;;;:::o;84250:113::-;30615:13;:11;:13::i;:::-;84335:20:::1;;;;;;;;;;;84334:21;84311:20;;:44;;;;;;;;;;;;;;;;;;84250:113::o:0;56050:207::-;56122:7;56167:1;56150:19;;:5;:19;;;56142:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;56233:9;:16;56243:5;56233:16;;;;;;;;;;;;;;;;56226:23;;56050:207;;;:::o;31377:103::-;30615:13;:11;:13::i;:::-;31442:30:::1;31469:1;31442:18;:30::i;:::-;31377:103::o:0;83928:192::-;30615:13;:11;:13::i;:::-;84017:9:::1;84012:101;84036:9;;:16;;84032:1;:20;84012:101;;;84074:27;84088:9;;84098:1;84088:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;84074:9;:13;;:27;;;;:::i;:::-;;84054:3;;;;;:::i;:::-;;;;84012:101;;;;83928:192:::0;;:::o;84789:61::-;30615:13;:11;:13::i;:::-;84834:8:::1;:6;:8::i;:::-;84789:61::o:0;30729:87::-;30775:7;30802:6;;;;;;;;;;;30795:13;;30729:87;:::o;56778:104::-;56834:13;56867:7;56860:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56778:104;:::o;58364:155::-;58459:52;58478:12;:10;:12::i;:::-;58492:8;58502;58459:18;:52::i;:::-;58364:155;;:::o;59483:322::-;59657:41;59676:12;:10;:12::i;:::-;59690:7;59657:18;:41::i;:::-;59649:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;59759:38;59773:4;59779:2;59783:7;59792:4;59759:13;:38::i;:::-;59483:322;;;;:::o;85035:417::-;85135:13;85169:17;85177:8;85169:7;:17::i;:::-;85161:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;85249:28;85280:10;:8;:10::i;:::-;85249:41;;85339:1;85314:14;85308:28;:32;:136;;;;;;;;;;;;;;;;;85380:14;85396:19;:8;:17;:19::i;:::-;85363:62;;;;;;;;;:::i;:::-;;;;;;;;;;;;;85308:136;85301:143;;;85035:417;;;:::o;83455:39::-;83491:3;83455:39;:::o;58590:164::-;58687:4;58711:18;:25;58730:5;58711:25;;;;;;;;;;;;;;;:35;58737:8;58711:35;;;;;;;;;;;;;;;;;;;;;;;;;58704:42;;58590:164;;;;:::o;31635:201::-;30615:13;:11;:13::i;:::-;31744:1:::1;31724:22;;:8;:22;;::::0;31716:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;31800:28;31819:8;31800:18;:28::i;:::-;31635:201:::0;:::o;72902:224::-;73004:4;73043:35;73028:50;;;:11;:50;;;;:90;;;;73082:36;73106:11;73082:23;:36::i;:::-;73028:90;73021:97;;72902:224;;;:::o;67940:135::-;68022:16;68030:7;68022;:16::i;:::-;68014:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;67940:135;:::o;29280:98::-;29333:7;29360:10;29353:17;;29280:98;:::o;67219:174::-;67321:2;67294:15;:24;67310:7;67294:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;67377:7;67373:2;67339:46;;67348:23;67363:7;67348:14;:23::i;:::-;67339:46;;;;;;;;;;;;67219:174;;:::o;34026:108::-;34097:8;:6;:8::i;:::-;34096:9;34088:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;34026:108::o;62444:110::-;62520:26;62530:2;62534:7;62520:26;;;;;;;;;;;;:9;:26::i;:::-;62444:110;;:::o;61838:264::-;61931:4;61948:13;61964:23;61979:7;61964:14;:23::i;:::-;61948:39;;62017:5;62006:16;;:7;:16;;;:52;;;;62026:32;62043:5;62050:7;62026:16;:32::i;:::-;62006:52;:87;;;;62086:7;62062:31;;:20;62074:7;62062:11;:20::i;:::-;:31;;;62006:87;61998:96;;;61838:264;;;;:::o;65837:1263::-;65996:4;65969:31;;:23;65984:7;65969:14;:23::i;:::-;:31;;;65961:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;66075:1;66061:16;;:2;:16;;;66053:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;66131:42;66152:4;66158:2;66162:7;66171:1;66131:20;:42::i;:::-;66303:4;66276:31;;:23;66291:7;66276:14;:23::i;:::-;:31;;;66268:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;66421:15;:24;66437:7;66421:24;;;;;;;;;;;;66414:31;;;;;;;;;;;66916:1;66897:9;:15;66907:4;66897:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;66949:1;66932:9;:13;66942:2;66932:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;66991:2;66972:7;:16;66980:7;66972:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;67030:7;67026:2;67011:27;;67020:4;67011:27;;;;;;;;;;;;67051:41;67071:4;67077:2;67081:7;67090:1;67051:19;:41::i;:::-;65837:1263;;;:::o;9181:167::-;9261:4;9285:55;9295:3;:10;;9331:5;9315:23;;9307:32;;9285:9;:55::i;:::-;9278:62;;9181:167;;;;:::o;30894:132::-;30969:12;:10;:12::i;:::-;30958:23;;:7;:5;:7::i;:::-;:23;;;30950:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;30894:132::o;34722:120::-;33731:16;:14;:16::i;:::-;34791:5:::1;34781:7;;:15;;;;;;;;;;;;;;;;;;34812:22;34821:12;:10;:12::i;:::-;34812:22;;;;;;:::i;:::-;;;;;;;;34722:120::o:0;61113:117::-;61179:7;61206;:16;61214:7;61206:16;;;;;;;;;;;;;;;;;;;;;61199:23;;61113:117;;;:::o;31996:191::-;32070:16;32089:6;;;;;;;;;;;32070:25;;32115:8;32106:6;;:17;;;;;;;;;;;;;;;;;;32170:8;32139:40;;32160:8;32139:40;;;;;;;;;;;;32059:128;31996:191;:::o;8609:152::-;8679:4;8703:50;8708:3;:10;;8744:5;8728:23;;8720:32;;8703:4;:50::i;:::-;8696:57;;8609:152;;;;:::o;34463:118::-;33472:19;:17;:19::i;:::-;34533:4:::1;34523:7;;:14;;;;;;;;;;;;;;;;;;34553:20;34560:12;:10;:12::i;:::-;34553:20;;;;;;:::i;:::-;;;;;;;;34463:118::o:0;67536:315::-;67691:8;67682:17;;:5;:17;;;67674:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;67778:8;67740:18;:25;67759:5;67740:25;;;;;;;;;;;;;;;:35;67766:8;67740:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;67824:8;67802:41;;67817:5;67802:41;;;67834:8;67802:41;;;;;;:::i;:::-;;;;;;;;67536:315;;;:::o;60686:313::-;60842:28;60852:4;60858:2;60862:7;60842:9;:28::i;:::-;60889:47;60912:4;60918:2;60922:7;60931:4;60889:22;:47::i;:::-;60881:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;60686:313;;;;:::o;61543:128::-;61608:4;61661:1;61632:31;;:17;61641:7;61632:8;:17::i;:::-;:31;;;;61625:38;;61543:128;;;:::o;83812:108::-;83872:13;83905:7;83898:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83812:108;:::o;26707:716::-;26763:13;26814:14;26851:1;26831:17;26842:5;26831:10;:17::i;:::-;:21;26814:38;;26867:20;26901:6;26890:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26867:41;;26923:11;27052:6;27048:2;27044:15;27036:6;27032:28;27025:35;;27089:288;27096:4;27089:288;;;27121:5;;;;;;;;27263:8;27258:2;27251:5;27247:14;27242:30;27237:3;27229:44;27319:2;27310:11;;;;;;:::i;:::-;;;;;27353:1;27344:5;:10;27089:288;27340:21;27089:288;27398:6;27391:13;;;;;26707:716;;;:::o;55681:305::-;55783:4;55835:25;55820:40;;;:11;:40;;;;:105;;;;55892:33;55877:48;;;:11;:48;;;;55820:105;:158;;;;55942:36;55966:11;55942:23;:36::i;:::-;55820:158;55800:178;;55681:305;;;:::o;62781:319::-;62910:18;62916:2;62920:7;62910:5;:18::i;:::-;62961:53;62992:1;62996:2;63000:7;63009:4;62961:22;:53::i;:::-;62939:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;62781:319;;;:::o;85460:293::-;85676:1;85664:13;;85688:57;85715:4;85721:2;85725:8;85735:9;85688:26;:57::i;:::-;85460:293;;;;:::o;71105:158::-;;;;;:::o;4436:129::-;4509:4;4556:1;4533:3;:12;;:19;4546:5;4533:19;;;;;;;;;;;;:24;;4526:31;;4436:129;;;;:::o;34211:108::-;34278:8;:6;:8::i;:::-;34270:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;34211:108::o;2340:414::-;2403:4;2425:21;2435:3;2440:5;2425:9;:21::i;:::-;2420:327;;2463:3;:11;;2480:5;2463:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2646:3;:11;;:18;;;;2624:3;:12;;:19;2637:5;2624:19;;;;;;;;;;;:40;;;;2686:4;2679:11;;;;2420:327;2730:5;2723:12;;2340:414;;;;;:::o;68639:853::-;68793:4;68814:15;:2;:13;;;:15::i;:::-;68810:675;;;68866:2;68850:36;;;68887:12;:10;:12::i;:::-;68901:4;68907:7;68916:4;68850:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;68846:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69108:1;69091:6;:13;:18;69087:328;;69134:60;;;;;;;;;;:::i;:::-;;;;;;;;69087:328;69365:6;69359:13;69350:6;69346:2;69342:15;69335:38;68846:584;68982:41;;;68972:51;;;:6;:51;;;;68965:58;;;;;68810:675;69469:4;69462:11;;68639:853;;;;;;;:::o;23573:922::-;23626:7;23646:14;23663:1;23646:18;;23713:6;23704:5;:15;23700:102;;23749:6;23740:15;;;;;;:::i;:::-;;;;;23784:2;23774:12;;;;23700:102;23829:6;23820:5;:15;23816:102;;23865:6;23856:15;;;;;;:::i;:::-;;;;;23900:2;23890:12;;;;23816:102;23945:6;23936:5;:15;23932:102;;23981:6;23972:15;;;;;;:::i;:::-;;;;;24016:2;24006:12;;;;23932:102;24061:5;24052;:14;24048:99;;24096:5;24087:14;;;;;;:::i;:::-;;;;;24130:1;24120:11;;;;24048:99;24174:5;24165;:14;24161:99;;24209:5;24200:14;;;;;;:::i;:::-;;;;;24243:1;24233:11;;;;24161:99;24287:5;24278;:14;24274:99;;24322:5;24313:14;;;;;;:::i;:::-;;;;;24356:1;24346:11;;;;24274:99;24400:5;24391;:14;24387:66;;24436:1;24426:11;;;;24387:66;24481:6;24474:13;;;23573:922;;;:::o;47113:157::-;47198:4;47237:25;47222:40;;;:11;:40;;;;47215:47;;47113:157;;;:::o;63436:942::-;63530:1;63516:16;;:2;:16;;;63508:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;63589:16;63597:7;63589;:16::i;:::-;63588:17;63580:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;63651:48;63680:1;63684:2;63688:7;63697:1;63651:20;:48::i;:::-;63798:16;63806:7;63798;:16::i;:::-;63797:17;63789:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;64213:1;64196:9;:13;64206:2;64196:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;64257:2;64238:7;:16;64246:7;64238:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;64302:7;64298:2;64277:33;;64294:1;64277:33;;;;;;;;;;;;64323:47;64351:1;64355:2;64359:7;64368:1;64323:19;:47::i;:::-;63436:942;;:::o;81863:324::-;82040:61;82067:4;82073:2;82077:12;82091:9;82040:26;:61::i;:::-;82123:8;:6;:8::i;:::-;82122:9;82114:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;81863:324;;;;:::o;36082:326::-;36142:4;36399:1;36377:7;:19;;;:23;36370:30;;36082:326;;;:::o;74039:915::-;74216:61;74243:4;74249:2;74253:12;74267:9;74216:26;:61::i;:::-;74306:1;74294:9;:13;74290:222;;;74437:63;;;;;;;;;;:::i;:::-;;;;;;;;74290:222;74524:15;74542:12;74524:30;;74587:1;74571:18;;:4;:18;;;74567:187;;74606:40;74638:7;74606:31;:40::i;:::-;74567:187;;;74676:2;74668:10;;:4;:10;;;74664:90;;74695:47;74728:4;74734:7;74695:32;:47::i;:::-;74664:90;74567:187;74782:1;74768:16;;:2;:16;;;74764:183;;74801:45;74838:7;74801:36;:45::i;:::-;74764:183;;;74874:4;74868:10;;:2;:10;;;74864:83;;74895:40;74923:2;74927:7;74895:27;:40::i;:::-;74864:83;74764:183;74205:749;74039:915;;;;:::o;70224:159::-;;;;;:::o;75677:164::-;75781:10;:17;;;;75754:15;:24;75770:7;75754:24;;;;;;;;;;;:44;;;;75809:10;75825:7;75809:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75677:164;:::o;76468:988::-;76734:22;76784:1;76759:22;76776:4;76759:16;:22::i;:::-;:26;;;;:::i;:::-;76734:51;;76796:18;76817:17;:26;76835:7;76817:26;;;;;;;;;;;;76796:47;;76964:14;76950:10;:28;76946:328;;76995:19;77017:12;:18;77030:4;77017:18;;;;;;;;;;;;;;;:34;77036:14;77017:34;;;;;;;;;;;;76995:56;;77101:11;77068:12;:18;77081:4;77068:18;;;;;;;;;;;;;;;:30;77087:10;77068:30;;;;;;;;;;;:44;;;;77218:10;77185:17;:30;77203:11;77185:30;;;;;;;;;;;:43;;;;76980:294;76946:328;77370:17;:26;77388:7;77370:26;;;;;;;;;;;77363:33;;;77414:12;:18;77427:4;77414:18;;;;;;;;;;;;;;;:34;77433:14;77414:34;;;;;;;;;;;77407:41;;;76549:907;;76468:988;;:::o;77751:1079::-;78004:22;78049:1;78029:10;:17;;;;:21;;;;:::i;:::-;78004:46;;78061:18;78082:15;:24;78098:7;78082:24;;;;;;;;;;;;78061:45;;78433:19;78455:10;78466:14;78455:26;;;;;;;;:::i;:::-;;;;;;;;;;78433:48;;78519:11;78494:10;78505;78494:22;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;78630:10;78599:15;:28;78615:11;78599:28;;;;;;;;;;;:41;;;;78771:15;:24;78787:7;78771:24;;;;;;;;;;;78764:31;;;78806:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;77822:1008;;;77751:1079;:::o;75255:221::-;75340:14;75357:20;75374:2;75357:16;:20::i;:::-;75340:37;;75415:7;75388:12;:16;75401:2;75388:16;;;;;;;;;;;;;;;:24;75405:6;75388:24;;;;;;;;;;;:34;;;;75462:6;75433:17;:26;75451:7;75433:26;;;;;;;;;;;:35;;;;75329:147;75255:221;;:::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:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:118::-;4977:24;4995:5;4977:24;:::i;:::-;4972:3;4965:37;4890:118;;:::o;5014:222::-;5107:4;5145:2;5134:9;5130:18;5122:26;;5158:71;5226:1;5215:9;5211:17;5202:6;5158:71;:::i;:::-;5014:222;;;;:::o;5242:619::-;5319:6;5327;5335;5384:2;5372:9;5363:7;5359:23;5355:32;5352:119;;;5390:79;;:::i;:::-;5352:119;5510:1;5535:53;5580:7;5571:6;5560:9;5556:22;5535:53;:::i;:::-;5525:63;;5481:117;5637:2;5663:53;5708:7;5699:6;5688:9;5684:22;5663:53;:::i;:::-;5653:63;;5608:118;5765:2;5791:53;5836:7;5827:6;5816:9;5812:22;5791:53;:::i;:::-;5781:63;;5736:118;5242:619;;;;;:::o;5867:329::-;5926:6;5975:2;5963:9;5954:7;5950:23;5946:32;5943:119;;;5981:79;;:::i;:::-;5943:119;6101:1;6126:53;6171:7;6162:6;6151:9;6147:22;6126:53;:::i;:::-;6116:63;;6072:117;5867:329;;;;:::o;6202:114::-;6269:6;6303:5;6297:12;6287:22;;6202:114;;;:::o;6322:184::-;6421:11;6455:6;6450:3;6443:19;6495:4;6490:3;6486:14;6471:29;;6322:184;;;;:::o;6512:132::-;6579:4;6602:3;6594:11;;6632:4;6627:3;6623:14;6615:22;;6512:132;;;:::o;6650:108::-;6727:24;6745:5;6727:24;:::i;:::-;6722:3;6715:37;6650:108;;:::o;6764:179::-;6833:10;6854:46;6896:3;6888:6;6854:46;:::i;:::-;6932:4;6927:3;6923:14;6909:28;;6764:179;;;;:::o;6949:113::-;7019:4;7051;7046:3;7042:14;7034:22;;6949:113;;;:::o;7098:732::-;7217:3;7246:54;7294:5;7246:54;:::i;:::-;7316:86;7395:6;7390:3;7316:86;:::i;:::-;7309:93;;7426:56;7476:5;7426:56;:::i;:::-;7505:7;7536:1;7521:284;7546:6;7543:1;7540:13;7521:284;;;7622:6;7616:13;7649:63;7708:3;7693:13;7649:63;:::i;:::-;7642:70;;7735:60;7788:6;7735:60;:::i;:::-;7725:70;;7581:224;7568:1;7565;7561:9;7556:14;;7521:284;;;7525:14;7821:3;7814:10;;7222:608;;;7098:732;;;;:::o;7836:373::-;7979:4;8017:2;8006:9;8002:18;7994:26;;8066:9;8060:4;8056:20;8052:1;8041:9;8037:17;8030:47;8094:108;8197:4;8188:6;8094:108;:::i;:::-;8086:116;;7836:373;;;;:::o;8215:117::-;8324:1;8321;8314:12;8338:117;8447:1;8444;8437:12;8461:180;8509:77;8506:1;8499:88;8606:4;8603:1;8596:15;8630:4;8627:1;8620:15;8647:281;8730:27;8752:4;8730:27;:::i;:::-;8722:6;8718:40;8860:6;8848:10;8845:22;8824:18;8812:10;8809:34;8806:62;8803:88;;;8871:18;;:::i;:::-;8803:88;8911:10;8907:2;8900:22;8690:238;8647:281;;:::o;8934:129::-;8968:6;8995:20;;:::i;:::-;8985:30;;9024:33;9052:4;9044:6;9024:33;:::i;:::-;8934:129;;;:::o;9069:308::-;9131:4;9221:18;9213:6;9210:30;9207:56;;;9243:18;;:::i;:::-;9207:56;9281:29;9303:6;9281:29;:::i;:::-;9273:37;;9365:4;9359;9355:15;9347:23;;9069:308;;;:::o;9383:146::-;9480:6;9475:3;9470;9457:30;9521:1;9512:6;9507:3;9503:16;9496:27;9383:146;;;:::o;9535:425::-;9613:5;9638:66;9654:49;9696:6;9654:49;:::i;:::-;9638:66;:::i;:::-;9629:75;;9727:6;9720:5;9713:21;9765:4;9758:5;9754:16;9803:3;9794:6;9789:3;9785:16;9782:25;9779:112;;;9810:79;;:::i;:::-;9779:112;9900:54;9947:6;9942:3;9937;9900:54;:::i;:::-;9619:341;9535:425;;;;;:::o;9980:340::-;10036:5;10085:3;10078:4;10070:6;10066:17;10062:27;10052:122;;10093:79;;:::i;:::-;10052:122;10210:6;10197:20;10235:79;10310:3;10302:6;10295:4;10287:6;10283:17;10235:79;:::i;:::-;10226:88;;10042:278;9980:340;;;;:::o;10326:509::-;10395:6;10444:2;10432:9;10423:7;10419:23;10415:32;10412:119;;;10450:79;;:::i;:::-;10412:119;10598:1;10587:9;10583:17;10570:31;10628:18;10620:6;10617:30;10614:117;;;10650:79;;:::i;:::-;10614:117;10755:63;10810:7;10801:6;10790:9;10786:22;10755:63;:::i;:::-;10745:73;;10541:287;10326:509;;;;:::o;10841:117::-;10950:1;10947;10940:12;10964:117;11073:1;11070;11063:12;11104:568;11177:8;11187:6;11237:3;11230:4;11222:6;11218:17;11214:27;11204:122;;11245:79;;:::i;:::-;11204:122;11358:6;11345:20;11335:30;;11388:18;11380:6;11377:30;11374:117;;;11410:79;;:::i;:::-;11374:117;11524:4;11516:6;11512:17;11500:29;;11578:3;11570:4;11562:6;11558:17;11548:8;11544:32;11541:41;11538:128;;;11585:79;;:::i;:::-;11538:128;11104:568;;;;;:::o;11678:559::-;11764:6;11772;11821:2;11809:9;11800:7;11796:23;11792:32;11789:119;;;11827:79;;:::i;:::-;11789:119;11975:1;11964:9;11960:17;11947:31;12005:18;11997:6;11994:30;11991:117;;;12027:79;;:::i;:::-;11991:117;12140:80;12212:7;12203:6;12192:9;12188:22;12140:80;:::i;:::-;12122:98;;;;11918:312;11678:559;;;;;:::o;12243:116::-;12313:21;12328:5;12313:21;:::i;:::-;12306:5;12303:32;12293:60;;12349:1;12346;12339:12;12293:60;12243:116;:::o;12365:133::-;12408:5;12446:6;12433:20;12424:29;;12462:30;12486:5;12462:30;:::i;:::-;12365:133;;;;:::o;12504:468::-;12569:6;12577;12626:2;12614:9;12605:7;12601:23;12597:32;12594:119;;;12632:79;;:::i;:::-;12594:119;12752:1;12777:53;12822:7;12813:6;12802:9;12798:22;12777:53;:::i;:::-;12767:63;;12723:117;12879:2;12905:50;12947:7;12938:6;12927:9;12923:22;12905:50;:::i;:::-;12895:60;;12850:115;12504:468;;;;;:::o;12978:307::-;13039:4;13129:18;13121:6;13118:30;13115:56;;;13151:18;;:::i;:::-;13115:56;13189:29;13211:6;13189:29;:::i;:::-;13181:37;;13273:4;13267;13263:15;13255:23;;12978:307;;;:::o;13291:423::-;13368:5;13393:65;13409:48;13450:6;13409:48;:::i;:::-;13393:65;:::i;:::-;13384:74;;13481:6;13474:5;13467:21;13519:4;13512:5;13508:16;13557:3;13548:6;13543:3;13539:16;13536:25;13533:112;;;13564:79;;:::i;:::-;13533:112;13654:54;13701:6;13696:3;13691;13654:54;:::i;:::-;13374:340;13291:423;;;;;:::o;13733:338::-;13788:5;13837:3;13830:4;13822:6;13818:17;13814:27;13804:122;;13845:79;;:::i;:::-;13804:122;13962:6;13949:20;13987:78;14061:3;14053:6;14046:4;14038:6;14034:17;13987:78;:::i;:::-;13978:87;;13794:277;13733:338;;;;:::o;14077:943::-;14172:6;14180;14188;14196;14245:3;14233:9;14224:7;14220:23;14216:33;14213:120;;;14252:79;;:::i;:::-;14213:120;14372:1;14397:53;14442:7;14433:6;14422:9;14418:22;14397:53;:::i;:::-;14387:63;;14343:117;14499:2;14525:53;14570:7;14561:6;14550:9;14546:22;14525:53;:::i;:::-;14515:63;;14470:118;14627:2;14653:53;14698:7;14689:6;14678:9;14674:22;14653:53;:::i;:::-;14643:63;;14598:118;14783:2;14772:9;14768:18;14755:32;14814:18;14806:6;14803:30;14800:117;;;14836:79;;:::i;:::-;14800:117;14941:62;14995:7;14986:6;14975:9;14971:22;14941:62;:::i;:::-;14931:72;;14726:287;14077:943;;;;;;;:::o;15026:474::-;15094:6;15102;15151:2;15139:9;15130:7;15126:23;15122:32;15119:119;;;15157:79;;:::i;:::-;15119:119;15277:1;15302:53;15347:7;15338:6;15327:9;15323:22;15302:53;:::i;:::-;15292:63;;15248:117;15404:2;15430:53;15475:7;15466:6;15455:9;15451:22;15430:53;:::i;:::-;15420:63;;15375:118;15026:474;;;;;:::o;15506:180::-;15554:77;15551:1;15544:88;15651:4;15648:1;15641:15;15675:4;15672:1;15665:15;15692:320;15736:6;15773:1;15767:4;15763:12;15753:22;;15820:1;15814:4;15810:12;15841:18;15831:81;;15897:4;15889:6;15885:17;15875:27;;15831:81;15959:2;15951:6;15948:14;15928:18;15925:38;15922:84;;15978:18;;:::i;:::-;15922:84;15743:269;15692:320;;;:::o;16018:220::-;16158:34;16154:1;16146:6;16142:14;16135:58;16227:3;16222:2;16214:6;16210:15;16203:28;16018:220;:::o;16244:366::-;16386:3;16407:67;16471:2;16466:3;16407:67;:::i;:::-;16400:74;;16483:93;16572:3;16483:93;:::i;:::-;16601:2;16596:3;16592:12;16585:19;;16244:366;;;:::o;16616:419::-;16782:4;16820:2;16809:9;16805:18;16797:26;;16869:9;16863:4;16859:20;16855:1;16844:9;16840:17;16833:47;16897:131;17023:4;16897:131;:::i;:::-;16889:139;;16616:419;;;:::o;17041:248::-;17181:34;17177:1;17169:6;17165:14;17158:58;17250:31;17245:2;17237:6;17233:15;17226:56;17041:248;:::o;17295:366::-;17437:3;17458:67;17522:2;17517:3;17458:67;:::i;:::-;17451:74;;17534:93;17623:3;17534:93;:::i;:::-;17652:2;17647:3;17643:12;17636:19;;17295:366;;;:::o;17667:419::-;17833:4;17871:2;17860:9;17856:18;17848:26;;17920:9;17914:4;17910:20;17906:1;17895:9;17891:17;17884:47;17948:131;18074:4;17948:131;:::i;:::-;17940:139;;17667:419;;;:::o;18092:178::-;18232:30;18228:1;18220:6;18216:14;18209:54;18092:178;:::o;18276:366::-;18418:3;18439:67;18503:2;18498:3;18439:67;:::i;:::-;18432:74;;18515:93;18604:3;18515:93;:::i;:::-;18633:2;18628:3;18624:12;18617:19;;18276:366;;;:::o;18648:419::-;18814:4;18852:2;18841:9;18837:18;18829:26;;18901:9;18895:4;18891:20;18887:1;18876:9;18872:17;18865:47;18929:131;19055:4;18929:131;:::i;:::-;18921:139;;18648:419;;;:::o;19073:173::-;19213:25;19209:1;19201:6;19197:14;19190:49;19073:173;:::o;19252:366::-;19394:3;19415:67;19479:2;19474:3;19415:67;:::i;:::-;19408:74;;19491:93;19580:3;19491:93;:::i;:::-;19609:2;19604:3;19600:12;19593:19;;19252:366;;;:::o;19624:419::-;19790:4;19828:2;19817:9;19813:18;19805:26;;19877:9;19871:4;19867:20;19863:1;19852:9;19848:17;19841:47;19905:131;20031:4;19905:131;:::i;:::-;19897:139;;19624:419;;;:::o;20049:179::-;20189:31;20185:1;20177:6;20173:14;20166:55;20049:179;:::o;20234:366::-;20376:3;20397:67;20461:2;20456:3;20397:67;:::i;:::-;20390:74;;20473:93;20562:3;20473:93;:::i;:::-;20591:2;20586:3;20582:12;20575:19;;20234:366;;;:::o;20606:419::-;20772:4;20810:2;20799:9;20795:18;20787:26;;20859:9;20853:4;20849:20;20845:1;20834:9;20830:17;20823:47;20887:131;21013:4;20887:131;:::i;:::-;20879:139;;20606:419;;;:::o;21031:180::-;21079:77;21076:1;21069:88;21176:4;21173:1;21166:15;21200:4;21197:1;21190:15;21217:233;21256:3;21279:24;21297:5;21279:24;:::i;:::-;21270:33;;21325:66;21318:5;21315:77;21312:103;;21395:18;;:::i;:::-;21312:103;21442:1;21435:5;21431:13;21424:20;;21217:233;;;:::o;21456:232::-;21596:34;21592:1;21584:6;21580:14;21573:58;21665:15;21660:2;21652:6;21648:15;21641:40;21456:232;:::o;21694:366::-;21836:3;21857:67;21921:2;21916:3;21857:67;:::i;:::-;21850:74;;21933:93;22022:3;21933:93;:::i;:::-;22051:2;22046:3;22042:12;22035:19;;21694:366;;;:::o;22066:419::-;22232:4;22270:2;22259:9;22255:18;22247:26;;22319:9;22313:4;22309:20;22305:1;22294:9;22290:17;22283:47;22347:131;22473:4;22347:131;:::i;:::-;22339:139;;22066:419;;;:::o;22491:180::-;22539:77;22536:1;22529:88;22636:4;22633:1;22626:15;22660:4;22657:1;22650:15;22677:230;22817:34;22813:1;22805:6;22801:14;22794:58;22886:13;22881:2;22873:6;22869:15;22862:38;22677:230;:::o;22913:366::-;23055:3;23076:67;23140:2;23135:3;23076:67;:::i;:::-;23069:74;;23152:93;23241:3;23152:93;:::i;:::-;23270:2;23265:3;23261:12;23254:19;;22913:366;;;:::o;23285:419::-;23451:4;23489:2;23478:9;23474:18;23466:26;;23538:9;23532:4;23528:20;23524:1;23513:9;23509:17;23502:47;23566:131;23692:4;23566:131;:::i;:::-;23558:139;;23285:419;;;:::o;23710:231::-;23850:34;23846:1;23838:6;23834:14;23827:58;23919:14;23914:2;23906:6;23902:15;23895:39;23710:231;:::o;23947:366::-;24089:3;24110:67;24174:2;24169:3;24110:67;:::i;:::-;24103:74;;24186:93;24275:3;24186:93;:::i;:::-;24304:2;24299:3;24295:12;24288:19;;23947:366;;;:::o;24319:419::-;24485:4;24523:2;24512:9;24508:18;24500:26;;24572:9;24566:4;24562:20;24558:1;24547:9;24543:17;24536:47;24600:131;24726:4;24600:131;:::i;:::-;24592:139;;24319:419;;;:::o;24744:141::-;24793:4;24816:3;24808:11;;24839:3;24836:1;24829:14;24873:4;24870:1;24860:18;24852:26;;24744:141;;;:::o;24891:93::-;24928:6;24975:2;24970;24963:5;24959:14;24955:23;24945:33;;24891:93;;;:::o;24990:107::-;25034:8;25084:5;25078:4;25074:16;25053:37;;24990:107;;;;:::o;25103:393::-;25172:6;25222:1;25210:10;25206:18;25245:97;25275:66;25264:9;25245:97;:::i;:::-;25363:39;25393:8;25382:9;25363:39;:::i;:::-;25351:51;;25435:4;25431:9;25424:5;25420:21;25411:30;;25484:4;25474:8;25470:19;25463:5;25460:30;25450:40;;25179:317;;25103:393;;;;;:::o;25502:60::-;25530:3;25551:5;25544:12;;25502:60;;;:::o;25568:142::-;25618:9;25651:53;25669:34;25678:24;25696:5;25678:24;:::i;:::-;25669:34;:::i;:::-;25651:53;:::i;:::-;25638:66;;25568:142;;;:::o;25716:75::-;25759:3;25780:5;25773:12;;25716:75;;;:::o;25797:269::-;25907:39;25938:7;25907:39;:::i;:::-;25968:91;26017:41;26041:16;26017:41;:::i;:::-;26009:6;26002:4;25996:11;25968:91;:::i;:::-;25962:4;25955:105;25873:193;25797:269;;;:::o;26072:73::-;26117:3;26072:73;:::o;26151:189::-;26228:32;;:::i;:::-;26269:65;26327:6;26319;26313:4;26269:65;:::i;:::-;26204:136;26151:189;;:::o;26346:186::-;26406:120;26423:3;26416:5;26413:14;26406:120;;;26477:39;26514:1;26507:5;26477:39;:::i;:::-;26450:1;26443:5;26439:13;26430:22;;26406:120;;;26346:186;;:::o;26538:543::-;26639:2;26634:3;26631:11;26628:446;;;26673:38;26705:5;26673:38;:::i;:::-;26757:29;26775:10;26757:29;:::i;:::-;26747:8;26743:44;26940:2;26928:10;26925:18;26922:49;;;26961:8;26946:23;;26922:49;26984:80;27040:22;27058:3;27040:22;:::i;:::-;27030:8;27026:37;27013:11;26984:80;:::i;:::-;26643:431;;26628:446;26538:543;;;:::o;27087:117::-;27141:8;27191:5;27185:4;27181:16;27160:37;;27087:117;;;;:::o;27210:169::-;27254:6;27287:51;27335:1;27331:6;27323:5;27320:1;27316:13;27287:51;:::i;:::-;27283:56;27368:4;27362;27358:15;27348:25;;27261:118;27210:169;;;;:::o;27384:295::-;27460:4;27606:29;27631:3;27625:4;27606:29;:::i;:::-;27598:37;;27668:3;27665:1;27661:11;27655:4;27652:21;27644:29;;27384:295;;;;:::o;27684:1395::-;27801:37;27834:3;27801:37;:::i;:::-;27903:18;27895:6;27892:30;27889:56;;;27925:18;;:::i;:::-;27889:56;27969:38;28001:4;27995:11;27969:38;:::i;:::-;28054:67;28114:6;28106;28100:4;28054:67;:::i;:::-;28148:1;28172:4;28159:17;;28204:2;28196:6;28193:14;28221:1;28216:618;;;;28878:1;28895:6;28892:77;;;28944:9;28939:3;28935:19;28929:26;28920:35;;28892:77;28995:67;29055:6;29048:5;28995:67;:::i;:::-;28989:4;28982:81;28851:222;28186:887;;28216:618;28268:4;28264:9;28256:6;28252:22;28302:37;28334:4;28302:37;:::i;:::-;28361:1;28375:208;28389:7;28386:1;28383:14;28375:208;;;28468:9;28463:3;28459:19;28453:26;28445:6;28438:42;28519:1;28511:6;28507:14;28497:24;;28566:2;28555:9;28551:18;28538:31;;28412:4;28409:1;28405:12;28400:17;;28375:208;;;28611:6;28602:7;28599:19;28596:179;;;28669:9;28664:3;28660:19;28654:26;28712:48;28754:4;28746:6;28742:17;28731:9;28712:48;:::i;:::-;28704:6;28697:64;28619:156;28596:179;28821:1;28817;28809:6;28805:14;28801:22;28795:4;28788:36;28223:611;;;28186:887;;27776:1303;;;27684:1395;;:::o;29085:174::-;29225:26;29221:1;29213:6;29209:14;29202:50;29085:174;:::o;29265:366::-;29407:3;29428:67;29492:2;29487:3;29428:67;:::i;:::-;29421:74;;29504:93;29593:3;29504:93;:::i;:::-;29622:2;29617:3;29613:12;29606:19;;29265:366;;;:::o;29637:419::-;29803:4;29841:2;29830:9;29826:18;29818:26;;29890:9;29884:4;29880:20;29876:1;29865:9;29861:17;29854:47;29918:131;30044:4;29918:131;:::i;:::-;29910:139;;29637:419;;;:::o;30062:228::-;30202:34;30198:1;30190:6;30186:14;30179:58;30271:11;30266:2;30258:6;30254:15;30247:36;30062:228;:::o;30296:366::-;30438:3;30459:67;30523:2;30518:3;30459:67;:::i;:::-;30452:74;;30535:93;30624:3;30535:93;:::i;:::-;30653:2;30648:3;30644:12;30637:19;;30296:366;;;:::o;30668:419::-;30834:4;30872:2;30861:9;30857:18;30849:26;;30921:9;30915:4;30911:20;30907:1;30896:9;30892:17;30885:47;30949:131;31075:4;30949:131;:::i;:::-;30941:139;;30668:419;;;:::o;31093:234::-;31233:34;31229:1;31221:6;31217:14;31210:58;31302:17;31297:2;31289:6;31285:15;31278:42;31093:234;:::o;31333:366::-;31475:3;31496:67;31560:2;31555:3;31496:67;:::i;:::-;31489:74;;31572:93;31661:3;31572:93;:::i;:::-;31690:2;31685:3;31681:12;31674:19;;31333:366;;;:::o;31705:419::-;31871:4;31909:2;31898:9;31894:18;31886:26;;31958:9;31952:4;31948:20;31944:1;31933:9;31929:17;31922:47;31986:131;32112:4;31986:131;:::i;:::-;31978:139;;31705:419;;;:::o;32130:148::-;32232:11;32269:3;32254:18;;32130:148;;;;:::o;32284:390::-;32390:3;32418:39;32451:5;32418:39;:::i;:::-;32473:89;32555:6;32550:3;32473:89;:::i;:::-;32466:96;;32571:65;32629:6;32624:3;32617:4;32610:5;32606:16;32571:65;:::i;:::-;32661:6;32656:3;32652:16;32645:23;;32394:280;32284:390;;;;:::o;32680:155::-;32820:7;32816:1;32808:6;32804:14;32797:31;32680:155;:::o;32841:400::-;33001:3;33022:84;33104:1;33099:3;33022:84;:::i;:::-;33015:91;;33115:93;33204:3;33115:93;:::i;:::-;33233:1;33228:3;33224:11;33217:18;;32841:400;;;:::o;33247:701::-;33528:3;33550:95;33641:3;33632:6;33550:95;:::i;:::-;33543:102;;33662:95;33753:3;33744:6;33662:95;:::i;:::-;33655:102;;33774:148;33918:3;33774:148;:::i;:::-;33767:155;;33939:3;33932:10;;33247:701;;;;;:::o;33954:225::-;34094:34;34090:1;34082:6;34078:14;34071:58;34163:8;34158:2;34150:6;34146:15;34139:33;33954:225;:::o;34185:366::-;34327:3;34348:67;34412:2;34407:3;34348:67;:::i;:::-;34341:74;;34424:93;34513:3;34424:93;:::i;:::-;34542:2;34537:3;34533:12;34526:19;;34185:366;;;:::o;34557:419::-;34723:4;34761:2;34750:9;34746:18;34738:26;;34810:9;34804:4;34800:20;34796:1;34785:9;34781:17;34774:47;34838:131;34964:4;34838:131;:::i;:::-;34830:139;;34557:419;;;:::o;34982:166::-;35122:18;35118:1;35110:6;35106:14;35099:42;34982:166;:::o;35154:366::-;35296:3;35317:67;35381:2;35376:3;35317:67;:::i;:::-;35310:74;;35393:93;35482:3;35393:93;:::i;:::-;35511:2;35506:3;35502:12;35495:19;;35154:366;;;:::o;35526:419::-;35692:4;35730:2;35719:9;35715:18;35707:26;;35779:9;35773:4;35769:20;35765:1;35754:9;35750:17;35743:47;35807:131;35933:4;35807:131;:::i;:::-;35799:139;;35526:419;;;:::o;35951:224::-;36091:34;36087:1;36079:6;36075:14;36068:58;36160:7;36155:2;36147:6;36143:15;36136:32;35951:224;:::o;36181:366::-;36323:3;36344:67;36408:2;36403:3;36344:67;:::i;:::-;36337:74;;36420:93;36509:3;36420:93;:::i;:::-;36538:2;36533:3;36529:12;36522:19;;36181:366;;;:::o;36553:419::-;36719:4;36757:2;36746:9;36742:18;36734:26;;36806:9;36800:4;36796:20;36792:1;36781:9;36777:17;36770:47;36834:131;36960:4;36834:131;:::i;:::-;36826:139;;36553:419;;;:::o;36978:223::-;37118:34;37114:1;37106:6;37102:14;37095:58;37187:6;37182:2;37174:6;37170:15;37163:31;36978:223;:::o;37207:366::-;37349:3;37370:67;37434:2;37429:3;37370:67;:::i;:::-;37363:74;;37446:93;37535:3;37446:93;:::i;:::-;37564:2;37559:3;37555:12;37548:19;;37207:366;;;:::o;37579:419::-;37745:4;37783:2;37772:9;37768:18;37760:26;;37832:9;37826:4;37822:20;37818:1;37807:9;37803:17;37796:47;37860:131;37986:4;37860:131;:::i;:::-;37852:139;;37579:419;;;:::o;38004:182::-;38144:34;38140:1;38132:6;38128:14;38121:58;38004:182;:::o;38192:366::-;38334:3;38355:67;38419:2;38414:3;38355:67;:::i;:::-;38348:74;;38431:93;38520:3;38431:93;:::i;:::-;38549:2;38544:3;38540:12;38533:19;;38192:366;;;:::o;38564:419::-;38730:4;38768:2;38757:9;38753:18;38745:26;;38817:9;38811:4;38807:20;38803:1;38792:9;38788:17;38781:47;38845:131;38971:4;38845:131;:::i;:::-;38837:139;;38564:419;;;:::o;38989:175::-;39129:27;39125:1;39117:6;39113:14;39106:51;38989:175;:::o;39170:366::-;39312:3;39333:67;39397:2;39392:3;39333:67;:::i;:::-;39326:74;;39409:93;39498:3;39409:93;:::i;:::-;39527:2;39522:3;39518:12;39511:19;;39170:366;;;:::o;39542:419::-;39708:4;39746:2;39735:9;39731:18;39723:26;;39795:9;39789:4;39785:20;39781:1;39770:9;39766:17;39759:47;39823:131;39949:4;39823:131;:::i;:::-;39815:139;;39542:419;;;:::o;39967:237::-;40107:34;40103:1;40095:6;40091:14;40084:58;40176:20;40171:2;40163:6;40159:15;40152:45;39967:237;:::o;40210:366::-;40352:3;40373:67;40437:2;40432:3;40373:67;:::i;:::-;40366:74;;40449:93;40538:3;40449:93;:::i;:::-;40567:2;40562:3;40558:12;40551:19;;40210:366;;;:::o;40582:419::-;40748:4;40786:2;40775:9;40771:18;40763:26;;40835:9;40829:4;40825:20;40821:1;40810:9;40806:17;40799:47;40863:131;40989:4;40863:131;:::i;:::-;40855:139;;40582:419;;;:::o;41007:180::-;41055:77;41052:1;41045:88;41152:4;41149:1;41142:15;41176:4;41173:1;41166:15;41193:170;41333:22;41329:1;41321:6;41317:14;41310:46;41193:170;:::o;41369:366::-;41511:3;41532:67;41596:2;41591:3;41532:67;:::i;:::-;41525:74;;41608:93;41697:3;41608:93;:::i;:::-;41726:2;41721:3;41717:12;41710:19;;41369:366;;;:::o;41741:419::-;41907:4;41945:2;41934:9;41930:18;41922:26;;41994:9;41988:4;41984:20;41980:1;41969:9;41965:17;41958:47;42022:131;42148:4;42022:131;:::i;:::-;42014:139;;41741:419;;;:::o;42166:98::-;42217:6;42251:5;42245:12;42235:22;;42166:98;;;:::o;42270:168::-;42353:11;42387:6;42382:3;42375:19;42427:4;42422:3;42418:14;42403:29;;42270:168;;;;:::o;42444:373::-;42530:3;42558:38;42590:5;42558:38;:::i;:::-;42612:70;42675:6;42670:3;42612:70;:::i;:::-;42605:77;;42691:65;42749:6;42744:3;42737:4;42730:5;42726:16;42691:65;:::i;:::-;42781:29;42803:6;42781:29;:::i;:::-;42776:3;42772:39;42765:46;;42534:283;42444:373;;;;:::o;42823:640::-;43018:4;43056:3;43045:9;43041:19;43033:27;;43070:71;43138:1;43127:9;43123:17;43114:6;43070:71;:::i;:::-;43151:72;43219:2;43208:9;43204:18;43195:6;43151:72;:::i;:::-;43233;43301:2;43290:9;43286:18;43277:6;43233:72;:::i;:::-;43352:9;43346:4;43342:20;43337:2;43326:9;43322:18;43315:48;43380:76;43451:4;43442:6;43380:76;:::i;:::-;43372:84;;42823:640;;;;;;;:::o;43469:141::-;43525:5;43556:6;43550:13;43541:22;;43572:32;43598:5;43572:32;:::i;:::-;43469:141;;;;:::o;43616:349::-;43685:6;43734:2;43722:9;43713:7;43709:23;43705:32;43702:119;;;43740:79;;:::i;:::-;43702:119;43860:1;43885:63;43940:7;43931:6;43920:9;43916:22;43885:63;:::i;:::-;43875:73;;43831:127;43616:349;;;;:::o;43971:182::-;44111:34;44107:1;44099:6;44095:14;44088:58;43971:182;:::o;44159:366::-;44301:3;44322:67;44386:2;44381:3;44322:67;:::i;:::-;44315:74;;44398:93;44487:3;44398:93;:::i;:::-;44516:2;44511:3;44507:12;44500:19;;44159:366;;;:::o;44531:419::-;44697:4;44735:2;44724:9;44720:18;44712:26;;44784:9;44778:4;44774:20;44770:1;44759:9;44755:17;44748:47;44812:131;44938:4;44812:131;:::i;:::-;44804:139;;44531:419;;;:::o;44956:178::-;45096:30;45092:1;45084:6;45080:14;45073:54;44956:178;:::o;45140:366::-;45282:3;45303:67;45367:2;45362:3;45303:67;:::i;:::-;45296:74;;45379:93;45468:3;45379:93;:::i;:::-;45497:2;45492:3;45488:12;45481:19;;45140:366;;;:::o;45512:419::-;45678:4;45716:2;45705:9;45701:18;45693:26;;45765:9;45759:4;45755:20;45751:1;45740:9;45736:17;45729:47;45793:131;45919:4;45793:131;:::i;:::-;45785:139;;45512:419;;;:::o;45937:230::-;46077:34;46073:1;46065:6;46061:14;46054:58;46146:13;46141:2;46133:6;46129:15;46122:38;45937:230;:::o;46173:366::-;46315:3;46336:67;46400:2;46395:3;46336:67;:::i;:::-;46329:74;;46412:93;46501:3;46412:93;:::i;:::-;46530:2;46525:3;46521:12;46514:19;;46173:366;;;:::o;46545:419::-;46711:4;46749:2;46738:9;46734:18;46726:26;;46798:9;46792:4;46788:20;46784:1;46773:9;46769:17;46762:47;46826:131;46952:4;46826:131;:::i;:::-;46818:139;;46545:419;;;:::o;46970:240::-;47110:34;47106:1;47098:6;47094:14;47087:58;47179:23;47174:2;47166:6;47162:15;47155:48;46970:240;:::o;47216:366::-;47358:3;47379:67;47443:2;47438:3;47379:67;:::i;:::-;47372:74;;47455:93;47544:3;47455:93;:::i;:::-;47573:2;47568:3;47564:12;47557:19;;47216:366;;;:::o;47588:419::-;47754:4;47792:2;47781:9;47777:18;47769:26;;47841:9;47835:4;47831:20;47827:1;47816:9;47812:17;47805:47;47869:131;47995:4;47869:131;:::i;:::-;47861:139;;47588:419;;;:::o;48013:194::-;48053:4;48073:20;48091:1;48073:20;:::i;:::-;48068:25;;48107:20;48125:1;48107:20;:::i;:::-;48102:25;;48151:1;48148;48144:9;48136:17;;48175:1;48169:4;48166:11;48163:37;;;48180:18;;:::i;:::-;48163:37;48013:194;;;;:::o;48213:180::-;48261:77;48258:1;48251:88;48358:4;48355:1;48348:15;48382:4;48379:1;48372:15
Swarm Source
ipfs://6b2a48bc7fadb5ebd0d4958b35f4572e3d445e7cfa65eaeb044e38e988c0bd88
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
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.