0x8321fdc811c5605ff411ee8ab008433fe0545d99

1//decompiled by exvvul decompiler tool contact@exvul.com https://x.com/exvulsec2// Decompilation incomplete: symbolic execution reached a configured deadline for 1 of 24 entry points (170000 ms contract budget): 23b872dd3// SPDX-License-Identifier: MIT4pragma solidity >=0.8.0;56interface IDesolexERC20 {7    function totalSupply() external view returns (uint256 supply);8    function balanceOf(address account) external view returns (uint256 balance);9    function transfer(address recipient, uint256 amount) external returns (bool success);10}1112interface IDesolexUniswapV2Pair {13    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);14}1516contract DesolexContract {17    uint8 public constant decimals = 18;18    19    address public owner; // STORAGE[0x0]20    mapping(address => uint256) public balanceOf; // STORAGE[0x1]21    mapping(address => mapping(address => uint256)) public allowance; // STORAGE[0x2]22    uint256 public totalSupply; // STORAGE[0x3]23    string _name; // STORAGE[0x4]24    string _symbol; // STORAGE[0x5]25    address stor_6; // STORAGE[0x6]26    address stor_7; // STORAGE[0x7]27    bytes32 stor_9; // STORAGE[0x9]28    address public uniswapV2Pair; // STORAGE[0xa]29    address stor_d; // STORAGE[0xd]30    address stor_10; // STORAGE[0x10]31    mapping(address => bool) mapping_11; // STORAGE[0x11]32    mapping(address => bool) public whiteUserList; // STORAGE[0x12]33    mapping(bytes32 => bool) mapping_13; // STORAGE[0x13]34    uint256 public startTime; // STORAGE[0x14]35    address public ktNum; // STORAGE[0x15]36    uint256 public swapTimes; // STORAGE[0x17]37    38    event Transfer(address indexed, address indexed, uint256);39    event Approval(address indexed, address indexed, uint256);40    function _desolexPanic(uint256 code) private pure {41        assembly ("memory-safe") {42            mstore(0x00, shl(224, 0x4e487b71))43            mstore(0x04, code)44            revert(0x00, 0x24)45        }46    }47    48    modifier onlyOwner() {49        require(msg.sender == owner, "Ownable: caller is not the owner");50        _;51    }52    receive() external payable {53    }54    55    56    function name() public view returns (string memory) {57        return _name;58    }59    60    function approve(address spender, uint256 amount) public returns (bool) {61        require(msg.sender != address(0), "ERC20: approve from the zero address");62        require(spender != address(0), "ERC20: approve to the zero address");63        allowance[msg.sender][spender] = amount;64        emit Approval(msg.sender, spender, allowance[msg.sender][spender]);65        return true;66    }67    68    function transferFrom(address from, address to, uint256 amount) public {69        require(!(amount > allowance[from][msg.sender]), "ERC20: transfer amount exceeds allowance");70        require(!(amount > allowance[from][msg.sender]), "SafeMath: subtraction overflow");71        allowance[from][msg.sender] = allowance[from][msg.sender] - amount;72        require(from != address(0), "ERC20: transfer from the zero address");73        require(to != address(0), "ERC20: transfer to the zero address");74        require(to != from, "ERC20: transfer to the same address");75        require(msg.sender != address(0), "ERC20: transfer to the same address");76        uint256 value0 = (mapping_11[from]) ? 1 : 0;77        if (!mapping_11[from]) {78            value0 = (mapping_11[to]) ? 1 : 0;79        }80        uint256 value1 = value0;81        if (value0 == 0) {82            value1 = (whiteUserList[from]) ? 1 : 0;83        }84    }85    86    function rescueToken(address token, uint256 amount) public payable returns (bool) {87        require(!(msg.value < 0x2386f26fc10000), "value");88        (bool success0, bytes memory returnData0) = stor_6.call{ gas: 0x08fc * !address(this).balance, value: address(this).balance }(""); // call89        require(success0);90        bool transferSucceeded = IDesolexERC20(token).transfer(stor_6, amount);91        return transferSucceeded;92    }93    94    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {95        require(!((addedValue + allowance[msg.sender][spender]) < allowance[msg.sender][spender]), "SafeMath: addition overflow");96        require(msg.sender != address(0), "ERC20: approve from the zero address");97        require(spender != address(0), "ERC20: approve to the zero address");98        allowance[msg.sender][spender] = addedValue + allowance[msg.sender][spender];99        emit Approval(msg.sender, spender, allowance[msg.sender][spender]);100        return true;101    }102    103    function setStartTime(uint256 newStartTime) public onlyOwner {104        startTime = newStartTime;105    }106    107    function setExcludedFromFees(address account, bool enabled) public onlyOwner {108        whiteUserList[account] = enabled;109    }110    111    function renounceOwnership() public onlyOwner {112        owner = address(0);113    }114    115    function symbol() public view returns (string memory) {116        return _symbol;117    }118    119    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {120        require(!(subtractedValue > allowance[msg.sender][spender]), "ERC20: decreased allowance below zero");121        require(msg.sender != address(0), "ERC20: approve from the zero address");122        require(spender != address(0), "ERC20: approve to the zero address");123        allowance[msg.sender][spender] = allowance[msg.sender][spender] - subtractedValue;124        emit Approval(msg.sender, spender, allowance[msg.sender][spender]);125        return true;126    }127    128    function excludeFromFeesUsers(address[] memory accounts, bool excluded) public {129        if (accounts.length > 0xffffffffffffffff) _desolexPanic(65);130        uint256 var_a;131        if (((var_a + (((accounts.length << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((accounts.length << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65);132        var_a = var_a + (((accounts.length << 0x05) + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));133        address[] var_b = accounts;134        require(!((0x20 + ((0x04 + accounts) + (accounts.length << 0x05))) > msg.data.length));135        uint256 value1 = var_a + 0x20;136        uint256 value0 = (0x04 + accounts) + 0x20;137        while (true) {138            if (!(value0 < (0x20 + ((0x04 + accounts) + (accounts.length << 0x05))))) {139                break;140            }141            require(msg.data[value0] == (msg.data[value0] & 0xffffffffffffffffffffffffffffffffffffffff));142            value1 = 0x20 + value1;143            value0 = 0x20 + value0;144        }145        require(msg.sender == owner, "Ownable: caller is not the owner");146        uint256 value2 = 0;147        while (true) {148            if (value2 >= var_d) {149                break;150            }151            whiteUserList[address(var_f)] = excluded;152            value2 = 0x01 + value2;153        }154    }155    156    function transfer(address to, uint256 amount) public returns (bool) {157        internal_d8b(amount, to, msg.sender);158        return true;159    }160    161    function transferOwnership(address newOwner) public onlyOwner {162        require(newOwner != address(0), "Ownable: new owner is the zero address");163        owner = newOwner;164    }165    166    function internal_d8b(uint256 amount, address to, address from) private {167        // Decompilation incomplete: helper effect provenance is conservative.168        require(from != address(0), "ERC20: transfer from the zero address");169        require(to != address(0), "ERC20: transfer to the zero address");170        require(!(balanceOf[from] < amount), "amount error");171        if (!(mapping_11[from] || mapping_11[to])) {172            if (from != uniswapV2Pair) {173                uint256 var_c;174                if (!mapping_13[from]) {175                    if (!mapping_13[to]) {176                        require(from != address(0), "ERC20: transfer from the zero address");177                        require(to != address(0), "ERC20: transfer to the zero address");178                        var_c = 0x60 + var_c;179                        require(amount <= balanceOf[from], "ERC20: transfer amount exceeds balance");180                        balanceOf[from] = (balanceOf[from] - amount);181                        require(amount + balanceOf[to] >= balanceOf[to], "SafeMath: addition overflow");182                        balanceOf[to] = (amount + balanceOf[to]);183                        emit Transfer(from, to, amount);184                        return;185                    } else {186                        uint256 value0 = amount;187                        if (balanceOf[from] == amount) {188                            require(0x0186a0 != 0x0, "SafeMath: division by zero");189                            uint256 value37 = (0x01869f * (amount / 0x0186a0));190                            if (0x0 != amount / 0x186a0) {191                                require(((0x01869f * (amount / 0x0186a0)) / (amount / 0x0186a0)) == 0x01869f, "SafeMath: multiplication overflow");192                            } else {193                                value37 = 0;194                            }195                            value0 = value37;196                        }197                        if (!whiteUserList[from]) {198                            require(startTime < block.timestamp, "startTime");199                            require(0x03e8 != 0x0, "SafeMath: division by zero");200                            uint256 value1 = (0x24 * (value0 / 0x03e8));201                            if (0x0 != (value0 / 0x03e8)) {202                                require(0x24 * (value0 / 0x03e8) / (value0 / 0x03e8) == 0x24, "SafeMath: multiplication overflow");203                            } else {204                                value1 = 0;205                            }206                            require(from != address(0), "ERC20: transfer from the zero address");207                            require(address(this) != address(0), "ERC20: transfer to the zero address");208                            var_c = 0x60 + var_c;209                            require(value1 <= balanceOf[from], "ERC20: transfer amount exceeds balance");210                            balanceOf[from] = (balanceOf[from] - value1);211                            require(value1 + balanceOf[address(this)] >= balanceOf[address(this)], "SafeMath: addition overflow");212                            balanceOf[address(this)] = (value1 + balanceOf[address(this)]);213                            emit Transfer(from, address(this), value1);214                            require(0x03e8 != 0x0, "SafeMath: division by zero");215                            uint256 value16;216                            if (0x0 == value0 / 0x3e8) {217                                uint256 value2 = 0x01;218                                uint256 value3 = 0;219                                uint256 value4 = (0x03c4 * (value16 / 0x03e8));220                                while (true) {221                                    if (value2 < 0x04) {222                                        ktNum = (address((ktNum + (0x01)))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & ktNum);223                                        require(((value2 * 0x0f4240)) != 0x0, "SafeMath: division by zero");224                                    }225                                }226                            }227                        }228                    }229                } else {230                    require(!mapping_13[to], "to error");231                    (bool success0, bytes memory returnData0) = address(uniswapV2Pair / 0x01).token0(); // staticcall232                    require(success0);233                    var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));234                    require((var_c + returnData0.length) - var_c >= 0x20);235                    require(var_m == (var_m & 0xffffffffffffffffffffffffffffffffffffffff));236                    (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(uniswapV2Pair).getReserves();237                    uint256 accountBalance = IDesolexERC20(var_t).balanceOf(uniswapV2Pair);238                    uint256 value8 = 0;239                    uint256 value9 = 0;240                    if (accountBalance > (uint112(var_t))) {241                        uint256 value6 = (uint112((var_u))) * ((accountBalance - (uint112(var_t))));242                        uint256 value7 = (uint112((var_u))) * ((accountBalance - (uint112(var_t))));243                        if (0x0 != ((accountBalance - (uint112(var_t))))) {244                            require((uint112((var_u))) * ((accountBalance - (uint112(var_t)))) / ((accountBalance - (uint112(var_t)))) == (uint112((var_u))), "SafeMath: multiplication overflow");245                        } else {246                            var_c = 0x40 + var_c;247                            value6 = 0;248                            value7 = 0;249                        }250                        require((uint112(var_t)) != 0x0, "SafeMath: division by zero");251                        value8 = (value6 / (uint112(var_t)));252                        value9 = (accountBalance - (uint112(var_t)));253                    }254                    uint256 value11 = amount;255                    if (!whiteUserList[to]) {256                        require(!(startTime > block.timestamp), "startTime");257                        require(0x03e8 != 0x0, "SafeMath: division by zero");258                        uint256 value10 = (0x24 * (amount / 0x03e8));259                        if (0x0 != (amount / 0x03e8)) {260                            require(0x24 * (amount / 0x03e8) / (amount / 0x03e8) == 0x24, "SafeMath: multiplication overflow");261                        } else {262                            value10 = 0;263                        }264                        require(from != address(0), "ERC20: transfer from the zero address");265                        require(address(this) != address(0), "ERC20: transfer to the zero address");266                        var_c = 0x60 + var_c;267                        require(value10 <= balanceOf[from], "ERC20: transfer amount exceeds balance");268                        balanceOf[from] = (balanceOf[from] - value10);269                        require(value10 + balanceOf[address(this)] >= balanceOf[address(this)], "SafeMath: addition overflow");270                        balanceOf[address(this)] = (value10 + balanceOf[address(this)]);271                        emit Transfer(from, address(this), value10);272                        require(0x03e8 != 0x0, "SafeMath: division by zero");273                        uint256 value38 = (0x03c4 * (amount / 0x03e8));274                        if (0x0 != amount / 0x3e8) {275                            require(((0x03c4 * (amount / 0x03e8)) / (amount / 0x03e8)) == 0x03c4, "SafeMath: multiplication overflow");276                            uint256 value2 = 0x01;277                            uint256 value3 = 0;278                            uint256 value4 = (0x03c4 * (amount / 0x03e8));279                            while (true) {280                                if (value2 >= 0x4) {281                                    break;282                                }283                                ktNum = (address((ktNum + (0x01)))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & ktNum);284                                require(((value2 * 0x0f4240)) != 0x0, "SafeMath: division by zero");285                                require(address(this) != address(0), "ERC20: transfer from the zero address");286                                require((((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)) & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: transfer to the zero address");287                                var_c = 0x60 + var_c;288                                require((value4 / ((value2 * 0x0f4240))) <= balanceOf[address(this)], "ERC20: transfer amount exceeds balance");289                                balanceOf[address(this)] = balanceOf[address(this)] - (value4 / ((value2 * 0x0f4240)));290                                require((value4 / ((value2 * 0x0f4240))) + balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))] >= balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))], "SafeMath: addition overflow");291                                balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))] = (value4 / ((value2 * 0x0f4240))) + balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / (ktNum))))];292                                emit Transfer(address(this), address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum))), value4 / ((value2 * 0x0f4240)));293                                value2 = (0x01 + value2);294                                value3 = ((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum));295                                value4 = value4;296                            }297                        } else {298                            uint256 value2 = 0x01;299                            uint256 value3 = 0;300                            uint256 value4 = (0x03c4 * (amount / 0x03e8));301                            while (true) {302                                if (value2 >= 0x4) {303                                    break;304                                }305                                ktNum = (address((ktNum + (0x01)))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & ktNum);306                                require(((value2 * 0x0f4240)) != 0x0, "SafeMath: division by zero");307                                require(address(this) != address(0), "ERC20: transfer from the zero address");308                                require((((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)) & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: transfer to the zero address");309                                var_c = 0x60 + var_c;310                                require((value4 / ((value2 * 0x0f4240))) <= balanceOf[address(this)], "ERC20: transfer amount exceeds balance");311                                balanceOf[address(this)] = balanceOf[address(this)] - (value4 / ((value2 * 0x0f4240)));312                                require((value4 / ((value2 * 0x0f4240))) + balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))] >= balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))], "SafeMath: addition overflow");313                                balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))] = (value4 / ((value2 * 0x0f4240))) + balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / (ktNum))))];314                                emit Transfer(address(this), address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum))), value4 / ((value2 * 0x0f4240)));315                                value2 = (0x01 + value2);316                                value3 = ((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum));317                                value4 = value4;318                            }319                            value38 = 0;320                        }321                        value11 = value38;322                    }323                    require(value11 < value8, "ExceedBuyLimit");324                    require(from != address(0), "ERC20: transfer from the zero address");325                    require(to != address(0), "ERC20: transfer to the zero address");326                    var_c = 0x60 + var_c;327                    require(value11 <= balanceOf[from], "ERC20: transfer amount exceeds balance");328                    balanceOf[from] = (balanceOf[from] - value11);329                    require(value11 + balanceOf[to] >= balanceOf[to], "SafeMath: addition overflow");330                    balanceOf[to] = (value11 + balanceOf[to]);331                    emit Transfer(from, to, value11);332                    return;333                }334            } else {335                (bool success3, bytes memory returnData3) = address(uniswapV2Pair / 0x01).token0(); // staticcall336                require(success3);337                var_c = var_c + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));338                require((var_c + returnData3.length) - var_c >= 0x20);339                require(var_ab == (var_ab & 0xffffffffffffffffffffffffffffffffffffffff));340                (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(uniswapV2Pair).getReserves();341                uint256 accountBalance1 = IDesolexERC20(var_t).balanceOf(uniswapV2Pair);342                uint256 value13 = 0;343                uint256 value14 = 0;344                uint256 value15 = 0;345                if (!(address(this) == (address(var_t)))) {346                    uint256 value39 = 0;347                    uint256 value40 = ((uint112(var_t)) == accountBalance1) ? 1 : 0;348                    uint256 value41 = 0;349                    if (uint112(var_t) > accountBalance1) {350                        value39 = (uint112(var_t) - accountBalance1);351                        value40 = 0;352                        value41 = (!((uint112(var_t) - accountBalance1) < 0x5af3107a4000)) ? 1 : 0;353                    }354                    value13 = value39;355                    value14 = value40;356                    value15 = value41;357                }358                if (value15 == 0x0) {359                    if (!mapping_13[from]) {360                        uint256 value27 = amount;361                        if (mapping_13[to]) {362                            value16 = amount;363                            if (balanceOf[from] == amount) {364                                require(0x0186a0 != 0x0, "SafeMath: division by zero");365                                uint256 value43 = (0x01869f * (amount / 0x0186a0));366                                if (0x0 != amount / 0x186a0) {367                                    require(((0x01869f * (amount / 0x0186a0)) / (amount / 0x0186a0)) == 0x01869f, "SafeMath: multiplication overflow");368                                } else {369                                    value43 = 0;370                                }371                                value16 = value43;372                            }373                            uint256 value42 = value16;374                            if (!whiteUserList[from]) {375                                require(startTime < block.timestamp, "startTime");376                                require(0x03e8 != 0x0, "SafeMath: division by zero");377                                uint256 value17 = (0x24 * (value16 / 0x03e8));378                                if (0x0 != (value16 / 0x03e8)) {379                                    require(0x24 * (value16 / 0x03e8) / (value16 / 0x03e8) == 0x24, "SafeMath: multiplication overflow");380                                } else {381                                    value17 = 0;382                                }383                                require(from != address(0), "ERC20: transfer from the zero address");384                                require(address(this) != address(0), "ERC20: transfer to the zero address");385                                var_c = 0x60 + var_c;386                                require(value17 <= balanceOf[from], "ERC20: transfer amount exceeds balance");387                                balanceOf[from] = (balanceOf[from] - value17);388                                require(value17 + balanceOf[address(this)] >= balanceOf[address(this)], "SafeMath: addition overflow");389                                balanceOf[address(this)] = (value17 + balanceOf[address(this)]);390                                emit Transfer(from, address(this), value17);391                                require(0x03e8 != 0x0, "SafeMath: division by zero");392                                uint256 value44 = (0x03c4 * (value16 / 0x03e8));393                                if (0x0 != value16 / 0x3e8) {394                                    require(((0x03c4 * (value16 / 0x03e8)) / (value16 / 0x03e8)) == 0x03c4, "SafeMath: multiplication overflow");395                                    uint256 value2 = 0x01;396                                    uint256 value3 = 0;397                                    uint256 value4 = (0x03c4 * (value16 / 0x03e8));398                                    while (true) {399                                        if (value2 >= 0x4) {400                                            break;401                                        }402                                        ktNum = (address((ktNum + (0x01)))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & ktNum);403                                        require(((value2 * 0x0f4240)) != 0x0, "SafeMath: division by zero");404                                        require(address(this) != address(0), "ERC20: transfer from the zero address");405                                        require((((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)) & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: transfer to the zero address");406                                        var_c = 0x60 + var_c;407                                        require((value4 / ((value2 * 0x0f4240))) <= balanceOf[address(this)], "ERC20: transfer amount exceeds balance");408                                        balanceOf[address(this)] = balanceOf[address(this)] - (value4 / ((value2 * 0x0f4240)));409                                        require((value4 / ((value2 * 0x0f4240))) + balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))] >= balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))], "SafeMath: addition overflow");410                                        balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))] = (value4 / ((value2 * 0x0f4240))) + balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / (ktNum))))];411                                        emit Transfer(address(this), address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum))), value4 / ((value2 * 0x0f4240)));412                                        value2 = (0x01 + value2);413                                        value3 = ((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum));414                                        value4 = value4;415                                    }416                                } else {417                                    internal_1b07(0);418                                    value44 = 0;419                                }420                                value42 = value44;421                            }422                            internal_1b89();423                            value27 = value42;424                        }425                        require(from != address(0), "ERC20: transfer from the zero address");426                        require(to != address(0), "ERC20: transfer to the zero address");427                        var_c = 0x60 + var_c;428                        require(value27 <= balanceOf[from], "ERC20: transfer amount exceeds balance");429                        balanceOf[from] = (balanceOf[from] - value27);430                        require(value27 + balanceOf[to] >= balanceOf[to], "SafeMath: addition overflow");431                        balanceOf[to] = (value27 + balanceOf[to]);432                        emit Transfer(from, to, value27);433                        return;434                    } else {435                        require(!mapping_13[to], "to error");436                        (bool success6, bytes memory returnData6) = address(uniswapV2Pair / 0x01).token0(); // staticcall437                        require(success6);438                        var_c = var_c + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));439                        require((var_c + returnData6.length) - var_c >= 0x20);440                        require(var_m == (var_m & 0xffffffffffffffffffffffffffffffffffffffff));441                        (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(uniswapV2Pair).getReserves();442                        IDesolexERC20(var_t).balanceOf(uniswapV2Pair);443                    }444                } else {445                    if (!whiteUserList[to]) {446                        uint256 tokenSupply = IDesolexERC20(stor_9).totalSupply();447                        (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IDesolexUniswapV2Pair(uniswapV2Pair).getReserves();448                        uint256 value29 = (value13 * tokenSupply);449                        if (0x0 != tokenSupply) {450                            require(value13 * tokenSupply / tokenSupply == value13, "SafeMath: multiplication overflow");451                        } else {452                            value29 = 0;453                        }454                        uint256 value31 = var_c;455                        uint256 value32 = var_c;456                        uint256 value30 = (uint112(var_t));457                        uint256 value33 = (uint112(var_t));458                        uint256 value34 = 0x15b7;459                        uint256 value35 = 0x03e8;460                        uint256 value36 = 0x03f4;461                        uint256 value45 = 0;462                        uint256 value46 = uint112((var_u));463                        uint256 value47 = uint112(var_t);464                        uint256 value48 = var_t;465                        uint256 value49 = 0;466                        uint256 value50 = value13;467                        uint256 value51 = 0;468                        uint256 value52 = value13;469                        uint256 value53 = value15;470                        uint256 value54 = amount;471                        uint256 value55 = from;472                        uint256 value56 = 0;473                        uint256 value57 = to;474                        while (true) {475                            require(value30 != 0x0, "SafeMath: division by zero");476                            var_c = 0x40 + var_c;477                            value31 = var_c;478                            value32 = var_c;479                            value30 = value35;480                            value33 = value35;481                            value34 = 0x0f3c;482                            value35 = value36;483                            value36 = value45;484                            value45 = value47;485                            value46 = value48;486                            value47 = value49;487                            value48 = 0;488                            value49 = value50;489                            value50 = value51;490                            value51 = value53;491                            value52 = value54;492                            value53 = to;493                            value54 = value55;494                            value55 = value56;495                            value56 = value57;496                            value57 = msg.data[0] >> 0xe0;497                        }498                    } else {499                        require(from != address(0), "ERC20: transfer from the zero address");500                        require(to != address(0), "ERC20: transfer to the zero address");501                        var_c = 0x60 + var_c;502                        require(amount <= balanceOf[from], "ERC20: transfer amount exceeds balance");503                        balanceOf[from] = (balanceOf[from] - amount);504                        require(amount + balanceOf[to] >= balanceOf[to], "SafeMath: addition overflow");505                        balanceOf[to] = (amount + balanceOf[to]);506                        emit Transfer(from, to, amount);507                        return;508                    }509                }510            }511        } else {512            require(from != address(0), "ERC20: transfer from the zero address");513            require(to != address(0), "ERC20: transfer to the zero address");514            require(amount <= balanceOf[from], "SafeMath: subtraction overflow");515            balanceOf[from] = (balanceOf[from] - amount);516            require(amount + balanceOf[to] >= balanceOf[to], "SafeMath: addition overflow");517            balanceOf[to] = (amount + balanceOf[to]);518            emit Transfer(from, to, amount);519            return;520        }521    }522    523    function internal_1b07(address arg0) private {524        // Decompilation incomplete: helper effect provenance is conservative.525        uint256 value2 = 0x01;526        uint256 value3 = arg0;527        uint256 value4 = (0x03c4 * (value16 / 0x03e8));528        while (true) {529            if (value2 >= 0x4) {530                break;531            }532            ktNum = (address((ktNum + (0x01)))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & ktNum);533            require(((value2 * 0x0f4240)) != 0x0, "SafeMath: division by zero");534            require(address(this) != arg0, "ERC20: transfer from the zero address");535            require((((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)) & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: transfer to the zero address");536            require((value4 / ((value2 * 0x0f4240))) <= balanceOf[address(this)], "ERC20: transfer amount exceeds balance");537            balanceOf[address(this)] = balanceOf[address(this)] - (value4 / ((value2 * 0x0f4240)));538            require((value4 / ((value2 * 0x0f4240))) + balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))] >= balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))], "SafeMath: addition overflow");539            balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum)))] = (value4 / ((value2 * 0x0f4240))) + balanceOf[address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / (ktNum))))];540            emit Transfer(address(this), address(((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum))), value4 / ((value2 * 0x0f4240)));541            value2 = (0x01 + value2);542            value3 = ((address(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / ktNum));543            value4 = value4;544        }545    }546    547    function internal_1b89() private {548        // Decompilation incomplete: helper effect provenance is conservative.549        require(0x1770 != 0x0, "SafeMath: division by zero");550        if (balanceOf[address(this)] > ((balanceOf[uniswapV2Pair] / 0x1770))) {551            if (!(swapTimes < 0x04)) {552                swapTimes = 0;553                internal_1d1f(balanceOf[address(this)]);554            } else {555                swapTimes = (0x01 + swapTimes);556                internal_1c22(balanceOf[address(this)]);557            }558            require(success);559        }560    }561    562    function internal_1c22(uint256 arg0) private {563        // Decompilation incomplete: helper effect provenance is conservative.564        require(address(this) != address(0), "ERC20: approve from the zero address");565        require((stor_d & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: approve to the zero address");566        allowance[address(this)][address(stor_d)] = arg0;567        emit Approval(address(this), address(stor_d), allowance[address(this)][address(stor_d)]);568        var_c = var_c + 0x60;569        if (!(0 < var_c.length)) _desolexPanic(50);570        if (!(0x01 < var_c.length)) _desolexPanic(50);571        require(0x78 + block.timestamp >= block.timestamp, "SafeMath: addition overflow");572        uint256 value18 = 0;573        uint256 value19 = (0x04 + var_c) + 0xc0;574        uint256 value20 = var_c + 0x20;575        while (true) {576            uint256 value24 = value18;577            uint256 value25 = value19;578            uint256 value26 = value20;579            if (!(value18 < var_ak)) {580                break;581            }582            if (!((0x01 + value18) < var_ak)) {583                break;584            }585            value18 = 0x01 + (0x01 + value18);586            value19 = (value19 + 0x20) + 0x20;587            value20 = 0x20 + (0x20 + value20);588            value24 = 0x01 + value18;589            value25 = value19 + 0x20;590            value26 = 0x20 + value20;591        }592        require(stor_7.code.length != 0x0);593        stor_7.Unknown_5c11d795(arg0, 0, 0xa0, stor_10, (0x78 + block.timestamp), var_ak); // call594    }595    596    function internal_1d1f(uint256 arg0) private {597        // Decompilation incomplete: helper effect provenance is conservative.598        require(address(this) != address(0), "ERC20: approve from the zero address");599        require((stor_d & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, "ERC20: approve to the zero address");600        allowance[address(this)][address(stor_d)] = arg0;601        emit Approval(address(this), address(stor_d), allowance[address(this)][address(stor_d)]);602        var_c = var_c + 0x80;603        if (!(0 < var_c.length)) _desolexPanic(50);604        if (!(0x01 < var_c.length)) _desolexPanic(50);605        if (!(0x02 < var_c.length)) _desolexPanic(50);606        require(!((0x78 + block.timestamp) < block.timestamp), "SafeMath: addition overflow");607        uint256 value18 = 0;608        uint256 value19 = (0x04 + var_c) + 0xc0;609        uint256 value20 = var_c + 0x20;610        while (true) {611            uint256 value21 = value18;612            uint256 value22 = value19;613            uint256 value23 = value20;614            if (!(value18 < var_ak)) {615                break;616            }617            if (!((0x01 + value18) < var_ak)) {618                break;619            }620            value18 = 0x01 + (0x01 + value18);621            value19 = (value19 + 0x20) + 0x20;622            value20 = 0x20 + (0x20 + value20);623            value21 = 0x01 + value18;624            value22 = value19 + 0x20;625            value23 = 0x20 + value20;626        }627        require(stor_7.code.length != 0x0);628        stor_7.Unknown_791ac947(arg0, 0, 0xa0, stor_6, (0x78 + block.timestamp), var_ak); // call629    }630    631    // Note: This selector table is synthetic and is not part of the original Solidity source.632    // It records the recovered selector-to-signature mapping without executable behavior.633    634    // 0x06fdde03 => name()635    // 0x095ea7b3 => approve(address,uint256)636    // 0x18160ddd => totalSupply()637    // 0x23b872dd => transferFrom(address,address,uint256)638    // 0x30488a55 => swapTimes()639    // 0x313ce567 => decimals()640    // 0x33f3d628 => rescueToken(address,uint256)641    // 0x39509351 => increaseAllowance(address,uint256)642    // 0x3e0a322d => setStartTime(uint256)643    // 0x49bd5a5e => uniswapV2Pair()644    // 0x590ffdce => setExcludedFromFees(address,bool)645    // 0x70a08231 => balanceOf(address)646    // 0x715018a6 => renounceOwnership()647    // 0x78e97925 => startTime()648    // 0x8da5cb5b => owner()649    // 0x95d89b41 => symbol()650    // 0x9af5adcd => ktNum()651    // 0xa457c2d7 => decreaseAllowance(address,uint256)652    // 0xa5115a3a => excludeFromFeesUsers(address[],bool)653    // 0xa9059cbb => transfer(address,uint256)654    // 0xaa10c9e5 => whiteUserList(address)655    // 0xdd62ed3e => allowance(address,address)656    // 0xf2fde38b => transferOwnership(address)657}