 				// the disposal would be delegated to the current sender, or
 				// occasionally one of the senders waiting on `sendLock`.
 				if let state = signal.state.swap(nil) {
-					// `terminationEvent` must be written before `terminationState`, or
-					// concurrent readers might not see the value of `terminationEvent`.
-					terminationEvent = event
-					terminationState = state
+					terminationState = SignalTerminationState(state: state,
+					                                          event: event)
 
 					// Writes to `terminationState` are implicitly synchronized. So we do
 					// not need to guard it with locks.

	}
}

private struct SignalState<Value, Error: Swift.Error> {
	var observers: Bag<Signal<Value, Error>.Observer> = Bag()
	var retaining: Signal<Value, Error>?
}


		let sendLock = NSLock()
		sendLock.name = "org.reactivecocoa.ReactiveSwift.Signal"

		@inline(__always)
		func terminate(with state: SignalTerminationState<Value, Error>) {
			state.send()
			terminated = true
			terminationState = nil
		}

		let observer = Observer { [weak self] event in
			guard let signal = self else {
				return
			}

			if event.isTerminating {
