     return _roundUpToAlignment(sizeof(_HeapObject.self), alignof(Value.self))
   }
 
+  /// An **unmanaged** pointer to the storage for the `Value`
+  /// instance.  Not safe to use without _fixLifetime calls to
+  /// guarantee it doesn't dangle
+  internal var _valuePointer: UnsafeMutablePointer<Value> {
+    return UnsafeMutablePointer(_address + _My._valueOffset)
+  }
+
+  /// An **unmanaged** pointer to the storage for `Element`\ s.  Not
+  /// safe to use without _fixLifetime calls to guarantee it doesn't
+  /// dangle.
+  internal var _elementPointer: UnsafeMutablePointer<Element> {
+    return UnsafeMutablePointer(_address + _My._elementOffset)
+  }
+
   /// Offset from the allocated storage for `self` to the `Element` storage
   internal static var _elementOffset: Int {
     return _roundUpToAlignment(

    minimumCapacity: Int,
    initialValue: (buffer: AnyObject, allocatedCount: (AnyObject)->Int)->Value
  ) {
    ManagedBufferPointer._checkValidBufferClass(bufferClass, creating: true)
    _precondition(
      minimumCapacity >= 0,
      "ManagedBufferPointer must have non-negative capacity")

    let totalSize = _My._elementOffset
      +  minimumCapacity * strideof(Element.self)

    let newBuffer: AnyObject = _swift_bufferAllocate(
      bufferClass, totalSize, _My._alignmentMask)

    self._nativeBuffer = Builtin.castToNativeObject(newBuffer)

    // initialize the value field
    withUnsafeMutablePointerToValue {
      $0.initialize(
        initialValue(
          buffer: newBuffer,
          allocatedCount: {
            ManagedBufferPointer(unsafeBufferObject: $0).allocatedElementCount
          }))

  /// The stored `Value` instance.
  public final var value: Value {
    address {
      return ManagedBufferPointer(self).withUnsafeMutablePointerToValue { UnsafePointer($0) }
    }
    mutableAddress {
      return ManagedBufferPointer(self).withUnsafeMutablePointerToValue { $0 }
