             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 (args[0] == "slti" ? ($0 < $1) : ($0.unsigned() < $1.unsigned())) ? 1 : 0 }), dest, src1, src2)
+            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

            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 (args[0] == "slt" ? ($0 < $1) : ($0.unsigned() < $1.unsigned())) ? 1 : 0 }), dest, src1, src2)
            self.pcIncrement = 4
        case "sllv", "srlv":
            // SRL is essentially unsigned right shift

            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
