anchor.diff:          (kernel-targets kernel)
         (trivia:when-match (list (cons _ input))
             (instruction-inputs store-instruction)
  -        (when (and (eq input load-instruction))
  +        (when (eq input load-instruction)
             (return-from copy-kernel-p t))))))
   
   (defun copy-kernel-transformation (kernel)
  
positive.code:      (value t)
       (shape shape)
       (transformation transformation))
    (let* ((lazy-array (layout-lazy-array layout))
           (buffer (make-buffer
                    :shape shape
                    :reusablep t
                    :ntype (petalisp.type-inference:generalize-ntype
                            (element-ntype lazy-array))))
           (store (make-store-instruction value buffer transformation)))
      (push `(,buffer ,store) (layout-buffer-stores layout))
      store))
  
negative.code: 
  (defstruct (layout
              (:constructor nil))
    (lazy-array nil :type lazy-array :read-only t)
    (ntype nil :read-only t))
  
  (defstruct (range-immediate-layout
              (:include layout)
              (:constructor make-range-immediate-layout
                  (range-immediate
                   &aux
                     (lazy-array range-immediate)
                     (ntype
                      (petalisp.type-inference:generalize-ntype
                       (element-ntype range-immediate)))))))
  
  (defstruct (array-immediate-layout
              (:include layout)
  