MultiProxy.sol

contract MultiProxy{   
   //Data schema: [from: 32 bytes, to: 32 bytes, value: 32 bytes, data_length: 32 bytes, data: data_length bytes]
    function forward(bytes32[]) external payable { 
        assembly {
            
            function next_tx (c) -> n {
                let data_size := calldataload(add(c, 96))
                n := add(c, add(128, mul(div(data_size, 32), 32)))
                switch mod(data_size, 32)
                case 0 {
                }
                default {
                    n := add(n, 32)
                }
            } 
            
            for {let c := 68} lt(c, mul(calldataload(36), 32)) {c := next_tx(c) }{
                let from := calldataload(c)
                let to := calldataload(add(c, 32))
                let val := calldataload(add(c, 64))
                let data_len := calldataload(add(c, 96))
                let m := mload(0x40)
                let success := 0
                switch from
                case 0 {
                    calldatacopy(m, add(c, 128), data_len)
                    success := call(200000, to, val, m, data_len, 0, 0)
                }
                default {
                    let sig := 0xd7f31eb900000000000000000000000000000000000000000000000000000000
                    mstore(m, sig)
                    mstore(add(m, 4), to)
                    mstore(add(m, 36), val)
                    calldatacopy(add(m, 68), add(c, 72), add(data_len, 32))
                    success := call(sub(gas, 5000), from, 0, m, add(data_len, 84), 0,0)
                }
                
                switch success 
                case 0 {
                    invalid
                }
            }
        }
    } 
}

contract Test {
    function is_sixteen(uint a){
        require(a == 16);
    }
    function sig() returns(bytes4){
        return bytes4(sha3("is_sixteen(uint256)"));
    }
}