 			//   also be checked again after the locks are acquired. Fail gracefully
 			//   if the state has changed since the relaxed read, i.e. a concurrent
 			//   sender has already handled the termination event.
+			//
+			// Exploiting the relaxation of reads, please note that false positives
+			// are intentionally allowed in the `terminating` checks below. As a
+			// result, normal event deliveries need not acquire `updateLock`.
+			// Nevertheless, this should not cause the termination event being
+			// sent multiple times, since `shouldReallyTerminate` would not
+			// respond to false positives.
 
 			if event.isTerminating {
 				// Recursive events are disallowed for `value` events, but are permitted

		generatorDisposable = generator(observer)
	}

	/// Swap the generator disposable with `nil`.
	///
	/// - returns:
	///   The generator disposable, or `nil` if it has been disposed of.
	@inline(__always)
	private func swapDisposable() -> Disposable? {
		if let d = generatorDisposable {
			generatorDisposable = nil


					// Check if the status has been bumped to `terminating` due to a
					// concurrent or a recursive termination event.
					if case .terminating = signal.state, let snapshot = signal.shouldReallyTerminate() {
						for observer in snapshot.observers {
							observer.action(snapshot.associated)
						}

						shouldDispose = true
					}
				}

