anchor.diff:    (let* ((dim (length x0))
            (rk-steps  (length *c*))
            (len (* dim rk-steps)))
  -    (labels ((weight-diff (kij fj) (- kij (* fj stepsize)))
  -             (eqs-for-ki (ki ode-system) (mapcar #'weight-diff ki ode-system))
  -             (ode-system-for-step (k) (flet ((ode-eval (ai ci)
  -                                                       (funcall ode
  -                                                                (+ t0 (* ci stepsize))
  -                                                                (eval-point x0 k ai))))
  -                                        (mapcar #'ode-eval *A* *c*)))
  -             (implicit-system (k-flat) (let ((k (split k-flat dim)))
  -                                         (mapcan #'eqs-for-ki k (ode-system-for-step k)))))
  +    (labels ((weight-diff (kij fj)
  +               (- kij (* fj stepsize)))
  +             (eqs-for-ki (ki ode-system)
  +               (mapcar #'weight-diff
  +                       ki
  +                       ode-system))
  +             (ode-system-for-step (k)
  +               (mapcar (curry #'ode-eval ode stepsize k x0 t0)
  +                       *A*
  +                       *c*))
  +             (implicit-system (k-flat)
  +               (let1 (k (split k-flat dim))
  +                 (mapcan #'eqs-for-ki
  +                         k
  +                         (ode-system-for-step k)))))
         (split (newton-solver #'implicit-system len) dim))))
   
   (defun runge-kutta-single-step (f x0 t0 stepsize)
     (let* ((solver (if *is-implicit* #'solve-implicit-rks #'solve-explicit-rks))
            (k (funcall solver f x0 t0 stepsize))
  -         (bk (mapcar (lambda (bi ki) (mapcar (lambda (kij) (* bi kij)) ki)) *b* k)))
  +         (bk (mapcar (lambda (bi ki)
  +                       (mapcar (lambda (kij) (* bi kij))
  +                               ki))
  +                     *b*
  +                     k)))
       (apply #'mapcar (cons #'+ (cons x0 bk)))))
   
   (defun ensure-last-step (ode last-x last-t t1)
  
positive.code:       (apply #'mapcar (list #'fma x (swap-matrix-layout k))))
      x))
  
  (defun scaled-ode-eval (ode stepsize ai ci k t0 x0)
    (mapcar (lambda (fi) (* stepsize fi))
            (funcall ode
                     (+ t0 (* ci stepsize))
                     (eval-point x0 k ai))))
  
  (defun solve-explicit-rks (ode x0 t0 stepsize)
    (let ((k))
      (loop for ai in *A*
            for ci in *c*
            do (let ((ki (list (scaled-ode-eval ode stepsize ai ci k t0 x0))))
                 (appendf k ki)))
      k))
  
  
negative.code:         return i))
  
  (defun insert-at (place-to-put new-points)
    (let1 (tail (cdr place-to-put))
      (setf (cdr place-to-put) (append new-points tail))))
  
  (defun cached-ode-solution (the-ode init-t0 init-x0 &optional (init-stepsize *step*))
    "Create a closure caching already calculated values of the solution."
    (let ((stepsize (max *eps* init-stepsize))
          (known-graph (list (list init-t0 init-x0))))
      (values
  