anchor.diff:  	next.prev = src
   	prev.next = src
   
  -///Returns a string of the type of the callback for this timer
  +/**
  +  * Returns a string of the type of the callback for this timer
  +  */
   /datum/timedevent/proc/getcallingtype()
   	. = "ERROR"
   	if (callBack.object == GLOBAL_PROC)
  
positive.code: 		else
  			qdel(ctime_timer)
  
  
  	if (next_clienttime_timer_index)
  		clienttime_timers.Cut(1, next_clienttime_timer_index+1)
  
  	if (MC_TICK_CHECK)
  		return
  
  	var/static/list/spent = list()
  	var/static/datum/timedevent/timer
  	if (practical_offset > BUCKET_LEN)
  		head_offset += TICKS2DS(BUCKET_LEN)
  		practical_offset = 1
  		resumed = FALSE
  
  	if ((length(bucket_list) != BUCKET_LEN) || (world.tick_lag != bucket_resolution))
  		reset_buckets()
  		bucket_list = src.bucket_list
  		resumed = FALSE
  
  
  	if (!resumed)
  		timer = null
  
  	while (practical_offset <= BUCKET_LEN && head_offset + ((practical_offset-1)*world.tick_lag) <= world.time)
  		var/datum/timedevent/head = bucket_list[practical_offset]
  		if (!timer || !head || timer == head)
  			head = bucket_list[practical_offset]
  			timer = head
  		while (timer)
  			var/datum/callback/callBack = timer.callBack
  			if (!callBack)
  				bucket_resolution = null //force bucket recreation
  				CRASH("Invalid timer: [get_timer_debug_string(timer)] world.time: [world.time], head_offset: [head_offset], practical_offset: [practical_offset]")
  
  			if (!timer.spent)
  				spent += timer
  				timer.spent = world.time
  				callBack.InvokeAsync()
  				last_invoke_tick = world.time
  
negative.code: /// Controls how many buckets should be kept, each representing a tick. (1 minutes worth)
  #define BUCKET_LEN (world.fps*1*60)
  /// Helper for getting the correct bucket for a given timer
  #define BUCKET_POS(timer) (((round((timer.timeToRun - SStimer.head_offset) / world.tick_lag)+1) % BUCKET_LEN)||BUCKET_LEN)
  /// Gets the maximum time at which timers will be invoked from buckets, used for deferring to secondary queue
  #define TIMER_MAX (world.time + TICKS2DS(min(BUCKET_LEN-(SStimer.practical_offset-DS2TICKS(world.time - SStimer.head_offset))-1, BUCKET_LEN-1)))
  /// Max float with integer precision
  #define TIMER_ID_MAX (2**24)
  
  /**
    * # Timer Subsystem
    *
    * Handles creation, callbacks, and destruction of timed events.
    *
    * It is important to understand the buckets used in the timer subsystem are just a series of circular doubly-linked
    * lists. The object at a given index in bucket_list is a /datum/timedevent, the head of a circular list, which has prev
    * and next references for the respective elements in that bucket's circular list.
    */
  SUBSYSTEM_DEF(timer)
  	name = "Timer"
  	wait = 1 // SS_TICKER subsystem, so wait is in ticks
  	init_order = INIT_ORDER_TIMER
  	priority = FIRE_PRIORITY_TIMER
  	flags = SS_TICKER|SS_NO_INIT
  
  	/// Queue used for storing timers that do not fit into the current buckets
  	var/list/datum/timedevent/second_queue = list()
  	/// A hashlist dictionary used for storing unique timers
  	var/list/hashes = list()
  	/// world.time of the first entry in the bucket list, effectively the 'start time' of the current buckets
  	var/head_offset = 0
  	/// Index of the wrap around pivot for buckets. buckets before this are later running buckets wrapped around from the end of the bucket list.
  	var/practical_offset = 1
  	/// world.tick_lag the bucket was designed for
  	var/bucket_resolution = 0
  	/// How many timers are in the buckets
  	var/bucket_count = 0
  	/// List of buckets, each bucket holds every timer that has to run that byond tick
  	var/list/bucket_list = list()
  	/// List of all active timers associated to their timer ID (for easy lookup)
  	var/list/timer_id_dict = list()
  	/// Special timers that run in real-time, not BYOND time; these are more expensive to run and maintain
  	var/list/clienttime_timers = list()
  	/// Contains the last time that a timer's callback was invoked, or the last tick the SS fired if no timers are being processed
  	var/last_invoke_tick = 0
  	/// Contains the last time that a warning was issued for not invoking callbacks
  	var/static/last_invoke_warning = 0
  	/// Boolean operator controlling if the timer SS will automatically reset buckets if it fails to invoke callbacks for an extended period of time
  	var/static/bucket_auto_reset = TRUE
  
  /datum/controller/subsystem/timer/PreInit()
  