anchor.diff:             {error, {already_started, pid()}} |
              {error, Reason :: term()}.
   start_link(Name, Mod, Args, Options) ->
  -    {TickedGServerOptions, GenServerOptions} = split_start_options(Options),
  -    gen_server:start_link(Name, ?MODULE, {Mod, Args, TickedGServerOptions}, GenServerOptions).
  +    {TickOptions, GenServerOptions} = split_start_options(Options),
  +    gen_server:start_link(Name, ?MODULE, {Mod, Args, TickOptions}, GenServerOptions).
   
   %% ------------------------------------------------------------------
   %% gen_server Function Definitions
   %% ------------------------------------------------------------------
   
  --spec init({Mod :: module(), Args :: term(), TickedGServerOptions :: [{ticks, tick_start_option()}]})
  +-spec init({Mod :: module(), Args :: term(), TickOptions :: [{ticks, tick_start_option()}]})
           -> {ok, State :: term(), Timeout :: non_neg_integer()} |
              {stop, Reason :: term()} | ignore.
  -init({Mod, Args, TickedGServerOptions}) ->
  -    RawTickOptions = proplists:get_value(ticks, TickedGServerOptions, []),
  -    TickOptions = lists:map(
  -                    fun ({TickId, TickDurationMS}) ->
  -                        {TickId, TickDurationMS, []};
  -                        ({TickId, TickDurationMS, TickSettings}) ->
  -                        {TickId, TickDurationMS, TickSettings}
  -                    end,
  -                    RawTickOptions),
  +init({Mod, Args, TickOptions}) ->
  +    NowNS = now_timestamp_ns(),
  +    TickSettings = proplists:get_value(ticks, TickOptions, []),
       Ticks = lists:map(
  -              fun ({TickId, TickDurationMS, TickSettings}) ->
  -                  DontSkipMissed = (lists:member(dont_skip_missed, TickSettings) orelse
  -                                    not lists:member(skip_missed, TickSettings)),
  -                  #tick{id = TickId,
  -                        duration_ns = TickDurationMS * 1000000,
  -                        deadline_ns = now_timestamp_ns(),
  -                        generation = 0,
  -                        skip_missed = not DontSkipMissed}
  +              fun ({TickId, TickDurationMS}) ->
  +                      #tick{id = TickId,
  +                            duration_ns = TickDurationMS * 1000000,
  +                            deadline_ns = NowNS,
  +                            generation = 0}
                 end,
  -              TickOptions),
  +              TickSettings),
       undefined = put(?PROCDIC_MODULE, Mod),
       undefined = put(?PROCDIC_TICKS, Ticks),
       inject_init_timeout(Mod:init(Args)).
  
positive.code:   when DeadlineNS =< NowNS ->
      #tick{id = Id,
            duration_ns = DurationNS,
            generation = Generation,
            skip_missed = SkipMissed} = Tick,
      GenerationsSkip = case SkipMissed of
                          false -> 0;
                          true  -> trunc((NowNS - DeadlineNS) / DurationNS)
                        end,
      {noreply, NewState} = Mod:handle_tick(Id, Generation + GenerationsSkip, State),
      NewTick = Tick#tick{deadline_ns = DeadlineNS + ((1 + GenerationsSkip) * DurationNS),
                          generation = Generation + GenerationsSkip + 1},
      handle_tick_deadlines(NewState, UntriggeredTicks, NowNS, Mod, [NewTick | TriggeredTicks]);
  handle_tick_deadlines(State, UntriggeredTicks, _NowNS, _Mod, TriggeredTicks) ->
      {State, TriggeredTicks ++ UntriggeredTicks}.
  
negative.code:           id :: term(),
            duration_ns :: pos_integer(),
            deadline_ns :: timestamp(),
            generation :: non_neg_integer()
  }).
  -type tick() :: #tick{}.
  
  