0xfbfa4f2f29d1007751bf47cf5069cc29e60a2a0e

1//decompiled by exvvul decompiler tool contact@exvul.com https://x.com/exvulsec2// SPDX-License-Identifier: MIT3pragma solidity >=0.8.0;45interface IDesolexERC20 {6    function balanceOf(address account) external view returns (uint256 balance);7    function transfer(address recipient, uint256 amount) external returns (bool success);8}910contract DesolexContract {11    address public constant ROUTER = address(0xd056975ec810087d7f400a212459d03b45daa3e7);12    address public constant REG = address(0xee6a49bd08af328f4d7f7c686732319087472a7);13    address public constant SEASON = address(0x9596806b1f375e714be2165dec949e2c1cefbc14);14    address public constant NFT = address(0x4101da71a3d53d26bf9b68d01296164a180f6f2b);15    address public constant PANCAKE = address(0x10ed43c718714eb63d5aa57b78b54704e256024e);16    address public constant AC = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77);17    address public constant USDT = address(0x55d398326f99059ff775485246999027b3197955);18    address public constant REWARD = address(0xf065a79f1f04a53ff9b23be8b026046640249134);19    20    address public owner; // STORAGE[0x0]21    uint256 public pid; // STORAGE[0x1]22    23    event Event_78548519(uint256);24    event Harvested(uint256, uint256, uint256);25    event Event_62c51f2d(uint256, uint256);26    function _desolexPanic(uint256 code) private pure {27        assembly ("memory-safe") {28            mstore(0x00, shl(224, 0x4e487b71))29            mstore(0x04, code)30            revert(0x00, 0x24)31        }32    }33    34    modifier onlyOwner() {35        require(msg.sender == owner, "not owner");36        _;37    }38    fallback() external payable {39        // Synthetic compatibility routes preserve original selectors for unresolved names.40        if ((msg.data.length >= 4) && (msg.sig == 0x03ff07ec)) {41            // Route to Unknown_03ff07ec() after replacing only msg.sig.42            __desolexSelectorShim(uint32(0x2bcf3e4d));43            return;44        }45        if ((msg.data.length >= 4) && (msg.sig == 0x33257ccf)) {46            // Route to Unknown_33257ccf() after replacing only msg.sig.47            __desolexSelectorShim(uint32(0x1af4b2f7));48            return;49        }50        if ((msg.data.length >= 4) && (msg.sig == 0xe92788f2)) {51            // Route to Unknown_e92788f2(uint256) after replacing only msg.sig.52            __desolexSelectorShim(uint32(0x96f27ca1));53            return;54        }55        revert();56    }57    58    59    function Unknown_03ff07ec() public payable returns (bool) {60        uint256 var_b;61        var_b = var_b + 0x24;62        (bool success0, bytes memory returnData0) = address(0xd056975ec810087d7f400a212459d03b45daa3e7).Unknown_047c7755(); // call63        uint256 value0 = 0x60;64        if (returnData0.length != 0) {65            var_b = var_b + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));66            value0 = var_b;67        }68        return success0;69    }70    71    function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes memory _data) public pure returns (uint256) {72        require(!(((0x04 + _data) + _data + 0x20) > msg.data.length));73        return 0x150b7a0200000000000000000000000000000000000000000000000000000000;74    }75    76    function setPid(uint256 newPid) public payable onlyOwner {77        (bool success0, bytes memory returnData0) = address(0x4101da71a3d53d26bf9b68d01296164a180f6f2b).ownerOf(newPid); // staticcall78        require(success0);79        uint256 var_c;80        var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));81        require(!(((var_c + returnData0.length) - var_c) < 0x20));82        require(var_c.length == (var_c.length & 0xffffffffffffffffffffffffffffffffffffffff));83        require((0xffffffffffffffffffffffffffffffffffffffff & value0) == address(this), "not owner of pid");84        pid = newPid;85    }86    87    function Unknown_33257ccf() public payable onlyOwner returns (uint256) {88        (bool success0, bytes memory returnData0) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).balanceOf(address(this)); // staticcall89        require(success0);90        uint256 accountBalance = abi.decode(returnData0, (uint256));91        if (0 - accountBalance != 0) {92            (bool success1, bytes memory returnData1) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall93            require(success1);94            uint256 beforeBalance = abi.decode(returnData1, (uint256));95            (bool success2, bytes memory returnData2) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, accountBalance); // call96            require(success2);97            bool approvalSucceeded = abi.decode(returnData2, (bool));98            require(approvalSucceeded, "ac approve failed");99            uint256 var_c;100            var_c = var_c + 0x60;101            if (!(0 < var_c.length)) _desolexPanic(50);102            if (!(0x01 < var_c.length)) _desolexPanic(50);103            uint256 value0 = 0;104            uint256 value2 = var_c + 0x20;105            uint256 value1 = var_p;106            uint256 value3 = 0;107            uint256 value4 = var_c;108            uint256 value5 = ((0x04 + var_c) + 0x40) + 0x20;109            while (true) {110                if (value0 >= value1) {111                    break;112                }113                if ((0x01 + value0) >= value1) {114                    break;115                }116                value0 = 0x01 + (0x01 + value0);117                value2 = (value2 + 0x20) + 0x20;118                value1 = value1;119                value3 = value3;120                value4 = value4;121                value5 = 0x20 + (0x20 + value5);122                (bool success3, bytes memory returnData3) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_d06ca61f(accountBalance, 0x40); // staticcall123                require(success3);124                var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData3.length + 0x1f));125                require((var_c + returnData3.length) - var_c >= 0x20);126                require(!(var_v > 0xffffffffffffffff));127                require((var_c + returnData3.length) > ((var_c + var_v) + 0x1f));128                if (var_w > 0xffffffffffffffff) _desolexPanic(65);129                if (((var_c + (((var_w << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((var_w << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65);130                var_c = var_c + (((var_w << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));131                require(!((0x20 + ((var_c + var_v) + (var_y << 0x05))) > (var_c + returnData3.length)));132                uint256 value8 = var_c + 0x20;133                uint256 value9 = var_c;134                uint256 value10 = var_w << 0x05;135                uint256 value7 = 0x20 + ((var_c + var_v) + (var_y << 0x05));136                uint256 value6 = (var_c + var_v) + 0x20;137                uint256 value11 = 0;138                uint256 value12 = var_c;139                uint256 value13 = var_c + returnData3.length;140                while (true) {141                    if (value6 >= value7) {142                        break;143                    }144                    if ((0x20 + value6) >= value7) {145                        break;146                    }147                    value8 = 0x20 + value8;148                    value9 = value9;149                    value10 = var_aa;150                    value7 = value7;151                    value6 = 0x20 + value6;152                    value11 = value11;153                    value12 = value12;154                    value13 = value13;155                    if (!(0x01 < var_ad)) _desolexPanic(50);156                    require((var_ae / 0x02) > 0, "quote is 0");157                    uint256 value0 = 0;158                    uint256 value2 = var_c + 0x20;159                    uint256 value1 = var_af;160                    uint256 value3 = 0;161                    uint256 value4 = var_c;162                    uint256 value5 = ((0x04 + var_c) + 0xa0) + 0x20;163                    while (true) {164                        if (value0 >= value1) {165                            break;166                        }167                        if ((0x01 + value0) >= value1) {168                            break;169                        }170                        value0 = 0x01 + value0;171                        value2 = value2 + 0x20;172                        value1 = value1;173                        value3 = value3;174                        value4 = value4;175                        value5 = 0x20 + value5;176                        require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);177                        (bool success4, bytes memory returnData4) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_ae / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0)); // call178                        require(success4);179                        (bool success5, bytes memory returnData5) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall180                        require(success5);181                        uint256 accountBalance_5 = abi.decode(returnData5, (uint256));182                        uint256 afterBalance = abi.decode(returnData5, (uint256));183                        require(!((afterBalance - beforeBalance) < (accountBalance_5 / 0x02)), "sell short");184                        return afterBalance - beforeBalance;185                    }186                    require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);187                    (bool success6, bytes memory returnData6) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_ae / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0), var_af); // call188                    require(success6);189                    (bool success7, bytes memory returnData7) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall190                    require(success7);191                    uint256 afterBalance1 = abi.decode(returnData7, (uint256));192                    require(!((afterBalance1 - beforeBalance) < (var_ae / 0x02)), "sell short");193                    return afterBalance1 - beforeBalance;194                }195                if (!(0x01 < var_ad)) _desolexPanic(50);196                require((var_ae / 0x02) > 0, "quote is 0");197                uint256 value0 = 0;198                uint256 value2 = var_c + 0x20;199                uint256 value1 = var_af;200                uint256 value3 = 0;201                uint256 value4 = var_c;202                uint256 value5 = ((0x04 + var_c) + 0xa0) + 0x20;203                while (true) {204                    if (value0 >= value1) {205                        break;206                    }207                    if ((0x01 + value0) >= value1) {208                        break;209                    }210                    value0 = 0x01 + value0;211                    value2 = value2 + 0x20;212                    value1 = value1;213                    value3 = value3;214                    value4 = value4;215                    value5 = 0x20 + value5;216                    require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);217                    (bool success8, bytes memory returnData8) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_ae / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0)); // call218                    require(success8);219                    (bool success9, bytes memory returnData9) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall220                    require(success9);221                    uint256 accountBalance_9 = abi.decode(returnData9, (uint256));222                    uint256 afterBalance2 = abi.decode(returnData9, (uint256));223                    require(!((afterBalance2 - beforeBalance) < (accountBalance_9 / 0x02)), "sell short");224                    return afterBalance2 - beforeBalance;225                }226                require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);227                (bool success10, bytes memory returnData10) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_ae / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0), var_af); // call228                require(success10);229                (bool success11, bytes memory returnData11) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall230                require(success11);231                uint256 afterBalance3 = abi.decode(returnData11, (uint256));232                require(!((afterBalance3 - beforeBalance) < (var_ae / 0x02)), "sell short");233                return afterBalance3 - beforeBalance;234            }235            (bool success12, bytes memory returnData12) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_d06ca61f(accountBalance, 0x40, var_p); // staticcall236            require(success12);237            var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData12.length + 0x1f));238            require(!(((var_c + returnData12.length) - var_c) < 0x20));239            require(!(var_c.length > 0xffffffffffffffff));240            require((var_c + returnData12.length) > ((var_c + var_c.length) + 0x1f));241            if (var_am > 0xffffffffffffffff) _desolexPanic(65);242            if (((var_c + (((var_an << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((var_an << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65);243            var_c = var_c + (((var_an << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));244            require(!((0x20 + ((var_c + var_c.length) + (var_an << 0x05))) > (var_c + returnData12.length)));245            uint256 value8 = var_c + 0x20;246            uint256 value9 = var_c;247            uint256 value10 = var_w << 0x05;248            uint256 value7 = 0x20 + ((var_c + var_v) + (var_y << 0x05));249            uint256 value6 = (var_c + var_v) + 0x20;250            uint256 value11 = 0;251            uint256 value12 = var_c;252            uint256 value13 = var_c + returnData12.length;253            while (true) {254                if (value6 >= value7) {255                    break;256                }257                value8 = 0x20 + value8;258                value9 = value9;259                value10 = var_aa;260                value7 = value7;261                value6 = 0x20 + value6;262                value11 = value11;263                value12 = value12;264                value13 = value13;265                if (!(0x01 < var_ad)) _desolexPanic(50);266                require((var_ae / 0x02) > 0, "quote is 0");267                uint256 value0 = 0;268                uint256 value2 = var_c + 0x20;269                uint256 value1 = var_af;270                uint256 value3 = 0;271                uint256 value4 = var_c;272                uint256 value5 = ((0x04 + var_c) + 0xa0) + 0x20;273                while (true) {274                    if (value0 >= value1) {275                        break;276                    }277                    if ((0x01 + value0) >= value1) {278                        break;279                    }280                    value0 = 0x01 + (0x01 + value0);281                    value2 = (value2 + 0x20) + 0x20;282                    value1 = value1;283                    value3 = value3;284                    value4 = value4;285                    value5 = 0x20 + (0x20 + value5);286                    require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);287                    (bool success13, bytes memory returnData13) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, var_ae / 0x02, 0xa0, address(this), block.timestamp + 0x04b0); // call288                    require(success13);289                    (bool success14, bytes memory returnData14) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall290                    require(success14);291                    uint256 afterBalance4 = abi.decode(returnData14, (uint256));292                    require(!((afterBalance4 - beforeBalance) < (var_ae / 0x02)), "sell short");293                    return afterBalance4 - beforeBalance;294                }295                require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);296                (bool success15, bytes memory returnData15) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, var_ae / 0x02, 0xa0, address(this), block.timestamp + 0x04b0, var_af); // call297                require(success15);298                (bool success16, bytes memory returnData16) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall299                require(success16);300                uint256 afterBalance5 = abi.decode(returnData16, (uint256));301                require(!((afterBalance5 - beforeBalance) < (var_ae / 0x02)), "sell short");302                return afterBalance5 - beforeBalance;303            }304        } else {305            return 0;306        }307    }308    309    function runDay() public payable onlyOwner returns (bytes memory) {310        uint256 var_b;311        var_b = var_b + 0x24;312        (bool success0, bytes memory returnData0) = address(0xd056975ec810087d7f400a212459d03b45daa3e7).Unknown_047c7755(); // call313        uint256 value0 = 0x60;314        if (returnData0.length != 0) {315            var_b = var_b + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));316            value0 = var_b;317        }318        require(msg.sender == owner, "not owner");319        require(0x0 != pid, "no pid");320        (bool success1, bytes memory returnData1) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).balanceOf(address(this)); // staticcall321        require(success1);322        var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));323        require((var_b + returnData1.length) - var_b >= 0x20);324        var_b = 0x20 + (0x24 + var_b);325        (bool success2, bytes memory returnData2) = address(0xf065a79f1f04a53ff9b23be8b026046640249134).takeReward(var_n); // call326        uint256 value1 = 0x60;327        if (returnData2.length != 0) {328            var_b = var_b + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));329            value1 = var_b;330        }331        if (!(success2)) {332            require(!var_p);333            revert("call failed");334        }335        (bool success3, bytes memory returnData3) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).balanceOf(address(this)); // staticcall336        require(success3);337        var_b = var_b + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));338        require((var_b + returnData3.length) - var_b >= 0x20);339        require((var_b.length - var_b.length) > 0, "nothing to claim");340        require(msg.sender == owner, "not owner");341        (bool success4, bytes memory returnData4) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).balanceOf(address(this)); // staticcall342        require(success4);343        uint256 accountBalance = abi.decode(returnData4, (uint256));344        uint256 value23 = var_b.length - var_b.length;345        if (0 - accountBalance != 0) {346            (bool success5, bytes memory returnData5) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall347            require(success5);348            var_b = var_b + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));349            require((var_b + returnData5.length) - var_b >= 0x20);350            (bool success6, bytes memory returnData6) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, accountBalance); // call351            require(success6);352            bool approvalSucceeded = abi.decode(returnData6, (bool));353            require(approvalSucceeded, "ac approve failed");354            var_b = var_b + 0x60;355            if (!(0 < var_b.length)) _desolexPanic(50);356            if (!(0x01 < var_b.length)) _desolexPanic(50);357            uint256 value2 = 0;358            uint256 value4 = var_b + 0x20;359            uint256 value3 = var_ae;360            uint256 value5 = 0;361            uint256 value6 = var_b;362            uint256 value7 = ((0x04 + var_b) + 0x40) + 0x20;363            while (true) {364                if (value2 >= value3) {365                    break;366                }367                if (__desolex_internal_16e6_172f_arg0 >= __desolex_internal_16e6_172f_arg2) {368                    break;369                }370                value2 = __desolex_internal_16e6_172f_arg0;371                value4 = __desolex_internal_16e6_172f_arg1;372                value3 = __desolex_internal_16e6_172f_arg2;373                value5 = __desolex_internal_16e6_172f_arg3;374                value6 = __desolex_internal_16e6_172f_arg4;375                value7 = __desolex_internal_16e6_172f_arg5;376                (bool success7, bytes memory returnData7) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_d06ca61f(accountBalance, 0x40); // staticcall377                require(success7);378                var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData7.length + 0x1f));379                require((var_b + returnData7.length) - var_b >= 0x20);380                require(!(var_ak > 0xffffffffffffffff));381                require((var_b + returnData7.length) > ((var_b + var_ak) + 0x1f));382                if (var_al > 0xffffffffffffffff) _desolexPanic(65);383                if (((var_b + (((var_al << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + (((var_al << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);384                var_b = var_b + (((var_al << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));385                require(!((0x20 + ((var_b + var_ak) + (var_an << 0x05))) > (var_b + returnData7.length)));386                uint256 value10 = var_b + 0x20;387                uint256 value11 = var_b;388                uint256 value12 = var_al << 0x05;389                uint256 value9 = 0x20 + ((var_b + var_ak) + (var_an << 0x05));390                uint256 value8 = (var_b + var_ak) + 0x20;391                uint256 value13 = 0;392                uint256 value14 = var_b;393                uint256 value15 = var_b + returnData7.length;394                while (true) {395                    if (value8 >= value9) {396                        break;397                    }398                    if ((0x20 + value8) >= value9) {399                        break;400                    }401                    value10 = 0x20 + value10;402                    value11 = value11;403                    value12 = var_ap;404                    value9 = value9;405                    value8 = 0x20 + value8;406                    value13 = value13;407                    value14 = value14;408                    value15 = value15;409                    if (!(0x01 < var_as)) _desolexPanic(50);410                    require((var_at / 0x02) > 0, "quote is 0");411                    uint256 value2 = 0;412                    uint256 value4 = var_b + 0x20;413                    uint256 value3 = var_au;414                    uint256 value5 = 0;415                    uint256 value6 = var_b;416                    uint256 value7 = ((0x04 + var_b) + 0xa0) + 0x20;417                    while (true) {418                        if (value2 >= value3) {419                            break;420                        }421                        if (__desolex_internal_16e6_1869_arg0 >= __desolex_internal_16e6_1869_arg2) {422                            break;423                        }424                        value2 = 0x01 + __desolex_internal_16e6_1869_arg0;425                        value4 = __desolex_internal_16e6_1869_arg1 + 0x20;426                        value3 = __desolex_internal_16e6_1869_arg2;427                        value5 = __desolex_internal_16e6_1869_arg3;428                        value6 = __desolex_internal_16e6_1869_arg4;429                        value7 = 0x20 + __desolex_internal_16e6_1869_arg5;430                        require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);431                        (bool success8, bytes memory returnData8) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_at / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0)); // call432                        require(success8);433                        (bool success9, bytes memory returnData9) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall434                        require(success9);435                        var_b = var_b + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));436                        require((var_b + returnData9.length) - var_b >= 0x20);437                        uint256 value16 = abi.decode(returnData9, (uint256));438                        require(!((value16 - var_b.length) < (var_at / 0x02)), "sell short");439                        require((value16 - var_b.length) > 0, "sell returned 0");440                        emit Harvested(pid, (var_b.length - var_b.length), value16 - var_b.length);441                        return abi.encodePacked((var_b.length - var_b.length), value16 - var_b.length);442                    }443                    require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);444                    (bool success10, bytes memory returnData10) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_at / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0), var_au); // call445                    require(success10);446                    (bool success11, bytes memory returnData11) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall447                    require(success11);448                    uint256 accountBalance_11 = abi.decode(returnData11, (uint256));449                    uint256 value17 = abi.decode(returnData11, (uint256));450                    require(!((value17 - var_b.length) < (accountBalance_11 / 0x02)), "sell short");451                    require((value17 - var_b.length) > 0, "sell returned 0");452                    emit Harvested(pid, (var_b.length - var_b.length), value17 - var_b.length);453                    return abi.encodePacked((var_b.length - var_b.length), value17 - var_b.length);454                }455                if (!(0x01 < var_as)) _desolexPanic(50);456                require((var_at / 0x02) > 0, "quote is 0");457                uint256 value2 = 0;458                uint256 value4 = var_b + 0x20;459                uint256 value3 = var_au;460                uint256 value5 = 0;461                uint256 value6 = var_b;462                uint256 value7 = ((0x04 + var_b) + 0xa0) + 0x20;463                while (true) {464                    if (value2 >= value3) {465                        break;466                    }467                    if (__desolex_internal_16e6_1869_arg0 >= __desolex_internal_16e6_1869_arg2) {468                        break;469                    }470                    value2 = __desolex_internal_16e6_1869_arg0;471                    value4 = __desolex_internal_16e6_1869_arg1;472                    value3 = __desolex_internal_16e6_1869_arg2;473                    value5 = __desolex_internal_16e6_1869_arg3;474                    value6 = __desolex_internal_16e6_1869_arg4;475                    value7 = __desolex_internal_16e6_1869_arg5;476                    require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);477                    (bool success12, bytes memory returnData12) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_at / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0)); // call478                    require(success12);479                    (bool success13, bytes memory returnData13) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall480                    require(success13);481                    uint256 accountBalance_13 = abi.decode(returnData13, (uint256));482                    uint256 value18 = abi.decode(returnData13, (uint256));483                    require(!((value18 - var_b.length) < (accountBalance_13 / 0x02)), "sell short");484                    require((value18 - var_b.length) > 0, "sell returned 0");485                    emit Harvested(pid, (var_b.length - var_b.length), value18 - var_b.length);486                    return abi.encodePacked((var_b.length - var_b.length), value18 - var_b.length);487                }488                require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);489                (bool success14, bytes memory returnData14) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_at / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0), var_au); // call490                require(success14);491                (bool success15, bytes memory returnData15) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall492                require(success15);493                uint256 accountBalance_15 = abi.decode(returnData15, (uint256));494                uint256 value19 = abi.decode(returnData15, (uint256));495                require(!((value19 - var_b.length) < (accountBalance_15 / 0x02)), "sell short");496                require((value19 - var_b.length) > 0, "sell returned 0");497                emit Harvested(pid, (var_b.length - var_b.length), value19 - var_b.length);498                return abi.encodePacked((var_b.length - var_b.length), value19 - var_b.length);499            }500            (bool success16, bytes memory returnData16) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_d06ca61f(accountBalance, 0x40, var_ae); // staticcall501            require(success16);502            var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData16.length + 0x1f));503            require((var_b + returnData16.length) - var_b >= 0x20);504            require(!(var_ak > 0xffffffffffffffff));505            require((var_b + returnData16.length) > ((var_b + var_ak) + 0x1f));506            if (var_al > 0xffffffffffffffff) _desolexPanic(65);507            if (((var_b + (((var_al << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + (((var_al << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);508            var_b = var_b + (((var_al << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));509            require(!((0x20 + ((var_b + var_ak) + (var_an << 0x05))) > (var_b + returnData16.length)));510            uint256 value10 = var_b + 0x20;511            uint256 value11 = var_b;512            uint256 value12 = var_al << 0x05;513            uint256 value9 = 0x20 + ((var_b + var_ak) + (var_an << 0x05));514            uint256 value8 = (var_b + var_ak) + 0x20;515            uint256 value13 = 0;516            uint256 value14 = var_b;517            uint256 value15 = var_b + returnData16.length;518            while (true) {519                if (value8 >= value9) {520                    break;521                }522                if ((0x20 + value8) >= value9) {523                    break;524                }525                value10 = 0x20 + value10;526                value11 = value11;527                value12 = var_ap;528                value9 = value9;529                value8 = 0x20 + value8;530                value13 = value13;531                value14 = value14;532                value15 = value15;533                if (!(0x01 < var_as)) _desolexPanic(50);534                require((var_at / 0x02) > 0, "quote is 0");535                uint256 value2 = 0;536                uint256 value4 = var_b + 0x20;537                uint256 value3 = var_au;538                uint256 value5 = 0;539                uint256 value6 = var_b;540                uint256 value7 = ((0x04 + var_b) + 0xa0) + 0x20;541                while (true) {542                    if (value2 >= value3) {543                        break;544                    }545                    if (__desolex_internal_16e6_1869_arg0 >= __desolex_internal_16e6_1869_arg2) {546                        break;547                    }548                    value2 = __desolex_internal_16e6_1869_arg0;549                    value4 = __desolex_internal_16e6_1869_arg1;550                    value3 = __desolex_internal_16e6_1869_arg2;551                    value5 = __desolex_internal_16e6_1869_arg3;552                    value6 = __desolex_internal_16e6_1869_arg4;553                    value7 = __desolex_internal_16e6_1869_arg5;554                    require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);555                    (bool success17, bytes memory returnData17) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_at / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0)); // call556                    require(success17);557                    (bool success18, bytes memory returnData18) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall558                    require(success18);559                    uint256 accountBalance_18 = abi.decode(returnData18, (uint256));560                    uint256 value20 = abi.decode(returnData18, (uint256));561                    require(!((value20 - var_b.length) < (accountBalance_18 / 0x02)), "sell short");562                    require((value20 - var_b.length) > 0, "sell returned 0");563                    emit Harvested(pid, (var_b.length - var_b.length), value20 - var_b.length);564                    return abi.encodePacked((var_b.length - var_b.length), value20 - var_b.length);565                }566                require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);567                (bool success19, bytes memory returnData19) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_at / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0), var_au); // call568                require(success19);569                (bool success20, bytes memory returnData20) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall570                require(success20);571                uint256 value21 = abi.decode(returnData20, (uint256));572                require(!((value21 - var_b.length) < (var_at / 0x02)), "sell short");573                require((value21 - var_b.length) > 0, "sell returned 0");574                emit Harvested(pid, (var_b.length - var_b.length), value21 - var_b.length);575                return abi.encodePacked((var_b.length - var_b.length), value21 - var_b.length);576            }577            if (!(0x01 < var_as)) _desolexPanic(50);578            require((var_at / 0x02) > 0, "quote is 0");579            value2 = 0;580            value4 = var_b + 0x20;581            value3 = var_au;582            value5 = 0;583            value6 = var_b;584            value7 = ((0x04 + var_b) + 0xa0) + 0x20;585            while (true) {586                if (value2 >= value3) {587                    break;588                }589                if (__desolex_internal_16e6_1869_arg0 >= __desolex_internal_16e6_1869_arg2) {590                    break;591                }592                value2 = __desolex_internal_16e6_1869_arg0;593                value4 = __desolex_internal_16e6_1869_arg1;594                value3 = __desolex_internal_16e6_1869_arg2;595                value5 = __desolex_internal_16e6_1869_arg3;596                value6 = __desolex_internal_16e6_1869_arg4;597                value7 = __desolex_internal_16e6_1869_arg5;598                require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);599                (bool success21, bytes memory returnData21) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_at / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0)); // call600                require(success21);601                (bool success22, bytes memory returnData22) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall602                require(success22);603                uint256 accountBalance_22 = abi.decode(returnData22, (uint256));604                uint256 value22 = abi.decode(returnData22, (uint256));605                require(!((value22 - var_b.length) < (accountBalance_22 / 0x02)), "sell short");606                require((value22 - var_b.length) > 0, "sell returned 0");607                emit Harvested(pid, (var_b.length - var_b.length), value22 - var_b.length);608                return abi.encodePacked((var_b.length - var_b.length), value22 - var_b.length);609            }610            require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);611            (bool success23, bytes memory returnData23) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance, (var_at / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0), var_au); // call612            require(success23);613            (bool success24, bytes memory returnData24) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall614            require(success24);615            uint256 accountBalance_24 = abi.decode(returnData24, (uint256));616            require(!((var_b.length - var_b.length) < (accountBalance_24 / 0x02)), "sell short");617        } else {618            value23 = 0;619        }620        require(value23 > 0x0, "sell returned 0");621        emit Harvested(pid, (var_b.length - var_b.length), value23);622        return abi.encodePacked((var_b.length - var_b.length), value23);623    }624    625    function setup(uint256 index) public payable onlyOwner returns (uint256) {626        require(msg.sender == owner, "not owner");627        require(!pid, "pid already set");628        (bool success0, bytes memory returnData0) = address(0x4101da71a3d53d26bf9b68d01296164a180f6f2b).balanceOf(address(this)); // staticcall629        require(success0);630        uint256 accountBalance = abi.decode(returnData0, (uint256));631        uint256 var_c;632        var_c = 0x20 + (0x24 + var_c);633        (bool success1, bytes memory returnData1) = address(0x0ee6a49bd08af328f4d7f7c686732319087472a7).createRole(var_j); // call634        uint256 value0 = 0x60;635        if (returnData1.length != 0) {636            var_c = var_c + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));637            value0 = var_c;638        }639        if (!(success1)) {640            require(!var_l);641            revert("call failed");642        }643        (bool success2, bytes memory returnData2) = address(0x4101da71a3d53d26bf9b68d01296164a180f6f2b).balanceOf(address(this)); // staticcall644        require(success2);645        var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));646        require(!(((var_c + returnData2.length) - var_c) < 0x20));647        require(var_c.length == (accountBalance + 0x01), "pid not minted");648        (bool success3, bytes memory returnData3) = address(0x4101da71a3d53d26bf9b68d01296164a180f6f2b).tokenOfOwnerByIndex(address(this), var_c.length - 0x01); // staticcall649        require(success3);650        var_c = var_c + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));651        require(!(((var_c + returnData3.length) - var_c) < 0x20));652        pid = var_c.length;653        emit Event_78548519(pid);654        internal_dd8(index);655        return pid;656    }657    658    function harvest() public payable onlyOwner returns (bytes memory) {659        require(msg.sender == owner, "not owner");660        require(0x0 != pid, "no pid");661        (bool success0, bytes memory returnData0) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).balanceOf(address(this)); // staticcall662        require(success0);663        uint256 accountBalance = abi.decode(returnData0, (uint256));664        uint256 var_c;665        var_c = 0x20 + (0x24 + var_c);666        (bool success1, bytes memory returnData1) = address(0xf065a79f1f04a53ff9b23be8b026046640249134).takeReward(var_j); // call667        uint256 value0 = 0x60;668        if (returnData1.length != 0) {669            var_c = var_c + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));670            value0 = var_c;671        }672        if (!(success1)) {673            require(!var_l);674            revert("call failed");675        }676        (bool success2, bytes memory returnData2) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).balanceOf(address(this)); // staticcall677        require(success2);678        var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));679        require(!(((var_c + returnData2.length) - var_c) < 0x20));680        require((var_c.length - accountBalance) > 0, "nothing to claim");681        require(msg.sender == owner, "not owner");682        (bool success3, bytes memory returnData3) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).balanceOf(address(this)); // staticcall683        require(success3);684        uint256 accountBalance1 = abi.decode(returnData3, (uint256));685        if (0 - accountBalance1 != 0) {686            (bool success4, bytes memory returnData4) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall687            require(success4);688            uint256 beforeBalance = abi.decode(returnData4, (uint256));689            (bool success5, bytes memory returnData5) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, accountBalance1); // call690            require(success5);691            bool approvalSucceeded = abi.decode(returnData5, (bool));692            require(approvalSucceeded, "ac approve failed");693            var_c = var_c + 0x60;694            if (!(0 < var_c.length)) _desolexPanic(50);695            if (!(0x01 < var_c.length)) _desolexPanic(50);696            uint256 value1 = 0;697            uint256 value3 = var_c + 0x20;698            uint256 value2 = var_y;699            uint256 value4 = 0;700            uint256 value5 = var_c;701            uint256 value6 = ((0x04 + var_c) + 0x40) + 0x20;702            while (true) {703                if (value1 >= value2) {704                    break;705                }706                if ((0x01 + value1) >= value2) {707                    break;708                }709                value1 = 0x01 + (0x01 + value1);710                value3 = (value3 + 0x20) + 0x20;711                value2 = value2;712                value4 = value4;713                value5 = value5;714                value6 = 0x20 + (0x20 + value6);715                (bool success6, bytes memory returnData6) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_d06ca61f(accountBalance1, 0x40); // staticcall716                require(success6);717                var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData6.length + 0x1f));718                require((var_c + returnData6.length) - var_c >= 0x20);719                require(!(var_ae > 0xffffffffffffffff));720                require((var_c + returnData6.length) > ((var_c + var_ae) + 0x1f));721                if (var_af > 0xffffffffffffffff) _desolexPanic(65);722                if (((var_c + (((var_af << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((var_af << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65);723                var_c = var_c + (((var_af << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));724                require(!((0x20 + ((var_c + var_ae) + (var_ah << 0x05))) > (var_c + returnData6.length)));725                uint256 value9 = var_c + 0x20;726                uint256 value10 = var_c;727                uint256 value11 = var_af << 0x05;728                uint256 value8 = 0x20 + ((var_c + var_ae) + (var_ah << 0x05));729                uint256 value7 = (var_c + var_ae) + 0x20;730                uint256 value12 = 0;731                uint256 value13 = var_c;732                uint256 value14 = var_c + returnData6.length;733                while (true) {734                    if (value7 >= value8) {735                        break;736                    }737                    if ((0x20 + value7) >= value8) {738                        break;739                    }740                    value9 = 0x20 + value9;741                    value10 = value10;742                    value11 = var_aj;743                    value8 = value8;744                    value7 = 0x20 + value7;745                    value12 = value12;746                    value13 = value13;747                    value14 = value14;748                    if (!(0x01 < var_am)) _desolexPanic(50);749                    require((var_an / 0x02) > 0, "quote is 0");750                    uint256 value1 = 0;751                    uint256 value3 = var_c + 0x20;752                    uint256 value2 = var_ao;753                    uint256 value4 = 0;754                    uint256 value5 = var_c;755                    uint256 value6 = ((0x04 + var_c) + 0xa0) + 0x20;756                    while (true) {757                        if (value1 >= value2) {758                            break;759                        }760                        if ((0x01 + value1) >= value2) {761                            break;762                        }763                        value1 = 0x01 + value1;764                        value3 = value3 + 0x20;765                        value2 = value2;766                        value4 = value4;767                        value5 = value5;768                        value6 = 0x20 + value6;769                        require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);770                        (bool success7, bytes memory returnData7) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance1, (var_an / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0)); // call771                        require(success7);772                        (bool success8, bytes memory returnData8) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall773                        require(success8);774                        uint256 accountBalance_8 = abi.decode(returnData8, (uint256));775                        uint256 afterBalance = abi.decode(returnData8, (uint256));776                        require(!((afterBalance - beforeBalance) < (accountBalance_8 / 0x02)), "sell short");777                        require((afterBalance - beforeBalance) > 0, "sell returned 0");778                        emit Harvested(pid, var_c.length - accountBalance, afterBalance - beforeBalance);779                        return abi.encodePacked(var_c.length - accountBalance, afterBalance - beforeBalance);780                    }781                    require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);782                    (bool success9, bytes memory returnData9) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance1, (var_an / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0), var_ao); // call783                    require(success9);784                    (bool success10, bytes memory returnData10) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall785                    require(success10);786                    uint256 afterBalance1 = abi.decode(returnData10, (uint256));787                    require(!((afterBalance1 - beforeBalance) < (var_an / 0x02)), "sell short");788                    require((afterBalance1 - beforeBalance) > 0, "sell returned 0");789                    emit Harvested(pid, var_c.length - accountBalance, afterBalance1 - beforeBalance);790                    return abi.encodePacked(var_c.length - accountBalance, afterBalance1 - beforeBalance);791                }792                if (!(0x01 < var_am)) _desolexPanic(50);793                require((var_an / 0x02) > 0, "quote is 0");794                uint256 value1 = 0;795                uint256 value3 = var_c + 0x20;796                uint256 value2 = var_ao;797                uint256 value4 = 0;798                uint256 value5 = var_c;799                uint256 value6 = ((0x04 + var_c) + 0xa0) + 0x20;800                while (true) {801                    if (value1 >= value2) {802                        break;803                    }804                    if ((0x01 + value1) >= value2) {805                        break;806                    }807                    value1 = 0x01 + value1;808                    value3 = value3 + 0x20;809                    value2 = value2;810                    value4 = value4;811                    value5 = value5;812                    value6 = 0x20 + value6;813                    require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);814                    (bool success11, bytes memory returnData11) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance1, (var_an / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0)); // call815                    require(success11);816                    (bool success12, bytes memory returnData12) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall817                    require(success12);818                    uint256 accountBalance_12 = abi.decode(returnData12, (uint256));819                    uint256 afterBalance2 = abi.decode(returnData12, (uint256));820                    require(!((afterBalance2 - beforeBalance) < (accountBalance_12 / 0x02)), "sell short");821                    require((afterBalance2 - beforeBalance) > 0, "sell returned 0");822                    emit Harvested(pid, var_c.length - accountBalance, afterBalance2 - beforeBalance);823                    return abi.encodePacked(var_c.length - accountBalance, afterBalance2 - beforeBalance);824                }825                require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);826                (bool success13, bytes memory returnData13) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance1, (var_an / 0x02), 0xa0, address(this), (block.timestamp + 0x04b0), var_ao); // call827                require(success13);828                (bool success14, bytes memory returnData14) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall829                require(success14);830                uint256 afterBalance3 = abi.decode(returnData14, (uint256));831                require(!((afterBalance3 - beforeBalance) < (var_an / 0x02)), "sell short");832                require((afterBalance3 - beforeBalance) > 0, "sell returned 0");833                emit Harvested(pid, var_c.length - accountBalance, afterBalance3 - beforeBalance);834                return abi.encodePacked(var_c.length - accountBalance, afterBalance3 - beforeBalance);835            }836            (bool success15, bytes memory returnData15) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_d06ca61f(accountBalance1, 0x40, var_y); // staticcall837            require(success15);838            var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData15.length + 0x1f));839            require(!(((var_c + returnData15.length) - var_c) < 0x20));840            require(!(var_c.length > 0xffffffffffffffff));841            require((var_c + returnData15.length) > ((var_c + var_c.length) + 0x1f));842            if (var_ax > 0xffffffffffffffff) _desolexPanic(65);843            if (((var_c + (((var_ay << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((var_ay << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65);844            var_c = var_c + (((var_ay << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));845            require(!((0x20 + ((var_c + var_c.length) + (var_ay << 0x05))) > (var_c + returnData15.length)));846            uint256 value9 = var_c + 0x20;847            uint256 value10 = var_c;848            uint256 value11 = var_af << 0x05;849            uint256 value8 = 0x20 + ((var_c + var_ae) + (var_ah << 0x05));850            uint256 value7 = (var_c + var_ae) + 0x20;851            uint256 value12 = 0;852            uint256 value13 = var_c;853            uint256 value14 = var_c + returnData15.length;854            while (true) {855                if (value7 >= value8) {856                    break;857                }858                value9 = 0x20 + value9;859                value10 = value10;860                value11 = var_aj;861                value8 = value8;862                value7 = 0x20 + value7;863                value12 = value12;864                value13 = value13;865                value14 = value14;866                if (!(0x01 < var_am)) _desolexPanic(50);867                require((var_an / 0x02) > 0, "quote is 0");868                uint256 value1 = 0;869                uint256 value3 = var_c + 0x20;870                uint256 value2 = var_ao;871                uint256 value4 = 0;872                uint256 value5 = var_c;873                uint256 value6 = ((0x04 + var_c) + 0xa0) + 0x20;874                while (true) {875                    if (value1 >= value2) {876                        break;877                    }878                    if ((0x01 + value1) >= value2) {879                        break;880                    }881                    value1 = 0x01 + (0x01 + value1);882                    value3 = (value3 + 0x20) + 0x20;883                    value2 = value2;884                    value4 = value4;885                    value5 = value5;886                    value6 = 0x20 + (0x20 + value6);887                    require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);888                    (bool success16, bytes memory returnData16) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance1, var_an / 0x02, 0xa0, address(this), block.timestamp + 0x04b0); // call889                    require(success16);890                    (bool success17, bytes memory returnData17) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall891                    require(success17);892                    uint256 afterBalance4 = abi.decode(returnData17, (uint256));893                    require(!((afterBalance4 - beforeBalance) < (var_an / 0x02)), "sell short");894                    require((afterBalance4 - beforeBalance) > 0, "sell returned 0");895                    emit Harvested(pid, var_c.length - accountBalance, afterBalance4 - beforeBalance);896                    return abi.encodePacked(var_c.length - accountBalance, afterBalance4 - beforeBalance);897                }898                require(address(0x10ed43c718714eb63d5aa57b78b54704e256024e).code.length != 0x0);899                (bool success18, bytes memory returnData18) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).Unknown_5c11d795(accountBalance1, var_an / 0x02, 0xa0, address(this), block.timestamp + 0x04b0, var_ao); // call900                require(success18);901                (bool success19, bytes memory returnData19) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall902                require(success19);903                uint256 afterBalance5 = abi.decode(returnData19, (uint256));904                require(!((afterBalance5 - beforeBalance) < (var_an / 0x02)), "sell short");905                require((afterBalance5 - beforeBalance) > 0, "sell returned 0");906                emit Harvested(pid, var_c.length - accountBalance, afterBalance5 - beforeBalance);907                return abi.encodePacked(var_c.length - accountBalance, afterBalance5 - beforeBalance);908            }909        } else {910            require(0x0 > 0x0, "sell returned 0");911            emit Harvested(pid, var_c.length - accountBalance, 0);912            return abi.encodePacked(var_c.length - accountBalance, 0);913        }914    }915    916    function claim() public payable onlyOwner returns (uint256) {917        require(0x0 != pid, "no pid");918        (bool success0, bytes memory returnData0) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).balanceOf(address(this)); // staticcall919        require(success0);920        uint256 accountBalance = abi.decode(returnData0, (uint256));921        uint256 var_c;922        var_c = 0x20 + (0x24 + var_c);923        (bool success1, bytes memory returnData1) = address(0xf065a79f1f04a53ff9b23be8b026046640249134).takeReward(var_i); // call924        uint256 value0 = 0x60;925        if (returnData1.length != 0) {926            var_c = var_c + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));927            value0 = var_c;928        }929        if (!(success1)) {930            require(!var_k);931            revert("call failed");932        }933        (bool success2, bytes memory returnData2) = address(0x2b280b233b681f54c04e91341b6b601a1ef1ff77).balanceOf(address(this)); // staticcall934        require(success2);935        var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));936        require(!(((var_c + returnData2.length) - var_c) < 0x20));937        return var_c.length - accountBalance;938    }939    940    function sweep(address token, address recipient) public payable onlyOwner {941        require(recipient != address(0), "zero to");942        uint256 accountBalance = IDesolexERC20(token).balanceOf(address(this));943        require(accountBalance > 0, "nothing to sweep");944        bool transferSucceeded = IDesolexERC20(token).transfer(recipient, accountBalance);945        require(transferSucceeded, "sweep failed");946    }947    948    function buyPower(uint256 amount) public payable onlyOwner {949        require(0x0 != pid, "no pid");950        require((amount >= 0x56bc75e2d63100000 && amount <= 0xd3c21bcecceda1000000), "usdt out of range");951        (bool success0, bytes memory returnData0) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall952        require(success0);953        uint256 accountBalance = abi.decode(returnData0, (uint256));954        require(!(accountBalance < amount), "no usdt");955        (bool success1, bytes memory returnData1) = address(0x55d398326f99059ff775485246999027b3197955).approve(0x9596806b1f375e714be2165dec949e2c1cefbc14, amount); // call956        require(success1);957        bool approvalSucceeded = abi.decode(returnData1, (bool));958        require(approvalSucceeded, "usdt approve failed");959        uint256 var_c;960        var_c = 0x84 + var_c;961        (bool success2, bytes memory returnData2) = address(0x9596806b1f375e714be2165dec949e2c1cefbc14).Unknown_8637548f(var_o, var_p, var_q); // call962        uint256 value0 = 0x60;963        if (returnData2.length != 0) {964            var_c = var_c + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));965            value0 = var_c;966        }967        if (!(success2)) {968            require(!var_s);969            revert("call failed");970        }971        emit Event_62c51f2d(pid, amount);972    }973    974    function distribute() public payable {975        uint256 var_b;976        var_b = var_b + 0x24;977        (bool success0, bytes memory returnData0) = address(0xd056975ec810087d7f400a212459d03b45daa3e7).Unknown_047c7755(); // call978        uint256 value0 = 0x60;979        if (returnData0.length != 0) {980            var_b = var_b + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));981            value0 = var_b;982        }983        if (!(success0)) {984            require(!var_h);985            revert("call failed");986        }987    }988    989    function Unknown_e92788f2(uint256 arg0) public payable onlyOwner returns (uint256) {990        require(!pid, "pid already set");991        (bool success0, bytes memory returnData0) = address(0x4101da71a3d53d26bf9b68d01296164a180f6f2b).balanceOf(address(this)); // staticcall992        require(success0);993        uint256 accountBalance = abi.decode(returnData0, (uint256));994        uint256 var_c;995        var_c = 0x20 + (0x24 + var_c);996        (bool success1, bytes memory returnData1) = address(0x0ee6a49bd08af328f4d7f7c686732319087472a7).createRole(var_i); // call997        uint256 value0 = 0x60;998        if (returnData1.length != 0) {999            var_c = var_c + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));1000            value0 = var_c;1001        }1002        if (!(success1)) {1003            require(!var_k);1004            revert("call failed");1005        }1006        (bool success2, bytes memory returnData2) = address(0x4101da71a3d53d26bf9b68d01296164a180f6f2b).balanceOf(address(this)); // staticcall1007        require(success2);1008        var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));1009        require(!(((var_c + returnData2.length) - var_c) < 0x20));1010        require(var_c.length == (accountBalance + 0x01), "pid not minted");1011        (bool success3, bytes memory returnData3) = address(0x4101da71a3d53d26bf9b68d01296164a180f6f2b).tokenOfOwnerByIndex(address(this), var_c.length - 0x01); // staticcall1012        require(success3);1013        var_c = var_c + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));1014        require(!(((var_c + returnData3.length) - var_c) < 0x20));1015        pid = var_c.length;1016        emit Event_78548519(pid);1017        return pid;1018    }1019    1020    function internal_dd8(uint256 arg0) private {1021        // Decompilation incomplete: helper effect provenance is conservative.1022        require(msg.sender == owner, "not owner");1023        require(0x0 != pid, "no pid");1024        require((arg0 >= 0x56bc75e2d63100000 && arg0 <= 0xd3c21bcecceda1000000), "usdt out of range");1025        (bool success0, bytes memory returnData0) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall1026        require(success0);1027        uint256 accountBalance1 = abi.decode(returnData0, (uint256));1028        require(!(accountBalance1 < arg0), "no usdt");1029        (bool success1, bytes memory returnData1) = address(0x55d398326f99059ff775485246999027b3197955).approve(0x9596806b1f375e714be2165dec949e2c1cefbc14, arg0); // call1030        require(success1);1031        bool approvalSucceeded = abi.decode(returnData1, (bool));1032        require(approvalSucceeded, "usdt approve failed");1033        var_c = 0x84 + var_c;1034        (bool success2, bytes memory returnData2) = address(0x9596806b1f375e714be2165dec949e2c1cefbc14).Unknown_8637548f(var_y, var_z, var_aa); // call1035        uint256 value2 = 0x60;1036        if (returnData2.length != 0) {1037            var_c = var_c + ((returnData2.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));1038            value2 = var_c;1039        }1040        if (!(success2)) {1041            require(!var_ac);1042            revert("call failed");1043        }1044        emit Event_62c51f2d(pid, arg0);1045    }1046    1047    function __desolexSelectorShim(uint32 rewrittenSelector) private {1048        assembly {1049            let input := mload(0x40)1050            calldatacopy(input, 0, calldatasize())1051            mstore(input, or(and(mload(input), 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(224, and(rewrittenSelector, 0xffffffff))))1052            let success := delegatecall(gas(), address(), input, calldatasize(), 0, 0)1053            let size := returndatasize()1054            returndatacopy(input, 0, size)1055            switch success1056            case 0 { revert(input, size) }1057            default { return(input, size) }1058        }1059    }1060    1061    // Note: This selector table is synthetic and is not part of the original Solidity source.1062    // It records the recovered selector-to-signature mapping without executable behavior.1063    1064    // 0x03ff07ec => Unknown_03ff07ec()1065    // 0x150b7a02 => onERC721Received(address,address,uint256,bytes)1066    // 0x1b0d8aab => setPid(uint256)1067    // 0x32fe7b26 => ROUTER()1068    // 0x33257ccf => Unknown_33257ccf()1069    // 0x33b326f8 => runDay()1070    // 0x39363112 => REG()1071    // 0x4313b9e5 => setup(uint256)1072    // 0x4641257d => harvest()1073    // 0x4e71d92d => claim()1074    // 0x7bf544d5 => SEASON()1075    // 0x7c0b8de2 => NFT()1076    // 0x7e4fadf7 => PANCAKE()1077    // 0x8da5cb5b => owner()1078    // 0xb8dc491b => sweep(address,address)1079    // 0xbcf0196b => AC()1080    // 0xc54e44eb => USDT()1081    // 0xcab34c08 => REWARD()1082    // 0xe29a8d09 => buyPower(uint256)1083    // 0xe4fc6b6d => distribute()1084    // 0xe92788f2 => Unknown_e92788f2(uint256)1085    // 0xf1068454 => pid()1086}