Token BingoNFT
Overview CRC721
Total Supply:
769 BNFT
Holders:
105 addresses
Contract:
Balance
16 BNFT
[ Download CSV Export ]
[ Download CSV Export ]
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
BingoNFT
Compiler Version
v0.8.13+commit.abaa5c0e
Contract Source Code (Solidity)
/** *Submitted for verification at cronoscan.com on 2023-02-07 */ // File: @openzeppelin/contracts/token/ERC20/IERC20.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); } // File: @openzeppelin/contracts/utils/math/Math.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } // File: @openzeppelin/contracts/token/ERC721/extensions/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/ERC721Burnable.sol // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Burnable.sol) pragma solidity ^0.8.0; /** * @title ERC721 Burnable Token * @dev ERC721 Token that can be burned (destroyed). */ abstract contract ERC721Burnable is Context, ERC721 { /** * @dev Burns `tokenId`. See {ERC721-_burn}. * * Requirements: * * - The caller must own `tokenId` or be an approved operator. */ function burn(uint256 tokenId) public virtual { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _burn(tokenId); } } // File: @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: contracts/Cromunds.sol pragma solidity >=0.7.0 <0.9.0; contract BingoNFT is ERC721Enumerable, ERC721Burnable, Ownable { using Strings for uint256; IERC20 public tokenAddress; string baseURI; string public baseExtension = ".json"; uint256 public cost = 25 ether; uint256 public maxSupply = 5000; uint256 public maxMintAmount = 20; bool public paused = false; bool public revealed = false; string public notRevealedUri; string public initBaseURI; constructor( string memory _initBaseURI, string memory _initNotRevealedUri, address _tokenAddress ) ERC721("BingoNFT", "BNFT") { setBaseURI(_initBaseURI); setNotRevealedURI(_initNotRevealedUri); tokenAddress = IERC20(_tokenAddress); } // internal function _baseURI() internal view virtual override returns (string memory) { return baseURI; } // The following functions are overrides required by Solidity. function _beforeTokenTransfer( address from, address to, uint256 tokenId, uint256 batchSize ) internal override(ERC721, ERC721Enumerable) { super._beforeTokenTransfer(from, to, tokenId, batchSize); } function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) { return super.supportsInterface(interfaceId); } // public function mint(uint256 _mintAmount) public { uint256 supply = totalSupply(); require(!paused); require(_mintAmount > 0); require(_mintAmount <= maxMintAmount); require(supply + _mintAmount <= maxSupply); uint256 due = _mintAmount * cost; if (msg.sender != owner()) { tokenAddress.transferFrom(msg.sender, address(this), due); } for (uint256 i = 1; i <= _mintAmount; i++) { _safeMint(msg.sender, supply + i); } } function walletOfOwner(address _owner) public view returns (uint256[] memory) { uint256 ownerTokenCount = balanceOf(_owner); uint256[] memory tokenIds = new uint256[](ownerTokenCount); for (uint256 i; i < ownerTokenCount; i++) { tokenIds[i] = tokenOfOwnerByIndex(_owner, i); } return tokenIds; } function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require( _exists(tokenId), "ERC721Metadata: URI query for nonexistent token" ); if (revealed == false) { return notRevealedUri; } string memory currentBaseURI = _baseURI(); return bytes(currentBaseURI).length > 0 ? string( abi.encodePacked( currentBaseURI, tokenId.toString(), baseExtension ) ) : ""; } //only owner function reveal() public onlyOwner { revealed = true; } function setCost(uint256 _newCost) public onlyOwner { cost = _newCost; } function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner { maxMintAmount = _newmaxMintAmount; } function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner { notRevealedUri = _notRevealedURI; } function setBaseURI(string memory _newBaseURI) public onlyOwner { baseURI = _newBaseURI; } function setBaseExtension(string memory _newBaseExtension) public onlyOwner { baseExtension = _newBaseExtension; } function pause(bool _state) public onlyOwner { paused = _state; } function withdraw(address _to, uint256 _amount) public onlyOwner { tokenAddress.transfer(_to, _amount); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_initBaseURI","type":"string"},{"internalType":"string","name":"_initNotRevealedUri","type":"string"},{"internalType":"address","name":"_tokenAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":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":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initBaseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notRevealedUri","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":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_notRevealedURI","type":"string"}],"name":"setNotRevealedURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newmaxMintAmount","type":"uint256"}],"name":"setmaxMintAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenAddress","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"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","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000006c04b0ad236e7ca3b3189b1d049fe80109c7977000000000000000000000000000000000000000000000000000000000000005168747470733a2f2f63616e64792e6d7970696e6174612e636c6f75642f697066732f516d6350523148424444627048327a354e4265737665724d5859464a483463355263694d633957627347624651762f0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _initBaseURI (string): https://candy.mypinata.cloud/ipfs/QmcPR1HBDDbpH2z5NBesverMXYFJH4c5RciMc9WbsGbFQv/
Arg [1] : _initNotRevealedUri (string):
Arg [2] : _tokenAddress (address): 0x06c04b0ad236e7ca3b3189b1d049fe80109c7977
-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 00000000000000000000000006c04b0ad236e7ca3b3189b1d049fe80109c7977
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000051
Arg [4] : 68747470733a2f2f63616e64792e6d7970696e6174612e636c6f75642f697066
Arg [5] : 732f516d6350523148424444627048327a354e4265737665724d5859464a4834
Arg [6] : 63355263694d633957627347624651762f000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000000
Deployed ByteCode Sourcemap
66173:4067:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;67398:212;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70031:79;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43431:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44943:171;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66558:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44461:416;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66375:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;60796:113;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66450:33;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45643:335;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60464:256;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46049:185;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58881:242;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;68176:390;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69402:86;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60986:233;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66523:28;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69760:104;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66490:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43141:223;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66593:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42872:207;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20854:103;;;:::i;:::-;;69496:122;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;20206:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43600:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66275:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;67633:535;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45186:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69325:69;;;:::i;:::-;;46305:322;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;66331:37;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68574:725;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;66412:31;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69872:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45412:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69626:126;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;21112:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70118:119;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;67398:212;67537:4;67566:36;67590:11;67566:23;:36::i;:::-;67559:43;;67398:212;;;:::o;70031:79::-;20092:13;:11;:13::i;:::-;70096:6:::1;70087;;:15;;;;;;;;;;;;;;;;;;70031:79:::0;:::o;43431:100::-;43485:13;43518:5;43511:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43431:100;:::o;44943:171::-;45019:7;45039:23;45054:7;45039:14;:23::i;:::-;45082:15;:24;45098:7;45082:24;;;;;;;;;;;;;;;;;;;;;45075:31;;44943:171;;;:::o;66558:28::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;44461:416::-;44542:13;44558:23;44573:7;44558:14;:23::i;:::-;44542:39;;44606:5;44600:11;;:2;:11;;;44592:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;44700:5;44684:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;44709:37;44726:5;44733:12;:10;:12::i;:::-;44709:16;:37::i;:::-;44684:62;44662:173;;;;;;;;;;;;:::i;:::-;;;;;;;;;44848:21;44857:2;44861:7;44848:8;:21::i;:::-;44531:346;44461:416;;:::o;66375:30::-;;;;:::o;60796:113::-;60857:7;60884:10;:17;;;;60877:24;;60796:113;:::o;66450:33::-;;;;:::o;45643:335::-;45838:41;45857:12;:10;:12::i;:::-;45871:7;45838:18;:41::i;:::-;45830:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;45942:28;45952:4;45958:2;45962:7;45942:9;:28::i;:::-;45643:335;;;:::o;60464:256::-;60561:7;60597:23;60614:5;60597:16;:23::i;:::-;60589:5;:31;60581:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;60686:12;:19;60699:5;60686:19;;;;;;;;;;;;;;;:26;60706:5;60686:26;;;;;;;;;;;;60679:33;;60464:256;;;;:::o;46049:185::-;46187:39;46204:4;46210:2;46214:7;46187:39;;;;;;;;;;;;:16;:39::i;:::-;46049:185;;;:::o;58881:242::-;58999:41;59018:12;:10;:12::i;:::-;59032:7;58999:18;:41::i;:::-;58991:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;59101:14;59107:7;59101:5;:14::i;:::-;58881:242;:::o;68176:390::-;68263:16;68297:23;68323:17;68333:6;68323:9;:17::i;:::-;68297:43;;68351:25;68393:15;68379:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68351:58;;68425:9;68420:113;68440:15;68436:1;:19;68420:113;;;68491:30;68511:6;68519:1;68491:19;:30::i;:::-;68477:8;68486:1;68477:11;;;;;;;;:::i;:::-;;;;;;;:44;;;;;68457:3;;;;;:::i;:::-;;;;68420:113;;;;68550:8;68543:15;;;;68176:390;;;:::o;69402:86::-;20092:13;:11;:13::i;:::-;69472:8:::1;69465:4;:15;;;;69402:86:::0;:::o;60986:233::-;61061:7;61097:30;:28;:30::i;:::-;61089:5;:38;61081:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;61194:10;61205:5;61194:17;;;;;;;;:::i;:::-;;;;;;;;;;61187:24;;60986:233;;;:::o;66523:28::-;;;;;;;;;;;;;:::o;69760:104::-;20092:13;:11;:13::i;:::-;69845:11:::1;69835:7;:21;;;;;;;;;;;;:::i;:::-;;69760:104:::0;:::o;66490:26::-;;;;;;;;;;;;;:::o;43141:223::-;43213:7;43233:13;43249:17;43258:7;43249:8;:17::i;:::-;43233:33;;43302:1;43285:19;;:5;:19;;;43277:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;43351:5;43344:12;;;43141:223;;;:::o;66593:25::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;42872:207::-;42944:7;42989:1;42972:19;;:5;:19;;;42964:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;43055:9;:16;43065:5;43055:16;;;;;;;;;;;;;;;;43048:23;;42872:207;;;:::o;20854:103::-;20092:13;:11;:13::i;:::-;20919:30:::1;20946:1;20919:18;:30::i;:::-;20854:103::o:0;69496:122::-;20092:13;:11;:13::i;:::-;69593:17:::1;69577:13;:33;;;;69496:122:::0;:::o;20206:87::-;20252:7;20279:6;;;;;;;;;;;20272:13;;20206:87;:::o;43600:104::-;43656:13;43689:7;43682:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43600:104;:::o;66275:26::-;;;;;;;;;;;;;:::o;67633:535::-;67686:14;67703:13;:11;:13::i;:::-;67686:30;;67736:6;;;;;;;;;;;67735:7;67727:16;;;;;;67776:1;67762:11;:15;67754:24;;;;;;67812:13;;67797:11;:28;;67789:37;;;;;;67869:9;;67854:11;67845:6;:20;;;;:::i;:::-;:33;;67837:42;;;;;;67890:11;67918:4;;67904:11;:18;;;;:::i;:::-;67890:32;;67953:7;:5;:7::i;:::-;67939:21;;:10;:21;;;67935:111;;67977:12;;;;;;;;;;;:25;;;68003:10;68023:4;68030:3;67977:57;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;67935:111;68063:9;68075:1;68063:13;;68058:103;68083:11;68078:1;:16;68058:103;;68116:33;68126:10;68147:1;68138:6;:10;;;;:::i;:::-;68116:9;:33::i;:::-;68096:3;;;;;:::i;:::-;;;;68058:103;;;;67675:493;;67633:535;:::o;45186:155::-;45281:52;45300:12;:10;:12::i;:::-;45314:8;45324;45281:18;:52::i;:::-;45186:155;;:::o;69325:69::-;20092:13;:11;:13::i;:::-;69382:4:::1;69371:8;;:15;;;;;;;;;;;;;;;;;;69325:69::o:0;46305:322::-;46479:41;46498:12;:10;:12::i;:::-;46512:7;46479:18;:41::i;:::-;46471:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;46581:38;46595:4;46601:2;46605:7;46614:4;46581:13;:38::i;:::-;46305:322;;;;:::o;66331:37::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;68574:725::-;68692:13;68745:16;68753:7;68745;:16::i;:::-;68723:113;;;;;;;;;;;;:::i;:::-;;;;;;;;;68865:5;68853:17;;:8;;;;;;;;;;;:17;;;68849:71;;68894:14;68887:21;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68849:71;68932:28;68963:10;:8;:10::i;:::-;68932:41;;69035:1;69010:14;69004:28;:32;:287;;;;;;;;;;;;;;;;;69128:14;69169:18;:7;:16;:18::i;:::-;69214:13;69085:165;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;69004:287;68984:307;;;68574:725;;;;:::o;66412:31::-;;;;:::o;69872:151::-;20092:13;:11;:13::i;:::-;69998:17:::1;69982:13;:33;;;;;;;;;;;;:::i;:::-;;69872:151:::0;:::o;45412:164::-;45509:4;45533:18;:25;45552:5;45533:25;;;;;;;;;;;;;;;:35;45559:8;45533:35;;;;;;;;;;;;;;;;;;;;;;;;;45526:42;;45412:164;;;;:::o;69626:126::-;20092:13;:11;:13::i;:::-;69729:15:::1;69712:14;:32;;;;;;;;;;;;:::i;:::-;;69626:126:::0;:::o;21112:201::-;20092:13;:11;:13::i;:::-;21221:1:::1;21201:22;;:8;:22;;::::0;21193:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;21277:28;21296:8;21277:18;:28::i;:::-;21112:201:::0;:::o;70118:119::-;20092:13;:11;:13::i;:::-;70194:12:::1;;;;;;;;;;;:21;;;70216:3;70221:7;70194:35;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;70118:119:::0;;:::o;60156:224::-;60258:4;60297:35;60282:50;;;:11;:50;;;;:90;;;;60336:36;60360:11;60336:23;:36::i;:::-;60282:90;60275:97;;60156:224;;;:::o;20371:132::-;20446:12;:10;:12::i;:::-;20435:23;;:7;:5;:7::i;:::-;:23;;;20427:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;20371:132::o;54762:135::-;54844:16;54852:7;54844;:16::i;:::-;54836:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;54762:135;:::o;18757:98::-;18810:7;18837:10;18830:17;;18757:98;:::o;54041:174::-;54143:2;54116:15;:24;54132:7;54116:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;54199:7;54195:2;54161:46;;54170:23;54185:7;54170:14;:23::i;:::-;54161:46;;;;;;;;;;;;54041:174;;:::o;48660:264::-;48753:4;48770:13;48786:23;48801:7;48786:14;:23::i;:::-;48770:39;;48839:5;48828:16;;:7;:16;;;:52;;;;48848:32;48865:5;48872:7;48848:16;:32::i;:::-;48828:52;:87;;;;48908:7;48884:31;;:20;48896:7;48884:11;:20::i;:::-;:31;;;48828:87;48820:96;;;48660:264;;;;:::o;52659:1263::-;52818:4;52791:31;;:23;52806:7;52791:14;:23::i;:::-;:31;;;52783:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;52897:1;52883:16;;:2;:16;;;52875:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;52953:42;52974:4;52980:2;52984:7;52993:1;52953:20;:42::i;:::-;53125:4;53098:31;;:23;53113:7;53098:14;:23::i;:::-;:31;;;53090:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;53243:15;:24;53259:7;53243:24;;;;;;;;;;;;53236:31;;;;;;;;;;;53738:1;53719:9;:15;53729:4;53719:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;53771:1;53754:9;:13;53764:2;53754:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;53813:2;53794:7;:16;53802:7;53794:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;53852:7;53848:2;53833:27;;53842:4;53833:27;;;;;;;;;;;;53873:41;53893:4;53899:2;53903:7;53912:1;53873:19;:41::i;:::-;52659:1263;;;:::o;51539:783::-;51599:13;51615:23;51630:7;51615:14;:23::i;:::-;51599:39;;51651:51;51672:5;51687:1;51691:7;51700:1;51651:20;:51::i;:::-;51815:23;51830:7;51815:14;:23::i;:::-;51807:31;;51886:15;:24;51902:7;51886:24;;;;;;;;;;;;51879:31;;;;;;;;;;;52151:1;52131:9;:16;52141:5;52131:16;;;;;;;;;;;;;;;;:21;;;;;;;;;;;52181:7;:16;52189:7;52181:16;;;;;;;;;;;;52174:23;;;;;;;;;;;52243:7;52239:1;52215:36;;52224:5;52215:36;;;;;;;;;;;;52264:50;52284:5;52299:1;52303:7;52312:1;52264:19;:50::i;:::-;51588:734;51539:783;:::o;47935:117::-;48001:7;48028;:16;48036:7;48028:16;;;;;;;;;;;;;;;;;;;;;48021:23;;47935:117;;;:::o;21473:191::-;21547:16;21566:6;;;;;;;;;;;21547:25;;21592:8;21583:6;;:17;;;;;;;;;;;;;;;;;;21647:8;21616:40;;21637:8;21616:40;;;;;;;;;;;;21536:128;21473:191;:::o;49266:110::-;49342:26;49352:2;49356:7;49342:26;;;;;;;;;;;;:9;:26::i;:::-;49266:110;;:::o;54358:315::-;54513:8;54504:17;;:5;:17;;;54496:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;54600:8;54562:18;:25;54581:5;54562:25;;;;;;;;;;;;;;;:35;54588:8;54562:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;54646:8;54624:41;;54639:5;54624:41;;;54656:8;54624:41;;;;;;:::i;:::-;;;;;;;;54358:315;;;:::o;47508:313::-;47664:28;47674:4;47680:2;47684:7;47664:9;:28::i;:::-;47711:47;47734:4;47740:2;47744:7;47753:4;47711:22;:47::i;:::-;47703:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;47508:313;;;;:::o;48365:128::-;48430:4;48483:1;48454:31;;:17;48463:7;48454:8;:17::i;:::-;:31;;;;48447:38;;48365:128;;;:::o;66950:108::-;67010:13;67043:7;67036:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66950:108;:::o;16184:716::-;16240:13;16291:14;16328:1;16308:17;16319:5;16308:10;:17::i;:::-;:21;16291:38;;16344:20;16378:6;16367:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16344:41;;16400:11;16529:6;16525:2;16521:15;16513:6;16509:28;16502:35;;16566:288;16573:4;16566:288;;;16598:5;;;;;;;;16740:8;16735:2;16728:5;16724:14;16719:30;16714:3;16706:44;16796:2;16787:11;;;;;;:::i;:::-;;;;;16830:1;16821:5;:10;16566:288;16817:21;16566:288;16875:6;16868:13;;;;;16184:716;;;:::o;42503:305::-;42605:4;42657:25;42642:40;;;:11;:40;;;;:105;;;;42714:33;42699:48;;;:11;:48;;;;42642:105;:158;;;;42764:36;42788:11;42764:23;:36::i;:::-;42642:158;42622:178;;42503:305;;;:::o;67136:254::-;67326:56;67353:4;67359:2;67363:7;67372:9;67326:26;:56::i;:::-;67136:254;;;;:::o;58178:158::-;;;;;:::o;49603:319::-;49732:18;49738:2;49742:7;49732:5;:18::i;:::-;49783:53;49814:1;49818:2;49822:7;49831:4;49783:22;:53::i;:::-;49761:153;;;;;;;;;;;;:::i;:::-;;;;;;;;;49603:319;;;:::o;55461:853::-;55615:4;55636:15;:2;:13;;;:15::i;:::-;55632:675;;;55688:2;55672:36;;;55709:12;:10;:12::i;:::-;55723:4;55729:7;55738:4;55672:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;55668:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55930:1;55913:6;:13;:18;55909:328;;55956:60;;;;;;;;;;:::i;:::-;;;;;;;;55909:328;56187:6;56181:13;56172:6;56168:2;56164:15;56157:38;55668:584;55804:41;;;55794:51;;;:6;:51;;;;55787:58;;;;;55632:675;56291:4;56284:11;;55461:853;;;;;;;:::o;13050:922::-;13103:7;13123:14;13140:1;13123:18;;13190:6;13181:5;:15;13177:102;;13226:6;13217:15;;;;;;:::i;:::-;;;;;13261:2;13251:12;;;;13177:102;13306:6;13297:5;:15;13293:102;;13342:6;13333:15;;;;;;:::i;:::-;;;;;13377:2;13367:12;;;;13293:102;13422:6;13413:5;:15;13409:102;;13458:6;13449:15;;;;;;:::i;:::-;;;;;13493:2;13483:12;;;;13409:102;13538:5;13529;:14;13525:99;;13573:5;13564:14;;;;;;:::i;:::-;;;;;13607:1;13597:11;;;;13525:99;13651:5;13642;:14;13638:99;;13686:5;13677:14;;;;;;:::i;:::-;;;;;13720:1;13710:11;;;;13638:99;13764:5;13755;:14;13751:99;;13799:5;13790:14;;;;;;:::i;:::-;;;;;13833:1;13823:11;;;;13751:99;13877:5;13868;:14;13864:66;;13913:1;13903:11;;;;13864:66;13958:6;13951:13;;;13050:922;;;:::o;33935:157::-;34020:4;34059:25;34044:40;;;:11;:40;;;;34037:47;;33935:157;;;:::o;61293:915::-;61470:61;61497:4;61503:2;61507:12;61521:9;61470:26;:61::i;:::-;61560:1;61548:9;:13;61544:222;;;61691:63;;;;;;;;;;:::i;:::-;;;;;;;;61544:222;61778:15;61796:12;61778:30;;61841:1;61825:18;;:4;:18;;;61821:187;;61860:40;61892:7;61860:31;:40::i;:::-;61821:187;;;61930:2;61922:10;;:4;:10;;;61918:90;;61949:47;61982:4;61988:7;61949:32;:47::i;:::-;61918:90;61821:187;62036:1;62022:16;;:2;:16;;;62018:183;;62055:45;62092:7;62055:36;:45::i;:::-;62018:183;;;62128:4;62122:10;;:2;:10;;;62118:83;;62149:40;62177:2;62181:7;62149:27;:40::i;:::-;62118:83;62018:183;61459:749;61293:915;;;;:::o;50258:942::-;50352:1;50338:16;;:2;:16;;;50330:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;50411:16;50419:7;50411;:16::i;:::-;50410:17;50402:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;50473:48;50502:1;50506:2;50510:7;50519:1;50473:20;:48::i;:::-;50620:16;50628:7;50620;:16::i;:::-;50619:17;50611:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;51035:1;51018:9;:13;51028:2;51018:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;51079:2;51060:7;:16;51068:7;51060:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;51124:7;51120:2;51099:33;;51116:1;51099:33;;;;;;;;;;;;51145:47;51173:1;51177:2;51181:7;51190:1;51145:19;:47::i;:::-;50258:942;;:::o;22904:326::-;22964:4;23221:1;23199:7;:19;;;:23;23192:30;;22904:326;;;:::o;57046:410::-;57236:1;57224:9;:13;57220:229;;;57274:1;57258:18;;:4;:18;;;57254:87;;57316:9;57297;:15;57307:4;57297:15;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;57254:87;57373:1;57359:16;;:2;:16;;;57355:83;;57413:9;57396;:13;57406:2;57396:13;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;57355:83;57220:229;57046:410;;;;:::o;62931:164::-;63035:10;:17;;;;63008:15;:24;63024:7;63008:24;;;;;;;;;;;:44;;;;63063:10;63079:7;63063:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62931:164;:::o;63722:988::-;63988:22;64038:1;64013:22;64030:4;64013:16;:22::i;:::-;:26;;;;:::i;:::-;63988:51;;64050:18;64071:17;:26;64089:7;64071:26;;;;;;;;;;;;64050:47;;64218:14;64204:10;:28;64200:328;;64249:19;64271:12;:18;64284:4;64271:18;;;;;;;;;;;;;;;:34;64290:14;64271:34;;;;;;;;;;;;64249:56;;64355:11;64322:12;:18;64335:4;64322:18;;;;;;;;;;;;;;;:30;64341:10;64322:30;;;;;;;;;;;:44;;;;64472:10;64439:17;:30;64457:11;64439:30;;;;;;;;;;;:43;;;;64234:294;64200:328;64624:17;:26;64642:7;64624:26;;;;;;;;;;;64617:33;;;64668:12;:18;64681:4;64668:18;;;;;;;;;;;;;;;:34;64687:14;64668:34;;;;;;;;;;;64661:41;;;63803:907;;63722:988;;:::o;65005:1079::-;65258:22;65303:1;65283:10;:17;;;;:21;;;;:::i;:::-;65258:46;;65315:18;65336:15;:24;65352:7;65336:24;;;;;;;;;;;;65315:45;;65687:19;65709:10;65720:14;65709:26;;;;;;;;:::i;:::-;;;;;;;;;;65687:48;;65773:11;65748:10;65759;65748:22;;;;;;;;:::i;:::-;;;;;;;;;:36;;;;65884:10;65853:15;:28;65869:11;65853:28;;;;;;;;;;;:41;;;;66025:15;:24;66041:7;66025:24;;;;;;;;;;;66018:31;;;66060:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;65076:1008;;;65005:1079;:::o;62509:221::-;62594:14;62611:20;62628:2;62611:16;:20::i;:::-;62594:37;;62669:7;62642:12;:16;62655:2;62642:16;;;;;;;;;;;;;;;:24;62659:6;62642:24;;;;;;;;;;;:34;;;;62716:6;62687:17;:26;62705:7;62687:26;;;;;;;;;;;:35;;;;62583:147;62509:221;;:::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:116::-;1588:21;1603:5;1588:21;:::i;:::-;1581:5;1578:32;1568:60;;1624:1;1621;1614:12;1568:60;1518:116;:::o;1640:133::-;1683:5;1721:6;1708:20;1699:29;;1737:30;1761:5;1737:30;:::i;:::-;1640:133;;;;:::o;1779:323::-;1835:6;1884:2;1872:9;1863:7;1859:23;1855:32;1852:119;;;1890:79;;:::i;:::-;1852:119;2010:1;2035:50;2077:7;2068:6;2057:9;2053:22;2035:50;:::i;:::-;2025:60;;1981:114;1779:323;;;;:::o;2108:99::-;2160:6;2194:5;2188:12;2178:22;;2108:99;;;:::o;2213:169::-;2297:11;2331:6;2326:3;2319:19;2371:4;2366:3;2362:14;2347:29;;2213:169;;;;:::o;2388:307::-;2456:1;2466:113;2480:6;2477:1;2474:13;2466:113;;;2565:1;2560:3;2556:11;2550:18;2546:1;2541:3;2537:11;2530:39;2502:2;2499:1;2495:10;2490:15;;2466:113;;;2597:6;2594:1;2591:13;2588:101;;;2677:1;2668:6;2663:3;2659:16;2652:27;2588:101;2437:258;2388:307;;;:::o;2701:102::-;2742:6;2793:2;2789:7;2784:2;2777:5;2773:14;2769:28;2759:38;;2701:102;;;:::o;2809:364::-;2897:3;2925:39;2958:5;2925:39;:::i;:::-;2980:71;3044:6;3039:3;2980:71;:::i;:::-;2973:78;;3060:52;3105:6;3100:3;3093:4;3086:5;3082:16;3060:52;:::i;:::-;3137:29;3159:6;3137:29;:::i;:::-;3132:3;3128:39;3121:46;;2901:272;2809:364;;;;:::o;3179:313::-;3292:4;3330:2;3319:9;3315:18;3307:26;;3379:9;3373:4;3369:20;3365:1;3354:9;3350:17;3343:47;3407:78;3480:4;3471:6;3407:78;:::i;:::-;3399:86;;3179:313;;;;:::o;3498:77::-;3535:7;3564:5;3553:16;;3498:77;;;:::o;3581:122::-;3654:24;3672:5;3654:24;:::i;:::-;3647:5;3644:35;3634:63;;3693:1;3690;3683:12;3634:63;3581:122;:::o;3709:139::-;3755:5;3793:6;3780:20;3771:29;;3809:33;3836:5;3809:33;:::i;:::-;3709:139;;;;:::o;3854:329::-;3913:6;3962:2;3950:9;3941:7;3937:23;3933:32;3930:119;;;3968:79;;:::i;:::-;3930:119;4088:1;4113:53;4158:7;4149:6;4138:9;4134:22;4113:53;:::i;:::-;4103:63;;4059:117;3854:329;;;;:::o;4189:126::-;4226:7;4266:42;4259:5;4255:54;4244:65;;4189:126;;;:::o;4321:96::-;4358:7;4387:24;4405:5;4387:24;:::i;:::-;4376:35;;4321:96;;;:::o;4423:118::-;4510:24;4528:5;4510:24;:::i;:::-;4505:3;4498:37;4423:118;;:::o;4547:222::-;4640:4;4678:2;4667:9;4663:18;4655:26;;4691:71;4759:1;4748:9;4744:17;4735:6;4691:71;:::i;:::-;4547:222;;;;:::o;4775:122::-;4848:24;4866:5;4848:24;:::i;:::-;4841:5;4838:35;4828:63;;4887:1;4884;4877:12;4828:63;4775:122;:::o;4903:139::-;4949:5;4987:6;4974:20;4965:29;;5003:33;5030:5;5003:33;:::i;:::-;4903:139;;;;:::o;5048:474::-;5116:6;5124;5173:2;5161:9;5152:7;5148:23;5144:32;5141:119;;;5179:79;;:::i;:::-;5141:119;5299:1;5324:53;5369:7;5360:6;5349:9;5345:22;5324:53;:::i;:::-;5314:63;;5270:117;5426:2;5452:53;5497:7;5488:6;5477:9;5473:22;5452:53;:::i;:::-;5442:63;;5397:118;5048:474;;;;;:::o;5528:118::-;5615:24;5633:5;5615:24;:::i;:::-;5610:3;5603:37;5528:118;;:::o;5652:222::-;5745:4;5783:2;5772:9;5768:18;5760:26;;5796:71;5864:1;5853:9;5849:17;5840:6;5796:71;:::i;:::-;5652:222;;;;:::o;5880:619::-;5957:6;5965;5973;6022:2;6010:9;6001:7;5997:23;5993:32;5990:119;;;6028:79;;:::i;:::-;5990:119;6148:1;6173:53;6218:7;6209:6;6198:9;6194:22;6173:53;:::i;:::-;6163:63;;6119:117;6275:2;6301:53;6346:7;6337:6;6326:9;6322:22;6301:53;:::i;:::-;6291:63;;6246:118;6403:2;6429:53;6474:7;6465:6;6454:9;6450:22;6429:53;:::i;:::-;6419:63;;6374:118;5880:619;;;;;:::o;6505:329::-;6564:6;6613:2;6601:9;6592:7;6588:23;6584:32;6581:119;;;6619:79;;:::i;:::-;6581:119;6739:1;6764:53;6809:7;6800:6;6789:9;6785:22;6764:53;:::i;:::-;6754:63;;6710:117;6505:329;;;;:::o;6840:114::-;6907:6;6941:5;6935:12;6925:22;;6840:114;;;:::o;6960:184::-;7059:11;7093:6;7088:3;7081:19;7133:4;7128:3;7124:14;7109:29;;6960:184;;;;:::o;7150:132::-;7217:4;7240:3;7232:11;;7270:4;7265:3;7261:14;7253:22;;7150:132;;;:::o;7288:108::-;7365:24;7383:5;7365:24;:::i;:::-;7360:3;7353:37;7288:108;;:::o;7402:179::-;7471:10;7492:46;7534:3;7526:6;7492:46;:::i;:::-;7570:4;7565:3;7561:14;7547:28;;7402:179;;;;:::o;7587:113::-;7657:4;7689;7684:3;7680:14;7672:22;;7587:113;;;:::o;7736:732::-;7855:3;7884:54;7932:5;7884:54;:::i;:::-;7954:86;8033:6;8028:3;7954:86;:::i;:::-;7947:93;;8064:56;8114:5;8064:56;:::i;:::-;8143:7;8174:1;8159:284;8184:6;8181:1;8178:13;8159:284;;;8260:6;8254:13;8287:63;8346:3;8331:13;8287:63;:::i;:::-;8280:70;;8373:60;8426:6;8373:60;:::i;:::-;8363:70;;8219:224;8206:1;8203;8199:9;8194:14;;8159:284;;;8163:14;8459:3;8452:10;;7860:608;;;7736:732;;;;:::o;8474:373::-;8617:4;8655:2;8644:9;8640:18;8632:26;;8704:9;8698:4;8694:20;8690:1;8679:9;8675:17;8668:47;8732:108;8835:4;8826:6;8732:108;:::i;:::-;8724:116;;8474:373;;;;:::o;8853:117::-;8962:1;8959;8952:12;8976:117;9085:1;9082;9075:12;9099:180;9147:77;9144:1;9137:88;9244:4;9241:1;9234:15;9268:4;9265:1;9258:15;9285:281;9368:27;9390:4;9368:27;:::i;:::-;9360:6;9356:40;9498:6;9486:10;9483:22;9462:18;9450:10;9447:34;9444:62;9441:88;;;9509:18;;:::i;:::-;9441:88;9549:10;9545:2;9538:22;9328:238;9285:281;;:::o;9572:129::-;9606:6;9633:20;;:::i;:::-;9623:30;;9662:33;9690:4;9682:6;9662:33;:::i;:::-;9572:129;;;:::o;9707:308::-;9769:4;9859:18;9851:6;9848:30;9845:56;;;9881:18;;:::i;:::-;9845:56;9919:29;9941:6;9919:29;:::i;:::-;9911:37;;10003:4;9997;9993:15;9985:23;;9707:308;;;:::o;10021:154::-;10105:6;10100:3;10095;10082:30;10167:1;10158:6;10153:3;10149:16;10142:27;10021:154;;;:::o;10181:412::-;10259:5;10284:66;10300:49;10342:6;10300:49;:::i;:::-;10284:66;:::i;:::-;10275:75;;10373:6;10366:5;10359:21;10411:4;10404:5;10400:16;10449:3;10440:6;10435:3;10431:16;10428:25;10425:112;;;10456:79;;:::i;:::-;10425:112;10546:41;10580:6;10575:3;10570;10546:41;:::i;:::-;10265:328;10181:412;;;;;:::o;10613:340::-;10669:5;10718:3;10711:4;10703:6;10699:17;10695:27;10685:122;;10726:79;;:::i;:::-;10685:122;10843:6;10830:20;10868:79;10943:3;10935:6;10928:4;10920:6;10916:17;10868:79;:::i;:::-;10859:88;;10675:278;10613:340;;;;:::o;10959:509::-;11028:6;11077:2;11065:9;11056:7;11052:23;11048:32;11045:119;;;11083:79;;:::i;:::-;11045:119;11231:1;11220:9;11216:17;11203:31;11261:18;11253:6;11250:30;11247:117;;;11283:79;;:::i;:::-;11247:117;11388:63;11443:7;11434:6;11423:9;11419:22;11388:63;:::i;:::-;11378:73;;11174:287;10959:509;;;;:::o;11474:60::-;11502:3;11523:5;11516:12;;11474:60;;;:::o;11540:142::-;11590:9;11623:53;11641:34;11650:24;11668:5;11650:24;:::i;:::-;11641:34;:::i;:::-;11623:53;:::i;:::-;11610:66;;11540:142;;;:::o;11688:126::-;11738:9;11771:37;11802:5;11771:37;:::i;:::-;11758:50;;11688:126;;;:::o;11820:139::-;11883:9;11916:37;11947:5;11916:37;:::i;:::-;11903:50;;11820:139;;;:::o;11965:157::-;12065:50;12109:5;12065:50;:::i;:::-;12060:3;12053:63;11965:157;;:::o;12128:248::-;12234:4;12272:2;12261:9;12257:18;12249:26;;12285:84;12366:1;12355:9;12351:17;12342:6;12285:84;:::i;:::-;12128:248;;;;:::o;12382:468::-;12447:6;12455;12504:2;12492:9;12483:7;12479:23;12475:32;12472:119;;;12510:79;;:::i;:::-;12472:119;12630:1;12655:53;12700:7;12691:6;12680:9;12676:22;12655:53;:::i;:::-;12645:63;;12601:117;12757:2;12783:50;12825:7;12816:6;12805:9;12801:22;12783:50;:::i;:::-;12773:60;;12728:115;12382:468;;;;;:::o;12856:307::-;12917:4;13007:18;12999:6;12996:30;12993:56;;;13029:18;;:::i;:::-;12993:56;13067:29;13089:6;13067:29;:::i;:::-;13059:37;;13151:4;13145;13141:15;13133:23;;12856:307;;;:::o;13169:410::-;13246:5;13271:65;13287:48;13328:6;13287:48;:::i;:::-;13271:65;:::i;:::-;13262:74;;13359:6;13352:5;13345:21;13397:4;13390:5;13386:16;13435:3;13426:6;13421:3;13417:16;13414:25;13411:112;;;13442:79;;:::i;:::-;13411:112;13532:41;13566:6;13561:3;13556;13532:41;:::i;:::-;13252:327;13169:410;;;;;:::o;13598:338::-;13653:5;13702:3;13695:4;13687:6;13683:17;13679:27;13669:122;;13710:79;;:::i;:::-;13669:122;13827:6;13814:20;13852:78;13926:3;13918:6;13911:4;13903:6;13899:17;13852:78;:::i;:::-;13843:87;;13659:277;13598:338;;;;:::o;13942:943::-;14037:6;14045;14053;14061;14110:3;14098:9;14089:7;14085:23;14081:33;14078:120;;;14117:79;;:::i;:::-;14078:120;14237:1;14262:53;14307:7;14298:6;14287:9;14283:22;14262:53;:::i;:::-;14252:63;;14208:117;14364:2;14390:53;14435:7;14426:6;14415:9;14411:22;14390:53;:::i;:::-;14380:63;;14335:118;14492:2;14518:53;14563:7;14554:6;14543:9;14539:22;14518:53;:::i;:::-;14508:63;;14463:118;14648:2;14637:9;14633:18;14620:32;14679:18;14671:6;14668:30;14665:117;;;14701:79;;:::i;:::-;14665:117;14806:62;14860:7;14851:6;14840:9;14836:22;14806:62;:::i;:::-;14796:72;;14591:287;13942:943;;;;;;;:::o;14891:474::-;14959:6;14967;15016:2;15004:9;14995:7;14991:23;14987:32;14984:119;;;15022:79;;:::i;:::-;14984:119;15142:1;15167:53;15212:7;15203:6;15192:9;15188:22;15167:53;:::i;:::-;15157:63;;15113:117;15269:2;15295:53;15340:7;15331:6;15320:9;15316:22;15295:53;:::i;:::-;15285:63;;15240:118;14891:474;;;;;:::o;15371:180::-;15419:77;15416:1;15409:88;15516:4;15513:1;15506:15;15540:4;15537:1;15530:15;15557:320;15601:6;15638:1;15632:4;15628:12;15618:22;;15685:1;15679:4;15675:12;15706:18;15696:81;;15762:4;15754:6;15750:17;15740:27;;15696:81;15824:2;15816:6;15813:14;15793:18;15790:38;15787:84;;15843:18;;:::i;:::-;15787:84;15608:269;15557:320;;;:::o;15883:220::-;16023:34;16019:1;16011:6;16007:14;16000:58;16092:3;16087:2;16079:6;16075:15;16068:28;15883:220;:::o;16109:366::-;16251:3;16272:67;16336:2;16331:3;16272:67;:::i;:::-;16265:74;;16348:93;16437:3;16348:93;:::i;:::-;16466:2;16461:3;16457:12;16450:19;;16109:366;;;:::o;16481:419::-;16647:4;16685:2;16674:9;16670:18;16662:26;;16734:9;16728:4;16724:20;16720:1;16709:9;16705:17;16698:47;16762:131;16888:4;16762:131;:::i;:::-;16754:139;;16481:419;;;:::o;16906:248::-;17046:34;17042:1;17034:6;17030:14;17023:58;17115:31;17110:2;17102:6;17098:15;17091:56;16906:248;:::o;17160:366::-;17302:3;17323:67;17387:2;17382:3;17323:67;:::i;:::-;17316:74;;17399:93;17488:3;17399:93;:::i;:::-;17517:2;17512:3;17508:12;17501:19;;17160:366;;;:::o;17532:419::-;17698:4;17736:2;17725:9;17721:18;17713:26;;17785:9;17779:4;17775:20;17771:1;17760:9;17756:17;17749:47;17813:131;17939:4;17813:131;:::i;:::-;17805:139;;17532:419;;;:::o;17957:232::-;18097:34;18093:1;18085:6;18081:14;18074:58;18166:15;18161:2;18153:6;18149:15;18142:40;17957:232;:::o;18195:366::-;18337:3;18358:67;18422:2;18417:3;18358:67;:::i;:::-;18351:74;;18434:93;18523:3;18434:93;:::i;:::-;18552:2;18547:3;18543:12;18536:19;;18195:366;;;:::o;18567:419::-;18733:4;18771:2;18760:9;18756:18;18748:26;;18820:9;18814:4;18810:20;18806:1;18795:9;18791:17;18784:47;18848:131;18974:4;18848:131;:::i;:::-;18840:139;;18567:419;;;:::o;18992:230::-;19132:34;19128:1;19120:6;19116:14;19109:58;19201:13;19196:2;19188:6;19184:15;19177:38;18992:230;:::o;19228:366::-;19370:3;19391:67;19455:2;19450:3;19391:67;:::i;:::-;19384:74;;19467:93;19556:3;19467:93;:::i;:::-;19585:2;19580:3;19576:12;19569:19;;19228:366;;;:::o;19600:419::-;19766:4;19804:2;19793:9;19789:18;19781:26;;19853:9;19847:4;19843:20;19839:1;19828:9;19824:17;19817:47;19881:131;20007:4;19881:131;:::i;:::-;19873:139;;19600:419;;;:::o;20025:180::-;20073:77;20070:1;20063:88;20170:4;20167:1;20160:15;20194:4;20191:1;20184:15;20211:180;20259:77;20256:1;20249:88;20356:4;20353:1;20346:15;20380:4;20377:1;20370:15;20397:233;20436:3;20459:24;20477:5;20459:24;:::i;:::-;20450:33;;20505:66;20498:5;20495:77;20492:103;;20575:18;;:::i;:::-;20492:103;20622:1;20615:5;20611:13;20604:20;;20397:233;;;:::o;20636:231::-;20776:34;20772:1;20764:6;20760:14;20753:58;20845:14;20840:2;20832:6;20828:15;20821:39;20636:231;:::o;20873:366::-;21015:3;21036:67;21100:2;21095:3;21036:67;:::i;:::-;21029:74;;21112:93;21201:3;21112:93;:::i;:::-;21230:2;21225:3;21221:12;21214:19;;20873:366;;;:::o;21245:419::-;21411:4;21449:2;21438:9;21434:18;21426:26;;21498:9;21492:4;21488:20;21484:1;21473:9;21469:17;21462:47;21526:131;21652:4;21526:131;:::i;:::-;21518:139;;21245:419;;;:::o;21670:174::-;21810:26;21806:1;21798:6;21794:14;21787:50;21670:174;:::o;21850:366::-;21992:3;22013:67;22077:2;22072:3;22013:67;:::i;:::-;22006:74;;22089:93;22178:3;22089:93;:::i;:::-;22207:2;22202:3;22198:12;22191:19;;21850:366;;;:::o;22222:419::-;22388:4;22426:2;22415:9;22411:18;22403:26;;22475:9;22469:4;22465:20;22461:1;22450:9;22446:17;22439:47;22503:131;22629:4;22503:131;:::i;:::-;22495:139;;22222:419;;;:::o;22647:228::-;22787:34;22783:1;22775:6;22771:14;22764:58;22856:11;22851:2;22843:6;22839:15;22832:36;22647:228;:::o;22881:366::-;23023:3;23044:67;23108:2;23103:3;23044:67;:::i;:::-;23037:74;;23120:93;23209:3;23120:93;:::i;:::-;23238:2;23233:3;23229:12;23222:19;;22881:366;;;:::o;23253:419::-;23419:4;23457:2;23446:9;23442:18;23434:26;;23506:9;23500:4;23496:20;23492:1;23481:9;23477:17;23470:47;23534:131;23660:4;23534:131;:::i;:::-;23526:139;;23253:419;;;:::o;23678:305::-;23718:3;23737:20;23755:1;23737:20;:::i;:::-;23732:25;;23771:20;23789:1;23771:20;:::i;:::-;23766:25;;23925:1;23857:66;23853:74;23850:1;23847:81;23844:107;;;23931:18;;:::i;:::-;23844:107;23975:1;23972;23968:9;23961:16;;23678:305;;;;:::o;23989:348::-;24029:7;24052:20;24070:1;24052:20;:::i;:::-;24047:25;;24086:20;24104:1;24086:20;:::i;:::-;24081:25;;24274:1;24206:66;24202:74;24199:1;24196:81;24191:1;24184:9;24177:17;24173:105;24170:131;;;24281:18;;:::i;:::-;24170:131;24329:1;24326;24322:9;24311:20;;23989:348;;;;:::o;24343:442::-;24492:4;24530:2;24519:9;24515:18;24507:26;;24543:71;24611:1;24600:9;24596:17;24587:6;24543:71;:::i;:::-;24624:72;24692:2;24681:9;24677:18;24668:6;24624:72;:::i;:::-;24706;24774:2;24763:9;24759:18;24750:6;24706:72;:::i;:::-;24343:442;;;;;;:::o;24791:137::-;24845:5;24876:6;24870:13;24861:22;;24892:30;24916:5;24892:30;:::i;:::-;24791:137;;;;:::o;24934:345::-;25001:6;25050:2;25038:9;25029:7;25025:23;25021:32;25018:119;;;25056:79;;:::i;:::-;25018:119;25176:1;25201:61;25254:7;25245:6;25234:9;25230:22;25201:61;:::i;:::-;25191:71;;25147:125;24934:345;;;;:::o;25285:234::-;25425:34;25421:1;25413:6;25409:14;25402:58;25494:17;25489:2;25481:6;25477:15;25470:42;25285:234;:::o;25525:366::-;25667:3;25688:67;25752:2;25747:3;25688:67;:::i;:::-;25681:74;;25764:93;25853:3;25764:93;:::i;:::-;25882:2;25877:3;25873:12;25866:19;;25525:366;;;:::o;25897:419::-;26063:4;26101:2;26090:9;26086:18;26078:26;;26150:9;26144:4;26140:20;26136:1;26125:9;26121:17;26114:47;26178:131;26304:4;26178:131;:::i;:::-;26170:139;;25897:419;;;:::o;26322:148::-;26424:11;26461:3;26446:18;;26322:148;;;;:::o;26476:377::-;26582:3;26610:39;26643:5;26610:39;:::i;:::-;26665:89;26747:6;26742:3;26665:89;:::i;:::-;26658:96;;26763:52;26808:6;26803:3;26796:4;26789:5;26785:16;26763:52;:::i;:::-;26840:6;26835:3;26831:16;26824:23;;26586:267;26476:377;;;;:::o;26859:141::-;26908:4;26931:3;26923:11;;26954:3;26951:1;26944:14;26988:4;26985:1;26975:18;26967:26;;26859:141;;;:::o;27030:845::-;27133:3;27170:5;27164:12;27199:36;27225:9;27199:36;:::i;:::-;27251:89;27333:6;27328:3;27251:89;:::i;:::-;27244:96;;27371:1;27360:9;27356:17;27387:1;27382:137;;;;27533:1;27528:341;;;;27349:520;;27382:137;27466:4;27462:9;27451;27447:25;27442:3;27435:38;27502:6;27497:3;27493:16;27486:23;;27382:137;;27528:341;27595:38;27627:5;27595:38;:::i;:::-;27655:1;27669:154;27683:6;27680:1;27677:13;27669:154;;;27757:7;27751:14;27747:1;27742:3;27738:11;27731:35;27807:1;27798:7;27794:15;27783:26;;27705:4;27702:1;27698:12;27693:17;;27669:154;;;27852:6;27847:3;27843:16;27836:23;;27535:334;;27349:520;;27137:738;;27030:845;;;;:::o;27881:589::-;28106:3;28128:95;28219:3;28210:6;28128:95;:::i;:::-;28121:102;;28240:95;28331:3;28322:6;28240:95;:::i;:::-;28233:102;;28352:92;28440:3;28431:6;28352:92;:::i;:::-;28345:99;;28461:3;28454:10;;27881:589;;;;;;:::o;28476:225::-;28616:34;28612:1;28604:6;28600:14;28593:58;28685:8;28680:2;28672:6;28668:15;28661:33;28476:225;:::o;28707:366::-;28849:3;28870:67;28934:2;28929:3;28870:67;:::i;:::-;28863:74;;28946:93;29035:3;28946:93;:::i;:::-;29064:2;29059:3;29055:12;29048:19;;28707:366;;;:::o;29079:419::-;29245:4;29283:2;29272:9;29268:18;29260:26;;29332:9;29326:4;29322:20;29318:1;29307:9;29303:17;29296:47;29360:131;29486:4;29360:131;:::i;:::-;29352:139;;29079:419;;;:::o;29504:332::-;29625:4;29663:2;29652:9;29648:18;29640:26;;29676:71;29744:1;29733:9;29729:17;29720:6;29676:71;:::i;:::-;29757:72;29825:2;29814:9;29810:18;29801:6;29757:72;:::i;:::-;29504:332;;;;;:::o;29842:182::-;29982:34;29978:1;29970:6;29966:14;29959:58;29842:182;:::o;30030:366::-;30172:3;30193:67;30257:2;30252:3;30193:67;:::i;:::-;30186:74;;30269:93;30358:3;30269:93;:::i;:::-;30387:2;30382:3;30378:12;30371:19;;30030:366;;;:::o;30402:419::-;30568:4;30606:2;30595:9;30591:18;30583:26;;30655:9;30649:4;30645:20;30641:1;30630:9;30626:17;30619:47;30683:131;30809:4;30683:131;:::i;:::-;30675:139;;30402:419;;;:::o;30827:224::-;30967:34;30963:1;30955:6;30951:14;30944:58;31036:7;31031:2;31023:6;31019:15;31012:32;30827:224;:::o;31057:366::-;31199:3;31220:67;31284:2;31279:3;31220:67;:::i;:::-;31213:74;;31296:93;31385:3;31296:93;:::i;:::-;31414:2;31409:3;31405:12;31398:19;;31057:366;;;:::o;31429:419::-;31595:4;31633:2;31622:9;31618:18;31610:26;;31682:9;31676:4;31672:20;31668:1;31657:9;31653:17;31646:47;31710:131;31836:4;31710:131;:::i;:::-;31702:139;;31429:419;;;:::o;31854:223::-;31994:34;31990:1;31982:6;31978:14;31971:58;32063:6;32058:2;32050:6;32046:15;32039:31;31854:223;:::o;32083:366::-;32225:3;32246:67;32310:2;32305:3;32246:67;:::i;:::-;32239:74;;32322:93;32411:3;32322:93;:::i;:::-;32440:2;32435:3;32431:12;32424:19;;32083:366;;;:::o;32455:419::-;32621:4;32659:2;32648:9;32644:18;32636:26;;32708:9;32702:4;32698:20;32694:1;32683:9;32679:17;32672:47;32736:131;32862:4;32736:131;:::i;:::-;32728:139;;32455:419;;;:::o;32880:175::-;33020:27;33016:1;33008:6;33004:14;32997:51;32880:175;:::o;33061:366::-;33203:3;33224:67;33288:2;33283:3;33224:67;:::i;:::-;33217:74;;33300:93;33389:3;33300:93;:::i;:::-;33418:2;33413:3;33409:12;33402:19;;33061:366;;;:::o;33433:419::-;33599:4;33637:2;33626:9;33622:18;33614:26;;33686:9;33680:4;33676:20;33672:1;33661:9;33657:17;33650:47;33714:131;33840:4;33714:131;:::i;:::-;33706:139;;33433:419;;;:::o;33858:237::-;33998:34;33994:1;33986:6;33982:14;33975:58;34067:20;34062:2;34054:6;34050:15;34043:45;33858:237;:::o;34101:366::-;34243:3;34264:67;34328:2;34323:3;34264:67;:::i;:::-;34257:74;;34340:93;34429:3;34340:93;:::i;:::-;34458:2;34453:3;34449:12;34442:19;;34101:366;;;:::o;34473:419::-;34639:4;34677:2;34666:9;34662:18;34654:26;;34726:9;34720:4;34716:20;34712:1;34701:9;34697:17;34690:47;34754:131;34880:4;34754:131;:::i;:::-;34746:139;;34473:419;;;:::o;34898:180::-;34946:77;34943:1;34936:88;35043:4;35040:1;35033:15;35067:4;35064:1;35057:15;35084:98;35135:6;35169:5;35163:12;35153:22;;35084:98;;;:::o;35188:168::-;35271:11;35305:6;35300:3;35293:19;35345:4;35340:3;35336:14;35321:29;;35188:168;;;;:::o;35362:360::-;35448:3;35476:38;35508:5;35476:38;:::i;:::-;35530:70;35593:6;35588:3;35530:70;:::i;:::-;35523:77;;35609:52;35654:6;35649:3;35642:4;35635:5;35631:16;35609:52;:::i;:::-;35686:29;35708:6;35686:29;:::i;:::-;35681:3;35677:39;35670:46;;35452:270;35362:360;;;;:::o;35728:640::-;35923:4;35961:3;35950:9;35946:19;35938:27;;35975:71;36043:1;36032:9;36028:17;36019:6;35975:71;:::i;:::-;36056:72;36124:2;36113:9;36109:18;36100:6;36056:72;:::i;:::-;36138;36206:2;36195:9;36191:18;36182:6;36138:72;:::i;:::-;36257:9;36251:4;36247:20;36242:2;36231:9;36227:18;36220:48;36285:76;36356:4;36347:6;36285:76;:::i;:::-;36277:84;;35728:640;;;;;;;:::o;36374:141::-;36430:5;36461:6;36455:13;36446:22;;36477:32;36503:5;36477:32;:::i;:::-;36374:141;;;;:::o;36521:349::-;36590:6;36639:2;36627:9;36618:7;36614:23;36610:32;36607:119;;;36645:79;;:::i;:::-;36607:119;36765:1;36790:63;36845:7;36836:6;36825:9;36821:22;36790:63;:::i;:::-;36780:73;;36736:127;36521:349;;;;:::o;36876:240::-;37016:34;37012:1;37004:6;37000:14;36993:58;37085:23;37080:2;37072:6;37068:15;37061:48;36876:240;:::o;37122:366::-;37264:3;37285:67;37349:2;37344:3;37285:67;:::i;:::-;37278:74;;37361:93;37450:3;37361:93;:::i;:::-;37479:2;37474:3;37470:12;37463:19;;37122:366;;;:::o;37494:419::-;37660:4;37698:2;37687:9;37683:18;37675:26;;37747:9;37741:4;37737:20;37733:1;37722:9;37718:17;37711:47;37775:131;37901:4;37775:131;:::i;:::-;37767:139;;37494:419;;;:::o;37919:182::-;38059:34;38055:1;38047:6;38043:14;38036:58;37919:182;:::o;38107:366::-;38249:3;38270:67;38334:2;38329:3;38270:67;:::i;:::-;38263:74;;38346:93;38435:3;38346:93;:::i;:::-;38464:2;38459:3;38455:12;38448:19;;38107:366;;;:::o;38479:419::-;38645:4;38683:2;38672:9;38668:18;38660:26;;38732:9;38726:4;38722:20;38718:1;38707:9;38703:17;38696:47;38760:131;38886:4;38760:131;:::i;:::-;38752:139;;38479:419;;;:::o;38904:178::-;39044:30;39040:1;39032:6;39028:14;39021:54;38904:178;:::o;39088:366::-;39230:3;39251:67;39315:2;39310:3;39251:67;:::i;:::-;39244:74;;39327:93;39416:3;39327:93;:::i;:::-;39445:2;39440:3;39436:12;39429:19;;39088:366;;;:::o;39460:419::-;39626:4;39664:2;39653:9;39649:18;39641:26;;39713:9;39707:4;39703:20;39699:1;39688:9;39684:17;39677:47;39741:131;39867:4;39741:131;:::i;:::-;39733:139;;39460:419;;;:::o;39885:191::-;39925:4;39945:20;39963:1;39945:20;:::i;:::-;39940:25;;39979:20;39997:1;39979:20;:::i;:::-;39974:25;;40018:1;40015;40012:8;40009:34;;;40023:18;;:::i;:::-;40009:34;40068:1;40065;40061:9;40053:17;;39885:191;;;;:::o;40082:180::-;40130:77;40127:1;40120:88;40227:4;40224:1;40217:15;40251:4;40248:1;40241:15
Swarm Source
ipfs://a126481151c866e11f73557ab72b0b91cc3ae7eaad32c0f0612500330b90a0bb