Error: Parse error: missing ';' at '{' using SOLHINT, how to fix it?

Question

I have a typical ERC20 contract.

The contract compiles just fine and works, however when using some styling and security check with SOLHINT, it gives me this error for all my lines which have the "unchecked{}" in it. This is the error:

ERC20.sol:82:17: Error: Parse error: missing ';' at '{' 
ERC20.sol:92:18: Error: Parse error: missing ';' at '{' 
ERC20.sol:101:18: Error: Parse error: missing ';' at '{' 
ERC20.sol:111:18: Error: Parse error: missing ';' at '{' 
ERC20.sol:127:22: Error: Parse error: missing ';' at '{' 

Here are the line of code that gives the error according to SOLHINT:

unchecked{_approve(owner, spender, currentAllowance - subtractedValue);
unchecked {_balances[from] = fromBalance - amount; _balances[to] += amount;}
unchecked {_balances[account] += amount;}
unchecked {_balances[account] = accountBalance - amount; _totalSupply -= amount;}
unchecked {_approve(owner, spender, currentAllowance - amount);}

Here is the full code (Typical ERC20):

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0.0;

contract ERC20 {

mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;

uint256 private _totalSupply;

string private _name;
string private _symbol;

event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);

constructor() {
    _name = "Kato";
    _symbol = "KTO";
    }

function _msgSender() internal view returns (address) {
    return msg.sender;
    }

function _msgData() internal pure returns (bytes calldata) {
    return msg.data;
    }

function name() public view returns (string memory) {
    return _name;
    }

function symbol() public view returns (string memory) {
    return _symbol;
    }

function decimals() public pure returns (uint8) {
    return 18;}

function totalSupply() public view returns (uint256) {
    return _totalSupply;
    }

function balanceOf(address account) public view returns (uint256) {
    return _balances[account];
    }

function transfer(address to, uint256 amount) public returns (bool) {
    address owner = _msgSender();
    _transfer(owner, to, amount);
    return true;
    }

function allowance(address owner, address spender) public view  returns (uint256) {
    return _allowances[owner][spender];
    }

function approve(address spender, uint256 amount) public  returns (bool) {
    address owner = _msgSender();
    _approve(owner, spender, amount);
    return true;
    }

function transferFrom(address from, address to, uint256 amount) public  returns (bool) {
    address spender = _msgSender();
    _spendAllowance(from, spender, amount);
    _transfer(from, to, amount);
    return true;
    }

function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
    address owner = _msgSender();
    _approve(owner, spender, allowance(owner, spender) + addedValue);
    return true;
    }

function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
    address owner = _msgSender();
    uint256 currentAllowance = allowance(owner, spender);
    require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
    unchecked{_approve(owner, spender, currentAllowance - subtractedValue);
    }
    return true;}

function _transfer(address from, address to, uint256 amount) internal {
    require(from != address(0), "ERC20: transfer from the zero address");
    require(to != address(0), "ERC20: transfer to the zero address");
    _beforeTokenTransfer(from, to, amount);
    uint256 fromBalance = _balances[from];
    require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
    unchecked {_balances[from] = fromBalance - amount; _balances[to] += amount;}
    emit Transfer(from, to, amount);
    _afterTokenTransfer(from, to, amount);
    }

function _mint(address account, uint256 amount) public {
    require(account != address(0), "ERC20: mint to the zero address");
    _beforeTokenTransfer(address(0), account, amount);
    _totalSupply += amount;
    unchecked {_balances[account] += amount;}
    emit Transfer(address(0), account, amount);
    _afterTokenTransfer(address(0), account, amount);
    }

function _burn(address account, uint256 amount) public {
    require(account != address(0), "ERC20: burn from the zero address");
    _beforeTokenTransfer(account, address(0), amount);
    uint256 accountBalance = _balances[account];
    require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
    unchecked {_balances[account] = accountBalance - amount; _totalSupply -= amount;}
    emit Transfer(account, address(0), amount);
    _afterTokenTransfer(account, address(0), amount);
    }

function _approve(address owner, address spender, uint256 amount) internal {
    require(owner != address(0), "ERC20: approve from the zero address");
    require(spender != address(0), "ERC20: approve to the zero address");
    _allowances[owner][spender] = amount;
    emit Approval(owner, spender, amount);
    }

function _spendAllowance(address owner, address spender, uint256 amount) internal {
    uint256 currentAllowance = allowance(owner, spender);
    if (currentAllowance != type(uint256).max) {
        require(currentAllowance >= amount, "ERC20: insufficient allowance");
        unchecked {_approve(owner, spender, currentAllowance - amount);}
        }
    }

function _beforeTokenTransfer(address from, address to,uint256 amount) internal {}

function _afterTokenTransfer(address from, address to, uint256 amount) internal {}

}

What is that error and how to fix it?