anchor.diff:  max_cv(CV1, CV2) ->
       Merger = fun(_Key, V1, V2) -> max(V1, V2) end,
       dict:merge(Merger, CV1, CV2).
  +
  +add_all_child_backtracks({spawn, unknown}, State) ->
  +    #dpor_state{trace = [TraceTop|_]} = State,
  +    #trace_state{last = {_, {spawn, ChildLid}}, enabled = Enabled,
  +                 nexts = Nexts} = TraceTop,
  +    case ordsets:is_element(ChildLid, Enabled) of
  +        true ->
  +            ChildNext = dict:fetch(ChildLid, Nexts),
  +            add_all_backtracks({ChildLid, ChildNext}, State);
  +        false ->
  +            State
  +    end;
  +add_all_child_backtracks(_Else, State) ->
  +    State.    
   
   %% STUB
   add_some_next_to_backtrack(State) ->
  
positive.code:     {{value, Transition}, TmpLidTrace} = queue:out_r(LidTrace),
      NewLast = {Lid, {Spawn, ChildLid}},
      NewLidTrace = queue:in(NewLast, TmpLidTrace),
      ?f_debug("Child adding more backtracks...\n"),
      NewTrace = add_all_backtracks_trace(ChildTr, Trace),
      case NewTrace =/= Trace of
          true ->
              ?f_debug("CHANGED!\n");
          false ->
              ?f_debug("NOT CHANGED!\n")
      end,
      {TraceTop#trace_state{last = NewLast,
                            enabled = NewEnabled,
                            blocked = NewBlocked,
                            nexts = NewNexts,
                            lid_trace = NewLidTrace},
       NewTrace};
  handle_instruction_al({Lid, {'receive', [_HasMatching, _HasAfter]}} = Transition,
                        _ClockVector, TraceTop, ReceiveDetails, Trace) ->
      #trace_state{lid_trace = LidTrace} = TraceTop,
      {{value, Transition}, TmpLidTrace} = queue:out_r(LidTrace),
      NewLast =
  
negative.code:     end.
  
  %% STUB
  handle_instruction_al({Lid, {exit, normal}}, _ClockVector, TraceTop, {}) ->
      ?f_debug("Exit\n"),
      #trace_state{enabled = Enabled, nexts = Nexts} = TraceTop,
      NewEnabled = ordsets:del_element(Lid, Enabled),
      NewNexts = dict:erase(Lid, Nexts),
      TraceTop#trace_state{enabled = NewEnabled, nexts = NewNexts};
  handle_instruction_al({Lid, {Spawn, unknown}} = Transition, ClockVector,
                        TraceTop, {ChildLid, ChildNextInstr})
    when Spawn =:= spawn; Spawn =:= spawn_link ->
      #trace_state{enabled = Enabled, blocked = Blocked, nexts = Nexts,
                   lid_trace = LidTrace} = TraceTop,
  