Source Code
Overview
MATIC Balance
0 MATIC
More Info
ContractCreator:
TokenTracker
Multichain Info
N/A
Loading...
Loading
Contract Name:
SVGNFT
Compiler Version
v0.8.13+commit.abaa5c0e
Contract Source Code (Solidity)
/** *Submitted for verification at mumbai.polygonscan.com on 2022-12-06 */ // File: base64-sol/base64.sol pragma solidity >=0.6.0; /// @title Base64 /// @author Brecht Devos - <[email protected]> /// @notice Provides functions for encoding/decoding base64 library Base64 { string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; bytes internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000" hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000" hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000" hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000"; function encode(bytes memory data) internal pure returns (string memory) { if (data.length == 0) return ''; // load the table into memory string memory table = TABLE_ENCODE; // multiply by 4/3 rounded up uint256 encodedLen = 4 * ((data.length + 2) / 3); // add some extra buffer at the end required for the writing string memory result = new string(encodedLen + 32); assembly { // set the actual output length mstore(result, encodedLen) // prepare the lookup table let tablePtr := add(table, 1) // input ptr let dataPtr := data let endPtr := add(dataPtr, mload(data)) // result ptr, jump over length let resultPtr := add(result, 32) // run over the input, 3 bytes at a time for {} lt(dataPtr, endPtr) {} { // read 3 bytes dataPtr := add(dataPtr, 3) let input := mload(dataPtr) // write 4 characters mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F)))) resultPtr := add(resultPtr, 1) mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F)))) resultPtr := add(resultPtr, 1) mstore8(resultPtr, mload(add(tablePtr, and(shr( 6, input), 0x3F)))) resultPtr := add(resultPtr, 1) mstore8(resultPtr, mload(add(tablePtr, and( input, 0x3F)))) resultPtr := add(resultPtr, 1) } // padding with '=' switch mod(mload(data), 3) case 1 { mstore(sub(resultPtr, 2), shl(240, 0x3d3d)) } case 2 { mstore(sub(resultPtr, 1), shl(248, 0x3d)) } } return result; } function decode(string memory _data) internal pure returns (bytes memory) { bytes memory data = bytes(_data); if (data.length == 0) return new bytes(0); require(data.length % 4 == 0, "invalid base64 decoder input"); // load the table into memory bytes memory table = TABLE_DECODE; // every 4 characters represent 3 bytes uint256 decodedLen = (data.length / 4) * 3; // add some extra buffer at the end required for the writing bytes memory result = new bytes(decodedLen + 32); assembly { // padding with '=' let lastBytes := mload(add(data, mload(data))) if eq(and(lastBytes, 0xFF), 0x3d) { decodedLen := sub(decodedLen, 1) if eq(and(lastBytes, 0xFFFF), 0x3d3d) { decodedLen := sub(decodedLen, 1) } } // set the actual output length mstore(result, decodedLen) // prepare the lookup table let tablePtr := add(table, 1) // input ptr let dataPtr := data let endPtr := add(dataPtr, mload(data)) // result ptr, jump over length let resultPtr := add(result, 32) // run over the input, 4 characters at a time for {} lt(dataPtr, endPtr) {} { // read 4 characters dataPtr := add(dataPtr, 4) let input := mload(dataPtr) // write 3 bytes let output := add( add( shl(18, and(mload(add(tablePtr, and(shr(24, input), 0xFF))), 0xFF)), shl(12, and(mload(add(tablePtr, and(shr(16, input), 0xFF))), 0xFF))), add( shl( 6, and(mload(add(tablePtr, and(shr( 8, input), 0xFF))), 0xFF)), and(mload(add(tablePtr, and( input , 0xFF))), 0xFF) ) ) mstore(resultPtr, shl(232, output)) resultPtr := add(resultPtr, 3) } } return result; } } // File: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol // OpenZeppelin Contracts (last updated v4.7.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 = _owners[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 nor 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 nor approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory data ) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved"); _safeTransfer(from, to, tokenId, data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory data ) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _owners[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); _balances[to] += 1; _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); _balances[owner] -= 1; delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _balances[from] -= 1; _balances[to] += 1; _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId); } /** * @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. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} } // File: @openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/extensions/ERC721URIStorage.sol) pragma solidity ^0.8.0; /** * @dev ERC721 token with storage based token URI management. */ abstract contract ERC721URIStorage is ERC721 { using Strings for uint256; // Optional mapping for token URIs mapping(uint256 => string) private _tokenURIs; /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory _tokenURI = _tokenURIs[tokenId]; string memory base = _baseURI(); // If there is no base URI, return the token URI. if (bytes(base).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(base, _tokenURI)); } return super.tokenURI(tokenId); } /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } /** * @dev See {ERC721-_burn}. This override additionally checks to see if a * token-specific URI was set for the token, and if so, it deletes the token URI from * the storage mapping. */ function _burn(uint256 tokenId) internal virtual override { super._burn(tokenId); if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } } } // File: svgNFTBasic.sol //give the contract some SVG code //output NFT URI with this SVG code //storing all the NFT metadata on chain //SPDX-License-Identifier: MIT pragma solidity 0.8.13; contract SVGNFT is ERC721URIStorage { uint256 public tokenCounter; event CreatedSVGNFT(uint256 indexed tokenId, string tokenURI); constructor() ERC721("SVG NFT", "svgNFT") { tokenCounter = 0; } function create(string memory _svg) public { _safeMint(msg.sender, tokenCounter); string memory imageURI = svgToImageURI(_svg); string memory tokenURI = formatTokenURI(imageURI); _setTokenURI(tokenCounter, tokenURI); emit CreatedSVGNFT(tokenCounter, tokenURI); tokenCounter = tokenCounter +1; } function svgToImageURI(string memory _svg) public pure returns (string memory) { //<svg xmlns="http://www.w3.org/2000/svg" height="210" width="400"> <path d="M150 0 L75 200 L225 200 Z" /> </svg> //data:image/svg+xml;base64, <base64-encoding/> string memory baseURL = "data:image/svg+xml;base64,"; string memory svgBase64Encoded = Base64.encode(bytes(string(abi.encodePacked(_svg)))); string memory imageURI = string(abi.encodePacked(baseURL, svgBase64Encoded)); return imageURI; } function formatTokenURI(string memory _imageURI) public pure returns (string memory) { string memory baseURL = "data:application/json;base64,"; return string(abi.encodePacked(baseURL, Base64.encode(bytes(abi.encodePacked('{"name": "SVG NFT", "description": "NFT with on-chain SVG", "attributes": "", "image": "', _imageURI, '"}'))))); } }
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"string","name":"tokenURI","type":"string"}],"name":"CreatedSVGNFT","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_svg","type":"string"}],"name":"create","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_imageURI","type":"string"}],"name":"formatTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","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":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_svg","type":"string"}],"name":"svgToImageURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenCounter","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":[{"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"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
56157:1451:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40804:305;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41731:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43244:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42761:417;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43944:336;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56720:521;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44351:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;41442:222;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41173:207;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57247:358;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41900:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43487:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56383:329;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44607:323;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54512:624;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56200:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43713:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40804:305;40906:4;40958:25;40943:40;;;:11;:40;;;;:105;;;;41015:33;41000:48;;;:11;:48;;;;40943:105;:158;;;;41065:36;41089:11;41065:23;:36::i;:::-;40943:158;40923:178;;40804:305;;;:::o;41731:100::-;41785:13;41818:5;41811:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41731:100;:::o;43244:171::-;43320:7;43340:23;43355:7;43340:14;:23::i;:::-;43383:15;:24;43399:7;43383:24;;;;;;;;;;;;;;;;;;;;;43376:31;;43244:171;;;:::o;42761:417::-;42842:13;42858:23;42873:7;42858:14;:23::i;:::-;42842:39;;42906:5;42900:11;;:2;:11;;;42892:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;43000:5;42984:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;43009:37;43026:5;43033:12;:10;:12::i;:::-;43009:16;:37::i;:::-;42984:62;42962:174;;;;;;;;;;;;:::i;:::-;;;;;;;;;43149:21;43158:2;43162:7;43149:8;:21::i;:::-;42831:347;42761:417;;:::o;43944:336::-;44139:41;44158:12;:10;:12::i;:::-;44172:7;44139:18;:41::i;:::-;44131:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;44244:28;44254:4;44260:2;44264:7;44244:9;:28::i;:::-;43944:336;;;:::o;56720:521::-;56784:13;56980:21;:52;;;;;;;;;;;;;;;;;;;57039:30;57072:52;57116:4;57099:22;;;;;;;;:::i;:::-;;;;;;;;;;;;;57072:13;:52::i;:::-;57039:85;;57131:22;57180:7;57189:16;57163:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57131:76;;57227:8;57220:15;;;;;56720:521;;;:::o;44351:185::-;44489:39;44506:4;44512:2;44516:7;44489:39;;;;;;;;;;;;:16;:39::i;:::-;44351:185;;;:::o;41442:222::-;41514:7;41534:13;41550:7;:16;41558:7;41550:16;;;;;;;;;;;;;;;;;;;;;41534:32;;41602:1;41585:19;;:5;:19;;;41577:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;41651:5;41644:12;;;41442:222;;;:::o;41173:207::-;41245:7;41290:1;41273:19;;:5;:19;;;41265:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;41356:9;:16;41366:5;41356:16;;;;;;;;;;;;;;;;41349:23;;41173:207;;;:::o;57247:358::-;57317:13;57341:21;:55;;;;;;;;;;;;;;;;;;;57434:7;57443:147;57572:9;57463:125;;;;;;;;:::i;:::-;;;;;;;;;;;;;57443:13;:147::i;:::-;57417:174;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57403:189;;;57247:358;;;:::o;41900:104::-;41956:13;41989:7;41982:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41900:104;:::o;43487:155::-;43582:52;43601:12;:10;:12::i;:::-;43615:8;43625;43582:18;:52::i;:::-;43487:155;;:::o;56383:329::-;56435:35;56445:10;56457:12;;56435:9;:35::i;:::-;56477:22;56502:19;56516:4;56502:13;:19::i;:::-;56477:44;;56528:22;56553:24;56568:8;56553:14;:24::i;:::-;56528:49;;56584:36;56597:12;;56611:8;56584:12;:36::i;:::-;56646:12;;56632:37;56660:8;56632:37;;;;;;:::i;:::-;;;;;;;;56705:1;56691:12;;:15;;;;:::i;:::-;56676:12;:30;;;;56426:286;;56383:329;:::o;44607:323::-;44781:41;44800:12;:10;:12::i;:::-;44814:7;44781:18;:41::i;:::-;44773:100;;;;;;;;;;;;:::i;:::-;;;;;;;;;44884:38;44898:4;44904:2;44908:7;44917:4;44884:13;:38::i;:::-;44607:323;;;;:::o;54512:624::-;54585:13;54611:23;54626:7;54611:14;:23::i;:::-;54647;54673:10;:19;54684:7;54673:19;;;;;;;;;;;54647:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54703:18;54724:10;:8;:10::i;:::-;54703:31;;54832:1;54816:4;54810:18;:23;54806:72;;54857:9;54850:16;;;;;;54806:72;55008:1;54988:9;54982:23;:27;54978:108;;;55057:4;55063:9;55040:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;55026:48;;;;;;54978:108;55105:23;55120:7;55105:14;:23::i;:::-;55098:30;;;;54512:624;;;;:::o;56200:27::-;;;;:::o;43713:164::-;43810:4;43834:18;:25;43853:5;43834:25;;;;;;;;;;;;;;;:35;43860:8;43834:35;;;;;;;;;;;;;;;;;;;;;;;;;43827:42;;43713:164;;;;:::o;33316:157::-;33401:4;33440:25;33425:40;;;:11;:40;;;;33418:47;;33316:157;;;:::o;51219:135::-;51301:16;51309:7;51301;:16::i;:::-;51293:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;51219:135;:::o;20838:98::-;20891:7;20918:10;20911:17;;20838:98;:::o;50498:174::-;50600:2;50573:15;:24;50589:7;50573:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;50656:7;50652:2;50618:46;;50627:23;50642:7;50627:14;:23::i;:::-;50618:46;;;;;;;;;;;;50498:174;;:::o;46731:264::-;46824:4;46841:13;46857:23;46872:7;46857:14;:23::i;:::-;46841:39;;46910:5;46899:16;;:7;:16;;;:52;;;;46919:32;46936:5;46943:7;46919:16;:32::i;:::-;46899:52;:87;;;;46979:7;46955:31;;:20;46967:7;46955:11;:20::i;:::-;:31;;;46899:87;46891:96;;;46731:264;;;;:::o;49754:625::-;49913:4;49886:31;;:23;49901:7;49886:14;:23::i;:::-;:31;;;49878:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;49992:1;49978:16;;:2;:16;;;49970:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;50048:39;50069:4;50075:2;50079:7;50048:20;:39::i;:::-;50152:29;50169:1;50173:7;50152:8;:29::i;:::-;50213:1;50194:9;:15;50204:4;50194:15;;;;;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;;;;;;50242:1;50225:9;:13;50235:2;50225:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;50273:2;50254:7;:16;50262:7;50254:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;50312:7;50308:2;50293:27;;50302:4;50293:27;;;;;;;;;;;;50333:38;50353:4;50359:2;50363:7;50333:19;:38::i;:::-;49754:625;;;:::o;794:1912::-;852:13;897:1;882:4;:11;:16;878:31;;900:9;;;;;;;;;;;;;;;;878:31;961:19;983:12;;;;;;;;;;;;;;;;;961:34;;1047:18;1093:1;1088;1074:4;:11;:15;;;;:::i;:::-;1073:21;;;;:::i;:::-;1068:1;:27;;;;:::i;:::-;1047:48;;1178:20;1225:2;1212:10;:15;;;;:::i;:::-;1201:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1178:50;;1325:10;1317:6;1310:26;1420:1;1413:5;1409:13;1479:4;1530;1524:11;1515:7;1511:25;1626:2;1618:6;1614:15;1699:754;1718:6;1709:7;1706:19;1699:754;;;1818:1;1809:7;1805:15;1794:26;;1857:7;1851:14;1983:4;1975:5;1971:2;1967:14;1963:25;1953:8;1949:40;1943:47;1932:9;1924:67;2037:1;2026:9;2022:17;2009:30;;2116:4;2108:5;2104:2;2100:14;2096:25;2086:8;2082:40;2076:47;2065:9;2057:67;2170:1;2159:9;2155:17;2142:30;;2249:4;2241:5;2238:1;2233:14;2229:25;2219:8;2215:40;2209:47;2198:9;2190:67;2303:1;2292:9;2288:17;2275:30;;2382:4;2374:5;2362:25;2352:8;2348:40;2342:47;2331:9;2323:67;2436:1;2425:9;2421:17;2408:30;;1742:711;1699:754;;;2526:1;2519:4;2513:11;2509:19;2547:1;2542:54;;;;2615:1;2610:52;;;;2502:160;;2542:54;2586:6;2581:3;2577:16;2573:1;2562:9;2558:17;2551:43;2542:54;;2610:52;2654:4;2649:3;2645:14;2641:1;2630:9;2626:17;2619:41;2502:160;;1250:1423;;;;2692:6;2685:13;;;;;794:1912;;;;:::o;50815:315::-;50970:8;50961:17;;:5;:17;;;50953:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;51057:8;51019:18;:25;51038:5;51019:25;;;;;;;;;;;;;;;:35;51045:8;51019:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;51103:8;51081:41;;51096:5;51081:41;;;51113:8;51081:41;;;;;;:::i;:::-;;;;;;;;50815:315;;;:::o;47337:110::-;47413:26;47423:2;47427:7;47413:26;;;;;;;;;;;;:9;:26::i;:::-;47337:110;;:::o;55292:217::-;55392:16;55400:7;55392;:16::i;:::-;55384:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;55492:9;55470:10;:19;55481:7;55470:19;;;;;;;;;;;:31;;;;;;;;;;;;:::i;:::-;;55292:217;;:::o;45811:313::-;45967:28;45977:4;45983:2;45987:7;45967:9;:28::i;:::-;46014:47;46037:4;46043:2;46047:7;46056:4;46014:22;:47::i;:::-;46006:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;45811:313;;;;:::o;42605:94::-;42656:13;42682:9;;;;;;;;;;;;;;42605:94;:::o;42075:281::-;42148:13;42174:23;42189:7;42174:14;:23::i;:::-;42210:21;42234:10;:8;:10::i;:::-;42210:34;;42286:1;42268:7;42262:21;:25;:86;;;;;;;;;;;;;;;;;42314:7;42323:18;:7;:16;:18::i;:::-;42297:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;42262:86;42255:93;;;42075:281;;;:::o;46437:127::-;46502:4;46554:1;46526:30;;:7;:16;46534:7;46526:16;;;;;;;;;;;;;;;;;;;;;:30;;;;46519:37;;46437:127;;;:::o;53343:126::-;;;;:::o;53854:125::-;;;;:::o;47674:319::-;47803:18;47809:2;47813:7;47803:5;:18::i;:::-;47854:53;47885:1;47889:2;47893:7;47902:4;47854:22;:53::i;:::-;47832:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;47674:319;;;:::o;51918:853::-;52072:4;52093:15;:2;:13;;;:15::i;:::-;52089:675;;;52145:2;52129:36;;;52166:12;:10;:12::i;:::-;52180:4;52186:7;52195:4;52129:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;52125:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52387:1;52370:6;:13;:18;52366:328;;52413:60;;;;;;;;;;:::i;:::-;;;;;;;;52366:328;52644:6;52638:13;52629:6;52625:2;52621:15;52614:38;52125:584;52261:41;;;52251:51;;;:6;:51;;;;52244:58;;;;;52089:675;52748:4;52741:11;;51918:853;;;;;;;:::o;18265:716::-;18321:13;18372:14;18409:1;18389:17;18400:5;18389:10;:17::i;:::-;:21;18372:38;;18425:20;18459:6;18448:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18425:41;;18481:11;18610:6;18606:2;18602:15;18594:6;18590:28;18583:35;;18647:288;18654:4;18647:288;;;18679:5;;;;;;;;18821:8;18816:2;18809:5;18805:14;18800:30;18795:3;18787:44;18877:2;18868:11;;;;;;:::i;:::-;;;;;18911:1;18902:5;:10;18647:288;18898:21;18647:288;18956:6;18949:13;;;;;18265:716;;;:::o;48329:439::-;48423:1;48409:16;;:2;:16;;;48401:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;48482:16;48490:7;48482;:16::i;:::-;48481:17;48473:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;48544:45;48573:1;48577:2;48581:7;48544:20;:45::i;:::-;48619:1;48602:9;:13;48612:2;48602:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;48650:2;48631:7;:16;48639:7;48631:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;48695:7;48691:2;48670:33;;48687:1;48670:33;;;;;;;;;;;;48716:44;48744:1;48748:2;48752:7;48716:19;:44::i;:::-;48329:439;;:::o;22285:326::-;22345:4;22602:1;22580:7;:19;;;:23;22573:30;;22285:326;;;:::o;15131:922::-;15184:7;15204:14;15221:1;15204:18;;15271:6;15262:5;:15;15258:102;;15307:6;15298:15;;;;;;:::i;:::-;;;;;15342:2;15332:12;;;;15258:102;15387:6;15378:5;:15;15374:102;;15423:6;15414:15;;;;;;:::i;:::-;;;;;15458:2;15448:12;;;;15374:102;15503:6;15494:5;:15;15490:102;;15539:6;15530:15;;;;;;:::i;:::-;;;;;15574:2;15564:12;;;;15490:102;15619:5;15610;:14;15606:99;;15654:5;15645:14;;;;;;:::i;:::-;;;;;15688:1;15678:11;;;;15606:99;15732:5;15723;:14;15719:99;;15767:5;15758:14;;;;;;:::i;:::-;;;;;15801:1;15791:11;;;;15719:99;15845:5;15836;:14;15832:99;;15880:5;15871:14;;;;;;:::i;:::-;;;;;15914:1;15904:11;;;;15832:99;15958:5;15949;:14;15945:66;;15994:1;15984:11;;;;15945:66;16039:6;16032:13;;;15131:922;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:307::-;1866:1;1876:113;1890:6;1887:1;1884:13;1876:113;;;1975:1;1970:3;1966:11;1960:18;1956:1;1951:3;1947:11;1940:39;1912:2;1909:1;1905:10;1900:15;;1876:113;;;2007:6;2004:1;2001:13;1998:101;;;2087:1;2078:6;2073:3;2069:16;2062:27;1998:101;1847:258;1798:307;;;:::o;2111:102::-;2152:6;2203:2;2199:7;2194:2;2187:5;2183:14;2179:28;2169:38;;2111:102;;;:::o;2219:364::-;2307:3;2335:39;2368:5;2335:39;:::i;:::-;2390:71;2454:6;2449:3;2390:71;:::i;:::-;2383:78;;2470:52;2515:6;2510:3;2503:4;2496:5;2492:16;2470:52;:::i;:::-;2547:29;2569:6;2547:29;:::i;:::-;2542:3;2538:39;2531:46;;2311:272;2219:364;;;;:::o;2589:313::-;2702:4;2740:2;2729:9;2725:18;2717:26;;2789:9;2783:4;2779:20;2775:1;2764:9;2760:17;2753:47;2817:78;2890:4;2881:6;2817:78;:::i;:::-;2809:86;;2589:313;;;;:::o;2908:77::-;2945:7;2974:5;2963:16;;2908:77;;;:::o;2991:122::-;3064:24;3082:5;3064:24;:::i;:::-;3057:5;3054:35;3044:63;;3103:1;3100;3093:12;3044:63;2991:122;:::o;3119:139::-;3165:5;3203:6;3190:20;3181:29;;3219:33;3246:5;3219:33;:::i;:::-;3119:139;;;;:::o;3264:329::-;3323:6;3372:2;3360:9;3351:7;3347:23;3343:32;3340:119;;;3378:79;;:::i;:::-;3340:119;3498:1;3523:53;3568:7;3559:6;3548:9;3544:22;3523:53;:::i;:::-;3513:63;;3469:117;3264:329;;;;:::o;3599:126::-;3636:7;3676:42;3669:5;3665:54;3654:65;;3599:126;;;:::o;3731:96::-;3768:7;3797:24;3815:5;3797:24;:::i;:::-;3786:35;;3731:96;;;:::o;3833:118::-;3920:24;3938:5;3920:24;:::i;:::-;3915:3;3908:37;3833:118;;:::o;3957:222::-;4050:4;4088:2;4077:9;4073:18;4065:26;;4101:71;4169:1;4158:9;4154:17;4145:6;4101:71;:::i;:::-;3957:222;;;;:::o;4185:122::-;4258:24;4276:5;4258:24;:::i;:::-;4251:5;4248:35;4238:63;;4297:1;4294;4287:12;4238:63;4185:122;:::o;4313:139::-;4359:5;4397:6;4384:20;4375:29;;4413:33;4440:5;4413:33;:::i;:::-;4313:139;;;;:::o;4458:474::-;4526:6;4534;4583:2;4571:9;4562:7;4558:23;4554:32;4551:119;;;4589:79;;:::i;:::-;4551:119;4709:1;4734:53;4779:7;4770:6;4759:9;4755:22;4734:53;:::i;:::-;4724:63;;4680:117;4836:2;4862:53;4907:7;4898:6;4887:9;4883:22;4862:53;:::i;:::-;4852:63;;4807:118;4458:474;;;;;:::o;4938:619::-;5015:6;5023;5031;5080:2;5068:9;5059:7;5055:23;5051:32;5048:119;;;5086:79;;:::i;:::-;5048:119;5206:1;5231:53;5276:7;5267:6;5256:9;5252:22;5231:53;:::i;:::-;5221:63;;5177:117;5333:2;5359:53;5404:7;5395:6;5384:9;5380:22;5359:53;:::i;:::-;5349:63;;5304:118;5461:2;5487:53;5532:7;5523:6;5512:9;5508:22;5487:53;:::i;:::-;5477:63;;5432:118;4938:619;;;;;:::o;5563:117::-;5672:1;5669;5662:12;5686:117;5795:1;5792;5785:12;5809:180;5857:77;5854:1;5847:88;5954:4;5951:1;5944:15;5978:4;5975:1;5968:15;5995:281;6078:27;6100:4;6078:27;:::i;:::-;6070:6;6066:40;6208:6;6196:10;6193:22;6172:18;6160:10;6157:34;6154:62;6151:88;;;6219:18;;:::i;:::-;6151:88;6259:10;6255:2;6248:22;6038:238;5995:281;;:::o;6282:129::-;6316:6;6343:20;;:::i;:::-;6333:30;;6372:33;6400:4;6392:6;6372:33;:::i;:::-;6282:129;;;:::o;6417:308::-;6479:4;6569:18;6561:6;6558:30;6555:56;;;6591:18;;:::i;:::-;6555:56;6629:29;6651:6;6629:29;:::i;:::-;6621:37;;6713:4;6707;6703:15;6695:23;;6417:308;;;:::o;6731:154::-;6815:6;6810:3;6805;6792:30;6877:1;6868:6;6863:3;6859:16;6852:27;6731:154;;;:::o;6891:412::-;6969:5;6994:66;7010:49;7052:6;7010:49;:::i;:::-;6994:66;:::i;:::-;6985:75;;7083:6;7076:5;7069:21;7121:4;7114:5;7110:16;7159:3;7150:6;7145:3;7141:16;7138:25;7135:112;;;7166:79;;:::i;:::-;7135:112;7256:41;7290:6;7285:3;7280;7256:41;:::i;:::-;6975:328;6891:412;;;;;:::o;7323:340::-;7379:5;7428:3;7421:4;7413:6;7409:17;7405:27;7395:122;;7436:79;;:::i;:::-;7395:122;7553:6;7540:20;7578:79;7653:3;7645:6;7638:4;7630:6;7626:17;7578:79;:::i;:::-;7569:88;;7385:278;7323:340;;;;:::o;7669:509::-;7738:6;7787:2;7775:9;7766:7;7762:23;7758:32;7755:119;;;7793:79;;:::i;:::-;7755:119;7941:1;7930:9;7926:17;7913:31;7971:18;7963:6;7960:30;7957:117;;;7993:79;;:::i;:::-;7957:117;8098:63;8153:7;8144:6;8133:9;8129:22;8098:63;:::i;:::-;8088:73;;7884:287;7669:509;;;;:::o;8184:329::-;8243:6;8292:2;8280:9;8271:7;8267:23;8263:32;8260:119;;;8298:79;;:::i;:::-;8260:119;8418:1;8443:53;8488:7;8479:6;8468:9;8464:22;8443:53;:::i;:::-;8433:63;;8389:117;8184:329;;;;:::o;8519:118::-;8606:24;8624:5;8606:24;:::i;:::-;8601:3;8594:37;8519:118;;:::o;8643:222::-;8736:4;8774:2;8763:9;8759:18;8751:26;;8787:71;8855:1;8844:9;8840:17;8831:6;8787:71;:::i;:::-;8643:222;;;;:::o;8871:116::-;8941:21;8956:5;8941:21;:::i;:::-;8934:5;8931:32;8921:60;;8977:1;8974;8967:12;8921:60;8871:116;:::o;8993:133::-;9036:5;9074:6;9061:20;9052:29;;9090:30;9114:5;9090:30;:::i;:::-;8993:133;;;;:::o;9132:468::-;9197:6;9205;9254:2;9242:9;9233:7;9229:23;9225:32;9222:119;;;9260:79;;:::i;:::-;9222:119;9380:1;9405:53;9450:7;9441:6;9430:9;9426:22;9405:53;:::i;:::-;9395:63;;9351:117;9507:2;9533:50;9575:7;9566:6;9555:9;9551:22;9533:50;:::i;:::-;9523:60;;9478:115;9132:468;;;;;:::o;9606:307::-;9667:4;9757:18;9749:6;9746:30;9743:56;;;9779:18;;:::i;:::-;9743:56;9817:29;9839:6;9817:29;:::i;:::-;9809:37;;9901:4;9895;9891:15;9883:23;;9606:307;;;:::o;9919:410::-;9996:5;10021:65;10037:48;10078:6;10037:48;:::i;:::-;10021:65;:::i;:::-;10012:74;;10109:6;10102:5;10095:21;10147:4;10140:5;10136:16;10185:3;10176:6;10171:3;10167:16;10164:25;10161:112;;;10192:79;;:::i;:::-;10161:112;10282:41;10316:6;10311:3;10306;10282:41;:::i;:::-;10002:327;9919:410;;;;;:::o;10348:338::-;10403:5;10452:3;10445:4;10437:6;10433:17;10429:27;10419:122;;10460:79;;:::i;:::-;10419:122;10577:6;10564:20;10602:78;10676:3;10668:6;10661:4;10653:6;10649:17;10602:78;:::i;:::-;10593:87;;10409:277;10348:338;;;;:::o;10692:943::-;10787:6;10795;10803;10811;10860:3;10848:9;10839:7;10835:23;10831:33;10828:120;;;10867:79;;:::i;:::-;10828:120;10987:1;11012:53;11057:7;11048:6;11037:9;11033:22;11012:53;:::i;:::-;11002:63;;10958:117;11114:2;11140:53;11185:7;11176:6;11165:9;11161:22;11140:53;:::i;:::-;11130:63;;11085:118;11242:2;11268:53;11313:7;11304:6;11293:9;11289:22;11268:53;:::i;:::-;11258:63;;11213:118;11398:2;11387:9;11383:18;11370:32;11429:18;11421:6;11418:30;11415:117;;;11451:79;;:::i;:::-;11415:117;11556:62;11610:7;11601:6;11590:9;11586:22;11556:62;:::i;:::-;11546:72;;11341:287;10692:943;;;;;;;:::o;11641:474::-;11709:6;11717;11766:2;11754:9;11745:7;11741:23;11737:32;11734:119;;;11772:79;;:::i;:::-;11734:119;11892:1;11917:53;11962:7;11953:6;11942:9;11938:22;11917:53;:::i;:::-;11907:63;;11863:117;12019:2;12045:53;12090:7;12081:6;12070:9;12066:22;12045:53;:::i;:::-;12035:63;;11990:118;11641:474;;;;;:::o;12121:180::-;12169:77;12166:1;12159:88;12266:4;12263:1;12256:15;12290:4;12287:1;12280:15;12307:320;12351:6;12388:1;12382:4;12378:12;12368:22;;12435:1;12429:4;12425:12;12456:18;12446:81;;12512:4;12504:6;12500:17;12490:27;;12446:81;12574:2;12566:6;12563:14;12543:18;12540:38;12537:84;;12593:18;;:::i;:::-;12537:84;12358:269;12307:320;;;:::o;12633:220::-;12773:34;12769:1;12761:6;12757:14;12750:58;12842:3;12837:2;12829:6;12825:15;12818:28;12633:220;:::o;12859:366::-;13001:3;13022:67;13086:2;13081:3;13022:67;:::i;:::-;13015:74;;13098:93;13187:3;13098:93;:::i;:::-;13216:2;13211:3;13207:12;13200:19;;12859:366;;;:::o;13231:419::-;13397:4;13435:2;13424:9;13420:18;13412:26;;13484:9;13478:4;13474:20;13470:1;13459:9;13455:17;13448:47;13512:131;13638:4;13512:131;:::i;:::-;13504:139;;13231:419;;;:::o;13656:249::-;13796:34;13792:1;13784:6;13780:14;13773:58;13865:32;13860:2;13852:6;13848:15;13841:57;13656:249;:::o;13911:366::-;14053:3;14074:67;14138:2;14133:3;14074:67;:::i;:::-;14067:74;;14150:93;14239:3;14150:93;:::i;:::-;14268:2;14263:3;14259:12;14252:19;;13911:366;;;:::o;14283:419::-;14449:4;14487:2;14476:9;14472:18;14464:26;;14536:9;14530:4;14526:20;14522:1;14511:9;14507:17;14500:47;14564:131;14690:4;14564:131;:::i;:::-;14556:139;;14283:419;;;:::o;14708:233::-;14848:34;14844:1;14836:6;14832:14;14825:58;14917:16;14912:2;14904:6;14900:15;14893:41;14708:233;:::o;14947:366::-;15089:3;15110:67;15174:2;15169:3;15110:67;:::i;:::-;15103:74;;15186:93;15275:3;15186:93;:::i;:::-;15304:2;15299:3;15295:12;15288:19;;14947:366;;;:::o;15319:419::-;15485:4;15523:2;15512:9;15508:18;15500:26;;15572:9;15566:4;15562:20;15558:1;15547:9;15543:17;15536:47;15600:131;15726:4;15600:131;:::i;:::-;15592:139;;15319:419;;;:::o;15744:148::-;15846:11;15883:3;15868:18;;15744:148;;;;:::o;15898:377::-;16004:3;16032:39;16065:5;16032:39;:::i;:::-;16087:89;16169:6;16164:3;16087:89;:::i;:::-;16080:96;;16185:52;16230:6;16225:3;16218:4;16211:5;16207:16;16185:52;:::i;:::-;16262:6;16257:3;16253:16;16246:23;;16008:267;15898:377;;;;:::o;16281:275::-;16413:3;16435:95;16526:3;16517:6;16435:95;:::i;:::-;16428:102;;16547:3;16540:10;;16281:275;;;;:::o;16562:435::-;16742:3;16764:95;16855:3;16846:6;16764:95;:::i;:::-;16757:102;;16876:95;16967:3;16958:6;16876:95;:::i;:::-;16869:102;;16988:3;16981:10;;16562:435;;;;;:::o;17003:174::-;17143:26;17139:1;17131:6;17127:14;17120:50;17003:174;:::o;17183:366::-;17325:3;17346:67;17410:2;17405:3;17346:67;:::i;:::-;17339:74;;17422:93;17511:3;17422:93;:::i;:::-;17540:2;17535:3;17531:12;17524:19;;17183:366;;;:::o;17555:419::-;17721:4;17759:2;17748:9;17744:18;17736:26;;17808:9;17802:4;17798:20;17794:1;17783:9;17779:17;17772:47;17836:131;17962:4;17836:131;:::i;:::-;17828:139;;17555:419;;;:::o;17980:228::-;18120:34;18116:1;18108:6;18104:14;18097:58;18189:11;18184:2;18176:6;18172:15;18165:36;17980:228;:::o;18214:366::-;18356:3;18377:67;18441:2;18436:3;18377:67;:::i;:::-;18370:74;;18453:93;18542:3;18453:93;:::i;:::-;18571:2;18566:3;18562:12;18555:19;;18214:366;;;:::o;18586:419::-;18752:4;18790:2;18779:9;18775:18;18767:26;;18839:9;18833:4;18829:20;18825:1;18814:9;18810:17;18803:47;18867:131;18993:4;18867:131;:::i;:::-;18859:139;;18586:419;;;:::o;19011:416::-;19151:66;19147:1;19139:6;19135:14;19128:90;19252:66;19247:2;19239:6;19235:15;19228:91;19353:66;19348:2;19340:6;19336:15;19329:91;19011:416;:::o;19433:402::-;19593:3;19614:85;19696:2;19691:3;19614:85;:::i;:::-;19607:92;;19708:93;19797:3;19708:93;:::i;:::-;19826:2;19821:3;19817:12;19810:19;;19433:402;;;:::o;19841:214::-;19981:66;19977:1;19969:6;19965:14;19958:90;19841:214;:::o;20061:400::-;20221:3;20242:84;20324:1;20319:3;20242:84;:::i;:::-;20235:91;;20335:93;20424:3;20335:93;:::i;:::-;20453:1;20448:3;20444:11;20437:18;;20061:400;;;:::o;20467:807::-;20801:3;20823:148;20967:3;20823:148;:::i;:::-;20816:155;;20988:95;21079:3;21070:6;20988:95;:::i;:::-;20981:102;;21100:148;21244:3;21100:148;:::i;:::-;21093:155;;21265:3;21258:10;;20467:807;;;;:::o;21280:180::-;21328:77;21325:1;21318:88;21425:4;21422:1;21415:15;21449:4;21446:1;21439:15;21466:305;21506:3;21525:20;21543:1;21525:20;:::i;:::-;21520:25;;21559:20;21577:1;21559:20;:::i;:::-;21554:25;;21713:1;21645:66;21641:74;21638:1;21635:81;21632:107;;;21719:18;;:::i;:::-;21632:107;21763:1;21760;21756:9;21749:16;;21466:305;;;;:::o;21777:224::-;21917:34;21913:1;21905:6;21901:14;21894:58;21986:7;21981:2;21973:6;21969:15;21962:32;21777:224;:::o;22007:366::-;22149:3;22170:67;22234:2;22229:3;22170:67;:::i;:::-;22163:74;;22246:93;22335:3;22246:93;:::i;:::-;22364:2;22359:3;22355:12;22348:19;;22007:366;;;:::o;22379:419::-;22545:4;22583:2;22572:9;22568:18;22560:26;;22632:9;22626:4;22622:20;22618:1;22607:9;22603:17;22596:47;22660:131;22786:4;22660:131;:::i;:::-;22652:139;;22379:419;;;:::o;22804:223::-;22944:34;22940:1;22932:6;22928:14;22921:58;23013:6;23008:2;23000:6;22996:15;22989:31;22804:223;:::o;23033:366::-;23175:3;23196:67;23260:2;23255:3;23196:67;:::i;:::-;23189:74;;23272:93;23361:3;23272:93;:::i;:::-;23390:2;23385:3;23381:12;23374:19;;23033:366;;;:::o;23405:419::-;23571:4;23609:2;23598:9;23594:18;23586:26;;23658:9;23652:4;23648:20;23644:1;23633:9;23629:17;23622:47;23686:131;23812:4;23686:131;:::i;:::-;23678:139;;23405:419;;;:::o;23830:191::-;23870:4;23890:20;23908:1;23890:20;:::i;:::-;23885:25;;23924:20;23942:1;23924:20;:::i;:::-;23919:25;;23963:1;23960;23957:8;23954:34;;;23968:18;;:::i;:::-;23954:34;24013:1;24010;24006:9;23998:17;;23830:191;;;;:::o;24027:180::-;24075:77;24072:1;24065:88;24172:4;24169:1;24162:15;24196:4;24193:1;24186:15;24213:185;24253:1;24270:20;24288:1;24270:20;:::i;:::-;24265:25;;24304:20;24322:1;24304:20;:::i;:::-;24299:25;;24343:1;24333:35;;24348:18;;:::i;:::-;24333:35;24390:1;24387;24383:9;24378:14;;24213:185;;;;:::o;24404:348::-;24444:7;24467:20;24485:1;24467:20;:::i;:::-;24462:25;;24501:20;24519:1;24501:20;:::i;:::-;24496:25;;24689:1;24621:66;24617:74;24614:1;24611:81;24606:1;24599:9;24592:17;24588:105;24585:131;;;24696:18;;:::i;:::-;24585:131;24744:1;24741;24737:9;24726:20;;24404:348;;;;:::o;24758:175::-;24898:27;24894:1;24886:6;24882:14;24875:51;24758:175;:::o;24939:366::-;25081:3;25102:67;25166:2;25161:3;25102:67;:::i;:::-;25095:74;;25178:93;25267:3;25178:93;:::i;:::-;25296:2;25291:3;25287:12;25280:19;;24939:366;;;:::o;25311:419::-;25477:4;25515:2;25504:9;25500:18;25492:26;;25564:9;25558:4;25554:20;25550:1;25539:9;25535:17;25528:47;25592:131;25718:4;25592:131;:::i;:::-;25584:139;;25311:419;;;:::o;25736:233::-;25876:34;25872:1;25864:6;25860:14;25853:58;25945:16;25940:2;25932:6;25928:15;25921:41;25736:233;:::o;25975:366::-;26117:3;26138:67;26202:2;26197:3;26138:67;:::i;:::-;26131:74;;26214:93;26303:3;26214:93;:::i;:::-;26332:2;26327:3;26323:12;26316:19;;25975:366;;;:::o;26347:419::-;26513:4;26551:2;26540:9;26536:18;26528:26;;26600:9;26594:4;26590:20;26586:1;26575:9;26571:17;26564:47;26628:131;26754:4;26628:131;:::i;:::-;26620:139;;26347:419;;;:::o;26772:237::-;26912:34;26908:1;26900:6;26896:14;26889:58;26981:20;26976:2;26968:6;26964:15;26957:45;26772:237;:::o;27015:366::-;27157:3;27178:67;27242:2;27237:3;27178:67;:::i;:::-;27171:74;;27254:93;27343:3;27254:93;:::i;:::-;27372:2;27367:3;27363:12;27356:19;;27015:366;;;:::o;27387:419::-;27553:4;27591:2;27580:9;27576:18;27568:26;;27640:9;27634:4;27630:20;27626:1;27615:9;27611:17;27604:47;27668:131;27794:4;27668:131;:::i;:::-;27660:139;;27387:419;;;:::o;27812:98::-;27863:6;27897:5;27891:12;27881:22;;27812:98;;;:::o;27916:168::-;27999:11;28033:6;28028:3;28021:19;28073:4;28068:3;28064:14;28049:29;;27916:168;;;;:::o;28090:360::-;28176:3;28204:38;28236:5;28204:38;:::i;:::-;28258:70;28321:6;28316:3;28258:70;:::i;:::-;28251:77;;28337:52;28382:6;28377:3;28370:4;28363:5;28359:16;28337:52;:::i;:::-;28414:29;28436:6;28414:29;:::i;:::-;28409:3;28405:39;28398:46;;28180:270;28090:360;;;;:::o;28456:640::-;28651:4;28689:3;28678:9;28674:19;28666:27;;28703:71;28771:1;28760:9;28756:17;28747:6;28703:71;:::i;:::-;28784:72;28852:2;28841:9;28837:18;28828:6;28784:72;:::i;:::-;28866;28934:2;28923:9;28919:18;28910:6;28866:72;:::i;:::-;28985:9;28979:4;28975:20;28970:2;28959:9;28955:18;28948:48;29013:76;29084:4;29075:6;29013:76;:::i;:::-;29005:84;;28456:640;;;;;;;:::o;29102:141::-;29158:5;29189:6;29183:13;29174:22;;29205:32;29231:5;29205:32;:::i;:::-;29102:141;;;;:::o;29249:349::-;29318:6;29367:2;29355:9;29346:7;29342:23;29338:32;29335:119;;;29373:79;;:::i;:::-;29335:119;29493:1;29518:63;29573:7;29564:6;29553:9;29549:22;29518:63;:::i;:::-;29508:73;;29464:127;29249:349;;;;:::o;29604:182::-;29744:34;29740:1;29732:6;29728:14;29721:58;29604:182;:::o;29792:366::-;29934:3;29955:67;30019:2;30014:3;29955:67;:::i;:::-;29948:74;;30031:93;30120:3;30031:93;:::i;:::-;30149:2;30144:3;30140:12;30133:19;;29792:366;;;:::o;30164:419::-;30330:4;30368:2;30357:9;30353:18;30345:26;;30417:9;30411:4;30407:20;30403:1;30392:9;30388:17;30381:47;30445:131;30571:4;30445:131;:::i;:::-;30437:139;;30164:419;;;:::o;30589:178::-;30729:30;30725:1;30717:6;30713:14;30706:54;30589:178;:::o;30773:366::-;30915:3;30936:67;31000:2;30995:3;30936:67;:::i;:::-;30929:74;;31012:93;31101:3;31012:93;:::i;:::-;31130:2;31125:3;31121:12;31114:19;;30773:366;;;:::o;31145:419::-;31311:4;31349:2;31338:9;31334:18;31326:26;;31398:9;31392:4;31388:20;31384:1;31373:9;31369:17;31362:47;31426:131;31552:4;31426:131;:::i;:::-;31418:139;;31145:419;;;:::o
Swarm Source
ipfs://4095ef9875ebfb4f1d31edaaeef7f15626e929feb8c0a07060feb85a41f47935
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.