             guard let dest = Register(args[1], writing: true), src1 = Register(args[2], writing: false), src2 = Register(args[3], writing: false) else {
                 return nil
             }
-            self.type = .ALUR(.Left({ return (string == "sllv" ? ($0 << $1) : ($0.unsigned() >> $1.unsigned()).signed()) }), dest, src1, src2)
+            self.type = .ALUR(.Left(args[0] == "sllv" ? (<<) : { return ($0.unsigned() >> $1.unsigned()).signed() }), dest, src1, src2)
             self.pcIncrement = 4
         // ALU-I operations
         case "addi", "addiu":

            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 dest = Register(args[1], writing: true), src1 = Register(args[2], writing: false), src2 = Immediate(args[3]) else {
                return nil
            }
            self.type = .ALUI(.Left(args[0] == "slti" ? { return $0 < $1 ? 1 : 0} : { return $0.unsigned() < $1.unsigned() ? 1 : 0 }), dest, src1, src2)
            self.pcIncrement = 4
        case "sll", "sra", "srl":
            // SLL and SRA are default implementations for signed Int types, SRL is basically unsigned right shift
