anchor.diff:      {ok, [{TestModule, TestFunction, [TestCommands]}]} = file:consult(CounterexampleConsultFile),
   
       io:format("Loading commands...~n", []),
  -    [io:format("~p.~n", [TestCommand]) || TestCommand <- TestCommands],
  +    [io:format(" ~p.~n", [TestCommand]) || TestCommand <- TestCommands],
   
       %% Drop last command -- forced failure.
       TestFinalCommands = lists:reverse(tl(lists:reverse(TestCommands))),
   
       io:format("Rewritten commands...~n", []),
  -    [io:format("~p.~n", [TestFinalCommand]) || TestFinalCommand <- TestFinalCommands],
  +    [io:format(" ~p.~n", [TestFinalCommand]) || TestFinalCommand <- TestFinalCommands],
   
       %% Write the schedule out.
       {ok, CounterexampleIo} = file:open(RebarCounterexampleConsultFile, [write, {encoding, utf8}]),
  
positive.code:     end, TraceLinesWithoutFailure),
      io:format("Number of items in message trace: ~p~n", [length(MessageTraceLines)]),
  
      [io:format("** ~p.~n", [T]) || T <- MessageTraceLines],
  
  
      %% Generate the powerset of tracelines.
      MessageTraceLinesPowerset = powerset(MessageTraceLines),
      io:format("Number of message sets in powerset: ~p~n", [length(MessageTraceLinesPowerset)]),
  
      %% For each powerset, generate a trace that only allows those messages.
      Traces = lists:map(fun(Set) ->
          %% TODO: Allow non-pre-interposition through.
          ConcreteTrace = lists:flatmap(fun({T, M} = Full) -> 
              case T of 
                  pre_interposition_fun ->
                      {_TracingNode, InterpositionType, _OriginNode, _MessagePayload} = M,
                      
                      case InterpositionType of
                          forward_message ->
                              case lists:member(Full, Set) of 
                                  %% If powerset contains message, allow.
                                  %% This means that the message should be allowed during this execution.
                                  true ->
                                      [{T, M}];
                                  %% If powerset doesn't contain the message, remap message to an omission.
                                  %% This is the omission we want to test.
                                  false ->
                                      [{{omit, T}, M}]
                              end;
                          _ ->
                              %% Pass anything but a forward_message through.
                              %% We only test partitions on the sender side.
                              [{T, M}]
                      end;
                  _ ->
                      %% Pass non-pre-interposition-funs through.
                      %% Other commands are not subject to fault-injection.
                      [{T, M}]
              end
          end, TraceLinesWithoutFailure),
  
          %% Return concrete trace.
          ConcreteTrace
      end, MessageTraceLinesPowerset),
  
      io:format("Number of traces materialized: ~p~n", [length(Traces)]),
  
      %% For each trace, write out the trace file.
      lists:foreach(fun(Trace) ->
          %% Write out a new replay trace from the last used trace.
          {ok, TraceIo} = file:open(ReplayTraceFile, [write, {encoding, utf8}]),
  
          %% Write new trace out.
          [io:format(TraceIo, "~p.~n", [TraceLine]) || TraceLine <- [Trace]],
  
          %% Close file.
          ok = file:close(TraceIo),
  
          %% Run the trace.
          Command = "REPLAY=true REPLAY_TRACE_FILE=" ++ ReplayTraceFile ++ " TRACE_FILE=" ++ TraceFile ++ " ./rebar3 proper --retry",
          io:format("Command to execute: ~p~n", [Command])
  
      end, [hd(lists:reverse(Traces))]), %% TODO: FIX ME
  
      ok.
  
  
negative.code: #!/usr/bin/env escript
  
  main([TraceFile, ReplayTraceFile, CounterexampleConsultFile, RebarCounterexampleConsultFile, PreloadOmissionFile]) ->
      %% Open the trace file.
      {ok, TraceLines} = file:consult(TraceFile),
  
  