Tokens stuck

Details
I have created a contract for buying tokens but my tokens now stuck i can withdraw bnb but i can't withdraw or sell my tokens even i cannot sell my tokens please help me.
bnb.sol

pragma solidity ^0.8.0;

import "https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/interfaces/IUniswapV2Router02.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol";

contract BlockrunnerV3 {
    address internal constant UNISWAP_ROUTER_ADDRESS = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
    
    mapping (address => bool) internal members;
    address private _owner;

    /**
     * Necessary interfaces.
     */
    IUniswapV2Router02 public uniswapRouter;

    /**
     * Creates an instance of the UniswapV2 Router02 contract.
     * Also adds the contract creator to the list of members.
     */
    constructor() {
        _owner = msg.sender;
        uniswapRouter = IUniswapV2Router02(UNISWAP_ROUTER_ADDRESS);
        // Add the owner to the members mapping
        members[msg.sender] = true;
    }

    /**
     * Access modifier to restrict access to certain methods to only the owner.
     */
    modifier restricted(address account) {
        require(msg.sender == account, "NOT_AUTHORIZED");
        _;
    }
    
    /**
     * _isMember is a private function that returns whether an address
     * is already a member or not.
     */
    function isMember(address member) public view returns(bool) {
        return members[member];
    }
    
    /**
     * addMember adds an address to the members mapping.
     * It is restricted to the owner and the new address can't be a member already.
     */
    function addMember(address member) external restricted(_owner) {
        require(!isMember(member), "ALREADY_A_MEMBER");
        members[member] = true;
    }

    /**
     * getBalance returns the contract's ETH balance.
     */
    function getBalance() external view returns(uint) {
        return address(this).balance;
    }
    
    /**
     * getTokenBalance returns the contract's balance of the token provided as a parameter.
     */
    function getTokenBalance(address tokenAddress) public view returns(uint) {
        return IERC20(tokenAddress).balanceOf(address(this));
    }

    /**
     * withdraw transfers an amount back to the sender. It is restricted
     * to the owner.
     */
    function withdraw(uint amount) external restricted(_owner) {
        payable(msg.sender).transfer(amount);
    }
    
    /**
     * withdrawTokens withdraws an amount of the tokens provided as an address if it has any.
     */
    function withdrawTokens(uint amount, address tokenAddress) external restricted(_owner) {
        require(getTokenBalance(tokenAddress) >= amount, "NOT_ENOUGH_TOKENS");
        IERC20(tokenAddress).transfer(msg.sender, amount);
    }

    /**
     * swapBNB uses the Pancake Router01 contract to swap BNB for tokens using swapExactETHForTokens.
     * _targetToken is the target token address, amountOutMin is the minimum number of tokens
     * wanted (required by the swapExactETHForTokens method), and deadline is the
     * Unix timestamp that marks the end of this swap request.
     * 
     * It requires the caller to be a member.
     */
    function swapETH(address targetToken, uint swapAmount, uint amountOutMin, uint deadline) external {
        require(isMember(msg.sender), "NOT_AUTHORIZED");
        require(address(this).balance > 0, "EMPTY_BALANCE");
        // Path for the swap
        address[] memory path = new address[](2);
        path[0] = uniswapRouter.WETH();
        path[1] = targetToken;

        uniswapRouter.swapExactETHForTokens{value: swapAmount}(amountOutMin, path, address(this), deadline);
    }
    
    function swapAllETH(address targetToken, uint amountOutMin, uint deadline) external {
        require(isMember(msg.sender), "NOT_AUTHORIZED");
        require(address(this).balance > 0, "EMPTY_BALANCE");
        // Path for the swap
        address[] memory path = new address[](2);
        path[0] = uniswapRouter.WETH();
        path[1] = targetToken;

        uniswapRouter.swapExactETHForTokens{value: address(this).balance}(amountOutMin, path, address(this), deadline);
    }
    
    /**
     * swapToken uses the Pancake Router01 contract to swap BNB for tokens using swapExactTokensForTokens.
     * This method is used when the liquidity pair is something other than the target token and BNB.
     * To buy the target token, we specify the route our BNB tokens have to take to buy the target token.
     * 
     * It requires the caller to be a member.
     */ 
    function swapToken(address intermediaryToken, address targetToken, uint swapAmount, uint amountOutMin, uint deadline) external {
        require(isMember(msg.sender), "NOT_AUTHORIZED");
        require(address(this).balance > 0, "EMPTY_BALANCE");
        address[] memory path = new address[](3);
        path[0] = uniswapRouter.WETH();
        path[1] = intermediaryToken;
        path[2] = targetToken;
        
        uniswapRouter.swapExactETHForTokens{value: swapAmount}(amountOutMin, path, address(this), deadline);
    }
    
    function swapAllToken(address intermediaryToken, address targetToken, uint amountOutMin, uint deadline) external {
        require(isMember(msg.sender), "NOT_AUTHORIZED");
        require(address(this).balance > 0, "EMPTY_BALANCE");
        address[] memory path = new address[](3);
        path[0] = uniswapRouter.WETH();
        path[1] = intermediaryToken;
        path[2] = targetToken;
        
        uniswapRouter.swapExactETHForTokens{value: address(this).balance}(amountOutMin, path, address(this), deadline);
    }
    
    function sellETH(address tokenAddress, uint8 percentage, uint amountOutMin, uint deadline) external restricted(_owner) {
        require(percentage <= 100, "WRONG_PERCENTAGE");
        IERC20 token = IERC20(tokenAddress);
        uint amount = percentage * token.balanceOf(address(this)) / 100;
        address[] memory path = new address[](2);
        path[0] = tokenAddress;
        path[1] = uniswapRouter.WETH();
        
        token.approve(address(uniswapRouter), amount+10);
        uniswapRouter.swapExactTokensForETH(amount, amountOutMin, path, address(this), deadline);
    }
    
    function sellToken(address tokenAddress, address intermediaryToken, uint8 percentage, uint amountOutMin, uint deadline) external restricted(_owner) {
        require(percentage <= 100, "WRONG_PERCENTAGE");
        IERC20 token = IERC20(tokenAddress);
        uint amount = percentage * token.balanceOf(address(this)) / 100;
        address[] memory path = new address[](3);
        path[0] = tokenAddress;
        path[1] = intermediaryToken;
        path[2] = uniswapRouter.WETH();
        
        token.approve(address(uniswapRouter), amount+10);
        uniswapRouter.swapExactTokensForETH(amount, amountOutMin, path, address(this), deadline);
    }
    
    // Receive any incoming amount
    receive () external payable {}
}

Environment

Remix

Hi, welcome! :wave:

It seems like you only can call withdraw() correctly, the remaining functions do not work as expect. So what is your contract address?

i can call withdraw but only BNB
not even selling works
or not even token withdraw works
i can pay even if someone can help me get out of my tokens
my contract is

0x48a30833e87d55317a51584fa7a970eeca967bfa

It seems like there are three tokens in your contract.

1. For token: PAYOU, when you withdraw it, you need to unlock it, the requirement is

require(_unlocked[sender], "ERC20: token must be unlocked before transfer.Visit https://payou.finance/ for more info'");

You can have a look at the code of this token.

2. For token: SAFEMOON_DIVIDEND_TRACKER, the same reason just like PAYOU as above

ERC20: token must be unlocked before transfer.Visit https://safemoon-dividend.com/ for more info'

3. For token: VLXPAD, I think you can withdraw it as expected.

VLXPad its not working can you help me ? will pay
when i am calling vlxpad its shows me -3200 error.

Is it possible to verify your contract?