                  (var-ref op1 byte-varref)
                  (var-set op1 byte-varset)
                  ;; - Instructions without argument -
-                 (setcar op0 (byte-setcar))
-                 (setcdr op0 (byte-setcdr))
-                 (car op0 (byte-car))
-                 (cdr op0 (byte-cdr))
-                 (array-ref op0 (byte-aref))
-                 (array-set op0 (byte-aset))
-                 (substr op0 (byte-substring))
-                 (string= op0 (byte-string=))
-                 (string< op0 (byte-string<))
-                 (to-lower op0 (byte-downcase))
-                 (to-upper op0 (byte-upcase))
-                 (cons? op0 (byte-consp))
-                 (string? op0 (byte-stringp))
-                 (int? op0 (byte-integerp))
-                 (symbol? op0 (byte-symbolp))
-                 (add1 op0 (byte-add1))
-                 (sub1 op0 (byte-sub1))
-                 (add op0 (byte-plus))
-                 (sub op0 (byte-diff))
-                 (mul op0 (byte-mult))
-                 (quo op0 (byte-quo))
-                 (num= op0 (byte-eqlsign))
-                 (num> op0 (byte-gtr))
-                 (num< op0 (byte-lss))
-                 (num>= op0 (byte-geq))
-                 (num<= op0 (byte-leq))
-                 (neg op0 (byte-negate))
-                 (max op0 (byte-max))
-                 (min op0 (byte-min))
-                 (rem op0 (byte-rem))
-                 (eq op0 (byte-eq))
-                 (equal op0 (byte-equal))
-                 (not op0 (byte-not))
-                 (cons op0 (byte-cons))
-                 (return op0 (byte-return))))
+                 (setcar op0)
+                 (setcdr op0)
+                 (car op0)
+                 (cdr op0)
+                 (array-ref op0 byte-aref)
+                 (array-set op0 byte-aset)
+                 (substr op0 byte-substring)
+                 (string= op0)
+                 (string< op0)
+                 (to-lower op0 byte-downcase)
+                 (to-upper op0 byte-upcase)
+                 (cons? op0 byte-consp)
+                 (string? op0 byte-stringp)
+                 (int? op0 byte-integerp)
+                 (symbol? op0 byte-symbolp)
+                 (add1 op0)
+                 (sub1 op0)
+                 (add op0 byte-plus)
+                 (sub op0 byte-diff)
+                 (mul op0 byte-mult)
+                 (quo op0)
+                 (num= op0 byte-eqlsign)
+                 (num> op0 byte-gtr)
+                 (num< op0 byte-lss)
+                 (num>= op0 byte-geq)
+                 (num<= op0 byte-leq)
+                 (neg op0)
+                 (max op0)
+                 (min op0)
+                 (rem op0)
+                 (eq op0)
+                 (equal op0)
+                 (not op0)
+                 (cons op0)
+                 (return op0)))
       (let* ((instr (nth 0 x))
              (kind (nth 1 x))
              (data (or (nth 2 x)
-                                (intern (format "byte-%s" instr)))))
+                       (intern (format "byte-%s" instr)))))
         (puthash instr (ir--make-info kind data) table)))
     table))
 

    (dolist (x '(;; - Special instructions -
                 (label label ir-label)
                 ;; - Combined instructions -
                 (stack-ref stack-ref (byte-dup))
                 (discard discard (byte-discard))
                 (concat comb5 [nil
                                nil
                                (byte-concat2)
                                (byte-concat3)
                                (byte-concat4)
                                byte-concatN])
                 (list comb5 [nil
                              (byte-list1)
                              (byte-list2)
                              (byte-list3)
                              (byte-list4)
                              byte-listN])
                 ;; - Jump instructions -
                 (goto jmp)

    (nreverse output)))

(defun ir--lap-instr (tags op-info op arg)
  ;; Patterns in `pcase' are sorted by frequency order.
  (pcase (ir--info-kind op-info)
    (`op0 (list (ir--info-data op-info)))
    (`op1 (let ((lap-op (ir--info-data op-info)))
            (cons lap-op arg)))
    (`stack-ref (if (= arg 0)
                    (list 'byte-dup)
                  (cons 'byte-stack-ref arg)))
    (`discard (if (= arg 1)
                  (list 'byte-discard)
                (cons 'byte-discardN arg)))
    (`label (ir--tag-ref tags arg))
    (`jmp (let* ((lap-op (ir--info-data op-info))
                 (tag (ir--tag-ref tags arg)))
            (cons lap-op tag)))
    (`comb5 (if (<= arg 4)
                (list (aref (ir--info-data op-info) arg))
              (cons (aref (ir--info-data op-info) 5) arg)))
    (_
     (error "Unexpected op kind for `%s'" op))))
