anchor.diff:      // length of cached node
       nLength := Node.SortValue;
     until (nLength >= NATTANABLE_LENGTH_LIMIT);
  -  Node := ParentNode;
  -  nLength := Node.SortValue;
   
     // cache: attainable <-- cached
  +  {$ifdef CPUX86}
  +  Cardinal(Cell) := nLength;
  +  {$else}
  +  NodeInfo := Node.NodeInfo;
  +  {$endif}
     repeat
       // parameters
       ParentNodeInfo := ParentNode.NodeInfo;
       SingleWeigths := {$ifdef CPUX86}Store.{$endif}SingleLineWeigths;
  -    Dec(nLength){increment};
  -    Inc(NativeInt(SingleWeigths), (ParentNodeInfo and (1 shl 3)) shl (10 - 3));
  -
  -    // length and distance
  -    ParentNode.nAttainableLength := nLength;
  +    Inc(NativeInt(SingleWeigths), (ParentNodeInfo and (1 shl 3){child}) shl (10 - 3));
  +
  +    // heuristics, length and distance
  +    Dec({$ifdef CPUX86}Cardinal(Cell){$else}nLength{$endif}){increment};
  +    ParentNode.Path := {$ifdef CPUX86}Cardinal(Cell){$else}nLength{$endif} - (ParentNode.SortValue - ParentNode.Path){heurisctics};
  +    ParentNode.nAttainableLength := {$ifdef CPUX86}Cardinal(Cell){$else}nLength{$endif};
       {$ifdef CPUX86}
         ParentNode.AttainableDistance := Node.AttainableDistance +
  -        HALF * (SingleWeigths[ParentNodeInfo shr 24] + SingleWeigths[NativeUInt(Node.NodeInfo) shr 24]);
  +        HALF * (SingleWeigths[ParentNodeInfo shr 24] + SingleWeigths[Node.NodeInfo shr 24]);
       {$else}
         W1 := SingleWeigths[ParentNodeInfo shr 24];
  -      W2 := SingleWeigths[NativeUInt(Node.NodeInfo) shr 24]);
  +      W2 := SingleWeigths[NodeInfo shr 24];
         ParentNode.AttainableDistance := Node.AttainableDistance + HALF * (W1 + W2);
  +      NodeInfo := ParentNodeInfo;
       {$endif}
   
       // next node
  
positive.code:         (ParentNodeInfo and NODEPTR_CLEAN_MASK) );
      {$else}
        ParentNode := Pointer(Cell.NodePtr and NODEPTR_CLEAN_MASK);
        //ParentNode := Pointer(Cell.NodePtr);
      {$endif}
  
  
  
     (*   nLength{Right} := Cardinal(ParentNode.Next);
        ParentNodeInfo{Left} := Cardinal(ParentNode.Prev);
        PCPFNode(nLength{Right}).Prev := PCPFNode(ParentNodeInfo{Left});
        PCPFNode(ParentNodeInfo{Left}).Next := PCPFNode(nLength{Right});
     *)
      ParentNodeInfo := ParentNode.NodeInfo;
  
      // child and flags
      ParentNode.NodeInfo := (ParentNodeInfo and CHILDS_BITS_CLEAR_MASK) +
        (((NodeInfo{$ifNdef CPUX86} and 7{$endif}) shl 3) + (FLAG_KNOWN_PATH + FLAG_ATTAINABLE));
  
      // remove from list
    (*  {$ifdef CPUX86}
        nLength{Right} := Cardinal(ParentNode.Next);
        NodeInfo{Left} := Cardinal(ParentNode.Prev);
        PCPFNode(nLength{Right}).Prev := PCPFNode(NodeInfo{Left});
        PCPFNode(NodeInfo{Left}).Next := PCPFNode(nLength{Right});
      {$else}
        Right := ParentNode.Next;
        Left := ParentNode.Prev;
        Right.Prev := Left;
        Left.Next := Right;
      {$endif} *)
  
  
  
      // parameters
      {$ifdef CPUX86}
      nLength := Node.nAttainableLength;
      {$endif}
      Dec(nLength){increment};
      SingleWeigths := {$ifdef CPUX86}Store.{$endif}SingleLineWeigths;
  
      // length and distance
      ParentNode.nAttainableLength := nLength;
      Inc(NativeInt(SingleWeigths), ((ParentNodeInfo and 1) shl 10));
      {$ifdef CPUX86}
        ParentNode.AttainableDistance := Node.AttainableDistance +
          HALF * (SingleWeigths[Node.NodeInfo shr 24] + SingleWeigths[ParentNodeInfo shr 24]);
  
        NodeInfo := ParentNode.NodeInfo;
      {$else}
        W1 := SingleWeigths[ParentNodeInfo shr 24];
        W2 := SingleWeigths[NodeInfo shr 24]);
        ParentNode.AttainableDistance := Left.AttainableDistance + HALF * (W1 + W2);
  
        NodeInfo := ParentNodeInfo;
      {$endif}
      Node := ParentNode;
      Inc(NodeInfo, 4{invert parent});
    if (ParentNode <> {$ifdef CPUX86}Store.{$endif}StartPointNode) then goto cacheloop;
    // until (ParentNode <> {$ifdef CPUX86}Store.{$endif}StartPointNode);
  
    // result length and distance
    with {$ifdef CPUX86}Store.StartPoint^{$else}StartPoint{$endif} do
    begin
      Length :=  not {$ifdef CPUX86}ParentNode.nAttainableLength{$else}nLength{$endif};
      Distance := ParentNode.AttainableDistance;
    end;
  end;
  
negative.code:   // remove from list and cache: start node <-- attainable
    Cell := Store.Cell;
    NodeInfo := NativeUInt(Node.NodeInfo) + 4{invert parent};
    repeat
      // parent cell
      {$ifdef CPUX86}
        NodeInfo := NodeInfo and 7;
      {$endif}
      Inc(NativeInt(Cell), {$ifdef CPUX86}Store.{$endif}CellOffsets[NodeInfo{$ifNdef CPUX86} and 7{$endif}]);
  
      // cell node
      {$ifdef LARGEINT}
  