   @inline(__always)
   public mutating func load(order: LoadMemoryOrder = .relaxed) -> Int64
   {
-    return Read64(&self.value, order.order)
-  }
-
-  @inline(__always)
-  public mutating func store(v: Int64, order: StoreMemoryOrder = .relaxed)
-  {
-    Store64(v, &self.value, order.order)
-  }
-
-  @inline(__always)
-  public mutating func swap(v: Int64, order: MemoryOrder = .relaxed) -> Int64
-  {
-    return Swap64(v, &self.value, order.order)
-  }
-
-  @inline(__always)
-  public mutating func add(i: Int64, order: MemoryOrder = .relaxed) -> Int64
-  {
-    return Add64(i, &self.value, order.order)
+    return Read64(&val, order.order)
+  }
+
+  @inline(__always)
+  public mutating func store(value: Int64, order: StoreMemoryOrder = .relaxed)
+  {
+    Store64(value, &val, order.order)
+  }
+
+  @inline(__always)
+  public mutating func swap(value: Int64, order: MemoryOrder = .relaxed) -> Int64
+  {
+    return Swap64(value, &val, order.order)
+  }
+
+  @inline(__always)
+  public mutating func add(delta: Int64, order: MemoryOrder = .relaxed) -> Int64
+  {
+    return Add64(delta, &val, order.order)
   }
 
   @inline(__always)
   public mutating func increment(order: MemoryOrder = .relaxed) -> Int64
   {
-    return Add64(1, &self.value, order.order)
-  }
-
-  @inline(__always)
-  public mutating func subtract(i: Int64, order: MemoryOrder = .relaxed) -> Int64
-  {
-    return Sub64(i, &self.value, order.order)
+    return Add64(1, &val, order.order)
+  }
+
+  @inline(__always)
+  public mutating func subtract(delta: Int64, order: MemoryOrder = .relaxed) -> Int64
+  {
+    return Sub64(delta, &val, order.order)
   }
 
   @inline(__always)
   public mutating func decrement(order: MemoryOrder = .relaxed) -> Int64
   {
-    return Sub64(1, &self.value, order.order)
+    return Sub64(1, &val, order.order)
   }
 
   @inline(__always)
   public mutating func bitwiseOr(bits: Int64, order: MemoryOrder = .relaxed) -> Int64
   {
-    return Or64(bits, &self.value, order.order)
+    return Or64(bits, &val, order.order)
   }
 
   @inline(__always)
   public mutating func bitwiseXor(bits: Int64, order: MemoryOrder = .relaxed) -> Int64
   {
-    return Xor64(bits, &self.value, order.order)
+    return Xor64(bits, &val, order.order)
   }
 
   @inline(__always)
   public mutating func bitwiseAnd(bits: Int64, order: MemoryOrder = .relaxed) -> Int64
   {
-    return And64(bits, &self.value, order.order)
+    return And64(bits, &val, order.order)
   }
 
   @inline(__always)

    var expect = current
    switch type {
    case .strong:
      return CASWord(&expect, future, &self.value, orderSuccess.order, orderFailure.order)
    case .weak:
      return CASWeakWord(&expect, future, &self.value, orderSuccess.order, orderFailure.order)
    }
  }
}

  }

  @inline(__always)
  public mutating func subtract(delta: UInt, order: MemoryOrder = .relaxed) -> UInt
  {
    return unsafeBitCast(SubWord(unsafeBitCast(delta, Int.self), ptr(&val), order.order), UInt.self)
  }

  @inline(__always)
