0xee77aa3fd23bbebaf94386dd44b548e9a785ea4b

deployer: unknown relevance score: 0 status: partially_identified bytecode: 15553 bytes

DECOMPILED SOLIDITY (Heimdall)

// 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 TOKE_REWARD = 695719339573683366998415990452264859095307588549;
    uint256 public constant LIQUIDITY_RESERVE = 815097114666913843171378172313492526308344057145;
    uint256 public constant STAKING_TOKEN = 1138607664929985305611767491010480812189834732845;
    uint256 public constant REWARD_TOKEN = 1257607365722262311637681592664463731920859590355;
    uint256 public constant TOKE_TOKEN = 266123457577436995845573104083093324340849249428;
    uint256 public constant COOL_DOWN_CONTRACT = 943474111210740989920666375389276722625819646384;
    uint256 public constant WARM_UP_CONTRACT = 1011198968760356795444963916900308127067136747449;
    uint256 public constant TOKE_MANAGER = 961569205011395151246068305409299099139060558356;
    uint256 public constant TOKE_POOL = 733900661157331000415993771500599469113294541585;
    
    bytes32 store_d;
    uint256 public requestWithdrawalAmount;
    mapping(bytes32 => bytes32) storage_map_v;
    mapping(bytes32 => bytes32) storage_map_w;
    uint256 public warmUpPeriod;
    mapping(bytes32 => bytes32) storage_map_z;
    uint256 public lastTokeCycleIndex;
    mapping(bytes32 => bytes32) storage_map_h;
    mapping(bytes32 => bytes32) storage_map_g;
    mapping(bytes32 => bytes32) storage_map_s;
    mapping(bytes32 => bytes32) storage_map_t;
    uint256 public timeLeftToRequestWithdrawal;
    uint256 public withdrawalAmount;
    mapping(bytes32 => bytes32) storage_map_aa;
    bytes public epoch;
    bool public pauseStaking;
    mapping(bytes32 => bytes32) storage_map_y;
    bytes32 store_c;
    bytes32 store_e;
    mapping(bytes32 => bytes32) storage_map_i;
    uint256 public coolDownPeriod;
    address public getOwner;
    mapping(bytes32 => bytes32) storage_map_m;
    mapping(bytes32 => bytes32) storage_map_u;
    mapping(bytes32 => bytes32) storage_map_x;
    mapping(bytes32 => bytes32) storage_map_n;
    mapping(bytes32 => bytes32) storage_map_o;
    
    event OwnershipPulled(address, address);
    event OwnershipPushed(address, address);
    
    /// @custom:selector    0x1e83409a
    /// @custom:signature   claim(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function claim(address arg0) public payable {
        require(arg0 == (address(arg0)));
        address var_a = address(arg0);
        var_a = address(arg0);
        require(store_c < (storage_map_i[var_a]));
        require(store_c < (storage_map_i[var_a]));
        var_a = address(arg0);
        storage_map_g[var_a] = 0;
        storage_map_h[var_a] = 0;
        storage_map_i[var_a] = 0;
        var_k = var_l;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_7965d56d(var_k); // staticcall
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0x20);
        address var_n = address(arg0);
        require(address(0xb11fbae0567a6bb7e6ae6afa7a6b06ec316e67b9).code.length);
        (bool success, bytes memory ret0) = address(0xb11fbae0567a6bb7e6ae6afa7a6b06ec316e67b9).{ value: storage_map_i[var_a] ether }Unresolved_c3a2a665(var_n); // call
        require(!var_p);
    }
    
    /// @custom:selector    0x54d4be5a
    /// @custom:signature   transferToke(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function transferToke(address arg0) public payable {
        require(arg0 == (address(arg0)));
        require(msg.sender == (address(getOwner)), "Ownable: caller is not the owner");
        require(address(arg0));
        var_a = 0x70a0823100000000000000000000000000000000000000000000000000000000;
        address var_b = address(this);
        require(address(0x2e9d63788249371f1dfc918a52f8d799f4a38c94).code.length);
        (bool success, bytes memory ret0) = address(0x2e9d63788249371f1dfc918a52f8d799f4a38c94).Unresolved_70a08231(var_b); // staticcall
        uint256 var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "Address: insufficient balance for call");
        var_e = 0x40 + var_e;
        require(!(address(this).balance < 0), "Address: insufficient balance for call");
        require(address(0x2e9d63788249371f1dfc918a52f8d799f4a38c94).code.length, "Address: call to non-contract");
        var_m = 0x20;
        require(!0 > var_e.length);
        uint256 var_o = 0;
        (bool success, bytes memory ret0) = address(0x2e9d63788249371f1dfc918a52f8d799f4a38c94).{ value: var_o ether }Unresolved_08c379a0(var_m); // call
        require(ret0.length == 0);
        require(!var_q);
        require(!(0 > var_e.length), "");
        require(!var_q, "SafeERC20: ERC20 operation did not succeed");
        require(!(((0x80 + var_q) - 0x80) < 0x20), "SafeERC20: ERC20 operation did not succeed");
        require(var_a == var_a, "SafeERC20: ERC20 operation did not succeed");
        require(var_a, "SafeERC20: ERC20 operation did not succeed");
        var_e = var_e + (uint248(ret0.length + 0x3f));
        require(!var_e.length);
        require(!var_e.length);
    }
    
    /// @custom:selector    0x1b618cc0
    /// @custom:signature   coolDownInfo(address arg0) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function coolDownInfo(address arg0) public view returns (bytes memory) {
        require(arg0 == (address(arg0)));
        address var_b = arg0;
        return abi.encodePacked(storage_map_m[var_b], storage_map_n[var_b], storage_map_o[var_b]);
    }
    
    /// @custom:selector    0x7fa91eba
    /// @custom:signature   Unresolved_7fa91eba(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_7fa91eba(uint256 arg0) public payable {
        require(arg0 == arg0);
        require(msg.sender == (address(getOwner)), "Ownable: caller is not the owner");
        pauseStaking = (uint248(pauseStaking)) | (0x010000000000000000000000000000000000000000 * arg0);
    }
    
    /// @custom:selector    0x6cef16e6
    /// @custom:signature   pullOwner() public payable
    function pullOwner() public payable {
        require(msg.sender == (address(pauseStaking)), "Ownable: must be new owner to pull");
        emit OwnershipPulled(address(getOwner), address(pauseStaking));
        getOwner = (address(pauseStaking)) | (uint96(getOwner));
        pauseStaking = uint96(pauseStaking);
    }
    
    /// @custom:selector    0x68d8f514
    /// @custom:signature   unstakeAllFromTokemak() public payable
    function unstakeAllFromTokemak() public payable {
        require(msg.sender == (address(getOwner)), "Ownable: caller is not the owner");
        address var_b = address(this);
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).Unresolved_70a08231(var_b); // staticcall
        uint256 var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "Ownable: caller is not the owner");
        require(msg.sender == (address(getOwner)), "Ownable: caller is not the owner");
        pauseStaking = (uint248(pauseStaking)) | (0x010000000000000000000000000000000000000000 * 0x01);
        requestWithdrawalAmount = var_e.length;
        uint256 var_c = var_e.length;
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).{ value: 0 ether }Unresolved_9ee679e8(var_c); // call
    }
    
    /// @custom:selector    0x736f616b
    /// @custom:signature   setCoolDownPeriod(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setCoolDownPeriod(uint256 arg0) public payable {
        require(msg.sender == (address(getOwner)), "Ownable: caller is not the owner");
        coolDownPeriod = arg0;
    }
    
    /// @custom:selector    0x820c6f5b
    /// @custom:signature   warmUpInfo(address arg0) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function warmUpInfo(address arg0) public view returns (bytes memory) {
        require(arg0 == (address(arg0)));
        address var_b = arg0;
        return abi.encodePacked(storage_map_m[var_b], storage_map_n[var_b], storage_map_o[var_b]);
    }
    
    /// @custom:selector    0x37df07ee
    /// @custom:signature   sendWithdrawalRequests() public payable
    function sendWithdrawalRequests() public payable {
        require(address(0xa86e412109f77c45a3bc1c5870b880492fb86a14).code.length);
        (bool success, bytes memory ret0) = address(0xa86e412109f77c45a3bc1c5870b880492fb86a14).getCycleDuration(); // staticcall
        uint256 var_b = var_b + (uint248(ret0.length + 0x1f));
        require(!((var_b + ret0.length) - var_b) < 0x20);
        require(address(0xa86e412109f77c45a3bc1c5870b880492fb86a14).code.length);
        (bool success, bytes memory ret0) = address(0xa86e412109f77c45a3bc1c5870b880492fb86a14).getCurrentCycle(); // staticcall
        var_b = var_b + (uint248(ret0.length + 0x1f));
        require(!((var_b + ret0.length) - var_b) < 0x20);
        require(address(0xa86e412109f77c45a3bc1c5870b880492fb86a14).code.length);
        (bool success, bytes memory ret0) = address(0xa86e412109f77c45a3bc1c5870b880492fb86a14).getCurrentCycleIndex(); // staticcall
        var_b = var_b + (uint248(ret0.length + 0x1f));
        require(!((var_b + ret0.length) - var_b) < 0x20);
        require(!var_b.length > ~(var_b.length));
        require(!block.timestamp > ~(timeLeftToRequestWithdrawal));
        require((block.timestamp + timeLeftToRequestWithdrawal) < (var_b.length + var_b.length));
        require(!var_b.length > lastTokeCycleIndex);
        require(!var_b.length > lastTokeCycleIndex);
        address var_h = address(this);
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).{ value: 0 ether }Unresolved_bb582d80(var_h); // call
        var_b = var_b + (uint248(ret0.length + 0x1f));
        require(!((var_b + ret0.length) - var_b) < 0x40);
        require(!((var_b + 0x40) > 0xffffffffffffffff) | ((var_b + 0x40) < var_b));
        var_b = var_b + 0x40;
        require(address(0xa86e412109f77c45a3bc1c5870b880492fb86a14).code.length);
        (bool success, bytes memory ret0) = address(0xa86e412109f77c45a3bc1c5870b880492fb86a14).getCurrentCycleIndex(); // staticcall
        if (!requestWithdrawalAmount > 0) {
            require(!requestWithdrawalAmount > 0);
        }
    }
    
    /// @custom:selector    0xaf14052c
    /// @custom:signature   rebase() public payable
    function rebase() public payable {
        require(block.number < store_d);
        var_b = store_e;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).{ value: 0 ether }Unresolved_058ecdb4(var_b); // call
        uint256 var_d = var_d + (uint248(ret0.length + 0x1f));
        require(!((var_d + ret0.length) - var_d) < 0x20);
        require(!store_d > ~(epoch));
        store_d = store_d + epoch;
        require(!store_c == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        store_c = 0x01 + store_c;
        address var_c = address(this);
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).Unresolved_70a08231(var_c); // staticcall
        var_d = var_d + (uint248(ret0.length + 0x1f));
        require(!((var_d + ret0.length) - var_d) < 0x20);
        address var_i = address(this);
        require(address(0xc770eefad204b5180df6a14ee197d99d808ee52d).code.length);
        (bool success, bytes memory ret0) = address(0xc770eefad204b5180df6a14ee197d99d808ee52d).Unresolved_70a08231(var_i); // staticcall
    }
    
    /// @custom:selector    0x54eea796
    /// @custom:signature   setEpochLength(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setEpochLength(uint256 arg0) public payable {
        require(msg.sender == (address(getOwner)), "Ownable: caller is not the owner");
        epoch = arg0;
    }
    
    /// @custom:selector    0xac5a7d5c
    /// @custom:signature   pushOwner(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function pushOwner(address arg0) public payable {
        require(arg0 == (address(arg0)));
        require(msg.sender == (address(getOwner)), "Ownable: caller is not the owner");
        emit OwnershipPushed(address(getOwner), address(arg0));
        pauseStaking = (address(arg0)) | (uint96(pauseStaking));
    }
    
    /// @custom:selector    0x7acb7757
    /// @custom:signature   stake(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function stake(uint256 arg0, address arg1) public payable {
        require(arg1 == (address(arg1)));
        require(!(bytes1(pauseStaking / 0x010000000000000000000000000000000000000000)), "Staking is paused");
        require(arg0 > 0);
        var_a = 0x9358928b00000000000000000000000000000000000000000000000000000000;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).circulatingSupply(); // staticcall
        uint256 var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "Address: insufficient balance for call");
        require(!var_e.length, "Address: insufficient balance for call");
        var_e = 0x40 + var_e;
        require(!(address(this).balance < 0), "Address: insufficient balance for call");
        require(address(0xc770eefad204b5180df6a14ee197d99d808ee52d).code.length, "Address: call to non-contract");
        var_n = 0x20;
        require(!0 > var_e.length);
        uint256 var_q = 0;
        (bool success, bytes memory ret0) = address(0xc770eefad204b5180df6a14ee197d99d808ee52d).{ value: var_q ether }Unresolved_08c379a0(var_n); // call
        require(ret0.length == 0);
        require(!var_r);
        require(!(0 > var_e.length), "");
        require(!var_r, "SafeERC20: ERC20 operation did not succeed");
        require(!(((0x80 + var_r) - 0x80) < 0x20), "SafeERC20: ERC20 operation did not succeed");
        require(var_a == var_a, "SafeERC20: ERC20 operation did not succeed");
        require(var_a, "SafeERC20: ERC20 operation did not succeed");
        var_t = address(arg1);
        require(store_c < (storage_map_u[var_t]));
        require(store_c < (storage_map_u[var_t]));
        var_q = arg0;
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).{ value: 0 ether }Unresolved_b6b55f25(var_q); // call
        require(warmUpPeriod);
        require(!(storage_map_v[var_t]) > ~(arg0));
        var_t = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        uint256 var_aa = arg0;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_1bd39674(var_aa); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(!(address(this).balance < 0), "Address: insufficient balance for call");
        var_t = address(arg1);
        var_t = address(arg1);
        require(store_c < (storage_map_u[var_t]));
        require(store_c < (storage_map_u[var_t]));
        uint256 var_ao = arg0;
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).{ value: 0 ether }Unresolved_b6b55f25(var_ao); // call
        var_t = address(arg1);
        storage_map_s[var_t] = 0;
        storage_map_t[var_t] = 0;
        storage_map_u[var_t] = 0;
        var_ao = var_j;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_7965d56d(var_ao); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        if (!var_ap) {
        }
        if (!var_ap) {
        }
        var_e = var_e + (uint248(ret0.length + 0x3f));
        require(!var_e.length);
        if (!var_e.length) {
        }
        require(block.number < store_d);
        var_c = store_e;
        var_d = store_c;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).{ value: storage_map_t[var_t] ether }Unresolved_058ecdb4(var_c, var_d); // call
    }
    
    /// @custom:selector    0x0a8dd5e6
    /// @custom:signature   Unresolved_0a8dd5e6(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_0a8dd5e6(uint256 arg0) public payable {
        require(arg0 == arg0);
        require(!(bytes1(pauseStaking / 0x01000000000000000000000000000000000000000000)), "Unstaking is paused");
        require(!arg0);
        require(block.number < store_d);
        address var_e = msg.sender;
        address var_a = storage_map_w[var_e];
        address var_k = msg.sender;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_70a08231(var_k); // staticcall
        var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!((var_g + ret0.length) - var_g) < 0x20);
        var_m = var_n;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_7965d56d(var_m); // staticcall
        var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!((var_g + ret0.length) - var_g) < 0x20);
        require(!var_g.length > ~(var_g.length));
        var_q = 0x8ec637fe2800940c7959f9bad4fe69e41225cd39;
        require(address(0xc770eefad204b5180df6a14ee197d99d808ee52d).code.length);
        (bool success, bytes memory ret0) = address(0xc770eefad204b5180df6a14ee197d99d808ee52d).Unresolved_70a08231(var_q); // staticcall
        var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!(((var_g + ret0.length) - var_g) < 0x20), "Must have reward tokens");
        require(var_g.length + var_g.length, "Must have reward tokens");
        require(!var_g.length < (var_g.length + var_g.length));
        require(!var_g.length);
        require(!var_g.length);
        uint256 var_s = var_g.length + var_g.length;
        require(address(0x8ec637fe2800940c7959f9bad4fe69e41225cd39).code.length);
        (bool success, bytes memory ret0) = address(0x8ec637fe2800940c7959f9bad4fe69e41225cd39).{ value: 0 ether }Unresolved_bbb6a983(var_s); // call
        var_g = 0x40 + var_g;
        require(!(address(this).balance < 0), "Address: insufficient balance for call");
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length, "Address: call to non-contract");
        var_ab = 0x20;
        require(!0 > var_g.length);
        var_ae = 0;
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).{ value: var_ae ether }Unresolved_08c379a0(var_ab); // call
        require(ret0.length == 0);
        require(!var_af);
        require(!(0 > var_g.length), "");
        var_ae = 0;
        require(!var_af);
        require(!((0x80 + var_af) - 0x80) < 0x20);
        require(var_a == var_a);
        require(var_a);
        var_ab = var_g.length + var_g.length;
        require(address(0x8ec637fe2800940c7959f9bad4fe69e41225cd39).code.length);
        (bool success, bytes memory ret0) = address(0x8ec637fe2800940c7959f9bad4fe69e41225cd39).{ value: var_ae ether }Unresolved_bbb6a983(var_ab); // call
        var_g = var_g + (uint248(ret0.length + 0x3f));
        require(!var_g.length);
        require(!var_g.length);
        var_ad = var_g.length + var_g.length;
        require(address(0x8ec637fe2800940c7959f9bad4fe69e41225cd39).code.length);
        (bool success, bytes memory ret0) = address(0x8ec637fe2800940c7959f9bad4fe69e41225cd39).{ value: 0 ether }Unresolved_bbb6a983(var_ad); // call
        var_s = address(this);
        var_t = var_g.length;
        require(address(0xb11fbae0567a6bb7e6ae6afa7a6b06ec316e67b9).code.length);
        (bool success, bytes memory ret0) = address(0xb11fbae0567a6bb7e6ae6afa7a6b06ec316e67b9).{ value: 0 ether }Unresolved_c3a2a665(var_s, var_t); // call
        var_b = store_e;
        var_c = store_c;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).{ value: 0 ether }rebase(var_b, var_c); // call
    }
    
    /// @custom:selector    0x4baa0cd2
    /// @custom:signature   Unresolved_4baa0cd2(uint256 arg0, uint256 arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_4baa0cd2(uint256 arg0, uint256 arg1) public payable {
        require(arg1 == arg1);
        uint256 var_d = ((0x84 + var_e) - var_e) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0;
        var_e = 0x40 + var_e;
        require(!(address(this).balance < 0), "Address: insufficient balance for call");
        require(address(0xc770eefad204b5180df6a14ee197d99d808ee52d).code.length, "Address: call to non-contract");
        var_k = 0x20;
        require(!0 > var_e.length);
        uint256 var_n = 0;
        (bool success, bytes memory ret0) = address(0xc770eefad204b5180df6a14ee197d99d808ee52d).{ value: var_n ether }Unresolved_08c379a0(var_k); // call
        require(ret0.length == 0);
        require(!var_o);
        require(!(0 > var_e.length), "");
        require(!var_o, "SafeERC20: ERC20 operation did not succeed");
        require(!(((0x80 + var_o) - 0x80) < 0x20), "SafeERC20: ERC20 operation did not succeed");
        require(var_d == var_d, "SafeERC20: ERC20 operation did not succeed");
        require(var_d, "SafeERC20: ERC20 operation did not succeed");
        address var_k = address(this);
        require(address(0xc770eefad204b5180df6a14ee197d99d808ee52d).code.length);
        (bool success, bytes memory ret0) = address(0xc770eefad204b5180df6a14ee197d99d808ee52d).Unresolved_70a08231(var_k); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(!var_e.length < withdrawalAmount);
        var_l = var_e.length - withdrawalAmount;
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).{ value: 0 ether }Unresolved_b6b55f25(var_l); // call
        require(!arg1);
        require(block.number < store_d);
        var_l = store_e;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).{ value: 0 ether }Unresolved_058ecdb4(var_l); // call
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(!store_d > ~(epoch));
        store_d = store_d + epoch;
        require(!store_c == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        store_c = 0x01 + store_c;
        address var_m = address(this);
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).Unresolved_70a08231(var_m); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        var_n = address(this);
        require(address(0xc770eefad204b5180df6a14ee197d99d808ee52d).code.length);
        (bool success, bytes memory ret0) = address(0xc770eefad204b5180df6a14ee197d99d808ee52d).Unresolved_70a08231(var_n); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x3f));
        require(!var_e.length);
        require(!var_e.length);
        var_m = address(this);
        require(address(0xc770eefad204b5180df6a14ee197d99d808ee52d).code.length);
        (bool success, bytes memory ret0) = address(0xc770eefad204b5180df6a14ee197d99d808ee52d).balanceOf(var_m); // staticcall
    }
    
    /// @custom:selector    0xf9a571a2
    /// @custom:signature   setWarmUpPeriod(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setWarmUpPeriod(uint256 arg0) public payable {
        require(msg.sender == (address(getOwner)), "Ownable: caller is not the owner");
        warmUpPeriod = arg0;
    }
    
    /// @custom:selector    0x9ebea88c
    /// @custom:signature   Unresolved_9ebea88c(uint256 arg0, uint256 arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_9ebea88c(uint256 arg0, uint256 arg1) public payable {
        require(arg1 == arg1);
        require(!(bytes1(pauseStaking / 0x01000000000000000000000000000000000000000000)), "Unstaking is paused");
        require(!arg1);
        require(block.number < store_d);
        address var_e = address(msg.sender);
        address var_a = storage_map_w[var_e];
        address var_k = address(msg.sender);
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_70a08231(var_k); // staticcall
        var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!((var_g + ret0.length) - var_g) < 0x20);
        var_m = var_n;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_7965d56d(var_m); // staticcall
        var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!(((var_g + ret0.length) - var_g) < 0x20), "Insufficient Balance");
        require(!(var_g.length > ~(var_g.length)), "Insufficient Balance");
        require(!(arg0 > (var_g.length + var_g.length)), "Insufficient Balance");
        require(!var_g.length, "Address: insufficient balance for call");
        require(!arg0, "Address: insufficient balance for call");
        var_g = 0x40 + var_g;
        require(!(address(this).balance < 0), "Address: insufficient balance for call");
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length, "Address: call to non-contract");
        var_z = 0x20;
        require(!0 > var_g.length);
        var_ac = 0;
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).{ value: var_ac ether }Unresolved_08c379a0(var_z); // call
        require(ret0.length == 0);
        require(!var_ad);
        require(!(0 > var_g.length), "");
        require(!var_ad);
        require(!((0x80 + var_ad) - 0x80) < 0x20);
        require(var_a == var_a);
        require(var_a);
        var_e = address(msg.sender);
        var_ac = storage_map_x[var_e];
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_7965d56d(var_ac); // staticcall
        var_g = var_g + (uint248(ret0.length + 0x3f));
        require(!var_g.length);
        require(!var_g.length);
        var_e = address(msg.sender);
        address var_ak = storage_map_x[var_e];
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_7965d56d(var_ak); // staticcall
        var_e = address(msg.sender);
        var_g = var_g + 0x60;
        var_t = storage_map_x[var_e];
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_7965d56d(var_t); // staticcall
        address var_q = address(this);
        var_r = var_g.length;
        require(address(0xb11fbae0567a6bb7e6ae6afa7a6b06ec316e67b9).code.length);
        (bool success, bytes memory ret0) = address(0xb11fbae0567a6bb7e6ae6afa7a6b06ec316e67b9).{ value: 0 ether }retrieve(var_q, var_r); // call
        var_e = address(msg.sender);
        storage_map_w[var_e] = 0;
        storage_map_x[var_e] = 0;
        storage_map_y[var_e] = 0;
        require(!(arg0 - var_g.length), "Address: insufficient balance for call");
        require(!(address(this).balance < 0), "Address: insufficient balance for call");
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length, "Address: call to non-contract");
        var_q = address(this);
        var_r = arg0;
        require(address(0xb11fbae0567a6bb7e6ae6afa7a6b06ec316e67b9).code.length);
        (bool success, bytes memory ret0) = address(0xb11fbae0567a6bb7e6ae6afa7a6b06ec316e67b9).{ value: storage_map_x[var_e] ether }retrieve(var_q, var_r); // call
        var_q = arg0;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).gonsForBalance(var_q); // staticcall
        var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!((var_g + ret0.length) - var_g) < 0x20);
        require(!(var_n) < var_g.length);
        var_r = (var_n) - var_g.length;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).balanceForGons(var_r); // staticcall
        var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!((var_g + ret0.length) - var_g) < 0x20);
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        var_b = store_e;
        var_c = store_c;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).{ value: storage_map_x[var_e] ether }rebase(var_b, var_c); // call
    }
    
    /// @custom:selector    0xa694fc3a
    /// @custom:signature   stake(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function stake(uint256 arg0) public payable {
        require(!(bytes1(pauseStaking / 0x010000000000000000000000000000000000000000)), "Staking is paused");
        require(arg0 > 0);
        var_a = 0x9358928b00000000000000000000000000000000000000000000000000000000;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).circulatingSupply(); // staticcall
        uint256 var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!(((var_e + ret0.length) - var_e) < 0x20), "Address: insufficient balance for call");
        require(!var_e.length, "Address: insufficient balance for call");
        var_e = 0x40 + var_e;
        require(!(address(this).balance < 0), "Address: insufficient balance for call");
        require(address(0xc770eefad204b5180df6a14ee197d99d808ee52d).code.length, "Address: call to non-contract");
        var_n = 0x20;
        require(!0 > var_e.length);
        uint256 var_q = 0;
        (bool success, bytes memory ret0) = address(0xc770eefad204b5180df6a14ee197d99d808ee52d).{ value: var_q ether }Unresolved_08c379a0(var_n); // call
        require(ret0.length == 0);
        require(!var_r);
        require(!(0 > var_e.length), "");
        require(!var_r, "SafeERC20: ERC20 operation did not succeed");
        require(!(((0x80 + var_r) - 0x80) < 0x20), "SafeERC20: ERC20 operation did not succeed");
        require(var_a == var_a, "SafeERC20: ERC20 operation did not succeed");
        require(var_a, "SafeERC20: ERC20 operation did not succeed");
        var_t = address(msg.sender);
        require(store_c < (storage_map_u[var_t]));
        require(store_c < (storage_map_u[var_t]));
        var_q = arg0;
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).{ value: 0 ether }Unresolved_b6b55f25(var_q); // call
        require(warmUpPeriod);
        require(!(storage_map_v[var_t]) > ~(arg0));
        var_t = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        uint256 var_aa = arg0;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_1bd39674(var_aa); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(!(address(this).balance < 0), "Address: insufficient balance for call");
        var_t = address(msg.sender);
        var_t = address(msg.sender);
        require(store_c < (storage_map_u[var_t]));
        require(store_c < (storage_map_u[var_t]));
        uint256 var_ao = arg0;
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).{ value: 0 ether }Unresolved_b6b55f25(var_ao); // call
        var_t = address(msg.sender);
        storage_map_s[var_t] = 0;
        storage_map_t[var_t] = 0;
        storage_map_u[var_t] = 0;
        var_ao = var_j;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_7965d56d(var_ao); // staticcall
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        if (!var_ap) {
        }
        if (!var_ap) {
        }
        var_e = var_e + (uint248(ret0.length + 0x3f));
        require(!var_e.length);
        if (!var_e.length) {
        }
        require(block.number < store_d);
        var_c = store_e;
        var_d = store_c;
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).{ value: storage_map_t[var_t] ether }Unresolved_058ecdb4(var_c, var_d); // call
    }
    
    /// @custom:selector    0x4bbce08b
    /// @custom:signature   Unresolved_4bbce08b(uint256 arg0, uint256 arg1, address arg2, uint256 arg3, bool arg4, uint256 arg5, uint256 arg6) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    function Unresolved_4bbce08b(uint256 arg0, uint256 arg1, address arg2, uint256 arg3, bool arg4, uint256 arg5, uint256 arg6) public payable {
        require(arg4 == (bytes1(arg4)));
        require(arg3 > 0);
        uint256 var_b = arg0;
        require(arg2 == (address(arg2)));
        require(address(0x79dd22579112d8a5f7347c5ed7e609e60da713c5).code.length);
        (bool success, bytes memory ret0) = address(0x79dd22579112d8a5f7347c5ed7e609e60da713c5).{ value: 0 ether }Unresolved_e1fc8691(var_b); // call
    }
    
    /// @custom:selector    0x3897e22b
    /// @custom:signature   Unresolved_3897e22b(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_3897e22b(uint256 arg0) public payable {
        require(arg0 == arg0);
        require(msg.sender == (address(getOwner)), "Ownable: caller is not the owner");
        pauseStaking = (uint248(pauseStaking)) | (0x01000000000000000000000000000000000000000000 * arg0);
    }
    
    /// @custom:selector    0x516c49d9
    /// @custom:signature   claimWithdraw(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function claimWithdraw(address arg0) public payable {
        require(arg0 == (address(arg0)));
        address var_a = address(arg0);
        address var_h = storage_map_h[var_a];
        require(address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).code.length);
        (bool success, bytes memory ret0) = address(0xdc49108ce5c57bc3408c3a5e95f3d864ec386ed3).Unresolved_7965d56d(var_h); // staticcall
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0x20);
        var_a = address(arg0);
        address var_m = address(this);
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).{ value: 0 ether }Unresolved_bb582d80(var_m); // call
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0x40);
        require(!((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c));
        var_c = var_c + 0x40;
        require(address(0xa86e412109f77c45a3bc1c5870b880492fb86a14).code.length);
        (bool success, bytes memory ret0) = address(0xa86e412109f77c45a3bc1c5870b880492fb86a14).getCurrentCycleIndex(); // staticcall
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0x20);
        require(store_c < (var_s));
        require(store_c < (var_s));
        require(store_c < (var_s));
        require(store_c < (var_s));
        address var_u = address(this);
        require(address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).code.length);
        (bool success, bytes memory ret0) = address(0x808d3e6b23516967ceae4f17a5f9038383ed5311).{ value: 0 ether }Unresolved_bb582d80(var_u); // call
        if (var_c.length < var_c.length) {
            if (!(var_v) > ~(withdrawalAmount)) {
                if (!(var_v + withdrawalAmount) < var_c.length) {
                }
                require(var_c.length < var_c.length);
                require(!(var_v) > ~(withdrawalAmount));
                require(!var_c.length < var_c.length);
            }
            require(var_c.length < var_c.length);
        }
    }
    
    /// @custom:selector    0x5b3112fc
    /// @custom:signature   setTimeLeftToRequestWithdrawal(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setTimeLeftToRequestWithdrawal(uint256 arg0) public payable {
        require(msg.sender == (address(getOwner)), "Ownable: caller is not the owner");
        timeLeftToRequestWithdrawal = arg0;
    }
}

