anchor.diff:    * If the timed event is tracking client time, it will be added to a special bucket.
     */
   /datum/timedevent/proc/bucketJoin()
  +	// Generate debug-friendly name for timer
  +	var/static/list/bitfield_flags = list("TIMER_UNIQUE", "TIMER_OVERRIDE", "TIMER_CLIENT_TIME", "TIMER_STOPPABLE", "TIMER_NO_HASH_WAIT", "TIMER_LOOP")
  +	name = "Timer: [id] (\ref[src]), TTR: [timeToRun], wait:[wait] Flags: [jointext(bitfield2list(flags, bitfield_flags), ", ")], \
  +		callBack: \ref[callBack], callBack.object: [callBack.object]\ref[callBack.object]([getcallingtype()]), \
  +		callBack.delegate:[callBack.delegate]([callBack.arguments ? callBack.arguments.Join(", ") : ""]), source: [source]"
  +		
   	// Check if this timed event should be diverted to the client time bucket, or the secondary queue
   	var/list/L
   	if (flags & TIMER_CLIENT_TIME)
  
positive.code: 		bucket_list = src.bucket_list
  		resumed = FALSE
  
  	var/static/list/invoked_timers = list()
  	var/static/datum/timedevent/timer
  	if (!resumed)
  		timer = null
  
  	// Iterate through each bucket starting from the practical offset
  	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
  
  		// Iterate through each timer, invoking callbacks as necessary
  		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]")
  
  			// Invoke callback if possible
  			if (!timer.spent)
  				invoked_timers += timer
  				timer.spent = world.time
  				callBack.InvokeAsync()
  				last_invoke_tick = world.time
  
  			if (MC_TICK_CHECK)
  				return
  
  			// Break once we've invoked the entire bucket
  			timer = timer.next
  			if (timer == head)
  				break
  
  		// Empty the bucket, check if anything in the secondary queue should be shifted to this bucket
  		bucket_list[practical_offset++] = null
  		var/i = 0
  		for (i in 1 to length(second_queue))
  			timer = second_queue[i]
  			if (timer.timeToRun >= TIMER_MAX)
  				i--
  				break
  
  			// Check for timers that are scheduled to run in the past
  			if (timer.timeToRun < head_offset)
  				bucket_resolution = null // force bucket recreation
  				stack_trace("[i] Invalid timer state: Timer in long run queue with a time to run less then head_offset. \
  					[get_timer_debug_string(timer)] world.time: [world.time], head_offset: [head_offset], practical_offset: [practical_offset]")
  
  				if (timer.callBack && !timer.spent)
  					timer.callBack.InvokeAsync()
  					invoked_timers += timer
  					bucket_count++
  				else if(!QDELETED(timer))
  					qdel(timer)
  				continue
  
  			// Check for timers that are not capable of being scheduled to run without rebuilding buckets
  			if (timer.timeToRun < head_offset + TICKS2DS(practical_offset - 1))
  				bucket_resolution = null // force bucket recreation
  				stack_trace("[i] Invalid timer state: Timer in long run queue that would require a backtrack to transfer to \
  					short run queue. [get_timer_debug_string(timer)] world.time: [world.time], head_offset: [head_offset], practical_offset: [practical_offset]")
  				if (timer.callBack && !timer.spent)
  					timer.callBack.InvokeAsync()
  					invoked_timers += timer
  					bucket_count++
  				else if(!QDELETED(timer))
  					qdel(timer)
  				continue
  
  			// Transfer the timer into the bucket, performing necessary circular doubly-linked list operations
  			bucket_count++
  			var/bucket_pos = max(1, BUCKET_POS(timer))
  			var/datum/timedevent/bucket_head = bucket_list[bucket_pos]
  			if (!bucket_head)
  				bucket_list[bucket_pos] = timer
  				timer.next = null
  				timer.prev = null
  				continue
  
  			if (!bucket_head.prev)
  				bucket_head.prev = bucket_head
  			timer.next = bucket_head
  			timer.prev = bucket_head.prev
  			timer.next.prev = timer
  			timer.prev.next = timer
  		if (i)
  			second_queue.Cut(1, i+1)
  		timer = null
  
  	// Process each invoked timer
  	bucket_count -= length(invoked_timers)
  	for (var/datum/timedevent/qtimer in invoked_timers)
  		if(QDELETED(qtimer))
  			bucket_count++
  			continue
  		if(!(qtimer.flags & TIMER_LOOP))
  			qdel(qtimer)
  		else // Prepare looping timers to re-enter the queue
  			bucket_count++
  			qtimer.spent = 0
  			qtimer.bucketEject()
  			qtimer.timeToRun = (qtimer.flags & TIMER_CLIENT_TIME ? REALTIMEOFDAY : world.time) + qtimer.wait
  			qtimer.bucketJoin()
  	invoked_timers.len = 0
  
  /**
    * Generates a string with details about the timed event for debugging purposes
  
negative.code: 			nextid++
  		SStimer.timer_id_dict[id] = src
  
  	if ((timeToRun < world.time || timeToRun < SStimer.head_offset) && !(flags & TIMER_CLIENT_TIME))
  		CRASH("Invalid timer state: Timer created that would require a backtrack to run (addtimer would never let this happen): [SStimer.get_timer_debug_string(src)]")
  
  