0x9cfb6c0721eebd197514daad9e06d0263608263b

deployer: unknown relevance score: 0 status: partially_identified bytecode: 12191 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_40df7b57 = 10000;
    uint256 public constant unresolved_cf72af38 = 9971;
    
    bytes32 store_b;
    bytes32 store_a;
    address store_d;
    mapping(bytes32 => bytes32) storage_map_e;
    mapping(bytes32 => bytes32) storage_map_c;
    
    
    /// @custom:selector    0x84cee21c
    /// @custom:signature   Unresolved_84cee21c(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, uint256 arg6) 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"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    function Unresolved_84cee21c(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, uint256 arg6) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x60);
        require(arg2 > 0xffffffffffffffff);
        require(arg2 > 0xffffffffffffffff);
        require(msg.sender - (address(store_a)), "NA");
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        require(!(arg2) > 0x20);
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg2));
        require(arg2 > (arg2));
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg2) + 0x20) + (arg2 - (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - ((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg2) + 0x20)) < 0x20);
        require(0x5d > (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg2), "IIA");
        require(!(arg0 < 0), "IIA");
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "IIA");
        require((0 - arg0) < ((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + (arg2 + 0x20)), "IIA");
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        uint256 var_e = var_e + 0xa0;
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require(!arg0 > 0);
        address var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(arg1 > 0);
        var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x54), "tag OOB");
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(!(uint32((0x5d + (arg2 + 0x20)) >> 0xe0)) == 0x01);
        require(0x54 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)));
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)));
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - 0x54) < 0x18);
        require(!(uint32((0x5d + (arg2 + 0x20)) >> 0xe0)) == 0x01);
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require(address(var_e.length) - msg.sender);
        require(0 == (11 > 0));
        require(!11 > 0);
        require(!address(var_e.length).code.length);
        var_r = 11;
        (bool success, bytes memory ret0) = address(var_e.length).Unresolved_022c0d9f(var_r); // call
        if (!11) {
        }
        require(((var_e + 0) > 0xffffffffffffffff) | ((var_e + 0) < var_e));
        var_e = var_e + 0;
        require((var_e - var_e) < 0);
        require(!(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - 0x54) < 0x04), "tag OOB");
        require(uint32((0x54 + (0x5d + (arg2 + 0x20))) >> 0xe0) - 0x01, "pool OOB");
        require(0x18 > ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - 0x54), "pool OOB");
        if (!(uint32((0x5d + (arg2 + 0x20)) >> 0xe0)) == 0x01) {
        }
        if (!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18) {
        }
        require(!arg0 > 0);
        require(arg2 == 0x20);
        address var_b = msg.sender;
        uint256 var_c = arg0;
        (bool success, bytes memory ret0) = address(0).transfer(var_b, var_c); // call
        if (0x20 > ret0.length) {
        }
        require(arg1 > 0);
        require(arg2 == 0x20);
        var_b = msg.sender;
        var_c = arg1;
        (bool success, bytes memory ret0) = address(0).transfer(var_b, var_c); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
    }
    
    /// @custom:selector    0x84800812
    /// @custom:signature   Unresolved_84800812(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_84800812(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x80);
        require(address(arg0) - arg0);
        require(arg3 > 0xffffffffffffffff);
        require(arg3 > 0xffffffffffffffff);
        require(msg.sender - (address(store_a)), "NA");
        require(msg.sender == (address(store_b)), "NA");
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        uint256 var_e = var_e + 0xa0;
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg3));
        require(arg3 > (arg3));
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg3) + 0x20) + (arg3 - (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - ((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg3) + 0x20)) < 0x20);
        require(0x54 > (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg3), "IIA");
        require(!arg1, "IIA");
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "IIA");
        require(arg1 < ((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + (arg3 + 0x20)), "IIA");
        require(!11 < 0);
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        address var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        require(11 < 0);
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(uint32((0x54 + (arg3 + 0x20)) >> 0xe0) == 0x01, "pool OOB");
        require(0x18 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)), "pool OOB");
        require(address((0x54 + (arg3 + 0x20)) >> 0x60) - address(this));
        require(!arg1);
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        var_r = address((0x54 + (arg3 + 0x20)) >> 0x60);
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x54) {
        }
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        require(arg2);
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        var_r = address((0x54 + (arg3 + 0x20)) >> 0x60);
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "tag OOB");
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(uint32((0x54 + (arg3 + 0x20)) >> 0xe0) == 0x01, "pool OOB");
        require(0x18 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)), "pool OOB");
    }
    
    /// @custom:selector    0x1e1bff3f
    /// @custom:signature   Unresolved_1e1bff3f(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_1e1bff3f(address arg0, uint256 arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(address(arg0) - arg0);
        require(arg1 - arg1);
        require(!(msg.sender == (address(store_b))), "NA");
        address var_e = address(arg0);
        storage_map_c[var_e] = (bytes1(arg1)) | (uint248(storage_map_c[var_e]));
    }
    
    /// @custom:selector    0x10d1e85c
    /// @custom:signature   Unresolved_10d1e85c(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_10d1e85c(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x80);
        require(address(arg0) - arg0);
        require(arg3 > 0xffffffffffffffff);
        require(arg3 > 0xffffffffffffffff);
        require(msg.sender - (address(store_a)), "NA");
        require(msg.sender == (address(store_b)), "NA");
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        uint256 var_e = var_e + 0xa0;
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg3));
        require(arg3 > (arg3));
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg3) + 0x20) + (arg3 - (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - ((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg3) + 0x20)) < 0x20);
        require(0x54 > (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg3), "IIA");
        require(!arg1, "IIA");
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "IIA");
        require(arg1 < ((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + (arg3 + 0x20)), "IIA");
        require(!11 < 0);
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        address var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        require(11 < 0);
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(uint32((0x54 + (arg3 + 0x20)) >> 0xe0) == 0x01, "pool OOB");
        require(0x18 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)), "pool OOB");
        require(address((0x54 + (arg3 + 0x20)) >> 0x60) - address(this));
        require(!arg1);
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        var_r = address((0x54 + (arg3 + 0x20)) >> 0x60);
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x54) {
        }
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        require(arg2);
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        var_r = address((0x54 + (arg3 + 0x20)) >> 0x60);
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "tag OOB");
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(uint32((0x54 + (arg3 + 0x20)) >> 0xe0) == 0x01, "pool OOB");
        require(0x18 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)), "pool OOB");
    }
    
    /// @custom:selector    0xd76f529c
    /// @custom:signature   drain(address[] arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function drain(address[] arg0, address arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(address(arg1) - arg1);
        require(!(msg.sender == (address(store_b))), "NA");
        require(0 < (arg0));
        require(!0 < (arg0));
        require(address(0 + (arg0 + 0x20)) - (0 + (arg0 + 0x20)));
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).token0(); // staticcall
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).token1(); // staticcall
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).getReserves(); // staticcall
        require(0 == (0 == (address(arg1))));
        address var_b = address(this);
        (bool success, bytes memory ret0) = address(0).Unresolved_70a08231(var_b); // staticcall
        require(!0);
        var_b = address(0 + (arg0 + 0x20));
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_b); // call
        require(!address(0 + (arg0 + 0x20)).code.length);
        var_b = 0;
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).Unresolved_022c0d9f(var_b); // call
        require(((var_g + 0) > 0xffffffffffffffff) | ((var_g + 0) < var_g));
        uint256 var_g = var_g + 0;
        require((var_g - var_g) < 0);
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(var_g.length - var_g.length);
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(!0 + (0x26f3 * var_g.length));
        var_c = address(0 + (arg0 + 0x20));
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_c); // call
        require(!address(0 + (arg0 + 0x20)).code.length);
        var_c = 0;
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).Unresolved_022c0d9f(var_c); // call
        if (0x20 > ret0.length) {
        }
        var_b = address(this);
        (bool success, bytes memory ret0) = address(0).balanceOf(var_b); // staticcall
        require(!0);
        var_b = address(0 + (arg0 + 0x20));
        (bool success, bytes memory ret0) = address(0).many_msg_babbage(var_b); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        if (0x60 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
    }
    
    /// @custom:selector    0xb60c164c
    /// @custom:signature   Unresolved_b60c164c(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_b60c164c(uint256 arg0, address arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(!(msg.sender == (address(store_b))), "NA");
        require(0 < (arg0));
        require(!0 < (arg0));
        require(address(0 + (arg0 + 0x20)) - (0 + (arg0 + 0x20)));
        address var_b = address(this);
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).Unresolved_70a08231(var_b); // staticcall
        var_b = address(store_d);
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).Unresolved_a9059cbb(var_b); // call
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        uint256 var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        var_c = address(store_d);
        (bool success, bytes memory ret0) = address(0 + (arg0 + 0x20)).Unresolved_a9059cbb(var_c); // call
        if (0x20 > ret0.length) {
        }
    }
    
    /// @custom:selector    0x6199cdd3
    /// @custom:signature   Unresolved_6199cdd3(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_6199cdd3(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x80);
        require(address(arg0) - arg0);
        require(arg3 > 0xffffffffffffffff);
        require(arg3 > 0xffffffffffffffff);
        require(msg.sender - (address(store_a)), "NA");
        require(msg.sender == (address(store_b)), "NA");
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        uint256 var_e = var_e + 0xa0;
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg3));
        require(arg3 > (arg3));
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg3) + 0x20) + (arg3 - (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - ((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg3) + 0x20)) < 0x20);
        require(0x54 > (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg3), "IIA");
        require(!arg1, "IIA");
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "IIA");
        require(arg1 < ((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + (arg3 + 0x20)), "IIA");
        require(!11 < 0);
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        address var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        require(11 < 0);
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(uint32((0x54 + (arg3 + 0x20)) >> 0xe0) == 0x01, "pool OOB");
        require(0x18 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)), "pool OOB");
        require(address((0x54 + (arg3 + 0x20)) >> 0x60) - address(this));
        require(!arg1);
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        var_r = address((0x54 + (arg3 + 0x20)) >> 0x60);
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x54) {
        }
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        require(arg2);
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        var_r = address((0x54 + (arg3 + 0x20)) >> 0x60);
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "tag OOB");
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(uint32((0x54 + (arg3 + 0x20)) >> 0xe0) == 0x01, "pool OOB");
        require(0x18 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)), "pool OOB");
    }
    
    /// @custom:selector    0x9d851408
    /// @custom:signature   Unresolved_9d851408(uint256 arg0, uint256 arg1) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_9d851408(uint256 arg0, uint256 arg1) public view {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(arg1 - arg1);
        require(!(msg.sender == (address(store_b))), "NA");
        require(0 < (arg0));
        require(!0 < (arg0));
        require(address(0 + (arg0 + 0x20)) - (0 + (arg0 + 0x20)));
    }
    
    /// @custom:selector    0xab5898e8
    /// @custom:signature   Unresolved_ab5898e8(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_ab5898e8(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(block.number > arg1);
        address var_a = address(msg.sender);
        require(!bytes1(storage_map_e[var_a]));
        require(arg0 < 0x20);
        require(0 < (arg0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require(0 > 0x04);
        require(arg0 < 0x04);
        require(uint32(((arg0 + 0x20) + 0) >> 0xe0) - 0x01);
        require(((var_d + 0xa0) > 0xffffffffffffffff) | ((var_d + 0xa0) < var_d));
        uint256 var_d = var_d + 0xa0;
        (bool success, bytes memory ret0) = address(var_d.length).getReserves(); // staticcall
        require(!(11 > 0), "FR");
        require(!(0 < (uint112(var_k))), "FR");
        require(0 < (uint112(var_k)), "FR");
        require(!(0 < (uint112(var_o))), "FR");
        require(0 < (uint112(var_o)), "FR");
        require(0x60 > ret0.length);
        require(((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d));
        var_d = var_d + 0x60;
        require(((var_d + 0x60) - var_d) < 0x60);
        require(var_d.length - (uint112(var_d.length)));
        require(var_p - (uint112(var_p)));
        require(var_q - (uint32(var_q)));
        if (!11 > 0) {
        }
        require(((var_d + 0xa0) > 0xffffffffffffffff) | ((var_d + 0xa0) < var_d));
        var_d = var_d + 0xa0;
        (bool success, bytes memory ret0) = address(var_d.length).slot0(); // staticcall
        (bool success, bytes memory ret0) = address(var_d.length).liquidity(); // staticcall
        require(0 < (address(var_o)), "FR");
        require(!(var_p), "FR");
        require(0 < (address(var_r)), "FR");
        require(0 > (address(var_r)), "FR");
        require(0x20 > ret0.length);
        require(((var_d + 0x20) > 0xffffffffffffffff) | ((var_d + 0x20) < var_d));
        var_d = var_d + 0x20;
        require(((var_d + 0x20) - var_d) < 0x20);
        require(var_d.length - (address(var_d.length)));
        if (0xe0 > ret0.length) {
        }
    }
    
    /// @custom:selector    0x718da7ee
    /// @custom:signature   setReceiver(address arg0) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setReceiver(address arg0) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(address(arg0) - arg0);
        require(!(msg.sender == (address(store_b))), "NA");
        store_d = (uint96(store_d)) | (address(arg0));
        return ;
    }
    
    /// @custom:selector    0xb898e776
    /// @custom:signature   Unresolved_b898e776(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_b898e776(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x80);
        require(address(arg0) - arg0);
        require(arg3 > 0xffffffffffffffff);
        require(arg3 > 0xffffffffffffffff);
        require(msg.sender - (address(store_a)), "NA");
        require(msg.sender == (address(store_b)), "NA");
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        uint256 var_e = var_e + 0xa0;
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg3));
        require(arg3 > (arg3));
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg3) + 0x20) + (arg3 - (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - ((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg3) + 0x20)) < 0x20);
        require(0x54 > (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg3), "IIA");
        require(!arg1, "IIA");
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "IIA");
        require(arg1 < ((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + (arg3 + 0x20)), "IIA");
        require(!11 < 0);
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        address var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        require(11 < 0);
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(uint32((0x54 + (arg3 + 0x20)) >> 0xe0) == 0x01, "pool OOB");
        require(0x18 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)), "pool OOB");
        require(address((0x54 + (arg3 + 0x20)) >> 0x60) - address(this));
        require(!arg1);
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        var_r = address((0x54 + (arg3 + 0x20)) >> 0x60);
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x54) {
        }
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        require(arg2);
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        var_r = address((0x54 + (arg3 + 0x20)) >> 0x60);
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "tag OOB");
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(uint32((0x54 + (arg3 + 0x20)) >> 0xe0) == 0x01, "pool OOB");
        require(0x18 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)), "pool OOB");
    }
    
    /// @custom:selector    0x48c7e528
    /// @custom:signature   executor(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function executor(address arg0) public view returns (bool) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(address(arg0) - arg0);
        address var_a = address(arg0);
        return !(!bytes1(storage_map_e[var_a]));
    }
    
    /// @custom:selector    0x23a69e75
    /// @custom:signature   Unresolved_23a69e75(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, uint256 arg6) 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"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    function Unresolved_23a69e75(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, uint256 arg6) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x60);
        require(arg2 > 0xffffffffffffffff);
        require(arg2 > 0xffffffffffffffff);
        require(msg.sender - (address(store_a)), "NA");
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        require(!(arg2) > 0x20);
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg2));
        require(arg2 > (arg2));
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg2) + 0x20) + (arg2 - (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - ((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg2) + 0x20)) < 0x20);
        require(0x5d > (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg2), "IIA");
        require(!(arg0 < 0), "IIA");
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "IIA");
        require((0 - arg0) < ((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + (arg2 + 0x20)), "IIA");
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        uint256 var_e = var_e + 0xa0;
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require(!arg0 > 0);
        address var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(arg1 > 0);
        var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x54), "tag OOB");
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(!(uint32((0x5d + (arg2 + 0x20)) >> 0xe0)) == 0x01);
        require(0x54 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)));
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)));
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - 0x54) < 0x18);
        require(!(uint32((0x5d + (arg2 + 0x20)) >> 0xe0)) == 0x01);
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require(address(var_e.length) - msg.sender);
        require(0 == (11 > 0));
        require(!11 > 0);
        require(!address(var_e.length).code.length);
        var_r = 11;
        (bool success, bytes memory ret0) = address(var_e.length).Unresolved_022c0d9f(var_r); // call
        if (!11) {
        }
        require(((var_e + 0) > 0xffffffffffffffff) | ((var_e + 0) < var_e));
        var_e = var_e + 0;
        require((var_e - var_e) < 0);
        require(!(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - 0x54) < 0x04), "tag OOB");
        require(uint32((0x54 + (0x5d + (arg2 + 0x20))) >> 0xe0) - 0x01, "pool OOB");
        require(0x18 > ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - 0x54), "pool OOB");
        if (!(uint32((0x5d + (arg2 + 0x20)) >> 0xe0)) == 0x01) {
        }
        if (!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa3 + (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18) {
        }
        require(!arg0 > 0);
        require(arg2 == 0x20);
        address var_b = msg.sender;
        uint256 var_c = arg0;
        (bool success, bytes memory ret0) = address(0).transfer(var_b, var_c); // call
        if (0x20 > ret0.length) {
        }
        require(arg1 > 0);
        require(arg2 == 0x20);
        var_b = msg.sender;
        var_c = arg1;
        (bool success, bytes memory ret0) = address(0).transfer(var_b, var_c); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
    }
    
    /// @custom:selector    0x8da3aba3
    /// @custom:signature   skimEth() public payable
    function skimEth() public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        require(!(msg.sender == (address(store_b))), "NA");
        (bool success, bytes memory ret0) = address(store_d).transfer(address(this).balance);
        require(!ret0.length, "ETH transfer failed");
        if (ret0.length > 0xffffffffffffffff) {
            if (((var_g + (uint248((0x20 + (ret0.length + 0x1f)) + 0x1f))) > 0xffffffffffffffff) | ((var_g + (uint248((0x20 + (ret0.length + 0x1f)) + 0x1f))) < var_g)) {
            }
        }
    }
    
    /// @custom:selector    0x838a23ed
    /// @custom:signature   Unresolved_838a23ed(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_838a23ed(address arg0, uint256 arg1, uint256 arg2, uint256 arg3) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x80);
        require(address(arg0) - arg0);
        require(arg3 > 0xffffffffffffffff);
        require(arg3 > 0xffffffffffffffff);
        require(msg.sender - (address(store_a)), "NA");
        require(msg.sender == (address(store_b)), "NA");
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        uint256 var_e = var_e + 0xa0;
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        var_e = var_e + 0xa0;
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg3));
        require(arg3 > (arg3));
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg3) + 0x20) + (arg3 - (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) - ((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + ((0x04 + arg3) + 0x20)) < 0x20);
        require(0x54 > (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) > (arg3), "IIA");
        require(!arg1, "IIA");
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "IIA");
        require(arg1 < ((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) + (arg3 + 0x20)), "IIA");
        require(!11 < 0);
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        address var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        require(11 < 0);
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        var_r = msg.sender;
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(uint32((0x54 + (arg3 + 0x20)) >> 0xe0) == 0x01, "pool OOB");
        require(0x18 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)), "pool OOB");
        require(address((0x54 + (arg3 + 0x20)) >> 0x60) - address(this));
        require(!arg1);
        (bool success, bytes memory ret0) = address(msg.sender).token0(); // staticcall
        var_r = address((0x54 + (arg3 + 0x20)) >> 0x60);
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x54) {
        }
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(var_e.length - var_e.length);
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        require(arg2);
        (bool success, bytes memory ret0) = address(msg.sender).token1(); // staticcall
        var_r = address((0x54 + (arg3 + 0x20)) >> 0x60);
        (bool success, bytes memory ret0) = address(0).Unresolved_a9059cbb(var_r); // call
        if (0x20 > ret0.length) {
        }
        if (0x20 > ret0.length) {
        }
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x18), "tag OOB");
        require(!(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < 0x04), "tag OOB");
        require(uint32((0x54 + (arg3 + 0x20)) >> 0xe0) == 0x01, "pool OOB");
        require(0x18 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffac + (arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)), "pool OOB");
    }
}

ABI

[
  {
    "type": "function",
    "name": "Unresolved_10d1e85c",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_1e1bff3f",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_23a69e75",
    "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"
      },
      {
        "name": "arg6",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_40df7b57",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_6199cdd3",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_838a23ed",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_84800812",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_84cee21c",
    "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"
      },
      {
        "name": "arg6",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_9d851408",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_ab5898e8",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_b60c164c",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_b898e776",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_cf72af38",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "drain",
    "inputs": [
      {
        "name": "arg0",
        "type": "address[]"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "executor",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "setReceiver",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "skimEth",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  }
]

UNKNOWN SELECTORS (11)

0x48c7e528	unknown
0x6199cdd3	unknown
0xd76f529c	unknown
0xb898e776	unknown
0x838a23ed	unknown
0x40df7b57	unknown
0xcf72af38	unknown
0x9d851408	unknown
0x84cee21c	unknown
0xab5898e8	unknown
0x8da3aba3	unknown

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)

0x9cfb6c0721eebd197514daad9e06d0263608263b

DECOMPILED SOLIDITY (Heimdall) VERIFY

ABI

UNKNOWN SELECTORS (11)

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)

DECOMPILED SOLIDITY (Heimdall)