anchor.diff:          unless (and (zerop (vec-x v))
                       (zerop (vec-y v)))
           do
  -          (incf i)
  -        ;; plan
  -          (setq *plan*
  -                (itmp-rec (scene-graph *sg-table* blocks) *sg-goal*
  -                          (rope *tmsmt-root* "pddl/itmp/itmp-blocks-linear.pddl")
  -                          :encoding :linear
  -                          :action-encoding :enum
  -                          :max-steps 3 :resolution *resolution*))
  -        ;;(print *plan*)
  -        ;; write output
  -          (output-timing n-obj "idtmp")))
  +          (progn
  +            (incf i)
  +            ;; plan
  +            (print 'informed-idtmp)
  +            (itmp-rec (scene-graph *sg-table* blocks) *sg-goal*
  +                      (rope *tmsmt-root* "pddl/itmp/itmp-blocks-linear.pddl")
  +                      :naive nil
  +                      :encoding :linear
  +                      :action-encoding :enum
  +                      :max-steps n-obj :resolution *resolution*)
  +            (output-timing n-obj "idtmp-side")
  +
  +            ;; (print 'naive-idtmp)
  +            (itmp-rec (scene-graph *sg-table* blocks) *sg-goal*
  +                      (rope *tmsmt-root* "pddl/itmp/itmp-blocks-linear.pddl")
  +                      :naive t
  +                      :encoding :linear
  +                      :action-encoding :enum
  +                      :max-steps n-obj :resolution *resolution*)
  +            (output-timing n-obj "n-idtmp-side")
  +          )))
   
   ;; (render-group-itmp *plan-context* *group*
   ;;                    *plan*
  
positive.code:                        (robray::output-file "baxter.inc" robray::*robray-tmp-directory*))
  
  
  (let ((frame (robray::scene-graph-lookup *sg-block* "block-0"))
        (blocks (scene-graph-remove-frame *sg-block* "block-0")))
  
    (robray::scene-graph-pov-frame
     (scene-graph *robot* *sg-table* *sg-marker* blocks
                  (scene-frame-fixed "front_table" "block-0"
                                     :geometry (robray::scene-geometry *box*
                                                                       (draw-options-default :color '(0 0 1)
                                                                                             :specular .3
                                                                                             :type "moveable"
                                                                                             :visual t
                                                                                             :collision t))
                                     :tf (robray::scene-frame-tf frame)))
     :configuration-map
     (alist-tree-map `(;("right_s0" . ,(* .25 pi))
                                          ;("right_s1" . ,(* -0.25 pi))
                                          ;("right_e0" . ,(* 0.0 pi))
                                          ;("right_e1" . ,(* 0.25 pi))
                                          ;("right_w0" . ,(* 0.0 pi))
                                          ;("right_w1" . ,(* 0.5 pi))
                                          ;("right_w2" . ,(* 0.0 pi))
                       )
                     #'string-compare)
     :include "baxter.inc"
     :render t
     :options (render-options-default :use-collision nil
                                                   :options (render-options-full-hd))
   :output "robray.pov"))
  
  (moveit-init (robray::urdf-resolve-file "package://baxter_description/urdf/baxter.urdf"))
  
  
negative.code:                           (vec3* 2 2 2)
                            )
  
  (defparameter *tf-grasp-top* (tf* (y-angle (* 1 pi)) (vec3* .00 .00 (+ .04 (/ *box-dim* 2)))))
  (defparameter *tf-grasp-back* (tf* (y-angle (* .5 pi)) (vec3* (- (+ .04 (/ *box-dim* 2)))  .00 .070)))
  (defparameter *tf-grasp-rel* *tf-grasp-back*)
  
  (defvar *plan*)
  
  (loop for n-obj from 6 to 6
     for i = 0
     do
       (loop
  