   private func waiterQueue(from state: Int) -> UnsafeMutablePointer<Waiter<Value>>?
   {
     if state.isResolved { return nil }
-    return state.pointer?.assumingMemoryBound(to: Waiter<Value>.self)
+    return state.ptr?.assumingMemoryBound(to: Waiter<Value>.self)
   }
 
   deinit

  private func resolvedPointer(from state: Int) -> UnsafeMutablePointer<Result<Value, Error>>?
  {
    guard state.isResolved else { return nil }
    return state.pointer?.assumingMemoryBound(to: Result<Value, Error>.self)
  }

  /// Get a pointer to the first `Waiter` for an unresolved `Deferred`.

  static let resolved =  0x3
  private static let stateMask = 0x3

  init(_ pointer: UnsafeMutableRawPointer, tag: Int)
  {
    self = Int(bitPattern: pointer) | (tag & .stateMask)
  }

  var isResolved: Bool { return tag == .resolved }

  var tag: Int { return self & .stateMask }
  var ptr: UnsafeMutableRawPointer? { return UnsafeMutableRawPointer(bitPattern: self & ~.stateMask) }
}

/// An asynchronous computation.
