anchor.diff:              ComponentState
       end.
   
  +-spec gc_state_bp_set_cond(component_state(),fun(),atom())
  +                          -> component_state().
   gc_state_bp_set_cond({Options, Slowest, BPState}, Cond, BPName) ->
       ?TRACE_BP("Set bp ~p with name ~p~n", [Cond, BPName]),
       {Options, Slowest, bp_state_bp_set_cond(BPState, Cond, BPName)}.
   
  +-spec gc_state_bp_set(component_state(),comm:message_tag(),atom())
  +                     -> component_state().
   gc_state_bp_set({Options, Slowest, BPState}, MsgTag, BPName) ->
       ?TRACE_BP("Set bp ~p with name ~p~n", [MsgTag, BPName]),
       {Options, Slowest, bp_state_bp_set(BPState, MsgTag, BPName)}.
   
  +-spec gc_state_bp_del(component_state(), atom())
  +                     -> component_state().
   gc_state_bp_del({Options, Slowest, BPState}, BPName) ->
       ?TRACE_BP("Del bp ~p~n", [BPName]),
       {Options, Slowest, bp_state_bp_del(BPState, BPName)}.
   
  +-spec gc_state_bp_hold_back(component_state(), bp_message())
  +                           -> component_state().
   gc_state_bp_hold_back({Options, Slowest, BPState}, Message) ->
       ?TRACE_BP("Enqueued bp op ~p -> ~p~n", [Message,
       {Options, Slowest, bp_state_hold_back(BPState, Message)}]),
       {Options, Slowest, bp_state_hold_back(BPState, Message)}.
   %    NewQueue = lists:append(Queue, [Message]),
   
  +-spec handle_breakpoint(comm:message(), any(), component_state())
  +                           -> component_state().
   handle_breakpoint(Message, State, ComponentState) ->
       BPActive = bp_active(Message, State, ComponentState),
       wait_for_bp_leave(Message, State, ComponentState, BPActive).
   
  +-spec bp_active(comm:message(), any(), component_state()) -> boolean().
   bp_active(_Message, _State,
             {_Options, _Slowest,
              {[] = _BPs, false = _BPActive, _HB_BP_Ops, false = _BPStepped, unknown}}
  
positive.code:     Pid ! {'$gen_component', bp, bp_set_cond, Cond, BPName},
      ok.
  
  -spec bp_del(Pid::comm:erl_local_pid(), BPName::any()) -> ok.
  bp_del(Pid, BPName) ->
      Pid ! {'$gen_component', bp, bp_del, BPName},
      ok.
  
  -spec bp_step(Pid::comm:erl_local_pid()) -> {module(), On::atom(), comm:message()}.
  bp_step(Pid) ->
      Pid !  {'$gen_component', bp, breakpoint, step, self()},
      receive {'$gen_component', bp, breakpoint, step_done,
  
negative.code:               try_loop(Module, On, State, ComponentState)
      end.
  
  -spec loop(module(), atom(), term(), component_state()) -> ok.
  loop(Module, On, State, {_Options, _Slowest, _BPState} = ComponentState) ->
      ?CALLING_RECEIVE(Module),
      receive Msg -> loop(Module, On, Msg, State, ComponentState)
      end.
  
  -spec loop(module(), atom(), comm:message(), term(), component_state()) -> ok.
  loop(Module, On, ReceivedMsg, State, {_Options, _Slowest, _BPState} = ComponentState) ->
      case ReceivedMsg of
          %%%%%%%%%%%%%%%%%%%%
  