   typealias Buffer = _ContiguousArrayBuffer<T>
 
   deinit {
-    let b = Buffer(self)
-    b.baseAddress.destroy(b.count)
-    b._base._value.destroy()
-  }
-
-  final func __getInstanceSizeAndAlignMask() -> (Int,Int) {
-    return Buffer(self)._base._allocatedSizeAndAlignMask()
+    __manager.withUnsafeMutablePointers {
+      (pointerToValue, pointerToElements)->Void in
+      pointerToElements.destroy(pointerToValue.memory.count)
+      pointerToValue.destroy()
+    }
   }
 
   /// If `T` is bridged verbatim, invoke `body` on an

        newValue <= capacity,
        "Can't grow an array buffer past its capacity")

      _sanityCheck(_base.hasStorage || newValue == 0)

      if _base.hasStorage {
        _base.value.count = newValue
      }
    }
  }

    /// Note that this is better than folding hasStorage in to
    /// the return from this function, as this implementation generates
    /// no shortcircuiting blocks.
    return (index >= 0) & (index < __bufferPointer.value.count)
  }

  /// How many elements the buffer can store without reallocation
  public var capacity: Int {
    return __bufferPointer.value.capacity
  }

  /// Copy the given subRange of this buffer into uninitialized memory
