anchor.diff:                    | {error, reason()} | {eof, dict:dict()}.
   get_ops_from_log(Log, Key, Continuation, MinSnapshotTime, Ops, CommittedOpsDict, LoadAll) ->
       case disk_log:chunk(Log, Continuation) of
  +        {error, Reason} ->
  +            {error, Reason};
  +
           eof ->
               {eof, finish_op_load(CommittedOpsDict)};
  -        {error, Reason} ->
  -            {error, Reason};
  +
           {NewContinuation, NewTerms} ->
               {NewOps, NewCommittedOps} = filter_terms_for_key(NewTerms, Key, MinSnapshotTime, Ops, CommittedOpsDict),
               case LoadAll of
  
positive.code:             {reply, Error, State}
      end;
  
  handle_command({get, LogId, MinSnapshotTime, Type, Key}, _Sender,
      #state{logs_map = Map, partition = Partition} = State) ->
      case get_log_from_map(Map, Partition, LogId) of
          {ok, Log} ->
              ok = disk_log:sync(Log),
              case get_ops_from_log(Log, Key, MinSnapshotTime, load_all) of
                  {error, Reason} ->
                      {reply, {error, Reason}, State};
  
                  {ok, CommittedOpsForKey} ->
                      {reply, #snapshot_get_response{number_of_ops = length(CommittedOpsForKey), ops_list = CommittedOpsForKey,
                                                     materialized_snapshot = #materialized_snapshot{last_op_id = 0, value = clocksi_materializer:new(Type)},
                                                     snapshot_time = vectorclock:new(), is_newest_snapshot = false},
                       State}
              end;
          {error, Reason} ->
              {reply, {error, Reason}, State}
      end;
  
  %% This will reply with all downstream operations that have
  %% been stored in the log given by LogId
  
negative.code:                 load_per_chunk ->
                      {NewContinuation, NewOps, finish_op_load(NewCommittedOps)}
              end;
  
          {NewContinuation, NewTerms, BadBytes} ->
              case BadBytes > 0 of
                  true ->
                      {error, bad_bytes};
  
                  false ->
                      {NewOps, NewCommittedOps} = filter_terms_for_key(NewTerms, Key, MinSnapshotTime, Ops, CommittedOpsDict),
                      case LoadAll of
  