0xb9960d9bca016e9748be75dd52f02188b9d0829f

DECOMPILED SOLIDITY (Heimdall) VERIFY

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

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

contract DecompiledContract {
    uint256 public constant unresolved_c45a0155 = 1206234914267266553517356379090733284012541281362;
    uint256 public constant WETH = 1097077688018008265106216665536940668749033598146;
    
    
    /// @custom:selector    0x791ac947
    /// @custom:signature   swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public {
        require(!arg2 > 0x0100000000);
        require(!(arg4 < block.timestamp), "TransferHelper: TRANSFER_FROM_FAILED");
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address((0x20 * (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg2))) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "TransferHelper: TRANSFER_FROM_FAILED");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0x01 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(address(0 + (0x20 + (arg2))) == (address(0x20 + (0x20 + (arg2))))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))) < (address(0x20 + (0x20 + (arg2)))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))), "TransferHelper: TRANSFER_FROM_FAILED");
        uint256 var_d = var_d + 0x48;
        var_d = var_d + 0xbd;
        var_d = var_d + 0x84;
        require(var_d.length < 0x20, "TransferHelper: TRANSFER_FROM_FAILED");
        (bool success, bytes memory ret0) = address(0 + (0x20 + (arg2))).{ value: 0 ether }adfepixw(); // call
        require(ret0.length == 0, "TransferHelper: TRANSFER_FROM_FAILED");
        var_d = var_d + (0x20 + (0x20 * (arg2)));
        var_h = msg.data[36:36];
        require(!0 < (var_d.length - 0x01));
        address var_s = address(this);
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).Unresolved_70a08231(var_s); // staticcall
        require(!(ret0.length < 0x20), "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require(!(var_d.length < arg1), "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        var_s = var_d.length;
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).{ value: 0 ether }Unresolved_2e1a7d4d(var_s); // call
        var_d = var_d + 0x20;
        require(var_d.length < 0x20, "TransferHelper: ETH_TRANSFER_FAILED");
        require((var_d.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < 0x20, "TransferHelper: ETH_TRANSFER_FAILED");
        (bool success, bytes memory ret0) = address(arg3).transfer(var_d.length);
        require(ret0.length == 0, "TransferHelper: ETH_TRANSFER_FAILED");
        require(!var_ab);
        require(!var_ab < 0x20);
        var_d = var_d + (uint248(ret0.length + 0x3f));
        require(!var_d.length, "TransferHelper: TRANSFER_FROM_FAILED");
        require(!var_d.length, "TransferHelper: TRANSFER_FROM_FAILED");
        var_af = var_af;
        var_af = var_af;
    }
    
    /// @custom:selector    0xb6f9de95
    /// @custom:signature   swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 arg0, address[] arg1, address arg2, uint256 arg3) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 arg0, address[] arg1, address arg2, uint256 arg3) public payable {
        require(!arg1 > 0x0100000000);
        require(!arg3 < block.timestamp);
        require(0 < (arg1));
        require(address(0 + (0x20 + (arg1))) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2);
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).{ value: msg.value }deposit(); // call
        require(0 < (arg1));
        require(0x01 < (arg1));
        require(!(address(0 + (0x20 + (arg1)))) == (address(0x20 + (0x20 + (arg1)))));
        require(address(0 + (0x20 + (arg1))) < (address(0x20 + (0x20 + (arg1)))));
        require(address(0 + (0x20 + (arg1))));
        uint256 var_d = var_d + 0x48;
        var_d = var_d + 0xbd;
        address var_l = address(keccak256(var_h));
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).{ value: 0 ether }Unresolved_a9059cbb(var_l); // call
        require(!ret0.length < 0x20);
        require(var_d.length);
        require((arg1 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg1));
        var_l = address(arg2);
        require(address((0x20 * (arg1 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg1))).code.length);
        (bool success, bytes memory ret0) = address((0x20 * (arg1 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg1))).Unresolved_70a08231(var_l); // staticcall
        require(!ret0.length < 0x20);
        var_d = 0x20 + ((0x20 * (arg1)) + var_d);
        require(!0 < (var_d.length - 0x01));
        require((arg1 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg1));
        var_m = address(arg2);
        require(address((0x20 * (arg1 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg1))).code.length);
        (bool success, bytes memory ret0) = address((0x20 * (arg1 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg1))).Unresolved_70a08231(var_m); // staticcall
        require(!(ret0.length < 0x20), "ds-math-sub-underflow");
        require(!((var_d.length - var_d.length) > var_d.length), "ds-math-sub-underflow");
        require(!((var_d.length - var_d.length) < arg0), "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        var_v = var_v;
        var_v = var_v;
    }
    
    /// @custom:selector    0xded9382a
    /// @custom:signature   Unresolved_ded9382a(address arg0, uint256 arg1, uint256 arg2, uint256 arg3, address arg4, uint256 arg5, uint256 arg6, bool arg7, uint256 arg8, uint256 arg9) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    /// @param              arg7 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg8 ["uint256", "bytes32", "int256"]
    /// @param              arg9 ["uint256", "bytes32", "int256"]
    function Unresolved_ded9382a(address arg0, uint256 arg1, uint256 arg2, uint256 arg3, address arg4, uint256 arg5, uint256 arg6, bool arg7, uint256 arg8, uint256 arg9) public {
        require(!(address(arg0) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(address(arg0) < 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        uint256 var_c = var_c + 0x48;
        var_c = var_c + 0xbd;
        require(arg6);
        address var_p = msg.sender;
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_d505accf(var_p); // call
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(address(arg0) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(address(arg0) < 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        var_c = var_c + 0x48;
        var_c = var_c + 0xbd;
        uint256 var_ae = msg.sender;
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_23b872dd(var_ae); // call
        require(!ret0.length < 0x20);
        var_ae = address(this);
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_89afcb44(var_ae); // call
        require(!ret0.length < 0x40);
        require(address(arg0), "DXswapLibrary: ZERO_ADDRESS");
        var_ah = var_ah;
        var_ah = var_ah;
        var_p = msg.sender;
        var_q = address(this);
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_d505accf(var_p, var_q); // call
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(address(arg0) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(address(arg0) < 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(address(arg0), "DXswapLibrary: ZERO_ADDRESS");
        var_ah = var_ah;
        var_ah = var_ah;
    }
    
    /// @custom:selector    0xbaa2abde
    /// @custom:signature   removeLiquidity(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, address arg5, uint256 arg6) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    function removeLiquidity(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, address arg5, uint256 arg6) public {
        require(!arg6 < block.timestamp);
        require(!(address(arg0)) == (address(arg1)));
        require(address(arg0) < (address(arg1)));
        require(address(arg0));
        uint256 var_d = var_d + 0x48;
        var_d = var_d + 0xbd;
        address var_l = msg.sender;
        require(address(keccak256(var_h)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_h)).{ value: 0 ether }Unresolved_23b872dd(var_l); // call
        require(!ret0.length < 0x20);
        var_l = address(arg5);
        require(address(keccak256(var_h)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_h)).{ value: 0 ether }Unresolved_89afcb44(var_l); // call
        require(!ret0.length < 0x40);
        var_s = var_s;
    }
    
    /// @custom:selector    0x571fd012
    /// @custom:signature   getAmountIn(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function getAmountIn(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3) public pure {
        require(arg0 > 0, "ds-math-mul-overflow");
        require(!(arg1 > 0), "ds-math-mul-overflow");
        require(arg2 > 0, "ds-math-mul-overflow");
        require(!arg0, "ds-math-mul-overflow");
        require(arg0, "ds-math-mul-overflow");
        require(((arg1 * arg0) / arg0) == arg1, "ds-math-mul-overflow");
    }
    
    /// @custom:selector    0x18cbafe5
    /// @custom:signature   swapExactTokensForETH(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function swapExactTokensForETH(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public returns (bytes memory) {
        require(!arg2 > 0x0100000000);
        require(!arg4 < block.timestamp);
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg2));
        require(address((0x20 * (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg2))) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2);
        uint256 var_a = var_a + (0x20 + (0x20 * (arg2)));
        uint256 var_b = (arg2);
        require(!var_a.length < 0x02);
        require(!var_a.length > 0xffffffffffffffff);
        var_a = var_a + (0x20 + (0x20 * var_a.length));
        require(!var_a.length, "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        var_c = msg.data[4:4];
        require(!(0 < (var_a.length - 0x01)), "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require((var_a.length - 0x01) < var_a.length, "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require(!(var_f < arg1), "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0x01 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(address(0 + (0x20 + (arg2))) == (address(0x20 + (0x20 + (arg2))))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))) < (address(0x20 + (0x20 + (arg2)))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))), "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        var_a = var_a + 0x84;
        require(var_a.length < 0x20, "TransferHelper: TRANSFER_FROM_FAILED");
        (bool success, bytes memory ret0) = address(0 + (0x20 + (arg2))).{ value: 0 ether }adfepixw(); // call
        require(ret0.length == 0, "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + (0x20 + (0x20 * (arg2)));
        var_c = msg.data[36:36];
        require(!0 < (var_a.length - 0x01));
        require((var_a.length - 0x01) < var_a.length);
        var_y = var_f;
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).{ value: 0 ether }Unresolved_2e1a7d4d(var_y); // call
        require((var_a.length - 0x01) < var_a.length, "TransferHelper: ETH_TRANSFER_FAILED");
        var_a = var_a + 0x20;
        require(var_a.length < 0x20, "TransferHelper: ETH_TRANSFER_FAILED");
        require((var_a.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < 0x20, "TransferHelper: ETH_TRANSFER_FAILED");
        (bool success, bytes memory ret0) = address(arg3).transfer(var_f);
        require(ret0.length == 0, "TransferHelper: ETH_TRANSFER_FAILED");
        require(!(0 < (var_a.length * 0x20)), "TransferHelper: TRANSFER_FROM_FAILED");
        return abi.encodePacked(0x20, var_a.length);
        require(!var_ag, "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(var_ag < 0x20), "TransferHelper: TRANSFER_FROM_FAILED");
        require(var_b, "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + (uint248(ret0.length + 0x3f));
        if (!var_a.length) {
        }
        require(!(address(var_c)) == (address(var_ai)));
        require(address(var_c) < (address(var_ai)));
        require(address(var_c));
        require(!(address(var_c)) == (address(var_ai)));
        require(address(var_c) < (address(var_ai)));
        require(address(var_c));
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        require(address(keccak256(var_c)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_c)).getReserves(); // staticcall
        require(!ret0.length < 0x60);
        require(address(var_c) == (address(var_c)));
        var_al = var_al;
        var_al = var_al;
    }
    
    /// @custom:selector    0x8803dbee
    /// @custom:signature   swapTokensForExactTokens(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function swapTokensForExactTokens(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public returns (bytes memory) {
        require(!arg2 > 0x0100000000);
        require(!arg4 < block.timestamp);
        uint256 var_a = var_a + (0x20 + (0x20 * (arg2)));
        uint256 var_b = (arg2);
        require(!var_a.length < 0x02);
        require(!var_a.length > 0xffffffffffffffff);
        var_a = var_a + (0x20 + (0x20 * var_a.length));
        require(!var_a.length, "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        var_c = msg.data[4:4];
        require((var_a.length - 0x01) < var_a.length, "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        require(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length), "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        require(!(var_c > arg1), "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0x01 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(address(0 + (0x20 + (arg2))) == (address(0x20 + (0x20 + (arg2))))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))) < (address(0x20 + (0x20 + (arg2)))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))), "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        var_a = var_a + 0x84;
        require(var_a.length < 0x20, "TransferHelper: TRANSFER_FROM_FAILED");
        (bool success, bytes memory ret0) = address(0 + (0x20 + (arg2))).{ value: 0 ether }adfepixw(); // call
        require(ret0.length == 0, "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + (0x20 + (0x20 * (arg2)));
        var_c = msg.data[36:36];
        require(!(0 < (var_a.length - 0x01)), "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(0 < (var_a.length * 0x20)), "TransferHelper: TRANSFER_FROM_FAILED");
        return abi.encodePacked(0x20, var_a.length);
        require(!var_aa, "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(var_aa < 0x20), "TransferHelper: TRANSFER_FROM_FAILED");
        require(var_b, "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + (uint248(ret0.length + 0x3f));
        if (!var_a.length) {
        }
        require(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) - 0x01) < var_a.length);
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        require(!(address(var_ae)) == (address(var_af)));
        require(address(var_ae) < (address(var_af)));
        require(address(var_ae));
        require(!(address(var_ae)) == (address(var_af)));
        require(address(var_ae) < (address(var_af)));
        require(address(var_ae));
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        require(address(keccak256(var_c)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_c)).getReserves(); // staticcall
        require(!ret0.length < 0x60);
        require(address(var_ae) == (address(var_ae)));
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        require(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) - 0x01) < var_a.length);
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        var_ai = var_ai;
    }
    
    /// @custom:selector    0x52707d8c
    /// @custom:signature   getAmountOut(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3) public pure returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function getAmountOut(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3) public pure returns (uint256) {
        require(arg0 > 0, "ds-math-sub-underflow");
        require(!(arg1 > 0), "ds-math-sub-underflow");
        require(arg2 > 0, "ds-math-sub-underflow");
        require(!((0x2710 - arg3) > 0x2710), "ds-math-sub-underflow");
        require(!(0x2710 - arg3), "ds-math-mul-overflow");
        require(!(0x2710 - arg3), "ds-math-mul-overflow");
        require(!arg2, "ds-math-mul-overflow");
        require(arg2, "ds-math-mul-overflow");
        require(((0 * arg2) / arg2) == 0, "ds-math-mul-overflow");
        require(!0x2710, "ds-math-add-overflow");
        require(!0x2710, "ds-math-add-overflow");
        require(!(0 < 0), "ds-math-add-overflow");
        require(0, "ds-math-mul-overflow");
        return (0 * arg2) / 0;
        require(0x2710, "ds-math-mul-overflow");
        require(((arg1 * 0x2710) / 0x2710) == arg1, "ds-math-mul-overflow");
    }
    
    /// @custom:selector    0x5b0d5984
    /// @custom:signature   Unresolved_5b0d5984(address arg0, uint256 arg1, uint256 arg2, uint256 arg3, address arg4, uint256 arg5, uint256 arg6, bool arg7, uint256 arg8, uint256 arg9) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    /// @param              arg7 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg8 ["uint256", "bytes32", "int256"]
    /// @param              arg9 ["uint256", "bytes32", "int256"]
    function Unresolved_5b0d5984(address arg0, uint256 arg1, uint256 arg2, uint256 arg3, address arg4, uint256 arg5, uint256 arg6, bool arg7, uint256 arg8, uint256 arg9) public {
        require(!(address(arg0) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(address(arg0) < 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        uint256 var_c = var_c + 0x48;
        var_c = var_c + 0xbd;
        require(arg6);
        address var_p = msg.sender;
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_d505accf(var_p); // call
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(address(arg0) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(address(arg0) < 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        var_c = var_c + 0x48;
        var_c = var_c + 0xbd;
        uint256 var_ae = msg.sender;
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_23b872dd(var_ae); // call
        require(!ret0.length < 0x20);
        var_ae = address(this);
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_89afcb44(var_ae); // call
        require(!ret0.length < 0x40);
        require(address(arg0), "DXswapLibrary: ZERO_ADDRESS");
        var_ah = var_ah;
        var_ah = var_ah;
        var_p = msg.sender;
        var_q = address(this);
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_d505accf(var_p, var_q); // call
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(address(arg0) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(address(arg0) < 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(address(arg0), "DXswapLibrary: ZERO_ADDRESS");
        var_ah = var_ah;
        var_ah = var_ah;
    }
    
    /// @custom:selector    0xe8e33700
    /// @custom:signature   addLiquidity(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, address arg6, uint256 arg7) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg7 ["uint256", "bytes32", "int256"]
    function addLiquidity(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, address arg6, uint256 arg7) public {
        require(!arg7 < block.timestamp);
        address var_b = address(arg0);
        require(address(0xd34971bab6e5e356fd250715f5de0492bb070452).code.length);
        (bool success, bytes memory ret0) = address(0xd34971bab6e5e356fd250715f5de0492bb070452).Unresolved_e6a43905(var_b); // staticcall
        require(!(ret0.length < 0x20), "DXswapLibrary: ZERO_ADDRESS");
        require(!(address(var_d.length) == 0), "DXswapLibrary: ZERO_ADDRESS");
        require(!(address(arg0) == (address(arg1))), "DXswapLibrary: ZERO_ADDRESS");
        require(address(arg0) < (address(arg1)), "DXswapLibrary: ZERO_ADDRESS");
        require(address(arg0), "DXswapLibrary: ZERO_ADDRESS");
        var_b = address(arg0);
        require(address(0xd34971bab6e5e356fd250715f5de0492bb070452).code.length);
        (bool success, bytes memory ret0) = address(0xd34971bab6e5e356fd250715f5de0492bb070452).{ value: 0 ether }Unresolved_c9c65396(var_b); // call
        require(!ret0.length < 0x20);
        var_g = var_g;
    }
    
    /// @custom:selector    0x1f00ca74
    /// @custom:signature   getAmountsIn(uint256 arg0, address[] arg1) public returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function getAmountsIn(uint256 arg0, address[] arg1) public returns (bytes memory) {
        require(!arg1 > 0x0100000000);
        uint256 var_a = var_a + (0x20 + (0x20 * (arg1)));
        require(!var_a.length < 0x02);
        require(!var_a.length > 0xffffffffffffffff);
        var_a = var_a + (0x20 + (0x20 * var_a.length));
        require(!var_a.length);
        var_c = msg.data[4:4];
        require((var_a.length - 0x01) < var_a.length);
        require(!0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length);
        require(!0 < (var_a.length * 0x20));
        return abi.encodePacked(0x20, var_a.length);
        require(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) - 0x01) < var_a.length);
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        require(!(address(var_g)) == (address(var_h)));
        require(address(var_g) < (address(var_h)));
        require(address(var_g));
        require(!(address(var_g)) == (address(var_h)));
        require(address(var_g) < (address(var_h)));
        require(address(var_g));
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        require(address(keccak256(var_c)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_c)).getReserves(); // staticcall
        require(!ret0.length < 0x60);
        require(address(var_g) == (address(var_g)));
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        require(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) - 0x01) < var_a.length);
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
    }
    
    /// @custom:selector    0xad615dec
    /// @custom:signature   quote(uint256 arg0, uint256 arg1, uint256 arg2) public pure returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function quote(uint256 arg0, uint256 arg1, uint256 arg2) public pure returns (uint256) {
        require(arg0 > 0, "ds-math-mul-overflow");
        require(!(arg1 > 0), "ds-math-mul-overflow");
        require(arg2 > 0, "ds-math-mul-overflow");
        require(!arg2, "ds-math-mul-overflow");
        require(arg2, "ds-math-mul-overflow");
        require(((arg0 * arg2) / arg2) == arg0, "ds-math-mul-overflow");
        require(arg1, "ds-math-mul-overflow");
        return (arg0 * arg2) / arg1;
        require(!arg2, "ds-math-mul-overflow");
        require(arg1, "DXswapLibrary: INSUFFICIENT_LIQUIDITY");
        return 0 / arg1;
    }
    
    /// @custom:selector    0xf305d719
    /// @custom:signature   addLiquidityETH(address arg0, uint256 arg1, uint256 arg2, uint256 arg3, address arg4, uint256 arg5) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function addLiquidityETH(address arg0, uint256 arg1, uint256 arg2, uint256 arg3, address arg4, uint256 arg5) public payable {
        require(!arg5 < block.timestamp);
        address var_b = address(arg0);
        require(address(0xd34971bab6e5e356fd250715f5de0492bb070452).code.length);
        (bool success, bytes memory ret0) = address(0xd34971bab6e5e356fd250715f5de0492bb070452).Unresolved_e6a43905(var_b); // staticcall
        require(!(ret0.length < 0x20), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(address(var_d.length) == 0), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(address(arg0) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(address(arg0) < 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(address(arg0), "DXswapLibrary: ZERO_ADDRESS");
        var_b = address(arg0);
        require(address(0xd34971bab6e5e356fd250715f5de0492bb070452).code.length);
        (bool success, bytes memory ret0) = address(0xd34971bab6e5e356fd250715f5de0492bb070452).{ value: 0 ether }Unresolved_c9c65396(var_b); // call
        require(!ret0.length < 0x20);
        var_g = var_g;
    }
    
    /// @custom:selector    0xfb3bdb41
    /// @custom:signature   swapETHForExactTokens(uint256 arg0, address[] arg1, address arg2, uint256 arg3) public payable returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function swapETHForExactTokens(uint256 arg0, address[] arg1, address arg2, uint256 arg3) public payable returns (bytes memory) {
        require(!arg1 > 0x0100000000);
        require(!arg3 < block.timestamp);
        require(0 < (arg1));
        require(address(0 + (0x20 + (arg1))) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2);
        uint256 var_a = var_a + (0x20 + (0x20 * (arg1)));
        require(!var_a.length < 0x02);
        require(!var_a.length > 0xffffffffffffffff);
        var_a = var_a + (0x20 + (0x20 * var_a.length));
        require(!var_a.length, "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        var_c = msg.data[4:4];
        require((var_a.length - 0x01) < var_a.length, "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        require(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length), "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        require(!(var_c > msg.value), "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).{ value: var_c }deposit(); // call
        require(0 < (arg1));
        require(0x01 < (arg1));
        require(!(address(0 + (0x20 + (arg1)))) == (address(0x20 + (0x20 + (arg1)))));
        require(address(0 + (0x20 + (arg1))) < (address(0x20 + (0x20 + (arg1)))));
        require(address(0 + (0x20 + (arg1))));
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        address var_q = address(keccak256(var_c));
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).{ value: 0 ether }Unresolved_a9059cbb(var_q); // call
        require(!(ret0.length < 0x20), "TransferHelper: ETH_TRANSFER_FAILED");
        require(var_a.length, "TransferHelper: ETH_TRANSFER_FAILED");
        var_a = var_a + (0x20 + (0x20 * (arg1)));
        var_c = msg.data[36:36];
        require(!(0 < (var_a.length - 0x01)), "TransferHelper: ETH_TRANSFER_FAILED");
        require(!(msg.value > (var_c)), "TransferHelper: ETH_TRANSFER_FAILED");
        var_a = var_a + 0x20;
        require(var_a.length < 0x20, "TransferHelper: ETH_TRANSFER_FAILED");
        require((var_a.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < 0x20, "TransferHelper: ETH_TRANSFER_FAILED");
        (bool success, bytes memory ret0) = address(msg.sender).transfer(msg.value - (var_c));
        require(ret0.length == 0, "TransferHelper: ETH_TRANSFER_FAILED");
        require(!0 < (var_a.length * 0x20));
        return abi.encodePacked(0x20, var_a.length);
        require(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) - 0x01) < var_a.length);
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        require(!(address(var_aa)) == (address(var_ab)));
        require(address(var_aa) < (address(var_ab)));
        require(address(var_aa));
        require(!(address(var_aa)) == (address(var_ab)));
        require(address(var_aa) < (address(var_ab)));
        require(address(var_aa));
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        require(address(keccak256(var_c)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_c)).getReserves(); // staticcall
        require(!ret0.length < 0x60);
        require(address(var_aa) == (address(var_aa)));
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        require(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) - 0x01) < var_a.length);
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        var_ae = var_ae;
        var_ae = var_ae;
    }
    
    /// @custom:selector    0x02751cec
    /// @custom:signature   removeLiquidityETH(address arg0, uint256 arg1, uint256 arg2, uint256 arg3, address arg4, uint256 arg5) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function removeLiquidityETH(address arg0, uint256 arg1, uint256 arg2, uint256 arg3, address arg4, uint256 arg5) public {
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(address(arg0) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(address(arg0) < 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        uint256 var_c = var_c + 0x48;
        address var_p = msg.sender;
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_23b872dd(var_p); // call
        require(!ret0.length < 0x20);
        var_p = address(this);
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_89afcb44(var_p); // call
        require(!ret0.length < 0x40);
        require(address(arg0), "DXswapLibrary: ZERO_ADDRESS");
        var_s = var_s;
        var_s = var_s;
    }
    
    /// @custom:selector    0xd06ca61f
    /// @custom:signature   getAmountsOut(uint256 arg0, address[] arg1) public returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function getAmountsOut(uint256 arg0, address[] arg1) public returns (bytes memory) {
        require(!arg1 > 0x0100000000);
        uint256 var_a = var_a + (0x20 + (0x20 * (arg1)));
        require(!var_a.length < 0x02);
        require(!var_a.length > 0xffffffffffffffff);
        var_a = var_a + (0x20 + (0x20 * var_a.length));
        require(!var_a.length);
        var_c = msg.data[4:4];
        require(!0 < (var_a.length - 0x01));
        require(!0 < (var_a.length * 0x20));
        return abi.encodePacked(0x20, var_a.length);
        require(!(address(var_c)) == (address(var_g)));
        require(address(var_c) < (address(var_g)));
        require(address(var_c));
        require(!(address(var_c)) == (address(var_g)));
        require(address(var_c) < (address(var_g)));
        require(address(var_c));
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        require(address(keccak256(var_c)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_c)).getReserves(); // staticcall
        require(!ret0.length < 0x60);
        require(address(var_c) == (address(var_c)));
    }
    
    /// @custom:selector    0x2195995c
    /// @custom:signature   Unresolved_2195995c(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, address arg5, uint256 arg6, uint256 arg7, bool arg8, uint256 arg9, uint256 arg10) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    /// @param              arg7 ["uint256", "bytes32", "int256"]
    /// @param              arg8 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg9 ["uint256", "bytes32", "int256"]
    /// @param              arg10 ["uint256", "bytes32", "int256"]
    function Unresolved_2195995c(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, address arg5, uint256 arg6, uint256 arg7, bool arg8, uint256 arg9, uint256 arg10) public {
        require(!(address(arg0)) == (address(arg1)));
        require(address(arg0) < (address(arg1)));
        require(address(arg0));
        uint256 var_d = var_d + 0x48;
        var_d = var_d + 0xbd;
        require(arg7);
        address var_l = msg.sender;
        require(address(keccak256(var_h)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_h)).{ value: 0 ether }Unresolved_d505accf(var_l); // call
        require(!arg6 < block.timestamp);
        require(!(address(arg0)) == (address(arg1)));
        require(address(arg0) < (address(arg1)));
        require(address(arg0));
        var_d = var_d + 0x48;
        var_d = var_d + 0xbd;
        address var_aa = msg.sender;
        require(address(keccak256(var_h)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_h)).{ value: 0 ether }Unresolved_23b872dd(var_aa); // call
        require(!ret0.length < 0x20);
        var_aa = address(arg5);
        require(address(keccak256(var_h)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_h)).{ value: 0 ether }Unresolved_89afcb44(var_aa); // call
        require(!ret0.length < 0x40);
        var_ae = var_ae;
        var_l = msg.sender;
        var_m = address(this);
        require(address(keccak256(var_h)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_h)).{ value: 0 ether }Unresolved_d505accf(var_l, var_m); // call
        if (!arg6 < block.timestamp) {
            require(!(arg6 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
            require(!(address(arg0) == (address(arg1))), "DXswapLibrary: IDENTICAL_ADDRESSES");
        }
        var_ae = var_ae;
    }
    
    /// @custom:selector    0x38ed1739
    /// @custom:signature   swapExactTokensForTokens(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function swapExactTokensForTokens(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public returns (bytes memory) {
        require(!arg2 > 0x0100000000);
        require(!arg4 < block.timestamp);
        uint256 var_a = var_a + (0x20 + (0x20 * (arg2)));
        uint256 var_b = (arg2);
        require(!var_a.length < 0x02);
        require(!var_a.length > 0xffffffffffffffff);
        var_a = var_a + (0x20 + (0x20 * var_a.length));
        require(!var_a.length, "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        var_c = msg.data[4:4];
        require(!(0 < (var_a.length - 0x01)), "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require((var_a.length - 0x01) < var_a.length, "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require(!(var_f < arg1), "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0x01 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(address(0 + (0x20 + (arg2))) == (address(0x20 + (0x20 + (arg2))))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))) < (address(0x20 + (0x20 + (arg2)))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))), "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        var_a = var_a + 0x84;
        require(var_a.length < 0x20, "TransferHelper: TRANSFER_FROM_FAILED");
        (bool success, bytes memory ret0) = address(0 + (0x20 + (arg2))).{ value: 0 ether }adfepixw(); // call
        require(ret0.length == 0, "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + (0x20 + (0x20 * (arg2)));
        var_c = msg.data[36:36];
        require(!(0 < (var_a.length - 0x01)), "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(0 < (var_a.length * 0x20)), "TransferHelper: TRANSFER_FROM_FAILED");
        return abi.encodePacked(0x20, var_a.length);
        require(!var_ab, "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(var_ab < 0x20), "TransferHelper: TRANSFER_FROM_FAILED");
        require(var_b, "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + (uint248(ret0.length + 0x3f));
        if (!var_a.length) {
        }
        require(!(address(var_c)) == (address(var_af)));
        require(address(var_c) < (address(var_af)));
        require(address(var_c));
        require(!(address(var_c)) == (address(var_af)));
        require(address(var_c) < (address(var_af)));
        require(address(var_c));
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        require(address(keccak256(var_c)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_c)).getReserves(); // staticcall
        require(!ret0.length < 0x60);
        require(address(var_c) == (address(var_c)));
        var_ai = var_ai;
    }
    
    /// @custom:selector    0x5c11d795
    /// @custom:signature   swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public {
        require(!arg2 > 0x0100000000);
        require(!(arg4 < block.timestamp), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0x01 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(address(0 + (0x20 + (arg2))) == (address(0x20 + (0x20 + (arg2))))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))) < (address(0x20 + (0x20 + (arg2)))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))), "TransferHelper: TRANSFER_FROM_FAILED");
        uint256 var_d = var_d + 0x48;
        var_d = var_d + 0xbd;
        var_d = var_d + 0x84;
        require(var_d.length < 0x20, "TransferHelper: TRANSFER_FROM_FAILED");
        (bool success, bytes memory ret0) = address(0 + (0x20 + (arg2))).{ value: 0 ether }adfepixw(); // call
        require(ret0.length == 0, "TransferHelper: TRANSFER_FROM_FAILED");
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg2));
        var_r = address(arg3);
        require(address((0x20 * (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg2))).code.length);
        (bool success, bytes memory ret0) = address((0x20 * (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg2))).Unresolved_70a08231(var_r); // staticcall
        require(!ret0.length < 0x20);
        var_d = 0x20 + ((0x20 * (arg2)) + var_d);
        require(!0 < (var_d.length - 0x01));
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg2));
        address var_s = address(arg3);
        require(address((0x20 * (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg2))).code.length);
        (bool success, bytes memory ret0) = address((0x20 * (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg2))).Unresolved_70a08231(var_s); // staticcall
        require(!(ret0.length < 0x20), "ds-math-sub-underflow");
        require(!((var_d.length - var_d.length) > var_d.length), "ds-math-sub-underflow");
        require(!((var_d.length - var_d.length) < arg1), "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require(!var_x);
        require(!var_x < 0x20);
        var_d = var_d + (uint248(ret0.length + 0x3f));
        require(!var_d.length, "TransferHelper: TRANSFER_FROM_FAILED");
        require(!var_d.length, "TransferHelper: TRANSFER_FROM_FAILED");
        var_ac = var_ac;
    }
    
    /// @custom:selector    0x7ff36ab5
    /// @custom:signature   swapExactETHForTokens(uint256 arg0, address[] arg1, address arg2, uint256 arg3) public payable returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function swapExactETHForTokens(uint256 arg0, address[] arg1, address arg2, uint256 arg3) public payable returns (bytes memory) {
        require(!arg1 > 0x0100000000);
        require(!arg3 < block.timestamp);
        require(0 < (arg1));
        require(address(0 + (0x20 + (arg1))) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2);
        uint256 var_a = var_a + (0x20 + (0x20 * (arg1)));
        require(!var_a.length < 0x02);
        require(!var_a.length > 0xffffffffffffffff);
        var_a = var_a + (0x20 + (0x20 * var_a.length));
        require(!var_a.length, "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        var_c = msg.data[4:4];
        require(!(0 < (var_a.length - 0x01)), "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require((var_a.length - 0x01) < var_a.length, "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require(!(var_f < arg0), "DXswapRouter: INSUFFICIENT_OUTPUT_AMOUNT");
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).{ value: var_c }deposit(); // call
        require(0 < (arg1));
        require(0x01 < (arg1));
        require(!(address(0 + (0x20 + (arg1)))) == (address(0x20 + (0x20 + (arg1)))));
        require(address(0 + (0x20 + (arg1))) < (address(0x20 + (0x20 + (arg1)))));
        require(address(0 + (0x20 + (arg1))));
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        address var_r = address(keccak256(var_c));
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).{ value: 0 ether }Unresolved_a9059cbb(var_r); // call
        require(!ret0.length < 0x20);
        require(var_a.length);
        var_a = var_a + (0x20 + (0x20 * (arg1)));
        var_c = msg.data[36:36];
        require(!0 < (var_a.length - 0x01));
        require(!0 < (var_a.length * 0x20));
        return abi.encodePacked(0x20, var_a.length);
        require(!(address(var_c)) == (address(var_w)));
        require(address(var_c) < (address(var_w)));
        require(address(var_c));
        require(!(address(var_c)) == (address(var_w)));
        require(address(var_c) < (address(var_w)));
        require(address(var_c));
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        require(address(keccak256(var_c)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_c)).getReserves(); // staticcall
        require(!ret0.length < 0x60);
        require(address(var_c) == (address(var_c)));
        var_z = var_z;
        var_z = var_z;
    }
    
    /// @custom:selector    0x4a25d94a
    /// @custom:signature   swapTokensForExactETH(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function swapTokensForExactETH(uint256 arg0, uint256 arg1, address[] arg2, address arg3, uint256 arg4) public returns (bytes memory) {
        require(!arg2 > 0x0100000000);
        require(!arg4 < block.timestamp);
        require((arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg2));
        require(address((0x20 * (arg2 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) + (0x20 + (arg2))) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2);
        uint256 var_a = var_a + (0x20 + (0x20 * (arg2)));
        uint256 var_b = (arg2);
        require(!var_a.length < 0x02);
        require(!var_a.length > 0xffffffffffffffff);
        var_a = var_a + (0x20 + (0x20 * var_a.length));
        require(!var_a.length, "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        var_c = msg.data[4:4];
        require((var_a.length - 0x01) < var_a.length, "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        require(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length), "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        require(!(var_c > arg1), "DXswapRouter: EXCESSIVE_INPUT_AMOUNT");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(0x01 < (arg2), "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(address(0 + (0x20 + (arg2))) == (address(0x20 + (0x20 + (arg2))))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))) < (address(0x20 + (0x20 + (arg2)))), "TransferHelper: TRANSFER_FROM_FAILED");
        require(address(0 + (0x20 + (arg2))), "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        var_a = var_a + 0x84;
        require(var_a.length < 0x20, "TransferHelper: TRANSFER_FROM_FAILED");
        (bool success, bytes memory ret0) = address(0 + (0x20 + (arg2))).{ value: 0 ether }adfepixw(); // call
        require(ret0.length == 0, "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + (0x20 + (0x20 * (arg2)));
        var_c = msg.data[36:36];
        require(!0 < (var_a.length - 0x01));
        require((var_a.length - 0x01) < var_a.length);
        var_x = var_z;
        require(address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length);
        (bool success, bytes memory ret0) = address(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).{ value: 0 ether }Unresolved_2e1a7d4d(var_x); // call
        require((var_a.length - 0x01) < var_a.length, "TransferHelper: ETH_TRANSFER_FAILED");
        var_a = var_a + 0x20;
        require(var_a.length < 0x20, "TransferHelper: ETH_TRANSFER_FAILED");
        require((var_a.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0) < 0x20, "TransferHelper: ETH_TRANSFER_FAILED");
        (bool success, bytes memory ret0) = address(arg3).transfer(var_z);
        require(ret0.length == 0, "TransferHelper: ETH_TRANSFER_FAILED");
        require(!(0 < (var_a.length * 0x20)), "TransferHelper: TRANSFER_FROM_FAILED");
        return abi.encodePacked(0x20, var_a.length);
        require(!var_ag, "TransferHelper: TRANSFER_FROM_FAILED");
        require(!(var_ag < 0x20), "TransferHelper: TRANSFER_FROM_FAILED");
        require(var_b, "TransferHelper: TRANSFER_FROM_FAILED");
        var_a = var_a + (uint248(ret0.length + 0x3f));
        if (!var_a.length) {
        }
        require(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) - 0x01) < var_a.length);
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        require(!(address(var_ai)) == (address(var_aj)));
        require(address(var_ai) < (address(var_aj)));
        require(address(var_ai));
        require(!(address(var_ai)) == (address(var_aj)));
        require(address(var_ai) < (address(var_aj)));
        require(address(var_ai));
        var_a = var_a + 0x48;
        var_a = var_a + 0xbd;
        require(address(keccak256(var_c)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_c)).getReserves(); // staticcall
        require(!ret0.length < 0x60);
        require(address(var_ai) == (address(var_ai)));
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        require(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) - 0x01) < var_a.length);
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_a.length) < var_a.length);
        var_am = var_am;
        var_am = var_am;
    }
    
    /// @custom:selector    0xaf2979eb
    /// @custom:signature   removeLiquidityETHSupportingFeeOnTransferTokens(address arg0, uint256 arg1, uint256 arg2, uint256 arg3, address arg4, uint256 arg5) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function removeLiquidityETHSupportingFeeOnTransferTokens(address arg0, uint256 arg1, uint256 arg2, uint256 arg3, address arg4, uint256 arg5) public {
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(arg5 < block.timestamp), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(!(address(arg0) == 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2), "DXswapLibrary: IDENTICAL_ADDRESSES");
        require(address(arg0) < 0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        require(0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, "DXswapLibrary: ZERO_ADDRESS");
        uint256 var_c = var_c + 0x48;
        address var_p = msg.sender;
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_23b872dd(var_p); // call
        require(!ret0.length < 0x20);
        var_p = address(this);
        require(address(keccak256(var_l)).code.length);
        (bool success, bytes memory ret0) = address(keccak256(var_l)).{ value: 0 ether }Unresolved_89afcb44(var_p); // call
        require(!ret0.length < 0x40);
        require(address(arg0), "DXswapLibrary: ZERO_ADDRESS");
        var_s = var_s;
        var_s = var_s;
    }
}