0x1811a719a05d20b6447ca556a54f00f9c14578be

deployer: unknown relevance score: 0 status: partially_identified bytecode: 22537 bytes

DECOMPILED SOLIDITY (Heimdall)

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

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

contract DecompiledContract {
    uint256 public constant getColor = 29998076816151136843738273904393362944190410987371835869422740716572129624064;
    uint256 public constant MAX_OUT_RATIO = 333333333333333334;
    uint256 public constant MIN_BOUND_TOKENS = 2;
    uint256 public constant MAX_FEE = 100000000000000000;
    uint256 public constant BONE = 1000000000000000000;
    uint256 public constant MIN_BPOW_BASE = 1;
    uint256 public constant BPOW_PRECISION = 100000000;
    uint256 public constant MAX_BPOW_BASE = 1999999999999999999;
    uint256 public constant MIN_FEE = 1000000000000;
    uint256 public constant EXIT_FEE = 0;
    uint256 public constant MAX_WEIGHT = 50000000000000000000;
    uint256 public constant MAX_BOUND_TOKENS = 8;
    uint256 public constant MAX_TOTAL_WEIGHT = 50000000000000000000;
    uint256 public constant MIN_WEIGHT = 1000000000000000000;
    uint256 public constant MIN_BALANCE = 1000000;
    uint256 public constant MAX_IN_RATIO = 500000000000000000;
    uint256 public constant INIT_POOL_SUPPLY = 100000000000000000000;
    
    mapping(bytes32 => bytes32) storage_map_f;
    mapping(bytes32 => bytes32) storage_map_w;
    uint256 public getSwapFee;
    uint256 public getTotalDenormalizedWeight;
    mapping(bytes32 => bytes32) storage_map_q;
    mapping(bytes32 => bytes32) storage_map_s;
    mapping(bytes32 => bytes32) storage_map_af;
    mapping(bytes32 => bytes32) storage_map_ac;
    mapping(bytes32 => bytes32) storage_map_j;
    uint256 public totalSupply;
    bool public decimals;
    mapping(bytes32 => bytes32) storage_map_b;
    mapping(bytes32 => bytes32) storage_map_i;
    bool public isPublicSwap;
    bytes32 store_h;
    uint256 public getNumTokens;
    mapping(bytes32 => bytes32) storage_map_e;
    mapping(bytes32 => bytes32) storage_map_x;
    mapping(bytes32 => bytes32) storage_map_n;
    mapping(bytes32 => bytes32) storage_map_ae;
    mapping(bytes32 => bytes32) storage_map_o;
    address store_p;
    mapping(bytes32 => bytes32) storage_map_z;
    mapping(bytes32 => bytes32) storage_map_v;
    mapping(bytes32 => bytes32) storage_map_d;
    bool public isFinalized;
    mapping(bytes32 => bytes32) storage_map_ah;
    mapping(bytes32 => bytes32) storage_map_ab;
    mapping(bytes32 => bytes32) storage_map_ad;
    mapping(bytes32 => bytes32) storage_map_aa;
    mapping(bytes32 => bytes32) storage_map_ai;
    mapping(bytes32 => bytes32) storage_map_y;
    mapping(bytes32 => bytes32) storage_map_m;
    bytes32 store_t;
    mapping(bytes32 => bytes32) storage_map_ag;
    mapping(bytes32 => bytes32) storage_map_aj;
    address storage_map_z[getNumTokens + keccak256(var_h)];
    
    event Event_5db34277();
    event Event_7c5e9ea4();
    event Approval(address, address, uint256);
    event Event_92eefe9b();
    event Event_8c28cbe8();
    event Event_4bb278f3();
    event Event_02c96748();
    event Event_e4e1e538();
    event Event_b02f0b73();
    event Transfer(address, address, uint256);
    event Event_cf5e7bd3();
    event Event_49b59552();
    event Event_8201aa3f();
    event Event_46ab38f1();
    event Event_3fdddaa2();
    event Event_4f69c0d4();
    event Event_34e19907();
    event Event_6d06dfa0();
    event LOG_JOIN(address, address, uint256);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   approve(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function approve(address arg0, uint256 arg1) public payable returns (bool) {
        var_a = address(arg0);
        storage_map_b[var_a] = arg1;
        emit Approval(msg.sender, address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x66188463
    /// @custom:signature   decreaseApproval(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function decreaseApproval(address arg0, uint256 arg1) public payable returns (bool) {
        var_a = address(arg0);
        require(!(arg1 > storage_map_b[var_a]), "ERR_SUB_UNDERFLOW");
        var_a = address(arg0);
        storage_map_b[var_a] = 0;
        var_a = address(arg0);
        emit Approval(msg.sender, address(arg0), storage_map_b[var_a]);
        return 0x01;
        require(storage_map_b[var_a] < arg1, "ERR_SUB_UNDERFLOW");
        require(!0x01, "ERR_SUB_UNDERFLOW");
        var_a = address(arg0);
        storage_map_b[var_a] = arg1 - storage_map_b[var_a];
        var_a = address(arg0);
        emit Approval(msg.sender, address(arg0), storage_map_b[var_a]);
        return 0x01;
        require(!0, "ERR_SUB_UNDERFLOW");
        var_a = address(arg0);
        storage_map_b[var_a] = storage_map_b[var_a] - arg1;
        var_a = address(arg0);
        emit Approval(msg.sender, address(arg0), storage_map_b[var_a]);
        return 0x01;
    }
    
    /// @custom:selector    0x1446a7ff
    /// @custom:signature   getSpotPriceSansFee(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function getSpotPriceSansFee(address arg0, address arg1) public view returns (uint256) {
        require(!(bytes1(decimals / 0x0100)), "ERR_REENTRY");
        address var_e = address(arg0);
        require(bytes1(storage_map_d[var_e]), "ERR_DIV_INTERNAL");
        var_e = address(arg1);
        require(bytes1(storage_map_d[var_e]), "ERR_DIV_INTERNAL");
        var_e = address(arg1);
        require(storage_map_e[var_e], "ERR_DIV_INTERNAL");
        require(!(storage_map_f[var_e]), "ERR_DIV_INTERNAL");
        require(storage_map_f[var_e], "ERR_DIV_INTERNAL");
        require((storage_map_f[var_e] * 0x0de0b6b3a7640000) / (storage_map_f[var_e]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) < (storage_map_f[var_e] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(storage_map_e[var_e], "ERR_DIV_INTERNAL");
        require(storage_map_e[var_e], "ERR_DIV_INTERNAL");
        require(!(storage_map_f[var_e]), "ERR_DIV_INTERNAL");
        require(storage_map_f[var_e], "ERR_DIV_INTERNAL");
        require((storage_map_f[var_e] * 0x0de0b6b3a7640000) / (storage_map_f[var_e]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) < (storage_map_f[var_e] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(storage_map_e[var_e], "ERR_DIV_INTERNAL");
        require((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]), "ERR_DIV_INTERNAL");
        require(!((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e])), "ERR_DIV_INTERNAL");
        require((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]), "ERR_DIV_INTERNAL");
        require(((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) * 0x0de0b6b3a7640000) / ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e])) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!(((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) / 0x02) < ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]), "ERR_DIV_ZERO");
        require(0x0de0b6b3a7640000 < 0, "ERR_DIV_ZERO");
        require(!0x01, "ERR_DIV_ZERO");
        require(0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000, "ERR_DIV_ZERO");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!(0x8000000000000000000000000000000000c097ce7bc90715ac5b43b62c4e0000 < 0xc097ce7bc90715b34b9f1000000000), "ERR_DIV_INTERNAL");
        require(0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000, "ERR_MUL_OVERFLOW");
        require(!(((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) / 0x02) / ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]))), "ERR_MUL_OVERFLOW");
        require(((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) / 0x02) / ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e])), "ERR_MUL_OVERFLOW");
        require((0 * (((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) / 0x02) / ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e])))) / (((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) / 0x02) / ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]))) == 0, "ERR_MUL_OVERFLOW");
        require(!(((0 * (((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) / 0x02) / ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e])))) + 0x06f05b59d3b20000) < (0 * (((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) / 0x02) / ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]))))), "ERR_MUL_OVERFLOW");
        return ((0 * (((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e]) / 0x02) / ((storage_map_f[var_e] * 0x0de0b6b3a7640000) + (storage_map_e[var_e] / 0x02) / (storage_map_e[var_e])))) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000;
        require(0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(0x0de0b6b3a7640000 == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0, "ERR_SUB_UNDERFLOW");
    }
    
    /// @custom:selector    0xdd62ed3e
    /// @custom:signature   allowance(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function allowance(address arg0, address arg1) public view returns (uint256) {
        var_a = address(arg1);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   name() public view returns (string memory)
    function name() public view returns (string memory) {
        bytes1 var_a = 0x20 + (var_a + (0x20 * (((store_h & (((!bytes1(store_h)) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02) + 0x1f) / 0x20)));
        if (!(store_h & (((!store_h) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / 0x02) {
            if (0x1f < (store_h & (((!store_h) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02)) {
                var_c = 0x03;
                if ((var_a + 0x20) + (store_h & (((!store_h) * 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    0xe4e1e538
    /// @custom:signature   bind(address arg0, uint256 arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function bind(address arg0, uint256 arg1, uint256 arg2) public payable {
        emit Event_e4e1e538(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(msg.sender == (address(isPublicSwap)), "ERR_NOT_CONTROLLER");
        address var_h = address(arg0);
        require(!(bytes1(storage_map_j[var_h])), "ERR_IS_BOUND");
        require(!(bytes1(isFinalized)), "ERR_IS_FINALIZED");
        require(0x08 > getNumTokens, "ERR_MAX_TOKENS");
        uint256 var_b = var_b + 0x80;
        uint256 var_k = 0;
        var_h = address(arg0);
        storage_map_j[var_h] = var_b.length | (uint248(storage_map_j[var_h]));
        storage_map_m[var_h] = var_l;
        storage_map_n[var_h] = var_m;
        storage_map_o[var_h] = var_n;
        getNumTokens = getNumTokens + 0x01;
        store_p = (address(arg0)) | (uint96(store_p));
        emit Event_e4e1e538(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_REENTRY");
        decimals = 0x0100 | (uint248(decimals));
        require(address(isPublicSwap) == msg.sender, "ERR_NOT_CONTROLLER");
        var_h = address(arg0);
        require(bytes1(storage_map_j[var_h]), "ERR_NOT_BOUND");
        require(!(bytes1(isFinalized)), "ERR_IS_FINALIZED");
        require(!(arg2 < 0x0de0b6b3a7640000), "ERR_MAX_WEIGHT");
        require(!(arg2 > 0x02b5e3af16b1880000), "ERR_MAX_WEIGHT");
        require(!(arg1 < 0x0f4240), "ERR_ADD_OVERFLOW");
        var_h = address(arg0);
        require(!(arg2 > (storage_map_q[var_h])), "ERR_ADD_OVERFLOW");
        require(arg2 < (storage_map_q[var_h]), "ERR_ADD_OVERFLOW");
        require(!0x01, "ERR_ADD_OVERFLOW");
        require(!(((storage_map_q[var_h] - arg2) + getTotalDenormalizedWeight) < getTotalDenormalizedWeight), "ERR_ADD_OVERFLOW");
        getTotalDenormalizedWeight = (storage_map_q[var_h] - arg2) + getTotalDenormalizedWeight;
        require(!(0x02b5e3af16b1880000 < ((storage_map_q[var_h] - arg2) + getTotalDenormalizedWeight)), "ERR_MAX_TOTAL_WEIGHT");
        var_h = address(arg0);
        storage_map_n[var_h] = arg2;
        storage_map_s[var_h] = arg1;
        require(!arg1 > (storage_map_s[var_h]));
        require(arg1 < (storage_map_s[var_h]));
        require(!0x01);
        address var_r = address(msg.sender);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: var_k ether }gasprice_bit_ether(var_r); // call
        require(!(ret0.length < 0x20), "ERR_ERC20_FALSE");
        require(var_b.length, "ERR_ERC20_FALSE");
        decimals = uint248(decimals);
        require(!0, "ERR_SUB_UNDERFLOW");
        var_r = address(msg.sender);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: var_k ether }gasprice_bit_ether(var_r); // call
        require(!(ret0.length < 0x20), "ERR_ERC20_FALSE");
        require(var_b.length, "ERR_ERC20_FALSE");
        decimals = uint248(decimals);
        require(!(arg1 < (storage_map_s[var_h])), "ERR_SUB_UNDERFLOW");
        decimals = uint248(decimals);
        if (!arg2 < (storage_map_q[var_h])) {
        }
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   symbol() public view returns (string memory)
    function symbol() public view returns (string memory) {
        bytes1 var_a = 0x20 + (var_a + (0x20 * (((store_t & (((!bytes1(store_t)) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02) + 0x1f) / 0x20)));
        if (!(store_t & (((!store_t) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / 0x02) {
            if (0x1f < (store_t & (((!store_t) * 0x0100) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x02)) {
                var_c = 0x04;
                if ((var_a + 0x20) + (store_t & (((!store_t) * 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    0xf8d6aed4
    /// @custom:signature   calcInGivenOut(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function calcInGivenOut(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure {
        require(arg1, "ERR_DIV_INTERNAL");
        require(!arg3, "ERR_DIV_INTERNAL");
        require(arg3, "ERR_DIV_INTERNAL");
        require(((arg3 * 0x0de0b6b3a7640000) / arg3) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg3 * 0x0de0b6b3a7640000) + (arg1 / 0x02) < (arg3 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg1, "ERR_DIV_INTERNAL");
        require(arg2 < arg4, "ERR_DIV_INTERNAL");
        require(!0x01, "ERR_DIV_INTERNAL");
        require(arg4 - arg2, "ERR_DIV_INTERNAL");
        require(!arg2, "ERR_DIV_INTERNAL");
        require(arg2, "ERR_DIV_INTERNAL");
        require(((arg2 * 0x0de0b6b3a7640000) / arg2) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) < (arg2 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg4 - arg2, "ERR_BPOW_BASE_TOO_HIGH");
        require(!((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2) < 0x01), "ERR_BPOW_BASE_TOO_HIGH");
        require(!((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2) > 0x1bc16d674ec7ffff), "ERR_BPOW_BASE_TOO_HIGH");
        require(((arg3 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) < ((((arg3 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require((((((arg3 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) % 0x02, "ERR_MUL_OVERFLOW");
        require(!((((((arg3 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) / 0x02), "ERR_MUL_OVERFLOW");
        require(!((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2)), "ERR_MUL_OVERFLOW");
        require((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2), "ERR_MUL_OVERFLOW");
        require((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2) * ((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2)) / ((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2)) == ((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2)), "ERR_MUL_OVERFLOW");
        require(!(((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2) * ((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2)) + 0x06f05b59d3b20000) < ((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2) * ((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2)))), "ERR_MUL_OVERFLOW");
        require(!(((((((arg3 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) / 0x02) % 0x02), "ERR_SUB_UNDERFLOW");
        require(!((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2)), "ERR_SUB_UNDERFLOW");
        require((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2), "ERR_SUB_UNDERFLOW");
        require(((((arg3 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) - ((arg3 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1), "ERR_SUB_UNDERFLOW");
        require((arg2 * 0x0de0b6b3a7640000) + ((arg4 - arg2) / 0x02) / (arg4 - arg2) < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x05f5e100, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(!0x01, "ERR_SUB_UNDERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x05f5e100, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(!arg2, "ERR_DIV_INTERNAL");
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   transferFrom(address arg0, address arg1, uint256 arg2) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function transferFrom(address arg0, address arg1, uint256 arg2) public payable returns (bool) {
        require(address(arg0) == msg.sender, "ERR_BTOKEN_BAD_CALLER");
        var_a = msg.sender;
        require(!(arg2 > storage_map_b[var_a]), "ERR_BTOKEN_BAD_CALLER");
        var_a = address(arg0);
        require(!(arg2 > storage_map_b[var_a]), "ERR_INSUFFICIENT_BAL");
        var_a = address(arg0);
        require(storage_map_b[var_a] < arg2, "ERR_ADD_OVERFLOW");
        require(!0x01, "ERR_ADD_OVERFLOW");
        var_a = address(arg0);
        storage_map_b[var_a] = arg2 - storage_map_b[var_a];
        var_a = address(arg1);
        require(!((arg2 + storage_map_b[var_a]) < storage_map_b[var_a]), "ERR_ADD_OVERFLOW");
        var_a = address(arg1);
        storage_map_b[var_a] = arg2 + storage_map_b[var_a];
        emit Transfer(address(arg0), address(arg1), arg2);
        require(address(arg0) == msg.sender, "ERR_SUB_UNDERFLOW");
        var_a = msg.sender;
        require(!(!0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff == storage_map_b[var_a]), "ERR_SUB_UNDERFLOW");
        return 0x01;
        require(!(!(address(arg0)) == msg.sender), "ERR_SUB_UNDERFLOW");
        return 0x01;
        require(!0, "ERR_SUB_UNDERFLOW");
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   balanceOf(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function balanceOf(address arg0) public view returns (uint256) {
        address var_a = address(arg0);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0x34e19907
    /// @custom:signature   setSwapFee(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setSwapFee(uint256 arg0) public payable {
        emit Event_34e19907(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_REENTRY");
        decimals = 0x0100 | (uint248(decimals));
        require(!(bytes1(isFinalized)), "ERR_IS_FINALIZED");
        require(msg.sender == (address(isPublicSwap)), "ERR_NOT_CONTROLLER");
        require(!(arg0 < 0xe8d4a51000), "ERR_MAX_FEE");
        require(!(arg0 > 0x016345785d8a0000), "ERR_MAX_FEE");
        getSwapFee = arg0;
        decimals = uint248(decimals);
    }
    
    /// @custom:selector    0xb02f0b73
    /// @custom:signature   exitPool(uint256 arg0, uint256[] arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function exitPool(uint256 arg0, uint256[] arg1) public payable {
        require(!arg1 > 0x0100000000);
        emit Event_b02f0b73(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_REENTRY");
        decimals = 0x0100 | (uint248(decimals));
        require(bytes1(isFinalized), "ERR_MUL_OVERFLOW");
        require(!arg0, "ERR_MUL_OVERFLOW");
        require(arg0, "ERR_MUL_OVERFLOW");
        require(((0 * arg0) / arg0) == 0, "ERR_MUL_OVERFLOW");
        require(!(((0 * arg0) + 0x06f05b59d3b20000) < (0 * arg0)), "ERR_MUL_OVERFLOW");
        require(arg0 < (((0 * arg0) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000), "ERR_DIV_INTERNAL");
        require(!0x01, "ERR_DIV_INTERNAL");
        require(totalSupply, "ERR_DIV_INTERNAL");
        require(!((((0 * arg0) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - arg0), "ERR_DIV_INTERNAL");
        require((((0 * arg0) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - arg0, "ERR_DIV_INTERNAL");
        require((((((0 * arg0) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - arg0) * 0x0de0b6b3a7640000) / ((((0 * arg0) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - arg0) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((((((0 * arg0) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - arg0) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) < (((((0 * arg0) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - arg0) * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(totalSupply, "ERR_INSUFFICIENT_BAL");
        require((((((0 * arg0) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - arg0) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply, "ERR_INSUFFICIENT_BAL");
        address var_h = address(msg.sender);
        require(!(arg0 > storage_map_j[var_h]), "ERR_INSUFFICIENT_BAL");
        var_h = address(msg.sender);
        require(storage_map_j[var_h] < arg0, "ERR_ADD_OVERFLOW");
        require(!0x01, "ERR_ADD_OVERFLOW");
        var_h = address(msg.sender);
        storage_map_j[var_h] = arg0 - storage_map_j[var_h];
        var_h = address(this);
        require(!((arg0 + storage_map_j[var_h]) < storage_map_j[var_h]), "ERR_ADD_OVERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(!((((0 * arg0) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - arg0), "ERR_DIV_INTERNAL");
    }
    
    /// @custom:selector    0xcc77828d
    /// @custom:signature   getCurrentTokens() public view returns (bytes memory)
    function getCurrentTokens() public view returns (bytes memory) {
        require(!(bytes1(decimals / 0x0100)), "ERR_REENTRY");
        uint256 var_e = var_e + (0x20 + (0x20 * getNumTokens));
        if (!getNumTokens) {
            var_f = 0x09;
            if ((0x20 + var_e) + (0x20 * getNumTokens) > (0x20 + (0x20 + var_e))) {
                if (!0 < (var_e.length * 0x20)) {
                    return abi.encodePacked(0x20, var_e.length);
                }
            }
        }
    }
    
    /// @custom:selector    0x8c28cbe8
    /// @custom:signature   gulp(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function gulp(address arg0) public payable {
        emit Event_8c28cbe8(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_REENTRY");
        decimals = 0x0100 | (uint248(decimals));
        address var_h = address(arg0);
        require(bytes1(storage_map_j[var_h]));
        address var_f = address(this);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).balanceOf(var_f); // staticcall
        require(!ret0.length < 0x20);
        var_h = address(arg0);
        storage_map_s[var_h] = var_b.length;
        decimals = uint248(decimals);
    }
    
    /// @custom:selector    0x5db34277
    /// @custom:signature   joinswapExternAmountIn(address arg0, uint256 arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function joinswapExternAmountIn(address arg0, uint256 arg1, uint256 arg2) public payable {
        emit Event_5db34277(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_REENTRY");
        decimals = 0x0100 | (uint248(decimals));
        require(bytes1(isFinalized), "ERR_MUL_OVERFLOW");
        address var_h = address(arg0);
        require(bytes1(storage_map_j[var_h]), "ERR_MUL_OVERFLOW");
        var_h = address(arg0);
        require(!(storage_map_s[var_h]), "ERR_MUL_OVERFLOW");
        require(storage_map_s[var_h], "ERR_MUL_OVERFLOW");
        require((0x06f05b59d3b20000 * (storage_map_s[var_h])) / (storage_map_s[var_h]) == 0x06f05b59d3b20000, "ERR_MUL_OVERFLOW");
        require(!(((0x06f05b59d3b20000 * (storage_map_s[var_h])) + 0x06f05b59d3b20000) < (0x06f05b59d3b20000 * (storage_map_s[var_h]))), "ERR_MUL_OVERFLOW");
        require(!(arg1 > (((0x06f05b59d3b20000 * (storage_map_s[var_h])) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000)), "ERR_MAX_IN_RATIO");
        var_h = address(arg0);
        require(getTotalDenormalizedWeight, "ERR_DIV_INTERNAL");
        require(!(storage_map_n[var_h]), "ERR_DIV_INTERNAL");
        require(storage_map_n[var_h], "ERR_DIV_INTERNAL");
        require((storage_map_n[var_h] * 0x0de0b6b3a7640000) / (storage_map_n[var_h]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) < (storage_map_n[var_h] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(getTotalDenormalizedWeight, "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < ((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight), "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(!(((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!(((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!(((getSwapFee * (((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) < (getSwapFee * (((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000))), "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < (((getSwapFee * (((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(!arg1, "ERR_MUL_OVERFLOW");
        require(arg1, "ERR_MUL_OVERFLOW");
        require(((((((getSwapFee * (((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg1) / arg1) == ((((getSwapFee * (((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!(((((((getSwapFee * (((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg1) + 0x06f05b59d3b20000) < (((((getSwapFee * (((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg1)), "ERR_MUL_OVERFLOW");
        require(!((((((((getSwapFee * (((storage_map_n[var_h] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg1) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + (storage_map_o[var_h]) < (storage_map_o[var_h])), "ERR_ADD_OVERFLOW");
        require(storage_map_o[var_h], "ERR_DIV_ZERO");
        require(!arg1, "ERR_MUL_OVERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(!arg1, "ERR_MUL_OVERFLOW");
        require(arg1, "ERR_MUL_OVERFLOW");
        require(!arg1, "ERR_MUL_OVERFLOW");
        require(!(storage_map_n[var_h]), "ERR_DIV_INTERNAL");
    }
    
    /// @custom:selector    0xd73dd623
    /// @custom:signature   increaseApproval(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function increaseApproval(address arg0, uint256 arg1) public payable returns (bool) {
        var_a = address(arg0);
        require(!((arg1 + storage_map_b[var_a]) < storage_map_b[var_a]), "ERR_ADD_OVERFLOW");
        var_a = address(arg0);
        storage_map_b[var_a] = arg1 + storage_map_b[var_a];
        emit Approval(msg.sender, address(arg0), arg1 + storage_map_b[var_a]);
        return 0x01;
    }
    
    /// @custom:selector    0xcf5e7bd3
    /// @custom:signature   unbind(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function unbind(address arg0) public payable {
        emit Event_cf5e7bd3(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_REENTRY");
        decimals = 0x0100 | (uint248(decimals));
        require(address(isPublicSwap) == msg.sender, "ERR_NOT_CONTROLLER");
        address var_h = address(arg0);
        require(bytes1(storage_map_j[var_h]), "ERR_IS_FINALIZED");
        require(!(bytes1(isFinalized)), "ERR_IS_FINALIZED");
        var_h = address(arg0);
        require(!(storage_map_s[var_h]), "ERR_MUL_OVERFLOW");
        require(storage_map_s[var_h], "ERR_MUL_OVERFLOW");
        require((0 * (storage_map_s[var_h])) / (storage_map_s[var_h]) == 0, "ERR_MUL_OVERFLOW");
        require(!(((0 * (storage_map_s[var_h])) + 0x06f05b59d3b20000) < (0 * (storage_map_s[var_h]))), "ERR_MUL_OVERFLOW");
        var_h = address(arg0);
        require(getTotalDenormalizedWeight < (storage_map_q[var_h]));
        require(!0x01);
        getTotalDenormalizedWeight = (storage_map_q[var_h]) - getTotalDenormalizedWeight;
        require((getNumTokens + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < getNumTokens);
        var_h = 0x09;
        require(storage_map_m[var_h] < getNumTokens);
        var_h = 0x09;
        storage_map_w[var_h] = (address(storage_map_x[var_h]) * 0x01) | (uint96(storage_map_w[var_h]));
        require(storage_map_m[var_h] < getNumTokens);
        var_h = address(storage_map_y[storage_map_m[var_h]]);
        storage_map_m[var_h] = storage_map_m[var_h];
        require(getNumTokens);
        var_h = 0x09;
        storage_map_z[getNumTokens + keccak256(var_h)] = uint96(storage_map_z[getNumTokens + keccak256(var_h)]);
        getNumTokens = getNumTokens + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        uint256 var_b = var_b + 0x80;
        var_c = 0;
        var_h = address(arg0);
        storage_map_j[var_h] = var_b.length | (uint248(storage_map_j[var_h]));
        storage_map_aa[var_h] = var_l;
        storage_map_n[var_h] = var_m;
        storage_map_o[var_h] = var_n;
        require(storage_map_s[var_h] < (((0 * (storage_map_s[var_h])) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000));
        require(!0x01);
        address var_p = address(msg.sender);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: var_c ether }Unresolved_a9059cbb(var_p); // call
        require(!(ret0.length < 0x20), "ERR_ERC20_FALSE");
        require(var_b.length, "ERR_ERC20_FALSE");
        var_p = address(decimals / 0x010000);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: var_c ether }Unresolved_a9059cbb(var_p); // call
        require(!(ret0.length < 0x20), "ERR_ERC20_FALSE");
        require(var_b.length, "ERR_ERC20_FALSE");
        decimals = uint248(decimals);
        require(!0, "ERR_SUB_UNDERFLOW");
        var_p = address(msg.sender);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: var_c ether }Unresolved_a9059cbb(var_p); // call
        require(!(ret0.length < 0x20), "ERR_ERC20_FALSE");
        require(var_b.length, "ERR_ERC20_FALSE");
    }
    
    /// @custom:selector    0xbe3bbd2e
    /// @custom:signature   getFinalTokens() public view returns (bytes memory)
    function getFinalTokens() public view returns (bytes memory) {
        require(!(bytes1(decimals / 0x0100)), "ERR_REENTRY");
        require(bytes1(isFinalized), "ERR_NOT_FINALIZED");
        uint256 var_e = var_e + (0x20 + (0x20 * getNumTokens));
        require(!getNumTokens, "ERR_NOT_FINALIZED");
        var_f = 0x09;
        require((0x20 + var_e) + (0x20 * getNumTokens) > (0x20 + (0x20 + var_e)), "ERR_NOT_FINALIZED");
        require(!(0 < (var_e.length * 0x20)), "ERR_NOT_FINALIZED");
        return abi.encodePacked(0x20, var_e.length);
    }
    
    /// @custom:selector    0xa9059cbb
    /// @custom:signature   transfer(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function transfer(address arg0, uint256 arg1) public payable returns (bool) {
        address var_a = address(msg.sender);
        require(!(arg1 > storage_map_b[var_a]), "ERR_INSUFFICIENT_BAL");
        var_a = address(msg.sender);
        require(storage_map_b[var_a] < arg1, "ERR_ADD_OVERFLOW");
        require(!0x01, "ERR_ADD_OVERFLOW");
        var_a = address(msg.sender);
        storage_map_b[var_a] = arg1 - storage_map_b[var_a];
        var_a = address(arg0);
        require(!((arg1 + storage_map_b[var_a]) < storage_map_b[var_a]), "ERR_ADD_OVERFLOW");
        var_a = address(arg0);
        storage_map_b[var_a] = arg1 + storage_map_b[var_a];
        emit Transfer(address(msg.sender), address(arg0), arg1);
        return 0x01;
        require(!0, "ERR_SUB_UNDERFLOW");
    }
    
    /// @custom:selector    0x4bb278f3
    /// @custom:signature   Unresolved_4bb278f3(uint32 arg0) public payable
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function Unresolved_4bb278f3(uint32 arg0) public payable {
        emit Event_4bb278f3(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_REENTRY");
        decimals = 0x0100 | (uint248(decimals));
        require(address(isPublicSwap) == msg.sender, "ERR_NOT_CONTROLLER");
        require(!(bytes1(isFinalized)), "ERR_IS_FINALIZED");
        require(!(0x02 > getNumTokens), "ERR_ADD_OVERFLOW");
        isFinalized = 0x01 | (uint248(isFinalized));
        isPublicSwap = 0x010000000000000000000000000000000000000000 | (uint248(isPublicSwap));
        address var_h = address(this);
        require(!((0x056bc75e2d63100000 + storage_map_j[var_h]) < storage_map_j[var_h]), "ERR_ADD_OVERFLOW");
    }
    
    /// @custom:selector    0xba9530a6
    /// @custom:signature   calcOutGivenIn(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function calcOutGivenIn(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure {
        require(arg3, "ERR_DIV_INTERNAL");
        require(!arg1, "ERR_DIV_INTERNAL");
        require(arg1, "ERR_DIV_INTERNAL");
        require(((arg1 * 0x0de0b6b3a7640000) / arg1) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) < (arg1 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg3, "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < arg5, "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(!arg4, "ERR_MUL_OVERFLOW");
        require(arg4, "ERR_MUL_OVERFLOW");
        require((((arg5 - 0x0de0b6b3a7640000) * arg4) / arg4) == (arg5 - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) < ((arg5 - 0x0de0b6b3a7640000) * arg4)), "ERR_MUL_OVERFLOW");
        require(!((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) < arg0), "ERR_ADD_OVERFLOW");
        require(((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0, "ERR_DIV_INTERNAL");
        require(!arg0, "ERR_DIV_INTERNAL");
        require(arg0, "ERR_DIV_INTERNAL");
        require(((arg0 * 0x0de0b6b3a7640000) / arg0) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) < (arg0 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0, "ERR_BPOW_BASE_TOO_HIGH");
        require(!((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) < 0x01), "ERR_BPOW_BASE_TOO_HIGH");
        require(!((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) > 0x1bc16d674ec7ffff), "ERR_BPOW_BASE_TOO_HIGH");
        require(((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) < ((((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require((((((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) % 0x02, "ERR_MUL_OVERFLOW");
        require(!((((((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) / 0x02), "ERR_MUL_OVERFLOW");
        require(!((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0)), "ERR_MUL_OVERFLOW");
        require((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0), "ERR_MUL_OVERFLOW");
        require((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) * ((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0)) / ((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0)) == ((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0)), "ERR_MUL_OVERFLOW");
        require(!(((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) * ((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0)) + 0x06f05b59d3b20000) < ((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) * ((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0)))), "ERR_MUL_OVERFLOW");
        require(!(((((((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) / 0x02) % 0x02), "ERR_SUB_UNDERFLOW");
        require(!((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0)), "ERR_SUB_UNDERFLOW");
        require((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0), "ERR_SUB_UNDERFLOW");
        require(((((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) - ((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3), "ERR_SUB_UNDERFLOW");
        require((arg0 * 0x0de0b6b3a7640000) + ((((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) / 0x02) / (((((arg5 - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x05f5e100, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(!0x01, "ERR_SUB_UNDERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x05f5e100, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(!arg0, "ERR_DIV_INTERNAL");
    }
    
    /// @custom:selector    0x49b59552
    /// @custom:signature   Unresolved_49b59552(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_49b59552(uint256 arg0) public payable {
        emit Event_49b59552(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_IS_FINALIZED");
        decimals = 0x0100 | (uint248(decimals));
        require(!(bytes1(isFinalized)), "ERR_IS_FINALIZED");
        require(msg.sender == (address(isPublicSwap)), "ERR_NOT_CONTROLLER");
        isPublicSwap = (uint248(isPublicSwap)) | (0x010000000000000000000000000000000000000000 * arg0);
        decimals = uint248(decimals);
    }
    
    /// @custom:selector    0x4f69c0d4
    /// @custom:signature   joinPool(uint256 arg0, uint256[] arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function joinPool(uint256 arg0, uint256[] arg1) public payable {
        require(!arg1 > 0x0100000000);
        emit Event_4f69c0d4(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_DIV_INTERNAL");
        decimals = 0x0100 | (uint248(decimals));
        require(bytes1(isFinalized), "ERR_DIV_INTERNAL");
        require(totalSupply, "ERR_DIV_INTERNAL");
        require(!arg0, "ERR_DIV_INTERNAL");
        require(arg0, "ERR_DIV_INTERNAL");
        require(((arg0 * 0x0de0b6b3a7640000) / arg0) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) < (arg0 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(totalSupply, "ERR_MUL_OVERFLOW");
        require((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply, "ERR_MUL_OVERFLOW");
        require(!(0 < getNumTokens), "ERR_MUL_OVERFLOW");
        require(0 < getNumTokens, "ERR_MUL_OVERFLOW");
        address var_h = address(storage_map_ab[var_h]);
        require(!((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply), "ERR_MUL_OVERFLOW");
        require((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply, "ERR_MUL_OVERFLOW");
        require(storage_map_s[var_h] * ((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) / ((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) == (storage_map_s[var_h]), "ERR_MUL_OVERFLOW");
        require(!((storage_map_s[var_h] * ((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) + 0x06f05b59d3b20000) < (storage_map_s[var_h] * ((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply))), "ERR_MUL_OVERFLOW");
        require((storage_map_s[var_h] * ((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000, "ERR_LIMIT_IN");
        require(0 < (arg1), "ERR_LIMIT_IN");
        require(!(((storage_map_s[var_h] * ((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) > (0 + (0x20 + (arg1)))), "ERR_LIMIT_IN");
        var_h = address(storage_map_ab[var_h]);
        require(!(((storage_map_s[var_h] * ((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + (storage_map_s[var_h]) < (storage_map_s[var_h])), "ERR_ADD_OVERFLOW");
        var_h = address(storage_map_ab[var_h]);
        storage_map_s[var_h] = ((storage_map_s[var_h] * ((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + (storage_map_s[var_h]);
        emit LOG_JOIN(msg.sender, address(storage_map_ab[var_h]), (storage_map_s[var_h] * ((arg0 * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000);
        address var_f = address(msg.sender);
        require(address(storage_map_ab[var_h]).code.length);
        (bool success, bytes memory ret0) = address(storage_map_ab[var_h]).{ value: 0 ether }gasprice_bit_ether(var_f); // call
        require(!(ret0.length < 0x20), "ERR_ERC20_FALSE");
        require(var_b.length, "ERR_ERC20_FALSE");
        require(!arg0, "ERR_DIV_INTERNAL");
    }
    
    /// @custom:selector    0x8201aa3f
    /// @custom:signature   swapExactAmountIn(address arg0, uint256 arg1, address arg2, uint256 arg3, uint256 arg4) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function swapExactAmountIn(address arg0, uint256 arg1, address arg2, uint256 arg3, uint256 arg4) public payable {
        emit Event_8201aa3f(msg.sender, 0x20, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_MUL_OVERFLOW");
        decimals = 0x0100 | (uint248(decimals));
        address var_e = address(arg0);
        require(bytes1(storage_map_d[var_e]), "ERR_MUL_OVERFLOW");
        var_e = address(arg2);
        require(bytes1(storage_map_d[var_e]), "ERR_MUL_OVERFLOW");
        require(bytes1(isPublicSwap / 0x010000000000000000000000000000000000000000), "ERR_MUL_OVERFLOW");
        var_e = address(arg2);
        require(!(storage_map_f[var_e]), "ERR_MUL_OVERFLOW");
        require(storage_map_f[var_e], "ERR_MUL_OVERFLOW");
        require((0x06f05b59d3b20000 * (storage_map_f[var_e])) / (storage_map_f[var_e]) == 0x06f05b59d3b20000, "ERR_MUL_OVERFLOW");
        require(!(((0x06f05b59d3b20000 * (storage_map_f[var_e])) + 0x06f05b59d3b20000) < (0x06f05b59d3b20000 * (storage_map_f[var_e]))), "ERR_MUL_OVERFLOW");
        require(!(arg1 > (((0x06f05b59d3b20000 * (storage_map_f[var_e])) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000)), "ERR_MAX_IN_RATIO");
        require(storage_map_ac[var_e], "ERR_DIV_INTERNAL");
        require(!(storage_map_ad[var_e]), "ERR_DIV_INTERNAL");
        require(storage_map_ad[var_e], "ERR_DIV_INTERNAL");
        require((storage_map_ad[var_e] * 0x0de0b6b3a7640000) / (storage_map_ad[var_e]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) < (storage_map_ad[var_e] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(storage_map_ac[var_e], "ERR_DIV_INTERNAL");
        require(storage_map_ac[var_e], "ERR_DIV_INTERNAL");
        require(!(storage_map_ad[var_e]), "ERR_DIV_INTERNAL");
        require(storage_map_ad[var_e], "ERR_DIV_INTERNAL");
        require((storage_map_ad[var_e] * 0x0de0b6b3a7640000) / (storage_map_ad[var_e]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) < (storage_map_ad[var_e] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(storage_map_ac[var_e], "ERR_DIV_INTERNAL");
        require((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]), "ERR_DIV_INTERNAL");
        require(!((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e])), "ERR_DIV_INTERNAL");
        require((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]), "ERR_DIV_INTERNAL");
        require(((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e])) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!(((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) < ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]), "ERR_DIV_ZERO");
        require(0x0de0b6b3a7640000 < getSwapFee, "ERR_DIV_ZERO");
        require(!0x01, "ERR_DIV_ZERO");
        require(getSwapFee - 0x0de0b6b3a7640000, "ERR_DIV_ZERO");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) < 0xc097ce7bc90715b34b9f1000000000), "ERR_DIV_INTERNAL");
        require(getSwapFee - 0x0de0b6b3a7640000, "ERR_MUL_OVERFLOW");
        require(!(((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))), "ERR_MUL_OVERFLOW");
        require(((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e])), "ERR_MUL_OVERFLOW");
        require((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))) / (((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))) == ((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000)), "ERR_MUL_OVERFLOW");
        require(!(((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))) + 0x06f05b59d3b20000) < ((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))))), "ERR_MUL_OVERFLOW");
        require(!((((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) > arg4), "ERR_BAD_LIMIT_PRICE");
        require(0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(0x0de0b6b3a7640000 == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0, "ERR_SUB_UNDERFLOW");
    }
    
    /// @custom:selector    0x8656b653
    /// @custom:signature   calcPoolOutGivenSingleIn(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function calcPoolOutGivenSingleIn(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure {
        require(arg3, "ERR_DIV_INTERNAL");
        require(!arg1, "ERR_DIV_INTERNAL");
        require(arg1, "ERR_DIV_INTERNAL");
        require(((arg1 * 0x0de0b6b3a7640000) / arg1) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) < (arg1 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg3, "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < ((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3), "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(!(((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!(((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!(((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) < (arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000))), "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < (((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(!arg4, "ERR_MUL_OVERFLOW");
        require(arg4, "ERR_MUL_OVERFLOW");
        require(((((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4) / arg4) == ((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!(((((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) < (((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4)), "ERR_MUL_OVERFLOW");
        require(!(((((((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) < arg0), "ERR_ADD_OVERFLOW");
        require(arg0, "ERR_DIV_INTERNAL");
        require(!((((((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0), "ERR_DIV_INTERNAL");
        require((((((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0, "ERR_DIV_INTERNAL");
        require((((((((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) * 0x0de0b6b3a7640000) / ((((((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((((((((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) * 0x0de0b6b3a7640000) + (arg0 / 0x02) < (((((((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0) * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg0, "ERR_DIV_INTERNAL");
        require(!((((((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) * arg4) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) + arg0), "ERR_DIV_INTERNAL");
        require(!arg4, "ERR_MUL_OVERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(!arg4, "ERR_MUL_OVERFLOW");
        require(arg4, "ERR_MUL_OVERFLOW");
        require(!arg4, "ERR_MUL_OVERFLOW");
    }
    
    /// @custom:selector    0x3fdddaa2
    /// @custom:signature   rebind(address arg0, uint256 arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function rebind(address arg0, uint256 arg1, uint256 arg2) public payable {
        emit Event_3fdddaa2(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_NOT_CONTROLLER");
        decimals = 0x0100 | (uint248(decimals));
        require(address(isPublicSwap) == msg.sender, "ERR_NOT_CONTROLLER");
        address var_h = address(arg0);
        require(bytes1(storage_map_j[var_h]), "ERR_IS_FINALIZED");
        require(!(bytes1(isFinalized)), "ERR_IS_FINALIZED");
        require(!(arg2 < 0x0de0b6b3a7640000), "ERR_MAX_WEIGHT");
        require(!(arg2 > 0x02b5e3af16b1880000), "ERR_MAX_WEIGHT");
        require(!(arg1 < 0x0f4240), "ERR_ADD_OVERFLOW");
        var_h = address(arg0);
        require(!(arg2 > (storage_map_q[var_h])), "ERR_ADD_OVERFLOW");
        require(arg2 < (storage_map_q[var_h]), "ERR_ADD_OVERFLOW");
        require(!0x01, "ERR_ADD_OVERFLOW");
        require(!(((storage_map_q[var_h] - arg2) + getTotalDenormalizedWeight) < getTotalDenormalizedWeight), "ERR_ADD_OVERFLOW");
        getTotalDenormalizedWeight = (storage_map_q[var_h] - arg2) + getTotalDenormalizedWeight;
        require(!(0x02b5e3af16b1880000 < ((storage_map_q[var_h] - arg2) + getTotalDenormalizedWeight)), "ERR_MAX_TOTAL_WEIGHT");
        var_h = address(arg0);
        storage_map_n[var_h] = arg2;
        storage_map_s[var_h] = arg1;
        require(!arg1 > (storage_map_s[var_h]));
        require(arg1 < (storage_map_s[var_h]));
        require(!0x01);
        address var_f = address(msg.sender);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }gasprice_bit_ether(var_f); // call
        require(!(ret0.length < 0x20), "ERR_ERC20_FALSE");
        require(var_b.length, "ERR_ERC20_FALSE");
        decimals = uint248(decimals);
        require(!0, "ERR_SUB_UNDERFLOW");
        var_f = address(msg.sender);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }gasprice_bit_ether(var_f); // call
        require(!(ret0.length < 0x20), "ERR_ERC20_FALSE");
        require(var_b.length, "ERR_ERC20_FALSE");
        decimals = uint248(decimals);
        require(!(arg1 < (storage_map_s[var_h])), "ERR_SUB_UNDERFLOW");
        decimals = uint248(decimals);
        if (!arg2 < (storage_map_q[var_h])) {
        }
    }
    
    /// @custom:selector    0xa221ee49
    /// @custom:signature   calcSpotPrice(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4) public pure returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function calcSpotPrice(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4) public pure returns (uint256) {
        require(arg1, "ERR_DIV_INTERNAL");
        require(!arg0, "ERR_DIV_INTERNAL");
        require(arg0, "ERR_DIV_INTERNAL");
        require(((arg0 * 0x0de0b6b3a7640000) / arg0) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) < (arg0 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg1, "ERR_DIV_INTERNAL");
        require(arg3, "ERR_DIV_INTERNAL");
        require(!arg2, "ERR_DIV_INTERNAL");
        require(arg2, "ERR_DIV_INTERNAL");
        require(((arg2 * 0x0de0b6b3a7640000) / arg2) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) < (arg2 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg3, "ERR_DIV_INTERNAL");
        require((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3, "ERR_DIV_INTERNAL");
        require(!((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1), "ERR_DIV_INTERNAL");
        require((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1, "ERR_DIV_INTERNAL");
        require((((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) * 0x0de0b6b3a7640000) / ((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) * 0x0de0b6b3a7640000) + (((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02) < (((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3, "ERR_DIV_ZERO");
        require(0x0de0b6b3a7640000 < arg4, "ERR_DIV_ZERO");
        require(!0x01, "ERR_DIV_ZERO");
        require(arg4 - 0x0de0b6b3a7640000, "ERR_DIV_ZERO");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((0xc097ce7bc90715b34b9f1000000000 + ((arg4 - 0x0de0b6b3a7640000) / 0x02)) < 0xc097ce7bc90715b34b9f1000000000), "ERR_DIV_INTERNAL");
        require(arg4 - 0x0de0b6b3a7640000, "ERR_MUL_OVERFLOW");
        require(!((((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) * 0x0de0b6b3a7640000) + (((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02) / ((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3)), "ERR_MUL_OVERFLOW");
        require((((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) * 0x0de0b6b3a7640000) + (((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02) / ((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3), "ERR_MUL_OVERFLOW");
        require((0xc097ce7bc90715b34b9f1000000000 + ((arg4 - 0x0de0b6b3a7640000) / 0x02)) / (arg4 - 0x0de0b6b3a7640000) * ((((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) * 0x0de0b6b3a7640000) + (((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02) / ((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3)) / ((((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) * 0x0de0b6b3a7640000) + (((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02) / ((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3)) == ((0xc097ce7bc90715b34b9f1000000000 + ((arg4 - 0x0de0b6b3a7640000) / 0x02)) / (arg4 - 0x0de0b6b3a7640000)), "ERR_MUL_OVERFLOW");
        require(!(((0xc097ce7bc90715b34b9f1000000000 + ((arg4 - 0x0de0b6b3a7640000) / 0x02)) / (arg4 - 0x0de0b6b3a7640000) * ((((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) * 0x0de0b6b3a7640000) + (((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02) / ((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3)) + 0x06f05b59d3b20000) < ((0xc097ce7bc90715b34b9f1000000000 + ((arg4 - 0x0de0b6b3a7640000) / 0x02)) / (arg4 - 0x0de0b6b3a7640000) * ((((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) * 0x0de0b6b3a7640000) + (((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02) / ((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3)))), "ERR_MUL_OVERFLOW");
        return ((0xc097ce7bc90715b34b9f1000000000 + ((arg4 - 0x0de0b6b3a7640000) / 0x02)) / (arg4 - 0x0de0b6b3a7640000) * ((((arg0 * 0x0de0b6b3a7640000) + (arg1 / 0x02) / arg1) * 0x0de0b6b3a7640000) + (((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02) / ((arg2 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000;
        require(0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(0x0de0b6b3a7640000 == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0, "ERR_SUB_UNDERFLOW");
    }
    
    /// @custom:selector    0x5c1bbaf7
    /// @custom:signature   calcSingleInGivenPoolOut(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function calcSingleInGivenPoolOut(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure {
        require(arg3, "ERR_DIV_INTERNAL");
        require(!arg1, "ERR_DIV_INTERNAL");
        require(arg1, "ERR_DIV_INTERNAL");
        require(((arg1 * 0x0de0b6b3a7640000) / arg1) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) < (arg1 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg3, "ERR_ADD_OVERFLOW");
        require(!((arg4 + arg2) < arg2), "ERR_ADD_OVERFLOW");
        require(arg2, "ERR_DIV_INTERNAL");
        require(!(arg4 + arg2), "ERR_DIV_INTERNAL");
        require(arg4 + arg2, "ERR_DIV_INTERNAL");
        require(((arg4 + arg2) * 0x0de0b6b3a7640000) / (arg4 + arg2) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!(((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) < ((arg4 + arg2) * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg2, "ERR_DIV_INTERNAL");
        require((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3, "ERR_DIV_INTERNAL");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((0xc097ce7bc90715b34b9f1000000000 + (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02)) < 0xc097ce7bc90715b34b9f1000000000), "ERR_DIV_INTERNAL");
        require((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3, "ERR_BPOW_BASE_TOO_HIGH");
        require(!((((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2) < 0x01), "ERR_BPOW_BASE_TOO_HIGH");
        require(!((((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2) > 0x1bc16d674ec7ffff), "ERR_BPOW_BASE_TOO_HIGH");
        require((0xc097ce7bc90715b34b9f1000000000 + (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02)) / ((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) < (((0xc097ce7bc90715b34b9f1000000000 + (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02)) / ((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(((((0xc097ce7bc90715b34b9f1000000000 + (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02)) / ((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) % 0x02, "ERR_MUL_OVERFLOW");
        require(!(((((0xc097ce7bc90715b34b9f1000000000 + (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02)) / ((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) / 0x02), "ERR_MUL_OVERFLOW");
        require(!(((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2), "ERR_MUL_OVERFLOW");
        require(((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2, "ERR_MUL_OVERFLOW");
        require((((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2) * (((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2) / (((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2) == (((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2), "ERR_MUL_OVERFLOW");
        require(!(((((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2) * (((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2) + 0x06f05b59d3b20000) < ((((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2) * (((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2))), "ERR_MUL_OVERFLOW");
        require(!((((((0xc097ce7bc90715b34b9f1000000000 + (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02)) / ((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) / 0x02) % 0x02), "ERR_SUB_UNDERFLOW");
        require(!(((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2), "ERR_SUB_UNDERFLOW");
        require(((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2, "ERR_SUB_UNDERFLOW");
        require((((0xc097ce7bc90715b34b9f1000000000 + (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02)) / ((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) - ((0xc097ce7bc90715b34b9f1000000000 + (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) / 0x02)) / ((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3)), "ERR_SUB_UNDERFLOW");
        require((((arg4 + arg2) * 0x0de0b6b3a7640000) + (arg2 / 0x02) / arg2) < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x05f5e100, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(!0x01, "ERR_SUB_UNDERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x05f5e100, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(0x0de0b6b3a7640000 == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
    }
    
    /// @custom:selector    0x948d8ce6
    /// @custom:signature   getDenormalizedWeight(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getDenormalizedWeight(address arg0) public view returns (uint256) {
        require(!(bytes1(decimals / 0x0100)), "ERR_NOT_BOUND");
        address var_a = address(arg0);
        require(bytes1(storage_map_b[var_a]), "ERR_NOT_BOUND");
        var_a = address(arg0);
        return storage_map_ae[var_a];
    }
    
    /// @custom:selector    0x92eefe9b
    /// @custom:signature   setController(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setController(address arg0) public payable {
        emit Event_92eefe9b(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_NOT_CONTROLLER");
        decimals = 0x0100 | (uint248(decimals));
        require(address(isPublicSwap) == msg.sender, "ERR_NOT_CONTROLLER");
        isPublicSwap = (address(arg0)) | (uint96(isPublicSwap));
        decimals = uint248(decimals);
    }
    
    /// @custom:selector    0xf1b8a9b7
    /// @custom:signature   getNormalizedWeight(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getNormalizedWeight(address arg0) public view returns (uint256) {
        require(!(bytes1(decimals / 0x0100)), "ERR_DIV_INTERNAL");
        address var_a = address(arg0);
        require(bytes1(storage_map_b[var_a]), "ERR_DIV_INTERNAL");
        var_a = address(arg0);
        require(getTotalDenormalizedWeight, "ERR_DIV_INTERNAL");
        require(!(storage_map_ae[var_a]), "ERR_DIV_INTERNAL");
        require(storage_map_ae[var_a], "ERR_DIV_INTERNAL");
        require((storage_map_ae[var_a] * 0x0de0b6b3a7640000) / (storage_map_ae[var_a]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_ae[var_a] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) < (storage_map_ae[var_a] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(getTotalDenormalizedWeight, "ERR_DIV_INTERNAL");
        return ((storage_map_ae[var_a] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02)) / getTotalDenormalizedWeight;
        require(!(storage_map_ae[var_a]), "ERR_DIV_INTERNAL");
    }
    
    /// @custom:selector    0x82f652ad
    /// @custom:signature   calcPoolInGivenSingleOut(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function calcPoolInGivenSingleOut(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure {
        require(arg3, "ERR_DIV_INTERNAL");
        require(!arg1, "ERR_DIV_INTERNAL");
        require(arg1, "ERR_DIV_INTERNAL");
        require(((arg1 * 0x0de0b6b3a7640000) / arg1) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) < (arg1 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg3, "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < ((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3), "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(!(((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!(((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!(((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) < (arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000))), "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < (((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000), "ERR_DIV_ZERO");
        require(!0x01, "ERR_DIV_ZERO");
        require((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000, "ERR_DIV_ZERO");
        require(!arg4, "ERR_DIV_INTERNAL");
        require(arg4, "ERR_DIV_INTERNAL");
        require(((arg4 * 0x0de0b6b3a7640000) / arg4) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg4 * 0x0de0b6b3a7640000) + (((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) / 0x02) < (arg4 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require((((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!arg4, "ERR_DIV_INTERNAL");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000, "ERR_MUL_OVERFLOW");
        require((arg5 * (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000)) / (((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) / arg3) - 0x0de0b6b3a7640000) == arg5, "ERR_MUL_OVERFLOW");
    }
    
    /// @custom:selector    0xf8b2cb4f
    /// @custom:signature   getBalance(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getBalance(address arg0) public view returns (uint256) {
        require(!(bytes1(decimals / 0x0100)), "ERR_NOT_BOUND");
        address var_a = address(arg0);
        require(bytes1(storage_map_b[var_a]), "ERR_NOT_BOUND");
        var_a = address(arg0);
        return storage_map_af[var_a];
    }
    
    /// @custom:selector    0x6d06dfa0
    /// @custom:signature   joinswapPoolAmountOut(address arg0, uint256 arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function joinswapPoolAmountOut(address arg0, uint256 arg1, uint256 arg2) public payable {
        emit Event_6d06dfa0(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_DIV_INTERNAL");
        decimals = 0x0100 | (uint248(decimals));
        require(bytes1(isFinalized), "ERR_DIV_INTERNAL");
        address var_f = address(arg0);
        require(bytes1(storage_map_v[var_f]), "ERR_DIV_INTERNAL");
        var_f = address(arg0);
        require(getTotalDenormalizedWeight, "ERR_DIV_INTERNAL");
        require(!(storage_map_ag[var_f]), "ERR_DIV_INTERNAL");
        require(storage_map_ag[var_f], "ERR_DIV_INTERNAL");
        require((storage_map_ag[var_f] * 0x0de0b6b3a7640000) / (storage_map_ag[var_f]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) < (storage_map_ag[var_f] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(getTotalDenormalizedWeight, "ERR_ADD_OVERFLOW");
        require(!((arg1 + totalSupply) < totalSupply), "ERR_ADD_OVERFLOW");
        require(totalSupply, "ERR_DIV_INTERNAL");
        require(!(arg1 + totalSupply), "ERR_DIV_INTERNAL");
        require(arg1 + totalSupply, "ERR_DIV_INTERNAL");
        require(((arg1 + totalSupply) * 0x0de0b6b3a7640000) / (arg1 + totalSupply) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!(((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) < ((arg1 + totalSupply) * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(totalSupply, "ERR_DIV_INTERNAL");
        require((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight, "ERR_DIV_INTERNAL");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((0xc097ce7bc90715b34b9f1000000000 + (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x02)) < 0xc097ce7bc90715b34b9f1000000000), "ERR_DIV_INTERNAL");
        require((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight, "ERR_BPOW_BASE_TOO_HIGH");
        require(!((((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) < 0x01), "ERR_BPOW_BASE_TOO_HIGH");
        require(!((((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) > 0x1bc16d674ec7ffff), "ERR_BPOW_BASE_TOO_HIGH");
        require((0xc097ce7bc90715b34b9f1000000000 + (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x02)) / ((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) < (((0xc097ce7bc90715b34b9f1000000000 + (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x02)) / ((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(((((0xc097ce7bc90715b34b9f1000000000 + (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x02)) / ((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) % 0x02, "ERR_MUL_OVERFLOW");
        require(!(((((0xc097ce7bc90715b34b9f1000000000 + (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x02)) / ((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) / 0x02), "ERR_MUL_OVERFLOW");
        require(!(((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply), "ERR_MUL_OVERFLOW");
        require(((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply, "ERR_MUL_OVERFLOW");
        require((((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) * (((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) / (((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) == (((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply), "ERR_MUL_OVERFLOW");
        require(!(((((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) * (((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) + 0x06f05b59d3b20000) < ((((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) * (((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply))), "ERR_MUL_OVERFLOW");
        if (!(((((0xc097ce7bc90715b34b9f1000000000 + (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x02)) / ((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) / 0x0de0b6b3a7640000) / 0x02) % 0x02) {
        }
        require((((0xc097ce7bc90715b34b9f1000000000 + (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x02)) / ((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x0de0b6b3a7640000) * 0x0de0b6b3a7640000) - ((0xc097ce7bc90715b34b9f1000000000 + (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) / 0x02)) / ((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight)), "ERR_SUB_UNDERFLOW");
        require((((arg1 + totalSupply) * 0x0de0b6b3a7640000) + (totalSupply / 0x02) / totalSupply) < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x05f5e100, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(!0x01, "ERR_SUB_UNDERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x05f5e100, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000 < 0x0de0b6b3a7640000, "ERR_SUB_UNDERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(0x0de0b6b3a7640000 == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
    }
    
    /// @custom:selector    0x15e84af9
    /// @custom:signature   getSpotPrice(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function getSpotPrice(address arg0, address arg1) public view returns (uint256) {
        require(!(bytes1(decimals / 0x0100)), "ERR_DIV_INTERNAL");
        address var_a = address(arg0);
        require(bytes1(storage_map_b[var_a]), "ERR_DIV_INTERNAL");
        var_a = address(arg1);
        require(bytes1(storage_map_b[var_a]), "ERR_DIV_INTERNAL");
        var_a = address(arg1);
        require(storage_map_ah[var_a], "ERR_DIV_INTERNAL");
        require(!(storage_map_ai[var_a]), "ERR_DIV_INTERNAL");
        require(storage_map_ai[var_a], "ERR_DIV_INTERNAL");
        require((storage_map_ai[var_a] * 0x0de0b6b3a7640000) / (storage_map_ai[var_a]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) < (storage_map_ai[var_a] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(storage_map_ah[var_a], "ERR_DIV_INTERNAL");
        require(storage_map_ah[var_a], "ERR_DIV_INTERNAL");
        require(!(storage_map_ai[var_a]), "ERR_DIV_INTERNAL");
        require(storage_map_ai[var_a], "ERR_DIV_INTERNAL");
        require((storage_map_ai[var_a] * 0x0de0b6b3a7640000) / (storage_map_ai[var_a]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) < (storage_map_ai[var_a] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(storage_map_ah[var_a], "ERR_DIV_INTERNAL");
        require((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]), "ERR_DIV_INTERNAL");
        require(!((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a])), "ERR_DIV_INTERNAL");
        require((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]), "ERR_DIV_INTERNAL");
        require(((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) * 0x0de0b6b3a7640000) / ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a])) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!(((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) * 0x0de0b6b3a7640000) + ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) / 0x02) < ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]), "ERR_DIV_ZERO");
        require(0x0de0b6b3a7640000 < getSwapFee, "ERR_DIV_ZERO");
        require(!0x01, "ERR_DIV_ZERO");
        require(getSwapFee - 0x0de0b6b3a7640000, "ERR_DIV_ZERO");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) < 0xc097ce7bc90715b34b9f1000000000), "ERR_DIV_INTERNAL");
        require(getSwapFee - 0x0de0b6b3a7640000, "ERR_MUL_OVERFLOW");
        require(!(((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) * 0x0de0b6b3a7640000) + ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) / 0x02) / ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]))), "ERR_MUL_OVERFLOW");
        require(((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) * 0x0de0b6b3a7640000) + ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) / 0x02) / ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a])), "ERR_MUL_OVERFLOW");
        require((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) * 0x0de0b6b3a7640000) + ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) / 0x02) / ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]))) / (((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) * 0x0de0b6b3a7640000) + ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) / 0x02) / ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]))) == ((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000)), "ERR_MUL_OVERFLOW");
        require(!(((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) * 0x0de0b6b3a7640000) + ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) / 0x02) / ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]))) + 0x06f05b59d3b20000) < ((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) * 0x0de0b6b3a7640000) + ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) / 0x02) / ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]))))), "ERR_MUL_OVERFLOW");
        return ((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) * 0x0de0b6b3a7640000) + ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]) / 0x02) / ((storage_map_ai[var_a] * 0x0de0b6b3a7640000) + (storage_map_ah[var_a] / 0x02) / (storage_map_ah[var_a]))) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000;
        require(0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(0x0de0b6b3a7640000 == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0, "ERR_SUB_UNDERFLOW");
    }
    
    /// @custom:selector    0x02c96748
    /// @custom:signature   exitswapExternAmountOut(address arg0, uint256 arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function exitswapExternAmountOut(address arg0, uint256 arg1, uint256 arg2) public payable {
        emit Event_02c96748(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_MUL_OVERFLOW");
        decimals = 0x0100 | (uint248(decimals));
        require(bytes1(isFinalized), "ERR_MUL_OVERFLOW");
        address var_f = address(arg0);
        require(bytes1(storage_map_v[var_f]), "ERR_MUL_OVERFLOW");
        var_f = address(arg0);
        require(!(storage_map_aj[var_f]), "ERR_MUL_OVERFLOW");
        require(storage_map_aj[var_f], "ERR_MUL_OVERFLOW");
        require((0x04a03ce68d215556 * (storage_map_aj[var_f])) / (storage_map_aj[var_f]) == 0x04a03ce68d215556, "ERR_MUL_OVERFLOW");
        require(!(((0x04a03ce68d215556 * (storage_map_aj[var_f])) + 0x06f05b59d3b20000) < (0x04a03ce68d215556 * (storage_map_aj[var_f]))), "ERR_MUL_OVERFLOW");
        require(!(arg1 > (((0x04a03ce68d215556 * (storage_map_aj[var_f])) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000)), "ERR_MAX_OUT_RATIO");
        var_f = address(arg0);
        require(getTotalDenormalizedWeight, "ERR_DIV_INTERNAL");
        require(!(storage_map_ag[var_f]), "ERR_DIV_INTERNAL");
        require(storage_map_ag[var_f], "ERR_DIV_INTERNAL");
        require((storage_map_ag[var_f] * 0x0de0b6b3a7640000) / (storage_map_ag[var_f]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) < (storage_map_ag[var_f] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(getTotalDenormalizedWeight, "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < ((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight), "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(!(((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!(((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000), "ERR_MUL_OVERFLOW");
        require(!(((getSwapFee * (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) < (getSwapFee * (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000))), "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < (((getSwapFee * (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000), "ERR_DIV_ZERO");
        require(!0x01, "ERR_DIV_ZERO");
        require((((getSwapFee * (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000, "ERR_DIV_ZERO");
        require(!arg1, "ERR_DIV_INTERNAL");
        require(arg1, "ERR_DIV_INTERNAL");
        require(((arg1 * 0x0de0b6b3a7640000) / arg1) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg1 * 0x0de0b6b3a7640000) + (((((getSwapFee * (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000) / 0x02) < (arg1 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require((((getSwapFee * (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) - 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!arg1, "ERR_DIV_INTERNAL");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000, "ERR_MUL_OVERFLOW");
        require((getSwapFee * (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000)) / (((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) / getTotalDenormalizedWeight) - 0x0de0b6b3a7640000) == getSwapFee, "ERR_MUL_OVERFLOW");
    }
    
    /// @custom:selector    0x2f37b624
    /// @custom:signature   isBound(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function isBound(address arg0) public view returns (bool) {
        address var_a = address(arg0);
        return !(!bytes1(storage_map_b[var_a]));
    }
    
    /// @custom:selector    0x46ab38f1
    /// @custom:signature   exitswapPoolAmountIn(address arg0, uint256 arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function exitswapPoolAmountIn(address arg0, uint256 arg1, uint256 arg2) public payable {
        emit Event_46ab38f1(address(msg.sender), (0x20 + var_b) - var_b, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_DIV_INTERNAL");
        decimals = 0x0100 | (uint248(decimals));
        require(bytes1(isFinalized), "ERR_DIV_INTERNAL");
        address var_f = address(arg0);
        require(bytes1(storage_map_v[var_f]), "ERR_DIV_INTERNAL");
        var_f = address(arg0);
        require(getTotalDenormalizedWeight, "ERR_DIV_INTERNAL");
        require(!(storage_map_ag[var_f]), "ERR_DIV_INTERNAL");
        require(storage_map_ag[var_f], "ERR_DIV_INTERNAL");
        require((storage_map_ag[var_f] * 0x0de0b6b3a7640000) / (storage_map_ag[var_f]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_ag[var_f] * 0x0de0b6b3a7640000) + (getTotalDenormalizedWeight / 0x02) < (storage_map_ag[var_f] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(getTotalDenormalizedWeight, "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < 0, "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(!arg1, "ERR_MUL_OVERFLOW");
        require(arg1, "ERR_MUL_OVERFLOW");
        require(((0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000 * arg1) / arg1) == 0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000, "ERR_MUL_OVERFLOW");
        require(!(((0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000 * arg1) + 0x06f05b59d3b20000) < (0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000 * arg1)), "ERR_MUL_OVERFLOW");
        require(!arg1, "ERR_MUL_OVERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(!arg1, "ERR_MUL_OVERFLOW");
        require(arg1, "ERR_MUL_OVERFLOW");
        require(!arg1, "ERR_MUL_OVERFLOW");
        require(!(storage_map_ag[var_f]), "ERR_DIV_INTERNAL");
    }
    
    /// @custom:selector    0x7c5e9ea4
    /// @custom:signature   swapExactAmountOut(address arg0, uint256 arg1, address arg2, uint256 arg3, uint256 arg4) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function swapExactAmountOut(address arg0, uint256 arg1, address arg2, uint256 arg3, uint256 arg4) public payable {
        emit Event_7c5e9ea4(msg.sender, 0x20, msg.data.length);
        require(!(bytes1(decimals / 0x0100)), "ERR_MUL_OVERFLOW");
        decimals = 0x0100 | (uint248(decimals));
        address var_e = address(arg0);
        require(bytes1(storage_map_d[var_e]), "ERR_MUL_OVERFLOW");
        var_e = address(arg2);
        require(bytes1(storage_map_d[var_e]), "ERR_MUL_OVERFLOW");
        require(bytes1(isPublicSwap / 0x010000000000000000000000000000000000000000), "ERR_MUL_OVERFLOW");
        var_e = address(arg2);
        require(!(storage_map_f[var_e]), "ERR_MUL_OVERFLOW");
        require(storage_map_f[var_e], "ERR_MUL_OVERFLOW");
        require((0x04a03ce68d215556 * (storage_map_f[var_e])) / (storage_map_f[var_e]) == 0x04a03ce68d215556, "ERR_MUL_OVERFLOW");
        require(!(((0x04a03ce68d215556 * (storage_map_f[var_e])) + 0x06f05b59d3b20000) < (0x04a03ce68d215556 * (storage_map_f[var_e]))), "ERR_MUL_OVERFLOW");
        require(!(arg3 > (((0x04a03ce68d215556 * (storage_map_f[var_e])) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000)), "ERR_MAX_OUT_RATIO");
        require(storage_map_ac[var_e], "ERR_DIV_INTERNAL");
        require(!(storage_map_ad[var_e]), "ERR_DIV_INTERNAL");
        require(storage_map_ad[var_e], "ERR_DIV_INTERNAL");
        require((storage_map_ad[var_e] * 0x0de0b6b3a7640000) / (storage_map_ad[var_e]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) < (storage_map_ad[var_e] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(storage_map_ac[var_e], "ERR_DIV_INTERNAL");
        require(storage_map_ac[var_e], "ERR_DIV_INTERNAL");
        require(!(storage_map_ad[var_e]), "ERR_DIV_INTERNAL");
        require(storage_map_ad[var_e], "ERR_DIV_INTERNAL");
        require((storage_map_ad[var_e] * 0x0de0b6b3a7640000) / (storage_map_ad[var_e]) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) < (storage_map_ad[var_e] * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(storage_map_ac[var_e], "ERR_DIV_INTERNAL");
        require((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]), "ERR_DIV_INTERNAL");
        require(!((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e])), "ERR_DIV_INTERNAL");
        require((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]), "ERR_DIV_INTERNAL");
        require(((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e])) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!(((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) < ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]), "ERR_DIV_ZERO");
        require(0x0de0b6b3a7640000 < getSwapFee, "ERR_DIV_ZERO");
        require(!0x01, "ERR_DIV_ZERO");
        require(getSwapFee - 0x0de0b6b3a7640000, "ERR_DIV_ZERO");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) < 0xc097ce7bc90715b34b9f1000000000), "ERR_DIV_INTERNAL");
        require(getSwapFee - 0x0de0b6b3a7640000, "ERR_MUL_OVERFLOW");
        require(!(((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))), "ERR_MUL_OVERFLOW");
        require(((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e])), "ERR_MUL_OVERFLOW");
        require((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))) / (((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))) == ((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000)), "ERR_MUL_OVERFLOW");
        require(!(((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))) + 0x06f05b59d3b20000) < ((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))))), "ERR_MUL_OVERFLOW");
        require(!((((0xc097ce7bc90715b34b9f1000000000 + ((getSwapFee - 0x0de0b6b3a7640000) / 0x02)) / (getSwapFee - 0x0de0b6b3a7640000) * (((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) * 0x0de0b6b3a7640000) + ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]) / 0x02) / ((storage_map_ad[var_e] * 0x0de0b6b3a7640000) + (storage_map_ac[var_e] / 0x02) / (storage_map_ac[var_e]))) + 0x06f05b59d3b20000) / 0x0de0b6b3a7640000) > arg4), "ERR_BAD_LIMIT_PRICE");
        require(0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(0x0de0b6b3a7640000 == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!0, "ERR_SUB_UNDERFLOW");
    }
    
    /// @custom:selector    0x89298012
    /// @custom:signature   calcSingleOutGivenPoolIn(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function calcSingleOutGivenPoolIn(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public pure {
        require(arg3, "ERR_DIV_INTERNAL");
        require(!arg1, "ERR_DIV_INTERNAL");
        require(arg1, "ERR_DIV_INTERNAL");
        require(((arg1 * 0x0de0b6b3a7640000) / arg1) == 0x0de0b6b3a7640000, "ERR_DIV_INTERNAL");
        require(!((arg1 * 0x0de0b6b3a7640000) + (arg3 / 0x02) < (arg1 * 0x0de0b6b3a7640000)), "ERR_DIV_INTERNAL");
        require(arg3, "ERR_MUL_OVERFLOW");
        require(0x0de0b6b3a7640000 < 0, "ERR_MUL_OVERFLOW");
        require(!0x01, "ERR_MUL_OVERFLOW");
        require(!arg4, "ERR_MUL_OVERFLOW");
        require(arg4, "ERR_MUL_OVERFLOW");
        require(((0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000 * arg4) / arg4) == 0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000, "ERR_MUL_OVERFLOW");
        require(!(((0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000 * arg4) + 0x06f05b59d3b20000) < (0xfffffffffffffffffffffffffffffffffffffffffffffffff21f494c589c0000 * arg4)), "ERR_MUL_OVERFLOW");
        require(!arg4, "ERR_MUL_OVERFLOW");
        require(!0, "ERR_SUB_UNDERFLOW");
        require(!arg4, "ERR_MUL_OVERFLOW");
        require(arg4, "ERR_MUL_OVERFLOW");
        require(!arg4, "ERR_MUL_OVERFLOW");
        require(!arg1, "ERR_DIV_INTERNAL");
    }
}

ABI

[
  {
    "type": "function",
    "name": "BONE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "BPOW_PRECISION",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "EXIT_FEE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "INIT_POOL_SUPPLY",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MAX_BOUND_TOKENS",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MAX_BPOW_BASE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MAX_FEE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MAX_IN_RATIO",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MAX_OUT_RATIO",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MAX_TOTAL_WEIGHT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MAX_WEIGHT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MIN_BALANCE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MIN_BOUND_TOKENS",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MIN_BPOW_BASE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MIN_FEE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "MIN_WEIGHT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_49b59552",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_4bb278f3",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint32"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "allowance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "approve",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "balanceOf",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "bind",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "calcInGivenOut",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "calcOutGivenIn",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "calcPoolInGivenSingleOut",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "calcPoolOutGivenSingleIn",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "calcSingleInGivenPoolOut",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "calcSingleOutGivenPoolIn",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "calcSpotPrice",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "decimals",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "decreaseApproval",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "exitPool",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256[]"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "exitswapExternAmountOut",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "exitswapPoolAmountIn",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "getBalance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getColor",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "getController",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getCurrentTokens",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getDenormalizedWeight",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getFinalTokens",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getNormalizedWeight",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getNumTokens",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getSpotPrice",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getSpotPriceSansFee",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getSwapFee",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getTotalDenormalizedWeight",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "gulp",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "increaseApproval",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "isBound",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "isFinalized",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "isPublicSwap",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "joinPool",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256[]"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "joinswapExternAmountIn",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "joinswapPoolAmountOut",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "name",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "rebind",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setController",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setSwapFee",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "swapExactAmountIn",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "address"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "swapExactAmountOut",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "address"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "symbol",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalSupply",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "transferFrom",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "unbind",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "event",
    "name": "Approval",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_02c9674800000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_34e1990700000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_3fdddaa200000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_46ab38f100000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_49b5955200000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_4bb278f300000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_4f69c0d400000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_5db3427700000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_6d06dfa000000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_7c5e9ea400000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_8201aa3f00000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_8c28cbe800000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_92eefe9b00000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_b02f0b7300000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_cf5e7bd300000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_e4e1e53800000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "LOG_JOIN",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (1)

0x05f5e100unknown
These selectors are not yet in the research database — they are being investigated and will be added as known functions once identified. They are also marked in red in the decompiled Solidity above.

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)

(none)