     let readUInt = randUInt.load(.sequential)
     XCTAssert(randUInt.value == readUInt)
 
-    var randInt32 = Int32(nzRandom())
-    let readInt32 = randInt32.atomicRead(synchronized: true)
-    XCTAssert(randInt32 == readInt32)
-
-    var randUInt32 = UInt32(nzRandom())
-    let readUInt32 = randUInt32.atomicRead(synchronized: true)
-    XCTAssert(randUInt32 == readUInt32)
-
-    var randInt64 = Int64(nzRandom())
-    let readInt64 = randInt64.atomicRead(synchronized: true)
-    XCTAssert(randInt64 == readInt64)
-
-    var randUInt64 = UInt64(nzRandom())
-    let readUInt64 = randUInt64.atomicRead(synchronized: true)
-    XCTAssert(randUInt64 == readUInt64)
-
-    var randPtr = UnsafePointer<CGPoint>(bitPattern: nzRandom())
-    let readPtr = randPtr.atomicRead(synchronized: true)
-    XCTAssert(randPtr == readPtr)
-
-    var randMutPtr = UnsafeMutablePointer<CGPoint>(bitPattern: nzRandom())
-    let readMutPtr = randMutPtr.atomicRead(synchronized: true)
-    XCTAssert(randMutPtr == readMutPtr)
-
-    var randOPtr = COpaquePointer(bitPattern: nzRandom())
-    let readOPtr = randOPtr.atomicRead(synchronized: true)
-    XCTAssert(randOPtr == readOPtr)
-  }
-  
+    var randInt32 = AtomicInt32(Int32(nzRandom()))
+    let readInt32 = randInt32.load(.sequential)
+    XCTAssert(randInt32.value == readInt32)
+
+    var randUInt32 = AtomicUInt32(UInt32(nzRandom()))
+    let readUInt32 = randUInt32.load(.sequential)
+    XCTAssert(randUInt32.value == readUInt32)
+
+    var randInt64 = AtomicInt64(Int64(nzRandom()))
+    let readInt64 = randInt64.load(.sequential)
+    XCTAssert(randInt64.value == readInt64)
+
+    var randUInt64 = AtomicUInt64(UInt64(nzRandom()))
+    let readUInt64 = randUInt64.load(.sequential)
+    XCTAssert(randUInt64.value == readUInt64)
+
+    var randPtr = AtomicPointer<CGPoint>(UnsafePointer(bitPattern: nzRandom()))
+    let readPtr = randPtr.load(.sequential)
+    XCTAssert(randPtr.pointer == readPtr)
+
+    var randMutPtr = AtomicMutablePointer<CGPoint>(UnsafeMutablePointer(bitPattern: nzRandom()))
+    let readMutPtr = randMutPtr.load(.sequential)
+    XCTAssert(randMutPtr.pointer == readMutPtr)
+
+    var randOPtr = AtomicOpaquePointer(COpaquePointer(bitPattern: nzRandom()))
+    let readOPtr = randOPtr.load(.sequential)
+    XCTAssert(randOPtr.pointer == readOPtr)
+  }
+
   
   func testStore()
   {

    XCTAssert(randUInt == storUInt.value)

    let randInt32 = Int32(nzRandom())
    var storInt32 = Int32(nzRandom())
    storInt32.atomicStore(randInt32, synchronized: true)
    XCTAssert(randInt32 == storInt32)

    let randUInt32 = UInt32(nzRandom())
    var storUInt32 = UInt32(nzRandom())
    storUInt32.atomicStore(randUInt32, synchronized: true)
    XCTAssert(randUInt32 == storUInt32)

    let randInt64 = Int64(nzRandom())
    var storInt64 = Int64(nzRandom())
    storInt64.atomicStore(randInt64, synchronized: true)
    XCTAssert(randInt64 == storInt64)

    let randUInt64 = UInt64(nzRandom())
    var storUInt64 = UInt64(nzRandom())
    storUInt64.atomicStore(randUInt64, synchronized: true)
    XCTAssert(randUInt64 == storUInt64)

    let randPtr = UnsafePointer<CGPoint>(bitPattern: nzRandom())
    var storPtr = UnsafePointer<CGPoint>(bitPattern: nzRandom())
    storPtr.atomicStore(randPtr, synchronized: true)
    XCTAssert(randPtr == storPtr)

    let randMutPtr = UnsafeMutablePointer<CGPoint>(bitPattern: nzRandom())
    var storMutPtr = UnsafeMutablePointer<CGPoint>(bitPattern: nzRandom())
    storMutPtr.atomicStore(randMutPtr, synchronized: true)
    XCTAssert(randMutPtr == storMutPtr)

    let randOPtr = COpaquePointer(bitPattern: nzRandom())
    var storOPtr = COpaquePointer(bitPattern: nzRandom())
    storOPtr.atomicStore(randOPtr, synchronized: true)
    XCTAssert(randOPtr == storOPtr)
  }



    XCTAssert(rUInt.value == fUInt-1)

    let fInt32 = Int32(nzRandom())
    var rInt32 = AtomicInt32(fInt32)
    XCTAssert(rInt32.subtract(1) == fInt32)
    XCTAssert(rInt32.value == fInt32-1)

    let fUInt32 = UInt32(nzRandom())
    var rUInt32 = AtomicUInt32(fUInt32)
    XCTAssert(rUInt32.subtract(1) == fUInt32)
    XCTAssert(rUInt32.value == fUInt32-1)

    let fInt64 = Int64(nzRandom())
    var rInt64 = AtomicInt64(fInt64)
    XCTAssert(rInt64.subtract(1) == fInt64)
    XCTAssert(rInt64.value == fInt64-1)

    let fUInt64 = UInt64(nzRandom())
    var rUInt64 = AtomicUInt64(fUInt64)
    XCTAssert(rUInt64.subtract(1) == fUInt64)
    XCTAssert(rUInt64.value == fUInt64-1)
  }

  func testIncrement()
