Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
ShellzOrbV2
Compiler Version
v0.8.16+commit.07a7930e
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-12-15 */ // File: operator-filter-registry/src/IOperatorFilterRegistry.sol pragma solidity ^0.8.13; interface IOperatorFilterRegistry { function isOperatorAllowed(address registrant, address operator) external view returns (bool); function register(address registrant) external; function registerAndSubscribe(address registrant, address subscription) external; function registerAndCopyEntries(address registrant, address registrantToCopy) external; function unregister(address addr) external; function updateOperator(address registrant, address operator, bool filtered) external; function updateOperators(address registrant, address[] calldata operators, bool filtered) external; function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external; function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external; function subscribe(address registrant, address registrantToSubscribe) external; function unsubscribe(address registrant, bool copyExistingEntries) external; function subscriptionOf(address addr) external returns (address registrant); function subscribers(address registrant) external returns (address[] memory); function subscriberAt(address registrant, uint256 index) external returns (address); function copyEntriesOf(address registrant, address registrantToCopy) external; function isOperatorFiltered(address registrant, address operator) external returns (bool); function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool); function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool); function filteredOperators(address addr) external returns (address[] memory); function filteredCodeHashes(address addr) external returns (bytes32[] memory); function filteredOperatorAt(address registrant, uint256 index) external returns (address); function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32); function isRegistered(address addr) external returns (bool); function codeHashOf(address addr) external returns (bytes32); } // File: @openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.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 AddressUpgradeable { /** * @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 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-upgradeable/proxy/utils/Initializable.sol // OpenZeppelin Contracts (last updated v4.8.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.2; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ``` * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. * * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a * constructor. * * Emits an {Initialized} event. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _initialized = 1; if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * A reinitializer may be used after the original initialization step. This is essential to configure modules that * are added through upgrades and that require initialization. * * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` * cannot be nested. If one is invoked in the context of another, execution will revert. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. * * WARNING: setting the version to 255 will prevent any future reinitialization. * * Emits an {Initialized} event. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. * * Emits an {Initialized} event the first time it is successfully executed. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized < type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } /** * @dev Internal function that returns the initialized version. Returns `_initialized` */ function _getInitializedVersion() internal view returns (uint8) { return _initialized; } /** * @dev Internal function that returns the initialized version. Returns `_initializing` */ function _isInitializing() internal view returns (bool) { return _initializing; } } // File: operator-filter-registry/src/upgradeable/OperatorFiltererUpgradeable.sol pragma solidity ^0.8.13; abstract contract OperatorFiltererUpgradeable is Initializable { error OperatorNotAllowed(address operator); IOperatorFilterRegistry constant operatorFilterRegistry = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E); function __OperatorFilterer_init(address subscriptionOrRegistrantToCopy, bool subscribe) internal onlyInitializing { // If an inheriting token contract is deployed to a network without the registry deployed, the modifier // will not revert, but the contract will need to be registered with the registry once it is deployed in // order for the modifier to filter addresses. if (address(operatorFilterRegistry).code.length > 0) { if (!operatorFilterRegistry.isRegistered(address(this))) { if (subscribe) { operatorFilterRegistry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy); } else { if (subscriptionOrRegistrantToCopy != address(0)) { operatorFilterRegistry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy); } else { operatorFilterRegistry.register(address(this)); } } } } } modifier onlyAllowedOperator(address from) virtual { // Check registry code length to facilitate testing in environments without a deployed registry. if (address(operatorFilterRegistry).code.length > 0) { // Allow spending tokens from addresses with balance // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred // from an EOA. if (from == msg.sender) { _; return; } if (!operatorFilterRegistry.isOperatorAllowed(address(this), msg.sender)) { revert OperatorNotAllowed(msg.sender); } } _; } modifier onlyAllowedOperatorApproval(address operator) virtual { // Check registry code length to facilitate testing in environments without a deployed registry. if (address(operatorFilterRegistry).code.length > 0) { if (!operatorFilterRegistry.isOperatorAllowed(address(this), operator)) { revert OperatorNotAllowed(operator); } } _; } } // File: operator-filter-registry/src/upgradeable/DefaultOperatorFiltererUpgradeable.sol pragma solidity ^0.8.13; abstract contract DefaultOperatorFiltererUpgradeable is OperatorFiltererUpgradeable { address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6); function __DefaultOperatorFilterer_init() internal onlyInitializing { OperatorFiltererUpgradeable.__OperatorFilterer_init(DEFAULT_SUBSCRIPTION, true); } } // File: @openzeppelin/contracts-upgradeable/utils/math/MathUpgradeable.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 MathUpgradeable { 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-upgradeable/utils/StringsUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library StringsUpgradeable { 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 = MathUpgradeable.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, MathUpgradeable.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-upgradeable/utils/cryptography/ECDSAUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.0; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSAUpgradeable { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV // Deprecated in v4.8 } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. /// @solidity memory-safe-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else { return (address(0), RecoverError.InvalidSignatureLength); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.3._ */ function tryRecover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address, RecoverError) { bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. * * _Available since v4.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } } // File: @openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.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 ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File: @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.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 OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable_init_unchained() internal onlyInitializing { _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); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } // File: @openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.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 IERC165Upgradeable { /** * @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-upgradeable/interfaces/IERC2981Upgradeable.sol // OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol) pragma solidity ^0.8.0; /** * @dev Interface for the NFT Royalty Standard. * * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal * support for royalty payments across all NFT marketplaces and ecosystem participants. * * _Available since v4.5._ */ interface IERC2981Upgradeable is IERC165Upgradeable { /** * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of * exchange. The royalty amount is denominated and should be paid in that same unit of exchange. */ function royaltyInfo(uint256 tokenId, uint256 salePrice) external view returns (address receiver, uint256 royaltyAmount); } // File: @openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.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 ERC165Upgradeable is Initializable, IERC165Upgradeable { function __ERC165_init() internal onlyInitializing { } function __ERC165_init_unchained() internal onlyInitializing { } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165Upgradeable).interfaceId; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } // File: @openzeppelin/contracts-upgradeable/token/common/ERC2981Upgradeable.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information. * * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first. * * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the * fee is specified in basis points by default. * * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported. * * _Available since v4.5._ */ abstract contract ERC2981Upgradeable is Initializable, IERC2981Upgradeable, ERC165Upgradeable { function __ERC2981_init() internal onlyInitializing { } function __ERC2981_init_unchained() internal onlyInitializing { } struct RoyaltyInfo { address receiver; uint96 royaltyFraction; } RoyaltyInfo private _defaultRoyaltyInfo; mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165Upgradeable, ERC165Upgradeable) returns (bool) { return interfaceId == type(IERC2981Upgradeable).interfaceId || super.supportsInterface(interfaceId); } /** * @inheritdoc IERC2981Upgradeable */ function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) { RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId]; if (royalty.receiver == address(0)) { royalty = _defaultRoyaltyInfo; } uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator(); return (royalty.receiver, royaltyAmount); } /** * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an * override. */ function _feeDenominator() internal pure virtual returns (uint96) { return 10000; } /** * @dev Sets the royalty information that all ids in this contract will default to. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual { require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice"); require(receiver != address(0), "ERC2981: invalid receiver"); _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Removes default royalty information. */ function _deleteDefaultRoyalty() internal virtual { delete _defaultRoyaltyInfo; } /** * @dev Sets the royalty information for a specific token id, overriding the global default. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setTokenRoyalty( uint256 tokenId, address receiver, uint96 feeNumerator ) internal virtual { require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice"); require(receiver != address(0), "ERC2981: Invalid parameters"); _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Resets royalty information for the token id back to the global default. */ function _resetTokenRoyalty(uint256 tokenId) internal virtual { delete _tokenRoyaltyInfo[tokenId]; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[48] private __gap; } // File: @openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol // OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuardUpgradeable is Initializable { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; function __ReentrancyGuard_init() internal onlyInitializing { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal onlyInitializing { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { // On the first call to nonReentrant, _status will be _NOT_ENTERED require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; } function _nonReentrantAfter() private { // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } // File: @openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.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 IERC721Upgradeable is IERC165Upgradeable { /** * @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/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-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.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 IERC721MetadataUpgradeable is IERC721Upgradeable { /** * @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-upgradeable/token/ERC721/extensions/IERC721EnumerableUpgradeable.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 IERC721EnumerableUpgradeable is IERC721Upgradeable { /** * @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: solidity-bits/contracts/BitScan.sol /** _____ ___ ___ __ ____ _ __ / ___/____ / (_)___/ (_) /___ __ / __ )(_) /______ \__ \/ __ \/ / / __ / / __/ / / / / __ / / __/ ___/ ___/ / /_/ / / / /_/ / / /_/ /_/ / / /_/ / / /_(__ ) /____/\____/_/_/\__,_/_/\__/\__, / /_____/_/\__/____/ /____/ - npm: https://www.npmjs.com/package/solidity-bits - github: https://github.com/estarriolvetch/solidity-bits */ pragma solidity ^0.8.0; library BitScan { uint256 constant private DEBRUIJN_256 = 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff; bytes constant private LOOKUP_TABLE_256 = hex"0001020903110a19042112290b311a3905412245134d2a550c5d32651b6d3a7506264262237d468514804e8d2b95569d0d495ea533a966b11c886eb93bc176c9071727374353637324837e9b47af86c7155181ad4fd18ed32c9096db57d59ee30e2e4a6a5f92a6be3498aae067ddb2eb1d5989b56fd7baf33ca0c2ee77e5caf7ff0810182028303840444c545c646c7425617c847f8c949c48a4a8b087b8c0c816365272829aaec650acd0d28fdad4e22d6991bd97dfdcea58b4d6f29fede4f6fe0f1f2f3f4b5b6b607b8b93a3a7b7bf357199c5abcfd9e168bcdee9b3f1ecf5fd1e3e5a7a8aa2b670c4ced8bbe8f0f4fc3d79a1c3cde7effb78cce6facbf9f8"; /** @dev Isolate the least significant set bit. */ function isolateLS1B256(uint256 bb) pure internal returns (uint256) { require(bb > 0); unchecked { return bb & (0 - bb); } } /** @dev Isolate the most significant set bit. */ function isolateMS1B256(uint256 bb) pure internal returns (uint256) { require(bb > 0); unchecked { bb |= bb >> 128; bb |= bb >> 64; bb |= bb >> 32; bb |= bb >> 16; bb |= bb >> 8; bb |= bb >> 4; bb |= bb >> 2; bb |= bb >> 1; return (bb >> 1) + 1; } } /** @dev Find the index of the lest significant set bit. (trailing zero count) */ function bitScanForward256(uint256 bb) pure internal returns (uint8) { unchecked { return uint8(LOOKUP_TABLE_256[(isolateLS1B256(bb) * DEBRUIJN_256) >> 248]); } } /** @dev Find the index of the most significant set bit. */ function bitScanReverse256(uint256 bb) pure internal returns (uint8) { unchecked { return 255 - uint8(LOOKUP_TABLE_256[((isolateMS1B256(bb) * DEBRUIJN_256) >> 248)]); } } function log2(uint256 bb) pure internal returns (uint8) { unchecked { return uint8(LOOKUP_TABLE_256[(isolateMS1B256(bb) * DEBRUIJN_256) >> 248]); } } } // File: solidity-bits/contracts/BitMaps.sol /** _____ ___ ___ __ ____ _ __ / ___/____ / (_)___/ (_) /___ __ / __ )(_) /______ \__ \/ __ \/ / / __ / / __/ / / / / __ / / __/ ___/ ___/ / /_/ / / / /_/ / / /_/ /_/ / / /_/ / / /_(__ ) /____/\____/_/_/\__,_/_/\__/\__, / /_____/_/\__/____/ /____/ - npm: https://www.npmjs.com/package/solidity-bits - github: https://github.com/estarriolvetch/solidity-bits */ pragma solidity ^0.8.0; /** * @dev This Library is a modified version of Openzeppelin's BitMaps library. * Functions of finding the index of the closest set bit from a given index are added. * The indexing of each bucket is modifed to count from the MSB to the LSB instead of from the LSB to the MSB. * The modification of indexing makes finding the closest previous set bit more efficient in gas usage. */ /** * @dev Library for managing uint256 to bool mapping in a compact and efficient way, providing the keys are sequential. * Largelly inspired by Uniswap's https://github.com/Uniswap/merkle-distributor/blob/master/contracts/MerkleDistributor.sol[merkle-distributor]. */ library BitMaps { using BitScan for uint256; uint256 private constant MASK_INDEX_ZERO = (1 << 255); uint256 private constant MASK_FULL = type(uint256).max; struct BitMap { mapping(uint256 => uint256) _data; } /** * @dev Returns whether the bit at `index` is set. */ function get(BitMap storage bitmap, uint256 index) internal view returns (bool) { uint256 bucket = index >> 8; uint256 mask = MASK_INDEX_ZERO >> (index & 0xff); return bitmap._data[bucket] & mask != 0; } /** * @dev Sets the bit at `index` to the boolean `value`. */ function setTo( BitMap storage bitmap, uint256 index, bool value ) internal { if (value) { set(bitmap, index); } else { unset(bitmap, index); } } /** * @dev Sets the bit at `index`. */ function set(BitMap storage bitmap, uint256 index) internal { uint256 bucket = index >> 8; uint256 mask = MASK_INDEX_ZERO >> (index & 0xff); bitmap._data[bucket] |= mask; } /** * @dev Unsets the bit at `index`. */ function unset(BitMap storage bitmap, uint256 index) internal { uint256 bucket = index >> 8; uint256 mask = MASK_INDEX_ZERO >> (index & 0xff); bitmap._data[bucket] &= ~mask; } /** * @dev Consecutively sets `amount` of bits starting from the bit at `startIndex`. */ function setBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal { uint256 bucket = startIndex >> 8; uint256 bucketStartIndex = (startIndex & 0xff); unchecked { if(bucketStartIndex + amount < 256) { bitmap._data[bucket] |= MASK_FULL << (256 - amount) >> bucketStartIndex; } else { bitmap._data[bucket] |= MASK_FULL >> bucketStartIndex; amount -= (256 - bucketStartIndex); bucket++; while(amount > 256) { bitmap._data[bucket] = MASK_FULL; amount -= 256; bucket++; } bitmap._data[bucket] |= MASK_FULL << (256 - amount); } } } /** * @dev Consecutively unsets `amount` of bits starting from the bit at `startIndex`. */ function unsetBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal { uint256 bucket = startIndex >> 8; uint256 bucketStartIndex = (startIndex & 0xff); unchecked { if(bucketStartIndex + amount < 256) { bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount) >> bucketStartIndex); } else { bitmap._data[bucket] &= ~(MASK_FULL >> bucketStartIndex); amount -= (256 - bucketStartIndex); bucket++; while(amount > 256) { bitmap._data[bucket] = 0; amount -= 256; bucket++; } bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount)); } } } /** * @dev Find the closest index of the set bit before `index`. */ function scanForward(BitMap storage bitmap, uint256 index) internal view returns (uint256 setBitIndex) { uint256 bucket = index >> 8; // index within the bucket uint256 bucketIndex = (index & 0xff); // load a bitboard from the bitmap. uint256 bb = bitmap._data[bucket]; // offset the bitboard to scan from `bucketIndex`. bb = bb >> (0xff ^ bucketIndex); // bb >> (255 - bucketIndex) if(bb > 0) { unchecked { setBitIndex = (bucket << 8) | (bucketIndex - bb.bitScanForward256()); } } else { while(true) { require(bucket > 0, "BitMaps: The set bit before the index doesn't exist."); unchecked { bucket--; } // No offset. Always scan from the least significiant bit now. bb = bitmap._data[bucket]; if(bb > 0) { unchecked { setBitIndex = (bucket << 8) | (255 - bb.bitScanForward256()); break; } } } } } function getBucket(BitMap storage bitmap, uint256 bucket) internal view returns (uint256) { return bitmap._data[bucket]; } } // File: erc721psi/contracts/ERC721PsiUpgradeable.sol /** ______ _____ _____ ______ ___ __ _ _ _ | ____| __ \ / ____|____ |__ \/_ | || || | | |__ | |__) | | / / ) || | \| |/ | | __| | _ /| | / / / / | |\_ _/ | |____| | \ \| |____ / / / /_ | | | | |______|_| \_\\_____|/_/ |____||_| |_| */ pragma solidity ^0.8.0; contract ERC721PsiUpgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721Upgradeable, IERC721MetadataUpgradeable, IERC721EnumerableUpgradeable { using AddressUpgradeable for address; using StringsUpgradeable for uint256; using BitMaps for BitMaps.BitMap; BitMaps.BitMap private _batchHead; string private _name; string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) internal _owners; uint256 internal _minted; mapping(uint256 => address) private _tokenApprovals; mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ function __ERC721Psi_init(string memory name_, string memory symbol_) internal onlyInitializing { __ERC721Psi_init_unchained(name_, symbol_); } function __ERC721Psi_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) { return interfaceId == type(IERC721Upgradeable).interfaceId || interfaceId == type(IERC721MetadataUpgradeable).interfaceId || interfaceId == type(IERC721EnumerableUpgradeable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint) { require(owner != address(0), "ERC721Psi: balance query for the zero address"); uint count; for( uint i; i < _minted; ++i ){ if(_exists(i)){ if( owner == ownerOf(i)){ ++count; } } } return count; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { (address owner, ) = _ownerAndBatchHeadOf(tokenId); return owner; } function _ownerAndBatchHeadOf(uint256 tokenId) internal view returns (address owner, uint256 tokenIdBatchHead){ require(_exists(tokenId), "ERC721Psi: owner query for nonexistent token"); tokenIdBatchHead = _getBatchHead(tokenId); owner = _owners[tokenIdBatchHead]; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Psi: URI query for nonexistent token"); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overriden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ownerOf(tokenId); require(to != owner, "ERC721Psi: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721Psi: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { require( _exists(tokenId), "ERC721Psi: approved query for nonexistent token" ); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721Psi: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721Psi: transfer caller is not owner nor approved" ); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public virtual override { require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721Psi: transfer caller is not owner nor approved" ); _safeTransfer(from, to, tokenId, _data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `_data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory _data ) internal virtual { _transfer(from, to, tokenId); require( _checkOnERC721Received(from, to, tokenId, 1,_data), "ERC721Psi: transfer to non ERC721Receiver implementer" ); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return tokenId < _minted; } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require( _exists(tokenId), "ERC721Psi: operator query for nonexistent token" ); address owner = ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } /** * @dev Safely mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 quantity) internal virtual { _safeMint(to, quantity, ""); } function _safeMint( address to, uint256 quantity, bytes memory _data ) internal virtual { uint256 startTokenId = _minted; _mint(to, quantity); require( _checkOnERC721Received(address(0), to, startTokenId, quantity, _data), "ERC721Psi: transfer to non ERC721Receiver implementer" ); } function _mint( address to, uint256 quantity ) internal virtual { uint256 tokenIdBatchHead = _minted; require(quantity > 0, "ERC721Psi: quantity must be greater 0"); require(to != address(0), "ERC721Psi: mint to the zero address"); _beforeTokenTransfers(address(0), to, tokenIdBatchHead, quantity); _minted += quantity; _owners[tokenIdBatchHead] = to; _batchHead.set(tokenIdBatchHead); _afterTokenTransfers(address(0), to, tokenIdBatchHead, quantity); // Emit events for(uint256 tokenId=tokenIdBatchHead;tokenId < tokenIdBatchHead + quantity; tokenId++){ emit Transfer(address(0), to, tokenId); } } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { (address owner, uint256 tokenIdBatchHead) = _ownerAndBatchHeadOf(tokenId); require( owner == from, "ERC721Psi: transfer of token that is not own" ); require(to != address(0), "ERC721Psi: transfer to the zero address"); _beforeTokenTransfers(from, to, tokenId, 1); // Clear approvals from the previous owner _approve(address(0), tokenId); uint256 nextTokenId = tokenId + 1; if(!_batchHead.get(nextTokenId) && nextTokenId < _minted ) { _owners[nextTokenId] = from; _batchHead.set(nextTokenId); } _owners[tokenId] = to; if(tokenId != tokenIdBatchHead) { _batchHead.set(tokenId); } emit Transfer(from, to, tokenId); _afterTokenTransfers(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ownerOf(tokenId), to, tokenId); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param startTokenId uint256 the first ID of the tokens to be transferred * @param quantity uint256 amount of the tokens to be transfered. * @param _data bytes optional data to send along with the call * @return r bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 startTokenId, uint256 quantity, bytes memory _data ) private returns (bool r) { if (to.isContract()) { r = true; for(uint256 tokenId = startTokenId; tokenId < startTokenId + quantity; tokenId++){ try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) { r = r && retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721Psi: transfer to non ERC721Receiver implementer"); } else { assembly { revert(add(32, reason), mload(reason)) } } } } return r; } else { return true; } } function _getBatchHead(uint256 tokenId) internal view returns (uint256 tokenIdBatchHead) { tokenIdBatchHead = _batchHead.scanForward(tokenId); } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _minted; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256 tokenId) { require(index < totalSupply(), "ERC721Psi: global index out of bounds"); uint count; for(uint i; i < _minted; i++){ if(_exists(i)){ if(count == index) return i; else count++; } } } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256 tokenId) { uint count; for(uint i; i < _minted; i++){ if(_exists(i) && owner == ownerOf(i)){ if(count == index) return i; else count++; } } revert("ERC721Psi: owner index out of bounds"); } /** * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. */ function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} /** * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes * minting. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - when `from` and `to` are both non-zero. * - `from` and `to` are never both zero. */ function _afterTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} } // File: contracts/interfaces/ILaunchpadNFT.sol pragma solidity ^0.8.16; interface ILaunchpadNFT { // return max supply config for launchpad, if no reserved will be collection's max supply function getMaxLaunchpadSupply() external view returns (uint256); // return current launchpad supply function getLaunchpadSupply() external view returns (uint256); // this function need to restrict mint permission to launchpad contract function mintTo(address to, uint256 size) external; } // 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/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: contracts/ERC721Retreatable.sol pragma solidity ^0.8.16; contract ERC721Retreatable { /// @dev The Retreating base contract is implemented with the diamond storage pattern to prevent /// data overlapping, so it can be added and removed during upgrades without affecting other data. bytes32 private constant storagePosition = keccak256("diamond.storage.ERC721Retreatable"); error AlreadyInRetreating(); error NotInRetreating(); error RetreatingDisabled(); error NotAllowed(); error NotAuthorized(); struct ERC721RetreatableStorage { mapping(uint256 => TokenParameter) tokenParam; bool enableRetreating; mapping(address => bool) operatorAddress; } /// @dev pack token related parameters into a single storage slot to reduce gas consumption. struct TokenParameter { uint64 retreatingStartTime; uint64 totalRetreatingTime; } modifier onlyTokenOwner(uint256 tokenId) { if (IERC721(address(this)).ownerOf(tokenId) != msg.sender) { revert NotAuthorized(); } _; } modifier onlyTokensOwner(uint256[] memory tokenId) { for (uint256 i; i < tokenId.length; i++) { if (IERC721(address(this)).ownerOf(tokenId[i]) != msg.sender) { revert NotAuthorized(); } } _; } modifier onlyOperator() { if (_retriveOperator(msg.sender) != true) { revert NotAuthorized(); } _; } function _retriveERC721Storage() private pure returns (ERC721RetreatableStorage storage ds) { bytes32 storagePosition_ = storagePosition; assembly { ds.slot := storagePosition_ } } function _retriveTokenParam(uint256 tokenId) private view returns (TokenParameter storage) { return _retriveERC721Storage().tokenParam[tokenId]; } function _retriveOperator(address operator) private view returns (bool) { return _retriveERC721Storage().operatorAddress[operator]; } function isRetreating(uint256 tokenId) public view returns (bool) { return _retriveTokenParam(tokenId).retreatingStartTime > 0; } function retreatingTime(uint256 tokenId) public view returns (uint256 t) { t = _retriveTokenParam(tokenId).totalRetreatingTime; if (isRetreating(tokenId)) { t += uint64(block.timestamp) - _retriveTokenParam(tokenId).retreatingStartTime; } } function enterRetreating(uint256 tokenId) external onlyTokenOwner(tokenId) { _enterRetreating(tokenId); } function exitRetreating(uint256 tokenId) external onlyTokenOwner(tokenId) { _exitRetreating(tokenId); } function enterRetreatingMulti(uint256[] calldata tokenId) external onlyTokensOwner(tokenId) { for (uint256 i; i < tokenId.length; i++) { _enterRetreating(tokenId[i]); } } function exitRetreatingMulti(uint256[] calldata tokenId) external onlyTokensOwner(tokenId) { for (uint256 i; i < tokenId.length; i++) { _exitRetreating(tokenId[i]); } } function _enterRetreating(uint256 tokenId) internal { if (isRetreating(tokenId)) { revert AlreadyInRetreating(); } if (!_retriveERC721Storage().enableRetreating) { revert RetreatingDisabled(); } _retriveTokenParam(tokenId).retreatingStartTime = uint64( block.timestamp ); } function _exitRetreating(uint256 tokenId) internal { if (!isRetreating(tokenId)) { revert NotInRetreating(); } _retriveTokenParam(tokenId).totalRetreatingTime += uint64(block.timestamp) - _retriveTokenParam(tokenId).retreatingStartTime; _retriveTokenParam(tokenId).retreatingStartTime = 0; } function _setRetreatingEnable(bool enableRetreating) internal { _retriveERC721Storage().enableRetreating = enableRetreating; } function _swapOperator(address operator) internal { _retriveERC721Storage().operatorAddress[ operator ] = !_retriveERC721Storage().operatorAddress[operator]; } function _kickRetreating(uint256 tokenId) internal onlyOperator { _exitRetreating(tokenId); } function isRetreatingEnabled() public view returns (bool) { return _retriveERC721Storage().enableRetreating; } /// @dev Insert this fuctions to the token transfer hook function _transferCheck(uint256 tokenId) internal view { if (isRetreating(tokenId)) { revert NotAllowed(); } } } // File: contracts/ShellzOrb.sol // Built for Shellz Orb by Pagzi / NFTApi pragma solidity ^0.8.16; contract ShellzOrb is ILaunchpadNFT, ERC2981Upgradeable, OwnableUpgradeable, ERC721PsiUpgradeable, ERC721Retreatable { error Ended(); error NotStarted(); error NotEOA(); error MintTooManyAtOnce(); error InvalidSignature(); error ZeroQuantity(); error ExceedMaxSupply(); error ExceedAllowedQuantity(); error NotEnoughETH(); error TicketUsed(); error ApprovalNotEnabled(); mapping(address => uint256) public userMinted; mapping(address => bool) public operatorProxies; /* within a single storage slot */ address public launchpad; //1-20 uint32 public launchpadQuantity; // 21-24 address public signer; //1-20 uint256 public saleQuantity; // 21-24 address public payoutWallet; //1-20 uint32 constant LAUNCHPAD_MAX_SUPPLY = 1000; // 21-24 uint256 public publicPrice; modifier onlyLaunchpad() { require(launchpad != address(0), "launchpad address must set"); require(msg.sender == launchpad, "must call by launchpad"); _; } modifier onlySigner() { require(msg.sender == signer, "must call by signer"); _; } modifier onlyEOA() { if (msg.sender != tx.origin) { revert NotEOA(); } _; } function initialize() public initializer { __ERC2981_init(); __ERC721Psi_init("Shellz Orb", "SHELLZ"); __Ownable_init(); _setDefaultRoyalty( address(0x4393DC2e19dAa06935deD20376965b667ABA4a6F), 500 ); signer = address(0xDe1736B2F811a1e43EF92f6A707b198B6C09FAa8); saleQuantity = 8000; publicPrice = 0.089 ether; payoutWallet = address(0x3A7606611c643bfBbc75f8BcE0cc9927Dd980Fb5); // Payout wallet launchpad = address(0xa2833c0fDeacfD2510243222f6FeA7881e8E6c68); // Launchpad wallet launchpadQuantity = LAUNCHPAD_MAX_SUPPLY; } function _baseURI() internal view virtual override returns (string memory) { return "https://shellzorb.nftapi.art/meta/"; } /** Retreating related functions. */ function setRetreatingEnable(bool enableRetreating) external onlyOwner { _setRetreatingEnable(enableRetreating); } function kickFromRetreat(uint256 tokenId) external onlyOwner { _kickRetreating(tokenId); } function swapRetreatOperator(address operator) external onlyOwner { _swapOperator(operator); } function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual override { for ( uint256 tokenId = startTokenId; tokenId < startTokenId + quantity; tokenId++ ) { _transferCheck(tokenId); } super._beforeTokenTransfers(from, to, startTokenId, quantity); } /** Retreating-based approval control: The users cannot approve their token if it is retreating. */ function approve(address to, uint256 tokenId) public virtual override { _transferCheck(tokenId); super.approve(to, tokenId); } /** Operator control and auto approvals. */ function isApprovedForAll(address _owner, address operator) public view override(ERC721PsiUpgradeable) returns (bool) { if (operatorProxies[operator]) return true; return super.isApprovedForAll(_owner, operator); } function swapOperatorProxies(address _proxyAddress) public onlyOwner { operatorProxies[_proxyAddress] = !operatorProxies[_proxyAddress]; } /* 1000 NFTs are reserved for Binance NFT launchpad with the mintTo function. */ function getMaxLaunchpadSupply() external pure override returns (uint256) { return LAUNCHPAD_MAX_SUPPLY; } function getLaunchpadSupply() external view override returns (uint256) { return LAUNCHPAD_MAX_SUPPLY - launchpadQuantity; } function mintTo(address to, uint256 size) external override onlyLaunchpad { require(to != address(0), "can't mint to empty address"); require(size > 0, "size must greater than zero"); require(size <= launchpadQuantity, "max supply reached"); launchpadQuantity -= uint32(size); _mint(to, size); } // devMint for vault and team minting. function devMint(address to, uint32 quantity) external onlyOwner { if (quantity > saleQuantity) { revert ExceedMaxSupply(); } saleQuantity -= quantity; _mint(to, quantity); } /// @param quantity Amount of NFT to be minted. /// @param allowedQuantity Maximum allowed NFTs to be minted from a given amount. /// @param startTime The start time of the mint. /// @param endTime The end time of the mint. /// @param signature The NFT can only be minted with the valid signature. function mint( uint256 quantity, uint256 allowedQuantity, uint256 startTime, uint256 endTime, bytes calldata signature ) external payable onlyEOA { // quantity check if (quantity == 0) { revert ZeroQuantity(); } if (quantity + userMinted[msg.sender] > allowedQuantity) { revert ExceedAllowedQuantity(); } if (quantity > saleQuantity) { revert ExceedMaxSupply(); } // timestamp check if (block.timestamp < startTime) { revert NotStarted(); } if (block.timestamp >= endTime) { revert Ended(); } // price check if (msg.value < quantity * publicPrice) { revert NotEnoughETH(); } // signature check // The address of the contract is specified in the signature. This prevents the replay attact accross contracts. bytes32 hash = ECDSAUpgradeable.toEthSignedMessageHash( keccak256( abi.encodePacked( msg.sender, allowedQuantity, startTime, endTime, address(this) ) ) ); if (ECDSAUpgradeable.recover(hash, signature) != signer) { revert InvalidSignature(); } userMinted[msg.sender] += quantity; saleQuantity -= quantity; // mint _mint(msg.sender, quantity); } function setLaunchpad(address launchpad_) external onlyOwner { launchpad = launchpad_; } function setPayoutWallet(address _payoutWallet) external onlyOwner { payoutWallet = _payoutWallet; } function setLaunchpadSupply(uint32 launchpad_supply) external onlyOwner { launchpadQuantity = launchpad_supply; } function setSigner(address signer_) external onlyOwner { signer = signer_; } function setMintPrice(uint256 newPrice_) external onlyOwner { publicPrice = newPrice_; } function setDefaultRoyalty(address receiver, uint96 feeNumerator) external onlyOwner { _setDefaultRoyalty(receiver, feeNumerator); } function withdraw() external onlyOwner { payable(payoutWallet).transfer(address(this).balance); } /** Operator control and auto approvals. */ function getHash( address buyer, uint256 allowedQuantity, uint256 startTime, uint256 endTime ) external view onlySigner returns (bytes32) { // Hash Generation for Backend // toEthSignedMessageHash adds Ethereum headers to signed message. bytes32 hash = keccak256( abi.encodePacked( buyer, // 20 allowedQuantity, // 4 startTime, // 32 endTime, // 32 address(this) // 20 ) ); return hash; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721PsiUpgradeable, ERC2981Upgradeable) returns (bool) { return super.supportsInterface(interfaceId); } } // File: contracts/ShellzOrbV2.sol // SPDX-License-Identifier: MIT // Built for Shellz Orb by megsdevs pragma solidity ^0.8.16; contract ShellzOrbV2 is ShellzOrb, DefaultOperatorFiltererUpgradeable { /** * @notice disable initialization of the implementation contract so connot bypass the proxy. */ /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } /** * @notice reinitializer allows initialisation on upgrade, in this case for version 2. */ function initializeV2() public reinitializer(2) { __DefaultOperatorFilterer_init(); } /** * @notice Operator filterer requires exchanges to enforce creator royalties to not be blacklisted * for approve and transfer functions. * https://github.com/ProjectOpenSea/operator-filter-registry */ function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) { super.setApprovalForAll(operator, approved); } function approve(address operator, uint256 tokenId) public override onlyAllowedOperatorApproval(operator) { super.approve(operator, tokenId); } function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) { super.transferFrom(from, to, tokenId); } function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) { super.safeTransferFrom(from, to, tokenId); } function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override onlyAllowedOperator(from) { super.safeTransferFrom(from, to, tokenId, data); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ShellzOrb) returns (bool) { return interfaceId == type(IOperatorFilterRegistry).interfaceId || super.supportsInterface(interfaceId); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInRetreating","type":"error"},{"inputs":[],"name":"ApprovalNotEnabled","type":"error"},{"inputs":[],"name":"Ended","type":"error"},{"inputs":[],"name":"ExceedAllowedQuantity","type":"error"},{"inputs":[],"name":"ExceedMaxSupply","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"inputs":[],"name":"MintTooManyAtOnce","type":"error"},{"inputs":[],"name":"NotAllowed","type":"error"},{"inputs":[],"name":"NotAuthorized","type":"error"},{"inputs":[],"name":"NotEOA","type":"error"},{"inputs":[],"name":"NotEnoughETH","type":"error"},{"inputs":[],"name":"NotInRetreating","type":"error"},{"inputs":[],"name":"NotStarted","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"RetreatingDisabled","type":"error"},{"inputs":[],"name":"TicketUsed","type":"error"},{"inputs":[],"name":"ZeroQuantity","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"operator","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":"address","name":"to","type":"address"},{"internalType":"uint32","name":"quantity","type":"uint32"}],"name":"devMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"enterRetreating","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenId","type":"uint256[]"}],"name":"enterRetreatingMulti","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exitRetreating","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenId","type":"uint256[]"}],"name":"exitRetreatingMulti","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"buyer","type":"address"},{"internalType":"uint256","name":"allowedQuantity","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"}],"name":"getHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLaunchpadSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMaxLaunchpadSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initializeV2","outputs":[],"stateMutability":"nonpayable","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":"uint256","name":"tokenId","type":"uint256"}],"name":"isRetreating","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isRetreatingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"kickFromRetreat","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"launchpad","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"launchpadQuantity","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"uint256","name":"allowedQuantity","type":"uint256"},{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"size","type":"uint256"}],"name":"mintTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"operatorProxies","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"payoutWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"retreatingTime","outputs":[{"internalType":"uint256","name":"t","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"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":[],"name":"saleQuantity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"launchpad_","type":"address"}],"name":"setLaunchpad","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"launchpad_supply","type":"uint32"}],"name":"setLaunchpadSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice_","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_payoutWallet","type":"address"}],"name":"setPayoutWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enableRetreating","type":"bool"}],"name":"setRetreatingEnable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"signer_","type":"address"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_proxyAddress","type":"address"}],"name":"swapOperatorProxies","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"swapRetreatOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"tokenId","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":"tokenId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
60806040523480156200001157600080fd5b506200001c62000022565b620000e4565b600054610100900460ff16156200008f5760405162461bcd60e51b815260206004820152602760248201527f496e697469616c697a61626c653a20636f6e747261637420697320696e697469604482015266616c697a696e6760c81b606482015260840160405180910390fd5b60005460ff9081161015620000e2576000805460ff191660ff9081179091556040519081527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b565b6142e280620000f46000396000f3fe6080604052600436106103355760003560e01c80637c17678f116101ab578063c87b56dd116100f7578063eebb28b211610095578063f8ea8f161161006f578063f8ea8f1614610999578063fbf0dfc0146109ac578063fbf7b5a4146109cc578063fe9877a114610a0557600080fd5b8063eebb28b214610944578063f2fde38b14610959578063f4a0a5281461097957600080fd5b8063e88d60b2116100d1578063e88d60b2146108b4578063e8f09055146108d4578063e985e9c514610904578063ed5a6ea41461092457600080fd5b8063c87b56dd14610848578063d3ff4a9114610868578063e336e01d1461089e57600080fd5b80639a308a5c11610164578063a945bf801161013e578063a945bf80146107d2578063b68fc0dc146107e8578063b88d4fde14610808578063bf95f4761461082857600080fd5b80639a308a5c14610772578063a22cb46514610792578063a553e45b146107b257600080fd5b80637c17678f146106ca5780638129fc1c146106ea5780638488bb4e146106ff5780638da5cb5b1461071f5780638ebac11b1461073d57806395d89b411461075d57600080fd5b80632f745c59116102855780635b43bba1116102235780636b8f9c43116101fd5780636b8f9c43146106555780636c19e7831461067557806370a0823114610695578063715018a6146106b557600080fd5b80635b43bba11461060b5780635cd8a76b146106205780636352211e1461063557600080fd5b80633ccfd60b1161025f5780633ccfd60b1461059657806342842e0e146105ab578063449a52f8146105cb5780634f6ccce7146105eb57600080fd5b80632f745c59146105365780632fdf37091461055657806336f4c0eb1461057657600080fd5b8063095ea7b3116102f25780631aa5e872116102cc5780631aa5e8721461048a578063238ac933146104b757806323b872dd146104d75780632a55205a146104f757600080fd5b8063095ea7b31461042b57806317a5aced1461044b57806318160ddd1461046b57600080fd5b806301ffc9a71461033a57806302669b521461036f57806304634d8d146103a7578063064dd737146103c957806306fdde03146103e9578063081812fc1461040b575b600080fd5b34801561034657600080fd5b5061035a610355366004613824565b610a25565b60405190151581526020015b60405180910390f35b34801561037b57600080fd5b5060d25461038f906001600160a01b031681565b6040516001600160a01b039091168152602001610366565b3480156103b357600080fd5b506103c76103c2366004613856565b610a50565b005b3480156103d557600080fd5b506103c76103e436600461389b565b610a66565b3480156103f557600080fd5b506103fe610bb3565b604051610366919061395f565b34801561041757600080fd5b5061038f610426366004613972565b610c45565b34801561043757600080fd5b506103c761044636600461398b565b610cd7565b34801561045757600080fd5b506103c76104663660046139cb565b610da0565b34801561047757600080fd5b5060cd545b604051908152602001610366565b34801561049657600080fd5b5061047c6104a5366004613a00565b60d06020526000908152604090205481565b3480156104c357600080fd5b5060d35461038f906001600160a01b031681565b3480156104e357600080fd5b506103c76104f2366004613a1d565b610dff565b34801561050357600080fd5b50610517610512366004613a5e565b610ed2565b604080516001600160a01b039093168352602083019190915201610366565b34801561054257600080fd5b5061047c61055136600461398b565b610f80565b34801561056257600080fd5b506103c7610571366004613972565b61104a565b34801561058257600080fd5b506103c7610591366004613a00565b6110de565b3480156105a257600080fd5b506103c7611108565b3480156105b757600080fd5b506103c76105c6366004613a1d565b61114c565b3480156105d757600080fd5b506103c76105e636600461398b565b61121a565b3480156105f757600080fd5b5061047c610606366004613972565b611408565b34801561061757600080fd5b506103e861047c565b34801561062c57600080fd5b506103c76114c2565b34801561064157600080fd5b5061038f610650366004613972565b611561565b34801561066157600080fd5b506103c7610670366004613a00565b611575565b34801561068157600080fd5b506103c7610690366004613a00565b61159f565b3480156106a157600080fd5b5061047c6106b0366004613a00565b6115c9565b3480156106c157600080fd5b506103c7611699565b3480156106d657600080fd5b506103c76106e536600461389b565b6116ad565b3480156106f657600080fd5b506103c76117f4565b34801561070b57600080fd5b5060d55461038f906001600160a01b031681565b34801561072b57600080fd5b506097546001600160a01b031661038f565b34801561074957600080fd5b5061047c610758366004613a80565b6119ad565b34801561076957600080fd5b506103fe611a3d565b34801561077e57600080fd5b506103c761078d366004613972565b611a4c565b34801561079e57600080fd5b506103c76107ad366004613ac9565b611ae0565b3480156107be57600080fd5b506103c76107cd366004613af7565b611ba4565b3480156107de57600080fd5b5061047c60d65481565b3480156107f457600080fd5b506103c7610803366004613972565b611bdb565b34801561081457600080fd5b506103c7610823366004613b2a565b611bec565b34801561083457600080fd5b506103c7610843366004613c09565b611cc8565b34801561085457600080fd5b506103fe610863366004613972565b611cf6565b34801561087457600080fd5b507e189a975947f9bb7cf5ddec70fbf14b37d6256f2ca73d67bee9dd73b16210885460ff1661035a565b3480156108aa57600080fd5b5061047c60d45481565b3480156108c057600080fd5b506103c76108cf366004613a00565b611dbe565b3480156108e057600080fd5b5061035a6108ef366004613a00565b60d16020526000908152604090205460ff1681565b34801561091057600080fd5b5061035a61091f366004613c24565b611e11565b34801561093057600080fd5b506103c761093f366004613a00565b611e68565b34801561095057600080fd5b5061047c611e99565b34801561096557600080fd5b506103c7610974366004613a00565b611ec3565b34801561098557600080fd5b506103c7610994366004613972565b611f39565b6103c76109a7366004613c52565b611f46565b3480156109b857600080fd5b5061047c6109c7366004613972565b61219b565b3480156109d857600080fd5b5060d2546109f090600160a01b900463ffffffff1681565b60405163ffffffff9091168152602001610366565b348015610a1157600080fd5b5061035a610a20366004613972565b6121fc565b60006001600160e01b03198216633acdc73b60e11b1480610a4a5750610a4a82612219565b92915050565b610a58612224565b610a62828261227e565b5050565b8181808060200260200160405190810160405280939291908181526020018383602002808284376000920182905250925050505b8151811015610b6e57336001600160a01b0316306001600160a01b0316636352211e848481518110610ace57610ace613ce9565b60200260200101516040518263ffffffff1660e01b8152600401610af491815260200190565b602060405180830381865afa158015610b11573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b359190613cff565b6001600160a01b031614610b5c5760405163ea8e4eb560e01b815260040160405180910390fd5b80610b6681613d32565b915050610a9a565b5060005b82811015610bad57610b9b848483818110610b8f57610b8f613ce9565b9050602002013561237b565b80610ba581613d32565b915050610b72565b50505050565b606060ca8054610bc290613d4b565b80601f0160208091040260200160405190810160405280929190818152602001828054610bee90613d4b565b8015610c3b5780601f10610c1057610100808354040283529160200191610c3b565b820191906000526020600020905b815481529060010190602001808311610c1e57829003601f168201915b5050505050905090565b6000610c528260cd541190565b610cbb5760405162461bcd60e51b815260206004820152602f60248201527f4552433732315073693a20617070726f76656420717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b60648201526084015b60405180910390fd5b50600090815260ce60205260409020546001600160a01b031690565b816daaeb6d7670e522a718067333cd4e3b15610d9157604051633185c44d60e21b81523060048201526001600160a01b03821660248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa158015610d45573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d699190613d85565b610d9157604051633b79c77360e21b81526001600160a01b0382166004820152602401610cb2565b610d9b8383612438565b505050565b610da8612224565b60d4548163ffffffff161115610dd157604051630f0c37b960e11b815260040160405180910390fd5b8063ffffffff1660d46000828254610de99190613da2565b90915550610a6290508263ffffffff831661244b565b826daaeb6d7670e522a718067333cd4e3b15610ec757336001600160a01b03821603610e3557610e308484846125be565b610bad565b604051633185c44d60e21b81523060048201523360248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa158015610e84573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ea89190613d85565b610ec757604051633b79c77360e21b8152336004820152602401610cb2565b610bad8484846125be565b60008281526066602090815260408083208151808301909252546001600160a01b038116808352600160a01b9091046001600160601b0316928201929092528291610f475750604080518082019091526065546001600160a01b0381168252600160a01b90046001600160601b031660208201525b602081015160009061271090610f66906001600160601b031687613db5565b610f709190613dd4565b91519350909150505b9250929050565b60008060005b60cd54811015610ff557610f9b8160cd541190565b8015610fc05750610fab81611561565b6001600160a01b0316856001600160a01b0316145b15610fe357838203610fd5579150610a4a9050565b81610fdf81613d32565b9250505b80610fed81613d32565b915050610f86565b5060405162461bcd60e51b8152602060048201526024808201527f4552433732315073693a206f776e657220696e646578206f7574206f6620626f604482015263756e647360e01b6064820152608401610cb2565b6040516331a9108f60e11b815260048101829052819033903090636352211e90602401602060405180830381865afa15801561108a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110ae9190613cff565b6001600160a01b0316146110d55760405163ea8e4eb560e01b815260040160405180910390fd5b610a628261237b565b6110e6612224565b60d280546001600160a01b0319166001600160a01b0392909216919091179055565b611110612224565b60d5546040516001600160a01b03909116904780156108fc02916000818181858888f19350505050158015611149573d6000803e3d6000fd5b50565b826daaeb6d7670e522a718067333cd4e3b1561120f57336001600160a01b0382160361117d57610e308484846125ef565b604051633185c44d60e21b81523060048201523360248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa1580156111cc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111f09190613d85565b61120f57604051633b79c77360e21b8152336004820152602401610cb2565b610bad8484846125ef565b60d2546001600160a01b03166112725760405162461bcd60e51b815260206004820152601a60248201527f6c61756e63687061642061646472657373206d757374207365740000000000006044820152606401610cb2565b60d2546001600160a01b031633146112c55760405162461bcd60e51b81526020600482015260166024820152751b5d5cdd0818d85b1b08189e481b185d5b98da1c185960521b6044820152606401610cb2565b6001600160a01b03821661131b5760405162461bcd60e51b815260206004820152601b60248201527f63616e2774206d696e7420746f20656d707479206164647265737300000000006044820152606401610cb2565b6000811161136b5760405162461bcd60e51b815260206004820152601b60248201527f73697a65206d7573742067726561746572207468616e207a65726f00000000006044820152606401610cb2565b60d254600160a01b900463ffffffff168111156113bf5760405162461bcd60e51b81526020600482015260126024820152711b585e081cdd5c1c1b1e481c995858da195960721b6044820152606401610cb2565b8060d260148282829054906101000a900463ffffffff166113e09190613df6565b92506101000a81548163ffffffff021916908363ffffffff160217905550610a62828261244b565b600061141360cd5490565b821061146f5760405162461bcd60e51b815260206004820152602560248201527f4552433732315073693a20676c6f62616c20696e646578206f7574206f6620626044820152646f756e647360d81b6064820152608401610cb2565b6000805b60cd548110156114bb576114888160cd541190565b156114a95783820361149b579392505050565b816114a581613d32565b9250505b806114b381613d32565b915050611473565b5050919050565b600054600290610100900460ff161580156114e4575060005460ff8083169116105b6115005760405162461bcd60e51b8152600401610cb290613e13565b6000805461ffff191660ff83161761010017905561151c61260a565b6000805461ff001916905560405160ff821681527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498906020015b60405180910390a150565b60008061156d83612650565b509392505050565b61157d612224565b60d580546001600160a01b0319166001600160a01b0392909216919091179055565b6115a7612224565b60d380546001600160a01b0319166001600160a01b0392909216919091179055565b60006001600160a01b0382166116375760405162461bcd60e51b815260206004820152602d60248201527f4552433732315073693a2062616c616e636520717565727920666f722074686560448201526c207a65726f206164647265737360981b6064820152608401610cb2565b6000805b60cd54811015611692576116508160cd541190565b156116825761165e81611561565b6001600160a01b0316846001600160a01b0316036116825761167f82613d32565b91505b61168b81613d32565b905061163b565b5092915050565b6116a1612224565b6116ab60006126e9565b565b8181808060200260200160405190810160405280939291908181526020018383602002808284376000920182905250925050505b81518110156117b557336001600160a01b0316306001600160a01b0316636352211e84848151811061171557611715613ce9565b60200260200101516040518263ffffffff1660e01b815260040161173b91815260200190565b602060405180830381865afa158015611758573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061177c9190613cff565b6001600160a01b0316146117a35760405163ea8e4eb560e01b815260040160405180910390fd5b806117ad81613d32565b9150506116e1565b5060005b82811015610bad576117e28484838181106117d6576117d6613ce9565b9050602002013561273b565b806117ec81613d32565b9150506117b9565b600054610100900460ff16158080156118145750600054600160ff909116105b8061182e5750303b15801561182e575060005460ff166001145b61184a5760405162461bcd60e51b8152600401610cb290613e13565b6000805460ff19166001179055801561186d576000805461ff0019166101001790555b6118756127ad565b6118bf6040518060400160405280600a81526020016929b432b6363d1027b93160b11b8152506040518060400160405280600681526020016529a422a6262d60d11b8152506127d4565b6118c7612805565b6118e7734393dc2e19daa06935ded20376965b667aba4a6f6101f461227e565b60d380546001600160a01b031990811673de1736b2f811a1e43ef92f6a707b198b6c09faa817909155611f4060d45567013c31074902800060d65560d58054909116733a7606611c643bfbbc75f8bce0cc9927dd980fb517905560d280547503e8a2833c0fdeacfd2510243222f6fea7881e8e6c686001600160c01b03199091161790558015611149576000805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249890602001611556565b60d3546000906001600160a01b03163314611a005760405162461bcd60e51b815260206004820152601360248201527236bab9ba1031b0b63610313c9039b4b3b732b960691b6044820152606401610cb2565b60008585858530604051602001611a1b959493929190613e61565b60408051808303601f1901815291905280516020909101209695505050505050565b606060cb8054610bc290613d4b565b6040516331a9108f60e11b815260048101829052819033903090636352211e90602401602060405180830381865afa158015611a8c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611ab09190613cff565b6001600160a01b031614611ad75760405163ea8e4eb560e01b815260040160405180910390fd5b610a628261273b565b816daaeb6d7670e522a718067333cd4e3b15611b9a57604051633185c44d60e21b81523060048201526001600160a01b03821660248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa158015611b4e573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b729190613d85565b611b9a57604051633b79c77360e21b81526001600160a01b0382166004820152602401610cb2565b610d9b8383612834565b611bac612224565b7e189a975947f9bb7cf5ddec70fbf14b37d6256f2ca73d67bee9dd73b1621088805460ff191682151517905550565b611be3612224565b611149816128f8565b836daaeb6d7670e522a718067333cd4e3b15611cb557336001600160a01b03821603611c2357611c1e85858585612954565b611cc1565b604051633185c44d60e21b81523060048201523360248201526daaeb6d7670e522a718067333cd4e9063c617113490604401602060405180830381865afa158015611c72573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611c969190613d85565b611cb557604051633b79c77360e21b8152336004820152602401610cb2565b611cc185858585612954565b5050505050565b611cd0612224565b60d2805463ffffffff909216600160a01b0263ffffffff60a01b19909216919091179055565b6060611d038260cd541190565b611d625760405162461bcd60e51b815260206004820152602a60248201527f4552433732315073693a2055524920717565727920666f72206e6f6e657869736044820152693a32b73a103a37b5b2b760b11b6064820152608401610cb2565b6000611d6c612986565b90506000815111611d8c5760405180602001604052806000815250611db7565b80611d96846129a6565b604051602001611da7929190613e9f565b6040516020818303038152906040525b9392505050565b611dc6612224565b611149816001600160a01b031660009081527e189a975947f9bb7cf5ddec70fbf14b37d6256f2ca73d67bee9dd73b162108960205260409020805460ff19811660ff90911615179055565b6001600160a01b038116600090815260d1602052604081205460ff1615611e3a57506001610a4a565b6001600160a01b03808416600090815260cf602090815260408083209386168352929052205460ff16611db7565b611e70612224565b6001600160a01b0316600090815260d160205260409020805460ff19811660ff90911615179055565b60d254600090611eb890600160a01b900463ffffffff166103e8613df6565b63ffffffff16905090565b611ecb612224565b6001600160a01b038116611f305760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b6064820152608401610cb2565b611149816126e9565b611f41612224565b60d655565b333214611f6657604051635d04968b60e11b815260040160405180910390fd5b85600003611f875760405163f4f5b73360e01b815260040160405180910390fd5b33600090815260d060205260409020548590611fa39088613ece565b1115611fc2576040516359b5807560e11b815260040160405180910390fd5b60d454861115611fe557604051630f0c37b960e11b815260040160405180910390fd5b8342101561200657604051636f312cbd60e01b815260040160405180910390fd5b8242106120265760405163477383f360e01b815260040160405180910390fd5b60d6546120339087613db5565b34101561205357604051632c1d501360e11b815260040160405180910390fd5b60006120d13387878730604051602001612071959493929190613e61565b60408051601f1981840301815282825280516020918201207f19457468657265756d205369676e6564204d6573736167653a0a33320000000084830152603c8085019190915282518085039091018152605c909301909152815191012090565b60d354604080516020601f87018190048102820181019092528581529293506001600160a01b0390911691612123918491908790879081908401838280828437600092019190915250612a3892505050565b6001600160a01b03161461214a57604051638baa579f60e01b815260040160405180910390fd5b33600090815260d0602052604081208054899290612169908490613ece565b925050819055508660d460008282546121829190613da2565b909155506121929050338861244b565b50505050505050565b60006121a682612a54565b54600160401b90046001600160401b031690506121c2826121fc565b156121f7576121d082612a54565b546121e4906001600160401b031642613ee1565b610a4a906001600160401b031682613ece565b919050565b60008061220883612a54565b546001600160401b03161192915050565b6000610a4a82612a83565b6097546001600160a01b031633146116ab5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726044820152606401610cb2565b6127106001600160601b03821611156122ec5760405162461bcd60e51b815260206004820152602a60248201527f455243323938313a20726f79616c7479206665652077696c6c206578636565646044820152692073616c65507269636560b01b6064820152608401610cb2565b6001600160a01b0382166123425760405162461bcd60e51b815260206004820152601960248201527f455243323938313a20696e76616c6964207265636569766572000000000000006044820152606401610cb2565b604080518082019091526001600160a01b039092168083526001600160601b039091166020909201829052600160a01b90910217606555565b612384816121fc565b6123a1576040516301e4846960e11b815260040160405180910390fd5b6123aa81612a54565b546123be906001600160401b031642613ee1565b6123c782612a54565b80546008906123e7908490600160401b90046001600160401b0316613f01565b92506101000a8154816001600160401b0302191690836001600160401b03160217905550600061241682612a54565b805467ffffffffffffffff19166001600160401b039290921691909117905550565b61244181612ade565b610a628282612b05565b60cd54816124a95760405162461bcd60e51b815260206004820152602560248201527f4552433732315073693a207175616e74697479206d7573742062652067726561604482015264074657220360dc1b6064820152608401610cb2565b6001600160a01b03831661250b5760405162461bcd60e51b815260206004820152602360248201527f4552433732315073693a206d696e7420746f20746865207a65726f206164647260448201526265737360e81b6064820152608401610cb2565b6125186000848385612c17565b8160cd600082825461252a9190613ece565b9091555050600081815260cc6020526040902080546001600160a01b0319166001600160a01b03851617905561256160c982612c4b565b805b61256d8383613ece565b811015610bad5760405181906001600160a01b038616906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4806125b681613d32565b915050612563565b6125c83382612c77565b6125e45760405162461bcd60e51b8152600401610cb290613f21565b610d9b838383612d46565b610d9b83838360405180602001604052806000815250611bec565b600054610100900460ff166126315760405162461bcd60e51b8152600401610cb290613f75565b6116ab733cc6cdda760b79bafa08df41ecfa224f810dceb66001612f41565b60008061265e8360cd541190565b6126bf5760405162461bcd60e51b815260206004820152602c60248201527f4552433732315073693a206f776e657220717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b6064820152608401610cb2565b6126c8836130e0565b600081815260cc60205260409020546001600160a01b031694909350915050565b609780546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b612744816121fc565b15612762576040516360c8091960e11b815260040160405180910390fd5b7e189a975947f9bb7cf5ddec70fbf14b37d6256f2ca73d67bee9dd73b16210885460ff166127a357604051635174aee160e01b815260040160405180910390fd5b4261241682612a54565b600054610100900460ff166116ab5760405162461bcd60e51b8152600401610cb290613f75565b600054610100900460ff166127fb5760405162461bcd60e51b8152600401610cb290613f75565b610a6282826130ed565b600054610100900460ff1661282c5760405162461bcd60e51b8152600401610cb290613f75565b6116ab61312d565b336001600160a01b0383160361288c5760405162461bcd60e51b815260206004820152601c60248201527f4552433732315073693a20617070726f766520746f2063616c6c6572000000006044820152606401610cb2565b33600081815260cf602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b3360009081527e189a975947f9bb7cf5ddec70fbf14b37d6256f2ca73d67bee9dd73b1621089602052604090205460ff16151560011461294b5760405163ea8e4eb560e01b815260040160405180910390fd5b6111498161237b565b61295e3383612c77565b61297a5760405162461bcd60e51b8152600401610cb290613f21565b610bad8484848461315d565b606060405180606001604052806022815260200161418b60229139905090565b606060006129b383613192565b60010190506000816001600160401b038111156129d2576129d2613b14565b6040519080825280601f01601f1916602001820160405280156129fc576020820181803683370190505b5090508181016020015b600019016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a8504945084612a0657509392505050565b6000806000612a47858561326a565b9150915061156d816132ac565b60009081527e189a975947f9bb7cf5ddec70fbf14b37d6256f2ca73d67bee9dd73b16210876020526040902090565b60006001600160e01b031982166380ac58cd60e01b1480612ab457506001600160e01b03198216635b5e139f60e01b145b80612acf57506001600160e01b0319821663780e9d6360e01b145b80610a4a5750610a4a826133f6565b612ae7816121fc565b1561114957604051631eb49d6d60e11b815260040160405180910390fd5b6000612b1082611561565b9050806001600160a01b0316836001600160a01b031603612b7f5760405162461bcd60e51b8152602060048201526024808201527f4552433732315073693a20617070726f76616c20746f2063757272656e74206f6044820152633bb732b960e11b6064820152608401610cb2565b336001600160a01b0382161480612b9b5750612b9b8133611e11565b612c0d5760405162461bcd60e51b815260206004820152603b60248201527f4552433732315073693a20617070726f76652063616c6c6572206973206e6f7460448201527f206f776e6572206e6f7220617070726f76656420666f7220616c6c00000000006064820152608401610cb2565b610d9b838361342b565b815b612c238284613ece565b811015612c4557612c3381612ade565b80612c3d81613d32565b915050612c19565b50610bad565b600881901c600090815260209290925260409091208054600160ff1b60ff9093169290921c9091179055565b6000612c848260cd541190565b612ce85760405162461bcd60e51b815260206004820152602f60248201527f4552433732315073693a206f70657261746f7220717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b6064820152608401610cb2565b6000612cf383611561565b9050806001600160a01b0316846001600160a01b03161480612d2e5750836001600160a01b0316612d2384610c45565b6001600160a01b0316145b80612d3e5750612d3e8185611e11565b949350505050565b600080612d5283612650565b91509150846001600160a01b0316826001600160a01b031614612dcc5760405162461bcd60e51b815260206004820152602c60248201527f4552433732315073693a207472616e73666572206f6620746f6b656e2074686160448201526b3a1034b9903737ba1037bbb760a11b6064820152608401610cb2565b6001600160a01b038416612e325760405162461bcd60e51b815260206004820152602760248201527f4552433732315073693a207472616e7366657220746f20746865207a65726f206044820152666164647265737360c81b6064820152608401610cb2565b612e3f8585856001612c17565b612e4a60008461342b565b6000612e57846001613ece565b600881901c600090815260c96020526040902054909150600160ff1b60ff83161c16158015612e87575060cd5481105b15612ebe57600081815260cc6020526040902080546001600160a01b0319166001600160a01b038816179055612ebe60c982612c4b565b600084815260cc6020526040902080546001600160a01b0319166001600160a01b038716179055818414612ef757612ef760c985612c4b565b83856001600160a01b0316876001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a45b505050505050565b600054610100900460ff16612f685760405162461bcd60e51b8152600401610cb290613f75565b6daaeb6d7670e522a718067333cd4e3b15610a625760405163c3c5a54760e01b81523060048201526daaeb6d7670e522a718067333cd4e9063c3c5a547906024016020604051808303816000875af1158015612fc8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612fec9190613d85565b610a6257801561306057604051633e9f1edf60e11b81523060048201526001600160a01b03831660248201526daaeb6d7670e522a718067333cd4e90637d3e3dbe906044015b600060405180830381600087803b15801561304c57600080fd5b505af1158015612f39573d6000803e3d6000fd5b6001600160a01b038216156130af5760405163a0af290360e01b81523060048201526001600160a01b03831660248201526daaeb6d7670e522a718067333cd4e9063a0af290390604401613032565b604051632210724360e11b81523060048201526daaeb6d7670e522a718067333cd4e90634420e48690602401613032565b6000610a4a60c983613499565b600054610100900460ff166131145760405162461bcd60e51b8152600401610cb290613f75565b60ca6131208382614006565b5060cb610d9b8282614006565b600054610100900460ff166131545760405162461bcd60e51b8152600401610cb290613f75565b6116ab336126e9565b613168848484612d46565b613176848484600185613591565b610bad5760405162461bcd60e51b8152600401610cb2906140c5565b60008072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b83106131d15772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef810000000083106131fd576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc10000831061321b57662386f26fc10000830492506010015b6305f5e1008310613233576305f5e100830492506008015b612710831061324757612710830492506004015b60648310613259576064830492506002015b600a8310610a4a5760010192915050565b60008082516041036132a05760208301516040840151606085015160001a613294878285856136c8565b94509450505050610f79565b50600090506002610f79565b60008160048111156132c0576132c061411a565b036132c85750565b60018160048111156132dc576132dc61411a565b036133295760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e617475726500000000000000006044820152606401610cb2565b600281600481111561333d5761333d61411a565b0361338a5760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e677468006044820152606401610cb2565b600381600481111561339e5761339e61411a565b036111495760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b6064820152608401610cb2565b60006001600160e01b0319821663152a902d60e11b1480610a4a57506301ffc9a760e01b6001600160e01b0319831614610a4a565b600081815260ce6020526040902080546001600160a01b0319166001600160a01b038416908117909155819061346082611561565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b600881901c60008181526020849052604081205490919060ff808516919082181c80156134db576134c98161378c565b60ff168203600884901b179350613588565b600083116135485760405162461bcd60e51b815260206004820152603460248201527f4269744d6170733a205468652073657420626974206265666f7265207468652060448201527334b73232bc103237b2b9b713ba1032bc34b9ba1760611b6064820152608401610cb2565b506000199091016000818152602086905260409020549091908015613583576135708161378c565b60ff0360ff16600884901b179350613588565b6134db565b50505092915050565b60006001600160a01b0385163b156136bb57506001835b6135b28486613ece565b8110156136b557604051630a85bd0160e11b81526001600160a01b0387169063150b7a02906135eb9033908b9086908990600401614130565b6020604051808303816000875af1925050508015613626575060408051601f3d908101601f191682019092526136239181019061416d565b60015b613683573d808015613654576040519150601f19603f3d011682016040523d82523d6000602084013e613659565b606091505b50805160000361367b5760405162461bcd60e51b8152600401610cb2906140c5565b805181602001fd5b8280156136a057506001600160e01b03198116630a85bd0160e11b145b925050806136ad81613d32565b9150506135a8565b506136bf565b5060015b95945050505050565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a08311156136ff5750600090506003613783565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015613753573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b03811661377c57600060019250925050613783565b9150600090505b94509492505050565b600060405180610120016040528061010081526020016141ad610100913960f87e818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff6137d5856137f6565b02901c815181106137e8576137e8613ce9565b016020015160f81c92915050565b600080821161380457600080fd5b5060008190031690565b6001600160e01b03198116811461114957600080fd5b60006020828403121561383657600080fd5b8135611db78161380e565b6001600160a01b038116811461114957600080fd5b6000806040838503121561386957600080fd5b823561387481613841565b915060208301356001600160601b038116811461389057600080fd5b809150509250929050565b600080602083850312156138ae57600080fd5b82356001600160401b03808211156138c557600080fd5b818501915085601f8301126138d957600080fd5b8135818111156138e857600080fd5b8660208260051b85010111156138fd57600080fd5b60209290920196919550909350505050565b60005b8381101561392a578181015183820152602001613912565b50506000910152565b6000815180845261394b81602086016020860161390f565b601f01601f19169290920160200192915050565b602081526000611db76020830184613933565b60006020828403121561398457600080fd5b5035919050565b6000806040838503121561399e57600080fd5b82356139a981613841565b946020939093013593505050565b803563ffffffff811681146121f757600080fd5b600080604083850312156139de57600080fd5b82356139e981613841565b91506139f7602084016139b7565b90509250929050565b600060208284031215613a1257600080fd5b8135611db781613841565b600080600060608486031215613a3257600080fd5b8335613a3d81613841565b92506020840135613a4d81613841565b929592945050506040919091013590565b60008060408385031215613a7157600080fd5b50508035926020909101359150565b60008060008060808587031215613a9657600080fd5b8435613aa181613841565b966020860135965060408601359560600135945092505050565b801515811461114957600080fd5b60008060408385031215613adc57600080fd5b8235613ae781613841565b9150602083013561389081613abb565b600060208284031215613b0957600080fd5b8135611db781613abb565b634e487b7160e01b600052604160045260246000fd5b60008060008060808587031215613b4057600080fd5b8435613b4b81613841565b93506020850135613b5b81613841565b92506040850135915060608501356001600160401b0380821115613b7e57600080fd5b818701915087601f830112613b9257600080fd5b813581811115613ba457613ba4613b14565b604051601f8201601f19908116603f01168101908382118183101715613bcc57613bcc613b14565b816040528281528a6020848701011115613be557600080fd5b82602086016020830137600060208483010152809550505050505092959194509250565b600060208284031215613c1b57600080fd5b611db7826139b7565b60008060408385031215613c3757600080fd5b8235613c4281613841565b9150602083013561389081613841565b60008060008060008060a08789031215613c6b57600080fd5b8635955060208701359450604087013593506060870135925060808701356001600160401b0380821115613c9e57600080fd5b818901915089601f830112613cb257600080fd5b813581811115613cc157600080fd5b8a6020828501011115613cd357600080fd5b6020830194508093505050509295509295509295565b634e487b7160e01b600052603260045260246000fd5b600060208284031215613d1157600080fd5b8151611db781613841565b634e487b7160e01b600052601160045260246000fd5b600060018201613d4457613d44613d1c565b5060010190565b600181811c90821680613d5f57607f821691505b602082108103613d7f57634e487b7160e01b600052602260045260246000fd5b50919050565b600060208284031215613d9757600080fd5b8151611db781613abb565b81810381811115610a4a57610a4a613d1c565b6000816000190483118215151615613dcf57613dcf613d1c565b500290565b600082613df157634e487b7160e01b600052601260045260246000fd5b500490565b63ffffffff82811682821603908082111561169257611692613d1c565b6020808252602e908201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160408201526d191e481a5b9a5d1a585b1a5e995960921b606082015260800190565b6bffffffffffffffffffffffff19606096871b8116825260148201959095526034810193909352605483019190915290921b16607482015260880190565b60008351613eb181846020880161390f565b835190830190613ec581836020880161390f565b01949350505050565b80820180821115610a4a57610a4a613d1c565b6001600160401b0382811682821603908082111561169257611692613d1c565b6001600160401b0381811683821601908082111561169257611692613d1c565b60208082526034908201527f4552433732315073693a207472616e736665722063616c6c6572206973206e6f6040820152731d081bdddb995c881b9bdc88185c1c1c9bdd995960621b606082015260800190565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b601f821115610d9b57600081815260208120601f850160051c81016020861015613fe75750805b601f850160051c820191505b81811015612f3957828155600101613ff3565b81516001600160401b0381111561401f5761401f613b14565b6140338161402d8454613d4b565b84613fc0565b602080601f83116001811461406857600084156140505750858301515b600019600386901b1c1916600185901b178555612f39565b600085815260208120601f198616915b8281101561409757888601518255948401946001909101908401614078565b50858210156140b55787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b60208082526035908201527f4552433732315073693a207472616e7366657220746f206e6f6e20455243373260408201527418a932b1b2b4bb32b91034b6b83632b6b2b73a32b960591b606082015260800190565b634e487b7160e01b600052602160045260246000fd5b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061416390830184613933565b9695505050505050565b60006020828403121561417f57600080fd5b8151611db78161380e56fe68747470733a2f2f7368656c6c7a6f72622e6e66746170692e6172742f6d6574612f0001020903110a19042112290b311a3905412245134d2a550c5d32651b6d3a7506264262237d468514804e8d2b95569d0d495ea533a966b11c886eb93bc176c9071727374353637324837e9b47af86c7155181ad4fd18ed32c9096db57d59ee30e2e4a6a5f92a6be3498aae067ddb2eb1d5989b56fd7baf33ca0c2ee77e5caf7ff0810182028303840444c545c646c7425617c847f8c949c48a4a8b087b8c0c816365272829aaec650acd0d28fdad4e22d6991bd97dfdcea58b4d6f29fede4f6fe0f1f2f3f4b5b6b607b8b93a3a7b7bf357199c5abcfd9e168bcdee9b3f1ecf5fd1e3e5a7a8aa2b670c4ced8bbe8f0f4fc3d79a1c3cde7effb78cce6facbf9f8a264697066735822122079dd9a742275e466e42a19eae33a92b86eea2568c550dbf6acf97108b4c0728064736f6c63430008100033
Deployed Bytecode
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
Deployed Bytecode Sourcemap
115180:2093:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;116968:300;;;;;;;;;;-1:-1:-1;116968:300:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;116968:300:0;;;;;;;;107013:24;;;;;;;;;;-1:-1:-1;107013:24:0;;;;-1:-1:-1;;;;;107013:24:0;;;;;;-1:-1:-1;;;;;756:32:1;;;738:51;;726:2;711:18;107013:24:0;592:203:1;113758:169:0;;;;;;;;;;-1:-1:-1;113758:169:0;;;;;:::i;:::-;;:::i;:::-;;104473:227;;;;;;;;;;-1:-1:-1;104473:227:0;;;;;:::i;:::-;;:::i;81338:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;82893:311::-;;;;;;;;;;-1:-1:-1;82893:311:0;;;;;:::i;:::-;;:::i;116153:157::-;;;;;;;;;;-1:-1:-1;116153:157:0;;;;;:::i;:::-;;:::i;111014:228::-;;;;;;;;;;-1:-1:-1;111014:228:0;;;;;:::i;:::-;;:::i;92485:103::-;;;;;;;;;;-1:-1:-1;92573:7:0;;92485:103;;;3895:25:1;;;3883:2;3868:18;92485:103:0;3749:177:1;106865:45:0;;;;;;;;;;-1:-1:-1;106865:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;107098:21;;;;;;;;;;-1:-1:-1;107098:21:0;;;;-1:-1:-1;;;;;107098:21:0;;;116318:163;;;;;;;;;;-1:-1:-1;116318:163:0;;;;;:::i;:::-;;:::i;54728:442::-;;;;;;;;;;-1:-1:-1;54728:442:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;5089:32:1;;;5071:51;;5153:2;5138:18;;5131:34;;;;5044:18;54728:442:0;4897:274:1;93134:397:0;;;;;;;;;;-1:-1:-1;93134:397:0;;;;;:::i;:::-;;:::i;104111:117::-;;;;;;;;;;-1:-1:-1;104111:117:0;;;;;:::i;:::-;;:::i;113183:102::-;;;;;;;;;;-1:-1:-1;113183:102:0;;;;;:::i;:::-;;:::i;113935:111::-;;;;;;;;;;;;;:::i;116489:171::-;;;;;;;;;;-1:-1:-1;116489:171:0;;;;;:::i;:::-;;:::i;110615:347::-;;;;;;;;;;-1:-1:-1;110615:347:0;;;;;:::i;:::-;;:::i;92665:385::-;;;;;;;;;;-1:-1:-1;92665:385:0;;;;;:::i;:::-;;:::i;110342:120::-;;;;;;;;;;-1:-1:-1;107256:4:0;110342:120;;115606:99;;;;;;;;;;;;;:::i;80743:222::-;;;;;;;;;;-1:-1:-1;80743:222:0;;;;;:::i;:::-;;:::i;113293:114::-;;;;;;;;;;-1:-1:-1;113293:114:0;;;;;:::i;:::-;;:::i;113550:90::-;;;;;;;;;;-1:-1:-1;113550:90:0;;;;;:::i;:::-;;:::i;80216:465::-;;;;;;;;;;-1:-1:-1;80216:465:0;;;;;:::i;:::-;;:::i;48266:103::-;;;;;;;;;;;;;:::i;104236:229::-;;;;;;;;;;-1:-1:-1;104236:229:0;;;;;:::i;:::-;;:::i;107747:658::-;;;;;;;;;;;;;:::i;107176:27::-;;;;;;;;;;-1:-1:-1;107176:27:0;;;;-1:-1:-1;;;;;107176:27:0;;;47618:87;;;;;;;;;;-1:-1:-1;47691:6:0;;-1:-1:-1;;;;;47691:6:0;47618:87;;114126:590;;;;;;;;;;-1:-1:-1;114126:590:0;;;;;:::i;:::-;;:::i;81507:104::-;;;;;;;;;;;;;:::i;103984:119::-;;;;;;;;;;-1:-1:-1;103984:119:0;;;;;:::i;:::-;;:::i;115969:176::-;;;;;;;;;;-1:-1:-1;115969:176:0;;;;;:::i;:::-;;:::i;108623:128::-;;;;;;;;;;-1:-1:-1;108623:128:0;;;;;:::i;:::-;;:::i;107276:26::-;;;;;;;;;;;;;;;;108759:104;;;;;;;;;;-1:-1:-1;108759:104:0;;;;;:::i;:::-;;:::i;116668:228::-;;;;;;;;;;-1:-1:-1;116668:228:0;;;;;:::i;:::-;;:::i;113415:127::-;;;;;;;;;;-1:-1:-1;113415:127:0;;;;;:::i;:::-;;:::i;81682:329::-;;;;;;;;;;-1:-1:-1;81682:329:0;;;;;:::i;:::-;;:::i;105938:124::-;;;;;;;;;;-1:-1:-1;106014:40:0;;;;105938:124;;107133:27;;;;;;;;;;;;;;;;108871:108;;;;;;;;;;-1:-1:-1;108871:108:0;;;;;:::i;:::-;;:::i;106917:47::-;;;;;;;;;;-1:-1:-1;106917:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;109793:278;;;;;;;;;;-1:-1:-1;109793:278:0;;;;;:::i;:::-;;:::i;110079:152::-;;;;;;;;;;-1:-1:-1;110079:152:0;;;;;:::i;:::-;;:::i;110470:137::-;;;;;;;;;;;;;:::i;48524:201::-;;;;;;;;;;-1:-1:-1;48524:201:0;;;;;:::i;:::-;;:::i;113648:102::-;;;;;;;;;;-1:-1:-1;113648:102:0;;;;;:::i;:::-;;:::i;111573:1602::-;;;;;;:::i;:::-;;:::i;103657:319::-;;;;;;;;;;-1:-1:-1;103657:319:0;;;;;:::i;:::-;;:::i;107051:31::-;;;;;;;;;;-1:-1:-1;107051:31:0;;;;-1:-1:-1;;;107051:31:0;;;;;;;;;9600:10:1;9588:23;;;9570:42;;9558:2;9543:18;107051:31:0;9426:192:1;103506:143:0;;;;;;;;;;-1:-1:-1;103506:143:0;;;;;:::i;:::-;;:::i;116968:300::-;117109:4;-1:-1:-1;;;;;;117151:56:0;;-1:-1:-1;;;117151:56:0;;:109;;;117224:36;117248:11;117224:23;:36::i;:::-;117131:129;116968:300;-1:-1:-1;;116968:300:0:o;113758:169::-;47504:13;:11;:13::i;:::-;113877:42:::1;113896:8;113906:12;113877:18;:42::i;:::-;113758:169:::0;;:::o;104473:227::-;104573:7;;102458:267;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;102458:267:0;-1:-1:-1;;;102520:186:0;102540:7;:14;102536:1;:18;102520:186;;;102626:10;-1:-1:-1;;;;;102580:56:0;102596:4;-1:-1:-1;;;;;102580:30:0;;102611:7;102619:1;102611:10;;;;;;;;:::i;:::-;;;;;;;102580:42;;;;;;;;;;;;;3895:25:1;;3883:2;3868:18;;3749:177;102580:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;102580:56:0;;102576:119;;102664:15;;-1:-1:-1;;;102664:15:0;;;;;;;;;;;102576:119;102556:3;;;;:::i;:::-;;;;102520:186;;;;104603:9:::1;104598:95;104614:18:::0;;::::1;104598:95;;;104654:27;104670:7;;104678:1;104670:10;;;;;;;:::i;:::-;;;;;;;104654:15;:27::i;:::-;104634:3:::0;::::1;::::0;::::1;:::i;:::-;;;;104598:95;;;;104473:227:::0;;;:::o;81338:100::-;81392:13;81425:5;81418:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81338:100;:::o;82893:311::-;83014:7;83061:16;83069:7;86625;;-1:-1:-1;86615:17:0;86526:114;83061:16;83039:113;;;;-1:-1:-1;;;83039:113:0;;10870:2:1;83039:113:0;;;10852:21:1;10909:2;10889:18;;;10882:30;10948:34;10928:18;;;10921:62;-1:-1:-1;;;10999:18:1;;;10992:45;11054:19;;83039:113:0;;;;;;;;;-1:-1:-1;83172:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;83172:24:0;;82893:311::o;116153:157::-;116249:8;17889:42;19964:43;:47;19960:221;;20033:65;;-1:-1:-1;;;20033:65:0;;20082:4;20033:65;;;11296:34:1;-1:-1:-1;;;;;11366:15:1;;11346:18;;;11339:43;17889:42:0;;20033:40;;11231:18:1;;20033:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20028:142;;20126:28;;-1:-1:-1;;;20126:28:0;;-1:-1:-1;;;;;756:32:1;;20126:28:0;;;738:51:1;711:18;;20126:28:0;592:203:1;20028:142:0;116270:32:::1;116284:8;116294:7;116270:13;:32::i;:::-;116153:157:::0;;;:::o;111014:228::-;47504:13;:11;:13::i;:::-;111105:12:::1;;111094:8;:23;;;111090:80;;;111141:17;;-1:-1:-1::0;;;111141:17:0::1;;;;;;;;;;;111090:80;111196:8;111180:24;;:12;;:24;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;111215:19:0::1;::::0;-1:-1:-1;111221:2:0;111215:19:::1;::::0;::::1;:5;:19::i;116318:163::-:0;116419:4;17889:42;19222:43;:47;19218:535;;19509:10;-1:-1:-1;;;;;19501:18:0;;;19497:85;;116436:37:::1;116455:4;116461:2;116465:7;116436:18;:37::i;:::-;19560:7:::0;;19497:85;19601:67;;-1:-1:-1;;;19601:67:0;;19650:4;19601:67;;;11296:34:1;19657:10:0;11346:18:1;;;11339:43;17889:42:0;;19601:40;;11231:18:1;;19601:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19596:146;;19696:30;;-1:-1:-1;;;19696:30:0;;19715:10;19696:30;;;738:51:1;711:18;;19696:30:0;592:203:1;19596:146:0;116436:37:::1;116455:4;116461:2;116465:7;116436:18;:37::i;54728:442::-:0;54825:7;54883:27;;;:17;:27;;;;;;;;54854:56;;;;;;;;;-1:-1:-1;;;;;54854:56:0;;;;;-1:-1:-1;;;54854:56:0;;;-1:-1:-1;;;;;54854:56:0;;;;;;;;54825:7;;54923:92;;-1:-1:-1;54974:29:0;;;;;;;;;54984:19;54974:29;-1:-1:-1;;;;;54974:29:0;;;;-1:-1:-1;;;54974:29:0;;-1:-1:-1;;;;;54974:29:0;;;;;54923:92;55065:23;;;;55027:21;;55536:5;;55052:36;;-1:-1:-1;;;;;55052:36:0;:10;:36;:::i;:::-;55051:58;;;;:::i;:::-;55130:16;;;-1:-1:-1;55027:82:0;;-1:-1:-1;;54728:442:0;;;;;;:::o;93134:397::-;93231:15;93259:10;93284:6;93280:185;93296:7;;93292:1;:11;93280:185;;;93327:10;93335:1;86625:7;;-1:-1:-1;86615:17:0;86526:114;93327:10;:33;;;;;93350:10;93358:1;93350:7;:10::i;:::-;-1:-1:-1;;;;;93341:19:0;:5;-1:-1:-1;;;;;93341:19:0;;93327:33;93324:130;;;93392:5;93383;:14;93380:58;;93406:1;-1:-1:-1;93399:8:0;;-1:-1:-1;93399:8:0;93380:58;93431:7;;;;:::i;:::-;;;;93380:58;93305:3;;;;:::i;:::-;;;;93280:185;;;-1:-1:-1;93477:46:0;;-1:-1:-1;;;93477:46:0;;12505:2:1;93477:46:0;;;12487:21:1;12544:2;12524:18;;;12517:30;12583:34;12563:18;;;12556:62;-1:-1:-1;;;12634:18:1;;;12627:34;12678:19;;93477:46:0;12303:400:1;104111:117:0;102327:39;;-1:-1:-1;;;102327:39:0;;;;;3895:25:1;;;104176:7:0;;102370:10;;102343:4;;102327:30;;3868:18:1;;102327:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;102327:53:0;;102323:108;;102404:15;;-1:-1:-1;;;102404:15:0;;;;;;;;;;;102323:108;104196:24:::1;104212:7;104196:15;:24::i;113183:102::-:0;47504:13;:11;:13::i;:::-;113255:9:::1;:22:::0;;-1:-1:-1;;;;;;113255:22:0::1;-1:-1:-1::0;;;;;113255:22:0;;;::::1;::::0;;;::::1;::::0;;113183:102::o;113935:111::-;47504:13;:11;:13::i;:::-;113993:12:::1;::::0;113985:53:::1;::::0;-1:-1:-1;;;;;113993:12:0;;::::1;::::0;114016:21:::1;113985:53:::0;::::1;;;::::0;113993:12:::1;113985:53:::0;113993:12;113985:53;114016:21;113993:12;113985:53;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;113935:111::o:0;116489:171::-;116594:4;17889:42;19222:43;:47;19218:535;;19509:10;-1:-1:-1;;;;;19501:18:0;;;19497:85;;116611:41:::1;116634:4;116640:2;116644:7;116611:22;:41::i;19497:85::-:0;19601:67;;-1:-1:-1;;;19601:67:0;;19650:4;19601:67;;;11296:34:1;19657:10:0;11346:18:1;;;11339:43;17889:42:0;;19601:40;;11231:18:1;;19601:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19596:146;;19696:30;;-1:-1:-1;;;19696:30:0;;19715:10;19696:30;;;738:51:1;711:18;;19696:30:0;592:203:1;19596:146:0;116611:41:::1;116634:4;116640:2;116644:7;116611:22;:41::i;110615:347::-:0;107355:9;;-1:-1:-1;;;;;107355:9:0;107347:62;;;;-1:-1:-1;;;107347:62:0;;12910:2:1;107347:62:0;;;12892:21:1;12949:2;12929:18;;;12922:30;12988:28;12968:18;;;12961:56;13034:18;;107347:62:0;12708:350:1;107347:62:0;107442:9;;-1:-1:-1;;;;;107442:9:0;107428:10;:23;107420:58;;;;-1:-1:-1;;;107420:58:0;;13265:2:1;107420:58:0;;;13247:21:1;13304:2;13284:18;;;13277:30;-1:-1:-1;;;13323:18:1;;;13316:52;13385:18;;107420:58:0;13063:346:1;107420:58:0;-1:-1:-1;;;;;110708:16:0;::::1;110700:56;;;::::0;-1:-1:-1;;;110700:56:0;;13616:2:1;110700:56:0::1;::::0;::::1;13598:21:1::0;13655:2;13635:18;;;13628:30;13694:29;13674:18;;;13667:57;13741:18;;110700:56:0::1;13414:351:1::0;110700:56:0::1;110782:1;110775:4;:8;110767:48;;;::::0;-1:-1:-1;;;110767:48:0;;13972:2:1;110767:48:0::1;::::0;::::1;13954:21:1::0;14011:2;13991:18;;;13984:30;14050:29;14030:18;;;14023:57;14097:18;;110767:48:0::1;13770:351:1::0;110767:48:0::1;110842:17;::::0;-1:-1:-1;;;110842:17:0;::::1;;;110834:25:::0;::::1;;110826:56;;;::::0;-1:-1:-1;;;110826:56:0;;14328:2:1;110826:56:0::1;::::0;::::1;14310:21:1::0;14367:2;14347:18;;;14340:30;-1:-1:-1;;;14386:18:1;;;14379:48;14444:18;;110826:56:0::1;14126:342:1::0;110826:56:0::1;110923:4;110895:17;;:33;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;110939:15;110945:2;110949:4;110939:5;:15::i;92665:385::-:0;92740:15;92784:13;92573:7;;;92485:103;92784:13;92776:5;:21;92768:71;;;;-1:-1:-1;;;92768:71:0;;14855:2:1;92768:71:0;;;14837:21:1;14894:2;14874:18;;;14867:30;14933:34;14913:18;;;14906:62;-1:-1:-1;;;14984:18:1;;;14977:35;15029:19;;92768:71:0;14653:401:1;92768:71:0;92860:10;92885:6;92881:162;92897:7;;92893:1;:11;92881:162;;;92928:10;92936:1;86625:7;;-1:-1:-1;86615:17:0;86526:114;92928:10;92925:107;;;92970:5;92961;:14;92958:58;;92984:1;92665:385;-1:-1:-1;;;92665:385:0:o;92958:58::-;93009:7;;;;:::i;:::-;;;;92958:58;92906:3;;;;:::i;:::-;;;;92881:162;;;;92757:293;92665:385;;;:::o;115606:99::-;15752:13;;115651:1;;15752:13;;;;;15751:14;:40;;;;-1:-1:-1;15769:12:0;;:22;;;;:12;;:22;15751:40;15743:99;;;;-1:-1:-1;;;15743:99:0;;;;;;;:::i;:::-;15853:12;:22;;-1:-1:-1;;15886:20:0;15853:22;;;15886:20;15853:22;15886:20;;;115665:32:::1;:30;:32::i;:::-;15945:5:::0;15929:21;;-1:-1:-1;;15929:21:0;;;15966:20;;15646:4:1;15634:17;;15616:36;;15966:20:0;;15604:2:1;15589:18;15966:20:0;;;;;;;;115606:99;:::o;80743:222::-;80860:7;80886:13;80905:29;80926:7;80905:20;:29::i;:::-;-1:-1:-1;80885:49:0;80743:222;-1:-1:-1;;;80743:222:0:o;113293:114::-;47504:13;:11;:13::i;:::-;113371:12:::1;:28:::0;;-1:-1:-1;;;;;;113371:28:0::1;-1:-1:-1::0;;;;;113371:28:0;;;::::1;::::0;;;::::1;::::0;;113293:114::o;113550:90::-;47504:13;:11;:13::i;:::-;113616:6:::1;:16:::0;;-1:-1:-1;;;;;;113616:16:0::1;-1:-1:-1::0;;;;;113616:16:0;;;::::1;::::0;;;::::1;::::0;;113550:90::o;80216:465::-;80338:4;-1:-1:-1;;;;;80369:19:0;;80361:77;;;;-1:-1:-1;;;80361:77:0;;15865:2:1;80361:77:0;;;15847:21:1;15904:2;15884:18;;;15877:30;15943:34;15923:18;;;15916:62;-1:-1:-1;;;15994:18:1;;;15987:43;16047:19;;80361:77:0;15663:409:1;80361:77:0;80451:10;80477:6;80472:179;80489:7;;80485:1;:11;80472:179;;;80521:10;80529:1;86625:7;;-1:-1:-1;86615:17:0;86526:114;80521:10;80518:122;;;80564:10;80572:1;80564:7;:10::i;:::-;-1:-1:-1;;;;;80555:19:0;:5;-1:-1:-1;;;;;80555:19:0;;80551:74;;80598:7;;;:::i;:::-;;;80551:74;80498:3;;;:::i;:::-;;;80472:179;;;-1:-1:-1;80668:5:0;80216:465;-1:-1:-1;;80216:465:0:o;48266:103::-;47504:13;:11;:13::i;:::-;48331:30:::1;48358:1;48331:18;:30::i;:::-;48266:103::o:0;104236:229::-;104337:7;;102458:267;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;102458:267:0;-1:-1:-1;;;102520:186:0;102540:7;:14;102536:1;:18;102520:186;;;102626:10;-1:-1:-1;;;;;102580:56:0;102596:4;-1:-1:-1;;;;;102580:30:0;;102611:7;102619:1;102611:10;;;;;;;;:::i;:::-;;;;;;;102580:42;;;;;;;;;;;;;3895:25:1;;3883:2;3868:18;;3749:177;102580:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;102580:56:0;;102576:119;;102664:15;;-1:-1:-1;;;102664:15:0;;;;;;;;;;;102576:119;102556:3;;;;:::i;:::-;;;;102520:186;;;;104367:9:::1;104362:96;104378:18:::0;;::::1;104362:96;;;104418:28;104435:7;;104443:1;104435:10;;;;;;;:::i;:::-;;;;;;;104418:16;:28::i;:::-;104398:3:::0;::::1;::::0;::::1;:::i;:::-;;;;104362:96;;107747:658:::0;14114:19;14137:13;;;;;;14136:14;;14184:34;;;;-1:-1:-1;14202:12:0;;14217:1;14202:12;;;;:16;14184:34;14183:108;;;-1:-1:-1;14263:4:0;3777:19;:23;;;14224:66;;-1:-1:-1;14273:12:0;;;;;:17;14224:66;14161:204;;;;-1:-1:-1;;;14161:204:0;;;;;;;:::i;:::-;14376:12;:16;;-1:-1:-1;;14376:16:0;14391:1;14376:16;;;14403:67;;;;14438:13;:20;;-1:-1:-1;;14438:20:0;;;;;14403:67;107799:16:::1;:14;:16::i;:::-;107826:40;;;;;;;;;;;;;;-1:-1:-1::0;;;107826:40:0::1;;::::0;::::1;;;;;;;;;;;;;-1:-1:-1::0;;;107826:40:0::1;;::::0;:16:::1;:40::i;:::-;107877:16;:14;:16::i;:::-;107906:113;107947:42;108005:3;107906:18;:113::i;:::-;108032:6;:60:::0;;-1:-1:-1;;;;;;108032:60:0;;::::1;108049:42;108032:60;::::0;;;108118:4:::1;108103:12;:19:::0;108147:11:::1;108133;:25:::0;108169:12:::1;:66:::0;;;;::::1;108192:42;108169:66;::::0;;108263:9:::1;:63:::0;;108357:40;-1:-1:-1;;;;;;108357:40:0;;;;;;14492:102;;;;14543:5;14527:21;;-1:-1:-1;;14527:21:0;;;14568:14;;-1:-1:-1;15616:36:1;;14568:14:0;;15604:2:1;15589:18;14568:14:0;15474:184:1;114126:590:0;107561:6;;114296:7;;-1:-1:-1;;;;;107561:6:0;107547:10;:20;107539:52;;;;-1:-1:-1;;;107539:52:0;;16478:2:1;107539:52:0;;;16460:21:1;16517:2;16497:18;;;16490:30;-1:-1:-1;;;16536:18:1;;;16529:49;16595:18;;107539:52:0;16276:343:1;107539:52:0;114432:12:::1;114506:5;114536:15;114575:9;114609:7;114649:4;114471:204;;;;;;;;;;;;:::i;:::-;;::::0;;;;::::1;-1:-1:-1::0;;114471:204:0;;;;;;114447:239;;114471:204:::1;114447:239:::0;;::::1;::::0;;114126:590;-1:-1:-1;;;;;;114126:590:0:o;81507:104::-;81563:13;81596:7;81589:14;;;;;:::i;103984:119::-;102327:39;;-1:-1:-1;;;102327:39:0;;;;;3895:25:1;;;104050:7:0;;102370:10;;102343:4;;102327:30;;3868:18:1;;102327:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;102327:53:0;;102323:108;;102404:15;;-1:-1:-1;;;102404:15:0;;;;;;;;;;;102323:108;104070:25:::1;104087:7;104070:16;:25::i;115969:176::-:0;116073:8;17889:42;19964:43;:47;19960:221;;20033:65;;-1:-1:-1;;;20033:65:0;;20082:4;20033:65;;;11296:34:1;-1:-1:-1;;;;;11366:15:1;;11346:18;;;11339:43;17889:42:0;;20033:40;;11231:18:1;;20033:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20028:142;;20126:28;;-1:-1:-1;;;20126:28:0;;-1:-1:-1;;;;;756:32:1;;20126:28:0;;;738:51:1;711:18;;20126:28:0;592:203:1;20028:142:0;116094:43:::1;116118:8;116128;116094:23;:43::i;108623:128::-:0;47504:13;:11;:13::i;:::-;105545:40;:59;;-1:-1:-1;;105545:59:0;;;;;;;113985:53:::1;113935:111::o:0;108759:104::-;47504:13;:11;:13::i;:::-;108831:24:::1;108847:7;108831:15;:24::i;116668:228::-:0;116819:4;17889:42;19222:43;:47;19218:535;;19509:10;-1:-1:-1;;;;;19501:18:0;;;19497:85;;116841:47:::1;116864:4;116870:2;116874:7;116883:4;116841:22;:47::i;:::-;19560:7:::0;;19497:85;19601:67;;-1:-1:-1;;;19601:67:0;;19650:4;19601:67;;;11296:34:1;19657:10:0;11346:18:1;;;11339:43;17889:42:0;;19601:40;;11231:18:1;;19601:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19596:146;;19696:30;;-1:-1:-1;;;19696:30:0;;19715:10;19696:30;;;738:51:1;711:18;;19696:30:0;592:203:1;19596:146:0;116841:47:::1;116864:4;116870:2;116874:7;116883:4;116841:22;:47::i;:::-;116668:228:::0;;;;;:::o;113415:127::-;47504:13;:11;:13::i;:::-;113498:17:::1;:36:::0;;::::1;::::0;;::::1;-1:-1:-1::0;;;113498:36:0::1;-1:-1:-1::0;;;;113498:36:0;;::::1;::::0;;;::::1;::::0;;113415:127::o;81682:329::-;81755:13;81789:16;81797:7;86625;;-1:-1:-1;86615:17:0;86526:114;81789:16;81781:71;;;;-1:-1:-1;;;81781:71:0;;17361:2:1;81781:71:0;;;17343:21:1;17400:2;17380:18;;;17373:30;17439:34;17419:18;;;17412:62;-1:-1:-1;;;17490:18:1;;;17483:40;17540:19;;81781:71:0;17159:406:1;81781:71:0;81865:21;81889:10;:8;:10::i;:::-;81865:34;;81941:1;81923:7;81917:21;:25;:86;;;;;;;;;;;;;;;;;81969:7;81978:18;:7;:16;:18::i;:::-;81952:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;81917:86;81910:93;81682:329;-1:-1:-1;;;81682:329:0:o;108871:108::-;47504:13;:11;:13::i;:::-;108948:23:::1;108962:8;-1:-1:-1::0;;;;;105758:49:0;;;;;:39;:49;;;;;;;-1:-1:-1;;105681:126:0;;105758:49;;;;105757:50;105681:126;;;105620:195;109793:278;-1:-1:-1;;;;;109967:25:0;;109941:4;109967:25;;;:15;:25;;;;;;;;109963:42;;;-1:-1:-1;110001:4:0;109994:11;;109963:42;-1:-1:-1;;;;;83848:25:0;;;83819:4;83848:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;110023:40;83677:214;110079:152;47504:13;:11;:13::i;:::-;-1:-1:-1;;;;;110193:30:0::1;;::::0;;;:15:::1;:30;::::0;;;;;;-1:-1:-1;;110159:64:0;::::1;110193:30;::::0;;::::1;110192:31;110159:64;::::0;;110079:152::o;110470:137::-;110582:17;;110532:7;;110559:40;;-1:-1:-1;;;110582:17:0;;;;107256:4;110559:40;:::i;:::-;110552:47;;;;110470:137;:::o;48524:201::-;47504:13;:11;:13::i;:::-;-1:-1:-1;;;;;48613:22:0;::::1;48605:73;;;::::0;-1:-1:-1;;;48605:73:0;;18273:2:1;48605:73:0::1;::::0;::::1;18255:21:1::0;18312:2;18292:18;;;18285:30;18351:34;18331:18;;;18324:62;-1:-1:-1;;;18402:18:1;;;18395:36;18448:19;;48605:73:0::1;18071:402:1::0;48605:73:0::1;48689:28;48708:8;48689:18;:28::i;113648:102::-:0;47504:13;:11;:13::i;:::-;113719:11:::1;:23:::0;113648:102::o;111573:1602::-;107653:10;107667:9;107653:23;107649:71;;107700:8;;-1:-1:-1;;;107700:8:0;;;;;;;;;;;107649:71;111811:8:::1;111823:1;111811:13:::0;111807:67:::1;;111848:14;;-1:-1:-1::0;;;111848:14:0::1;;;;;;;;;;;111807:67;111912:10;111901:22;::::0;;;:10:::1;:22;::::0;;;;;111926:15;;111890:33:::1;::::0;:8;:33:::1;:::i;:::-;:51;111886:114;;;111965:23;;-1:-1:-1::0;;;111965:23:0::1;;;;;;;;;;;111886:114;112027:12;;112016:8;:23;112012:80;;;112063:17;;-1:-1:-1::0;;;112063:17:0::1;;;;;;;;;;;112012:80;112154:9;112136:15;:27;112132:79;;;112187:12;;-1:-1:-1::0;;;112187:12:0::1;;;;;;;;;;;112132:79;112244:7;112225:15;:26;112221:73;;112275:7;;-1:-1:-1::0;;;112275:7:0::1;;;;;;;;;;;112221:73;112357:11;::::0;112346:22:::1;::::0;:8;:22:::1;:::i;:::-;112334:9;:34;112330:88;;;112392:14;;-1:-1:-1::0;;;112392:14:0::1;;;;;;;;;;;112330:88;112580:12;112595:312;112716:10;112749:15;112787:9;112819:7;112857:4;112677:204;;;;;;;;;;;;:::i;:::-;;::::0;;-1:-1:-1;;112677:204:0;;::::1;::::0;;;;;;112649:247;;112677:204:::1;112649:247:::0;;::::1;::::0;22762:66:1;43660:58:0;;;22750:79:1;22845:12;;;;22838:28;;;;43660:58:0;;;;;;;;;;22882:12:1;;;;43660:58:0;;;43650:69;;;;;;43458:269;112595:312:::1;112969:6;::::0;112924:41:::1;::::0;;::::1;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;;112580:327;;-1:-1:-1;;;;;;112969:6:0;;::::1;::::0;112924:41:::1;::::0;112580:327;;112924:41;112955:9;;;;;;112924:41;::::1;112955:9:::0;;;;112924:41;::::1;;::::0;::::1;::::0;;;;-1:-1:-1;112924:24:0::1;::::0;-1:-1:-1;;;112924:41:0:i:1;:::-;-1:-1:-1::0;;;;;112924:51:0::1;;112920:109;;112999:18;;-1:-1:-1::0;;;112999:18:0::1;;;;;;;;;;;112920:109;113052:10;113041:22;::::0;;;:10:::1;:22;::::0;;;;:34;;113067:8;;113041:22;:34:::1;::::0;113067:8;;113041:34:::1;:::i;:::-;;;;;;;;113102:8;113086:12;;:24;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;113140:27:0::1;::::0;-1:-1:-1;113146:10:0::1;113158:8:::0;113140:5:::1;:27::i;:::-;111769:1406;111573:1602:::0;;;;;;:::o;103657:319::-;103719:9;103745:27;103764:7;103745:18;:27::i;:::-;:47;-1:-1:-1;;;103745:47:0;;-1:-1:-1;;;;;103745:47:0;;-1:-1:-1;103807:21:0;103820:7;103807:12;:21::i;:::-;103803:166;;;103910:27;103929:7;103910:18;:27::i;:::-;:47;103867:90;;-1:-1:-1;;;;;103910:47:0;103874:15;103867:90;:::i;:::-;103845:112;;-1:-1:-1;;;;;103845:112:0;;;:::i;103803:166::-;103657:319;;;:::o;103506:143::-;103566:4;103640:1;103590:27;103609:7;103590:18;:27::i;:::-;:47;-1:-1:-1;;;;;103590:47:0;:51;;103506:143;-1:-1:-1;;103506:143:0:o;114788:245::-;114960:4;114989:36;115013:11;114989:23;:36::i;47783:132::-;47691:6;;-1:-1:-1;;;;;47691:6:0;45738:10;47847:23;47839:68;;;;-1:-1:-1;;;47839:68:0;;18998:2:1;47839:68:0;;;18980:21:1;;;19017:18;;;19010:30;19076:34;19056:18;;;19049:62;19128:18;;47839:68:0;18796:356:1;55820:332:0;55536:5;-1:-1:-1;;;;;55923:33:0;;;;55915:88;;;;-1:-1:-1;;;55915:88:0;;19359:2:1;55915:88:0;;;19341:21:1;19398:2;19378:18;;;19371:30;19437:34;19417:18;;;19410:62;-1:-1:-1;;;19488:18:1;;;19481:40;19538:19;;55915:88:0;19157:406:1;55915:88:0;-1:-1:-1;;;;;56022:22:0;;56014:60;;;;-1:-1:-1;;;56014:60:0;;19770:2:1;56014:60:0;;;19752:21:1;19809:2;19789:18;;;19782:30;19848:27;19828:18;;;19821:55;19893:18;;56014:60:0;19568:349:1;56014:60:0;56109:35;;;;;;;;;-1:-1:-1;;;;;56109:35:0;;;;;;-1:-1:-1;;;;;56109:35:0;;;;;;;;;;-1:-1:-1;;;56087:57:0;;;;:19;:57;55820:332::o;105091:373::-;105158:21;105171:7;105158:12;:21::i;:::-;105153:79;;105203:17;;-1:-1:-1;;;105203:17:0;;;;;;;;;;;105153:79;105347:27;105366:7;105347:18;:27::i;:::-;:47;105308:86;;-1:-1:-1;;;;;105347:47:0;105315:15;105308:86;:::i;:::-;105244:27;105263:7;105244:18;:27::i;:::-;:150;;:47;;:150;;;;-1:-1:-1;;;105244:150:0;;-1:-1:-1;;;;;105244:150:0;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;105244:150:0;;;;;-1:-1:-1;;;;;105244:150:0;;;;;;105455:1;105405:27;105424:7;105405:18;:27::i;:::-;:51;;-1:-1:-1;;105405:51:0;-1:-1:-1;;;;;105405:51:0;;;;;;;;;;-1:-1:-1;105091:373:0:o;109564:149::-;109645:23;109660:7;109645:14;:23::i;:::-;109679:26;109693:2;109697:7;109679:13;:26::i;88136:769::-;88261:7;;88297:12;88289:62;;;;-1:-1:-1;;;88289:62:0;;20309:2:1;88289:62:0;;;20291:21:1;20348:2;20328:18;;;20321:30;20387:34;20367:18;;;20360:62;-1:-1:-1;;;20438:18:1;;;20431:35;20483:19;;88289:62:0;20107:401:1;88289:62:0;-1:-1:-1;;;;;88370:16:0;;88362:64;;;;-1:-1:-1;;;88362:64:0;;20715:2:1;88362:64:0;;;20697:21:1;20754:2;20734:18;;;20727:30;20793:34;20773:18;;;20766:62;-1:-1:-1;;;20844:18:1;;;20837:33;20887:19;;88362:64:0;20513:399:1;88362:64:0;88447:65;88477:1;88481:2;88485:16;88503:8;88447:21;:65::i;:::-;88534:8;88523:7;;:19;;;;;;;:::i;:::-;;;;-1:-1:-1;;88553:25:0;;;;:7;:25;;;;;:30;;-1:-1:-1;;;;;;88553:30:0;-1:-1:-1;;;;;88553:30:0;;;;;88594:32;:10;88553:25;88594:14;:32::i;:::-;88766:16;88746:151;88793:27;88812:8;88793:16;:27;:::i;:::-;88783:7;:37;88746:151;;;88852:33;;88877:7;;-1:-1:-1;;;;;88852:33:0;;;88869:1;;88852:33;;88869:1;;88852:33;88822:9;;;;:::i;:::-;;;;88746:151;;83958:379;84167:41;45738:10;84200:7;84167:18;:41::i;:::-;84145:143;;;;-1:-1:-1;;;84145:143:0;;;;;;;:::i;:::-;84301:28;84311:4;84317:2;84321:7;84301:9;:28::i;84408:185::-;84546:39;84563:4;84569:2;84573:7;84546:39;;;;;;;;;;;;:16;:39::i;20520:166::-;16257:13;;;;;;;16249:69;;;;-1:-1:-1;;;16249:69:0;;;;;;;:::i;:::-;20599:79:::1;20468:42;20673:4;20599:51;:79::i;80973:298::-:0;81043:13;81058:24;81102:16;81110:7;86625;;-1:-1:-1;86615:17:0;86526:114;81102:16;81094:73;;;;-1:-1:-1;;;81094:73:0;;21952:2:1;81094:73:0;;;21934:21:1;21991:2;21971:18;;;21964:30;22030:34;22010:18;;;22003:62;-1:-1:-1;;;22081:18:1;;;22074:42;22133:19;;81094:73:0;21750:408:1;81094:73:0;81197:22;81211:7;81197:13;:22::i;:::-;81238:25;;;;:7;:25;;;;;;-1:-1:-1;;;;;81238:25:0;;81178:41;;-1:-1:-1;80973:298:0;-1:-1:-1;;80973:298:0:o;48885:191::-;48978:6;;;-1:-1:-1;;;;;48995:17:0;;;-1:-1:-1;;;;;;48995:17:0;;;;;;;49028:40;;48978:6;;;48995:17;48978:6;;49028:40;;48959:16;;49028:40;48948:128;48885:191;:::o;104708:375::-;104775:21;104788:7;104775:12;:21::i;:::-;104771:82;;;104820:21;;-1:-1:-1;;;104820:21:0;;;;;;;;;;;104771:82;104870:40;;;;104865:101;;104934:20;;-1:-1:-1;;;104934:20:0;;;;;;;;;;;104865:101;105049:15;104978:27;104997:7;104978:18;:27::i;53999:60::-;16257:13;;;;;;;16249:69;;;;-1:-1:-1;;;16249:69:0;;;;;;;:::i;79272:157::-;16257:13;;;;;;;16249:69;;;;-1:-1:-1;;;16249:69:0;;;;;;;:::i;:::-;79379:42:::1;79406:5;79413:7;79379:26;:42::i;47161:97::-:0;16257:13;;;;;;;16249:69;;;;-1:-1:-1;;;16249:69:0;;;;;;;:::i;:::-;47224:26:::1;:24;:26::i;83276:330::-:0;45738:10;-1:-1:-1;;;;;83411:24:0;;;83403:65;;;;-1:-1:-1;;;83403:65:0;;22365:2:1;83403:65:0;;;22347:21:1;22404:2;22384:18;;;22377:30;22443;22423:18;;;22416:58;22491:18;;83403:65:0;22163:352:1;83403:65:0;45738:10;83481:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;83481:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;83481:53:0;;;;;;;;;;83550:48;;540:41:1;;;83481:42:0;;45738:10;83550:48;;513:18:1;83550:48:0;;;;;;;83276:330;;:::o;105823:107::-;102789:10;103417:4;103441:49;;;:39;:49;;;;;;;;102772:36;;102804:4;102772:36;102768:91;;102832:15;;-1:-1:-1;;;102832:15:0;;;;;;;;;;;102768:91;105898:24:::1;105914:7;105898:15;:24::i;84664:368::-:0;84853:41;45738:10;84886:7;84853:18;:41::i;:::-;84831:143;;;;-1:-1:-1;;;84831:143:0;;;;;;;:::i;:::-;84985:39;84999:4;85005:2;85009:7;85018:5;84985:13;:39::i;108413:137::-;108473:13;108499:43;;;;;;;;;;;;;;;;;;;108413:137;:::o;34064:727::-;34120:13;34171:14;34188:28;34210:5;34188:21;:28::i;:::-;34219:1;34188:32;34171:49;;34235:20;34269:6;-1:-1:-1;;;;;34258:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;34258:18:0;-1:-1:-1;34235:41:0;-1:-1:-1;34400:28:0;;;34416:2;34400:28;34457:288;-1:-1:-1;;34489:5:0;-1:-1:-1;;;34626:2:0;34615:14;;34610:30;34489:5;34597:44;34687:2;34678:11;;;-1:-1:-1;34708:21:0;34457:288;34708:21;-1:-1:-1;34766:6:0;34064:727;-1:-1:-1;;;34064:727:0:o;39768:231::-;39846:7;39867:17;39886:18;39908:27;39919:4;39925:9;39908:10;:27::i;:::-;39866:69;;;;39946:18;39958:5;39946:11;:18::i;103151:192::-;103245:22;103292:43;;;101667:46;103292:43;;;;;;103151:192::o;79675:477::-;79844:4;-1:-1:-1;;;;;;79886:51:0;;-1:-1:-1;;;79886:51:0;;:127;;-1:-1:-1;;;;;;;79954:59:0;;-1:-1:-1;;;79954:59:0;79886:127;:205;;;-1:-1:-1;;;;;;;80030:61:0;;-1:-1:-1;;;80030:61:0;79886:205;:258;;;;80108:36;80132:11;80108:23;:36::i;106132:146::-;106202:21;106215:7;106202:12;:21::i;:::-;106198:73;;;106247:12;;-1:-1:-1;;;106247:12:0;;;;;;;;;;;82417:410;82498:13;82514:16;82522:7;82514;:16::i;:::-;82498:32;;82555:5;-1:-1:-1;;;;;82549:11:0;:2;-1:-1:-1;;;;;82549:11:0;;82541:60;;;;-1:-1:-1;;;82541:60:0;;23107:2:1;82541:60:0;;;23089:21:1;23146:2;23126:18;;;23119:30;23185:34;23165:18;;;23158:62;-1:-1:-1;;;23236:18:1;;;23229:34;23280:19;;82541:60:0;22905:400:1;82541:60:0;45738:10;-1:-1:-1;;;;;82636:21:0;;;;:62;;-1:-1:-1;82661:37:0;82678:5;45738:10;109793:278;:::i;82661:37::-;82614:171;;;;-1:-1:-1;;;82614:171:0;;23512:2:1;82614:171:0;;;23494:21:1;23551:2;23531:18;;;23524:30;23590:34;23570:18;;;23563:62;23661:29;23641:18;;;23634:57;23708:19;;82614:171:0;23310:423:1;82614:171:0;82798:21;82807:2;82811:7;82798:8;:21::i;108987:439::-;109201:12;109164:183;109238:23;109253:8;109238:12;:23;:::i;:::-;109228:7;:33;109164:183;;;109312:23;109327:7;109312:14;:23::i;:::-;109276:9;;;;:::i;:::-;;;;109164:183;;;;109357:61;104473:227;74149:204;74246:1;74237:10;;;74220:14;74317:20;;;;;;;;;;;;:28;;-1:-1:-1;;;74301:4:0;74293:12;;;74273:33;;;;74317:28;;;;;74149:204::o;86807:448::-;86936:4;86980:16;86988:7;86625;;-1:-1:-1;86615:17:0;86526:114;86980:16;86958:113;;;;-1:-1:-1;;;86958:113:0;;23940:2:1;86958:113:0;;;23922:21:1;23979:2;23959:18;;;23952:30;24018:34;23998:18;;;23991:62;-1:-1:-1;;;24069:18:1;;;24062:45;24124:19;;86958:113:0;23738:411:1;86958:113:0;87082:13;87098:16;87106:7;87098;:16::i;:::-;87082:32;;87144:5;-1:-1:-1;;;;;87133:16:0;:7;-1:-1:-1;;;;;87133:16:0;;:64;;;;87190:7;-1:-1:-1;;;;;87166:31:0;:20;87178:7;87166:11;:20::i;:::-;-1:-1:-1;;;;;87166:31:0;;87133:64;:113;;;;87214:32;87231:5;87238:7;87214:16;:32::i;:::-;87125:122;86807:448;-1:-1:-1;;;;86807:448:0:o;89244:1020::-;89369:13;89384:24;89412:29;89433:7;89412:20;:29::i;:::-;89368:73;;;;89485:4;-1:-1:-1;;;;;89476:13:0;:5;-1:-1:-1;;;;;89476:13:0;;89454:107;;;;-1:-1:-1;;;89454:107:0;;24356:2:1;89454:107:0;;;24338:21:1;24395:2;24375:18;;;24368:30;24434:34;24414:18;;;24407:62;-1:-1:-1;;;24485:18:1;;;24478:42;24537:19;;89454:107:0;24154:408:1;89454:107:0;-1:-1:-1;;;;;89580:16:0;;89572:68;;;;-1:-1:-1;;;89572:68:0;;24769:2:1;89572:68:0;;;24751:21:1;24808:2;24788:18;;;24781:30;24847:34;24827:18;;;24820:62;-1:-1:-1;;;24898:18:1;;;24891:37;24945:19;;89572:68:0;24567:403:1;89572:68:0;89653:43;89675:4;89681:2;89685:7;89694:1;89653:21;:43::i;:::-;89761:29;89778:1;89782:7;89761:8;:29::i;:::-;89806:19;89828:11;:7;89838:1;89828:11;:::i;:::-;73645:1;73636:10;;;73602:4;73723:20;;;89856:10;73723:20;;;;;;73636:10;;-1:-1:-1;;;;73700:4:0;73692:12;;73672:33;73723:27;:32;;;89855:68;;;89916:7;;89902:11;:21;89855:68;89852:179;;;89950:20;;;;:7;:20;;;;;:27;;-1:-1:-1;;;;;;89950:27:0;-1:-1:-1;;;;;89950:27:0;;;;;89992;:10;89950:20;89992:14;:27::i;:::-;90043:16;;;;:7;:16;;;;;:21;;-1:-1:-1;;;;;;90043:21:0;-1:-1:-1;;;;;90043:21:0;;;;;90078:27;;;90075:82;;90122:23;:10;90137:7;90122:14;:23::i;:::-;90193:7;90189:2;-1:-1:-1;;;;;90174:27:0;90183:4;-1:-1:-1;;;;;90174:27:0;;;;;;;;;;;90214:42;89357:907;;;89244:1020;;;:::o;17941:1101::-;16257:13;;;;;;;16249:69;;;;-1:-1:-1;;;16249:69:0;;;;;;;:::i;:::-;17889:42:::1;18377:43;:47:::0;18373:662:::1;;18446:50;::::0;-1:-1:-1;;;18446:50:0;;18490:4:::1;18446:50;::::0;::::1;738:51:1::0;17889:42:0::1;::::0;18446:35:::1;::::0;711:18:1;;18446:50:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;18441:583;;18521:9;18517:492;;;18555:90;::::0;-1:-1:-1;;;18555:90:0;;18607:4:::1;18555:90;::::0;::::1;11296:34:1::0;-1:-1:-1;;;;;11366:15:1;;11346:18;;;11339:43;17889:42:0::1;::::0;18555:43:::1;::::0;11231:18:1;;18555:90:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;18517:492;-1:-1:-1::0;;;;;18698:44:0;::::1;::::0;18694:296:::1;;18771:92;::::0;-1:-1:-1;;;18771:92:0;;18825:4:::1;18771:92;::::0;::::1;11296:34:1::0;-1:-1:-1;;;;;11366:15:1;;11346:18;;;11339:43;17889:42:0::1;::::0;18771:45:::1;::::0;11231:18:1;;18771:92:0::1;11084:304:1::0;18694:296:0::1;18920:46;::::0;-1:-1:-1;;;18920:46:0;;18960:4:::1;18920:46;::::0;::::1;738:51:1::0;17889:42:0::1;::::0;18920:31:::1;::::0;711:18:1;;18920:46:0::1;592:203:1::0;92250:159:0;92313:24;92369:31;:10;92392:7;92369:22;:31::i;79437:166::-;16257:13;;;;;;;16249:69;;;;-1:-1:-1;;;16249:69:0;;;;;;;:::i;:::-;79554:5:::1;:13;79562:5:::0;79554;:13:::1;:::i;:::-;-1:-1:-1::0;79578:7:0::1;:17;79588:7:::0;79578;:17:::1;:::i;47266:113::-:0;16257:13;;;;;;;16249:69;;;;-1:-1:-1;;;16249:69:0;;;;;;;:::i;:::-;47339:32:::1;45738:10:::0;47339:18:::1;:32::i;85914:357::-:0;86071:28;86081:4;86087:2;86091:7;86071:9;:28::i;:::-;86132:50;86155:4;86161:2;86165:7;86174:1;86176:5;86132:22;:50::i;:::-;86110:153;;;;-1:-1:-1;;;86110:153:0;;;;;;;:::i;30898:922::-;30951:7;;-1:-1:-1;;;31029:15:0;;31025:102;;-1:-1:-1;;;31065:15:0;;;-1:-1:-1;31109:2:0;31099:12;31025:102;31154:6;31145:5;:15;31141:102;;31190:6;31181:15;;;-1:-1:-1;31225:2:0;31215:12;31141:102;31270:6;31261:5;:15;31257:102;;31306:6;31297:15;;;-1:-1:-1;31341:2:0;31331:12;31257:102;31386:5;31377;:14;31373:99;;31421:5;31412:14;;;-1:-1:-1;31455:1:0;31445:11;31373:99;31499:5;31490;:14;31486:99;;31534:5;31525:14;;;-1:-1:-1;31568:1:0;31558:11;31486:99;31612:5;31603;:14;31599:99;;31647:5;31638:14;;;-1:-1:-1;31681:1:0;31671:11;31599:99;31725:5;31716;:14;31712:66;;31761:1;31751:11;31806:6;30898:922;-1:-1:-1;;30898:922:0:o;38219:747::-;38300:7;38309:12;38338:9;:16;38358:2;38338:22;38334:625;;38682:4;38667:20;;38661:27;38732:4;38717:20;;38711:27;38790:4;38775:20;;38769:27;38377:9;38761:36;38833:25;38844:4;38761:36;38661:27;38711;38833:10;:25::i;:::-;38826:32;;;;;;;;;38334:625;-1:-1:-1;38907:1:0;;-1:-1:-1;38911:35:0;38891:56;;36612:521;36690:20;36681:5;:29;;;;;;;;:::i;:::-;;36677:449;;36612:521;:::o;36677:449::-;36788:29;36779:5;:38;;;;;;;;:::i;:::-;;36775:351;;36834:34;;-1:-1:-1;;;36834:34:0;;27935:2:1;36834:34:0;;;27917:21:1;27974:2;27954:18;;;27947:30;28013:26;27993:18;;;27986:54;28057:18;;36834:34:0;27733:348:1;36775:351:0;36899:35;36890:5;:44;;;;;;;;:::i;:::-;;36886:240;;36951:41;;-1:-1:-1;;;36951:41:0;;28288:2:1;36951:41:0;;;28270:21:1;28327:2;28307:18;;;28300:30;28366:33;28346:18;;;28339:61;28417:18;;36951:41:0;28086:355:1;36886:240:0;37023:30;37014:5;:39;;;;;;;;:::i;:::-;;37010:116;;37070:44;;-1:-1:-1;;;37070:44:0;;28648:2:1;37070:44:0;;;28630:21:1;28687:2;28667:18;;;28660:30;28726:34;28706:18;;;28699:62;-1:-1:-1;;;28777:18:1;;;28770:32;28819:19;;37070:44:0;28446:398:1;54414:248:0;54538:4;-1:-1:-1;;;;;;54562:52:0;;-1:-1:-1;;;54562:52:0;;:92;;-1:-1:-1;;;;;;;;;;52449:51:0;;;54618:36;52340:168;90382:167;90457:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;90457:29:0;-1:-1:-1;;;;;90457:29:0;;;;;;;;:24;;90511:16;90457:24;90511:7;:16::i;:::-;-1:-1:-1;;;;;90502:39:0;;;;;;;;;;;90382:167;;:::o;76594:1234::-;76734:1;76725:10;;;76676:19;76891:20;;;;;;;;;;;76676:19;;76725:10;76815:4;76807:12;;;;76996:18;;;76989:26;77068:6;;77065:756;;77166:22;:2;:20;:22::i;:::-;77151:37;;:11;:37;77145:1;77135:6;:11;;77134:55;77120:69;;77065:756;;;77289:1;77280:6;:10;77272:75;;;;-1:-1:-1;;;77272:75:0;;29051:2:1;77272:75:0;;;29033:21:1;29090:2;29070:18;;;29063:30;29129:34;29109:18;;;29102:62;-1:-1:-1;;;29180:18:1;;;29173:50;29240:19;;77272:75:0;28849:416:1;77272:75:0;-1:-1:-1;;;77399:8:0;;;77530:12;:20;;;;;;;;;;;77399:8;;-1:-1:-1;77590:6:0;;77587:207;;77696:22;:2;:20;:22::i;:::-;77689:3;:29;77672:47;;77683:1;77673:6;:11;;77672:47;77658:61;;77746:5;;77587:207;77241:569;;;76697:1131;;;76594:1234;;;;:::o;91203:1039::-;91390:6;-1:-1:-1;;;;;91413:13:0;;3777:19;:23;91409:826;;-1:-1:-1;91449:4:0;91490:12;91468:689;91514:23;91529:8;91514:12;:23;:::i;:::-;91504:7;:33;91468:689;;;91572:72;;-1:-1:-1;;;91572:72:0;;-1:-1:-1;;;;;91572:36:0;;;;;:72;;45738:10;;91623:4;;91629:7;;91638:5;;91572:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;91572:72:0;;;;;;;;-1:-1:-1;;91572:72:0;;;;;;;;;;;;:::i;:::-;;;91568:574;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;91828:6;:13;91845:1;91828:18;91824:299;;91875:63;;-1:-1:-1;;;91875:63:0;;;;;;;:::i;91824:299::-;92065:6;92059:13;92050:6;92046:2;92042:15;92035:38;91568:574;91696:1;:56;;;;-1:-1:-1;;;;;;;91701:51:0;;-1:-1:-1;;;91701:51:0;91696:56;91692:60;;91645:127;91539:9;;;;:::i;:::-;;;;91468:689;;;;92171:8;;91409:826;-1:-1:-1;92219:4:0;91409:826;91203:1039;;;;;;;:::o;41220:1520::-;41351:7;;42285:66;42272:79;;42268:163;;;-1:-1:-1;42384:1:0;;-1:-1:-1;42388:30:0;42368:51;;42268:163;42545:24;;;42528:14;42545:24;;;;;;;;;30245:25:1;;;30318:4;30306:17;;30286:18;;;30279:45;;;;30340:18;;;30333:34;;;30383:18;;;30376:34;;;42545:24:0;;30217:19:1;;42545:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;42545:24:0;;-1:-1:-1;;42545:24:0;;;-1:-1:-1;;;;;;;42584:20:0;;42580:103;;42637:1;42641:29;42621:50;;;;;;;42580:103;42703:6;-1:-1:-1;42711:20:0;;-1:-1:-1;41220:1520:0;;;;;;;;:::o;71277:201::-;71339:5;71395:16;;;;;;;;;;;;;;;;;71451:3;69793:64;71413:18;71428:2;71413:14;:18::i;:::-;:33;71412:42;;71395:60;;;;;;;;:::i;:::-;;;;;;;;71277:201;-1:-1:-1;;71277:201:0:o;70504:169::-;70563:7;70596:1;70591:2;:6;70583:15;;;;;;-1:-1:-1;70647:1:0;:6;;;70641:13;;70504:169::o;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;800:131::-;-1:-1:-1;;;;;875:31:1;;865:42;;855:70;;921:1;918;911:12;936:435;1003:6;1011;1064:2;1052:9;1043:7;1039:23;1035:32;1032:52;;;1080:1;1077;1070:12;1032:52;1119:9;1106:23;1138:31;1163:5;1138:31;:::i;:::-;1188:5;-1:-1:-1;1245:2:1;1230:18;;1217:32;-1:-1:-1;;;;;1280:40:1;;1268:53;;1258:81;;1335:1;1332;1325:12;1258:81;1358:7;1348:17;;;936:435;;;;;:::o;1376:615::-;1462:6;1470;1523:2;1511:9;1502:7;1498:23;1494:32;1491:52;;;1539:1;1536;1529:12;1491:52;1579:9;1566:23;-1:-1:-1;;;;;1649:2:1;1641:6;1638:14;1635:34;;;1665:1;1662;1655:12;1635:34;1703:6;1692:9;1688:22;1678:32;;1748:7;1741:4;1737:2;1733:13;1729:27;1719:55;;1770:1;1767;1760:12;1719:55;1810:2;1797:16;1836:2;1828:6;1825:14;1822:34;;;1852:1;1849;1842:12;1822:34;1905:7;1900:2;1890:6;1887:1;1883:14;1879:2;1875:23;1871:32;1868:45;1865:65;;;1926:1;1923;1916:12;1865:65;1957:2;1949:11;;;;;1979:6;;-1:-1:-1;1376:615:1;;-1:-1:-1;;;;1376:615:1:o;1996:250::-;2081:1;2091:113;2105:6;2102:1;2099:13;2091:113;;;2181:11;;;2175:18;2162:11;;;2155:39;2127:2;2120:10;2091:113;;;-1:-1:-1;;2238:1:1;2220:16;;2213:27;1996:250::o;2251:271::-;2293:3;2331:5;2325:12;2358:6;2353:3;2346:19;2374:76;2443:6;2436:4;2431:3;2427:14;2420:4;2413:5;2409:16;2374:76;:::i;:::-;2504:2;2483:15;-1:-1:-1;;2479:29:1;2470:39;;;;2511:4;2466:50;;2251:271;-1:-1:-1;;2251:271:1:o;2527:220::-;2676:2;2665:9;2658:21;2639:4;2696:45;2737:2;2726:9;2722:18;2714:6;2696:45;:::i;2752:180::-;2811:6;2864:2;2852:9;2843:7;2839:23;2835:32;2832:52;;;2880:1;2877;2870:12;2832:52;-1:-1:-1;2903:23:1;;2752:180;-1:-1:-1;2752:180:1:o;2937:315::-;3005:6;3013;3066:2;3054:9;3045:7;3041:23;3037:32;3034:52;;;3082:1;3079;3072:12;3034:52;3121:9;3108:23;3140:31;3165:5;3140:31;:::i;:::-;3190:5;3242:2;3227:18;;;;3214:32;;-1:-1:-1;;;2937:315:1:o;3257:163::-;3324:20;;3384:10;3373:22;;3363:33;;3353:61;;3410:1;3407;3400:12;3425:319;3492:6;3500;3553:2;3541:9;3532:7;3528:23;3524:32;3521:52;;;3569:1;3566;3559:12;3521:52;3608:9;3595:23;3627:31;3652:5;3627:31;:::i;:::-;3677:5;-1:-1:-1;3701:37:1;3734:2;3719:18;;3701:37;:::i;:::-;3691:47;;3425:319;;;;;:::o;3931:247::-;3990:6;4043:2;4031:9;4022:7;4018:23;4014:32;4011:52;;;4059:1;4056;4049:12;4011:52;4098:9;4085:23;4117:31;4142:5;4117:31;:::i;4183:456::-;4260:6;4268;4276;4329:2;4317:9;4308:7;4304:23;4300:32;4297:52;;;4345:1;4342;4335:12;4297:52;4384:9;4371:23;4403:31;4428:5;4403:31;:::i;:::-;4453:5;-1:-1:-1;4510:2:1;4495:18;;4482:32;4523:33;4482:32;4523:33;:::i;:::-;4183:456;;4575:7;;-1:-1:-1;;;4629:2:1;4614:18;;;;4601:32;;4183:456::o;4644:248::-;4712:6;4720;4773:2;4761:9;4752:7;4748:23;4744:32;4741:52;;;4789:1;4786;4779:12;4741:52;-1:-1:-1;;4812:23:1;;;4882:2;4867:18;;;4854:32;;-1:-1:-1;4644:248:1:o;5176:452::-;5262:6;5270;5278;5286;5339:3;5327:9;5318:7;5314:23;5310:33;5307:53;;;5356:1;5353;5346:12;5307:53;5395:9;5382:23;5414:31;5439:5;5414:31;:::i;:::-;5464:5;5516:2;5501:18;;5488:32;;-1:-1:-1;5567:2:1;5552:18;;5539:32;;5618:2;5603:18;5590:32;;-1:-1:-1;5176:452:1;-1:-1:-1;;;5176:452:1:o;5815:118::-;5901:5;5894:13;5887:21;5880:5;5877:32;5867:60;;5923:1;5920;5913:12;5938:382;6003:6;6011;6064:2;6052:9;6043:7;6039:23;6035:32;6032:52;;;6080:1;6077;6070:12;6032:52;6119:9;6106:23;6138:31;6163:5;6138:31;:::i;:::-;6188:5;-1:-1:-1;6245:2:1;6230:18;;6217:32;6258:30;6217:32;6258:30;:::i;6325:241::-;6381:6;6434:2;6422:9;6413:7;6409:23;6405:32;6402:52;;;6450:1;6447;6440:12;6402:52;6489:9;6476:23;6508:28;6530:5;6508:28;:::i;6571:127::-;6632:10;6627:3;6623:20;6620:1;6613:31;6663:4;6660:1;6653:15;6687:4;6684:1;6677:15;6703:1266;6798:6;6806;6814;6822;6875:3;6863:9;6854:7;6850:23;6846:33;6843:53;;;6892:1;6889;6882:12;6843:53;6931:9;6918:23;6950:31;6975:5;6950:31;:::i;:::-;7000:5;-1:-1:-1;7057:2:1;7042:18;;7029:32;7070:33;7029:32;7070:33;:::i;:::-;7122:7;-1:-1:-1;7176:2:1;7161:18;;7148:32;;-1:-1:-1;7231:2:1;7216:18;;7203:32;-1:-1:-1;;;;;7284:14:1;;;7281:34;;;7311:1;7308;7301:12;7281:34;7349:6;7338:9;7334:22;7324:32;;7394:7;7387:4;7383:2;7379:13;7375:27;7365:55;;7416:1;7413;7406:12;7365:55;7452:2;7439:16;7474:2;7470;7467:10;7464:36;;;7480:18;;:::i;:::-;7555:2;7549:9;7523:2;7609:13;;-1:-1:-1;;7605:22:1;;;7629:2;7601:31;7597:40;7585:53;;;7653:18;;;7673:22;;;7650:46;7647:72;;;7699:18;;:::i;:::-;7739:10;7735:2;7728:22;7774:2;7766:6;7759:18;7814:7;7809:2;7804;7800;7796:11;7792:20;7789:33;7786:53;;;7835:1;7832;7825:12;7786:53;7891:2;7886;7882;7878:11;7873:2;7865:6;7861:15;7848:46;7936:1;7931:2;7926;7918:6;7914:15;7910:24;7903:35;7957:6;7947:16;;;;;;;6703:1266;;;;;;;:::o;7974:184::-;8032:6;8085:2;8073:9;8064:7;8060:23;8056:32;8053:52;;;8101:1;8098;8091:12;8053:52;8124:28;8142:9;8124:28;:::i;8163:388::-;8231:6;8239;8292:2;8280:9;8271:7;8267:23;8263:32;8260:52;;;8308:1;8305;8298:12;8260:52;8347:9;8334:23;8366:31;8391:5;8366:31;:::i;:::-;8416:5;-1:-1:-1;8473:2:1;8458:18;;8445:32;8486:33;8445:32;8486:33;:::i;8556:865::-;8662:6;8670;8678;8686;8694;8702;8755:3;8743:9;8734:7;8730:23;8726:33;8723:53;;;8772:1;8769;8762:12;8723:53;8808:9;8795:23;8785:33;;8865:2;8854:9;8850:18;8837:32;8827:42;;8916:2;8905:9;8901:18;8888:32;8878:42;;8967:2;8956:9;8952:18;8939:32;8929:42;;9022:3;9011:9;9007:19;8994:33;-1:-1:-1;;;;;9087:2:1;9079:6;9076:14;9073:34;;;9103:1;9100;9093:12;9073:34;9141:6;9130:9;9126:22;9116:32;;9186:7;9179:4;9175:2;9171:13;9167:27;9157:55;;9208:1;9205;9198:12;9157:55;9248:2;9235:16;9274:2;9266:6;9263:14;9260:34;;;9290:1;9287;9280:12;9260:34;9335:7;9330:2;9321:6;9317:2;9313:15;9309:24;9306:37;9303:57;;;9356:1;9353;9346:12;9303:57;9387:2;9383;9379:11;9369:21;;9409:6;9399:16;;;;;8556:865;;;;;;;;:::o;9623:127::-;9684:10;9679:3;9675:20;9672:1;9665:31;9715:4;9712:1;9705:15;9739:4;9736:1;9729:15;9755:251;9825:6;9878:2;9866:9;9857:7;9853:23;9849:32;9846:52;;;9894:1;9891;9884:12;9846:52;9926:9;9920:16;9945:31;9970:5;9945:31;:::i;10011:127::-;10072:10;10067:3;10063:20;10060:1;10053:31;10103:4;10100:1;10093:15;10127:4;10124:1;10117:15;10143:135;10182:3;10203:17;;;10200:43;;10223:18;;:::i;:::-;-1:-1:-1;10270:1:1;10259:13;;10143:135::o;10283:380::-;10362:1;10358:12;;;;10405;;;10426:61;;10480:4;10472:6;10468:17;10458:27;;10426:61;10533:2;10525:6;10522:14;10502:18;10499:38;10496:161;;10579:10;10574:3;10570:20;10567:1;10560:31;10614:4;10611:1;10604:15;10642:4;10639:1;10632:15;10496:161;;10283:380;;;:::o;11393:245::-;11460:6;11513:2;11501:9;11492:7;11488:23;11484:32;11481:52;;;11529:1;11526;11519:12;11481:52;11561:9;11555:16;11580:28;11602:5;11580:28;:::i;11643:128::-;11710:9;;;11731:11;;;11728:37;;;11745:18;;:::i;11776:168::-;11816:7;11882:1;11878;11874:6;11870:14;11867:1;11864:21;11859:1;11852:9;11845:17;11841:45;11838:71;;;11889:18;;:::i;:::-;-1:-1:-1;11929:9:1;;11776:168::o;12081:217::-;12121:1;12147;12137:132;;12191:10;12186:3;12182:20;12179:1;12172:31;12226:4;12223:1;12216:15;12254:4;12251:1;12244:15;12137:132;-1:-1:-1;12283:9:1;;12081:217::o;14473:175::-;14541:10;14584;;;14572;;;14568:27;;14607:12;;;14604:38;;;14622:18;;:::i;15059:410::-;15261:2;15243:21;;;15300:2;15280:18;;;15273:30;15339:34;15334:2;15319:18;;15312:62;-1:-1:-1;;;15405:2:1;15390:18;;15383:44;15459:3;15444:19;;15059:410::o;16624:530::-;-1:-1:-1;;16935:2:1;16931:15;;;16927:24;;16915:37;;16977:2;16968:12;;16961:28;;;;17014:2;17005:12;;16998:28;;;;17051:2;17042:12;;17035:28;;;;17098:15;;;17094:24;17088:3;17079:13;;17072:47;17144:3;17135:13;;16624:530::o;17570:496::-;17749:3;17787:6;17781:13;17803:66;17862:6;17857:3;17850:4;17842:6;17838:17;17803:66;:::i;:::-;17932:13;;17891:16;;;;17954:70;17932:13;17891:16;18001:4;17989:17;;17954:70;:::i;:::-;18040:20;;17570:496;-1:-1:-1;;;;17570:496:1:o;18478:125::-;18543:9;;;18564:10;;;18561:36;;;18577:18;;:::i;18608:183::-;-1:-1:-1;;;;;18727:10:1;;;18715;;;18711:27;;18750:12;;;18747:38;;;18765:18;;:::i;19922:180::-;-1:-1:-1;;;;;20027:10:1;;;20039;;;20023:27;;20062:11;;;20059:37;;;20076:18;;:::i;20917:416::-;21119:2;21101:21;;;21158:2;21138:18;;;21131:30;21197:34;21192:2;21177:18;;21170:62;-1:-1:-1;;;21263:2:1;21248:18;;21241:50;21323:3;21308:19;;20917:416::o;21338:407::-;21540:2;21522:21;;;21579:2;21559:18;;;21552:30;21618:34;21613:2;21598:18;;21591:62;-1:-1:-1;;;21684:2:1;21669:18;;21662:41;21735:3;21720:19;;21338:407::o;25101:545::-;25203:2;25198:3;25195:11;25192:448;;;25239:1;25264:5;25260:2;25253:17;25309:4;25305:2;25295:19;25379:2;25367:10;25363:19;25360:1;25356:27;25350:4;25346:38;25415:4;25403:10;25400:20;25397:47;;;-1:-1:-1;25438:4:1;25397:47;25493:2;25488:3;25484:12;25481:1;25477:20;25471:4;25467:31;25457:41;;25548:82;25566:2;25559:5;25556:13;25548:82;;;25611:17;;;25592:1;25581:13;25548:82;;25822:1352;25948:3;25942:10;-1:-1:-1;;;;;25967:6:1;25964:30;25961:56;;;25997:18;;:::i;:::-;26026:97;26116:6;26076:38;26108:4;26102:11;26076:38;:::i;:::-;26070:4;26026:97;:::i;:::-;26178:4;;26242:2;26231:14;;26259:1;26254:663;;;;26961:1;26978:6;26975:89;;;-1:-1:-1;27030:19:1;;;27024:26;26975:89;-1:-1:-1;;25779:1:1;25775:11;;;25771:24;25767:29;25757:40;25803:1;25799:11;;;25754:57;27077:81;;26224:944;;26254:663;25048:1;25041:14;;;25085:4;25072:18;;-1:-1:-1;;26290:20:1;;;26408:236;26422:7;26419:1;26416:14;26408:236;;;26511:19;;;26505:26;26490:42;;26603:27;;;;26571:1;26559:14;;;;26438:19;;26408:236;;;26412:3;26672:6;26663:7;26660:19;26657:201;;;26733:19;;;26727:26;-1:-1:-1;;26816:1:1;26812:14;;;26828:3;26808:24;26804:37;26800:42;26785:58;26770:74;;26657:201;-1:-1:-1;;;;;26904:1:1;26888:14;;;26884:22;26871:36;;-1:-1:-1;25822:1352:1:o;27179:417::-;27381:2;27363:21;;;27420:2;27400:18;;;27393:30;27459:34;27454:2;27439:18;;27432:62;-1:-1:-1;;;27525:2:1;27510:18;;27503:51;27586:3;27571:19;;27179:417::o;27601:127::-;27662:10;27657:3;27653:20;27650:1;27643:31;27693:4;27690:1;27683:15;27717:4;27714:1;27707:15;29270:489;-1:-1:-1;;;;;29539:15:1;;;29521:34;;29591:15;;29586:2;29571:18;;29564:43;29638:2;29623:18;;29616:34;;;29686:3;29681:2;29666:18;;29659:31;;;29464:4;;29707:46;;29733:19;;29725:6;29707:46;:::i;:::-;29699:54;29270:489;-1:-1:-1;;;;;;29270:489:1:o;29764:249::-;29833:6;29886:2;29874:9;29865:7;29861:23;29857:32;29854:52;;;29902:1;29899;29892:12;29854:52;29934:9;29928:16;29953:30;29977:5;29953:30;:::i
Swarm Source
ipfs://79dd9a742275e466e42a19eae33a92b86eea2568c550dbf6acf97108b4c07280
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.