anchor.diff:      Right.Prev := Left;
     end;
   
  +  // storage, pool, queue
  +  CellRec.Cell := Cell;
  +  Storage.Offsets := FInfo.CellOffsets;
  +  Storage.QueueLast := @CellRec;
  +  CellRec.Next := nil;
  +  Buffer[0].Next := @Buffer[1];
  +  Buffer[1].Next := @Buffer[2];
  +  Buffer[2].Next := @Buffer[3];
  +  Buffer[3].Next := @Buffer[4];
  +  Buffer[4].Next := @Buffer[5];
  +  Buffer[5].Next := @Buffer[6];
  +  Buffer[6].Next := @Buffer[7];
  +  Buffer[7].Next := nil;
  +  Storage.Pool := @Buffer[0];
  +
     // recursion call
  -  ReleaseAroundAttainableNodes({$ifdef CPFLIB}@Self{$else}Self{$endif},
  -    Cell{$ifdef LARGEINT}, NodeBuffers{$endif});
  +  ReleaseAroundAttainableNodes(Storage, @CellRec{$ifdef LARGEINT}, NodeBuffers{$endif});
   end;
   
   procedure TTileMap.ReleasePoolNodes(var PoolFirst, PoolLast: TCPFNode);
  
positive.code:   GrowNodeAllocator(FInfo);
  end;
  
  procedure ReleaseAroundAttainableNodes(const Self: TTileMapPtr; const Cell: PCPFCell
    {$ifdef LARGEINT}; NodeBuffers: PCPFNodeBuffers{$endif});
  label
    clearbit;
  var
    Offsets: PCPFOffsets;
    NodeInfo: NativeUInt;
    Node, Left, Right: PCPFNode;
    Mask, Flags: NativeUInt;
  
    Store: record
      Self: Pointer;
    end;
  begin
    // store parameters
    Offsets := @Self.FInfo.CellOffsets;
    Store.Self := Self;
  
    NodeInfo := Cell.NodePtr;
    Mask := PCPFNode
        (
          {$ifdef LARGEINT}NodeBuffers[NodeInfo shr LARGE_NODEPTR_OFFSET] +{$endif}
          NodeInfo and NODEPTR_CLEAN_MASK
        ).NodeInfo;
    Mask := Mask and $ff00;
  
    // check loop
    Flags := (1 shl 8){bit} + 0{child};
    if (Mask <> 0) then
    repeat
      // skip not childs
      while (Mask and Flags = 0) do
      begin
        NodeInfo := Flags and -8;
        Inc(Flags);
        Inc(Flags, NodeInfo);
      end;
  
      // look attainable (knownpath) child
      NodeInfo := PCPFCell(NativeInt(Cell) + Offsets[Flags and 7]).NodePtr;
      if (NodeInfo and NODEPTR_FLAG_HEURISTED <> 0) then
      begin
        Node := PCPFNode
            (
              {$ifdef LARGEINT}NodeBuffers[NodeInfo shr LARGE_NODEPTR_OFFSET] +{$endif}
              NodeInfo and NODEPTR_CLEAN_MASK
            );
        if (Node.NodeInfo and FLAG_KNOWN_PATH = 0) then goto clearbit;
  
        // mark as allocated only
        with PCPFCell(NativeInt(Cell) + Offsets[Flags and 7])^ do
          NodePtr := NodePtr and (not NODEPTR_FLAG_HEURISTED);
  
        // remove from list
        if (Node.SortValue < NATTANABLE_LENGTH_LIMIT) then
        begin
          Left := Node.Prev;
          Right := Node.Next;
          Left.Next := Right;
          Right.Prev := Left;
        end;
      end else
      begin
        clearbit:
        Mask := (Mask xor Flags) and -8;
      end;
  
      // bit << 1, child++
      NodeInfo := Flags and -8;
      Inc(Flags);
      Inc(Flags, NodeInfo);
    until (Flags = (1 shl (8+8)) + 8);
  
    // recursion loop
    Flags := (1 shl 8){bit} + 0{child};
    if (Mask <> 0) then
    repeat
      // skip not childs
      while (Mask and Flags = 0) do
      begin
        NodeInfo := Flags and -8;
        Inc(Flags);
        Inc(Flags, NodeInfo);
      end;
  
      // call
      ReleaseAroundAttainableNodes(Store.Self, PCPFCell(NativeInt(Cell) + Offsets[Flags and 7])
        {$ifdef LARGEINT}, NodeBuffers{$endif});
      Mask := (Mask xor Flags) and -8;
  
      // next iteration
      NodeInfo := Flags and -8;
      Inc(Flags);
      Inc(Flags, NodeInfo);
    until (Mask = 0);
  end;
  
  procedure TTileMap.ForgetAttainableTreeNodes;
  
negative.code:   {$endif}
  begin
    Result := nil;
    Len := 0;
    {$ifdef LARGEINT}
    NodeBuffers := Pointer(@FInfo.NodeAllocator.Buffers);
  