anchor.diff:              [
                   {beam, B},
                   {src, S},
  -                {time, [{src, Now - ST}, {beam, Now - BT}]},
  +                {time, [{src, if is_integer(ST) -> Now - ST; true -> ST end}, {beam, if is_integer(BT) -> Now - BT; true -> BT end}]},
                   {last, Now - L}
               ]
       end.
  
positive.code:     {noreply, hotload_mod(Module, State)};
  handle_cast(reload_all, State) ->
      {noreply, hotload(State#hotbeam_state.apps, State)};
  handle_cast({lazyload, Mod}, State) ->
      {noreply, case lists:keysearch(Mod, #hotbeam.mod, State#hotbeam_state.beams) of
          {value, #hotbeam{} = HB} -> 
              ?info("manually recompiling ~p", [Mod]),
              p_lazy_load(HB, State);
          false -> State
      end};
  handle_cast(rehash, State) ->
      {noreply, p_rehash(State)};
  
negative.code:     	    State
      end.
  
  reload_mod(Mod, #hotbeam_state{beams = Beams} = State) when is_atom(Mod) -> 
      HF = fun(M, B) -> case lists:keyfind(M, #hotbeam.mod, B) of false -> undefined; #hotbeam{} = HB -> HB end end,
      case {loaded, HF(Mod, Beams)} of
          {loaded, undefined} ->
              S0 = #hotbeam_state{beams = NewBeams} = p_rescan_fun(Mod, State),
              case {new, HF(Mod, NewBeams)} of
                  {new, undefined} -> 
                      ?info("unable to add ~p", [Mod]),
                      State;
                  {new, #hotbeam{} = HB} -> 
                      reload_mod(HB, S0)
              end;
          {loaded, #hotbeam{} = HB} -> 
              reload_mod(HB, State)
      end;
  reload_mod(#hotbeam{mod = Mod} = HB, #hotbeam_state{hotload_count = HC, beams = Beams} = State) when is_atom(Mod)->
      case {sticky, code:is_sticky(Mod)} of
          {sticky, true} -> State;
  