Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 25 from a total of 152 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Set Approval For... | 16391561 | 603 days ago | IN | 0 ETH | 0.00092667 | ||||
Free_mint | 16387967 | 604 days ago | IN | 0 ETH | 0.0024678 | ||||
Set Approval For... | 16383010 | 604 days ago | IN | 0 ETH | 0.0007548 | ||||
Free_mint | 16382343 | 605 days ago | IN | 0 ETH | 0.00259408 | ||||
Free_mint | 16382237 | 605 days ago | IN | 0 ETH | 0.00255534 | ||||
Free_mint | 16382170 | 605 days ago | IN | 0 ETH | 0.00201653 | ||||
Free_mint | 16382012 | 605 days ago | IN | 0 ETH | 0.00232365 | ||||
Free_mint | 16382011 | 605 days ago | IN | 0 ETH | 0.00221921 | ||||
Free_mint | 16382007 | 605 days ago | IN | 0 ETH | 0.00226235 | ||||
Free_mint | 16381893 | 605 days ago | IN | 0 ETH | 0.00234226 | ||||
Free_mint | 16381891 | 605 days ago | IN | 0 ETH | 0.00234226 | ||||
Free_mint | 16381891 | 605 days ago | IN | 0 ETH | 0.00234226 | ||||
Free_mint | 16381889 | 605 days ago | IN | 0 ETH | 0.00224185 | ||||
Free_mint | 16381887 | 605 days ago | IN | 0 ETH | 0.00217069 | ||||
Free_mint | 16381859 | 605 days ago | IN | 0 ETH | 0.00247969 | ||||
Free_mint | 16381847 | 605 days ago | IN | 0 ETH | 0.00234226 | ||||
Free_mint | 16381847 | 605 days ago | IN | 0 ETH | 0.00249995 | ||||
Free_mint | 16381846 | 605 days ago | IN | 0 ETH | 0.00234226 | ||||
Free_mint | 16381846 | 605 days ago | IN | 0 ETH | 0.00234226 | ||||
Free_mint | 16381846 | 605 days ago | IN | 0 ETH | 0.002484 | ||||
Free_mint | 16381845 | 605 days ago | IN | 0 ETH | 0.00246084 | ||||
Free_mint | 16381844 | 605 days ago | IN | 0 ETH | 0.00221822 | ||||
Free_mint | 16381805 | 605 days ago | IN | 0 ETH | 0.00266689 | ||||
Free_mint | 16381802 | 605 days ago | IN | 0 ETH | 0.00253828 | ||||
Free_mint | 16381802 | 605 days ago | IN | 0 ETH | 0.00253828 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
TorusInMotion
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-01-11 */ // File: 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: OperatorFilterer.sol pragma solidity ^0.8.13; /** * @title OperatorFilterer * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another * registrant's entries in the OperatorFilterRegistry. * @dev This smart contract is meant to be inherited by token contracts so they can use the following: * - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods. * - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods. */ abstract contract OperatorFilterer { error OperatorNotAllowed(address operator); IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E); constructor(address subscriptionOrRegistrantToCopy, bool subscribe) { // If an inheriting token contract is deployed to a network without the registry deployed, the modifier // will not revert, but the contract will need to be registered with the registry once it is deployed in // order for the modifier to filter addresses. if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) { if (subscribe) { OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy); } else { if (subscriptionOrRegistrantToCopy != address(0)) { OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy); } else { OPERATOR_FILTER_REGISTRY.register(address(this)); } } } } modifier onlyAllowedOperator(address from) virtual { // 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) { _checkFilterOperator(msg.sender); } _; } modifier onlyAllowedOperatorApproval(address operator) virtual { _checkFilterOperator(operator); _; } function _checkFilterOperator(address operator) internal view virtual { // Check registry code length to facilitate testing in environments without a deployed registry. if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) { if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) { revert OperatorNotAllowed(operator); } } } } // File: DefaultOperatorFilterer.sol pragma solidity ^0.8.13; /** * @title DefaultOperatorFilterer * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription. */ abstract contract DefaultOperatorFilterer is OperatorFilterer { address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6); constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {} } // File: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _ownerOf(tokenId); require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner or approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory data ) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _safeTransfer(from, to, tokenId, data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory data ) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { return _owners[tokenId]; } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _ownerOf(tokenId) != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId, 1); // Check that tokenId was not minted by `_beforeTokenTransfer` hook require(!_exists(tokenId), "ERC721: token already minted"); unchecked { // Will not overflow unless all 2**256 token ids are minted to the same owner. // Given that tokens are minted one by one, it is impossible in practice that // this ever happens. Might change if we allow batch minting. // The ERC fails to describe this case. _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId, 1); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId, 1); // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook owner = ERC721.ownerOf(tokenId); // Clear approvals delete _tokenApprovals[tokenId]; unchecked { // Cannot overflow, as that would require more tokens to be burned/transferred // out than the owner initially received through minting and transferring in. _balances[owner] -= 1; } delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId, 1); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId, 1); // Check that tokenId was not transferred by `_beforeTokenTransfer` hook require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); // Clear approvals from the previous owner delete _tokenApprovals[tokenId]; unchecked { // `_balances[from]` cannot overflow for the same reason as described in `_burn`: // `from`'s balance is the number of token held, which is at least one before the current // transfer. // `_balances[to]` could overflow in the conditions described in `_mint`. That would require // all 2**256 token ids to be minted, which in practice is impossible. _balances[from] -= 1; _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`. * - When `from` is zero, the tokens will be minted for `to`. * - When `to` is zero, ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256, /* firstTokenId */ uint256 batchSize ) internal virtual { if (batchSize > 1) { if (from != address(0)) { _balances[from] -= batchSize; } if (to != address(0)) { _balances[to] += batchSize; } } } /** * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`. * - When `from` is zero, the tokens were minted for `to`. * - When `to` is zero, ``from``'s tokens were burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual {} } // File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol) pragma solidity ^0.8.0; /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds * enumerability of all the token ids in the contract as well as all token ids owned by each * account. */ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable { // Mapping from owner to list of owned token IDs mapping(address => mapping(uint256 => uint256)) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds"); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds"); return _allTokens[index]; } /** * @dev See {ERC721-_beforeTokenTransfer}. */ function _beforeTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual override { super._beforeTokenTransfer(from, to, firstTokenId, batchSize); if (batchSize > 1) { // Will only trigger during construction. Batch transferring (minting) is not available afterwards. revert("ERC721Enumerable: consecutive transfers not supported"); } uint256 tokenId = firstTokenId; if (from == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (from != to) { _removeTokenFromOwnerEnumeration(from, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (to != from) { _addTokenToOwnerEnumeration(to, tokenId); } } /** * @dev Private function to add a token to this extension's ownership-tracking data structures. * @param to address representing the new owner of the given token ID * @param tokenId uint256 ID of the token to be added to the tokens list of the given address */ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = ERC721.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; } /** * @dev Private function to add a token to this extension's token tracking data structures. * @param tokenId uint256 ID of the token to be added to the tokens list */ function _addTokenToAllTokensEnumeration(uint256 tokenId) private { _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } /** * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for * gas optimizations e.g. when performing a transfer operation (avoiding double writes). * This has O(1) time complexity, but alters the order of the _ownedTokens array. * @param from address representing the previous owner of the given token ID * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = ERC721.balanceOf(from) - 1; uint256 tokenIndex = _ownedTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index } // This also deletes the contents at the last position of the array delete _ownedTokensIndex[tokenId]; delete _ownedTokens[from][lastTokenIndex]; } /** * @dev Private function to remove a token from this extension's token tracking data structures. * This has O(1) time complexity, but alters the order of the _allTokens array. * @param tokenId uint256 ID of the token to be removed from the tokens list */ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = _allTokens.length - 1; uint256 tokenIndex = _allTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding // an 'if' statement (like in _removeTokenFromOwnerEnumeration) uint256 lastTokenId = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index // This also deletes the contents at the last position of the array delete _allTokensIndex[tokenId]; _allTokens.pop(); } } // File: TERC721.sol pragma solidity ^0.8.13; contract TorusInMotion is ERC721Enumerable, DefaultOperatorFilterer { address public owner = msg.sender; uint256 public supply = 999; uint256 public free_supply = 333; uint256 public price = 3000000000000000; string public base_uri = "https://torus-in-motion.s3.amazonaws.com/"; uint256 public latest_token_id = 0; modifier only_owner() { require(msg.sender == owner, "This function is restricted to the owner"); _; } constructor() ERC721("Torus in Motion", "TIM") { owner = msg.sender; } function set_price(uint256 _price) external only_owner { price = _price; } function set_free_supply(uint256 _free_supply) external only_owner { free_supply = _free_supply; } function set_base_uri(string memory new_uri) external only_owner { base_uri = new_uri; } function mint(address wallet, uint256 n_items) internal { require(latest_token_id + n_items <= supply, "Can't mint requested amount!"); for (uint256 i = 0; i < n_items; i++) { latest_token_id++; _mint(wallet, latest_token_id); } } function free_mint() public { require(latest_token_id < free_supply, "No more free mints!"); mint(msg.sender, 1); } function public_mint(uint256 n_items) external payable { require(msg.value >= price * n_items, "Not enough eth sent!"); mint(msg.sender, n_items); } function admin_mint(address wallet, uint256 n_items) external only_owner { mint(wallet, n_items); } function _baseURI() internal view override returns (string memory) { return base_uri; } function contractURI() public pure returns (string memory) { return "https://torus-in-motion.s3.amazonaws.com/"; } function withdraw(address payable wallet) public only_owner { uint256 amount = address(this).balance; wallet.transfer(amount); emit Transfer(address(this), wallet, amount); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"uint256","name":"n_items","type":"uint256"}],"name":"admin_mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"base_uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"free_mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"free_supply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latest_token_id","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"n_items","type":"uint256"}],"name":"public_mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"new_uri","type":"string"}],"name":"set_base_uri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_free_supply","type":"uint256"}],"name":"set_free_supply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"set_price","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"supply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"wallet","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
65121:2103:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59128:224;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65238:27;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43190:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44702:171;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44220:416;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59768:113;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45402:335;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65702:88;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59436:256;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2869:143;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45808:185;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66470:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59958:233;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67015:206;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42900:223;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65272:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42631:207;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65357:68;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65196:33;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43359:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65311:39;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44945:155;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66324:138;;;;;;;;;;;;;:::i;:::-;;65918:102;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46064:322;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43534:281;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;65798:112;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;65434:34;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66879:128;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45171:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66649:113;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59128:224;59230:4;59269:35;59254:50;;;:11;:50;;;;:90;;;;59308:36;59332:11;59308:23;:36::i;:::-;59254:90;59247:97;;59128:224;;;:::o;65238:27::-;;;;:::o;43190:100::-;43244:13;43277:5;43270:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43190:100;:::o;44702:171::-;44778:7;44798:23;44813:7;44798:14;:23::i;:::-;44841:15;:24;44857:7;44841:24;;;;;;;;;;;;;;;;;;;;;44834:31;;44702:171;;;:::o;44220:416::-;44301:13;44317:23;44332:7;44317:14;:23::i;:::-;44301:39;;44365:5;44359:11;;:2;:11;;;44351:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;44459:5;44443:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;44468:37;44485:5;44492:12;:10;:12::i;:::-;44468:16;:37::i;:::-;44443:62;44421:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;44607:21;44616:2;44620:7;44607:8;:21::i;:::-;44290:346;44220:416;;:::o;59768:113::-;59829:7;59856:10;:17;;;;59849:24;;59768:113;:::o;45402:335::-;45597:41;45616:12;:10;:12::i;:::-;45630:7;45597:18;:41::i;:::-;45589:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;45701:28;45711:4;45717:2;45721:7;45701:9;:28::i;:::-;45402:335;;;:::o;65702:88::-;65532:5;;;;;;;;;;;65518:19;;:10;:19;;;65510:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;65776:6:::1;65768:5;:14;;;;65702:88:::0;:::o;59436:256::-;59533:7;59569:23;59586:5;59569:16;:23::i;:::-;59561:5;:31;59553:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;59658:12;:19;59671:5;59658:19;;;;;;;;;;;;;;;:26;59678:5;59658:26;;;;;;;;;;;;59651:33;;59436:256;;;;:::o;2869:143::-;2969:42;2869:143;:::o;45808:185::-;45946:39;45963:4;45969:2;45973:7;45946:39;;;;;;;;;;;;:16;:39::i;:::-;45808:185;;;:::o;66470:171::-;66565:7;66557:5;;:15;;;;:::i;:::-;66544:9;:28;;66536:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;66608:25;66613:10;66625:7;66608:4;:25::i;:::-;66470:171;:::o;59958:233::-;60033:7;60069:30;:28;:30::i;:::-;60061:5;:38;60053:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;60166:10;60177:5;60166:17;;;;;;;;:::i;:::-;;;;;;;;;;60159:24;;59958:233;;;:::o;67015:206::-;65532:5;;;;;;;;;;;65518:19;;:10;:19;;;65510:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;67086:14:::1;67103:21;67086:38;;67135:6;:15;;:23;67151:6;67135:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;67206:6;67198;67174:39;;67191:4;67174:39;;;;;;;;;;;;67075:146;67015:206:::0;:::o;42900:223::-;42972:7;42992:13;43008:17;43017:7;43008:8;:17::i;:::-;42992:33;;43061:1;43044:19;;:5;:19;;;43036:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;43110:5;43103:12;;;42900:223;;;:::o;65272:32::-;;;;:::o;42631:207::-;42703:7;42748:1;42731:19;;:5;:19;;;42723:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;42814:9;:16;42824:5;42814:16;;;;;;;;;;;;;;;;42807:23;;42631:207;;;:::o;65357:68::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;65196:33::-;;;;;;;;;;;;;:::o;43359:104::-;43415:13;43448:7;43441:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43359:104;:::o;65311:39::-;;;;:::o;44945:155::-;45040:52;45059:12;:10;:12::i;:::-;45073:8;45083;45040:18;:52::i;:::-;44945:155;;:::o;66324:138::-;66389:11;;66371:15;;:29;66363:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;66435:19;66440:10;66452:1;66435:4;:19::i;:::-;66324:138::o;65918:102::-;65532:5;;;;;;;;;;;65518:19;;:10;:19;;;65510:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;66005:7:::1;65994:8;:18;;;;;;:::i;:::-;;65918:102:::0;:::o;46064:322::-;46238:41;46257:12;:10;:12::i;:::-;46271:7;46238:18;:41::i;:::-;46230:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;46340:38;46354:4;46360:2;46364:7;46373:4;46340:13;:38::i;:::-;46064:322;;;;:::o;43534:281::-;43607:13;43633:23;43648:7;43633:14;:23::i;:::-;43669:21;43693:10;:8;:10::i;:::-;43669:34;;43745:1;43727:7;43721:21;:25;:86;;;;;;;;;;;;;;;;;43773:7;43782:18;:7;:16;:18::i;:::-;43756:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;43721:86;43714:93;;;43534:281;;;:::o;65798:112::-;65532:5;;;;;;;;;;;65518:19;;:10;:19;;;65510:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;65890:12:::1;65876:11;:26;;;;65798:112:::0;:::o;65434:34::-;;;;:::o;66879:128::-;66923:13;66949:50;;;;;;;;;;;;;;;;;;;66879:128;:::o;45171:164::-;45268:4;45292:18;:25;45311:5;45292:25;;;;;;;;;;;;;;;:35;45318:8;45292:35;;;;;;;;;;;;;;;;;;;;;;;;;45285:42;;45171:164;;;;:::o;66649:113::-;65532:5;;;;;;;;;;;65518:19;;:10;:19;;;65510:72;;;;;;;;;;;;:::i;:::-;;;;;;;;;66733:21:::1;66738:6;66746:7;66733:4;:21::i;:::-;66649:113:::0;;:::o;42262:305::-;42364:4;42416:25;42401:40;;;:11;:40;;;;:105;;;;42473:33;42458:48;;;:11;:48;;;;42401:105;:158;;;;42523:36;42547:11;42523:23;:36::i;:::-;42401:158;42381:178;;42262:305;;;:::o;54521:135::-;54603:16;54611:7;54603;:16::i;:::-;54595:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;54521:135;:::o;21216:98::-;21269:7;21296:10;21289:17;;21216:98;:::o;53800:174::-;53902:2;53875:15;:24;53891:7;53875:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;53958:7;53954:2;53920:46;;53929:23;53944:7;53929:14;:23::i;:::-;53920:46;;;;;;;;;;;;53800:174;;:::o;48419:264::-;48512:4;48529:13;48545:23;48560:7;48545:14;:23::i;:::-;48529:39;;48598:5;48587:16;;:7;:16;;;:52;;;;48607:32;48624:5;48631:7;48607:16;:32::i;:::-;48587:52;:87;;;;48667:7;48643:31;;:20;48655:7;48643:11;:20::i;:::-;:31;;;48587:87;48579:96;;;48419:264;;;;:::o;52418:1263::-;52577:4;52550:31;;:23;52565:7;52550:14;:23::i;:::-;:31;;;52542:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;52656:1;52642:16;;:2;:16;;;52634:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;52712:42;52733:4;52739:2;52743:7;52752:1;52712:20;:42::i;:::-;52884:4;52857:31;;:23;52872:7;52857:14;:23::i;:::-;:31;;;52849:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;53002:15;:24;53018:7;53002:24;;;;;;;;;;;;52995:31;;;;;;;;;;;53497:1;53478:9;:15;53488:4;53478:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;53530:1;53513:9;:13;53523:2;53513:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;53572:2;53553:7;:16;53561:7;53553:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;53611:7;53607:2;53592:27;;53601:4;53592:27;;;;;;;;;;;;53632:41;53652:4;53658:2;53662:7;53671:1;53632:19;:41::i;:::-;52418:1263;;;:::o;66028:288::-;66132:6;;66121:7;66103:15;;:25;;;;:::i;:::-;:35;;66095:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;66187:9;66182:127;66206:7;66202:1;:11;66182:127;;;66235:15;;:17;;;;;;;;;:::i;:::-;;;;;;66267:30;66273:6;66281:15;;66267:5;:30::i;:::-;66215:3;;;;;:::i;:::-;;;;66182:127;;;;66028:288;;:::o;47694:117::-;47760:7;47787;:16;47795:7;47787:16;;;;;;;;;;;;;;;;;;;;;47780:23;;47694:117;;;:::o;54117:315::-;54272:8;54263:17;;:5;:17;;;54255:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;54359:8;54321:18;:25;54340:5;54321:25;;;;;;;;;;;;;;;:35;54347:8;54321:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;54405:8;54383:41;;54398:5;54383:41;;;54415:8;54383:41;;;;;;:::i;:::-;;;;;;;;54117:315;;;:::o;47267:313::-;47423:28;47433:4;47439:2;47443:7;47423:9;:28::i;:::-;47470:47;47493:4;47499:2;47503:7;47512:4;47470:22;:47::i;:::-;47462:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;47267:313;;;;:::o;66770:101::-;66822:13;66855:8;66848:15;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66770:101;:::o;18643:716::-;18699:13;18750:14;18787:1;18767:17;18778:5;18767:10;:17::i;:::-;:21;18750:38;;18803:20;18837:6;18826:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18803:41;;18859:11;18988:6;18984:2;18980:15;18972:6;18968:28;18961:35;;19025:288;19032:4;19025:288;;;19057:5;;;;;;;;19199:8;19194:2;19187:5;19183:14;19178:30;19173:3;19165:44;19255:2;19246:11;;;;;;:::i;:::-;;;;;19289:1;19280:5;:10;19025:288;19276:21;19025:288;19334:6;19327:13;;;;;18643:716;;;:::o;33694:157::-;33779:4;33818:25;33803:40;;;:11;:40;;;;33796:47;;33694:157;;;:::o;48124:128::-;48189:4;48242:1;48213:31;;:17;48222:7;48213:8;:17::i;:::-;:31;;;;48206:38;;48124:128;;;:::o;60265:915::-;60442:61;60469:4;60475:2;60479:12;60493:9;60442:26;:61::i;:::-;60532:1;60520:9;:13;60516:222;;;60663:63;;;;;;;;;;:::i;:::-;;;;;;;;60516:222;60750:15;60768:12;60750:30;;60813:1;60797:18;;:4;:18;;;60793:187;;60832:40;60864:7;60832:31;:40::i;:::-;60793:187;;;60902:2;60894:10;;:4;:10;;;60890:90;;60921:47;60954:4;60960:7;60921:32;:47::i;:::-;60890:90;60793:187;61008:1;60994:16;;:2;:16;;;60990:183;;61027:45;61064:7;61027:36;:45::i;:::-;60990:183;;;61100:4;61094:10;;:2;:10;;;61090:83;;61121:40;61149:2;61153:7;61121:27;:40::i;:::-;61090:83;60990:183;60431:749;60265:915;;;;:::o;57937:158::-;;;;;:::o;50017:942::-;50111:1;50097:16;;:2;:16;;;50089:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;50170:16;50178:7;50170;:16::i;:::-;50169:17;50161:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;50232:48;50261:1;50265:2;50269:7;50278:1;50232:20;:48::i;:::-;50379:16;50387:7;50379;:16::i;:::-;50378:17;50370:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;50794:1;50777:9;:13;50787:2;50777:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;50838:2;50819:7;:16;50827:7;50819:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;50883:7;50879:2;50858:33;;50875:1;50858:33;;;;;;;;;;;;50904:47;50932:1;50936:2;50940:7;50949:1;50904:19;:47::i;:::-;50017:942;;:::o;55220:853::-;55374:4;55395:15;:2;:13;;;:15::i;:::-;55391:675;;;55447:2;55431:36;;;55468:12;:10;:12::i;:::-;55482:4;55488:7;55497:4;55431:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;55427:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55689:1;55672:6;:13;:18;55668:328;;55715:60;;;;;;;;;;:::i;:::-;;;;;;;;55668:328;55946:6;55940:13;55931:6;55927:2;55923:15;55916:38;55427:584;55563:41;;;55553:51;;;:6;:51;;;;55546:58;;;;;55391:675;56050:4;56043:11;;55220:853;;;;;;;:::o;15509:922::-;15562:7;15582:14;15599:1;15582:18;;15649:6;15640:5;:15;15636:102;;15685:6;15676:15;;;;;;:::i;:::-;;;;;15720:2;15710:12;;;;15636:102;15765:6;15756:5;:15;15752:102;;15801:6;15792:15;;;;;;:::i;:::-;;;;;15836:2;15826:12;;;;15752:102;15881:6;15872:5;:15;15868:102;;15917:6;15908:15;;;;;;:::i;:::-;;;;;15952:2;15942:12;;;;15868:102;15997:5;15988;:14;15984:99;;16032:5;16023:14;;;;;;:::i;:::-;;;;;16066:1;16056:11;;;;15984:99;16110:5;16101;:14;16097:99;;16145:5;16136:14;;;;;;:::i;:::-;;;;;16179:1;16169:11;;;;16097:99;16223:5;16214;:14;16210:99;;16258:5;16249:14;;;;;;:::i;:::-;;;;;16292:1;16282:11;;;;16210:99;16336:5;16327;:14;16323:66;;16372:1;16362:11;;;;16323:66;16417:6;16410:13;;;15509:922;;;:::o;56805:410::-;56995:1;56983:9;:13;56979:229;;;57033:1;57017:18;;:4;:18;;;57013:87;;57075:9;57056;:15;57066:4;57056:15;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;57013:87;57132:1;57118:16;;:2;:16;;;57114:83;;57172:9;57155;:13;57165:2;57155:13;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;57114:83;56979:229;56805:410;;;;:::o;61903:164::-;62007:10;:17;;;;61980:15;:24;61996:7;61980:24;;;;;;;;;;;:44;;;;62035:10;62051:7;62035:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61903:164;:::o;62694:988::-;62960:22;63010:1;62985:22;63002:4;62985:16;:22::i;:::-;:26;;;;:::i;:::-;62960:51;;63022:18;63043:17;:26;63061:7;63043:26;;;;;;;;;;;;63022:47;;63190:14;63176:10;:28;63172:328;;63221:19;63243:12;:18;63256:4;63243:18;;;;;;;;;;;;;;;:34;63262:14;63243:34;;;;;;;;;;;;63221:56;;63327:11;63294:12;:18;63307:4;63294:18;;;;;;;;;;;;;;;:30;63313:10;63294:30;;;;;;;;;;;:44;;;;63444:10;63411:17;:30;63429:11;63411:30;;;;;;;;;;;:43;;;;63206:294;63172:328;63596:17;:26;63614:7;63596:26;;;;;;;;;;;63589:33;;;63640:12;:18;63653:4;63640:18;;;;;;;;;;;;;;;:34;63659:14;63640:34;;;;;;;;;;;63633:41;;;62775:907;;62694:988;;:::o;63977:1079::-;64230:22;64275:1;64255:10;:17;;;;:21;;;;:::i;:::-;64230:46;;64287:18;64308:15;:24;64324:7;64308:24;;;;;;;;;;;;64287:45;;64659:19;64681:10;64692:14;64681:26;;;;;;;;:::i;:::-;;;;;;;;;;64659:48;;64745:11;64720:10;64731;64720:22;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;64856:10;64825:15;:28;64841:11;64825:28;;;;;;;;;;;:41;;;;64997:15;:24;65013:7;64997:24;;;;;;;;;;;64990:31;;;65032:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;64048:1008;;;63977:1079;:::o;61481:221::-;61566:14;61583:20;61600:2;61583:16;:20::i;:::-;61566:37;;61641:7;61614:12;:16;61627:2;61614:16;;;;;;;;;;;;;;;:24;61631:6;61614:24;;;;;;;;;;;:34;;;;61688:6;61659:17;:26;61677:7;61659:26;;;;;;;;;;;:35;;;;61555:147;61481:221;;:::o;22663:326::-;22723:4;22980:1;22958:7;:19;;;:23;22951:30;;22663:326;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:77::-;1555:7;1584:5;1573:16;;1518:77;;;:::o;1601:118::-;1688:24;1706:5;1688:24;:::i;:::-;1683:3;1676:37;1601:118;;:::o;1725:222::-;1818:4;1856:2;1845:9;1841:18;1833:26;;1869:71;1937:1;1926:9;1922:17;1913:6;1869:71;:::i;:::-;1725:222;;;;:::o;1953:99::-;2005:6;2039:5;2033:12;2023:22;;1953:99;;;:::o;2058:169::-;2142:11;2176:6;2171:3;2164:19;2216:4;2211:3;2207:14;2192:29;;2058:169;;;;:::o;2233:246::-;2314:1;2324:113;2338:6;2335:1;2332:13;2324:113;;;2423:1;2418:3;2414:11;2408:18;2404:1;2399:3;2395:11;2388:39;2360:2;2357:1;2353:10;2348:15;;2324:113;;;2471:1;2462:6;2457:3;2453:16;2446:27;2295:184;2233:246;;;:::o;2485:102::-;2526:6;2577:2;2573:7;2568:2;2561:5;2557:14;2553:28;2543:38;;2485:102;;;:::o;2593:377::-;2681:3;2709:39;2742:5;2709:39;:::i;:::-;2764:71;2828:6;2823:3;2764:71;:::i;:::-;2757:78;;2844:65;2902:6;2897:3;2890:4;2883:5;2879:16;2844:65;:::i;:::-;2934:29;2956:6;2934:29;:::i;:::-;2929:3;2925:39;2918:46;;2685:285;2593:377;;;;:::o;2976:313::-;3089:4;3127:2;3116:9;3112:18;3104:26;;3176:9;3170:4;3166:20;3162:1;3151:9;3147:17;3140:47;3204:78;3277:4;3268:6;3204:78;:::i;:::-;3196:86;;2976:313;;;;:::o;3295:122::-;3368:24;3386:5;3368:24;:::i;:::-;3361:5;3358:35;3348:63;;3407:1;3404;3397:12;3348:63;3295:122;:::o;3423:139::-;3469:5;3507:6;3494:20;3485:29;;3523:33;3550:5;3523:33;:::i;:::-;3423:139;;;;:::o;3568:329::-;3627:6;3676:2;3664:9;3655:7;3651:23;3647:32;3644:119;;;3682:79;;:::i;:::-;3644:119;3802:1;3827:53;3872:7;3863:6;3852:9;3848:22;3827:53;:::i;:::-;3817:63;;3773:117;3568:329;;;;:::o;3903:126::-;3940:7;3980:42;3973:5;3969:54;3958:65;;3903:126;;;:::o;4035:96::-;4072:7;4101:24;4119:5;4101:24;:::i;:::-;4090:35;;4035:96;;;:::o;4137:118::-;4224:24;4242:5;4224:24;:::i;:::-;4219:3;4212:37;4137:118;;:::o;4261:222::-;4354:4;4392:2;4381:9;4377:18;4369:26;;4405:71;4473:1;4462:9;4458:17;4449:6;4405:71;:::i;:::-;4261:222;;;;:::o;4489:122::-;4562:24;4580:5;4562:24;:::i;:::-;4555:5;4552:35;4542:63;;4601:1;4598;4591:12;4542:63;4489:122;:::o;4617:139::-;4663:5;4701:6;4688:20;4679:29;;4717:33;4744:5;4717:33;:::i;:::-;4617:139;;;;:::o;4762:474::-;4830:6;4838;4887:2;4875:9;4866:7;4862:23;4858:32;4855:119;;;4893:79;;:::i;:::-;4855:119;5013:1;5038:53;5083:7;5074:6;5063:9;5059:22;5038:53;:::i;:::-;5028:63;;4984:117;5140:2;5166:53;5211:7;5202:6;5191:9;5187:22;5166:53;:::i;:::-;5156:63;;5111:118;4762:474;;;;;:::o;5242:619::-;5319:6;5327;5335;5384:2;5372:9;5363:7;5359:23;5355:32;5352:119;;;5390:79;;:::i;:::-;5352:119;5510:1;5535:53;5580:7;5571:6;5560:9;5556:22;5535:53;:::i;:::-;5525:63;;5481:117;5637:2;5663:53;5708:7;5699:6;5688:9;5684:22;5663:53;:::i;:::-;5653:63;;5608:118;5765:2;5791:53;5836:7;5827:6;5816:9;5812:22;5791:53;:::i;:::-;5781:63;;5736:118;5242:619;;;;;:::o;5867:60::-;5895:3;5916:5;5909:12;;5867:60;;;:::o;5933:142::-;5983:9;6016:53;6034:34;6043:24;6061:5;6043:24;:::i;:::-;6034:34;:::i;:::-;6016:53;:::i;:::-;6003:66;;5933:142;;;:::o;6081:126::-;6131:9;6164:37;6195:5;6164:37;:::i;:::-;6151:50;;6081:126;;;:::o;6213:157::-;6294:9;6327:37;6358:5;6327:37;:::i;:::-;6314:50;;6213:157;;;:::o;6376:193::-;6494:68;6556:5;6494:68;:::i;:::-;6489:3;6482:81;6376:193;;:::o;6575:284::-;6699:4;6737:2;6726:9;6722:18;6714:26;;6750:102;6849:1;6838:9;6834:17;6825:6;6750:102;:::i;:::-;6575:284;;;;:::o;6865:104::-;6910:7;6939:24;6957:5;6939:24;:::i;:::-;6928:35;;6865:104;;;:::o;6975:138::-;7056:32;7082:5;7056:32;:::i;:::-;7049:5;7046:43;7036:71;;7103:1;7100;7093:12;7036:71;6975:138;:::o;7119:155::-;7173:5;7211:6;7198:20;7189:29;;7227:41;7262:5;7227:41;:::i;:::-;7119:155;;;;:::o;7280:345::-;7347:6;7396:2;7384:9;7375:7;7371:23;7367:32;7364:119;;;7402:79;;:::i;:::-;7364:119;7522:1;7547:61;7600:7;7591:6;7580:9;7576:22;7547:61;:::i;:::-;7537:71;;7493:125;7280:345;;;;:::o;7631:329::-;7690:6;7739:2;7727:9;7718:7;7714:23;7710:32;7707:119;;;7745:79;;:::i;:::-;7707:119;7865:1;7890:53;7935:7;7926:6;7915:9;7911:22;7890:53;:::i;:::-;7880:63;;7836:117;7631:329;;;;:::o;7966:116::-;8036:21;8051:5;8036:21;:::i;:::-;8029:5;8026:32;8016:60;;8072:1;8069;8062:12;8016:60;7966:116;:::o;8088:133::-;8131:5;8169:6;8156:20;8147:29;;8185:30;8209:5;8185:30;:::i;:::-;8088:133;;;;:::o;8227:468::-;8292:6;8300;8349:2;8337:9;8328:7;8324:23;8320:32;8317:119;;;8355:79;;:::i;:::-;8317:119;8475:1;8500:53;8545:7;8536:6;8525:9;8521:22;8500:53;:::i;:::-;8490:63;;8446:117;8602:2;8628:50;8670:7;8661:6;8650:9;8646:22;8628:50;:::i;:::-;8618:60;;8573:115;8227:468;;;;;:::o;8701:117::-;8810:1;8807;8800:12;8824:117;8933:1;8930;8923:12;8947:180;8995:77;8992:1;8985:88;9092:4;9089:1;9082:15;9116:4;9113:1;9106:15;9133:281;9216:27;9238:4;9216:27;:::i;:::-;9208:6;9204:40;9346:6;9334:10;9331:22;9310:18;9298:10;9295:34;9292:62;9289:88;;;9357:18;;:::i;:::-;9289:88;9397:10;9393:2;9386:22;9176:238;9133:281;;:::o;9420:129::-;9454:6;9481:20;;:::i;:::-;9471:30;;9510:33;9538:4;9530:6;9510:33;:::i;:::-;9420:129;;;:::o;9555:308::-;9617:4;9707:18;9699:6;9696:30;9693:56;;;9729:18;;:::i;:::-;9693:56;9767:29;9789:6;9767:29;:::i;:::-;9759:37;;9851:4;9845;9841:15;9833:23;;9555:308;;;:::o;9869:146::-;9966:6;9961:3;9956;9943:30;10007:1;9998:6;9993:3;9989:16;9982:27;9869:146;;;:::o;10021:425::-;10099:5;10124:66;10140:49;10182:6;10140:49;:::i;:::-;10124:66;:::i;:::-;10115:75;;10213:6;10206:5;10199:21;10251:4;10244:5;10240:16;10289:3;10280:6;10275:3;10271:16;10268:25;10265:112;;;10296:79;;:::i;:::-;10265:112;10386:54;10433:6;10428:3;10423;10386:54;:::i;:::-;10105:341;10021:425;;;;;:::o;10466:340::-;10522:5;10571:3;10564:4;10556:6;10552:17;10548:27;10538:122;;10579:79;;:::i;:::-;10538:122;10696:6;10683:20;10721:79;10796:3;10788:6;10781:4;10773:6;10769:17;10721:79;:::i;:::-;10712:88;;10528:278;10466:340;;;;:::o;10812:509::-;10881:6;10930:2;10918:9;10909:7;10905:23;10901:32;10898:119;;;10936:79;;:::i;:::-;10898:119;11084:1;11073:9;11069:17;11056:31;11114:18;11106:6;11103:30;11100:117;;;11136:79;;:::i;:::-;11100:117;11241:63;11296:7;11287:6;11276:9;11272:22;11241:63;:::i;:::-;11231:73;;11027:287;10812:509;;;;:::o;11327:307::-;11388:4;11478:18;11470:6;11467:30;11464:56;;;11500:18;;:::i;:::-;11464:56;11538:29;11560:6;11538:29;:::i;:::-;11530:37;;11622:4;11616;11612:15;11604:23;;11327:307;;;:::o;11640:423::-;11717:5;11742:65;11758:48;11799:6;11758:48;:::i;:::-;11742:65;:::i;:::-;11733:74;;11830:6;11823:5;11816:21;11868:4;11861:5;11857:16;11906:3;11897:6;11892:3;11888:16;11885:25;11882:112;;;11913:79;;:::i;:::-;11882:112;12003:54;12050:6;12045:3;12040;12003:54;:::i;:::-;11723:340;11640:423;;;;;:::o;12082:338::-;12137:5;12186:3;12179:4;12171:6;12167:17;12163:27;12153:122;;12194:79;;:::i;:::-;12153:122;12311:6;12298:20;12336:78;12410:3;12402:6;12395:4;12387:6;12383:17;12336:78;:::i;:::-;12327:87;;12143:277;12082:338;;;;:::o;12426:943::-;12521:6;12529;12537;12545;12594:3;12582:9;12573:7;12569:23;12565:33;12562:120;;;12601:79;;:::i;:::-;12562:120;12721:1;12746:53;12791:7;12782:6;12771:9;12767:22;12746:53;:::i;:::-;12736:63;;12692:117;12848:2;12874:53;12919:7;12910:6;12899:9;12895:22;12874:53;:::i;:::-;12864:63;;12819:118;12976:2;13002:53;13047:7;13038:6;13027:9;13023:22;13002:53;:::i;:::-;12992:63;;12947:118;13132:2;13121:9;13117:18;13104:32;13163:18;13155:6;13152:30;13149:117;;;13185:79;;:::i;:::-;13149:117;13290:62;13344:7;13335:6;13324:9;13320:22;13290:62;:::i;:::-;13280:72;;13075:287;12426:943;;;;;;;:::o;13375:474::-;13443:6;13451;13500:2;13488:9;13479:7;13475:23;13471:32;13468:119;;;13506:79;;:::i;:::-;13468:119;13626:1;13651:53;13696:7;13687:6;13676:9;13672:22;13651:53;:::i;:::-;13641:63;;13597:117;13753:2;13779:53;13824:7;13815:6;13804:9;13800:22;13779:53;:::i;:::-;13769:63;;13724:118;13375:474;;;;;:::o;13855:180::-;13903:77;13900:1;13893:88;14000:4;13997:1;13990:15;14024:4;14021:1;14014:15;14041:320;14085:6;14122:1;14116:4;14112:12;14102:22;;14169:1;14163:4;14159:12;14190:18;14180:81;;14246:4;14238:6;14234:17;14224:27;;14180:81;14308:2;14300:6;14297:14;14277:18;14274:38;14271:84;;14327:18;;:::i;:::-;14271:84;14092:269;14041:320;;;:::o;14367:220::-;14507:34;14503:1;14495:6;14491:14;14484:58;14576:3;14571:2;14563:6;14559:15;14552:28;14367:220;:::o;14593:366::-;14735:3;14756:67;14820:2;14815:3;14756:67;:::i;:::-;14749:74;;14832:93;14921:3;14832:93;:::i;:::-;14950:2;14945:3;14941:12;14934:19;;14593:366;;;:::o;14965:419::-;15131:4;15169:2;15158:9;15154:18;15146:26;;15218:9;15212:4;15208:20;15204:1;15193:9;15189:17;15182:47;15246:131;15372:4;15246:131;:::i;:::-;15238:139;;14965:419;;;:::o;15390:248::-;15530:34;15526:1;15518:6;15514:14;15507:58;15599:31;15594:2;15586:6;15582:15;15575:56;15390:248;:::o;15644:366::-;15786:3;15807:67;15871:2;15866:3;15807:67;:::i;:::-;15800:74;;15883:93;15972:3;15883:93;:::i;:::-;16001:2;15996:3;15992:12;15985:19;;15644:366;;;:::o;16016:419::-;16182:4;16220:2;16209:9;16205:18;16197:26;;16269:9;16263:4;16259:20;16255:1;16244:9;16240:17;16233:47;16297:131;16423:4;16297:131;:::i;:::-;16289:139;;16016:419;;;:::o;16441:232::-;16581:34;16577:1;16569:6;16565:14;16558:58;16650:15;16645:2;16637:6;16633:15;16626:40;16441:232;:::o;16679:366::-;16821:3;16842:67;16906:2;16901:3;16842:67;:::i;:::-;16835:74;;16918:93;17007:3;16918:93;:::i;:::-;17036:2;17031:3;17027:12;17020:19;;16679:366;;;:::o;17051:419::-;17217:4;17255:2;17244:9;17240:18;17232:26;;17304:9;17298:4;17294:20;17290:1;17279:9;17275:17;17268:47;17332:131;17458:4;17332:131;:::i;:::-;17324:139;;17051:419;;;:::o;17476:227::-;17616:34;17612:1;17604:6;17600:14;17593:58;17685:10;17680:2;17672:6;17668:15;17661:35;17476:227;:::o;17709:366::-;17851:3;17872:67;17936:2;17931:3;17872:67;:::i;:::-;17865:74;;17948:93;18037:3;17948:93;:::i;:::-;18066:2;18061:3;18057:12;18050:19;;17709:366;;;:::o;18081:419::-;18247:4;18285:2;18274:9;18270:18;18262:26;;18334:9;18328:4;18324:20;18320:1;18309:9;18305:17;18298:47;18362:131;18488:4;18362:131;:::i;:::-;18354:139;;18081:419;;;:::o;18506:230::-;18646:34;18642:1;18634:6;18630:14;18623:58;18715:13;18710:2;18702:6;18698:15;18691:38;18506:230;:::o;18742:366::-;18884:3;18905:67;18969:2;18964:3;18905:67;:::i;:::-;18898:74;;18981:93;19070:3;18981:93;:::i;:::-;19099:2;19094:3;19090:12;19083:19;;18742:366;;;:::o;19114:419::-;19280:4;19318:2;19307:9;19303:18;19295:26;;19367:9;19361:4;19357:20;19353:1;19342:9;19338:17;19331:47;19395:131;19521:4;19395:131;:::i;:::-;19387:139;;19114:419;;;:::o;19539:180::-;19587:77;19584:1;19577:88;19684:4;19681:1;19674:15;19708:4;19705:1;19698:15;19725:410;19765:7;19788:20;19806:1;19788:20;:::i;:::-;19783:25;;19822:20;19840:1;19822:20;:::i;:::-;19817:25;;19877:1;19874;19870:9;19899:30;19917:11;19899:30;:::i;:::-;19888:41;;20078:1;20069:7;20065:15;20062:1;20059:22;20039:1;20032:9;20012:83;19989:139;;20108:18;;:::i;:::-;19989:139;19773:362;19725:410;;;;:::o;20141:170::-;20281:22;20277:1;20269:6;20265:14;20258:46;20141:170;:::o;20317:366::-;20459:3;20480:67;20544:2;20539:3;20480:67;:::i;:::-;20473:74;;20556:93;20645:3;20556:93;:::i;:::-;20674:2;20669:3;20665:12;20658:19;;20317:366;;;:::o;20689:419::-;20855:4;20893:2;20882:9;20878:18;20870:26;;20942:9;20936:4;20932:20;20928:1;20917:9;20913:17;20906:47;20970:131;21096:4;20970:131;:::i;:::-;20962:139;;20689:419;;;:::o;21114:231::-;21254:34;21250:1;21242:6;21238:14;21231:58;21323:14;21318:2;21310:6;21306:15;21299:39;21114:231;:::o;21351:366::-;21493:3;21514:67;21578:2;21573:3;21514:67;:::i;:::-;21507:74;;21590:93;21679:3;21590:93;:::i;:::-;21708:2;21703:3;21699:12;21692:19;;21351:366;;;:::o;21723:419::-;21889:4;21927:2;21916:9;21912:18;21904:26;;21976:9;21970:4;21966:20;21962:1;21951:9;21947:17;21940:47;22004:131;22130:4;22004:131;:::i;:::-;21996:139;;21723:419;;;:::o;22148:180::-;22196:77;22193:1;22186:88;22293:4;22290:1;22283:15;22317:4;22314:1;22307:15;22334:174;22474:26;22470:1;22462:6;22458:14;22451:50;22334:174;:::o;22514:366::-;22656:3;22677:67;22741:2;22736:3;22677:67;:::i;:::-;22670:74;;22753:93;22842:3;22753:93;:::i;:::-;22871:2;22866:3;22862:12;22855:19;;22514:366;;;:::o;22886:419::-;23052:4;23090:2;23079:9;23075:18;23067:26;;23139:9;23133:4;23129:20;23125:1;23114:9;23110:17;23103:47;23167:131;23293:4;23167:131;:::i;:::-;23159:139;;22886:419;;;:::o;23311:228::-;23451:34;23447:1;23439:6;23435:14;23428:58;23520:11;23515:2;23507:6;23503:15;23496:36;23311:228;:::o;23545:366::-;23687:3;23708:67;23772:2;23767:3;23708:67;:::i;:::-;23701:74;;23784:93;23873:3;23784:93;:::i;:::-;23902:2;23897:3;23893:12;23886:19;;23545:366;;;:::o;23917:419::-;24083:4;24121:2;24110:9;24106:18;24098:26;;24170:9;24164:4;24160:20;24156:1;24145:9;24141:17;24134:47;24198:131;24324:4;24198:131;:::i;:::-;24190:139;;23917:419;;;:::o;24342:169::-;24482:21;24478:1;24470:6;24466:14;24459:45;24342:169;:::o;24517:366::-;24659:3;24680:67;24744:2;24739:3;24680:67;:::i;:::-;24673:74;;24756:93;24845:3;24756:93;:::i;:::-;24874:2;24869:3;24865:12;24858:19;;24517:366;;;:::o;24889:419::-;25055:4;25093:2;25082:9;25078:18;25070:26;;25142:9;25136:4;25132:20;25128:1;25117:9;25113:17;25106:47;25170:131;25296:4;25170:131;:::i;:::-;25162:139;;24889:419;;;:::o;25314:141::-;25363:4;25386:3;25378:11;;25409:3;25406:1;25399:14;25443:4;25440:1;25430:18;25422:26;;25314:141;;;:::o;25461:93::-;25498:6;25545:2;25540;25533:5;25529:14;25525:23;25515:33;;25461:93;;;:::o;25560:107::-;25604:8;25654:5;25648:4;25644:16;25623:37;;25560:107;;;;:::o;25673:393::-;25742:6;25792:1;25780:10;25776:18;25815:97;25845:66;25834:9;25815:97;:::i;:::-;25933:39;25963:8;25952:9;25933:39;:::i;:::-;25921:51;;26005:4;26001:9;25994:5;25990:21;25981:30;;26054:4;26044:8;26040:19;26033:5;26030:30;26020:40;;25749:317;;25673:393;;;;;:::o;26072:142::-;26122:9;26155:53;26173:34;26182:24;26200:5;26182:24;:::i;:::-;26173:34;:::i;:::-;26155:53;:::i;:::-;26142:66;;26072:142;;;:::o;26220:75::-;26263:3;26284:5;26277:12;;26220:75;;;:::o;26301:269::-;26411:39;26442:7;26411:39;:::i;:::-;26472:91;26521:41;26545:16;26521:41;:::i;:::-;26513:6;26506:4;26500:11;26472:91;:::i;:::-;26466:4;26459:105;26377:193;26301:269;;;:::o;26576:73::-;26621:3;26576:73;:::o;26655:189::-;26732:32;;:::i;:::-;26773:65;26831:6;26823;26817:4;26773:65;:::i;:::-;26708:136;26655:189;;:::o;26850:186::-;26910:120;26927:3;26920:5;26917:14;26910:120;;;26981:39;27018:1;27011:5;26981:39;:::i;:::-;26954:1;26947:5;26943:13;26934:22;;26910:120;;;26850:186;;:::o;27042:543::-;27143:2;27138:3;27135:11;27132:446;;;27177:38;27209:5;27177:38;:::i;:::-;27261:29;27279:10;27261:29;:::i;:::-;27251:8;27247:44;27444:2;27432:10;27429:18;27426:49;;;27465:8;27450:23;;27426:49;27488:80;27544:22;27562:3;27544:22;:::i;:::-;27534:8;27530:37;27517:11;27488:80;:::i;:::-;27147:431;;27132:446;27042:543;;;:::o;27591:117::-;27645:8;27695:5;27689:4;27685:16;27664:37;;27591:117;;;;:::o;27714:169::-;27758:6;27791:51;27839:1;27835:6;27827:5;27824:1;27820:13;27791:51;:::i;:::-;27787:56;27872:4;27866;27862:15;27852:25;;27765:118;27714:169;;;;:::o;27888:295::-;27964:4;28110:29;28135:3;28129:4;28110:29;:::i;:::-;28102:37;;28172:3;28169:1;28165:11;28159:4;28156:21;28148:29;;27888:295;;;;:::o;28188:1395::-;28305:37;28338:3;28305:37;:::i;:::-;28407:18;28399:6;28396:30;28393:56;;;28429:18;;:::i;:::-;28393:56;28473:38;28505:4;28499:11;28473:38;:::i;:::-;28558:67;28618:6;28610;28604:4;28558:67;:::i;:::-;28652:1;28676:4;28663:17;;28708:2;28700:6;28697:14;28725:1;28720:618;;;;29382:1;29399:6;29396:77;;;29448:9;29443:3;29439:19;29433:26;29424:35;;29396:77;29499:67;29559:6;29552:5;29499:67;:::i;:::-;29493:4;29486:81;29355:222;28690:887;;28720:618;28772:4;28768:9;28760:6;28756:22;28806:37;28838:4;28806:37;:::i;:::-;28865:1;28879:208;28893:7;28890:1;28887:14;28879:208;;;28972:9;28967:3;28963:19;28957:26;28949:6;28942:42;29023:1;29015:6;29011:14;29001:24;;29070:2;29059:9;29055:18;29042:31;;28916:4;28913:1;28909:12;28904:17;;28879:208;;;29115:6;29106:7;29103:19;29100:179;;;29173:9;29168:3;29164:19;29158:26;29216:48;29258:4;29250:6;29246:17;29235:9;29216:48;:::i;:::-;29208:6;29201:64;29123:156;29100:179;29325:1;29321;29313:6;29309:14;29305:22;29299:4;29292:36;28727:611;;;28690:887;;28280:1303;;;28188:1395;;:::o;29589:148::-;29691:11;29728:3;29713:18;;29589:148;;;;:::o;29743:390::-;29849:3;29877:39;29910:5;29877:39;:::i;:::-;29932:89;30014:6;30009:3;29932:89;:::i;:::-;29925:96;;30030:65;30088:6;30083:3;30076:4;30069:5;30065:16;30030:65;:::i;:::-;30120:6;30115:3;30111:16;30104:23;;29853:280;29743:390;;;;:::o;30139:435::-;30319:3;30341:95;30432:3;30423:6;30341:95;:::i;:::-;30334:102;;30453:95;30544:3;30535:6;30453:95;:::i;:::-;30446:102;;30565:3;30558:10;;30139:435;;;;;:::o;30580:224::-;30720:34;30716:1;30708:6;30704:14;30697:58;30789:7;30784:2;30776:6;30772:15;30765:32;30580:224;:::o;30810:366::-;30952:3;30973:67;31037:2;31032:3;30973:67;:::i;:::-;30966:74;;31049:93;31138:3;31049:93;:::i;:::-;31167:2;31162:3;31158:12;31151:19;;30810:366;;;:::o;31182:419::-;31348:4;31386:2;31375:9;31371:18;31363:26;;31435:9;31429:4;31425:20;31421:1;31410:9;31406:17;31399:47;31463:131;31589:4;31463:131;:::i;:::-;31455:139;;31182:419;;;:::o;31607:223::-;31747:34;31743:1;31735:6;31731:14;31724:58;31816:6;31811:2;31803:6;31799:15;31792:31;31607:223;:::o;31836:366::-;31978:3;31999:67;32063:2;32058:3;31999:67;:::i;:::-;31992:74;;32075:93;32164:3;32075:93;:::i;:::-;32193:2;32188:3;32184:12;32177:19;;31836:366;;;:::o;32208:419::-;32374:4;32412:2;32401:9;32397:18;32389:26;;32461:9;32455:4;32451:20;32447:1;32436:9;32432:17;32425:47;32489:131;32615:4;32489:131;:::i;:::-;32481:139;;32208:419;;;:::o;32633:191::-;32673:3;32692:20;32710:1;32692:20;:::i;:::-;32687:25;;32726:20;32744:1;32726:20;:::i;:::-;32721:25;;32769:1;32766;32762:9;32755:16;;32790:3;32787:1;32784:10;32781:36;;;32797:18;;:::i;:::-;32781:36;32633:191;;;;:::o;32830:178::-;32970:30;32966:1;32958:6;32954:14;32947:54;32830:178;:::o;33014:366::-;33156:3;33177:67;33241:2;33236:3;33177:67;:::i;:::-;33170:74;;33253:93;33342:3;33253:93;:::i;:::-;33371:2;33366:3;33362:12;33355:19;;33014:366;;;:::o;33386:419::-;33552:4;33590:2;33579:9;33575:18;33567:26;;33639:9;33633:4;33629:20;33625:1;33614:9;33610:17;33603:47;33667:131;33793:4;33667:131;:::i;:::-;33659:139;;33386:419;;;:::o;33811:233::-;33850:3;33873:24;33891:5;33873:24;:::i;:::-;33864:33;;33919:66;33912:5;33909:77;33906:103;;33989:18;;:::i;:::-;33906:103;34036:1;34029:5;34025:13;34018:20;;33811:233;;;:::o;34050:175::-;34190:27;34186:1;34178:6;34174:14;34167:51;34050:175;:::o;34231:366::-;34373:3;34394:67;34458:2;34453:3;34394:67;:::i;:::-;34387:74;;34470:93;34559:3;34470:93;:::i;:::-;34588:2;34583:3;34579:12;34572:19;;34231:366;;;:::o;34603:419::-;34769:4;34807:2;34796:9;34792:18;34784:26;;34856:9;34850:4;34846:20;34842:1;34831:9;34827:17;34820:47;34884:131;35010:4;34884:131;:::i;:::-;34876:139;;34603:419;;;:::o;35028:237::-;35168:34;35164:1;35156:6;35152:14;35145:58;35237:20;35232:2;35224:6;35220:15;35213:45;35028:237;:::o;35271:366::-;35413:3;35434:67;35498:2;35493:3;35434:67;:::i;:::-;35427:74;;35510:93;35599:3;35510:93;:::i;:::-;35628:2;35623:3;35619:12;35612:19;;35271:366;;;:::o;35643:419::-;35809:4;35847:2;35836:9;35832:18;35824:26;;35896:9;35890:4;35886:20;35882:1;35871:9;35867:17;35860:47;35924:131;36050:4;35924:131;:::i;:::-;35916:139;;35643:419;;;:::o;36068:180::-;36116:77;36113:1;36106:88;36213:4;36210:1;36203:15;36237:4;36234:1;36227:15;36254:240;36394:34;36390:1;36382:6;36378:14;36371:58;36463:23;36458:2;36450:6;36446:15;36439:48;36254:240;:::o;36500:366::-;36642:3;36663:67;36727:2;36722:3;36663:67;:::i;:::-;36656:74;;36739:93;36828:3;36739:93;:::i;:::-;36857:2;36852:3;36848:12;36841:19;;36500:366;;;:::o;36872:419::-;37038:4;37076:2;37065:9;37061:18;37053:26;;37125:9;37119:4;37115:20;37111:1;37100:9;37096:17;37089:47;37153:131;37279:4;37153:131;:::i;:::-;37145:139;;36872:419;;;:::o;37297:182::-;37437:34;37433:1;37425:6;37421:14;37414:58;37297:182;:::o;37485:366::-;37627:3;37648:67;37712:2;37707:3;37648:67;:::i;:::-;37641:74;;37724:93;37813:3;37724:93;:::i;:::-;37842:2;37837:3;37833:12;37826:19;;37485:366;;;:::o;37857:419::-;38023:4;38061:2;38050:9;38046:18;38038:26;;38110:9;38104:4;38100:20;38096:1;38085:9;38081:17;38074:47;38138:131;38264:4;38138:131;:::i;:::-;38130:139;;37857:419;;;:::o;38282:178::-;38422:30;38418:1;38410:6;38406:14;38399:54;38282:178;:::o;38466:366::-;38608:3;38629:67;38693:2;38688:3;38629:67;:::i;:::-;38622:74;;38705:93;38794:3;38705:93;:::i;:::-;38823:2;38818:3;38814:12;38807:19;;38466:366;;;:::o;38838:419::-;39004:4;39042:2;39031:9;39027:18;39019:26;;39091:9;39085:4;39081:20;39077:1;39066:9;39062:17;39055:47;39119:131;39245:4;39119:131;:::i;:::-;39111:139;;38838:419;;;:::o;39263:98::-;39314:6;39348:5;39342:12;39332:22;;39263:98;;;:::o;39367:168::-;39450:11;39484:6;39479:3;39472:19;39524:4;39519:3;39515:14;39500:29;;39367:168;;;;:::o;39541:373::-;39627:3;39655:38;39687:5;39655:38;:::i;:::-;39709:70;39772:6;39767:3;39709:70;:::i;:::-;39702:77;;39788:65;39846:6;39841:3;39834:4;39827:5;39823:16;39788:65;:::i;:::-;39878:29;39900:6;39878:29;:::i;:::-;39873:3;39869:39;39862:46;;39631:283;39541:373;;;;:::o;39920:640::-;40115:4;40153:3;40142:9;40138:19;40130:27;;40167:71;40235:1;40224:9;40220:17;40211:6;40167:71;:::i;:::-;40248:72;40316:2;40305:9;40301:18;40292:6;40248:72;:::i;:::-;40330;40398:2;40387:9;40383:18;40374:6;40330:72;:::i;:::-;40449:9;40443:4;40439:20;40434:2;40423:9;40419:18;40412:48;40477:76;40548:4;40539:6;40477:76;:::i;:::-;40469:84;;39920:640;;;;;;;:::o;40566:141::-;40622:5;40653:6;40647:13;40638:22;;40669:32;40695:5;40669:32;:::i;:::-;40566:141;;;;:::o;40713:349::-;40782:6;40831:2;40819:9;40810:7;40806:23;40802:32;40799:119;;;40837:79;;:::i;:::-;40799:119;40957:1;40982:63;41037:7;41028:6;41017:9;41013:22;40982:63;:::i;:::-;40972:73;;40928:127;40713:349;;;;:::o;41068:194::-;41108:4;41128:20;41146:1;41128:20;:::i;:::-;41123:25;;41162:20;41180:1;41162:20;:::i;:::-;41157:25;;41206:1;41203;41199:9;41191:17;;41230:1;41224:4;41221:11;41218:37;;;41235:18;;:::i;:::-;41218:37;41068:194;;;;:::o;41268:180::-;41316:77;41313:1;41306:88;41413:4;41410:1;41403:15;41437:4;41434:1;41427:15
Swarm Source
ipfs://5e56054351b96384fbe9b9da432c04c288b210df7ffe73ebf2cd515ea8e633e8
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
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.