anchor.diff:        // [child] x [parent ofchild] x [parent of parent of child]...
         //
         // In other words the child is mutiplied "into" the parent.
  -//      AffineTransform t = affineTransformMultiply(comp, parentT);
  -//      childT.setWithAT(t);
  -//      t.moveToPool();
         
         affineTransformMultiplyFrom(comp, parentT);   // <--- correct
  -//      affineTransformMultiplyTo(parentT, comp);
  -
  +
  +      if (p == psuedoRoot)
  +        break;
  +      
         // next parent upwards 
         p = p._parent;
       }
   
       return comp;  // return pooled object
     }
  -
  +  
     double nodeToWorldScale() {
       double scale = uniformScale;
       
  
positive.code:     // Iterate "upwards" starting with the child towards the parents
      // starting with this child's parent.
      BaseNode p = _parent;
      
      while (p != null) {
        AffineTransform parentT = p.calcTransform(); // Non-pooled object 
  
  
negative.code:    * If you don't move the object back to the pool
     * the GC will have something to collect and you may not want that.
     */
    AffineTransform nodeToWorldTransform([BaseNode psuedoRoot]) {
      // Get a pooled transform to accumulate the parent transforms.
      // child = comp
      AffineTransform comp = new AffineTransform.withAffineTransformP(calcTransform());
  