anchor.diff:                              "    Handler: ~p:~p/2~n"
                               "    Message: ~.0p~n",
                               [self(), catch pid_groups:group_and_name_of(self()),
  -                             gc_mod(State), gc_hand(State), Msg]),
  +                             gc_mod(GCState), gc_hand(GCState), Msg]),
               self() ! {'$gen_component', bp, breakpoint, step,
  -                      gc_bpstepper(State)},
  +                      gc_bpstepper(GCState)},
               ok;
           false -> ok
       end,
       case erlang:get(trace_mpath) of
  -        undefined ->
  -            ok;
  -        Logger ->
  -            trace_mpath:log_info(Logger, self(), Msg)
  -    end,
  -    on(Msg, State).
  -
  --spec on_gc_msg(gc_msg(), gc_state()) -> gc_state() | ok.
  -on_gc_msg({'$gen_component', trace_mpath, PState, From, To, Msg}, State) ->
  +        undefined -> on(Msg, UState, GCState);
  +        Logger    -> trace_mpath:log_info(Logger, self(), Msg),
  +                     on_traced_msg(Msg, UState, GCState)
  +    end.
  +
  +-spec on_gc_msg(gc_msg(), user_state(), gc_state()) -> ok.
  +on_gc_msg({'$gen_component', trace_mpath, PState, From, To, Msg}, UState, GCState) ->
       trace_mpath:log_recv(PState, From, To, Msg),
  +    erlang:put('$gen_component_trace_mpath_msg_tag', element(1, Msg)),
       trace_mpath:start(PState),
  -    NewState = on(Msg, State),
  -    trace_mpath:stop(),
  -    trace_mpath:log_info(PState, To, {gc_on_done, element(1, Msg)}),
  -    NewState;
  -on_gc_msg({'$gen_component', kill}, State) ->
  +    on_traced_msg(Msg, UState, GCState);
  +on_gc_msg({'$gen_component', kill}, _UState, GCState) ->
       log:log(info, "[ gen_component ] ~.0p killed (~.0p:~.0p/2):",
  -            [self(), gc_mod(State), gc_hand(State)]),
  +            [self(), gc_mod(GCState), gc_hand(GCState)]),
       ok;
  -on_gc_msg({'$gen_component', bp, msg_in_bp_waiting, Pid}, State) ->
  +on_gc_msg({'$gen_component', bp, msg_in_bp_waiting, Pid}, UState, GCState) ->
       Pid ! {'$gen_component', bp, msg_in_bp_waiting_response, false},
  -    State;
  -on_gc_msg({'$gen_component', sleep, Time}, State) ->
  +    loop(UState, GCState);
  +on_gc_msg({'$gen_component', sleep, Time}, UState, GCState) ->
       timer:sleep(Time),
  -    State;
  -on_gc_msg({'$gen_component', get_state, Pid}, State) ->
  +    loop(UState, GCState);
  +on_gc_msg({'$gen_component', get_state, Pid}, UState, GCState) ->
       comm:send_local(
  -      Pid, {'$gen_component', get_state_response, gc_ustate(State)}),
  -    State;
  -on_gc_msg({'$gen_component', get_component_state, Pid}, State) ->
  +      Pid, {'$gen_component', get_state_response, UState}),
  +    loop(UState, GCState);
  +on_gc_msg({'$gen_component', get_component_state, Pid}, UState, GCState) ->
       comm:send_local(
         Pid, {'$gen_component', get_component_state_response,
  -            {gc_mod(State), gc_hand(State), State}}),
  -    State;
  -on_gc_msg({'$gen_component', bp, bp_set_cond, Cond, BPName} = Msg, State) ->
  -    case gc_bpqueue(State) of
  -        [] -> gc_bp_set_cond(State, Cond, BPName);
  -        _ -> gc_bp_hold_back(State, Msg)
  -    end;
  -on_gc_msg({'$gen_component', bp, bp_set, MsgTag, BPName} = Msg, State) ->
  -    case gc_bpqueue(State) of
  -        [] -> gc_bp_set(State, MsgTag, BPName);
  -        _ -> gc_bp_hold_back(State, Msg)
  -    end;
  -on_gc_msg({'$gen_component', bp, bp_del, BPName} = Msg, State) ->
  -    case gc_bpqueue(State) of
  -        [] -> gc_bp_del(State, BPName);
  -        _ -> gc_bp_hold_back(State, Msg)
  -    end;
  -on_gc_msg({'$gen_component', bp, barrier} = Msg, State) ->
  -    gc_bp_hold_back(State, Msg);
  -on_gc_msg({'$gen_component', bp, breakpoint, step, _Stepper} = Msg, State) ->
  -    gc_bp_hold_back(State, Msg);
  -on_gc_msg({'$gen_component', bp, breakpoint, cont} = Msg, State) ->
  -    gc_bp_hold_back(State, Msg).
  -
  -
  --spec on_bp(comm:message(), gc_state()) -> gc_state().
  -on_bp(_Msg, State)
  -  when (false =:= element(?BP_ACTIVE, State))
  -       andalso ([] =:= element(?BPS, State)) ->
  -    State;
  -on_bp(Msg, State) ->
  -    BPActive = bp_active(Msg, State),
  -    wait_for_bp_leave(Msg, State, BPActive).
  -
  --spec bp_active(comm:message(), gc_state()) -> boolean().
  -bp_active(_Msg, State)
  -  when (false =:= element(?BP_ACTIVE, State))
  -       andalso ([] =:= element(?BPS, State))->
  +            {gc_mod(GCState), gc_hand(GCState), GCState}}),
  +    loop(UState, GCState);
  +on_gc_msg({'$gen_component', bp, bp_set_cond, Cond, BPName} = Msg, UState, GCState) ->
  +    NewGCState =
  +        case gc_bpqueue(GCState) of
  +            [] -> gc_bp_set_cond(GCState, Cond, BPName);
  +            _ -> gc_bp_hold_back(GCState, Msg)
  +        end,
  +    loop(UState, NewGCState);
  +on_gc_msg({'$gen_component', bp, bp_set, MsgTag, BPName} = Msg, UState, GCState) ->
  +    NewGCState =
  +        case gc_bpqueue(GCState) of
  +            [] -> gc_bp_set(GCState, MsgTag, BPName);
  +            _ -> gc_bp_hold_back(GCState, Msg)
  +        end,
  +    loop(UState, NewGCState);
  +on_gc_msg({'$gen_component', bp, bp_del, BPName} = Msg, UState, GCState) ->
  +    NewGCState =
  +        case gc_bpqueue(GCState) of
  +            [] -> gc_bp_del(GCState, BPName);
  +            _ -> gc_bp_hold_back(GCState, Msg)
  +        end,
  +    loop(UState, NewGCState);
  +on_gc_msg({'$gen_component', bp, barrier} = Msg, UState, GCState) ->
  +    NewGCState = gc_bp_hold_back(GCState, Msg),
  +    loop(UState, NewGCState);
  +on_gc_msg({'$gen_component', bp, breakpoint, step, _Stepper} = Msg,
  +          UState, GCState) ->
  +    NewGCState = gc_bp_hold_back(GCState, Msg),
  +    loop(UState, NewGCState);
  +on_gc_msg({'$gen_component', bp, breakpoint, cont} = Msg,
  +          UState, GCState) ->
  +    NewGCState = gc_bp_hold_back(GCState, Msg),
  +    loop(UState, NewGCState).
  +
  +
  +-spec on_bp(comm:message(), user_state(), gc_state()) -> gc_state().
  +on_bp(_Msg, _UState, GCState)
  +  when (false =:= element(?BP_ACTIVE, GCState))
  +       andalso ([] =:= element(?BPS, GCState)) ->
  +   GCState;
  +on_bp(Msg, UState, GCState) ->
  +    BPActive = bp_active(Msg, UState, GCState),
  +    wait_for_bp_leave(Msg, GCState, BPActive).
  +
  +-spec bp_active(comm:message(), user_state(), gc_state()) -> boolean().
  +bp_active(_Msg, _UState, GCState)
  +  when (false =:= element(?BP_ACTIVE, GCState))
  +       andalso ([] =:= element(?BPS, GCState))->
       false;
  -bp_active(Msg, State) ->
  -    gc_bpactive(State)
  +bp_active(Msg, UState, GCState) ->
  +    gc_bpactive(GCState)
           orelse
           begin
  -            [ ThisBP | RemainingBPs ] = gc_bps(State),
  +            [ ThisBP | RemainingBPs ] = gc_bps(GCState),
               Decision = case ThisBP of
                              {bp, ThisTag, _BPName} ->
                                  ThisTag =:= comm:get_msg_tag(Msg);
                              {bp_cond, Cond, _BPName} when is_function(Cond) ->
  -                               Cond(Msg, gc_ustate(State));
  +                               Cond(Msg, UState);
                              {bp_cond, {Module, Fun, Params}, _BPName} ->
  -                               apply(Module, Fun, [Msg, gc_ustate(State), Params])
  +                               apply(Module, Fun, [Msg, UState, Params])
                          end,
               case Decision of
                   true ->
  
