Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

/*

  Copyright 2019 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity 0.6.12;


interface IERC721Receiver {

    /// @notice Handle the receipt of an NFT
    /// @dev The ERC721 smart contract calls this function on the recipient
    ///  after a `transfer`. This function MAY throw to revert and reject the
    ///  transfer. Return of other than the magic value MUST result in the
    ///  transaction being reverted.
    ///  Note: the contract address is always the message sender.
    /// @param _operator The address which called `safeTransferFrom` function
    /// @param _from The address which previously owned the token
    /// @param _tokenId The NFT identifier which is being transferred
    /// @param _data Additional data with no specified format
    /// @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    ///  unless throwing
    function onERC721Received(
        address _operator,
        address _from,
        uint256 _tokenId,
        bytes calldata _data
    )
    external
    returns (bytes4);
}

// SPDX-License-Identifier: MIT

/*

  Copyright 2019 ZeroEx Intl.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

*/

pragma solidity 0.6.12;


interface IERC721Token {

    /// @dev This emits when ownership of any NFT changes by any mechanism.
    ///      This event emits when NFTs are created (`from` == 0) and destroyed
    ///      (`to` == 0). Exception: during contract creation, any number of NFTs
    ///      may be created and assigned without emitting Transfer. At the time of
    ///      any transfer, the approved address for that NFT (if any) is reset to none.
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );

    /// @dev This emits when the approved address for an NFT is changed or
    ///      reaffirmed. The zero address indicates there is no approved address.
    ///      When a Transfer event emits, this also indicates that the approved
    ///      address for that NFT (if any) is reset to none.
    event Approval(
        address indexed owner,
        address indexed approved,
        uint256 indexed tokenId
    );

    /// @dev This emits when an operator is enabled or disabled for an owner.
    ///      The operator can manage all NFTs of the owner.
    event ApprovalForAll(
        address indexed owner,
        address indexed operator,
        bool approved
    );

    /// @notice Transfers the ownership of an NFT from one address to another address
    /// @dev This works identically to the other function with an extra data parameter,
    ///      except this function just sets data to "".
    /// @param _from The current owner of the NFT
    /// @param _to The new owner
    /// @param _tokenId The NFT to transfer
    function safeTransferFrom(
        address _from,
        address _to,
        uint256 _tokenId
    )
    external;

    /// @notice Transfers the ownership of an NFT from one address to another address
    /// @dev Throws unless `msg.sender` is the current owner, an authorized
    ///      perator, or the approved address for this NFT. Throws if `_from` is
    ///      not the current owner. Throws if `_to` is the zero address. Throws if
    ///      `_tokenId` is not a valid NFT. When transfer is complete, this function
    ///      checks if `_to` is a smart contract (code size > 0). If so, it calls
    ///      `onERC721Received` on `_to` and throws if the return value is not
    ///      `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
    /// @param _from The current owner of the NFT
    /// @param _to The new owner
    /// @param _tokenId The NFT to transfer
    /// @param _data Additional data with no specified format, sent in call to `_to`
    function safeTransferFrom(
        address _from,
        address _to,
        uint256 _tokenId,
        bytes calldata _data
    )
    external;

    /// @notice Change or reaffirm the approved address for an NFT
    /// @dev The zero address indicates there is no approved address.
    ///      Throws unless `msg.sender` is the current NFT owner, or an authorized
    ///      operator of the current owner.
    /// @param _approved The new approved NFT controller
    /// @param _tokenId The NFT to approve
    function approve(address _approved, uint256 _tokenId)
    external;

    /// @notice Enable or disable approval for a third party ("operator") to manage
    ///         all of `msg.sender`'s assets
    /// @dev Emits the ApprovalForAll event. The contract MUST allow
    ///      multiple operators per owner.
    /// @param _operator Address to add to the set of authorized operators
    /// @param _approved True if the operator is approved, false to revoke approval
    function setApprovalForAll(address _operator, bool _approved)
    external;

    /// @notice Count all NFTs assigned to an owner
    /// @dev NFTs assigned to the zero address are considered invalid, and this
    ///      function throws for queries about the zero address.
    /// @param _owner An address for whom to query the balance
    /// @return The number of NFTs owned by `_owner`, possibly zero
    function balanceOf(address _owner)
    external
    view
    returns (uint256);

    /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
    ///         TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
    ///         THEY MAY BE PERMANENTLY LOST
    /// @dev Throws unless `msg.sender` is the current owner, an authorized
    ///      operator, or the approved address for this NFT. Throws if `_from` is
    ///      not the current owner. Throws if `_to` is the zero address. Throws if
    ///      `_tokenId` is not a valid NFT.
    /// @param _from The current owner of the NFT
    /// @param _to The new owner
    /// @param _tokenId The NFT to transfer
    function transferFrom(
        address _from,
        address _to,
        uint256 _tokenId
    )
    external;

    /// @notice Find the owner of an NFT
    /// @dev NFTs assigned to zero address are considered invalid, and queries
    ///      about them do throw.
    /// @param _tokenId The identifier for an NFT
    /// @return The address of the owner of the NFT
    function ownerOf(uint256 _tokenId)
    external
    view
    returns (address);

    /// @notice Get the approved address for a single NFT
    /// @dev Throws if `_tokenId` is not a valid NFT.
    /// @param _tokenId The NFT to find the approved address for
    /// @return The approved address for this NFT, or the zero address if there is none
    function getApproved(uint256 _tokenId)
    external
    view
    returns (address);

    /// @notice Query if an address is an authorized operator for another address
    /// @param _owner The address that owns the NFTs
    /// @param _operator The address that acts on behalf of the owner
    /// @return True if `_operator` is an approved operator for `_owner`, false otherwise
    function isApprovedForAll(address _owner, address _operator)
    external
    view
    returns (bool);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;

// Copyright 2020 Compound Labs, Inc.
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

