             guard let dest = Register(args[1], writing: true), src1 = Register(args[2], writing: false), src2 = Immediate(args[3]) else {
                 return nil
             }
-            self.type = .ALUI(.Left({ return string == "sll" ? ($0 << $1) : string == "sra" ? ($0 >> $1) : ($0.unsigned() >> $1.unsigned()).signed() }), dest, src1, src2)
+            self.type = .ALUI(.Left(args[0] == "sll" ? (<<) : (args[0] == "sra" ? (>>) : { return ($0.unsigned() >> $1.unsigned()).signed() })), dest, src1, src2)
             self.pcIncrement = 4
         // Memory operations
         case "lw", "lh", "lb", "sw", "sh", "sb":

            guard let src1 = Register(args[1], writing: false) else {
                return nil
            }
            let op: OperationBool
            switch(args[0]) {
            case "bgez", "bgezal":
                op = { return $0 >= $1 }
            case "blz", "blzal":
                op = { return $0 < $1 }
            case "bgtz":
                op = { return $0 > $1 }
            case "bltez":
                op = { return $0 <= $1 }
            default:
                fatalError("Invalid branch instruction \(args[0])")
            }
            self.type = .Branch(op, args[0] == "bgezal" || args[0] == "blzal", src1, zero, args[2])
            self.pcIncrement = 4
        // More complex instructions, mostly pseudo-instructions
        case "li":

            guard let src1 = Register(args[1], writing: false), src2 = Register(args[2], writing: false) else {
                return nil
            }
            self.type = .ALUR(.Right({ let fullValue = (args[0] == "mult" ? $0.signed64()*$1.signed64() : ($0.unsigned64()&*$1.unsigned64()).signed()); return (fullValue.signedUpper32(), fullValue.signedLower32()) }, false), nil, src1, src2)
            self.pcIncrement = 4
        case "mul":
            // Multiplication pseudoinstruction, which stores the lower 32 bits of src1*src2 in the destination
