ERC-721
Overview
Max Total Supply
53 GHOST
Holders
22
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Balance
1 GHOSTLoading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
Ghosty
Compiler Version
v0.8.9+commit.e5eed63a
Contract Source Code (Solidity)
/** *Submitted for verification at ftmscan.com on 2021-10-31 */ // Sources flattened with hardhat v2.6.6 https://hardhat.org // File contracts/Interfaces/IUniswapV2Router.sol // SPDX-License-Identifier: MIT pragma solidity ^0.8.9; interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } // pragma solidity >=0.6.2; interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } // File @openzeppelin/contracts/utils/introspection/[email protected] 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/token/ERC721/[email protected] 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/[email protected] 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/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File @openzeppelin/contracts/utils/[email protected] 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/utils/[email protected] pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File @openzeppelin/contracts/utils/[email protected] 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/introspection/[email protected] 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/[email protected] pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: 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 {} } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] 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/[email protected] pragma solidity ^0.8.0; /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds * enumerability of all the token ids in the contract as well as all token ids owned by each * account. */ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable { // Mapping from owner to list of owned token IDs mapping(address => mapping(uint256 => uint256)) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds"); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds"); return _allTokens[index]; } /** * @dev 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(); } } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @dev ERC721 token with storage based token URI management. */ abstract contract ERC721URIStorage is ERC721 { using Strings for uint256; // Optional mapping for token URIs mapping(uint256 => string) private _tokenURIs; /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token"); string memory _tokenURI = _tokenURIs[tokenId]; string memory base = _baseURI(); // If there is no base URI, return the token URI. if (bytes(base).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(base, _tokenURI)); } return super.tokenURI(tokenId); } /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } /** * @dev 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 override { super._burn(tokenId); if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } } } // File @openzeppelin/contracts/access/[email protected] 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() { _setOwner(_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 { _setOwner(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"); _setOwner(newOwner); } function _setOwner(address newOwner) private { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File @openzeppelin/contracts/security/[email protected] pragma solidity ^0.8.0; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor() { _paused = false; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } } // File @openzeppelin/contracts/utils/math/[email protected] 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 no longer needed starting with Solidity 0.8. 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/token/ERC20/[email protected] 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 contracts/Ghosty.sol pragma solidity ^0.8.9; contract Ghosty is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable, Pausable { using Strings for uint256; using SafeMath for uint256; uint256 public immutable maxSupply = 500; uint256 private index; string private baseURI; mapping(address => uint256) public rewardDebt; IUniswapV2Router01 public router; address public bGEIST; uint256 public startTime; uint256 public accRewardsPerShare; // multiplied by 1e12 mapping (uint256 => uint256) private prices; constructor(address _router, address _bGEIST) ERC721("Ghosty", "GHOST") { require(Address.isContract(_router), "Router not a contract"); require(Address.isContract(_bGEIST), "BabyGeist not a contract"); _pause(); startTime = block.timestamp; baseURI = "https://api.babygeist.finance/nft/ghosty/tokens/"; router = IUniswapV2Router01(_router); bGEIST = _bGEIST; for (uint256 i = 0; i < 6; i = i.add(1)) { prices[i.add(1)] = 0.1e18; } } function mint() external payable whenNotPaused { require(block.timestamp >= startTime, "Not started"); uint256 price = nextMintPrice(); require(msg.value >= price, "You haven't paid enough"); if (price > 0) { uint256 tokensAmount = _swapForTokens(price.div(100).mul(15)); accRewardsPerShare = accRewardsPerShare.add(tokensAmount.mul(1e12).div(totalSupply())); } _mint(msg.sender); _setRewardDebt(msg.sender); if (price < msg.value) { payable(msg.sender).transfer(msg.value.sub(price)); } } function claim() external { _sendRewards(msg.sender); _setRewardDebt(msg.sender); } function nextMintPrice() public view returns(uint256) { uint256 supply = totalSupply(); if (supply == 0) { return prices[0]; } else if (supply < 6) { return prices[1]; } else if (supply < 16) { return prices[2]; } else if (supply < 36) { return prices[3]; } else if (supply < 168) { return prices[4]; } else if (supply < 275) { return prices[5]; } return prices[6]; } function pendingRewards(address user) public view returns(uint256) { return balanceOf(user).mul(accRewardsPerShare).div(1e12).sub(rewardDebt[user]); } function setPrice(uint256 priceIndex, uint256 price) external onlyOwner { prices[priceIndex] = price; } function unpause() external onlyOwner { _unpause(); } function setStartTime(uint256 _startTime) external onlyOwner { startTime = _startTime; } function setBaseURI(string memory __baseURI) external onlyOwner { baseURI = __baseURI; } function setRouter(address _router) external onlyOwner { require(Address.isContract(_router), "Router not a contract"); router = IUniswapV2Router01(_router); } function setBabyGeist(address _bGEIST) external onlyOwner { require(Address.isContract(_bGEIST), "BabyGeist not a contract"); bGEIST = _bGEIST; } function withdraw() external onlyOwner { payable(owner()).transfer(address(this).balance); } function _swapForTokens(uint256 amount) private returns(uint256) { address[] memory path = new address[](2); path[0] = router.WETH(); path[1] = bGEIST; uint256[] memory amounts = router.swapExactETHForTokens{value: amount}(0, path, address(this), block.timestamp); return amounts[amounts.length.sub(1)]; } function _transfer(address from, address to, uint256 tokenId) internal override(ERC721) { super._transfer(from, to, tokenId); if (from != address(0)) _setRewardDebt(from); if (to != address(0)) _setRewardDebt(to); } function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal override(ERC721, ERC721Enumerable) { super._beforeTokenTransfer(from, to, tokenId); if (from != address(0)) _sendRewards(from); if (to != address(0)) _sendRewards(to); } function _sendRewards(address user) internal { uint256 pending = pendingRewards(user); if (pending > 0) { _safeBabyGeistTransfer(pending, user); } } function _setRewardDebt(address user) internal { rewardDebt[user] = balanceOf(user).mul(accRewardsPerShare).div(1e12); } function _safeBabyGeistTransfer(uint256 amount, address to) internal { IERC20 _bGEIST = IERC20(bGEIST); uint256 bal = _bGEIST.balanceOf(address(this)); if (amount > bal) { amount = bal; } IERC20(bGEIST).transfer(to, amount); } function _mint(address to) internal { require(totalSupply() <= maxSupply, "Supply depleated"); _safeMint(to, index); index = index.add(1); } function _baseURI() internal view override returns(string memory) { return baseURI; } function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) 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(), '.json')) : ''; } // The following functions are overrides required by Solidity. function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) { super._burn(tokenId); } function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) { return super.supportsInterface(interfaceId); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_router","type":"address"},{"internalType":"address","name":"_bGEIST","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"accRewardsPerShare","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":[],"name":"bGEIST","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextMintPrice","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":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"pendingRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardDebt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IUniswapV2Router01","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_bGEIST","type":"address"}],"name":"setBabyGeist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"__baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"priceIndex","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_router","type":"address"}],"name":"setRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startTime","type":"uint256"}],"name":"setStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000f491e7b69e4244ad4002bc14e878a34207e38c29000000000000000000000000727465b34ee5c2f4a2b55083a326b3634d2da6b0
-----Decoded View---------------
Arg [0] : _router (address): 0xF491e7B69E4244ad4002BC14e878a34207E38c29
Arg [1] : _bGEIST (address): 0x727465B34ee5C2f4a2b55083A326b3634d2Da6b0
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000f491e7b69e4244ad4002bc14e878a34207e38c29
Arg [1] : 000000000000000000000000727465b34ee5c2f4a2b55083a326b3634d2da6b0
Deployed Bytecode Sourcemap
62261:6050:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68137:171;;;;;;;;;;-1:-1:-1;68137:171:0;;;;;:::i;:::-;;:::i;:::-;;;611:14:1;;604:22;586:41;;574:2;559:18;68137:171:0;;;;;;;;26681:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;28240:221::-;;;;;;;;;;-1:-1:-1;28240:221:0;;;;;:::i;:::-;;:::i;:::-;;;1809:42:1;1797:55;;;1779:74;;1767:2;1752:18;28240:221:0;1633:226:1;27763:411:0;;;;;;;;;;-1:-1:-1;27763:411:0;;;;;:::i;:::-;;:::i;:::-;;63338:622;;;:::i;40424:113::-;;;;;;;;;;-1:-1:-1;40512:10:0;:17;40424:113;;;2489:25:1;;;2477:2;2462:18;40424:113:0;2343:177:1;29130:339:0;;;;;;;;;;-1:-1:-1;29130:339:0;;;;;:::i;:::-;;:::i;40092:256::-;;;;;;;;;;-1:-1:-1;40092:256:0;;;;;:::i;:::-;;:::i;64621:164::-;;;;;;;;;;-1:-1:-1;64621:164:0;;;;;:::i;:::-;;:::i;65579:106::-;;;;;;;;;;;;;:::i;64993:102::-;;;;;;;;;;-1:-1:-1;64993:102:0;;;;;:::i;:::-;;:::i;64918:67::-;;;;;;;;;;;;;:::i;29540:185::-;;;;;;;;;;-1:-1:-1;29540:185:0;;;;;:::i;:::-;;:::i;63968:106::-;;;;;;;;;;;;;:::i;40614:233::-;;;;;;;;;;-1:-1:-1;40614:233:0;;;;;:::i;:::-;;:::i;65103:102::-;;;;;;;;;;-1:-1:-1;65103:102:0;;;;;:::i;:::-;;:::i;62524:45::-;;;;;;;;;;-1:-1:-1;62524:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;51214:86;;;;;;;;;;-1:-1:-1;51285:7:0;;;;;;;51214:86;;64082:531;;;;;;;;;;;;;:::i;26375:239::-;;;;;;;;;;-1:-1:-1;26375:239:0;;;;;:::i;:::-;;:::i;65403:168::-;;;;;;;;;;-1:-1:-1;65403:168:0;;;;;:::i;:::-;;:::i;26105:208::-;;;;;;;;;;-1:-1:-1;26105:208:0;;;;;:::i;:::-;;:::i;49509:94::-;;;;;;;;;;;;;:::i;62645:24::-;;;;;;;;;;;;;;;;62676:33;;;;;;;;;;;;;;;;62617:21;;;;;;;;;;-1:-1:-1;62617:21:0;;;;;;;;48858:87;;;;;;;;;;-1:-1:-1;48931:6:0;;;;48858:87;;26850:104;;;;;;;;;;;;;:::i;28533:295::-;;;;;;;;;;-1:-1:-1;28533:295:0;;;;;:::i;:::-;;:::i;29796:328::-;;;;;;;;;;-1:-1:-1;29796:328:0;;;;;:::i;:::-;;:::i;65213:182::-;;;;;;;;;;-1:-1:-1;65213:182:0;;;;;:::i;:::-;;:::i;67569:367::-;;;;;;;;;;-1:-1:-1;67569:367:0;;;;;:::i;:::-;;:::i;62416:40::-;;;;;;;;;;;;;;;28899:164;;;;;;;;;;-1:-1:-1;28899:164:0;;;;;:::i;:::-;29020:25;;;;28996:4;29020:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;28899:164;49758:192;;;;;;;;;;-1:-1:-1;49758:192:0;;;;;:::i;:::-;;:::i;64793:117::-;;;;;;;;;;-1:-1:-1;64793:117:0;;;;;:::i;:::-;;:::i;62578:32::-;;;;;;;;;;-1:-1:-1;62578:32:0;;;;;;;;68137:171;68240:4;68264:36;68288:11;68264:23;:36::i;:::-;68257:43;68137:171;-1:-1:-1;;68137:171:0:o;26681:100::-;26735:13;26768:5;26761:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26681:100;:::o;28240:221::-;28316:7;31723:16;;;:7;:16;;;;;;:30;:16;28336:73;;;;;;;7550:2:1;28336:73:0;;;7532:21:1;7589:2;7569:18;;;7562:30;7628:34;7608:18;;;7601:62;7699:14;7679:18;;;7672:42;7731:19;;28336:73:0;;;;;;;;;-1:-1:-1;28429:24:0;;;;:15;:24;;;;;;;;;28240:221::o;27763:411::-;27844:13;27860:23;27875:7;27860:14;:23::i;:::-;27844:39;;27908:5;27902:11;;:2;:11;;;;27894:57;;;;;;;7963:2:1;27894:57:0;;;7945:21:1;8002:2;7982:18;;;7975:30;8041:34;8021:18;;;8014:62;8112:3;8092:18;;;8085:31;8133:19;;27894:57:0;7761:397:1;27894:57:0;21242:10;27986:21;;;;;:62;;-1:-1:-1;28011:37:0;28028:5;21242:10;28899:164;:::i;28011:37::-;27964:168;;;;;;;8365:2:1;27964:168:0;;;8347:21:1;8404:2;8384:18;;;8377:30;8443:34;8423:18;;;8416:62;8514:26;8494:18;;;8487:54;8558:19;;27964:168:0;8163:420:1;27964:168:0;28145:21;28154:2;28158:7;28145:8;:21::i;:::-;27833:341;27763:411;;:::o;63338:622::-;51285:7;;;;;;;51539:9;51531:38;;;;;;;8790:2:1;51531:38:0;;;8772:21:1;8829:2;8809:18;;;8802:30;8868:18;8848;;;8841:46;8904:18;;51531:38:0;8588:340:1;51531:38:0;63423:9:::1;;63404:15;:28;;63396:52;;;::::0;::::1;::::0;;9135:2:1;63396:52:0::1;::::0;::::1;9117:21:1::0;9174:2;9154:18;;;9147:30;9213:13;9193:18;;;9186:41;9244:18;;63396:52:0::1;8933:335:1::0;63396:52:0::1;63459:13;63475:15;:13;:15::i;:::-;63459:31;;63522:5;63509:9;:18;;63501:54;;;::::0;::::1;::::0;;9475:2:1;63501:54:0::1;::::0;::::1;9457:21:1::0;9514:2;9494:18;;;9487:30;9553:25;9533:18;;;9526:53;9596:18;;63501:54:0::1;9273:347:1::0;63501:54:0::1;63572:9:::0;;63568:204:::1;;63598:20;63621:38;63636:22;63655:2;63636:14;:5:::0;63646:3:::1;63636:9;:14::i;:::-;:18:::0;::::1;:22::i;:::-;63621:14;:38::i;:::-;63598:61;;63695:65;63718:41;63745:13;40512:10:::0;:17;;40424:113;63745:13:::1;63718:22;:12:::0;63735:4:::1;63718:16;:22::i;:::-;:26:::0;::::1;:41::i;:::-;63695:18;::::0;;:22:::1;:65::i;:::-;63674:18;:86:::0;-1:-1:-1;63568:204:0::1;63784:17;63790:10;63784:5;:17::i;:::-;63814:26;63829:10;63814:14;:26::i;:::-;63865:9;63857:5;:17;63853:100;;;63899:10;63891:50;63920:20;:9;63934:5:::0;63920:13:::1;:20::i;:::-;63891:50;::::0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;63853:100;63385:575;63338:622::o:0;29130:339::-;29325:41;21242:10;29358:7;29325:18;:41::i;:::-;29317:103;;;;;;;9827:2:1;29317:103:0;;;9809:21:1;9866:2;9846:18;;;9839:30;9905:34;9885:18;;;9878:62;9976:19;9956:18;;;9949:47;10013:19;;29317:103:0;9625:413:1;29317:103:0;29433:28;29443:4;29449:2;29453:7;29433:9;:28::i;40092:256::-;40189:7;40225:23;40242:5;40225:16;:23::i;:::-;40217:5;:31;40209:87;;;;;;;10245:2:1;40209:87:0;;;10227:21:1;10284:2;10264:18;;;10257:30;10323:34;10303:18;;;10296:62;10394:13;10374:18;;;10367:41;10425:19;;40209:87:0;10043:407:1;40209:87:0;-1:-1:-1;40314:19:0;;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;40092:256::o;64621:164::-;64760:16;;;64679:7;64760:16;;;:10;:16;;;;;;64726:18;;64706:71;;64760:16;64706:49;;64750:4;;64706:39;;:15;64771:4;64706:9;:15::i;:49::-;:53;;:71::i;65579:106::-;48931:6;;49078:23;48931:6;21242:10;49078:23;49070:68;;;;;;;10657:2:1;49070:68:0;;;10639:21:1;;;10676:18;;;10669:30;10735:34;10715:18;;;10708:62;10787:18;;49070:68:0;10455:356:1;49070:68:0;48931:6;;65629:48:::1;::::0;48931:6;;;;;65655:21:::1;65629:48:::0;::::1;;;::::0;::::1;::::0;;;65655:21;48931:6;65629:48;::::1;;;;;;;;;;;;;::::0;::::1;;;;64993:102:::0;48931:6;;49078:23;48931:6;21242:10;49078:23;49070:68;;;;;;;10657:2:1;49070:68:0;;;10639:21:1;;;10676:18;;;10669:30;10735:34;10715:18;;;10708:62;10787:18;;49070:68:0;10455:356:1;49070:68:0;65065:9:::1;:22:::0;64993:102::o;64918:67::-;48931:6;;49078:23;48931:6;21242:10;49078:23;49070:68;;;;;;;10657:2:1;49070:68:0;;;10639:21:1;;;10676:18;;;10669:30;10735:34;10715:18;;;10708:62;10787:18;;49070:68:0;10455:356:1;49070:68:0;64967:10:::1;:8;:10::i;:::-;64918:67::o:0;29540:185::-;29678:39;29695:4;29701:2;29705:7;29678:39;;;;;;;;;;;;:16;:39::i;63968:106::-;64005:24;64018:10;64005:12;:24::i;:::-;64040:26;64055:10;64040:14;:26::i;40614:233::-;40689:7;40725:30;40512:10;:17;;40424:113;40725:30;40717:5;:38;40709:95;;;;;;;11018:2:1;40709:95:0;;;11000:21:1;11057:2;11037:18;;;11030:30;11096:34;11076:18;;;11069:62;11167:14;11147:18;;;11140:42;11199:19;;40709:95:0;10816:408:1;40709:95:0;40822:10;40833:5;40822:17;;;;;;;;:::i;:::-;;;;;;;;;40815:24;;40614:233;;;:::o;65103:102::-;48931:6;;49078:23;48931:6;21242:10;49078:23;49070:68;;;;;;;10657:2:1;49070:68:0;;;10639:21:1;;;10676:18;;;10669:30;10735:34;10715:18;;;10708:62;10787:18;;49070:68:0;10455:356:1;49070:68:0;65178:19;;::::1;::::0;:7:::1;::::0;:19:::1;::::0;::::1;::::0;::::1;:::i;64082:531::-:0;64127:7;64147:14;64164:13;40512:10;:17;;40424:113;64164:13;64147:30;-1:-1:-1;64192:11:0;64188:391;;-1:-1:-1;;64227:9:0;;;:6;:9;;;;;64082:531::o;64188:391::-;64267:1;64258:6;:10;64254:325;;;-1:-1:-1;;64299:1:0;64292:9;;:6;:9;;;;;64082:531::o;64254:325::-;64332:2;64323:6;:11;64319:260;;;-1:-1:-1;;64365:1:0;64358:9;;:6;:9;;;;;64082:531::o;64319:260::-;64398:2;64389:6;:11;64385:194;;;-1:-1:-1;;64431:1:0;64424:9;;:6;:9;;;;;64082:531::o;64385:194::-;64464:3;64455:6;:12;64451:128;;;-1:-1:-1;;64498:1:0;64491:9;;:6;:9;;;;;64082:531::o;64451:128::-;64531:3;64522:6;:12;64518:61;;;-1:-1:-1;;64565:1:0;64558:9;;:6;:9;;;;;64082:531::o;64518:61::-;-1:-1:-1;;64603:1:0;64596:9;;:6;:9;;;;;64082:531::o;26375:239::-;26447:7;26483:16;;;:7;:16;;;;;;;;26518:19;26510:73;;;;;;;11620:2:1;26510:73:0;;;11602:21:1;11659:2;11639:18;;;11632:30;11698:34;11678:18;;;11671:62;11769:11;11749:18;;;11742:39;11798:19;;26510:73:0;11418:405:1;65403:168:0;48931:6;;49078:23;48931:6;21242:10;49078:23;49070:68;;;;;;;10657:2:1;49070:68:0;;;10639:21:1;;;10676:18;;;10669:30;10735:34;10715:18;;;10708:62;10787:18;;49070:68:0;10455:356:1;49070:68:0;13525:20;;65472:64:::1;;;::::0;::::1;::::0;;12030:2:1;65472:64:0::1;::::0;::::1;12012:21:1::0;12069:2;12049:18;;;12042:30;12108:26;12088:18;;;12081:54;12152:18;;65472:64:0::1;11828:348:1::0;65472:64:0::1;65547:6;:16:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;65403:168::o;26105:208::-;26177:7;26205:19;;;26197:74;;;;;;;12383:2:1;26197:74:0;;;12365:21:1;12422:2;12402:18;;;12395:30;12461:34;12441:18;;;12434:62;12532:12;12512:18;;;12505:40;12562:19;;26197:74:0;12181:406:1;26197:74:0;-1:-1:-1;26289:16:0;;;;;;:9;:16;;;;;;;26105:208::o;49509:94::-;48931:6;;49078:23;48931:6;21242:10;49078:23;49070:68;;;;;;;10657:2:1;49070:68:0;;;10639:21:1;;;10676:18;;;10669:30;10735:34;10715:18;;;10708:62;10787:18;;49070:68:0;10455:356:1;49070:68:0;49574:21:::1;49592:1;49574:9;:21::i;26850:104::-:0;26906:13;26939:7;26932:14;;;;;:::i;28533:295::-;28636:24;;;21242:10;28636:24;;28628:62;;;;;;;12794:2:1;28628:62:0;;;12776:21:1;12833:2;12813:18;;;12806:30;12872:27;12852:18;;;12845:55;12917:18;;28628:62:0;12592:349:1;28628:62:0;21242:10;28703:32;;;;:18;:32;;;;;;;;;:42;;;;;;;;;;;;:53;;;;;;;;;;;;;28772:48;;586:41:1;;;28703:42:0;;21242:10;28772:48;;559:18:1;28772:48:0;;;;;;;28533:295;;:::o;29796:328::-;29971:41;21242:10;30004:7;29971:18;:41::i;:::-;29963:103;;;;;;;9827:2:1;29963:103:0;;;9809:21:1;9866:2;9846:18;;;9839:30;9905:34;9885:18;;;9878:62;9976:19;9956:18;;;9949:47;10013:19;;29963:103:0;9625:413:1;29963:103:0;30077:39;30091:4;30097:2;30101:7;30110:5;30077:13;:39::i;:::-;29796:328;;;;:::o;65213:182::-;48931:6;;49078:23;48931:6;21242:10;49078:23;49070:68;;;;;;;10657:2:1;49070:68:0;;;10639:21:1;;;10676:18;;;10669:30;10735:34;10715:18;;;10708:62;10787:18;;49070:68:0;10455:356:1;49070:68:0;13525:20;;65279:61:::1;;;::::0;::::1;::::0;;13148:2:1;65279:61:0::1;::::0;::::1;13130:21:1::0;13187:2;13167:18;;;13160:30;13226:23;13206:18;;;13199:51;13267:18;;65279:61:0::1;12946:345:1::0;65279:61:0::1;65351:6;:36:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;65213:182::o;67569:367::-;31699:4;31723:16;;;:7;:16;;;;;;67660:13;;31723:30;:16;67686:76;;;;;;;13498:2:1;67686:76:0;;;13480:21:1;13537:2;13517:18;;;13510:30;13576:34;13556:18;;;13549:62;13647:17;13627:18;;;13620:45;13682:19;;67686:76:0;13296:411:1;67686:76:0;67775:23;67801:10;:8;:10::i;:::-;67775:36;;67855:1;67835:9;67829:23;:27;:99;;;;;;;;;;;;;;;;;67883:9;67894:18;:7;:16;:18::i;:::-;67866:56;;;;;;;;;:::i;:::-;;;;;;;;;;;;;67829:99;67822:106;67569:367;-1:-1:-1;;;67569:367:0:o;49758:192::-;48931:6;;49078:23;48931:6;21242:10;49078:23;49070:68;;;;;;;10657:2:1;49070:68:0;;;10639:21:1;;;10676:18;;;10669:30;10735:34;10715:18;;;10708:62;10787:18;;49070:68:0;10455:356:1;49070:68:0;49847:22:::1;::::0;::::1;49839:73;;;::::0;::::1;::::0;;14556:2:1;49839:73:0::1;::::0;::::1;14538:21:1::0;14595:2;14575:18;;;14568:30;14634:34;14614:18;;;14607:62;14705:8;14685:18;;;14678:36;14731:19;;49839:73:0::1;14354:402:1::0;49839:73:0::1;49923:19;49933:8;49923:9;:19::i;64793:117::-:0;48931:6;;49078:23;48931:6;21242:10;49078:23;49070:68;;;;;;;10657:2:1;49070:68:0;;;10639:21:1;;;10676:18;;;10669:30;10735:34;10715:18;;;10708:62;10787:18;;49070:68:0;10455:356:1;49070:68:0;64876:18:::1;::::0;;;:6:::1;:18;::::0;;;;;:26;64793:117::o;13202:387::-;13525:20;13573:8;;;13202:387::o;55196:98::-;55254:7;55281:5;55285:1;55281;:5;:::i;39784:224::-;39886:4;39910:50;;;39925:35;39910:50;;:90;;;39964:36;39988:11;39964:23;:36::i;35616:174::-;35691:24;;;;:15;:24;;;;;:29;;;;;;;;;;;;;:24;;35745:23;35691:24;35745:14;:23::i;:::-;35736:46;;;;;;;;;;;;35616:174;;:::o;56333:98::-;56391:7;56418:5;56422:1;56418;:5;:::i;55934:98::-;55992:7;56019:5;56023:1;56019;:5;:::i;65693:357::-;65793:16;;;65807:1;65793:16;;;;;;;;65749:7;;;;65793:16;65807:1;65793:16;;;;;;;;-1:-1:-1;;65830:6:0;;:13;;;;;;;;65769:40;;-1:-1:-1;65830:6:0;;;;;:11;;-1:-1:-1;65830:13:0;;;;;;;;;;;;;;:6;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65820:4;65825:1;65820:7;;;;;;;;:::i;:::-;:23;;;;:7;;;;;;;;;:23;65864:6;;65854:7;;65864:6;;;65854:4;;65864:6;;65854:7;;;;;;:::i;:::-;:16;;;;:7;;;;;;;;;:16;65910:6;;:84;;;;;65883:24;;65910:6;;;;;:28;;65946:6;;65910:84;;65883:24;;65957:4;;65971;;65978:15;;65910:84;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65883:111;;66012:7;66020:21;66039:1;66020:7;:14;:18;;:21;;;;:::i;:::-;66012:30;;;;;;;;:::i;:::-;;;;;;;66005:37;;;;65693:357;;;:::o;67282:172::-;67354:9;67337:13;40512:10;:17;;40424:113;67337:13;:26;;67329:55;;;;;;;17988:2:1;67329:55:0;;;17970:21:1;18027:2;18007:18;;;18000:30;18066:18;18046;;;18039:46;18102:18;;67329:55:0;17786:340:1;67329:55:0;67395:20;67405:2;67409:5;;67395:9;:20::i;:::-;67434:5;;:12;;67444:1;67434:9;:12::i;:::-;67426:5;:20;-1:-1:-1;67282:172:0:o;66843:134::-;66920:49;66964:4;66920:39;66940:18;;66920:15;66930:4;66920:9;:15::i;:49::-;66901:16;;;;;;;;:10;:16;;;;;:68;66843:134::o;55577:98::-;55635:7;55662:5;55666:1;55662;:5;:::i;31928:348::-;32021:4;31723:16;;;:7;:16;;;;;;:30;:16;32038:73;;;;;;;18463:2:1;32038:73:0;;;18445:21:1;18502:2;18482:18;;;18475:30;18541:34;18521:18;;;18514:62;18612:14;18592:18;;;18585:42;18644:19;;32038:73:0;18261:408:1;32038:73:0;32122:13;32138:23;32153:7;32138:14;:23::i;:::-;32122:39;;32191:5;32180:16;;:7;:16;;;:51;;;;32224:7;32200:31;;:20;32212:7;32200:11;:20::i;:::-;:31;;;32180:51;:87;;;-1:-1:-1;29020:25:0;;;;28996:4;29020:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;32235:32;32172:96;31928:348;-1:-1:-1;;;;31928:348:0:o;66058:249::-;66157:34;66173:4;66179:2;66183:7;66157:15;:34::i;:::-;66208:18;;;;66204:44;;66228:20;66243:4;66228:14;:20::i;:::-;66263:16;;;;66259:40;;66281:18;66296:2;66281:14;:18::i;52273:120::-;51285:7;;;;;;;51809:41;;;;;;;18876:2:1;51809:41:0;;;18858:21:1;18915:2;18895:18;;;18888:30;18954:22;18934:18;;;18927:50;18994:18;;51809:41:0;18674:344:1;51809:41:0;52332:7:::1;:15:::0;;;::::1;::::0;;52363:22:::1;::::0;;21242:10;1779:74:1;;52363:22:0;;::::1;::::0;;;;1767:2:1;52363:22:0;;::::1;52273:120::o:0;66642:193::-;66698:15;66716:20;66731:4;66716:14;:20::i;:::-;66698:38;-1:-1:-1;66751:11:0;;66747:81;;66779:37;66802:7;66811:4;66779:22;:37::i;49958:173::-;50033:6;;;;50050:17;;;;;;;;;;;50083:40;;50033:6;;;50050:17;50033:6;;50083:40;;50014:16;;50083:40;50003:128;49958:173;:::o;31006:315::-;31163:28;31173:4;31179:2;31183:7;31163:9;:28::i;:::-;31210:48;31233:4;31239:2;31243:7;31252:5;31210:22;:48::i;:::-;31202:111;;;;;;;19225:2:1;31202:111:0;;;19207:21:1;19264:2;19244:18;;;19237:30;19303:34;19283:18;;;19276:62;19374:20;19354:18;;;19347:48;19412:19;;31202:111:0;19023:414:1;67462:99:0;67513:13;67546:7;67539:14;;;;;:::i;21691:723::-;21747:13;21968:10;21964:53;;-1:-1:-1;;21995:10:0;;;;;;;;;;;;;;;;;;21691:723::o;21964:53::-;22042:5;22027:12;22083:78;22090:9;;22083:78;;22116:8;;;;:::i;:::-;;-1:-1:-1;22139:10:0;;-1:-1:-1;22147:2:0;22139:10;;:::i;:::-;;;22083:78;;;22171:19;22203:6;22193:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22193:17:0;;22171:39;;22221:154;22228:10;;22221:154;;22255:11;22265:1;22255:11;;:::i;:::-;;-1:-1:-1;22324:10:0;22332:2;22324:5;:10;:::i;:::-;22311:24;;:2;:24;:::i;:::-;22298:39;;22281:6;22288;22281:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;22352:11:0;22361:2;22352:11;;:::i;:::-;;;22221:154;;25736:305;25838:4;25875:40;;;25890:25;25875:40;;:105;;-1:-1:-1;25932:48:0;;;25947:33;25932:48;25875:105;:158;;;-1:-1:-1;24374:25:0;24359:40;;;;25997:36;24250:157;32618:110;32694:26;32704:2;32708:7;32694:26;;;;;;;;;;;;:9;:26::i;34920:578::-;35079:4;35052:31;;:23;35067:7;35052:14;:23::i;:::-;:31;;;35044:85;;;;;;;19961:2:1;35044:85:0;;;19943:21:1;20000:2;19980:18;;;19973:30;20039:34;20019:18;;;20012:62;20110:11;20090:18;;;20083:39;20139:19;;35044:85:0;19759:405:1;35044:85:0;35148:16;;;35140:65;;;;;;;20371:2:1;35140:65:0;;;20353:21:1;20410:2;20390:18;;;20383:30;20449:34;20429:18;;;20422:62;20520:6;20500:18;;;20493:34;20544:19;;35140:65:0;20169:400:1;35140:65:0;35218:39;35239:4;35245:2;35249:7;35218:20;:39::i;:::-;35322:29;35339:1;35343:7;35322:8;:29::i;:::-;35364:15;;;;;;;:9;:15;;;;;:20;;35383:1;;35364:15;:20;;35383:1;;35364:20;:::i;:::-;;;;-1:-1:-1;;35395:13:0;;;;;;;:9;:13;;;;;:18;;35412:1;;35395:13;:18;;35412:1;;35395:18;:::i;:::-;;;;-1:-1:-1;;35424:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;;35463:27;;35424:16;;35463:27;;;;;;;34920:578;;;:::o;66985:289::-;67089:6;;67121:32;;;;;67147:4;67121:32;;;1779:74:1;67089:6:0;;;;;67065:14;;67089:6;;67121:17;;1752:18:1;;67121:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67107:46;;67177:3;67168:6;:12;67164:57;;;67206:3;67197:12;;67164:57;67238:6;;67231:35;;;;;67238:6;20955:55:1;;;67231:35:0;;;20937:74:1;21027:18;;;21020:34;;;67238:6:0;;;;67231:23;;20910:18:1;;67231:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;67054:220;;66985:289;;:::o;36355:799::-;36510:4;36531:13;;;13525:20;13573:8;36527:620;;36567:72;;;;;:36;;;;;;:72;;21242:10;;36618:4;;36624:7;;36633:5;;36567:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36567:72:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;36563:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36809:13:0;;36805:272;;36852:60;;;;;19225:2:1;36852:60:0;;;19207:21:1;19264:2;19244:18;;;19237:30;19303:34;19283:18;;;19276:62;19374:20;19354:18;;;19347:48;19412:19;;36852:60:0;19023:414:1;36805:272:0;37027:6;37021:13;37012:6;37008:2;37004:15;36997:38;36563:529;36690:51;;36700:41;36690:51;;-1:-1:-1;36683:58:0;;36527:620;-1:-1:-1;37131:4:0;36355:799;;;;;;:::o;32955:321::-;33085:18;33091:2;33095:7;33085:5;:18::i;:::-;33136:54;33167:1;33171:2;33175:7;33184:5;33136:22;:54::i;:::-;33114:154;;;;;;;19225:2:1;33114:154:0;;;19207:21:1;19264:2;19244:18;;;19237:30;19303:34;19283:18;;;19276:62;19374:20;19354:18;;;19347:48;19412:19;;33114:154:0;19023:414:1;66315:319:0;66477:45;66504:4;66510:2;66514:7;66477:26;:45::i;:::-;66539:18;;;;66535:42;;66559:18;66572:4;66559:12;:18::i;:::-;66592:16;;;;66588:38;;66610:16;66623:2;66610:12;:16::i;33612:382::-;33692:16;;;33684:61;;;;;;;22288:2:1;33684:61:0;;;22270:21:1;;;22307:18;;;22300:30;22366:34;22346:18;;;22339:62;22418:18;;33684:61:0;22086:356:1;33684:61:0;31699:4;31723:16;;;:7;:16;;;;;;:30;:16;:30;33756:58;;;;;;;22649:2:1;33756:58:0;;;22631:21:1;22688:2;22668:18;;;22661:30;22727;22707:18;;;22700:58;22775:18;;33756:58:0;22447:352:1;33756:58:0;33827:45;33856:1;33860:2;33864:7;33827:20;:45::i;:::-;33885:13;;;;;;;:9;:13;;;;;:18;;33902:1;;33885:13;:18;;33902:1;;33885:18;:::i;:::-;;;;-1:-1:-1;;33914:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;33953:33;;33914:16;;;33953:33;;33914:16;;33953:33;33612:382;;:::o;41460:589::-;41666:18;;;41662:187;;41701:40;41733:7;42876:10;:17;;42849:24;;;;:15;:24;;;;;:44;;;42904:24;;;;;;;;;;;;42772:164;41701:40;41662:187;;;41771:2;41763:10;;:4;:10;;;41759:90;;41790:47;41823:4;41829:7;41790:32;:47::i;:::-;41863:16;;;41859:183;;41896:45;41933:7;41896:36;:45::i;41859:183::-;41969:4;41963:10;;:2;:10;;;41959:83;;41990:40;42018:2;42022:7;41990:27;:40::i;43563:988::-;43829:22;43879:1;43854:22;43871:4;43854:16;:22::i;:::-;:26;;;;:::i;:::-;43891:18;43912:26;;;:17;:26;;;;;;43829:51;;-1:-1:-1;44045:28:0;;;44041:328;;44112:18;;;44090:19;44112:18;;;:12;:18;;;;;;;;:34;;;;;;;;;44163:30;;;;;;:44;;;44280:30;;:17;:30;;;;;:43;;;44041:328;-1:-1:-1;44465:26:0;;;;:17;:26;;;;;;;;44458:33;;;44509:18;;;;;;:12;:18;;;;;:34;;;;;;;44502:41;43563:988::o;44846:1079::-;45124:10;:17;45099:22;;45124:21;;45144:1;;45124:21;:::i;:::-;45156:18;45177:24;;;:15;:24;;;;;;45550:10;:26;;45099:46;;-1:-1:-1;45177:24:0;;45099:46;;45550:26;;;;;;:::i;:::-;;;;;;;;;45528:48;;45614:11;45589:10;45600;45589:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;45694:28;;;:15;:28;;;;;;;:41;;;45866:24;;;;;45859:31;45901:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;44917:1008;;;44846:1079;:::o;42350:221::-;42435:14;42452:20;42469:2;42452:16;:20::i;:::-;42483:16;;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;42528:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;42350:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:177:1;99:66;92:5;88:78;81:5;78:89;68:117;;181:1;178;171:12;196:245;254:6;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;362:9;349:23;381:30;405:5;381:30;:::i;638:258::-;710:1;720:113;734:6;731:1;728:13;720:113;;;810:11;;;804:18;791:11;;;784:39;756:2;749:10;720:113;;;851:6;848:1;845:13;842:48;;;-1:-1:-1;;886:1:1;868:16;;861:27;638:258::o;901:317::-;943:3;981:5;975:12;1008:6;1003:3;996:19;1024:63;1080:6;1073:4;1068:3;1064:14;1057:4;1050:5;1046:16;1024:63;:::i;:::-;1132:2;1120:15;1137:66;1116:88;1107:98;;;;1207:4;1103:109;;901:317;-1:-1:-1;;901:317:1:o;1223:220::-;1372:2;1361:9;1354:21;1335:4;1392:45;1433:2;1422:9;1418:18;1410:6;1392:45;:::i;1448:180::-;1507:6;1560:2;1548:9;1539:7;1535:23;1531:32;1528:52;;;1576:1;1573;1566:12;1528:52;-1:-1:-1;1599:23:1;;1448:180;-1:-1:-1;1448:180:1:o;1864:154::-;1950:42;1943:5;1939:54;1932:5;1929:65;1919:93;;2008:1;2005;1998:12;2023:315;2091:6;2099;2152:2;2140:9;2131:7;2127:23;2123:32;2120:52;;;2168:1;2165;2158:12;2120:52;2207:9;2194:23;2226:31;2251:5;2226:31;:::i;:::-;2276:5;2328:2;2313:18;;;;2300:32;;-1:-1:-1;;;2023:315:1:o;2525:456::-;2602:6;2610;2618;2671:2;2659:9;2650:7;2646:23;2642:32;2639:52;;;2687:1;2684;2677:12;2639:52;2726:9;2713:23;2745:31;2770:5;2745:31;:::i;:::-;2795:5;-1:-1:-1;2852:2:1;2837:18;;2824:32;2865:33;2824:32;2865:33;:::i;:::-;2525:456;;2917:7;;-1:-1:-1;;;2971:2:1;2956:18;;;;2943:32;;2525:456::o;2986:247::-;3045:6;3098:2;3086:9;3077:7;3073:23;3069:32;3066:52;;;3114:1;3111;3104:12;3066:52;3153:9;3140:23;3172:31;3197:5;3172:31;:::i;3238:184::-;3290:77;3287:1;3280:88;3387:4;3384:1;3377:15;3411:4;3408:1;3401:15;3427:334;3498:2;3492:9;3554:2;3544:13;;3559:66;3540:86;3528:99;;3657:18;3642:34;;3678:22;;;3639:62;3636:88;;;3704:18;;:::i;:::-;3740:2;3733:22;3427:334;;-1:-1:-1;3427:334:1:o;3766:466::-;3831:5;3865:18;3857:6;3854:30;3851:56;;;3887:18;;:::i;:::-;3925:116;4035:4;3966:66;3961:2;3953:6;3949:15;3945:88;3941:99;3925:116;:::i;:::-;3916:125;;4064:6;4057:5;4050:21;4104:3;4095:6;4090:3;4086:16;4083:25;4080:45;;;4121:1;4118;4111:12;4080:45;4170:6;4165:3;4158:4;4151:5;4147:16;4134:43;4224:1;4217:4;4208:6;4201:5;4197:18;4193:29;4186:40;3766:466;;;;;:::o;4237:451::-;4306:6;4359:2;4347:9;4338:7;4334:23;4330:32;4327:52;;;4375:1;4372;4365:12;4327:52;4415:9;4402:23;4448:18;4440:6;4437:30;4434:50;;;4480:1;4477;4470:12;4434:50;4503:22;;4556:4;4548:13;;4544:27;-1:-1:-1;4534:55:1;;4585:1;4582;4575:12;4534:55;4608:74;4674:7;4669:2;4656:16;4651:2;4647;4643:11;4608:74;:::i;4693:118::-;4779:5;4772:13;4765:21;4758:5;4755:32;4745:60;;4801:1;4798;4791:12;4816:382;4881:6;4889;4942:2;4930:9;4921:7;4917:23;4913:32;4910:52;;;4958:1;4955;4948:12;4910:52;4997:9;4984:23;5016:31;5041:5;5016:31;:::i;:::-;5066:5;-1:-1:-1;5123:2:1;5108:18;;5095:32;5136:30;5095:32;5136:30;:::i;:::-;5185:7;5175:17;;;4816:382;;;;;:::o;5203:795::-;5298:6;5306;5314;5322;5375:3;5363:9;5354:7;5350:23;5346:33;5343:53;;;5392:1;5389;5382:12;5343:53;5431:9;5418:23;5450:31;5475:5;5450:31;:::i;:::-;5500:5;-1:-1:-1;5557:2:1;5542:18;;5529:32;5570:33;5529:32;5570:33;:::i;:::-;5622:7;-1:-1:-1;5676:2:1;5661:18;;5648:32;;-1:-1:-1;5731:2:1;5716:18;;5703:32;5758:18;5747:30;;5744:50;;;5790:1;5787;5780:12;5744:50;5813:22;;5866:4;5858:13;;5854:27;-1:-1:-1;5844:55:1;;5895:1;5892;5885:12;5844:55;5918:74;5984:7;5979:2;5966:16;5961:2;5957;5953:11;5918:74;:::i;:::-;5908:84;;;5203:795;;;;;;;:::o;6003:388::-;6071:6;6079;6132:2;6120:9;6111:7;6107:23;6103:32;6100:52;;;6148:1;6145;6138:12;6100:52;6187:9;6174:23;6206:31;6231:5;6206:31;:::i;:::-;6256:5;-1:-1:-1;6313:2:1;6298:18;;6285:32;6326:33;6285:32;6326:33;:::i;6396:248::-;6464:6;6472;6525:2;6513:9;6504:7;6500:23;6496:32;6493:52;;;6541:1;6538;6531:12;6493:52;-1:-1:-1;;6564:23:1;;;6634:2;6619:18;;;6606:32;;-1:-1:-1;6396:248:1:o;6906:437::-;6985:1;6981:12;;;;7028;;;7049:61;;7103:4;7095:6;7091:17;7081:27;;7049:61;7156:2;7148:6;7145:14;7125:18;7122:38;7119:218;;;7193:77;7190:1;7183:88;7294:4;7291:1;7284:15;7322:4;7319:1;7312:15;7119:218;;6906:437;;;:::o;11229:184::-;11281:77;11278:1;11271:88;11378:4;11375:1;11368:15;11402:4;11399:1;11392:15;13712:637;13992:3;14030:6;14024:13;14046:53;14092:6;14087:3;14080:4;14072:6;14068:17;14046:53;:::i;:::-;14162:13;;14121:16;;;;14184:57;14162:13;14121:16;14218:4;14206:17;;14184:57;:::i;:::-;14306:7;14263:20;;14292:22;;;14341:1;14330:13;;13712:637;-1:-1:-1;;;;13712:637:1:o;14761:184::-;14813:77;14810:1;14803:88;14910:4;14907:1;14900:15;14934:4;14931:1;14924:15;14950:128;14990:3;15021:1;15017:6;15014:1;15011:13;15008:39;;;15027:18;;:::i;:::-;-1:-1:-1;15063:9:1;;14950:128::o;15083:184::-;15135:77;15132:1;15125:88;15232:4;15229:1;15222:15;15256:4;15253:1;15246:15;15272:120;15312:1;15338;15328:35;;15343:18;;:::i;:::-;-1:-1:-1;15377:9:1;;15272:120::o;15397:228::-;15437:7;15563:1;15495:66;15491:74;15488:1;15485:81;15480:1;15473:9;15466:17;15462:105;15459:131;;;15570:18;;:::i;:::-;-1:-1:-1;15610:9:1;;15397:228::o;15630:251::-;15700:6;15753:2;15741:9;15732:7;15728:23;15724:32;15721:52;;;15769:1;15766;15759:12;15721:52;15801:9;15795:16;15820:31;15845:5;15820:31;:::i;15886:954::-;16120:4;16168:3;16157:9;16153:19;16199:6;16188:9;16181:25;16225:2;16263:3;16258:2;16247:9;16243:18;16236:31;16287:6;16322;16316:13;16353:6;16345;16338:22;16391:3;16380:9;16376:19;16369:26;;16430:2;16422:6;16418:15;16404:29;;16451:1;16461:218;16475:6;16472:1;16469:13;16461:218;;;16540:13;;16555:42;16536:62;16524:75;;16654:15;;;;16619:12;;;;16497:1;16490:9;16461:218;;;-1:-1:-1;;16747:42:1;16735:55;;;;16730:2;16715:18;;16708:83;-1:-1:-1;;;16822:2:1;16807:18;16800:34;16696:3;15886:954;-1:-1:-1;;15886:954:1:o;16845:936::-;16940:6;16971:2;17014;17002:9;16993:7;16989:23;16985:32;16982:52;;;17030:1;17027;17020:12;16982:52;17063:9;17057:16;17092:18;17133:2;17125:6;17122:14;17119:34;;;17149:1;17146;17139:12;17119:34;17187:6;17176:9;17172:22;17162:32;;17232:7;17225:4;17221:2;17217:13;17213:27;17203:55;;17254:1;17251;17244:12;17203:55;17283:2;17277:9;17305:2;17301;17298:10;17295:36;;;17311:18;;:::i;:::-;17357:2;17354:1;17350:10;17340:20;;17380:28;17404:2;17400;17396:11;17380:28;:::i;:::-;17442:15;;;17512:11;;;17508:20;;;17473:12;;;;17540:19;;;17537:39;;;17572:1;17569;17562:12;17537:39;17596:11;;;;17616:135;17632:6;17627:3;17624:15;17616:135;;;17698:10;;17686:23;;17649:12;;;;17729;;;;17616:135;;;17770:5;16845:936;-1:-1:-1;;;;;;;;16845:936:1:o;18131:125::-;18171:4;18199:1;18196;18193:8;18190:34;;;18204:18;;:::i;:::-;-1:-1:-1;18241:9:1;;18131:125::o;19442:195::-;19481:3;19512:66;19505:5;19502:77;19499:103;;;19582:18;;:::i;:::-;-1:-1:-1;19629:1:1;19618:13;;19442:195::o;19642:112::-;19674:1;19700;19690:35;;19705:18;;:::i;:::-;-1:-1:-1;19739:9:1;;19642:112::o;20574:184::-;20644:6;20697:2;20685:9;20676:7;20672:23;20668:32;20665:52;;;20713:1;20710;20703:12;20665:52;-1:-1:-1;20736:16:1;;20574:184;-1:-1:-1;20574:184:1:o;21065:245::-;21132:6;21185:2;21173:9;21164:7;21160:23;21156:32;21153:52;;;21201:1;21198;21191:12;21153:52;21233:9;21227:16;21252:28;21274:5;21252:28;:::i;21315:512::-;21509:4;21538:42;21619:2;21611:6;21607:15;21596:9;21589:34;21671:2;21663:6;21659:15;21654:2;21643:9;21639:18;21632:43;;21711:6;21706:2;21695:9;21691:18;21684:34;21754:3;21749:2;21738:9;21734:18;21727:31;21775:46;21816:3;21805:9;21801:19;21793:6;21775:46;:::i;:::-;21767:54;21315:512;-1:-1:-1;;;;;;21315:512:1:o;21832:249::-;21901:6;21954:2;21942:9;21933:7;21929:23;21925:32;21922:52;;;21970:1;21967;21960:12;21922:52;22002:9;21996:16;22021:30;22045:5;22021:30;:::i;22804:184::-;22856:77;22853:1;22846:88;22953:4;22950:1;22943:15;22977:4;22974:1;22967:15
Swarm Source
ipfs://d63de454afb5b19e232f13fede73e360684e812be2f304c7a3b87d5d1dc11791
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.