BNB Chain
0x6c3be48828f4a58a5270ace884374e505c9505c7
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0x6c3be488…5c9505c715.7 KB53.2 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0x6c3be48828f4a58a5270ace884374e505c9505c7
2,694 lines · Click a variable or keyword to highlight its references · Click a line number to copy its link; Shift-click to copy a block link
//decompiled by exvvul decompiler tool [email protected] https://x.com/exvulsec// Decompilation incomplete: symbolic execution reached a configured deadline for 1 of 59 entry points (170000 ms contract budget): 575e24b4// SPDX-License-Identifier: MITpragma solidity >=0.8.0;contract DesolexContract { uint256 public constant unresolved_ea5736af = 58639232507632130530701416626661503647331788005859456939721266614432451859472; uint256 public constant BPS_DENOMINATOR = 10000; address public constant poolManager = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df); bool public constant getHookPermissions = false; address public constant factory = address(0xaf6c9d662e00a04038b88216ff97e44); uint256 public constant unresolved_7d79e7d4 = 10100; bool public constant unresolved_58ad48fd = true; address stor_0; // STORAGE[0x0] bytes32 stor_1; // STORAGE[0x1] // DESOLEX_RAW_STORAGE: whole slot: uint16 [ArithmeticUse] vs uint256 [ArithmeticUse] (ambiguous) uint256 public gasThreshold; // STORAGE[0x2] bool stor_3; // STORAGE[0x3] address public feeRecipient; // STORAGE[0x4] mapping(address => uint24) public unresolved_6ada0ce6; // STORAGE[0x5] mapping(bytes32 => uint256) public swapCount; // STORAGE[0x6] mapping(bytes32 => bytes32) mapping_7; // STORAGE[0x7] // DESOLEX_RAW_STORAGE: mapping value 0: bool [VerifiedAbi] vs uint256 [VerifiedAbi] (ambiguous) bool stor_8; // STORAGE[0x8] mapping(bytes32 => bytes32) mapping_9; // STORAGE[0x9] // DESOLEX_RAW_STORAGE: mapping value 0: uint16 [ArithmeticUse] vs uint256 [ArithmeticUse] (ambiguous) bytes32 stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; // STORAGE[0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00] mapping(bytes32 => uint256) transient_map_a; mapping(bytes32 => uint256) transient_map_b; error HookAddressMismatch(address, address); event WhitelistOnlyUpdated(bool); error HookNotImplemented(); event Event_7788933e(uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, uint256, uint256); event Event_935183c4(uint256 indexed, uint256, uint256); error InsufficientBalance(uint256, uint256); error InvalidAddress(); error LPFeeTooLarge(uint24); event PausedUpdated(bool); error SafeERC20FailedOperation(address); error NotOwner(address); error CustomError_cb3dbf49(); error NotPoolManager(); event TrustedRouterSet(address indexed, bool); event Event_193a1c5e(); event Event_00da51e0(uint256); event Event_1d9af658(uint256); error FailedCall(); error ReentrancyGuardReentrantCall(); error CustomError_da59a58d(); event FeeRecipientUpdated(address indexed); event Withdrawn(address indexed, address indexed, uint256); event Event_93ec9a9d(uint256); error CustomError_da2a1e87(); error SafeCastOverflow(); event Event_a0d23374(uint256, uint256); event OwnershipTransferred(address indexed, address indexed); function _desolexPanic(uint256 code) private pure { assembly ("memory-safe") { mstore(0x00, shl(224, 0x4e487b71)) mstore(0x04, code) revert(0x00, 0x24) } } receive() external payable { } fallback() external payable { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x0024bbf9)) { // Route to Unknown_0024bbf9(bytes,uint24,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x5445927a)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x14724809)) { // Route to Unknown_14724809(uint16) after replacing only msg.sig. __desolexSelectorShim(uint32(0x73632787)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x1c21e91e)) { // Route to Unknown_1c21e91e() after replacing only msg.sig. __desolexSelectorShim(uint32(0x14f3e871)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x21d0ee70)) { // Route to Unknown_21d0ee70(address,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x9a54d77b)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x259982e5)) { // Route to Unknown_259982e5(address,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x16c6169a)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x265acb63)) { // Route to Unknown_265acb63(bytes32,uint16,uint16) after replacing only msg.sig. __desolexSelectorShim(uint32(0x3fc4dda2)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x403fefe5)) { // Route to Unknown_403fefe5(uint24,uint16,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x9f7b5c06)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x50e67a96)) { // Route to Unknown_50e67a96() after replacing only msg.sig. __desolexSelectorShim(uint32(0x7dddb5e9)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x53608258)) { // Route to Unknown_53608258() after replacing only msg.sig. __desolexSelectorShim(uint32(0x0b98e75d)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x54b60449)) { // Route to Unknown_54b60449(uint16,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0xefaf2a32)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x575e24b4)) { // Route to Unknown_575e24b4(address,address,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x3396f686)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x5ba9f60a)) { // Route to Unknown_5ba9f60a(uint24,uint24,uint24,uint24,uint16,uint16,uint16,uint256,address,uint16,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x480c7885)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x64c01488)) { // Route to Unknown_64c01488(bytes32) after replacing only msg.sig. __desolexSelectorShim(uint32(0x0864602a)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x6c2bbe7e)) { // Route to Unknown_6c2bbe7e(address,address,address,uint256,uint256,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x37878e58)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x6fe7e6eb)) { // Route to Unknown_6fe7e6eb(address,address,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xb24b8e2a)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x73fd43e2)) { // Route to Unknown_73fd43e2() after replacing only msg.sig. __desolexSelectorShim(uint32(0xccc4356b)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x952e60c2)) { // Route to Unknown_952e60c2(address,uint24,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x899866a3)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x9f063efc)) { // Route to Unknown_9f063efc(address,uint256,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0xcd54f82d)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x9f6fd915)) { // Route to Unknown_9f6fd915(uint24) after replacing only msg.sig. __desolexSelectorShim(uint32(0x385bd3f2)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xac807cf4)) { // Route to Unknown_ac807cf4(bool,uint24,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0xe13c9279)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xb47b2fb1)) { // Route to Unknown_b47b2fb1(address,address,address,uint24,uint256,address,bool,uint256,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x19e5bedb)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xb6a8b0fa)) { // Route to Unknown_b6a8b0fa(address,uint256,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0x4759fe67)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xd18e3427)) { // Route to Unknown_d18e3427(address,address,address,uint24,uint256,address,bool,uint256,address,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x625e1e07)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xdc98354e)) { // Route to Unknown_dc98354e(address,address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x7ae78782)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xdfbec3f1)) { // Route to Unknown_dfbec3f1(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x32073891)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xe1b4af69)) { // Route to Unknown_e1b4af69(address,uint256,uint256,bytes) after replacing only msg.sig. __desolexSelectorShim(uint32(0xe5403a88)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xf8a49c89)) { // Route to Unknown_f8a49c89() after replacing only msg.sig. __desolexSelectorShim(uint32(0x93bcfb5b)); return; } revert(); } function Unknown_f8a49c89() public view returns (uint16) { return uint16(stor_1 >> 0x20); } function transferOwnership(address newOwner) public { bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); if (!(stor_0 == msg.sender)) { uint256 var_c; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(stor_0 == msg.sender); } bool flag1; if (flag0) { (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); uint256 value1 = msg.data[0] >> 0xe0; uint256 value2 = var_c.length; if (success0) { uint256 value0 = returnData0.length; if (0x20 <= returnData0.length) { value0 = 0x20; } if (((var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + value0) - var_c) >= 0x20); require(var_c.length == (address(var_c.length))); } else { value1 = var_c; value2 = 0; } flag1 = msg.sender != (0xffffffffffffffffffffffffffffffffffffffff & value2); } else { flag1 = flag0; } require(!(flag1), NotOwner()); require(newOwner != address(0), InvalidAddress()); emit OwnershipTransferred(stor_0, newOwner); stor_0 = newOwner; } function setWhitelistOnly(bool arg0) public { bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); uint256 var_c; if (!(msg.sender == stor_0)) { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(msg.sender == stor_0); } if (!(flag0)) { stor_8 = (bytes1(arg0)) | (stor_8 & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); emit WhitelistOnlyUpdated(arg0); } (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); if (!(success0)) { require(msg.sender == 0, NotOwner()); stor_8 = (bytes1(arg0)) | (stor_8 & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); emit WhitelistOnlyUpdated(arg0); } if (0x20 > returnData0.length) { if (((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData0.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); stor_8 = (bytes1(arg0)) | (stor_8 & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); emit WhitelistOnlyUpdated(arg0); } function Unknown_b6a8b0fa(address arg0, uint256 arg6, uint256 arg7, bytes memory arg8) public view { require((msg.data.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc) >= 0xa0); require(((0x04 + arg8) + 0x1f) < msg.data.length); require(((0x04 + arg8) + arg8 + 0x20) <= msg.data.length); require(msg.sender != 0x28e2ea090877bf75740558f6bfb36a5ffee9e9df, HookNotImplemented()); revert NotPoolManager(); } function Unknown_e1b4af69(address arg0, uint256 arg6, uint256 arg7, bytes memory arg8) public view { require((msg.data.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc) >= 0xa0); require(((0x04 + arg8) + 0x1f) < msg.data.length); require(((0x04 + arg8) + arg8 + 0x20) <= msg.data.length); require(msg.sender != 0x28e2ea090877bf75740558f6bfb36a5ffee9e9df, HookNotImplemented()); revert NotPoolManager(); } function Unknown_dfbec3f1(address arg0) public { require(msg.sender == 0xaf6c9d662e00a04038b88216ff97e44, NotOwner()); require(arg0 != address(0), InvalidAddress()); feeRecipient = arg0; emit FeeRecipientUpdated(feeRecipient); } function Unknown_dc98354e(address arg0, address arg6) public view { require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc + msg.data.length) >= 0xa0); require(msg.sender != 0x28e2ea090877bf75740558f6bfb36a5ffee9e9df, HookNotImplemented()); revert NotPoolManager(); } function withdraw(address token, address recipient, uint256 amount) public { bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); if (!(msg.sender == stor_0)) { uint256 var_c; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(msg.sender == stor_0); } if (!(flag0)) { require(stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 != 0x02, ReentrancyGuardReentrantCall()); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x02; require(recipient != address(0), InvalidAddress()); if (!(token)) { require(address(this).balance >= amount, InsufficientBalance()); if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); (bool success0, bytes memory returnData0) = recipient.call{ value: amount }(""); // call if (!success0) { require(!returnData0.length); revert FailedCall(); } else { emit Withdrawn(token, recipient, amount); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x01; } } var_g = 0xa9059cbb00000000000000000000000000000000000000000000000000000000; (bool success1, bytes memory returnData1) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), recipient, amount)); // call transfer uint256 value0 = ((!returnData1.length) & (!(!(token.code.length)))) & success1; if (!(success1 & (var_g == 0x01))) { require(!((!success1) & (0x01))); } else { value0 = success1; } var_c = var_c; require(value0 != 0x0, SafeERC20FailedOperation()); emit Withdrawn(token, recipient, amount); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x01; } (bool success2, bytes memory returnData2) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success2); if (!(success2)) { require(msg.sender == 0, NotOwner()); require(stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 != 0x02, ReentrancyGuardReentrantCall()); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x02; require(recipient != address(0), InvalidAddress()); if (!(token)) { require(address(this).balance >= amount, InsufficientBalance()); if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); (bool success3, bytes memory returnData3) = recipient.call{ value: amount }(""); // call if (!success3) { require(!returnData3.length); revert FailedCall(); } else { emit Withdrawn(token, recipient, amount); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x01; } } var_g = 0xa9059cbb00000000000000000000000000000000000000000000000000000000; (bool success4, bytes memory returnData4) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), recipient, amount)); // call transfer uint256 value1 = ((!returnData4.length) & (!(!(token.code.length)))) & success4; if (!(success4 & (var_g == 0x01))) { require(!((!success4) & (0x01))); } else { value1 = success4; } var_c = var_c; require(value1 != 0x0, SafeERC20FailedOperation()); emit Withdrawn(token, recipient, amount); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x01; } if (0x20 > returnData2.length) { if (((var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData2.length) - var_c) >= 0x20); require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); require(stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 != 0x02, ReentrancyGuardReentrantCall()); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x02; require(recipient != address(0), InvalidAddress()); if (!(token)) { require(address(this).balance >= amount, InsufficientBalance()); if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); (bool success5, bytes memory returnData5) = recipient.call{ value: amount }(""); // call if (!success5) { require(!returnData5.length); revert FailedCall(); } else { emit Withdrawn(token, recipient, amount); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x01; } } var_g = 0xa9059cbb00000000000000000000000000000000000000000000000000000000; (bool success6, bytes memory returnData6) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), recipient, amount)); // call transfer uint256 value2 = ((!returnData6.length) & (!(!(token.code.length)))) & success6; if (!(success6 & (var_g == 0x01))) { require(!((!success6) & (0x01))); } else { value2 = success6; } var_c = var_c; require(value2 != 0x0, SafeERC20FailedOperation()); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); require(stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 != 0x02, ReentrancyGuardReentrantCall()); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x02; require(recipient != address(0), InvalidAddress()); if (!(token)) { require(address(this).balance >= amount, InsufficientBalance()); if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); (bool success7, bytes memory returnData7) = recipient.call{ value: amount }(""); // call if (!success7) { require(!returnData7.length); revert FailedCall(); } else { emit Withdrawn(token, recipient, amount); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x01; } } var_g = 0xa9059cbb00000000000000000000000000000000000000000000000000000000; (bool success8, bytes memory returnData8) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), recipient, amount)); // call transfer uint256 value3 = ((!returnData8.length) & (!(!(token.code.length)))) & success8; if (!(success8 & (var_g == 0x01))) { require(!((!success8) & (0x01))); } else { value3 = success8; } require(value3 != 0x0, SafeERC20FailedOperation()); } emit Withdrawn(token, recipient, amount); stor_9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00 = 0x01; } function Unknown_d18e3427(address arg0, address arg1, address arg2, uint24 arg3, uint256 arg4, address arg5, bool arg6, uint256 arg7, address arg8, uint256 arg9) public returns (uint16) { require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc + msg.data.length) >= 0xa0); require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3c + msg.data.length) >= 0x60); require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc + msg.data.length) >= 0xa0); uint256 var_a; if (((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a)) _desolexPanic(65); var_a = var_a + 0xa0; require(arg3 == (arg3 & 0xffffff)); require(arg4 == int24(arg4)); uint256 value0 = blockhash(block.number + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); if (block.number != 0x0) { } else { value0 = 0; } uint256 value58; uint256 value54; uint256 value55; uint256 value56 = address(0x4848489f0b2bedd788c696e2d79b6b69d7484848).balance + address(0x1266c6be60392a8ff346e8d5eccd3e69dd9c5f20).balance; uint256 value57; if (block.chainid == 0x38) { (bool success0, bytes memory returnData0) = address(0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c).totalSupply(); // staticcall require(success0); uint256 value2 = 0; uint256 value3 = var_a.length; if (success0) { uint256 value1 = returnData0.length; if (0x20 <= returnData0.length) { value1 = 0x20; } if (((var_a + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value1) - var_a) >= 0x20); } else { value2 = var_a; value3 = 0; } (bool success1, bytes memory returnData1) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df); // staticcall require(success1); uint256 value5 = 0; uint256 value6 = var_a.length; if (success1) { uint256 value4 = returnData1.length; if (0x20 <= returnData1.length) { value4 = 0x20; } if (((var_a + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value4) - var_a) >= 0x20); } else { value5 = var_a; value6 = 0; } (bool success2, bytes memory returnData2) = address(0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d).balanceOf(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df); // staticcall require(success2); uint256 value59; uint256 value61; if (success2) { uint256 value7 = returnData2.length; if (0x20 <= returnData2.length) { value7 = 0x20; } if (((var_a + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value7) - var_a) >= 0x20); (bool success3, bytes memory returnData3) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(0x238a358808379702088667322f80ac48bad5e6c4); // staticcall require(success3); uint256 value65; uint256 value67; if (success3) { uint256 value8 = returnData3.length; if (0x20 <= returnData3.length) { value8 = 0x20; } if (((var_a + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value8) - var_a) >= 0x20); (bool success4, bytes memory returnData4) = address(0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d).balanceOf(0x238a358808379702088667322f80ac48bad5e6c4); // staticcall require(success4); uint256 value69; uint256 value71 = ((value6 + var_a.length) + var_a.length) + var_a.length; if (success4) { uint256 value9 = returnData4.length; if (0x20 <= returnData4.length) { value9 = 0x20; } if (((var_a + ((value9 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value9 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value9 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value9) - var_a) >= 0x20); (bool success5, bytes memory returnData5) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves(); // staticcall require(success5); uint256 value11 = 0xffffffffffffffffffffffffffff; uint256 value12 = var_q; uint256 value13 = var_r; if (success5) { uint256 value10 = returnData5.length; if (0x60 <= returnData5.length) { value10 = 0x60; } if (((var_a + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value10) - var_a) >= 0x60); require(var_s == (uint112(var_s))); require(var_t == (uint112(var_t))); require(uint32(var_u) == var_u); } else { value11 = var_a; value12 = 0; value13 = 0; } value69 = ((value12 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000)) | (value13 & (0xffffffffffffffffffffffffffff)); } else { (bool success6, bytes memory returnData6) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves(); // staticcall require(success6); uint256 value15 = 0xffffffffffffffffffffffffffff; uint256 value16 = var_q; uint256 value17 = var_r; if (success6) { uint256 value14 = returnData6.length; if (0x60 <= returnData6.length) { value14 = 0x60; } if (((var_a + ((value14 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value14 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value14 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value14) - var_a) >= 0x60); require(var_s == (uint112(var_s))); require(var_t == (uint112(var_t))); require(uint32(var_u) == var_u); } else { value15 = var_a; value16 = 0; value17 = 0; } value69 = ((value16 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000)) | (value17 & (0xffffffffffffffffffffffffffff)); value71 = ((value6 + var_a.length) + var_a.length) + 0; } value65 = value69; value67 = value71; } else { (bool success7, bytes memory returnData7) = address(0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d).balanceOf(0x238a358808379702088667322f80ac48bad5e6c4); // staticcall require(success7); uint256 value70; uint256 value72 = ((value6 + var_a.length) + 0) + var_a.length; if (success7) { uint256 value18 = returnData7.length; if (0x20 <= returnData7.length) { value18 = 0x20; } if (((var_a + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value18) - var_a) >= 0x20); (bool success8, bytes memory returnData8) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves(); // staticcall require(success8); uint256 value20 = 0xffffffffffffffffffffffffffff; uint256 value21 = var_q; uint256 value22 = var_r; if (success8) { uint256 value19 = returnData8.length; if (0x60 <= returnData8.length) { value19 = 0x60; } if (((var_a + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value19) - var_a) >= 0x60); require(var_s == (uint112(var_s))); require(var_t == (uint112(var_t))); require(uint32(var_u) == var_u); } else { value20 = var_a; value21 = 0; value22 = 0; } value70 = ((value21 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000)) | (value22 & (0xffffffffffffffffffffffffffff)); } else { (bool success9, bytes memory returnData9) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves(); // staticcall require(success9); uint256 value24 = 0xffffffffffffffffffffffffffff; uint256 value25 = var_q; uint256 value26 = var_r; if (success9) { uint256 value23 = returnData9.length; if (0x60 <= returnData9.length) { value23 = 0x60; } if (((var_a + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value23) - var_a) >= 0x60); require(var_s == (uint112(var_s))); require(var_t == (uint112(var_t))); require(uint32(var_u) == var_u); } else { value24 = var_a; value25 = 0; value26 = 0; } value70 = ((value25 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000)) | (value26 & (0xffffffffffffffffffffffffffff)); value72 = ((value6 + var_a.length) + 0) + 0; } value65 = value70; value67 = value72; } value59 = value65; value61 = value67; } else { (bool success10, bytes memory returnData10) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(0x238a358808379702088667322f80ac48bad5e6c4); // staticcall require(success10); uint256 value66; uint256 value68; if (success10) { uint256 value27 = returnData10.length; if (0x20 <= returnData10.length) { value27 = 0x20; } if (((var_a + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value27) - var_a) >= 0x20); (bool success11, bytes memory returnData11) = address(0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d).balanceOf(0x238a358808379702088667322f80ac48bad5e6c4); // staticcall require(success11); uint256 value73; uint256 value75 = ((value6 + 0) + var_a.length) + var_a.length; if (success11) { uint256 value28 = returnData11.length; if (0x20 <= returnData11.length) { value28 = 0x20; } if (((var_a + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value28) - var_a) >= 0x20); (bool success12, bytes memory returnData12) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves(); // staticcall require(success12); uint256 value30 = 0xffffffffffffffffffffffffffff; uint256 value31 = var_q; uint256 value32 = var_r; if (success12) { uint256 value29 = returnData12.length; if (0x60 <= returnData12.length) { value29 = 0x60; } if (((var_a + ((value29 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value29 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value29 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value29) - var_a) >= 0x60); require(var_s == (uint112(var_s))); require(var_t == (uint112(var_t))); require(uint32(var_u) == var_u); } else { value30 = var_a; value31 = 0; value32 = 0; } value73 = ((value31 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000)) | (value32 & (0xffffffffffffffffffffffffffff)); } else { (bool success13, bytes memory returnData13) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves(); // staticcall require(success13); uint256 value34 = 0xffffffffffffffffffffffffffff; uint256 value35 = var_q; uint256 value36 = var_r; if (success13) { uint256 value33 = returnData13.length; if (0x60 <= returnData13.length) { value33 = 0x60; } if (((var_a + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value33) - var_a) >= 0x60); require(var_s == (uint112(var_s))); require(var_t == (uint112(var_t))); require(uint32(var_u) == var_u); } else { value34 = var_a; value35 = 0; value36 = 0; } value73 = ((value35 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000)) | (value36 & (0xffffffffffffffffffffffffffff)); value75 = ((value6 + 0) + var_a.length) + 0; } value66 = value73; value68 = value75; } else { (bool success14, bytes memory returnData14) = address(0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d).balanceOf(0x238a358808379702088667322f80ac48bad5e6c4); // staticcall require(success14); uint256 value74; uint256 value76 = ((value6 + 0) + 0) + var_a.length; if (success14) { uint256 value37 = returnData14.length; if (0x20 <= returnData14.length) { value37 = 0x20; } if (((var_a + ((value37 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value37 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value37 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value37) - var_a) >= 0x20); (bool success15, bytes memory returnData15) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves(); // staticcall require(success15); uint256 value39 = 0xffffffffffffffffffffffffffff; uint256 value40 = var_q; uint256 value41 = var_r; if (success15) { uint256 value38 = returnData15.length; if (0x60 <= returnData15.length) { value38 = 0x60; } if (((var_a + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value38) - var_a) >= 0x60); require(var_s == (uint112(var_s))); require(var_t == (uint112(var_t))); require(uint32(var_u) == var_u); } else { value39 = var_a; value40 = 0; value41 = 0; } value74 = ((value40 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000)) | (value41 & (0xffffffffffffffffffffffffffff)); } else { (bool success16, bytes memory returnData16) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves(); // staticcall require(success16); uint256 value43 = 0xffffffffffffffffffffffffffff; uint256 value44 = var_q; uint256 value45 = var_r; if (success16) { uint256 value42 = returnData16.length; if (0x60 <= returnData16.length) { value42 = 0x60; } if (((var_a + ((value42 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value42 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value42 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value42) - var_a) >= 0x60); require(var_s == (uint112(var_s))); require(var_t == (uint112(var_t))); require(uint32(var_u) == var_u); } else { value43 = var_a; value44 = 0; value45 = 0; } value74 = ((value44 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000)) | (value45 & (0xffffffffffffffffffffffffffff)); value76 = ((value6 + 0) + 0) + 0; } value66 = value74; value68 = value76; } value59 = value66; value61 = value68; } value54 = value59; value55 = value61; value57 = value3; } else { uint256 value60 = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).balance; uint256 value62; uint256 value63 = (address(0x4200000000000000000000000000000000000011).balance + address(0x4200000000000000000000000000000000000019).balance) + address(0x420000000000000000000000000000000000001a).balance; uint256 value64; if (block.chainid == 0x2105) { (bool success17, bytes memory returnData17) = address(0x4200000000000000000000000000000000000006).totalSupply(); // staticcall require(success17); uint256 value47 = 0; uint256 value48 = var_a.length; if (success17) { uint256 value46 = returnData17.length; if (0x20 <= returnData17.length) { value46 = 0x20; } if (((var_a + ((value46 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value46 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value46 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value46) - var_a) >= 0x20); } else { value47 = var_a; value48 = 0; } (bool success18, bytes memory returnData18) = address(0x833589fcd6edb6e08f4c7c32d4f71b54bda02913).balanceOf(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df); // staticcall require(success18); uint256 value50 = 0; uint256 value51 = var_a.length; if (success18) { uint256 value49 = returnData18.length; if (0x20 <= returnData18.length) { value49 = 0x20; } if (((var_a + ((value49 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value49 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value49 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value49) - var_a) >= 0x20); } else { value50 = var_a; value51 = 0; } (bool success19, bytes memory returnData19) = address(0x4200000000000000000000000000000000000006).balanceOf(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df); // staticcall require(success19); uint256 value78 = value51 + var_a.length; if (success19) { uint256 value52 = returnData19.length; if (0x20 <= returnData19.length) { value52 = 0x20; } if (((var_a + ((value52 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value52 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value52 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value52) - var_a) >= 0x20); } else { value78 = value51 + 0; } value62 = value78; value64 = value48; } else { uint256 value77 = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).balance; uint256 value79; uint256 value80 = address(0x5a2b80a9b7effc06129bd5462d77bc20a8a59be7).balance; uint256 value81 = address(0xbc5c3a7adecf54d34169fd90dbd1b7d3142df067).balance; if (block.chainid == 0x1237) { (bool success20, bytes memory returnData20) = address(0x5fc5360d0400a0fd4f2af552add042d716f1d168).balanceOf(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df); // staticcall require(success20); uint256 value82 = var_a.length; if (success20) { uint256 value53 = returnData20.length; if (0x20 <= returnData20.length) { value53 = 0x20; } if (((var_a + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value53) - var_a) >= 0x20); } else { value82 = 0; } value79 = value82; } else { value77 = 0; value79 = 0; value80 = 0; value81 = 0; } value60 = value77; value62 = value79; value63 = value80; value64 = value81; } value54 = value60; value55 = value62; value56 = value63; value57 = value64; } if (((var_a + 0x0180) > 0xffffffffffffffff) | ((var_a + 0x0180) < var_a)) _desolexPanic(65); var_a = var_a + 0x0180; value58 = uint16(keccak256(abi.encode(value0, block.timestamp, value57, value56, value55, value54, (arg0), (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), arg6, arg7, arg9)) % 0x2710); return uint16(value58); } function setGasThreshold(uint256 newGasThreshold) public { bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); uint256 var_c; if (!(msg.sender == stor_0)) { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(msg.sender == stor_0); } if (!(flag0)) { gasThreshold = newGasThreshold; emit Event_00da51e0(gasThreshold); } (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); if (!(success0)) { require(msg.sender == 0, NotOwner()); gasThreshold = newGasThreshold; emit Event_00da51e0(gasThreshold); } if (0x20 > returnData0.length) { if (((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData0.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); gasThreshold = newGasThreshold; emit Event_00da51e0(gasThreshold); } function splitEnabled() public view returns (bool) { return !(!(bytes1(stor_3 >> 0xc8))); } function setTrustedRouter(address account, bool enabled) public { bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); uint256 var_c; if (!(msg.sender == stor_0)) { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(msg.sender == stor_0); } if (!(flag0)) { require(account != address(0), InvalidAddress()); mapping_7[account] = (bytes1(enabled)) | (mapping_7[account] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); emit TrustedRouterSet(account, enabled); } (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); if (!(success0)) { require(msg.sender == 0, NotOwner()); require(account != address(0), InvalidAddress()); mapping_7[account] = (bytes1(enabled)) | (mapping_7[account] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); emit TrustedRouterSet(account, enabled); } if (0x20 > returnData0.length) { if (((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData0.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); require(account != address(0), InvalidAddress()); mapping_7[account] = (bytes1(enabled)) | (mapping_7[account] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); emit TrustedRouterSet(account, enabled); } function setTrustedRouterBatch(address[] memory accounts, bool enabled) public { require(((0x04 + accounts) + 0x1f) < msg.data.length); require(!(((accounts.length << 0x05) + (0x04 + accounts) + 0x20) > msg.data.length)); bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); if (!(msg.sender == stor_0)) { uint256 var_c; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(msg.sender == stor_0); } if (flag0) { (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); if (success0) { if (0x20 > returnData0.length) { if (((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData0.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); uint256 value0 = 0; while (true) { if (!((value0 < accounts.length))) _desolexPanic(50); if (msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)] != (address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)]))) { revert(); break; } if (!(address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)]))) { revert InvalidAddress(); break; } mapping_7[address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)])] = (bytes1(enabled)) | (mapping_7[address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)])] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); emit TrustedRouterSet(address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)]), enabled); value0 = value0 + 0x01; } } else { require(msg.sender == 0, NotOwner()); uint256 value0 = 0; while (true) { if (!((value0 < accounts.length))) _desolexPanic(50); if (msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)] != (address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)]))) { revert(); break; } if (!(address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)]))) { revert InvalidAddress(); break; } mapping_7[address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)])] = (bytes1(enabled)) | (mapping_7[address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)])] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); emit TrustedRouterSet(address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)]), enabled); value0 = value0 + 0x01; } } } else { uint256 value0 = 0; while (true) { if (!((value0 < accounts.length))) _desolexPanic(50); if (msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)] != (address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)]))) { revert(); break; } if (!(address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)]))) { revert InvalidAddress(); break; } mapping_7[address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)])] = (bytes1(enabled)) | (mapping_7[address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)])] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); emit TrustedRouterSet(address(msg.data[(value0 << 0x05) + ((0x04 + accounts) + 0x20)]), enabled); value0 = value0 + 0x01; } } } function Unknown_b47b2fb1(address arg0, address arg1, address arg2, uint24 arg3, uint256 arg4, address arg5, bool arg6, uint256 arg7, uint256 arg9, bytes memory arg10) public returns (bytes memory) { require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc + msg.data.length) >= 0xa0); require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3c + msg.data.length) >= 0x60); require(((0x04 + arg10) + 0x1f) < msg.data.length); require(((0x04 + arg10) + arg10 + 0x20) <= msg.data.length); require(msg.sender == 0x28e2ea090877bf75740558f6bfb36a5ffee9e9df, NotPoolManager()); require(arg5 == address(this), HookAddressMismatch()); require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc + msg.data.length) >= 0xa0); uint256 var_a; if (((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a)) _desolexPanic(65); var_a = var_a + 0xa0; require(arg3 == (arg3 & 0xffffff)); require(arg4 == int24(arg4)); if (((var_a + 0x80) > 0xffffffffffffffff) | ((var_a + 0x80) < var_a)) _desolexPanic(65); var_a = var_a + 0x80; require(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))], CustomError_da59a58d()); transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] = 0; if (!(uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) { return abi.encodePacked(0xb47b2fb100000000000000000000000000000000000000000000000000000000, int128(0)); } else { uint256 value0 = arg9 >> 0x80; address account0 = arg1; if (!(arg7 < 0x0 != arg6)) { value0 = int128(arg9); account0 = arg2; } if (0 == (int128(value0) < 0)) { require(uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5)), arg0)] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) <= 0x0f4240, LPFeeTooLarge()); bool flag0 = !(uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)); if (!(address(value0))) { flag0 = (0xffffffffffffffffffffffffffffffff & value0) == 0x0; } if (flag0) { return abi.encodePacked(0xb47b2fb100000000000000000000000000000000000000000000000000000000, int128(0)); } else { if (arg7 < 0x0) { require(0x0f4240 > ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0))) - ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)))))); uint256 value2 = (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0))) / 0x0f4240; if (!((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0))) == ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)))))) { value2 = ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) - (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0x0f4240) / 0x40) | ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0))) - ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)))) - ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0x0f4240) > (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)))) * 0x0400000000000000000000000000000000000000000000000000000000000000)) * 0xde8f6cefed634549b62c77574f722e1ac57e23f24d8fd5cb790fb65668c26139; } if ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0x0f4240) != 0x0) { require(value2 != type(uint256).max); require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success1, bytes memory returnData1) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(account0, feeRecipient, 0x01 + value2); // call require(success1); uint256 value3 = 0; if (success1) { if (((var_a + 0) > 0xffffffffffffffff) | ((var_a + 0) < var_a)) _desolexPanic(65); var_a = var_a + 0; } else { value3 = var_a; } require((0x01 + value2) < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0xb47b2fb100000000000000000000000000000000000000000000000000000000, int128(0x01 + value2)); } else { if (value2 == 0x0) { return abi.encodePacked(0xb47b2fb100000000000000000000000000000000000000000000000000000000, int128(0)); } else { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success2, bytes memory returnData2) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(account0, feeRecipient, value2); // call require(success2); uint256 value4 = 0; if (success2) { if (((var_a + 0) > 0xffffffffffffffff) | ((var_a + 0) < var_a)) _desolexPanic(65); var_a = var_a + 0; } else { value4 = var_a; } require(value2 < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0xb47b2fb100000000000000000000000000000000000000000000000000000000, int128(value2)); } } } else { require(uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5)), arg0)] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != 0x0f4240, CustomError_da2a1e87()); require(uint24(0x0f4240 - (transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) > ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0))) - ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)))))); uint256 value5 = (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0))) / (uint24(0x0f4240 - (transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))); if (!((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0))) == ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)))))) { uint256 sharedExpr23 = mstore(0x40, (var_a + 0xa0)); uint256 sharedExpr24 = transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; uint256 sharedExpr25 = uint24(sharedExpr24); uint256 sharedExpr26 = uint24(sharedExpr25); uint256 sharedExpr27 = uint24(sharedExpr25); uint256 sharedExpr28 = 0x0f4240 - (uint24(sharedExpr24)); uint256 sharedExpr29 = uint24(sharedExpr28); uint256 sharedExpr30 = 0 - (uint24(sharedExpr28)); uint256 sharedExpr31 = uint24(sharedExpr28); uint256 sharedExpr32 = uint24(sharedExpr25); uint256 sharedExpr33 = uint24(sharedExpr28); uint256 sharedExpr34 = sharedExpr30 & sharedExpr31; uint256 sharedExpr35 = 0x03 * (sharedExpr33 / sharedExpr34); uint256 sharedExpr36 = 0x02 - ((sharedExpr33 / sharedExpr34) * (sharedExpr35 ^ 0x02)); uint256 sharedExpr37 = sharedExpr35 ^ 0x02; uint256 sharedExpr38 = 0x02 - ((sharedExpr33 / sharedExpr34) * (sharedExpr36 * sharedExpr37)); uint256 sharedExpr39 = sharedExpr36 * sharedExpr37; uint256 sharedExpr40 = 0x02 - ((sharedExpr33 / sharedExpr34) * (sharedExpr38 * sharedExpr39)); uint256 sharedExpr41 = sharedExpr38 * sharedExpr39; uint256 sharedExpr42 = 0x02 - ((sharedExpr33 / sharedExpr34) * (sharedExpr40 * sharedExpr41)); uint256 sharedExpr43 = sharedExpr40 * sharedExpr41; uint256 sharedExpr44 = 0x02 - ((sharedExpr33 / sharedExpr34) * (sharedExpr42 * sharedExpr43)); uint256 sharedExpr45 = sharedExpr42 * sharedExpr43; uint256 sharedExpr46 = mstore(0x40, (var_a + 0xa0)); uint256 sharedExpr47 = transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; uint256 sharedExpr48 = uint24(sharedExpr47); uint256 sharedExpr49 = uint24(sharedExpr48); uint256 sharedExpr50 = uint24(sharedExpr48); uint256 sharedExpr51 = 0x0f4240 - (uint24(sharedExpr47)); uint256 sharedExpr52 = uint24(sharedExpr51); uint256 sharedExpr53 = 0 - (uint24(sharedExpr51)); uint256 sharedExpr54 = uint24(sharedExpr51); uint256 sharedExpr55 = uint24(sharedExpr48); uint256 sharedExpr56 = uint24(sharedExpr51); uint256 sharedExpr57 = sharedExpr53 & sharedExpr54; uint256 sharedExpr58 = 0x03 * (sharedExpr56 / sharedExpr57); uint256 sharedExpr59 = 0x02 - ((sharedExpr56 / sharedExpr57) * (sharedExpr58 ^ 0x02)); uint256 sharedExpr60 = sharedExpr58 ^ 0x02; uint256 sharedExpr61 = 0x02 - ((sharedExpr56 / sharedExpr57) * (sharedExpr59 * sharedExpr60)); uint256 sharedExpr62 = sharedExpr59 * sharedExpr60; uint256 sharedExpr63 = 0x02 - ((sharedExpr56 / sharedExpr57) * (sharedExpr61 * sharedExpr62)); uint256 sharedExpr64 = sharedExpr61 * sharedExpr62; uint256 sharedExpr65 = 0x02 - ((sharedExpr56 / sharedExpr57) * (sharedExpr63 * sharedExpr64)); uint256 sharedExpr66 = sharedExpr63 * sharedExpr64; uint256 sharedExpr67 = 0x02 - ((sharedExpr56 / sharedExpr57) * (sharedExpr65 * sharedExpr66)); uint256 sharedExpr68 = sharedExpr65 * sharedExpr66; value5 = ((sharedExpr49 * (address(value0))) - ((sharedExpr50 * (address(value0))) % sharedExpr52) / (sharedExpr53 & sharedExpr54) | (((sharedExpr55 * (address(value0))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (sharedExpr49 * (address(value0))) - (((sharedExpr55 * (address(value0))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (sharedExpr49 * (address(value0)))) - (((sharedExpr50 * (address(value0))) % sharedExpr52) > (sharedExpr49 * (address(value0)))) * ((0 - (sharedExpr53 & sharedExpr54)) / (sharedExpr53 & sharedExpr54) + 0x01))) * ((0x02 - ((sharedExpr56 / sharedExpr57) * (sharedExpr67 * sharedExpr68))) * (sharedExpr67 * sharedExpr68)); } uint256 value6 = 0x01 + value5; if (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(value0)) % (uint24(0x0f4240 - (transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) != 0x0) { require(value5 != type(uint256).max); } else { value6 = value5; } if (value6 == 0x0) { return abi.encodePacked(0xb47b2fb100000000000000000000000000000000000000000000000000000000, int128(0)); } else { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success3, bytes memory returnData3) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(account0, feeRecipient, value6); // call require(success3); uint256 value7 = 0; if (success3) { if (((var_a + 0) > 0xffffffffffffffff) | ((var_a + 0) < var_a)) _desolexPanic(65); var_a = var_a + 0; } else { value7 = var_a; } require(value6 < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0xb47b2fb100000000000000000000000000000000000000000000000000000000, int128(value6)); } } } } else { require(!(uint24(uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) > 0x0f4240), LPFeeTooLarge()); bool flag1 = !(uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)); if (!(address(0 - int128(value0)))) { flag1 = !(address(0 - int128(value0))); } uint256 value10 = 0; if (!(flag1)) { uint256 value12; if (arg7 < 0x0) { require(0x0f4240 > ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0)))) - ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))))))); uint256 value8 = uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) / 0x0f4240; if (!((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0)))) == ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))))))) { uint256 sharedExpr85 = (0 - 0x0f4240) & (0x0f4240); uint256 sharedExpr86 = 0x03 * (0x0f4240 / sharedExpr85); uint256 sharedExpr87 = 0x02 - ((0x0f4240 / sharedExpr85) * (sharedExpr86 ^ 0x02)); uint256 sharedExpr88 = sharedExpr86 ^ 0x02; uint256 sharedExpr89 = 0x02 - ((0x0f4240 / sharedExpr85) * (sharedExpr87 * sharedExpr88)); uint256 sharedExpr90 = sharedExpr87 * sharedExpr88; uint256 sharedExpr91 = 0x02 - ((0x0f4240 / sharedExpr85) * (sharedExpr89 * sharedExpr90)); uint256 sharedExpr92 = sharedExpr89 * sharedExpr90; uint256 sharedExpr93 = 0x02 - ((0x0f4240 / sharedExpr85) * (sharedExpr91 * sharedExpr92)); uint256 sharedExpr94 = sharedExpr91 * sharedExpr92; uint256 sharedExpr95 = 0x02 - ((0x0f4240 / sharedExpr85) * (sharedExpr93 * sharedExpr94)); uint256 sharedExpr96 = sharedExpr93 * sharedExpr94; uint256 sharedExpr97 = mstore(0x40, (var_a + 0xa0)); uint256 sharedExpr98 = uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint256 sharedExpr99 = address(0 - int128(value0)); uint256 sharedExpr100 = (0 - 0x0f4240) & (0x0f4240); uint256 sharedExpr101 = 0x03 * (0x0f4240 / sharedExpr100); uint256 sharedExpr102 = 0x02 - ((0x0f4240 / sharedExpr100) * (sharedExpr101 ^ 0x02)); uint256 sharedExpr103 = sharedExpr101 ^ 0x02; uint256 sharedExpr104 = 0x02 - ((0x0f4240 / sharedExpr100) * (sharedExpr102 * sharedExpr103)); uint256 sharedExpr105 = sharedExpr102 * sharedExpr103; uint256 sharedExpr106 = 0x02 - ((0x0f4240 / sharedExpr100) * (sharedExpr104 * sharedExpr105)); uint256 sharedExpr107 = sharedExpr104 * sharedExpr105; uint256 sharedExpr108 = 0x02 - ((0x0f4240 / sharedExpr100) * (sharedExpr106 * sharedExpr107)); uint256 sharedExpr109 = sharedExpr106 * sharedExpr107; uint256 sharedExpr110 = 0x02 - ((0x0f4240 / sharedExpr100) * (sharedExpr108 * sharedExpr109)); uint256 sharedExpr111 = sharedExpr108 * sharedExpr109; uint256 sharedExpr112 = (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0) - (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0) % 0x0f4240) / ((0 - 0x0f4240) & (0x0f4240)) | ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0)) - ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0))) - ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0) % 0x0f4240) > (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0))) * ((0 - ((0 - 0x0f4240) & (0x0f4240))) / ((0 - 0x0f4240) & (0x0f4240)) + 0x01))) * ((0x02 - ((0x0f4240 / sharedExpr100) * (sharedExpr110 * sharedExpr111))) * (sharedExpr110 * sharedExpr111)); value8 = sharedExpr112; } uint256 value13 = 0x01 + value8; if ((uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) % 0x0f4240) != 0x0) { require(value8 != type(uint256).max); } else { value13 = value8; } value12 = value13; } else { require(uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5)), arg0)] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != 0x0f4240, CustomError_da2a1e87()); require(uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) > ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0)))) - ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))))))); uint256 value9 = uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) / (uint24(0x0f4240 - (transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))); if (!((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0)))) == ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))))))) { uint256 sharedExpr133 = (0 - (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)))) & (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))); uint256 sharedExpr134 = 0x03 * (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr133); uint256 sharedExpr135 = 0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr133) * (sharedExpr134 ^ 0x02)); uint256 sharedExpr136 = sharedExpr134 ^ 0x02; uint256 sharedExpr137 = 0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr133) * (sharedExpr135 * sharedExpr136)); uint256 sharedExpr138 = sharedExpr135 * sharedExpr136; uint256 sharedExpr139 = 0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr133) * (sharedExpr137 * sharedExpr138)); uint256 sharedExpr140 = sharedExpr137 * sharedExpr138; uint256 sharedExpr141 = 0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr133) * (sharedExpr139 * sharedExpr140)); uint256 sharedExpr142 = sharedExpr139 * sharedExpr140; uint256 sharedExpr143 = 0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr133) * (sharedExpr141 * sharedExpr142)); uint256 sharedExpr144 = sharedExpr141 * sharedExpr142; uint256 sharedExpr145 = mstore(0x40, (var_a + 0xa0)); uint256 sharedExpr146 = transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; uint256 sharedExpr147 = uint24(sharedExpr146); uint256 sharedExpr148 = address(0 - int128(value0)); uint256 sharedExpr149 = uint24(sharedExpr146); uint256 sharedExpr150 = 0x0f4240 - (uint24(uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))); uint256 sharedExpr151 = uint24(sharedExpr150); uint256 sharedExpr152 = (0 - (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)))) & (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))); uint256 sharedExpr153 = 0x03 * (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr152); uint256 sharedExpr154 = 0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr152) * (sharedExpr153 ^ 0x02)); uint256 sharedExpr155 = sharedExpr153 ^ 0x02; uint256 sharedExpr156 = 0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr152) * (sharedExpr154 * sharedExpr155)); uint256 sharedExpr157 = sharedExpr154 * sharedExpr155; uint256 sharedExpr158 = 0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr152) * (sharedExpr156 * sharedExpr157)); uint256 sharedExpr159 = sharedExpr156 * sharedExpr157; uint256 sharedExpr160 = 0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr152) * (sharedExpr158 * sharedExpr159)); uint256 sharedExpr161 = sharedExpr158 * sharedExpr159; uint256 sharedExpr162 = 0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr152) * (sharedExpr160 * sharedExpr161)); uint256 sharedExpr163 = sharedExpr160 * sharedExpr161; uint256 sharedExpr164 = (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0) - (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0) % (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)))) / ((0 - (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)))) & (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)))) | ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0)) - ((uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0))) - (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0) % (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) > (uint24(transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * address(value0))) * ((0 - ((0 - (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)))) & (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))))) / ((0 - (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)))) & (uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)))) + 0x01))) * ((0x02 - ((uint24(0x0f4240 - (transient_map_b[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) / sharedExpr152) * (sharedExpr162 * sharedExpr163))) * (sharedExpr162 * sharedExpr163)); value9 = sharedExpr164; } uint256 value14 = 0x01 + value9; if (uint24(transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) * (address(0 - int128(value0))) % (uint24(0x0f4240 - (transient_map_a[abi.encode(0x040f882beb8d0ea6ad5b8845473bcf6db7d3fd44ca1c32c8cf9c0bf22daa2929, (keccak256(abi.encode(arg1, arg2, arg3, arg4, arg5))), (arg0))] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) != 0x0) { require(value9 != type(uint256).max); } else { value14 = value9; } value12 = value14; } value10 = value12; } if (value10 == 0x0) { return abi.encodePacked(0xb47b2fb100000000000000000000000000000000000000000000000000000000, int128(0)); } else { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success4, bytes memory returnData4) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(account0, feeRecipient, value10); // call require(success4); uint256 value11 = 0; if (success4) { if (((var_a + 0) > 0xffffffffffffffff) | ((var_a + 0) < var_a)) _desolexPanic(65); var_a = var_a + 0; } else { value11 = var_a; } require(value10 < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0xb47b2fb100000000000000000000000000000000000000000000000000000000, int128(value10)); } } } } function Unknown_ac807cf4(bool arg0, uint24 arg1, bool arg2) public pure returns (uint256) { require(arg1 == (arg1 & 0xffffff)); require(uint24(arg1) <= 0x0f4240, LPFeeTooLarge()); if (!(arg0 && (arg1 & 0xffffff) == 0x0 || !arg0)) { if (!(arg2)) { require(uint24(arg1) != 0x0f4240, CustomError_da2a1e87()); require(uint24(0x0f4240 - arg1) > (((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg1) * arg0) - (((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg1) * arg0)))); uint256 value0 = (uint24(arg1) * arg0) / (uint24(0x0f4240 - arg1)); if (!(((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg1) * arg0) == (((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg1) * arg0)))) { uint256 sharedExpr12 = (0 - (uint24(0x0f4240 - arg1))) & (uint24(0x0f4240 - arg1)); uint256 sharedExpr13 = 0x03 * (uint24(0x0f4240 - arg1) / sharedExpr12); uint256 sharedExpr14 = 0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr12) * (sharedExpr13 ^ 0x02)); uint256 sharedExpr15 = sharedExpr13 ^ 0x02; uint256 sharedExpr16 = 0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr12) * (sharedExpr14 * sharedExpr15)); uint256 sharedExpr17 = sharedExpr14 * sharedExpr15; uint256 sharedExpr18 = 0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr12) * (sharedExpr16 * sharedExpr17)); uint256 sharedExpr19 = sharedExpr16 * sharedExpr17; uint256 sharedExpr20 = 0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr12) * (sharedExpr18 * sharedExpr19)); uint256 sharedExpr21 = sharedExpr18 * sharedExpr19; uint256 sharedExpr22 = 0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr12) * (sharedExpr20 * sharedExpr21)); uint256 sharedExpr23 = sharedExpr20 * sharedExpr21; uint256 sharedExpr24 = (0 - (uint24(0x0f4240 - arg1))) & (uint24(0x0f4240 - arg1)); uint256 sharedExpr25 = 0x03 * (uint24(0x0f4240 - arg1) / sharedExpr24); uint256 sharedExpr26 = 0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr24) * (sharedExpr25 ^ 0x02)); uint256 sharedExpr27 = sharedExpr25 ^ 0x02; uint256 sharedExpr28 = 0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr24) * (sharedExpr26 * sharedExpr27)); uint256 sharedExpr29 = sharedExpr26 * sharedExpr27; uint256 sharedExpr30 = 0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr24) * (sharedExpr28 * sharedExpr29)); uint256 sharedExpr31 = sharedExpr28 * sharedExpr29; uint256 sharedExpr32 = 0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr24) * (sharedExpr30 * sharedExpr31)); uint256 sharedExpr33 = sharedExpr30 * sharedExpr31; uint256 sharedExpr34 = 0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr24) * (sharedExpr32 * sharedExpr33)); uint256 sharedExpr35 = sharedExpr32 * sharedExpr33; value0 = ((uint24(arg1) * arg0) - ((uint24(arg1) * arg0) % (uint24(0x0f4240 - arg1))) / ((0 - (uint24(0x0f4240 - arg1))) & (uint24(0x0f4240 - arg1))) | (((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg1) * arg0) - (((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg1) * arg0)) - ((uint24(arg1) * arg0) % (uint24(0x0f4240 - arg1)) > (uint24(arg1) * arg0)) * ((0 - ((0 - (uint24(0x0f4240 - arg1))) & (uint24(0x0f4240 - arg1)))) / ((0 - (uint24(0x0f4240 - arg1))) & (uint24(0x0f4240 - arg1))) + 0x01))) * ((0x02 - ((uint24(0x0f4240 - arg1) / sharedExpr24) * (sharedExpr34 * sharedExpr35))) * (sharedExpr34 * sharedExpr35)); } if ((uint24(arg1) * arg0) % (uint24(0x0f4240 - arg1)) == 0) { uint256 value0; } require(value0 != type(uint256).max); return 0x01 + value0; } require(0x0f4240 > (((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg1) * arg0) - (((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg1) * arg0)))); uint256 value1 = (uint24(arg1) * arg0) / 0x0f4240; if (!(((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg1) * arg0) == (((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg1) * arg0)))) { uint256 sharedExpr48 = (0 - 0x0f4240) & (0x0f4240); uint256 sharedExpr49 = 0x03 * (0x0f4240 / sharedExpr48); uint256 sharedExpr50 = 0x02 - ((0x0f4240 / sharedExpr48) * (sharedExpr49 ^ 0x02)); uint256 sharedExpr51 = sharedExpr49 ^ 0x02; uint256 sharedExpr52 = 0x02 - ((0x0f4240 / sharedExpr48) * (sharedExpr50 * sharedExpr51)); uint256 sharedExpr53 = sharedExpr50 * sharedExpr51; uint256 sharedExpr54 = 0x02 - ((0x0f4240 / sharedExpr48) * (sharedExpr52 * sharedExpr53)); uint256 sharedExpr55 = sharedExpr52 * sharedExpr53; uint256 sharedExpr56 = 0x02 - ((0x0f4240 / sharedExpr48) * (sharedExpr54 * sharedExpr55)); uint256 sharedExpr57 = sharedExpr54 * sharedExpr55; uint256 sharedExpr58 = 0x02 - ((0x0f4240 / sharedExpr48) * (sharedExpr56 * sharedExpr57)); uint256 sharedExpr59 = sharedExpr56 * sharedExpr57; uint256 sharedExpr60 = (0 - 0x0f4240) & (0x0f4240); uint256 sharedExpr61 = 0x03 * (0x0f4240 / sharedExpr60); uint256 sharedExpr62 = 0x02 - ((0x0f4240 / sharedExpr60) * (sharedExpr61 ^ 0x02)); uint256 sharedExpr63 = sharedExpr61 ^ 0x02; uint256 sharedExpr64 = 0x02 - ((0x0f4240 / sharedExpr60) * (sharedExpr62 * sharedExpr63)); uint256 sharedExpr65 = sharedExpr62 * sharedExpr63; uint256 sharedExpr66 = 0x02 - ((0x0f4240 / sharedExpr60) * (sharedExpr64 * sharedExpr65)); uint256 sharedExpr67 = sharedExpr64 * sharedExpr65; uint256 sharedExpr68 = 0x02 - ((0x0f4240 / sharedExpr60) * (sharedExpr66 * sharedExpr67)); uint256 sharedExpr69 = sharedExpr66 * sharedExpr67; uint256 sharedExpr70 = 0x02 - ((0x0f4240 / sharedExpr60) * (sharedExpr68 * sharedExpr69)); uint256 sharedExpr71 = sharedExpr68 * sharedExpr69; value1 = ((uint24(arg1) * arg0) - ((uint24(arg1) * arg0) % 0x0f4240) / ((0 - 0x0f4240) & (0x0f4240)) | (((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg1) * arg0) - (((uint24(arg1) * arg0) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg1) * arg0)) - (((uint24(arg1) * arg0) % 0x0f4240) > (uint24(arg1) * arg0)) * ((0 - ((0 - 0x0f4240) & (0x0f4240))) / ((0 - 0x0f4240) & (0x0f4240)) + 0x01))) * ((0x02 - ((0x0f4240 / sharedExpr60) * (sharedExpr70 * sharedExpr71))) * (sharedExpr70 * sharedExpr71)); } if (((uint24(arg1) * arg0) % 0x0f4240) != 0x0) { require(value1 != type(uint256).max); return 0x01 + value1; } else { uint256 value1; } } return 0; } function Unknown_9f6fd915(uint24 arg0) public { require(arg0 == (arg0 & 0xffffff)); bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); uint256 var_c; if (!(msg.sender == stor_0)) { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(msg.sender == stor_0); } if (!(flag0)) { require(uint24(arg0) <= 0x0f4240, LPFeeTooLarge()); stor_3 = (0xffffff0000000000000000000000000000000000000000 & (arg0 << 0xa0)) | (0xffffffffffffffffff000000ffffffffffffffffffffffffffffffffffffffff & stor_3); emit Event_93ec9a9d(uint24(arg0)); } (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); if (!(success0)) { require(msg.sender == 0, NotOwner()); require(uint24(arg0) <= 0x0f4240, LPFeeTooLarge()); stor_3 = (0xffffff0000000000000000000000000000000000000000 & (arg0 << 0xa0)) | (0xffffffffffffffffff000000ffffffffffffffffffffffffffffffffffffffff & stor_3); emit Event_93ec9a9d(uint24(arg0)); } if (0x20 > returnData0.length) { if (((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData0.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); require(uint24(arg0) <= 0x0f4240, LPFeeTooLarge()); stor_3 = (0xffffff0000000000000000000000000000000000000000 & (arg0 << 0xa0)) | (0xffffffffffffffffff000000ffffffffffffffffffffffffffffffffffffffff & stor_3); emit Event_93ec9a9d(uint24(arg0)); } function Unknown_9f063efc(address arg0, uint256 arg10, uint256 arg11, bytes memory arg12) public returns (bytes memory) { require((msg.data.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc) >= 0xa0); require((msg.data.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3c) >= 0x80); require(((0x04 + arg12) + 0x1f) < msg.data.length); require(((0x04 + arg12) + arg12 + 0x20) <= msg.data.length); require(msg.sender == 0x28e2ea090877bf75740558f6bfb36a5ffee9e9df, NotPoolManager()); uint256 value4 = 0; if (uint16(mapping_9[msg.data[0xc4 + 0x60]])) { uint256 value0 = 0; if (!(SIGNEXTEND(0xf, SAR(0x80, arg11)) <= 0x0 || (mapping_9[CALLDATALOAD(0xc4 + 0x60)] & 0xffff & 0xffff) == 0x0)) { value0 = (int128(arg11 >> 0x80) * (uint16(mapping_9[msg.data[0xc4 + 0x60]]))) / 0x2710; } uint256 value1 = 0; if (!(SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg11)) <= 0x0 || (mapping_9[CALLDATALOAD(0xc4 + 0x60)] & 0xffff & 0xffff) == 0x0)) { value1 = (int128(arg11) * (uint16(mapping_9[msg.data[0xc4 + 0x60]]))) / 0x2710; } if (value0 != 0x0) { require(msg.data[0x24] == (address(msg.data[0x24]))); require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success0, bytes memory returnData0) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(address(msg.data[0x24]), feeRecipient, value0); // call require(success0); uint256 value2 = 0; uint256 var_g; if (success0) { if (((var_g + 0) > 0xffffffffffffffff) | ((var_g + 0) < var_g)) _desolexPanic(65); var_g = var_g + 0; } else { value2 = var_g; } } uint256 value3; if (value1 != 0x0) { require(msg.data[0x20 + 0x24] == (address(msg.data[0x20 + 0x24]))); require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success1, bytes memory returnData1) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(address(msg.data[0x20 + 0x24]), feeRecipient, value1); // call require(success1); uint256 value5 = var_g; if (success1) { if (((var_g + 0) > 0xffffffffffffffff) | ((var_g + 0) < var_g)) _desolexPanic(65); require(!(0)); value5 = 0; } value3 = value5; } else { value3 = 0x24; } require(value0 < 0x80000000000000000000000000000000, SafeCastOverflow()); require(value1 < 0x80000000000000000000000000000000, SafeCastOverflow()); value4 = (value1 << 0x80) | (address(int128(value1))); } return abi.encodePacked(0x9f063efc00000000000000000000000000000000000000000000000000000000, value4); } function tierThreeFee() public view returns (uint24) { return uint24(stor_0 >> 0xd0); } function tierOneFee() public view returns (uint24) { return uint24(stor_0 >> 0xa0); } function Unknown_952e60c2(address arg0, uint24 arg1, bool arg2) public { require(arg1 == (arg1 & 0xffffff)); bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); if (!(msg.sender == stor_0)) { uint256 var_c; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(msg.sender == stor_0); } if (!(flag0)) { if (arg2) { require(uint24(arg1) <= 0x0f4240, LPFeeTooLarge()); require(arg0 != address(0), InvalidAddress()); if (!arg2) { unresolved_6ada0ce6[arg0] = 0; uint256 value0 = 0; emit Event_193a1c5e(arg0, uint24(value0), arg2); } else { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; unresolved_6ada0ce6[arg0] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & unresolved_6ada0ce6[arg0] | (var_c.length & (0xffffff))) | (((!(!(var_j))) << 0x18) & (0xff000000)); uint256 value1 = 0; value1 = (arg1) ? 1 : 0; emit Event_193a1c5e(arg0, uint24(value1), arg2); } } require(arg0 != address(0), InvalidAddress()); unresolved_6ada0ce6[arg0] = 0; uint256 value2 = 0; if (arg2) { value2 = (arg1) ? 1 : 0; } emit Event_193a1c5e(arg0, uint24(value2), arg2); } (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); if (!(success0)) { require(msg.sender == 0, NotOwner()); if (arg2) { require(uint24(arg1) <= 0x0f4240, LPFeeTooLarge()); require(arg0 != address(0), InvalidAddress()); if (!arg2) { unresolved_6ada0ce6[arg0] = 0; uint256 value3 = 0; emit Event_193a1c5e(arg0, uint24(value3), arg2); } else { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; unresolved_6ada0ce6[arg0] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & unresolved_6ada0ce6[arg0] | (var_c.length & (0xffffff))) | (((!(!(var_j))) << 0x18) & (0xff000000)); uint256 value4 = 0; value4 = (arg1) ? 1 : 0; emit Event_193a1c5e(arg0, uint24(value4), arg2); } } require(arg0 != address(0), InvalidAddress()); unresolved_6ada0ce6[arg0] = 0; uint256 value5 = 0; if (arg2) { value5 = (arg1) ? 1 : 0; } emit Event_193a1c5e(arg0, uint24(value5), arg2); } if (0x20 > returnData0.length) { if (((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData0.length) - var_c) >= 0x20); require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); if (arg2) { require(uint24(arg1) <= 0x0f4240, LPFeeTooLarge()); require(arg0 != address(0), InvalidAddress()); if (!arg2) { unresolved_6ada0ce6[arg0] = 0; uint256 value6 = 0; emit Event_193a1c5e(arg0, uint24(value6), arg2); } else { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; unresolved_6ada0ce6[arg0] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & unresolved_6ada0ce6[arg0] | (var_c.length & (0xffffff))) | (((!(!(var_j))) << 0x18) & (0xff000000)); uint256 value7 = 0; value7 = (arg1) ? 1 : 0; emit Event_193a1c5e(arg0, uint24(value7), arg2); } } require(arg0 != address(0), InvalidAddress()); unresolved_6ada0ce6[arg0] = 0; uint256 value8 = 0; if (arg2) { value8 = (arg1) ? 1 : 0; } emit Event_193a1c5e(arg0, uint24(value8), arg2); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); if (arg2) { require(uint24(arg1) <= 0x0f4240, LPFeeTooLarge()); require(arg0 != address(0), InvalidAddress()); if (!arg2) { unresolved_6ada0ce6[arg0] = 0; uint256 value9 = 0; emit Event_193a1c5e(arg0, uint24(value9), arg2); } else { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; unresolved_6ada0ce6[arg0] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & unresolved_6ada0ce6[arg0] | (var_c.length & (0xffffff))) | (((!(!(var_j))) << 0x18) & (0xff000000)); uint256 value10 = 0; value10 = (arg1) ? 1 : 0; emit Event_193a1c5e(arg0, uint24(value10), arg2); } } require(arg0 != address(0), InvalidAddress()); unresolved_6ada0ce6[arg0] = 0; uint256 value11 = 0; if (arg2) { value11 = (arg1) ? 1 : 0; } emit Event_193a1c5e(arg0, uint24(value11), arg2); } } function owner() public view returns (address) { return stor_0; } function exemptAddress() public view returns (address) { return address(stor_3); } function Unknown_73fd43e2() public view returns (uint256) { if (!(gasThreshold < block.gaslimit)) { require(0x2710 > (((block.gaslimit * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (block.gaslimit * 0x2774) - (((block.gaslimit * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (block.gaslimit * 0x2774)))); if (((block.gaslimit * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (block.gaslimit * 0x2774) != (((block.gaslimit * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (block.gaslimit * 0x2774))) { return (((block.gaslimit * 0x2774) - ((block.gaslimit * 0x2774) % 0x2710) >> 0x04) | (((block.gaslimit * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (block.gaslimit * 0x2774) - (((block.gaslimit * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (block.gaslimit * 0x2774)) - (((block.gaslimit * 0x2774) % 0x2710) > (block.gaslimit * 0x2774)) << 0xfc)) * 0xbc01a36e2eb1c432ca57a786c226809d495182a9930be0ded288ce703afb7e91; } return (block.gaslimit * 0x2774) / 0x2710; } else { require(0x2710 > (((gasThreshold * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (gasThreshold * 0x2774) - (((gasThreshold * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (gasThreshold * 0x2774)))); if (((gasThreshold * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (gasThreshold * 0x2774) != (((gasThreshold * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (gasThreshold * 0x2774))) { return (((gasThreshold * 0x2774) - ((gasThreshold * 0x2774) % 0x2710) >> 0x04) | (((gasThreshold * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (gasThreshold * 0x2774) - (((gasThreshold * 0x2774) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (gasThreshold * 0x2774)) - (((gasThreshold * 0x2774) % 0x2710) > (gasThreshold * 0x2774)) << 0xfc)) * 0xbc01a36e2eb1c432ca57a786c226809d495182a9930be0ded288ce703afb7e91; } return (gasThreshold * 0x2774) / 0x2710; } } function Unknown_6fe7e6eb(address arg0, address arg6, uint256 arg7) public view { require((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc + msg.data.length) >= 0xa0); require(arg7 == int24(arg7)); require(msg.sender != 0x28e2ea090877bf75740558f6bfb36a5ffee9e9df, HookNotImplemented()); revert NotPoolManager(); } function Unknown_6c2bbe7e(address arg0, address arg1, address arg2, uint256 arg9, uint256 arg10, uint256 arg11, bytes memory arg12) public payable returns (bytes memory) { if (!(msg.value)) { if ((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) >= 0x01a0) { if (arg0 == arg0) { if ((msg.data.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc) >= 0xa0) { if ((msg.data.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3c) >= 0x80) { if (!(arg12.length > 0xffffffffffffffff)) { if (((0x04 + arg12) + 0x1f) < msg.data.length) { if (!(arg12.length > 0xffffffffffffffff)) { if (((0x04 + arg12) + arg12 + 0x20) <= msg.data.length) { if (msg.sender == 0x28e2ea090877bf75740558f6bfb36a5ffee9e9df) { uint256 var_c; if (!(((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c))) { var_c = var_c + 0x40; uint256 value0 = 0; if (uint16(mapping_9[arg9])) { value0 = uint16(mapping_9[arg9] >> 0x10); } if (((mapping_9[arg9] & 0xffff) == 0x0) && ((SHR(0x10, mapping_9[arg9]) & 0xffff) == 0x0)) { return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, 0); } else { if ((SIGNEXTEND(0xf, SAR(0x80, arg11)) <= 0x0) || ((var_h & 0xffff & 0xffff) == 0x0)) { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, SAR(0x80, arg10)) - SIGNEXTEND(0xf, SAR(0x80, arg11))) <= 0x0) || ((var_i & 0xffff & 0xffff) == 0x0)) { } else { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg11)) <= 0x0) || ((var_h & 0xffff & 0xffff) == 0x0)) { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg10)) - SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg11))) <= 0x0) || ((var_i & 0xffff & 0xffff) == 0x0)) { if ((0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success0, bytes memory returnData0) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, 0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)); // call require(success0); uint256 value1 = 0; if (success0) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value1 = var_c; } } uint256 value2; value2 = 0x24; require((0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)) < 0x80000000000000000000000000000000, SafeCastOverflow()); require(0 < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(0 + ((arg10 >> 0x80) - (arg11 >> 0x80) * (uint16(uint16(var_i))) / 0x2710)) << 0x80) | (address(int128(0)))); } else { if ((0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success2, bytes memory returnData2) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, 0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)); // call require(success2); uint256 value3 = 0; if (success2) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value3 = var_c; } } uint256 value4; if ((0 + (int128(arg10 - arg11) * (uint16(var_i)) / 0x2710)) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success3, bytes memory returnData3) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg2, feeRecipient, 0 + (int128(arg10 - arg11) * (uint16(var_i)) / 0x2710)); // call require(success3); uint256 value26 = var_c; if (success3) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; require(!(0)); value26 = 0; } value4 = value26; } else { value4 = 0x24; } require((0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)) < 0x80000000000000000000000000000000, SafeCastOverflow()); require((0 + (int128(arg10 - arg11) * (uint16(var_i)) / 0x2710)) < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(0 + ((arg10 >> 0x80) - (arg11 >> 0x80) * (uint16(uint16(var_i))) / 0x2710)) << 0x80) | (address(int128(0 + (int128(int128(int128(arg10)) - int128(int128(arg11))) * (uint16(uint16(var_i))) / 0x2710))))); } } else { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg10)) - SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg11))) <= 0x0) || ((var_i & 0xffff & 0xffff) == 0x0)) { if ((0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success4, bytes memory returnData4) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, 0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)); // call require(success4); uint256 value5 = 0; if (success4) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value5 = var_c; } } uint256 value6; if (((int128(arg11) * (uint16(var_c.length)) / 0x2710) + 0) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success5, bytes memory returnData5) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg2, feeRecipient, (int128(arg11) * (uint16(var_c.length)) / 0x2710) + 0); // call require(success5); uint256 value27 = var_c; if (success5) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; require(!(0)); value27 = 0; } value6 = value27; } else { value6 = 0x24; } require((0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)) < 0x80000000000000000000000000000000, SafeCastOverflow()); require(((int128(arg11) * (uint16(var_c.length)) / 0x2710) + 0) < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(0 + ((arg10 >> 0x80) - (arg11 >> 0x80) * (uint16(uint16(var_i))) / 0x2710)) << 0x80) | (address(int128((int128(int128(arg11)) * (uint16(uint16(var_c.length))) / 0x2710) + 0)))); } else { if ((0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success6, bytes memory returnData6) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, 0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)); // call require(success6); uint256 value7 = 0; if (success6) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value7 = var_c; } } uint256 value8; if ((int128(arg11) * (uint16(var_c.length)) / 0x2710) + (int128(arg10 - arg11) * (uint16(var_j)) / 0x2710) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success7, bytes memory returnData7) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg2, feeRecipient, (int128(arg11) * (uint16(var_c.length)) / 0x2710) + (int128(arg10 - arg11) * (uint16(var_j)) / 0x2710)); // call require(success7); uint256 value28 = var_c; if (success7) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; require(!(0)); value28 = 0; } value8 = value28; } else { value8 = 0x24; } require((0 + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_i)) / 0x2710)) < 0x80000000000000000000000000000000, SafeCastOverflow()); require((int128(arg11) * (uint16(var_c.length)) / 0x2710) + (int128(arg10 - arg11) * (uint16(var_j)) / 0x2710) < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(0 + ((arg10 >> 0x80) - (arg11 >> 0x80) * (uint16(uint16(var_i))) / 0x2710)) << 0x80) | (address(int128((int128(int128(arg11)) * (uint16(uint16(var_c.length))) / 0x2710) + (int128(int128(int128(arg10)) - int128(int128(arg11))) * (uint16(uint16(var_i))) / 0x2710))))); } } } } else { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, SAR(0x80, arg10)) - SIGNEXTEND(0xf, SAR(0x80, arg11))) <= 0x0) || ((var_i & 0xffff & 0xffff) == 0x0)) { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg11)) <= 0x0) || ((var_h & 0xffff & 0xffff) == 0x0)) { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg10)) - SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg11))) <= 0x0) || ((var_i & 0xffff & 0xffff) == 0x0)) { if (((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success8, bytes memory returnData8) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, (int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0); // call require(success8); uint256 value9 = 0; if (success8) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value9 = var_c; } } uint256 value10; value10 = 0x24; require(((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0) < 0x80000000000000000000000000000000, SafeCastOverflow()); require(0 < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(((arg11 >> 0x80) * (uint16(uint16(var_c.length))) / 0x2710) + 0) << 0x80) | (address(int128(0)))); } else { if (((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success10, bytes memory returnData10) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, (int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0); // call require(success10); uint256 value11 = 0; if (success10) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value11 = var_c; } } uint256 value12; if ((0 + (int128(arg10 - arg11) * (uint16(var_i)) / 0x2710)) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success11, bytes memory returnData11) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg2, feeRecipient, 0 + (int128(arg10 - arg11) * (uint16(var_i)) / 0x2710)); // call require(success11); uint256 value30 = var_c; if (success11) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; require(!(0)); value30 = 0; } value12 = value30; } else { value12 = 0x24; } require(((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0) < 0x80000000000000000000000000000000, SafeCastOverflow()); require((0 + (int128(arg10 - arg11) * (uint16(var_i)) / 0x2710)) < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(((arg11 >> 0x80) * (uint16(uint16(var_c.length))) / 0x2710) + 0) << 0x80) | (address(int128(0 + (int128(int128(int128(arg10)) - int128(int128(arg11))) * (uint16(uint16(var_j))) / 0x2710))))); } } else { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg10)) - SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg11))) <= 0x0) || ((var_i & 0xffff & 0xffff) == 0x0)) { if (((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success12, bytes memory returnData12) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, (int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0); // call require(success12); uint256 value13 = 0; if (success12) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value13 = var_c; } } uint256 value14; if (((int128(arg11) * (uint16(var_c.length)) / 0x2710) + 0) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success13, bytes memory returnData13) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg2, feeRecipient, (int128(arg11) * (uint16(var_c.length)) / 0x2710) + 0); // call require(success13); uint256 value31 = var_c; if (success13) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; require(!(0)); value31 = 0; } value14 = value31; } else { value14 = 0x24; } require(((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0) < 0x80000000000000000000000000000000, SafeCastOverflow()); require(((int128(arg11) * (uint16(var_c.length)) / 0x2710) + 0) < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(((arg11 >> 0x80) * (uint16(uint16(var_c.length))) / 0x2710) + 0) << 0x80) | (address(int128((int128(int128(arg11)) * (uint16(uint16(var_c.length))) / 0x2710) + 0)))); } else { if (((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success14, bytes memory returnData14) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, (int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0); // call require(success14); uint256 value15 = 0; if (success14) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value15 = var_c; } } uint256 value16; if ((int128(arg11) * (uint16(var_c.length)) / 0x2710) + (int128(arg10 - arg11) * (uint16(var_j)) / 0x2710) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success15, bytes memory returnData15) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg2, feeRecipient, (int128(arg11) * (uint16(var_c.length)) / 0x2710) + (int128(arg10 - arg11) * (uint16(var_j)) / 0x2710)); // call require(success15); uint256 value32 = var_c; if (success15) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; require(!(0)); value32 = 0; } value16 = value32; } else { value16 = 0x24; } require(((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + 0) < 0x80000000000000000000000000000000, SafeCastOverflow()); require((int128(arg11) * (uint16(var_c.length)) / 0x2710) + (int128(arg10 - arg11) * (uint16(var_j)) / 0x2710) < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(((arg11 >> 0x80) * (uint16(uint16(var_c.length))) / 0x2710) + 0) << 0x80) | (address(int128((int128(int128(arg11)) * (uint16(uint16(var_c.length))) / 0x2710) + (int128(int128(int128(arg10)) - int128(int128(arg11))) * (uint16(uint16(var_j))) / 0x2710))))); } } } else { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg11)) <= 0x0) || ((var_h & 0xffff & 0xffff) == 0x0)) { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg10)) - SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg11))) <= 0x0) || ((var_i & 0xffff & 0xffff) == 0x0)) { if ((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success16, bytes memory returnData16) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, (int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710)); // call require(success16); uint256 value17 = 0; if (success16) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value17 = var_c; } } uint256 value18; value18 = 0x24; require((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710) < 0x80000000000000000000000000000000, SafeCastOverflow()); require(0 < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(((arg11 >> 0x80) * (uint16(uint16(var_c.length))) / 0x2710) + ((arg10 >> 0x80) - (arg11 >> 0x80) * (uint16(uint16(var_j))) / 0x2710)) << 0x80) | (address(int128(0)))); } else { if ((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success18, bytes memory returnData18) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, (int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710)); // call require(success18); uint256 value19 = 0; if (success18) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value19 = var_c; } } uint256 value20; if ((0 + (int128(arg10 - arg11) * (uint16(var_i)) / 0x2710)) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success19, bytes memory returnData19) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg2, feeRecipient, 0 + (int128(arg10 - arg11) * (uint16(var_i)) / 0x2710)); // call require(success19); uint256 value34 = var_c; if (success19) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; require(!(0)); value34 = 0; } value20 = value34; } else { value20 = 0x24; } require((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710) < 0x80000000000000000000000000000000, SafeCastOverflow()); require((0 + (int128(arg10 - arg11) * (uint16(var_i)) / 0x2710)) < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(((arg11 >> 0x80) * (uint16(uint16(var_c.length))) / 0x2710) + ((arg10 >> 0x80) - (arg11 >> 0x80) * (uint16(uint16(var_j))) / 0x2710)) << 0x80) | (address(int128(0 + (int128(int128(int128(arg10)) - int128(int128(arg11))) * (uint16(uint16(var_j))) / 0x2710))))); } } else { if ((SIGNEXTEND(0xf, SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg10)) - SIGNEXTEND(0xf, SIGNEXTEND(0xf, arg11))) <= 0x0) || ((var_i & 0xffff & 0xffff) == 0x0)) { if ((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success20, bytes memory returnData20) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, (int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710)); // call require(success20); uint256 value21 = 0; if (success20) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value21 = var_c; } } uint256 value22; if (((int128(arg11) * (uint16(var_c.length)) / 0x2710) + 0) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success21, bytes memory returnData21) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg2, feeRecipient, (int128(arg11) * (uint16(var_c.length)) / 0x2710) + 0); // call require(success21); uint256 value35 = var_c; if (success21) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; require(!(0)); value35 = 0; } value22 = value35; } else { value22 = 0x24; } require((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710) < 0x80000000000000000000000000000000, SafeCastOverflow()); require(((int128(arg11) * (uint16(var_c.length)) / 0x2710) + 0) < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(((arg11 >> 0x80) * (uint16(uint16(var_c.length))) / 0x2710) + ((arg10 >> 0x80) - (arg11 >> 0x80) * (uint16(uint16(var_j))) / 0x2710)) << 0x80) | (address(int128((int128(int128(arg11)) * (uint16(uint16(var_c.length))) / 0x2710) + 0)))); } else { if ((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success22, bytes memory returnData22) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg1, feeRecipient, (int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710)); // call require(success22); uint256 value23 = 0; if (success22) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; } else { value23 = var_c; } } uint256 value24; if ((int128(arg11) * (uint16(var_c.length)) / 0x2710) + (int128(arg10 - arg11) * (uint16(var_j)) / 0x2710) != 0x0) { require(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df.code.length != 0x0); (bool success23, bytes memory returnData23) = address(0x28e2ea090877bf75740558f6bfb36a5ffee9e9df).take(arg2, feeRecipient, (int128(arg11) * (uint16(var_c.length)) / 0x2710) + (int128(arg10 - arg11) * (uint16(var_j)) / 0x2710)); // call require(success23); uint256 value36 = var_c; if (success23) { if (((var_c + 0) > 0xffffffffffffffff) | ((var_c + 0) < var_c)) _desolexPanic(65); var_c = var_c + 0; require(!(0)); value36 = 0; } value24 = value36; } else { value24 = 0x24; } require((int128(arg11 >> 0x80) * (uint16(var_c.length)) / 0x2710) + (int128((arg10 >> 0x80) - (arg11 >> 0x80)) * (uint16(var_j)) / 0x2710) < 0x80000000000000000000000000000000, SafeCastOverflow()); require((int128(arg11) * (uint16(var_c.length)) / 0x2710) + (int128(arg10 - arg11) * (uint16(var_j)) / 0x2710) < 0x80000000000000000000000000000000, SafeCastOverflow()); return abi.encodePacked(0x6c2bbe7e00000000000000000000000000000000000000000000000000000000, (int128(((arg11 >> 0x80) * (uint16(uint16(var_c.length))) / 0x2710) + ((arg10 >> 0x80) - (arg11 >> 0x80) * (uint16(uint16(var_j))) / 0x2710)) << 0x80) | (address(int128((int128(int128(arg11)) * (uint16(uint16(var_c.length))) / 0x2710) + (int128(int128(int128(arg10)) - int128(int128(arg11))) * (uint16(uint16(var_j))) / 0x2710))))); } } } } } } } } } } } } } } } } } function setExemptAddress(address newAddress) public { bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); uint256 var_c; if (!(msg.sender == stor_0)) { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(msg.sender == stor_0); } if (!(flag0)) { stor_3 = newAddress | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_3); emit Event_1d9af658(newAddress); } (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); if (!(success0)) { require(msg.sender == 0, NotOwner()); stor_3 = newAddress | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_3); emit Event_1d9af658(newAddress); } if (0x20 > returnData0.length) { if (((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData0.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); stor_3 = newAddress | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_3); emit Event_1d9af658(newAddress); } function trustedRouter(address account) public view returns (bool) { return !(!(bytes1(mapping_7[account]))); } function Unknown_64c01488(bytes32 arg0) public view returns (bytes memory) { return abi.encodePacked(uint16(mapping_9[arg0]), uint16(mapping_9[arg0] >> 0x10)); } function paused() public view returns (bool) { return !(!(bytes1(stor_3 >> 0xd0))); } function Unknown_5ba9f60a(uint24 arg0, uint24 arg1, uint24 arg2, uint24 arg3, uint16 arg4, uint16 arg5, uint16 arg6, uint256 arg7, address arg8, uint16 arg9, bool arg10) public { bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); uint256 var_c; if (!(stor_0 == msg.sender)) { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(stor_0 == msg.sender); } if (!(flag0)) { if (((var_c + 0x0160) > 0xffffffffffffffff) | ((var_c + 0x0160) < var_c)) _desolexPanic(65); var_c = var_c + 0x0160; require(arg0 == (arg0 & 0xffffff)); require(arg1 == (arg1 & 0xffffff)); require(arg2 == (arg2 & 0xffffff)); require(arg3 == (arg3 & 0xffffff)); require(arg4 == (arg4 & 0xffff)); require(arg5 == (arg5 & 0xffff)); require(arg6 == (arg6 & 0xffff)); require(arg9 == (arg9 & 0xffff)); require(uint24(arg0) <= 0x0f4240, LPFeeTooLarge()); require(uint24(var_q) <= 0x0f4240, LPFeeTooLarge()); require(uint24(var_r) <= 0x0f4240, LPFeeTooLarge()); require(uint24(var_s) <= 0x0f4240, LPFeeTooLarge()); require(uint16(var_t) + uint16(var_u) + uint16(var_v) <= 0x2710, CustomError_da2a1e87()); stor_0 = (0xffffff000000000000000000ffffffffffffffffffffffffffffffffffffffff & stor_0 | ((var_c.length << 0xa0) & (0xffffff0000000000000000000000000000000000000000)) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | ((var_w << 0xb8) & (0xffffff0000000000000000000000000000000000000000000000)) | ((var_x << 0xd0) & (0xffffff0000000000000000000000000000000000000000000000000000))) | ((var_y << 0xe8) & (0xffffff0000000000000000000000000000000000000000000000000000000000)); stor_1 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000 & stor_1 | (0xffff & var_t) | (0xffff0000 & (var_u << 0x10))) | (0xffff00000000 & (var_v << 0x20)); gasThreshold = var_z; stor_3 = (stor_3 & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | (var_aa & (0xffffffffffffffffffffffffffffffffffffffff)); emit Event_7788933e(uint24(var_c.length), uint24(var_w), uint24(var_x), uint24(var_y), uint16(var_ao), uint16(var_ap), uint16(var_aq), var_ar, address(var_as), uint16(var_at), !(!(var_au))); } (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); if (!(success0)) { require(msg.sender == 0, NotOwner()); if (((var_c + 0x0160) > 0xffffffffffffffff) | ((var_c + 0x0160) < var_c)) _desolexPanic(65); var_c = var_c + 0x0160; require(arg0 == (arg0 & 0xffffff)); require(arg1 == (arg1 & 0xffffff)); require(arg2 == (arg2 & 0xffffff)); require(arg3 == (arg3 & 0xffffff)); require(arg4 == (arg4 & 0xffff)); require(arg5 == (arg5 & 0xffff)); require(arg6 == (arg6 & 0xffff)); require(arg9 == (arg9 & 0xffff)); require(uint24(arg0) <= 0x0f4240, LPFeeTooLarge()); require(uint24(var_q) <= 0x0f4240, LPFeeTooLarge()); require(uint24(var_r) <= 0x0f4240, LPFeeTooLarge()); require(uint24(var_s) <= 0x0f4240, LPFeeTooLarge()); require(uint16(var_t) + uint16(var_u) + uint16(var_v) <= 0x2710, CustomError_da2a1e87()); stor_0 = (0xffffff000000000000000000ffffffffffffffffffffffffffffffffffffffff & stor_0 | ((var_c.length << 0xa0) & (0xffffff0000000000000000000000000000000000000000)) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | ((var_w << 0xb8) & (0xffffff0000000000000000000000000000000000000000000000)) | ((var_x << 0xd0) & (0xffffff0000000000000000000000000000000000000000000000000000))) | ((var_y << 0xe8) & (0xffffff0000000000000000000000000000000000000000000000000000000000)); stor_1 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000 & stor_1 | (0xffff & var_t) | (0xffff0000 & (var_u << 0x10))) | (0xffff00000000 & (var_v << 0x20)); gasThreshold = var_z; stor_3 = (stor_3 & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | (var_aa & (0xffffffffffffffffffffffffffffffffffffffff)); emit Event_7788933e(uint24(var_c.length), uint24(var_w), uint24(var_x), uint24(var_y), uint16(var_ao), uint16(var_ap), uint16(var_aq), var_ar, address(var_as), uint16(var_at), !(!(var_au))); } if (0x20 > returnData0.length) { if (((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData0.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); if (((var_c + 0x0160) > 0xffffffffffffffff) | ((var_c + 0x0160) < var_c)) _desolexPanic(65); var_c = var_c + 0x0160; require(arg0 == (arg0 & 0xffffff)); require(arg1 == (arg1 & 0xffffff)); require(arg2 == (arg2 & 0xffffff)); require(arg3 == (arg3 & 0xffffff)); require(arg4 == (arg4 & 0xffff)); require(arg5 == (arg5 & 0xffff)); require(arg6 == (arg6 & 0xffff)); require(arg9 == (arg9 & 0xffff)); require(uint24(arg0) <= 0x0f4240, LPFeeTooLarge()); require(uint24(var_q) <= 0x0f4240, LPFeeTooLarge()); require(uint24(var_r) <= 0x0f4240, LPFeeTooLarge()); require(uint24(var_s) <= 0x0f4240, LPFeeTooLarge()); require(uint16(var_t) + uint16(var_u) + uint16(var_v) <= 0x2710, CustomError_da2a1e87()); stor_0 = (0xffffff000000000000000000ffffffffffffffffffffffffffffffffffffffff & stor_0 | ((var_c.length << 0xa0) & (0xffffff0000000000000000000000000000000000000000)) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | ((var_w << 0xb8) & (0xffffff0000000000000000000000000000000000000000000000)) | ((var_x << 0xd0) & (0xffffff0000000000000000000000000000000000000000000000000000))) | ((var_y << 0xe8) & (0xffffff0000000000000000000000000000000000000000000000000000000000)); stor_1 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffff000000000000 & stor_1 | (0xffff & var_t) | (0xffff0000 & (var_u << 0x10))) | (0xffff00000000 & (var_v << 0x20)); gasThreshold = var_z; stor_3 = (stor_3 & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | (var_aa & (0xffffffffffffffffffffffffffffffffffffffff)); emit Event_7788933e(uint24(var_c.length), uint24(var_w), uint24(var_x), uint24(var_y), uint16(var_ao), uint16(var_ap), uint16(var_aq), var_ar, address(var_as), uint16(var_at), !(!(var_au))); } function defaultFee() public view returns (uint256) { return stor_0 >> 0xe8; } function Unknown_575e24b4(address arg0, address arg5, bytes memory arg9) public view { } function Unknown_54b60449(uint16 arg0, bool arg1) public { require(arg0 == (arg0 & 0xffff)); require(msg.sender == 0xaf6c9d662e00a04038b88216ff97e44, NotOwner()); require(uint16(arg0) <= 0x2710, CustomError_da2a1e87()); stor_3 = (0xffffffffffff000000ffffffffffffffffffffffffffffffffffffffffffffff & stor_3 | ((arg0 << 0xb8) & (0xffff0000000000000000000000000000000000000000000000))) | ((arg1 << 0xc8) & (0xff00000000000000000000000000000000000000000000000000)); emit Event_a0d23374(uint16(arg0), arg1); } function Unknown_53608258() public view returns (uint16) { return uint16(stor_1); } function Unknown_50e67a96() public view returns (uint256) { if (gasThreshold < block.gaslimit) { return gasThreshold; } return block.gaslimit; } function whitelistOnly() public view returns (bool) { return !(!(bytes1(stor_8))); } function Unknown_403fefe5(uint24 arg0, uint16 arg1, bool arg2) public pure returns (bytes memory) { require(arg0 == (arg0 & 0xffffff)); require(arg1 == (arg1 & 0xffff)); require(!(uint24(arg0) > 0x0f4240), LPFeeTooLarge()); require(!(uint16(arg1) > 0x2710), CustomError_da2a1e87()); uint256 value5 = (arg0) ? 1 : 0; uint256 value6 = 0; if (!((arg0 & 0xffffff) != 0x0 && (arg1 & 0xffff) == 0x0 || (arg0 & 0xffffff) == 0x0)) { uint256 value7 = 0; uint256 value8 = (arg0) ? 1 : 0; if (!((arg1 & 0xffff) == 0x2710)) { uint256 value9; uint256 value10; if (!arg2) { require(0x2710 > ((uint16(arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg0) * (uint16(arg1))) - ((uint16(arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg0) * (uint16(arg1)))))); uint256 value0 = (uint24(arg0) * (uint16(arg1))) / 0x2710; if (!((uint16(arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg0) * (uint16(arg1))) == ((uint16(arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg0) * (uint16(arg1)))))) { value0 = ((uint24(arg0) * (uint16(arg1)) - (uint16(arg1) * (uint24(arg0)) % 0x2710) >> 0x04) | ((uint16(arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg0) * (uint16(arg1))) - ((uint16(arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg0) * (uint16(arg1)))) - ((uint16(arg1) * (uint24(arg0)) % 0x2710) > (uint24(arg0) * (uint16(arg1)))) << 0xfc)) * 0xbc01a36e2eb1c432ca57a786c226809d495182a9930be0ded288ce703afb7e91; } require((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) > (((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) - (((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff)))))); uint256 value1 = (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) / ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff)); if (!(((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) == (((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff)))))) { uint256 sharedExpr15 = (0 - ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) & ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff)); uint256 sharedExpr16 = 0x03 * ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr15); uint256 sharedExpr17 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr15) * (sharedExpr16 ^ 0x02)); uint256 sharedExpr18 = sharedExpr16 ^ 0x02; uint256 sharedExpr19 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr15) * (sharedExpr17 * sharedExpr18)); uint256 sharedExpr20 = sharedExpr17 * sharedExpr18; uint256 sharedExpr21 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr15) * (sharedExpr19 * sharedExpr20)); uint256 sharedExpr22 = sharedExpr19 * sharedExpr20; uint256 sharedExpr23 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr15) * (sharedExpr21 * sharedExpr22)); uint256 sharedExpr24 = sharedExpr21 * sharedExpr22; uint256 sharedExpr25 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr15) * (sharedExpr23 * sharedExpr24)); uint256 sharedExpr26 = sharedExpr23 * sharedExpr24; uint256 sharedExpr27 = (uint24(arg0) - (uint24(value0))) & (0xffffff); uint256 sharedExpr28 = (0x0f4240 - (uint24(uint24(value0)))) & (0xffffff); uint256 sharedExpr29 = (0 - ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) & ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff)); uint256 sharedExpr30 = 0x03 * ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr29); uint256 sharedExpr31 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr29) * (sharedExpr30 ^ 0x02)); uint256 sharedExpr32 = sharedExpr30 ^ 0x02; uint256 sharedExpr33 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr29) * (sharedExpr31 * sharedExpr32)); uint256 sharedExpr34 = sharedExpr31 * sharedExpr32; uint256 sharedExpr35 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr29) * (sharedExpr33 * sharedExpr34)); uint256 sharedExpr36 = sharedExpr33 * sharedExpr34; uint256 sharedExpr37 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr29) * (sharedExpr35 * sharedExpr36)); uint256 sharedExpr38 = sharedExpr35 * sharedExpr36; uint256 sharedExpr39 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr29) * (sharedExpr37 * sharedExpr38)); uint256 sharedExpr40 = sharedExpr37 * sharedExpr38; uint256 sharedExpr41 = ((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) - ((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) / ((0 - ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) & ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) | (((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) - (((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff)))) - ((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff)) > (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff)))) * ((0 - ((0 - ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) & ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff)))) / ((0 - ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) & ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) + 0x01))) * ((0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr29) * (sharedExpr39 * sharedExpr40))) * (sharedExpr39 * sharedExpr40)); value1 = sharedExpr41; } uint256 value11 = uint24(0x01 + value1); if ((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff)) != 0x0) { require(value1 != type(uint256).max); } else { value11 = uint24(value1); } value9 = value11; value10 = uint24(value0); } else { require(0x2710 > ((uint16(0x2710 - arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg0) * (uint16(0x2710 - arg1))) - ((uint16(0x2710 - arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg0) * (uint16(0x2710 - arg1)))))); uint256 value2 = (uint24(arg0) * (uint16(0x2710 - arg1))) / 0x2710; if (!((uint16(0x2710 - arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg0) * (uint16(0x2710 - arg1))) == ((uint16(0x2710 - arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg0) * (uint16(0x2710 - arg1)))))) { value2 = ((uint24(arg0) * (uint16(0x2710 - arg1)) - (uint16(0x2710 - arg1) * (uint24(arg0)) % 0x2710) >> 0x04) | ((uint16(0x2710 - arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (uint24(arg0) * (uint16(0x2710 - arg1))) - ((uint16(0x2710 - arg1) * (uint24(arg0)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (uint24(arg0) * (uint16(0x2710 - arg1)))) - ((uint16(0x2710 - arg1) * (uint24(arg0)) % 0x2710) > (uint24(arg0) * (uint16(0x2710 - arg1)))) << 0xfc)) * 0xbc01a36e2eb1c432ca57a786c226809d495182a9930be0ded288ce703afb7e91; } require(uint24(0x0f4240 - value2) > (((0x0f4240 * (uint24(arg0 - value2))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0f4240 * (uint24(arg0 - value2))) - (((0x0f4240 * (uint24(arg0 - value2))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0f4240 * (uint24(arg0 - value2)))))); uint256 value3 = (0x0f4240 * (uint24(arg0 - value2))) / (uint24(0x0f4240 - value2)); if (!(((0x0f4240 * (uint24(arg0 - value2))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0f4240 * (uint24(arg0 - value2))) == (((0x0f4240 * (uint24(arg0 - value2))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0f4240 * (uint24(arg0 - value2)))))) { uint256 sharedExpr57 = (0 - ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) & ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff)); uint256 sharedExpr58 = 0x03 * ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr57); uint256 sharedExpr59 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr57) * (sharedExpr58 ^ 0x02)); uint256 sharedExpr60 = sharedExpr58 ^ 0x02; uint256 sharedExpr61 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr57) * (sharedExpr59 * sharedExpr60)); uint256 sharedExpr62 = sharedExpr59 * sharedExpr60; uint256 sharedExpr63 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr57) * (sharedExpr61 * sharedExpr62)); uint256 sharedExpr64 = sharedExpr61 * sharedExpr62; uint256 sharedExpr65 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr57) * (sharedExpr63 * sharedExpr64)); uint256 sharedExpr66 = sharedExpr63 * sharedExpr64; uint256 sharedExpr67 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr57) * (sharedExpr65 * sharedExpr66)); uint256 sharedExpr68 = sharedExpr65 * sharedExpr66; uint256 sharedExpr69 = uint24(arg0 - value2); uint256 sharedExpr70 = uint24(0x0f4240 - value2); uint256 sharedExpr71 = (0 - ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) & ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff)); uint256 sharedExpr72 = 0x03 * ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr71); uint256 sharedExpr73 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr71) * (sharedExpr72 ^ 0x02)); uint256 sharedExpr74 = sharedExpr72 ^ 0x02; uint256 sharedExpr75 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr71) * (sharedExpr73 * sharedExpr74)); uint256 sharedExpr76 = sharedExpr73 * sharedExpr74; uint256 sharedExpr77 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr71) * (sharedExpr75 * sharedExpr76)); uint256 sharedExpr78 = sharedExpr75 * sharedExpr76; uint256 sharedExpr79 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr71) * (sharedExpr77 * sharedExpr78)); uint256 sharedExpr80 = sharedExpr77 * sharedExpr78; uint256 sharedExpr81 = 0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr71) * (sharedExpr79 * sharedExpr80)); uint256 sharedExpr82 = sharedExpr79 * sharedExpr80; uint256 sharedExpr83 = ((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) - ((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) / ((0 - ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) & ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) | (((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) - (((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff)))) - ((0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff))) % ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff)) > (0x0f4240 * (uint24(arg0) - (uint24(value0)) & (0xffffff)))) * ((0 - ((0 - ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) & ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff)))) / ((0 - ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) & ((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff))) + 0x01))) * ((0x02 - (((0x0f4240 - (uint24(uint24(value0)))) & (0xffffff) / sharedExpr71) * (sharedExpr81 * sharedExpr82))) * (sharedExpr81 * sharedExpr82)); value3 = sharedExpr83; } uint256 value4 = 0x01 + value3; if ((0x0f4240 * (uint24(arg0 - value2))) % (uint24(0x0f4240 - value2)) != 0x0) { require(value3 != type(uint256).max); } else { value4 = value3; } value9 = uint24(value2); value10 = uint24(value4); } value7 = value9; value8 = value10; } value5 = value7; value6 = value8; } return abi.encodePacked(uint24(value5), uint24(value6)); } function quoteFee() public view returns (uint24) { return uint24(stor_3 >> 0xa0); } function Unknown_265acb63(bytes32 arg0, uint16 arg1, uint16 arg2) public { require(arg1 == (arg1 & 0xffff)); require(arg2 == (arg2 & 0xffff)); require(msg.sender == 0xaf6c9d662e00a04038b88216ff97e44, NotOwner()); require(uint16(arg1) <= 0x2710, CustomError_da2a1e87()); require(uint16(arg2) <= 0x2710, CustomError_da2a1e87()); uint256 var_a; if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) _desolexPanic(65); var_a = var_a + 0x40; mapping_9[arg0] = (mapping_9[arg0] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000)) | (var_a.length & (0xffff)); mapping_9[arg0] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000ffff & mapping_9[arg0]) | ((var_f << 0x10) & (0xffff0000) & (0xffff0000)); emit Event_935183c4(arg0, uint16(arg1), uint16(arg2)); } function Unknown_21d0ee70(address arg0, bytes memory arg10) public view { require((msg.data.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc) >= 0xa0); require((msg.data.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3c) >= 0x80); require(((0x04 + arg10) + 0x1f) < msg.data.length); require(((0x04 + arg10) + arg10 + 0x20) <= msg.data.length); require(msg.sender != 0x28e2ea090877bf75740558f6bfb36a5ffee9e9df, HookNotImplemented()); revert NotPoolManager(); } function Unknown_259982e5(address arg0, bytes memory arg10) public view { require((msg.data.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc) >= 0xa0); require((msg.data.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3c) >= 0x80); require(((0x04 + arg10) + 0x1f) < msg.data.length); require(((0x04 + arg10) + arg10 + 0x20) <= msg.data.length); require(msg.sender != 0x28e2ea090877bf75740558f6bfb36a5ffee9e9df, HookNotImplemented()); revert NotPoolManager(); } function Unknown_1c21e91e() public view returns (uint16) { return uint16(stor_1 >> 0x10); } function setPaused(bool arg0) public { bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); uint256 var_c; if (!(msg.sender == stor_0)) { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { flag0 = !(msg.sender == stor_0); } if (!(flag0)) { stor_3 = (0xffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_3) | ((arg0 << 0xd0) & (0xff0000000000000000000000000000000000000000000000000000)); emit PausedUpdated(arg0); } (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); if (!(success0)) { require(msg.sender == 0, NotOwner()); stor_3 = (0xffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_3) | ((arg0 << 0xd0) & (0xff0000000000000000000000000000000000000000000000000000)); emit PausedUpdated(arg0); } if (0x20 > returnData0.length) { if (((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData0.length) - var_c) >= 0x20); } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); } require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); stor_3 = (0xffffffffff00ffffffffffffffffffffffffffffffffffffffffffffffffffff & stor_3) | ((arg0 << 0xd0) & (0xff0000000000000000000000000000000000000000000000000000)); emit PausedUpdated(arg0); } function Unknown_14724809(uint16 arg0) public view returns (uint24) { require(arg0 == (arg0 & 0xffff)); require(uint16(arg0) < 0x2710, CustomError_cb3dbf49()); if (uint16(arg0) < (uint16(stor_1))) { return uint24(stor_0 >> 0xa0); } else { if (uint16(arg0) < (uint16(stor_1 + (stor_1 >> 0x10)))) { return uint24(stor_0 >> 0xb8); } else { if (uint16(stor_1 + (stor_1 >> 0x10) + (stor_1 >> 0x20)) > (uint16(arg0))) { return uint24(stor_0 >> 0xd0); } else { return uint24(stor_0 >> 0xe8); } } } } function tierTwoFee() public view returns (uint24) { return uint24(stor_0 >> 0xb8); } function splitBps() public view returns (uint16) { return uint16(stor_3 >> 0xb8); } function Unknown_0024bbf9(bytes memory arg0, uint24 arg1, bool arg2) public { require(((0x04 + arg0) + 0x1f) < msg.data.length); require(!(((arg0.length << 0x05) + (0x04 + arg0) + 0x20) > msg.data.length)); require(arg1 == (arg1 & 0xffffff)); uint256 value0 = msg.data[0] >> 0xe0; bool flag0 = !(keccak256(abi.encode(0x52c6f702ce5d9a3ce449d3b7824c77dead000000000000000000000000)) == (keccak256(abi.encode(msg.sender << 0x60)))); if (!(msg.sender == stor_0)) { if ((0xc0 > 0xffffffffffffffff) | (0xc0 < 0x80)) _desolexPanic(65); uint256 var_c; var_c = 0xc0; if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; } else { value0 = 0x80; flag0 = !(msg.sender == stor_0); } if (flag0) { (bool success0, bytes memory returnData0) = address(0x0af6c9d662e00a04038b88216ff97e44).owner(); // staticcall require(success0); if (success0) { if (0x20 > returnData0.length) { if (((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + returnData0.length) - var_c) >= 0x20); require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); if (arg2) { require(uint24(arg1) <= 0x0f4240, LPFeeTooLarge()); } uint256 value1 = 0; while (true) { if (!(value1 < arg0.length)) { _desolexPanic(50); break; } if ((value1 << 0x05) + (arg0 + 0x20) != (address((value1 << 0x05) + (arg0 + 0x20)))) { revert(); break; } if (!(address((value1 << 0x05) + (arg0 + 0x20)))) { revert InvalidAddress(); break; } if (!arg2) { unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] = 0; uint256 value2 = 0; emit Event_193a1c5e(address((value1 << 0x05) + (arg0 + 0x20)), uint24(value2), arg2); } else { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] | (var_c.length & (0xffffff))) | (((!(!(var_l))) << 0x18) & (0xff000000)); uint256 value3 = 0; value3 = (arg1) ? 1 : 0; emit Event_193a1c5e(address((value1 << 0x05) + (arg0 + 0x20)), uint24(value3), arg2); } value1 = value1 + 0x01; } } else { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; require(((var_c + 0x20) - var_c) >= 0x20); require(var_c.length == (address(var_c.length))); require(msg.sender == (address(var_c.length)), NotOwner()); if (arg2) { require(uint24(arg1) <= 0x0f4240, LPFeeTooLarge()); } uint256 value1 = 0; while (true) { if (!(value1 < arg0.length)) { _desolexPanic(50); break; } if ((value1 << 0x05) + (arg0 + 0x20) != (address((value1 << 0x05) + (arg0 + 0x20)))) { revert(); break; } if (!(address((value1 << 0x05) + (arg0 + 0x20)))) { revert InvalidAddress(); break; } if (!arg2) { unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] = 0; uint256 value4 = 0; emit Event_193a1c5e(address((value1 << 0x05) + (arg0 + 0x20)), uint24(value4), arg2); } else { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] | (var_c.length & (0xffffff))) | (((!(!(var_l))) << 0x18) & (0xff000000)); uint256 value5 = 0; value5 = (arg1) ? 1 : 0; emit Event_193a1c5e(address((value1 << 0x05) + (arg0 + 0x20)), uint24(value5), arg2); } value1 = value1 + 0x01; } } } else { require(msg.sender == 0, NotOwner()); if (arg2) { require(uint24(arg1) <= 0x0f4240, LPFeeTooLarge()); } uint256 value1 = 0; while (true) { if (!(value1 < arg0.length)) { _desolexPanic(50); break; } if ((value1 << 0x05) + (arg0 + 0x20) != (address((value1 << 0x05) + (arg0 + 0x20)))) { revert(); break; } if (!(address((value1 << 0x05) + (arg0 + 0x20)))) { revert InvalidAddress(); break; } if (!arg2) { unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] = 0; uint256 value6 = 0; emit Event_193a1c5e(address((value1 << 0x05) + (arg0 + 0x20)), uint24(value6), arg2); } else { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] | (var_c.length & (0xffffff))) | (((!(!(var_l))) << 0x18) & (0xff000000)); uint256 value7 = 0; value7 = (arg1) ? 1 : 0; emit Event_193a1c5e(address((value1 << 0x05) + (arg0 + 0x20)), uint24(value7), arg2); } value1 = value1 + 0x01; } } } else { if (arg2) { require(uint24(arg1) <= 0x0f4240, LPFeeTooLarge()); } uint256 value1 = 0; while (true) { if (!(value1 < arg0.length)) { _desolexPanic(50); break; } if ((value1 << 0x05) + (arg0 + 0x20) != (address((value1 << 0x05) + (arg0 + 0x20)))) { revert(); break; } if (!(address((value1 << 0x05) + (arg0 + 0x20)))) { revert InvalidAddress(); break; } if (!arg2) { unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] = 0; uint256 value8 = 0; emit Event_193a1c5e(address((value1 << 0x05) + (arg0 + 0x20)), uint24(value8), arg2); } else { if (((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c)) _desolexPanic(65); var_c = var_c + 0x40; unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & unresolved_6ada0ce6[address((value1 << 0x05) + (arg0 + 0x20))] | (var_c.length & (0xffffff))) | (((!(!(var_l))) << 0x18) & (0xff000000)); uint256 value9 = 0; value9 = (arg1) ? 1 : 0; emit Event_193a1c5e(address((value1 << 0x05) + (arg0 + 0x20)), uint24(value9), arg2); } value1 = value1 + 0x01; } } } function __desolexSelectorShim(uint32 rewrittenSelector) private { assembly { let input := mload(0x40) calldatacopy(input, 0, calldatasize()) mstore(input, or(and(mload(input), 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(224, and(rewrittenSelector, 0xffffffff)))) let success := delegatecall(gas(), address(), input, calldatasize(), 0, 0) let size := returndatasize() returndatacopy(input, 0, size) switch success case 0 { revert(input, size) } default { return(input, size) } } } // Note: This selector table is synthetic and is not part of the original Solidity source. // It records the recovered selector-to-signature mapping without executable behavior. // 0x0024bbf9 => Unknown_0024bbf9(bytes,uint24,bool) // 0x048d372c => splitBps() // 0x08ac6289 => tierTwoFee() // 0x14724809 => Unknown_14724809(uint16) // 0x16c38b3c => setPaused(bool) // 0x1c21e91e => Unknown_1c21e91e() // 0x21d0ee70 => Unknown_21d0ee70(address,bytes) // 0x259982e5 => Unknown_259982e5(address,bytes) // 0x265acb63 => Unknown_265acb63(bytes32,uint16,uint16) // 0x38759da4 => gasThreshold() // 0x3ae9a260 => quoteFee() // 0x403fefe5 => Unknown_403fefe5(uint24,uint16,bool) // 0x46904840 => feeRecipient() // 0x4b4687b5 => whitelistOnly() // 0x50e67a96 => Unknown_50e67a96() // 0x53608258 => Unknown_53608258() // 0x54b60449 => Unknown_54b60449(uint16,bool) // 0x575e24b4 => Unknown_575e24b4(address,address,bytes) // 0x58ad48fd => unresolved_58ad48fd() // 0x5a6c72d0 => defaultFee() // 0x5ba9f60a => Unknown_5ba9f60a(uint24,uint24,uint24,uint24,uint16,uint16,uint16,uint256,address,uint16,bool) // 0x5c975abb => paused() // 0x64c01488 => Unknown_64c01488(bytes32) // 0x687e2c17 => trustedRouter(address) // 0x698c3891 => setExemptAddress(address) // 0x6ada0ce6 => unresolved_6ada0ce6(address) // 0x6c2bbe7e => Unknown_6c2bbe7e(address,address,address,uint256,uint256,uint256,bytes) // 0x6fe7e6eb => Unknown_6fe7e6eb(address,address,uint256) // 0x73fd43e2 => Unknown_73fd43e2() // 0x7d79e7d4 => unresolved_7d79e7d4() // 0x810da780 => exemptAddress() // 0x8da5cb5b => owner() // 0x94168af8 => swapCount(bytes32) // 0x952e60c2 => Unknown_952e60c2(address,uint24,bool) // 0x9a50c628 => tierOneFee() // 0x9d951b3b => tierThreeFee() // 0x9f063efc => Unknown_9f063efc(address,uint256,uint256,bytes) // 0x9f6fd915 => Unknown_9f6fd915(uint24) // 0xac807cf4 => Unknown_ac807cf4(bool,uint24,bool) // 0xb47b2fb1 => Unknown_b47b2fb1(address,address,address,uint24,uint256,address,bool,uint256,uint256,bytes) // 0xb6a8b0fa => Unknown_b6a8b0fa(address,uint256,uint256,bytes) // 0xc446726a => setTrustedRouterBatch(address[],bool) // 0xc45a0155 => factory() // 0xc4e833ce => getHookPermissions() // 0xc64f5351 => setTrustedRouter(address,bool) // 0xc899a6ac => splitEnabled() // 0xcb3b3ab3 => setGasThreshold(uint256) // 0xd18e3427 => Unknown_d18e3427(address,address,address,uint24,uint256,address,bool,uint256,address,uint256) // 0xd9caed12 => withdraw(address,address,uint256) // 0xdc4c90d3 => poolManager() // 0xdc98354e => Unknown_dc98354e(address,address) // 0xdfbec3f1 => Unknown_dfbec3f1(address) // 0xe1a45218 => BPS_DENOMINATOR() // 0xe1b4af69 => Unknown_e1b4af69(address,uint256,uint256,bytes) // 0xea05a8c6 => setWhitelistOnly(bool) // 0xea5736af => unresolved_ea5736af() // 0xf2fde38b => transferOwnership(address) // 0xf8a49c89 => Unknown_f8a49c89()}