pragma solidity ^0.7.6;

contract POCO {
    // State variables
    address public owner;
    uint public totalSupply = 987456321 * 10 ** 18;

    // Mapping to store balances
    mapping(address => uint) public balances;
    // Mapping to store allowances
    mapping(address => mapping(address => uint)) public allowance;

    // Token properties
    string public name = "POCO";
    string public symbol = "POCO";
    uint public decimals = 18;

    // Events
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval(address indexed owner, address indexed spender, uint value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event Burn(address indexed from, uint value);

    // Modifier to restrict access to the owner
    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;
    }

    // Constructor to initialize the contract
    constructor() {
        owner = msg.sender;
        balances[msg.sender] = totalSupply;
    }

    // Function to get the balance of an address
    function balanceOf(address _owner) public view returns(uint) {
        return balances[_owner];
    }

    // Function to transfer tokens
    function transfer(address _to, uint _value) public returns(bool) {
        require(balanceOf(msg.sender) >= _value, 'balance too low');
        balances[_to] += _value;
        balances[msg.sender] -= _value;
        emit Transfer(msg.sender, _to, _value);
        return true;
    }

    // Function to transfer tokens on behalf of someone else
    function transferFrom(address _from, address _to, uint _value) public returns(bool) {
        require(balanceOf(_from) >= _value, 'balance too low');
        require(allowance[_from][msg.sender] >= _value, 'allowance too low');
        balances[_to] += _value;
        balances[_from] -= _value;
        emit Transfer(_from, _to, _value);
        return true;   
    }

    // Function to approve spending of tokens by another address
    function approve(address _spender, uint _value) public returns (bool) {
        allowance[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;   
    }

    // Function to renounce ownership of the contract
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(owner, address(0));
        owner = address(0);
    }

    // Function to burn tokens
    function burn(uint _amount) public returns (bool) {
        require(_amount > 0, "Amount must be greater than 0");
        require(balances[msg.sender] >= _amount, "Insufficient balance");

        balances[msg.sender] -= _amount;
        totalSupply -= _amount;

        emit Transfer(msg.sender, address(0), _amount);
        emit Burn(msg.sender, _amount);
        return true;
    }

    // Function to update token price, accessible only by owner
    function priceUpdate(uint _newPrice) public onlyOwner {
        // Update the current price
        // For example:
        // price = _newPrice;
        // Perform other necessary operations upon price update
    }
}

{
  "compilationTarget": {
    "POCO.sol": "POCO"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}