0x047fe72ab46b12995b369d983e9f37e495b06c86

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 token1 = 1040817466782534455191290819516492883421470699959;
    bytes public constant getTokens = 0xBytes([0, 0]);
    uint256 public constant token0 = 0;
    
    uint256 store_d;
    bool public decimals;
    bytes public virtualFee;
    bytes32 store_u;
    mapping(bytes32 => bytes32) storage_map_h;
    address store_m;
    mapping(bytes32 => bytes32) storage_map_q;
    address store_n;
    mapping(bytes32 => bytes32) storage_map_r;
    mapping(bytes32 => bytes32) storage_map_t;
    address store_j;
    uint256 public unresolved_18160ddd;
    address public mooniswapFactoryGovernance;
    mapping(bytes32 => bytes32) storage_map_b;
    address store_e;
    bytes public virtualDecayPeriod;
    bytes32 store_g;
    bytes32 store_s;
    mapping(bytes32 => bytes32) storage_map_l;
    uint256 store_i;
    bytes public virtualSlippageFee;
    
    event Event_8c5be1e5();
    event FeeVoteUpdate(address, uint256, bool, uint256);
    event SlippageFeeVoteUpdate(address, uint256, bool, uint256);
    event DecayPeriodVoteUpdate(address, uint256, bool, uint256);
    event OwnershipTransferred(address, address);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   Unresolved_095ea7b3(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_095ea7b3(address arg0, uint256 arg1) public returns (bool) {
        require(address(msg.sender), "ERC20: approve to the zero address");
        require(address(arg0), "ERC20: approve to the zero address");
        var_a = address(arg0);
        storage_map_b[var_a] = arg1;
        emit Event_8c5be1e5(address(msg.sender), address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0xf76d13b4
    /// @custom:signature   discardDecayPeriodVote() public
    function discardDecayPeriodVote() public {
        address var_a = msg.sender;
        var_c = var_c + 0x20;
        var_a = address(msg.sender);
        require(address(mooniswapFactoryGovernance / 0x01).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance / 0x01).defaultDecayPeriod(); // staticcall
        require(!(ret0.length < 0x20), "");
        require(var_c.length, "");
        require(!var_c.length, "");
        require(storage_map_b[var_a], "");
        require(storage_map_b[var_a], "");
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a] / storage_map_b[var_a] == (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length), "");
        var_c = 0x40 + var_c;
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a] > store_d), "");
        require(!(bytes1(var_c.length)), "");
        require(var_c.length, "SafeMath: addition overflow");
        require(!((storage_map_b[var_a] + store_e) < store_e), "SafeMath: addition overflow");
        require((store_d - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a])) == store_d, "SafeMath: addition overflow");
        store_d = store_d - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a]);
        require((storage_map_b[var_a] + store_e) == store_e, "SafeMath: addition overflow");
        store_e = storage_map_b[var_a] + store_e;
        require(!unresolved_18160ddd, "SafeMath: addition overflow");
        require(storage_map_b[var_a] + store_e, "SafeMath: addition overflow");
        require(storage_map_b[var_a] + store_e, "SafeMath: addition overflow");
        require((var_c.length * (storage_map_b[var_a] + store_e)) / (storage_map_b[var_a] + store_e) == var_c.length, "SafeMath: addition overflow");
        require(!((var_c.length * (storage_map_b[var_a] + store_e)) + (store_d - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a])) < (store_d - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a]))), "SafeMath: addition overflow");
        require(unresolved_18160ddd, "");
        require(unresolved_18160ddd, "");
        var_c = var_c + 0x60;
        require(((var_c.length * (storage_map_b[var_a] + store_e)) + (store_d - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a])) / unresolved_18160ddd) == (uint104(virtualDecayPeriod / 0x0100000000000000000000000000)), "");
        var_c = 0x40 + var_c;
        require(!(uint48(var_x) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_x)))) {
        }
        if (var_c.length == var_c.length) {
        }
        if (!var_c.length) {
        }
        var_c = var_c + 0x60;
        if (var_c.length == (uint104(virtualDecayPeriod / 0x0100000000000000000000000000))) {
        }
    }
    
    /// @custom:selector    0x7e82a6f3
    /// @custom:signature   decayPeriodVotes(address arg0) public returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function decayPeriodVotes(address arg0) public returns (uint256) {
        address var_a = address(arg0);
        uint256 var_c = var_c + 0x20;
        require(!var_c.length);
        return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length;
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).defaultDecayPeriod(); // staticcall
        require(!ret0.length < 0x20);
        return var_c.length;
    }
    
    /// @custom:selector    0x5915d806
    /// @custom:signature   withdraw(uint256 arg0, uint256[] arg1) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function withdraw(uint256 arg0, uint256[] arg1) public {
        require(!arg1 > 0x0100000000);
        require(!(store_g == 0x02), "ReentrancyGuard: reentrant call");
        store_g = 0x02;
        var_a = 0x40 + var_a;
        require(!(uint48(var_q) > block.timestamp), "");
        require(!(bytes1(var_a.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_q)))) {
        }
    }
    
    /// @custom:selector    0xa9059cbb
    /// @custom:signature   transfer(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function transfer(address arg0, uint256 arg1) public {
        require(address(msg.sender));
        require(address(arg0));
        require(!(address(msg.sender)) == (address(arg0)));
        require(!address(msg.sender));
        address var_b = address(msg.sender);
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).Unresolved_3b90b9bf(var_b); // staticcall
        require(!ret0.length < 0x20);
        require(!address(arg0));
        var_b = address(arg0);
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).Unresolved_3b90b9bf(var_b); // staticcall
        require(!(ret0.length < 0x20), "SafeMath: addition overflow");
        require(!var_c.length, "SafeMath: addition overflow");
        require(!var_c.length, "SafeMath: addition overflow");
        require(address(msg.sender), "SafeMath: addition overflow");
        require(address(arg0), "SafeMath: addition overflow");
        var_d = address(arg0);
        require(!(address(arg0)), "SafeMath: addition overflow");
        require(!(address(msg.sender)), "SafeMath: addition overflow");
        require(!((0 + unresolved_18160ddd) < unresolved_18160ddd), "SafeMath: addition overflow");
        var_b = 0x20;
        uint256 var_c = 0x40 + var_c;
        require(!(0 > (0 + unresolved_18160ddd)), "");
        require(!(bytes1(var_c.length)), "");
        var_c = 0x0100 + var_c;
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).defaults(); // staticcall
        require(!(ret0.length < 0x60), "");
        var_c = var_b + var_c;
        var_d = address(var_c.length);
        var_d = address(var_af);
        var_c = var_c + 0x20;
        require(var_c.length, "");
        require(var_c.length, "");
        require(var_c.length, "");
        require(var_c.length, "");
        require(!(var_ah), "");
        var_c = 0x40 + var_c;
        require(!(var_ak > (var_al)), "");
        require(!(bytes1(var_c.length)), "");
        require(!(var_al - (var_ak)), "");
        require(var_c.length, "");
        require(!var_c.length, "");
        require(var_al, "");
        require(var_al, "");
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq) / (var_aq) == (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length), "");
        var_c = 0x40 + var_c;
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq) > store_i), "");
        require(!(bytes1(var_c.length)), "");
        if (var_c.length) {
            require(var_c.length, "SafeMath: addition overflow");
        }
        require(!((var_al - (var_ak) + store_j) < store_j), "SafeMath: addition overflow");
        require((store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq))) == store_i, "SafeMath: addition overflow");
        store_i = store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq));
        require((var_al - (var_ak) + store_j) == store_j, "SafeMath: addition overflow");
        store_j = (var_al - (var_ak)) + store_j;
        require(!(var_av), "SafeMath: addition overflow");
        require(var_al - (var_ak) + store_j, "SafeMath: addition overflow");
        require(var_al - (var_ak) + store_j, "SafeMath: addition overflow");
        require((var_c.length * (var_aq - (var_aw) + store_j)) / (var_aq - (var_aw) + store_j) == var_c.length, "SafeMath: addition overflow");
        require(!((var_c.length * (var_aq - (var_aw) + store_j)) + (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq))) < (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq)))), "SafeMath: addition overflow");
        require(var_av, "");
        require(var_av, "");
        var_c = var_c + 0x60;
        require((var_c.length * (var_aq - (var_aw) + store_j)) + (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq))) / (var_be) == (uint104(virtualFee / 0x0100000000000000000000000000)), "");
        var_c = 0x40 + var_c;
        require(!(uint48(var_ah) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_ah)))) {
        }
        if (var_c.length == var_c.length) {
        }
        if (!var_c.length) {
        }
        var_c = var_c + 0x60;
        if (var_c.length == (uint104(virtualFee / 0x0100000000000000000000000000))) {
        }
        if (!var_bn) {
        }
        if (!var_bn) {
        }
        if (!var_ah) {
        }
        if (!address(msg.sender)) {
        }
        if (!var_c.length) {
            require(!var_c.length);
            require(!var_c.length);
            require(address(msg.sender));
            require(address(arg0));
            require(!address(arg0));
        }
        require(!address(arg0));
        var_b = address(arg0);
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).isFeeCollector(var_b); // staticcall
        require(!ret0.length < 0x20);
    }
    
    /// @custom:selector    0xddca3f43
    /// @custom:signature   fee() public view
    function fee() public view {
        var_a = 0x40 + var_a;
        require(!(uint48(var_g) > block.timestamp), "");
        require(!(bytes1(var_a.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_g)))) {
        }
    }
    
    /// @custom:selector    0x07a80070
    /// @custom:signature   slippageFeeVote(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function slippageFeeVote(uint256 arg0) public {
        require(!(arg0 > 0x0de0b6b3a7640000), "Slippage fee vote is too high");
        var_b = 0x20;
        address var_e = msg.sender;
        var_g = var_g + 0x20;
        var_e = address(msg.sender);
        require(address(mooniswapFactoryGovernance / 0x01).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance / 0x01).defaultSlippageFee(); // staticcall
        require(!(ret0.length < 0x20), "");
        require(var_g.length, "");
        require(!var_g.length, "");
        require(storage_map_l[var_e], "");
        require(storage_map_l[var_e], "");
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e] / storage_map_l[var_e] == (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length), "");
        var_g = 0x40 + var_g;
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e] > store_m), "");
        require(!(bytes1(var_g.length)), "");
        require(var_g.length, "SafeMath: addition overflow");
        require(!((storage_map_l[var_e] + store_n) < store_n), "SafeMath: addition overflow");
        require((store_m - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e])) == store_m, "SafeMath: addition overflow");
        store_m = store_m - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e]);
        require((storage_map_l[var_e] + store_n) == store_n, "SafeMath: addition overflow");
        store_n = storage_map_l[var_e] + store_n;
        require(!unresolved_18160ddd, "SafeMath: addition overflow");
        require(storage_map_l[var_e] + store_n, "SafeMath: addition overflow");
        require(storage_map_l[var_e] + store_n, "SafeMath: addition overflow");
        require((var_g.length * (storage_map_l[var_e] + store_n)) / (storage_map_l[var_e] + store_n) == var_g.length, "SafeMath: addition overflow");
        require(!((var_g.length * (storage_map_l[var_e] + store_n)) + (store_m - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e])) < (store_m - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e]))), "SafeMath: addition overflow");
        require(unresolved_18160ddd, "");
        require(unresolved_18160ddd, "");
        var_g = var_g + 0x60;
        require(((var_g.length * (storage_map_l[var_e] + store_n)) + (store_m - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e])) / unresolved_18160ddd) == (uint104(virtualSlippageFee / 0x0100000000000000000000000000)), "");
        var_g = 0x40 + var_g;
        require(!(uint48(var_aa) > block.timestamp), "");
        require(!(bytes1(var_g.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_aa)))) {
        }
        if (var_g.length == var_g.length) {
            if (!var_g.length) {
                emit SlippageFeeVoteUpdate(address(msg.sender), var_g.length, !var_g.length, storage_map_l[var_e]);
                emit SlippageFeeVoteUpdate(address(msg.sender), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length, !var_g.length, storage_map_l[var_e]);
                require(var_g.length == var_g.length, "SafeMath: multiplication overflow");
            }
        }
        var_g = var_g + 0x60;
        if (var_g.length == (uint104(virtualSlippageFee / 0x0100000000000000000000000000))) {
        }
        if (!var_g.length) {
        }
    }
    
    /// @custom:selector    0x78e3214f
    /// @custom:signature   rescueFunds(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function rescueFunds(address arg0, uint256 arg1) public {
        require(!(store_g == 0x02), "ReentrancyGuard: reentrant call");
        store_g = 0x02;
        require(address(msg.sender) == (address(decimals / 0x0100)), "Ownable: caller is not the owner");
        require(0);
        address var_b = address(this);
        require(address(0).code.length);
        (bool success, bytes memory ret0) = address(0).Unresolved_70a08231(var_b); // staticcall
        require(!(ret0.length < 0x20), "Address: call to non-contract");
        require(0xb64fde8f199f073f41c132b9ec7ad5b61de0b1b7, "Address: call to non-contract");
        require(!arg1, "Address: call to non-contract");
        require(!(!address(arg0)), "Address: call to non-contract");
        uint256 var_a = 0x44 + (var_e - var_e);
        var_e = 0x40 + var_e;
        require(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(arg0).codehash), "Address: call to non-contract");
        require(!(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(arg0).codehash)), "Address: call to non-contract");
        require(var_e.length < 0x20);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }adfepixw(); // call
        require(ret0.length == 0);
        require(!var_o);
        require(!var_e.length, "");
        require(!(bytes1(var_e.length)), "");
        require(!var_o, "SafeERC20: ERC20 operation did not succeed");
        require(!(var_o < 0x20), "SafeERC20: ERC20 operation did not succeed");
        require(var_a, "SafeERC20: ERC20 operation did not succeed");
        require(0);
        var_k = address(this);
        require(address(0).code.length);
        (bool success, bytes memory ret0) = address(0).Unresolved_70a08231(var_k); // staticcall
        require(!(ret0.length < 0x20), "Mooniswap: access denied");
        require(!(var_e.length < var_e.length), "Mooniswap: access denied");
        require(0xb64fde8f199f073f41c132b9ec7ad5b61de0b1b7, "Mooniswap: access denied");
        require(!(address(this).balance < (address(this).balance)), "Mooniswap: access denied");
        address var_t = address(this);
        require(!(storage_map_q[var_t] < 0x03e8), "Mooniswap: access denied");
        store_g = 0x01;
        require(!(address(this).balance < var_e.length), "Mooniswap: access denied");
        var_e = var_e + (uint248(ret0.length + 0x3f));
        require(!var_e.length);
        if (!var_e.length) {
        }
        require(!(!address(arg0).codehash), "Address: call to non-contract");
        (bool success, bytes memory ret0) = address(msg.sender).transfer(arg1);
    }
    
    /// @custom:selector    0x9aad141b
    /// @custom:signature   feeVotes(address arg0) public returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function feeVotes(address arg0) public returns (uint256) {
        address var_a = address(arg0);
        uint256 var_c = var_c + 0x20;
        require(!var_c.length);
        return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length;
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).defaultFee(); // staticcall
        require(!ret0.length < 0x20);
        return var_c.length;
    }
    
    /// @custom:selector    0xa457c2d7
    /// @custom:signature   decreaseAllowance(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function decreaseAllowance(address arg0, uint256 arg1) public returns (bool) {
        uint256 var_a = 0x60 + var_a;
        var_d = address(arg0);
        require(!(arg1 > storage_map_h[var_d]), "");
        require(!(bytes1(var_a.length)), "");
        require(address(msg.sender), "ERC20: approve to the zero address");
        require(address(arg0), "ERC20: approve to the zero address");
        var_d = address(arg0);
        storage_map_h[var_d] = storage_map_h[var_d] - arg1;
        emit Event_8c5be1e5(address(msg.sender), address(arg0), storage_map_h[var_d] - arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x6edc2c09
    /// @custom:signature   virtualBalancesForAddition(address arg0) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function virtualBalancesForAddition(address arg0) public view returns (bytes memory) {
        address var_b = address(arg0);
        return abi.encodePacked(uint216(storage_map_r[var_b]), uint40(storage_map_r[var_b] / 0x01000000000000000000000000000000000000000000000000000000));
    }
    
    /// @custom:selector    0x6669302a
    /// @custom:signature   discardSlippageFeeVote() public
    function discardSlippageFeeVote() public {
        address var_a = msg.sender;
        var_c = var_c + 0x20;
        var_a = address(msg.sender);
        require(address(mooniswapFactoryGovernance / 0x01).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance / 0x01).defaultSlippageFee(); // staticcall
        require(!(ret0.length < 0x20), "");
        require(var_c.length, "");
        require(!var_c.length, "");
        require(storage_map_b[var_a], "");
        require(storage_map_b[var_a], "");
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a] / storage_map_b[var_a] == (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length), "");
        var_c = 0x40 + var_c;
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a] > store_m), "");
        require(!(bytes1(var_c.length)), "");
        require(var_c.length, "SafeMath: addition overflow");
        require(!((storage_map_b[var_a] + store_n) < store_n), "SafeMath: addition overflow");
        require((store_m - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a])) == store_m, "SafeMath: addition overflow");
        store_m = store_m - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a]);
        require((storage_map_b[var_a] + store_n) == store_n, "SafeMath: addition overflow");
        store_n = storage_map_b[var_a] + store_n;
        require(!unresolved_18160ddd, "SafeMath: addition overflow");
        require(storage_map_b[var_a] + store_n, "SafeMath: addition overflow");
        require(storage_map_b[var_a] + store_n, "SafeMath: addition overflow");
        require((var_c.length * (storage_map_b[var_a] + store_n)) / (storage_map_b[var_a] + store_n) == var_c.length, "SafeMath: addition overflow");
        require(!((var_c.length * (storage_map_b[var_a] + store_n)) + (store_m - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a])) < (store_m - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a]))), "SafeMath: addition overflow");
        require(unresolved_18160ddd, "");
        require(unresolved_18160ddd, "");
        var_c = var_c + 0x60;
        require(((var_c.length * (storage_map_b[var_a] + store_n)) + (store_m - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a])) / unresolved_18160ddd) == (uint104(virtualSlippageFee / 0x0100000000000000000000000000)), "");
        var_c = 0x40 + var_c;
        require(!(uint48(var_x) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_x)))) {
        }
        if (var_c.length == var_c.length) {
        }
        if (!var_c.length) {
        }
        var_c = var_c + 0x60;
        if (var_c.length == (uint104(virtualSlippageFee / 0x0100000000000000000000000000))) {
        }
    }
    
    /// @custom:selector    0xd7d3aab5
    /// @custom:signature   getBalanceForAddition(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getBalanceForAddition(address arg0) public {
        require(address(arg0));
        address var_b = address(this);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_70a08231(var_b); // staticcall
        require(!(ret0.length < 0x20), "");
        var_c = 0x40 + var_c;
        require(!(uint48(var_h) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_h)))) {
        }
        var_c = 0x40 + var_c;
        require(!(uint48(var_h) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_h)))) {
        }
    }
    
    /// @custom:selector    0xdd62ed3e
    /// @custom:signature   Unresolved_dd62ed3e(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_dd62ed3e(address arg0, address arg1) public view returns (uint256) {
        var_a = address(arg1);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0xd5bcb9b5
    /// @custom:signature   swap(address arg0, address arg1, uint256 arg2, uint256 arg3, address arg4) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["address", "uint160", "bytes20", "int160"]
    function swap(address arg0, address arg1, uint256 arg2, uint256 arg3, address arg4) public payable {
        require(!(store_g == 0x02), "ReentrancyGuard: reentrant call");
        store_g = 0x02;
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).isActive(); // staticcall
        require(!(ret0.length < 0x20), "Mooniswap: factory shutdown");
        require(var_e.length, "Mooniswap: factory shutdown");
        require(!(address(arg0)), "Mooniswap: wrong value usage");
        require(msg.value == 0, "Mooniswap: wrong value usage");
        require(!address(arg0));
        require(address(arg0));
        address var_h = address(this);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_70a08231(var_h); // staticcall
        require(!(ret0.length < 0x20), "");
        var_e = 0x40 + var_e;
        require(!(0 > var_e.length), "");
        require(!(bytes1(var_e.length)), "");
        require(address(arg0));
        var_h = address(this);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_70a08231(var_h, var_p); // staticcall
        require(!ret0.length < 0x20);
    }
    
    /// @custom:selector    0x3732b394
    /// @custom:signature   slippageFee() public view
    function slippageFee() public view {
        var_a = 0x40 + var_a;
        require(!(uint48(var_g) > block.timestamp), "");
        require(!(bytes1(var_a.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_g)))) {
        }
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   Unresolved_06fdde03() public view returns (string memory)
    function Unresolved_06fdde03() public view returns (string memory) {
        bytes1 var_a = 0x20 + (var_a + (0x20 * (((store_s & (((!bytes1(store_s)) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02) + 0x1f) / 0x20)));
        if (!(store_s & (((!store_s) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / 0x02) {
            if (0x1f < (store_s & (((!store_s) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02)) {
                var_c = 0x03;
                if ((var_a + 0x20) + (store_s & (((!store_s) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02) > (0x20 + (var_a + 0x20))) {
                    if (!var_a.length) {
                        return abi.encodePacked(0x20, var_a.length, (~((0x0100 ** (0x20 - (bytes1(var_a.length)))) - 0x01)) & (var_g));
                        return abi.encodePacked(0x20, var_a.length);
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x95cad3c7
    /// @custom:signature   slippageFeeVotes(address arg0) public returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function slippageFeeVotes(address arg0) public returns (uint256) {
        address var_a = address(arg0);
        uint256 var_c = var_c + 0x20;
        require(!var_c.length);
        return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length;
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).defaultSlippageFee(); // staticcall
        require(!ret0.length < 0x20);
        return var_c.length;
    }
    
    /// @custom:selector    0x39509351
    /// @custom:signature   increaseAllowance(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function increaseAllowance(address arg0, uint256 arg1) public returns (bool) {
        var_a = address(arg0);
        require(!((arg1 + storage_map_b[var_a]) < storage_map_b[var_a]), "SafeMath: addition overflow");
        require(address(msg.sender), "ERC20: approve to the zero address");
        require(address(arg0), "ERC20: approve to the zero address");
        var_a = address(arg0);
        storage_map_b[var_a] = arg1 + storage_map_b[var_a];
        emit Event_8c5be1e5(address(msg.sender), address(arg0), arg1 + storage_map_b[var_a]);
        return 0x01;
    }
    
    /// @custom:selector    0xeaadf848
    /// @custom:signature   decayPeriodVote(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function decayPeriodVote(uint256 arg0) public {
        require(!(arg0 > 0x012c), "Decay period vote is too high");
        var_b = 0x20;
        require(!arg0 < 0x3c);
        address var_e = msg.sender;
        var_g = var_g + 0x20;
        var_e = address(msg.sender);
        require(address(mooniswapFactoryGovernance / 0x01).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance / 0x01).defaultDecayPeriod(); // staticcall
        require(!(ret0.length < 0x20), "");
        require(var_g.length, "");
        require(!var_g.length, "");
        require(storage_map_l[var_e], "");
        require(storage_map_l[var_e], "");
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e] / storage_map_l[var_e] == (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length), "");
        var_g = 0x40 + var_g;
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e] > store_d), "");
        require(!(bytes1(var_g.length)), "");
        require(var_g.length, "SafeMath: addition overflow");
        require(!((storage_map_l[var_e] + store_e) < store_e), "SafeMath: addition overflow");
        require((store_d - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e])) == store_d, "SafeMath: addition overflow");
        store_d = store_d - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e]);
        require((storage_map_l[var_e] + store_e) == store_e, "SafeMath: addition overflow");
        store_e = storage_map_l[var_e] + store_e;
        require(!unresolved_18160ddd, "SafeMath: addition overflow");
        require(storage_map_l[var_e] + store_e, "SafeMath: addition overflow");
        require(storage_map_l[var_e] + store_e, "SafeMath: addition overflow");
        require((var_g.length * (storage_map_l[var_e] + store_e)) / (storage_map_l[var_e] + store_e) == var_g.length, "SafeMath: addition overflow");
        require(!((var_g.length * (storage_map_l[var_e] + store_e)) + (store_d - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e])) < (store_d - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e]))), "SafeMath: addition overflow");
        require(unresolved_18160ddd, "");
        require(unresolved_18160ddd, "");
        var_g = var_g + 0x60;
        require(((var_g.length * (storage_map_l[var_e] + store_e)) + (store_d - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e])) / unresolved_18160ddd) == (uint104(virtualDecayPeriod / 0x0100000000000000000000000000)), "");
        var_g = 0x40 + var_g;
        require(!(uint48(var_aa) > block.timestamp), "");
        require(!(bytes1(var_g.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_aa)))) {
        }
        if (var_g.length == var_g.length) {
            if (!var_g.length) {
                emit DecayPeriodVoteUpdate(address(msg.sender), var_g.length, !var_g.length, storage_map_l[var_e]);
                emit DecayPeriodVoteUpdate(address(msg.sender), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length, !var_g.length, storage_map_l[var_e]);
                require(var_g.length == var_g.length, "SafeMath: multiplication overflow");
            }
        }
        var_g = var_g + 0x60;
        if (var_g.length == (uint104(virtualDecayPeriod / 0x0100000000000000000000000000))) {
        }
        if (!var_g.length) {
        }
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   Unresolved_95d89b41() public view returns (string memory)
    function Unresolved_95d89b41() public view returns (string memory) {
        bytes1 var_a = 0x20 + (var_a + (0x20 * (((store_u & (((!bytes1(store_u)) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02) + 0x1f) / 0x20)));
        if (!(store_u & (((!store_u) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / 0x02) {
            if (0x1f < (store_u & (((!store_u) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02)) {
                var_c = 0x04;
                if ((var_a + 0x20) + (store_u & (((!store_u) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02) > (0x20 + (var_a + 0x20))) {
                    if (!var_a.length) {
                        return abi.encodePacked(0x20, var_a.length, (~((0x0100 ** (0x20 - (bytes1(var_a.length)))) - 0x01)) & (var_g));
                        return abi.encodePacked(0x20, var_a.length);
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x9ea5ce0a
    /// @custom:signature   Unresolved_9ea5ce0a(address arg0) public payable
    /// @param              arg4 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_9ea5ce0a(address arg0) public payable {
        uint256 var_c = 0;
        require(!(store_g == 0x02), "ReentrancyGuard: reentrant call");
        store_g = 0x02;
        require(!(address(var_k)), "Mooniswap: wrong value usage");
        require(!(address(var_l)), "Mooniswap: wrong value usage");
        require(msg.value == (var_m), "Mooniswap: wrong value usage");
        require(unresolved_18160ddd, "");
        require(!(0 < 0x02), "");
        require(!(0 < 0x02), "");
        require(!(0 < 0x02), "");
        var_a = 0x40 + var_a;
        require(!(uint48(var_w) > block.timestamp), "");
        require(!(bytes1(var_a.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_w)))) {
        }
        require(0 < 0x02, "SafeMath: addition overflow");
        require(var_k > 0, "SafeMath: addition overflow");
        require(0 < 0x02, "SafeMath: addition overflow");
        require(var_k, "SafeMath: addition overflow");
        require(var_k, "SafeMath: addition overflow");
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) / (var_k) == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "SafeMath: addition overflow");
        require(!((unresolved_18160ddd - 0x01) + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) < (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k))), "SafeMath: addition overflow");
        var_a = 0x40 + var_a;
        require(unresolved_18160ddd, "Mooniswap: minAmount not reached");
        require(unresolved_18160ddd, "Mooniswap: minAmount not reached");
        require(0 < 0x02, "Mooniswap: minAmount not reached");
        require(!(((unresolved_18160ddd - 0x01) + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) / unresolved_18160ddd) < (var_k)), "Mooniswap: minAmount not reached");
        require(0 < 0x02, "Address: call to non-contract");
        require(!((unresolved_18160ddd - 0x01) + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) / unresolved_18160ddd), "Address: call to non-contract");
        require(!(!address(var_k)), "Address: call to non-contract");
        var_a = 0x40 + var_a;
        require(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(var_k).codehash), "Address: call to non-contract");
        require(!(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(var_k).codehash)), "Address: call to non-contract");
        require(var_a.length < 0x20);
        (bool success, bytes memory ret0) = address(var_k).{ value: var_c ether }adfepixw(); // call
        require(ret0.length == 0);
        require(!var_al);
        require(!var_a.length, "");
        require(!(bytes1(var_a.length)), "");
        require(!var_al);
        require(!var_al < 0x20);
        require(var_ap);
        require(0 < 0x02);
        require(0 < 0x02);
        require(address(var_k));
        var_ai = address(this);
        require(address(var_k).code.length);
        (bool success, bytes memory ret0) = address(var_k).Unresolved_70a08231(var_ai); // staticcall
        require(!ret0.length < 0x20);
        var_a = var_a + (uint248(ret0.length + 0x3f));
        require(!var_a.length);
        if (!var_a.length) {
        }
        require(!(!address(var_k).codehash), "Address: call to non-contract");
        require(!(msg.value < ((unresolved_18160ddd - 0x01) + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) / unresolved_18160ddd)), "UniERC20: not enough value");
        require(msg.sender == (address(msg.sender)), "from is not msg.sender");
        require(address(this) == (address(this)), "to is not this");
        if (!msg.value > ((unresolved_18160ddd - 0x01) + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) / unresolved_18160ddd)) {
        }
        if (!var_a.length) {
        }
        require(0 < 0x02);
        require(0 < 0x02);
        require(0 < 0x02);
        require(!address(var_k));
        require(0 < 0x02);
        require(0 < 0x02);
    }
    
    /// @custom:selector    0x3c6216a6
    /// @custom:signature   withdrawFor(uint256 arg0, uint256[] arg1, address arg2) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    function withdrawFor(uint256 arg0, uint256[] arg1, address arg2) public {
        require(!arg1 > 0x0100000000);
        require(!(store_g == 0x02), "ReentrancyGuard: reentrant call");
        store_g = 0x02;
        var_a = 0x40 + var_a;
        require(!(uint48(var_q) > block.timestamp), "");
        require(!(bytes1(var_a.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_q)))) {
        }
    }
    
    /// @custom:selector    0xe7ff42c9
    /// @custom:signature   getBalanceForRemoval(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getBalanceForRemoval(address arg0) public {
        require(address(arg0));
        address var_b = address(this);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_70a08231(var_b); // staticcall
        require(!(ret0.length < 0x20), "");
        var_c = 0x40 + var_c;
        require(!(uint48(var_h) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_h)))) {
        }
        var_c = 0x40 + var_c;
        require(!(uint48(var_h) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_h)))) {
        }
    }
    
    /// @custom:selector    0xc40d4d66
    /// @custom:signature   setMooniswapFactoryGovernance(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setMooniswapFactoryGovernance(address arg0) public {
        require(address(msg.sender) == (address(decimals / 0x0100)), "Ownable: caller is not the owner");
        mooniswapFactoryGovernance = (address(arg0)) | (uint96(mooniswapFactoryGovernance));
        require(address(this).code.length);
        (bool success, bytes memory ret0) = address(this).{ value: 0 ether }discardFeeVote(); // call
        require(address(this).code.length);
        (bool success, bytes memory ret0) = address(this).{ value: 0 ether }discardSlippageFeeVote(); // call
        require(address(this).code.length);
        (bool success, bytes memory ret0) = address(this).{ value: 0 ether }discardDecayPeriodVote(); // call
    }
    
    /// @custom:selector    0xf2fde38b
    /// @custom:signature   transferOwnership(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function transferOwnership(address arg0) public {
        require(address(msg.sender) == (address(decimals / 0x0100)), "Ownable: caller is not the owner");
        require(address(arg0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(address(decimals / 0x0100), address(arg0));
        decimals = (uint96(decimals)) | (0x0100 * (address(arg0)));
    }
    
    /// @custom:selector    0x93028d83
    /// @custom:signature   discardFeeVote() public
    function discardFeeVote() public {
        address var_a = msg.sender;
        var_c = var_c + 0x20;
        var_a = address(msg.sender);
        require(address(mooniswapFactoryGovernance / 0x01).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance / 0x01).defaultFee(); // staticcall
        require(!(ret0.length < 0x20), "");
        require(var_c.length, "");
        require(!var_c.length, "");
        require(storage_map_b[var_a], "");
        require(storage_map_b[var_a], "");
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a] / storage_map_b[var_a] == (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length), "");
        var_c = 0x40 + var_c;
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a] > store_i), "");
        require(!(bytes1(var_c.length)), "");
        require(var_c.length, "SafeMath: addition overflow");
        require(!((storage_map_b[var_a] + store_j) < store_j), "SafeMath: addition overflow");
        require((store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a])) == store_i, "SafeMath: addition overflow");
        store_i = store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a]);
        require((storage_map_b[var_a] + store_j) == store_j, "SafeMath: addition overflow");
        store_j = storage_map_b[var_a] + store_j;
        require(!unresolved_18160ddd, "SafeMath: addition overflow");
        require(storage_map_b[var_a] + store_j, "SafeMath: addition overflow");
        require(storage_map_b[var_a] + store_j, "SafeMath: addition overflow");
        require((var_c.length * (storage_map_b[var_a] + store_j)) / (storage_map_b[var_a] + store_j) == var_c.length, "SafeMath: addition overflow");
        require(!((var_c.length * (storage_map_b[var_a] + store_j)) + (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a])) < (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a]))), "SafeMath: addition overflow");
        require(unresolved_18160ddd, "");
        require(unresolved_18160ddd, "");
        var_c = var_c + 0x60;
        require(((var_c.length * (storage_map_b[var_a] + store_j)) + (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * storage_map_b[var_a])) / unresolved_18160ddd) == (uint104(virtualFee / 0x0100000000000000000000000000)), "");
        var_c = 0x40 + var_c;
        require(!(uint48(var_x) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_x)))) {
        }
        if (var_c.length == var_c.length) {
        }
        if (!var_c.length) {
        }
        var_c = var_c + 0x60;
        if (var_c.length == (uint104(virtualFee / 0x0100000000000000000000000000))) {
        }
    }
    
    /// @custom:selector    0xb1ec4c40
    /// @custom:signature   volumes(address arg0) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function volumes(address arg0) public view returns (bytes memory) {
        address var_b = address(arg0);
        return abi.encodePacked(address(storage_map_r[var_b]), address(storage_map_r[var_b] / 0x0100000000000000000000000000000000));
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   Unresolved_70a08231(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_70a08231(address arg0) public view returns (uint256) {
        address var_a = address(arg0);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0x3049105d
    /// @custom:signature   Unresolved_3049105d() public payable
    function Unresolved_3049105d() public payable {
        require(!(store_g == 0x02), "ReentrancyGuard: reentrant call");
        store_g = 0x02;
        require(!(address(var_k)), "Mooniswap: wrong value usage");
        require(!(address(var_l)), "Mooniswap: wrong value usage");
        require(msg.value == (var_m), "Mooniswap: wrong value usage");
        require(unresolved_18160ddd, "");
        require(!(0 < 0x02), "");
        require(!(0 < 0x02), "");
        require(!(0 < 0x02), "");
        var_a = 0x40 + var_a;
        require(!(uint48(var_w) > block.timestamp), "");
        require(!(bytes1(var_a.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_w)))) {
        }
        require(0 < 0x02, "SafeMath: addition overflow");
        require(var_k > 0, "SafeMath: addition overflow");
        require(0 < 0x02, "SafeMath: addition overflow");
        require(var_k, "SafeMath: addition overflow");
        require(var_k, "SafeMath: addition overflow");
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) / (var_k) == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "SafeMath: addition overflow");
        require(!((unresolved_18160ddd - 0x01) + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) < (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k))), "SafeMath: addition overflow");
        var_a = 0x40 + var_a;
        require(unresolved_18160ddd, "Mooniswap: minAmount not reached");
        require(unresolved_18160ddd, "Mooniswap: minAmount not reached");
        require(0 < 0x02, "Mooniswap: minAmount not reached");
        require(!(((unresolved_18160ddd - 0x01) + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) / unresolved_18160ddd) < (var_k)), "Mooniswap: minAmount not reached");
        require(0 < 0x02, "Address: call to non-contract");
        require(!((unresolved_18160ddd - 0x01) + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) / unresolved_18160ddd), "Address: call to non-contract");
        require(!(!address(var_k)), "Address: call to non-contract");
        var_a = 0x40 + var_a;
        require(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(var_k).codehash), "Address: call to non-contract");
        require(!(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == (address(var_k).codehash)), "Address: call to non-contract");
        require(!(!address(var_k).codehash), "Address: call to non-contract");
        require(!(msg.value < ((unresolved_18160ddd - 0x01) + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) / unresolved_18160ddd)), "UniERC20: not enough value");
        require(msg.sender == (address(msg.sender)), "from is not msg.sender");
        require(address(this) == (address(this)), "to is not this");
        var_af = 0x0e;
        require(!msg.value > ((unresolved_18160ddd - 0x01) + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff * (var_k)) / unresolved_18160ddd));
        require(0 < 0x02);
        require(0 < 0x02);
        require(address(var_k));
        var_ae = address(this);
        require(address(var_k).code.length);
        (bool success, bytes memory ret0) = address(var_k).Unresolved_70a08231(var_ae, var_af); // staticcall
        require(!ret0.length < 0x20);
        if (!var_a.length) {
        }
        require(0 < 0x02);
        require(0 < 0x02);
        require(0 < 0x02);
        require(!address(var_k));
        require(0 < 0x02);
        require(0 < 0x02);
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   Unresolved_23b872dd(address arg0, address arg1, uint256 arg2) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_23b872dd(address arg0, address arg1, uint256 arg2) public {
        require(address(arg0));
        require(address(arg1));
        require(!(address(arg0)) == (address(arg1)));
        require(!address(arg0));
        address var_b = address(arg0);
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).Unresolved_3b90b9bf(var_b); // staticcall
        require(!ret0.length < 0x20);
        require(!address(arg1));
        var_b = address(arg1);
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).Unresolved_3b90b9bf(var_b); // staticcall
        require(!(ret0.length < 0x20), "SafeMath: addition overflow");
        require(!var_c.length, "SafeMath: addition overflow");
        require(!var_c.length, "SafeMath: addition overflow");
        require(address(arg0), "SafeMath: addition overflow");
        require(address(arg1), "SafeMath: addition overflow");
        var_d = address(arg1);
        require(!(address(arg1)), "SafeMath: addition overflow");
        require(!(address(arg0)), "SafeMath: addition overflow");
        require(!((0 + unresolved_18160ddd) < unresolved_18160ddd), "SafeMath: addition overflow");
        var_b = 0x20;
        uint256 var_c = 0x40 + var_c;
        require(!(0 > (0 + unresolved_18160ddd)), "");
        require(!(bytes1(var_c.length)), "");
        var_c = 0x0100 + var_c;
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).defaults(); // staticcall
        require(!(ret0.length < 0x60), "");
        var_c = var_b + var_c;
        var_d = address(var_c.length);
        var_d = address(var_af);
        var_c = var_c + 0x20;
        require(var_c.length, "");
        require(var_c.length, "");
        require(var_c.length, "");
        require(var_c.length, "");
        require(!(var_ah), "");
        var_c = 0x40 + var_c;
        require(!(var_ak > (var_al)), "");
        require(!(bytes1(var_c.length)), "");
        require(!(var_al - (var_ak)), "");
        require(var_c.length, "");
        require(!var_c.length, "");
        require(var_al, "");
        require(var_al, "");
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq) / (var_aq) == (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length), "");
        var_c = 0x40 + var_c;
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq) > store_i), "");
        require(!(bytes1(var_c.length)), "");
        if (var_c.length) {
            require(var_c.length, "SafeMath: addition overflow");
        }
        require(!((var_al - (var_ak) + store_j) < store_j), "SafeMath: addition overflow");
        require((store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq))) == store_i, "SafeMath: addition overflow");
        store_i = store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq));
        require((var_al - (var_ak) + store_j) == store_j, "SafeMath: addition overflow");
        store_j = (var_al - (var_ak)) + store_j;
        require(!(var_av), "SafeMath: addition overflow");
        require(var_al - (var_ak) + store_j, "SafeMath: addition overflow");
        require(var_al - (var_ak) + store_j, "SafeMath: addition overflow");
        require((var_c.length * (var_aq - (var_aw) + store_j)) / (var_aq - (var_aw) + store_j) == var_c.length, "SafeMath: addition overflow");
        require(!((var_c.length * (var_aq - (var_aw) + store_j)) + (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq))) < (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq)))), "SafeMath: addition overflow");
        require(var_av, "");
        require(var_av, "");
        var_c = var_c + 0x60;
        require((var_c.length * (var_aq - (var_aw) + store_j)) + (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_c.length) * (var_aq))) / (var_be) == (uint104(virtualFee / 0x0100000000000000000000000000)), "");
        var_c = 0x40 + var_c;
        require(!(uint48(var_ah) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_ah)))) {
        }
        if (var_c.length == var_c.length) {
        }
        if (!var_c.length) {
        }
        var_c = var_c + 0x60;
        if (var_c.length == (uint104(virtualFee / 0x0100000000000000000000000000))) {
        }
        if (!var_bn) {
        }
        if (!var_bn) {
        }
        if (!var_ah) {
        }
        if (!address(arg0)) {
        }
        if (!var_c.length) {
            require(!var_c.length);
            require(!var_c.length);
            require(address(arg0));
            require(address(arg1));
            require(!address(arg1));
        }
        require(!address(arg1));
        var_b = address(arg1);
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).isFeeCollector(var_b); // staticcall
        require(!ret0.length < 0x20);
    }
    
    /// @custom:selector    0x5ed9156d
    /// @custom:signature   virtualBalancesForRemoval(address arg0) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function virtualBalancesForRemoval(address arg0) public view returns (bytes memory) {
        address var_b = address(arg0);
        return abi.encodePacked(uint216(storage_map_r[var_b]), uint40(storage_map_r[var_b] / 0x01000000000000000000000000000000000000000000000000000000));
    }
    
    /// @custom:selector    0x4f64b2be
    /// @custom:signature   tokens(uint256 arg0) public pure returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function tokens(uint256 arg0) public pure returns (uint256) {
        require(arg0, "Pool has two tokens");
        require(!(0x01 == arg0), "Pool has two tokens");
        return 0xb64fde8f199f073f41c132b9ec7ad5b61de0b1b7;
        return 0;
    }
    
    /// @custom:selector    0x11212d66
    /// @custom:signature   feeVote(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function feeVote(uint256 arg0) public {
        require(!(arg0 > 0x2386f26fc10000), "Fee vote is too high");
        var_b = 0x20;
        address var_e = msg.sender;
        var_g = var_g + 0x20;
        var_e = address(msg.sender);
        require(address(mooniswapFactoryGovernance / 0x01).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance / 0x01).defaultFee(); // staticcall
        require(!(ret0.length < 0x20), "");
        require(var_g.length, "");
        require(!var_g.length, "");
        require(storage_map_l[var_e], "");
        require(storage_map_l[var_e], "");
        require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e] / storage_map_l[var_e] == (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length), "");
        var_g = 0x40 + var_g;
        require(!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e] > store_i), "");
        require(!(bytes1(var_g.length)), "");
        require(var_g.length, "SafeMath: addition overflow");
        require(!((storage_map_l[var_e] + store_j) < store_j), "SafeMath: addition overflow");
        require((store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e])) == store_i, "SafeMath: addition overflow");
        store_i = store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e]);
        require((storage_map_l[var_e] + store_j) == store_j, "SafeMath: addition overflow");
        store_j = storage_map_l[var_e] + store_j;
        require(!unresolved_18160ddd, "SafeMath: addition overflow");
        require(storage_map_l[var_e] + store_j, "SafeMath: addition overflow");
        require(storage_map_l[var_e] + store_j, "SafeMath: addition overflow");
        require((var_g.length * (storage_map_l[var_e] + store_j)) / (storage_map_l[var_e] + store_j) == var_g.length, "SafeMath: addition overflow");
        require(!((var_g.length * (storage_map_l[var_e] + store_j)) + (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e])) < (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e]))), "SafeMath: addition overflow");
        require(unresolved_18160ddd, "");
        require(unresolved_18160ddd, "");
        var_g = var_g + 0x60;
        require(((var_g.length * (storage_map_l[var_e] + store_j)) + (store_i - ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length) * storage_map_l[var_e])) / unresolved_18160ddd) == (uint104(virtualFee / 0x0100000000000000000000000000)), "");
        var_g = 0x40 + var_g;
        require(!(uint48(var_aa) > block.timestamp), "");
        require(!(bytes1(var_g.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_aa)))) {
        }
        if (var_g.length == var_g.length) {
            if (!var_g.length) {
                emit FeeVoteUpdate(address(msg.sender), var_g.length, !var_g.length, storage_map_l[var_e]);
                emit FeeVoteUpdate(address(msg.sender), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + var_g.length, !var_g.length, storage_map_l[var_e]);
                require(var_g.length == var_g.length, "SafeMath: multiplication overflow");
            }
        }
        var_g = var_g + 0x60;
        if (var_g.length == (uint104(virtualFee / 0x0100000000000000000000000000))) {
        }
        if (!var_g.length) {
        }
    }
    
    /// @custom:selector    0xe331d039
    /// @custom:signature   swapFor(address arg0, address arg1, uint256 arg2, uint256 arg3, address arg4, address arg5) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg5 ["address", "uint160", "bytes20", "int160"]
    function swapFor(address arg0, address arg1, uint256 arg2, uint256 arg3, address arg4, address arg5) public payable {
        require(!(store_g == 0x02), "ReentrancyGuard: reentrant call");
        store_g = 0x02;
        require(address(mooniswapFactoryGovernance).code.length);
        (bool success, bytes memory ret0) = address(mooniswapFactoryGovernance).isActive(); // staticcall
        require(!(ret0.length < 0x20), "Mooniswap: factory shutdown");
        require(var_e.length, "Mooniswap: factory shutdown");
        require(!(address(arg0)), "Mooniswap: wrong value usage");
        require(msg.value == 0, "Mooniswap: wrong value usage");
        require(!address(arg0));
        require(address(arg0));
        address var_h = address(this);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_70a08231(var_h); // staticcall
        require(!(ret0.length < 0x20), "");
        var_e = 0x40 + var_e;
        require(!(0 > var_e.length), "");
        require(!(bytes1(var_e.length)), "");
        require(address(arg0));
        var_h = address(this);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_70a08231(var_h, var_p); // staticcall
        require(!ret0.length < 0x20);
    }
    
    /// @custom:selector    0x1e1401f8
    /// @custom:signature   getReturn(address arg0, address arg1, uint256 arg2) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function getReturn(address arg0, address arg1, uint256 arg2) public {
        require(address(arg0));
        address var_b = address(this);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_70a08231(var_b); // staticcall
        require(!(ret0.length < 0x20), "");
        var_c = 0x40 + var_c;
        require(!(uint48(var_h) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_h)))) {
        }
        var_c = 0x40 + var_c;
        require(!(uint48(var_h) > block.timestamp), "");
        require(!(bytes1(var_c.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_h)))) {
        }
    }
    
    /// @custom:selector    0x48d67e1b
    /// @custom:signature   decayPeriod() public view
    function decayPeriod() public view {
        var_a = 0x40 + var_a;
        require(!(uint48(var_g) > block.timestamp), "");
        require(!(bytes1(var_a.length)), "");
        if (0x015180 < (block.timestamp - (uint48(var_g)))) {
        }
    }
    
    /// @custom:selector    0x715018a6
    /// @custom:signature   renounceOwnership() public
    function renounceOwnership() public {
        require(address(msg.sender) == (address(decimals / 0x0100)), "Ownable: caller is not the owner");
        emit OwnershipTransferred(address(decimals / 0x0100), 0);
        decimals = uint96(decimals);
    }
}