anchor.diff:           (unless (instruction-cache instruction)
              (setf (instruction-cache instruction)
                    (make-callable :prim0 args
  -                                :cached-prim (find-required-primitive vm args))))
  +                                :cached-prim (cons nil (find-required-primitive vm args)))))
            (push (instruction-cache instruction)
                  (vm-stack vm))
            (inc-pc vm)
  
positive.code:         (finish-primitive-call vm result
                                 save-return-address new-stack)))))
  
  (defun finish-primitive-call (vm result save-return-address new-stack)
    (declare (optimize speed (safety 0)))
    (setf (vm-stack vm) new-stack)
    (if save-return-address
        (incf (the fixnum (vm-program-counter vm)))
        (apply-return-address vm (pop (vm-stack vm))))
    (push result (vm-stack vm)))
  
  (defun call-primitive (callable vm num-args save-return-address)
    (declare (optimize speed)
             (type vm vm)
             (type callable callable)
             (type fixnum num-args))
    (unless (callable-cached-prim callable)
      (setf (callable-cached-prim callable)
            (or (alexandria:if-let (prim0 (callable-prim0 callable))
                  (find-required-primitive vm prim0))
                (alexandria:if-let (prim (callable-prim callable))
                  (find-user-primitive vm prim)))))
    (multiple-value-bind (arg-values new-stack)
        (reversed-prefix (vm-stack vm) num-args)
      (let* ((primitive-record (callable-cached-prim callable))
             (primitive (first primitive-record))
             (is-required-primitive (callable-prim0 callable))
             (primitive-arity (second primitive-record))
             (current-program-counter (vm-program-counter vm)))
        (declare (type (or fixnum null) num-args primitive-arity))
        (when (and primitive-arity (/= primitive-arity num-args))
          (arity-error vm primitive-arity num-args))
        (if is-required-primitive
            (finish-calling-required-primitive
             primitive arg-values save-return-address
             new-stack vm)
            (finish-calling-user-defined-primitive
             primitive arg-values
             current-program-counter callable
             save-return-address new-stack vm)))))
  
  (defun set-in-top-frame (environment var-index value)
    (declare (optimize speed))
  
negative.code: (defstruct callable
    (prim0 nil)
    (prim nil)
    (num-args nil :type (or null fixnum))
    (program-counter nil :type (or null fixnum))
    (environment nil)
    (cached-prim nil))
  
  (defstruct env-frame introduced-at-program-counter vars)
  
  (defmacro def-prim0 (op lisp-op &optional (arity 2))
    `(list ,(format nil "~a" op) #',lisp-op ,arity))
  
  (defparameter *primitives*
    (let ((prim0-alist
  