ERC-721
Overview
Max Total Supply
301 TINYBEAR
Holders
126
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
0 TINYBEARLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
TinyBear
Compiler Version
v0.8.18+commit.87f61d96
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-08-09 */ // File: @openzeppelin/contracts/utils/math/SafeMath.sol // OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol) pragma solidity ^0.8.0; // CAUTION//////// // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. //// * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. // */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File: @openzeppelin/contracts/utils/Counters.sol // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) pragma solidity ^0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } } // File: @openzeppelin/contracts/security/ReentrancyGuard.sol // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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 `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, uint256 amount ) external returns (bool); /** * @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); } // File: @openzeppelin/contracts/interfaces/IERC20.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol) pragma solidity ^0.8.0; // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts v4.4.1 (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @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] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } } // 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 v4.4.1 (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 Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { 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 v4.4.1 (utils/Address.sol) pragma solidity ^0.8.0; /** * @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 * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; assembly { size := extcodesize(account) } return size > 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 functionCall(target, data, "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"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(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) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(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) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason 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 { // 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 assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts v4.4.1 (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 `IERC721.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/interfaces/IERC165.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC165.sol) pragma solidity ^0.8.0; // File: @openzeppelin/contracts/interfaces/IERC2981.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC2981.sol) pragma solidity ^0.8.0; /** * @dev Interface for the NFT Royalty Standard */ interface IERC2981 is IERC165 { /** * @dev Called with the sale price to determine how much royalty is owed and to whom. * @param tokenId - the NFT asset queried for royalty information * @param salePrice - the sale price of the NFT asset specified by `tokenId` * @return receiver - address of who should be sent the royalty payment * @return royaltyAmount - the royalty payment amount for `salePrice` */ function royaltyInfo(uint256 tokenId, uint256 salePrice) external view returns (address receiver, uint256 royaltyAmount); } // 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 v4.4.1 (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`, 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 be 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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * 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 Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @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 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); /** * @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; } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol // OpenZeppelin Contracts v4.4.1 (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 tokenId); /** * @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: contracts/ERC721A.sol pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata and Enumerable extension. Built to optimize for lower gas during batch mints. * * Assumes serials are sequentially minted starting at 0 (e.g. 0, 1, 2, 3..). * * Assumes the number of issuable tokens (collection size) is capped and fits in a uint128. * * Does not support burning tokens to address(0). */ contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable { using Address for address; using Strings for uint256; struct TokenOwnership { address addr; uint64 startTimestamp; } struct AddressData { uint128 balance; uint128 numberMinted; } uint256 private currentIndex = 0; uint256 internal immutable collectionSize; uint256 internal immutable maxBatchSize; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to ownership details // An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details. mapping(uint256 => TokenOwnership) private _ownerships; // Mapping owner address to address data mapping(address => AddressData) private _addressData; // 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 * `maxBatchSize` refers to how much a minter can mint at a time. * `collectionSize_` refers to how many tokens are in the collection. */ constructor( string memory name_, string memory symbol_, uint256 maxBatchSize_, uint256 collectionSize_ ) { require( collectionSize_ > 0, "ERC721A: collection must have a nonzero supply" ); require(maxBatchSize_ > 0, "ERC721A: max batch size must be nonzero"); _name = name_; _symbol = symbol_; maxBatchSize = maxBatchSize_; collectionSize = collectionSize_; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view override returns (uint256) { return currentIndex; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view override returns (uint256) { require(index < totalSupply(), "ERC721A: global index out of bounds"); return index; } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. * This read function is O(collectionSize). If calling from a separate contract, be sure to test gas first. * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) { require(index < balanceOf(owner), "ERC721A: owner index out of bounds"); uint256 numMintedSoFar = totalSupply(); uint256 tokenIdsIdx = 0; address currOwnershipAddr = address(0); for (uint256 i = 0; i < numMintedSoFar; i++) { TokenOwnership memory ownership = _ownerships[i]; if (ownership.addr != address(0)) { currOwnershipAddr = ownership.addr; } if (currOwnershipAddr == owner) { if (tokenIdsIdx == index) { return i; } tokenIdsIdx++; } } revert("ERC721A: unable to get token of owner by index"); } /** * @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 || interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view override returns (uint256) { require(owner != address(0), "ERC721A: balance query for the zero address"); return uint256(_addressData[owner].balance); } function _numberMinted(address owner) internal view returns (uint256) { require( owner != address(0), "ERC721A: number minted query for the zero address" ); return uint256(_addressData[owner].numberMinted); } function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) { require(_exists(tokenId), "ERC721A: owner query for nonexistent token"); uint256 lowestTokenToCheck; if (tokenId >= maxBatchSize) { lowestTokenToCheck = tokenId - maxBatchSize + 1; } for (uint256 curr = tokenId; curr >= lowestTokenToCheck; curr--) { TokenOwnership memory ownership = _ownerships[curr]; if (ownership.addr != address(0)) { return ownership; } } revert("ERC721A: unable to determine the owner of token"); } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view override returns (address) { return ownershipOf(tokenId).addr; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require( _exists(tokenId), "ERC721Metadata: URI query for nonexistent token" ); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overriden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public override { address owner = ERC721A.ownerOf(tokenId); require(to != owner, "ERC721A: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721A: approve caller is not owner nor approved for all" ); _approve(to, tokenId, owner); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view override returns (address) { require(_exists(tokenId), "ERC721A: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public override { require(operator != _msgSender(), "ERC721A: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public override { _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public override { _transfer(from, to, tokenId); require( _checkOnERC721Received(from, to, tokenId, _data), "ERC721A: transfer to non ERC721Receiver implementer" ); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), */ function _exists(uint256 tokenId) internal view returns (bool) { return tokenId < currentIndex; } function _safeMint(address to, uint256 quantity) internal { _safeMint(to, quantity, ""); } /** * @dev Mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - there must be `quantity` tokens remaining unminted in the total collection. * - `to` cannot be the zero address. * - `quantity` cannot be larger than the max batch size. * * Emits a {Transfer} event. */ function _safeMint( address to, uint256 quantity, bytes memory _data ) internal { uint256 startTokenId = currentIndex; require(to != address(0), "ERC721A: mint to the zero address"); // We know if the first token in the batch doesn't exist, the other ones don't as well, because of serial ordering. require(!_exists(startTokenId), "ERC721A: token already minted"); require(quantity <= maxBatchSize, "ERC721A: quantity to mint too high"); _beforeTokenTransfers(address(0), to, startTokenId, quantity); AddressData memory addressData = _addressData[to]; _addressData[to] = AddressData( addressData.balance + uint128(quantity), addressData.numberMinted + uint128(quantity) ); _ownerships[startTokenId] = TokenOwnership(to, uint64(block.timestamp)); uint256 updatedIndex = startTokenId; for (uint256 i = 0; i < quantity; i++) { emit Transfer(address(0), to, updatedIndex); require( _checkOnERC721Received(address(0), to, updatedIndex, _data), "ERC721A: transfer to non ERC721Receiver implementer" ); updatedIndex++; } currentIndex = updatedIndex; _afterTokenTransfers(address(0), to, startTokenId, quantity); } /** * @dev Transfers `tokenId` from `from` to `to`. * * 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 ) private { TokenOwnership memory prevOwnership = ownershipOf(tokenId); bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr || getApproved(tokenId) == _msgSender() || isApprovedForAll(prevOwnership.addr, _msgSender())); require( isApprovedOrOwner, "ERC721A: transfer caller is not owner nor approved" ); require( prevOwnership.addr == from, "ERC721A: transfer from incorrect owner" ); require(to != address(0), "ERC721A: transfer to the zero address"); _beforeTokenTransfers(from, to, tokenId, 1); // Clear approvals from the previous owner _approve(address(0), tokenId, prevOwnership.addr); _addressData[from].balance -= 1; _addressData[to].balance += 1; _ownerships[tokenId] = TokenOwnership(to, uint64(block.timestamp)); // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it. // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls. uint256 nextTokenId = tokenId + 1; if (_ownerships[nextTokenId].addr == address(0)) { if (_exists(nextTokenId)) { _ownerships[nextTokenId] = TokenOwnership( prevOwnership.addr, prevOwnership.startTimestamp ); } } emit Transfer(from, to, tokenId); _afterTokenTransfers(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve( address to, uint256 tokenId, address owner ) private { _tokenApprovals[tokenId] = to; emit Approval(owner, to, tokenId); } uint256 public nextOwnerToExplicitlySet = 0; /** * @dev Explicitly set `owners` to eliminate loops in future calls of ownerOf(). */ function _setOwnersExplicit(uint256 quantity) internal { uint256 oldNextOwnerToSet = nextOwnerToExplicitlySet; require(quantity > 0, "quantity must be nonzero"); uint256 endIndex = oldNextOwnerToSet + quantity - 1; if (endIndex > collectionSize - 1) { endIndex = collectionSize - 1; } // We know if the last one in the group exists, all in the group exist, due to serial ordering. require(_exists(endIndex), "not enough minted yet for this cleanup"); for (uint256 i = oldNextOwnerToSet; i <= endIndex; i++) { if (_ownerships[i].addr == address(0)) { TokenOwnership memory ownership = ownershipOf(i); _ownerships[i] = TokenOwnership( ownership.addr, ownership.startTimestamp ); } } nextOwnerToExplicitlySet = endIndex + 1; } /** * @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(to).onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721A: transfer to non ERC721Receiver implementer"); } else { assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. */ function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} /** * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes * minting. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - when `from` and `to` are both non-zero. * - `from` and `to` are never both zero. */ function _afterTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} } //SPDX-License-Identifier: MIT //Contract based on [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721) pragma solidity ^0.8.0; contract TinyBear is ERC721A, IERC2981, Ownable, ReentrancyGuard { using Counters for Counters.Counter; using Strings for uint256; Counters.Counter private tokenCounter; string private baseURI = "ipfs://QmZjHsoHHdcSsKboAbvz3ooexYkSC6kq8hFQwCHwFRHdFS"; address private openSeaProxyRegistryAddress = 0xa5409ec958C83C3f309868babACA7c86DCB077c1; bool private isOpenSeaProxyActive = true; uint256 public constant MAX_MINTS_PER_TX = 2; uint256 public maxSupply = 1000; uint256 public constant PUBLIC_SALE_PRICE = 0.005 ether; uint256 public NUM_FREE_MINTS = 300; bool public isPublicSaleActive = true; // ============ ACCESS CONTROL/SANITY MODIFIERS ============ modifier publicSaleActive() { require(isPublicSaleActive, "Public sale is not open"); _; } modifier maxMintsPerTX(uint256 numberOfTokens) { require( numberOfTokens <= MAX_MINTS_PER_TX, "Max mints per transaction exceeded" ); _; } modifier canMintNFTs(uint256 numberOfTokens) { require( totalSupply() + numberOfTokens <= maxSupply, "Not enough mints remaining to mint" ); _; } modifier freeMintsAvailable() { require( totalSupply() <= NUM_FREE_MINTS, "Not enough free mints remain" ); _; } modifier isCorrectPayment(uint256 price, uint256 numberOfTokens) { if(totalSupply()>NUM_FREE_MINTS){ require( (price * numberOfTokens) == msg.value, "Incorrect ETH value sent" ); } _; } constructor( ) ERC721A("Tiny Based Bears", "TINYBEAR", 100, maxSupply) { } // ============ PUBLIC FUNCTIONS FOR MINTING ============ function mint(uint256 numberOfTokens) external payable nonReentrant isCorrectPayment(PUBLIC_SALE_PRICE, numberOfTokens) publicSaleActive canMintNFTs(numberOfTokens) maxMintsPerTX(numberOfTokens) { _safeMint(msg.sender, numberOfTokens); } //A simple free mint function to avoid confusion //The normal mint function with a cost of 0 would work too // ============ PUBLIC READ-ONLY FUNCTIONS ============ function getBaseURI() external view returns (string memory) { return baseURI; } // ============ OWNER-ONLY ADMIN FUNCTIONS ============ function setBaseURI(string memory _baseURI) external onlyOwner { baseURI = _baseURI; } // function to disable gasless listings for security in case // opensea ever shuts down or is compromised function setIsOpenSeaProxyActive(bool _isOpenSeaProxyActive) external onlyOwner { isOpenSeaProxyActive = _isOpenSeaProxyActive; } function setIsPublicSaleActive(bool _isPublicSaleActive) external onlyOwner { isPublicSaleActive = _isPublicSaleActive; } function setnumfree(uint256 _numfreemints) external onlyOwner { NUM_FREE_MINTS = _numfreemints; } function withdraw() public onlyOwner { uint256 balance = address(this).balance; payable(msg.sender).transfer(balance); } function withdrawTokens(IERC20 token) public onlyOwner { uint256 balance = token.balanceOf(address(this)); token.transfer(msg.sender, balance); } // ============ SUPPORTING FUNCTIONS ============ function nextTokenId() private returns (uint256) { tokenCounter.increment(); return tokenCounter.current(); } // ============ FUNCTION OVERRIDES ============ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, IERC165) returns (bool) { return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Override isApprovedForAll to allowlist user's OpenSea proxy accounts to enable gas-less listings. */ function isApprovedForAll(address owner, address operator) public view override returns (bool) { // Get a reference to OpenSea's proxy registry contract by instantiating // the contract using the already existing address. ProxyRegistry proxyRegistry = ProxyRegistry( openSeaProxyRegistryAddress ); if ( isOpenSeaProxyActive && address(proxyRegistry.proxies(owner)) == operator ) { return true; } return super.isApprovedForAll(owner, operator); } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "Nonexistent token"); return string(abi.encodePacked(baseURI, "/", (tokenId+1).toString(), ".json")); } /** * @dev See {IERC165-royaltyInfo}. */ function royaltyInfo(uint256 tokenId, uint256 salePrice) external view override returns (address receiver, uint256 royaltyAmount) { require(_exists(tokenId), "Nonexistent token"); return (address(this), SafeMath.div(SafeMath.mul(salePrice, 5), 100)); } } // These contract definitions are used to create a reference to the OpenSea // ProxyRegistry contract by using the registry's address (see isApprovedForAll). contract OwnableDelegateProxy { } contract ProxyRegistry { mapping(address => OwnableDelegateProxy) public proxies; }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"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":[],"name":"MAX_MINTS_PER_TX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NUM_FREE_MINTS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PUBLIC_SALE_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getBaseURI","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":"isPublicSaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextOwnerToExplicitlySet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isOpenSeaProxyActive","type":"bool"}],"name":"setIsOpenSeaProxyActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isPublicSaleActive","type":"bool"}],"name":"setIsPublicSaleActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numfreemints","type":"uint256"}],"name":"setnumfree","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":[{"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":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
6000808055600755610120604052603560c08181529062002a1d60e039600b906200002b9082620002cf565b50600c80546001600160a81b0319167401a5409ec958c83c3f309868babaca7c86dcb077c11790556103e8600d5561012c600e55600f805460ff191660011790553480156200007957600080fd5b506040518060400160405280601081526020016f54696e7920426173656420426561727360801b815250604051806040016040528060088152602001672a24a72ca122a0a960c11b8152506064600d5460008111620001365760405162461bcd60e51b815260206004820152602e60248201527f455243373231413a20636f6c6c656374696f6e206d757374206861766520612060448201526d6e6f6e7a65726f20737570706c7960901b60648201526084015b60405180910390fd5b60008211620001985760405162461bcd60e51b815260206004820152602760248201527f455243373231413a206d61782062617463682073697a65206d757374206265206044820152666e6f6e7a65726f60c81b60648201526084016200012d565b6001620001a68582620002cf565b506002620001b58482620002cf565b5060a09190915260805250620001cd905033620001d8565b60016009556200039b565b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b634e487b7160e01b600052604160045260246000fd5b600181811c908216806200025557607f821691505b6020821081036200027657634e487b7160e01b600052602260045260246000fd5b50919050565b601f821115620002ca57600081815260208120601f850160051c81016020861015620002a55750805b601f850160051c820191505b81811015620002c657828155600101620002b1565b5050505b505050565b81516001600160401b03811115620002eb57620002eb6200022a565b6200030381620002fc845462000240565b846200027c565b602080601f8311600181146200033b5760008415620003225750858301515b600019600386901b1c1916600185901b178555620002c6565b600085815260208120601f198616915b828110156200036c578886015182559484019460019091019084016200034b565b50858210156200038b5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b60805160a051612651620003cc6000396000818161181a015281816118440152611c6d0152600050506126516000f3fe6080604052600436106101f95760003560e01c806370a082311161010d578063b88d4fde116100a0578063d7224ba01161006f578063d7224ba01461058c578063e43082f7146105a2578063e985e9c5146105c2578063f0ea88ef146105e2578063f2fde38b1461060257600080fd5b8063b88d4fde14610521578063c6a91b4214610541578063c87b56dd14610556578063d5abeb011461057657600080fd5b806395d89b41116100dc57806395d89b41146104c3578063982d669e146104d8578063a0712d68146104ee578063a22cb4651461050157600080fd5b806370a082311461045b578063714c53981461047b578063715018a6146104905780638da5cb5b146104a557600080fd5b806328cad13d1161019057806342842e0e1161015f57806342842e0e146103bb57806349df728c146103db5780634f6ccce7146103fb57806355f804b31461041b5780636352211e1461043b57600080fd5b806328cad13d146103275780632a55205a146103475780632f745c59146103865780633ccfd60b146103a657600080fd5b8063095ea7b3116101cc578063095ea7b3146102b657806318160ddd146102d85780631e84c413146102ed57806323b872dd1461030757600080fd5b806301ffc9a7146101fe57806306fdde031461023357806307e89ec014610255578063081812fc1461027e575b600080fd5b34801561020a57600080fd5b5061021e610219366004611ea1565b610622565b60405190151581526020015b60405180910390f35b34801561023f57600080fd5b5061024861064d565b60405161022a9190611f0e565b34801561026157600080fd5b506102706611c37937e0800081565b60405190815260200161022a565b34801561028a57600080fd5b5061029e610299366004611f21565b6106df565b6040516001600160a01b03909116815260200161022a565b3480156102c257600080fd5b506102d66102d1366004611f4f565b61076f565b005b3480156102e457600080fd5b50600054610270565b3480156102f957600080fd5b50600f5461021e9060ff1681565b34801561031357600080fd5b506102d6610322366004611f7b565b610886565b34801561033357600080fd5b506102d6610342366004611fca565b610891565b34801561035357600080fd5b50610367610362366004611fe7565b6108ce565b604080516001600160a01b03909316835260208301919091520161022a565b34801561039257600080fd5b506102706103a1366004611f4f565b61093d565b3480156103b257600080fd5b506102d6610aa9565b3480156103c757600080fd5b506102d66103d6366004611f7b565b610b06565b3480156103e757600080fd5b506102d66103f6366004612009565b610b21565b34801561040757600080fd5b50610270610416366004611f21565b610c2a565b34801561042757600080fd5b506102d66104363660046120b2565b610c8c565b34801561044757600080fd5b5061029e610456366004611f21565b610cc2565b34801561046757600080fd5b50610270610476366004612009565b610cd4565b34801561048757600080fd5b50610248610d65565b34801561049c57600080fd5b506102d6610d74565b3480156104b157600080fd5b506008546001600160a01b031661029e565b3480156104cf57600080fd5b50610248610daa565b3480156104e457600080fd5b50610270600e5481565b6102d66104fc366004611f21565b610db9565b34801561050d57600080fd5b506102d661051c3660046120fb565b610fb5565b34801561052d57600080fd5b506102d661053c366004612134565b611079565b34801561054d57600080fd5b50610270600281565b34801561056257600080fd5b50610248610571366004611f21565b6110b2565b34801561058257600080fd5b50610270600d5481565b34801561059857600080fd5b5061027060075481565b3480156105ae57600080fd5b506102d66105bd366004611fca565b61113b565b3480156105ce57600080fd5b5061021e6105dd3660046121b4565b611183565b3480156105ee57600080fd5b506102d66105fd366004611f21565b611260565b34801561060e57600080fd5b506102d661061d366004612009565b61128f565b60006001600160e01b0319821663152a902d60e11b148061064757506106478261132a565b92915050565b60606001805461065c906121e2565b80601f0160208091040260200160405190810160405280929190818152602001828054610688906121e2565b80156106d55780601f106106aa576101008083540402835291602001916106d5565b820191906000526020600020905b8154815290600101906020018083116106b857829003601f168201915b5050505050905090565b60006106ec826000541190565b6107535760405162461bcd60e51b815260206004820152602d60248201527f455243373231413a20617070726f76656420717565727920666f72206e6f6e6560448201526c3c34b9ba32b73a103a37b5b2b760991b60648201526084015b60405180910390fd5b506000908152600560205260409020546001600160a01b031690565b600061077a82610cc2565b9050806001600160a01b0316836001600160a01b0316036107e85760405162461bcd60e51b815260206004820152602260248201527f455243373231413a20617070726f76616c20746f2063757272656e74206f776e60448201526132b960f11b606482015260840161074a565b336001600160a01b038216148061080457506108048133611183565b6108765760405162461bcd60e51b815260206004820152603960248201527f455243373231413a20617070726f76652063616c6c6572206973206e6f74206f60448201527f776e6572206e6f7220617070726f76656420666f7220616c6c00000000000000606482015260840161074a565b610881838383611395565b505050565b6108818383836113f1565b6008546001600160a01b031633146108bb5760405162461bcd60e51b815260040161074a9061221c565b600f805460ff1916911515919091179055565b6000806108dc846000541190565b61091c5760405162461bcd60e51b81526020600482015260116024820152702737b732bc34b9ba32b73a103a37b5b2b760791b604482015260640161074a565b3061093261092b856005611779565b606461178c565b915091509250929050565b600061094883610cd4565b82106109a15760405162461bcd60e51b815260206004820152602260248201527f455243373231413a206f776e657220696e646578206f7574206f6620626f756e604482015261647360f01b606482015260840161074a565b600080549080805b83811015610a49576000818152600360209081526040918290208251808401909352546001600160a01b038116808452600160a01b90910467ffffffffffffffff1691830191909152156109fc57805192505b876001600160a01b0316836001600160a01b031603610a3657868403610a285750935061064792505050565b83610a3281612267565b9450505b5080610a4181612267565b9150506109a9565b5060405162461bcd60e51b815260206004820152602e60248201527f455243373231413a20756e61626c6520746f2067657420746f6b656e206f662060448201526d0deeedccae440c4f240d2dcc8caf60931b606482015260840161074a565b6008546001600160a01b03163314610ad35760405162461bcd60e51b815260040161074a9061221c565b6040514790339082156108fc029083906000818181858888f19350505050158015610b02573d6000803e3d6000fd5b5050565b61088183838360405180602001604052806000815250611079565b6008546001600160a01b03163314610b4b5760405162461bcd60e51b815260040161074a9061221c565b6040516370a0823160e01b81523060048201526000906001600160a01b038316906370a0823190602401602060405180830381865afa158015610b92573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bb69190612280565b60405163a9059cbb60e01b8152336004820152602481018290529091506001600160a01b0383169063a9059cbb906044016020604051808303816000875af1158015610c06573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108819190612299565b600080548210610c885760405162461bcd60e51b815260206004820152602360248201527f455243373231413a20676c6f62616c20696e646578206f7574206f6620626f756044820152626e647360e81b606482015260840161074a565b5090565b6008546001600160a01b03163314610cb65760405162461bcd60e51b815260040161074a9061221c565b600b610b0282826122fc565b6000610ccd82611798565b5192915050565b60006001600160a01b038216610d405760405162461bcd60e51b815260206004820152602b60248201527f455243373231413a2062616c616e636520717565727920666f7220746865207a60448201526a65726f206164647265737360a81b606482015260840161074a565b506001600160a01b03166000908152600460205260409020546001600160801b031690565b6060600b805461065c906121e2565b6008546001600160a01b03163314610d9e5760405162461bcd60e51b815260040161074a9061221c565b610da86000611942565b565b60606002805461065c906121e2565b600260095403610e0b5760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015260640161074a565b6002600955600e546000546611c37937e080009183911115610e7f5734610e3282846123bc565b14610e7f5760405162461bcd60e51b815260206004820152601860248201527f496e636f7272656374204554482076616c75652073656e740000000000000000604482015260640161074a565b600f5460ff16610ed15760405162461bcd60e51b815260206004820152601760248201527f5075626c69632073616c65206973206e6f74206f70656e000000000000000000604482015260640161074a565b82600d5481610edf60005490565b610ee991906123d3565b1115610f425760405162461bcd60e51b815260206004820152602260248201527f4e6f7420656e6f756768206d696e74732072656d61696e696e6720746f206d696044820152611b9d60f21b606482015260840161074a565b836002811115610f9f5760405162461bcd60e51b815260206004820152602260248201527f4d6178206d696e747320706572207472616e73616374696f6e20657863656564604482015261195960f21b606482015260840161074a565b610fa93386611994565b50506001600955505050565b336001600160a01b0383160361100d5760405162461bcd60e51b815260206004820152601a60248201527f455243373231413a20617070726f766520746f2063616c6c6572000000000000604482015260640161074a565b3360008181526006602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b6110848484846113f1565b611090848484846119ae565b6110ac5760405162461bcd60e51b815260040161074a906123e6565b50505050565b60606110bf826000541190565b6110ff5760405162461bcd60e51b81526020600482015260116024820152702737b732bc34b9ba32b73a103a37b5b2b760791b604482015260640161074a565b600b61111461110f8460016123d3565b611aaf565b604051602001611125929190612439565b6040516020818303038152906040529050919050565b6008546001600160a01b031633146111655760405162461bcd60e51b815260040161074a9061221c565b600c8054911515600160a01b0260ff60a01b19909216919091179055565b600c546000906001600160a01b03811690600160a01b900460ff16801561121f575060405163c455279160e01b81526001600160a01b038581166004830152808516919083169063c455279190602401602060405180830381865afa1580156111f0573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061121491906124df565b6001600160a01b0316145b1561122e576001915050610647565b6001600160a01b0380851660009081526006602090815260408083209387168352929052205460ff165b949350505050565b6008546001600160a01b0316331461128a5760405162461bcd60e51b815260040161074a9061221c565b600e55565b6008546001600160a01b031633146112b95760405162461bcd60e51b815260040161074a9061221c565b6001600160a01b03811661131e5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161074a565b61132781611942565b50565b60006001600160e01b031982166380ac58cd60e01b148061135b57506001600160e01b03198216635b5e139f60e01b145b8061137657506001600160e01b0319821663780e9d6360e01b145b8061064757506301ffc9a760e01b6001600160e01b0319831614610647565b60008281526005602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b60006113fc82611798565b80519091506000906001600160a01b0316336001600160a01b03161480611433575033611428846106df565b6001600160a01b0316145b80611445575081516114459033611183565b9050806114af5760405162461bcd60e51b815260206004820152603260248201527f455243373231413a207472616e736665722063616c6c6572206973206e6f74206044820152711bdddb995c881b9bdc88185c1c1c9bdd995960721b606482015260840161074a565b846001600160a01b031682600001516001600160a01b0316146115235760405162461bcd60e51b815260206004820152602660248201527f455243373231413a207472616e736665722066726f6d20696e636f72726563746044820152651037bbb732b960d11b606482015260840161074a565b6001600160a01b0384166115875760405162461bcd60e51b815260206004820152602560248201527f455243373231413a207472616e7366657220746f20746865207a65726f206164604482015264647265737360d81b606482015260840161074a565b6115976000848460000151611395565b6001600160a01b03851660009081526004602052604081208054600192906115c99084906001600160801b03166124fc565b82546101009290920a6001600160801b038181021990931691831602179091556001600160a01b0386166000908152600460205260408120805460019450909261161591859116612523565b82546001600160801b039182166101009390930a9283029190920219909116179055506040805180820182526001600160a01b03808716825267ffffffffffffffff428116602080850191825260008981526003909152948520935184549151909216600160a01b026001600160e01b0319909116919092161717905561169d8460016123d3565b6000818152600360205260409020549091506001600160a01b031661172f576116c7816000541190565b1561172f5760408051808201825284516001600160a01b03908116825260208087015167ffffffffffffffff9081168285019081526000878152600390935294909120925183549451909116600160a01b026001600160e01b03199094169116179190911790555b83856001600160a01b0316876001600160a01b03167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef60405160405180910390a45b505050505050565b600061178582846123bc565b9392505050565b60006117858284612559565b60408051808201909152600080825260208201526117b7826000541190565b6118165760405162461bcd60e51b815260206004820152602a60248201527f455243373231413a206f776e657220717565727920666f72206e6f6e657869736044820152693a32b73a103a37b5b2b760b11b606482015260840161074a565b60007f00000000000000000000000000000000000000000000000000000000000000008310611877576118697f00000000000000000000000000000000000000000000000000000000000000008461256d565b6118749060016123d3565b90505b825b8181106118e1576000818152600360209081526040918290208251808401909352546001600160a01b038116808452600160a01b90910467ffffffffffffffff1691830191909152156118ce57949350505050565b50806118d981612580565b915050611879565b5060405162461bcd60e51b815260206004820152602f60248201527f455243373231413a20756e61626c6520746f2064657465726d696e652074686560448201526e1037bbb732b91037b3103a37b5b2b760891b606482015260840161074a565b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b610b02828260405180602001604052806000815250611bb0565b60006001600160a01b0384163b15611aa457604051630a85bd0160e11b81526001600160a01b0385169063150b7a02906119f2903390899088908890600401612597565b6020604051808303816000875af1925050508015611a2d575060408051601f3d908101601f19168201909252611a2a918101906125d4565b60015b611a8a573d808015611a5b576040519150601f19603f3d011682016040523d82523d6000602084013e611a60565b606091505b508051600003611a825760405162461bcd60e51b815260040161074a906123e6565b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050611258565b506001949350505050565b606081600003611ad65750506040805180820190915260018152600360fc1b602082015290565b8160005b8115611b005780611aea81612267565b9150611af99050600a83612559565b9150611ada565b60008167ffffffffffffffff811115611b1b57611b1b612026565b6040519080825280601f01601f191660200182016040528015611b45576020820181803683370190505b5090505b841561125857611b5a60018361256d565b9150611b67600a866125f1565b611b729060306123d3565b60f81b818381518110611b8757611b87612605565b60200101906001600160f81b031916908160001a905350611ba9600a86612559565b9450611b49565b6000546001600160a01b038416611c135760405162461bcd60e51b815260206004820152602160248201527f455243373231413a206d696e7420746f20746865207a65726f206164647265736044820152607360f81b606482015260840161074a565b611c1e816000541190565b15611c6b5760405162461bcd60e51b815260206004820152601d60248201527f455243373231413a20746f6b656e20616c7265616479206d696e746564000000604482015260640161074a565b7f0000000000000000000000000000000000000000000000000000000000000000831115611ce65760405162461bcd60e51b815260206004820152602260248201527f455243373231413a207175616e7469747920746f206d696e7420746f6f2068696044820152610ced60f31b606482015260840161074a565b6001600160a01b0384166000908152600460209081526040918290208251808401845290546001600160801b038082168352600160801b9091041691810191909152815180830190925280519091908190611d42908790612523565b6001600160801b03168152602001858360200151611d609190612523565b6001600160801b039081169091526001600160a01b0380881660008181526004602090815260408083208751978301518716600160801b0297909616969096179094558451808601865291825267ffffffffffffffff4281168386019081528883526003909552948120915182549451909516600160a01b026001600160e01b031990941694909216939093179190911790915582905b85811015611e805760405182906001600160a01b038916906000907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a4611e4460008884886119ae565b611e605760405162461bcd60e51b815260040161074a906123e6565b81611e6a81612267565b9250508080611e7890612267565b915050611df7565b506000819055611771565b6001600160e01b03198116811461132757600080fd5b600060208284031215611eb357600080fd5b813561178581611e8b565b60005b83811015611ed9578181015183820152602001611ec1565b50506000910152565b60008151808452611efa816020860160208601611ebe565b601f01601f19169290920160200192915050565b6020815260006117856020830184611ee2565b600060208284031215611f3357600080fd5b5035919050565b6001600160a01b038116811461132757600080fd5b60008060408385031215611f6257600080fd5b8235611f6d81611f3a565b946020939093013593505050565b600080600060608486031215611f9057600080fd5b8335611f9b81611f3a565b92506020840135611fab81611f3a565b929592945050506040919091013590565b801515811461132757600080fd5b600060208284031215611fdc57600080fd5b813561178581611fbc565b60008060408385031215611ffa57600080fd5b50508035926020909101359150565b60006020828403121561201b57600080fd5b813561178581611f3a565b634e487b7160e01b600052604160045260246000fd5b600067ffffffffffffffff8084111561205757612057612026565b604051601f8501601f19908116603f0116810190828211818310171561207f5761207f612026565b8160405280935085815286868601111561209857600080fd5b858560208301376000602087830101525050509392505050565b6000602082840312156120c457600080fd5b813567ffffffffffffffff8111156120db57600080fd5b8201601f810184136120ec57600080fd5b6112588482356020840161203c565b6000806040838503121561210e57600080fd5b823561211981611f3a565b9150602083013561212981611fbc565b809150509250929050565b6000806000806080858703121561214a57600080fd5b843561215581611f3a565b9350602085013561216581611f3a565b925060408501359150606085013567ffffffffffffffff81111561218857600080fd5b8501601f8101871361219957600080fd5b6121a88782356020840161203c565b91505092959194509250565b600080604083850312156121c757600080fd5b82356121d281611f3a565b9150602083013561212981611f3a565b600181811c908216806121f657607f821691505b60208210810361221657634e487b7160e01b600052602260045260246000fd5b50919050565b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b634e487b7160e01b600052601160045260246000fd5b60006001820161227957612279612251565b5060010190565b60006020828403121561229257600080fd5b5051919050565b6000602082840312156122ab57600080fd5b815161178581611fbc565b601f82111561088157600081815260208120601f850160051c810160208610156122dd5750805b601f850160051c820191505b81811015611771578281556001016122e9565b815167ffffffffffffffff81111561231657612316612026565b61232a8161232484546121e2565b846122b6565b602080601f83116001811461235f57600084156123475750858301515b600019600386901b1c1916600185901b178555611771565b600085815260208120601f198616915b8281101561238e5788860151825594840194600190910190840161236f565b50858210156123ac5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b808202811582820484141761064757610647612251565b8082018082111561064757610647612251565b60208082526033908201527f455243373231413a207472616e7366657220746f206e6f6e204552433732315260408201527232b1b2b4bb32b91034b6b83632b6b2b73a32b960691b606082015260800190565b6000808454612447816121e2565b6001828116801561245f5760018114612474576124a3565b60ff19841687528215158302870194506124a3565b8860005260208060002060005b8581101561249a5781548a820152908401908201612481565b50505082870194505b50602f60f81b8452865192506124bf8382860160208a01611ebe565b64173539b7b760d91b939092019182019290925260060195945050505050565b6000602082840312156124f157600080fd5b815161178581611f3a565b6001600160801b0382811682821603908082111561251c5761251c612251565b5092915050565b6001600160801b0381811683821601908082111561251c5761251c612251565b634e487b7160e01b600052601260045260246000fd5b60008261256857612568612543565b500490565b8181038181111561064757610647612251565b60008161258f5761258f612251565b506000190190565b6001600160a01b03858116825284166020820152604081018390526080606082018190526000906125ca90830184611ee2565b9695505050505050565b6000602082840312156125e657600080fd5b815161178581611e8b565b60008261260057612600612543565b500690565b634e487b7160e01b600052603260045260246000fdfea2646970667358221220749424b2e45dd2a58e897c56a6c4a860d85fbebacfb0c855def164576d7664fd64736f6c63430008120033697066733a2f2f516d5a6a48736f4848646353734b626f4162767a336f6f6578596b5343366b713868465177434877465248644653
Deployed Bytecode
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
Deployed Bytecode Sourcemap
54969:5708:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58866:292;;;;;;;;;;-1:-1:-1;58866:292:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;58866:292:0;;;;;;;;44188:94;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;55485:55::-;;;;;;;;;;;;55529:11;55485:55;;;;;1494:25:1;;;1482:2;1467:18;55485:55:0;1348:177:1;45713:204:0;;;;;;;;;;-1:-1:-1;45713:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1879:32:1;;;1861:51;;1849:2;1834:18;45713:204:0;1715:203:1;45276:379:0;;;;;;;;;;-1:-1:-1;45276:379:0;;;;;:::i;:::-;;:::i;:::-;;41023:94;;;;;;;;;;-1:-1:-1;41076:7:0;41099:12;41023:94;;55589:37;;;;;;;;;;-1:-1:-1;55589:37:0;;;;;;;;46563:142;;;;;;;;;;-1:-1:-1;46563:142:0;;;;;:::i;:::-;;:::i;57971:158::-;;;;;;;;;;-1:-1:-1;57971:158:0;;;;;:::i;:::-;;:::i;60356:318::-;;;;;;;;;;-1:-1:-1;60356:318:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3654:32:1;;;3636:51;;3718:2;3703:18;;3696:34;;;;3609:18;60356:318:0;3462:274:1;41654:744:0;;;;;;;;;;-1:-1:-1;41654:744:0;;;;;:::i;:::-;;:::i;58283:143::-;;;;;;;;;;;;;:::i;46768:157::-;;;;;;;;;;-1:-1:-1;46768:157:0;;;;;:::i;:::-;;:::i;58434:168::-;;;;;;;;;;-1:-1:-1;58434:168:0;;;;;:::i;:::-;;:::i;41186:177::-;;;;;;;;;;-1:-1:-1;41186:177:0;;;;;:::i;:::-;;:::i;57573:100::-;;;;;;;;;;-1:-1:-1;57573:100:0;;;;;:::i;:::-;;:::i;44011:118::-;;;;;;;;;;-1:-1:-1;44011:118:0;;;;;:::i;:::-;;:::i;42888:211::-;;;;;;;;;;-1:-1:-1;42888:211:0;;;;;:::i;:::-;;:::i;57409:93::-;;;;;;;;;;;;;:::i;19046:103::-;;;;;;;;;;;;;:::i;18395:87::-;;;;;;;;;;-1:-1:-1;18468:6:0;;-1:-1:-1;;;;;18468:6:0;18395:87;;44343:98;;;;;;;;;;;;;:::i;55547:35::-;;;;;;;;;;;;;;;;56893:321;;;;;;:::i;:::-;;:::i;45981:274::-;;;;;;;;;;-1:-1:-1;45981:274:0;;;;;:::i;:::-;;:::i;46988:311::-;;;;;;;;;;-1:-1:-1;46988:311:0;;;;;:::i;:::-;;:::i;55394:44::-;;;;;;;;;;;;55437:1;55394:44;;59983:307;;;;;;;;;;-1:-1:-1;59983:307:0;;;;;:::i;:::-;;:::i;55445:31::-;;;;;;;;;;;;;;;;51403:43;;;;;;;;;;;;;;;;57797:166;;;;;;;;;;-1:-1:-1;57797:166:0;;;;;:::i;:::-;;:::i;59295:617::-;;;;;;;;;;-1:-1:-1;59295:617:0;;;;;:::i;:::-;;:::i;58139:134::-;;;;;;;;;;-1:-1:-1;58139:134:0;;;;;:::i;:::-;;:::i;19304:201::-;;;;;;;;;;-1:-1:-1;19304:201:0;;;;;:::i;:::-;;:::i;58866:292::-;59014:4;-1:-1:-1;;;;;;59056:41:0;;-1:-1:-1;;;59056:41:0;;:94;;;59114:36;59138:11;59114:23;:36::i;:::-;59036:114;58866:292;-1:-1:-1;;58866:292:0:o;44188:94::-;44242:13;44271:5;44264:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44188:94;:::o;45713:204::-;45781:7;45805:16;45813:7;47595:4;47625:12;-1:-1:-1;47615:22:0;47538:105;45805:16;45797:74;;;;-1:-1:-1;;;45797:74:0;;7651:2:1;45797:74:0;;;7633:21:1;7690:2;7670:18;;;7663:30;7729:34;7709:18;;;7702:62;-1:-1:-1;;;7780:18:1;;;7773:43;7833:19;;45797:74:0;;;;;;;;;-1:-1:-1;45887:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;45887:24:0;;45713:204::o;45276:379::-;45345:13;45361:24;45377:7;45361:15;:24::i;:::-;45345:40;;45406:5;-1:-1:-1;;;;;45400:11:0;:2;-1:-1:-1;;;;;45400:11:0;;45392:58;;;;-1:-1:-1;;;45392:58:0;;8065:2:1;45392:58:0;;;8047:21:1;8104:2;8084:18;;;8077:30;8143:34;8123:18;;;8116:62;-1:-1:-1;;;8194:18:1;;;8187:32;8236:19;;45392:58:0;7863:398:1;45392:58:0;17199:10;-1:-1:-1;;;;;45475:21:0;;;;:62;;-1:-1:-1;45500:37:0;45517:5;17199:10;59295:617;:::i;45500:37::-;45459:153;;;;-1:-1:-1;;;45459:153:0;;8468:2:1;45459:153:0;;;8450:21:1;8507:2;8487:18;;;8480:30;8546:34;8526:18;;;8519:62;8617:27;8597:18;;;8590:55;8662:19;;45459:153:0;8266:421:1;45459:153:0;45621:28;45630:2;45634:7;45643:5;45621:8;:28::i;:::-;45338:317;45276:379;;:::o;46563:142::-;46671:28;46681:4;46687:2;46691:7;46671:9;:28::i;57971:158::-;18468:6;;-1:-1:-1;;;;;18468:6:0;17199:10;18615:23;18607:68;;;;-1:-1:-1;;;18607:68:0;;;;;;;:::i;:::-;58081:18:::1;:40:::0;;-1:-1:-1;;58081:40:0::1;::::0;::::1;;::::0;;;::::1;::::0;;57971:158::o;60356:318::-;60481:16;60499:21;60546:16;60554:7;47595:4;47625:12;-1:-1:-1;47615:22:0;47538:105;60546:16;60538:46;;;;-1:-1:-1;;;60538:46:0;;9255:2:1;60538:46:0;;;9237:21:1;9294:2;9274:18;;;9267:30;-1:-1:-1;;;9313:18:1;;;9306:47;9370:18;;60538:46:0;9053:341:1;60538:46:0;60613:4;60620:45;60633:26;60646:9;60657:1;60633:12;:26::i;:::-;60661:3;60620:12;:45::i;:::-;60597:69;;;;60356:318;;;;;:::o;41654:744::-;41763:7;41798:16;41808:5;41798:9;:16::i;:::-;41790:5;:24;41782:71;;;;-1:-1:-1;;;41782:71:0;;9601:2:1;41782:71:0;;;9583:21:1;9640:2;9620:18;;;9613:30;9679:34;9659:18;;;9652:62;-1:-1:-1;;;9730:18:1;;;9723:32;9772:19;;41782:71:0;9399:398:1;41782:71:0;41860:22;41099:12;;;41860:22;;41980:350;42004:14;42000:1;:18;41980:350;;;42034:31;42068:14;;;:11;:14;;;;;;;;;42034:48;;;;;;;;;-1:-1:-1;;;;;42034:48:0;;;;;-1:-1:-1;;;42034:48:0;;;;;;;;;;;;42095:28;42091:89;;42156:14;;;-1:-1:-1;42091:89:0;42213:5;-1:-1:-1;;;;;42192:26:0;:17;-1:-1:-1;;;;;42192:26:0;;42188:135;;42250:5;42235:11;:20;42231:59;;-1:-1:-1;42277:1:0;-1:-1:-1;42270:8:0;;-1:-1:-1;;;42270:8:0;42231:59;42300:13;;;;:::i;:::-;;;;42188:135;-1:-1:-1;42020:3:0;;;;:::i;:::-;;;;41980:350;;;-1:-1:-1;42336:56:0;;-1:-1:-1;;;42336:56:0;;10276:2:1;42336:56:0;;;10258:21:1;10315:2;10295:18;;;10288:30;10354:34;10334:18;;;10327:62;-1:-1:-1;;;10405:18:1;;;10398:44;10459:19;;42336:56:0;10074:410:1;58283:143:0;18468:6;;-1:-1:-1;;;;;18468:6:0;17199:10;18615:23;18607:68;;;;-1:-1:-1;;;18607:68:0;;;;;;;:::i;:::-;58381:37:::1;::::0;58349:21:::1;::::0;58389:10:::1;::::0;58381:37;::::1;;;::::0;58349:21;;58331:15:::1;58381:37:::0;58331:15;58381:37;58349:21;58389:10;58381:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;58320:106;58283:143::o:0;46768:157::-;46880:39;46897:4;46903:2;46907:7;46880:39;;;;;;;;;;;;:16;:39::i;58434:168::-;18468:6;;-1:-1:-1;;;;;18468:6:0;17199:10;18615:23;18607:68;;;;-1:-1:-1;;;18607:68:0;;;;;;;:::i;:::-;58518:30:::1;::::0;-1:-1:-1;;;58518:30:0;;58542:4:::1;58518:30;::::0;::::1;1861:51:1::0;58500:15:0::1;::::0;-1:-1:-1;;;;;58518:15:0;::::1;::::0;::::1;::::0;1834:18:1;;58518:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58559:35;::::0;-1:-1:-1;;;58559:35:0;;58574:10:::1;58559:35;::::0;::::1;3636:51:1::0;3703:18;;;3696:34;;;58500:48:0;;-1:-1:-1;;;;;;58559:14:0;::::1;::::0;::::1;::::0;3609:18:1;;58559:35:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;41186:177::-:0;41253:7;41099:12;;41277:5;:21;41269:69;;;;-1:-1:-1;;;41269:69:0;;11130:2:1;41269:69:0;;;11112:21:1;11169:2;11149:18;;;11142:30;11208:34;11188:18;;;11181:62;-1:-1:-1;;;11259:18:1;;;11252:33;11302:19;;41269:69:0;10928:399:1;41269:69:0;-1:-1:-1;41352:5:0;41186:177::o;57573:100::-;18468:6;;-1:-1:-1;;;;;18468:6:0;17199:10;18615:23;18607:68;;;;-1:-1:-1;;;18607:68:0;;;;;;;:::i;:::-;57647:7:::1;:18;57657:8:::0;57647:7;:18:::1;:::i;44011:118::-:0;44075:7;44098:20;44110:7;44098:11;:20::i;:::-;:25;;44011:118;-1:-1:-1;;44011:118:0:o;42888:211::-;42952:7;-1:-1:-1;;;;;42976:19:0;;42968:75;;;;-1:-1:-1;;;42968:75:0;;13738:2:1;42968:75:0;;;13720:21:1;13777:2;13757:18;;;13750:30;13816:34;13796:18;;;13789:62;-1:-1:-1;;;13867:18:1;;;13860:41;13918:19;;42968:75:0;13536:407:1;42968:75:0;-1:-1:-1;;;;;;43065:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;43065:27:0;;42888:211::o;57409:93::-;57454:13;57487:7;57480:14;;;;;:::i;19046:103::-;18468:6;;-1:-1:-1;;;;;18468:6:0;17199:10;18615:23;18607:68;;;;-1:-1:-1;;;18607:68:0;;;;;;;:::i;:::-;19111:30:::1;19138:1;19111:18;:30::i;:::-;19046:103::o:0;44343:98::-;44399:13;44428:7;44421:14;;;;;:::i;56893:321::-;10324:1;10922:7;;:19;10914:63;;;;-1:-1:-1;;;10914:63:0;;14150:2:1;10914:63:0;;;14132:21:1;14189:2;14169:18;;;14162:30;14228:33;14208:18;;;14201:61;14279:18;;10914:63:0;13948:355:1;10914:63:0;10324:1;11055:7;:18;56558:14:::1;::::0;41076:7;41099:12;55529:11:::1;::::0;57033:14;;56544:28:::1;56541:166;;;56634:9;56607:22;56615:14:::0;56607:5;:22:::1;:::i;:::-;56606:37;56584:111;;;::::0;-1:-1:-1;;;56584:111:0;;14683:2:1;56584:111:0::1;::::0;::::1;14665:21:1::0;14722:2;14702:18;;;14695:30;14761:26;14741:18;;;14734:54;14805:18;;56584:111:0::1;14481:348:1::0;56584:111:0::1;55756:18:::2;::::0;::::2;;55748:54;;;::::0;-1:-1:-1;;;55748:54:0;;15036:2:1;55748:54:0::2;::::0;::::2;15018:21:1::0;15075:2;15055:18;;;15048:30;15114:25;15094:18;;;15087:53;15157:18;;55748:54:0::2;14834:347:1::0;55748:54:0::2;57096:14:::3;56167:9;;56132:14;56116:13;41076:7:::0;41099:12;;41023:94;56116:13:::3;:30;;;;:::i;:::-;:60;;56094:144;;;::::0;-1:-1:-1;;;56094:144:0;;15518:2:1;56094:144:0::3;::::0;::::3;15500:21:1::0;15557:2;15537:18;;;15530:30;15596:34;15576:18;;;15569:62;-1:-1:-1;;;15647:18:1;;;15640:32;15689:19;;56094:144:0::3;15316:398:1::0;56094:144:0::3;57135:14:::4;55437:1;55914:14;:34;;55892:118;;;::::0;-1:-1:-1;;;55892:118:0;;15921:2:1;55892:118:0::4;::::0;::::4;15903:21:1::0;15960:2;15940:18;;;15933:30;15999:34;15979:18;;;15972:62;-1:-1:-1;;;16050:18:1;;;16043:32;16092:19;;55892:118:0::4;15719:398:1::0;55892:118:0::4;57169:37:::5;57179:10;57191:14;57169:9;:37::i;:::-;-1:-1:-1::0;;10280:1:0;11234:7;:22;-1:-1:-1;;;56893:321:0:o;45981:274::-;17199:10;-1:-1:-1;;;;;46072:24:0;;;46064:63;;;;-1:-1:-1;;;46064:63:0;;16324:2:1;46064:63:0;;;16306:21:1;16363:2;16343:18;;;16336:30;16402:28;16382:18;;;16375:56;16448:18;;46064:63:0;16122:350:1;46064:63:0;17199:10;46136:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;46136:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;46136:53:0;;;;;;;;;;46201:48;;540:41:1;;;46136:42:0;;17199:10;46201:48;;513:18:1;46201:48:0;;;;;;;45981:274;;:::o;46988:311::-;47125:28;47135:4;47141:2;47145:7;47125:9;:28::i;:::-;47176:48;47199:4;47205:2;47209:7;47218:5;47176:22;:48::i;:::-;47160:133;;;;-1:-1:-1;;;47160:133:0;;;;;;;:::i;:::-;46988:311;;;;:::o;59983:307::-;60101:13;60140:16;60148:7;47595:4;47625:12;-1:-1:-1;47615:22:0;47538:105;60140:16;60132:46;;;;-1:-1:-1;;;60132:46:0;;9255:2:1;60132:46:0;;;9237:21:1;9294:2;9274:18;;;9267:30;-1:-1:-1;;;9313:18:1;;;9306:47;9370:18;;60132:46:0;9053:341:1;60132:46:0;60235:7;60249:22;60250:9;:7;60258:1;60250:9;:::i;:::-;60249:20;:22::i;:::-;60218:63;;;;;;;;;:::i;:::-;;;;;;;;;;;;;60191:91;;59983:307;;;:::o;57797:166::-;18468:6;;-1:-1:-1;;;;;18468:6:0;17199:10;18615:23;18607:68;;;;-1:-1:-1;;;18607:68:0;;;;;;;:::i;:::-;57911:20:::1;:44:::0;;;::::1;;-1:-1:-1::0;;;57911:44:0::1;-1:-1:-1::0;;;;57911:44:0;;::::1;::::0;;;::::1;::::0;;57797:166::o;59295:617::-;59643:27;;59420:4;;-1:-1:-1;;;;;59643:27:0;;;-1:-1:-1;;;59710:20:0;;;;:86;;;;-1:-1:-1;59755:28:0;;-1:-1:-1;;;59755:28:0;;-1:-1:-1;;;;;1879:32:1;;;59755:28:0;;;1861:51:1;59747:49:0;;;;59755:21;;;;;;1834:18:1;;59755:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;59747:49:0;;59710:86;59692:154;;;59830:4;59823:11;;;;;59692:154;-1:-1:-1;;;;;46463:25:0;;;46440:4;46463:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;59865:39;59858:46;59295:617;-1:-1:-1;;;;59295:617:0:o;58139:134::-;18468:6;;-1:-1:-1;;;;;18468:6:0;17199:10;18615:23;18607:68;;;;-1:-1:-1;;;18607:68:0;;;;;;;:::i;:::-;58235:14:::1;:30:::0;58139:134::o;19304:201::-;18468:6;;-1:-1:-1;;;;;18468:6:0;17199:10;18615:23;18607:68;;;;-1:-1:-1;;;18607:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;19393:22:0;::::1;19385:73;;;::::0;-1:-1:-1;;;19385:73:0;;18711:2:1;19385:73:0::1;::::0;::::1;18693:21:1::0;18750:2;18730:18;;;18723:30;18789:34;18769:18;;;18762:62;-1:-1:-1;;;18840:18:1;;;18833:36;18886:19;;19385:73:0::1;18509:402:1::0;19385:73:0::1;19469:28;19488:8;19469:18;:28::i;:::-;19304:201:::0;:::o;42462:370::-;42589:4;-1:-1:-1;;;;;;42619:40:0;;-1:-1:-1;;;42619:40:0;;:99;;-1:-1:-1;;;;;;;42670:48:0;;-1:-1:-1;;;42670:48:0;42619:99;:160;;;-1:-1:-1;;;;;;;42729:50:0;;-1:-1:-1;;;42729:50:0;42619:160;:207;;;-1:-1:-1;;;;;;;;;;31904:40:0;;;42790:36;31795:157;51225:172;51322:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;51322:29:0;-1:-1:-1;;;;;51322:29:0;;;;;;;;;51363:28;;51322:24;;51363:28;;;;;;;51225:172;;;:::o;49590:1529::-;49687:35;49725:20;49737:7;49725:11;:20::i;:::-;49796:18;;49687:58;;-1:-1:-1;49754:22:0;;-1:-1:-1;;;;;49780:34:0;17199:10;-1:-1:-1;;;;;49780:34:0;;:81;;;-1:-1:-1;17199:10:0;49825:20;49837:7;49825:11;:20::i;:::-;-1:-1:-1;;;;;49825:36:0;;49780:81;:142;;;-1:-1:-1;49889:18:0;;49872:50;;17199:10;59295:617;:::i;49872:50::-;49754:169;;49948:17;49932:101;;;;-1:-1:-1;;;49932:101:0;;19118:2:1;49932:101:0;;;19100:21:1;19157:2;19137:18;;;19130:30;19196:34;19176:18;;;19169:62;-1:-1:-1;;;19247:18:1;;;19240:48;19305:19;;49932:101:0;18916:414:1;49932:101:0;50080:4;-1:-1:-1;;;;;50058:26:0;:13;:18;;;-1:-1:-1;;;;;50058:26:0;;50042:98;;;;-1:-1:-1;;;50042:98:0;;19537:2:1;50042:98:0;;;19519:21:1;19576:2;19556:18;;;19549:30;19615:34;19595:18;;;19588:62;-1:-1:-1;;;19666:18:1;;;19659:36;19712:19;;50042:98:0;19335:402:1;50042:98:0;-1:-1:-1;;;;;50155:16:0;;50147:66;;;;-1:-1:-1;;;50147:66:0;;19944:2:1;50147:66:0;;;19926:21:1;19983:2;19963:18;;;19956:30;20022:34;20002:18;;;19995:62;-1:-1:-1;;;20073:18:1;;;20066:35;20118:19;;50147:66:0;19742:401:1;50147:66:0;50322:49;50339:1;50343:7;50352:13;:18;;;50322:8;:49::i;:::-;-1:-1:-1;;;;;50380:18:0;;;;;;:12;:18;;;;;:31;;50410:1;;50380:18;:31;;50410:1;;-1:-1:-1;;;;;50380:31:0;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;50380:31:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;50418:16:0;;-1:-1:-1;50418:16:0;;;:12;:16;;;;;:29;;-1:-1:-1;;;50418:16:0;;:29;;-1:-1:-1;;50418:29:0;;:::i;:::-;;;-1:-1:-1;;;;;50418:29:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50477:43:0;;;;;;;;-1:-1:-1;;;;;50477:43:0;;;;;;50503:15;50477:43;;;;;;;;;-1:-1:-1;50454:20:0;;;:11;:20;;;;;;:66;;;;;;;;;-1:-1:-1;;;50454:66:0;-1:-1:-1;;;;;;50454:66:0;;;;;;;;;;;50770:11;50466:7;-1:-1:-1;50770:11:0;:::i;:::-;50833:1;50792:24;;;:11;:24;;;;;:29;50748:33;;-1:-1:-1;;;;;;50792:29:0;50788:236;;50850:20;50858:11;47595:4;47625:12;-1:-1:-1;47615:22:0;47538:105;50850:20;50846:171;;;50910:97;;;;;;;;50937:18;;-1:-1:-1;;;;;50910:97:0;;;;;;50968:28;;;;50910:97;;;;;;;;;;-1:-1:-1;50883:24:0;;;:11;:24;;;;;;;:124;;;;;;;;;-1:-1:-1;;;50883:124:0;-1:-1:-1;;;;;;50883:124:0;;;;;;;;;;;;50846:171;51056:7;51052:2;-1:-1:-1;;;;;51037:27:0;51046:4;-1:-1:-1;;;;;51037:27:0;;;;;;;;;;;51071:42;49680:1439;;;49590:1529;;;:::o;3620:98::-;3678:7;3705:5;3709:1;3705;:5;:::i;:::-;3698:12;3620:98;-1:-1:-1;;;3620:98:0:o;4019:::-;4077:7;4104:5;4108:1;4104;:5;:::i;43351:606::-;-1:-1:-1;;;;;;;;;;;;;;;;;43468:16:0;43476:7;47595:4;47625:12;-1:-1:-1;47615:22:0;47538:105;43468:16;43460:71;;;;-1:-1:-1;;;43460:71:0;;21014:2:1;43460:71:0;;;20996:21:1;21053:2;21033:18;;;21026:30;21092:34;21072:18;;;21065:62;-1:-1:-1;;;21143:18:1;;;21136:40;21193:19;;43460:71:0;20812:406:1;43460:71:0;43540:26;43588:12;43577:7;:23;43573:93;;43632:22;43642:12;43632:7;:22;:::i;:::-;:26;;43657:1;43632:26;:::i;:::-;43611:47;;43573:93;43694:7;43674:212;43711:18;43703:4;:26;43674:212;;43748:31;43782:17;;;:11;:17;;;;;;;;;43748:51;;;;;;;;;-1:-1:-1;;;;;43748:51:0;;;;;-1:-1:-1;;;43748:51:0;;;;;;;;;;;;43812:28;43808:71;;43860:9;43351:606;-1:-1:-1;;;;43351:606:0:o;43808:71::-;-1:-1:-1;43731:6:0;;;;:::i;:::-;;;;43674:212;;;-1:-1:-1;43894:57:0;;-1:-1:-1;;;43894:57:0;;21699:2:1;43894:57:0;;;21681:21:1;21738:2;21718:18;;;21711:30;21777:34;21757:18;;;21750:62;-1:-1:-1;;;21828:18:1;;;21821:45;21883:19;;43894:57:0;21497:411:1;19665:191:0;19758:6;;;-1:-1:-1;;;;;19775:17:0;;;-1:-1:-1;;;;;;19775:17:0;;;;;;;19808:40;;19758:6;;;19775:17;19758:6;;19808:40;;19739:16;;19808:40;19728:128;19665:191;:::o;47649:98::-;47714:27;47724:2;47728:8;47714:27;;;;;;;;;;;;:9;:27::i;52940:690::-;53077:4;-1:-1:-1;;;;;53094:13:0;;21006:20;21054:8;53090:535;;53133:72;;-1:-1:-1;;;53133:72:0;;-1:-1:-1;;;;;53133:36:0;;;;;:72;;17199:10;;53184:4;;53190:7;;53199:5;;53133:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53133:72:0;;;;;;;;-1:-1:-1;;53133:72:0;;;;;;;;;;;;:::i;:::-;;;53120:464;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53364:6;:13;53381:1;53364:18;53360:215;;53397:61;;-1:-1:-1;;;53397:61:0;;;;;;;:::i;53360:215::-;53543:6;53537:13;53528:6;53524:2;53520:15;53513:38;53120:464;-1:-1:-1;;;;;;53255:55:0;-1:-1:-1;;;53255:55:0;;-1:-1:-1;53248:62:0;;53090:535;-1:-1:-1;53613:4:0;52940:690;;;;;;:::o;14681:723::-;14737:13;14958:5;14967:1;14958:10;14954:53;;-1:-1:-1;;14985:10:0;;;;;;;;;;;;-1:-1:-1;;;14985:10:0;;;;;14681:723::o;14954:53::-;15032:5;15017:12;15073:78;15080:9;;15073:78;;15106:8;;;;:::i;:::-;;-1:-1:-1;15129:10:0;;-1:-1:-1;15137:2:0;15129:10;;:::i;:::-;;;15073:78;;;15161:19;15193:6;15183:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15183:17:0;;15161:39;;15211:154;15218:10;;15211:154;;15245:11;15255:1;15245:11;;:::i;:::-;;-1:-1:-1;15314:10:0;15322:2;15314:5;:10;:::i;:::-;15301:24;;:2;:24;:::i;:::-;15288:39;;15271:6;15278;15271:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;15271:56:0;;;;;;;;-1:-1:-1;15342:11:0;15351:2;15342:11;;:::i;:::-;;;15211:154;;48086:1272;48191:20;48214:12;-1:-1:-1;;;;;48241:16:0;;48233:62;;;;-1:-1:-1;;;48233:62:0;;23112:2:1;48233:62:0;;;23094:21:1;23151:2;23131:18;;;23124:30;23190:34;23170:18;;;23163:62;-1:-1:-1;;;23241:18:1;;;23234:31;23282:19;;48233:62:0;22910:397:1;48233:62:0;48432:21;48440:12;47595:4;47625:12;-1:-1:-1;47615:22:0;47538:105;48432:21;48431:22;48423:64;;;;-1:-1:-1;;;48423:64:0;;23514:2:1;48423:64:0;;;23496:21:1;23553:2;23533:18;;;23526:30;23592:31;23572:18;;;23565:59;23641:18;;48423:64:0;23312:353:1;48423:64:0;48514:12;48502:8;:24;;48494:71;;;;-1:-1:-1;;;48494:71:0;;23872:2:1;48494:71:0;;;23854:21:1;23911:2;23891:18;;;23884:30;23950:34;23930:18;;;23923:62;-1:-1:-1;;;24001:18:1;;;23994:32;24043:19;;48494:71:0;23670:398:1;48494:71:0;-1:-1:-1;;;;;48677:16:0;;48644:30;48677:16;;;:12;:16;;;;;;;;;48644:49;;;;;;;;;-1:-1:-1;;;;;48644:49:0;;;;;-1:-1:-1;;;48644:49:0;;;;;;;;;;;48719:119;;;;;;;;48739:19;;48644:49;;48719:119;;;48739:39;;48769:8;;48739:39;:::i;:::-;-1:-1:-1;;;;;48719:119:0;;;;;48822:8;48787:11;:24;;;:44;;;;:::i;:::-;-1:-1:-1;;;;;48719:119:0;;;;;;-1:-1:-1;;;;;48700:16:0;;;;;;;:12;:16;;;;;;;;:138;;;;;;;;-1:-1:-1;;;48700:138:0;;;;;;;;;;;;48873:43;;;;;;;;;;;48899:15;48873:43;;;;;;;;48845:25;;;:11;:25;;;;;;:71;;;;;;;;;-1:-1:-1;;;48845:71:0;-1:-1:-1;;;;;;48845:71:0;;;;;;;;;;;;;;;;;;48857:12;;48969:281;48993:8;48989:1;:12;48969:281;;;49022:38;;49047:12;;-1:-1:-1;;;;;49022:38:0;;;49039:1;;49022:38;;49039:1;;49022:38;49087:59;49118:1;49122:2;49126:12;49140:5;49087:22;:59::i;:::-;49069:150;;;;-1:-1:-1;;;49069:150:0;;;;;;;:::i;:::-;49228:14;;;;:::i;:::-;;;;49003:3;;;;;:::i;:::-;;;;48969:281;;;-1:-1:-1;49258:12:0;:27;;;49292:60;46988:311;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:250::-;677:1;687:113;701:6;698:1;695:13;687:113;;;777:11;;;771:18;758:11;;;751:39;723:2;716:10;687:113;;;-1:-1:-1;;834:1:1;816:16;;809:27;592:250::o;847:271::-;889:3;927:5;921:12;954:6;949:3;942:19;970:76;1039:6;1032:4;1027:3;1023:14;1016:4;1009:5;1005:16;970:76;:::i;:::-;1100:2;1079:15;-1:-1:-1;;1075:29:1;1066:39;;;;1107:4;1062:50;;847:271;-1:-1:-1;;847:271:1:o;1123:220::-;1272:2;1261:9;1254:21;1235:4;1292:45;1333:2;1322:9;1318:18;1310:6;1292:45;:::i;1530:180::-;1589:6;1642:2;1630:9;1621:7;1617:23;1613:32;1610:52;;;1658:1;1655;1648:12;1610:52;-1:-1:-1;1681:23:1;;1530:180;-1:-1:-1;1530:180:1:o;1923:131::-;-1:-1:-1;;;;;1998:31:1;;1988:42;;1978:70;;2044:1;2041;2034:12;2059:315;2127:6;2135;2188:2;2176:9;2167:7;2163:23;2159:32;2156:52;;;2204:1;2201;2194:12;2156:52;2243:9;2230:23;2262:31;2287:5;2262:31;:::i;:::-;2312:5;2364:2;2349:18;;;;2336:32;;-1:-1:-1;;;2059:315:1:o;2379:456::-;2456:6;2464;2472;2525:2;2513:9;2504:7;2500:23;2496:32;2493:52;;;2541:1;2538;2531:12;2493:52;2580:9;2567:23;2599:31;2624:5;2599:31;:::i;:::-;2649:5;-1:-1:-1;2706:2:1;2691:18;;2678:32;2719:33;2678:32;2719:33;:::i;:::-;2379:456;;2771:7;;-1:-1:-1;;;2825:2:1;2810:18;;;;2797:32;;2379:456::o;2840:118::-;2926:5;2919:13;2912:21;2905:5;2902:32;2892:60;;2948:1;2945;2938:12;2963:241;3019:6;3072:2;3060:9;3051:7;3047:23;3043:32;3040:52;;;3088:1;3085;3078:12;3040:52;3127:9;3114:23;3146:28;3168:5;3146:28;:::i;3209:248::-;3277:6;3285;3338:2;3326:9;3317:7;3313:23;3309:32;3306:52;;;3354:1;3351;3344:12;3306:52;-1:-1:-1;;3377:23:1;;;3447:2;3432:18;;;3419:32;;-1:-1:-1;3209:248:1:o;3741:261::-;3814:6;3867:2;3855:9;3846:7;3842:23;3838:32;3835:52;;;3883:1;3880;3873:12;3835:52;3922:9;3909:23;3941:31;3966:5;3941:31;:::i;4007:127::-;4068:10;4063:3;4059:20;4056:1;4049:31;4099:4;4096:1;4089:15;4123:4;4120:1;4113:15;4139:632;4204:5;4234:18;4275:2;4267:6;4264:14;4261:40;;;4281:18;;:::i;:::-;4356:2;4350:9;4324:2;4410:15;;-1:-1:-1;;4406:24:1;;;4432:2;4402:33;4398:42;4386:55;;;4456:18;;;4476:22;;;4453:46;4450:72;;;4502:18;;:::i;:::-;4542:10;4538:2;4531:22;4571:6;4562:15;;4601:6;4593;4586:22;4641:3;4632:6;4627:3;4623:16;4620:25;4617:45;;;4658:1;4655;4648:12;4617:45;4708:6;4703:3;4696:4;4688:6;4684:17;4671:44;4763:1;4756:4;4747:6;4739;4735:19;4731:30;4724:41;;;;4139:632;;;;;:::o;4776:451::-;4845:6;4898:2;4886:9;4877:7;4873:23;4869:32;4866:52;;;4914:1;4911;4904:12;4866:52;4954:9;4941:23;4987:18;4979:6;4976:30;4973:50;;;5019:1;5016;5009:12;4973:50;5042:22;;5095:4;5087:13;;5083:27;-1:-1:-1;5073:55:1;;5124:1;5121;5114:12;5073:55;5147:74;5213:7;5208:2;5195:16;5190:2;5186;5182:11;5147:74;:::i;5484:382::-;5549:6;5557;5610:2;5598:9;5589:7;5585:23;5581:32;5578:52;;;5626:1;5623;5616:12;5578:52;5665:9;5652:23;5684:31;5709:5;5684:31;:::i;:::-;5734:5;-1:-1:-1;5791:2:1;5776:18;;5763:32;5804:30;5763:32;5804:30;:::i;:::-;5853:7;5843:17;;;5484:382;;;;;:::o;5871:795::-;5966:6;5974;5982;5990;6043:3;6031:9;6022:7;6018:23;6014:33;6011:53;;;6060:1;6057;6050:12;6011:53;6099:9;6086:23;6118:31;6143:5;6118:31;:::i;:::-;6168:5;-1:-1:-1;6225:2:1;6210:18;;6197:32;6238:33;6197:32;6238:33;:::i;:::-;6290:7;-1:-1:-1;6344:2:1;6329:18;;6316:32;;-1:-1:-1;6399:2:1;6384:18;;6371:32;6426:18;6415:30;;6412:50;;;6458:1;6455;6448:12;6412:50;6481:22;;6534:4;6526:13;;6522:27;-1:-1:-1;6512:55:1;;6563:1;6560;6553:12;6512:55;6586:74;6652:7;6647:2;6634:16;6629:2;6625;6621:11;6586:74;:::i;:::-;6576:84;;;5871:795;;;;;;;:::o;6671:388::-;6739:6;6747;6800:2;6788:9;6779:7;6775:23;6771:32;6768:52;;;6816:1;6813;6806:12;6768:52;6855:9;6842:23;6874:31;6899:5;6874:31;:::i;:::-;6924:5;-1:-1:-1;6981:2:1;6966:18;;6953:32;6994:33;6953:32;6994:33;:::i;7064:380::-;7143:1;7139:12;;;;7186;;;7207:61;;7261:4;7253:6;7249:17;7239:27;;7207:61;7314:2;7306:6;7303:14;7283:18;7280:38;7277:161;;7360:10;7355:3;7351:20;7348:1;7341:31;7395:4;7392:1;7385:15;7423:4;7420:1;7413:15;7277:161;;7064:380;;;:::o;8692:356::-;8894:2;8876:21;;;8913:18;;;8906:30;8972:34;8967:2;8952:18;;8945:62;9039:2;9024:18;;8692:356::o;9802:127::-;9863:10;9858:3;9854:20;9851:1;9844:31;9894:4;9891:1;9884:15;9918:4;9915:1;9908:15;9934:135;9973:3;9994:17;;;9991:43;;10014:18;;:::i;:::-;-1:-1:-1;10061:1:1;10050:13;;9934:135::o;10489:184::-;10559:6;10612:2;10600:9;10591:7;10587:23;10583:32;10580:52;;;10628:1;10625;10618:12;10580:52;-1:-1:-1;10651:16:1;;10489:184;-1:-1:-1;10489:184:1:o;10678:245::-;10745:6;10798:2;10786:9;10777:7;10773:23;10769:32;10766:52;;;10814:1;10811;10804:12;10766:52;10846:9;10840:16;10865:28;10887:5;10865:28;:::i;11458:545::-;11560:2;11555:3;11552:11;11549:448;;;11596:1;11621:5;11617:2;11610:17;11666:4;11662:2;11652:19;11736:2;11724:10;11720:19;11717:1;11713:27;11707:4;11703:38;11772:4;11760:10;11757:20;11754:47;;;-1:-1:-1;11795:4:1;11754:47;11850:2;11845:3;11841:12;11838:1;11834:20;11828:4;11824:31;11814:41;;11905:82;11923:2;11916:5;11913:13;11905:82;;;11968:17;;;11949:1;11938:13;11905:82;;12179:1352;12305:3;12299:10;12332:18;12324:6;12321:30;12318:56;;;12354:18;;:::i;:::-;12383:97;12473:6;12433:38;12465:4;12459:11;12433:38;:::i;:::-;12427:4;12383:97;:::i;:::-;12535:4;;12599:2;12588:14;;12616:1;12611:663;;;;13318:1;13335:6;13332:89;;;-1:-1:-1;13387:19:1;;;13381:26;13332:89;-1:-1:-1;;12136:1:1;12132:11;;;12128:24;12124:29;12114:40;12160:1;12156:11;;;12111:57;13434:81;;12581:944;;12611:663;11405:1;11398:14;;;11442:4;11429:18;;-1:-1:-1;;12647:20:1;;;12765:236;12779:7;12776:1;12773:14;12765:236;;;12868:19;;;12862:26;12847:42;;12960:27;;;;12928:1;12916:14;;;;12795:19;;12765:236;;;12769:3;13029:6;13020:7;13017:19;13014:201;;;13090:19;;;13084:26;-1:-1:-1;;13173:1:1;13169:14;;;13185:3;13165:24;13161:37;13157:42;13142:58;13127:74;;13014:201;-1:-1:-1;;;;;13261:1:1;13245:14;;;13241:22;13228:36;;-1:-1:-1;12179:1352:1:o;14308:168::-;14381:9;;;14412;;14429:15;;;14423:22;;14409:37;14399:71;;14450:18;;:::i;15186:125::-;15251:9;;;15272:10;;;15269:36;;;15285:18;;:::i;16477:415::-;16679:2;16661:21;;;16718:2;16698:18;;;16691:30;16757:34;16752:2;16737:18;;16730:62;-1:-1:-1;;;16823:2:1;16808:18;;16801:49;16882:3;16867:19;;16477:415::o;16897:1322::-;17275:3;17304:1;17337:6;17331:13;17367:36;17393:9;17367:36;:::i;:::-;17422:1;17439:18;;;17466:133;;;;17613:1;17608:356;;;;17432:532;;17466:133;-1:-1:-1;;17499:24:1;;17487:37;;17572:14;;17565:22;17553:35;;17544:45;;;-1:-1:-1;17466:133:1;;17608:356;17639:6;17636:1;17629:17;17669:4;17714:2;17711:1;17701:16;17739:1;17753:165;17767:6;17764:1;17761:13;17753:165;;;17845:14;;17832:11;;;17825:35;17888:16;;;;17782:10;;17753:165;;;17757:3;;;17947:6;17942:3;17938:16;17931:23;;17432:532;;-1:-1:-1;;;17980:3:1;17973:16;18020:6;18014:13;17998:29;;18036:77;18104:8;18099:2;18094:3;18090:12;18083:4;18075:6;18071:17;18036:77;:::i;:::-;-1:-1:-1;;;18132:18:1;;;;18166:11;;;18159:28;;;;18211:1;18203:10;;16897:1322;-1:-1:-1;;;;;16897:1322:1:o;18224:280::-;18323:6;18376:2;18364:9;18355:7;18351:23;18347:32;18344:52;;;18392:1;18389;18382:12;18344:52;18424:9;18418:16;18443:31;18468:5;18443:31;:::i;20148:200::-;-1:-1:-1;;;;;20284:10:1;;;20272;;;20268:27;;20307:12;;;20304:38;;;20322:18;;:::i;:::-;20304:38;20148:200;;;;:::o;20353:197::-;-1:-1:-1;;;;;20475:10:1;;;20487;;;20471:27;;20510:11;;;20507:37;;;20524:18;;:::i;20555:127::-;20616:10;20611:3;20607:20;20604:1;20597:31;20647:4;20644:1;20637:15;20671:4;20668:1;20661:15;20687:120;20727:1;20753;20743:35;;20758:18;;:::i;:::-;-1:-1:-1;20792:9:1;;20687:120::o;21223:128::-;21290:9;;;21311:11;;;21308:37;;;21325:18;;:::i;21356:136::-;21395:3;21423:5;21413:39;;21432:18;;:::i;:::-;-1:-1:-1;;;21468:18:1;;21356:136::o;21913:489::-;-1:-1:-1;;;;;22182:15:1;;;22164:34;;22234:15;;22229:2;22214:18;;22207:43;22281:2;22266:18;;22259:34;;;22329:3;22324:2;22309:18;;22302:31;;;22107:4;;22350:46;;22376:19;;22368:6;22350:46;:::i;:::-;22342:54;21913:489;-1:-1:-1;;;;;;21913:489:1:o;22407:249::-;22476:6;22529:2;22517:9;22508:7;22504:23;22500:32;22497:52;;;22545:1;22542;22535:12;22497:52;22577:9;22571:16;22596:30;22620:5;22596:30;:::i;22661:112::-;22693:1;22719;22709:35;;22724:18;;:::i;:::-;-1:-1:-1;22758:9:1;;22661:112::o;22778:127::-;22839:10;22834:3;22830:20;22827:1;22820:31;22870:4;22867:1;22860:15;22894:4;22891:1;22884:15
Swarm Source
ipfs://749424b2e45dd2a58e897c56a6c4a860d85fbebacfb0c855def164576d7664fd
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.