BNB Chain
0xf080c366f7ee7b8efadbc74f8e7b1e76c7a7494e
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0xf080c366…c7a7494e18.0 KB185.9 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0xf080c366f7ee7b8efadbc74f8e7b1e76c7a7494e
3,465 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 2 of 64 entry points (170000 ms contract budget): 23b872dd, a9059cbb// SPDX-License-Identifier: MITpragma solidity >=0.8.0;interface IDesolexERC20 { function balanceOf(address account) external view returns (uint256 balance); function transfer(address recipient, uint256 amount) external returns (bool success);}contract DesolexContract { address public constant unresolved_0e052500 = address(0xd5df4d260d7a0145f655bcbf3b398076f21016c7); uint256 public constant INTERN_SYSTEM = 59982529565474602786053471651654676140957756238362561887554810313527260672626; uint8 public constant decimals = 18; uint256 public constant BLACK_HOLE = 57005; address public constant unresolved_60e1df63 = address(0xe45327ee4c003180c9a64ab6f98681a7bd72eff); uint256 public constant FOUNDATION = 1068955999388627156035710863268266351636844984665; address public constant unresolved_6f51e8de = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5); uint256 public constant DEFAULT_ADMIN_ROLE = 0; uint256 public constant unresolved_a5f596e5 = 831676613841306571475595674754198799807003507681; address public constant LP_TOKEN = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452); uint256 public constant INTERN_SYSTEM_MANAGER = 93607044848363402794244116661092631206634518530482369123436161345688078138743; uint256 public constant USDT = 489982930986835137684486657990555633941558688085; uint256 public constant unresolved_fda191e2 = 489982930986835137684486657990555633941558688085; address public constant SWAPROUTER = address(0x10ed43c718714eb63d5aa57b78b54704e256024e); address public constant FEEPOOL = address(0x69141c22a26b96b140faf74afd99f2fc5bfa9b18); uint256 public constant TOKEN_MANAGER = 40368397740492514231869833713661771874802627165310775572604548191503390570144; mapping(address => uint256) public balanceOf; // STORAGE[0x0] mapping(address => mapping(address => uint256)) public allowance; // STORAGE[0x1] uint256 public totalSupply; // STORAGE[0x2] string _name; // STORAGE[0x3] string _symbol; // STORAGE[0x4] bytes32[] array_5; // STORAGE[0x5] bytes32[] array_6; // STORAGE[0x6] mapping(address => uint256) public nonces; // STORAGE[0x7] mapping(bytes32 => mapping(address => bool)) public hasRole; // STORAGE[0x9] uint256 public buyFee; // STORAGE[0xa] uint256 public sellFee; // STORAGE[0xb] uint256 public lastDay; // STORAGE[0xc] uint256 public minFeeAmount; // STORAGE[0xd] uint256 public unresolved_130b3867; // STORAGE[0xe] uint256 public sellFeeAmount; // STORAGE[0xf] uint256 public unresolved_45a0b6ae; // STORAGE[0x10] bool stor_11; // STORAGE[0x11] uint256 public openPrice; // STORAGE[0x12] uint256 public lastDayPrice; // STORAGE[0x13] uint256 public unresolved_b1e49a0c; // STORAGE[0x14] mapping(bytes32 => uint256) public unresolved_2e6369d0; // STORAGE[0x15] bool stor_16; // STORAGE[0x16] bytes32 stor_expr_ab; bytes32 stor_expr_bf; bytes32 stor_expr_v; event RoleRevoked(bytes32 indexed, address indexed, address indexed); event Transfer(address indexed, address indexed, uint256); error ErrorFailureTransfer(); event Event_a4416906(uint256, uint256, uint256, uint256, uint256, uint256); error ErrorCaller(); event Approval(address indexed, address indexed, uint256); event Event_b9070ed8(uint256, uint256); event RoleGranted(bytes32 indexed, address indexed, address indexed); error ErrorValue(); error InvalidShortString(); error CustomError_000000000000000(); 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 { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x0563d853)) { // Route to Unknown_0563d853(bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0xa68a5fdf)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x41acb2bd)) { // Route to Unknown_41acb2bd() after replacing only msg.sig. __desolexSelectorShim(uint32(0xfdf225e9)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x475f4131)) { // Route to Unknown_475f4131() after replacing only msg.sig. __desolexSelectorShim(uint32(0xe0c20730)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x8ce5c9b2)) { // Route to Unknown_8ce5c9b2(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xad98e3dd)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x932fdf2f)) { // Route to Unknown_932fdf2f(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x2bddac2d)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xd505accf)) { // Route to Unknown_d505accf(address,address,uint256,uint256,bool,uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xcd2d430f)); return; } revert(); } function supportsInterface(bytes4 interfaceId) public pure returns (bool) { require(interfaceId == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)); bool flag0 = 0x7965db0b00000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000); if (0x7965db0b00000000000000000000000000000000000000000000000000000000 != (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)) { flag0 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x1ffc9a700000000000000000000000000000000000000000000000000000000; } return flag0; } function Unknown_0563d853(bool arg0) public { var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, ErrorCaller()); stor_11 = arg0 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_11); } function name() public view returns (string memory) { return _name; } function approve(address spender, uint256 amount) public returns (bool) { require(msg.sender != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, allowance[msg.sender][spender]); return true; } function setLastDay(uint256 arg0) public { var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, ErrorCaller()); lastDay = arg0 / 0x015180; } function transferFrom(address from, address to, uint256 amount) public { if (!(allowance[from][msg.sender] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) { require(!(allowance[from][msg.sender] < amount), "ERC20: insufficient allowance"); require(from != address(0), "ERC20: approve from the zero address"); require(msg.sender != address(0), "ERC20: approve to the zero address"); allowance[from][msg.sender] = allowance[from][address(msg.sender)] - amount; emit Approval(from, msg.sender, allowance[from][msg.sender]); } if ((hasRole[0x849ce89bfb011047badb624cc7bca584328cbe2b50dc206a08607a3818d8f272][from] == 0x0) && ((hasRole[0x849ce89bfb011047badb624cc7bca584328cbe2b50dc206a08607a3818d8f272][to] == 0x0) && (to == address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452)))) { internal_25e6(); } } function getRoleAdmin(bytes32 role) public view returns (uint256) { return stor_expr_v; } function setBuyLimit(bool arg0) public { var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, ErrorCaller()); stor_16 = arg0 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_16); } function grantRole(bytes32 role, address account) public { internal_d87(account, role); } function DOMAIN_SEPARATOR() public view returns (uint256) { if (!(address(0xf080c366f7ee7b8efadbc74f8e7b1e76c7a7494e) == address(this) && CHAINID() == 0x38)) { return keccak256(abi.encode(0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f, 0x4afed11c0b1de2ec13e8fa3c66cc3b0245905785c22b480a217c66bc2c75b47d, 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6, block.chainid, address(this))); } else { return 0x6962d9ef115cd42c5fccaa9b3756105eeadfe9e28cec5fca04bdf1d573b8daac; } } function renounceRole(bytes32 role, address account) public { require(msg.sender == account, "AccessControl: can only renounce roles for self"); if (bytes1(hasRole[role][account])) { hasRole[role][account] = false; emit RoleRevoked(role, account, msg.sender); } } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { require(msg.sender != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); allowance[msg.sender][spender] = addedValue + allowance[msg.sender][spender]; emit Approval(msg.sender, spender, allowance[msg.sender][spender]); return true; } function Unknown_41acb2bd() public view returns (bool) { return !(!(bytes1(stor_11))); } function rescueToken(address arg0, uint256 arg1, uint256 arg2) public { internal_e65(arg2, arg1, arg0); } function Unknown_475f4131() public returns (uint256) { (bool success0, bytes memory returnData0) = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).token0(); // staticcall require(success0); uint256 var_b; var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData0.length) - var_b >= 0x20); require(var_c == (var_c & 0xffffffffffffffffffffffffffffffffffffffff)); (bool success1, bytes memory returnData1) = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).getReserves(); // staticcall require(success1); (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData1, (uint112, uint112, uint32)); bool flag0 = 0 == (uint112(var_k)); if (!(0 == (uint112(var_k)))) { flag0 = !(uint112(var_l)); } uint256 value2; if (!flag0) { uint256 value1 = (uint112(var_l) * 0x0de0b6b3a7640000) / (uint112(var_k)); if (address(this) == (address(var_k))) { } else { value1 = (uint112(var_k) * 0x0de0b6b3a7640000) / (uint112(var_l)); } value2 = value1; } else { value2 = 0; } if (0x0 != value2) { (bool success2, bytes memory returnData2) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).slot0(); // staticcall require(success2); var_b = var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData2.length) - var_b >= 0xe0); require(var_n == (var_n & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_o == (int24(var_o))); require(var_p == (uint16(var_p))); require(var_q == (uint16(var_q))); require(var_r == (uint16(var_r))); require(var_s == (uint32(var_s))); require(var_t == (var_t != 0x0)); (bool success3, bytes memory returnData3) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).observations(uint16(var_y + (0x01) % var_z)); // staticcall require(success3); var_b = var_b + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData3.length) - var_b >= 0x80); require(var_ac == (uint32(var_ac))); require(var_ad == int56(var_ad)); require(var_ae == (var_ae & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_af == (var_af != 0x0)); uint256 value17 = var_b.length; if (!(var_z)) { (bool success4, bytes memory returnData4) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).observations(0); // staticcall require(success4); var_b = var_b + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData4.length) - var_b >= 0x80); require(var_ac == (uint32(var_ac))); require(var_ad == int56(var_ad)); require(var_ak == (var_ak & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_al == (var_al != 0x0)); value17 = var_b.length; } uint256 value18 = block.timestamp - value17; if (!(uint32(block.timestamp - value17) < 0x0384)) { value18 = 0x0384; } if (0x0 != (0xffffffff & value18)) { var_b = var_b + 0x60; if (!(0 < var_b.length)) _desolexPanic(50); if (!(0x01 < var_b.length)) _desolexPanic(50); uint256 value19 = 0; uint256 value20 = var_aq; uint256 value21 = (0x04 + var_b) + 0x40; uint256 value22 = 0x20 + var_b; uint256 value23 = 0x20; uint256 value24 = 0; uint256 value25 = 0x04 + var_b; uint256 value26 = var_b; uint256 value93; uint256 value94; while (true) { if (value19 >= value20) { break; } if ((0x01 + value19) >= value20) { break; } value19 = 0x01 + (0x01 + value19); value20 = value20; value21 = value23 + (value23 + value21); value22 = value23 + (value23 + value22); value23 = value23; value24 = value24; value25 = value25; value26 = value26; (bool success5, bytes memory returnData5) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).Unknown_883bdbfd(0x20); // staticcall require(success5); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData5.length + 0x1f)); require((var_b + returnData5.length) - var_b >= 0x40); require(!(var_az > 0xffffffffffffffff)); require(((var_b + var_az) + 0x1f) < (var_b + returnData5.length)); if (!(var_ba <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ba << 0x05)) + 0x1f))) < var_b) | ((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ba << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ba << 0x05)) + 0x1f)); require(!((0x20 + ((var_b + var_az) + (var_bc << 0x05))) > (var_b + returnData5.length))); uint256 value28 = var_b + 0x20; uint256 value27 = 0x20 + (var_b + var_az); while (true) { uint256 value29 = value28; uint256 value30 = value27; if (!(value27 < (0x20 + ((var_b + var_az) + (var_bc << 0x05))))) { break; } require(var_bd == int56(var_bd)); if (!((0x20 + value27) < (0x20 + ((var_b + var_az) + (var_bc << 0x05))))) { break; } require(var_bd == int56(var_bd)); value28 = 0x20 + (0x20 + value28); value27 = 0x20 + (0x20 + value27); value29 = 0x20 + value28; value30 = 0x20 + value27; } require(!(var_bi > 0xffffffffffffffff)); require((var_b + var_bi) + 0x1f < (var_b + returnData5.length)); if (!(__desolex_internal_4484_44db_arg0 <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (__desolex_internal_4453_44e0_arg0 + 0x1f))) < var_b) | ((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (__desolex_internal_4453_44e0_arg0 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (__desolex_internal_4453_44e0_arg0 + 0x1f)); require(!((0x20 + ((var_b + var_bi) + (var_bj << 0x05))) > (var_b + returnData5.length))); uint256 value31 = (var_b + var_bi) + 0x20; uint256 value33 = var_b; uint256 value34 = var_b + 0x20; uint256 value35 = 0x20; uint256 value32 = 0x20 + ((var_b + var_bi) + (var_bj << 0x05)); uint256 value36 = 0; uint256 value37 = var_b + var_bi; uint256 value38 = var_b + returnData5.length; uint256 value95; while (true) { if (value31 >= value32) { break; } require(__desolex_internal_3e31_4516_arg0 == (__desolex_internal_3e31_4516_arg0 & 0xffffffffffffffffffffffffffffffffffffffff)); if (__desolex_internal_4503_45e7_arg0 >= __desolex_internal_4503_45e7_arg4) { break; } require(__desolex_internal_3e31_4516_arg0 == (__desolex_internal_3e31_4516_arg0 & 0xffffffffffffffffffffffffffffffffffffffff)); value31 = __desolex_internal_4503_45e7_arg0; value33 = __desolex_internal_4503_45e7_arg1; value34 = __desolex_internal_4503_45e7_arg2; value35 = __desolex_internal_4503_45e7_arg3; value32 = __desolex_internal_4503_45e7_arg4; value36 = __desolex_internal_4503_45e7_arg5; value37 = __desolex_internal_4503_45e7_arg6; value38 = __desolex_internal_4503_45e7_arg7; if (!(0 < var_b.length)) _desolexPanic(50); if (!(0x01 < var_b.length)) _desolexPanic(50); if (int56(var_bn - var_bo) < 0) { } if (!(int56(var_bn - var_bo) < 0)) { uint256 value39 = 0 - int24(var_l); if (int24(var_l) < 0) { } else { value39 = int24(var_l); } require(value39 <= 0xd89e8, CustomError_00000000()); uint256 value40 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value39)) { value40 = 0x0100000000000000000000000000000000; } uint256 value41 = address(value40); if ((value39 & 0x2) != 0x0) { value41 = (address(value40) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value42 = value41; if ((value39 & 0x4) != 0x0) { value42 = (value41 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value43 = value42; if ((value39 & 0x8) != 0x0) { value43 = (value42 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } } else { uint256 value44 = 0 - int24(var_l); if (int24(var_l) < 0) { } else { value44 = int24(var_l); } require(value44 <= 0xd89e8, CustomError_00000000()); uint256 value45 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value44)) { value45 = 0x0100000000000000000000000000000000; } uint256 value46 = address(value45); if ((value44 & 0x2) != 0x0) { value46 = (address(value45) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value47 = value46; if ((value44 & 0x4) != 0x0) { value47 = (value46 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value48 = value47; if ((value44 & 0x8) != 0x0) { value48 = (value47 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } uint256 value49 = value48; if ((value44 & 0x10) != 0x0) { value49 = (value48 * 0xffcb9843d60f6159c9db58835c926644) >> 0x80; } uint256 value50 = value49; if ((value44 & 0x20) != 0x0) { value50 = (value49 * 0xff973b41fa98c081472e6896dfb254c0) >> 0x80; } uint256 value51 = value50; if ((value44 & 0x40) != 0x0) { value51 = (value50 * 0xff2ea16466c96a3843ec78b326b52861) >> 0x80; } uint256 value52 = value51; if ((value44 & 0x80) != 0x0) { value52 = (value51 * 0xfe5dee046a99a2a811c461f1969c3053) >> 0x80; } uint256 value53 = value52; if ((value44 & 0x100) != 0x0) { value53 = (value52 * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 0x80; } uint256 value54 = value53; if ((value44 & 0x200) != 0x0) { value54 = (value53 * 0xf987a7253ac413176f2b074cf7815e54) >> 0x80; } uint256 value55 = value54; if ((value44 & 0x400) != 0x0) { value55 = (value54 * 0xf3392b0822b70005940c7a398e4b70f3) >> 0x80; } uint256 value56 = value55; if ((value44 & 0x800) != 0x0) { value56 = (value55 * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 0x80; } uint256 value57 = value56; if ((value44 & 0x1000) != 0x0) { value57 = (value56 * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 0x80; } uint256 value58 = value57; if ((value44 & 0x2000) != 0x0) { value58 = (value57 * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 0x80; } uint256 value59 = value58; if ((value44 & 0x4000) != 0x0) { value59 = (value58 * 0x70d869a156d2a1b890bb3df62baf32f7) >> 0x80; } uint256 value60 = value59; if ((value44 & 0x8000) != 0x0) { value60 = (value59 * 0x31be135f97d08fd981231505542fcfa6) >> 0x80; } uint256 value61 = value60; if ((value44 & 0x10000) != 0x0) { value61 = (value60 * 0x09aa508b5b7a84e1c677de54f3e99bc9) >> 0x80; } uint256 value62 = value61; if ((value44 & 0x20000) != 0x0) { value62 = (value61 * 0x5d6af8dedb81196699c329225ee604) >> 0x80; } uint256 value63 = value62; if ((value44 & 0x40000) != 0x0) { value63 = (value62 * 0x2216e584f5fa1ea926041bedfe98) >> 0x80; } uint256 value64 = value63; if ((value44 & 0x80000) != 0x0) { value64 = (value63 * 0x048a170391f7dc42444e8fa2) >> 0x80; } uint256 value65 = value64 % 0x0100000000; uint256 value67 = value64; if (!(int24(var_l) > 0)) { } else { value65 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value64) % 0x0100000000; value67 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value64; } uint256 value66 = 0; if (value65 != 0x0) { value66 = 0x01; } uint256 value68; if (address(bytes1(value66) + (value67 >> 0x20)) > 0xffffffffffffffffffffffffffffffff) { uint256 sharedExpr0 = (bytes1(value66)) + (value67 >> 0x20); uint256 sharedExpr1 = address(sharedExpr0); uint256 sharedExpr2 = address(sharedExpr0); uint256 sharedExpr3 = address(sharedExpr0); uint256 sharedExpr4 = address(sharedExpr0); uint256 sharedExpr5 = address(sharedExpr0); uint256 sharedExpr6 = address(sharedExpr0); uint256 sharedExpr7 = (0x010000000000000000) & (0x01 + ~(0x010000000000000000)); uint256 sharedExpr8 = (0x010000000000000000 / sharedExpr7) * 0x03; uint256 sharedExpr9 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (0x02 ^ sharedExpr8)); uint256 sharedExpr10 = 0x02 ^ sharedExpr8; uint256 sharedExpr11 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr9 * sharedExpr10)); uint256 sharedExpr12 = sharedExpr9 * sharedExpr10; uint256 sharedExpr13 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr11 * sharedExpr12)); uint256 sharedExpr14 = sharedExpr11 * sharedExpr12; uint256 sharedExpr15 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr13 * sharedExpr14)); uint256 sharedExpr16 = sharedExpr13 * sharedExpr14; uint256 sharedExpr17 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr15 * sharedExpr16)); uint256 sharedExpr18 = sharedExpr15 * sharedExpr16; value68 = ((sharedExpr1 * sharedExpr2) - ((sharedExpr3 * sharedExpr4) % 0x010000000000000000) / (0x010000000000000000 & (0x01 + ~(0x010000000000000000))) | (((sharedExpr5 * sharedExpr6) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (sharedExpr1 * sharedExpr2) - (((sharedExpr5 * sharedExpr6) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (sharedExpr1 * sharedExpr2)) - (((sharedExpr3 * sharedExpr4) % 0x010000000000000000) > (sharedExpr1 * sharedExpr2)) * (0x01 + ((0 - (0x010000000000000000 & (0x01 + ~(0x010000000000000000)))) / (0x010000000000000000 & (0x01 + ~(0x010000000000000000))))))) * ((sharedExpr17 * sharedExpr18) * (0x02 - ((sharedExpr17 * sharedExpr18) * (0x010000000000000000 / sharedExpr7)))); if (0 != ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))) - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))))))) { require(0x010000000000000000 > ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))) - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))))), CustomError_00000000()); } else { value68 = (address(bytes1(value66) + (value67 >> 0x20)) * (address(bytes1(value66) + (value67 >> 0x20)))) / 0x010000000000000000; } uint256 sharedExpr38 = 0x01 + ~(value68); uint256 sharedExpr39 = value68 & sharedExpr38; uint256 sharedExpr40 = (value68 / sharedExpr39) * 0x03; uint256 sharedExpr41 = 0x02 - ((value68 / sharedExpr39) * (0x02 ^ sharedExpr40)); uint256 sharedExpr42 = 0x02 ^ sharedExpr40; uint256 sharedExpr43 = 0x02 - ((value68 / sharedExpr39) * (sharedExpr41 * sharedExpr42)); uint256 sharedExpr44 = sharedExpr41 * sharedExpr42; uint256 sharedExpr45 = 0x02 - ((value68 / sharedExpr39) * (sharedExpr43 * sharedExpr44)); uint256 sharedExpr46 = sharedExpr43 * sharedExpr44; uint256 sharedExpr47 = 0x02 - ((value68 / sharedExpr39) * (sharedExpr45 * sharedExpr46)); uint256 sharedExpr48 = sharedExpr45 * sharedExpr46; uint256 sharedExpr49 = 0x02 - ((value68 / sharedExpr39) * (sharedExpr47 * sharedExpr48)); uint256 sharedExpr50 = sharedExpr47 * sharedExpr48; uint256 value69 = ((0x0100000000000000000000000000000000 * value2) - ((0x0100000000000000000000000000000000 * value2) % value68) / (value68 & sharedExpr38) | (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)) - (((0x0100000000000000000000000000000000 * value2) % value68) > (0x0100000000000000000000000000000000 * value2)) * (0x01 + ((0 - (value68 & sharedExpr38)) / (value68 & sharedExpr38))))) * ((sharedExpr49 * sharedExpr50) * (0x02 - ((sharedExpr49 * sharedExpr50) * (value68 / sharedExpr39)))); if (0 != (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)))) { require(value95 > (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2))), CustomError_00000000()); } else { value69 = (0x0100000000000000000000000000000000 * value2) / value68; } } else { uint256 value70; uint256 sharedExpr100 = (bytes1(value66)) + (value67 >> 0x20); uint256 sharedExpr101 = address(sharedExpr100); uint256 sharedExpr102 = address(sharedExpr100); uint256 sharedExpr103 = sharedExpr101 * sharedExpr102; uint256 sharedExpr104 = sharedExpr101 * sharedExpr102; uint256 sharedExpr105 = 0x01 + (~(sharedExpr101 * sharedExpr102)); uint256 sharedExpr106 = sharedExpr101 * sharedExpr102; uint256 sharedExpr107 = sharedExpr104 & sharedExpr105; uint256 sharedExpr108 = (sharedExpr106 / sharedExpr107) * 0x03; uint256 sharedExpr109 = 0x02 - ((sharedExpr106 / sharedExpr107) * (0x02 ^ sharedExpr108)); uint256 sharedExpr110 = 0x02 ^ sharedExpr108; uint256 sharedExpr111 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr109 * sharedExpr110)); uint256 sharedExpr112 = sharedExpr109 * sharedExpr110; uint256 sharedExpr113 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr111 * sharedExpr112)); uint256 sharedExpr114 = sharedExpr111 * sharedExpr112; uint256 sharedExpr115 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr113 * sharedExpr114)); uint256 sharedExpr116 = sharedExpr113 * sharedExpr114; uint256 sharedExpr117 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr115 * sharedExpr116)); uint256 sharedExpr118 = sharedExpr115 * sharedExpr116; uint256 value102 = ((0x01000000000000000000000000000000000000000000000000 * value2) - ((0x01000000000000000000000000000000000000000000000000 * value2) % sharedExpr103) / (sharedExpr104 & sharedExpr105) | (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)) - (((0x01000000000000000000000000000000000000000000000000 * value2) % sharedExpr103) > (0x01000000000000000000000000000000000000000000000000 * value2)) * (0x01 + ((0 - (sharedExpr104 & sharedExpr105)) / (sharedExpr104 & sharedExpr105))))) * ((sharedExpr117 * sharedExpr118) * (0x02 - ((sharedExpr117 * sharedExpr118) * (sharedExpr106 / sharedExpr107)))); if (0 != (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)))) { require(address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) > (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2))), CustomError_00000000()); } else { value102 = (0x01000000000000000000000000000000000000000000000000 * value2) / (address(bytes1(value66) + (value67 >> 0x20)) * (address(bytes1(value66) + (value67 >> 0x20)))); } value70 = value102; } if ((((value68 * value2) - ((value68 * value2) % 0x0100000000000000000000000000000000) / 0x0100000000000000000000000000000000) | (((value68 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value68 * value2) - (((value68 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value68 * value2)) - (((value68 * value2) % 0x0100000000000000000000000000000000) > (value68 * value2)) * 0x0100000000000000000000000000000000) * 0x01) > openPrice) { if (((((((value68 * value2) - ((value68 * value2) % 0x0100000000000000000000000000000000) / 0x0100000000000000000000000000000000) | (((value68 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value68 * value2) - (((value68 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value68 * value2)) - (((value68 * value2) % 0x0100000000000000000000000000000000) > (value68 * value2)) * 0x0100000000000000000000000000000000) * 0x01) - openPrice) * 0x64) / openPrice) > 0) { if (((((((((value68 * value2) - ((value68 * value2) % 0x0100000000000000000000000000000000) / 0x0100000000000000000000000000000000) | (((value68 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value68 * value2) - (((value68 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value68 * value2)) - (((value68 * value2) % 0x0100000000000000000000000000000000) > (value68 * value2)) * 0x0100000000000000000000000000000000) * 0x01) - openPrice) * 0x64) / openPrice) / 0x02) + 0x01) <= 0x06) { return ; } } else { return ; } return ; } return ; } } } } else { (bool success6, bytes memory returnData6) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).slot0(); // staticcall require(success6); var_b = var_b + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData6.length) - var_b >= 0xe0); require(var_bq == (var_bq & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_br == (int24(var_br))); require(var_p == (uint16(var_p))); require(var_q == (uint16(var_q))); require(var_r == (uint16(var_r))); require(var_s == (uint32(var_s))); require(var_bs == (var_bs != 0x0)); uint256 value71 = 0 - int24(var_l); if (int24(var_l) < 0) { } else { value71 = int24(var_l); } require(value71 <= 0xd89e8, "T"); uint256 value72 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value71)) { value72 = 0x0100000000000000000000000000000000; } uint256 value73 = address(value72); if ((value71 & 0x2) != 0x0) { value73 = (address(value72) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value74 = value73; if ((value71 & 0x4) != 0x0) { value74 = (value73 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value75 = value74; if ((value71 & 0x8) != 0x0) { value75 = (value74 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } uint256 value76 = value75; if ((value71 & 0x10) != 0x0) { value76 = (value75 * 0xffcb9843d60f6159c9db58835c926644) >> 0x80; } uint256 value77 = value76; if ((value71 & 0x20) != 0x0) { value77 = (value76 * 0xff973b41fa98c081472e6896dfb254c0) >> 0x80; } uint256 value78 = value77; if ((value71 & 0x40) != 0x0) { value78 = (value77 * 0xff2ea16466c96a3843ec78b326b52861) >> 0x80; } uint256 value79 = value78; if ((value71 & 0x80) != 0x0) { value79 = (value78 * 0xfe5dee046a99a2a811c461f1969c3053) >> 0x80; } uint256 value80 = value79; if ((value71 & 0x100) != 0x0) { value80 = (value79 * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 0x80; } uint256 value81 = value80; if ((value71 & 0x200) != 0x0) { value81 = (value80 * 0xf987a7253ac413176f2b074cf7815e54) >> 0x80; } uint256 value82 = value81; if ((value71 & 0x400) != 0x0) { value82 = (value81 * 0xf3392b0822b70005940c7a398e4b70f3) >> 0x80; } uint256 value83 = value82; if ((value71 & 0x800) != 0x0) { value83 = (value82 * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 0x80; } uint256 value84 = value83; if ((value71 & 0x1000) != 0x0) { value84 = (value83 * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 0x80; } uint256 value85 = value84; if ((value71 & 0x2000) != 0x0) { value85 = (value84 * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 0x80; } uint256 value86 = value85; if ((value71 & 0x4000) != 0x0) { value86 = (value85 * 0x70d869a156d2a1b890bb3df62baf32f7) >> 0x80; } uint256 value87 = value86; if ((value71 & 0x8000) != 0x0) { value87 = (value86 * 0x31be135f97d08fd981231505542fcfa6) >> 0x80; } uint256 value88 = value87; if ((value71 & 0x10000) != 0x0) { value88 = (value87 * 0x09aa508b5b7a84e1c677de54f3e99bc9) >> 0x80; } uint256 value89 = value88; if ((value71 & 0x20000) != 0x0) { value89 = (value88 * 0x5d6af8dedb81196699c329225ee604) >> 0x80; } uint256 value90 = value89; if ((value71 & 0x40000) != 0x0) { value90 = (value89 * 0x2216e584f5fa1ea926041bedfe98) >> 0x80; } uint256 value91 = value90; if ((value71 & 0x80000) != 0x0) { value91 = (value90 * 0x048a170391f7dc42444e8fa2) >> 0x80; } uint256 value92 = value91 % 0x0100000000; value94 = value91; if (!(int24(var_l) > 0)) { } else { value92 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value91) % 0x0100000000; value94 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value91; } value93 = 0; if (value92 != 0x0) { value93 = 0x01; } uint256 value98; if (address(bytes1(value93) + (value94 >> 0x20)) > 0xffffffffffffffffffffffffffffffff) { uint256 sharedExpr138 = var_b; uint256 sharedExpr139 = var_b + returnData6.length; uint256 sharedExpr140 = var_br; uint256 sharedExpr141 = sharedExpr140; uint256 sharedExpr142 = (bytes1(value93)) + (value94 >> 0x20); uint256 sharedExpr143 = sharedExpr142; uint256 sharedExpr144 = address(sharedExpr143); uint256 sharedExpr145 = address(sharedExpr143); uint256 sharedExpr146 = 0x01 + ~(0x010000000000000000); uint256 sharedExpr147 = (0x010000000000000000) & sharedExpr146; uint256 sharedExpr148 = (0x010000000000000000 / sharedExpr147) * 0x03; uint256 sharedExpr149 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (0x02 ^ sharedExpr148)); uint256 sharedExpr150 = 0x02 ^ sharedExpr148; uint256 sharedExpr151 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr149 * sharedExpr150)); uint256 sharedExpr152 = sharedExpr149 * sharedExpr150; uint256 sharedExpr153 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr151 * sharedExpr152)); uint256 sharedExpr154 = sharedExpr151 * sharedExpr152; uint256 sharedExpr155 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr153 * sharedExpr154)); uint256 sharedExpr156 = sharedExpr153 * sharedExpr154; uint256 sharedExpr157 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr155 * sharedExpr156)); uint256 sharedExpr158 = sharedExpr155 * sharedExpr156; uint256 sharedExpr159 = (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) - (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0x010000000000000000) / (0x010000000000000000 & sharedExpr146) | ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))) - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))))) - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0x010000000000000000) > (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))))) * (0x01 + ((0 - (0x010000000000000000 & sharedExpr146)) / (0x010000000000000000 & sharedExpr146))))) * ((sharedExpr157 * sharedExpr158) * (0x02 - ((sharedExpr157 * sharedExpr158) * (0x010000000000000000 / sharedExpr147)))); value95 = sharedExpr159; if (0 != ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))) - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))))))) { require(0x010000000000000000 > ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))) - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))))), "Math: mulDiv overflow"); uint256 sharedExpr160 = 0x01 + ~(0x010000000000000000); uint256 sharedExpr161 = (0x010000000000000000) & sharedExpr160; uint256 sharedExpr162 = (0x010000000000000000 / sharedExpr161) * 0x03; uint256 sharedExpr163 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (0x02 ^ sharedExpr162)); uint256 sharedExpr164 = 0x02 ^ sharedExpr162; uint256 sharedExpr165 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr163 * sharedExpr164)); uint256 sharedExpr166 = sharedExpr163 * sharedExpr164; uint256 sharedExpr167 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr165 * sharedExpr166)); uint256 sharedExpr168 = sharedExpr165 * sharedExpr166; uint256 sharedExpr169 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr167 * sharedExpr168)); uint256 sharedExpr170 = sharedExpr167 * sharedExpr168; uint256 sharedExpr171 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr169 * sharedExpr170)); uint256 sharedExpr172 = sharedExpr169 * sharedExpr170; } else { value95 = address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / 0x010000000000000000; } uint256 value103; uint256 sharedExpr195 = 0x01 + ~(value95); uint256 sharedExpr196 = value95 & sharedExpr195; uint256 sharedExpr197 = (value95 / sharedExpr196) * 0x03; uint256 sharedExpr198 = 0x02 - ((value95 / sharedExpr196) * (0x02 ^ sharedExpr197)); uint256 sharedExpr199 = 0x02 ^ sharedExpr197; uint256 sharedExpr200 = 0x02 - ((value95 / sharedExpr196) * (sharedExpr198 * sharedExpr199)); uint256 sharedExpr201 = sharedExpr198 * sharedExpr199; uint256 sharedExpr202 = 0x02 - ((value95 / sharedExpr196) * (sharedExpr200 * sharedExpr201)); uint256 sharedExpr203 = sharedExpr200 * sharedExpr201; uint256 sharedExpr204 = 0x02 - ((value95 / sharedExpr196) * (sharedExpr202 * sharedExpr203)); uint256 sharedExpr205 = sharedExpr202 * sharedExpr203; uint256 sharedExpr206 = 0x02 - ((value95 / sharedExpr196) * (sharedExpr204 * sharedExpr205)); uint256 sharedExpr207 = sharedExpr204 * sharedExpr205; uint256 sharedExpr208 = ((0x0100000000000000000000000000000000 * value2) - ((0x0100000000000000000000000000000000 * value2) % value95) / (value95 & sharedExpr195) | (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)) - (((0x0100000000000000000000000000000000 * value2) % value95) > (0x0100000000000000000000000000000000 * value2)) * (0x01 + ((0 - (value95 & sharedExpr195)) / (value95 & sharedExpr195))))) * ((sharedExpr206 * sharedExpr207) * (0x02 - ((sharedExpr206 * sharedExpr207) * (value95 / sharedExpr196)))); uint256 value96 = sharedExpr208; if (0 != (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)))) { require(value95 > (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2))), "Math: mulDiv overflow"); uint256 sharedExpr209 = 0x01 + ~(value95); uint256 sharedExpr210 = value95 & sharedExpr209; uint256 sharedExpr211 = (value95 / sharedExpr210) * 0x03; uint256 sharedExpr212 = 0x02 - ((value95 / sharedExpr210) * (0x02 ^ sharedExpr211)); uint256 sharedExpr213 = 0x02 ^ sharedExpr211; uint256 sharedExpr214 = 0x02 - ((value95 / sharedExpr210) * (sharedExpr212 * sharedExpr213)); uint256 sharedExpr215 = sharedExpr212 * sharedExpr213; uint256 sharedExpr216 = 0x02 - ((value95 / sharedExpr210) * (sharedExpr214 * sharedExpr215)); uint256 sharedExpr217 = sharedExpr214 * sharedExpr215; uint256 sharedExpr218 = 0x02 - ((value95 / sharedExpr210) * (sharedExpr216 * sharedExpr217)); uint256 sharedExpr219 = sharedExpr216 * sharedExpr217; uint256 sharedExpr220 = 0x02 - ((value95 / sharedExpr210) * (sharedExpr218 * sharedExpr219)); uint256 sharedExpr221 = sharedExpr218 * sharedExpr219; } else { value96 = (0x0100000000000000000000000000000000 * value2) / value95; } value103 = value96; value98 = value103; } else { uint256 value97; uint256 sharedExpr297 = var_b; uint256 sharedExpr298 = var_b + returnData6.length; uint256 sharedExpr299 = var_br; uint256 sharedExpr300 = sharedExpr299; uint256 sharedExpr301 = (bytes1(value93)) + (value94 >> 0x20); uint256 sharedExpr302 = sharedExpr301; uint256 sharedExpr303 = address(sharedExpr302); uint256 sharedExpr304 = address(sharedExpr302); uint256 sharedExpr305 = (address(bytes1(value93) + (value94 >> 0x20))) * (address(bytes1(value93) + (value94 >> 0x20))); uint256 sharedExpr306 = sharedExpr305; uint256 sharedExpr307 = 0x01 + ~(address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))); uint256 sharedExpr308 = (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))) & sharedExpr307; uint256 sharedExpr309 = (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr308) * 0x03; uint256 sharedExpr310 = 0x02 - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr308) * (0x02 ^ sharedExpr309)); uint256 sharedExpr311 = 0x02 ^ sharedExpr309; uint256 sharedExpr312 = 0x02 - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr308) * (sharedExpr310 * sharedExpr311)); uint256 sharedExpr313 = sharedExpr310 * sharedExpr311; uint256 sharedExpr314 = 0x02 - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr308) * (sharedExpr312 * sharedExpr313)); uint256 sharedExpr315 = sharedExpr312 * sharedExpr313; uint256 sharedExpr316 = 0x02 - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr308) * (sharedExpr314 * sharedExpr315)); uint256 sharedExpr317 = sharedExpr314 * sharedExpr315; uint256 sharedExpr318 = 0x02 - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr308) * (sharedExpr316 * sharedExpr317)); uint256 sharedExpr319 = sharedExpr316 * sharedExpr317; uint256 sharedExpr320 = ((0x01000000000000000000000000000000000000000000000000 * value2) - ((0x01000000000000000000000000000000000000000000000000 * value2) % (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))))) / (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) & sharedExpr307) | (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)) - ((0x01000000000000000000000000000000000000000000000000 * value2) % (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))) > (0x01000000000000000000000000000000000000000000000000 * value2)) * (0x01 + ((0 - (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) & sharedExpr307)) / (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) & sharedExpr307))))) * ((sharedExpr318 * sharedExpr319) * (0x02 - ((sharedExpr318 * sharedExpr319) * (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr308)))); uint256 value106 = sharedExpr320; if (0 != (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)))) { require(address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) > (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2))), "Math: mulDiv overflow"); uint256 sharedExpr321 = 0x01 + ~(address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))); uint256 sharedExpr322 = (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))) & sharedExpr321; uint256 sharedExpr323 = (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr322) * 0x03; uint256 sharedExpr324 = 0x02 - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr322) * (0x02 ^ sharedExpr323)); uint256 sharedExpr325 = 0x02 ^ sharedExpr323; uint256 sharedExpr326 = 0x02 - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr322) * (sharedExpr324 * sharedExpr325)); uint256 sharedExpr327 = sharedExpr324 * sharedExpr325; uint256 sharedExpr328 = 0x02 - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr322) * (sharedExpr326 * sharedExpr327)); uint256 sharedExpr329 = sharedExpr326 * sharedExpr327; uint256 sharedExpr330 = 0x02 - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr322) * (sharedExpr328 * sharedExpr329)); uint256 sharedExpr331 = sharedExpr328 * sharedExpr329; uint256 sharedExpr332 = 0x02 - ((address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20))) / sharedExpr322) * (sharedExpr330 * sharedExpr331)); uint256 sharedExpr333 = sharedExpr330 * sharedExpr331; } else { value106 = (0x01000000000000000000000000000000000000000000000000 * value2) / (address(bytes1(value93) + (value94 >> 0x20)) * (address(bytes1(value93) + (value94 >> 0x20)))); } value97 = value106; value98 = value97; } if (value98 > openPrice) { uint256 value99 = ((((value98 - openPrice) * 0x64) / openPrice) / 0x02) + 0x01; if ((((value98 - openPrice) * 0x64) / openPrice) > 0) { } else { value99 = 0; } if (value99 <= 0x06) { uint256 value99; } return 0x06; } return 0; } } else { if (0 > openPrice) { uint256 value100 = ((((0 - openPrice) * 0x64) / openPrice) / 0x02) + 0x01; if ((((0 - openPrice) * 0x64) / openPrice) > 0) { } else { value100 = 0; } if (value100 <= 0x06) { uint256 value100; } return 0x06; } return 0; } } function getDayPrice() public returns (uint256) { if ((block.timestamp / 0x015180) > lastDayPrice) { (bool success0, bytes memory returnData0) = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).token0(); // staticcall require(success0); uint256 var_b; var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData0.length) - var_b >= 0x20); require(var_c == (var_c & 0xffffffffffffffffffffffffffffffffffffffff)); (bool success1, bytes memory returnData1) = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).getReserves(); // staticcall require(success1); (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData1, (uint112, uint112, uint32)); bool flag0 = 0 == (uint112(var_k)); if (!(0 == (uint112(var_k)))) { flag0 = !(uint112(var_l)); } uint256 value2; if (!flag0) { uint256 value1 = (uint112(var_l) * 0x0de0b6b3a7640000) / (uint112(var_k)); if (address(this) == (address(var_k))) { } else { value1 = (uint112(var_k) * 0x0de0b6b3a7640000) / (uint112(var_l)); } value2 = value1; } else { value2 = 0; } if (0x0 != value2) { (bool success2, bytes memory returnData2) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).slot0(); // staticcall require(success2); var_b = var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData2.length) - var_b >= 0xe0); require(var_n == (var_n & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_o == (int24(var_o))); require(var_p == (uint16(var_p))); require(var_q == (uint16(var_q))); require(var_r == (uint16(var_r))); require(var_s == (uint32(var_s))); require(var_t == (var_t != 0x0)); (bool success3, bytes memory returnData3) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).observations(uint16(var_y + (0x01) % var_z)); // staticcall require(success3); var_b = var_b + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData3.length) - var_b >= 0x80); require(var_ac == (uint32(var_ac))); require(var_ad == int56(var_ad)); require(var_ae == (var_ae & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_af == (var_af != 0x0)); uint256 value17 = var_b.length; if (!(var_z)) { (bool success4, bytes memory returnData4) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).observations(0); // staticcall require(success4); var_b = var_b + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData4.length) - var_b >= 0x80); require(var_ac == (uint32(var_ac))); require(var_ad == int56(var_ad)); require(var_ak == (var_ak & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_al == (var_al != 0x0)); value17 = var_b.length; } uint256 value18 = block.timestamp - value17; if (!(uint32(block.timestamp - value17) < 0x0384)) { value18 = 0x0384; } if (0x0 != (0xffffffff & value18)) { var_b = var_b + 0x60; if (!(0 < var_b.length)) _desolexPanic(50); if (!(0x01 < var_b.length)) _desolexPanic(50); uint256 value87; uint256 value88; if (0 < var_au) { if (!(0x01 >= var_au)) { } (bool success5, bytes memory returnData5) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).Unknown_883bdbfd(0x20); // staticcall require(success5); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData5.length + 0x1f)); require((var_b + returnData5.length) - var_b >= 0x40); require(!(var_az > 0xffffffffffffffff)); require(((var_b + var_az) + 0x1f) < (var_b + returnData5.length)); if (!(var_ba <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ba << 0x05)) + 0x1f))) < var_b) | ((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ba << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ba << 0x05)) + 0x1f)); require(!((0x20 + ((var_b + var_az) + (var_bc << 0x05))) > (var_b + returnData5.length))); uint256 value19 = var_b + 0x20; uint256 value20 = 0x20 + (var_b + var_az); if ((0x20 + (var_b + var_az)) < (0x20 + ((var_b + var_az) + (var_bc << 0x05)))) { require(var_bd == int56(var_bd)); if ((0x20 + (0x20 + (var_b + var_az))) < (0x20 + ((var_b + var_az) + (var_bc << 0x05)))) { require(var_bd == int56(var_bd)); } value19 = 0x20 + (var_b + 0x20); value20 = 0x20 + (0x20 + (var_b + var_az)); } require(!(var_bi > 0xffffffffffffffff)); require((var_b + var_bi) + 0x1f < (var_b + returnData5.length)); if (!(__desolex_internal_4484_44db_arg0 <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (__desolex_internal_4453_44e0_arg0 + 0x1f))) < var_b) | ((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (__desolex_internal_4453_44e0_arg0 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (__desolex_internal_4453_44e0_arg0 + 0x1f)); require(!((0x20 + ((var_b + var_bi) + (var_bj << 0x05))) > (var_b + returnData5.length))); uint256 value89; if (((var_b + var_bi) + 0x20) < (0x20 + ((var_b + var_bi) + (var_bj << 0x05)))) { require(__desolex_internal_3e31_4516_arg0 == (__desolex_internal_3e31_4516_arg0 & 0xffffffffffffffffffffffffffffffffffffffff)); if (__desolex_internal_4503_45e7_arg0 < __desolex_internal_4503_45e7_arg4) { require(__desolex_internal_3e31_4516_arg0 == (__desolex_internal_3e31_4516_arg0 & 0xffffffffffffffffffffffffffffffffffffffff)); } if (!(0 < var_b.length)) _desolexPanic(50); if (!(0x01 < var_b.length)) _desolexPanic(50); if (int56(var_bn - var_bo) < 0) { } if (!(int56(var_bn - var_bo) < 0)) { uint256 value21 = 0 - int24(var_l); if (int24(var_l) < 0) { } else { value21 = int24(var_l); } require(value21 <= 0xd89e8, CustomError_00000000()); uint256 value22 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value21)) { value22 = 0x0100000000000000000000000000000000; } uint256 value23 = address(value22); if ((value21 & 0x2) != 0x0) { value23 = (address(value22) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value24 = value23; if ((value21 & 0x4) != 0x0) { value24 = (value23 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value25 = value24; if ((value21 & 0x8) != 0x0) { value25 = (value24 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } uint256 value26 = value25; if ((value21 & 0x10) != 0x0) { value26 = (value25 * 0xffcb9843d60f6159c9db58835c926644) >> 0x80; } uint256 value27 = value26; if ((value21 & 0x20) != 0x0) { value27 = (value26 * 0xff973b41fa98c081472e6896dfb254c0) >> 0x80; } uint256 value28 = value27; if ((value21 & 0x40) != 0x0) { value28 = (value27 * 0xff2ea16466c96a3843ec78b326b52861) >> 0x80; } uint256 value29 = value28; if ((value21 & 0x80) != 0x0) { value29 = (value28 * 0xfe5dee046a99a2a811c461f1969c3053) >> 0x80; } uint256 value30 = value29; if ((value21 & 0x100) != 0x0) { value30 = (value29 * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 0x80; } uint256 value31 = value30; if ((value21 & 0x200) != 0x0) { value31 = (value30 * 0xf987a7253ac413176f2b074cf7815e54) >> 0x80; } uint256 value32 = value31; if ((value21 & 0x400) != 0x0) { value32 = (value31 * 0xf3392b0822b70005940c7a398e4b70f3) >> 0x80; } uint256 value33 = value32; if ((value21 & 0x800) != 0x0) { value33 = (value32 * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 0x80; } uint256 value34 = value33; if ((value21 & 0x1000) != 0x0) { value34 = (value33 * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 0x80; } uint256 value35 = value34; if ((value21 & 0x2000) != 0x0) { value35 = (value34 * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 0x80; } uint256 value36 = value35; if ((value21 & 0x4000) != 0x0) { value36 = (value35 * 0x70d869a156d2a1b890bb3df62baf32f7) >> 0x80; } uint256 value37 = value36; if ((value21 & 0x8000) != 0x0) { value37 = (value36 * 0x31be135f97d08fd981231505542fcfa6) >> 0x80; } } else { uint256 value38 = 0 - int24(var_l); if (int24(var_l) < 0) { } else { value38 = int24(var_l); } require(value38 <= 0xd89e8, CustomError_00000000()); uint256 value39 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value38)) { value39 = 0x0100000000000000000000000000000000; } uint256 value40 = address(value39); if ((value38 & 0x2) != 0x0) { value40 = (address(value39) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value41 = value40; if ((value38 & 0x4) != 0x0) { value41 = (value40 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value42 = value41; if ((value38 & 0x8) != 0x0) { value42 = (value41 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } uint256 value43 = value42; if ((value38 & 0x10) != 0x0) { value43 = (value42 * 0xffcb9843d60f6159c9db58835c926644) >> 0x80; } uint256 value44 = value43; if ((value38 & 0x20) != 0x0) { value44 = (value43 * 0xff973b41fa98c081472e6896dfb254c0) >> 0x80; } uint256 value45 = value44; if ((value38 & 0x40) != 0x0) { value45 = (value44 * 0xff2ea16466c96a3843ec78b326b52861) >> 0x80; } uint256 value46 = value45; if ((value38 & 0x80) != 0x0) { value46 = (value45 * 0xfe5dee046a99a2a811c461f1969c3053) >> 0x80; } uint256 value47 = value46; if ((value38 & 0x100) != 0x0) { value47 = (value46 * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 0x80; } uint256 value48 = value47; if ((value38 & 0x200) != 0x0) { value48 = (value47 * 0xf987a7253ac413176f2b074cf7815e54) >> 0x80; } uint256 value49 = value48; if ((value38 & 0x400) != 0x0) { value49 = (value48 * 0xf3392b0822b70005940c7a398e4b70f3) >> 0x80; } uint256 value50 = value49; if ((value38 & 0x800) != 0x0) { value50 = (value49 * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 0x80; } uint256 value51 = value50; if ((value38 & 0x1000) != 0x0) { value51 = (value50 * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 0x80; } uint256 value52 = value51; if ((value38 & 0x2000) != 0x0) { value52 = (value51 * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 0x80; } uint256 value53 = value52; if ((value38 & 0x4000) != 0x0) { value53 = (value52 * 0x70d869a156d2a1b890bb3df62baf32f7) >> 0x80; } uint256 value54 = value53; if ((value38 & 0x8000) != 0x0) { value54 = (value53 * 0x31be135f97d08fd981231505542fcfa6) >> 0x80; } uint256 value55 = value54; if ((value38 & 0x10000) != 0x0) { value55 = (value54 * 0x09aa508b5b7a84e1c677de54f3e99bc9) >> 0x80; } uint256 value56 = value55; if ((value38 & 0x20000) != 0x0) { value56 = (value55 * 0x5d6af8dedb81196699c329225ee604) >> 0x80; } uint256 value57 = value56; if ((value38 & 0x40000) != 0x0) { value57 = (value56 * 0x2216e584f5fa1ea926041bedfe98) >> 0x80; } uint256 value58 = value57; if ((value38 & 0x80000) != 0x0) { value58 = (value57 * 0x048a170391f7dc42444e8fa2) >> 0x80; } uint256 value59 = value58 % 0x0100000000; uint256 value61 = value58; if (!(int24(var_l) > 0)) { } else { value59 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value58) % 0x0100000000; value61 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value58; } uint256 value60 = 0; if (value59 != 0x0) { value60 = 0x01; } if (address(bytes1(value60) + (value61 >> 0x20)) > 0xffffffffffffffffffffffffffffffff) { uint256 sharedExpr0 = (bytes1(value60)) + (value61 >> 0x20); uint256 sharedExpr1 = address(sharedExpr0); uint256 sharedExpr2 = address(sharedExpr0); uint256 sharedExpr3 = address(sharedExpr0); uint256 sharedExpr4 = address(sharedExpr0); uint256 sharedExpr5 = address(sharedExpr0); uint256 sharedExpr6 = address(sharedExpr0); uint256 sharedExpr7 = (0x010000000000000000) & (0x01 + ~(0x010000000000000000)); uint256 sharedExpr8 = (0x010000000000000000 / sharedExpr7) * 0x03; uint256 sharedExpr9 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (0x02 ^ sharedExpr8)); uint256 sharedExpr10 = 0x02 ^ sharedExpr8; uint256 sharedExpr11 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr9 * sharedExpr10)); uint256 sharedExpr12 = sharedExpr9 * sharedExpr10; uint256 sharedExpr13 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr11 * sharedExpr12)); uint256 sharedExpr14 = sharedExpr11 * sharedExpr12; uint256 sharedExpr15 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr13 * sharedExpr14)); uint256 sharedExpr16 = sharedExpr13 * sharedExpr14; uint256 sharedExpr17 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr15 * sharedExpr16)); uint256 sharedExpr18 = sharedExpr15 * sharedExpr16; uint256 value62 = ((sharedExpr1 * sharedExpr2) - ((sharedExpr3 * sharedExpr4) % 0x010000000000000000) / (0x010000000000000000 & (0x01 + ~(0x010000000000000000))) | (((sharedExpr5 * sharedExpr6) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (sharedExpr1 * sharedExpr2) - (((sharedExpr5 * sharedExpr6) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (sharedExpr1 * sharedExpr2)) - (((sharedExpr3 * sharedExpr4) % 0x010000000000000000) > (sharedExpr1 * sharedExpr2)) * (0x01 + ((0 - (0x010000000000000000 & (0x01 + ~(0x010000000000000000)))) / (0x010000000000000000 & (0x01 + ~(0x010000000000000000))))))) * ((sharedExpr17 * sharedExpr18) * (0x02 - ((sharedExpr17 * sharedExpr18) * (0x010000000000000000 / sharedExpr7)))); if (0 != ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))) - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))))))) { require(0x010000000000000000 > ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))) - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))))), CustomError_00000000()); } else { value62 = (address(bytes1(value60) + (value61 >> 0x20)) * (address(bytes1(value60) + (value61 >> 0x20)))) / 0x010000000000000000; } uint256 sharedExpr38 = 0x01 + ~(value62); uint256 sharedExpr39 = value62 & sharedExpr38; uint256 sharedExpr40 = (value62 / sharedExpr39) * 0x03; uint256 sharedExpr41 = 0x02 - ((value62 / sharedExpr39) * (0x02 ^ sharedExpr40)); uint256 sharedExpr42 = 0x02 ^ sharedExpr40; uint256 sharedExpr43 = 0x02 - ((value62 / sharedExpr39) * (sharedExpr41 * sharedExpr42)); uint256 sharedExpr44 = sharedExpr41 * sharedExpr42; uint256 sharedExpr45 = 0x02 - ((value62 / sharedExpr39) * (sharedExpr43 * sharedExpr44)); uint256 sharedExpr46 = sharedExpr43 * sharedExpr44; uint256 sharedExpr47 = 0x02 - ((value62 / sharedExpr39) * (sharedExpr45 * sharedExpr46)); uint256 sharedExpr48 = sharedExpr45 * sharedExpr46; uint256 sharedExpr49 = 0x02 - ((value62 / sharedExpr39) * (sharedExpr47 * sharedExpr48)); uint256 sharedExpr50 = sharedExpr47 * sharedExpr48; uint256 value63 = ((0x0100000000000000000000000000000000 * value2) - ((0x0100000000000000000000000000000000 * value2) % value62) / (value62 & sharedExpr38) | (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)) - (((0x0100000000000000000000000000000000 * value2) % value62) > (0x0100000000000000000000000000000000 * value2)) * (0x01 + ((0 - (value62 & sharedExpr38)) / (value62 & sharedExpr38))))) * ((sharedExpr49 * sharedExpr50) * (0x02 - ((sharedExpr49 * sharedExpr50) * (value62 / sharedExpr39)))); if (0 != (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)))) { require(value89 > (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2))), CustomError_00000000()); } else { value63 = (0x0100000000000000000000000000000000 * value2) / value62; } } else { uint256 value64; uint256 sharedExpr100 = (bytes1(value60)) + (value61 >> 0x20); uint256 sharedExpr101 = address(sharedExpr100); uint256 sharedExpr102 = address(sharedExpr100); uint256 sharedExpr103 = sharedExpr101 * sharedExpr102; uint256 sharedExpr104 = sharedExpr101 * sharedExpr102; uint256 sharedExpr105 = 0x01 + (~(sharedExpr101 * sharedExpr102)); uint256 sharedExpr106 = sharedExpr101 * sharedExpr102; uint256 sharedExpr107 = sharedExpr104 & sharedExpr105; uint256 sharedExpr108 = (sharedExpr106 / sharedExpr107) * 0x03; uint256 sharedExpr109 = 0x02 - ((sharedExpr106 / sharedExpr107) * (0x02 ^ sharedExpr108)); uint256 sharedExpr110 = 0x02 ^ sharedExpr108; uint256 sharedExpr111 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr109 * sharedExpr110)); uint256 sharedExpr112 = sharedExpr109 * sharedExpr110; uint256 sharedExpr113 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr111 * sharedExpr112)); uint256 sharedExpr114 = sharedExpr111 * sharedExpr112; uint256 sharedExpr115 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr113 * sharedExpr114)); uint256 sharedExpr116 = sharedExpr113 * sharedExpr114; uint256 sharedExpr117 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr115 * sharedExpr116)); uint256 sharedExpr118 = sharedExpr115 * sharedExpr116; uint256 value112 = ((0x01000000000000000000000000000000000000000000000000 * value2) - ((0x01000000000000000000000000000000000000000000000000 * value2) % sharedExpr103) / (sharedExpr104 & sharedExpr105) | (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)) - (((0x01000000000000000000000000000000000000000000000000 * value2) % sharedExpr103) > (0x01000000000000000000000000000000000000000000000000 * value2)) * (0x01 + ((0 - (sharedExpr104 & sharedExpr105)) / (sharedExpr104 & sharedExpr105))))) * ((sharedExpr117 * sharedExpr118) * (0x02 - ((sharedExpr117 * sharedExpr118) * (sharedExpr106 / sharedExpr107)))); if (0 != (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)))) { require(address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) > (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2))), CustomError_00000000()); } else { value112 = (0x01000000000000000000000000000000000000000000000000 * value2) / (address(bytes1(value60) + (value61 >> 0x20)) * (address(bytes1(value60) + (value61 >> 0x20)))); } value64 = value112; } return ; } } } } else { (bool success6, bytes memory returnData6) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).slot0(); // staticcall require(success6); var_b = var_b + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData6.length) - var_b >= 0xe0); require(var_bq == (var_bq & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_br == (int24(var_br))); require(var_p == (uint16(var_p))); require(var_q == (uint16(var_q))); require(var_r == (uint16(var_r))); require(var_s == (uint32(var_s))); require(var_bs == (var_bs != 0x0)); uint256 value65 = 0 - int24(var_l); if (int24(var_l) < 0) { } else { value65 = int24(var_l); } require(value65 <= 0xd89e8, "T"); uint256 value66 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value65)) { value66 = 0x0100000000000000000000000000000000; } uint256 value67 = address(value66); if ((value65 & 0x2) != 0x0) { value67 = (address(value66) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value68 = value67; if ((value65 & 0x4) != 0x0) { value68 = (value67 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value69 = value68; if ((value65 & 0x8) != 0x0) { value69 = (value68 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } uint256 value70 = value69; if ((value65 & 0x10) != 0x0) { value70 = (value69 * 0xffcb9843d60f6159c9db58835c926644) >> 0x80; } uint256 value71 = value70; if ((value65 & 0x20) != 0x0) { value71 = (value70 * 0xff973b41fa98c081472e6896dfb254c0) >> 0x80; } uint256 value72 = value71; if ((value65 & 0x40) != 0x0) { value72 = (value71 * 0xff2ea16466c96a3843ec78b326b52861) >> 0x80; } uint256 value73 = value72; if ((value65 & 0x80) != 0x0) { value73 = (value72 * 0xfe5dee046a99a2a811c461f1969c3053) >> 0x80; } uint256 value74 = value73; if ((value65 & 0x100) != 0x0) { value74 = (value73 * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 0x80; } uint256 value75 = value74; if ((value65 & 0x200) != 0x0) { value75 = (value74 * 0xf987a7253ac413176f2b074cf7815e54) >> 0x80; } uint256 value76 = value75; if ((value65 & 0x400) != 0x0) { value76 = (value75 * 0xf3392b0822b70005940c7a398e4b70f3) >> 0x80; } uint256 value77 = value76; if ((value65 & 0x800) != 0x0) { value77 = (value76 * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 0x80; } uint256 value78 = value77; if ((value65 & 0x1000) != 0x0) { value78 = (value77 * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 0x80; } uint256 value79 = value78; if ((value65 & 0x2000) != 0x0) { value79 = (value78 * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 0x80; } uint256 value80 = value79; if ((value65 & 0x4000) != 0x0) { value80 = (value79 * 0x70d869a156d2a1b890bb3df62baf32f7) >> 0x80; } uint256 value81 = value80; if ((value65 & 0x8000) != 0x0) { value81 = (value80 * 0x31be135f97d08fd981231505542fcfa6) >> 0x80; } uint256 value82 = value81; if ((value65 & 0x10000) != 0x0) { value82 = (value81 * 0x09aa508b5b7a84e1c677de54f3e99bc9) >> 0x80; } uint256 value83 = value82; if ((value65 & 0x20000) != 0x0) { value83 = (value82 * 0x5d6af8dedb81196699c329225ee604) >> 0x80; } uint256 value84 = value83; if ((value65 & 0x40000) != 0x0) { value84 = (value83 * 0x2216e584f5fa1ea926041bedfe98) >> 0x80; } uint256 value85 = value84; if ((value65 & 0x80000) != 0x0) { value85 = (value84 * 0x048a170391f7dc42444e8fa2) >> 0x80; } uint256 value86 = value85 % 0x0100000000; value88 = value85; if (!(int24(var_l) > 0)) { } else { value86 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value85) % 0x0100000000; value88 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value85; } value87 = 0; if (value86 != 0x0) { value87 = 0x01; } uint256 value92; if (address(bytes1(value87) + (value88 >> 0x20)) > 0xffffffffffffffffffffffffffffffff) { uint256 sharedExpr138 = var_b; uint256 sharedExpr139 = var_b + returnData6.length; uint256 sharedExpr140 = var_br; uint256 sharedExpr141 = sharedExpr140; uint256 sharedExpr142 = (bytes1(value87)) + (value88 >> 0x20); uint256 sharedExpr143 = sharedExpr142; uint256 sharedExpr144 = address(sharedExpr143); uint256 sharedExpr145 = address(sharedExpr143); uint256 sharedExpr146 = 0x01 + ~(0x010000000000000000); uint256 sharedExpr147 = (0x010000000000000000) & sharedExpr146; uint256 sharedExpr148 = (0x010000000000000000 / sharedExpr147) * 0x03; uint256 sharedExpr149 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (0x02 ^ sharedExpr148)); uint256 sharedExpr150 = 0x02 ^ sharedExpr148; uint256 sharedExpr151 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr149 * sharedExpr150)); uint256 sharedExpr152 = sharedExpr149 * sharedExpr150; uint256 sharedExpr153 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr151 * sharedExpr152)); uint256 sharedExpr154 = sharedExpr151 * sharedExpr152; uint256 sharedExpr155 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr153 * sharedExpr154)); uint256 sharedExpr156 = sharedExpr153 * sharedExpr154; uint256 sharedExpr157 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr155 * sharedExpr156)); uint256 sharedExpr158 = sharedExpr155 * sharedExpr156; uint256 sharedExpr159 = (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) - (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0x010000000000000000) / (0x010000000000000000 & sharedExpr146) | ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))) - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))))) - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0x010000000000000000) > (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))))) * (0x01 + ((0 - (0x010000000000000000 & sharedExpr146)) / (0x010000000000000000 & sharedExpr146))))) * ((sharedExpr157 * sharedExpr158) * (0x02 - ((sharedExpr157 * sharedExpr158) * (0x010000000000000000 / sharedExpr147)))); value89 = sharedExpr159; if (0 != ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))) - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))))))) { require(0x010000000000000000 > ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))) - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))))), "Math: mulDiv overflow"); uint256 sharedExpr160 = 0x01 + ~(0x010000000000000000); uint256 sharedExpr161 = (0x010000000000000000) & sharedExpr160; uint256 sharedExpr162 = (0x010000000000000000 / sharedExpr161) * 0x03; uint256 sharedExpr163 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (0x02 ^ sharedExpr162)); uint256 sharedExpr164 = 0x02 ^ sharedExpr162; uint256 sharedExpr165 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr163 * sharedExpr164)); uint256 sharedExpr166 = sharedExpr163 * sharedExpr164; uint256 sharedExpr167 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr165 * sharedExpr166)); uint256 sharedExpr168 = sharedExpr165 * sharedExpr166; uint256 sharedExpr169 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr167 * sharedExpr168)); uint256 sharedExpr170 = sharedExpr167 * sharedExpr168; uint256 sharedExpr171 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr169 * sharedExpr170)); uint256 sharedExpr172 = sharedExpr169 * sharedExpr170; } else { value89 = address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / 0x010000000000000000; } uint256 value113; uint256 sharedExpr195 = 0x01 + ~(value89); uint256 sharedExpr196 = value89 & sharedExpr195; uint256 sharedExpr197 = (value89 / sharedExpr196) * 0x03; uint256 sharedExpr198 = 0x02 - ((value89 / sharedExpr196) * (0x02 ^ sharedExpr197)); uint256 sharedExpr199 = 0x02 ^ sharedExpr197; uint256 sharedExpr200 = 0x02 - ((value89 / sharedExpr196) * (sharedExpr198 * sharedExpr199)); uint256 sharedExpr201 = sharedExpr198 * sharedExpr199; uint256 sharedExpr202 = 0x02 - ((value89 / sharedExpr196) * (sharedExpr200 * sharedExpr201)); uint256 sharedExpr203 = sharedExpr200 * sharedExpr201; uint256 sharedExpr204 = 0x02 - ((value89 / sharedExpr196) * (sharedExpr202 * sharedExpr203)); uint256 sharedExpr205 = sharedExpr202 * sharedExpr203; uint256 sharedExpr206 = 0x02 - ((value89 / sharedExpr196) * (sharedExpr204 * sharedExpr205)); uint256 sharedExpr207 = sharedExpr204 * sharedExpr205; uint256 sharedExpr208 = ((0x0100000000000000000000000000000000 * value2) - ((0x0100000000000000000000000000000000 * value2) % value89) / (value89 & sharedExpr195) | (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)) - (((0x0100000000000000000000000000000000 * value2) % value89) > (0x0100000000000000000000000000000000 * value2)) * (0x01 + ((0 - (value89 & sharedExpr195)) / (value89 & sharedExpr195))))) * ((sharedExpr206 * sharedExpr207) * (0x02 - ((sharedExpr206 * sharedExpr207) * (value89 / sharedExpr196)))); uint256 value90 = sharedExpr208; if (0 != (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)))) { require(value89 > (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2))), "Math: mulDiv overflow"); uint256 sharedExpr209 = 0x01 + ~(value89); uint256 sharedExpr210 = value89 & sharedExpr209; uint256 sharedExpr211 = (value89 / sharedExpr210) * 0x03; uint256 sharedExpr212 = 0x02 - ((value89 / sharedExpr210) * (0x02 ^ sharedExpr211)); uint256 sharedExpr213 = 0x02 ^ sharedExpr211; uint256 sharedExpr214 = 0x02 - ((value89 / sharedExpr210) * (sharedExpr212 * sharedExpr213)); uint256 sharedExpr215 = sharedExpr212 * sharedExpr213; uint256 sharedExpr216 = 0x02 - ((value89 / sharedExpr210) * (sharedExpr214 * sharedExpr215)); uint256 sharedExpr217 = sharedExpr214 * sharedExpr215; uint256 sharedExpr218 = 0x02 - ((value89 / sharedExpr210) * (sharedExpr216 * sharedExpr217)); uint256 sharedExpr219 = sharedExpr216 * sharedExpr217; uint256 sharedExpr220 = 0x02 - ((value89 / sharedExpr210) * (sharedExpr218 * sharedExpr219)); uint256 sharedExpr221 = sharedExpr218 * sharedExpr219; } else { value90 = (0x0100000000000000000000000000000000 * value2) / value89; } value113 = value90; value92 = value113; } else { uint256 value91; uint256 sharedExpr297 = var_b; uint256 sharedExpr298 = var_b + returnData6.length; uint256 sharedExpr299 = var_br; uint256 sharedExpr300 = sharedExpr299; uint256 sharedExpr301 = (bytes1(value87)) + (value88 >> 0x20); uint256 sharedExpr302 = sharedExpr301; uint256 sharedExpr303 = address(sharedExpr302); uint256 sharedExpr304 = address(sharedExpr302); uint256 sharedExpr305 = (address(bytes1(value87) + (value88 >> 0x20))) * (address(bytes1(value87) + (value88 >> 0x20))); uint256 sharedExpr306 = sharedExpr305; uint256 sharedExpr307 = 0x01 + ~(address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))); uint256 sharedExpr308 = (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))) & sharedExpr307; uint256 sharedExpr309 = (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr308) * 0x03; uint256 sharedExpr310 = 0x02 - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr308) * (0x02 ^ sharedExpr309)); uint256 sharedExpr311 = 0x02 ^ sharedExpr309; uint256 sharedExpr312 = 0x02 - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr308) * (sharedExpr310 * sharedExpr311)); uint256 sharedExpr313 = sharedExpr310 * sharedExpr311; uint256 sharedExpr314 = 0x02 - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr308) * (sharedExpr312 * sharedExpr313)); uint256 sharedExpr315 = sharedExpr312 * sharedExpr313; uint256 sharedExpr316 = 0x02 - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr308) * (sharedExpr314 * sharedExpr315)); uint256 sharedExpr317 = sharedExpr314 * sharedExpr315; uint256 sharedExpr318 = 0x02 - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr308) * (sharedExpr316 * sharedExpr317)); uint256 sharedExpr319 = sharedExpr316 * sharedExpr317; uint256 sharedExpr320 = ((0x01000000000000000000000000000000000000000000000000 * value2) - ((0x01000000000000000000000000000000000000000000000000 * value2) % (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))))) / (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) & sharedExpr307) | (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)) - ((0x01000000000000000000000000000000000000000000000000 * value2) % (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))) > (0x01000000000000000000000000000000000000000000000000 * value2)) * (0x01 + ((0 - (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) & sharedExpr307)) / (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) & sharedExpr307))))) * ((sharedExpr318 * sharedExpr319) * (0x02 - ((sharedExpr318 * sharedExpr319) * (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr308)))); uint256 value116 = sharedExpr320; if (0 != (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)))) { require(address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) > (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2))), "Math: mulDiv overflow"); uint256 sharedExpr321 = 0x01 + ~(address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))); uint256 sharedExpr322 = (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))) & sharedExpr321; uint256 sharedExpr323 = (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr322) * 0x03; uint256 sharedExpr324 = 0x02 - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr322) * (0x02 ^ sharedExpr323)); uint256 sharedExpr325 = 0x02 ^ sharedExpr323; uint256 sharedExpr326 = 0x02 - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr322) * (sharedExpr324 * sharedExpr325)); uint256 sharedExpr327 = sharedExpr324 * sharedExpr325; uint256 sharedExpr328 = 0x02 - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr322) * (sharedExpr326 * sharedExpr327)); uint256 sharedExpr329 = sharedExpr326 * sharedExpr327; uint256 sharedExpr330 = 0x02 - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr322) * (sharedExpr328 * sharedExpr329)); uint256 sharedExpr331 = sharedExpr328 * sharedExpr329; uint256 sharedExpr332 = 0x02 - ((address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20))) / sharedExpr322) * (sharedExpr330 * sharedExpr331)); uint256 sharedExpr333 = sharedExpr330 * sharedExpr331; } else { value116 = (0x01000000000000000000000000000000000000000000000000 * value2) / (address(bytes1(value87) + (value88 >> 0x20)) * (address(bytes1(value87) + (value88 >> 0x20)))); } value91 = value116; value92 = value91; } // duplicate declaration of value92 omitted } } else { return 0; } } } function isLimitBuy() public view returns (bool) { return !(!(bytes1(stor_16))); } function getDownFee() public returns (uint256) { (bool success0, bytes memory returnData0) = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).token0(); // staticcall require(success0); uint256 var_b; var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData0.length) - var_b >= 0x20); require(var_c == (var_c & 0xffffffffffffffffffffffffffffffffffffffff)); (bool success1, bytes memory returnData1) = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).getReserves(); // staticcall require(success1); (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData1, (uint112, uint112, uint32)); bool flag0 = 0 == (uint112(var_k)); if (!(0 == (uint112(var_k)))) { flag0 = !(uint112(var_l)); } uint256 value2; if (!flag0) { uint256 value1 = (uint112(var_l) * 0x0de0b6b3a7640000) / (uint112(var_k)); if (address(this) == (address(var_k))) { } else { value1 = (uint112(var_k) * 0x0de0b6b3a7640000) / (uint112(var_l)); } value2 = value1; } else { value2 = 0; } if (0x0 != value2) { (bool success2, bytes memory returnData2) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).slot0(); // staticcall require(success2); var_b = var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData2.length) - var_b >= 0xe0); require(var_n == (var_n & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_o == (int24(var_o))); require(var_p == (uint16(var_p))); require(var_q == (uint16(var_q))); require(var_r == (uint16(var_r))); require(var_s == (uint32(var_s))); require(var_t == (var_t != 0x0)); (bool success3, bytes memory returnData3) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).observations(uint16(var_y + (0x01) % var_z)); // staticcall require(success3); var_b = var_b + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData3.length) - var_b >= 0x80); require(var_ac == (uint32(var_ac))); require(var_ad == int56(var_ad)); require(var_ae == (var_ae & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_af == (var_af != 0x0)); uint256 value17 = var_b.length; if (!(var_z)) { (bool success4, bytes memory returnData4) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).observations(0); // staticcall require(success4); var_b = var_b + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData4.length) - var_b >= 0x80); require(var_ac == (uint32(var_ac))); require(var_ad == int56(var_ad)); require(var_ak == (var_ak & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_al == (var_al != 0x0)); value17 = var_b.length; } uint256 value18 = block.timestamp - value17; if (!(uint32(block.timestamp - value17) < 0x0384)) { value18 = 0x0384; } if (0x0 != (0xffffffff & value18)) { var_b = var_b + 0x60; if (!(0 < var_b.length)) _desolexPanic(50); if (!(0x01 < var_b.length)) _desolexPanic(50); uint256 value19 = 0; uint256 value20 = var_aq; uint256 value21 = (0x04 + var_b) + 0x40; uint256 value22 = 0x20 + var_b; uint256 value23 = 0x20; uint256 value24 = 0; uint256 value25 = 0x04 + var_b; uint256 value26 = var_b; uint256 value93; uint256 value92; while (true) { if (value19 >= value20) { break; } if ((0x01 + value19) >= value20) { break; } value19 = 0x01 + (0x01 + value19); value20 = value20; value21 = value23 + (value23 + value21); value22 = value23 + (value23 + value22); value23 = value23; value24 = value24; value25 = value25; value26 = value26; (bool success5, bytes memory returnData5) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).Unknown_883bdbfd(0x20); // staticcall require(success5); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData5.length + 0x1f)); require((var_b + returnData5.length) - var_b >= 0x40); require(!(var_az > 0xffffffffffffffff)); require(((var_b + var_az) + 0x1f) < (var_b + returnData5.length)); if (!(var_ba <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ba << 0x05)) + 0x1f))) < var_b) | ((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ba << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ba << 0x05)) + 0x1f)); require(!((0x20 + ((var_b + var_az) + (var_bc << 0x05))) > (var_b + returnData5.length))); uint256 value28 = var_b + 0x20; uint256 value27 = 0x20 + (var_b + var_az); while (true) { uint256 value29 = value28; uint256 value30 = value27; if (!(value27 < (0x20 + ((var_b + var_az) + (var_bc << 0x05))))) { break; } require(var_bd == int56(var_bd)); if (!((0x20 + value27) < (0x20 + ((var_b + var_az) + (var_bc << 0x05))))) { break; } require(var_bd == int56(var_bd)); value28 = 0x20 + (0x20 + value28); value27 = 0x20 + (0x20 + value27); value29 = 0x20 + value28; value30 = 0x20 + value27; } require(!(var_bi > 0xffffffffffffffff)); require((var_b + var_bi) + 0x1f < (var_b + returnData5.length)); if (!(__desolex_internal_4484_44db_arg0 <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (__desolex_internal_4453_44e0_arg0 + 0x1f))) < var_b) | ((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (__desolex_internal_4453_44e0_arg0 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (__desolex_internal_4453_44e0_arg0 + 0x1f)); require(!((0x20 + ((var_b + var_bi) + (var_bj << 0x05))) > (var_b + returnData5.length))); uint256 value31 = (var_b + var_bi) + 0x20; uint256 value33 = var_b; uint256 value34 = var_b + 0x20; uint256 value35 = 0x20; uint256 value32 = 0x20 + ((var_b + var_bi) + (var_bj << 0x05)); uint256 value36 = 0; uint256 value37 = var_b + var_bi; uint256 value38 = var_b + returnData5.length; uint256 value94; while (true) { if (value31 >= value32) { break; } require(__desolex_internal_3e31_4516_arg0 == (__desolex_internal_3e31_4516_arg0 & 0xffffffffffffffffffffffffffffffffffffffff)); if (__desolex_internal_4503_45e7_arg0 >= __desolex_internal_4503_45e7_arg4) { break; } require(__desolex_internal_3e31_4516_arg0 == (__desolex_internal_3e31_4516_arg0 & 0xffffffffffffffffffffffffffffffffffffffff)); value31 = __desolex_internal_4503_45e7_arg0; value33 = __desolex_internal_4503_45e7_arg1; value34 = __desolex_internal_4503_45e7_arg2; value35 = __desolex_internal_4503_45e7_arg3; value32 = __desolex_internal_4503_45e7_arg4; value36 = __desolex_internal_4503_45e7_arg5; value37 = __desolex_internal_4503_45e7_arg6; value38 = __desolex_internal_4503_45e7_arg7; if (!(0 < var_b.length)) _desolexPanic(50); if (!(0x01 < var_b.length)) _desolexPanic(50); if (int56(var_bn - var_bo) < 0) { } if (!(int56(var_bn - var_bo) < 0)) { uint256 value39 = 0 - int24(var_l); if (int24(var_l) < 0) { } else { value39 = int24(var_l); } require(value39 <= 0xd89e8, CustomError_00000000()); uint256 value40 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value39)) { value40 = 0x0100000000000000000000000000000000; } uint256 value41 = address(value40); if ((value39 & 0x2) != 0x0) { value41 = (address(value40) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value42 = value41; if ((value39 & 0x4) != 0x0) { value42 = (value41 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } } else { uint256 value43 = 0 - int24(var_l); if (int24(var_l) < 0) { } else { value43 = int24(var_l); } require(value43 <= 0xd89e8, CustomError_00000000()); uint256 value44 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value43)) { value44 = 0x0100000000000000000000000000000000; } uint256 value45 = address(value44); if ((value43 & 0x2) != 0x0) { value45 = (address(value44) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value46 = value45; if ((value43 & 0x4) != 0x0) { value46 = (value45 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value47 = value46; if ((value43 & 0x8) != 0x0) { value47 = (value46 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } uint256 value48 = value47; if ((value43 & 0x10) != 0x0) { value48 = (value47 * 0xffcb9843d60f6159c9db58835c926644) >> 0x80; } uint256 value49 = value48; if ((value43 & 0x20) != 0x0) { value49 = (value48 * 0xff973b41fa98c081472e6896dfb254c0) >> 0x80; } uint256 value50 = value49; if ((value43 & 0x40) != 0x0) { value50 = (value49 * 0xff2ea16466c96a3843ec78b326b52861) >> 0x80; } uint256 value51 = value50; if ((value43 & 0x80) != 0x0) { value51 = (value50 * 0xfe5dee046a99a2a811c461f1969c3053) >> 0x80; } uint256 value52 = value51; if ((value43 & 0x100) != 0x0) { value52 = (value51 * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 0x80; } uint256 value53 = value52; if ((value43 & 0x200) != 0x0) { value53 = (value52 * 0xf987a7253ac413176f2b074cf7815e54) >> 0x80; } uint256 value54 = value53; if ((value43 & 0x400) != 0x0) { value54 = (value53 * 0xf3392b0822b70005940c7a398e4b70f3) >> 0x80; } uint256 value55 = value54; if ((value43 & 0x800) != 0x0) { value55 = (value54 * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 0x80; } uint256 value56 = value55; if ((value43 & 0x1000) != 0x0) { value56 = (value55 * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 0x80; } uint256 value57 = value56; if ((value43 & 0x2000) != 0x0) { value57 = (value56 * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 0x80; } uint256 value58 = value57; if ((value43 & 0x4000) != 0x0) { value58 = (value57 * 0x70d869a156d2a1b890bb3df62baf32f7) >> 0x80; } uint256 value59 = value58; if ((value43 & 0x8000) != 0x0) { value59 = (value58 * 0x31be135f97d08fd981231505542fcfa6) >> 0x80; } uint256 value60 = value59; if ((value43 & 0x10000) != 0x0) { value60 = (value59 * 0x09aa508b5b7a84e1c677de54f3e99bc9) >> 0x80; } uint256 value61 = value60; if ((value43 & 0x20000) != 0x0) { value61 = (value60 * 0x5d6af8dedb81196699c329225ee604) >> 0x80; } uint256 value62 = value61; if ((value43 & 0x40000) != 0x0) { value62 = (value61 * 0x2216e584f5fa1ea926041bedfe98) >> 0x80; } uint256 value63 = value62; if ((value43 & 0x80000) != 0x0) { value63 = (value62 * 0x048a170391f7dc42444e8fa2) >> 0x80; } uint256 value64 = value63 % 0x0100000000; uint256 value66 = value63; if (!(int24(var_l) > 0)) { } else { value64 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value63) % 0x0100000000; value66 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value63; } uint256 value65 = 0; if (value64 != 0x0) { value65 = 0x01; } uint256 value67; if (address(bytes1(value65) + (value66 >> 0x20)) > 0xffffffffffffffffffffffffffffffff) { uint256 sharedExpr0 = (bytes1(value65)) + (value66 >> 0x20); uint256 sharedExpr1 = address(sharedExpr0); uint256 sharedExpr2 = address(sharedExpr0); uint256 sharedExpr3 = address(sharedExpr0); uint256 sharedExpr4 = address(sharedExpr0); uint256 sharedExpr5 = address(sharedExpr0); uint256 sharedExpr6 = address(sharedExpr0); uint256 sharedExpr7 = (0x010000000000000000) & (0x01 + ~(0x010000000000000000)); uint256 sharedExpr8 = (0x010000000000000000 / sharedExpr7) * 0x03; uint256 sharedExpr9 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (0x02 ^ sharedExpr8)); uint256 sharedExpr10 = 0x02 ^ sharedExpr8; uint256 sharedExpr11 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr9 * sharedExpr10)); uint256 sharedExpr12 = sharedExpr9 * sharedExpr10; uint256 sharedExpr13 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr11 * sharedExpr12)); uint256 sharedExpr14 = sharedExpr11 * sharedExpr12; uint256 sharedExpr15 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr13 * sharedExpr14)); uint256 sharedExpr16 = sharedExpr13 * sharedExpr14; uint256 sharedExpr17 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr15 * sharedExpr16)); uint256 sharedExpr18 = sharedExpr15 * sharedExpr16; value67 = ((sharedExpr1 * sharedExpr2) - ((sharedExpr3 * sharedExpr4) % 0x010000000000000000) / (0x010000000000000000 & (0x01 + ~(0x010000000000000000))) | (((sharedExpr5 * sharedExpr6) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (sharedExpr1 * sharedExpr2) - (((sharedExpr5 * sharedExpr6) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (sharedExpr1 * sharedExpr2)) - (((sharedExpr3 * sharedExpr4) % 0x010000000000000000) > (sharedExpr1 * sharedExpr2)) * (0x01 + ((0 - (0x010000000000000000 & (0x01 + ~(0x010000000000000000)))) / (0x010000000000000000 & (0x01 + ~(0x010000000000000000))))))) * ((sharedExpr17 * sharedExpr18) * (0x02 - ((sharedExpr17 * sharedExpr18) * (0x010000000000000000 / sharedExpr7)))); if (0 != ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))) - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))))))) { require(0x010000000000000000 > ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))) - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))))), CustomError_00000000()); } else { value67 = (address(bytes1(value65) + (value66 >> 0x20)) * (address(bytes1(value65) + (value66 >> 0x20)))) / 0x010000000000000000; } uint256 sharedExpr38 = 0x01 + ~(value67); uint256 sharedExpr39 = value67 & sharedExpr38; uint256 sharedExpr40 = (value67 / sharedExpr39) * 0x03; uint256 sharedExpr41 = 0x02 - ((value67 / sharedExpr39) * (0x02 ^ sharedExpr40)); uint256 sharedExpr42 = 0x02 ^ sharedExpr40; uint256 sharedExpr43 = 0x02 - ((value67 / sharedExpr39) * (sharedExpr41 * sharedExpr42)); uint256 sharedExpr44 = sharedExpr41 * sharedExpr42; uint256 sharedExpr45 = 0x02 - ((value67 / sharedExpr39) * (sharedExpr43 * sharedExpr44)); uint256 sharedExpr46 = sharedExpr43 * sharedExpr44; uint256 sharedExpr47 = 0x02 - ((value67 / sharedExpr39) * (sharedExpr45 * sharedExpr46)); uint256 sharedExpr48 = sharedExpr45 * sharedExpr46; uint256 sharedExpr49 = 0x02 - ((value67 / sharedExpr39) * (sharedExpr47 * sharedExpr48)); uint256 sharedExpr50 = sharedExpr47 * sharedExpr48; uint256 value68 = ((0x0100000000000000000000000000000000 * value2) - ((0x0100000000000000000000000000000000 * value2) % value67) / (value67 & sharedExpr38) | (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)) - (((0x0100000000000000000000000000000000 * value2) % value67) > (0x0100000000000000000000000000000000 * value2)) * (0x01 + ((0 - (value67 & sharedExpr38)) / (value67 & sharedExpr38))))) * ((sharedExpr49 * sharedExpr50) * (0x02 - ((sharedExpr49 * sharedExpr50) * (value67 / sharedExpr39)))); if (0 != (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)))) { require(value94 > (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2))), CustomError_00000000()); } else { value68 = (0x0100000000000000000000000000000000 * value2) / value67; } } else { uint256 value69; uint256 sharedExpr100 = (bytes1(value65)) + (value66 >> 0x20); uint256 sharedExpr101 = address(sharedExpr100); uint256 sharedExpr102 = address(sharedExpr100); uint256 sharedExpr103 = sharedExpr101 * sharedExpr102; uint256 sharedExpr104 = sharedExpr101 * sharedExpr102; uint256 sharedExpr105 = 0x01 + (~(sharedExpr101 * sharedExpr102)); uint256 sharedExpr106 = sharedExpr101 * sharedExpr102; uint256 sharedExpr107 = sharedExpr104 & sharedExpr105; uint256 sharedExpr108 = (sharedExpr106 / sharedExpr107) * 0x03; uint256 sharedExpr109 = 0x02 - ((sharedExpr106 / sharedExpr107) * (0x02 ^ sharedExpr108)); uint256 sharedExpr110 = 0x02 ^ sharedExpr108; uint256 sharedExpr111 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr109 * sharedExpr110)); uint256 sharedExpr112 = sharedExpr109 * sharedExpr110; uint256 sharedExpr113 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr111 * sharedExpr112)); uint256 sharedExpr114 = sharedExpr111 * sharedExpr112; uint256 sharedExpr115 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr113 * sharedExpr114)); uint256 sharedExpr116 = sharedExpr113 * sharedExpr114; uint256 sharedExpr117 = 0x02 - ((sharedExpr106 / sharedExpr107) * (sharedExpr115 * sharedExpr116)); uint256 sharedExpr118 = sharedExpr115 * sharedExpr116; uint256 value99 = ((0x01000000000000000000000000000000000000000000000000 * value2) - ((0x01000000000000000000000000000000000000000000000000 * value2) % sharedExpr103) / (sharedExpr104 & sharedExpr105) | (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)) - (((0x01000000000000000000000000000000000000000000000000 * value2) % sharedExpr103) > (0x01000000000000000000000000000000000000000000000000 * value2)) * (0x01 + ((0 - (sharedExpr104 & sharedExpr105)) / (sharedExpr104 & sharedExpr105))))) * ((sharedExpr117 * sharedExpr118) * (0x02 - ((sharedExpr117 * sharedExpr118) * (sharedExpr106 / sharedExpr107)))); if (0 != (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)))) { require(address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) > (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2))), CustomError_00000000()); } else { value99 = (0x01000000000000000000000000000000000000000000000000 * value2) / (address(bytes1(value65) + (value66 >> 0x20)) * (address(bytes1(value65) + (value66 >> 0x20)))); } value69 = value99; } if (!((((value67 * value2) - ((value67 * value2) % 0x0100000000000000000000000000000000) / 0x0100000000000000000000000000000000) | (((value67 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value67 * value2) - (((value67 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value67 * value2)) - (((value67 * value2) % 0x0100000000000000000000000000000000) > (value67 * value2)) * 0x0100000000000000000000000000000000) * 0x01) < openPrice)) { } else { if ((((openPrice - (((value67 * value2) - ((value67 * value2) % 0x0100000000000000000000000000000000) / 0x0100000000000000000000000000000000) | (((value67 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value67 * value2) - (((value67 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value67 * value2)) - (((value67 * value2) % 0x0100000000000000000000000000000000) > (value67 * value2)) * 0x0100000000000000000000000000000000) * 0x01)) * 0x2710) / openPrice) < 0x0a) { return ; } if ((((openPrice - (((value67 * value2) - ((value67 * value2) % 0x0100000000000000000000000000000000) / 0x0100000000000000000000000000000000) | (((value67 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value67 * value2) - (((value67 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value67 * value2)) - (((value67 * value2) % 0x0100000000000000000000000000000000) > (value67 * value2)) * 0x0100000000000000000000000000000000) * 0x01)) * 0x2710) / openPrice) >= 0x01f4) { return ; } if ((((openPrice - (((value67 * value2) - ((value67 * value2) % 0x0100000000000000000000000000000000) / 0x0100000000000000000000000000000000) | (((value67 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value67 * value2) - (((value67 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value67 * value2)) - (((value67 * value2) % 0x0100000000000000000000000000000000) > (value67 * value2)) * 0x0100000000000000000000000000000000) * 0x01)) * 0x2710) / openPrice) < 0x64) { } else { } } return ; } } } } else { (bool success6, bytes memory returnData6) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).slot0(); // staticcall require(success6); var_b = var_b + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData6.length) - var_b >= 0xe0); require(var_bq == (var_bq & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_br == (int24(var_br))); require(var_p == (uint16(var_p))); require(var_q == (uint16(var_q))); require(var_r == (uint16(var_r))); require(var_s == (uint32(var_s))); require(var_bs == (var_bs != 0x0)); uint256 value70 = 0 - int24(var_l); if (int24(var_l) < 0) { } else { value70 = int24(var_l); } require(value70 <= 0xd89e8, "T"); uint256 value71 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value70)) { value71 = 0x0100000000000000000000000000000000; } uint256 value72 = address(value71); if ((value70 & 0x2) != 0x0) { value72 = (address(value71) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value73 = value72; if ((value70 & 0x4) != 0x0) { value73 = (value72 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value74 = value73; if ((value70 & 0x8) != 0x0) { value74 = (value73 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } uint256 value75 = value74; if ((value70 & 0x10) != 0x0) { value75 = (value74 * 0xffcb9843d60f6159c9db58835c926644) >> 0x80; } uint256 value76 = value75; if ((value70 & 0x20) != 0x0) { value76 = (value75 * 0xff973b41fa98c081472e6896dfb254c0) >> 0x80; } uint256 value77 = value76; if ((value70 & 0x40) != 0x0) { value77 = (value76 * 0xff2ea16466c96a3843ec78b326b52861) >> 0x80; } uint256 value78 = value77; if ((value70 & 0x80) != 0x0) { value78 = (value77 * 0xfe5dee046a99a2a811c461f1969c3053) >> 0x80; } uint256 value79 = value78; if ((value70 & 0x100) != 0x0) { value79 = (value78 * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 0x80; } uint256 value80 = value79; if ((value70 & 0x200) != 0x0) { value80 = (value79 * 0xf987a7253ac413176f2b074cf7815e54) >> 0x80; } uint256 value81 = value80; if ((value70 & 0x400) != 0x0) { value81 = (value80 * 0xf3392b0822b70005940c7a398e4b70f3) >> 0x80; } uint256 value82 = value81; if ((value70 & 0x800) != 0x0) { value82 = (value81 * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 0x80; } uint256 value83 = value82; if ((value70 & 0x1000) != 0x0) { value83 = (value82 * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 0x80; } uint256 value84 = value83; if ((value70 & 0x2000) != 0x0) { value84 = (value83 * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 0x80; } uint256 value85 = value84; if ((value70 & 0x4000) != 0x0) { value85 = (value84 * 0x70d869a156d2a1b890bb3df62baf32f7) >> 0x80; } uint256 value86 = value85; if ((value70 & 0x8000) != 0x0) { value86 = (value85 * 0x31be135f97d08fd981231505542fcfa6) >> 0x80; } uint256 value87 = value86; if ((value70 & 0x10000) != 0x0) { value87 = (value86 * 0x09aa508b5b7a84e1c677de54f3e99bc9) >> 0x80; } uint256 value88 = value87; if ((value70 & 0x20000) != 0x0) { value88 = (value87 * 0x5d6af8dedb81196699c329225ee604) >> 0x80; } uint256 value89 = value88; if ((value70 & 0x40000) != 0x0) { value89 = (value88 * 0x2216e584f5fa1ea926041bedfe98) >> 0x80; } uint256 value90 = value89; if ((value70 & 0x80000) != 0x0) { value90 = (value89 * 0x048a170391f7dc42444e8fa2) >> 0x80; } uint256 value91 = value90 % 0x0100000000; value93 = value90; if (!(int24(var_l) > 0)) { } else { value91 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value90) % 0x0100000000; value93 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value90; } value92 = 0; if (value91 != 0x0) { value92 = 0x01; } uint256 value97; if (address(bytes1(value92) + (value93 >> 0x20)) > 0xffffffffffffffffffffffffffffffff) { uint256 sharedExpr138 = var_b; uint256 sharedExpr139 = var_b + returnData6.length; uint256 sharedExpr140 = var_br; uint256 sharedExpr141 = sharedExpr140; uint256 sharedExpr142 = (bytes1(value92)) + (value93 >> 0x20); uint256 sharedExpr143 = sharedExpr142; uint256 sharedExpr144 = address(sharedExpr143); uint256 sharedExpr145 = address(sharedExpr143); uint256 sharedExpr146 = 0x01 + ~(0x010000000000000000); uint256 sharedExpr147 = (0x010000000000000000) & sharedExpr146; uint256 sharedExpr148 = (0x010000000000000000 / sharedExpr147) * 0x03; uint256 sharedExpr149 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (0x02 ^ sharedExpr148)); uint256 sharedExpr150 = 0x02 ^ sharedExpr148; uint256 sharedExpr151 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr149 * sharedExpr150)); uint256 sharedExpr152 = sharedExpr149 * sharedExpr150; uint256 sharedExpr153 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr151 * sharedExpr152)); uint256 sharedExpr154 = sharedExpr151 * sharedExpr152; uint256 sharedExpr155 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr153 * sharedExpr154)); uint256 sharedExpr156 = sharedExpr153 * sharedExpr154; uint256 sharedExpr157 = 0x02 - ((0x010000000000000000 / sharedExpr147) * (sharedExpr155 * sharedExpr156)); uint256 sharedExpr158 = sharedExpr155 * sharedExpr156; uint256 sharedExpr159 = (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) - (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0x010000000000000000) / (0x010000000000000000 & sharedExpr146) | ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))) - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))))) - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0x010000000000000000) > (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))))) * (0x01 + ((0 - (0x010000000000000000 & sharedExpr146)) / (0x010000000000000000 & sharedExpr146))))) * ((sharedExpr157 * sharedExpr158) * (0x02 - ((sharedExpr157 * sharedExpr158) * (0x010000000000000000 / sharedExpr147)))); value94 = sharedExpr159; if (0 != ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))) - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))))))) { require(0x010000000000000000 > ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))) - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))))), "Math: mulDiv overflow"); uint256 sharedExpr160 = 0x01 + ~(0x010000000000000000); uint256 sharedExpr161 = (0x010000000000000000) & sharedExpr160; uint256 sharedExpr162 = (0x010000000000000000 / sharedExpr161) * 0x03; uint256 sharedExpr163 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (0x02 ^ sharedExpr162)); uint256 sharedExpr164 = 0x02 ^ sharedExpr162; uint256 sharedExpr165 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr163 * sharedExpr164)); uint256 sharedExpr166 = sharedExpr163 * sharedExpr164; uint256 sharedExpr167 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr165 * sharedExpr166)); uint256 sharedExpr168 = sharedExpr165 * sharedExpr166; uint256 sharedExpr169 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr167 * sharedExpr168)); uint256 sharedExpr170 = sharedExpr167 * sharedExpr168; uint256 sharedExpr171 = 0x02 - ((0x010000000000000000 / sharedExpr161) * (sharedExpr169 * sharedExpr170)); uint256 sharedExpr172 = sharedExpr169 * sharedExpr170; } else { value94 = address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / 0x010000000000000000; } uint256 value100; uint256 sharedExpr195 = 0x01 + ~(value94); uint256 sharedExpr196 = value94 & sharedExpr195; uint256 sharedExpr197 = (value94 / sharedExpr196) * 0x03; uint256 sharedExpr198 = 0x02 - ((value94 / sharedExpr196) * (0x02 ^ sharedExpr197)); uint256 sharedExpr199 = 0x02 ^ sharedExpr197; uint256 sharedExpr200 = 0x02 - ((value94 / sharedExpr196) * (sharedExpr198 * sharedExpr199)); uint256 sharedExpr201 = sharedExpr198 * sharedExpr199; uint256 sharedExpr202 = 0x02 - ((value94 / sharedExpr196) * (sharedExpr200 * sharedExpr201)); uint256 sharedExpr203 = sharedExpr200 * sharedExpr201; uint256 sharedExpr204 = 0x02 - ((value94 / sharedExpr196) * (sharedExpr202 * sharedExpr203)); uint256 sharedExpr205 = sharedExpr202 * sharedExpr203; uint256 sharedExpr206 = 0x02 - ((value94 / sharedExpr196) * (sharedExpr204 * sharedExpr205)); uint256 sharedExpr207 = sharedExpr204 * sharedExpr205; uint256 sharedExpr208 = ((0x0100000000000000000000000000000000 * value2) - ((0x0100000000000000000000000000000000 * value2) % value94) / (value94 & sharedExpr195) | (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)) - (((0x0100000000000000000000000000000000 * value2) % value94) > (0x0100000000000000000000000000000000 * value2)) * (0x01 + ((0 - (value94 & sharedExpr195)) / (value94 & sharedExpr195))))) * ((sharedExpr206 * sharedExpr207) * (0x02 - ((sharedExpr206 * sharedExpr207) * (value94 / sharedExpr196)))); uint256 value95 = sharedExpr208; if (0 != (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)))) { require(value94 > (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2))), "Math: mulDiv overflow"); uint256 sharedExpr209 = 0x01 + ~(value94); uint256 sharedExpr210 = value94 & sharedExpr209; uint256 sharedExpr211 = (value94 / sharedExpr210) * 0x03; uint256 sharedExpr212 = 0x02 - ((value94 / sharedExpr210) * (0x02 ^ sharedExpr211)); uint256 sharedExpr213 = 0x02 ^ sharedExpr211; uint256 sharedExpr214 = 0x02 - ((value94 / sharedExpr210) * (sharedExpr212 * sharedExpr213)); uint256 sharedExpr215 = sharedExpr212 * sharedExpr213; uint256 sharedExpr216 = 0x02 - ((value94 / sharedExpr210) * (sharedExpr214 * sharedExpr215)); uint256 sharedExpr217 = sharedExpr214 * sharedExpr215; uint256 sharedExpr218 = 0x02 - ((value94 / sharedExpr210) * (sharedExpr216 * sharedExpr217)); uint256 sharedExpr219 = sharedExpr216 * sharedExpr217; uint256 sharedExpr220 = 0x02 - ((value94 / sharedExpr210) * (sharedExpr218 * sharedExpr219)); uint256 sharedExpr221 = sharedExpr218 * sharedExpr219; } else { value95 = (0x0100000000000000000000000000000000 * value2) / value94; } value100 = value95; value97 = value100; } else { uint256 value96; uint256 sharedExpr297 = var_b; uint256 sharedExpr298 = var_b + returnData6.length; uint256 sharedExpr299 = var_br; uint256 sharedExpr300 = sharedExpr299; uint256 sharedExpr301 = (bytes1(value92)) + (value93 >> 0x20); uint256 sharedExpr302 = sharedExpr301; uint256 sharedExpr303 = address(sharedExpr302); uint256 sharedExpr304 = address(sharedExpr302); uint256 sharedExpr305 = (address(bytes1(value92) + (value93 >> 0x20))) * (address(bytes1(value92) + (value93 >> 0x20))); uint256 sharedExpr306 = sharedExpr305; uint256 sharedExpr307 = 0x01 + ~(address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))); uint256 sharedExpr308 = (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))) & sharedExpr307; uint256 sharedExpr309 = (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr308) * 0x03; uint256 sharedExpr310 = 0x02 - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr308) * (0x02 ^ sharedExpr309)); uint256 sharedExpr311 = 0x02 ^ sharedExpr309; uint256 sharedExpr312 = 0x02 - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr308) * (sharedExpr310 * sharedExpr311)); uint256 sharedExpr313 = sharedExpr310 * sharedExpr311; uint256 sharedExpr314 = 0x02 - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr308) * (sharedExpr312 * sharedExpr313)); uint256 sharedExpr315 = sharedExpr312 * sharedExpr313; uint256 sharedExpr316 = 0x02 - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr308) * (sharedExpr314 * sharedExpr315)); uint256 sharedExpr317 = sharedExpr314 * sharedExpr315; uint256 sharedExpr318 = 0x02 - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr308) * (sharedExpr316 * sharedExpr317)); uint256 sharedExpr319 = sharedExpr316 * sharedExpr317; uint256 sharedExpr320 = ((0x01000000000000000000000000000000000000000000000000 * value2) - ((0x01000000000000000000000000000000000000000000000000 * value2) % (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))))) / (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) & sharedExpr307) | (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)) - ((0x01000000000000000000000000000000000000000000000000 * value2) % (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))) > (0x01000000000000000000000000000000000000000000000000 * value2)) * (0x01 + ((0 - (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) & sharedExpr307)) / (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) & sharedExpr307))))) * ((sharedExpr318 * sharedExpr319) * (0x02 - ((sharedExpr318 * sharedExpr319) * (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr308)))); uint256 value103 = sharedExpr320; if (0 != (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)))) { require(address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) > (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2))), "Math: mulDiv overflow"); uint256 sharedExpr321 = 0x01 + ~(address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))); uint256 sharedExpr322 = (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))) & sharedExpr321; uint256 sharedExpr323 = (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr322) * 0x03; uint256 sharedExpr324 = 0x02 - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr322) * (0x02 ^ sharedExpr323)); uint256 sharedExpr325 = 0x02 ^ sharedExpr323; uint256 sharedExpr326 = 0x02 - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr322) * (sharedExpr324 * sharedExpr325)); uint256 sharedExpr327 = sharedExpr324 * sharedExpr325; uint256 sharedExpr328 = 0x02 - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr322) * (sharedExpr326 * sharedExpr327)); uint256 sharedExpr329 = sharedExpr326 * sharedExpr327; uint256 sharedExpr330 = 0x02 - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr322) * (sharedExpr328 * sharedExpr329)); uint256 sharedExpr331 = sharedExpr328 * sharedExpr329; uint256 sharedExpr332 = 0x02 - ((address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20))) / sharedExpr322) * (sharedExpr330 * sharedExpr331)); uint256 sharedExpr333 = sharedExpr330 * sharedExpr331; } else { value103 = (0x01000000000000000000000000000000000000000000000000 * value2) / (address(bytes1(value92) + (value93 >> 0x20)) * (address(bytes1(value92) + (value93 >> 0x20)))); } value96 = value103; value97 = value96; } if (!(value97 < openPrice)) { return 0; } else { if ((((openPrice - value97) * 0x2710) / openPrice) < 0x0a) { return 0; } if ((((openPrice - value97) * 0x2710) / openPrice) >= 0x01f4) { return 0x32; } if ((((openPrice - value97) * 0x2710) / openPrice) < 0x64) { return 0x05; } else { return ((((openPrice - value97) * 0x2710) / openPrice) / 0x64) * 0x0a; } } } } else { if (!(0 < openPrice)) { return 0; } else { if ((((openPrice - 0) * 0x2710) / openPrice) < 0x0a) { return 0; } if ((((openPrice - 0) * 0x2710) / openPrice) >= 0x01f4) { return 0x32; } if ((((openPrice - 0) * 0x2710) / openPrice) < 0x64) { return 0x05; } else { return ((((openPrice - 0) * 0x2710) / openPrice) / 0x64) * 0x0a; } } } } function allotFee() public { internal_fd2(); } function mining() public { if ((block.timestamp / 0x015180) > lastDay) { lastDay = block.timestamp / 0x015180; uint256 accountBalance = IDesolexERC20(this).balanceOf(0x922fa121945ed6f6017d3ebfd39d9a3838db6452); if (accountBalance > 0x0de0b6b3a7640000) { uint256 value0 = (unresolved_b1e49a0c * accountBalance) / 0x0186a0; if ((accountBalance - ((unresolved_b1e49a0c * accountBalance) / 0x0186a0)) < 0x0de0b6b3a7640000) { value0 = accountBalance - 0x0de0b6b3a7640000; } require((0x922fa121945ed6f6017d3ebfd39d9a3838db6452 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: transfer from the zero address"); require((0x0e45327ee4c003180c9a64ab6f98681a7bd72eff & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: transfer to the zero address"); require(!(balanceOf[address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452)] < value0), "ERC20: transfer amount exceeds balance"); balanceOf[address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452)] = balanceOf[address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452)] - value0; balanceOf[address(0x0e45327ee4c003180c9a64ab6f98681a7bd72eff)] = value0 + balanceOf[address(0x0e45327ee4c003180c9a64ab6f98681a7bd72eff)]; emit Transfer(address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452), address(0x0e45327ee4c003180c9a64ab6f98681a7bd72eff), value0); require(address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).code.length != 0x0); (bool success1, bytes memory returnData1) = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).sync(); // call require(success1); emit Event_b9070ed8(accountBalance, value0); } } } function eip712Domain() public view returns (uint256) { uint256 value13 = var_a; require((0x51696c696e20546f6b656e00000000000000000000000000000000000000000b & 0xff) <= 0x1f, InvalidShortString()); var_a = 0x40 + var_a; value13 = var_a; uint256 value12 = var_a; require((0x3100000000000000000000000000000000000000000000000000000000000001 & 0xff) <= 0x1f, InvalidShortString()); var_a = 0x40 + var_a; value12 = var_a; var_a = var_a + 0x20; uint256 value14 = 0; while (true) { if (!(value14 < var_j)) { break; } value14 = 0x20 + value14; uint256 value14 = 0; while (true) { if (!(value14 < var_n)) { break; } value14 = 0x20 + value14; uint256 value15 = 0; uint256 value16 = 0x20 + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_n) + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_j) + (var_a + 0xe0))))); uint256 value17 = var_a + 0x20; while (true) { if (!(value15 < var_a.length)) { break; } value15 = 0x01 + value15; value16 = 0x20 + value16; value17 = 0x20 + value17; } return abi.encodePacked(0x0f00000000000000000000000000000000000000000000000000000000000000, 0xe0, (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_j) + (var_a + 0xe0))) - var_a, block.chainid, address(this), 0, (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_n) + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_j) + (var_a + 0xe0))))) - var_a, var_j, var_n, var_a.length); } } } function Unknown_8ce5c9b2(uint256 arg0) public { var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, ErrorCaller()); lastDayPrice = arg0 / 0x015180; } function Unknown_932fdf2f(uint256 arg0) public { var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, ErrorCaller()); require(!(arg0 > 0x7d0 || arg0 < 0x3e8), ErrorValue()); unresolved_b1e49a0c = (arg0) ? 1 : 0; } function symbol() public view returns (string memory) { return _symbol; } function setFeeRatio(uint256 arg0, uint256 arg1) public { var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, ErrorCaller()); require(!(arg0 > 0x186a0 || arg1 > 0x186a0), ErrorValue()); buyFee = (arg0) ? 1 : 0; sellFee = arg1; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { require(!(allowance[msg.sender][spender] < subtractedValue), "ERC20: decreased allowance below zero"); require(msg.sender != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); allowance[msg.sender][spender] = allowance[address(msg.sender)][spender] - subtractedValue; emit Approval(msg.sender, spender, allowance[msg.sender][spender]); return true; } function transfer(address to, uint256 amount) public view { } function Unknown_d505accf(address arg0, address arg1, uint256 arg2, uint256 arg3, bool arg4, uint256 arg5, uint256 arg6) public { require(arg4 == (arg4 & 0xff)); internal_12ac(arg6, arg5, arg4, arg3, arg2, arg1, arg0); } function revokeRole(bytes32 role, address account) public { internal_1410(account, role); } function setMinFeeAmount(uint256 newMinFeeAmount) public { var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, ErrorCaller()); minFeeAmount = newMinFeeAmount; } function getTokenUPrice() public returns (uint256) { (bool success0, bytes memory returnData0) = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).token0(); // staticcall require(success0); uint256 var_b; var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData0.length) - var_b) < 0x20)); require(var_b.length == (var_b.length & 0xffffffffffffffffffffffffffffffffffffffff)); (bool success1, bytes memory returnData1) = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).getReserves(); // staticcall require(success1); (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData1, (uint112, uint112, uint32)); bool flag0 = 0 == (uint112(var_i)); if (!(0 == (uint112(var_i)))) { flag0 = !(uint112(var_h)); } uint256 value2; if (!flag0) { uint256 value1 = (uint112(var_h) * 0x0de0b6b3a7640000) / (uint112(var_i)); if (address(this) == (0xffffffffffffffffffffffffffffffffffffffff & value0)) { } else { value1 = (uint112(var_i) * 0x0de0b6b3a7640000) / (uint112(var_h)); } value2 = value1; } else { value2 = 0; } if (0x0 == value2) { return 0; } (bool success2, bytes memory returnData2) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).slot0(); // staticcall require(success2); var_b = var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData2.length) - var_b >= 0xe0); require(var_k == (var_k & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_l == (int24(var_l))); require(var_m == (uint16(var_m))); require(var_n == (uint16(var_n))); require(var_o == (uint16(var_o))); require(var_p == (uint32(var_p))); require(var_q == (var_q != 0x0)); (bool success3, bytes memory returnData3) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).observations(uint16(var_g + (0x01) % var_v)); // staticcall require(success3); var_b = var_b + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData3.length) - var_b >= 0x80); require(var_y == (uint32(var_y))); require(var_z == int56(var_z)); require(var_aa == (var_aa & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_ab == (var_ab != 0x0)); uint256 value17 = var_i; if (!(var_v)) { (bool success4, bytes memory returnData4) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).observations(0); // staticcall require(success4); var_b = var_b + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData4.length) - var_b >= 0x80); require(var_y == (uint32(var_y))); require(var_z == int56(var_z)); require(var_ag == (var_ag & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_ah == (var_ah != 0x0)); value17 = var_i; } uint256 value18 = block.timestamp - value17; if (!(uint32(block.timestamp - value17) < 0x0384)) { value18 = 0x0384; } if (0x0 != (0xffffffff & value18)) { var_b = var_b + 0x60; var_ak = msg.data[4:68]; if (!(0 < var_b.length)) _desolexPanic(50); if (!(0x01 < var_b.length)) _desolexPanic(50); uint256 value19 = 0; uint256 value20 = var_b.length; uint256 value21 = (0x04 + var_b) + 0x40; uint256 value22 = 0x20 + var_b; uint256 value23 = 0x20; uint256 value24 = 0; uint256 value25 = 0x04 + var_b; uint256 value26 = var_b; while (true) { if (value19 >= value20) { break; } value19 = 0x01 + value19; value20 = value20; value21 = value23 + value21; value22 = value23 + value22; value23 = value23; value24 = value24; value25 = value25; value26 = value26; } (bool success5, bytes memory returnData5) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).observe(0x20); // staticcall require(success5); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData5.length + 0x1f)); require(!(((var_b + returnData5.length) - var_b) < 0x40)); require(!(var_b.length > 0xffffffffffffffff)); require(((var_b + var_b.length) + 0x1f) < (var_b + returnData5.length)); if (!(var_as <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_as << 0x05)) + 0x1f))) < var_b) | ((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_as << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_as << 0x05)) + 0x1f)); require(!((0x20 + ((var_b + var_b.length) + (var_au << 0x05))) > (var_b + returnData5.length))); uint256 value28 = var_b + 0x20; uint256 value27 = 0x20 + (var_b + var_b.length); while (true) { if (!(value27 < (0x20 + ((var_b + var_b.length) + (var_au << 0x05))))) { break; } require(var_av == int56(var_av)); value28 = 0x20 + value28; value27 = 0x20 + value27; } require(!(var_ak > 0xffffffffffffffff)); require((var_b + var_h) + 0x1f < (var_b + returnData5.length)); if (!(var_ay <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ay << 0x05)) + 0x1f))) < var_b) | ((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ay << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_ay << 0x05)) + 0x1f)); require(!((0x20 + ((var_b + var_h) + (var_ay << 0x05))) > (var_b + returnData5.length))); uint256 value29 = (var_b + var_h) + 0x20; uint256 value31 = var_b; uint256 value32 = var_b + 0x20; uint256 value33 = 0x20; uint256 value30 = 0x20 + ((var_b + var_h) + (var_ay << 0x05)); uint256 value34 = 0; uint256 value35 = var_b + var_h; uint256 value36 = var_b + returnData5.length; while (true) { if (value29 >= value30) { break; } require(var_az == (var_az & 0xffffffffffffffffffffffffffffffffffffffff)); if ((value33 + value29) >= value30) { break; } require(var_bb == (var_bb & 0xffffffffffffffffffffffffffffffffffffffff)); value29 = value33 + (value33 + value29); value31 = value31; value32 = value33 + (value33 + value32); value33 = value33; value30 = value30; value34 = value34; value35 = value35; value36 = value36; if (!(0 < var_bd)) _desolexPanic(50); if (!(0x01 < var_bd)) _desolexPanic(50); if (int56(var_be - var_bf) < 0) { } if (!(int56(var_be - var_bf) < 0)) { uint256 value37 = 0 - int24(int56(var_be - var_bf) / (int56(uint32(value18)))); if (int24(int56(var_be - var_bf) / (int56(uint32(value18)))) < 0) { } else { value37 = int24(int56(var_be - var_bf) / (int56(uint32(value18)))); } require(value37 <= 0xd89e8, CustomError_00000000()); uint256 value38 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value37)) { value38 = 0x0100000000000000000000000000000000; } uint256 value39 = address(value38); if ((value37 & 0x2) != 0x0) { value39 = (address(value38) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value40 = value39; if ((value37 & 0x4) != 0x0) { value40 = (value39 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value41 = value40; if ((value37 & 0x8) != 0x0) { value41 = (value40 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } uint256 value42 = value41; if ((value37 & 0x10) != 0x0) { value42 = (value41 * 0xffcb9843d60f6159c9db58835c926644) >> 0x80; } uint256 value43 = value42; if ((value37 & 0x20) != 0x0) { value43 = (value42 * 0xff973b41fa98c081472e6896dfb254c0) >> 0x80; } uint256 value44 = value43; if ((value37 & 0x40) != 0x0) { value44 = (value43 * 0xff2ea16466c96a3843ec78b326b52861) >> 0x80; } uint256 value45 = value44; if ((value37 & 0x80) != 0x0) { value45 = (value44 * 0xfe5dee046a99a2a811c461f1969c3053) >> 0x80; } uint256 value46 = value45; if ((value37 & 0x100) != 0x0) { value46 = (value45 * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 0x80; } uint256 value47 = value46; if ((value37 & 0x200) != 0x0) { value47 = (value46 * 0xf987a7253ac413176f2b074cf7815e54) >> 0x80; } uint256 value48 = value47; if ((value37 & 0x400) != 0x0) { value48 = (value47 * 0xf3392b0822b70005940c7a398e4b70f3) >> 0x80; } uint256 value49 = value48; if ((value37 & 0x800) != 0x0) { value49 = (value48 * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 0x80; } uint256 value50 = value49; if ((value37 & 0x1000) != 0x0) { value50 = (value49 * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 0x80; } uint256 value51 = value50; if ((value37 & 0x2000) != 0x0) { value51 = (value50 * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 0x80; } uint256 value52 = value51; if ((value37 & 0x4000) != 0x0) { value52 = (value51 * 0x70d869a156d2a1b890bb3df62baf32f7) >> 0x80; } uint256 value53 = value52; if ((value37 & 0x8000) != 0x0) { value53 = (value52 * 0x31be135f97d08fd981231505542fcfa6) >> 0x80; } uint256 value54 = value53; if ((value37 & 0x10000) != 0x0) { value54 = (value53 * 0x09aa508b5b7a84e1c677de54f3e99bc9) >> 0x80; } uint256 value55 = value54; if ((value37 & 0x20000) != 0x0) { value55 = (value54 * 0x5d6af8dedb81196699c329225ee604) >> 0x80; } } else { uint256 value56 = 0 - int24(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (int24(int56(int56(var_be) - (int56(var_bf))) / (int56(uint32(value18)))))); if (int24(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (int24(int56(int56(var_be) - (int56(var_bf))) / (int56(uint32(value18)))))) < 0) { } else { value56 = int24(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (int24(int56(int56(var_be) - (int56(var_bf))) / (int56(uint32(value18)))))); } require(value56 <= 0xd89e8, CustomError_00000000()); uint256 value57 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value56)) { value57 = 0x0100000000000000000000000000000000; } uint256 value58 = address(value57); if ((value56 & 0x2) != 0x0) { value58 = (address(value57) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value59 = value58; if ((value56 & 0x4) != 0x0) { value59 = (value58 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value60 = value59; if ((value56 & 0x8) != 0x0) { value60 = (value59 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } uint256 value61 = value60; if ((value56 & 0x10) != 0x0) { value61 = (value60 * 0xffcb9843d60f6159c9db58835c926644) >> 0x80; } uint256 value62 = value61; if ((value56 & 0x20) != 0x0) { value62 = (value61 * 0xff973b41fa98c081472e6896dfb254c0) >> 0x80; } uint256 value63 = value62; if ((value56 & 0x40) != 0x0) { value63 = (value62 * 0xff2ea16466c96a3843ec78b326b52861) >> 0x80; } uint256 value64 = value63; if ((value56 & 0x80) != 0x0) { value64 = (value63 * 0xfe5dee046a99a2a811c461f1969c3053) >> 0x80; } uint256 value65 = value64; if ((value56 & 0x100) != 0x0) { value65 = (value64 * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 0x80; } uint256 value66 = value65; if ((value56 & 0x200) != 0x0) { value66 = (value65 * 0xf987a7253ac413176f2b074cf7815e54) >> 0x80; } uint256 value67 = value66; if ((value56 & 0x400) != 0x0) { value67 = (value66 * 0xf3392b0822b70005940c7a398e4b70f3) >> 0x80; } uint256 value68 = value67; if ((value56 & 0x800) != 0x0) { value68 = (value67 * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 0x80; } uint256 value69 = value68; if ((value56 & 0x1000) != 0x0) { value69 = (value68 * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 0x80; } uint256 value70 = value69; if ((value56 & 0x2000) != 0x0) { value70 = (value69 * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 0x80; } uint256 value71 = value70; if ((value56 & 0x4000) != 0x0) { value71 = (value70 * 0x70d869a156d2a1b890bb3df62baf32f7) >> 0x80; } uint256 value72 = value71; if ((value56 & 0x8000) != 0x0) { value72 = (value71 * 0x31be135f97d08fd981231505542fcfa6) >> 0x80; } uint256 value73 = value72; if ((value56 & 0x10000) != 0x0) { value73 = (value72 * 0x09aa508b5b7a84e1c677de54f3e99bc9) >> 0x80; } uint256 value74 = value73; if ((value56 & 0x20000) != 0x0) { value74 = (value73 * 0x5d6af8dedb81196699c329225ee604) >> 0x80; } uint256 value75 = value74; if ((value56 & 0x40000) != 0x0) { value75 = (value74 * 0x2216e584f5fa1ea926041bedfe98) >> 0x80; } uint256 value76 = value75; if ((value56 & 0x80000) != 0x0) { value76 = (value75 * 0x048a170391f7dc42444e8fa2) >> 0x80; } uint256 value77 = value76 % 0x0100000000; uint256 value79 = value76; if (!(int24(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (int24(int56(int56(var_be) - (int56(var_bf))) / (int56(uint32(value18)))))) > 0)) { } else { value77 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value76) % 0x0100000000; value79 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value76; } uint256 value78 = 0; if (value77 != 0x0) { value78 = 0x01; } uint256 value80; if (address(bytes1(value78) + (value79 >> 0x20)) > 0xffffffffffffffffffffffffffffffff) { uint256 sharedExpr0 = (bytes1(value78)) + (value79 >> 0x20); uint256 sharedExpr1 = address(sharedExpr0); uint256 sharedExpr2 = address(sharedExpr0); uint256 sharedExpr3 = address(sharedExpr0); uint256 sharedExpr4 = address(sharedExpr0); uint256 sharedExpr5 = address(sharedExpr0); uint256 sharedExpr6 = address(sharedExpr0); uint256 sharedExpr7 = (0x010000000000000000) & (0x01 + ~(0x010000000000000000)); uint256 sharedExpr8 = (0x010000000000000000 / sharedExpr7) * 0x03; uint256 sharedExpr9 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (0x02 ^ sharedExpr8)); uint256 sharedExpr10 = 0x02 ^ sharedExpr8; uint256 sharedExpr11 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr9 * sharedExpr10)); uint256 sharedExpr12 = sharedExpr9 * sharedExpr10; uint256 sharedExpr13 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr11 * sharedExpr12)); uint256 sharedExpr14 = sharedExpr11 * sharedExpr12; uint256 sharedExpr15 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr13 * sharedExpr14)); uint256 sharedExpr16 = sharedExpr13 * sharedExpr14; uint256 sharedExpr17 = 0x02 - ((0x010000000000000000 / sharedExpr7) * (sharedExpr15 * sharedExpr16)); uint256 sharedExpr18 = sharedExpr15 * sharedExpr16; value80 = ((sharedExpr1 * sharedExpr2) - ((sharedExpr3 * sharedExpr4) % 0x010000000000000000) / (0x010000000000000000 & (0x01 + ~(0x010000000000000000))) | (((sharedExpr5 * sharedExpr6) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (sharedExpr1 * sharedExpr2) - (((sharedExpr5 * sharedExpr6) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (sharedExpr1 * sharedExpr2)) - (((sharedExpr3 * sharedExpr4) % 0x010000000000000000) > (sharedExpr1 * sharedExpr2)) * (0x01 + ((0 - (0x010000000000000000 & (0x01 + ~(0x010000000000000000)))) / (0x010000000000000000 & (0x01 + ~(0x010000000000000000))))))) * ((sharedExpr17 * sharedExpr18) * (0x02 - ((sharedExpr17 * sharedExpr18) * (0x010000000000000000 / sharedExpr7)))); if (0 != ((address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20)))) - ((address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))))))) { require(0x010000000000000000 > ((address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20)))) - ((address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20)))))), CustomError_00000000()); uint256 sharedExpr19 = 0x01 + ~(0x010000000000000000); uint256 sharedExpr20 = (0x010000000000000000) & sharedExpr19; uint256 sharedExpr21 = (0x010000000000000000 / sharedExpr20) * 0x03; uint256 sharedExpr22 = 0x02 - ((0x010000000000000000 / sharedExpr20) * (0x02 ^ sharedExpr21)); uint256 sharedExpr23 = 0x02 ^ sharedExpr21; uint256 sharedExpr24 = 0x02 - ((0x010000000000000000 / sharedExpr20) * (sharedExpr22 * sharedExpr23)); uint256 sharedExpr25 = sharedExpr22 * sharedExpr23; uint256 sharedExpr26 = 0x02 - ((0x010000000000000000 / sharedExpr20) * (sharedExpr24 * sharedExpr25)); uint256 sharedExpr27 = sharedExpr24 * sharedExpr25; uint256 sharedExpr28 = 0x02 - ((0x010000000000000000 / sharedExpr20) * (sharedExpr26 * sharedExpr27)); uint256 sharedExpr29 = sharedExpr26 * sharedExpr27; uint256 sharedExpr30 = 0x02 - ((0x010000000000000000 / sharedExpr20) * (sharedExpr28 * sharedExpr29)); uint256 sharedExpr31 = sharedExpr28 * sharedExpr29; } else { value80 = (address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20)))) / 0x010000000000000000; } uint256 sharedExpr51 = 0x01 + ~(value80); uint256 sharedExpr52 = value80 & sharedExpr51; uint256 sharedExpr53 = (value80 / sharedExpr52) * 0x03; uint256 sharedExpr54 = 0x02 - ((value80 / sharedExpr52) * (0x02 ^ sharedExpr53)); uint256 sharedExpr55 = 0x02 ^ sharedExpr53; uint256 sharedExpr56 = 0x02 - ((value80 / sharedExpr52) * (sharedExpr54 * sharedExpr55)); uint256 sharedExpr57 = sharedExpr54 * sharedExpr55; uint256 sharedExpr58 = 0x02 - ((value80 / sharedExpr52) * (sharedExpr56 * sharedExpr57)); uint256 sharedExpr59 = sharedExpr56 * sharedExpr57; uint256 sharedExpr60 = 0x02 - ((value80 / sharedExpr52) * (sharedExpr58 * sharedExpr59)); uint256 sharedExpr61 = sharedExpr58 * sharedExpr59; uint256 sharedExpr62 = 0x02 - ((value80 / sharedExpr52) * (sharedExpr60 * sharedExpr61)); uint256 sharedExpr63 = sharedExpr60 * sharedExpr61; uint256 value81 = ((0x0100000000000000000000000000000000 * value2) - ((0x0100000000000000000000000000000000 * value2) % value80) / (value80 & sharedExpr51) | (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)) - (((0x0100000000000000000000000000000000 * value2) % value80) > (0x0100000000000000000000000000000000 * value2)) * (0x01 + ((0 - (value80 & sharedExpr51)) / (value80 & sharedExpr51))))) * ((sharedExpr62 * sharedExpr63) * (0x02 - ((sharedExpr62 * sharedExpr63) * (value80 / sharedExpr52)))); if (0 != (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)))) { require(value80 > (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2))), CustomError_00000000()); uint256 sharedExpr64 = 0x01 + ~(value80); uint256 sharedExpr65 = value80 & sharedExpr64; uint256 sharedExpr66 = (value80 / sharedExpr65) * 0x03; uint256 sharedExpr67 = 0x02 - ((value80 / sharedExpr65) * (0x02 ^ sharedExpr66)); uint256 sharedExpr68 = 0x02 ^ sharedExpr66; uint256 sharedExpr69 = 0x02 - ((value80 / sharedExpr65) * (sharedExpr67 * sharedExpr68)); uint256 sharedExpr70 = sharedExpr67 * sharedExpr68; uint256 sharedExpr71 = 0x02 - ((value80 / sharedExpr65) * (sharedExpr69 * sharedExpr70)); uint256 sharedExpr72 = sharedExpr69 * sharedExpr70; uint256 sharedExpr73 = 0x02 - ((value80 / sharedExpr65) * (sharedExpr71 * sharedExpr72)); uint256 sharedExpr74 = sharedExpr71 * sharedExpr72; uint256 sharedExpr75 = 0x02 - ((value80 / sharedExpr65) * (sharedExpr73 * sharedExpr74)); uint256 sharedExpr76 = sharedExpr73 * sharedExpr74; } else { value81 = (0x0100000000000000000000000000000000 * value2) / value80; } } else { uint256 value82; uint256 sharedExpr139 = (bytes1(value78)) + (value79 >> 0x20); uint256 sharedExpr140 = address(sharedExpr139); uint256 sharedExpr141 = address(sharedExpr139); uint256 sharedExpr142 = sharedExpr140 * sharedExpr141; uint256 sharedExpr143 = sharedExpr140 * sharedExpr141; uint256 sharedExpr144 = 0x01 + (~(sharedExpr140 * sharedExpr141)); uint256 sharedExpr145 = sharedExpr140 * sharedExpr141; uint256 sharedExpr146 = sharedExpr143 & sharedExpr144; uint256 sharedExpr147 = (sharedExpr145 / sharedExpr146) * 0x03; uint256 sharedExpr148 = 0x02 - ((sharedExpr145 / sharedExpr146) * (0x02 ^ sharedExpr147)); uint256 sharedExpr149 = 0x02 ^ sharedExpr147; uint256 sharedExpr150 = 0x02 - ((sharedExpr145 / sharedExpr146) * (sharedExpr148 * sharedExpr149)); uint256 sharedExpr151 = sharedExpr148 * sharedExpr149; uint256 sharedExpr152 = 0x02 - ((sharedExpr145 / sharedExpr146) * (sharedExpr150 * sharedExpr151)); uint256 sharedExpr153 = sharedExpr150 * sharedExpr151; uint256 sharedExpr154 = 0x02 - ((sharedExpr145 / sharedExpr146) * (sharedExpr152 * sharedExpr153)); uint256 sharedExpr155 = sharedExpr152 * sharedExpr153; uint256 sharedExpr156 = 0x02 - ((sharedExpr145 / sharedExpr146) * (sharedExpr154 * sharedExpr155)); uint256 sharedExpr157 = sharedExpr154 * sharedExpr155; uint256 value112 = ((0x01000000000000000000000000000000000000000000000000 * value2) - ((0x01000000000000000000000000000000000000000000000000 * value2) % sharedExpr142) / (sharedExpr143 & sharedExpr144) | (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)) - (((0x01000000000000000000000000000000000000000000000000 * value2) % sharedExpr142) > (0x01000000000000000000000000000000000000000000000000 * value2)) * (0x01 + ((0 - (sharedExpr143 & sharedExpr144)) / (sharedExpr143 & sharedExpr144))))) * ((sharedExpr156 * sharedExpr157) * (0x02 - ((sharedExpr156 * sharedExpr157) * (sharedExpr145 / sharedExpr146)))); if (0 != (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)))) { require(address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) > (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2))), CustomError_00000000()); uint256 sharedExpr158 = 0x01 + ~(address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20)))); uint256 sharedExpr159 = (address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20)))) & sharedExpr158; uint256 sharedExpr160 = (address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) / sharedExpr159) * 0x03; uint256 sharedExpr161 = 0x02 - ((address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) / sharedExpr159) * (0x02 ^ sharedExpr160)); uint256 sharedExpr162 = 0x02 ^ sharedExpr160; uint256 sharedExpr163 = 0x02 - ((address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) / sharedExpr159) * (sharedExpr161 * sharedExpr162)); uint256 sharedExpr164 = sharedExpr161 * sharedExpr162; uint256 sharedExpr165 = 0x02 - ((address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) / sharedExpr159) * (sharedExpr163 * sharedExpr164)); uint256 sharedExpr166 = sharedExpr163 * sharedExpr164; uint256 sharedExpr167 = 0x02 - ((address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) / sharedExpr159) * (sharedExpr165 * sharedExpr166)); uint256 sharedExpr168 = sharedExpr165 * sharedExpr166; uint256 sharedExpr169 = 0x02 - ((address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20))) / sharedExpr159) * (sharedExpr167 * sharedExpr168)); uint256 sharedExpr170 = sharedExpr167 * sharedExpr168; } else { value112 = (0x01000000000000000000000000000000000000000000000000 * value2) / (address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20)))); } value82 = value112; } return ; } } } else { (bool success6, bytes memory returnData6) = address(0xca3f029a70d5d90000e614afd29e5c833f33cea5).slot0(); // staticcall require(success6); var_b = var_b + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData6.length) - var_b) < 0xe0)); require(var_b.length == (var_b.length & 0xffffffffffffffffffffffffffffffffffffffff)); require(var_ak == (int24(var_ak))); require(var_m == (uint16(var_m))); require(var_n == (uint16(var_n))); require(var_o == (uint16(var_o))); require(var_p == (uint32(var_p))); require(var_bh == (var_bh != 0x0)); uint256 value83 = 0 - int24(var_ak); if (int24(var_ak) < 0) { } else { value83 = int24(var_ak); } require(value83 <= 0xd89e8, "T"); uint256 value84 = 0xfffcb933bd6fad37aa2d162d1a594001; if (0x0 == (0x1 & value83)) { value84 = 0x0100000000000000000000000000000000; } uint256 value85 = address(value84); if ((value83 & 0x2) != 0x0) { value85 = (address(value84) * 0xfff97272373d413259a46990580e213a) >> 0x80; } uint256 value86 = value85; if ((value83 & 0x4) != 0x0) { value86 = (value85 * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 0x80; } uint256 value87 = value86; if ((value83 & 0x8) != 0x0) { value87 = (value86 * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 0x80; } uint256 value88 = value87; if ((value83 & 0x10) != 0x0) { value88 = (value87 * 0xffcb9843d60f6159c9db58835c926644) >> 0x80; } uint256 value89 = value88; if ((value83 & 0x20) != 0x0) { value89 = (value88 * 0xff973b41fa98c081472e6896dfb254c0) >> 0x80; } uint256 value90 = value89; if ((value83 & 0x40) != 0x0) { value90 = (value89 * 0xff2ea16466c96a3843ec78b326b52861) >> 0x80; } uint256 value91 = value90; if ((value83 & 0x80) != 0x0) { value91 = (value90 * 0xfe5dee046a99a2a811c461f1969c3053) >> 0x80; } uint256 value92 = value91; if ((value83 & 0x100) != 0x0) { value92 = (value91 * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 0x80; } uint256 value93 = value92; if ((value83 & 0x200) != 0x0) { value93 = (value92 * 0xf987a7253ac413176f2b074cf7815e54) >> 0x80; } uint256 value94 = value93; if ((value83 & 0x400) != 0x0) { value94 = (value93 * 0xf3392b0822b70005940c7a398e4b70f3) >> 0x80; } uint256 value95 = value94; if ((value83 & 0x800) != 0x0) { value95 = (value94 * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 0x80; } uint256 value96 = value95; if ((value83 & 0x1000) != 0x0) { value96 = (value95 * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 0x80; } uint256 value97 = value96; if ((value83 & 0x2000) != 0x0) { value97 = (value96 * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 0x80; } uint256 value98 = value97; if ((value83 & 0x4000) != 0x0) { value98 = (value97 * 0x70d869a156d2a1b890bb3df62baf32f7) >> 0x80; } uint256 value99 = value98; if ((value83 & 0x8000) != 0x0) { value99 = (value98 * 0x31be135f97d08fd981231505542fcfa6) >> 0x80; } uint256 value100 = value99; if ((value83 & 0x10000) != 0x0) { value100 = (value99 * 0x09aa508b5b7a84e1c677de54f3e99bc9) >> 0x80; } uint256 value101 = value100; if ((value83 & 0x20000) != 0x0) { value101 = (value100 * 0x5d6af8dedb81196699c329225ee604) >> 0x80; } uint256 value102 = value101; if ((value83 & 0x40000) != 0x0) { value102 = (value101 * 0x2216e584f5fa1ea926041bedfe98) >> 0x80; } uint256 value103 = value102; if ((value83 & 0x80000) != 0x0) { value103 = (value102 * 0x048a170391f7dc42444e8fa2) >> 0x80; } uint256 value104 = value103 % 0x0100000000; uint256 value106 = value103; if (!(int24(var_ak) > 0)) { } else { value104 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value103) % 0x0100000000; value106 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / value103; } uint256 value105 = 0; if (value104 != 0x0) { value105 = 0x01; } uint256 value110; if (address(bytes1(value105) + (value106 >> 0x20)) > 0xffffffffffffffffffffffffffffffff) { uint256 sharedExpr190 = 0x01 + ~(0x010000000000000000); uint256 sharedExpr191 = (0x010000000000000000) & sharedExpr190; uint256 sharedExpr192 = (0x010000000000000000 / sharedExpr191) * 0x03; uint256 sharedExpr193 = 0x02 - ((0x010000000000000000 / sharedExpr191) * (0x02 ^ sharedExpr192)); uint256 sharedExpr194 = 0x02 ^ sharedExpr192; uint256 sharedExpr195 = 0x02 - ((0x010000000000000000 / sharedExpr191) * (sharedExpr193 * sharedExpr194)); uint256 sharedExpr196 = sharedExpr193 * sharedExpr194; uint256 sharedExpr197 = 0x02 - ((0x010000000000000000 / sharedExpr191) * (sharedExpr195 * sharedExpr196)); uint256 sharedExpr198 = sharedExpr195 * sharedExpr196; uint256 sharedExpr199 = 0x02 - ((0x010000000000000000 / sharedExpr191) * (sharedExpr197 * sharedExpr198)); uint256 sharedExpr200 = sharedExpr197 * sharedExpr198; uint256 sharedExpr201 = 0x02 - ((0x010000000000000000 / sharedExpr191) * (sharedExpr199 * sharedExpr200)); uint256 sharedExpr202 = sharedExpr199 * sharedExpr200; uint256 value107 = (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) - (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) % 0x010000000000000000) / (0x010000000000000000 & sharedExpr190) | ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20)))) - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))))) - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) % 0x010000000000000000) > (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))))) * (0x01 + ((0 - (0x010000000000000000 & sharedExpr190)) / (0x010000000000000000 & sharedExpr190))))) * ((sharedExpr201 * sharedExpr202) * (0x02 - ((sharedExpr201 * sharedExpr202) * (0x010000000000000000 / sharedExpr191)))); if (0 != ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20)))) - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))))))) { require(0x010000000000000000 > ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20)))) - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20)))))), "Math: mulDiv overflow"); uint256 sharedExpr203 = 0x01 + ~(0x010000000000000000); uint256 sharedExpr204 = (0x010000000000000000) & sharedExpr203; uint256 sharedExpr205 = (0x010000000000000000 / sharedExpr204) * 0x03; uint256 sharedExpr206 = 0x02 - ((0x010000000000000000 / sharedExpr204) * (0x02 ^ sharedExpr205)); uint256 sharedExpr207 = 0x02 ^ sharedExpr205; uint256 sharedExpr208 = 0x02 - ((0x010000000000000000 / sharedExpr204) * (sharedExpr206 * sharedExpr207)); uint256 sharedExpr209 = sharedExpr206 * sharedExpr207; uint256 sharedExpr210 = 0x02 - ((0x010000000000000000 / sharedExpr204) * (sharedExpr208 * sharedExpr209)); uint256 sharedExpr211 = sharedExpr208 * sharedExpr209; uint256 sharedExpr212 = 0x02 - ((0x010000000000000000 / sharedExpr204) * (sharedExpr210 * sharedExpr211)); uint256 sharedExpr213 = sharedExpr210 * sharedExpr211; uint256 sharedExpr214 = 0x02 - ((0x010000000000000000 / sharedExpr204) * (sharedExpr212 * sharedExpr213)); uint256 sharedExpr215 = sharedExpr212 * sharedExpr213; } else { value107 = (address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20)))) / 0x010000000000000000; } uint256 value113; uint256 sharedExpr229 = 0x01 + ~(value107); uint256 sharedExpr230 = value107 & sharedExpr229; uint256 sharedExpr231 = (value107 / sharedExpr230) * 0x03; uint256 sharedExpr232 = 0x02 - ((value107 / sharedExpr230) * (0x02 ^ sharedExpr231)); uint256 sharedExpr233 = 0x02 ^ sharedExpr231; uint256 sharedExpr234 = 0x02 - ((value107 / sharedExpr230) * (sharedExpr232 * sharedExpr233)); uint256 sharedExpr235 = sharedExpr232 * sharedExpr233; uint256 sharedExpr236 = 0x02 - ((value107 / sharedExpr230) * (sharedExpr234 * sharedExpr235)); uint256 sharedExpr237 = sharedExpr234 * sharedExpr235; uint256 sharedExpr238 = 0x02 - ((value107 / sharedExpr230) * (sharedExpr236 * sharedExpr237)); uint256 sharedExpr239 = sharedExpr236 * sharedExpr237; uint256 sharedExpr240 = 0x02 - ((value107 / sharedExpr230) * (sharedExpr238 * sharedExpr239)); uint256 sharedExpr241 = sharedExpr238 * sharedExpr239; uint256 value108 = ((0x0100000000000000000000000000000000 * value2) - ((0x0100000000000000000000000000000000 * value2) % value107) / (value107 & sharedExpr229) | (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)) - (((0x0100000000000000000000000000000000 * value2) % value107) > (0x0100000000000000000000000000000000 * value2)) * (0x01 + ((0 - (value107 & sharedExpr229)) / (value107 & sharedExpr229))))) * ((sharedExpr240 * sharedExpr241) * (0x02 - ((sharedExpr240 * sharedExpr241) * (value107 / sharedExpr230)))); if (0 != (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2)))) { require(value107 > (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x0100000000000000000000000000000000 * value2) - (((0x0100000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x0100000000000000000000000000000000 * value2))), "Math: mulDiv overflow"); uint256 sharedExpr242 = 0x01 + ~(value107); uint256 sharedExpr243 = value107 & sharedExpr242; uint256 sharedExpr244 = (value107 / sharedExpr243) * 0x03; uint256 sharedExpr245 = 0x02 - ((value107 / sharedExpr243) * (0x02 ^ sharedExpr244)); uint256 sharedExpr246 = 0x02 ^ sharedExpr244; uint256 sharedExpr247 = 0x02 - ((value107 / sharedExpr243) * (sharedExpr245 * sharedExpr246)); uint256 sharedExpr248 = sharedExpr245 * sharedExpr246; uint256 sharedExpr249 = 0x02 - ((value107 / sharedExpr243) * (sharedExpr247 * sharedExpr248)); uint256 sharedExpr250 = sharedExpr247 * sharedExpr248; uint256 sharedExpr251 = 0x02 - ((value107 / sharedExpr243) * (sharedExpr249 * sharedExpr250)); uint256 sharedExpr252 = sharedExpr249 * sharedExpr250; uint256 sharedExpr253 = 0x02 - ((value107 / sharedExpr243) * (sharedExpr251 * sharedExpr252)); uint256 sharedExpr254 = sharedExpr251 * sharedExpr252; } else { value108 = (0x0100000000000000000000000000000000 * value2) / value80; } value113 = value108; value110 = value113; } else { uint256 value109; uint256 sharedExpr307 = 0x01 + ~(address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20)))); uint256 sharedExpr308 = (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20)))) & sharedExpr307; uint256 sharedExpr309 = (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr308) * 0x03; uint256 sharedExpr310 = 0x02 - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr308) * (0x02 ^ sharedExpr309)); uint256 sharedExpr311 = 0x02 ^ sharedExpr309; uint256 sharedExpr312 = 0x02 - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr308) * (sharedExpr310 * sharedExpr311)); uint256 sharedExpr313 = sharedExpr310 * sharedExpr311; uint256 sharedExpr314 = 0x02 - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr308) * (sharedExpr312 * sharedExpr313)); uint256 sharedExpr315 = sharedExpr312 * sharedExpr313; uint256 sharedExpr316 = 0x02 - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr308) * (sharedExpr314 * sharedExpr315)); uint256 sharedExpr317 = sharedExpr314 * sharedExpr315; uint256 sharedExpr318 = 0x02 - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr308) * (sharedExpr316 * sharedExpr317)); uint256 sharedExpr319 = sharedExpr316 * sharedExpr317; uint256 value116 = ((0x01000000000000000000000000000000000000000000000000 * value2) - ((0x01000000000000000000000000000000000000000000000000 * value2) % (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))))) / (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) & sharedExpr307) | (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)) - ((0x01000000000000000000000000000000000000000000000000 * value2) % (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20)))) > (0x01000000000000000000000000000000000000000000000000 * value2)) * (0x01 + ((0 - (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) & sharedExpr307)) / (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) & sharedExpr307))))) * ((sharedExpr318 * sharedExpr319) * (0x02 - ((sharedExpr318 * sharedExpr319) * (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr308)))); if (0 != (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2)))) { require(address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) > (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x01000000000000000000000000000000000000000000000000 * value2) - (((0x01000000000000000000000000000000000000000000000000 * value2) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x01000000000000000000000000000000000000000000000000 * value2))), "Math: mulDiv overflow"); uint256 sharedExpr320 = 0x01 + ~(address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20)))); uint256 sharedExpr321 = (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20)))) & sharedExpr320; uint256 sharedExpr322 = (address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr321) * 0x03; uint256 sharedExpr323 = 0x02 - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr321) * (0x02 ^ sharedExpr322)); uint256 sharedExpr324 = 0x02 ^ sharedExpr322; uint256 sharedExpr325 = 0x02 - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr321) * (sharedExpr323 * sharedExpr324)); uint256 sharedExpr326 = sharedExpr323 * sharedExpr324; uint256 sharedExpr327 = 0x02 - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr321) * (sharedExpr325 * sharedExpr326)); uint256 sharedExpr328 = sharedExpr325 * sharedExpr326; uint256 sharedExpr329 = 0x02 - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr321) * (sharedExpr327 * sharedExpr328)); uint256 sharedExpr330 = sharedExpr327 * sharedExpr328; uint256 sharedExpr331 = 0x02 - ((address(bytes1(value105) + (value106 >> 0x20)) * (address(bytes1(value105) + (value106 >> 0x20))) / sharedExpr321) * (sharedExpr329 * sharedExpr330)); uint256 sharedExpr332 = sharedExpr329 * sharedExpr330; } else { value116 = (0x01000000000000000000000000000000000000000000000000 * value2) / (address(bytes1(value78) + (value79 >> 0x20)) * (address(bytes1(value78) + (value79 >> 0x20)))); } value109 = value116; value110 = value109; } // duplicate declaration of value110 omitted } } function internal_25e6() private { // Decompilation incomplete: helper effect provenance is conservative. if (!((block.timestamp / 0x015180) > lastDay)) { return; } else { lastDay = (block.timestamp / 0x015180); uint256 accountBalance = IDesolexERC20(this).balanceOf(0x922fa121945ed6f6017d3ebfd39d9a3838db6452); if (accountBalance > 0x0de0b6b3a7640000) { uint256 value0 = ((unresolved_b1e49a0c * accountBalance) / 0x0186a0); if ((accountBalance - (((unresolved_b1e49a0c * accountBalance) / 0x0186a0))) < 0x0de0b6b3a7640000) { value0 = (accountBalance - 0x0de0b6b3a7640000); } _basicTransfer(value0, address(uint160(0x0e45327ee4c003180c9a64ab6f98681a7bd72eff)), address(uint160(0x922fa121945ed6f6017d3ebfd39d9a3838db6452))); require(address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).code.length != 0x0); (bool success1, bytes memory returnData1) = address(0x922fa121945ed6f6017d3ebfd39d9a3838db6452).sync(); // call require(success1); emit Event_b9070ed8(accountBalance, value0); } return; } } function _basicTransfer(uint256 amount, address to, address from) private { require((from & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: transfer from the zero address"); require((to & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: transfer to the zero address"); require(!(balanceOf[from] < amount), "ERC20: transfer amount exceeds balance"); balanceOf[from] = balanceOf[from] - amount; balanceOf[to] = amount + balanceOf[to]; emit Transfer(from, to, amount); } function internal_d87(address account, bytes32 role) private { // Decompilation incomplete: helper effect provenance is conservative. if (!(bytes1(hasRole[stor_expr_ab][msg.sender]) != 0x0)) { if (!(0x14 * 0x2 + 0x2 <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_d; var_d = var_d + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + ((0x14 * 0x02) + 0x02)))); uint256 value0 = (0x14 * 0x02) + 0x02; if (0x14 * 0x2 + 0x2 != 0x0) { value0 = ((0x14 * 0x02) + 0x02) + (var_d + 0x20); } if (!(0 < var_d.length)) _desolexPanic(50); if (!(0x01 < var_d.length)) _desolexPanic(50); uint256 value1 = (0x14 * 0x02) + 0x01; uint256 value2 = msg.sender; uint256 value4; while (true) { uint256 value3 = value1; value4 = value2; if (value1 <= 0x1) { break; } if (!((0xf & value2) < 0x10)) _desolexPanic(50); if (!(value1 < var_d.length)) _desolexPanic(50); if (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1 <= 0x1) { break; } if (!(0x0f & (value2 >> 0x04) < 0x10)) _desolexPanic(50); if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1) < var_d.length)) _desolexPanic(50); value1 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1); value2 = (value2 >> 0x04) >> 0x04; value3 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1; value4 = value2 >> 0x04; } require(value4 == 0x0, "Strings: hex length insufficient"); if (!(0x20 * 0x2 + 0x2 <= 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + ((0x20 * 0x02) + 0x02)))); uint256 value5 = (0x20 * 0x02) + 0x02; if ((0x20 * 0x02) + 0x02 != 0) { value5 = ((0x20 * 0x02) + 0x02) + (var_d + 0x20); } if (!(0 < var_d.length)) _desolexPanic(50); if (!(0x01 < var_d.length)) _desolexPanic(50); value1 = (0x20 * 0x02) + 0x01; value2 = stor_expr_ab; uint256 value7; while (true) { uint256 value6 = value1; value7 = value2; if (value1 <= 0x1) { break; } if (!((0xf & value2) < 0x10)) _desolexPanic(50); if (!(value1 < var_d.length)) _desolexPanic(50); if (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1 <= 0x1) { break; } if (!(0x0f & (value2 >> 0x04) < 0x10)) _desolexPanic(50); if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1) < var_d.length)) _desolexPanic(50); value1 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1); value2 = (value2 >> 0x04) >> 0x04; value6 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1; value7 = value2 >> 0x04; } require(value7 == 0x0, "Strings: hex length insufficient"); uint256 value8 = 0; while (true) { uint256 value9 = value8; if (value8 >= var_p) { break; } if (0x20 + value8 >= var_p) { break; } value8 = 0x20 + (0x20 + value8); value9 = 0x20 + value8; } value8 = 0; while (true) { uint256 value10 = value8; if (value8 >= var_v) { break; } if (0x20 + value8 >= var_v) { break; } value8 = 0x20 + (0x20 + value8); value10 = 0x20 + value8; } var_d = 0x28 + (var_d.length + ((0x20 + var_d) + var_d.length)); value8 = 0; while (true) { if (value8 >= var_d.length) { break; } if (0x20 + value8 >= var_d.length) { break; } value8 = 0x20 + (0x20 + value8); revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } } if (!((bytes1(hasRole[role][account])) != 0x0)) { hasRole[role][account] = true; emit RoleGranted(role, account, msg.sender); } } function internal_e65(uint256 arg0, uint256 arg1, address arg2) private { // Decompilation incomplete: helper effect provenance is conservative. var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, ErrorCaller()); if (address(this).balance != 0x0) { (bool success0, bytes memory returnData0) = address(msg.sender).call{ value: address(this).balance }(""); // call uint256 value0 = 0x60; if (returnData0.length != 0) { uint256 var_c; var_c = var_c + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_c; } require(success0, ErrorFailureTransfer()); } if ((arg1 > 0x0) && (address(this) != arg2)) { internal_1e96(arg1, msg.sender, arg2); } if (!(arg0 > 0x0 && address(this) == arg2)) { return; } else { require((0x69141c22a26b96b140faf74afd99f2fc5bfa9b18 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: transfer from the zero address"); require(msg.sender != address(0), "ERC20: transfer to the zero address"); require(!(balanceOf[address(0x69141c22a26b96b140faf74afd99f2fc5bfa9b18)] < arg0), "ERC20: transfer amount exceeds balance"); balanceOf[address(0x69141c22a26b96b140faf74afd99f2fc5bfa9b18)] = balanceOf[address(0x69141c22a26b96b140faf74afd99f2fc5bfa9b18)] - arg0; balanceOf[msg.sender] = arg0 + balanceOf[msg.sender]; emit Transfer(address(0x69141c22a26b96b140faf74afd99f2fc5bfa9b18), msg.sender, arg0); return; } } function internal_1e96(uint256 arg0, address arg1, address arg2) private { // Decompilation incomplete: helper effect provenance is conservative. var_c = 0x64 + var_c; internal_29ce(var_c, arg2); } function internal_29ce(uint256 arg0, address arg1) private { uint256 value3 = 0; // Decompilation incomplete: helper effect provenance is conservative. var_c = 0x40 + var_c; value3 = internal_327a(var_c, arg0, arg1); uint256 value4 = (0 == var_q) ? 1 : 0; if (0 != var_q) { require(((0x20 + value3) + var_q) - (0x20 + value3) >= 0x20); require(var_x == (var_x != 0x0)); value4 = var_y; } require(value4 != 0x0, "SafeERC20: ERC20 operation did not succeed"); } function internal_327a(uint256 arg0, uint256 arg1, address arg2) private returns (uint256) { // Decompilation incomplete: helper effect provenance is conservative. require(!(address(this).balance < 0), "Address: insufficient balance for call"); uint256 value1 = 0; while (true) { uint256 value2 = value1; if (value1 >= __desolex_internal_3dce_46b3_arg2) { break; } if (0x20 + value1 >= __desolex_internal_3dce_46b3_arg2) { break; } value1 = 0x20 + (0x20 + value1); value2 = 0x20 + value1; } (bool success0, bytes memory returnData0) = arg2.adfepixw(); // call uint256 value3 = 0x60; if (returnData0.length != 0) { var_c = var_c + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value3 = var_c; } if (!success0) { require(!var_q); uint256 value1 = 0; while (true) { if (value1 >= var_t) { break; } if (0x20 + value1 >= var_t) { break; } value1 = 0x20 + (0x20 + value1); revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } } else { if (0x0 == var_q) { require(arg2.code.length != 0x0, "Address: call to non-contract"); } return value3; } } function internal_fd2() private { // Decompilation incomplete: helper effect provenance is conservative. var_a = var_a; var_a = msg.sender; require(bytes1(hasRole[var_a][msg.sender]) != 0x0, ErrorCaller()); uint256 accountBalance = IDesolexERC20(this).balanceOf(address(this)); if (!(accountBalance < minFeeAmount)) { unresolved_130b3867 = 0; sellFeeAmount = 0; unresolved_45a0b6ae = 0; uint256 var_e; if (!(bytes1(stor_11))) { if ((accountBalance * 0x28) / 0x64 != 0) { IDesolexERC20(this).transfer(address(uint160(0x91adab4f34233824ceb52e93e8e2bc4696a43be1)), ((accountBalance * 0x28) / 0x64)); } (bool success2, bytes memory returnData2) = this.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(uint160(0xbb3da51265b61505936640d17d0ddce1038d3959)), (accountBalance - (((accountBalance * 0x28) / 0x64))))); // call transfer require(success2); var_e = var_e + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData2.length) - var_e >= 0x20); require(var_i == (var_i != 0x0)); emit Event_a4416906((accountBalance), 0, (((accountBalance * 0x28) / 0x64)), (((unresolved_130b3867 * 0x3c) / 0x64)), (((sellFeeAmount * 0x3c) / 0x64)), ((((accountBalance - (((unresolved_130b3867 * 0x3c) / 0x64))) - (((sellFeeAmount * 0x3c) / 0x64))) - (((accountBalance * 0x28) / 0x64))))); } var_e = var_e + 0x60; var_p = msg.data[4:68]; if (!(0 < var_e.length)) _desolexPanic(50); if (!(0x01 < var_e.length)) _desolexPanic(50); if (!((var_q - 0x01) < var_q)) _desolexPanic(50); (bool success3, bytes memory returnData3) = var_s.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(0x69141c22a26b96b140faf74afd99f2fc5bfa9b18))); // staticcall balanceOf require(success3); uint256 beforeBalance = abi.decode(returnData3, (uint256)); uint256 value0 = 0; uint256 value1 = (0x04 + var_e) + 0xc0; uint256 value2 = var_e + 0x20; uint256 afterBalance; while (true) { if (!(value0 < var_x)) { break; } value0 = 0x01 + value0; value1 = 0x20 + value1; value2 = 0x20 + value2; if ((((accountBalance * 0x28) / 0x64) * ((afterBalance - beforeBalance))) / accountBalance != 0) { var_e = 0x40 + var_e; require(!(address(this).balance < 0), "Address: insufficient balance for call"); uint256 value3 = 0; while (true) { if (value3 >= __desolex_internal_3dce_46b3_arg2) { break; } value3 = 0x20 + value3; (bool success4, bytes memory returnData4) = address(0xd5df4d260d7a0145f655bcbf3b398076f21016c7).pisnfmc(var_ae, var_af, var_ag); // call uint256 value4 = 0x60; if (returnData4.length != 0) { var_e = var_e + ((returnData4.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value4 = var_e; } if (!success4) { require(!var_ah); var_ae = 0x20; var_af = var_ai; uint256 value3 = 0; while (true) { if (value3 >= __desolex_internal_3dce_3e0a_arg2) { break; } var_ag = var_aj; value3 = 0x20 + value3; revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } } else { if (0x0 == var_ah) { require(address(0xd5df4d260d7a0145f655bcbf3b398076f21016c7).code.length != 0x0, "Address: call to non-contract"); } } uint256 value5 = (0 == var_ah) ? 1 : 0; if (0 != var_ah) { require(((0x20 + value4) + var_ah) - (0x20 + value4) >= 0x20); value5 = var_am; } require(value5 != 0x0, "SafeERC20: ERC20 operation did not succeed"); } } if ((afterBalance - beforeBalance) > (((((accountBalance * 0x28) / 0x64) * ((afterBalance - beforeBalance))) / accountBalance))) { uint256 sharedExpr0 = var_e; uint256 sharedExpr1 = var_e + returnData3.length; uint256 sharedExpr2 = var_e; uint256 sharedExpr3 = accountBalance; uint256 sharedExpr4 = sharedExpr3; uint256 sharedExpr5 = mstore(0x40, (var_e + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)))); uint256 sharedExpr6 = var_e; uint256 sharedExpr7 = sharedExpr6; uint256 sharedExpr8 = mstore(0x40, (var_e + 0x60)); uint256 sharedExpr9 = mstore(0x40, (var_e + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)))); uint256 sharedExpr10 = var_e + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); uint256 sharedExpr11 = mstore(0x40, sharedExpr10); uint256 sharedExpr12 = var_e; uint256 sharedExpr13 = mstore(0x40, (var_e + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)))); uint256 sharedExpr14 = var_e + 0x60; uint256 sharedExpr15 = mstore(0x40, sharedExpr14); uint256 sharedExpr16 = var_e; uint256 sharedExpr17 = afterBalance - beforeBalance; uint256 sharedExpr18 = sharedExpr17; uint256 sharedExpr19 = sharedExpr17; uint256 sharedExpr20 = sharedExpr3; uint256 sharedExpr21 = accountBalance * 0x28; uint256 sharedExpr22 = sharedExpr21; uint256 sharedExpr23 = ((accountBalance * 0x28)) / 0x64; uint256 sharedExpr24 = sharedExpr23; uint256 sharedExpr25 = (((accountBalance * 0x28) / 0x64)) * ((afterBalance - beforeBalance)); uint256 sharedExpr26 = sharedExpr25; uint256 sharedExpr27 = sharedExpr3; uint256 sharedExpr28 = ((((accountBalance * 0x28) / 0x64) * ((afterBalance - beforeBalance)))) / accountBalance; uint256 sharedExpr29 = sharedExpr28; uint256 sharedExpr30 = ((afterBalance - beforeBalance)) - (((((accountBalance * 0x28) / 0x64) * ((afterBalance - beforeBalance))) / accountBalance)); var_e = 0x40 + var_e; require(!(address(this).balance < 0), "Address: insufficient balance for call"); uint256 value3 = 0; while (true) { if (value3 >= __desolex_internal_3dce_46b3_arg2) { break; } value3 = 0x20 + value3; (bool success5, bytes memory returnData5) = address(0xd5df4d260d7a0145f655bcbf3b398076f21016c7).pisnfmc(var_ae, var_af, var_ag); // call uint256 value6 = 0x60; if (returnData5.length != 0) { var_e = var_e + ((returnData5.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value6 = var_e; } if (!success5) { require(!var_an); uint256 value3 = 0; while (true) { if (value3 >= __desolex_internal_3dce_3e0a_arg2) { break; } value3 = 0x20 + value3; revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } } else { if (0x0 == var_an) { require(address(0xd5df4d260d7a0145f655bcbf3b398076f21016c7).code.length != 0x0, "Address: call to non-contract"); } } uint256 value7 = (0 == var_an) ? 1 : 0; if (0 != var_an) { require(((0x20 + value6) + var_an) - (0x20 + value6) >= 0x20); value7 = var_ao; } require(value7 != 0x0, "SafeERC20: ERC20 operation did not succeed"); } } emit Event_a4416906(accountBalance, (afterBalance - beforeBalance), ((accountBalance * 0x28) / 0x64), ((unresolved_130b3867 * 0x3c) / 0x64), ((sellFeeAmount * 0x3c) / 0x64), (((accountBalance - (((unresolved_130b3867 * 0x3c) / 0x64))) - (((sellFeeAmount * 0x3c) / 0x64))) - (((accountBalance * 0x28) / 0x64)))); } require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0); (bool success6, bytes memory returnData6) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795((accountBalance), 0x01, 0xa0, address(0x69141c22a26b96b140faf74afd99f2fc5bfa9b18), block.timestamp, var_x); // call require(success6); afterBalance = IDesolexERC20(var_s).balanceOf(address(0x69141c22a26b96b140faf74afd99f2fc5bfa9b18)); } } function internal_12ac(uint256 arg0, uint256 arg1, bool arg2, uint256 arg3, uint256 arg4, address arg5, address arg6) private { // Decompilation incomplete: helper effect provenance is conservative. require(!(block.timestamp > arg3), "ERC20Permit: expired deadline"); var_b = 0x07; nonces[arg6] = nonces[arg6] + 0x01; uint256 value0 = (keccak256(abi.encode(0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f, 0x4afed11c0b1de2ec13e8fa3c66cc3b0245905785c22b480a217c66bc2c75b47d, 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6, block.chainid, address(this)))); if ((address(0xf080c366f7ee7b8efadbc74f8e7b1e76c7a7494e) == address(this)) && (CHAINID() == 0x38)) { value0 = 0x6962d9ef115cd42c5fccaa9b3756105eeadfe9e28cec5fca04bdf1d573b8daac; } uint256 value1; uint256 value2; if (arg0 <= 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) { require(var_b); uint256 value3 = 0; uint256 value4 = var_y; if (!(address(var_y))) { value3 = 0x01; value4 = 0; } value1 = value3; value2 = value4; } else { value1 = 0x03; value2 = 0; } if (!(value1 <= 0x4)) _desolexPanic(33); if (value1 != 0x0) { require(value1 != 0x1, "ECDSA: invalid signature"); require(value1 != 0x2, "ECDSA: invalid signature length"); require(value1 != 0x3, "ECDSA: invalid signature 's' value"); } require(address(value2) == arg6, "ERC20Permit: invalid signature"); require(arg6 != address(0), "ERC20: approve from the zero address"); require(arg5 != address(0), "ERC20: approve to the zero address"); allowance[arg6][arg5] = arg4; emit Approval(arg6, arg5, allowance[arg6][arg5]); } function internal_1410(address account, bytes32 role) private { // Decompilation incomplete: helper effect provenance is conservative. if (!(bytes1(hasRole[stor_expr_bf][msg.sender]) != 0x0)) { if (!(0x14 * 0x2 + 0x2 <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_d; var_d = var_d + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + ((0x14 * 0x02) + 0x02)))); uint256 value0 = (0x14 * 0x02) + 0x02; if (0x14 * 0x2 + 0x2 != 0x0) { value0 = ((0x14 * 0x02) + 0x02) + (var_d + 0x20); } if (!(0 < var_d.length)) _desolexPanic(50); if (!(0x01 < var_d.length)) _desolexPanic(50); uint256 value1 = (0x14 * 0x02) + 0x01; uint256 value2 = msg.sender; uint256 value4; while (true) { uint256 value3 = value1; value4 = value2; if (value1 <= 0x1) { break; } if (!((0xf & value2) < 0x10)) _desolexPanic(50); if (!(value1 < var_d.length)) _desolexPanic(50); if (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1 <= 0x1) { break; } if (!(0x0f & (value2 >> 0x04) < 0x10)) _desolexPanic(50); if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1) < var_d.length)) _desolexPanic(50); value1 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1); value2 = (value2 >> 0x04) >> 0x04; value3 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1; value4 = value2 >> 0x04; } require(value4 == 0x0, "Strings: hex length insufficient"); if (!(0x20 * 0x2 + 0x2 <= 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + ((0x20 * 0x02) + 0x02)))); uint256 value5 = (0x20 * 0x02) + 0x02; if ((0x20 * 0x02) + 0x02 != 0) { value5 = ((0x20 * 0x02) + 0x02) + (var_d + 0x20); } if (!(0 < var_d.length)) _desolexPanic(50); if (!(0x01 < var_d.length)) _desolexPanic(50); value1 = (0x20 * 0x02) + 0x01; value2 = stor_expr_bf; uint256 value7; while (true) { uint256 value6 = value1; value7 = value2; if (value1 <= 0x1) { break; } if (!((0xf & value2) < 0x10)) _desolexPanic(50); if (!(value1 < var_d.length)) _desolexPanic(50); if (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1 <= 0x1) { break; } if (!(0x0f & (value2 >> 0x04) < 0x10)) _desolexPanic(50); if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1) < var_d.length)) _desolexPanic(50); value1 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1); value2 = (value2 >> 0x04) >> 0x04; value6 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1; value7 = value2 >> 0x04; } require(value7 == 0x0, "Strings: hex length insufficient"); uint256 value8 = 0; while (true) { uint256 value9 = value8; if (value8 >= var_p) { break; } if (0x20 + value8 >= var_p) { break; } value8 = 0x20 + (0x20 + value8); value9 = 0x20 + value8; } value8 = 0; while (true) { uint256 value10 = value8; if (value8 >= var_v) { break; } if (0x20 + value8 >= var_v) { break; } value8 = 0x20 + (0x20 + value8); value10 = 0x20 + value8; } var_d = 0x28 + (var_d.length + ((0x20 + var_d) + var_d.length)); value8 = 0; while (true) { if (value8 >= var_d.length) { break; } if (0x20 + value8 >= var_d.length) { break; } value8 = 0x20 + (0x20 + value8); revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } } if ((bytes1(hasRole[role][account]))) { hasRole[role][account] = false; emit RoleRevoked(role, account, msg.sender); } } 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. // 0x01ffc9a7 => supportsInterface(bytes4) // 0x0563d853 => Unknown_0563d853(bool) // 0x06fdde03 => name() // 0x095ea7b3 => approve(address,uint256) // 0x0e052500 => unresolved_0e052500() // 0x0ee37889 => setLastDay(uint256) // 0x130b3867 => unresolved_130b3867() // 0x18160ddd => totalSupply() // 0x1f9bbe20 => INTERN_SYSTEM() // 0x23b872dd => transferFrom(address,address,uint256) // 0x248a9ca3 => getRoleAdmin(bytes32) // 0x29555f0c => setBuyLimit(bool) // 0x2b14ca56 => sellFee() // 0x2c871eec => lastDayPrice() // 0x2dfb66d7 => openPrice() // 0x2e6369d0 => unresolved_2e6369d0(address) // 0x2f2ff15d => grantRole(bytes32,address) // 0x313ce567 => decimals() // 0x3644e515 => DOMAIN_SEPARATOR() // 0x36568abe => renounceRole(bytes32,address) // 0x39509351 => increaseAllowance(address,uint256) // 0x41acb2bd => Unknown_41acb2bd() // 0x45a0b6ae => unresolved_45a0b6ae() // 0x46572d60 => rescueToken(address,uint256,uint256) // 0x47062402 => buyFee() // 0x475f4131 => Unknown_475f4131() // 0x4b9036d1 => getDayPrice() // 0x4c0dd643 => isLimitBuy() // 0x546da5f6 => getDownFee() // 0x55eda4e8 => BLACK_HOLE() // 0x56f0ef4b => allotFee() // 0x60e1df63 => unresolved_60e1df63() // 0x65df2e51 => FOUNDATION() // 0x662fac39 => mining() // 0x6b0c932d => lastDay() // 0x6f51e8de => unresolved_6f51e8de() // 0x70a08231 => balanceOf(address) // 0x7ecebe00 => nonces(address) // 0x84b0196e => eip712Domain() // 0x8ce5c9b2 => Unknown_8ce5c9b2(uint256) // 0x91d14854 => hasRole(bytes32,address) // 0x932fdf2f => Unknown_932fdf2f(uint256) // 0x95d89b41 => symbol() // 0x98b7d4be => setFeeRatio(uint256,uint256) // 0xa217fddf => DEFAULT_ADMIN_ROLE() // 0xa457c2d7 => decreaseAllowance(address,uint256) // 0xa5f596e5 => unresolved_a5f596e5() // 0xa9059cbb => transfer(address,uint256) // 0xa95de078 => sellFeeAmount() // 0xb1e49a0c => unresolved_b1e49a0c() // 0xbfd9041b => LP_TOKEN() // 0xc2524a4a => INTERN_SYSTEM_MANAGER() // 0xc54e44eb => USDT() // 0xcbd7be97 => SWAPROUTER() // 0xd0227f22 => FEEPOOL() // 0xd505accf => Unknown_d505accf(address,address,uint256,uint256,bool,uint256,uint256) // 0xd547741f => revokeRole(bytes32,address) // 0xd6117529 => setMinFeeAmount(uint256) // 0xdd62ed3e => allowance(address,address) // 0xe0956e0f => TOKEN_MANAGER() // 0xe8e0f92e => getTokenUPrice() // 0xf5d36475 => minFeeAmount() // 0xfda191e2 => unresolved_fda191e2()}