anchor.diff:  
       Acc2 = lists:foldl(F2, Acc1, Segments),
   
  -    %% Reply...
       {reply, {ok, Acc2}, State};
  -    
  +
   handle_call(is_empty, _From, State) ->
  -    #state { terms=Terms } = State,
  -    IsEmpty = (mi_incdex:size(Terms) == 0),
  +    IsEmpty = mi_ift_server:term_count() == 0,
       {reply, IsEmpty, State};
   
   handle_call(drop, _From, State) ->
  -    #state { indexes=Indexes, fields=Fields, terms=Terms, buffers=Buffers, segments=Segments } = State,
  +    #state { buffers=Buffers, segments=Segments } = State,
   
       %% Figure out some options...
       SyncInterval = ?SYNC_INTERVAL(State),
  
positive.code: 
  handle_call({info, Index, Field, Term}, _From, State) ->
      %% Calculate the IFT...
      #state { indexes=Indexes, fields=Fields, terms=Terms, buffers=Buffers, segments=Segments } = State,
      IndexID = mi_incdex:lookup_nocreate(Index, Indexes),
      FieldID = mi_incdex:lookup_nocreate(Field, Fields),
      TermID = mi_incdex:lookup_nocreate(Term, Terms),
      IFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
  
      %% Look up the counts in buffers and segments...
      BufferCount = lists:sum([mi_buffer:info(IFT, X) || X <- Buffers]),
      SegmentCount = lists:sum([mi_segment:info(IFT, X) || X <- Segments]),
      Counts = [{Term, BufferCount + SegmentCount}],
  
      %% Return...
      {reply, {ok, Counts}, State};
  
  handle_call({info_range, Index, Field, StartTerm, EndTerm, Size}, _From, State) ->
      %% Get the IDs...
      #state { indexes=Indexes, fields=Fields, terms=Terms, buffers=Buffers, segments=Segments } = State,
      IndexID = mi_incdex:lookup_nocreate(Index, Indexes),
      FieldID = mi_incdex:lookup_nocreate(Field, Fields),
      TermIDs = mi_incdex:select(StartTerm, EndTerm, Size, Terms),
  
      F = fun({Term, TermID}) ->
          StartIFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
          EndIFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
          BufferCount = lists:sum([mi_buffer:info(StartIFT, EndIFT, X) || X <- Buffers]),
          SegmentCount = lists:sum([mi_segment:info(StartIFT, EndIFT, X) || X <- Segments]),
          {Term, BufferCount + SegmentCount}
      end,
      Counts1 = [F(X) || X <- TermIDs],
      Counts2 = [{Term, Count} || {Term, Count} <- Counts1, Count > 0],
      {reply, {ok, Counts2}, State};
  
  handle_call({stream, Index, Field, Term, Pid, Ref, FilterFun}, _From, State) ->
      %% Get the IDs...
      #state { locks=Locks, indexes=Indexes, fields=Fields, terms=Terms, buffers=Buffers, segments=Segments } = State,
      IndexID = mi_incdex:lookup_nocreate(Index, Indexes),
      FieldID = mi_incdex:lookup_nocreate(Field, Fields),
      TermID = mi_incdex:lookup_nocreate(Term, Terms),
  
      %% TODO - These next two lines are indicitive of vestigal code
      %% from when merge_index used the fated subtype/subterm
      %% structure. We no longer need a StartIFT and EndIFT, we just
      %% need the IFT to stream. As a result, there are simplifications
      %% we could make in mi_buffer and mi_segment. Not making them now
      %% due to time pressure. - RTK
      StartIFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
      EndIFT = mi_utils:ift_pack(IndexID, FieldID, TermID),
  
      %% Add locks to all buffers...
      F1 = fun(Buffer, Acc) ->
          mi_locks:claim(mi_buffer:filename(Buffer), Acc)
      end,
      NewLocks = lists:foldl(F1, Locks, Buffers),
  
      %% Add locks to all segments...
      F2 = fun(Segment, Acc) ->
          mi_locks:claim(mi_segment:filename(Segment), Acc)
      end,
      NewLocks1 = lists:foldl(F2, NewLocks, Segments),
  
      %% Spawn a streaming function...
      Self = self(),
      spawn_link(fun() -> 
          F = fun(_IFT, Value, Props, _TS) ->
              case FilterFun(Value, Props) of
                  true -> 
                      Pid!{result, {Value, Props}, Ref};
                  _ -> 
                      skip
              end
          end,
          stream(StartIFT, EndIFT, F, Buffers, Segments),
          Pid!{result, '$end_of_table', Ref},
          gen_server:call(Self, {stream_finished, Buffers, Segments}, infinity)
      end),
  
      %% Reply...
      {reply, ok, State#state { locks=NewLocks1 }};
  
  handle_call({stream_finished, Buffers, Segments}, _From, State) ->
      #state { locks=Locks } = State,
  
negative.code:     {reply, ok, State#state { locks=NewLocks1 }};
  
  handle_call({fold, Fun, Acc}, _From, State) ->
      #state { buffers=Buffers, segments=Segments } = State,
  
      %% Create the fold function.
      WrappedFun = fun({IFT, Value, Props, TS}, AccIn) ->
                           %% Look up the Index, Field, and Term...
                           {Index, Field, Term} = mi_ift_server:reverse_ift(IFT),
  
                           %% Call the fold function...
                           Fun(Index, Field, Term, Value, Props, TS, AccIn)
                   end,
  
      %% Fold over each buffer...
      F1 = fun(Buffer, AccIn) ->
  