ABI

[
  {
    "type": "function",
    "name": "COOL_DOWN_CONTRACT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "LIQUIDITY_RESERVE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "REWARD_TOKEN",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "STAKING_TOKEN",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "TOKE_MANAGER",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "TOKE_POOL",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "TOKE_REWARD",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "TOKE_TOKEN",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_0a8dd5e6",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_3897e22b",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_4baa0cd2",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_4bbce08b",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "address"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "bool"
      },
      {
        "name": "arg5",
        "type": "uint256"
      },
      {
        "name": "arg6",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_7fa91eba",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_9ebea88c",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "WARM_UP_CONTRACT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "claim",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "claimWithdraw",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "coolDownInfo",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "coolDownPeriod",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "epoch",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getNewOwner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getOwner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "lastTokeCycleIndex",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pauseStaking",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pauseUnstaking",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pullOwner",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "pushOwner",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "rebase",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "requestWithdrawalAmount",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "sendWithdrawalRequests",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setCoolDownPeriod",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setEpochLength",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setTimeLeftToRequestWithdrawal",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setWarmUpPeriod",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "stake",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "timeLeftToRequestWithdrawal",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transferToke",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "unstakeAllFromTokemak",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "warmUpInfo",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "warmUpPeriod",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "withdrawalAmount",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "event",
    "name": "OwnershipPulled",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "OwnershipPushed",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (24)

0x0a8dd5e6unknown
0x9776cb78unknown
0x050c486cunknown
0x3897e22bunknown
0x820c6f5bunknown
0x28ebcda1unknown
0x4baa0cd2unknown
0xc9d4f350unknown
0x5b3112fcunknown
0xe2a8179dunknown
0xb8e4b244unknown
0x7fa91ebaunknown
0x37df07eeunknown
0x68d8f514unknown
0x156c46bfunknown
0xbbb6a983unknown
0x516c49d9unknown
0xb09881ccunknown
0x823a46a1unknown
0x54d4be5aunknown
0x4bbce08bunknown
0x10781679unknown
0xed295509unknown
0x1b618cc0unknown
These selectors are not yet in the research database — they are being investigated and will be added as known functions once identified. They are also marked in red in the decompiled Solidity above.

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)

(none)