contract LavaToken {
    ///@dev EIP-20 token name for this token
    string public constant name = "Lava ThunderEgg Token";

    ///@dev EIP-20 token symbol for this token
    string public constant symbol = "LAVA";

    ///@dev EIP-20 token decimals for this token
    uint8 public constant decimals = 18;

    ///@dev Total number of tokens in circulation
    uint public totalSupply;

    ///@dev Minter address
    address public minter;

    ///@dev Allowance amounts on behalf of others
    mapping (address => mapping (address => uint96)) internal allowances;

    ///@dev Official record of token balances for each account
    mapping (address => uint96) internal balances;

    ///@dev A record of each accounts delegate
    mapping (address => address) public delegates;

    ///@dev A checkpoint for marking number of votes from a given block
    struct Checkpoint {
        uint32 fromBlock;
        uint96 votes;
    }

    ///@dev A record of votes checkpoints for each account, by index
    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;

    ///@dev The number of checkpoints for each account
    mapping (address => uint32) public numCheckpoints;

    ///@dev The EIP-712 typehash for the contract's domain
    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");

    ///@dev The EIP-712 typehash for the delegation struct used by the contract
    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

    ///@dev A record of states for signing / validating signatures
    mapping (address => uint) public nonces;

    ///@dev An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    ///@dev An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    ///@dev The standard EIP-20 transfer event
    event Transfer(address indexed from, address indexed to, uint256 amount);

    ///@dev The standard EIP-20 approval event
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    ///@dev An event thats emitted when the minter is changed
    event NewMinter(address minter);

    modifier onlyMinter {
        require(msg.sender == minter, "Token:onlyMinter: should only be called by minter");
        _;
    }

    /**
     *@dev Construct a new Fuel token
     * @param initialSupply The initial supply minted at deployment
     * @param account The initial account to grant all the tokens
     */
    constructor(uint initialSupply, address account, address _minter) public {
        totalSupply = safe96(initialSupply, "Token::constructor:amount exceeds 96 bits");
        balances[account] = uint96(initialSupply);
        minter = _minter;
        emit Transfer(address(0), account, initialSupply);
    }

    /**
     *@dev Get the number of tokens `spender` is approved to spend on behalf of `account`
     * @param account The address of the account holding the funds
     * @param spender The address of the account spending the funds
     * @return The number of tokens approved
     */
    function allowance(address account, address spender) external view returns (uint) {
        return allowances[account][spender];
    }

    /**
     *@dev Approve `spender` to transfer up to `amount` from `src`
     * @dev This will overwrite the approval amount for `spender`
     *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
     * @param spender The address of the account which may transfer tokens
     * @param rawAmount The number of tokens that are approved (2^256-1 means infinite)
     * @return Whether or not the approval succeeded
     */
    function approve(address spender, uint rawAmount) external returns (bool) {
        uint96 amount;
        if (rawAmount == uint(-1)) {
            amount = uint96(-1);
        } else {
            amount = safe96(rawAmount, "Token::approve: amount exceeds 96 bits");
        }

        allowances[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);
        return true;
    }

    /**
     *@dev Get the number of tokens held by the `account`
     * @param account The address of the account to get the balance of
     * @return The number of tokens held
     */
    function balanceOf(address account) external view returns (uint) {
        return balances[account];
    }

    /**
     *@dev Mint `amount` tokens to `dst`
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to mint
     *@dev only callable by minter
     */
    function mint(address dst, uint rawAmount) external onlyMinter {
        uint96 amount = safe96(rawAmount, "Token::mint: amount exceeds 96 bits");
        _mintTokens(dst, amount);
    }

    /**
     *@dev Burn `amount` tokens
     * @param rawAmount The number of tokens to burn
     */
    function burn(uint rawAmount) external {
        uint96 amount = safe96(rawAmount, "Token::burn: amount exceeds 96 bits");
        _burnTokens(msg.sender, amount);
    }

    /**
     *@dev Change minter address to `account`
     * @param account The address of the new minter
     *@dev only callable by minter
     */
    function changeMinter(address account) external onlyMinter {
        minter = account;
        emit NewMinter(account);
    }

    /**
     *@dev Transfer `amount` tokens from `msg.sender` to `dst`
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transfer(address dst, uint rawAmount) external returns (bool) {
        uint96 amount = safe96(rawAmount, "Token::transfer: amount exceeds 96 bits");
        _transferTokens(msg.sender, dst, amount);
        return true;
    }

    /**
     *@dev Transfer `amount` tokens from `src` to `dst`
     * @param src The address of the source account
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
        address spender = msg.sender;
        uint96 spenderAllowance = allowances[src][spender];
        uint96 amount = safe96(rawAmount, "Token::approve: amount exceeds 96 bits");

        if (spender != src && spenderAllowance != uint96(-1)) {
            uint96 newAllowance = sub96(spenderAllowance, amount, "Token::transferFrom: transfer amount exceeds spender allowance");
            allowances[src][spender] = newAllowance;

            emit Approval(src, spender, newAllowance);
        }

        _transferTokens(src, dst, amount);
        return true;
    }

    /**
     *@dev Delegate votes from `msg.sender` to `delegatee`
     * @param delegatee The address to delegate votes to
     */
    function delegate(address delegatee) public {
        return _delegate(msg.sender, delegatee);
    }

    /**
     *@dev Delegates votes from signatory to `delegatee`
     * @param delegatee The address to delegate votes to
     * @param nonce The contract state required to match the signature
     * @param expiry The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
        bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
        bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "Token::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "Token::delegateBySig: invalid nonce");
        require(now <= expiry, "Token::delegateBySig: signature expired");
        return _delegate(signatory, delegatee);
    }

    /**
     *@dev Gets the current votes balance for `account`
     * @param account The address to get votes balance
     * @return The number of current votes for `account`
     */
    function getCurrentVotes(address account) external view returns (uint96) {
        uint32 nCheckpoints = numCheckpoints[account];
        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }

    /**
     *@dev Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
        require(blockNumber < block.number, "Token::getPriorVotes: not yet determined");

        uint32 nCheckpoints = numCheckpoints[account];
        if (nCheckpoints == 0) {
            return 0;
        }

        // First check most recent balance
        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
            return checkpoints[account][nCheckpoints - 1].votes;
        }

        // Next check implicit zero balance
        if (checkpoints[account][0].fromBlock > blockNumber) {
            return 0;
        }

        uint32 lower = 0;
        uint32 upper = nCheckpoints - 1;
        while (upper > lower) {
            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
            Checkpoint memory cp = checkpoints[account][center];
            if (cp.fromBlock == blockNumber) {
                return cp.votes;
            } else if (cp.fromBlock < blockNumber) {
                lower = center;
            } else {
                upper = center - 1;
            }
        }
        return checkpoints[account][lower].votes;
    }

    function _delegate(address delegator, address delegatee) internal {
        address currentDelegate = delegates[delegator];
        uint96 delegatorBalance = balances[delegator];
        delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

    function _transferTokens(address src, address dst, uint96 amount) internal {
        require(src != address(0), "Token::_transferTokens: cannot transfer from the zero address");
        require(dst != address(0), "Token::_transferTokens: cannot transfer to the zero address");

        balances[src] = sub96(balances[src], amount, "Token::_transferTokens: transfer amount exceeds balance");
        balances[dst] = add96(balances[dst], amount, "Token::_transferTokens: transfer amount overflows");
        emit Transfer(src, dst, amount);

        _moveDelegates(delegates[src], delegates[dst], amount);
    }

    function _mintTokens(address dst, uint96 amount) internal {
        require(dst != address(0), "Token::_mintTokens: cannot transfer to the zero address");
        uint96 supply = safe96(totalSupply, "Token::_mintTokens: totalSupply exceeds 96 bits");
        totalSupply = add96(supply, amount, "Token::_mintTokens: totalSupply exceeds 96 bits");
        balances[dst] = add96(balances[dst], amount, "Token::_mintTokens: transfer amount overflows");
        emit Transfer(address(0), dst, amount);

        _moveDelegates(address(0), delegates[dst], amount);
    }

    function _burnTokens(address src, uint96 amount) internal {
        uint96 supply = safe96(totalSupply, "Token::_burnTokens: totalSupply exceeds 96 bits");
        totalSupply = sub96(supply, amount, "Token::_burnTokens:totalSupply underflow");
        balances[src] = sub96(balances[src], amount, "Token::_burnTokens: amount overflows");
        emit Transfer(src, address(0), amount);

        _moveDelegates(delegates[src], address(0), amount);
    }

    function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
        if (srcRep != dstRep && amount > 0) {
            if (srcRep != address(0)) {
                uint32 srcRepNum = numCheckpoints[srcRep];
                uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
                uint96 srcRepNew = sub96(srcRepOld, amount, "Token::_moveVotes: vote amount underflows");
                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
            }

            if (dstRep != address(0)) {
                uint32 dstRepNum = numCheckpoints[dstRep];
                uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
                uint96 dstRepNew = add96(dstRepOld, amount, "Token::_moveVotes: vote amount overflows");
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
        uint32 blockNumber = safe32(block.number, "Token::_writeCheckpoint: block number exceeds 32 bits");

        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
        } else {
            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
            numCheckpoints[delegatee] = nCheckpoints + 1;
        }

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }

    function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
        require(n < 2**96, errorMessage);
        return uint96(n);
    }

    function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
        uint96 c = a + b;
        require(c >= a, errorMessage);
        return c;
    }

    function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
        require(b <= a, errorMessage);
        return a - b;
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;


/**
 * @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.
 */
contract Godable {
    address private _god;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = msg.sender;
        _god = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function god() public view returns (address) {
        return _god;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyGod() {
        require(_god == msg.sender, "Godable: caller is not the god");
        _;
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferGod(address newOwner) public virtual onlyGod {
        require(newOwner != address(0), "Godable: new owner is the zero address");
        emit OwnershipTransferred(_god, newOwner);
        _god = newOwner;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

library Strings {

    // via https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol
    function strConcat(string memory _a, string memory _b, string memory _c, string memory _d, string memory _e) internal pure returns (string memory _concatenatedString) {
        bytes memory _ba = bytes(_a);
        bytes memory _bb = bytes(_b);
        bytes memory _bc = bytes(_c);
        bytes memory _bd = bytes(_d);
        bytes memory _be = bytes(_e);
        string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
        bytes memory babcde = bytes(abcde);
        uint k = 0;
        uint i = 0;
        for (i = 0; i < _ba.length; i++) {
            babcde[k++] = _ba[i];
        }
        for (i = 0; i < _bb.length; i++) {
            babcde[k++] = _bb[i];
        }
        for (i = 0; i < _bc.length; i++) {
            babcde[k++] = _bc[i];
        }
        for (i = 0; i < _bd.length; i++) {
            babcde[k++] = _bd[i];
        }
        for (i = 0; i < _be.length; i++) {
            babcde[k++] = _be[i];
        }
        return string(babcde);
    }

    function strConcat(string memory _a, string memory _b) internal pure returns (string memory) {
        return strConcat(_a, _b, "", "", "");
    }

    function strConcat(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
        return strConcat(_a, _b, _c, "", "");
    }

    function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (_i != 0) {
            bstr[k--] = byte(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";

contract ERC721ReceiverMock is IERC721Receiver {
    bytes4 private _retval;
    bool private _reverts;

    event Received(address operator, address from, uint256 tokenId, bytes data, uint256 gas);

    constructor (bytes4 retval, bool reverts) public {
        _retval = retval;
        _reverts = reverts;
    }

    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
    public override returns (bytes4)
    {
        require(!_reverts, "ERC721ReceiverMock: reverting");
        emit Received(operator, from, tokenId, data, gasleft());
        return _retval;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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);
}

pragma solidity 0.6.12;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MockERC20 is ERC20 {
    constructor(
        string memory name,
        string memory symbol,
        uint256 supply
    ) public ERC20(name, symbol) {
        _mint(msg.sender, supply);
    }

    function mint(address _to, uint256 _amount) public {
        _mint(_to, _amount);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "../../GSN/Context.sol";
import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.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 guidelines: functions revert instead
 * of 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 {
    using SafeMath for uint256;
    using Address for address;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view 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 {_setupDecimals} is
     * called.
     *
     * 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 returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view 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);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        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].add(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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is 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);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(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
     *
     * - `to` 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 = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(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);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(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 Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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 GSN 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 payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @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 sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

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

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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 mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

/**
 * @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 in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        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");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;


import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/introspection/ERC165.sol";

import "./interfaces/IERC721Token.sol";
import "./interfaces/IERC721Receiver.sol";

import "./LavaToken.sol";

import "./libs/Strings.sol";
import "./libs/Godable.sol";

import "@nomiclabs/buidler/console.sol";

// In the fertile sacred grove under the lightning tree ThunderEggs are spawned!
//
// ThunderEggs are controlled by a god that wields tremendous power. You have been warned!
//
// Don't mess with the Gods especially the God of Thunder!
//
contract ThunderEgg is Godable, IERC721Token, ERC165 {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // ** Chef

    // Info of each ThunderEgg.
    struct ThunderEggInfo {
        uint256 amount;     // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        //
        // We do some fancy math here. Basically, any point in time, the amount of lava entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accLavaPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
        //   1. The pool's `accLavaPerShare` (and `lastRewardBlock`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }

    // Info of each sacred grove.
    struct SacredGrove {
        IERC20 lpToken;           // Address of LP token contract.
        uint256 allocPoint;       // How many allocation points assigned to this pool. lavas to distribute per block.
        uint256 lastRewardBlock;  // Last block number that lavas distribution occurs.
        uint256 accLavaPerShare; // Accumulated lava per share, times 1e18. See below.
        uint256 totalSupply; // max ThunderEggs for this pool
        uint256 endBlock; // god has spoken - this pool is 'ova
    }

    // The lavaToken TOKEN!
    LavaToken public lava;

    // Block number when bonus period ends.
    uint256 public bonusEndBlock;

    // Lava tokens created per block.
    uint256 public lavaPerBlock;

    // Bonus muliplier for early makers.
    uint256 public constant BONUS_MULTIPLIER = 10;

    // Offering to the GODS
    uint256 public godsOffering = 80; // 1.25%

    // Info of each grove.
    SacredGrove[] public sacredGrove;

    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(uint256 => ThunderEggInfo)) public thunderEggInfoMapping;

    // Total allocation poitns. Must be the sum of all allocation points in all groves.
    uint256 public totalAllocPoint = 0;

    // The block number when mining starts.
    uint256 public startBlock;

    mapping(address => bool) public isSacredGrove;

    event Deposit(address indexed user, uint256 indexed groveId, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed groveId, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed groveId, uint256 amount);

    // ** end Chef

    // ** ERC721

    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

    // Function selector for ERC721Receiver.onERC721Received
    // 0x150b7a02
    bytes4 constant internal ERC721_RECEIVED = bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));

    string public baseTokenURI;

    // Note: the first token ID will be 1
    uint256 public tokenPointer;

    // Token name
    string public name = "ThunderEgg";

    // Token symbol
    string public symbol = "TEGG";

    // total supply across sacred groves
    uint256 public totalSupply;
    uint256 public totalSpawned;
    uint256 public totalDestroyed;

    // Mapping of eggId => owner
    mapping(uint256 => address) internal thunderEggIdToOwner;
    mapping(uint256 => uint256) internal thunderEggIdToBirth;
    mapping(uint256 => bytes32) internal thunderEggIdToName;

    mapping(address => uint256) public ownerToThunderEggId;

    // Mapping of eggId => approved address
    mapping(uint256 => address) internal approvals;

    // Mapping of owner => operator => approved
    mapping(address => mapping(address => bool)) internal operatorApprovals;

    // ** end ERC721

    constructor(
        LavaToken _lava,
        uint256 _lavaPerBlock,
        uint256 _startBlock,
        uint256 _bonusEndBlock
    ) public {
        lava = _lava;
        lavaPerBlock = _lavaPerBlock;
        bonusEndBlock = _bonusEndBlock;
        startBlock = _startBlock;

        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
    }

    function sacredGroveLength() external view returns (uint256) {
        return sacredGrove.length;
    }

    // Add a new sacred grove. Can only be called by god!!
    function addSacredGrove(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyGod {
        require(!isSacredGrove[address(_lpToken)], "This is already a known sacred grove");

        if (_withUpdate) {
            massUpdateSacredGroves();
        }

        uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);
        sacredGrove.push(SacredGrove({
            lpToken : _lpToken,
            allocPoint : _allocPoint,
            lastRewardBlock : lastRewardBlock,
            accLavaPerShare : 0,
            totalSupply : 0,
            endBlock : 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
            }));

        isSacredGrove[address(_lpToken)] = true;
    }

    // Update the given grove's allocation point. Can only be called by the owner.
    function set(uint256 _groveId, uint256 _allocPoint, bool _withUpdate) public onlyGod {
        if (_withUpdate) {
            massUpdateSacredGroves();
        }
        totalAllocPoint = totalAllocPoint.sub(sacredGrove[_groveId].allocPoint).add(_allocPoint);
        sacredGrove[_groveId].allocPoint = _allocPoint;
    }

    function end(uint256 _groveId, uint256 _endBlock, bool _withUpdate) public onlyGod {
        SacredGrove storage grove = sacredGrove[_groveId];
        grove.endBlock = _endBlock;

        if (_withUpdate) {
            massUpdateSacredGroves();
        }
    }

    // Return reward multiplier over the given _from to _to block.
    function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
        if (_to <= bonusEndBlock) {
            return _to.sub(_from).mul(BONUS_MULTIPLIER);
        } else if (_from >= bonusEndBlock) {
            return _to.sub(_from);
        } else {
            return bonusEndBlock.sub(_from).mul(BONUS_MULTIPLIER).add(_to.sub(bonusEndBlock));
        }
    }

    function thunderEggStats(uint256 _groveId, uint256 _eggId) external view returns (address _owner, uint256 _birth, uint256 _age, uint256 _lp, uint256 _lava, bytes32 _name) {
        if (!_exists(_eggId)) {
            return (address(0x0), 0, 0, 0, 0, bytes32(0x0));
        }

        ThunderEggInfo storage info = thunderEggInfoMapping[_groveId][_eggId];

        return (
        thunderEggIdToOwner[_eggId],
        thunderEggIdToBirth[_eggId],
        block.number - thunderEggIdToBirth[_eggId],
        info.amount,
        _calculatePendingLava(_groveId, _eggId),
        thunderEggIdToName[_eggId]
        );
    }

    // View function to see pending LAVAs on frontend.
    function pendingLava(uint256 _groveId, uint256 _eggId) external view returns (uint256) {
        // no ThunderEgg, no lava!
        if (!_exists(_eggId)) {
            return 0;
        }

        return _calculatePendingLava(_groveId, _eggId);
    }

    function _calculatePendingLava(uint256 _groveId, uint256 _eggId) internal view returns (uint256) {
        SacredGrove storage grove = sacredGrove[_groveId];
        ThunderEggInfo storage info = thunderEggInfoMapping[_groveId][_eggId];

        uint256 accLavaPerShare = grove.accLavaPerShare;

        uint256 lpSupply = grove.lpToken.balanceOf(address(this));
        if (block.number > grove.lastRewardBlock && lpSupply != 0) {
            uint256 multiplier = getMultiplier(grove.lastRewardBlock, block.number <= grove.endBlock ? block.number : grove.endBlock);
            uint256 lavaReward = multiplier.mul(lavaPerBlock).mul(grove.allocPoint).div(totalAllocPoint);
            accLavaPerShare = accLavaPerShare.add(lavaReward.mul(1e18).div(lpSupply));
        }

        return info.amount.mul(accLavaPerShare).div(1e18).sub(info.rewardDebt);
    }

    // Update reward variables for all grove. Be careful of gas spending!
    function massUpdateSacredGroves() public {
        uint256 length = sacredGrove.length;
        for (uint256 groveId = 0; groveId < length; ++groveId) {
            updateSacredGrove(groveId);
        }
    }

    // Update reward variables of the given grove to be up-to-date.
    function updateSacredGrove(uint256 _groveId) public {
        SacredGrove storage grove = sacredGrove[_groveId];
        if (block.number <= grove.lastRewardBlock) {
            return;
        }

        uint256 lpSupply = grove.lpToken.balanceOf(address(this));
        if (lpSupply == 0) {
            grove.lastRewardBlock = block.number;
            return;
        }

        uint256 multiplier = getMultiplier(grove.lastRewardBlock, block.number <= grove.endBlock ? block.number : grove.endBlock);
        uint256 lavaReward = multiplier.mul(lavaPerBlock).mul(grove.allocPoint).div(totalAllocPoint);

        // offering to the gods
        lava.mint(god(), lavaReward.div(godsOffering));

        // reward for ThunderEggs
        lava.mint(address(this), lavaReward);

        grove.accLavaPerShare = grove.accLavaPerShare.add(lavaReward.mul(1e18).div(lpSupply));
        grove.lastRewardBlock = block.number;
    }

    // mint the ThunderEgg by depositing LP tokens,
    function spawn(uint256 _groveId, uint256 _amount, bytes32 _name) public {
        require(ownerToThunderEggId[msg.sender] == 0, "Thor has already blessed you with a ThunderEgg!");
        require(_amount > 0, "You must sacrifice your LP tokens to the gods!");

        updateSacredGrove(_groveId);

        // Thunder 🥚 time!
        uint256 eggId = _mint(_groveId, msg.sender, _name);

        SacredGrove storage pool = sacredGrove[_groveId];
        ThunderEggInfo storage info = thunderEggInfoMapping[_groveId][eggId];

        // credit the staked amount
        pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
        info.amount = info.amount.add(_amount);

        info.rewardDebt = info.amount.mul(pool.accLavaPerShare).div(1e18);
        emit Deposit(msg.sender, _groveId, _amount);
    }

    // Destroy and get all the tokens back - bye bye NFT!
    function destroy(uint256 _groveId) public {

        uint256 eggId = ownerToThunderEggId[msg.sender];
        require(eggId != 0, "No ThunderEgg!");

        updateSacredGrove(_groveId);

        SacredGrove storage pool = sacredGrove[_groveId];
        ThunderEggInfo storage info = thunderEggInfoMapping[_groveId][eggId];

        // burn the token - send all rewards and LP back!
        _burn(_groveId, eggId);

        // pay out rewards from the ThunderEgg
        uint256 pending = info.amount.mul(pool.accLavaPerShare).div(1e18).sub(info.rewardDebt);
        if (pending > 0) {
            safeLavaTransfer(msg.sender, pending);
        }

        // send all LP back...
        pool.lpToken.safeTransfer(address(msg.sender), info.amount);

        info.rewardDebt = info.amount.mul(pool.accLavaPerShare).div(1e18);
        emit Withdraw(msg.sender, _groveId, info.amount);
    }

    // Safe sushi transfer function, just in case if rounding error causes pool to not have enough SUSHIs.
    function safeLavaTransfer(address _to, uint256 _amount) internal {
        uint256 lavaBal = lava.balanceOf(address(this));
        if (_amount > lavaBal) {
            lava.transfer(_to, lavaBal);
        } else {
            lava.transfer(_to, _amount);
        }
    }

    // *** ERC721 functions below

    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly {codehash := extcodehash(account)}
        return (codehash != accountHash && codehash != 0x0);
    }

    function _checkOnERC721Received(address from, address to, uint256 eggId, bytes memory _data) private returns (bool) {
        if (!isContract(to)) {
            return true;
        }
        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = to.call(abi.encodeWithSelector(
                IERC721Receiver(to).onERC721Received.selector,
                msg.sender,
                from,
                eggId,
                _data
            ));

        if (!success) {
            if (returndata.length > 0) {
                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert("ERC721: transfer to non ERC721Receiver implementer");
            }
        } else {
            bytes4 retval = abi.decode(returndata, (bytes4));
            return (retval == ERC721_RECEIVED);
        }

        return true;
    }

    function setGodsOffering(uint256 _godsOffering) external onlyGod {
        godsOffering = _godsOffering;
    }

    function setBaseTokenURI(string calldata _uri) external onlyGod {
        baseTokenURI = _uri;
    }

    function setName(uint256 _eggId, bytes32 _name) external onlyGod {
        thunderEggIdToName[_eggId] = _name;
    }

    function _mint(uint256 _groveId, address _to, bytes32 _name) internal returns (uint256) {
        require(_to != address(0), "ERC721: mint to the zero address");

        SacredGrove storage grove = sacredGrove[_groveId];
        require(grove.endBlock >= block.number, 'This grove is not longer fertile');

        tokenPointer = tokenPointer.add(1);
        uint256 eggId = tokenPointer;

        // Mint
        thunderEggIdToOwner[eggId] = _to;
        ownerToThunderEggId[msg.sender] = eggId;

        // birth
        thunderEggIdToBirth[eggId] = block.number;

        // name
        thunderEggIdToName[eggId] = _name;

        // MetaData
        grove.totalSupply = grove.totalSupply.add(1);
        totalSupply = totalSupply.add(1);
        totalSpawned = totalSpawned.add(1);

        // Single Transfer event for a single token
        emit Transfer(address(0), _to, eggId);

        return eggId;
    }

    function exists(uint256 _eggId) external view returns (bool) {
        return _exists(_eggId);
    }

    function _exists(uint256 _eggId) internal view returns (bool) {
        return thunderEggIdToOwner[_eggId] != address(0);
    }

    function tokenURI(uint256 _eggId) external view returns (string memory) {
        require(_exists(_eggId), "ERC721Metadata: URI query for nonexistent token");
        return Strings.strConcat(baseTokenURI, Strings.uint2str(_eggId));
    }

    function _burn(uint256 _groveId, uint256 _eggId) internal {
        require(_exists(_eggId), "must exist");

        address owner = thunderEggIdToOwner[_eggId];

        require(owner == msg.sender, "Must own the egg!");

        SacredGrove storage pool = sacredGrove[_groveId];

        thunderEggIdToOwner[_eggId] = address(0);
        ownerToThunderEggId[msg.sender] = 0;

        pool.totalSupply = pool.totalSupply.sub(1);
        totalSupply = totalSupply.sub(1);
        totalDestroyed = totalDestroyed.add(1);

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

    function safeTransferFrom(address _from, address _to, uint256 _eggId) override public {
        safeTransferFrom(_from, _to, _eggId, "");
    }

    function safeTransferFrom(address _from, address _to, uint256 _eggId, bytes memory _data) override public {
        transferFrom(_from, _to, _eggId);
        require(_checkOnERC721Received(_from, _to, _eggId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    function approve(address _approved, uint256 _eggId) override external {
        address owner = ownerOf(_eggId);
        require(_approved != owner, "ERC721: approval to current owner");

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

        approvals[_eggId] = _approved;
        emit Approval(
            owner,
            _approved,
            _eggId
        );
    }

    function setApprovalForAll(address _operator, bool _approved) override external {
        require(_operator != msg.sender, "ERC721: approve to caller");

        operatorApprovals[msg.sender][_operator] = _approved;
        emit ApprovalForAll(
            msg.sender,
            _operator,
            _approved
        );
    }

    function balanceOf(address _owner) override external view returns (uint256) {
        require(_owner != address(0), "ERC721: balance query for the zero address");
        return ownerToThunderEggId[_owner] != 0 ? 1 : 0;
    }

    function transferFrom(address _from, address _to, uint256 _eggId) override public {
        require(
            _to != address(0),
            "ERC721: transfer to the zero address"
        );

        address owner = ownerOf(_eggId);
        require(
            _from == owner,
            "ERC721: transfer of token that is not own"
        );

        address spender = msg.sender;
        address approvedAddress = getApproved(_eggId);
        require(
            spender == owner ||
            isApprovedForAll(owner, spender) ||
            approvedAddress == spender,
            "ERC721: transfer caller is not owner nor approved"
        );

        if (approvedAddress != address(0)) {
            approvals[_eggId] = address(0);
        }

        emit Approval(owner, address(0), _eggId);

        thunderEggIdToOwner[_eggId] = _to;
        ownerToThunderEggId[_from] = 0;
        ownerToThunderEggId[_to] = _eggId;

        emit Transfer(
            _from,
            _to,
            _eggId
        );
    }

    function ownerOf(uint256 _eggId) override public view returns (address) {
        require(_exists(_eggId), "ERC721: operator query for nonexistent token");
        return thunderEggIdToOwner[_eggId];
    }

    function getApproved(uint256 _eggId) override public view returns (address) {
        require(_exists(_eggId), "ERC721: approved query for nonexistent token");
        return approvals[_eggId];
    }

    function isApprovedForAll(address _owner, address _operator) override public view returns (bool) {
        return operatorApprovals[_owner][_operator];
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () internal {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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);
}

// SPDX-License-Identifier: MIT
pragma solidity >= 0.4.22 <0.8.0;

library console {
	address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);

	function _sendLogPayload(bytes memory payload) private view {
		uint256 payloadLength = payload.length;
		address consoleAddress = CONSOLE_ADDRESS;
		assembly {
			let payloadStart := add(payload, 32)
			let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
		}
	}

	function log() internal view {
		_sendLogPayload(abi.encodeWithSignature("log()"));
	}

	function logInt(int p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(int)", p0));
	}

	function logUint(uint p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
	}

	function logString(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function logBool(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function logAddress(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function logBytes(bytes memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
	}

	function logByte(byte p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(byte)", p0));
	}

	function logBytes1(bytes1 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
	}

	function logBytes2(bytes2 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
	}

	function logBytes3(bytes3 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
	}

	function logBytes4(bytes4 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
	}

	function logBytes5(bytes5 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
	}

	function logBytes6(bytes6 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
	}

	function logBytes7(bytes7 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
	}

	function logBytes8(bytes8 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
	}

	function logBytes9(bytes9 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
	}

	function logBytes10(bytes10 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
	}

	function logBytes11(bytes11 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
	}

	function logBytes12(bytes12 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
	}

	function logBytes13(bytes13 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
	}

	function logBytes14(bytes14 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
	}

	function logBytes15(bytes15 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
	}

	function logBytes16(bytes16 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
	}

	function logBytes17(bytes17 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
	}

	function logBytes18(bytes18 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
	}

	function logBytes19(bytes19 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
	}

	function logBytes20(bytes20 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
	}

	function logBytes21(bytes21 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
	}

	function logBytes22(bytes22 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
	}

	function logBytes23(bytes23 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
	}

	function logBytes24(bytes24 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
	}

	function logBytes25(bytes25 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
	}

	function logBytes26(bytes26 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
	}

	function logBytes27(bytes27 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
	}

	function logBytes28(bytes28 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
	}

	function logBytes29(bytes29 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
	}

	function logBytes30(bytes30 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
	}

	function logBytes31(bytes31 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
	}

	function logBytes32(bytes32 p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
	}

	function log(uint p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
	}

	function log(string memory p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
	}

	function log(bool p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
	}

	function log(address p0) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
	}

	function log(uint p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
	}

	function log(uint p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
	}

	function log(uint p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
	}

	function log(uint p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
	}

	function log(string memory p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
	}

	function log(string memory p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
	}

	function log(string memory p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
	}

	function log(string memory p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
	}

	function log(bool p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
	}

	function log(bool p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
	}

	function log(bool p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
	}

	function log(bool p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
	}

	function log(address p0, uint p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
	}

	function log(address p0, string memory p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
	}

	function log(address p0, bool p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
	}

	function log(address p0, address p1) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
	}

	function log(uint p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
	}

	function log(uint p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
	}

	function log(uint p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
	}

	function log(uint p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
	}

	function log(uint p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
	}

	function log(uint p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
	}

	function log(uint p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
	}

	function log(uint p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
	}

	function log(uint p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
	}

	function log(uint p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
	}

	function log(uint p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
	}

	function log(uint p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
	}

	function log(uint p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
	}

	function log(string memory p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
	}

	function log(string memory p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
	}

	function log(string memory p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
	}

	function log(string memory p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
	}

	function log(string memory p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
	}

	function log(string memory p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
	}

	function log(string memory p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
	}

	function log(bool p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
	}

	function log(bool p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
	}

	function log(bool p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
	}

	function log(bool p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
	}

	function log(bool p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
	}

	function log(bool p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
	}

	function log(bool p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
	}

	function log(bool p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
	}

	function log(bool p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
	}

	function log(bool p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
	}

	function log(bool p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
	}

	function log(bool p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
	}

	function log(bool p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
	}

	function log(address p0, uint p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
	}

	function log(address p0, uint p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
	}

	function log(address p0, uint p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
	}

	function log(address p0, uint p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
	}

	function log(address p0, string memory p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
	}

	function log(address p0, string memory p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
	}

	function log(address p0, string memory p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
	}

	function log(address p0, string memory p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
	}

	function log(address p0, bool p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
	}

	function log(address p0, bool p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
	}

	function log(address p0, bool p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
	}

	function log(address p0, bool p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
	}

	function log(address p0, address p1, uint p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
	}

	function log(address p0, address p1, string memory p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
	}

	function log(address p0, address p1, bool p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
	}

	function log(address p0, address p1, address p2) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
	}

	function log(uint p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
	}

	function log(uint p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
	}

	function log(string memory p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
	}

	function log(bool p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, uint p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, string memory p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, bool p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, uint p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, string memory p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, bool p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, uint p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, string memory p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, bool p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
	}

	function log(address p0, address p1, address p2, address p3) internal view {
		_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
	}

}

{
  "metadata": {
    "useLiteralContent": false
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"initialSupply","type":"uint256"},{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"_minter","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":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter","type":"address"}],"name":"NewMinter","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":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DELEGATION_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","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":"rawAmount","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":[{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"changeMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint32","name":"","type":"uint32"}],"name":"checkpoints","outputs":[{"internalType":"uint32","name":"fromBlock","type":"uint32"},{"internalType":"uint96","name":"votes","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getCurrentVotes","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"getPriorVotes","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numCheckpoints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"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":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b506004361061014d5760003560e01c80635c19a95c116100c3578063a9059cbb1161007c578063a9059cbb146102b9578063b4b5ea57146102cc578063c3cda520146102df578063dd62ed3e146102f2578063e7a324dc14610305578063f1127ed81461030d5761014d565b80635c19a95c146102385780636fcfff451461024b57806370a082311461026b578063782d6fe11461027e5780637ecebe001461029e57806395d89b41146102b15761014d565b806323b872dd1161011557806323b872dd146101c25780632c4d4d18146101d5578063313ce567146101ea57806340c10f19146101ff57806342966c6814610212578063587cde1e146102255761014d565b806306fdde03146101525780630754617214610170578063095ea7b31461018557806318160ddd146101a557806320606b70146101ba575b600080fd5b61015a61032e565b60405161016791906117ca565b60405180910390f35b61017861035f565b604051610167919061173c565b610198610193366004611641565b61036e565b6040516101679190611750565b6101ad61042d565b604051610167919061175b565b6101ad610433565b6101986101d0366004611601565b610457565b6101e86101e33660046115b2565b61059e565b005b6101f2610627565b6040516101679190611ace565b6101e861020d366004611641565b61062c565b6101e8610220366004611709565b61068b565b6101786102333660046115b2565b6106bf565b6101e86102463660046115b2565b6106da565b61025e6102593660046115b2565b6106e7565b6040516101679190611a9e565b6101ad6102793660046115b2565b6106ff565b61029161028c366004611641565b610723565b6040516101679190611adc565b6101ad6102ac3660046115b2565b610931565b61015a610943565b6101986102c7366004611641565b610963565b6102916102da3660046115b2565b61099f565b6101e86102ed36600461166b565b610a10565b6101ad6103003660046115cd565b610c23565b6101ad610c57565b61032061031b3660046116ca565b610c7b565b604051610167929190611aaf565b604051806040016040528060158152602001742630bb30902a343ab73232b922b3b3902a37b5b2b760591b81525081565b6001546001600160a01b031681565b60008060001983141561038457506000196103a9565b6103a683604051806060016040528060268152602001611be960269139610cb0565b90505b3360008181526002602090815260408083206001600160a01b03891680855292529182902080546001600160601b0319166001600160601b03861617905590519091907f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92590610419908590611adc565b60405180910390a360019150505b92915050565b60005481565b7f8cad95687ba82c2ce50e74f7b754645e5117c3a5bec8151c0726d5857980a86681565b6001600160a01b03831660009081526002602090815260408083203380855290835281842054825160608101909352602680845291936001600160601b039091169285926104af9288929190611be990830139610cb0565b9050866001600160a01b0316836001600160a01b0316141580156104dc57506001600160601b0382811614155b1561058657600061050683836040518060600160405280603e8152602001611b57603e9139610cdf565b6001600160a01b038981166000818152600260209081526040808320948a16808452949091529081902080546001600160601b0319166001600160601b0386161790555192935090917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259061057c908590611adc565b60405180910390a3505b610591878783610d1e565b5060019695505050505050565b6001546001600160a01b031633146105d15760405162461bcd60e51b81526004016105c890611a4d565b60405180910390fd5b600180546001600160a01b0319166001600160a01b0383161790556040517f6adffd5c93085d835dac6f3b40adf7c242ca4b3284048d20c3d8a501748dc9739061061c90839061173c565b60405180910390a150565b601281565b6001546001600160a01b031633146106565760405162461bcd60e51b81526004016105c890611a4d565b600061067a82604051806060016040528060238152602001611d6b60239139610cb0565b90506106868382610ec4565b505050565b60006106af82604051806060016040528060238152602001611b9560239139610cb0565b90506106bb338261101e565b5050565b6004602052600090815260409020546001600160a01b031681565b6106e43382611150565b50565b60066020526000908152604090205463ffffffff1681565b6001600160a01b03166000908152600360205260409020546001600160601b031690565b60004382106107445760405162461bcd60e51b81526004016105c89061181d565b6001600160a01b03831660009081526006602052604090205463ffffffff1680610772576000915050610427565b6001600160a01b038416600090815260056020908152604080832063ffffffff6000198601811685529252909120541683106107ee576001600160a01b03841660009081526005602090815260408083206000199490940163ffffffff1683529290522054600160201b90046001600160601b03169050610427565b6001600160a01b038416600090815260056020908152604080832083805290915290205463ffffffff16831015610829576000915050610427565b600060001982015b8163ffffffff168163ffffffff1611156108ec57600282820363ffffffff1604810361085b611584565b506001600160a01b038716600090815260056020908152604080832063ffffffff858116855290835292819020815180830190925254928316808252600160201b9093046001600160601b031691810191909152908714156108c7576020015194506104279350505050565b805163ffffffff168711156108de578193506108e5565b6001820392505b5050610831565b506001600160a01b038516600090815260056020908152604080832063ffffffff909416835292905220546001600160601b03600160201b9091041691505092915050565b60076020526000908152604090205481565b604051806040016040528060048152602001634c41564160e01b81525081565b60008061098883604051806060016040528060278152602001611cf160279139610cb0565b9050610995338583610d1e565b5060019392505050565b6001600160a01b03811660009081526006602052604081205463ffffffff16806109ca576000610a09565b6001600160a01b0383166000908152600560209081526040808320600019850163ffffffff168452909152902054600160201b90046001600160601b03165b9392505050565b6040805180820190915260158152742630bb30902a343ab73232b922b3b3902a37b5b2b760591b60209091015260007f8cad95687ba82c2ce50e74f7b754645e5117c3a5bec8151c0726d5857980a8667fc5ccd3a7c6d74157080f1204611267b12c82535a5b7a57857bcd63de22bee405610a896111da565b30604051602001610a9d9493929190611788565b60405160208183030381529060405280519060200120905060007fe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf888888604051602001610aee9493929190611764565b60405160208183030381529060405280519060200120905060008282604051602001610b1b929190611721565b604051602081830303815290604052805190602001209050600060018288888860405160008152602001604052604051610b5894939291906117ac565b6020604051602081039080840390855afa158015610b7a573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b038116610bad5760405162461bcd60e51b81526004016105c89061197c565b6001600160a01b03811660009081526007602052604090208054600181019091558914610bec5760405162461bcd60e51b81526004016105c8906119c3565b87421115610c0c5760405162461bcd60e51b81526004016105c890611a06565b610c16818b611150565b505050505b505050505050565b6001600160a01b0391821660009081526002602090815260408083209390941682529190915220546001600160601b031690565b7fe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf81565b600560209081526000928352604080842090915290825290205463ffffffff811690600160201b90046001600160601b031682565b600081600160601b8410610cd75760405162461bcd60e51b81526004016105c891906117ca565b509192915050565b6000836001600160601b0316836001600160601b031611158290610d165760405162461bcd60e51b81526004016105c891906117ca565b505050900390565b6001600160a01b038316610d445760405162461bcd60e51b81526004016105c890611865565b6001600160a01b038216610d6a5760405162461bcd60e51b81526004016105c8906118c2565b6001600160a01b038316600090815260036020908152604091829020548251606081019093526037808452610db5936001600160601b039092169285929190611b2090830139610cdf565b6001600160a01b03848116600090815260036020908152604080832080546001600160601b0319166001600160601b03968716179055928616825290829020548251606081019093526031808452610e1d9491909116928592909190611bb8908301396111de565b6001600160a01b038381166000818152600360205260409081902080546001600160601b0319166001600160601b0395909516949094179093559151908516907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef90610e8a908590611adc565b60405180910390a36001600160a01b038084166000908152600460205260408082205485841683529120546106869291821691168361121a565b6001600160a01b038216610eea5760405162461bcd60e51b81526004016105c89061191f565b6000610f106000546040518060600160405280602f8152602001611c44602f9139610cb0565b9050610f3581836040518060600160405280602f8152602001611c44602f91396111de565b6001600160601b0390811660009081556001600160a01b03851681526003602090815260409182902054825160608101909352602d808452610f879491909116928692909190611cc4908301396111de565b6001600160a01b03841660008181526003602052604080822080546001600160601b0319166001600160601b03959095169490941790935591519091907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef90610ff1908690611adc565b60405180910390a36001600160a01b0380841660009081526004602052604081205461068692168461121a565b60006110446000546040518060600160405280602f8152602001611d18602f9139610cb0565b90506110698183604051806060016040528060288152602001611d8e60289139610cdf565b6001600160601b0390811660009081556001600160a01b0385168152600360209081526040918290205482516060810190935260248084526110bb9491909116928692909190611d4790830139610cdf565b6001600160a01b03841660008181526003602052604080822080546001600160601b0319166001600160601b03959095169490941790935591517fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef90611122908690611adc565b60405180910390a36001600160a01b038084166000908152600460205260408120546106869216908461121a565b6001600160a01b03808316600081815260046020818152604080842080546003845282862054949093528787166001600160a01b031984168117909155905191909516946001600160601b039092169391928592917f3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f9190a46111d482848361121a565b50505050565b4690565b6000838301826001600160601b0380871690831610156112115760405162461bcd60e51b81526004016105c891906117ca565b50949350505050565b816001600160a01b0316836001600160a01b03161415801561124557506000816001600160601b0316115b15610686576001600160a01b038316156112fd576001600160a01b03831660009081526006602052604081205463ffffffff1690816112855760006112c4565b6001600160a01b0385166000908152600560209081526040808320600019860163ffffffff168452909152902054600160201b90046001600160601b03165b905060006112eb8285604051806060016040528060298152602001611c7360299139610cdf565b90506112f9868484846113a8565b5050505b6001600160a01b03821615610686576001600160a01b03821660009081526006602052604081205463ffffffff169081611338576000611377565b6001600160a01b0384166000908152600560209081526040808320600019860163ffffffff168452909152902054600160201b90046001600160601b03165b9050600061139e8285604051806060016040528060288152602001611c9c602891396111de565b9050610c1b858484845b60006113cc43604051806060016040528060358152602001611c0f6035913961155d565b905060008463ffffffff1611801561141557506001600160a01b038516600090815260056020908152604080832063ffffffff6000198901811685529252909120548282169116145b15611474576001600160a01b0385166000908152600560209081526040808320600019880163ffffffff168452909152902080546fffffffffffffffffffffffff000000001916600160201b6001600160601b03851602179055611513565b60408051808201825263ffffffff80841682526001600160601b0380861660208085019182526001600160a01b038b166000818152600583528781208c871682528352878120965187549451909516600160201b026fffffffffffffffffffffffff000000001995871663ffffffff19958616179590951694909417909555938252600690935292909220805460018801909316929091169190911790555b846001600160a01b03167fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a724848460405161154e929190611af0565b60405180910390a25050505050565b600081600160201b8410610cd75760405162461bcd60e51b81526004016105c891906117ca565b604080518082019091526000808252602082015290565b80356001600160a01b038116811461042757600080fd5b6000602082840312156115c3578081fd5b610a09838361159b565b600080604083850312156115df578081fd5b6115e9848461159b565b91506115f8846020850161159b565b90509250929050565b600080600060608486031215611615578081fd5b833561162081611b0a565b9250602084013561163081611b0a565b929592945050506040919091013590565b60008060408385031215611653578182fd5b61165d848461159b565b946020939093013593505050565b60008060008060008060c08789031215611683578182fd5b61168d888861159b565b95506020870135945060408701359350606087013560ff811681146116b0578283fd5b9598949750929560808101359460a0909101359350915050565b600080604083850312156116dc578182fd5b6116e6848461159b565b9150602083013563ffffffff811681146116fe578182fd5b809150509250929050565b60006020828403121561171a578081fd5b5035919050565b61190160f01b81526002810192909252602282015260420190565b6001600160a01b0391909116815260200190565b901515815260200190565b90815260200190565b9384526001600160a01b039290921660208401526040830152606082015260800190565b938452602084019290925260408301526001600160a01b0316606082015260800190565b93845260ff9290921660208401526040830152606082015260800190565b6000602080835283518082850152825b818110156117f6578581018301518582016040015282016117da565b818111156118075783604083870101525b50601f01601f1916929092016040019392505050565b60208082526028908201527f546f6b656e3a3a6765745072696f72566f7465733a206e6f74207965742064656040820152671d195c9b5a5b995960c21b606082015260800190565b6020808252603d908201527f546f6b656e3a3a5f7472616e73666572546f6b656e733a2063616e6e6f74207460408201527f72616e736665722066726f6d20746865207a65726f2061646472657373000000606082015260800190565b6020808252603b908201527f546f6b656e3a3a5f7472616e73666572546f6b656e733a2063616e6e6f74207460408201527f72616e7366657220746f20746865207a65726f20616464726573730000000000606082015260800190565b60208082526037908201527f546f6b656e3a3a5f6d696e74546f6b656e733a2063616e6e6f74207472616e7360408201527f66657220746f20746865207a65726f2061646472657373000000000000000000606082015260800190565b60208082526027908201527f546f6b656e3a3a64656c656761746542795369673a20696e76616c6964207369604082015266676e617475726560c81b606082015260800190565b60208082526023908201527f546f6b656e3a3a64656c656761746542795369673a20696e76616c6964206e6f6040820152626e636560e81b606082015260800190565b60208082526027908201527f546f6b656e3a3a64656c656761746542795369673a207369676e617475726520604082015266195e1c1a5c995960ca1b606082015260800190565b60208082526031908201527f546f6b656e3a6f6e6c794d696e7465723a2073686f756c64206f6e6c792062656040820152701031b0b63632b210313c9036b4b73a32b960791b606082015260800190565b63ffffffff91909116815260200190565b63ffffffff9290921682526001600160601b0316602082015260400190565b60ff91909116815260200190565b6001600160601b0391909116815260200190565b6001600160601b0392831681529116602082015260400190565b6001600160a01b03811681146106e457600080fdfe546f6b656e3a3a5f7472616e73666572546f6b656e733a207472616e7366657220616d6f756e7420657863656564732062616c616e6365546f6b656e3a3a7472616e7366657246726f6d3a207472616e7366657220616d6f756e742065786365656473207370656e64657220616c6c6f77616e6365546f6b656e3a3a6275726e3a20616d6f756e7420657863656564732039362062697473546f6b656e3a3a5f7472616e73666572546f6b656e733a207472616e7366657220616d6f756e74206f766572666c6f7773546f6b656e3a3a617070726f76653a20616d6f756e7420657863656564732039362062697473546f6b656e3a3a5f7772697465436865636b706f696e743a20626c6f636b206e756d62657220657863656564732033322062697473546f6b656e3a3a5f6d696e74546f6b656e733a20746f74616c537570706c7920657863656564732039362062697473546f6b656e3a3a5f6d6f7665566f7465733a20766f746520616d6f756e7420756e646572666c6f7773546f6b656e3a3a5f6d6f7665566f7465733a20766f746520616d6f756e74206f766572666c6f7773546f6b656e3a3a5f6d696e74546f6b656e733a207472616e7366657220616d6f756e74206f766572666c6f7773546f6b656e3a3a7472616e736665723a20616d6f756e7420657863656564732039362062697473546f6b656e3a3a5f6275726e546f6b656e733a20746f74616c537570706c7920657863656564732039362062697473546f6b656e3a3a5f6275726e546f6b656e733a20616d6f756e74206f766572666c6f7773546f6b656e3a3a6d696e743a20616d6f756e7420657863656564732039362062697473546f6b656e3a3a5f6275726e546f6b656e733a746f74616c537570706c7920756e646572666c6f77a264697066735822122022f44bac328f96074754879b0549d2063b571c4e897c733ee706f513d276545b64736f6c634300060c0033

00000000000000000000000000000000000000000000021e19e0c9bab240000000000000000000000000000033333db2ddf48330e597cd9e0334aacc81b7230700000000000000000000000033333db2ddf48330e597cd9e0334aacc81b72307

-----Decoded View---------------
Arg [0] : initialSupply (uint256): 10000000000000000000000
Arg [1] : account (address): 0x33333dB2DDF48330E597cD9e0334AAcc81b72307
Arg [2] : _minter (address): 0x33333dB2DDF48330E597cD9e0334AAcc81b72307

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000021e19e0c9bab2400000
Arg [1] : 00000000000000000000000033333db2ddf48330e597cd9e0334aacc81b72307
Arg [2] : 00000000000000000000000033333db2ddf48330e597cd9e0334aacc81b72307

1570:14929:10:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1640:53;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1990:21;;;:::i;:::-;;;;;;;:::i;5513:408::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;1933:23::-;;;:::i;:::-;;;;;;;:::i;2824:122::-;;;:::i;7953:660::-;;;;;;:::i;:::-;;:::i;7044:125::-;;;;;;:::i;:::-;;:::i;:::-;;1841:35;;;:::i;:::-;;;;;;;:::i;6427:186::-;;;;;;:::i;:::-;;:::i;6720:169::-;;;;;;:::i;:::-;;:::i;2305:45::-;;;;;;:::i;:::-;;:::i;8751:100::-;;;;;;:::i;:::-;;:::i;2709:49::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;6113:106::-;;;;;;:::i;:::-;;:::i;10880:1187::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3224:39::-;;;;;;:::i;:::-;;:::i;1747:38::-;;;:::i;7421:235::-;;;;;;:::i;:::-;;:::i;10243:219::-;;;;;;:::i;:::-;;:::i;9270:783::-;;;;;;:::i;:::-;;:::i;4915:134::-;;;;;;:::i;:::-;;:::i;3033:117::-;;;:::i;2577:70::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;1640:53::-;;;;;;;;;;;;;;-1:-1:-1;;;1640:53:10;;;;:::o;1990:21::-;;;-1:-1:-1;;;;;1990:21:10;;:::o;5513:408::-;5581:4;5597:13;-1:-1:-1;;5624:9:10;:21;5620:170;;;-1:-1:-1;;;5620:170:10;;;5720:59;5727:9;5720:59;;;;;;;;;;;;;;;;;:6;:59::i;:::-;5711:68;;5620:170;5811:10;5800:22;;;;:10;:22;;;;;;;;-1:-1:-1;;;;;5800:31:10;;;;;;;;;;;:40;;-1:-1:-1;;;;;;5800:40:10;-1:-1:-1;;;;;5800:40:10;;;;;5856:37;;5800:31;;5811:10;5856:37;;;;5800:40;;5856:37;:::i;:::-;;;;;;;;5910:4;5903:11;;;5513:408;;;;;:::o;1933:23::-;;;;:::o;2824:122::-;2866:80;2824:122;:::o;7953:660::-;-1:-1:-1;;;;;8115:15:10;;8035:4;8115:15;;;:10;:15;;;;;;;;8069:10;8115:24;;;;;;;;;;8165:59;;;;;;;;;;;;8069:10;;-1:-1:-1;;;;;8115:24:10;;;;8035:4;;8165:59;;8172:9;;8165:59;;;;;;;:6;:59::i;:::-;8149:75;;8250:3;-1:-1:-1;;;;;8239:14:10;:7;-1:-1:-1;;;;;8239:14:10;;;:48;;;;-1:-1:-1;;;;;;8257:30:10;;;;;8239:48;8235:307;;;8303:19;8325:97;8331:16;8349:6;8325:97;;;;;;;;;;;;;;;;;:5;:97::i;:::-;-1:-1:-1;;;;;8436:15:10;;;;;;;:10;:15;;;;;;;;:24;;;;;;;;;;;;;;:39;;-1:-1:-1;;;;;;8436:39:10;-1:-1:-1;;;;;8436:39:10;;;;;8495:36;8436:39;;-1:-1:-1;8436:24:10;;8495:36;;;;8436:39;;8495:36;:::i;:::-;;;;;;;;8235:307;;8552:33;8568:3;8573;8578:6;8552:15;:33::i;:::-;-1:-1:-1;8602:4:10;;7953:660;-1:-1:-1;;;;;;7953:660:10:o;7044:125::-;4045:6;;-1:-1:-1;;;;;4045:6:10;4031:10;:20;4023:82;;;;-1:-1:-1;;;4023:82:10;;;;;;;:::i;:::-;;;;;;;;;7113:6:::1;:16:::0;;-1:-1:-1;;;;;;7113:16:10::1;-1:-1:-1::0;;;;;7113:16:10;::::1;;::::0;;7144:18:::1;::::0;::::1;::::0;::::1;::::0;7113:16;;7144:18:::1;:::i;:::-;;;;;;;;7044:125:::0;:::o;1841:35::-;1874:2;1841:35;:::o;6427:186::-;4045:6;;-1:-1:-1;;;;;4045:6:10;4031:10;:20;4023:82;;;;-1:-1:-1;;;4023:82:10;;;;;;;:::i;:::-;6500:13:::1;6516:56;6523:9;6516:56;;;;;;;;;;;;;;;;;:6;:56::i;:::-;6500:72;;6582:24;6594:3;6599:6;6582:11;:24::i;:::-;4115:1;6427:186:::0;;:::o;6720:169::-;6769:13;6785:56;6792:9;6785:56;;;;;;;;;;;;;;;;;:6;:56::i;:::-;6769:72;;6851:31;6863:10;6875:6;6851:11;:31::i;:::-;6720:169;;:::o;2305:45::-;;;;;;;;;;;;-1:-1:-1;;;;;2305:45:10;;:::o;8751:100::-;8812:32;8822:10;8834:9;8812;:32::i;:::-;8751:100;:::o;2709:49::-;;;;;;;;;;;;;;;:::o;6113:106::-;-1:-1:-1;;;;;6195:17:10;6172:4;6195:17;;;:8;:17;;;;;;-1:-1:-1;;;;;6195:17:10;;6113:106::o;10880:1187::-;10959:6;10999:12;10985:11;:26;10977:79;;;;-1:-1:-1;;;10977:79:10;;;;;;;:::i;:::-;-1:-1:-1;;;;;11089:23:10;;11067:19;11089:23;;;:14;:23;;;;;;;;11126:17;11122:56;;11166:1;11159:8;;;;;11122:56;-1:-1:-1;;;;;11235:20:10;;;;;;:11;:20;;;;;;;;:38;-1:-1:-1;;11256:16:10;;11235:38;;;;;;;;;:48;;:63;-1:-1:-1;11231:145:10;;-1:-1:-1;;;;;11321:20:10;;;;;;:11;:20;;;;;;;;-1:-1:-1;;11342:16:10;;;;11321:38;;;;;;;;:44;-1:-1:-1;;;11321:44:10;;-1:-1:-1;;;;;11321:44:10;;-1:-1:-1;11314:51:10;;11231:145;-1:-1:-1;;;;;11434:20:10;;;;;;:11;:20;;;;;;;;:23;;;;;;;;:33;:23;:33;:47;-1:-1:-1;11430:86:10;;;11504:1;11497:8;;;;;11430:86;11526:12;-1:-1:-1;;11567:16:10;;11593:418;11608:5;11600:13;;:5;:13;;;11593:418;;;11671:1;11654:13;;;11653:19;;;11645:27;;11713:20;;:::i;:::-;-1:-1:-1;;;;;;11736:20:10;;;;;;:11;:20;;;;;;;;:28;;;;;;;;;;;;;11713:51;;;;;;;;;;;;;;;-1:-1:-1;;;11713:51:10;;;-1:-1:-1;;;;;11713:51:10;;;;;;;;;11782:27;;11778:223;;;11836:8;;;;-1:-1:-1;11829:15:10;;-1:-1:-1;;;;11829:15:10;11778:223;11869:12;;:26;;;-1:-1:-1;11865:136:10;;;11923:6;11915:14;;11865:136;;;11985:1;11976:6;:10;11968:18;;11865:136;11593:418;;;;;-1:-1:-1;;;;;;12027:20:10;;;;;;:11;:20;;;;;;;;:27;;;;;;;;;;:33;-1:-1:-1;;;;;;;;12027:33:10;;;;;-1:-1:-1;;10880:1187:10;;;;:::o;3224:39::-;;;;;;;;;;;;;:::o;1747:38::-;;;;;;;;;;;;;;-1:-1:-1;;;1747:38:10;;;;:::o;7421:235::-;7486:4;7502:13;7518:60;7525:9;7518:60;;;;;;;;;;;;;;;;;:6;:60::i;:::-;7502:76;;7588:40;7604:10;7616:3;7621:6;7588:15;:40::i;:::-;-1:-1:-1;7645:4:10;;7421:235;-1:-1:-1;;;7421:235:10:o;10243:219::-;-1:-1:-1;;;;;10348:23:10;;10308:6;10348:23;;;:14;:23;;;;;;;;10388:16;:67;;10454:1;10388:67;;;-1:-1:-1;;;;;10407:20:10;;;;;;:11;:20;;;;;;;;-1:-1:-1;;10428:16:10;;10407:38;;;;;;;;;:44;-1:-1:-1;;;10407:44:10;;-1:-1:-1;;;;;10407:44:10;10388:67;10381:74;10243:219;-1:-1:-1;;;10243:219:10:o;9270:783::-;9465:4;;;;;;;;;;;;-1:-1:-1;;;9465:4:10;;;;;9385:23;2866:80;9449:22;9473:12;:10;:12::i;:::-;9495:4;9421:80;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;9411:91;;;;;;9385:117;;9512:18;3079:71;9575:9;9586:5;9593:6;9543:57;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;9533:68;;;;;;9512:89;;9611:14;9667:15;9684:10;9638:57;;;;;;;;;:::i;:::-;;;;;;;;;;;;;9628:68;;;;;;9611:85;;9706:17;9726:26;9736:6;9744:1;9747;9750;9726:26;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;9726:26:10;;-1:-1:-1;;9726:26:10;;;-1:-1:-1;;;;;;;9770:23:10;;9762:75;;;;-1:-1:-1;;;9762:75:10;;;;;;;:::i;:::-;-1:-1:-1;;;;;9864:17:10;;;;;;:6;:17;;;;;:19;;;;;;;;9855:28;;9847:76;;;;-1:-1:-1;;;9847:76:10;;;;;;;:::i;:::-;9948:6;9941:3;:13;;9933:65;;;;-1:-1:-1;;;9933:65:10;;;;;;;:::i;:::-;10015:31;10025:9;10036;10015;:31::i;:::-;10008:38;;;;9270:783;;;;;;;:::o;4915:134::-;-1:-1:-1;;;;;5014:19:10;;;4991:4;5014:19;;;:10;:19;;;;;;;;:28;;;;;;;;;;;;-1:-1:-1;;;;;5014:28:10;;4915:134::o;3033:117::-;3079:71;3033:117;:::o;2577:70::-;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2577:70:10;;-1:-1:-1;;;;;2577:70:10;;:::o;15826:158::-;15901:6;15938:12;-1:-1:-1;;;15927:9:10;;15919:32;;;;-1:-1:-1;;;15919:32:10;;;;;;;;:::i;:::-;-1:-1:-1;15975:1:10;;15826:158;-1:-1:-1;;15826:158:10:o;16180:162::-;16266:6;16297:1;-1:-1:-1;;;;;16292:6:10;:1;-1:-1:-1;;;;;16292:6:10;;;16300:12;16284:29;;;;;-1:-1:-1;;;16284:29:10;;;;;;;;:::i;:::-;-1:-1:-1;;;16330:5:10;;;16180:162::o;12446:609::-;-1:-1:-1;;;;;12539:17:10;;12531:91;;;;-1:-1:-1;;;12531:91:10;;;;;;;:::i;:::-;-1:-1:-1;;;;;12640:17:10;;12632:89;;;;-1:-1:-1;;;12632:89:10;;;;;;;:::i;:::-;-1:-1:-1;;;;;12754:13:10;;;;;;:8;:13;;;;;;;;;;12748:87;;;;;;;;;;;;;;-1:-1:-1;;;;;12754:13:10;;;;12769:6;;12748:87;;;;;;;:5;:87::i;:::-;-1:-1:-1;;;;;12732:13:10;;;;;;;:8;:13;;;;;;;;:103;;-1:-1:-1;;;;;;12732:103:10;-1:-1:-1;;;;;12732:103:10;;;;;;12867:13;;;;;;;;;;12861:81;;;;;;;;;;;;;;12867:13;;;;;12882:6;;12861:81;;;;;;;;:5;:81::i;:::-;-1:-1:-1;;;;;12845:13:10;;;;;;;:8;:13;;;;;;;:97;;-1:-1:-1;;;;;;12845:97:10;-1:-1:-1;;;;;12845:97:10;;;;;;;;;;;12957:26;;;;;;;;;;12976:6;;12957:26;:::i;:::-;;;;;;;;-1:-1:-1;;;;;13009:14:10;;;;;;;:9;:14;;;;;;;13025;;;;;;;;12994:54;;13009:14;;;;13025;13041:6;12994:14;:54::i;13061:564::-;-1:-1:-1;;;;;13137:17:10;;13129:85;;;;-1:-1:-1;;;13129:85:10;;;;;;;:::i;:::-;13224:13;13240:70;13247:11;;13240:70;;;;;;;;;;;;;;;;;:6;:70::i;:::-;13224:86;;13334:72;13340:6;13348;13334:72;;;;;;;;;;;;;;;;;:5;:72::i;:::-;-1:-1:-1;;;;;13320:86:10;;;:11;:86;;;-1:-1:-1;;;;;13438:13:10;;;;:8;:13;;;;;;;;;;13432:77;;;;;;;;;;;;;;13438:13;;;;;13453:6;;13432:77;;;;;;;;:5;:77::i;:::-;-1:-1:-1;;;;;13416:13:10;;;;;;:8;:13;;;;;;:93;;-1:-1:-1;;;;;;13416:93:10;-1:-1:-1;;;;;13416:93:10;;;;;;;;;;;13524:33;;13416:13;;;13524:33;;;;13550:6;;13524:33;:::i;:::-;;;;;;;;-1:-1:-1;;;;;13595:14:10;;;13591:1;13595:14;;;:9;:14;;;;;;13568:50;;13595:14;13611:6;13568:14;:50::i;13631:453::-;13699:13;13715:70;13722:11;;13715:70;;;;;;;;;;;;;;;;;:6;:70::i;:::-;13699:86;;13809:65;13815:6;13823;13809:65;;;;;;;;;;;;;;;;;:5;:65::i;:::-;-1:-1:-1;;;;;13795:79:10;;;:11;:79;;;-1:-1:-1;;;;;13906:13:10;;;;:8;:13;;;;;;;;;;13900:68;;;;;;;;;;;;;;13906:13;;;;;13921:6;;13900:68;;;;;;;;:5;:68::i;:::-;-1:-1:-1;;;;;13884:13:10;;;;;;:8;:13;;;;;;:84;;-1:-1:-1;;;;;;13884:84:10;-1:-1:-1;;;;;13884:84:10;;;;;;;;;;;13983:33;;;;;;14009:6;;13983:33;:::i;:::-;;;;;;;;-1:-1:-1;;;;;14042:14:10;;;;;;;:9;:14;;;;;;14027:50;;14042:14;;14070:6;14027:14;:50::i;12073:367::-;-1:-1:-1;;;;;12175:20:10;;;12149:23;12175:20;;;:9;:20;;;;;;;;;;12231:8;:19;;;;;;12260:20;;;;:32;;;-1:-1:-1;;;;;;12260:32:10;;;;;;;12308:54;;12175:20;;;;;-1:-1:-1;;;;;12231:19:10;;;;12260:32;;12175:20;;;12308:54;;12149:23;12308:54;12373:60;12388:15;12405:9;12416:16;12373:14;:60::i;:::-;12073:367;;;;:::o;16348:149::-;16456:9;16348:149;:::o;15990:184::-;16076:6;16105:5;;;16136:12;-1:-1:-1;;;;;16128:6:10;;;;;;;;16120:29;;;;-1:-1:-1;;;16120:29:10;;;;;;;;:::i;:::-;-1:-1:-1;16166:1:10;15990:184;-1:-1:-1;;;;15990:184:10:o;14090:925::-;14194:6;-1:-1:-1;;;;;14184:16:10;:6;-1:-1:-1;;;;;14184:16:10;;;:30;;;;;14213:1;14204:6;-1:-1:-1;;;;;14204:10:10;;14184:30;14180:829;;;-1:-1:-1;;;;;14234:20:10;;;14230:378;;-1:-1:-1;;;;;14293:22:10;;14274:16;14293:22;;;:14;:22;;;;;;;;;14352:13;:60;;14411:1;14352:60;;;-1:-1:-1;;;;;14368:19:10;;;;;;:11;:19;;;;;;;;-1:-1:-1;;14388:13:10;;14368:34;;;;;;;;;:40;-1:-1:-1;;;14368:40:10;;-1:-1:-1;;;;;14368:40:10;14352:60;14333:79;;14430:16;14449:69;14455:9;14466:6;14449:69;;;;;;;;;;;;;;;;;:5;:69::i;:::-;14430:88;;14536:57;14553:6;14561:9;14572;14583;14536:16;:57::i;:::-;14230:378;;;;-1:-1:-1;;;;;14626:20:10;;;14622:377;;-1:-1:-1;;;;;14685:22:10;;14666:16;14685:22;;;:14;:22;;;;;;;;;14744:13;:60;;14803:1;14744:60;;;-1:-1:-1;;;;;14760:19:10;;;;;;:11;:19;;;;;;;;-1:-1:-1;;14780:13:10;;14760:34;;;;;;;;;:40;-1:-1:-1;;;14760:40:10;;-1:-1:-1;;;;;14760:40:10;14744:60;14725:79;;14822:16;14841:68;14847:9;14858:6;14841:68;;;;;;;;;;;;;;;;;:5;:68::i;:::-;14822:87;;14927:57;14944:6;14952:9;14963;14974;15021:635;15140:18;15161:77;15168:12;15161:77;;;;;;;;;;;;;;;;;:6;:77::i;:::-;15140:98;;15268:1;15253:12;:16;;;:85;;;;-1:-1:-1;;;;;;15273:22:10;;;;;;:11;:22;;;;;;;;:65;-1:-1:-1;;15296:16:10;;15273:40;;;;;;;;;:50;:65;;;:50;;:65;15253:85;15249:334;;;-1:-1:-1;;;;;15354:22:10;;;;;;:11;:22;;;;;;;;-1:-1:-1;;15377:16:10;;15354:40;;;;;;;;;:57;;-1:-1:-1;;15354:57:10;-1:-1:-1;;;;;;;;15354:57:10;;;;;;15249:334;;;15481:33;;;;;;;;;;;;;;-1:-1:-1;;;;;15481:33:10;;;;;;;;;;-1:-1:-1;;;;;15442:22:10;;-1:-1:-1;15442:22:10;;;:11;:22;;;;;:36;;;;;;;;;;:72;;;;;;;;;-1:-1:-1;;;15442:72:10;-1:-1:-1;;15442:72:10;;;-1:-1:-1;;15442:72:10;;;;;;;;;;;;;;;15528:25;;;:14;:25;;;;;;;:44;;15442:72;15556:16;;15528:44;;;;;;;;;;;;;15249:334;15619:9;-1:-1:-1;;;;;15598:51:10;;15630:8;15640;15598:51;;;;;;;:::i;:::-;;;;;;;;15021:635;;;;;:::o;15662:158::-;15737:6;15774:12;-1:-1:-1;;;15763:9:10;;15755:32;;;;-1:-1:-1;;;15755:32:10;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;:::o;5:130::-;72:20;;-1:-1;;;;;17986:54;;19060:35;;19050:2;;19109:1;;19099:12;684:241;;788:2;776:9;767:7;763:23;759:32;756:2;;;-1:-1;;794:12;756:2;856:53;901:7;877:22;856:53;:::i;932:366::-;;;1053:2;1041:9;1032:7;1028:23;1024:32;1021:2;;;-1:-1;;1059:12;1021:2;1121:53;1166:7;1142:22;1121:53;:::i;:::-;1111:63;;1229:53;1274:7;1211:2;1254:9;1250:22;1229:53;:::i;:::-;1219:63;;1015:283;;;;;:::o;1305:491::-;;;;1443:2;1431:9;1422:7;1418:23;1414:32;1411:2;;;-1:-1;;1449:12;1411:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;1501:63;-1:-1;1601:2;1640:22;;72:20;97:33;72:20;97:33;:::i;:::-;1405:391;;1609:63;;-1:-1;;;1709:2;1748:22;;;;346:20;;1405:391::o;1803:366::-;;;1924:2;1912:9;1903:7;1899:23;1895:32;1892:2;;;-1:-1;;1930:12;1892:2;1992:53;2037:7;2013:22;1992:53;:::i;:::-;1982:63;2082:2;2121:22;;;;346:20;;-1:-1;;;1886:283::o;2176:865::-;;;;;;;2363:3;2351:9;2342:7;2338:23;2334:33;2331:2;;;-1:-1;;2370:12;2331:2;2432:53;2477:7;2453:22;2432:53;:::i;:::-;2422:63;;2522:2;2565:9;2561:22;346:20;2530:63;;2630:2;2673:9;2669:22;346:20;2638:63;;2738:2;2779:9;2775:22;616:20;18297:4;19578:5;18286:16;19555:5;19552:33;19542:2;;-1:-1;;19589:12;19542:2;2325:716;;;;-1:-1;2325:716;;2844:3;2884:22;;209:20;;2953:3;2993:22;;;209:20;;-1:-1;2325:716;-1:-1;;2325:716::o;3048:364::-;;;3168:2;3156:9;3147:7;3143:23;3139:32;3136:2;;;-1:-1;;3174:12;3136:2;3236:53;3281:7;3257:22;3236:53;:::i;:::-;3226:63;;3326:2;3368:9;3364:22;482:20;18203:10;19458:5;18192:22;19434:5;19431:34;19421:2;;-1:-1;;19469:12;19421:2;3334:62;;;;3130:282;;;;;:::o;3419:241::-;;3523:2;3511:9;3502:7;3498:23;3494:32;3491:2;;;-1:-1;;3529:12;3491:2;-1:-1;346:20;;3485:175;-1:-1;3485:175::o;8682:659::-;-1:-1;;;6406:87;;6391:1;6512:11;;3969:37;;;;9193:12;;;3969:37;9304:12;;;8927:414::o;9348:222::-;-1:-1;;;;;17986:54;;;;3738:37;;9475:2;9460:18;;9446:124::o;9577:210::-;17819:13;;17812:21;3852:34;;9698:2;9683:18;;9669:118::o;9794:222::-;3969:37;;;9921:2;9906:18;;9892:124::o;10023:556::-;3969:37;;;-1:-1;;;;;17986:54;;;;10399:2;10384:18;;3738:37;10482:2;10467:18;;3969:37;10565:2;10550:18;;3969:37;10234:3;10219:19;;10205:374::o;10586:556::-;3969:37;;;10962:2;10947:18;;3969:37;;;;11045:2;11030:18;;3969:37;-1:-1;;;;;17986:54;11128:2;11113:18;;3738:37;10797:3;10782:19;;10768:374::o;11149:548::-;3969:37;;;18297:4;18286:16;;;;11517:2;11502:18;;8387:35;11600:2;11585:18;;3969:37;11683:2;11668:18;;3969:37;11356:3;11341:19;;11327:370::o;11704:310::-;;11851:2;;11872:17;11865:47;4322:5;17288:12;17445:6;11851:2;11840:9;11836:18;17433:19;-1:-1;18611:101;18625:6;18622:1;18619:13;18611:101;;;18692:11;;;;;18686:18;18673:11;;;17473:14;18673:11;18666:39;18640:10;;18611:101;;;18727:6;18724:1;18721:13;18718:2;;;-1:-1;17473:14;18783:6;11840:9;18774:16;;18767:27;18718:2;-1:-1;18980:7;18964:14;-1:-1;;18960:28;4480:39;;;;17473:14;4480:39;;11822:192;-1:-1;;;11822:192::o;12021:416::-;12221:2;12235:47;;;4756:2;12206:18;;;17433:19;4792:34;17473:14;;;4772:55;-1:-1;;;4847:12;;;4840:32;4891:12;;;12192:245::o;12444:416::-;12644:2;12658:47;;;5142:2;12629:18;;;17433:19;5178:34;17473:14;;;5158:55;5247:31;5233:12;;;5226:53;5298:12;;;12615:245::o;12867:416::-;13067:2;13081:47;;;5549:2;13052:18;;;17433:19;5585:34;17473:14;;;5565:55;5654:29;5640:12;;;5633:51;5703:12;;;13038:245::o;13290:416::-;13490:2;13504:47;;;5954:2;13475:18;;;17433:19;5990:34;17473:14;;;5970:55;6059:25;6045:12;;;6038:47;6104:12;;;13461:245::o;13713:416::-;13913:2;13927:47;;;6762:2;13898:18;;;17433:19;6798:34;17473:14;;;6778:55;-1:-1;;;6853:12;;;6846:31;6896:12;;;13884:245::o;14136:416::-;14336:2;14350:47;;;7147:2;14321:18;;;17433:19;7183:34;17473:14;;;7163:55;-1:-1;;;7238:12;;;7231:27;7277:12;;;14307:245::o;14559:416::-;14759:2;14773:47;;;7528:2;14744:18;;;17433:19;7564:34;17473:14;;;7544:55;-1:-1;;;7619:12;;;7612:31;7662:12;;;14730:245::o;14982:416::-;15182:2;15196:47;;;7913:2;15167:18;;;17433:19;7949:34;17473:14;;;7929:55;-1:-1;;;8004:12;;;7997:41;8057:12;;;15153:245::o;15634:218::-;18203:10;18192:22;;;;8272:36;;15759:2;15744:18;;15730:122::o;15859:325::-;18203:10;18192:22;;;;8272:36;;-1:-1;;;;;18375:38;16170:2;16155:18;;8634:36;16010:2;15995:18;;15981:203::o;16191:214::-;18297:4;18286:16;;;;8387:35;;16314:2;16299:18;;16285:120::o;16412:220::-;-1:-1;;;;;18375:38;;;;8504:49;;16538:2;16523:18;;16509:123::o;16864:329::-;-1:-1;;;;;18375:38;;;8504:49;;18375:38;;17179:2;17164:18;;8504:49;17017:2;17002:18;;16988:205::o;19001:117::-;-1:-1;;;;;17986:54;;19060:35;;19050:2;;19109:1;;19099:12

ipfs://22f44bac328f96074754879b0549d2063b571c4e897c733ee706f513d276545b