anchor.diff:                expected-arity actual-arity)))
   
   (defun call-function (callable vm num-args save-return-address)
  +  (declare (optimize speed (safety 0)))
     (when save-return-address
  -    (push (make-return-address :program-counter (1+ (vm-program-counter vm))
  +    (push (make-return-address :program-counter (the fixnum (1+ (the fixnum (vm-program-counter vm))))
                                  :environment (vm-current-environment vm))
             (vm-stack vm)))
  -  (when (and (callable-num-args callable )
  -             (/= (callable-num-args callable) num-args))
  +  (when (and (callable-num-args callable)
  +             (/= (the fixnum (callable-num-args callable))
  +                 (the fixnum num-args)))
       (arity-error vm (callable-num-args callable) num-args))
     (setf (vm-program-counter vm) (callable-program-counter callable)
           (vm-current-environment vm) (callable-environment callable)))
  
positive.code:                 (find-required-primitive vm prim0))
                (alexandria:if-let (prim (callable-prim callable))
                  (find-user-primitive vm prim)))))
    (let* ((arg-values (reversed-prefix (vm-stack vm) num-args))
           (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 num-args save-return-address vm)
          (finish-calling-user-defined-primitive
           primitive arg-values num-args
           current-program-counter callable
           save-return-address vm))))
  
  (defun set-in-top-frame (environment var-index value)
    (declare (optimize speed))
  
negative.code:         value))
  
  (defun get-from-environment (enviroment frame-number var-index)
    (let ((frame (env-frame-vars (nth frame-number enviroment))))
      (second (aref frame var-index))))
  
  (defstruct serializer-state (hash (make-hash-table)) (array nil))
  
  