// File: /Context.sol





pragma solidity ^0.8.0;



abstract contract Context {

    function _msgSender() internal view virtual returns (address) {

        return msg.sender;

    }



    function _msgData() internal view virtual returns (bytes calldata) {

        return msg.data;

    }

}


// File: /Ownable.sol





pragma solidity ^0.8.0;




abstract contract Ownable is Context {

    address private _owner;



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



    constructor() {

        _setOwner(_msgSender());

    }



    function owner() public view virtual returns (address) {

        return _owner;

    }



    modifier onlyOwner() {

        require(owner() == _msgSender(), "Ownable: caller is not the owner");

        _;

    }



    function renounceOwnership() external virtual onlyOwner {

        _setOwner(address(0));

    }



    function transferOwnership(address newOwner) external virtual onlyOwner {

        require(newOwner != address(0), "Ownable: new owner is the zero address");

        _setOwner(newOwner);

    }



    function _setOwner(address newOwner) private {

        address oldOwner = _owner;

        _owner = newOwner;

        emit OwnershipTransferred(oldOwner, newOwner);

    }

}
// File: /Pausable.sol





pragma solidity ^0.8.0;




abstract contract Pausable is Ownable {

    event Paused(address account);



    event Unpaused(address account);



    bool private _paused;



    constructor() {

        _paused = false;

    }



    function paused() public view virtual returns (bool) {

        return _paused;

    }

    

    function pause() external virtual onlyOwner {

        _pause();

    }

    

    function unpause() external virtual onlyOwner {

        _unpause();

    }

    

    modifier whenNotPaused() {

        require(!paused(), "Pausable: paused");

        _;

    }



    modifier whenPaused() {

        require(paused(), "Pausable: not paused");

        _;

    }



    function _pause() internal virtual whenNotPaused {

        _paused = true;

        emit Paused(_msgSender());

    }



    function _unpause() internal virtual whenPaused {

        _paused = false;

        emit Unpaused(_msgSender());

    }

}


// File: HERMIA.sol





/**

███╗░░░███╗███████╗████████╗░█████╗░██╗░░██╗███████╗██████╗░███╗░░░███╗██╗░█████╗░

████╗░████║██╔════╝╚══██╔══╝██╔══██╗██║░░██║██╔════╝██╔══██╗████╗░████║██║██╔══██╗

██╔████╔██║█████╗░░░░░██║░░░███████║███████║█████╗░░██████╔╝██╔████╔██║██║███████║

██║╚██╔╝██║██╔══╝░░░░░██║░░░██╔══██║██╔══██║██╔══╝░░██╔══██╗██║╚██╔╝██║██║██╔══██║

██║░╚═╝░██║███████╗░░░██║░░░██║░░██║██║░░██║███████╗██║░░██║██║░╚═╝░██║██║██║░░██║

╚═╝░░░░░╚═╝╚══════╝░░░╚═╝░░░╚═╝░░╚═╝╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝╚═╝░░░░░╚═╝╚═╝╚═╝░░╚═╝

**/



pragma solidity ^0.8.0;




contract HERMIA is Pausable {

    mapping(address => uint256) private _balances;



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



    uint256 private _totalSupply = 50 * (10 ** 9) * (10 ** 18);     // 50 Billion

    

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



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



    constructor() {

        _balances[_msgSender()] = _totalSupply;

    }



    function name() public view virtual returns (string memory) {

        return "Metahermia Token";

    }



    function symbol() public view virtual returns (string memory) {

        return "HERMIA";

    }



    function decimals() public view virtual returns (uint8) {

        return 18;

    }



    function totalSupply() public view virtual returns (uint256) {

        return _totalSupply;

    }



    function balanceOf(address account) public view virtual returns (uint256) {

        return _balances[account];

    }



    function transfer(address recipient, uint256 amount) external virtual returns (bool) {

        _transfer(_msgSender(), recipient, amount);

        return true;

    }



    function allowance(address owner, address spender) public view virtual returns (uint256) {

        return _allowances[owner][spender];

    }



    function approve(address spender, uint256 amount) external virtual returns (bool) {

        _approve(_msgSender(), spender, amount);

        return true;

    }



    function transferFrom(

        address sender,

        address recipient,

        uint256 amount

    ) external virtual returns (bool) {

        _transfer(sender, recipient, amount);



        uint256 currentAllowance = _allowances[sender][_msgSender()];

        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");

        unchecked {

            _approve(sender, _msgSender(), currentAllowance - amount);

        }



        return true;

    }



    function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {

        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);

        return true;

    }



    function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {

        uint256 currentAllowance = _allowances[_msgSender()][spender];

        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");

        unchecked {

            _approve(_msgSender(), spender, currentAllowance - subtractedValue);

        }



        return true;

    }

    

    function burn(uint256 amount) external virtual {

        _burn(_msgSender(), amount);

    }



    function _transfer(

        address sender,

        address recipient,

        uint256 amount

    ) internal virtual {

        require(sender != address(0), "ERC20: transfer from the zero address");

        require(recipient != address(0), "ERC20: transfer to the zero address");



        _beforeTokenTransfer();



        uint256 senderBalance = _balances[sender];

        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");

        unchecked {

            _balances[sender] = senderBalance - amount;

        }

        _balances[recipient] += amount;



        emit Transfer(sender, recipient, amount);

    }



  

    function _burn(address account, uint256 amount) internal virtual {

        require(account != address(0), "ERC20: burn from the zero address");



        _beforeTokenTransfer();



        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);

    }



    function _approve(

        address owner,

        address spender,

        uint256 amount

    ) internal virtual {

        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 _beforeTokenTransfer() internal virtual {

        require(!paused(), "ERC20Pausable: token transfer while paused");

    }

}