Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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());
    }
}

• 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"}]

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

000000000000000000000000549d38f104ac46d856c1b2bf2a20d170efdb2a8d

-----Decoded View---------------
Arg [0] : lflcAddress (address): 0x549d38F104AC46d856C1b2bF2A20D170EfdB2a8D

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000549d38f104ac46d856c1b2bf2a20d170efdb2a8d

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

ipfs://321c0fa7908d43e0382cc3f16254f3d15a8032fa7bf786f0511cfd1e680a68a8