contract Registry {
    address[] versions;
    uint currentVersion;
    mapping(address => bool) isUpdated;

    function addBalance(address _addr, uint256 _val) {
        bytes4 sig = bytes4(keccak256("addBalance(address,uint256)"));
        if(!isUpdated[_addr]) {
            bytes4 sigGet = bytes4(keccak256("getBalance(address)"));
            address prevVersion = versions[currVersion-1];

            // use assembly to call getBalance in previous contract so we can update
            // value in current contract correctly
            assembly {
                let x := mload(0x40) // get empty storage location
                mstore ( x, sigGet ) // 4 bytes - place signature in empty storage
                mstore (add(x, 0x04), _addr) // 20 bytes - place first argument next to 4-bit signature

                let ret := call (gas,
                    prevVersion,
                    0, // no wei value passed to function
                    x, // input
                    0x18, // input size = 20 + 4 bytes
                    x, // output stored at input location, save space
                    0x20 // output size = 32 bytes
                )

                let ans := mload(x)
                mstore(0x40, add(x,0x20)) // update free memory pointer
            }

            uint _val += ans;
        }

        versions[currVersion].call(sig, _addr, _val);
}

contract oldContract {
    mapping (address => uint256) public balances;

    function addBalance(address _addr, uint256 _val) {
        balances[_addr] += _val;
    }

    function getBalance(address _addr) returns (uint) {
        return balances[_addr];
    }
}

contract newContract {
    function addBalance(address _addr, uint256 _val){
      // do stuff
    }
}