0xecb456ea5365865ebab8a2661b0c503410e9b347

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 store_b;
    uint256 store_d;
    uint256 store_a;
    uint256 store_c;
    uint256 store_e;
    uint256 store_f;
    bytes32 store_g;
    mapping(bytes32 => bytes32) storage_map_h;
    bytes32 store_i;
    uint256 store_j;
    
    event CommitAdmins(address, address, address);
    event ApplyAdmins(address, address, address);
    event AddBurner(address);
    fallback() external payable {
        require(!var_b == 0x8cb16c8a);
        require(!arg0 >> 0xa0);
        require(!arg1 >> 0xa0);
        require(!arg2 >> 0xa0);
        require(!(!msg.sender == store_a), "Access denied");
        store_b = arg0;
        store_c = arg1;
        store_d = arg2;
        emit CommitAdmins(arg0, arg1, arg2);
        require(!var_b == 0x61893921);
        require(!(!msg.sender == store_a), "Access denied");
        var_c = store_b;
        var_d = store_c;
        var_e = store_d;
        store_a = var_c;
        store_e = var_d;
        store_f = var_e;
        uint256 var_h = var_e;
        emit ApplyAdmins(var_c, var_d, var_e);
        require(!0);
        require(!var_b == 0x1198c785);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(!arg1 >> 0xa0);
        require(!(!msg.sender == store_a), "Access denied");
        var_c = var_c;
        var_d = var_d;
        var_j = 0x07;
        var_f = storage_map_h[var_j];
        require(!var_c ^ 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
        var_j = 0x07;
        storage_map_h[var_j] = var_d;
        var_g = var_d;
        emit AddBurner(var_d);
        require(!var_f ^ 0);
        var_k = 0x04;
        (bool success, bytes memory ret0) = address(0x04).{ value: 0 ether }Unresolved_095ea7b3(var_m); // call
        uint256 var_o = 0;
        (bool success, bytes memory ret0) = address(0x04).{ value: var_o ether }adfepixw(); // call
        (bool success, bytes memory ret0) = address(var_c).transfer(0);
        require(!0x20 > ret0.length);
        (bool success, bytes memory ret0) = address(0x04).{ value: var_o ether }adfepixw(); // call
        require(!var_g ^ 0);
        require(!var_g > 0x20);
        require(!var_g < 0);
        require(var_h / (0x0100 ** (0x20 - var_g)));
        require(!var_d ^ 0);
        var_k = 0x04;
        (bool success, bytes memory ret0) = address(0x04).{ value: var_o ether }Unresolved_095ea7b3(var_m); // call
        (bool success, bytes memory ret0) = address(0x04).{ value: 0 ether }adfepixw(); // call
        (bool success, bytes memory ret0) = address(var_c).transfer(0);
        require(!0x20 > ret0.length);
        (bool success, bytes memory ret0) = address(0x04).{ value: 0 ether }adfepixw(); // call
        require(!var_g ^ 0);
        require(!var_g > 0x20);
        require(!var_g < 0);
        require(var_h / (0x0100 ** (0x20 - var_g)));
        var_j = 0x07;
        storage_map_h[var_j] = var_d;
        emit AddBurner(var_d);
        var_j = 0x07;
        storage_map_h[var_j] = var_d;
        emit AddBurner(var_d);
        (bool success, bytes memory ret0) = address(0x04).{ value: 0 ether }adfepixw(); // call
        var_j = 0x07;
        storage_map_h[var_j] = var_d;
        emit AddBurner(var_d);
        (bool success, bytes memory ret0) = address(0x04).{ value: 0 ether }adfepixw(); // call
        require(!var_b == 0x0ab74d6f);
        require(!store_g);
        store_g = 0x01;
        uint256 var_r = 0;
        require(!(var_r) >> 0xa0);
        var_r = var_r + 0x20;
        require(!var_r < 0x0280);
        var_r = 0;
        require(!(msg.data[0x0284 + var_r]) >> 0xa0);
        var_r = var_r + 0x20;
        require(!(var_r < 0x0280), "Access denied");
        require(!(!msg.sender == store_a), "Access denied");
        var_c = 0;
        require(var_c < 0x14);
        var_d = ((0x20 * var_c) );
        require(var_d);
        require(var_c < 0x14);
        var_f = msg.data[(0x20 * var_c) + 0x0284];
        var_e = 88 + 0x06;
        var_c = var_e;
        var_d = var_f;
        var_j = 0x07;
        var_f = storage_map_h[var_j];
        require(!var_c ^ 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
        var_j = 0x07;
        storage_map_h[var_j] = var_d;
        var_g = var_d;
        emit AddBurner(var_d);
        require(!var_f ^ 0);
        var_k = 0x04;
        (bool success, bytes memory ret0) = address(0x04).{ value: 0 ether }Unresolved_095ea7b3(var_m); // call
        var_o = 0;
        (bool success, bytes memory ret0) = address(0x04).{ value: var_o ether }adfepixw(); // call
        (bool success, bytes memory ret0) = address(var_c).transfer(0);
        require(!0x20 > ret0.length);
        (bool success, bytes memory ret0) = address(0x04).{ value: var_o ether }adfepixw(); // call
        require(!var_g ^ 0);
        require(!var_g > 0x20);
        require(!var_g < 0);
        require(var_h / (0x0100 ** (0x20 - var_g)));
        require(!var_d ^ 0);
        var_k = 0x04;
        (bool success, bytes memory ret0) = address(0x04).{ value: var_o ether }Unresolved_095ea7b3(var_m); // call
        (bool success, bytes memory ret0) = address(0x04).{ value: 0 ether }adfepixw(); // call
        (bool success, bytes memory ret0) = address(var_c).transfer(0);
        require(!0x20 > ret0.length);
        (bool success, bytes memory ret0) = address(0x04).{ value: 0 ether }adfepixw(); // call
        require(!var_g ^ 0);
        require(!var_g > 0x20);
        require(!var_g < 0);
        require(var_h / (0x0100 ** (0x20 - var_g)));
        var_j = 0x07;
        storage_map_h[var_j] = var_d;
        emit AddBurner(var_d);
        var_j = 0x07;
        storage_map_h[var_j] = var_d;
        emit AddBurner(var_d);
        (bool success, bytes memory ret0) = address(0x04).{ value: 0 ether }adfepixw(); // call
        var_j = 0x07;
        storage_map_h[var_j] = var_d;
        emit AddBurner(var_d);
        var_q = ret0.length;
        (bool success, bytes memory ret0) = address(0x04).{ value: 0 ether }adfepixw(); // call
        store_g = 0;
        require(!var_b == 0xe4e67c0f);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0xd7f649fd);
        require(!store_g);
        store_g = 0x01;
        var_r = 0;
        require(!(var_r) >> 0xa0);
        var_r = var_r + 0x20;
        require(!var_r < 0x0280);
        var_d = 0;
        var_c = (var_d * 0x20);
        require(var_c);
        require(address(var_c).code.length);
        (bool success, bytes memory ret0) = address(var_c).transfer(0);
        var_d = store_g + var_d;
        require(!0x14 == (0x01 + var_d));
        store_g = 0;
        store_g = 0;
        require(!var_b == 0x89afcb44);
        require(!store_i);
        store_i = 0x01;
        require(!arg0 >> 0xa0);
        require(tx.origin == msg.sender);
        require(!store_j);
        require(!arg0 == 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
        var_c = address(this).balance;
        var_j = 0x07;
        (bool success, bytes memory ret0) = address(storage_map_h[var_j]).transfer(var_c);
        require(ret0.length > 0x1f);
        store_i = 0;
        require(!var_b == 0x910a8aec);
        require(!store_i);
        store_i = 0x01;
        var_r = 0;
        require(!(var_r) >> 0xa0);
        var_r = var_r + 0x20;
        require(!var_r < 0x0280);
        require(tx.origin == msg.sender);
        require(!store_j);
        var_d = 0;
        var_c = (var_d * 0x20);
        require(var_c);
        require(!var_c == 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
        var_e = address(this).balance;
        var_j = 0x07;
        (bool success, bytes memory ret0) = address(storage_map_h[var_j]).transfer(var_e);
        require(ret0.length > 0x1f);
        var_d = store_i + var_d;
        require(!0x14 == (0x01 + var_d));
        store_i = 0;
        store_i = 0;
        require(!var_b == 0xb01f275f);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(!(!msg.sender == store_f), "Access denied");
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0x1cfbc236);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(!(msg.sender == store_f), "Access denied");
        require(!(!msg.sender == store_a), "Access denied");
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0xf132f2a5);
        require(!arg0 >> 0x01);
        require(!(msg.sender == store_f), "Access denied");
        require(!(!msg.sender == store_a), "Access denied");
        store_j = arg0;
        require(!var_b == 0x3ea1c6f4);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(!arg1 >> 0xa0);
        require(!(!msg.sender == store_a), "Access denied");
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0x5f608d1e);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0xa8f22cf1);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0xa352c2eb);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        var_c = 0;
        require(!msg.sender == (var_s));
        var_r = store_g + var_r;
        require(!0x02 == (0x01 + var_r));
        require(0x01 == var_c);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        var_c = 0x01;
        require(!(!0x01 == var_c), "Access denied");
        var_h = 0x0d;
        require(!var_b == 0x6f331ff3);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(!(!msg.sender == store_e), "Access denied");
        var_j = 0x06;
        storage_map_h[var_j] = arg4;
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0xcf56a4d8);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(msg.sender == tx.origin);
        var_j = 0x06;
        var_c = storage_map_h[var_j];
        require(!var_c > 0);
        (bool success, bytes memory ret0) = address(0x22d53366457f9d5e68ec105046fc4383).Unresolved_(var_u); // staticcall
        require(ret0.length > 0x1f);
        var_d = var_h;
        (bool success, bytes memory ret0) = address(var_d).Unresolved_(var_w); // staticcall
        require(ret0.length > 0xff);
        (bool success, bytes memory ret0) = address(var_d).Unresolved_(var_af); // staticcall
        require(ret0.length > 0xff);
        uint256 var_ao = 0;
        require(var_ao < 0x08);
        var_ap = var_aq;
        require(var_ap);
        require(var_ao < 0x08);
        require(!0x12 < (var_ar));
        require((0x12 - (var_ar)) < 0x4e);
        require(var_ao < 0x08);
        require(!0x12 < (var_ar));
        require(((var_ap * (0x0a ** (0x12 - (var_ar)))) / var_ap) == (0x0a ** (0x12 - (var_ar))) | !var_ap);
        uint256 var_ap = var_ap * (0x0a ** (0x12 - (var_ar)));
        require(var_ao < 0x08);
        require(!(var_am + var_ap) < var_am);
        uint256 var_am = var_am + var_ap;
        var_ao = store_g + var_ao;
        require(!0x08 == (0x01 + var_ao));
        require((((var_an * 0x0de0b6b3a7640000) / var_an) == 0x0de0b6b3a7640000) | !var_an);
        var_ao = var_an * 0x0de0b6b3a7640000;
        var_ap = 0;
        require(var_ap < 0x08);
        var_as = var_at;
        require(var_as);
        require((((var_ao * var_as) / var_ao) == var_as) | !var_ao);
        require(var_am, "Unsafe to apply");
        var_ao = (var_ao * var_as) / var_am;
        var_ap = store_g + var_ap;
        require(!(0x08 == (0x01 + var_ap)), "Unsafe to apply");
        require(!(var_ao < var_c), "Unsafe to apply");
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0x5082b389);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        var_c = 0;
        require(!msg.sender == (var_s));
        var_r = store_g + var_r;
        require(!0x03 == (0x01 + var_r));
        require(0x01 == var_c);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        var_c = 0x01;
        require(!(!0x01 == var_c), "Access denied");
        require(!var_b == 0xcfca0bdb);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(!(!msg.sender == store_e), "Access denied");
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0xe8d64d6c);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0x9d4a4380);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(!(!msg.sender == store_e), "Access denied");
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0x53f79b2b);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        var_c = 0;
        require(!msg.sender == (var_s));
        var_r = store_g + var_r;
        require(!0x02 == (0x01 + var_r));
        require(0x01 == var_c);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        var_c = 0x01;
        require(!(!0x01 == var_c), "Access denied");
        require(!var_b == 0xdda3c543);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(!(!msg.sender == store_a), "Access denied");
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0xf7709539);
        require(!arg0 >> 0xa0);
        require(!arg1 >> 0xa0);
        require(!arg2 >> 0x01);
        require(!(!msg.sender == store_a), "Access denied");
        var_j = keccak256(var_j);
        storage_map_h[var_j] = arg2;
        require(!var_b == 0xdb0a8406);
        require(!store_g);
        store_g = 0x01;
        require(!arg0 >> 0xa0);
        require(!msg.sender ^ store_a);
        var_j = keccak256(var_j);
        require(storage_map_h[var_j]);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        store_g = 0;
        require(!var_b == 0x47c8715f);
        var_b = store_a;
        return store_a;
        require(!var_b == 0xa5b0b7e9);
        var_b = store_e;
        return store_e;
        require(!var_b == 0x680c7783);
        var_b = store_f;
        return store_f;
        require(!var_b == 0x3c2fcbf4);
        var_b = store_b;
        return store_b;
        require(!var_b == 0x824b5085);
        var_b = store_c;
        return store_c;
        require(!var_b == 0x5866507a);
        var_b = store_d;
        return store_d;
        require(!var_b == 0xdd165f91);
        require(!arg0 >> 0xa0);
        var_j = 0x06;
        var_b = storage_map_h[var_j];
        return storage_map_h[var_j];
        require(!var_b == 0x03d41e0e);
        require(!arg0 >> 0xa0);
        var_j = 0x07;
        var_b = storage_map_h[var_j];
        return storage_map_h[var_j];
        require(!var_b == 0x49dd3788);
        var_b = store_j;
        return store_j;
        require(!var_b == 0x87dcefb7);
        require(!arg0 >> 0xa0);
        require(!arg1 >> 0xa0);
        var_j = keccak256(var_j);
        return storage_map_h[var_j];
    }
    
}

ABI

[]

UNKNOWN SELECTORS (24)

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)