anchor.diff:           end;
          end;
       }
  -    PBufferHigh := @{$ifdef CPUX86}Store.{$endif}Buffer[(NodeInfo shr COUNTER_OFFSET) and $f];
  +   (* PBufferHigh := @{$ifdef CPUX86}Store.{$endif}Buffer[(NodeInfo shr COUNTER_OFFSET) and $f];
       PBufferBase := @{$ifdef CPUX86}Store.{$endif}Buffer[1];
       PBufferCurrent := @{$ifdef CPUX86}Store.{$endif}Buffer[0];
       while (PBufferBase <> PBufferHigh) do
  
positive.code:       Cell := Store.Current.Cell;
        Inc(NativeInt(Cell), Store.Info.CellOffsets[Child]);
  
        // tile, mask --> (0, mask, 0, tile)
        ChildNodeInfo := PWord(Cell)^;
        ChildNodeInfo := (ChildNodeInfo + (ChildNodeInfo shl 24)) and Integer($00ff00ff);
  
        // (parent:3, mask, parentmask, tile)
        Child := (Child shl 2) + (NodeInfo and 2) + (NativeUInt(Cardinal(Store.Current.Coordinates)) and 1);
        ChildNodeInfo := ChildNodeInfo or PARENT_BITS[Child];
  
        // path of current(tile) --> child(tile)
        TileWeights := Store.Info.TileWeights[ChildNodeInfo{parent} and 1];
        Path := TileWeights[NodeInfo shr 24];
        Inc(Path, TileWeights[ChildNodeInfo shr 24]);
  
        // pathless tiles test
        if (Path > PATHLESS_TILE_WEIGHT) then
          goto nextchild_continue;
  
        // from start point path
        Path := Store.Current.Path + (Path shr 1);
  
        // if node is allocated/initialized
        ChildNode := Pointer(NativeUInt(Cell.NodePtr));
        if (NativeInt(ChildNode) and NODEPTR_FLAG_HEURISTED = 0) then
        begin
          // mask & parentmask test
          if (ChildNodeInfo and ((ChildNodeInfo and $ff00) shl 8) = 0) then
            goto nextchild_continue;
  
          if (NativeInt(ChildNode) and NODEPTR_FLAG_ALLOCATED = 0) then
          begin
            // allocate new node
            ChildNode := Store.Info.NodeAllocator.NewNode;
  
  
negative.code:           // already node allocated and coordinates filled
            // need to fill path/parent and heuristics/way data
            {$ifdef LARGEINT}
              NodeAllocatorBuffers := Pointer(@Store.Info.NodeAllocator.Items);
              ChildNode := Pointer(
                (NodeAllocatorBuffers[ChildNodeInfo) shr LARGE_NODEPTR_OFFSET]) +
                (ChildNodeInfo and NODEPTR_CLEAN_MASK) );
            {$else}
              ChildNode := Pointer(ChildNodeInfo and NODEPTR_CLEAN_MASK);
            {$endif}
  
            // (parent:3, mask, parentmask, tile) + test
            ParentBits := ParentBits or (ChildNode.NodeInfo and Integer($ff00ff00));
            if (ParentBits and (ParentBits shl 8) = 0) then
              goto nextchild_continue;
  
            // path
            TileWeights := Store.Info.TileWeights[ParentBits and 1];
            Path := TileWeights[NodeInfo shr 24] + TileWeights[ParentBits shr 24];
            if (Path > PATHLESS_TILE_WEIGHT) then
              goto nextchild_continue;
            Path := Store.Current.Path + (Path shr 1);
  
            {$ifdef CPUX86}
            // todo optimize
  //          ChildNodeInfo := //Cell.NodePtr;
            ChildNode := Pointer(Cell.NodePtr and NODEPTR_CLEAN_MASK);
            Cell.NodePtr := Cell.NodePtr or NODEPTR_FLAG_HEURISTED;
            {$else}
            Cell.NodePtr := ChildNodeInfo or NODEPTR_FLAG_HEURISTED;
            {$endif}
            ChildNode.Path := Path;
            ChildNode.NodeInfo := ParentBits;
  
          heuristics_data:
            // (dX, dY) = ChildNode.Coordinates - Store.Info.FinishPoint;
            (*dX := Cardinal(ChildNode.Coordinates);
            dY := Word(dX);
            dX := dX shr 16;
            Mask := Cardinal(Store.Info.FinishPoint);
            dY := dY - Word(Mask);
            dX := dX - (Mask shr 16);*)
            dX := 0;
            dY := 0;
  
            // Way
            Mask := 2*Byte(dY > 0);
  