0xc36442b4a4522e871399cd717abdd847ab11fe88

deployer: unknown relevance score: 0 status: partially_identified bytecode: 24384 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 unresolved_4aa4a4fc = 1097077688018008265106216665536940668749033598146;
    bytes public constant unresolved_6c0360eb = 0xBytes([]);
    uint256 public constant unresolved_30adf81f = 33437492377378226760087498811281282659873828549087316441254475749622436198829;
    uint256 public constant unresolved_c45a0155 = 180374273401342273892298139690832307271870052740;
    
    bytes32 store_o;
    mapping(bytes32 => bytes32) storage_map_f;
    mapping(bytes32 => bytes32) storage_map_d;
    mapping(bytes32 => bytes32) storage_map_h;
    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 unresolved_18160ddd;
    mapping(bytes32 => bytes32) storage_map_k;
    mapping(bytes32 => bytes32) storage_map_i;
    mapping(bytes32 => bytes32) storage_map_b;
    mapping(bytes32 => bytes32) storage_map_m;
    mapping(bytes32 => bytes32) storage_map_p;
    mapping(bytes32 => bytes32) storage_map_e;
    mapping(bytes32 => bytes32) storage_map_l;
    mapping(bytes32 => bytes32) storage_map_n;
    mapping(bytes32 => bytes32) storage_map_c;
    
    event Event_8c5be1e5();
    event Event_17307eab();
    
    /// @custom:selector    0x88316456
    /// @custom:signature   Unresolved_88316456(address arg0, uint256 arg1) public view
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg10 ["uint256", "bytes32", "int256"]
    function Unresolved_88316456(address arg0, uint256 arg1) public view {
        require(!block.timestamp > arg10);
        require(!0x20 < 0x20);
        require(arg0 == (address(arg0)));
        require(!0x20 < 0x20);
    }
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   Unresolved_095ea7b3(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_095ea7b3(address arg0, uint256 arg1) public {
        require(arg0 == (address(arg0)));
        uint256 var_d = arg1;
        require(storage_map_b[var_d], "");
        require((storage_map_b[var_d] - 0x01) < unresolved_18160ddd, "");
        var_d = 0x02;
        require(!(address(arg0) == (address(storage_map_c[(0x02 * (storage_map_b[var_d] - 0x01)) + keccak256(var_d)]))), "");
        require(address(msg.sender) == (address(storage_map_c[(0x02 * (storage_map_b[var_d] - 0x01)) + keccak256(var_d)])), "");
        var_d = address(msg.sender);
        require(bytes1(storage_map_b[var_d]), "");
        var_d = arg1;
        storage_map_b[var_d] = (address(arg0) * 0x01000000000000000000000000) | (uint96(storage_map_b[var_d]));
        var_a = 0x60 + var_a;
        var_d = arg1;
        require(storage_map_b[var_d], "");
        require((storage_map_b[var_d] - 0x01) < unresolved_18160ddd, "");
        var_d = 0x02;
        emit Event_8c5be1e5(address(storage_map_c[(0x02 * (storage_map_b[var_d] - 0x01)) + keccak256(var_d)]), address(arg0), arg1);
        require(!(bytes1(var_a.length)), "");
        require(address(msg.sender) == (address(storage_map_c[(0x02 * (storage_map_b[var_d] - 0x01)) + keccak256(var_d)])), "ERC721: approve caller is not owner nor approved for all");
    }
    
    /// @custom:selector    0xa4a78f0c
    /// @custom:signature   Unresolved_a4a78f0c(address arg0, uint256 arg1, uint256 arg2, bool arg3, uint256 arg4, uint256 arg5) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function Unresolved_a4a78f0c(address arg0, uint256 arg1, uint256 arg2, bool arg3, uint256 arg4, uint256 arg5) public payable {
        require(arg0 == (address(arg0)));
        require(arg3 == (bytes1(arg3)));
        address var_b = msg.sender;
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_dd62ed3e(var_b); // staticcall
        require(!ret0.length < 0x20);
        require(!var_d.length < 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_b = msg.sender;
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }Unresolved_8fcbaf0c(var_b); // call
    }
    
    /// @custom:selector    0x2f745c59
    /// @custom:signature   Unresolved_2f745c59(address arg0, uint256 arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_2f745c59(address arg0, uint256 arg1) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        address var_a = address(arg0);
        require(arg1 < storage_map_d[var_a], "EnumerableSet: index out of bounds");
        require(arg1 < (storage_map_e[var_a]), "EnumerableSet: index out of bounds");
        var_a = 0 + keccak256(var_a);
        return storage_map_f[var_a];
    }
    
    /// @custom:selector    0xfc6f7865
    /// @custom:signature   Unresolved_fc6f7865(uint256 arg0, address arg1, address arg2) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["address", "uint128", "bytes16", "int128"]
    function Unresolved_fc6f7865(uint256 arg0, address arg1, address arg2) public payable {
        uint256 var_a = arg0;
        require(storage_map_d[var_a]);
        var_e = this.code[24174:24215];
        var_a = arg0;
        require(storage_map_d[var_a]);
        require((storage_map_d[var_a] - 0x01) < unresolved_18160ddd);
        var_a = 0x02;
        require(address(msg.sender) == (address(storage_map_g[(0x02 * (storage_map_d[var_a] - 0x01)) + keccak256(var_a)])));
        var_a = arg0;
        require(storage_map_d[var_a]);
        var_a = arg0;
        require(address(storage_map_d[var_a] / 0x01000000000000000000000000) == (address(msg.sender)));
        var_a = address(msg.sender);
        require(bytes1(storage_map_d[var_a]));
        require(!0x20 < 0x20);
        require(arg2 == (address(arg2)));
        require(address(arg2) > 0);
        require(address(arg2) > 0);
        require(!0x20 < 0x20);
        require(arg1 == (address(arg1)));
        require(address(arg1) == 0);
        var_a = uint80(storage_map_h[var_a]);
        var_c = var_c + 0x60;
        require(address(var_i) < (address(var_e)));
        var_c = var_c + 0x80;
        require(!address(storage_map_h[var_a] / 0x0100000000000000000000000000000000));
        uint256 var_v = 11;
        uint256 var_x = 0;
        require(address(keccak256(var_e)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_e)).{ value: var_x ether }Unresolved_a34123a7(var_v); // call
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0x40);
        uint256 var_ad = keccak256(var_e);
        require(address(keccak256(var_e)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_e)).Unresolved_514ea4bf(var_ad); // staticcall
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0xa0);
        require(var_c.length == (address(var_c.length)));
        require(var_ae == (address(var_ae)));
        require(!0x20 < 0x20);
        require(address(storage_map_d[var_a] / 0x01000000000000000000000000) == (address(msg.sender)), "Not approved");
        require(!(bytes1(var_c.length)), "");
    }
    
    /// @custom:selector    0x01ffc9a7
    /// @custom:signature   Unresolved_01ffc9a7(uint32 arg0) public view returns (bool)
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function Unresolved_01ffc9a7(uint32 arg0) public view returns (bool) {
        require(arg0 == (uint32(arg0)));
        uint32 var_a = uint32(arg0);
        return !(!bytes1(storage_map_d[var_a]));
    }
    
    /// @custom:selector    0xe985e9c5
    /// @custom:signature   Unresolved_e985e9c5(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_e985e9c5(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xc87b56dd
    /// @custom:signature   Unresolved_c87b56dd(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_c87b56dd(uint256 arg0) public {
        uint256 var_a = arg0;
        require(storage_map_d[var_a]);
        address var_d = address(this);
        require(address(0xee6a57ec80ea46401049e92587e52f5ec1c24785).code.length);
        (bool success, bytes memory ret0) = address(0xee6a57ec80ea46401049e92587e52f5ec1c24785).Unresolved_e9dc6375(var_d); // staticcall
        uint256 var_f = var_f + (uint248(ret0.length + 0x1f));
        if (!((var_f + ret0.length) - var_f) < 0x20) {
            require(!((var_f + ret0.length) - var_f) < 0x20);
            require(!var_f.length > 0xffffffffffffffff);
            require((var_f + ret0.length) > ((var_f + var_f.length) + 0x1f));
            require(!(var_g) > 0xffffffffffffffff);
            var_f = var_f + (0x20 + (uint248(0x1f + (var_h))));
            require(!((var_f + (0x20 + (uint248(0x1f + (var_h))))) < var_f) | ((var_f + (0x20 + (uint248(0x1f + (var_h))))) > 0xffffffffffffffff));
            require(!((var_f + var_f.length) + (var_h) + 0x20) > (var_f + ret0.length));
            require(!0 < (var_g));
        }
    }
    
    /// @custom:selector    0x99fbab88
    /// @custom:signature   Unresolved_99fbab88(uint256 arg0) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_99fbab88(uint256 arg0) public view returns (bytes memory) {
        uint256 var_a = arg0;
        require(uint80(storage_map_h[var_a]), "Invalid token ID");
        var_a = uint80(var_n);
        return abi.encodePacked(uint96(var_s), address(var_u), address(var_s), address(var_u), uint24(var_n), 11, 11, address(var_ab), var_ad, var_af, address(var_ah), address(var_aj));
    }
    
    /// @custom:selector    0x219f5d17
    /// @custom:signature   Unresolved_219f5d17(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function Unresolved_219f5d17(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public payable {
        require(!block.timestamp > arg5);
        var_a = uint80(storage_map_h[var_a]);
        var_c = var_c + 0x0140;
        var_c = 0x60 + var_c;
        require(address(var_t) < (address(var_i)));
        var_c = var_c + 0x80;
        require(address(keccak256(var_i)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_i)).Unresolved_3850c7bd(var_ah); // staticcall
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0xe0);
        require(var_c.length == (address(var_c.length)));
        require(var_y == 11);
        require(var_ai == (uint16(var_ai)));
    }
    
    /// @custom:selector    0x13ead562
    /// @custom:signature   Unresolved_13ead562(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_13ead562(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xa22cb465
    /// @custom:signature   Unresolved_a22cb465(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_a22cb465(address arg0, uint256 arg1) public {
        require(arg0 == (address(arg0)));
        require(arg1 == arg1);
        require(!(address(arg0) == (address(msg.sender))), "ERC721: approve to caller");
        var_a = address(arg0);
        storage_map_d[var_a] = arg1 | (uint248(storage_map_d[var_a]));
        emit Event_17307eab(address(msg.sender), address(arg0), arg1);
    }
    
    /// @custom:selector    0x6352211e
    /// @custom:signature   Unresolved_6352211e(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_6352211e(uint256 arg0) public view returns (address) {
        uint256 var_a = 0x60 + var_a;
        uint256 var_d = arg0;
        require(storage_map_b[var_d], "");
        require((storage_map_b[var_d] - 0x01) < unresolved_18160ddd, "");
        var_d = 0x02;
        return address(storage_map_c[(0x02 * (storage_map_b[var_d] - 0x01)) + keccak256(var_d)]);
        require(!(bytes1(var_a.length)), "");
    }
    
    /// @custom:selector    0x4f6ccce7
    /// @custom:signature   Unresolved_4f6ccce7(uint256 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_4f6ccce7(uint256 arg0) public view returns (uint256) {
        require(arg0 < unresolved_18160ddd, "EnumerableMap: index out of bounds");
        require(arg0 < unresolved_18160ddd, "EnumerableMap: index out of bounds");
        var_a = 0x02;
        return storage_map_n[(0x02 * arg0) + keccak256(var_a)];
    }
    
    /// @custom:selector    0xc2e3140a
    /// @custom:signature   Unresolved_c2e3140a(address arg0, uint256 arg1, uint256 arg2, bool arg3, uint256 arg4, uint256 arg5) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function Unresolved_c2e3140a(address arg0, uint256 arg1, uint256 arg2, bool arg3, uint256 arg4, uint256 arg5) public payable {
        require(arg0 == (address(arg0)));
        require(arg3 == (bytes1(arg3)));
        address var_b = msg.sender;
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_dd62ed3e(var_b); // staticcall
        require(!ret0.length < 0x20);
        require(!var_d.length < arg1);
        var_b = msg.sender;
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }Unresolved_d505accf(var_b); // call
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   Unresolved_06fdde03() public view returns (string memory)
    function Unresolved_06fdde03() public view returns (string memory) {
        bytes1 var_a = 0x20 + (var_a + (0x20 * (((store_o & (((!bytes1(store_o)) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02) + 0x1f) / 0x20)));
        if (!(store_o & (((!store_o) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / 0x02) {
            if (0x1f < (store_o & (((!store_o) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02)) {
                var_c = 0x06;
                if ((var_a + 0x20) + (store_o & (((!store_o) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02) > (0x20 + (var_a + 0x20))) {
                    if (!0 > var_a.length) {
                        return abi.encodePacked(0x20, var_a.length);
                        return abi.encodePacked(0x20, var_a.length);
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   Unresolved_95d89b41() public view returns (string memory)
    function Unresolved_95d89b41() public view returns (string memory) {
        bytes1 var_a = 0x20 + (var_a + (0x20 * (((store_q & (((!bytes1(store_q)) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02) + 0x1f) / 0x20)));
        if (!(store_q & (((!store_q) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / 0x02) {
            if (0x1f < (store_q & (((!store_q) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02)) {
                var_c = 0x07;
                if ((var_a + 0x20) + (store_q & (((!store_q) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02) > (0x20 + (var_a + 0x20))) {
                    if (!0 > var_a.length) {
                        return abi.encodePacked(0x20, var_a.length);
                        return abi.encodePacked(0x20, var_a.length);
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xb88d4fde
    /// @custom:signature   Unresolved_b88d4fde(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_b88d4fde(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x081812fc
    /// @custom:signature   Unresolved_081812fc(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_081812fc(uint256 arg0) public view returns (address) {
        uint256 var_a = arg0;
        require(storage_map_d[var_a], "ERC721: approved query for nonexistent token");
        var_a = arg0;
        return address(storage_map_d[var_a] / 0x01000000000000000000000000);
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   Unresolved_23b872dd(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_23b872dd(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xdf2ab5bb
    /// @custom:signature   Unresolved_df2ab5bb(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_df2ab5bb(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xf3995c67
    /// @custom:signature   Unresolved_f3995c67(address arg0, uint256 arg1, uint256 arg2, bool arg3, uint256 arg4, uint256 arg5) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function Unresolved_f3995c67(address arg0, uint256 arg1, uint256 arg2, bool arg3, uint256 arg4, uint256 arg5) public payable {
        require(arg0 == (address(arg0)));
        require(arg3 == (bytes1(arg3)));
        address var_b = msg.sender;
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }Unresolved_d505accf(var_b); // call
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   Unresolved_70a08231(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_70a08231(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        require(address(arg0), "ERC721: balance query for the zero address");
        address var_a = address(arg0);
        return storage_map_d[var_a];
    }
    
    /// @custom:selector    0x3644e515
    /// @custom:signature   Unresolved_3644e515() public view returns (uint256)
    function Unresolved_3644e515() public view returns (uint256) {
        return keccak256(var_i);
    }
    
    /// @custom:selector    0x4659a494
    /// @custom:signature   Unresolved_4659a494(address arg0, uint256 arg1, uint256 arg2, bool arg3, uint256 arg4, uint256 arg5) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function Unresolved_4659a494(address arg0, uint256 arg1, uint256 arg2, bool arg3, uint256 arg4, uint256 arg5) public payable {
        require(arg0 == (address(arg0)));
        require(arg3 == (bytes1(arg3)));
        address var_b = msg.sender;
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }Unresolved_8fcbaf0c(var_b); // call
    }
    
    /// @custom:selector    0x42842e0e
    /// @custom:signature   Unresolved_42842e0e(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_42842e0e(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x0c49ccbe
    /// @custom:signature   Unresolved_0c49ccbe(uint256 arg0, address arg1, uint256 arg2, uint256 arg3) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint128", "bytes16", "int128"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function Unresolved_0c49ccbe(uint256 arg0, address arg1, uint256 arg2, uint256 arg3) public payable {
        uint256 var_a = arg0;
        require(storage_map_d[var_a]);
        var_e = this.code[24174:24215];
        var_a = arg0;
        require(storage_map_d[var_a]);
        require((storage_map_d[var_a] - 0x01) < unresolved_18160ddd);
        var_a = 0x02;
        require(address(msg.sender) == (address(storage_map_g[(0x02 * (storage_map_d[var_a] - 0x01)) + keccak256(var_a)])));
        var_a = arg0;
        require(storage_map_d[var_a]);
        var_a = arg0;
        require(address(storage_map_d[var_a] / 0x01000000000000000000000000) == (address(msg.sender)));
        var_a = address(msg.sender);
        require(bytes1(storage_map_d[var_a]));
        require(!block.timestamp > arg4);
        require(!0x20 < 0x20);
        require(arg1 == (address(arg1)));
        require(address(arg1) > 0);
        var_a = arg0;
        require(!0x20 < 0x20);
        require(arg1 == (address(arg1)));
        require(!(address(storage_map_h[var_a] / 0x0100000000000000000000000000000000)) < (address(arg1)));
        var_a = uint80(storage_map_i[var_a]);
        var_c = var_c + 0x60;
        require(address(var_i) < (address(var_e)));
        var_c = var_c + 0x80;
        require(!0x20 < 0x20);
        require(arg1 == (address(arg1)));
        uint256 var_v = 11;
        require(address(keccak256(var_e)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_e)).{ value: 0 ether }Unresolved_a34123a7(var_v); // call
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!(((var_c + ret0.length) - var_c) < 0x40), "Price slippage check");
        require(var_c.length < arg2, "Price slippage check");
        require(!(var_c.length < arg2), "Price slippage check");
        uint256 var_ae = keccak256(var_e);
        require(address(keccak256(var_e)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_e)).Unresolved_514ea4bf(var_ae); // staticcall
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0xa0);
        require(var_c.length == (address(var_c.length)));
        require(var_af == (address(var_af)));
        require(address(storage_map_d[var_a] / 0x01000000000000000000000000) == (address(msg.sender)), "Not approved");
        require(!(bytes1(var_c.length)), "");
    }
    
    /// @custom:selector    0x42966c68
    /// @custom:signature   Unresolved_42966c68(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_42966c68(uint256 arg0) public view {
        uint256 var_a = arg0;
        require(storage_map_d[var_a], "Not cleared");
        uint256 var_c = 0x60 + var_c;
        var_a = arg0;
        require(storage_map_d[var_a], "Not cleared");
        require((storage_map_d[var_a] - 0x01) < unresolved_18160ddd, "Not cleared");
        var_a = 0x02;
        require(address(msg.sender) == (address(storage_map_g[(0x02 * (storage_map_d[var_a] - 0x01)) + keccak256(var_a)])), "Not cleared");
        var_a = arg0;
        require(storage_map_d[var_a], "Not cleared");
        var_a = arg0;
        require(address(storage_map_d[var_a] / 0x01000000000000000000000000) == (address(msg.sender)), "Not cleared");
        var_a = address(msg.sender);
        require(bytes1(storage_map_d[var_a]), "Not cleared");
        var_a = arg0;
        require(!(!address(storage_map_h[var_a] / 0x0100000000000000000000000000000000)), "Not cleared");
        require(!(!address(storage_map_h[var_a] / 0x0100000000000000000000000000000000)), "Not cleared");
        require(!(address(storage_map_h[var_a] / 0x0100000000000000000000000000000000)), "Not cleared");
        require(address(storage_map_d[var_a] / 0x01000000000000000000000000) == (address(msg.sender)), "Not approved");
        require(!(bytes1(var_c.length)), "");
    }
    
    /// @custom:selector    0x12210e8a
    /// @custom:signature   Unresolved_12210e8a() public payable
    function Unresolved_12210e8a() public payable {
        require(!address(this).balance, "STE");
        uint256 var_b = var_b + 0x20;
        require(var_b.length < 0x20, "STE");
        require((var_b.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < 0x20, "STE");
        (bool success, bytes memory ret0) = address(msg.sender).transfer(address(this).balance);
        require(ret0.length == 0, "STE");
    }
    
    /// @custom:selector    0xac9650d8
    /// @custom:signature   Unresolved_ac9650d8(uint256 arg0, uint256 arg1) public payable returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_ac9650d8(uint256 arg0, uint256 arg1) public payable returns (bytes memory) {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        uint256 var_b = var_b + (0x20 + (0x20 * (arg0)));
        require(!arg0);
        require(arg0 - 0x01);
        require(!0 < (arg0));
        require(0 < (arg0));
        require(!((0x20 + (arg0)) + ((0x20 + (arg0)) + 0)) > 0xffffffffffffffff);
        (bool success, bytes memory ret0) = address(this).Unresolved_(var_e); // delegatecall
        require(ret0.length == 0);
        require(!var_f < 0x44);
        require(!((0x84 + var_g) - 0x84) < 0x20);
        require(!var_h > 0xffffffffffffffff);
        require((0x84 + var_g) > ((0x84 + var_h) + 0x1f), "");
        require(!(var_i > 0xffffffffffffffff), "");
        require(!(((var_b + (0x20 + (uint248(0x1f + (var_i))))) < var_b) | ((var_b + (0x20 + (uint248(0x1f + (var_i))))) > 0xffffffffffffffff)), "");
        var_b = var_b + (0x20 + (uint248(0x1f + (var_i))));
        require(!(((0x84 + var_h) + (var_j) + 0x20) > (0x84 + var_g)), "");
        require(!(0 < (var_i)), "");
        require(!(0 > (var_i)), "");
        require(!(0 > var_b.length), "");
        var_b = var_b + (uint248(ret0.length + 0x3f));
        return abi.encodePacked(0x20, var_b.length);
    }
    
    /// @custom:selector    0xd3487997
    /// @custom:signature   Unresolved_d3487997(uint256 arg0, uint256 arg1, uint256 arg2) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_d3487997(uint256 arg0, uint256 arg1, uint256 arg2) public pure {
        require(!arg2 > 0xffffffffffffffff);
        require(!(arg2) > 0xffffffffffffffff);
        require(!((0x20 + (0x04 + arg2)) + (arg2) - (0x20 + (0x04 + arg2))) < 0x80);
        require(!((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
        uint256 var_a = var_a + 0x40;
        require(!((0x20 + (0x04 + arg2)) + (arg2) - (0x20 + (0x04 + arg2))) < 0x60);
        require(!((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < (var_a + 0x40)));
        require((0x20 + (arg2)) == (address(0x20 + (arg2))));
    }
    
    /// @custom:selector    0x49404b7c
    /// @custom:signature   Unresolved_49404b7c(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_49404b7c(uint256 arg0, address arg1) public payable {
        require(arg1 == (address(arg1)));
        address var_b = address(this);
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).Unresolved_70a08231(var_b); // staticcall
        require(!(ret0.length < 0x20), "Insufficient WETH9");
        require(!(var_c.length < arg0), "Insufficient WETH9");
        require(!var_c.length);
        var_b = var_c.length;
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).{ value: 0 ether }Unresolved_2e1a7d4d(var_b); // call
        uint256 var_c = var_c + 0x20;
        require(var_c.length < 0x20, "STE");
        require((var_c.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < 0x20, "STE");
        (bool success, bytes memory ret0) = address(arg1).transfer(var_c.length);
        require(ret0.length == 0, "STE");
    }
    
    /// @custom:selector    0x7ac2ff7b
    /// @custom:signature   Unresolved_7ac2ff7b(address arg0, uint256 arg1, uint256 arg2, bool arg3, uint256 arg4, uint256 arg5) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function Unresolved_7ac2ff7b(address arg0, uint256 arg1, uint256 arg2, bool arg3, uint256 arg4, uint256 arg5) public payable {
        require(arg0 == (address(arg0)));
        require(arg3 == (bytes1(arg3)));
        require(!block.timestamp > arg2);
        uint256 var_g = 0x20 + (0x20 + (0x20 + (0x20 + (0x20 + (0x20 + var_g)))));
        uint256 var_h = arg1;
        storage_map_r[var_h] = (uint96(storage_map_r[var_h] + 0x01)) | (address(storage_map_r[var_h]));
        var_g = var_g + 0xc0;
        var_h = arg1;
        var_i = 0x03;
        require(storage_map_r[var_h]);
        require((storage_map_r[var_h] - 0x01) < unresolved_18160ddd);
        var_h = 0x02;
        require(!(address(arg0)) == (address(storage_map_s[(0x02 * (storage_map_r[var_h] - 0x01)) + keccak256(var_h)])));
        require(!address(storage_map_s[(0x02 * (storage_map_r[var_h] - 0x01)) + keccak256(var_h)]).code.length);
        require(var_i);
        require(address(var_ac), "Unauthorized");
        require(address(var_ac) == (address(storage_map_s[(0x02 * (storage_map_r[var_h] - 0x01)) + keccak256(var_h)])), "Unauthorized");
        var_h = arg1;
        storage_map_r[var_h] = (address(arg0) * 0x01000000000000000000000000) | (uint96(storage_map_r[var_h]));
        var_g = 0x60 + var_g;
        var_h = arg1;
        require(storage_map_r[var_h], "");
        require((storage_map_r[var_h] - 0x01) < unresolved_18160ddd, "");
        var_h = 0x02;
        emit Event_8c5be1e5(address(storage_map_s[(0x02 * (storage_map_r[var_h] - 0x01)) + keccak256(var_h)]), address(arg0), arg1);
        require(!(bytes1(var_g.length)), "");
        var_g = var_g + 0x61;
        var_al = keccak256(var_x);
        require(!bytes1(var_g.length));
        require(address(storage_map_s[(0x02 * (storage_map_r[var_h] - 0x01)) + keccak256(var_h)]).code.length);
        (bool success, bytes memory ret0) = address(storage_map_s[(0x02 * (storage_map_r[var_h] - 0x01)) + keccak256(var_h)]).Unresolved_1626ba7e(var_al); // staticcall
        require(!(ret0.length < 0x20), "Unauthorized");
        require(0x1626ba7e00000000000000000000000000000000000000000000000000000000 == (uint32(var_g.length)), "Unauthorized");
        var_h = arg1;
        storage_map_r[var_h] = (address(arg0) * 0x01000000000000000000000000) | (uint96(storage_map_r[var_h]));
        var_g = 0x60 + var_g;
        var_h = arg1;
        require(storage_map_r[var_h]);
        require((storage_map_r[var_h] - 0x01) < unresolved_18160ddd);
        var_h = 0x02;
        emit Event_8c5be1e5(address(storage_map_s[(0x02 * (storage_map_r[var_h] - 0x01)) + keccak256(var_h)]), address(arg0), arg1);
        require(address(storage_map_s[(0x02 * (storage_map_r[var_h] - 0x01)) + keccak256(var_h)]).code.length);
    }
}

ABI

[
  {
    "type": "function",
    "name": "Unresolved_01ffc9a7",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_06fdde03",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_081812fc",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_095ea7b3",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_0c49ccbe",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_12210e8a",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_13ead562",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_18160ddd",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_219f5d17",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_23b872dd",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_2f745c59",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_30adf81f",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_3644e515",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_42842e0e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_42966c68",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_4659a494",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "bool"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_49404b7c",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_4aa4a4fc",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_4f6ccce7",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_6352211e",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_6c0360eb",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_70a08231",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_7ac2ff7b",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "bool"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_88316456",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_95d89b41",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_99fbab88",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_a22cb465",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_a4a78f0c",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "bool"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_ac9650d8",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_b88d4fde",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_c2e3140a",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "bool"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_c45a0155",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_c87b56dd",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_d3487997",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_df2ab5bb",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_e985e9c5",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_f3995c67",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "bool"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_fc6f7865",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "event",
    "name": "Event_17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
    "inputs": [],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (1)

0x43000706unknown
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)