anchor.diff:                              case os:getenv("EXIT_ON_COUNTEREXAMPLE") of 
                                   false ->
                                       ok;
  -                                "false" ->
  -                                    ok;
  +                                "true" ->
  +                                    exit({error, counterexample_found});
                                   _Other ->
  -                                    exit({error, counterexample_found})
  +                                    ok
                               end,
   
                               %% Insert result into the ETS table.
  
positive.code:                     io:format("=> Executed test and test contained ~p lines compared to original trace with ~p lines.~n", [length(hd(NewTraceLines)), length(TraceLines)]),
  
                      MessageTypesFromTraceLines = message_types(TraceLines),
                      io:format("=> MessageTypesFromTraceLines: ~p~n", [MessageTypesFromTraceLines]),
                      MessageTypesFromNewTraceLines = message_types(hd(NewTraceLines)),
                      io:format("=> MessageTypesFromNewTraceLines: ~p~n", [MessageTypesFromNewTraceLines]),
  
                      Difference = lists:usort(MessageTypesFromNewTraceLines) -- lists:usort(MessageTypesFromTraceLines),
                      io:format("=> Difference: ~p~n", [Difference]),
  
negative.code:     Classification.
  
  %% @private
  classify_schedule(_N, Annotations, CandidateTrace0) ->
      CandidateTrace = message_types(CandidateTrace0),
  
      Classification = lists:foldl(fun({Type, Preconditions}, Dict0) ->
          Result = lists:foldl(fun(Precondition, Acc) ->
              case Precondition of 
                  {{_, PreconditionType}, N} ->
                      Num = length(lists:filter(fun(T) -> T =:= {forward_message, PreconditionType} end, CandidateTrace)),
                      % io:format("=> * found ~p messages of type ~p~n", [Num, PreconditionType]),
                      Acc andalso Num >= N;
                  true ->
                      Acc andalso true
              end
          end, true, Preconditions),
  
          % io:format("=> type: ~p, preconditions: ~p~n", [Type, Result]),
          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) ->
  