you are solidity programming language expert. I will give you solidity based BSC chain crypto token contract. Make it upgradable(proxy) and add more features to it, but keep the old 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;
}
}