     var expect = UnsafeMutablePointer<Void>(current)
     switch type {
     case .strong:
-      return CASVoidPtr(&expect, UnsafePointer(future), &self.p, orderSuccess.order, orderFailure.order)
+      return CASVoidPtr(&expect, UnsafePointer(future), &ptr, orderSuccess.order, orderFailure.order)
     case .weak:
-      return CASWeakVoidPtr(&expect, UnsafePointer(future), &self.p, orderSuccess.order, orderFailure.order)
+      return CASWeakVoidPtr(&expect, UnsafePointer(future), &ptr, orderSuccess.order, orderFailure.order)
     }
   }
 }
 
 public struct AtomicPointer<Pointee>: NilLiteralConvertible
 {
-  private var p: UnsafeMutablePointer<Void>
-  public init(_ ptr: UnsafePointer<Pointee> = nil) { self.p = UnsafeMutablePointer(ptr) }
-  public init(nilLiteral: ()) { self.p = nil }
+  private var ptr: UnsafeMutablePointer<Void>
+  public init(_ ptr: UnsafePointer<Pointee> = nil) { self.ptr = UnsafeMutablePointer(ptr) }
+  public init(nilLiteral: ()) { self.ptr = nil }
 
   public var pointer: UnsafePointer<Pointee> {
-    mutating get { return UnsafePointer(ReadVoidPtr(&self.p, memory_order_relaxed)) }
-    mutating set { StoreVoidPtr(newValue, &self.p, memory_order_relaxed) }
+    mutating get { return UnsafePointer(ReadVoidPtr(&ptr, memory_order_relaxed)) }
+    mutating set { StoreVoidPtr(newValue, &ptr, memory_order_relaxed) }
   }
 }
 

    var expect = UnsafeMutablePointer<Void>(current)
    switch type {
    case .strong:
      return CASVoidPtr(&expect, UnsafePointer(future), &self.p, orderSuccess.order, orderFailure.order)
    case .weak:
      return CASWeakVoidPtr(&expect, UnsafePointer(future), &self.p, orderSuccess.order, orderFailure.order)
    }
  }
}

public struct AtomicOpaquePointer: NilLiteralConvertible
{
  private var p: UnsafeMutablePointer<Void>
  public init(_ ptr: COpaquePointer = nil) { self.p = UnsafeMutablePointer(ptr) }
  public init(nilLiteral: ()) { self.p = nil }

  public var pointer: COpaquePointer {
    mutating get { return COpaquePointer(ReadVoidPtr(&self.p, memory_order_relaxed)) }
    mutating set { StoreVoidPtr(UnsafePointer(newValue), &self.p, memory_order_relaxed) }
  }
}


  @inline(__always)
  public mutating func load(order: LoadMemoryOrder = .relaxed) -> UnsafeMutablePointer<Pointee>
  {
    return UnsafeMutablePointer(ReadVoidPtr(&ptr, order.order))
  }

  @inline(__always)
  public mutating func store(pointer: UnsafeMutablePointer<Pointee>, order: StoreMemoryOrder = .relaxed)
  {
    StoreVoidPtr(UnsafePointer(pointer), &ptr, order.order)
  }

  @inline(__always)
  public mutating func swap(pointer: UnsafeMutablePointer<Pointee>, order: MemoryOrder = .relaxed) -> UnsafeMutablePointer<Pointee>
  {
    return UnsafeMutablePointer(SwapVoidPtr(UnsafePointer(pointer), &ptr, order.order))
  }

  @inline(__always)
