Smart Contract Compilation & Deployment Fix

I need an expert to help me with my ERC-20 Token smart contract. I'm facing compilation errors and issues with function execution.

Key Requirements:
- Extensive experience with ERC-20 Token smart contracts.
- Proficient in identifying and fixing compilation errors.
- Skilled in troubleshooting function execution problems.
- Able to compile and deploy the smart contract successfully.

Please only bid if you have relevant experience and can demonstrate past successful projects of a similar nature. ParserError: Expected pragma, import directive or contract/interface/library/struct/enum/constant/function/error definition.
-ParserError: Expected pragma, import directive or contract/interface/library/struct/enum/constant/function/error definition.
--> artifacts/LeLe4.1.sol:93:1:
|
93 | }
| ^
and here is the contract. // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

interface IUniswapV2Router {
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);

function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IERC20 {
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
}

contract AutoArbitrageBot {
address private immutable owner;
IUniswapV2Router private immutable uniswapRouter;
IUniswapV2Router private immutable sushiRouter;
address private immutable WETH;

event ArbitrageExecuted(uint profit, address indexed executor);
event ProfitWithdrawn(uint amount);

modifier onlyOwner() {
require(msg.sender == owner, "Not the contract owner");
_;
}

constructor(address _uniswapRouter, address _sushiRouter, address _WETH) {
require(_uniswapRouter != address(0) && _sushiRouter != address(0) && _WETH != address(0), "Invalid addresses");
owner = msg.sender;
uniswapRouter = IUniswapV2Router(_uniswapRouter);
sushiRouter = IUniswapV2Router(_sushiRouter);
WETH = _WETH;
}

function checkProfitability(address token, uint256 amount) public view returns (bool profitable, uint256 expectedProfit) {
address;
path[0] = token;
path[1] = WETH;

uint256 amountOutUniswap = uniswapRouter.getAmountsOut(amount, path)[1];
uint256 amountOutSushi = sushiRouter.getAmountsOut(amountOutUniswap, path)[1];

if (amountOutSushi > amount) {
return (true, amountOutSushi - amount);
}
return (false, 0);
}

function executeArbitrage(address token, uint256 amount) external onlyOwner {
(bool profitable, uint256 profit) = checkProfitability(token, amount);
require(profitable, "Not profitable");

uint256 initialBalance = IERC20(token).balanceOf(address(this));

// Buy token on Uniswap
address;
path[0] = token;
path[1] = WETH;
IERC20(token).approve(address(uniswapRouter), amount);
uniswapRouter.swapExactTokensForTokens(
amount, 1, path, address(this), block.timestamp + 120
);

// Sell on Sushiswap
path[0] = WETH;
path[1] = token;
uint256 wethBalance = IERC20(WETH).balanceOf(address(this));
IERC20(WETH).approve(address(sushiRouter), wethBalance);
sushiRouter.swapExactTokensForTokens(
wethBalance, 1, path, address(this), block.timestamp + 120
);

uint256 finalBalance = IERC20(token).balanceOf(address(this));
require(finalBalance > initialBalance, "No profit made");

emit ArbitrageExecuted(finalBalance - initialBalance, msg.sender);
}

function withdrawProfit(address token) external onlyOwner {
uint256 balance = IERC20(token).balanceOf(address(this));
require(balance > 0, "No profit available"); }

}
}