Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "./interfaces/IRegistry.sol";
import "./lib/MinimalProxyStore.sol";
import "./Account.sol";

/**
 * @title A registry for token bound accounts
 * @dev Determines the address for each token bound account and performs deployment of accounts
 * @author Jayden Windle (jaydenwindle)
 */

contract AccountRegistry is IRegistry, Ownable {
    /**
     * @dev Address of the account implementation
     */
    address public immutable implementation;

    /**
     * @dev User wallet Information struct having NFT tokenIds and NFT wallet address
     */
    struct userWalletInfo {
        uint256 tokenId;
        address walletAddress;
    }

    /**
     * @dev Cycle information details: Start time and End time of the cycle
     */
    struct cycleDetails {
        uint256 startTime;
        uint256 endTime;
    }

    /**
     * @dev Account info mapping maps user addres to userWalletInfo struct array
     */
    mapping(address => userWalletInfo[]) public accountInfo;

    /**
     * @dev Number of wallets created by registry
     */
    mapping(address => uint256) public numOfWalletCreated;

    /**
     * @dev this mapping maps cycle number to cycle details
     */
    mapping(uint256 => cycleDetails) public cycleNumToCycleDetails;

    /**
     * @dev GODL rewards entitled for the cycle
     */
    mapping(uint256 => uint256) public GODLRewardsForCycle;

    /**
     * @dev Total Value staked for that cycle
     */
    mapping(uint256 => uint256) public TVSforCycle;

    /**
     * @dev Vgold token address
     */
    address public vgoldToken;

    /**
     * @dev totalVGold stake for all the cycles
     */
    uint256 public totalVgoldStake;

    uint256 public immutable minimumLockup = 180;

    Account accountContract;

    uint256 public cycleCount;

    address public GODLToken;

    mapping(address => bool) public isNFTWalletAccount;

    uint256 public cyclePeriod = 180;

    /**
     * @dev Emitted whenever new Address Created
     */
    event AddressCreated(address indexed newAddress);

    event VgoldStaked(address NFTWalletAddress, uint256 stakeAmount, uint256 cycleNum);

    event VGoldUnstaked(address NFTWalletAddress, uint256 totalUnstake, uint256 userRewards, uint256 eligibleStakes, uint256 cycleNum);
    
    event RewardsClaimed(address NFTWalletAddress, uint256 userRewards, uint256 eligibleStakes, uint256 cycleNum);

    modifier onlyWalletOwner(address payable _NFTWalletAccount) {
        address walletOwner = Account(_NFTWalletAccount).owner();
        require(
            msg.sender == walletOwner,
            "Can only be called by wallet owner"
        );
        _;
    }

    /**
     * @dev Constructor for Account Registry contract.
     * @param _implementation is the Account template address
     * @param _GODLToken address of GODL Token
     * @param _vgoldToken address of VGold Token
     */
    constructor(
        address _implementation,
        address _GODLToken,
        address _vgoldToken
    ) {
        implementation = _implementation;
        GODLToken = _GODLToken;
        vgoldToken = _vgoldToken;
    }

    // /**
    //     To get NFT wallet addresses owned by a user
    //     */
    // function getAccountInfo(address userAdd) public view returns(address[] memory){
    //     address[] memory walletAddresses
    //     while(accountInfo)
    // }
    /**
     * @dev Creates the account for an ERC721 token. Will revert if account has already been deployed
     *
     * @param chainId the chainid of the network the ERC721 token exists on
     * @param tokenCollection the contract address of the ERC721 token which will control the deployed account
     * @param tokenId the token ID of the ERC721 token which will control the deployed account
     * @return The address of the deployed ccount
     */
    function createAccount(
        uint256 chainId,
        address tokenCollection,
        uint256 tokenId
    ) external returns (address) {
        return _createAccount(chainId, tokenCollection, tokenId);
    }

    /**
     * @dev Deploys the account for an ERC721 token. Will revert if account has already been deployed
     *
     * @param tokenCollection the contract address of the ERC721 token which will control the deployed account
     * @param tokenId the token ID of the ERC721 token which will control the deployed account
     * @return The address of the deployed account
     */
    function createAccount(
        address tokenCollection,
        uint256 tokenId
    ) external returns (address) {
        return _createAccount(block.chainid, tokenCollection, tokenId);
    }

    /**
     * @dev Gets the address of the account for an ERC721 token. If account is
     * not yet deployed, returns the address it will be deployed to
     *
     * @param chainId the chainid of the network the ERC721 token exists on
     * @param tokenCollection the address of the ERC721 token contract
     * @param tokenId the tokenId of the ERC721 token that controls the account
     * @return The account address
     */
    function account(
        uint256 chainId,
        address tokenCollection,
        uint256 tokenId
    ) external view returns (address) {
        return _account(chainId, tokenCollection, tokenId);
    }

    /**
     * @dev Gets the address of the account for an ERC721 token. If account is
     * not yet deployed, returns the address it will be deployed to
     *
     * @param tokenCollection the address of the ERC721 token contract
     * @param tokenId the tokenId of the ERC721 token that controls the account
     * @return The account address
     */
    function account(
        address tokenCollection,
        uint256 tokenId
    ) external view returns (address) {
        return _account(block.chainid, tokenCollection, tokenId);
    }

    function _createAccount(
        uint256 chainId,
        address tokenCollection,
        uint256 tokenId
    ) internal returns (address) {
        require(
            IERC721(tokenCollection).ownerOf(tokenId) == msg.sender,
            "You are not the owner of NFT"
        );
        bytes memory encodedTokenData = abi.encode(
            chainId,
            tokenCollection,
            tokenId
        );
        bytes32 salt = keccak256(encodedTokenData);
        address accountProxy = MinimalProxyStore.cloneDeterministic(
            implementation,
            encodedTokenData,
            salt
        );

        userWalletInfo memory userInfo = userWalletInfo(tokenId, accountProxy);
        accountInfo[msg.sender].push(userInfo);
        numOfWalletCreated[msg.sender]++;
        isNFTWalletAccount[accountProxy] = true;
        //setting the Registry contract setter funciton which can only be called once
        accountContract = Account(payable(accountProxy));
        accountContract.setRegistry(address(this));
        accountContract.setMinLockup(minimumLockup);
        emit AccountCreated(accountProxy, tokenCollection, tokenId);

        return accountProxy;
    }

    function _account(
        uint256 chainId,
        address tokenCollection,
        uint256 tokenId
    ) internal view returns (address) {
        bytes memory encodedTokenData = abi.encode(
            chainId,
            tokenCollection,
            tokenId
        );
        bytes32 salt = keccak256(encodedTokenData);

        address accountProxy = MinimalProxyStore.predictDeterministicAddress(
            implementation,
            encodedTokenData,
            salt
        );

        return accountProxy;
    }

    function getMinimumLockuop() external pure returns (uint256) {
        return minimumLockup;
    }

    function getCycleCount() external view returns (uint256) {
        return cycleCount;
    }

    function getVgoldToken() external view returns (address) {
        return vgoldToken;
    }

    function getCycleNumToCycleEndTime(
        uint256 _cycleNum
    ) public view returns (uint256) {
        return cycleNumToCycleDetails[_cycleNum].endTime;
    }

    function setVgoldToken(address _vgold) public onlyOwner {
        vgoldToken = _vgold;
    }

    function setCycle(uint256 _startTime, uint256 _freq) public onlyOwner {
        require(_startTime >= block.timestamp, "You can't creat cycle in past");
        for (uint256 i = 1; i <= _freq; i++) {
            if (i == 1) {
                cycleCount++;
                cycleNumToCycleDetails[cycleCount] = cycleDetails(
                    _startTime,
                    _startTime + cyclePeriod
                );
            } else {
                cycleCount++;
                _startTime = cycleNumToCycleDetails[cycleCount - 1].endTime;
                cycleNumToCycleDetails[cycleCount] = cycleDetails(
                    _startTime,
                    _startTime + cyclePeriod
                );
            }
        }
    }

    function getCurrentCycle() public view returns (uint256) {
        uint256 cycleNumber;
        for (uint256 i = 1; i <= cycleCount; i++) {
            if (
                cycleNumToCycleDetails[i].startTime <= block.timestamp &&
                cycleNumToCycleDetails[i].endTime > block.timestamp
            ) {
                cycleNumber = i;
                break;
            }
        }
        return cycleNumber;
    }

    function fundGODL(
        uint256 _cycleNum,
        uint256 _rewardAmount
    ) public onlyOwner {
        require(_rewardAmount > 0, "Amount should be greater than zero");
        require(_cycleNum <= cycleCount, "Invalid cycle");
        require(
            IERC20(GODLToken).transferFrom(
                msg.sender,
                address(this),
                _rewardAmount
            ),
            "GODL TransferFailed"
        );
        GODLRewardsForCycle[_cycleNum] += _rewardAmount;
    }

    function fundGODLForMultipleCycles(
        uint256[] memory _cycles,
        uint256[] memory _rewardAmounts
    ) public onlyOwner {
        require(
            _cycles.length == _rewardAmounts.length,
            "Cycles and reward counts are not matching"
        );
        for (uint256 i = 0; i < _cycles.length; i++) {
            require(
                _rewardAmounts[i] > 0,
                "Amount should be greater than zero"
            );
            require(_cycles[i] <= cycleCount, "Invalid cycle");
            require(
                IERC20(GODLToken).transferFrom(
                    msg.sender,
                    address(this),
                    _rewardAmounts[i]
                ),
                "GODL TransferFailed"
            );
            GODLRewardsForCycle[_cycles[i]] += _rewardAmounts[i];
        }
    }

    function withdrawGODLforCycle(
        uint256 _cycleNum,
        uint256 _amount
    ) public onlyOwner {
        require(_amount > 0, "Amount should be greater than zero");
        require(
            IERC20(GODLToken).transfer(msg.sender, _amount),
            "GODL Token transferFailed"
        );
        GODLRewardsForCycle[_cycleNum] -= _amount;
    }

    function withdrawAllGODL() public onlyOwner {
        uint256 balanceOfContract = IERC20(GODLToken).balanceOf(address(this));
        require(balanceOfContract > 0, "Zero GODL in contract");
        require(
            IERC20(GODLToken).transfer(msg.sender, balanceOfContract),
            "GODL Token transferFailed"
        );
        for (uint256 i = 1; i <= cycleCount; i++) {
            GODLRewardsForCycle[i] = 0;
        }
    }

    function withdrawAnyTokenorETH(
        address _token,
        bool _ifETH,
        uint256 _amount
    ) public onlyOwner {
        if (!_ifETH) {
            require(_amount > 0, "Amount should be greater than zero");
            require(
                IERC20(_token).transfer(msg.sender, _amount),
                "Token transfer failed"
            );
        } else {
            require(_amount > 0, "Amount should be greater than zero");
            payable(msg.sender).transfer(_amount);
        }
    }

    function stakeVgold(
        address payable _NFTWalletAccount,
        uint256 _stakeAmount
    ) public onlyWalletOwner(_NFTWalletAccount) {
        uint256 cycleNum = getCurrentCycle();
        require(
            isNFTWalletAccount[_NFTWalletAccount],
            "Invalid NFT wallet acoount"
        );
        require(cycleNum!=0, "Cycle not set");
        require(cycleNum <= cycleCount, "Invalid cycle");
        require(_stakeAmount > 0, "Amount should be greater than 0");
        // require(block.timestamp < getCycleNumToCycleEndTime(cycleNum), "You can't stake in old cycle, Please check the cycle Number");
        // require(block.timestamp >= cycleNumToCycleDetails[cycleNum].startTime, "You can't stake in upcoming cycle, Please check the cycle Number");
        require(
            IERC20(vgoldToken).transferFrom(
                msg.sender,
                _NFTWalletAccount,
                _stakeAmount
            ),
            "Token Transfer Failed"
        );
        accountContract = Account(_NFTWalletAccount);
        accountContract.stake(_stakeAmount, cycleNum);
        TVSforCycle[cycleNum] += _stakeAmount;
        totalVgoldStake += _stakeAmount;
        emit VgoldStaked(_NFTWalletAccount, _stakeAmount, cycleNum);
    }

    function claimVgold(
        address payable _NFTWalletAccount,
        uint256 _cycleNum
    ) public onlyWalletOwner(_NFTWalletAccount) {
        uint256 userRewards;
        require(
            isNFTWalletAccount[_NFTWalletAccount],
            "Invalid NFT wallet acoount"
        );
        require(_cycleNum <= cycleCount, "Invalid cycle");
        accountContract = Account(_NFTWalletAccount);
        uint256 eligibleStake = accountContract.calculateEligibleStake(
            _cycleNum
        );
        if(eligibleStake != 0 && TVSforCycle[_cycleNum] == 0){
            userRewards = 0;
        }
        else{
            userRewards = (eligibleStake * GODLRewardsForCycle[_cycleNum]) /
            TVSforCycle[_cycleNum];
        }
        require(userRewards > 0, "Unable to claim: Zero Rewards");
        require(
            IERC20(GODLToken).balanceOf(address(this)) >= userRewards,
            "Not enough rewards in the contract"
        );
        require(
            IERC20(GODLToken).transfer(msg.sender, userRewards),
            "GODL Reward Transfer Failed"
        );
        accountContract.postClaim(block.timestamp, _cycleNum);
        GODLRewardsForCycle[_cycleNum] -= userRewards;
        emit RewardsClaimed(_NFTWalletAccount, userRewards, eligibleStake, _cycleNum);
    }

    function calculateRewards(
        address payable _NFTWalletAccount,
        uint256 _cycleNum
    ) public view returns(uint256){
        uint256 userRewards;
        require(
            isNFTWalletAccount[_NFTWalletAccount],
            "Invalid NFT wallet acoount"
        );
        require(_cycleNum <= cycleCount, "Invalid cycle");
        Account accountContractInstance = Account(_NFTWalletAccount);
        uint256 eligibleStake = accountContractInstance.calculateEligibleStake(
            _cycleNum
        );
        if(eligibleStake != 0 && TVSforCycle[_cycleNum] == 0){
            userRewards = 0;    
        }
        else{
            userRewards = (eligibleStake * GODLRewardsForCycle[_cycleNum]) /
            TVSforCycle[_cycleNum];
        }
        return userRewards;
    }


    function unstakeVgoldForStake(
        address payable _NFTWalletAccount,
        uint256[] memory arrayIndexes,
        uint256 _cycleNum
    ) public onlyWalletOwner(_NFTWalletAccount) {
        // TO check if its a registry generated NFT account
        require(
            isNFTWalletAccount[_NFTWalletAccount],
            "Invalid NFT wallet acoount"
        );
        // To check the valid cycle number
        require(_cycleNum <= cycleCount, "Invalid cycle");
        accountContract = Account(_NFTWalletAccount);
        // Calculate eligible stake to claim GODL reward
        uint256 eligibleStake = accountContract.calculateEligibleStakeArray(
            arrayIndexes,
            _cycleNum
        );
        uint256 userRewards;
        // if user has eligible stakes then calculate user rewards
        if (eligibleStake != 0 && TVSforCycle[_cycleNum] != 0) {
            userRewards =
                (eligibleStake * GODLRewardsForCycle[_cycleNum]) /
                TVSforCycle[_cycleNum];
        } else {
            userRewards = 0;
        }
        // if user has some rewards then transfer the GODL rewards to user.
        if (userRewards != 0) {
            require(
                IERC20(GODLToken).balanceOf(address(this)) >= userRewards,
                "Not enough rewards in the contract"
            );
            require(
                IERC20(GODLToken).transfer(msg.sender, userRewards),
                "GODL Reward Transfer Failed"
            );
            GODLRewardsForCycle[_cycleNum] -= userRewards;
        }
        // Call account contract post unstake for array function to make the stakes and time stamps 0 for the array indexes.
        uint256 totalUnstake = accountContract.postUnstakeForArray(
            arrayIndexes,
            _cycleNum
        );
        totalVgoldStake -= totalUnstake;
        TVSforCycle[_cycleNum] -= totalUnstake;
        emit VGoldUnstaked(_NFTWalletAccount, totalUnstake, userRewards, eligibleStake, _cycleNum);

    }

    function unstakeVgoldForCycle(
        address payable _NFTWalletAccount,
        uint256 _cycleNum
    ) public onlyWalletOwner(_NFTWalletAccount) {
        require(
            isNFTWalletAccount[_NFTWalletAccount],
            "Invalid NFT wallet acoount"
        );
        require(_cycleNum <= cycleCount, "Invalid cycle");
        accountContract = Account(_NFTWalletAccount);
        uint256 eligibleStake = accountContract.calculateEligibleStake(
            _cycleNum
        );
        uint256 userRewards;
        if (eligibleStake != 0 && TVSforCycle[_cycleNum] != 0) {
            userRewards =
                (eligibleStake * GODLRewardsForCycle[_cycleNum]) /
                TVSforCycle[_cycleNum];
        } else {
            userRewards = 0;
        }
        if (userRewards != 0) {
            require(
                IERC20(GODLToken).balanceOf(address(this)) >= userRewards,
                "Not enough rewards in the contract"
            );
            require(
                IERC20(GODLToken).transfer(msg.sender, userRewards),
                "GODL Reward Transfer Failed"
            );
            GODLRewardsForCycle[_cycleNum] -= userRewards;
        }
        uint256 totalUnstake = accountContract.getTotalVgoldStakeForCycle(
            _cycleNum
        );
        TVSforCycle[_cycleNum] -= totalUnstake; 
        totalVgoldStake -= totalUnstake;
        require(
            accountContract.postUnstakeForCycle(_cycleNum),
            "PostUnstake for cycle failed"
        );
        emit VGoldUnstaked(_NFTWalletAccount, totalUnstake, userRewards, eligibleStake, _cycleNum);
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "./contracts/token/ERC721/IERC721.sol";
import "./contracts/token/ERC20/IERC20.sol";
import "./contracts/token/ERC1155/IERC1155.sol";
import "./contracts/interfaces/IERC1271.sol";
import "./contracts/utils/cryptography/SignatureChecker.sol";

import "./contracts/utils/introspection/IERC165.sol";
import "./contracts/token/ERC1155/IERC1155Receiver.sol";

import "./CrossChainExecutorList.sol";
import "./MinimalReceiver.sol";
import "./interfaces/IAccount.sol";
import "./lib/MinimalProxyStore.sol";
import "hardhat/console.sol";

/**
 * @title A smart contract wallet owned by a single ERC721 token
 * @author Jayden Windle (jaydenwindle)
 */

interface IRegistryContract {
    // function getMinimumLockup() external returns(uint256);
    function getCurrentCycle() external view returns (uint256);

    function getVgoldToken() external view returns (address);

    function getCycleNumToCycleEndTime(
        uint256 _cycleNum
    ) external view returns (uint256);
}

contract Account is IERC165, IERC1271, IAccount, MinimalReceiver {
    error NotAuthorized();
    error AccountLocked();
    error ExceedsMaxLockTime();

    CrossChainExecutorList public immutable crossChainExecutorList;

    /**
     * @dev Timestamp at which Account will unlock
     */
    uint256 public unlockTimestamp;

    /**
        to check if the contract is destroyed
        */
    bool public isDestroyed;

    /**
     * @dev Mapping from owner address to executor address
     */
    mapping(address => address) public executor;

    /**
     * @dev User Staking information
     */
    struct userStakeInfo {
        uint256 stakeAmount;
        uint256 stakeTime;
        uint256 cycleNum;
    }

    struct userStakeInfoWithArrayIndex {
        uint256 stakeAmount;
        uint256 stakeTime;
        uint256 arrayIndex;
    }


    /**
     * @dev User Staking information
     */
    mapping(uint256 => userStakeInfo[]) public userStake;

    /**
     * @dev User total staked VGOLD
     */
    uint256 public totalVgoldStake;

    mapping(uint256 => uint256) public totalVgoldStakeForCycle;

    // uint256 public

    /**
     * @dev User token deposit info
     */
    address[] public userDepositedTokenAddresses;

    /**
     * @dev Registry Contract Address
     */
    address public registryContract;

    mapping(uint256 => bool) public userstakedCycle;

    /**
     * @dev User NFT deposit info
     */
    address[] public userDepositedNFTAddresses;

    /**
     * @dev to check if the token was deposited or not
     */
    mapping(address => bool) public isthisTokenDeposited;

    /**
     * @dev to check if the NFT was deposited or not
     */
    mapping(address => bool) public isthisNFTDeposited;

    mapping(address => uint256[]) public NFTtokenIdDeposited;

    mapping(address => mapping(uint256 => bool)) NFTtokenIdexist;

    bool public isRegistrySet;

    /**
     * @dev Emitted whenever the lock status of a account is updated
     */
    event LockUpdated(uint256 timestamp);

    // Event emitted when an NFT is transferred
    event NFTTransferred(address from, address to, uint256 tokenId);

    // Event emitted when an ERC2O Token is transferred
    event ERC2OTokenTransferred(address from, address to, uint256 tokenId);

    uint256 public minLockup;

    // Event emitted when spender is approved
    event ERC20Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event ERC721Approval(
        address indexed owner,
        address indexed approved,
        uint256 indexed tokenId
    );

    // Event emitted when ERC1155 tokens are transferred
    event BatchErc1155TokensTransferred(
        address from,
        address to,
        uint256[] tokenIds,
        uint256[] amounts
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(
        address indexed account,
        address indexed operator,
        bool approved
    );

    // Event emitted when an ERC1155 token is transferred
    event ERC1155TokenTransferred(
        address from,
        address to,
        uint256 tokenId,
        uint256 amount
    );

    /**
     * @dev Emitted whenever the executor for a account is updated
     */
    event ExecutorUpdated(address owner, address executor);

    /**
     * @dev Throws if called by any smart contract other than the registry.
     */
    modifier onlyRegistry() {
        _checkRegistry();
        _;
    }

    modifier onlyOnce() {
        require(!isRegistrySet, "Setter function can only be called once");
        _;
        isRegistrySet = true;
    }

    constructor(address _crossChainExecutorList) {
        crossChainExecutorList = CrossChainExecutorList(
            _crossChainExecutorList
        );
    }

    /**
     * @dev Ensures execution can only continue if the account is not locked
     */
    modifier onlyUnlocked() {
        if (unlockTimestamp > block.timestamp) revert AccountLocked();
        _;
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        address _owner = owner();
        if (msg.sender != _owner) revert NotAuthorized();
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkRegistry() internal view virtual {
        require(registryContract == msg.sender, "Caller is not the Registry");
    }

    //UB
    /**
     * @dev gives deposited token Balalnce of this smart contract
     */
    function walletBalance(address tokenAddress) public view returns (uint256) {
        IERC20 erc20Contract = IERC20(tokenAddress);
        return erc20Contract.balanceOf(address(this));
    }

    // ----- WRITE Functions -------
    /**
     * @dev If account is unlocked and an executor is set, pass call to executor
     */
    fallback(
        bytes calldata data
    ) external payable onlyUnlocked returns (bytes memory result) {
        address _owner = owner();
        address _executor = executor[_owner];

        // accept funds if executor is undefined or cannot be called
        if (_executor.code.length == 0) return "";

        return _call(_executor, 0, data);
    }

    /**
     * @dev Executes a transaction from the Account. Must be called by an account owner.
     *
     * @param to      Destination address of the transaction
     * @param value   Ether value of the transaction
     * @param data    Encoded payload of the transaction
     */
    function executeCall(
        address to,
        uint256 value,
        bytes calldata data
    ) external payable onlyUnlocked returns (bytes memory result) {
        address _owner = owner();
        if (msg.sender != _owner) revert NotAuthorized();

        return _call(to, value, data);
    }

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAllERC1155(
        address tokenCollection,
        address operator,
        bool approved
    ) external onlyUnlocked onlyOwner {
        // Get the instance of the ERC1155 contract
        IERC1155 erc1155Contract = IERC1155(tokenCollection);

        // Check if the operator is nit owner
        require(
            operator == address(this),
            "NFTHandler: operator should not be owner"
        );
        // Transfer the tokens to the specified address
        erc1155Contract.setApprovalForAll(operator, approved);

        // Emit the ApprovalForAll event
        emit ApprovalForAll(address(this), operator, approved);
    }

    // Transfer ERC1155 tokens from this contract to another address
    function batchTransferERC1155Tokens(
        address tokenCollection,
        address to,
        uint256[] memory tokenIds,
        uint256[] memory amounts
    ) external onlyUnlocked onlyOwner {
        require(
            tokenIds.length == amounts.length,
            "ERC1155Handler: Invalid input length"
        );

        // Get the instance of the ERC1155 contract
        IERC1155 erc1155Contract = IERC1155(tokenCollection);

        for (uint256 i = 0; i < tokenIds.length; i++) {
            require(
                erc1155Contract.balanceOf(address(this), tokenIds[i]) >=
                    amounts[i],
                "ERC1155Handler: Insufficient balance"
            );
        }

        // Batch transfer the tokens to the specified address
        erc1155Contract.safeBatchTransferFrom(
            address(this),
            to,
            tokenIds,
            amounts,
            ""
        );

        // Emit the TokensTransferred event
        emit BatchErc1155TokensTransferred(
            address(this),
            to,
            tokenIds,
            amounts
        );
    }

    /**
     * @dev Executes a transaction from the Account. Must be called by an authorized executor.
     *
     * @param to      Destination address of the transaction
     * @param value   Ether value of the transaction
     * @param data    Encoded payload of the transaction
     */
    function executeTrustedCall(
        address to,
        uint256 value,
        bytes calldata data
    ) external payable onlyUnlocked returns (bytes memory result) {
        address _executor = executor[owner()];
        if (msg.sender != _executor) revert NotAuthorized();

        return _call(to, value, data);
    }

    // TODO - remove if not needed

    /**
     * @dev Executes a transaction from the Account. Must be called by a trusted cross-chain executor.
     * Can only be called if account is owned by a token on another chain.
     *
     * @param to      Destination address of the transaction
     * @param value   Ether value of the transaction
     * @param data    Encoded payload of the transaction
     */
    function executeCrossChainCall(
        address to,
        uint256 value,
        bytes calldata data
    ) external payable onlyUnlocked returns (bytes memory result) {
        (uint256 chainId, , ) = context();

        if (chainId == block.chainid) {
            revert NotAuthorized();
        }

        if (!crossChainExecutorList.isCrossChainExecutor(chainId, msg.sender)) {
            revert NotAuthorized();
        }

        return _call(to, value, data);
    }

    /**
     * @dev Sets executor address for Account, allowing owner to use a custom implementation if they choose to.
     * When the token controlling the account is transferred, the implementation address will reset
     *
     * @param _executionModule the address of the execution module
     */
    function setExecutor(address _executionModule) external onlyUnlocked {
        address _owner = owner();
        if (_owner != msg.sender) revert NotAuthorized();

        executor[_owner] = _executionModule;

        emit ExecutorUpdated(_owner, _executionModule);
    }

    // TODO : in review
    /**
     * @dev Locks Account, preventing transactions from being executed until a certain time
     * Note: Lock time should not be greater than 1 year here.
     *
     * @param _unlockTimestamp timestamp when the account will become unlocked
     */
    function lock(uint256 _unlockTimestamp) external onlyUnlocked {
        if (_unlockTimestamp > block.timestamp + 365 days)
            revert ExceedsMaxLockTime();

        address _owner = owner();
        if (_owner != msg.sender) revert NotAuthorized();

        unlockTimestamp = _unlockTimestamp;

        emit LockUpdated(_unlockTimestamp);
    }

    /**
     * @dev Returns Account lock status
     *
     * @return true if Account is locked, false otherwise
     */
    function isLocked() external view returns (bool) {
        return unlockTimestamp > block.timestamp;
    }

    /**
     * @dev Returns true if caller is authorized to execute actions on this account
     *
     * @param caller the address to query authorization for
     * @return true if caller is authorized, false otherwise
     */
    function isAuthorized(address caller) external view returns (bool) {
        (uint256 chainId, address tokenCollection, uint256 tokenId) = context();

        if (chainId != block.chainid) {
            return crossChainExecutorList.isCrossChainExecutor(chainId, caller);
        }

        address _owner = IERC721(tokenCollection).ownerOf(tokenId);
        if (caller == _owner) return true;

        address _executor = executor[_owner];
        if (caller == _executor) return true;

        return false;
    }

    // TODO : remove me if not needed

    /**
     * @dev Implements EIP-1271 signature validation
     *
     * @param hash      Hash of the signed data
     * @param signature Signature to validate
     */
    function isValidSignature(
        bytes32 hash,
        bytes memory signature
    ) external view returns (bytes4 magicValue) {
        // If account is locked, disable signing
        if (unlockTimestamp > block.timestamp) return "";

        // If account has an executor, check if executor signature is valid
        address _owner = owner();
        address _executor = executor[_owner];

        if (
            _executor != address(0) &&
            SignatureChecker.isValidSignatureNow(_executor, hash, signature)
        ) {
            return IERC1271.isValidSignature.selector;
        }

        // Default - check if signature is valid for account owner
        if (SignatureChecker.isValidSignatureNow(_owner, hash, signature)) {
            return IERC1271.isValidSignature.selector;
        }

        return "";
    }

    /**
     * @dev Implements EIP-165 standard interface detection
     *
     * @param interfaceId the interfaceId to check support for
     * @return true if the interface is supported, false otherwise
     */
    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(IERC165, ERC1155Receiver) returns (bool) {
        // default interface support
        if (
            interfaceId == type(IAccount).interfaceId ||
            interfaceId == type(IERC1155Receiver).interfaceId ||
            interfaceId == type(IERC165).interfaceId
        ) {
            return true;
        }

        address _executor = executor[owner()];

        if (_executor == address(0) || _executor.code.length == 0) {
            return false;
        }

        // if interface is not supported by default, check executor
        try IERC165(_executor).supportsInterface(interfaceId) returns (
            bool _supportsInterface
        ) {
            return _supportsInterface;
        } catch {
            return false;
        }
    }

    /**
     * @dev Returns the owner of the token that controls this Account (public for Ownable compatibility)
     *
     * @return the address of the Account owner
     */
    function owner() public view returns (address) {
        (uint256 chainId, address tokenCollection, uint256 tokenId) = context();

        if (chainId != block.chainid) {
            return address(0);
        }

        return IERC721(tokenCollection).ownerOf(tokenId);
    }

    /**
     * @dev Returns information about the token that owns this account
     *
     * @return tokenCollection the contract address of the  ERC721 token which owns this account
     * @return tokenId the tokenId of the  ERC721 token which owns this account
     */
    function token()
        public
        view
        returns (address tokenCollection, uint256 tokenId)
    {
        (, tokenCollection, tokenId) = context();
    }

    function context() internal view returns (uint256, address, uint256) {
        bytes memory rawContext = MinimalProxyStore.getContext(address(this));
        if (rawContext.length == 0) return (0, address(0), 0);

        return abi.decode(rawContext, (uint256, address, uint256));
    }

    /**
     * @dev Executes a low-level call
     */
    function _call(
        address to,
        uint256 value,
        bytes calldata data
    ) internal returns (bytes memory result) {
        bool success;
        (success, result) = to.call{value: value}(data);

        if (!success) {
            assembly {
                revert(add(result, 32), mload(result))
            }
        }
    }

    function setMinLockup(uint256 _time) public onlyRegistry {
        minLockup = _time;
    }

    function setRegistry(address _registry) public onlyOnce {
        registryContract = _registry;
    }

    function getCycleEndTime(uint256 _cycleNum) public view returns (uint256) {
        return
            IRegistryContract(registryContract).getCycleNumToCycleEndTime(
                _cycleNum
            );
    }

    function getUserStakedCycles() public view returns(uint256[] memory){
        uint256 currentCycle = IRegistryContract(registryContract).getCurrentCycle();
        uint256[] memory userStakedCycles = new uint256[](currentCycle);
        uint256 arrayCount;
        for(uint i=1 ; i <= currentCycle; i++){
            if(userstakedCycle[i]){
                userStakedCycles[arrayCount] = i;
                arrayCount++;
            }
        }
        return userStakedCycles;
    }

    function getTotalVgoldStakeForCycle(
        uint256 _cycleNum
    ) public view returns (uint256) {
        return totalVgoldStakeForCycle[_cycleNum];
    }

    //UB
    function stake(
        uint256 _amount,
        uint256 _cycleNum
    ) external onlyUnlocked onlyRegistry {
        userStakeInfo memory stakeInfo = userStakeInfo(
            _amount,
            block.timestamp,
            _cycleNum
        );
        userStake[_cycleNum].push(stakeInfo);
        totalVgoldStake += _amount;
        totalVgoldStakeForCycle[_cycleNum] += _amount;
        userstakedCycle[_cycleNum] = true;
    }

    //UB
    function postClaim(
        uint256 _timeStamp,
        uint256 _cycleNum
    ) external onlyRegistry onlyUnlocked {
        for (uint i = 0; i < userStake[_cycleNum].length; i++) {
            if (
                userStake[_cycleNum][i].stakeTime + minLockup <= block.timestamp
            ) {
                userStake[_cycleNum][i].stakeTime = _timeStamp;
            }
        }
    }

    //UB
    function calculateEligibleStake(
        uint256 _cycleNum
    ) public view returns (uint256) {
        uint256 eligibleStake;
        for (uint i = 0; i < userStake[_cycleNum].length; i++) {
            if (
                userStake[_cycleNum][i].stakeTime + minLockup <= block.timestamp
            ) {
                eligibleStake += userStake[_cycleNum][i].stakeAmount;
            }
        }
        return eligibleStake;
    }

    function calculateEligibleStakeArray(
        uint256[] memory _arrayIndexes,
        uint256 _cycleNum
    ) public view returns (uint256) {
        uint256 eligibleStake;
        for (uint i; i < _arrayIndexes.length; i++) {
            require(
                _arrayIndexes[i] <= userStake[_cycleNum].length,
                "ArrayIndex beyond array length"
            );
            if (
                userStake[_cycleNum][_arrayIndexes[i]].stakeTime + minLockup <=
                block.timestamp
            ) {
                eligibleStake += userStake[_cycleNum][_arrayIndexes[i]]
                    .stakeAmount;
            }
        }
        return eligibleStake;
    }

    function postUnstakeForArray(
        uint256[] memory _arrayIndexes,
        uint256 _cycleNum
    ) public onlyRegistry returns (uint256) {
        address VGOLDtoken = IRegistryContract(registryContract)
            .getVgoldToken();
        uint256 totalUnstake;
        for (uint i; i < _arrayIndexes.length; i++) {
            require(
                _arrayIndexes[i] <= userStake[_cycleNum].length,
                "ArrayIndex beyond array length"
            );
            IERC20(VGOLDtoken).transfer(
                owner(),
                userStake[_cycleNum][_arrayIndexes[i]].stakeAmount
            );
            totalUnstake += userStake[_cycleNum][_arrayIndexes[i]].stakeAmount;

            userStake[_cycleNum][_arrayIndexes[i]].stakeAmount = 0;
            userStake[_cycleNum][_arrayIndexes[i]].stakeTime = 0;
        }
        totalVgoldStake -= totalUnstake;
        totalVgoldStakeForCycle[_cycleNum] -= totalUnstake;
        return totalUnstake;
    }

    function postUnstakeForCycle(
        uint256 _cycleNum
    ) external onlyRegistry onlyUnlocked returns (bool) {
        address VGOLDtoken = IRegistryContract(registryContract)
            .getVgoldToken();
        IERC20(VGOLDtoken).transfer(
            owner(),
            totalVgoldStakeForCycle[_cycleNum]
        );
        for (uint i; i < userStake[_cycleNum].length; i++) {
            userStake[_cycleNum][i].stakeAmount = 0;
            userStake[_cycleNum][i].stakeTime = 0;
        }
        totalVgoldStake -= totalVgoldStakeForCycle[_cycleNum];
        totalVgoldStakeForCycle[_cycleNum] = 0;
        userstakedCycle[_cycleNum] = false;
        return true;
    }

    //UB
    /**
     * @dev deposit any ERC 20 token in the NFT wallet account
     * Note: this funciton will have unique ids for a particular NFT to execute
     */
    function depositToken(
        address tokenAddress,
        uint amount
    ) external onlyUnlocked onlyOwner {
        // Get the instance of the IERC20 contract
        IERC20 erc20Contract = IERC20(tokenAddress);
        // Check if amount > 0
        require(amount > 0, "Amount should be greater than 0");
        //Token transfer to the wallet account
        require(
            erc20Contract.transferFrom(msg.sender, address(this), amount),
            "Token deposit failed"
        );
        //Saving new deposit token addresses
        if (!isthisTokenDeposited[tokenAddress]) {
            userDepositedTokenAddresses.push(tokenAddress);
            isthisTokenDeposited[tokenAddress] = true;
        }
        emit ERC2OTokenTransferred(msg.sender, address(this), amount);
    }

    //UB
    /**
     * @dev function allows user to deposit NFT
     */
    function depositNFT(
        address tokenAddress,
        uint256 tokenId
    ) external onlyUnlocked onlyOwner {
        // Get the instance of the ERC721 contract
        IERC721 nftContract = IERC721(tokenAddress);
        // Check if the sender is the current owner of the NFT
        require(
            nftContract.ownerOf(tokenId) == msg.sender,
            "NFTHandler: Sender is not the owner"
        );
        // Transfer the NFT to the specified address
        nftContract.safeTransferFrom(msg.sender, address(this), tokenId);

        //Saving new deposit token addresses
        if (!isthisNFTDeposited[tokenAddress]) {
            userDepositedNFTAddresses.push(tokenAddress);
            isthisNFTDeposited[tokenAddress] = true;
        }
        NFTtokenIdDeposited[tokenAddress].push(tokenId);
        NFTtokenIdexist[tokenAddress][tokenId] = true;
        // Emit the NFTTransferred event
        emit NFTTransferred(msg.sender, address(this), tokenId);
    }

    //UB
    /**
     * @dev This function allow the wallet owner to withdraw the deposited token
     */
    function withdrawToken(
        address tokenAddress,
        uint amount
    ) external onlyUnlocked onlyOwner {
        // Get the instance of the IERC20 contract
        IERC20 erc20Contract = IERC20(tokenAddress);
        // Check if amount > 0
        require(amount > 0, "Amount should be greater than 0");
        // Check if contarct has enough balance
        require(
            erc20Contract.balanceOf(address(this)) >= amount,
            "not enough token balance for withdrawl"
        );
        require(
            erc20Contract.transfer(msg.sender, amount),
            "token withdrawl failed"
        );
        emit ERC2OTokenTransferred(address(this), msg.sender, amount);
    }

    //UB
    /**
     * @dev This function allow the wallet owner to withdraw the deposited NFT
     */
    function withdrawNFT(
        address tokenAddress,
        uint256 tokenId
    ) public onlyUnlocked onlyOwner {
        // Get the instance of the ERC721 contract
        IERC721 nftContract = IERC721(tokenAddress);

        // Check if the sender is the current owner of the NFT
        require(
            nftContract.ownerOf(tokenId) == address(this),
            "NFTHandler: Contract doesn't owns this NFT"
        );

        // Transfer the NFT to the specified address
        nftContract.safeTransferFrom(address(this), msg.sender, tokenId);

        NFTtokenIdexist[tokenAddress][tokenId] = false;

        // Emit the NFTTransferred event
        emit NFTTransferred(address(this), msg.sender, tokenId);
    }

    function getTokenIdsDepositedOfNFT(address _nftAddress) public view returns(uint256[] memory){
        uint256 length = NFTtokenIdDeposited[_nftAddress].length;
        uint256[] memory tokenIds = new uint256[](length);
        uint256 arrayCount;
        for(uint256 i; i < length; i++){
            uint256 tokenId = NFTtokenIdDeposited[_nftAddress][i];
            if(NFTtokenIdexist[_nftAddress][tokenId]){
                tokenIds[arrayCount] = tokenId;
                arrayCount++;
            }
        }
        return tokenIds;
    }

    //UB
    function getStakesForCyCle(
        uint _cycleNum
    )
        public
        view
        returns (
            userStakeInfoWithArrayIndex[] memory,
            userStakeInfoWithArrayIndex[] memory
        )
    {
        userStakeInfoWithArrayIndex[]
            memory eligibleStakes = new userStakeInfoWithArrayIndex[](
                userStake[_cycleNum].length
            );
        userStakeInfoWithArrayIndex[]
            memory nonEligibleStakes = new userStakeInfoWithArrayIndex[](
                userStake[_cycleNum].length
            );
        uint256 eligibleCount;
        uint256 nonEligibleCount;
        for (uint i = 0; i < userStake[_cycleNum].length; i++) {
            console.log(
                userStake[_cycleNum][i].stakeTime + minLockup > block.timestamp,
                "if condition"
            );
            if (
                userStake[_cycleNum][i].stakeAmount == 0 &&
                userStake[_cycleNum][i].stakeTime == 0
            ) {
                continue;
            } else if (
                userStake[_cycleNum][i].stakeTime + minLockup > block.timestamp
            ) {
                nonEligibleStakes[nonEligibleCount].stakeTime = userStake[
                    _cycleNum
                ][i].stakeTime;
                nonEligibleStakes[nonEligibleCount].stakeAmount = userStake[
                    _cycleNum
                ][i].stakeAmount;
                nonEligibleStakes[nonEligibleCount].arrayIndex = i;
                nonEligibleCount++;
            } else {
                eligibleStakes[eligibleCount].stakeTime = userStake[_cycleNum][
                    i
                ].stakeTime;
                eligibleStakes[eligibleCount].stakeAmount = userStake[
                    _cycleNum
                ][i].stakeAmount;
                eligibleStakes[eligibleCount].arrayIndex = i;
                eligibleCount++;
            }
        }
        return (eligibleStakes, nonEligibleStakes);
    }

    //UB
    /**
     * @dev This function allow the wallet owner to destroy the contract and get all the funds
     */
    function destroy() public onlyOwner {
        require(!isDestroyed, "The contract has already been destroyed");

        address payable payableOwner = payable(msg.sender);

        // Perform any cleanup or asset transfers here
        //Transfer ethers
        uint256 contractBalanceEther = address(this).balance;
        if (contractBalanceEther > 0) {
            payable(msg.sender).transfer(contractBalanceEther);
        }

        //Transfer other tokens
        for (uint i = 0; i < userDepositedTokenAddresses.length; i++) {
            address tokenAddress = userDepositedTokenAddresses[i];
            // Get the instance of the IERC20 contract
            IERC20 erc20Contract = IERC20(tokenAddress);
            uint256 contractBalanceToken = erc20Contract.balanceOf(
                address(this)
            );
            if (contractBalanceToken > 0) {
                erc20Contract.transfer(msg.sender, contractBalanceToken);
            }
        }

        //Transfer NFTs
        for (uint i = 0; i < userDepositedNFTAddresses.length; i++) {
            address NFTAddress = userDepositedNFTAddresses[i];
            for (uint j = 0; j < NFTtokenIdDeposited[NFTAddress].length; j++) {
                uint256 tokenId = NFTtokenIdDeposited[NFTAddress][j];
                if(NFTtokenIdexist[NFTAddress][j]){
                    withdrawNFT(NFTAddress, tokenId);
                }
            }
        }
        //Transfer rest of the funds
        selfdestruct(payableOwner);

        // Mark the contract as destroyed
        isDestroyed = true;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "../contracts/utils/Create2.sol";
import "./Bytecode.sol";

/**
 * @title A library for deploying EIP-1167 minimal proxy contracts with embedded constant data
 * @author Jayden Windle (jaydenwindle)
 */
library MinimalProxyStore {
    error CreateError();
    error ContextOverflow();

    /**
     * @dev Returns bytecode for a minmal proxy with additional context data appended to it
     *
     * @param implementation the implementation this proxy will delegate to
     * @param context the data to be appended to the proxy
     * @return the generated bytecode
     */
    function getBytecode(address implementation, bytes memory context)
        internal
        pure
        returns (bytes memory)
    {
        return
            abi.encodePacked(
                hex"3d61", // RETURNDATASIZE, PUSH2
                uint16(0x2d + context.length + 1), // size of minimal proxy (45 bytes) + size of context + stop byte
                hex"8060", // DUP1, PUSH1
                uint8(0x0a + 1), // default offset (0x0a) + 1 byte because we increased size from uint8 to uint16
                hex"3d3981f3363d3d373d3d3d363d73", // standard EIP1167 implementation
                implementation, // implementation address
                hex"5af43d82803e903d91602b57fd5bf3", // standard EIP1167 implementation
                hex"00", // stop byte (prevents context from executing as code)
                context // appended context data
            );
    }

    /**
     * @dev Fetches the context data stored in a deployed proxy
     *
     * @param instance the proxy to query context data for
     * @return the queried context data
     */
    function getContext(address instance) internal view returns (bytes memory) {
        uint256 instanceCodeLength = instance.code.length;

        return Bytecode.codeAt(instance, 46, instanceCodeLength);
    }

    /**
     * @dev Deploys and returns the address of a clone with stored context data that mimics the behaviour of `implementation`.
     *
     * This function uses the create opcode, which should never revert.
     *
     * @param implementation the implementation to delegate to
     * @param context context data to be stored in the proxy
     * @return instance the address of the deployed proxy
     */
    function clone(address implementation, bytes memory context)
        internal
        returns (address instance)
    {
        // Generate bytecode for proxy
        bytes memory code = getBytecode(implementation, context);

        // Deploy contract using create
        assembly {
            instance := create(0, add(code, 32), mload(code))
        }

        // If address is zero, deployment failed
        if (instance == address(0)) revert CreateError();
    }

    /**
     * @dev Deploys and returns the address of a clone with stored context data that mimics the behaviour of `implementation`.
     *
     * This function uses the create2 opcode and a `salt` to deterministically deploy
     * the clone. Using the same `implementation` and `salt` multiple time will revert, since
     * the clones cannot be deployed twice at the same address.
     *
     * @param implementation the implementation to delegate to
     * @param context context data to be stored in the proxy
     * @return instance the address of the deployed proxy
     */
    function cloneDeterministic(
        address implementation,
        bytes memory context,
        bytes32 salt
    ) internal returns (address instance) {
        bytes memory code = getBytecode(implementation, context);

        // Deploy contract using create2
        assembly {
            instance := create2(0, add(code, 32), mload(code), salt)
        }

        // If address is zero, deployment failed
        if (instance == address(0)) revert CreateError();
    }

    /**
     * @dev Computes the address of a clone deployed using {MinimalProxyStore-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes memory context,
        bytes32 salt,
        address deployer
    ) internal pure returns (address predicted) {
        bytes memory code = getBytecode(implementation, context);

        return Create2.computeAddress(salt, keccak256(code), deployer);
    }

    /**
     * @dev Computes the address of a clone deployed using {MinimalProxyStore-cloneDeterministic}.
     */
    function predictDeterministicAddress(
        address implementation,
        bytes memory context,
        bytes32 salt
    ) internal view returns (address predicted) {
        return
            predictDeterministicAddress(
                implementation,
                context,
                salt,
                address(this)
            );
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

interface IRegistry {
    event AccountCreated(
        address account,
        address indexed tokenContract,
        uint256 indexed tokenId
    );

    function createAccount(address tokenContract, uint256 tokenId)
        external
        returns (address);

    function account(address tokenContract, uint256 tokenId)
        external
        view
        returns (address);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;


library Bytecode {
  error InvalidCodeAtRange(uint256 _size, uint256 _start, uint256 _end);

  /**
    @notice Generate a creation code that results on a contract with `_code` as bytecode
    @param _code The returning value of the resulting `creationCode`
    @return creationCode (constructor) for new contract
  */
  function creationCodeFor(bytes memory _code) internal pure returns (bytes memory) {
    /*
      0x00    0x63         0x63XXXXXX  PUSH4 _code.length  size
      0x01    0x80         0x80        DUP1                size size
      0x02    0x60         0x600e      PUSH1 14            14 size size
      0x03    0x60         0x6000      PUSH1 00            0 14 size size
      0x04    0x39         0x39        CODECOPY            size
      0x05    0x60         0x6000      PUSH1 00            0 size
      0x06    0xf3         0xf3        RETURN
      <CODE>
    */

    return abi.encodePacked(
      hex"63",
      uint32(_code.length),
      hex"80_60_0E_60_00_39_60_00_F3",
      _code
    );
  }

  /**
    @notice Returns the size of the code on a given address
    @param _addr Address that may or may not contain code
    @return size of the code on the given `_addr`
  */
  function codeSize(address _addr) internal view returns (uint256 size) {
    assembly { size := extcodesize(_addr) }
  }

  /**
    @notice Returns the code of a given address
    @dev It will fail if `_end < _start`
    @param _addr Address that may or may not contain code
    @param _start number of bytes of code to skip on read
    @param _end index before which to end extraction
    @return oCode read from `_addr` deployed bytecode

    Forked from: https://gist.github.com/KardanovIR/fe98661df9338c842b4a30306d507fbd
  */
  function codeAt(address _addr, uint256 _start, uint256 _end) internal view returns (bytes memory oCode) {
    uint256 csize = codeSize(_addr);
    if (csize == 0) return bytes("");

    if (_start > csize) return bytes("");
    if (_end < _start) revert InvalidCodeAtRange(csize, _start, _end); 

    unchecked {
      uint256 reqSize = _end - _start;
      uint256 maxSize = csize - _start;

      uint256 size = maxSize < reqSize ? maxSize : reqSize;

      assembly {
        // allocate output byte array - this could also be done without assembly
        // by using o_code = new bytes(size)
        oCode := mload(0x40)
        // new "memory end" including padding
        mstore(0x40, add(oCode, and(add(add(size, 0x20), 0x1f), not(0x1f))))
        // store length in memory
        mstore(oCode, size)
        // actually retrieve the code, this needs assembly
        extcodecopy(_addr, add(oCode, 0x20), _start, size)
      }
    }
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Create2.sol)

pragma solidity ^0.8.0;

/**
 * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
 * `CREATE2` can be used to compute in advance the address where a smart
 * contract will be deployed, which allows for interesting new mechanisms known
 * as 'counterfactual interactions'.
 *
 * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
 * information.
 */
library Create2 {
    /**
     * @dev Deploys a contract using `CREATE2`. The address where the contract
     * will be deployed can be known in advance via {computeAddress}.
     *
     * The bytecode for a contract can be obtained from Solidity with
     * `type(contractName).creationCode`.
     *
     * Requirements:
     *
     * - `bytecode` must not be empty.
     * - `salt` must have not been used for `bytecode` already.
     * - the factory must have a balance of at least `amount`.
     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
     */
    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) {
        require(address(this).balance >= amount, "Create2: insufficient balance");
        require(bytecode.length != 0, "Create2: bytecode length is zero");
        /// @solidity memory-safe-assembly
        assembly {
            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
        }
        require(addr != address(0), "Create2: Failed on deploy");
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
     * `bytecodeHash` or `salt` will result in a new destination address.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
        return computeAddress(salt, bytecodeHash, address(this));
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40) // Get free memory pointer

            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |
            // |-------------------|---------------------------------------------------------------------------|
            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |
            // | salt              |                                      BBBBBBBBBBBBB...BB                   |
            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |
            // | 0xFF              |            FF                                                             |
            // |-------------------|---------------------------------------------------------------------------|
            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |
            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |

            mstore(add(ptr, 0x40), bytecodeHash)
            mstore(add(ptr, 0x20), salt)
            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes
            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff
            mstore8(start, 0xff)
            addr := keccak256(start, 85)
        }
    }
}

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

library console {
    address constant CONSOLE_ADDRESS =
        0x000000000000000000636F6e736F6c652e6c6f67;

    function _sendLogPayloadImplementation(bytes memory payload) internal view {
        address consoleAddress = CONSOLE_ADDRESS;
        /// @solidity memory-safe-assembly
        assembly {
            pop(
                staticcall(
                    gas(),
                    consoleAddress,
                    add(payload, 32),
                    mload(payload),
                    0,
                    0
                )
            )
        }
    }

    function _castToPure(
      function(bytes memory) internal view fnIn
    ) internal pure returns (function(bytes memory) pure fnOut) {
        assembly {
            fnOut := fnIn
        }
    }

    function _sendLogPayload(bytes memory payload) internal pure {
        _castToPure(_sendLogPayloadImplementation)(payload);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    function log(uint256 p0) internal pure {
        _sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
        _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 pure {
        _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 pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
    }

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

    function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
        _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 pure {
        _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 pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
    }

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

    function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
        _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 pure {
        _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 pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
    }

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

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

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

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

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

    function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
        _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 pure {
        _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 pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
        _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 pure {
        _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 pure {
        _sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
        _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 pure {
        _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 pure {
        _sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
        _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 pure {
        _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 pure {
        _sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

interface IAccount {
    function owner() external view returns (address);

    function token()
        external
        view
        returns (address tokenContract, uint256 tokenId);

    function executeCall(
        address to,
        uint256 value,
        bytes calldata data
    ) external payable returns (bytes memory);
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "./contracts/token/ERC721/utils/ERC721Holder.sol";
import "./contracts/token/ERC1155/utils/ERC1155Holder.sol";

contract MinimalReceiver is ERC721Holder, ERC1155Holder {
    /**
     * @dev Allows all Ether transfers
     */
    receive() external payable virtual {}
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "./contracts/access/Ownable2Step.sol";

contract CrossChainExecutorList is Ownable2Step {
    mapping(uint256 => mapping(address => bool)) public isCrossChainExecutor;

    /**
     * @dev Enables or disables a trusted cross-chain executor.
     *
     * @param chainId the chainid of the network the executor exists on
     * @param executor the address of the executor
     * @param enabled true if executor should be enabled, false otherwise
     */
    function setCrossChainExecutor(
        uint256 chainId,
        address executor,
        bool enabled
    ) external onlyOwner {
        isCrossChainExecutor[chainId][executor] = enabled;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/SignatureChecker.sol)

pragma solidity ^0.8.0;

import "./ECDSA.sol";
import "../../interfaces/IERC1271.sol";

/**
 * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
 * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
 * Argent and Gnosis Safe.
 *
 * _Available since v4.1._
 */
library SignatureChecker {
    /**
     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
     * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
        (address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(hash, signature);
        return
            (error == ECDSA.RecoverError.NoError && recovered == signer) ||
            isValidERC1271SignatureNow(signer, hash, signature);
    }

    /**
     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
     * against the signer smart contract using ERC1271.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidERC1271SignatureNow(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) internal view returns (bool) {
        (bool success, bytes memory result) = signer.staticcall(
            abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)
        );
        return (success &&
            result.length >= 32 &&
            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 *
 * _Available since v4.1._
 */
interface IERC1271 {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;

import "../Strings.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/utils/ERC1155Holder.sol)

pragma solidity ^0.8.0;

import "./ERC1155Receiver.sol";

/**
 * Simple implementation of `ERC1155Receiver` that will allow a contract to hold ERC1155 tokens.
 *
 * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be
 * stuck.
 *
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/utils/ERC721Holder.sol)

pragma solidity ^0.8.0;

import "../IERC721Receiver.sol";

/**
 * @dev Implementation of the {IERC721Receiver} interface.
 *
 * Accepts all token transfers.
 * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}.
 */
contract ERC721Holder is IERC721Receiver {
    /**
     * @dev See {IERC721Receiver-onERC721Received}.
     *
     * Always returns `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(address, address, uint256, bytes memory) public virtual override returns (bytes4) {
        return this.onERC721Received.selector;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)

pragma solidity ^0.8.0;

import "./Ownable.sol";

/**
 * @dev Contract module which provides 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} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2Step is Ownable {
    address private _pendingOwner;

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

    /**
     * @dev Returns the address of the pending owner.
     */
    function pendingOwner() public view virtual returns (address) {
        return _pendingOwner;
    }

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
        _transferOwnership(sender);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/utils/ERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../IERC1155Receiver.sol";
import "../../../utils/introspection/ERC165.sol";

/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_implementation","type":"address"},{"internalType":"address","name":"_GODLToken","type":"address"},{"internalType":"address","name":"_vgoldToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CreateError","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"tokenContract","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"AccountCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"AddressCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"NFTWalletAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"userRewards","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"eligibleStakes","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cycleNum","type":"uint256"}],"name":"RewardsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"NFTWalletAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"totalUnstake","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"userRewards","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"eligibleStakes","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cycleNum","type":"uint256"}],"name":"VGoldUnstaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"NFTWalletAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"stakeAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cycleNum","type":"uint256"}],"name":"VgoldStaked","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"GODLRewardsForCycle","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GODLToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"TVSforCycle","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenCollection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"account","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"tokenCollection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"account","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"accountInfo","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"walletAddress","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"_NFTWalletAccount","type":"address"},{"internalType":"uint256","name":"_cycleNum","type":"uint256"}],"name":"calculateRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"_NFTWalletAccount","type":"address"},{"internalType":"uint256","name":"_cycleNum","type":"uint256"}],"name":"claimVgold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenCollection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"createAccount","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"tokenCollection","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"createAccount","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cycleCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"cycleNumToCycleDetails","outputs":[{"internalType":"uint256","name":"startTime","type":"uint256"},{"internalType":"uint256","name":"endTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cyclePeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cycleNum","type":"uint256"},{"internalType":"uint256","name":"_rewardAmount","type":"uint256"}],"name":"fundGODL","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_cycles","type":"uint256[]"},{"internalType":"uint256[]","name":"_rewardAmounts","type":"uint256[]"}],"name":"fundGODLForMultipleCycles","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getCurrentCycle","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCycleCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cycleNum","type":"uint256"}],"name":"getCycleNumToCycleEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinimumLockuop","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getVgoldToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isNFTWalletAccount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minimumLockup","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"numOfWalletCreated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startTime","type":"uint256"},{"internalType":"uint256","name":"_freq","type":"uint256"}],"name":"setCycle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_vgold","type":"address"}],"name":"setVgoldToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_NFTWalletAccount","type":"address"},{"internalType":"uint256","name":"_stakeAmount","type":"uint256"}],"name":"stakeVgold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalVgoldStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_NFTWalletAccount","type":"address"},{"internalType":"uint256","name":"_cycleNum","type":"uint256"}],"name":"unstakeVgoldForCycle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_NFTWalletAccount","type":"address"},{"internalType":"uint256[]","name":"arrayIndexes","type":"uint256[]"},{"internalType":"uint256","name":"_cycleNum","type":"uint256"}],"name":"unstakeVgoldForStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vgoldToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawAllGODL","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"bool","name":"_ifETH","type":"bool"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawAnyTokenorETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cycleNum","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawGODLforCycle","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60c060405260b460a0819052600c553480156200001a575f80fd5b5060405162002d3438038062002d348339810160408190526200003d91620000ea565b62000048336200007f565b6001600160a01b03928316608052600a80549284166001600160a01b03199384161790556006805491909316911617905562000131565b5f80546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b80516001600160a01b0381168114620000e5575f80fd5b919050565b5f805f60608486031215620000fd575f80fd5b6200010884620000ce565b92506200011860208501620000ce565b91506200012860408501620000ce565b90509250925092565b60805160a051612bc56200016f5f395f818161039a01528181610440015261239301525f818161032d0152818161212c01526122610152612bc55ff3fe608060405234801561000f575f80fd5b506004361061021e575f3560e01c806393f416bf1161012a578063d69b3307116100b4578063eedff70b11610079578063eedff70b14610522578063f2fde38b14610535578063f558115a14610548578063f76e083b1461055b578063f89dcd181461056e575f80fd5b8063d69b3307146104b4578063d78c14cc146104c7578063dd8abeba146104da578063dda5752d146104ed578063de15e6291461050f575f80fd5b8063b329e9fa116100fa578063b329e9fa14610475578063baea89301461047d578063be26ed7f14610490578063beb8314c14610498578063ce932919146104ab575f80fd5b806393f416bf146103e157806393ffa89614610400578063965290621461043b578063ad0dfb7e14610462575f80fd5b80635c60da1b116101ab57806378c3a43f1161017b57806378c3a43f1461037d5780637c14667114610385578063864a7db7146103985780638a7ab80c146103be5780638da5cb5b146103d1575f80fd5b80635c60da1b146103285780635fbfb9cf1461034f5780636f27967414610362578063715018a614610375575f80fd5b80632ab24bef116101f15780632ab24bef146102a65780632de47ec1146102bb578063316fda0f146102ce57806342232592146102d757806343d6427814610309575f80fd5b80630d26f90c14610222578063192df6551461024c5780631be2211f1461025f5780631d61cabd1461028f575b5f80fd5b6006546001600160a01b03165b6040516001600160a01b0390911681526020015b60405180910390f35b61022f61025a3660046125f5565b61058d565b61027261026d3660046125f5565b6105a2565b604080519283526001600160a01b03909116602083015201610243565b61029860075481565b604051908152602001610243565b6102b96102b43660046126c3565b6105e3565b005b60065461022f906001600160a01b031681565b61029860095481565b6102f96102e5366004612718565b600b6020525f908152604090205460ff1681565b6040519015158152602001610243565b61029861031736600461273a565b60046020525f908152604090205481565b61022f7f000000000000000000000000000000000000000000000000000000000000000081565b61022f61035d3660046125f5565b6109fc565b6102b96103703660046125f5565b610a08565b6102b9610ec7565b600954610298565b6102b9610393366004612751565b610eda565b7f0000000000000000000000000000000000000000000000000000000000000000610298565b6102b96103cc366004612751565b611003565b5f546001600160a01b031661022f565b6102986103ef36600461273a565b60056020525f908152604090205481565b61042661040e36600461273a565b60036020525f90815260409020805460019091015482565b60408051928352602083019190915201610243565b6102987f000000000000000000000000000000000000000000000000000000000000000081565b6102b96104703660046125f5565b611101565b6102b961143a565b6102b961048b36600461277e565b6115df565b610298611711565b6102986104a63660046125f5565b611770565b610298600c5481565b6102b96104c23660046127bc565b61189a565b61022f6104d536600461281c565b611ad1565b61022f6104e836600461281c565b611ae5565b6102986104fb36600461273a565b5f9081526003602052604090206001015490565b600a5461022f906001600160a01b031681565b6102b9610530366004612718565b611af1565b6102b9610543366004612718565b611b1b565b6102b96105563660046125f5565b611b94565b6102b9610569366004612751565b611f91565b61029861057c366004612718565b60026020525f908152604090205481565b5f6105994684846120e2565b90505b92915050565b6001602052815f5260405f2081815481106105bb575f80fd5b5f918252602090912060029091020180546001909101549092506001600160a01b0316905082565b825f816001600160a01b0316638da5cb5b6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610621573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106459190612840565b9050336001600160a01b038216146106785760405162461bcd60e51b815260040161066f9061285b565b60405180910390fd5b6001600160a01b0385165f908152600b602052604090205460ff166106af5760405162461bcd60e51b815260040161066f9061289d565b6009548311156106d15760405162461bcd60e51b815260040161066f906128d4565b600880546001600160a01b0319166001600160a01b0387169081179091556040516319ae272760e01b81525f91906319ae27279061071590889088906004016128fb565b602060405180830381865afa158015610730573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906107549190612947565b90505f811580159061077257505f8581526005602052604090205415155b156107ac575f8581526005602090815260408083205460049092529091205461079b9084612972565b6107a59190612989565b90506107af565b505f5b80156108ee57600a546040516370a0823160e01b815230600482015282916001600160a01b0316906370a0823190602401602060405180830381865afa1580156107fb573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061081f9190612947565b101561083d5760405162461bcd60e51b815260040161066f906129a8565b600a5460405163a9059cbb60e01b8152336004820152602481018390526001600160a01b039091169063a9059cbb906044016020604051808303815f875af115801561088b573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906108af91906129ea565b6108cb5760405162461bcd60e51b815260040161066f90612a05565b5f85815260046020526040812080548392906108e8908490612a3c565b90915550505b600854604051632fc7d98360e01b81525f916001600160a01b031690632fc7d98390610920908a908a906004016128fb565b6020604051808303815f875af115801561093c573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906109609190612947565b90508060075f8282546109739190612a3c565b90915550505f8681526005602052604081208054839290610995908490612a3c565b9091555050604080516001600160a01b038a1681526020810183905290810183905260608101849052608081018790527f03aaca6b3d0b04ede36ee41393096dfb4c2de69d90cb0989c5e2f31596bc17029060a00160405180910390a15050505050505050565b5f61059946848461215d565b815f816001600160a01b0316638da5cb5b6040518163ffffffff1660e01b8152600401602060405180830381865afa158015610a46573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a6a9190612840565b9050336001600160a01b03821614610a945760405162461bcd60e51b815260040161066f9061285b565b6001600160a01b0384165f908152600b602052604090205460ff16610acb5760405162461bcd60e51b815260040161066f9061289d565b600954831115610aed5760405162461bcd60e51b815260040161066f906128d4565b600880546001600160a01b0319166001600160a01b03861690811790915560405163f219ae1d60e01b8152600481018590525f919063f219ae1d90602401602060405180830381865afa158015610b46573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610b6a9190612947565b90505f8115801590610b8857505f8581526005602052604090205415155b15610bc2575f85815260056020908152604080832054600490925290912054610bb19084612972565b610bbb9190612989565b9050610bc5565b505f5b8015610d0457600a546040516370a0823160e01b815230600482015282916001600160a01b0316906370a0823190602401602060405180830381865afa158015610c11573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610c359190612947565b1015610c535760405162461bcd60e51b815260040161066f906129a8565b600a5460405163a9059cbb60e01b8152336004820152602481018390526001600160a01b039091169063a9059cbb906044016020604051808303815f875af1158015610ca1573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610cc591906129ea565b610ce15760405162461bcd60e51b815260040161066f90612a05565b5f8581526004602052604081208054839290610cfe908490612a3c565b90915550505b60085460405163298f34f960e21b8152600481018790525f916001600160a01b03169063a63cd3e490602401602060405180830381865afa158015610d4b573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610d6f9190612947565b90508060055f8881526020019081526020015f205f828254610d919190612a3c565b925050819055508060075f828254610da99190612a3c565b909155505060085460405163f803cded60e01b8152600481018890526001600160a01b039091169063f803cded906024016020604051808303815f875af1158015610df6573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610e1a91906129ea565b610e665760405162461bcd60e51b815260206004820152601c60248201527f506f7374556e7374616b6520666f72206379636c65206661696c656400000000604482015260640161066f565b604080516001600160a01b03891681526020810183905290810183905260608101849052608081018790527f03aaca6b3d0b04ede36ee41393096dfb4c2de69d90cb0989c5e2f31596bc17029060a00160405180910390a150505050505050565b610ecf612448565b610ed85f6124a1565b565b610ee2612448565b5f8111610f015760405162461bcd60e51b815260040161066f90612a4f565b600954821115610f235760405162461bcd60e51b815260040161066f906128d4565b600a546040516323b872dd60e01b8152336004820152306024820152604481018390526001600160a01b03909116906323b872dd906064016020604051808303815f875af1158015610f77573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610f9b91906129ea565b610fdd5760405162461bcd60e51b815260206004820152601360248201527211d3d11308151c985b9cd9995c91985a5b1959606a1b604482015260640161066f565b5f8281526004602052604081208054839290610ffa908490612a91565b90915550505050565b61100b612448565b5f811161102a5760405162461bcd60e51b815260040161066f90612a4f565b600a5460405163a9059cbb60e01b8152336004820152602481018390526001600160a01b039091169063a9059cbb906044016020604051808303815f875af1158015611078573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061109c91906129ea565b6110e45760405162461bcd60e51b815260206004820152601960248201527811d3d11308151bdad95b881d1c985b9cd9995c91985a5b1959603a1b604482015260640161066f565b5f8281526004602052604081208054839290610ffa908490612a3c565b815f816001600160a01b0316638da5cb5b6040518163ffffffff1660e01b8152600401602060405180830381865afa15801561113f573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906111639190612840565b9050336001600160a01b0382161461118d5760405162461bcd60e51b815260040161066f9061285b565b5f611196611711565b6001600160a01b0386165f908152600b602052604090205490915060ff166111d05760405162461bcd60e51b815260040161066f9061289d565b805f0361120f5760405162461bcd60e51b815260206004820152600d60248201526c10de58db19481b9bdd081cd95d609a1b604482015260640161066f565b6009548111156112315760405162461bcd60e51b815260040161066f906128d4565b5f84116112805760405162461bcd60e51b815260206004820152601f60248201527f416d6f756e742073686f756c642062652067726561746572207468616e203000604482015260640161066f565b6006546040516323b872dd60e01b81523360048201526001600160a01b03878116602483015260448201879052909116906323b872dd906064016020604051808303815f875af11580156112d6573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906112fa91906129ea565b61133e5760405162461bcd60e51b8152602060048201526015602482015274151bdad95b88151c985b9cd9995c8811985a5b1959605a1b604482015260640161066f565b600880546001600160a01b0319166001600160a01b0387169081179091556040516307b0472f60e41b81526004810186905260248101839052637b0472f0906044015f604051808303815f87803b158015611397575f80fd5b505af11580156113a9573d5f803e3d5ffd5b5050505f82815260056020526040812080548793509091906113cc908490612a91565b925050819055508360075f8282546113e49190612a91565b9091555050604080516001600160a01b0387168152602081018690529081018290527f4a220ff2866895e05d22d438b9b272f9a192fee196619196c0698aeaba73fac29060600160405180910390a15050505050565b611442612448565b600a546040516370a0823160e01b81523060048201525f916001600160a01b0316906370a0823190602401602060405180830381865afa158015611488573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906114ac9190612947565b90505f81116114f55760405162461bcd60e51b815260206004820152601560248201527416995c9bc811d3d113081a5b8818dbdb9d1c9858dd605a1b604482015260640161066f565b600a5460405163a9059cbb60e01b8152336004820152602481018390526001600160a01b039091169063a9059cbb906044016020604051808303815f875af1158015611543573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061156791906129ea565b6115af5760405162461bcd60e51b815260206004820152601960248201527811d3d11308151bdad95b881d1c985b9cd9995c91985a5b1959603a1b604482015260640161066f565b60015b60095481116115db575f81815260046020526040812055806115d381612aa4565b9150506115b2565b5050565b6115e7612448565b816116c2575f811161160b5760405162461bcd60e51b815260040161066f90612a4f565b60405163a9059cbb60e01b8152336004820152602481018290526001600160a01b0384169063a9059cbb906044016020604051808303815f875af1158015611655573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061167991906129ea565b6116bd5760405162461bcd60e51b8152602060048201526015602482015274151bdad95b881d1c985b9cd9995c8819985a5b1959605a1b604482015260640161066f565b505050565b5f81116116e15760405162461bcd60e51b815260040161066f90612a4f565b604051339082156108fc029083905f818181858888f1935050505015801561170b573d5f803e3d5ffd5b50505050565b5f8060015b600954811161176a575f81815260036020526040902054421080159061174b57505f8181526003602052604090206001015442105b156117585780915061176a565b8061176281612aa4565b915050611716565b50919050565b6001600160a01b0382165f908152600b6020526040812054819060ff166117a95760405162461bcd60e51b815260040161066f9061289d565b6009548311156117cb5760405162461bcd60e51b815260040161066f906128d4565b60405163f219ae1d60e01b81526004810184905284905f906001600160a01b0383169063f219ae1d90602401602060405180830381865afa158015611812573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906118369190612947565b9050801580159061185257505f85815260056020526040902054155b1561185f575f9250611890565b5f858152600560209081526040808320546004909252909120546118839083612972565b61188d9190612989565b92505b5090949350505050565b6118a2612448565b80518251146119055760405162461bcd60e51b815260206004820152602960248201527f4379636c657320616e642072657761726420636f756e747320617265206e6f74604482015268206d61746368696e6760b81b606482015260840161066f565b5f5b82518110156116bd575f82828151811061192357611923612abc565b6020026020010151116119485760405162461bcd60e51b815260040161066f90612a4f565b60095483828151811061195d5761195d612abc565b602002602001015111156119835760405162461bcd60e51b815260040161066f906128d4565b600a5482516001600160a01b03909116906323b872dd90339030908690869081106119b0576119b0612abc565b60209081029190910101516040516001600160e01b031960e086901b1681526001600160a01b03938416600482015292909116602483015260448201526064016020604051808303815f875af1158015611a0c573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611a3091906129ea565b611a725760405162461bcd60e51b815260206004820152601360248201527211d3d11308151c985b9cd9995c91985a5b1959606a1b604482015260640161066f565b818181518110611a8457611a84612abc565b602002602001015160045f858481518110611aa157611aa1612abc565b602002602001015181526020019081526020015f205f828254611ac49190612a91565b9091555050600101611907565b5f611add84848461215d565b949350505050565b5f611add8484846120e2565b611af9612448565b600680546001600160a01b0319166001600160a01b0392909216919091179055565b611b23612448565b6001600160a01b038116611b885760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161066f565b611b91816124a1565b50565b815f816001600160a01b0316638da5cb5b6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611bd2573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611bf69190612840565b9050336001600160a01b03821614611c205760405162461bcd60e51b815260040161066f9061285b565b6001600160a01b0384165f908152600b602052604081205460ff16611c575760405162461bcd60e51b815260040161066f9061289d565b600954841115611c795760405162461bcd60e51b815260040161066f906128d4565b600880546001600160a01b0319166001600160a01b03871690811790915560405163f219ae1d60e01b8152600481018690525f919063f219ae1d90602401602060405180830381865afa158015611cd2573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611cf69190612947565b90508015801590611d1257505f85815260056020526040902054155b15611d1f575f9150611d50565b5f85815260056020908152604080832054600490925290912054611d439083612972565b611d4d9190612989565b91505b5f8211611d9f5760405162461bcd60e51b815260206004820152601d60248201527f556e61626c6520746f20636c61696d3a205a65726f2052657761726473000000604482015260640161066f565b600a546040516370a0823160e01b815230600482015283916001600160a01b0316906370a0823190602401602060405180830381865afa158015611de5573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611e099190612947565b1015611e275760405162461bcd60e51b815260040161066f906129a8565b600a5460405163a9059cbb60e01b8152336004820152602481018490526001600160a01b039091169063a9059cbb906044016020604051808303815f875af1158015611e75573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611e9991906129ea565b611eb55760405162461bcd60e51b815260040161066f90612a05565b6008546040516339f76f9760e01b8152426004820152602481018790526001600160a01b03909116906339f76f97906044015f604051808303815f87803b158015611efe575f80fd5b505af1158015611f10573d5f803e3d5ffd5b5050505f8681526004602052604081208054859350909190611f33908490612a3c565b9091555050604080516001600160a01b038816815260208101849052908101829052606081018690527f56253d287efacdb2c4cd76dd03624a4821c1ce721d1152e8f5f5718f6087c9bf9060800160405180910390a1505050505050565b611f99612448565b42821015611fe95760405162461bcd60e51b815260206004820152601d60248201527f596f752063616e2774206372656174206379636c6520696e2070617374000000604482015260640161066f565b60015b8181116116bd57806001036120555760098054905f61200a83612aa4565b91905055506040518060400160405280848152602001600c548561202e9190612a91565b90526009545f908152600360209081526040909120825181559101516001909101556120d0565b60098054905f61206483612aa4565b919050555060035f600160095461207b9190612a3c565b81526020019081526020015f206001015492506040518060400160405280848152602001600c54856120ad9190612a91565b90526009545f908152600360209081526040909120825181559101516001909101555b806120da81612aa4565b915050611fec565b60408051602081018590526001600160a01b03841691810191909152606081018290525f90819060800160408051601f19818403018152919052805160208201209091505f6121527f000000000000000000000000000000000000000000000000000000000000000084846124f0565b979650505050505050565b6040516331a9108f60e11b8152600481018290525f9033906001600160a01b03851690636352211e90602401602060405180830381865afa1580156121a4573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906121c89190612840565b6001600160a01b03161461221e5760405162461bcd60e51b815260206004820152601c60248201527f596f7520617265206e6f7420746865206f776e6572206f66204e465400000000604482015260640161066f565b6040805160208082018790526001600160a01b0386168284015260608083018690528351808403909101815260809092019092528051918101919091205f6122877f000000000000000000000000000000000000000000000000000000000000000084846124fd565b6040805180820182528781526001600160a01b038381166020808401918252335f8181526001808452878220805480830182559083528483208851600292830290910190815595519590910180546001600160a01b0319169590961694909417909455835252918220805493945090929161230183612aa4565b90915550506001600160a01b0382165f818152600b602052604090819020805460ff19166001179055600880546001600160a01b0319168317905551632a47b83760e21b815230600482015263a91ee0dc906024015f604051808303815f87803b15801561236d575f80fd5b505af115801561237f573d5f803e3d5ffd5b5050600854604051637d0892e960e11b81527f000000000000000000000000000000000000000000000000000000000000000060048201526001600160a01b03909116925063fa1125d291506024015f604051808303815f87803b1580156123e5575f80fd5b505af11580156123f7573d5f803e3d5ffd5b50506040516001600160a01b0385811682528993508a1691507f33310a89c32d8cc00057ad6ef6274d2f8fe22389a992cf89983e09fc84f6cfff9060200160405180910390a3509695505050505050565b5f546001600160a01b03163314610ed85760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161066f565b5f80546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b5f611add84848430612545565b5f80612509858561256f565b9050828151602083015ff591506001600160a01b03821661253d57604051630985da9b60e41b815260040160405180910390fd5b509392505050565b5f80612551868661256f565b9050612565848280519060200120856125b8565b9695505050505050565b60608151602d61257f9190612a91565b61258a906001612a91565b600b84846040516020016125a19493929190612ad0565b604051602081830303815290604052905092915050565b5f604051836040820152846020820152828152600b8101905060ff815360559020949350505050565b6001600160a01b0381168114611b91575f80fd5b5f8060408385031215612606575f80fd5b8235612611816125e1565b946020939093013593505050565b634e487b7160e01b5f52604160045260245ffd5b5f82601f830112612642575f80fd5b8135602067ffffffffffffffff8083111561265f5761265f61261f565b8260051b604051601f19603f830116810181811084821117156126845761268461261f565b60405293845260208187018101949081019250878511156126a3575f80fd5b6020870191505b84821015612152578135835291830191908301906126aa565b5f805f606084860312156126d5575f80fd5b83356126e0816125e1565b9250602084013567ffffffffffffffff8111156126fb575f80fd5b61270786828701612633565b925050604084013590509250925092565b5f60208284031215612728575f80fd5b8135612733816125e1565b9392505050565b5f6020828403121561274a575f80fd5b5035919050565b5f8060408385031215612762575f80fd5b50508035926020909101359150565b8015158114611b91575f80fd5b5f805f60608486031215612790575f80fd5b833561279b816125e1565b925060208401356127ab81612771565b929592945050506040919091013590565b5f80604083850312156127cd575f80fd5b823567ffffffffffffffff808211156127e4575f80fd5b6127f086838701612633565b93506020850135915080821115612805575f80fd5b5061281285828601612633565b9150509250929050565b5f805f6060848603121561282e575f80fd5b8335925060208401356127ab816125e1565b5f60208284031215612850575f80fd5b8151612733816125e1565b60208082526022908201527f43616e206f6e6c792062652063616c6c65642062792077616c6c6574206f776e60408201526132b960f11b606082015260800190565b6020808252601a908201527f496e76616c6964204e46542077616c6c65742061636f6f756e74000000000000604082015260600190565b6020808252600d908201526c496e76616c6964206379636c6560981b604082015260600190565b604080825283519082018190525f906020906060840190828701845b8281101561293357815184529284019290840190600101612917565b505050602093909301939093525092915050565b5f60208284031215612957575f80fd5b5051919050565b634e487b7160e01b5f52601160045260245ffd5b808202811582820484141761059c5761059c61295e565b5f826129a357634e487b7160e01b5f52601260045260245ffd5b500490565b60208082526022908201527f4e6f7420656e6f756768207265776172647320696e2074686520636f6e74726160408201526118dd60f21b606082015260800190565b5f602082840312156129fa575f80fd5b815161273381612771565b6020808252601b908201527f474f444c20526577617264205472616e73666572204661696c65640000000000604082015260600190565b8181038181111561059c5761059c61295e565b60208082526022908201527f416d6f756e742073686f756c642062652067726561746572207468616e207a65604082015261726f60f01b606082015260800190565b8082018082111561059c5761059c61295e565b5f60018201612ab557612ab561295e565b5060010190565b634e487b7160e01b5f52603260045260245ffd5b613d6160f01b815260f085901b6001600160f01b031916600282015261040360f51b600482015260f884901b6001600160f81b03191660068201526d3d3981f3363d3d373d3d3d363d7360901b6007820152606083901b6bffffffffffffffffffffffff191660158201526e5af43d82803e903d91602b57fd5bf360881b60298201525f603882018190528251815b81811015612b7c5760208186018101516039868401015201612b5f565b505f92016039019182525094935050505056fea2646970667358221220799f9c4f9ceca036e52a5af6e6a29201dfbb2ffb9d61cdcaa58954647a5da46c64736f6c63430008170033000000000000000000000000b1c9c767dbd0ad091abc727aab5c2fd79f10169200000000000000000000000039d3db3591e31f12aa395e935fc46b152242e1370000000000000000000000006f8435d278d57cb9d73dd3092bb999e920d49f9e

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

000000000000000000000000b1c9c767dbd0ad091abc727aab5c2fd79f10169200000000000000000000000039d3db3591e31f12aa395e935fc46b152242e1370000000000000000000000006f8435d278d57cb9d73dd3092bb999e920d49f9e

-----Decoded View---------------
Arg [0] : _implementation (address): 0xb1C9c767Dbd0aD091AbC727aaB5C2Fd79F101692
Arg [1] : _GODLToken (address): 0x39D3dB3591E31f12AA395e935fC46b152242e137
Arg [2] : _vgoldToken (address): 0x6F8435d278D57cB9D73Dd3092BB999e920d49F9e

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000b1c9c767dbd0ad091abc727aab5c2fd79f101692
Arg [1] : 00000000000000000000000039d3db3591e31f12aa395e935fc46b152242e137
Arg [2] : 0000000000000000000000006f8435d278d57cb9d73dd3092bb999e920d49f9e