Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
• interface IERC721Receiver
•    - function onERC721Received(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
• interface IERC721Metadata is IERC721
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
•  contract ERC721 is Context, ERC165 ...
•    - function supportsInterface(bytes4 int ...
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function name()
•    - function symbol()
•    - function tokenURI(uint256 tokenId)
•    - function _baseURI()
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function transferFrom(
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function _safeTransfer(
•    - function _exists(uint256 tokenId)
•    - function _isApprovedOrOwner(address s ...
•    - function _safeMint(address to, uint25 ...
•    - function _safeMint(
•    - function _mint(address to, uint256 to ...
•    - function _burn(uint256 tokenId)
•    - function _transfer(
•    - function _approve(address to, uint256 ...
•    - function _checkOnERC721Received(
•    - function _beforeTokenTransfer(
•    - function supportsInterface(bytes4 int ...
•    - function tokenOfOwnerByIndex(address ...
•    - function totalSupply()
•    - function tokenByIndex(uint256 index)
•    - function _beforeTokenTransfer(
•    - function _addTokenToOwnerEnumeration( ...
•    - function _addTokenToAllTokensEnumerat ...
•    - function _removeTokenFromOwnerEnumera ...
•    - function _removeTokenFromAllTokensEnu ...
•  contract WastedWhales is ERC721Enu ...
•    - function mintWhale(uint256 num)
•    - function mintWhaleWL(uint256 num, str ...
•    - function walletOfOwner(address _owner ...
•    - function setPrice(uint256 _newPrice)
•    - function _baseURI()
•    - function setBaseURI(string memory bas ...
•    - function getPrice()
•    - function whitelist(string memory addr ...
•    - function giveAway(address _to, uint25 ...
•    - function pause(bool val)
•    - function wlPause(bool val)
•    - function withdrawAll()
•  contract WastedWhalesDispensary is ... *
•    - function _getTotalEther()
•    - function _getTotalEtherOwed(address a ...
•    - function _getTotalEtherOwedPerWhale()
•    - function _getTotalEtherClaimed(addres ...
•    - function _getRewardsForAccount(addres ...
•    - function claimRewards()
•    - function deposit()
•    - function withdrawAll()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-01-22
*/

// SPDX-License-Identifier: MIT
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);
	}
}

/**
 * @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);
}

/**
 * @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);
			}
		}
	}
}

/**
 * @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;
	}
}

/**
 * @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);
	}
}


/**
 * @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);
}

/**
 * @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;
	}
}


/**
 * @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;
}

/**
 * @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);
}

/**
 * @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);
}


/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
	using Address for address;
	using Strings for uint256;

	// Token name
	string private _name;

	// Token symbol
	string private _symbol;

	// Mapping from token ID to owner address
	mapping(uint256 => address) private _owners;

	// Mapping owner address to token count
	mapping(address => uint256) private _balances;

	// Mapping from token ID to approved address
	mapping(uint256 => address) private _tokenApprovals;

	// Mapping from owner to operator approvals
	mapping(address => mapping(address => bool)) private _operatorApprovals;

	/**
	 * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
	 */
	constructor(string memory name_, string memory symbol_) {
		_name = name_;
		_symbol = symbol_;
	}

	/**
	 * @dev See {IERC165-supportsInterface}.
	 */
	function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
		return
			interfaceId == type(IERC721).interfaceId ||
			interfaceId == type(IERC721Metadata).interfaceId ||
			super.supportsInterface(interfaceId);
	}

	/**
	 * @dev See {IERC721-balanceOf}.
	 */
	function balanceOf(address owner) public view virtual override returns (uint256) {
		require(owner != address(0), "ERC721: balance query for the zero address");
		return _balances[owner];
	}

	/**
	 * @dev See {IERC721-ownerOf}.
	 */
	function ownerOf(uint256 tokenId) public view virtual override returns (address) {
		address owner = _owners[tokenId];
		require(owner != address(0), "ERC721: owner query for nonexistent token");
		return owner;
	}

	/**
	 * @dev See {IERC721Metadata-name}.
	 */
	function name() public view virtual override returns (string memory) {
		return _name;
	}

	/**
	 * @dev See {IERC721Metadata-symbol}.
	 */
	function symbol() public view virtual override returns (string memory) {
		return _symbol;
	}

	/**
	 * @dev See {IERC721Metadata-tokenURI}.
	 */
	function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
		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 virtual override {
		address owner = ERC721.ownerOf(tokenId);
		require(to != owner, "ERC721: approval to current owner");

		require(
			_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
			"ERC721: approve caller is not owner nor approved for all"
		);

		_approve(to, tokenId);
	}

	/**
	 * @dev See {IERC721-getApproved}.
	 */
	function getApproved(uint256 tokenId) public view virtual override returns (address) {
		require(_exists(tokenId), "ERC721: approved query for nonexistent token");

		return _tokenApprovals[tokenId];
	}

	/**
	 * @dev See {IERC721-setApprovalForAll}.
	 */
	function setApprovalForAll(address operator, bool approved) public virtual override {
		require(operator != _msgSender(), "ERC721: approve to caller");

		_operatorApprovals[_msgSender()][operator] = approved;
		emit ApprovalForAll(_msgSender(), operator, approved);
	}

	/**
	 * @dev See {IERC721-isApprovedForAll}.
	 */
	function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
		return _operatorApprovals[owner][operator];
	}

	/**
	 * @dev See {IERC721-transferFrom}.
	 */
	function transferFrom(
		address from,
		address to,
		uint256 tokenId
	) public virtual override {
		//solhint-disable-next-line max-line-length
		require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

		_transfer(from, to, tokenId);
	}

	/**
	 * @dev See {IERC721-safeTransferFrom}.
	 */
	function safeTransferFrom(
		address from,
		address to,
		uint256 tokenId
	) public virtual override {
		safeTransferFrom(from, to, tokenId, "");
	}

	/**
	 * @dev See {IERC721-safeTransferFrom}.
	 */
	function safeTransferFrom(
		address from,
		address to,
		uint256 tokenId,
		bytes memory _data
	) public virtual override {
		require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
		_safeTransfer(from, to, tokenId, _data);
	}

	/**
	 * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
	 * are aware of the ERC721 protocol to prevent tokens from being forever locked.
	 *
	 * `_data` is additional data, it has no specified format and it is sent in call to `to`.
	 *
	 * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
	 * implement alternative mechanisms to perform token transfer, such as signature-based.
	 *
	 * Requirements:
	 *
	 * - `from` cannot be the zero address.
	 * - `to` cannot be the zero address.
	 * - `tokenId` token must exist and be owned by `from`.
	 * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
	 *
	 * Emits a {Transfer} event.
	 */
	function _safeTransfer(
		address from,
		address to,
		uint256 tokenId,
		bytes memory _data
	) internal virtual {
		_transfer(from, to, tokenId);
		require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
	}

	/**
	 * @dev Returns whether `tokenId` exists.
	 *
	 * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
	 *
	 * Tokens start existing when they are minted (`_mint`),
	 * and stop existing when they are burned (`_burn`).
	 */
	function _exists(uint256 tokenId) internal view virtual returns (bool) {
		return _owners[tokenId] != address(0);
	}

	/**
	 * @dev Returns whether `spender` is allowed to manage `tokenId`.
	 *
	 * Requirements:
	 *
	 * - `tokenId` must exist.
	 */
	function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
		require(_exists(tokenId), "ERC721: operator query for nonexistent token");
		address owner = ERC721.ownerOf(tokenId);
		return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
	}

	/**
	 * @dev Safely mints `tokenId` and transfers it to `to`.
	 *
	 * Requirements:
	 *
	 * - `tokenId` must not exist.
	 * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
	 *
	 * Emits a {Transfer} event.
	 */
	function _safeMint(address to, uint256 tokenId) internal virtual {
		_safeMint(to, tokenId, "");
	}

	/**
	 * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
	 * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
	 */
	function _safeMint(
		address to,
		uint256 tokenId,
		bytes memory _data
	) internal virtual {
		_mint(to, tokenId);
		require(
			_checkOnERC721Received(address(0), to, tokenId, _data),
			"ERC721: transfer to non ERC721Receiver implementer"
		);
	}

	/**
	 * @dev Mints `tokenId` and transfers it to `to`.
	 *
	 * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
	 *
	 * Requirements:
	 *
	 * - `tokenId` must not exist.
	 * - `to` cannot be the zero address.
	 *
	 * Emits a {Transfer} event.
	 */
	function _mint(address to, uint256 tokenId) internal virtual {
		require(to != address(0), "ERC721: mint to the zero address");
		require(!_exists(tokenId), "ERC721: token already minted");

		_beforeTokenTransfer(address(0), to, tokenId);

		_balances[to] += 1;
		_owners[tokenId] = to;

		emit Transfer(address(0), to, tokenId);
	}

	/**
	 * @dev Destroys `tokenId`.
	 * The approval is cleared when the token is burned.
	 *
	 * Requirements:
	 *
	 * - `tokenId` must exist.
	 *
	 * Emits a {Transfer} event.
	 */
	function _burn(uint256 tokenId) internal virtual {
		address owner = ERC721.ownerOf(tokenId);

		_beforeTokenTransfer(owner, address(0), tokenId);

		// Clear approvals
		_approve(address(0), tokenId);

		_balances[owner] -= 1;
		delete _owners[tokenId];

		emit Transfer(owner, address(0), tokenId);
	}

	/**
	 * @dev Transfers `tokenId` from `from` to `to`.
	 *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
	 *
	 * Requirements:
	 *
	 * - `to` cannot be the zero address.
	 * - `tokenId` token must be owned by `from`.
	 *
	 * Emits a {Transfer} event.
	 */
	function _transfer(
		address from,
		address to,
		uint256 tokenId
	) internal virtual {
		require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
		require(to != address(0), "ERC721: transfer to the zero address");

		_beforeTokenTransfer(from, to, tokenId);

		// Clear approvals from the previous owner
		_approve(address(0), tokenId);

		_balances[from] -= 1;
		_balances[to] += 1;
		_owners[tokenId] = to;

		emit Transfer(from, to, tokenId);
	}

	/**
	 * @dev Approve `to` to operate on `tokenId`
	 *
	 * Emits a {Approval} event.
	 */
	function _approve(address to, uint256 tokenId) internal virtual {
		_tokenApprovals[tokenId] = to;
		emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
	}

	/**
	 * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
	 * The call is not executed if the target address is not a contract.
	 *
	 * @param from address representing the previous owner of the given token ID
	 * @param to target address that will receive the tokens
	 * @param tokenId uint256 ID of the token to be transferred
	 * @param _data bytes optional data to send along with the call
	 * @return bool whether the call correctly returned the expected magic value
	 */
	function _checkOnERC721Received(
		address from,
		address to,
		uint256 tokenId,
		bytes memory _data
	) private returns (bool) {
		if (to.isContract()) {
			try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
				return retval == IERC721Receiver.onERC721Received.selector;
			} catch (bytes memory reason) {
				if (reason.length == 0) {
					revert("ERC721: transfer to non ERC721Receiver implementer");
				} else {
					assembly {
						revert(add(32, reason), mload(reason))
					}
				}
			}
		} else {
			return true;
		}
	}

	/**
	 * @dev Hook that is called before any token transfer. This includes minting
	 * and burning.
	 *
	 * Calling conditions:
	 *
	 * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
	 * transferred to `to`.
	 * - When `from` is zero, `tokenId` will be minted for `to`.
	 * - When `to` is zero, ``from``'s `tokenId` will be burned.
	 * - `from` and `to` are never both zero.
	 *
	 * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
	 */
	function _beforeTokenTransfer(
		address from,
		address to,
		uint256 tokenId
	) internal virtual {}
}

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
	// Mapping from owner to list of owned token IDs
	mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

	// Mapping from token ID to index of the owner tokens list
	mapping(uint256 => uint256) private _ownedTokensIndex;

	// Array with all token ids, used for enumeration
	uint256[] private _allTokens;

	// Mapping from token id to position in the allTokens array
	mapping(uint256 => uint256) private _allTokensIndex;

	/**
	 * @dev See {IERC165-supportsInterface}.
	 */
	function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
		return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
	}

	/**
	 * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
	 */
	function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
		require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
		return _ownedTokens[owner][index];
	}

	/**
	 * @dev See {IERC721Enumerable-totalSupply}.
	 */
	function totalSupply() public view virtual override returns (uint256) {
		return _allTokens.length;
	}

	/**
	 * @dev See {IERC721Enumerable-tokenByIndex}.
	 */
	function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
		require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
		return _allTokens[index];
	}

	/**
	 * @dev Hook that is called before any token transfer. This includes minting
	 * and burning.
	 *
	 * Calling conditions:
	 *
	 * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
	 * transferred to `to`.
	 * - When `from` is zero, `tokenId` will be minted for `to`.
	 * - When `to` is zero, ``from``'s `tokenId` will be burned.
	 * - `from` cannot be the zero address.
	 * - `to` cannot be the zero address.
	 *
	 * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
	 */
	function _beforeTokenTransfer(
		address from,
		address to,
		uint256 tokenId
	) internal virtual override {
		super._beforeTokenTransfer(from, to, tokenId);

		if (from == address(0)) {
			_addTokenToAllTokensEnumeration(tokenId);
		} else if (from != to) {
			_removeTokenFromOwnerEnumeration(from, tokenId);
		}
		if (to == address(0)) {
			_removeTokenFromAllTokensEnumeration(tokenId);
		} else if (to != from) {
			_addTokenToOwnerEnumeration(to, tokenId);
		}
	}

	/**
	 * @dev Private function to add a token to this extension's ownership-tracking data structures.
	 * @param to address representing the new owner of the given token ID
	 * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
	 */
	function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
		uint256 length = ERC721.balanceOf(to);
		_ownedTokens[to][length] = tokenId;
		_ownedTokensIndex[tokenId] = length;
	}

	/**
	 * @dev Private function to add a token to this extension's token tracking data structures.
	 * @param tokenId uint256 ID of the token to be added to the tokens list
	 */
	function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
		_allTokensIndex[tokenId] = _allTokens.length;
		_allTokens.push(tokenId);
	}

	/**
	 * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
	 * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
	 * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
	 * This has O(1) time complexity, but alters the order of the _ownedTokens array.
	 * @param from address representing the previous owner of the given token ID
	 * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
	 */
	function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
		// To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
		// then delete the last slot (swap and pop).

		uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
		uint256 tokenIndex = _ownedTokensIndex[tokenId];

		// When the token to delete is the last token, the swap operation is unnecessary
		if (tokenIndex != lastTokenIndex) {
			uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

			_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
			_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
		}

		// This also deletes the contents at the last position of the array
		delete _ownedTokensIndex[tokenId];
		delete _ownedTokens[from][lastTokenIndex];
	}

	/**
	 * @dev Private function to remove a token from this extension's token tracking data structures.
	 * This has O(1) time complexity, but alters the order of the _allTokens array.
	 * @param tokenId uint256 ID of the token to be removed from the tokens list
	 */
	function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
		// To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
		// then delete the last slot (swap and pop).

		uint256 lastTokenIndex = _allTokens.length - 1;
		uint256 tokenIndex = _allTokensIndex[tokenId];

		// When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
		// rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
		// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
		uint256 lastTokenId = _allTokens[lastTokenIndex];

		_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
		_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

		// This also deletes the contents at the last position of the array
		delete _allTokensIndex[tokenId];
		_allTokens.pop();
	}
}

contract WastedWhales is ERC721Enumerable, Ownable {

	using Strings for uint256;

	string _baseTokenURI;
	uint256 private _reserved = 14;
	uint256 private _price = 0.069 ether;
	bool public _paused = true;
	bool public _wlPaused = true;
	string private _uri;

	// withdraw address
	address t1;

	constructor(string memory baseURI) ERC721("WastedWhales", "WW")  {
		setBaseURI(baseURI);
		t1 = msg.sender;
	}

	function mintWhale(uint256 num) public payable {
		uint256 supply = totalSupply();
		require( !_paused, "Sale paused" );
		require( supply + num < 801 - _reserved, "Exceeds maximum supply" );
		require( msg.value >= _price * num, "Incorrect ether amount" );

		for(uint256 i; i < num; i++){
			_safeMint(msg.sender, supply + i);
		}
	}

	function mintWhaleWL(uint256 num, string memory id) public payable {
		uint256 supply = totalSupply();
		require( !_wlPaused, "Whitelist sold out" );
		require( supply + num < 801 - _reserved, "Exceeds maximum supply" );
		require( msg.value >= _price * num, "Incorrect ether amount" );
		require( keccak256(bytes(id)) == keccak256(bytes(_uri)), "Not whitelisted" );

		for(uint256 i; i < num; i++){
			_safeMint(msg.sender, supply + i);
		}
	}

	function walletOfOwner(address _owner) public view returns(uint256[] memory) {
		uint256 tokenCount = balanceOf(_owner);

		uint256[] memory tokensId = new uint256[](tokenCount);
		for(uint256 i; i < tokenCount; i++){
			tokensId[i] = tokenOfOwnerByIndex(_owner, i);
		}
		return tokensId;
	}

	// Just in case Eth does some crazy stuff
	function setPrice(uint256 _newPrice) public onlyOwner {
		_price = _newPrice;
	}

	function _baseURI() internal view virtual override returns (string memory) {
		return _baseTokenURI;
	}

	function setBaseURI(string memory baseURI) public onlyOwner {
		_baseTokenURI = baseURI;
	}

	function getPrice() public view returns (uint256) {
		return _price;
	}

	function whitelist(string memory addr) public onlyOwner {
		_uri = addr;
	}

	function giveAway(address _to, uint256 _amount) external onlyOwner {
		require( _amount <= _reserved, "Amount exceeds reserved amount for giveaways" );
		uint256 supply = totalSupply();
		for(uint256 i; i < _amount; i++){
			_safeMint( _to, supply + i );
		}
		_reserved -= _amount;
	}

	function pause(bool val) public onlyOwner {
		_paused = val;
	}

	function wlPause(bool val) public onlyOwner {
		_wlPaused = val;
	}

	function withdrawAll() public onlyOwner {
		address payable _to = payable(t1);
		uint256 _balance = address(this).balance;
		_to.transfer(_balance);
	}
}


contract WastedWhalesDispensary is Ownable {

	WastedWhales public token;
	mapping(uint256 => uint256) private _etherClaimedByWhale;
	uint256 private _allTimeEthClaimed;

	constructor(address _tokenAddress) public {
		token = WastedWhales(_tokenAddress);
	}

	/**
	 * @dev gets total ether accrued.
	 */
	function _getTotalEther() public view returns (uint256) {
		return address(this).balance + _allTimeEthClaimed;
	}

	/**
	 * @dev gets total ether owed to to the whales in account.
	 */
	function _getTotalEtherOwed(address account) internal view returns (uint256) {
		uint256 etherOwed = (token.balanceOf(account) * _getTotalEther())/800;
		return etherOwed;
	}

	/**
	 * @dev gets total ether owed per whale.
	 */
	function _getTotalEtherOwedPerWhale() internal view returns (uint256) {
		uint256 etherOwed = (_getTotalEther()/800);
		return etherOwed;
	}

	/**
	 * @dev gets total ether claimed for whales in account.
	 */
	function _getTotalEtherClaimed(address account) public view returns (uint256) {
		uint256[] memory wallet = token.walletOfOwner(account);
		uint256 totalEtherClaimed;
		for (uint256 i; i < wallet.length; i++) {
			totalEtherClaimed += _etherClaimedByWhale[wallet[i]];
		}
		return totalEtherClaimed;
	}

	/**
	 * @dev gets current rewards for account.
	 */
	function _getRewardsForAccount(address account) public view returns (uint256) {
		uint256 rewards = _getTotalEtherOwed(account) - _getTotalEtherClaimed(account);
		return rewards;
	}

	/**
	 * @dev claims rewards for account.
	 */
	function claimRewards() public {
		address account = msg.sender;
		uint256[] memory wallet = token.walletOfOwner(account);
		uint256 totalEtherOwed = _getTotalEtherOwed(account);
		uint256 _totalEtherOwedPerWhale = _getTotalEtherOwedPerWhale();

		uint256 totalEtherClaimed;
		for (uint256 i; i < wallet.length; i++) {
			totalEtherClaimed += _etherClaimedByWhale[wallet[i]];
			uint256 diff = _totalEtherOwedPerWhale - _etherClaimedByWhale[wallet[i]];
			_etherClaimedByWhale[wallet[i]] += diff;
		}

		uint256 rewards = totalEtherOwed - totalEtherClaimed;
		if (rewards > address(this).balance) {
			rewards = address(this).balance;
		}
		_allTimeEthClaimed += rewards;

		address payable _to = payable(account);
		_to.transfer(rewards);
	}

	/**
	 * @dev deposit ETH
	 */
	function deposit() public payable {
		require(msg.value > 0, "Can't deposit zero ether.");
	}	

	/**
	 * @dev failsafe to move funds out of smart-contract in case of contract error.
	 */
	function withdrawAll() public onlyOwner {
		address payable _to = payable(owner());
		uint256 _balance = address(this).balance;
		_to.transfer(_balance);
	}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"_getRewardsForAccount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_getTotalEther","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"_getTotalEtherClaimed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract WastedWhales","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040523480156200001157600080fd5b506040516200132638038062001326833981810160405281019062000037919062000182565b620000576200004b6200009f60201b60201c565b620000a760201b60201c565b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050620001fc565b600033905090565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000815190506200017c81620001e2565b92915050565b6000602082840312156200019557600080fd5b6000620001a5848285016200016b565b91505092915050565b6000620001bb82620001c2565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b620001ed81620001ae565b8114620001f957600080fd5b50565b61111a806200020c6000396000f3fe6080604052600436106100915760003560e01c80638da5cb5b116100595780638da5cb5b14610143578063cb16c5a41461016e578063d0e30db0146101ab578063f2fde38b146101b5578063fc0c546a146101de57610091565b8063372500ab1461009657806341d0eed1146100ad578063715018a6146100d8578063853828b6146100ef578063863cb01f14610106575b600080fd5b3480156100a257600080fd5b506100ab610209565b005b3480156100b957600080fd5b506100c26104b5565b6040516100cf9190610de2565b60405180910390f35b3480156100e457600080fd5b506100ed6104ca565b005b3480156100fb57600080fd5b50610104610552565b005b34801561011257600080fd5b5061012d60048036038101906101289190610ba6565b61062a565b60405161013a9190610de2565b60405180910390f35b34801561014f57600080fd5b5061015861076b565b6040516101659190610d4c565b60405180910390f35b34801561017a57600080fd5b5061019560048036038101906101909190610ba6565b610794565b6040516101a29190610de2565b60405180910390f35b6101b36107be565b005b3480156101c157600080fd5b506101dc60048036038101906101d79190610ba6565b610803565b005b3480156101ea57600080fd5b506101f36108fb565b6040516102009190610d67565b60405180910390f35b60003390506000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663438b6300836040518263ffffffff1660e01b815260040161026b9190610d4c565b60006040518083038186803b15801561028357600080fd5b505afa158015610297573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052508101906102c09190610bcf565b905060006102cd83610921565b905060006102d96109f9565b90506000805b845181101561042a5760026000868381518110610325577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b6020026020010151815260200190815260200160002054826103479190610e6b565b9150600060026000878481518110610388577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b6020026020010151815260200190815260200160002054846103aa9190610f4c565b905080600260008885815181106103ea577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60200260200101518152602001908152602001600020600082825461040f9190610e6b565b9250508190555050808061042290610fe0565b9150506102df565b50600081846104399190610f4c565b905047811115610447574790505b80600360008282546104599190610e6b565b9250508190555060008690508073ffffffffffffffffffffffffffffffffffffffff166108fc839081150290604051600060405180830381858888f193505050501580156104ab573d6000803e3d6000fd5b5050505050505050565b6000600354476104c59190610e6b565b905090565b6104d2610a1a565b73ffffffffffffffffffffffffffffffffffffffff166104f061076b565b73ffffffffffffffffffffffffffffffffffffffff1614610546576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161053d90610da2565b60405180910390fd5b6105506000610a22565b565b61055a610a1a565b73ffffffffffffffffffffffffffffffffffffffff1661057861076b565b73ffffffffffffffffffffffffffffffffffffffff16146105ce576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105c590610da2565b60405180910390fd5b60006105d861076b565b905060004790508173ffffffffffffffffffffffffffffffffffffffff166108fc829081150290604051600060405180830381858888f19350505050158015610625573d6000803e3d6000fd5b505050565b600080600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663438b6300846040518263ffffffff1660e01b81526004016106889190610d4c565b60006040518083038186803b1580156106a057600080fd5b505afa1580156106b4573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052508101906106dd9190610bcf565b90506000805b82518110156107605760026000848381518110610729577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60200260200101518152602001908152602001600020548261074b9190610e6b565b9150808061075890610fe0565b9150506106e3565b508092505050919050565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6000806107a08361062a565b6107a984610921565b6107b39190610f4c565b905080915050919050565b60003411610801576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107f890610dc2565b60405180910390fd5b565b61080b610a1a565b73ffffffffffffffffffffffffffffffffffffffff1661082961076b565b73ffffffffffffffffffffffffffffffffffffffff161461087f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161087690610da2565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156108ef576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108e690610d82565b60405180910390fd5b6108f881610a22565b50565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008061032061092f6104b5565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231866040518263ffffffff1660e01b815260040161098a9190610d4c565b60206040518083038186803b1580156109a257600080fd5b505afa1580156109b6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109da9190610c10565b6109e49190610ef2565b6109ee9190610ec1565b905080915050919050565b600080610320610a076104b5565b610a119190610ec1565b90508091505090565b600033905090565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000610af9610af484610e2e565b610dfd565b90508083825260208201905082856020860282011115610b1857600080fd5b60005b85811015610b485781610b2e8882610b91565b845260208401935060208301925050600181019050610b1b565b5050509392505050565b600081359050610b61816110b6565b92915050565b600082601f830112610b7857600080fd5b8151610b88848260208601610ae6565b91505092915050565b600081519050610ba0816110cd565b92915050565b600060208284031215610bb857600080fd5b6000610bc684828501610b52565b91505092915050565b600060208284031215610be157600080fd5b600082015167ffffffffffffffff811115610bfb57600080fd5b610c0784828501610b67565b91505092915050565b600060208284031215610c2257600080fd5b6000610c3084828501610b91565b91505092915050565b610c4281610f80565b82525050565b610c5181610fbc565b82525050565b6000610c64602683610e5a565b91507f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008301527f64647265737300000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000610cca602083610e5a565b91507f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65726000830152602082019050919050565b6000610d0a601983610e5a565b91507f43616e2774206465706f736974207a65726f2065746865722e000000000000006000830152602082019050919050565b610d4681610fb2565b82525050565b6000602082019050610d616000830184610c39565b92915050565b6000602082019050610d7c6000830184610c48565b92915050565b60006020820190508181036000830152610d9b81610c57565b9050919050565b60006020820190508181036000830152610dbb81610cbd565b9050919050565b60006020820190508181036000830152610ddb81610cfd565b9050919050565b6000602082019050610df76000830184610d3d565b92915050565b6000604051905081810181811067ffffffffffffffff82111715610e2457610e23611087565b5b8060405250919050565b600067ffffffffffffffff821115610e4957610e48611087565b5b602082029050602081019050919050565b600082825260208201905092915050565b6000610e7682610fb2565b9150610e8183610fb2565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115610eb657610eb5611029565b5b828201905092915050565b6000610ecc82610fb2565b9150610ed783610fb2565b925082610ee757610ee6611058565b5b828204905092915050565b6000610efd82610fb2565b9150610f0883610fb2565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615610f4157610f40611029565b5b828202905092915050565b6000610f5782610fb2565b9150610f6283610fb2565b925082821015610f7557610f74611029565b5b828203905092915050565b6000610f8b82610f92565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610fc782610fce565b9050919050565b6000610fd982610f92565b9050919050565b6000610feb82610fb2565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82141561101e5761101d611029565b5b600182019050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6110bf81610f80565b81146110ca57600080fd5b50565b6110d681610fb2565b81146110e157600080fd5b5056fea2646970667358221220f61def94e061a4f7a69186ae40186eb9ce3778ae7a42d12cae259135ee25bee064736f6c63430008000033000000000000000000000000757f0e9e8a4f84650ae94caab516a00fd7fb2961

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

000000000000000000000000757f0e9e8a4f84650ae94caab516a00fd7fb2961

-----Decoded View---------------
Arg [0] : _tokenAddress (address): 0x757F0e9E8a4F84650ae94caAB516a00fD7Fb2961

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000757f0e9e8a4f84650ae94caab516a00fd7fb2961

40936:2736:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42512:763;;;;;;;;;;;;;:::i;:::-;;41254:115;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11952:94;;;;;;;;;;;;;:::i;:::-;;43509:160;;;;;;;;;;;;;:::i;:::-;;41902:309;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;11361:78;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42272:185;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43314:95;;;:::i;:::-;;12186:186;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40985:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42512:763;42548:15;42566:10;42548:28;;42581:23;42607:5;;;;;;;;;;;:19;;;42627:7;42607:28;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42581:54;;42640:22;42665:27;42684:7;42665:18;:27::i;:::-;42640:52;;42697:31;42731:28;:26;:28::i;:::-;42697:62;;42766:25;42801:9;42796:227;42816:6;:13;42812:1;:17;42796:227;;;42863:20;:31;42884:6;42891:1;42884:9;;;;;;;;;;;;;;;;;;;;;;42863:31;;;;;;;;;;;;42842:52;;;;;:::i;:::-;;;42900:12;42941:20;:31;42962:6;42969:1;42962:9;;;;;;;;;;;;;;;;;;;;;;42941:31;;;;;;;;;;;;42915:23;:57;;;;:::i;:::-;42900:72;;43013:4;42978:20;:31;42999:6;43006:1;42999:9;;;;;;;;;;;;;;;;;;;;;;42978:31;;;;;;;;;;;;:39;;;;;;;:::i;:::-;;;;;;;;42796:227;42831:3;;;;;:::i;:::-;;;;42796:227;;;;43029:15;43064:17;43047:14;:34;;;;:::i;:::-;43029:52;;43100:21;43090:7;:31;43086:80;;;43139:21;43129:31;;43086:80;43192:7;43170:18;;:29;;;;;;;:::i;:::-;;;;;;;;43206:19;43236:7;43206:38;;43249:3;:12;;:21;43262:7;43249:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42512:763;;;;;;;:::o;41254:115::-;41301:7;41346:18;;41322:21;:42;;;;:::i;:::-;41315:49;;41254:115;:::o;11952:94::-;11565:12;:10;:12::i;:::-;11554:23;;:7;:5;:7::i;:::-;:23;;;11546:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;12011:30:::1;12038:1;12011:18;:30::i;:::-;11952:94::o:0;43509:160::-;11565:12;:10;:12::i;:::-;11554:23;;:7;:5;:7::i;:::-;:23;;;11546:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;43554:19:::1;43584:7;:5;:7::i;:::-;43554:38;;43597:16;43616:21;43597:40;;43642:3;:12;;:22;43655:8;43642:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;11619:1;;43509:160::o:0;41902:309::-;41971:7;41985:23;42011:5;;;;;;;;;;;:19;;;42031:7;42011:28;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41985:54;;42044:25;42079:9;42074:104;42094:6;:13;42090:1;:17;42074:104;;;42141:20;:31;42162:6;42169:1;42162:9;;;;;;;;;;;;;;;;;;;;;;42141:31;;;;;;;;;;;;42120:52;;;;;:::i;:::-;;;42109:3;;;;;:::i;:::-;;;;42074:104;;;;42189:17;42182:24;;;;41902:309;;;:::o;11361:78::-;11407:7;11428:6;;;;;;;;;;;11421:13;;11361:78;:::o;42272:185::-;42341:7;42355:15;42403:30;42425:7;42403:21;:30::i;:::-;42373:27;42392:7;42373:18;:27::i;:::-;:60;;;;:::i;:::-;42355:78;;42445:7;42438:14;;;42272:185;;;:::o;43314:95::-;43373:1;43361:9;:13;43353:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;43314:95::o;12186:186::-;11565:12;:10;:12::i;:::-;11554:23;;:7;:5;:7::i;:::-;:23;;;11546:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;12289:1:::1;12269:22;;:8;:22;;;;12261:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;12339:28;12358:8;12339:18;:28::i;:::-;12186:186:::0;:::o;40985:25::-;;;;;;;;;;;;;:::o;41447:177::-;41515:7;41529:17;41595:3;41577:16;:14;:16::i;:::-;41550:5;;;;;;;;;;;:15;;;41566:7;41550:24;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:43;;;;:::i;:::-;41549:49;;;;:::i;:::-;41529:69;;41610:9;41603:16;;;41447:177;;;:::o;41684:143::-;41745:7;41759:17;41797:3;41780:16;:14;:16::i;:::-;:20;;;;:::i;:::-;41759:42;;41813:9;41806:16;;;41684:143;:::o;10288:89::-;10341:7;10362:10;10355:17;;10288:89;:::o;12517:170::-;12585:16;12604:6;;;;;;;;;;;12585:25;;12624:8;12615:6;;:17;;;;;;;;;;;;;;;;;;12673:8;12642:40;;12663:8;12642:40;;;;;;;;;;;;12517:170;;:::o;24:644:1:-;;156:80;171:64;228:6;171:64;:::i;:::-;156:80;:::i;:::-;147:89;;256:5;284:6;277:5;270:21;310:4;303:5;299:16;292:23;;335:6;385:3;377:4;369:6;365:17;360:3;356:27;353:36;350:2;;;402:1;399;392:12;350:2;430:1;415:247;440:6;437:1;434:13;415:247;;;507:3;535:48;579:3;567:10;535:48;:::i;:::-;530:3;523:61;613:4;608:3;604:14;597:21;;647:4;642:3;638:14;631:21;;475:187;462:1;459;455:9;450:14;;415:247;;;419:14;137:531;;;;;;;:::o;674:139::-;;758:6;745:20;736:29;;774:33;801:5;774:33;:::i;:::-;726:87;;;;:::o;836:318::-;;967:3;960:4;952:6;948:17;944:27;934:2;;985:1;982;975:12;934:2;1018:6;1012:13;1043:105;1144:3;1136:6;1129:4;1121:6;1117:17;1043:105;:::i;:::-;1034:114;;924:230;;;;;:::o;1160:143::-;;1248:6;1242:13;1233:22;;1264:33;1291:5;1264:33;:::i;:::-;1223:80;;;;:::o;1309:262::-;;1417:2;1405:9;1396:7;1392:23;1388:32;1385:2;;;1433:1;1430;1423:12;1385:2;1476:1;1501:53;1546:7;1537:6;1526:9;1522:22;1501:53;:::i;:::-;1491:63;;1447:117;1375:196;;;;:::o;1577:420::-;;1721:2;1709:9;1700:7;1696:23;1692:32;1689:2;;;1737:1;1734;1727:12;1689:2;1801:1;1790:9;1786:17;1780:24;1831:18;1823:6;1820:30;1817:2;;;1863:1;1860;1853:12;1817:2;1891:89;1972:7;1963:6;1952:9;1948:22;1891:89;:::i;:::-;1881:99;;1751:239;1679:318;;;;:::o;2003:284::-;;2122:2;2110:9;2101:7;2097:23;2093:32;2090:2;;;2138:1;2135;2128:12;2090:2;2181:1;2206:64;2262:7;2253:6;2242:9;2238:22;2206:64;:::i;:::-;2196:74;;2152:128;2080:207;;;;:::o;2293:118::-;2380:24;2398:5;2380:24;:::i;:::-;2375:3;2368:37;2358:53;;:::o;2417:173::-;2525:58;2577:5;2525:58;:::i;:::-;2520:3;2513:71;2503:87;;:::o;2596:370::-;;2759:67;2823:2;2818:3;2759:67;:::i;:::-;2752:74;;2856:34;2852:1;2847:3;2843:11;2836:55;2922:8;2917:2;2912:3;2908:12;2901:30;2957:2;2952:3;2948:12;2941:19;;2742:224;;;:::o;2972:330::-;;3135:67;3199:2;3194:3;3135:67;:::i;:::-;3128:74;;3232:34;3228:1;3223:3;3219:11;3212:55;3293:2;3288:3;3284:12;3277:19;;3118:184;;;:::o;3308:323::-;;3471:67;3535:2;3530:3;3471:67;:::i;:::-;3464:74;;3568:27;3564:1;3559:3;3555:11;3548:48;3622:2;3617:3;3613:12;3606:19;;3454:177;;;:::o;3637:118::-;3724:24;3742:5;3724:24;:::i;:::-;3719:3;3712:37;3702:53;;:::o;3761:222::-;;3892:2;3881:9;3877:18;3869:26;;3905:71;3973:1;3962:9;3958:17;3949:6;3905:71;:::i;:::-;3859:124;;;;:::o;3989:264::-;;4141:2;4130:9;4126:18;4118:26;;4154:92;4243:1;4232:9;4228:17;4219:6;4154:92;:::i;:::-;4108:145;;;;:::o;4259:419::-;;4463:2;4452:9;4448:18;4440:26;;4512:9;4506:4;4502:20;4498:1;4487:9;4483:17;4476:47;4540:131;4666:4;4540:131;:::i;:::-;4532:139;;4430:248;;;:::o;4684:419::-;;4888:2;4877:9;4873:18;4865:26;;4937:9;4931:4;4927:20;4923:1;4912:9;4908:17;4901:47;4965:131;5091:4;4965:131;:::i;:::-;4957:139;;4855:248;;;:::o;5109:419::-;;5313:2;5302:9;5298:18;5290:26;;5362:9;5356:4;5352:20;5348:1;5337:9;5333:17;5326:47;5390:131;5516:4;5390:131;:::i;:::-;5382:139;;5280:248;;;:::o;5534:222::-;;5665:2;5654:9;5650:18;5642:26;;5678:71;5746:1;5735:9;5731:17;5722:6;5678:71;:::i;:::-;5632:124;;;;:::o;5762:283::-;;5828:2;5822:9;5812:19;;5870:4;5862:6;5858:17;5977:6;5965:10;5962:22;5941:18;5929:10;5926:34;5923:62;5920:2;;;5988:18;;:::i;:::-;5920:2;6028:10;6024:2;6017:22;5802:243;;;;:::o;6051:311::-;;6218:18;6210:6;6207:30;6204:2;;;6240:18;;:::i;:::-;6204:2;6290:4;6282:6;6278:17;6270:25;;6350:4;6344;6340:15;6332:23;;6133:229;;;:::o;6368:169::-;;6486:6;6481:3;6474:19;6526:4;6521:3;6517:14;6502:29;;6464:73;;;;:::o;6543:305::-;;6602:20;6620:1;6602:20;:::i;:::-;6597:25;;6636:20;6654:1;6636:20;:::i;:::-;6631:25;;6790:1;6722:66;6718:74;6715:1;6712:81;6709:2;;;6796:18;;:::i;:::-;6709:2;6840:1;6837;6833:9;6826:16;;6587:261;;;;:::o;6854:185::-;;6911:20;6929:1;6911:20;:::i;:::-;6906:25;;6945:20;6963:1;6945:20;:::i;:::-;6940:25;;6984:1;6974:2;;6989:18;;:::i;:::-;6974:2;7031:1;7028;7024:9;7019:14;;6896:143;;;;:::o;7045:348::-;;7108:20;7126:1;7108:20;:::i;:::-;7103:25;;7142:20;7160:1;7142:20;:::i;:::-;7137:25;;7330:1;7262:66;7258:74;7255:1;7252:81;7247:1;7240:9;7233:17;7229:105;7226:2;;;7337:18;;:::i;:::-;7226:2;7385:1;7382;7378:9;7367:20;;7093:300;;;;:::o;7399:191::-;;7459:20;7477:1;7459:20;:::i;:::-;7454:25;;7493:20;7511:1;7493:20;:::i;:::-;7488:25;;7532:1;7529;7526:8;7523:2;;;7537:18;;:::i;:::-;7523:2;7582:1;7579;7575:9;7567:17;;7444:146;;;;:::o;7596:96::-;;7662:24;7680:5;7662:24;:::i;:::-;7651:35;;7641:51;;;:::o;7698:126::-;;7775:42;7768:5;7764:54;7753:65;;7743:81;;;:::o;7830:77::-;;7896:5;7885:16;;7875:32;;;:::o;7913:168::-;;8017:58;8069:5;8017:58;:::i;:::-;8004:71;;7994:87;;;:::o;8087:134::-;;8191:24;8209:5;8191:24;:::i;:::-;8178:37;;8168:53;;;:::o;8227:233::-;;8289:24;8307:5;8289:24;:::i;:::-;8280:33;;8335:66;8328:5;8325:77;8322:2;;;8405:18;;:::i;:::-;8322:2;8452:1;8445:5;8441:13;8434:20;;8270:190;;;:::o;8466:180::-;8514:77;8511:1;8504:88;8611:4;8608:1;8601:15;8635:4;8632:1;8625:15;8652:180;8700:77;8697:1;8690:88;8797:4;8794:1;8787:15;8821:4;8818:1;8811:15;8838:180;8886:77;8883:1;8876:88;8983:4;8980:1;8973:15;9007:4;9004:1;8997:15;9024:122;9097:24;9115:5;9097:24;:::i;:::-;9090:5;9087:35;9077:2;;9136:1;9133;9126:12;9077:2;9067:79;:::o;9152:122::-;9225:24;9243:5;9225:24;:::i;:::-;9218:5;9215:35;9205:2;;9264:1;9261;9254:12;9205:2;9195:79;:::o

ipfs://f61def94e061a4f7a69186ae40186eb9ce3778ae7a42d12cae259135ee25bee0