anchor.diff:  #!/usr/bin/env escript
  +%%! -pa ./_build/default/lib/jsx/ebin -Wall
   
   %% TODO: Store results in ETS table.
   %% TODO: Sort omissions ascending by size.
  
positive.code:     % % %% Print out final schedule.
      % % %% lists:foreach(fun(Command) -> io:format("~p~n", [Command]) end, AlteredCommands),
  
      % ok.
negative.code:                 io:format("Generating new trace based on message omissions (~p omissions): ~n", 
                          [length(Omissions)]),
  
                  {FinalTraceLines, _, _} = lists:foldl(fun({Type, Message} = Line, {FinalTrace0, FaultsStarted0, AdditionalOmissions0}) ->
                      case Type =:= pre_interposition_fun of 
                          true ->
                              {TracingNode, InterpositionType, OriginNode, MessagePayload} = Message,
  
                              case FaultsStarted0 of 
                                  true ->
                                      %% Once we start omitting, omit everything after that's a message
                                      %% send because we don't know what might be coming. %% In 2PC, if we
                                      %% have a successful trace and omit a prepare -- we can't be guaranteed
                                      %% to ever see a prepare vote or commmit.
                                      {FinalTrace0, FaultsStarted0, AdditionalOmissions0};
                                  false ->
                                      %% Otherwise, find just the targeted commands to remove.
                                      case InterpositionType of 
                                          forward_message ->
                                              case lists:member(Line, Omissions) of 
                                                  true ->
                                                      io:format("-> Omitting trace message (forward_message): ~p~n", 
                                                              [Line]),
                                                      % %% TODO: HACK: HARDCODED.
                                                      ReceiveOmission = {Type, {OriginNode, receive_message, TracingNode, {forward_message, lampson_2pc, MessagePayload}}},
                                                      io:format("-> Adding to additional omissions corresponding (receive_message): ~p~n", 
                                                              [ReceiveOmission]),
                                                      {FinalTrace0, true, AdditionalOmissions0 ++ [ReceiveOmission]};
                                                  false ->
                                                      {FinalTrace0 ++ [Line], FaultsStarted0, AdditionalOmissions0}
                                              end;
                                          receive_message -> 
                                              case lists:member(Line, AdditionalOmissions0) of 
                                                  true ->
                                                      io:format("-> Omitting corresponding message (receive_message): ~p~n", [Line]),
                                                      {FinalTrace0, FaultsStarted0, AdditionalOmissions0 -- [Line]};
                                                  false ->
                                                      {FinalTrace0 ++ [Line], FaultsStarted0, AdditionalOmissions0}
                                              end
                                      end
                              end;
                          false ->
                              {FinalTrace0 ++ [Line], FaultsStarted0, AdditionalOmissions0}
                      end
                  end, {[], false, []}, TraceLinesWithoutFailure),
  
                  % io:format("New trace: ~n", []),
                  % [io:format("-> ~p.~n", [TraceLine]) || TraceLine <- [FinalTraceLines]],
  