I will give you solidity based BSC chain crypto token contract. Make it upgradable(proxy) and add all possible features to it, but keep the code I gave you. Preserve imports and use them in newly generated code. Generate full contract code in response. Contract is:
pragma solidity ^0.8.0;

import “@openzeppelin/contracts/token/ERC20/ERC20.sol”;
import “@openzeppelin/contracts/access/Ownable.sol”;
import “@openzeppelin/contracts/utils/math/SafeMath.sol”;
import “@openzeppelin/contracts/utils/Address.sol”;
import “@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/token/BEP20/IBEP20.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/token/BEP20/extensions/IBEP20Metadata.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/token/BEP20/utils/SafeBEP20.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/access/Ownable.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/utils/Context.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/utils/math/SafeMath.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/utils/Address.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/utils/Arrays.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/interfaces/IPancakeFactory.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/interfaces/IPancakePair.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/interfaces/IPancakeRouter01.sol”;
import “@pancakeswap/pancake-swap-lib/contracts/interfaces/IPancakeRouter02.sol”;


contract Ukraine is Context, IBEP20, Ownable, ERC1967Proxy {
using SafeMath for uint256;
using Address for address;
using SafeBEP20 for IBEP20;

mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;

mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isExcluded;
address[] private _excluded;

uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 * 109;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;

string private _name = “Ukraine”;
string private _symbol = “SFM”;
uint8 private _decimals = 9;

uint256 public _taxFee = 5;
uint256 private _previousTaxFee = _taxFee;

uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;

IPancakeRouter02 public immutable pancakeRouter;
address public immutable pancakePair;

bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;

uint256 public maxTxAmount = 5000000 * 106 * 109;
uint256 private numTokensSellToAddToLiquidity = 500000 * 106 * 10**9;

event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);

modifier lockTheSwap {
inSwapAndLiquify = true;
;
swapAndLiquifyEnabled = false;
}

function _transfer(
address from,
address to,
uint256 amount
) private {
require(from != address(0), “BEP20: transfer from the zero address”);
require(to != address(0), “BEP20: transfer to the zero address”);
require(amount > 0, “Transfer amount must be greater than zero”);

// Check if the transfer is within the maximum transaction amount
if (from != owner() && to != owner()) {
require(amount <= _maxTxAmount, “Transfer amount exceeds the maximum transaction amount”);
}

// Determine if the transaction is a buy or sell
bool isSell = from == pancakePair || to == pancakePair;

// Handle liquidity and token transfer differently for buy and sell transactions
if (isSell && swapAndLiquifyEnabled) {
_swapAndLiquify(to, amount);
} else {
_tokenTransfer(from, to, amount);
}
}

function _swapAndLiquify(address to, uint256 amount) private lockTheSwap {
// Split the amount into halves for liquidity and token conversion
uint256 half = amount.div(2);
uint256 otherHalf = amount.sub(half);

// Capture the initial contract balance
uint256 initialBalance = address(this).balance;

// Swap tokens for BNB
_swapTokensForBNB(half);

// Calculate the amount of BNB obtained from the swap
uint256 newBalance = address(this).balance.sub(initialBalance);

// Add liquidity to PancakeSwap
_addLiquidity(otherHalf, newBalance);

// Transfer the remaining BNB to the recipient
_transferBNB(to, address(this).balance);
}

function _swapTokensForBNB(uint256 tokenAmount) private {
// Generate the PancakeSwap pair path
address[] memory path = new address;
path[0] = address(this);
path[1] = pancakeRouter.WETH();

// Approve the token transfer to the PancakeSwap router
_approve(address(this), address(pancakeRouter), tokenAmount);

// Perform the token swap
pancakeRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp
);
}

function _addLiquidity(uint256 tokenAmount, uint256 bnbAmount) private {
// Approve the token transfer to the PancakeSwap router
_approve(address(this), address(pancakeRouter), tokenAmount);

// Add liquidity to the PancakeSwap pair
pancakeRouter.addLiquidityETH{value: bnbAmount}(
address(this),
tokenAmount,
0,
0,
owner(),
block.timestamp
);
}

function _transferBNB(address recipient, uint256 amount) private {
// Transfer BNB to the recipient
(bool success,) = recipient.call{value: amount}(“”);
require(success, “BNB transfer failed”);
}

function _tokenTransfer(address sender, address recipient, uint256 amount) private {
// Check if the transfer involves a fee
if (!_isExcludedFromFee[sender] && !_isExcludedFromFee[recipient]) {
// Apply the transaction fees
uint256 feeAmount = amount.mul(_taxFee.add(_liquidityFee)).div(100);
amount = amount.sub(feeAmount);

// Update the fee





// Transfer the fee amount to the fee wallet
_tokenTransfer(sender, feeWallet, feeAmount);
}

// Transfer the remaining token amount to the recipient
_tokenTransfer(sender, recipient, amount);

// Update the balance and total supply for both sender and recipient
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);

// Emit the transfer event
emit Transfer(sender, recipient, amount);
}

// Additional functions for managing fees and liquidity

function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}

function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}

function setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
_maxTxAmount = maxTxAmount;
}

function setSwapAndLiquifyEnabled(bool enabled) external onlyOwner() {
swapAndLiquifyEnabled = enabled;
emit SwapAndLiquifyEnabledUpdated(enabled);
}

function setFeeWallet(address wallet) external onlyOwner() {
feeWallet = wallet;
}
}