event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

modifier onlyOwner() {
    require(msg.sender == owner, "Ownable: caller is not the owner");
    _;
}

function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0), "Ownable: new owner is the zero address");
    emit OwnershipTransferred(owner, newOwner);
    owner = newOwner;
}

bool public paused = false;

modifier whenNotPaused() {
    require(!paused, "Pausable: paused");
    _;
}

modifier whenPaused() {
    require(paused, "Pausable: not paused");
    _;
}

function pause() onlyOwner whenNotPaused public {
    paused = true;
    emit Pause();
}

function unpause() onlyOwner whenPaused public {
    paused = false;
    emit Unpause();
}

function balanceOf(address who) virtual public view returns (uint256);
function transfer(address to, uint256 value) virtual  public returns (bool);

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

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

mapping(address => uint256) balances;

function transfer(address _to, uint256 _value) virtual override  public returns (bool) {
    require(!tokenBlacklist[msg.sender], "StandardToken: sender is blacklisted");
    require(_to != address(0), "StandardToken: transfer to the zero address");
    require(_value <= balances[msg.sender], "StandardToken: insufficient balance");

    balances[msg.sender] -= _value;
    balances[_to] += _value;
    emit Transfer(msg.sender, _to, _value);
    return true;
}

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

function transferFrom(address _from, address _to, uint256 _value) virtual override public returns (bool) {
    require(!tokenBlacklist[msg.sender], "StandardToken: sender is blacklisted");
    require(_to != address(0), "StandardToken: transfer to the zero address");
    require(_value <= balances[_from], "StandardToken: insufficient balance");
    require(_value <= allowed[_from][msg.sender], "StandardToken: allowance exceeded");

    balances[_from] -= _value;
    balances[_to] += _value;
    allowed[_from][msg.sender] -= _value;
    emit Transfer(_from, _to, _value);
    return true;
}

function approve(address _spender, uint256 _value) virtual override public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
}

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

function increaseApproval(address _spender, uint _addedValue) virtual public returns (bool) {
    allowed[msg.sender][_spender] += _addedValue;
    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
}

function decreaseApproval(address _spender, uint _subtractedValue) virtual public returns (bool) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
        allowed[msg.sender][_spender] = 0;
    } else {
        allowed[msg.sender][_spender] = oldValue - _subtractedValue;
    }
    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
}

function _blackList(address _address, bool _isBlackListed) internal returns (bool) {
    require(tokenBlacklist[_address] != _isBlackListed, "StandardToken: address already in the given state");
    tokenBlacklist[_address] = _isBlackListed;
    emit Blacklist(_address, _isBlackListed);
    return true;
}

function transfer(address _to, uint256 _value) override public whenNotPaused returns (bool) {
    return super.transfer(_to, _value);
}

function transferFrom(address _from, address _to, uint256 _value) override public whenNotPaused returns (bool) {
    return super.transferFrom(_from, _to, _value);
}

function approve(address _spender, uint256 _value) override public whenNotPaused returns (bool) {
    return super.approve(_spender, _value);
}

function increaseApproval(address _spender, uint _addedValue) override public whenNotPaused returns (bool success) {
    return super.increaseApproval(_spender, _addedValue);
}

function decreaseApproval(address _spender, uint _subtractedValue) override public whenNotPaused returns (bool success) {
    return super.decreaseApproval(_spender, _subtractedValue);
}

function blackListAddress(address listAddress, bool isBlackListed) public whenNotPaused onlyOwner returns (bool success) {
    return super._blackList(listAddress, isBlackListed);
}

event Mint(address indexed from, address indexed to, uint256 value);
event Burn(address indexed burner, uint256 value);

constructor(string memory _name, string memory _symbol, uint256 _decimals, uint256 _supply, address tokenOwner) {
    name = _name;
    symbol = _symbol;
    decimals = _decimals;
    totalSupply = _supply * 10 ** _decimals;
    balances[tokenOwner] = totalSupply;
    owner = tokenOwner;
    emit Transfer(address(0), tokenOwner, totalSupply);
}

function burn(uint256 _value) public {
    _burn(msg.sender, _value);
}

function _burn(address _who, uint256 _value) internal {
    require(_value <= balances[_who], "Rokda: burn amount exceeds balance");
    balances[_who] -= _value;
    totalSupply -= _value;
    emit Burn(_who, _value);
    emit Transfer(_who, address(0), _value);
}

function mint(address account, uint256 amount) onlyOwner public {
    totalSupply += amount;
    balances[account] += amount;
    emit Mint(address(0), account, amount);
    emit Transfer(address(0), account, amount);
}