Feature Tip: Add private address tag to any address under My Name Tag !
ERC-20
Overview
Max Total Supply
200,195,737.812499999999999318 Ribbit
Holders
742
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Balance
171,950.347222222222222221 RibbitValue
$0.00Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
Ribbit
Compiler Version
v0.8.7+commit.e28d00a7
Contract Source Code (Solidity Multiple files format)
pragma solidity ^0.8.0; import "./Ownable.sol"; import "./Pausable.sol"; import "./ERC20.sol"; import "./LFLC.sol"; interface InterfaceLFLC { function balanceOf(address owner) external view returns (uint256 balance); function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); } contract Ribbit is ERC20, Ownable, Pausable { InterfaceLFLC public LFLC; // a mapping for an address for whether or not it can mint mapping(address => bool) controllers; // The starting block. uint256 public startBlock; // The interval that the user is paid out. uint256 public interval = 86400; uint256 public rate = 1000 ether; //Max rewards from LFLC staking uint256 public constant cap = 200000000 ether; // The rewards for the user. mapping(address => uint256) public rewards; // The last time they were paid out. mapping(address => uint256) public lastUpdate; // Only allow the contract to interact with it. modifier onlyFromLFLC() { require(msg.sender == address(LFLC)); _; } constructor(address lflcAddress) ERC20("Ribbit Token", "Ribbit") { // Set the LFLC erc 721 address. LFLC = InterfaceLFLC(lflcAddress); // Set the starting block. startBlock = block.timestamp; // Pause the system so no one can interact with it. _pause(); } /* Admin Utility. */ // Pause it. function pause() public onlyOwner { _pause(); } // Unpause it. function unpause() public onlyOwner { _unpause(); } // Set the start block. function setStartBlock(uint256 arg) public onlyOwner { if(arg == 0){ startBlock = block.timestamp; }else{ startBlock = arg; } } // Set the start block. function setIntervalAndRate(uint256 _interval, uint256 _rate) public onlyOwner { interval = _interval; rate = _rate; } // Set the address for the LFLC contract. function setLFLCContractAddress(address _lflc) public onlyOwner { LFLC = InterfaceLFLC(_lflc); } // Phase 2 Minting function mintSecondPhase(address user, uint256 amount) public onlyOwner { require(controllers[msg.sender], "Only controllers can mint"); _mint(user, amount); } /** * enables an address to mint / burn * @param controller the address to enable */ function addController(address controller) external onlyOwner { controllers[controller] = true; } /** * disables an address from minting / burning * @param controller the address to disbale */ function removeController(address controller) external onlyOwner { controllers[controller] = false; } /* User Utilities. */ // Transfer the tokens (only accessable from the contract). function transferTokens(address _from, address _to) onlyFromLFLC whenNotPaused external { // Refactor this. if(_from != address(0)){ rewards[_from] += getPendingReward(_from); lastUpdate[_from] = block.timestamp; } if(_to != address(0)){ rewards[_to] += getPendingReward(_to); lastUpdate[_to] = block.timestamp; } } // Pay out the holder. function claimReward() external whenNotPaused { //Ribbit earned through LFLC staking will not be claimable after 200M LFLC cap has been minted. require(_totalSupply < cap, "Sorry ser, LFLC staking has ended."); // Mint the user their tokens. _mint(msg.sender, rewards[msg.sender] + getPendingReward(msg.sender)); // Reset the rewards for the user. rewards[msg.sender] = 0; lastUpdate[msg.sender] = block.timestamp; } // The rewards to the user. function getTotalClaimable(address user) external view returns(uint256) { return rewards[user] + getPendingReward(user); } // The rewards to the user. function getlastUpdate(address user) external view returns(uint256) { return lastUpdate[user]; } // gets the Ribbit you own and returns it for our staking dapp function getRibbit(address user) external view returns (uint256) { uint256 balance = balanceOf(user); return balance; } // gets the LFLC NFTs you own and returns it for our staking dapp function getLFLC(address user) external view returns (uint256) { uint256 balance = LFLC.balanceOf(user); return balance; } // gets the LFLC token ids you own and returns it for our staking dapp function getLFLCTokenIds(address _owner) public view returns (uint256[] memory _tokensOfOwner) { _tokensOfOwner = new uint256[](LFLC.balanceOf(_owner)); for (uint256 i;i<LFLC.balanceOf(_owner);i++){ _tokensOfOwner[i] = LFLC.tokenOfOwnerByIndex(_owner, i); } } // Get the total rewards. function getPendingReward(address user) internal view returns(uint256) { return LFLC.balanceOf(user) * rate * (block.timestamp - (lastUpdate[user] >= startBlock ? lastUpdate[user] : startBlock)) / interval; } }
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; } }
pragma solidity ^0.8.0; import "./IERC20.sol"; import "./IERC20Metadata.sol"; import "./Context.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 public _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); unchecked { _approve(sender, _msgSender(), currentAllowance - amount); } return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(_msgSender(), spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `sender` to `recipient`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer( address sender, address recipient, uint256 amount ) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[sender] = senderBalance - amount; } _balances[recipient] += amount; emit Transfer(sender, recipient, amount); _afterTokenTransfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens 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 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} }
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); }
pragma solidity ^0.8.0; import "./IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
/** *Submitted for verification at Etherscan.io on 2021-09-15 */ // Sources flattened with hardhat v2.6.4 https://hardhat.org // File @openzeppelin/contracts/utils/introspection/[email protected] // SPDX-License-Identifier: MIT import "./Ownable.sol"; import "./Pausable.sol"; import "./Context.sol"; pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File @openzeppelin/contracts/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 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/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/finance/[email protected] pragma solidity ^0.8.0; /** * @title PaymentSplitter * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware * that the Ether will be split in this way, since it is handled transparently by the contract. * * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim * an amount proportional to the percentage of total shares they were assigned. * * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release} * function. */ contract PaymentSplitter is Context { event PayeeAdded(address account, uint256 shares); event PaymentReleased(address to, uint256 amount); event PaymentReceived(address from, uint256 amount); uint256 private _totalShares; uint256 private _totalReleased; mapping(address => uint256) private _shares; mapping(address => uint256) private _released; address[] private _payees; /** * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at * the matching position in the `shares` array. * * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no * duplicates in `payees`. */ constructor(address[] memory payees, uint256[] memory shares_) payable { require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch"); require(payees.length > 0, "PaymentSplitter: no payees"); for (uint256 i = 0; i < payees.length; i++) { _addPayee(payees[i], shares_[i]); } } /** * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the * reliability of the events, and not the actual splitting of Ether. * * To learn more about this see the Solidity documentation for * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback * functions]. */ receive() external payable virtual { emit PaymentReceived(_msgSender(), msg.value); } /** * @dev Getter for the total shares held by payees. */ function totalShares() public view returns (uint256) { return _totalShares; } /** * @dev Getter for the total amount of Ether already released. */ function totalReleased() public view returns (uint256) { return _totalReleased; } /** * @dev Getter for the amount of shares held by an account. */ function shares(address account) public view returns (uint256) { return _shares[account]; } /** * @dev Getter for the amount of Ether already released to a payee. */ function released(address account) public view returns (uint256) { return _released[account]; } /** * @dev Getter for the address of the payee number `index`. */ function payee(uint256 index) public view returns (address) { return _payees[index]; } /** * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the * total shares and their previous withdrawals. */ function release(address payable account) public virtual { require(_shares[account] > 0, "PaymentSplitter: account has no shares"); uint256 totalReceived = address(this).balance + _totalReleased; uint256 payment = (totalReceived * _shares[account]) / _totalShares - _released[account]; require(payment != 0, "PaymentSplitter: account is not due payment"); _released[account] = _released[account] + payment; _totalReleased = _totalReleased + payment; Address.sendValue(account, payment); emit PaymentReleased(account, payment); } /** * @dev Add a new payee to the contract. * @param account The address of the payee to add. * @param shares_ The number of shares owned by the payee. */ function _addPayee(address account, uint256 shares_) private { require(account != address(0), "PaymentSplitter: account is the zero address"); require(shares_ > 0, "PaymentSplitter: shares are 0"); require(_shares[account] == 0, "PaymentSplitter: account already has shares"); _payees.push(account); _shares[account] = shares_; _totalShares = _totalShares + shares_; emit PayeeAdded(account, shares_); } } // File contracts/LFLC.sol pragma solidity ^0.8.0; contract LFLC is ERC721Enumerable, Ownable, PaymentSplitter { using Strings for uint256; uint256 private _price = 0.042 ether; string public _baseTokenURI = ''; string public FROG_PROVENANCE = ''; uint256 public MAX_TOKENS_PER_TRANSACTION = 20; uint256 public MAX_SUPPLY = 10000; uint256 public _startTime = 1631300400; mapping(uint => string) private _owners; // Withdrawal addresses address t1 = 0xD02bf9b3DA78BEc791014EB3cEecA65990cb046F; address t2 = 0x4c6b83Ca1c59781faB57790a46281bbd93E539FE; address t3 = 0x83343A12e98E0044bF5b0DcD11818961CB5E9FdA; address[] addressList = [t1, t2, t3]; uint256[] shareList = [15, 15, 70]; constructor() ERC721("Lonely Frog Lambo Club", "LFLC") PaymentSplitter(addressList, shareList) {} function mint(uint256 _count) public payable { uint256 supply = totalSupply(); require( block.timestamp >= _startTime, "General sale has not started yet" ); require( _count <= MAX_TOKENS_PER_TRANSACTION, "You can mint a maximum of 20 Frogs per transaction" ); require( supply + _count <= MAX_SUPPLY, "Exceeds current Frog supply limit" ); require( msg.value >= _price * _count, "Ether sent is not correct" ); for(uint256 i; i < _count; i++){ _safeMint( msg.sender, supply + i ); } } function airdrop(address _wallet, uint256 _count) public onlyOwner { uint256 supply = totalSupply(); require(supply + _count <= MAX_SUPPLY, "Exceeds maximum Frog supply"); for(uint256 i; i < _count; i++){ _safeMint(_wallet, supply + i ); } } // Just in case Eth does some crazy stuff function setPrice(uint256 _newPrice) public onlyOwner { _price = _newPrice; } function _baseURI() internal view virtual override returns (string memory) { return _baseTokenURI; } function setBaseURI(string memory _newBaseURI) public onlyOwner { _baseTokenURI = _newBaseURI; } function getPrice() public view returns (uint256){ return _price; } function setProvenanceHash(string memory _provenanceHash) public onlyOwner { FROG_PROVENANCE = _provenanceHash; } function walletOfOwner(address _owner) public view returns(uint256[] memory) { uint256 tokenCount = balanceOf(_owner); uint256[] memory tokensId = new uint256[](tokenCount); for(uint256 i; i < tokenCount; i++){ tokensId[i] = tokenOfOwnerByIndex(_owner, i); } return tokensId; } function setStartTime(uint256 _newStartTime) public onlyOwner { _startTime = _newStartTime; } }
pragma solidity ^0.8.0; import "./Context.sol"; /** * @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); } }
pragma solidity ^0.8.0; import "./Context.sol"; /** * @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()); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"lflcAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","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":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"LFLC","outputs":[{"internalType":"contract InterfaceLFLC","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"addController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getLFLC","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"getLFLCTokenIds","outputs":[{"internalType":"uint256[]","name":"_tokensOfOwner","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getRibbit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getTotalClaimable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getlastUpdate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"interval","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastUpdate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mintSecondPhase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller","type":"address"}],"name":"removeController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_interval","type":"uint256"},{"internalType":"uint256","name":"_rate","type":"uint256"}],"name":"setIntervalAndRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_lflc","type":"address"}],"name":"setLFLCContractAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"arg","type":"uint256"}],"name":"setStartBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","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":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"transferTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","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)
000000000000000000000000549d38f104ac46d856c1b2bf2a20d170efdb2a8d
-----Decoded View---------------
Arg [0] : lflcAddress (address): 0x549d38F104AC46d856C1b2bF2A20D170EfdB2a8D
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000549d38f104ac46d856c1b2bf2a20d170efdb2a8d
Deployed Bytecode Sourcemap
344:5119:7:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2278:182;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2089:100:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;866:42:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4256:169:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3209:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4907:492;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4032:136:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;692:40;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3051:93:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;778:45:7;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5808:215:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4395:142:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1497:27:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1628:51:7;;;:::i;:::-;;568:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4845:304;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4616:145;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1039:86:6;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1938:141:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3038:429;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3380:127:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1615:94:5;;;:::i;:::-;;397:25:7;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1553:47;;;:::i;:::-;;964:87:5;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;650:35:7;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2308:104:1;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6526:413;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2573:111:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3720:175:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2136:110:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3503:488;;;:::i;:::-;;4209:110;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;959:45;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3958:151:1;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1864:192:5;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1716:185:7;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2807:115;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2278:182;1195:12:5;:10;:12::i;:::-;1184:23;;:7;:5;:7::i;:::-;:23;;;1176:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2369:11:7::1;:23;2381:10;2369:23;;;;;;;;;;;;;;;;;;;;;;;;;2361:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;2433:19;2439:4;2445:6;2433:5;:19::i;:::-;2278:182:::0;;:::o;2089:100:1:-;2143:13;2176:5;2169:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2089:100;:::o;866:42:7:-;;;;;;;;;;;;;;;;;:::o;4256:169:1:-;4339:4;4356:39;4365:12;:10;:12::i;:::-;4379:7;4388:6;4356:8;:39::i;:::-;4413:4;4406:11;;4256:169;;;;:::o;3209:108::-;3270:7;3297:12;;3290:19;;3209:108;:::o;4907:492::-;5047:4;5064:36;5074:6;5082:9;5093:6;5064:9;:36::i;:::-;5113:24;5140:11;:19;5152:6;5140:19;;;;;;;;;;;;;;;:33;5160:12;:10;:12::i;:::-;5140:33;;;;;;;;;;;;;;;;5113:60;;5212:6;5192:16;:26;;5184:79;;;;;;;;;;;;:::i;:::-;;;;;;;;;5299:57;5308:6;5316:12;:10;:12::i;:::-;5349:6;5330:16;:25;5299:8;:57::i;:::-;5387:4;5380:11;;;4907:492;;;;;:::o;4032:136:7:-;4095:7;4138:22;4155:4;4138:16;:22::i;:::-;4122:7;:13;4130:4;4122:13;;;;;;;;;;;;;;;;:38;;;;:::i;:::-;4115:45;;4032:136;;;:::o;692:40::-;;;;:::o;3051:93:1:-;3109:5;3134:2;3127:9;;3051:93;:::o;778:45:7:-;808:15;778:45;:::o;5808:215:1:-;5896:4;5913:80;5922:12;:10;:12::i;:::-;5936:7;5982:10;5945:11;:25;5957:12;:10;:12::i;:::-;5945:25;;;;;;;;;;;;;;;:34;5971:7;5945:34;;;;;;;;;;;;;;;;:47;;;;:::i;:::-;5913:8;:80::i;:::-;6011:4;6004:11;;5808:215;;;;:::o;4395:142:7:-;4451:7;4471:15;4489;4499:4;4489:9;:15::i;:::-;4471:33;;4522:7;4515:14;;;4395:142;;;:::o;1497:27:1:-;;;;:::o;1628:51:7:-;1195:12:5;:10;:12::i;:::-;1184:23;;:7;:5;:7::i;:::-;:23;;;1176:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1666:10:7::1;:8;:10::i;:::-;1628:51::o:0;568:25::-;;;;:::o;4845:304::-;4907:31;4982:4;;;;;;;;;;;:14;;;4997:6;4982:22;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4968:37;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4951:54;;5021:9;5016:126;5033:4;;;;;;;;;;;:14;;;5048:6;5033:22;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5031:1;:24;5016:126;;;5095:4;;;;;;;;;;;:24;;;5120:6;5128:1;5095:35;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5075:14;5090:1;5075:17;;;;;;;;:::i;:::-;;;;;;;:55;;;;;5056:3;;;;;:::i;:::-;;;;5016:126;;;;4845:304;;;:::o;4616:145::-;4670:7;4690:15;4708:4;;;;;;;;;;;:14;;;4723:4;4708:20;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4690:38;;4746:7;4739:14;;;4616:145;;;:::o;1039:86:6:-;1086:4;1110:7;;;;;;;;;;;1103:14;;1039:86;:::o;1938:141:7:-;1195:12:5;:10;:12::i;:::-;1184:23;;:7;:5;:7::i;:::-;:23;;;1176:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2039:9:7::1;2028:8;:20;;;;2066:5;2059:4;:12;;;;1938:141:::0;;:::o;3038:429::-;1131:4;;;;;;;;;;;1109:27;;:10;:27;;;1101:36;;;;;;1365:8:6::1;:6;:8::i;:::-;1364:9;1356:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;3186:1:7::2;3169:19;;:5;:19;;;3166:145;;3225:23;3242:5;3225:16;:23::i;:::-;3204:7;:14;3212:5;3204:14;;;;;;;;;;;;;;;;:44;;;;;;;:::i;:::-;;;;;;;;3284:15;3263:10;:17;3274:5;3263:17;;;;;;;;;;;;;;;:36;;;;3166:145;3341:1;3326:17;;:3;:17;;;3323:137;;3378:21;3395:3;3378:16;:21::i;:::-;3359:7;:12;3367:3;3359:12;;;;;;;;;;;;;;;;:40;;;;;;;:::i;:::-;;;;;;;;3433:15;3414:10;:15;3425:3;3414:15;;;;;;;;;;;;;;;:34;;;;3323:137;3038:429:::0;;:::o;3380:127:1:-;3454:7;3481:9;:18;3491:7;3481:18;;;;;;;;;;;;;;;;3474:25;;3380:127;;;:::o;1615:94:5:-;1195:12;:10;:12::i;:::-;1184:23;;:7;:5;:7::i;:::-;:23;;;1176:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1680:21:::1;1698:1;1680:9;:21::i;:::-;1615:94::o:0;397:25:7:-;;;;;;;;;;;;;:::o;1553:47::-;1195:12:5;:10;:12::i;:::-;1184:23;;:7;:5;:7::i;:::-;:23;;;1176:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1589:8:7::1;:6;:8::i;:::-;1553:47::o:0;964:87:5:-;1010:7;1037:6;;;;;;;;;;;1030:13;;964:87;:::o;650:35:7:-;;;;:::o;2308:104:1:-;2364:13;2397:7;2390:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2308:104;:::o;6526:413::-;6619:4;6636:24;6663:11;:25;6675:12;:10;:12::i;:::-;6663:25;;;;;;;;;;;;;;;:34;6689:7;6663:34;;;;;;;;;;;;;;;;6636:61;;6736:15;6716:16;:35;;6708:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;6829:67;6838:12;:10;:12::i;:::-;6852:7;6880:15;6861:16;:34;6829:8;:67::i;:::-;6927:4;6920:11;;;6526:413;;;;:::o;2573:111:7:-;1195:12:5;:10;:12::i;:::-;1184:23;;:7;:5;:7::i;:::-;:23;;;1176:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2672:4:7::1;2646:11;:23;2658:10;2646:23;;;;;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;2573:111:::0;:::o;3720:175:1:-;3806:4;3823:42;3833:12;:10;:12::i;:::-;3847:9;3858:6;3823:9;:42::i;:::-;3883:4;3876:11;;3720:175;;;;:::o;2136:110:7:-;1195:12:5;:10;:12::i;:::-;1184:23;;:7;:5;:7::i;:::-;:23;;;1176:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2232:5:7::1;2211:4;;:27;;;;;;;;;;;;;;;;;;2136:110:::0;:::o;3503:488::-;1365:8:6;:6;:8::i;:::-;1364:9;1356:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;808:15:7::1;3673:12;;:18;3665:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;3783:69;3789:10;3823:28;3840:10;3823:16;:28::i;:::-;3801:7;:19;3809:10;3801:19;;;;;;;;;;;;;;;;:50;;;;:::i;:::-;3783:5;:69::i;:::-;3931:1;3909:7;:19;3917:10;3909:19;;;;;;;;;;;;;;;:23;;;;3968:15;3943:10;:22;3954:10;3943:22;;;;;;;;;;;;;;;:40;;;;3503:488::o:0;4209:110::-;4268:7;4295:10;:16;4306:4;4295:16;;;;;;;;;;;;;;;;4288:23;;4209:110;;;:::o;959:45::-;;;;;;;;;;;;;;;;;:::o;3958:151:1:-;4047:7;4074:11;:18;4086:5;4074:18;;;;;;;;;;;;;;;:27;4093:7;4074:27;;;;;;;;;;;;;;;;4067:34;;3958:151;;;;:::o;1864:192:5:-;1195:12;:10;:12::i;:::-;1184:23;;:7;:5;:7::i;:::-;:23;;;1176:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1973:1:::1;1953:22;;:8;:22;;;;1945:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2029:19;2039:8;2029:9;:19::i;:::-;1864:192:::0;:::o;1716:185:7:-;1195:12:5;:10;:12::i;:::-;1184:23;;:7;:5;:7::i;:::-;:23;;;1176:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1790:1:7::1;1783:3;:8;1780:114;;;1820:15;1807:10;:28;;;;1780:114;;;1879:3;1866:10;:16;;;;1780:114;1716:185:::0;:::o;2807:115::-;1195:12:5;:10;:12::i;:::-;1184:23;;:7;:5;:7::i;:::-;:23;;;1176:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;2909:5:7::1;2883:11;:23;2895:10;2883:23;;;;;;;;;;;;;;;;:31;;;;;;;;;;;;;;;;;;2807:115:::0;:::o;567:98:0:-;620:7;647:10;640:17;;567:98;:::o;8449:399:1:-;8552:1;8533:21;;:7;:21;;;;8525:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;8603:49;8632:1;8636:7;8645:6;8603:20;:49::i;:::-;8681:6;8665:12;;:22;;;;;;;:::i;:::-;;;;;;;;8720:6;8698:9;:18;8708:7;8698:18;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;8763:7;8742:37;;8759:1;8742:37;;;8772:6;8742:37;;;;;;:::i;:::-;;;;;;;;8792:48;8820:1;8824:7;8833:6;8792:19;:48::i;:::-;8449:399;;:::o;10210:380::-;10363:1;10346:19;;:5;:19;;;;10338:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;10444:1;10425:21;;:7;:21;;;;10417:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;10528:6;10498:11;:18;10510:5;10498:18;;;;;;;;;;;;;;;:27;10517:7;10498:27;;;;;;;;;;;;;;;:36;;;;10566:7;10550:32;;10559:5;10550:32;;;10575:6;10550:32;;;;;;:::i;:::-;;;;;;;;10210:380;;;:::o;7429:733::-;7587:1;7569:20;;:6;:20;;;;7561:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;7671:1;7650:23;;:9;:23;;;;7642:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;7726:47;7747:6;7755:9;7766:6;7726:20;:47::i;:::-;7786:21;7810:9;:17;7820:6;7810:17;;;;;;;;;;;;;;;;7786:41;;7863:6;7846:13;:23;;7838:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;7984:6;7968:13;:22;7948:9;:17;7958:6;7948:17;;;;;;;;;;;;;;;:42;;;;8036:6;8012:9;:20;8022:9;8012:20;;;;;;;;;;;;;;;;:30;;;;;;;:::i;:::-;;;;;;;;8077:9;8060:35;;8069:6;8060:35;;;8088:6;8060:35;;;;;;:::i;:::-;;;;;;;;8108:46;8128:6;8136:9;8147:6;8108:19;:46::i;:::-;7550:612;7429:733;;;:::o;5188:272:7:-;5250:7;5444:8;;5380:10;;5360;:16;5371:4;5360:16;;;;;;;;;;;;;;;;:30;;:62;;5412:10;;5360:62;;;5393:10;:16;5404:4;5393:16;;;;;;;;;;;;;;;;5360:62;5341:15;:82;;;;:::i;:::-;5317:4;;5277;;;;;;;;;;;:14;;;5292:4;5277:20;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;;;;:::i;:::-;:147;;;;:::i;:::-;:175;;;;:::i;:::-;5270:182;;5188:272;;;:::o;2098:120:6:-;1642:8;:6;:8::i;:::-;1634:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;2167:5:::1;2157:7;;:15;;;;;;;;;;;;;;;;;;2188:22;2197:12;:10;:12::i;:::-;2188:22;;;;;;:::i;:::-;;;;;;;;2098:120::o:0;2064:173:5:-;2120:16;2139:6;;;;;;;;;;;2120:25;;2165:8;2156:6;;:17;;;;;;;;;;;;;;;;;;2220:8;2189:40;;2210:8;2189:40;;;;;;;;;;;;2109:128;2064:173;:::o;1839:118:6:-;1365:8;:6;:8::i;:::-;1364:9;1356:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;1909:4:::1;1899:7;;:14;;;;;;;;;;;;;;;;;;1929:20;1936:12;:10;:12::i;:::-;1929:20;;;;;;:::i;:::-;;;;;;;;1839:118::o:0;11190:125:1:-;;;;:::o;11919:124::-;;;;:::o;7:139:8:-;53:5;91:6;78:20;69:29;;107:33;134:5;107:33;:::i;:::-;7:139;;;;:::o;152:::-;198:5;236:6;223:20;214:29;;252:33;279:5;252:33;:::i;:::-;152:139;;;;:::o;297:143::-;354:5;385:6;379:13;370:22;;401:33;428:5;401:33;:::i;:::-;297:143;;;;:::o;446:329::-;505:6;554:2;542:9;533:7;529:23;525:32;522:119;;;560:79;;:::i;:::-;522:119;680:1;705:53;750:7;741:6;730:9;726:22;705:53;:::i;:::-;695:63;;651:117;446:329;;;;:::o;781:474::-;849:6;857;906:2;894:9;885:7;881:23;877:32;874:119;;;912:79;;:::i;:::-;874:119;1032:1;1057:53;1102:7;1093:6;1082:9;1078:22;1057:53;:::i;:::-;1047:63;;1003:117;1159:2;1185:53;1230:7;1221:6;1210:9;1206:22;1185:53;:::i;:::-;1175:63;;1130:118;781:474;;;;;:::o;1261:619::-;1338:6;1346;1354;1403:2;1391:9;1382:7;1378:23;1374:32;1371:119;;;1409:79;;:::i;:::-;1371:119;1529:1;1554:53;1599:7;1590:6;1579:9;1575:22;1554:53;:::i;:::-;1544:63;;1500:117;1656:2;1682:53;1727:7;1718:6;1707:9;1703:22;1682:53;:::i;:::-;1672:63;;1627:118;1784:2;1810:53;1855:7;1846:6;1835:9;1831:22;1810:53;:::i;:::-;1800:63;;1755:118;1261:619;;;;;:::o;1886:474::-;1954:6;1962;2011:2;1999:9;1990:7;1986:23;1982:32;1979:119;;;2017:79;;:::i;:::-;1979:119;2137:1;2162:53;2207:7;2198:6;2187:9;2183:22;2162:53;:::i;:::-;2152:63;;2108:117;2264:2;2290:53;2335:7;2326:6;2315:9;2311:22;2290:53;:::i;:::-;2280:63;;2235:118;1886:474;;;;;:::o;2366:329::-;2425:6;2474:2;2462:9;2453:7;2449:23;2445:32;2442:119;;;2480:79;;:::i;:::-;2442:119;2600:1;2625:53;2670:7;2661:6;2650:9;2646:22;2625:53;:::i;:::-;2615:63;;2571:117;2366:329;;;;:::o;2701:351::-;2771:6;2820:2;2808:9;2799:7;2795:23;2791:32;2788:119;;;2826:79;;:::i;:::-;2788:119;2946:1;2971:64;3027:7;3018:6;3007:9;3003:22;2971:64;:::i;:::-;2961:74;;2917:128;2701:351;;;;:::o;3058:474::-;3126:6;3134;3183:2;3171:9;3162:7;3158:23;3154:32;3151:119;;;3189:79;;:::i;:::-;3151:119;3309:1;3334:53;3379:7;3370:6;3359:9;3355:22;3334:53;:::i;:::-;3324:63;;3280:117;3436:2;3462:53;3507:7;3498:6;3487:9;3483:22;3462:53;:::i;:::-;3452:63;;3407:118;3058:474;;;;;:::o;3538:179::-;3607:10;3628:46;3670:3;3662:6;3628:46;:::i;:::-;3706:4;3701:3;3697:14;3683:28;;3538:179;;;;:::o;3723:118::-;3810:24;3828:5;3810:24;:::i;:::-;3805:3;3798:37;3723:118;;:::o;3877:732::-;3996:3;4025:54;4073:5;4025:54;:::i;:::-;4095:86;4174:6;4169:3;4095:86;:::i;:::-;4088:93;;4205:56;4255:5;4205:56;:::i;:::-;4284:7;4315:1;4300:284;4325:6;4322:1;4319:13;4300:284;;;4401:6;4395:13;4428:63;4487:3;4472:13;4428:63;:::i;:::-;4421:70;;4514:60;4567:6;4514:60;:::i;:::-;4504:70;;4360:224;4347:1;4344;4340:9;4335:14;;4300:284;;;4304:14;4600:3;4593:10;;4001:608;;;3877:732;;;;:::o;4615:109::-;4696:21;4711:5;4696:21;:::i;:::-;4691:3;4684:34;4615:109;;:::o;4730:175::-;4839:59;4892:5;4839:59;:::i;:::-;4834:3;4827:72;4730:175;;:::o;4911:364::-;4999:3;5027:39;5060:5;5027:39;:::i;:::-;5082:71;5146:6;5141:3;5082:71;:::i;:::-;5075:78;;5162:52;5207:6;5202:3;5195:4;5188:5;5184:16;5162:52;:::i;:::-;5239:29;5261:6;5239:29;:::i;:::-;5234:3;5230:39;5223:46;;5003:272;4911:364;;;;:::o;5281:366::-;5423:3;5444:67;5508:2;5503:3;5444:67;:::i;:::-;5437:74;;5520:93;5609:3;5520:93;:::i;:::-;5638:2;5633:3;5629:12;5622:19;;5281:366;;;:::o;5653:::-;5795:3;5816:67;5880:2;5875:3;5816:67;:::i;:::-;5809:74;;5892:93;5981:3;5892:93;:::i;:::-;6010:2;6005:3;6001:12;5994:19;;5653:366;;;:::o;6025:::-;6167:3;6188:67;6252:2;6247:3;6188:67;:::i;:::-;6181:74;;6264:93;6353:3;6264:93;:::i;:::-;6382:2;6377:3;6373:12;6366:19;;6025:366;;;:::o;6397:::-;6539:3;6560:67;6624:2;6619:3;6560:67;:::i;:::-;6553:74;;6636:93;6725:3;6636:93;:::i;:::-;6754:2;6749:3;6745:12;6738:19;;6397:366;;;:::o;6769:::-;6911:3;6932:67;6996:2;6991:3;6932:67;:::i;:::-;6925:74;;7008:93;7097:3;7008:93;:::i;:::-;7126:2;7121:3;7117:12;7110:19;;6769:366;;;:::o;7141:::-;7283:3;7304:67;7368:2;7363:3;7304:67;:::i;:::-;7297:74;;7380:93;7469:3;7380:93;:::i;:::-;7498:2;7493:3;7489:12;7482:19;;7141:366;;;:::o;7513:::-;7655:3;7676:67;7740:2;7735:3;7676:67;:::i;:::-;7669:74;;7752:93;7841:3;7752:93;:::i;:::-;7870:2;7865:3;7861:12;7854:19;;7513:366;;;:::o;7885:::-;8027:3;8048:67;8112:2;8107:3;8048:67;:::i;:::-;8041:74;;8124:93;8213:3;8124:93;:::i;:::-;8242:2;8237:3;8233:12;8226:19;;7885:366;;;:::o;8257:::-;8399:3;8420:67;8484:2;8479:3;8420:67;:::i;:::-;8413:74;;8496:93;8585:3;8496:93;:::i;:::-;8614:2;8609:3;8605:12;8598:19;;8257:366;;;:::o;8629:::-;8771:3;8792:67;8856:2;8851:3;8792:67;:::i;:::-;8785:74;;8868:93;8957:3;8868:93;:::i;:::-;8986:2;8981:3;8977:12;8970:19;;8629:366;;;:::o;9001:::-;9143:3;9164:67;9228:2;9223:3;9164:67;:::i;:::-;9157:74;;9240:93;9329:3;9240:93;:::i;:::-;9358:2;9353:3;9349:12;9342:19;;9001:366;;;:::o;9373:::-;9515:3;9536:67;9600:2;9595:3;9536:67;:::i;:::-;9529:74;;9612:93;9701:3;9612:93;:::i;:::-;9730:2;9725:3;9721:12;9714:19;;9373:366;;;:::o;9745:::-;9887:3;9908:67;9972:2;9967:3;9908:67;:::i;:::-;9901:74;;9984:93;10073:3;9984:93;:::i;:::-;10102:2;10097:3;10093:12;10086:19;;9745:366;;;:::o;10117:::-;10259:3;10280:67;10344:2;10339:3;10280:67;:::i;:::-;10273:74;;10356:93;10445:3;10356:93;:::i;:::-;10474:2;10469:3;10465:12;10458:19;;10117:366;;;:::o;10489:108::-;10566:24;10584:5;10566:24;:::i;:::-;10561:3;10554:37;10489:108;;:::o;10603:118::-;10690:24;10708:5;10690:24;:::i;:::-;10685:3;10678:37;10603:118;;:::o;10727:112::-;10810:22;10826:5;10810:22;:::i;:::-;10805:3;10798:35;10727:112;;:::o;10845:222::-;10938:4;10976:2;10965:9;10961:18;10953:26;;10989:71;11057:1;11046:9;11042:17;11033:6;10989:71;:::i;:::-;10845:222;;;;:::o;11073:332::-;11194:4;11232:2;11221:9;11217:18;11209:26;;11245:71;11313:1;11302:9;11298:17;11289:6;11245:71;:::i;:::-;11326:72;11394:2;11383:9;11379:18;11370:6;11326:72;:::i;:::-;11073:332;;;;;:::o;11411:373::-;11554:4;11592:2;11581:9;11577:18;11569:26;;11641:9;11635:4;11631:20;11627:1;11616:9;11612:17;11605:47;11669:108;11772:4;11763:6;11669:108;:::i;:::-;11661:116;;11411:373;;;;:::o;11790:210::-;11877:4;11915:2;11904:9;11900:18;11892:26;;11928:65;11990:1;11979:9;11975:17;11966:6;11928:65;:::i;:::-;11790:210;;;;:::o;12006:266::-;12121:4;12159:2;12148:9;12144:18;12136:26;;12172:93;12262:1;12251:9;12247:17;12238:6;12172:93;:::i;:::-;12006:266;;;;:::o;12278:313::-;12391:4;12429:2;12418:9;12414:18;12406:26;;12478:9;12472:4;12468:20;12464:1;12453:9;12449:17;12442:47;12506:78;12579:4;12570:6;12506:78;:::i;:::-;12498:86;;12278:313;;;;:::o;12597:419::-;12763:4;12801:2;12790:9;12786:18;12778:26;;12850:9;12844:4;12840:20;12836:1;12825:9;12821:17;12814:47;12878:131;13004:4;12878:131;:::i;:::-;12870:139;;12597:419;;;:::o;13022:::-;13188:4;13226:2;13215:9;13211:18;13203:26;;13275:9;13269:4;13265:20;13261:1;13250:9;13246:17;13239:47;13303:131;13429:4;13303:131;:::i;:::-;13295:139;;13022:419;;;:::o;13447:::-;13613:4;13651:2;13640:9;13636:18;13628:26;;13700:9;13694:4;13690:20;13686:1;13675:9;13671:17;13664:47;13728:131;13854:4;13728:131;:::i;:::-;13720:139;;13447:419;;;:::o;13872:::-;14038:4;14076:2;14065:9;14061:18;14053:26;;14125:9;14119:4;14115:20;14111:1;14100:9;14096:17;14089:47;14153:131;14279:4;14153:131;:::i;:::-;14145:139;;13872:419;;;:::o;14297:::-;14463:4;14501:2;14490:9;14486:18;14478:26;;14550:9;14544:4;14540:20;14536:1;14525:9;14521:17;14514:47;14578:131;14704:4;14578:131;:::i;:::-;14570:139;;14297:419;;;:::o;14722:::-;14888:4;14926:2;14915:9;14911:18;14903:26;;14975:9;14969:4;14965:20;14961:1;14950:9;14946:17;14939:47;15003:131;15129:4;15003:131;:::i;:::-;14995:139;;14722:419;;;:::o;15147:::-;15313:4;15351:2;15340:9;15336:18;15328:26;;15400:9;15394:4;15390:20;15386:1;15375:9;15371:17;15364:47;15428:131;15554:4;15428:131;:::i;:::-;15420:139;;15147:419;;;:::o;15572:::-;15738:4;15776:2;15765:9;15761:18;15753:26;;15825:9;15819:4;15815:20;15811:1;15800:9;15796:17;15789:47;15853:131;15979:4;15853:131;:::i;:::-;15845:139;;15572:419;;;:::o;15997:::-;16163:4;16201:2;16190:9;16186:18;16178:26;;16250:9;16244:4;16240:20;16236:1;16225:9;16221:17;16214:47;16278:131;16404:4;16278:131;:::i;:::-;16270:139;;15997:419;;;:::o;16422:::-;16588:4;16626:2;16615:9;16611:18;16603:26;;16675:9;16669:4;16665:20;16661:1;16650:9;16646:17;16639:47;16703:131;16829:4;16703:131;:::i;:::-;16695:139;;16422:419;;;:::o;16847:::-;17013:4;17051:2;17040:9;17036:18;17028:26;;17100:9;17094:4;17090:20;17086:1;17075:9;17071:17;17064:47;17128:131;17254:4;17128:131;:::i;:::-;17120:139;;16847:419;;;:::o;17272:::-;17438:4;17476:2;17465:9;17461:18;17453:26;;17525:9;17519:4;17515:20;17511:1;17500:9;17496:17;17489:47;17553:131;17679:4;17553:131;:::i;:::-;17545:139;;17272:419;;;:::o;17697:::-;17863:4;17901:2;17890:9;17886:18;17878:26;;17950:9;17944:4;17940:20;17936:1;17925:9;17921:17;17914:47;17978:131;18104:4;17978:131;:::i;:::-;17970:139;;17697:419;;;:::o;18122:::-;18288:4;18326:2;18315:9;18311:18;18303:26;;18375:9;18369:4;18365:20;18361:1;18350:9;18346:17;18339:47;18403:131;18529:4;18403:131;:::i;:::-;18395:139;;18122:419;;;:::o;18547:222::-;18640:4;18678:2;18667:9;18663:18;18655:26;;18691:71;18759:1;18748:9;18744:17;18735:6;18691:71;:::i;:::-;18547:222;;;;:::o;18775:214::-;18864:4;18902:2;18891:9;18887:18;18879:26;;18915:67;18979:1;18968:9;18964:17;18955:6;18915:67;:::i;:::-;18775:214;;;;:::o;19076:132::-;19143:4;19166:3;19158:11;;19196:4;19191:3;19187:14;19179:22;;19076:132;;;:::o;19214:114::-;19281:6;19315:5;19309:12;19299:22;;19214:114;;;:::o;19334:99::-;19386:6;19420:5;19414:12;19404:22;;19334:99;;;:::o;19439:113::-;19509:4;19541;19536:3;19532:14;19524:22;;19439:113;;;:::o;19558:184::-;19657:11;19691:6;19686:3;19679:19;19731:4;19726:3;19722:14;19707:29;;19558:184;;;;:::o;19748:169::-;19832:11;19866:6;19861:3;19854:19;19906:4;19901:3;19897:14;19882:29;;19748:169;;;;:::o;19923:305::-;19963:3;19982:20;20000:1;19982:20;:::i;:::-;19977:25;;20016:20;20034:1;20016:20;:::i;:::-;20011:25;;20170:1;20102:66;20098:74;20095:1;20092:81;20089:107;;;20176:18;;:::i;:::-;20089:107;20220:1;20217;20213:9;20206:16;;19923:305;;;;:::o;20234:185::-;20274:1;20291:20;20309:1;20291:20;:::i;:::-;20286:25;;20325:20;20343:1;20325:20;:::i;:::-;20320:25;;20364:1;20354:35;;20369:18;;:::i;:::-;20354:35;20411:1;20408;20404:9;20399:14;;20234:185;;;;:::o;20425:348::-;20465:7;20488:20;20506:1;20488:20;:::i;:::-;20483:25;;20522:20;20540:1;20522:20;:::i;:::-;20517:25;;20710:1;20642:66;20638:74;20635:1;20632:81;20627:1;20620:9;20613:17;20609:105;20606:131;;;20717:18;;:::i;:::-;20606:131;20765:1;20762;20758:9;20747:20;;20425:348;;;;:::o;20779:191::-;20819:4;20839:20;20857:1;20839:20;:::i;:::-;20834:25;;20873:20;20891:1;20873:20;:::i;:::-;20868:25;;20912:1;20909;20906:8;20903:34;;;20917:18;;:::i;:::-;20903:34;20962:1;20959;20955:9;20947:17;;20779:191;;;;:::o;20976:96::-;21013:7;21042:24;21060:5;21042:24;:::i;:::-;21031:35;;20976:96;;;:::o;21078:90::-;21112:7;21155:5;21148:13;21141:21;21130:32;;21078:90;;;:::o;21174:126::-;21211:7;21251:42;21244:5;21240:54;21229:65;;21174:126;;;:::o;21306:77::-;21343:7;21372:5;21361:16;;21306:77;;;:::o;21389:86::-;21424:7;21464:4;21457:5;21453:16;21442:27;;21389:86;;;:::o;21481:148::-;21553:9;21586:37;21617:5;21586:37;:::i;:::-;21573:50;;21481:148;;;:::o;21635:126::-;21685:9;21718:37;21749:5;21718:37;:::i;:::-;21705:50;;21635:126;;;:::o;21767:113::-;21817:9;21850:24;21868:5;21850:24;:::i;:::-;21837:37;;21767:113;;;:::o;21886:307::-;21954:1;21964:113;21978:6;21975:1;21972:13;21964:113;;;22063:1;22058:3;22054:11;22048:18;22044:1;22039:3;22035:11;22028:39;22000:2;21997:1;21993:10;21988:15;;21964:113;;;22095:6;22092:1;22089:13;22086:101;;;22175:1;22166:6;22161:3;22157:16;22150:27;22086:101;21935:258;21886:307;;;:::o;22199:320::-;22243:6;22280:1;22274:4;22270:12;22260:22;;22327:1;22321:4;22317:12;22348:18;22338:81;;22404:4;22396:6;22392:17;22382:27;;22338:81;22466:2;22458:6;22455:14;22435:18;22432:38;22429:84;;;22485:18;;:::i;:::-;22429:84;22250:269;22199:320;;;:::o;22525:233::-;22564:3;22587:24;22605:5;22587:24;:::i;:::-;22578:33;;22633:66;22626:5;22623:77;22620:103;;;22703:18;;:::i;:::-;22620:103;22750:1;22743:5;22739:13;22732:20;;22525:233;;;:::o;22764:180::-;22812:77;22809:1;22802:88;22909:4;22906:1;22899:15;22933:4;22930:1;22923:15;22950:180;22998:77;22995:1;22988:88;23095:4;23092:1;23085:15;23119:4;23116:1;23109:15;23136:180;23184:77;23181:1;23174:88;23281:4;23278:1;23271:15;23305:4;23302:1;23295:15;23322:180;23370:77;23367:1;23360:88;23467:4;23464:1;23457:15;23491:4;23488:1;23481:15;23508:180;23556:77;23553:1;23546:88;23653:4;23650:1;23643:15;23677:4;23674:1;23667:15;23817:117;23926:1;23923;23916:12;23940:102;23981:6;24032:2;24028:7;24023:2;24016:5;24012:14;24008:28;23998:38;;23940:102;;;:::o;24048:222::-;24188:34;24184:1;24176:6;24172:14;24165:58;24257:5;24252:2;24244:6;24240:15;24233:30;24048:222;:::o;24276:170::-;24416:22;24412:1;24404:6;24400:14;24393:46;24276:170;:::o;24452:225::-;24592:34;24588:1;24580:6;24576:14;24569:58;24661:8;24656:2;24648:6;24644:15;24637:33;24452:225;:::o;24683:221::-;24823:34;24819:1;24811:6;24807:14;24800:58;24892:4;24887:2;24879:6;24875:15;24868:29;24683:221;:::o;24910:::-;25050:34;25046:1;25038:6;25034:14;25027:58;25119:4;25114:2;25106:6;25102:15;25095:29;24910:221;:::o;25137:225::-;25277:34;25273:1;25265:6;25261:14;25254:58;25346:8;25341:2;25333:6;25329:15;25322:33;25137:225;:::o;25368:175::-;25508:27;25504:1;25496:6;25492:14;25485:51;25368:175;:::o;25549:166::-;25689:18;25685:1;25677:6;25673:14;25666:42;25549:166;:::o;25721:227::-;25861:34;25857:1;25849:6;25845:14;25838:58;25930:10;25925:2;25917:6;25913:15;25906:35;25721:227;:::o;25954:182::-;26094:34;26090:1;26082:6;26078:14;26071:58;25954:182;:::o;26142:224::-;26282:34;26278:1;26270:6;26266:14;26259:58;26351:7;26346:2;26338:6;26334:15;26327:32;26142:224;:::o;26372:223::-;26512:34;26508:1;26500:6;26496:14;26489:58;26581:6;26576:2;26568:6;26564:15;26557:31;26372:223;:::o;26601:224::-;26741:34;26737:1;26729:6;26725:14;26718:58;26810:7;26805:2;26797:6;26793:15;26786:32;26601:224;:::o;26831:181::-;26971:33;26967:1;26959:6;26955:14;26948:57;26831:181;:::o;27018:122::-;27091:24;27109:5;27091:24;:::i;:::-;27084:5;27081:35;27071:63;;27130:1;27127;27120:12;27071:63;27018:122;:::o;27146:::-;27219:24;27237:5;27219:24;:::i;:::-;27212:5;27209:35;27199:63;;27258:1;27255;27248:12;27199:63;27146:122;:::o
Swarm Source
ipfs://321c0fa7908d43e0382cc3f16254f3d15a8032fa7bf786f0511cfd1e680a68a8
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.