Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.8.11+commit.d7f03943.js&optimize=false&runs=200&gist=

contracts...ERC20...1.sol

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.0;

// ERC-20
// https://ethereum.org/en/developers/docs/standards/tokens/erc-20/

abstract contract ERC20_STD{
    function name() public view virtual returns (string memory);
    function symbol() public view virtual returns (string memory);
    function decimals() public view virtual returns (uint8);
    function totalSupply() public view virtual returns (uint256);
    function balanceOf(address _owner) public view virtual returns (uint256 balance);
    function transfer(address _to, uint256 _value) public virtual returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) public virtual returns (bool success);
    function approve(address _spender, uint256 _value) public virtual returns (bool success);
    function allowance(address _owner, address _spender) public view virtual returns (uint256 remaining);

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

contract Ownership {
    address public contractOwner;
    address public newOwner;

    event TransferOwnership(address indexed _from, address indexed _to);

    constructor() {
        contractOwner = msg.sender;
    }

    function changeOwner(address _to) public {

        // Only the owner can transfer ownership
        require(msg.sender == contractOwner, "Only the owner can call this function - changeOwner(address _to)");
        newOwner = _to;
    }

    function acceptOwner() public {

        // Owner must assign an address as the new owner, then that owner can accept it
        require(msg.sender == newOwner, "Only assigned users can call this funciton - acceptOwner()");
        emit TransferOwnership(contractOwner, newOwner);
        contractOwner = newOwner;

        // Set newOwner to an empty address so ownership can be transferred again in the future. 
        newOwner = address(0);
    }
}

contract MyERC20 is ERC20_STD, Ownership{

    string public _name;
    string public _symbol;
    uint8 public _decimals;
    uint256 public _totalSupply;

    address public _minter;

    mapping(address => uint256) tokenBalances;
    mapping(address => mapping(address => uint256)) allowed;

    constructor(address minter_) {
        _name = "AlphaCoin";
        _symbol = "ACN";
        _totalSupply = 100000000; 
        _minter = minter_;

        tokenBalances[_minter] = _totalSupply;
    }

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

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

    function decimals() public view override returns (uint8) {
        return _decimals;
    }

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

    function balanceOf(address _owner) public view override returns (uint256 balance) {
        return tokenBalances[_owner];
    }

    function transfer(address _to, uint256 _value) public override returns (bool success) {

        // Must have a balance >= the value being sent. 
        require(tokenBalances[msg.sender] >= _value, "Insufficient balance");

        emit Transfer(msg.sender, _to, _value);

        tokenBalances[msg.sender] -= _value;
        tokenBalances[_to] += _value;

        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public override returns (bool success) {

        uint256 allowedBalance = allowed[_from][msg.sender];
        require(allowedBalance >= _value, "Insufficient balance");

        emit Transfer(_from, _to, _value);

        tokenBalances[_from] -= _value;
        tokenBalances[_to] += _value;

        allowed[_from][msg.sender] -= _value;

        return true;
    }

    function approve(address _spender, uint256 _value) public override returns (bool success) {
        // Must have enough token balance
        require(tokenBalances[msg.sender] >= _value, "Insufficient balance");
        allowed[msg.sender][_spender] = _value;

        emit Approval(msg.sender, _spender, _value);

        return true;
    }

    function allowance(address _owner, address _spender) public view override returns (uint256 remaining){
        return allowed[_owner][_spender];
    }
}

First working ERC20 Token