anchor.diff:                                                    (- (random 1.0) 0.5)
                                                     (- (random 1.0) 0.5))))
               (k (divided-point inner outer (random 1.0))))
  -        (setf (mem-aref pos i) (make-float4 (* (float3-x point) k)
  -                                            (* (float3-y point) k)
  -                                            (* (float3-z point) k)
  -                                            1.0)))
  +        (setf (array-ref pos i) (list (* (float3-x point) k)
  +                                      (* (float3-y point) k)
  +                                      (* (float3-z point) k)
  +                                      1.0))
  +
         (let* ((axis (make-float3 0.0 0.0 1.0))
  -             (vv (cross (make-float3 (float4-x (mem-aref pos i))
  -                                     (float4-y (mem-aref pos i))
  -                                     (float4-z (mem-aref pos i)))
  -                        axis)))
  -        (setf (mem-aref vel i) (make-float4 (* (float3-x vv) vscale)
  -                                            (* (float3-y vv) vscale)
  -                                            (* (float3-z vv) vscale)
  -                                            1.0))))))
  +             (vv (multiple-value-bind (x y z _) (array-ref pos i)
  +                   (declare (ignorable _))
  +                   (cross (make-float3 x y z) axis))))
  +        (setf (array-ref vel i) (list (* (float3-x vv) vscale)
  +                                      (* (float3-y vv) vscale)
  +                                      (* (float3-z vv) vscale)
  +                                      1.0)))))))
   
   
   ;;;
  
positive.code:       (set (aref new-pos index) position)
        (set (aref vel index) velocity))))
  
  (defun integrate-nbody-system (new-pos old-pos vel delta-time damping num-bodies p)
    (let ((grid-dim (list (ceiling (/ num-bodies p)) 1 1))
          (block-dim (list p 1 1)))
      (integrate-bodies new-pos old-pos vel delta-time damping num-bodies
                        :grid-dim grid-dim
                        :block-dim block-dim)))
  
  
  ;;;
  ;;; cl-glut window subclass
  ;;;
  
  (defclass nbody-window (glut:window) ()
    (:default-initargs :width 640 :height 480 :pos-x 100 :pos-y 100
                       :mode '(:double :rgb) :title "nbody"))
  
  
negative.code: 
  
  ;;;
  ;;; NBody Demo
  ;;;
  
  (defun unlines (&rest string-list)
  