 				}
 
 				self.sendLock.unlock()
-
-				// Check if the status has been bumped to `terminating` due to a
-				// terminal event being sent concurrently or recursively.
-				//
-				// The check is deliberately made outside of the `sendLock` so that it
-				// covers also any potential concurrent terminal event in one shot.
-				//
-				// Related PR:
-				// https://github.com/ReactiveCocoa/ReactiveSwift/pull/112
-				self.stateLock.lock()
-				if result == .none, case .terminating = self.state {
-					self.stateLock.unlock()
-					result = self.tryToCommitTermination()
-				} else {
-					self.stateLock.unlock()
-				}
-
+			}
+
+			// Check if the status has been bumped to `terminating` due to a
+			// terminal event being sent concurrently or recursively.
+			//
+			// The check is deliberately made outside of the `sendLock` so that it
+			// covers also any potential concurrent terminal event in one shot.
+			//
+			// Related PR:
+			// https://github.com/ReactiveCocoa/ReactiveSwift/pull/112
+			if .shouldDispose == self.tryToCommitTermination() {
 				// Dispose only after notifying observers, so disposal
 				// logic is consistently the last thing to run.
-				if result == .shouldDispose {
-					self.disposable.dispose()
-				}
+				self.disposable.dispose()
 			}
 		}
 


					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 {
