 				if case let .alive(observers, _) = state {
 					self.state = .terminating(observers, .init(event))
 					self.stateLock.unlock()
-
-					// Check whether the terminating state has been handled by a
-					// concurrent sender. If not, handle it.
-					if self.tryToCommitTermination() == .shouldDispose {
-						self.disposable.dispose()
-					}
 				} else {
 					self.stateLock.unlock()
 				}
 			} else {
-				var result = OperationResult.none
-
 				self.sendLock.lock()
 				self.stateLock.lock()
 


					return .shouldDispose
				}

				self.stateLock.unlock()
				return .none
			}

			// If the caller declares prior acquisition of `sendLock`, go straight to
			// the termination committing routine.
			guard sendLock == nil else {
				return commit()
			}

			guard self.sendLock.try() else {
				// The current sender would commit the termination anyway.
				return .none
			}

			defer { self.sendLock.unlock() }
			return commit()
		}

		/// Try to dispose of the signal silently if the `Signal` has deinitialized and

		///
		/// - precondition: `stateLock` must not be acquired by the caller.
		///
		/// - returns: `.shouldDispose` if the attempt succeeds. `.none` otherwise.
		private func tryToCommitTermination() -> OperationResult {
			// Acquire `stateLock`. If the termination has still not yet been
			// handled, take it over and bump the status to `terminated`.
			stateLock.lock()

			if case let .terminating(observers, terminationKind) = state {
				// Try to acquire the `sendLock`, and fail gracefully since the current
				// lock holder would attempt to commit after it is done anyway.
				if sendLock.try() {
					state = .terminated
					stateLock.unlock()

					defer { sendLock.unlock() }

					if let event = terminationKind.materialize() {
						for observer in observers {
