0x8a5832d7cebbe5c25f7919c7d8e0cd101d9ea57f

DECOMPILED SOLIDITY (Heimdall) VERIFY

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

/// @title            Decompiled Contract
/// @author           Jonathan Becker <jonathan@jbecker.dev>
/// @custom:version   heimdall-rs v0.9.2
///
/// @notice           This contract was decompiled using the heimdall-rs decompiler.
///                     It was generated directly by tracing the EVM opcodes from this contract.
///                     As a result, it may not compile or even be valid solidity code.
///                     Despite this, it should be obvious what each function does. Overall
///                     logic should have been preserved throughout decompiling.
///
/// @custom:github    You can find the open-source decompiler here:
///                       https://heimdall.rs

contract DecompiledContract {
    uint256 public constant stake = 927207093430488017675169061713288062032531070626;
    
    mapping(bytes32 => bytes32) storage_map_f;
    mapping(bytes32 => bytes32) storage_map_d;
    mapping(bytes32 => bytes32) storage_map_g;
    mapping(bytes32 => bytes32) storage_map_s;
    bytes32 store_q;
    mapping(bytes32 => bytes32) storage_map_r;
    mapping(bytes32 => bytes32) storage_map_j;
    uint256 public totalSupply;
    mapping(bytes32 => bytes32) storage_map_k;
    uint256 public rewardsListLength;
    mapping(bytes32 => bytes32) storage_map_b;
    mapping(bytes32 => bytes32) storage_map_i;
    mapping(bytes32 => bytes32) storage_map_m;
    mapping(bytes32 => bytes32) storage_map_p;
    bytes32 store_h;
    mapping(bytes32 => bytes32) storage_map_e;
    mapping(bytes32 => bytes32) storage_map_l;
    mapping(bytes32 => bytes32) storage_map_n;
    bytes32 store_o;
    
    event RewardWhitelisted(address, bool);
    error ReentrancyGuardReentrantCall();
    
    /// @custom:selector    0x48e5d9f8
    /// @custom:signature   rewardData(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function rewardData(address arg0) public pure {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        require(((var_a + 0x80) > 0xffffffffffffffff) | ((var_a + 0x80) < var_a));
    }
    
    /// @custom:selector    0x36925259
    /// @custom:signature   storedRewardsPerUser(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function storedRewardsPerUser(address arg0, address arg1) public view returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        var_a = address(arg1);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0x853828b6
    /// @custom:signature   withdrawAll() public payable
    function withdrawAll() public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
        if (!0 < rewardsListLength) {
            require(!(0 < rewardsListLength), CustomError_3ee5aeb5());
            require(!(0 < rewardsListLength), CustomError_3ee5aeb5());
            require(!totalSupply, CustomError_3ee5aeb5());
            var_a = address(storage_map_d[var_a] >> 0);
            require((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) > ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])), CustomError_3ee5aeb5());
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a])) == storage_map_b[var_a] | (!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])) - (storage_map_f[var_a]))), CustomError_3ee5aeb5());
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(storage_map_g[var_a] > (storage_map_g[var_a] + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply)), CustomError_3ee5aeb5());
            var_a = address(storage_map_d[var_a] >> 0);
            storage_map_g[var_a] = (storage_map_g[var_a]) + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply);
            require(!(0 < rewardsListLength), CustomError_3ee5aeb5());
            require(!(0 < rewardsListLength), CustomError_3ee5aeb5());
            var_a = address(storage_map_d[var_a] >> 0);
            storage_map_f[var_a] = ((block.timestamp ^ (storage_map_e[var_a])) * (block.timestamp < (storage_map_e[var_a]))) ^ (storage_map_e[var_a]);
            require(!(0 < rewardsListLength), CustomError_3ee5aeb5());
        }
        require(store_h == 0x02, CustomError_3ee5aeb5());
        var_a = 0x3ee5aeb500000000000000000000000000000000000000000000000000000000;
        store_h = 0x02;
        require(!storage_map_b[var_a], CustomError_f6fa5450());
    }
    
    /// @custom:selector    0x4d5ce038
    /// @custom:signature   isReward(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function isReward(address arg0) public view returns (bool) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return !(!bytes1(storage_map_b[var_a]));
    }
    
    /// @custom:selector    0xf1229777
    /// @custom:signature   rewardPerToken(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function rewardPerToken(address arg0) public view returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        require(!totalSupply);
        address var_a = address(arg0);
        require((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) > ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])));
        var_a = address(arg0);
        require(!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a])) == storage_map_b[var_a]) | (!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])) - (storage_map_f[var_a])));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(storage_map_g[var_a] > (storage_map_g[var_a] + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply)));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        return (storage_map_g[var_a]) + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply);
        var_a = address(arg0);
        return storage_map_i[var_a];
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   balanceOf(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function balanceOf(address arg0) public view returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0x3af32abf
    /// @custom:signature   isWhitelisted(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function isWhitelisted(address arg0) public view returns (bool) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0xb6b55f25
    /// @custom:signature   deposit(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function deposit(uint256 arg0) public payable {
        require(msg.value);
        if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20) {
            require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20, CustomError_c69cbf86());
            require(!(0 < rewardsListLength), CustomError_c69cbf86());
            require(!(0 < rewardsListLength), CustomError_c69cbf86());
            require(!totalSupply, CustomError_c69cbf86());
            var_a = address(storage_map_d[var_a] >> 0);
            require((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) > ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])), CustomError_c69cbf86());
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a])) == storage_map_b[var_a] | (!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])) - (storage_map_f[var_a]))), CustomError_c69cbf86());
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(storage_map_g[var_a] > (storage_map_g[var_a] + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply)), CustomError_c69cbf86());
            var_a = address(storage_map_d[var_a] >> 0);
            storage_map_g[var_a] = (storage_map_g[var_a]) + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply);
            require(!(0 < rewardsListLength), CustomError_c69cbf86());
            require(!(0 < rewardsListLength), CustomError_c69cbf86());
            var_a = address(storage_map_d[var_a] >> 0);
            storage_map_f[var_a] = ((block.timestamp ^ (storage_map_e[var_a])) * (block.timestamp < (storage_map_e[var_a]))) ^ (storage_map_e[var_a]);
            require(!(0 < rewardsListLength), CustomError_c69cbf86());
        }
        require(store_h == 0x02, CustomError_c69cbf86());
        store_h = 0x02;
        require(!arg0, CustomError_c69cbf86());
        require(!address(0xa269676eecbb09decad8f38ab8f1bfdcf4ee9ea2).code.length, CustomError_c69cbf86());
        address var_e = address(msg.sender);
        var_h = 0x64;
        require(((var_i + 0xa0) > 0xffffffffffffffff) | ((var_i + 0xa0) < var_i));
        (bool success, bytes memory ret0) = address(0xa269676eecbb09decad8f38ab8f1bfdcf4ee9ea2).{ value: 0 ether }Unresolved_23b872dd(var_e); // call
        require(!ret0.length);
        require(var_j);
        require((((0x60 + var_j) + 0x20) - 0x80) < 0x20);
        require(var_h - var_h);
        require(ret0.length > 0xffffffffffffffff, CustomError_f6fa5450());
    }
    
    /// @custom:selector    0x8003b614
    /// @custom:signature   rewardsList() public view returns (bytes memory)
    function rewardsList() public view returns (bytes memory) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
        if (0 < rewardsListLength) {
            if (((var_c + (uint248(((var_c + 0x20) - var_c) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248(((var_c + 0x20) - var_c) + 0x1f))) < var_c)) {
                uint248 var_c = var_c + (uint248(((var_c + 0x20) - var_c) + 0x1f));
                return abi.encodePacked(0x20, var_c.length);
            }
        }
    }
    
    /// @custom:selector    0x211dc32d
    /// @custom:signature   earned(address arg0, address arg1) public view
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function earned(address arg0, address arg1) public view {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        require(!totalSupply);
        var_a = address(arg0);
        require((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) > ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])));
        var_a = address(arg0);
        require(!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a])) == storage_map_b[var_a]) | (!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])) - (storage_map_f[var_a])));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(storage_map_g[var_a] > (storage_map_g[var_a] + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply)));
    }
    
    /// @custom:selector    0x31279d3d
    /// @custom:signature   getReward(address arg0, address[] arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function getReward(address arg0, address[] arg1) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(arg0 - (address(arg0)));
        require(arg1 > 0xffffffffffffffff);
        require(!(arg1 + 0x23) < msg.data.length);
        require(arg1 > 0xffffffffffffffff);
        require((((arg1 << 0x05) + arg1) + 0x24) > msg.data.length, CustomError_3d83866f());
        require(!(0 < rewardsListLength), CustomError_3d83866f());
        require(!(0 < rewardsListLength), CustomError_3d83866f());
        require(!totalSupply, CustomError_3d83866f());
        address var_a = address(storage_map_d[var_a] >> 0);
        require((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) > ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])), CustomError_3d83866f());
        var_a = address(storage_map_d[var_a] >> 0);
        require(!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a])) == storage_map_b[var_a] | (!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])) - (storage_map_f[var_a]))), CustomError_3d83866f());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(storage_map_g[var_a] > (storage_map_g[var_a] + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply)), CustomError_3d83866f());
        require(!(0 < rewardsListLength), CustomError_3d83866f());
        var_a = address(storage_map_d[var_a] >> 0);
        storage_map_g[var_a] = (storage_map_g[var_a]) + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply);
        require(!(0 < rewardsListLength), CustomError_3d83866f());
        require(!(0 < rewardsListLength), CustomError_3d83866f());
        var_a = address(storage_map_d[var_a] >> 0);
        storage_map_f[var_a] = ((block.timestamp ^ (storage_map_e[var_a])) * (block.timestamp < (storage_map_e[var_a]))) ^ (storage_map_e[var_a]);
        require(!(!address(arg0)), CustomError_3d83866f());
        require(!(0 < rewardsListLength), CustomError_3d83866f());
        require(!totalSupply, CustomError_3d83866f());
        var_a = address(storage_map_d[var_a] >> 0);
        require((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) > ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])), CustomError_3d83866f());
        var_a = address(storage_map_d[var_a] >> 0);
        require(!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a])) == storage_map_b[var_a] | (!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])) - (storage_map_f[var_a]))), CustomError_3d83866f());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(storage_map_g[var_a] > (storage_map_g[var_a] + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply)), CustomError_3d83866f());
        require(store_h == 0x02, CustomError_3d83866f());
        store_h = 0x02;
        require(msg.sender - (address(arg0)), CustomError_3d83866f());
        require(0 < (arg1));
        require(!0 < (arg1));
        require(msg.data[0 + (arg1 + 0x24)] - (address(msg.data[0 + (arg1 + 0x24)])));
        var_a = address(msg.data[0 + (arg1 + 0x24)]);
        require(storage_map_b[var_a]);
        require(!0 < (arg1));
        require(msg.data[0 + (arg1 + 0x24)] - (address(msg.data[0 + (arg1 + 0x24)])));
        var_a = address(msg.data[0 + (arg1 + 0x24)]);
        storage_map_b[var_a] = 0;
        require(!0 < (arg1));
        require(msg.data[0 + (arg1 + 0x24)] - (address(msg.data[0 + (arg1 + 0x24)])));
        require(!(address(msg.data[0 + (arg1 + 0x24)]).code.length), CustomError_c69cbf86());
        var_a = 0xc69cbf8600000000000000000000000000000000000000000000000000000000;
        address var_e = address(arg0);
        var_g = 0x44;
        require(((var_h + 0x80) > 0xffffffffffffffff) | ((var_h + 0x80) < var_h));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        (bool success, bytes memory ret0) = address(msg.data[0 + (arg1 + 0x24)]).{ value: storage_map_b[var_a] ether }Unresolved_a9059cbb(var_e); // call
        require(!ret0.length);
        require(var_i);
        require((((0x60 + var_i) + 0x20) - 0x80) < 0x20);
        require(var_g - var_g);
        require(ret0.length > 0xffffffffffffffff, CustomError_3ee5aeb5());
        store_h = 0x01;
    }
    
    /// @custom:selector    0x2f211012
    /// @custom:signature   notifyRewardAmount(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function notifyRewardAmount(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x80);
        require(arg0 - (address(arg0)));
        require(!(0 < rewardsListLength), CustomError_c6034fed());
        require(!(0 < rewardsListLength), CustomError_c6034fed());
        require(!totalSupply, CustomError_c6034fed());
        address var_a = address(storage_map_d[var_a] >> 0);
        require((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) > ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])), CustomError_c6034fed());
        var_a = address(storage_map_d[var_a] >> 0);
        require(!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a])) == storage_map_b[var_a] | (!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])) - (storage_map_f[var_a]))), CustomError_c6034fed());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(storage_map_g[var_a] > (storage_map_g[var_a] + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply)), CustomError_c6034fed());
        require(!(0 < rewardsListLength), CustomError_c6034fed());
        var_a = address(storage_map_d[var_a] >> 0);
        storage_map_g[var_a] = (storage_map_g[var_a]) + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply);
        require(!(0 < rewardsListLength), CustomError_c6034fed());
        require(!(0 < rewardsListLength), CustomError_c6034fed());
        require(!(0 < rewardsListLength), CustomError_c6034fed());
        require(store_h == 0x02, CustomError_c6034fed());
        store_h = 0x02;
        require(address(arg0) == 0xa269676eecbb09decad8f38ab8f1bfdcf4ee9ea2, CustomError_c6034fed());
        require(!arg1, CustomError_bffbc6be());
        var_a = address(arg0);
        require(!storage_map_b[var_a], CustomError_bffbc6be());
    }
    
    /// @custom:selector    0xde5f6268
    /// @custom:signature   depositAll() public payable
    function depositAll() public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
        address var_b = msg.sender;
        (bool success, bytes memory ret0) = address(0xa269676eecbb09decad8f38ab8f1bfdcf4ee9ea2).Unresolved_70a08231(var_b); // staticcall
        if (!0 < rewardsListLength) {
            require(!(0 < rewardsListLength), CustomError_c69cbf86());
            require(!(0 < rewardsListLength), CustomError_c69cbf86());
            require(!totalSupply, CustomError_c69cbf86());
            var_c = address(storage_map_j[var_c] >> 0);
            require((storage_map_k[var_c] ^ block.timestamp) * (storage_map_k[var_c] > block.timestamp) ^ (storage_map_k[var_c]) - (storage_map_l[var_c]) > ((storage_map_k[var_c] ^ block.timestamp) * (storage_map_k[var_c] > block.timestamp) ^ (storage_map_k[var_c])), CustomError_c69cbf86());
            var_c = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(!((storage_map_k[var_c] ^ block.timestamp) * (storage_map_k[var_c] > block.timestamp) ^ (storage_map_k[var_c]) - (storage_map_l[var_c]) * storage_map_m[var_c] / ((storage_map_k[var_c] ^ block.timestamp) * (storage_map_k[var_c] > block.timestamp) ^ (storage_map_k[var_c]) - (storage_map_l[var_c])) == storage_map_m[var_c] | (!((storage_map_k[var_c] ^ block.timestamp) * (storage_map_k[var_c] > block.timestamp) ^ (storage_map_k[var_c])) - (storage_map_l[var_c]))), CustomError_c69cbf86());
            var_c = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(storage_map_n[var_c] > (storage_map_n[var_c] + ((storage_map_k[var_c] ^ block.timestamp) * (storage_map_k[var_c] > block.timestamp) ^ (storage_map_k[var_c]) - (storage_map_l[var_c]) * storage_map_m[var_c] / totalSupply)), CustomError_c69cbf86());
            var_c = address(storage_map_j[var_c] >> 0);
            storage_map_n[var_c] = (storage_map_n[var_c]) + ((storage_map_k[var_c] ^ block.timestamp) * (storage_map_k[var_c] > block.timestamp) ^ (storage_map_k[var_c]) - (storage_map_l[var_c]) * storage_map_m[var_c] / totalSupply);
            require(!(0 < rewardsListLength), CustomError_c69cbf86());
            require(!(0 < rewardsListLength), CustomError_c69cbf86());
            var_c = address(storage_map_j[var_c] >> 0);
            storage_map_l[var_c] = ((block.timestamp ^ (storage_map_k[var_c])) * (block.timestamp < (storage_map_k[var_c]))) ^ (storage_map_k[var_c]);
            require(!(0 < rewardsListLength), CustomError_c69cbf86());
        }
        require(store_h == 0x02, CustomError_c69cbf86());
        store_h = 0x02;
        require(!0, CustomError_c69cbf86());
        require(!address(0xa269676eecbb09decad8f38ab8f1bfdcf4ee9ea2).code.length, CustomError_c69cbf86());
        address var_g = address(msg.sender);
        uint256 var_i = 0;
        var_a = 0x64;
        require(((var_j + 0xa0) > 0xffffffffffffffff) | ((var_j + 0xa0) < var_j));
        (bool success, bytes memory ret0) = address(0xa269676eecbb09decad8f38ab8f1bfdcf4ee9ea2).{ value: var_i ether }Unresolved_23b872dd(var_g); // call
        require(!ret0.length);
        require(var_k);
        require((((0x60 + var_k) + 0x20) - 0x80) < 0x20);
        require(var_a - var_a);
        require(ret0.length > 0xffffffffffffffff, CustomError_f6fa5450());
        if (0x20 > ret0.length) {
        }
    }
    
    /// @custom:selector    0x2f4f21e2
    /// @custom:signature   depositFor(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function depositFor(address arg0, uint256 arg1) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(arg0 - (address(arg0)));
        require(!(0 < rewardsListLength), CustomError_c69cbf86());
        require(!(0 < rewardsListLength), CustomError_c69cbf86());
        require(!totalSupply, CustomError_c69cbf86());
        address var_a = address(storage_map_d[var_a] >> 0);
        require((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) > ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])), CustomError_c69cbf86());
        var_a = address(storage_map_d[var_a] >> 0);
        require(!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a])) == storage_map_b[var_a] | (!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])) - (storage_map_f[var_a]))), CustomError_c69cbf86());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(storage_map_g[var_a] > (storage_map_g[var_a] + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply)), CustomError_c69cbf86());
        require(!(0 < rewardsListLength), CustomError_c69cbf86());
        var_a = address(storage_map_d[var_a] >> 0);
        storage_map_g[var_a] = (storage_map_g[var_a]) + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply);
        require(!(0 < rewardsListLength), CustomError_c69cbf86());
        require(!(0 < rewardsListLength), CustomError_c69cbf86());
        var_a = address(storage_map_d[var_a] >> 0);
        storage_map_f[var_a] = ((block.timestamp ^ (storage_map_e[var_a])) * (block.timestamp < (storage_map_e[var_a]))) ^ (storage_map_e[var_a]);
        require(!(!address(arg0)), CustomError_c69cbf86());
        require(!(0 < rewardsListLength), CustomError_c69cbf86());
        require(!totalSupply, CustomError_c69cbf86());
        var_a = address(storage_map_d[var_a] >> 0);
        require((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) > ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])), CustomError_c69cbf86());
        var_a = address(storage_map_d[var_a] >> 0);
        require(!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a])) == storage_map_b[var_a] | (!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])) - (storage_map_f[var_a]))), CustomError_c69cbf86());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(storage_map_g[var_a] > (storage_map_g[var_a] + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply)), CustomError_c69cbf86());
        require(store_h == 0x02, CustomError_c69cbf86());
        store_h = 0x02;
        require(!arg1, CustomError_c69cbf86());
        require(!address(0xa269676eecbb09decad8f38ab8f1bfdcf4ee9ea2).code.length, CustomError_c69cbf86());
        address var_e = address(msg.sender);
        var_h = 0x64;
        require(((var_i + 0xa0) > 0xffffffffffffffff) | ((var_i + 0xa0) < var_i));
        (bool success, bytes memory ret0) = address(0xa269676eecbb09decad8f38ab8f1bfdcf4ee9ea2).{ value: 0 ether }Unresolved_23b872dd(var_e); // call
        require(!ret0.length);
        require(var_j);
        require((((0x60 + var_j) + 0x20) - 0x80) < 0x20);
        require(var_h - var_h);
        require(ret0.length > 0xffffffffffffffff, CustomError_f6fa5450());
    }
    
    /// @custom:selector    0xdb89461b
    /// @custom:signature   whitelistReward(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function whitelistReward(address arg0) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        address var_b = msg.sender;
        (bool success, bytes memory ret0) = address(store_o).Unresolved_23a3ad72(var_b); // staticcall
        require(!0, "Access Restricted");
        address var_d = address(arg0);
        require(0 == !storage_map_p[var_d], "Access Restricted");
        emit RewardWhitelisted(address(arg0), 0x01);
        require(!(store_q < 0x010000000000000000), "Access Restricted");
        store_q = store_q + 0x01;
        require(!(store_q < store_q), "Access Restricted");
        var_d = 0x09;
        storage_map_r[var_d] = (0 & (storage_map_r[var_d])) | (address(arg0) << 0);
        var_d = address(arg0);
        storage_map_p[var_d] = store_q;
        emit RewardWhitelisted(address(arg0), 0x01);
        require(0x20 > ret0.length);
        require(((var_h + 0x20) > 0xffffffffffffffff) | ((var_h + 0x20) < var_h));
        uint256 var_h = var_h + 0x20;
        require(((var_h + 0x20) - var_h) < 0x20);
        require(var_h.length - var_h.length, "Access Restricted");
        require(!var_h.length, "Access Restricted");
    }
    
    /// @custom:selector    0x99bcc052
    /// @custom:signature   left(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function left(address arg0) public view returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        require(!block.timestamp < (storage_map_s[var_a]));
        var_a = address(arg0);
        require((storage_map_e[var_a] - block.timestamp) > (storage_map_e[var_a]));
        var_a = address(arg0);
        require(!((storage_map_e[var_a] - block.timestamp) * storage_map_b[var_a] / (storage_map_e[var_a] - block.timestamp) == storage_map_b[var_a]) | (!(storage_map_e[var_a]) - block.timestamp));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        return ((storage_map_e[var_a] - block.timestamp) * storage_map_b[var_a]) / 0x0de0b6b3a7640000;
        return 0;
    }
    
    /// @custom:selector    0x3ca068b6
    /// @custom:signature   userRewardPerTokenStored(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function userRewardPerTokenStored(address arg0, address arg1) public view returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        var_a = address(arg1);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0x2e1a7d4d
    /// @custom:signature   withdraw(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function withdraw(uint256 arg0) public payable {
        require(msg.value);
        if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20) {
            require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20, CustomError_f6fa5450());
            require(!(0 < rewardsListLength), CustomError_f6fa5450());
            require(!(0 < rewardsListLength), CustomError_f6fa5450());
            require(!totalSupply, CustomError_f6fa5450());
            var_a = address(storage_map_d[var_a] >> 0);
            require((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) > ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])), CustomError_f6fa5450());
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a])) == storage_map_b[var_a] | (!((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a])) - (storage_map_f[var_a]))), CustomError_f6fa5450());
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(storage_map_g[var_a] > (storage_map_g[var_a] + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply)), CustomError_f6fa5450());
            var_a = address(storage_map_d[var_a] >> 0);
            storage_map_g[var_a] = (storage_map_g[var_a]) + ((storage_map_e[var_a] ^ block.timestamp) * (storage_map_e[var_a] > block.timestamp) ^ (storage_map_e[var_a]) - (storage_map_f[var_a]) * storage_map_b[var_a] / totalSupply);
            require(!(0 < rewardsListLength), CustomError_f6fa5450());
            require(!(0 < rewardsListLength), CustomError_f6fa5450());
            var_a = address(storage_map_d[var_a] >> 0);
            storage_map_f[var_a] = ((block.timestamp ^ (storage_map_e[var_a])) * (block.timestamp < (storage_map_e[var_a]))) ^ (storage_map_e[var_a]);
            require(!(0 < rewardsListLength), CustomError_f6fa5450());
        }
        require(store_h == 0x02, CustomError_f6fa5450());
        store_h = 0x02;
        require(!arg0, CustomError_f6fa5450());
    }
    
    /// @custom:selector    0x638634ee
    /// @custom:signature   lastTimeRewardApplicable(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function lastTimeRewardApplicable(address arg0) public view returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return ((block.timestamp ^ (storage_map_e[var_a])) * (block.timestamp < (storage_map_e[var_a]))) ^ (storage_map_e[var_a]);
    }
    
    /// @custom:selector    0x0c96238f
    /// @custom:signature   removeRewardWhitelist(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function removeRewardWhitelist(address arg0) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        address var_b = msg.sender;
        (bool success, bytes memory ret0) = address(store_o).Unresolved_23a3ad72(var_b); // staticcall
        require(!0, "Access Restricted");
        address var_d = address(arg0);
        require(!storage_map_p[var_d], "Access Restricted");
        require((storage_map_p[var_d] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) > storage_map_p[var_d], "Access Restricted");
        require((store_q + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) > store_q, "Access Restricted");
        require((storage_map_p[var_d] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (store_q + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "Access Restricted");
        require(!((store_q + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < store_q), "Access Restricted");
        require(!store_q, "Access Restricted");
        emit RewardWhitelisted(address(arg0), 0);
        var_a = 0x08c379a000000000000000000000000000000000000000000000000000000000;
        require(0x20 > ret0.length);
        require((0xa0 > 0xffffffffffffffff) | (0xa0 < 0x80));
        require(0x20 < 0x20);
        require(var_a - var_a, "Access Restricted");
        require(!var_a, "Access Restricted");
    }
}

ABI

[
  {
    "type": "function",
    "name": "balanceOf",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "deposit",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "depositAll",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "depositFor",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "earned",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getReward",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address[]"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "isReward",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "isWhitelisted",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "lastTimeRewardApplicable",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "left",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "notifyRewardAmount",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "removeRewardWhitelist",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "rewardData",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "rewardPerToken",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "rewardsList",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "rewardsListLength",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "stake",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "storedRewardsPerUser",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalSupply",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "userRewardPerTokenStored",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "whitelistReward",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "withdraw",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "withdrawAll",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "event",
    "name": "RewardWhitelisted",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "bool",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "error",
    "name": "CANT_NOTIFY_STAKE",
    "inputs": []
  },
  {
    "type": "error",
    "name": "NOT_AUTHORIZED",
    "inputs": []
  },
  {
    "type": "error",
    "name": "NOT_WHITELISTED",
    "inputs": []
  },
  {
    "type": "error",
    "name": "ReentrancyGuardReentrantCall",
    "inputs": []
  },
  {
    "type": "error",
    "name": "TOKEN_ERROR",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ]
  },
  {
    "type": "error",
    "name": "ZERO_AMOUNT",
    "inputs": []
  }
]

UNKNOWN SELECTORS (8)

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)