anchor.diff:              case Precondition of 
                   {PreconditionType, N} ->
                       Num = length(lists:filter(fun(T) -> T =:= PreconditionType end, DerivedSchedule)),
  -                    debug("=> * found ~p messages of type ~p~n", [Num, PreconditionType]),
  +                    % debug("=> * found ~p messages of type ~p~n", [Num, PreconditionType]),
                       Acc andalso Num >= N;
                   true ->
  -                    debug("=> * found true precondition", []),
  +                    % debug("=> * found true precondition", []),
                       Acc andalso true
               end
           end, true, Preconditions),
   
  -        debug("=> type: ~p, preconditions: ~p~n", [Type, Result]),
  +        % debug("=> type: ~p, preconditions: ~p~n", [Type, Result]),
           dict:store(Type, Result, Dict0)
       end, dict:new(), dict:to_list(CausalityAnnotations)),
   
  -    debug("classification: ~p~n", [dict:to_list(Classification)]),
  +    % debug("classification: ~p~n", [dict:to_list(Classification)]),
   
       Classification.
   
  
positive.code: %% @private
  schedule_valid_causality(Causality, PrefixSchedule, _OmittedSchedule, ConditionalSchedule) ->
      DerivedSchedule = PrefixSchedule ++ ConditionalSchedule,
      % debug("derived_schedule: ~p~n", [length(DerivedSchedule)]),
      % debug("prefix_schedule: ~p~n", [length(PrefixSchedule)]),
      % debug("omitted_schedule: ~p~n", [length(OmittedSchedule)]),
      % debug("conditional_schedule: ~p~n", [length(ConditionalSchedule)]),
  
      RequirementsMet = lists:foldl(fun(Type, Acc) ->
          % debug("=> Type: ~p~n", [Type]),
  
          All = lists:foldl(fun({K, V}, Acc1) ->
              % debug("=> V: ~p~n", [V]),
  
              case lists:member(Type, V) of 
                  true ->
                      % debug("=> Presence of ~p requires: ~p~n", [Type, K]),
  
                      case lists:member(K, DerivedSchedule) of 
                          true ->
                              % debug("=> Present!~n", []),
                              true andalso Acc1;
                          false ->
                              % debug("=> NOT Present!~n", []),
                              false andalso Acc1
                      end;
                  false ->
                      % debug("=> * fallthrough: ~p not in ~p.~n", [Type, V]),
                      true andalso Acc1
              end
          end, Acc, dict:to_list(Causality)),
  
          All andalso Acc
      end, true, DerivedSchedule),
  
      case RequirementsMet of 
          true ->
              % debug("Causality verified.~n", []),
              ok;
          false ->
              % debug("Schedule does not represent a valid schedule!~n", []),
              ok
      end,
  
  
negative.code: 
  %% @private
  classify_schedule(_N, CausalityAnnotations, PrefixSchedule, _OmittedSchedule, ConditionalSchedule) ->
      % debug("classifying schedule using causality annotations: ~p", [dict:to_list(CausalityAnnotations)]),
  
      DerivedSchedule = PrefixSchedule ++ ConditionalSchedule,
  
  