anchor.diff:      function GetTile(const X, Y: Word): Byte;
       procedure SetTile(const X, Y: Word; Value: Byte);
       procedure GrowNodeAllocator(var Buffer: TCPFInfo);
  -    function CalculateHeuristics(const Start, Finish: TPoint): NativeInt;
  -    function AllocateHeuristedNode(const X, Y: NativeInt): PCPFNode;
   //    procedure ClearMapCells(Node: PCPFNode; Count: NativeUInt); overload;
   //    procedure ClearMapCells(Node: PCPFNode{as list}); overload;
       function DoFindPathLoop(StartNode: PCPFNode): PCPFNode;
  
positive.code:   FoundPaths := Params.StartsCount;
    StartPoint := FActualInfo.Starts.Buffer.Memory;
    AttainableAlgorithm := (FoundPaths > 1) or (Self.FCaching);
    FailureNode.SortValue := SORTVALUE_LIMIT;
    FailureNode.Path := SORTVALUE_LIMIT;
    Cardinal(FailureNode.Coordinates) := High(Cardinal);
    FailureNode.NodeInfo := FLAG_KNOWN_PATH {+ not FLAG_ATTAINABLE};
    for i := Params.StartsCount downto 1 do
  
negative.code:   HeuristedPoolNode: PCPFNode;
    Node, AttainableNode, Buffer: PCPFNode;
  begin
    // mark list end (nil)
    FailureNode.Prev.Next := nil;
  
    // start point nodes
    Buffer{Node} := StartPoint.Node;
    AttainableNode := StartPoint.AttainableNode;
  
    // first heuristed pool node
    Buffer{Node}.Prev := @FNodes.HeuristedPool.First;
    HeuristedPoolNode := FNodes.HeuristedPool.First.Next;
    FNodes.HeuristedPool.First.Next := Buffer{Node};
  
    // process each node
    if (AttainableNode.NodeInfo and FLAG_ATTAINABLE <> 0) then
    begin
      // retrieve parent mask (unlock)
      // clear sort value
      while (Buffer <> AttainableNode) do
      begin
        Node := Buffer;
        Buffer := Buffer.Next;
  
        Node.ParentMask := $ff;
        Node.Path := SORTVALUE_LIMIT - (Node.SortValue - Node.Path);
        Node.SortValue := SORTVALUE_LIMIT;
      end;
  
      // clear sort value
      repeat
        Node := Buffer;
        Buffer := Buffer.Next;
  
        Node.Path := SORTVALUE_LIMIT - (Node.SortValue - Node.Path);
        Node.SortValue := SORTVALUE_LIMIT;
      until (Buffer = nil);
    end else
    begin
      // retrieve parent mask (unlock)
      // mark as KnownPath Unattainable
      // clear node heuristics
      repeat
        Node := Buffer;
        Buffer := Buffer.Next;
  
        Node.NodeInfo := Node.NodeInfo or ($00ff0000{parent mask} or FLAG_KNOWN_PATH);
        Node.Path := SORTVALUE_LIMIT;
        Node.SortValue := SORTVALUE_LIMIT;
      until (Buffer = nil);
    end;
  
    // last heuristed pool node
    Node.Next := HeuristedPoolNode;
    HeuristedPoolNode.Prev := Node;
  end;
  