anchor.diff:              case Other of 
                   "" ->
                       exit({error, no_sublist_provided});
  +                "0" ->
  +                    lists:reverse(SortedPowerset);
                   _ ->
                       lists:reverse(lists:sublist(SortedPowerset, list_to_integer(Other)))
               end
  
positive.code:     %% For each trace, write out the preload omission file.
      lists:foldl(fun(Omissions, Iteration) ->
          io:format("~n", []),
  
          %% Write out a new omission file from the previously used trace.
          io:format("Writing out new preload omissions file!~n", []),
          {ok, PreloadOmissionIo} = file:open(PreloadOmissionFile, [write, {encoding, utf8}]),
          [io:format(PreloadOmissionIo, "~p.~n", [O]) || O <- [Omissions]],
          ok = file:close(PreloadOmissionIo),
  
          %% Generate a new trace.
          io:format("Generating new trace based on message omissions (~p omissions): ~n", 
  
negative.code:         ScheduleValid = schedule_valid(Causality, PrefixMessageTypes, OmittedMessageTypes, ConditionalMessageTypes),
          io:format("schedule_valid: ~p~n", [ScheduleValid]),
  
          ClassifySchedule = classify_schedule(3, Annotations, PrefixMessageTypes, OmittedMessageTypes, ConditionalMessageTypes),
  
          case ScheduleValid of 
              true ->
                  io:format("classify_schedule: ~p, schedule_valid: ~p~n", [dict:to_list(ClassifySchedule), ScheduleValid]);
              false ->
                  ok
          end,
  
          %% Store generated schedule.
          true = ets:insert(?SCHEDULES, {Iteration, {Omissions, FinalTraceLines, ClassifySchedule, ScheduleValid}}),
  
          %% Bump iteration.
          Iteration + 1
      end, 1, TracesToIterate),
  
      %% Run schedules.
      {NumberPassed, NumberFailed, NumberPruned, _} = ets:foldl(fun({Iteration, {Omissions, FinalTraceLines, ClassifySchedule, ScheduleValid}}, {NumPassed, NumFailed, NumPruned, ClassificationsExplored0}) ->
          Classification = dict:to_list(ClassifySchedule),
  
          case ScheduleValid of 
              false ->
                  {NumPassed, NumFailed, NumPruned + 1, ClassificationsExplored0};
              true ->
                  case lists:member(Classification, ClassificationsExplored0) of 
                      true ->
                          {NumPassed, NumFailed, NumPruned + 1, ClassificationsExplored0};
                      false ->
                          %% Write out a new omission file from the previously used trace.
                          io:format("Writing out new preload omissions file!~n", []),
                          {ok, PreloadOmissionIo} = file:open(PreloadOmissionFile, [write, {encoding, utf8}]),
                          [io:format(PreloadOmissionIo, "~p.~n", [O]) || O <- [Omissions]],
                          ok = file:close(PreloadOmissionIo),
  
                          %% Write out replay trace.
                          io:format("Writing out new replay trace file!~n", []),
                          {ok, TraceIo} = file:open(ReplayTraceFile, [write, {encoding, utf8}]),
                          [io:format(TraceIo, "~p.~n", [TraceLine]) || TraceLine <- [FinalTraceLines]],
                          ok = file:close(TraceIo),
  
                          %% Run the trace.
                          Command = "rm -rf priv/lager; SHRINKING=true REPLAY=true PRELOAD_OMISSIONS_FILE=" ++ PreloadOmissionFile ++ " REPLAY_TRACE_FILE=" ++ ReplayTraceFile ++ " TRACE_FILE=" ++ TraceFile ++ " ./rebar3 proper --retry | tee /tmp/partisan.output",
                          io:format("Executing command for iteration ~p of ~p:", [Iteration, length(TracesToIterate)]),
                          io:format(" ~p~n", [Command]),
                          Output = os:cmd(Command),
  
                          %% Store set of omissions as omissions that didn't invalidate the execution.
                          case string:find(Output, "{postcondition,false}") of 
                              nomatch ->
                                  %% This passed.
                                  io:format("Test passed.~n", []),
  
                                  %% Insert result into the ETS table.
                                  true = ets:insert(?RESULTS, {Iteration, {Iteration, FinalTraceLines, Omissions, true}}),
  
                                  {NumPassed + 1, NumFailed, NumPruned, ClassificationsExplored0 ++ [Classification]};
                              _ ->
                                  %% This failed.
                                  io:format("Test FAILED!~n", []),
                                  io:format("Failing test contained the following omitted mesage types: ~p~n", [Omissions]),
  
                                  case os:getenv("EXIT_ON_COUNTEREXAMPLE") of 
                                      false ->
                                          ok;
                                      "false" ->
                                          ok;
                                      _Other ->
                                          exit({error, counterexample_found})
                                  end,
  
                                  %% Insert result into the ETS table.
                                  true = ets:insert(?RESULTS, {Iteration, {Iteration, FinalTraceLines, Omissions, false}}),
  
                                  {NumPassed, NumFailed + 1, NumPruned, ClassificationsExplored0 ++ [Classification]}
                          end
                  end
          end
      end, {0, 0, 0, []}, ?SCHEDULES),
  
      io:format("Passed: ~p, Failed: ~p, Pruned: ~p~n", [NumberPassed, NumberFailed, NumberPruned]),
  
      %% Should we try to find witnesses?
      case os:getenv("FIND_WITNESSES") of 
  