 	fileprivate weak var blockable: SignalBlockable?
 	fileprivate let activationCount: Int
 	fileprivate let predecessor: Unmanaged<AnyObject>?
-
+	
 	fileprivate let activated: Bool
 	fileprivate var needUnblock = false
-
+	
 	/// Constructs with the details of the next `Signal` and the `blockable` (the `SignalTransformer` or `SignalTransformerWithState` to which this belongs). NOTE: predecessor and blockable are typically the same instance, just stored differently, for efficiency.
 	fileprivate init(signal: Signal<T>, predecessor: SignalPredecessor, activationCount: Int, activated: Bool, blockable: SignalBlockable) {
 		self.signal = signal

			}
			return
		}

		if case .synchronous(let count) = delivery {
			assert(count == 0)
			delivery = .synchronous(values.count + (error != nil ? 1 : 0))

			}
		case .disabled:
			mutex.unbalancedUnlock()
			
			// Retain the result past the end of the lock
			withExtendedLifetime(result) {}
			return SignalError.inactive
		}
		
		if !refreshItemContextInternal() {
			mutex.unbalancedUnlock()
			return SignalError.inactive
		}
		
		assert(holdCount == 0 && itemProcessing == false)
		itemProcessing = true
		
		mutex.unbalancedUnlock()
		
		// As an optimization/ARC-avoidance, the common path through the `dispatch` and `invokeHandler` functions is manually inlined here.
		// I'd love to express this two layer switch as `switch (itemContext.context, result)` but without specialization, it malloc's.
		switch itemContext.context {