positive.code:         failed -> ok;
          _      -> comm:send_local(Pid, Msg)
      end,
      State;
  on(Msg, State) ->
      T1State = on_bp(Msg, State),
      Module  = gc_mod(T1State),
      Handler = gc_hand(T1State),
      UState = gc_ustate(T1State),
      T2State =
          try Handler(Msg, UState)
          catch Level:Reason ->
  
negative.code: 
  %% @doc release the bp_step function when we executed a bp_step
  -spec bp_step_done(comm:message(), gc_state()) -> gc_state().
  bp_step_done(_, State)
    when not element(?BP_ACTIVE, State)
         orelse not element(?BP_STEPPED, State) ->
      State;
  bp_step_done(Msg, State) ->
      ?TRACE_BP_STEPS("step done ~.0p~n", [Msg]),
      comm:send_local(gc_bpstepper(State),
                      {'$gen_component', bp, breakpoint, step_done,
                       self(), gc_mod(State), gc_hand(State), Msg}),
      T1State = gc_set_bpstepper(State, unknown),
      gc_set_bpstepped(T1State, false).
  
  
  -spec gc_new(module(), handler()) -> gc_state().
  gc_new(Module, Handler) ->
      {Module, Handler,
  %     Options, _Slowest = 0.0,
       _BPs = [], _BPActive = false,
       _BPHoldbackQueue = [], _BPStepped = false,
       _BPStepperPid = unknown
  