anchor.diff:            ChildNode := Pointer(ChildNodePtr);
           {$endif}
   
  +        if (Path >= ChildNode.Path) then
  +        begin
  +          if (NodeInfo and $ff00 <> 0) then Continue;
  +          Break;
  +        end;
  +
  +        // new parent bits
  +        ChildNode.NodeInfo := (ChildNode.NodeInfo and DELTA_CLEAR_MASK) or ChildNodeInfo;
  +
  +        // new Path and SortValue
  +        ChildNode.SortValue := Path + (ChildNode.SortValue - ChildNode.Path);
  +
  +        // remove todo
  +        //
  +
  +        goto child_tobuffer;
         end;
   
  -      if (Path < ChildNode.Path) then
  +      // allocate new node
  +      ChildNode := Store.Info.NodeStorage.NewNode;
  +      {$ifdef LARGEINT}
  +        Cell.NodePtr := NativeUInt(NativeInt(ChildNode) + Store.Info.NodeStorage.LargeModifier);
  +      {$else}
  +        Cell.NodePtr := NativeUInt(ChildNode);
  +      {$endif}
  +
  +      // child coordinates
  +      OffsetXY := Cardinal(POINT_OFFSETS_INVERT[ChildNodeInfo and 7]);
  +      NodeXY := Cardinal(Store.Current.Coordinates);
  +      ChildXY := NodeXY + OffsetXY;
  +      OffsetXY := OffsetXY and $ffff0000;
  +      NodeXY := NodeXY and $ffff0000;
  +      ChildXY := Word(ChildXY) + NodeXY + OffsetXY;
  +      Cardinal(ChildNode.Coordinates) := ChildXY;
  +
  +      // heuristics and so on
  +      // todo
  +
  +      // set next allocable node
  +      if (ChildNode = Store.Info.NodeStorage.MaximumNode) then
         begin
  -        ChildNode.Path := Path;
  -        Store.Buffer[NodeInfo shr 28] := ChildNode;
  -        Inc(NodeInfo, 100500);
  +        // todo call some realloc
  +        CopyInfo(Store.Info, TPathMapPtr(Store.Self).FInfo);
  +      end else
  +      begin
  +        Inc(ChildNode);
  +        Store.Info.NodeStorage.NewNode := ChildNode;
  +        Dec(ChildNode);
         end;
   
  -//      MapCell: PPathMapCell;
  -
  -
  -      // try open child node
  -
  -
  -      //Node.
  -
  -
  -
  -      if (NodeInfo = 0) or (Child = 0) then
  -        raise Exception.Create('Error Message');
  -      
  -
  -      if (NodeInfo and $ff = 0) then Break;
  +      // found test
  +      if (ChildXY = Cardinal(Store.Info.FinishPoint)) then
  +      begin
  +        Result := True;
  +        Exit;
  +        // todo
  +      end;
  +
  +    child_tobuffer:
  +      {$ifdef CPUX86}Store.{$endif}Buffer[(NodeInfo shr COUNTER_OFFSET) and 7] := ChildNode;
  +      Inc(NodeInfo, (1 shl COUNTER_OFFSET));
  +
  +      if (NodeInfo and $ff00 = 0) then Break;
       until (False);
   
  +    // move buffered nodes to opened list
  +    if (NodeInfo and (7 shl COUNTER_OFFSET) = 0) then
  +      goto next_current;
  +
  +    // sort
  +    // todo
  +
       // next opened node
  +  next_current:
       Node := Store.Current.Node.Next;
     current_initialize:
       Store.Current.Node := Node;
  -    if (Node.SortValue = High(Cardinal)) then
  +    Store.Current.Path := Node.Path;
  +    if (Store.Current.Path = High(Cardinal)) then
       begin
         Result := False;
         Exit;
  
positive.code:     Current: record
        Node: PPathMapNode;
        Cell: PPathMapCell;
        Coordinates: TWPoint;
        Path: Cardinal;
      end;
    end;
  begin
    Store.Self := MapSelf;//Pointer({$ifdef CPFLIB}@Self{$else}Self{$endif});
    Store.HexagonalFlag := NativeUInt(TPathMapPtr(MapSelf).FKind = mkHexagonal) shl 17;
    //Store.Info := TPathMapPtr(Store.Self).FInfo;
    CopyInfo(Store.Info, TPathMapPtr(MapSelf).FInfo);
  
    // finding loop from Finish to Start
    Node := FinishNode;
    goto current_initialize;
    repeat
      // child list
      ChildList := Pointer(NativeUInt(CHILD_ARRAYS_OFFSETS[Byte(NodeInfo shr 8)]));
      Inc(NativeUInt(ChildList), NativeUInt(@CHILD_ARRAYS));
  
      // reinitialize NodeInfo:
      //   - mask
      //   - stored childs counter
      //   - bit hexagonal << 1
      //   - tile
      NodeInfo := ((NodeInfo and (NodeInfo shr 16)) and Integer($ff0000ff)) or Store.HexagonalFlag;
  
      // each child cell loop
      goto nextchild;
  
negative.code:     // cell
      NodeInfo{XY} := Cardinal(Node.Coordinates);
      Cardinal(Store.Current.Coordinates) := NodeInfo{XY};
      Cell := @Store.Info.Cells[(NativeInt(NodeInfo{XY}) shr 16) + Store.Info.MapWidth * Word(NodeInfo{XY})];
      Store.Current.Cell := Cell;
  
      // lock
      Cell.NodePtr := Cell.NodePtr or 1;
  