     return (_allocatedByteCount &- _My._elementOffset) &/ strideof(Element)
   }
 
-  /// Call `body` with an `UnsafeMutablePointer` to the stored `Value`
+  /// Call `body` with an `UnsafeMutablePointer` to the stored
+  /// `Value`.  **Note**: this pointer is only valid
+  /// for the duration of the call to `body`
   public func withUnsafeMutablePointerToValue<R>(
     body: (UnsafeMutablePointer<Value>)->R
   ) -> R {
     return withUnsafeMutablePointers { (v, e) in return body(v) }
   }
   
-  /// Call body with an `UnsafeMutablePointer` to the `Element` storage
+  /// Call `body` with an `UnsafeMutablePointer` to the `Element`
+  /// storage.  **Note**: this pointer is only valid
+  /// for the duration of the call to `body`.
   public func withUnsafeMutablePointerToElements<R>(
     body: (UnsafeMutablePointer<Element>)->R
   ) -> R {
     return withUnsafeMutablePointers { return body($0.1) }
   }
 
-  /// Call body with `UnsafeMutablePointer`\ s to the stored `Value`
-  /// and raw `Element` storage
+  /// Call `body` with `UnsafeMutablePointer`\ s to the stored `Value`
+  /// and raw `Element` storage.  **Note**: these pointers are only valid
+  /// for the duration of the call to `body`.
   public func withUnsafeMutablePointers<R>(
     body: (_: UnsafeMutablePointer<Value>, _: UnsafeMutablePointer<Element>)->R
   ) -> R {
-    let result = body(
-      UnsafeMutablePointer(_address + _My._valueOffset),
-      UnsafeMutablePointer(_address + _My._elementOffset)
-    )
+    let result = body(_valuePointer, _elementPointer)
     _fixLifetime(_nativeBuffer)
     return result
   }

    return p.allocatedElementCount
  }

  /// Call `body` with an `UnsafeMutablePointer` to the stored `Value`
  public final func withUnsafeMutablePointerToValue<R>(
    body: (UnsafeMutablePointer<Value>)->R
  ) -> R {
    return withUnsafeMutablePointers { (v, e) in return body(v) }
  }
  
  /// Call body with an `UnsafeMutablePointer` to the `Element` storage
  public final func withUnsafeMutablePointerToElements<R>(
    body: (UnsafeMutablePointer<Element>)->R
  ) -> R {
    return withUnsafeMutablePointers { return body($0.1) }
  }

  /// Call body with `UnsafeMutablePointer`\ s to the stored `Value`
  /// and raw `Element` storage
  public final func withUnsafeMutablePointers<R>(
    body: (_: UnsafeMutablePointer<Value>, _: UnsafeMutablePointer<Element>)->R
  ) -> R {

    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(
