pragma solidity ^0.5.0;

contract OwnershipStorage {
    address internal _admin;

    constructor () public {
        _admin = msg.sender;
    }

    function admin() public view returns (address) {
        return _admin;
    }

    function setNewAdmin(address newAdmin) public {
        require(msg.sender == _admin);
        require(newAdmin != address(0));
        _admin = newAdmin;
    }
}

pragma solidity ^0.5.0;

contract Proxy {
    function implementation() public view returns (address);

    function() payable external {
        address _impl = implementation();
        require(_impl != address(0));
        bytes memory data = msg.data;

        // forward the call to the implemetation contract
        assembly {
            let result := delegatecall(gas, _impl, add(data, 0x20), mload(data), 0, 0)
            let size := returndatasize
            let ptr := mload(0x40)
            returndatacopy(ptr, 0, size)
            switch result
            case 0 { revert(ptr, size) }
            default { return(ptr, size) }
        }
    }
}

pragma solidity ^0.5.0;

import "./UpgradeabilityProxy.sol";
import "./TokenStorage.sol";
import "./OwnershipStorage.sol";

contract TokenProxy is UpgradeabilityProxy, TokenStorage, OwnershipStorage {
    constructor (
        string memory name,
        string memory symbol,
        uint8 decimals
    ) 
        public 
    {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
        _tokensMinted = false;
    } 
}

pragma solidity ^0.5.0;

contract TokenStorage {
    string internal _name;
    string internal _symbol;
    uint8 internal _decimals;
    uint256 internal _totalSupply;
    mapping(address => uint256) internal _balances;
    mapping(address => mapping(address => uint256)) internal _allowances;
    bool internal _tokensMinted = true;
}

pragma solidity ^0.5.0;

import "./Proxy.sol";
import "./UpgradeabilityStorage.sol";

contract UpgradeabilityProxy is Proxy, UpgradeabilityStorage {
    function admin() public view returns (address);

    event Upgraded(string version, address indexed implementation);

    function upgradeTo(string memory version, address implementation) public {
        require(msg.sender == admin());
        require(_implementation != implementation);
        _version = version;
        _implementation = implementation;
        emit Upgraded(version, implementation);
    }
}

pragma solidity ^0.5.0;

contract UpgradeabilityStorage {
    string internal _version;
    address internal _implementation;

    function version() public view returns (string memory) {
        return _version;
    }

    function implementation() public view returns (address) {
        return _implementation;
    }
}

{
  "compilationTarget": {
    "TokenProxy.sol": "TokenProxy"
  },
  "evmVersion": "byzantium",
  "libraries": {},
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}