   }
 
   @inline(__always)
-  public mutating func store(v: UInt32, order: StoreMemoryOrder = .relaxed)
-  {
-    Store32(unsafeBitCast(v, Int32.self), ptr(&val), order.order)
-  }
-
-  @inline(__always)
-  public mutating func swap(v: UInt32, order: MemoryOrder = .relaxed) -> UInt32
-  {
-    return unsafeBitCast(Swap32(unsafeBitCast(v, Int32.self), ptr(&val), order.order), UInt32.self)
-  }
-
-  @inline(__always)
-  public mutating func add(i: UInt32, order: MemoryOrder = .relaxed) -> UInt32
-  {
-    return unsafeBitCast(Add32(unsafeBitCast(i, Int32.self), ptr(&val), order.order), UInt32.self)
+  public mutating func store(value: UInt32, order: StoreMemoryOrder = .relaxed)
+  {
+    Store32(unsafeBitCast(value, Int32.self), ptr(&val), order.order)
+  }
+
+  @inline(__always)
+  public mutating func swap(value: UInt32, order: MemoryOrder = .relaxed) -> UInt32
+  {
+    return unsafeBitCast(Swap32(unsafeBitCast(value, Int32.self), ptr(&val), order.order), UInt32.self)
+  }
+
+  @inline(__always)
+  public mutating func add(delta: UInt32, order: MemoryOrder = .relaxed) -> UInt32
+  {
+    return unsafeBitCast(Add32(unsafeBitCast(delta, Int32.self), ptr(&val), order.order), UInt32.self)
   }
 
   @inline(__always)

  @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)
  }

  @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)
  }

  @inline(__always)
  public mutating func decrement(order: MemoryOrder = .relaxed) -> Int64
  {
    return Sub64(1, &self.value, order.order)
  }

  @inline(__always)
  public mutating func bitwiseOr(bits: Int64, order: MemoryOrder = .relaxed) -> Int64
  {
    return Or64(bits, &self.value, order.order)
  }

  @inline(__always)
  public mutating func bitwiseXor(bits: Int64, order: MemoryOrder = .relaxed) -> Int64
  {
    return Xor64(bits, &self.value, order.order)
  }

  @inline(__always)
  public mutating func bitwiseAnd(bits: Int64, order: MemoryOrder = .relaxed) -> Int64
  {
    return And64(bits, &self.value, order.order)
  }

  @inline(__always)

  }

  @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)
