anchor.diff:    TPathMapNode = packed record
       SortValue: Cardinal; // path + heuristics to start point
       Path: Cardinal; // path from finish point to the cell
  -    Coordinates: TWPoint;
  +    Coordinates: TCPFPoint;
       Prev, Next: PPathMapNode;
       case Integer of
       0: (
  +         ParentAndFlags: Byte{Parent:3; WayDeltaId:2; Way:3};
            Mask: Byte;
  -         ParentAndFlags: Byte{Parent:3; WayDeltaId:2; Way:3};
            ParentMask: Byte;
            Tile: Byte;
          );
  
positive.code: 
        // clear child bit, get child number
        NodeInfo := NodeInfo and (not Child);
        Child := Child shr (8 + 4);
  
        // child map cell
        Cell := Store.Current.Cell;
        Inc(NativeInt(Cell), Store.Info.CellOffsets[Child]);
        ChildNodePtr := Cell.NodePtr;
        if (ChildNodePtr and 1 <> 0{Fixed}) then
        begin
          if (NodeInfo and $ff <> 0) then Continue;
          Break;
        end;
  
        // parent bits
        ChildNodeInfo := PARENT_BITS[Child +
        ((NodeInfo or (NativeUInt(Cardinal(Store.Current.Coordinates)) and (1 shl 16)))
          shr (16 - 3))];
  
        // test
  
  //      ChildNodeInfo := PWord(Cell)^;
  
        // Path
        TileWeights := Store.Info.TileWeights[Child and 1];
        //Path := (TileWeights[NodeInfo shr 24] +  shr 1;
        //Inc(Path, Store.Current.Path);
        Path := TileWeights[NodeInfo shr 24];
        Inc(Path, TileWeights[Byte(ChildNodeInfo){Cell.Tile}]);
        Path := Store.Current.Path + (Path shr 1);
  
        // allocate new node or compare exists path
        if (ChildNodePtr = 0) then
        begin
          // 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[Child]);
          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 todo and so
  
          // found test
          if (ChildXY = Cardinal(Store.Info.FinishPoint)) then
          begin
            Result := True;
            Exit;
            // todo
          end;
  
  
  
          if (ChildNode = Store.Info.NodeStorage.MaximumNode) then
          begin
            // todo call some realloc
            CopyInfo(Store.Info, TPathMapPtr(Store.Self).FInfo);
          end else
          begin
            Inc(ChildNode);
            Store.Info.NodeStorage.NewNode := ChildNode;
            Dec(ChildNode);
          end;
        end else
        begin
          // node is already exists
          {$ifdef LARGEINT}
            // todo
            ChildNode := Pointer(ChildNodePtr);
  
negative.code:   NodeXY, OffsetXY, ChildXY: Cardinal;
  
    Store: record
      Buffer: TMapNodeBuffer;
      Self: Pointer;
      Info: TPathMapInfo;
  
  