anchor.diff:  %%! -pa ./_build/default/lib/jsx/ebin -Wall
   
   -define(RESULTS, results).
  +-define(SCHEDULES, schedules).
   
   main([TraceFile, ReplayTraceFile, CounterexampleConsultFile, RebarCounterexampleConsultFile, PreloadOmissionFile]) ->
  +    %% Get module as string.
  +    ModuleString = os:getenv("IMPLEMENTATION_MODULE"),
  +
       %% Keep track of when test started.
       StartTime = os:timestamp(),
   
       %% Open ets table for results.
       ?RESULTS = ets:new(?RESULTS, [named_table, set]),
   
  +    %% Open table for schedules.
  +    ?SCHEDULES = ets:new(?SCHEDULES, [named_table, ordered_set]),
  +
       %% Open the trace file.
       {ok, TraceLines} = file:consult(TraceFile),
   
       %% Open the causality file.
  -    {ok, [Causality]} = file:consult("/tmp/partisan-causality"),
  +    {ok, [RawCausality]} = file:consult("/tmp/partisan-causality-" ++ ModuleString),
  +    Causality = dict:from_list(RawCausality),
       io:format("Causality loaded: ~p~n", [dict:to_list(Causality)]),
   
       %% Open the annotations file.
  -    {ok, [RawAnnotations]} = file:consult("/tmp/partisan-annotations"),
  +    {ok, [RawAnnotations]} = file:consult("/tmp/partisan-annotations-" ++ ModuleString),
       Annotations = dict:from_list(RawAnnotations),
       io:format("Annotations loaded: ~p~n", [dict:to_list(Annotations)]),
  +
  +    %% Check that we have the necessary preconditions.
  +    PreconditionsPresent = ensure_preconditions_present(Causality, Annotations),
  +    io:format("All preconditions present: ~p~n", [PreconditionsPresent]),
  +    case PreconditionsPresent of 
  +        true ->
  +            ok;
  +        false ->
  +            exit({error, not_all_preconditions_present})
  +    end,
   
       %% Open the counterexample consult file:
       %% - we make an assumption that there will only be a single counterexample here.
  
positive.code:             case Other of 
                  "" ->
                      exit({error, no_sublist_provided});
                  _ ->
                      lists:reverse(lists:sublist(SortedPowerset, list_to_integer(Other)))
              end
  
negative.code:         dict:store(Type, Result, Dict0)
      end, dict:new(), dict:to_list(Annotations)),
  
      % io:format("classification: ~p~n", [dict:to_list(Classification)]),
  
      Classification.
  
  %% @private
  ensure_preconditions_present(Causality, Annotations) ->
      %% Get all messages that are the result of other messages.
      CausalMessages = lists:foldl(fun({_, Messages}, Acc) ->
          Messages ++ Acc
      end, [], dict:to_list(Causality)),
  
      lists:foldl(fun(Message, Acc) ->
          case lists:keymember(Message, 1, dict:to_list(Annotations)) of 
              true ->
                  Acc andalso true;
              false ->
                  io:format("Precondition not found for message type: ~p~n", [Message]),
                  Acc andalso false
          end
      end, true, CausalMessages).