     var expect = current
     switch type {
     case .strong:
-      return CAS32(&expect, future, &self.value, orderSuccess.order, orderFailure.order)
+      return CAS32(&expect, future, &val, orderSuccess.order, orderFailure.order)
     case .weak:
-      return CASWeak32(&expect, future, &self.value, orderSuccess.order, orderFailure.order)
+      return CASWeak32(&expect, future, &val, orderSuccess.order, orderFailure.order)
     }
   }
 }

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

  @inline(__always)
  public mutating func load(order: LoadMemoryOrder = .relaxed) -> Int64
  {
    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, &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, &val, order.order)
  }

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

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

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

  @inline(__always)
