0001 /* 0002 * Atomic (atomic.swift) - Please be Safe 0003 * 0004 * Copyright (C) 2015 ONcast, LLC. All Rights Reserved. 0005 * Created by Josh Baker (joshbaker77@gmail.com) 0006 * 0007 * This software may be modified and distributed under the terms 0008 * of the MIT license. See the LICENSE file for details. 0009 */ 0010 0011 import Foundation 0012 0013 /** 0014 Atomic is a class that allows for atomic loading and storing of objects.atomic 0015 0016 ``` 0017 var ai = Atomic<Int>(15) 0018 ai += 10 0019 print(ai) // prints 25 0020 ``` 0021 0022 There are a number of helper aliases for common types such as IntA, StringA, BoolA 0023 0024 ``` 0025 var ai = IntA(15) 0026 ai += 10 0027 print(ai) // prints 25 0028 ``` 0029 0030 */ 0031 public class Atomic<T
atomic.swift:51 public func exchange(atomic : Atomic<T>) {atomic.swift:67 @inline(__always) private func lock<T>(lhs: Atomic<T>, _ rhs: Atomic<T>){atomic.swift:67 @inline(__always) private func lock<T>(lhs: Atomic<T>, _ rhs: Atomic<T>){atomic.swift:71 @inline(__always) private func lock<T>(lhs: Atomic<T>){atomic.swift:74 @inline(__always) private func unlock<T>(lhs: Atomic<T>, _ rhs: Atomic<T>){atomic.swift:74 @inline(__always) private func unlock<T>(lhs: Atomic<T>, _ rhs: Atomic<T>){atomic.swift:78 @inline(__always) private func unlock<T>(lhs: Atomic<T>){atomic.swift:83 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value == rhs.value; unlock(lhs, rhs); return result }atomic.swift:83 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value == rhs.value; unlock(lhs, rhs); return result }atomic.swift:84 public func ==<T : Equatable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs == rhs.value; unlock(rhs); return result }atomic.swift:85 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value == rhs; unlock(lhs); return result }atomic.swift:86 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value != rhs.value; unlock(lhs, rhs); return result }atomic.swift:86 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value != rhs.value; unlock(lhs, rhs); return result }atomic.swift:87 public func !=<T : Equatable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs != rhs.value; unlock(rhs); return result }atomic.swift:88 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value != rhs; unlock(lhs); return result }atomic.swift:89 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value && rhs.value; unlock(lhs, rhs); return result }atomic.swift:89 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value && rhs.value; unlock(lhs, rhs); return result }atomic.swift:90 public func &&<T : BooleanType>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs && rhs.value; unlock(rhs); return result }atomic.swift:91 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value && rhs; unlock(lhs); return result }atomic.swift:92 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value || rhs.value; unlock(lhs, rhs); return result }atomic.swift:92 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value || rhs.value; unlock(lhs, rhs); return result }atomic.swift:93 public func ||<T : BooleanType>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs || rhs.value; unlock(rhs); return result }atomic.swift:94 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value || rhs; unlock(lhs); return result }atomic.swift:95 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value <= rhs.value; unlock(lhs, rhs); return result }atomic.swift:95 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value <= rhs.value; unlock(lhs, rhs); return result }atomic.swift:96 public func <=<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs <= rhs.value; unlock(rhs); return result }atomic.swift:97 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value <= rhs; unlock(lhs); return result }atomic.swift:98 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value >= rhs.value; unlock(lhs, rhs); return result }atomic.swift:98 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value >= rhs.value; unlock(lhs, rhs); return result }atomic.swift:99 public func >=<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs >= rhs.value; unlock(rhs); return result }atomic.swift:100 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value >= rhs; unlock(lhs); return result }atomic.swift:101 public func ><T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value > rhs.value; unlock(lhs, rhs); return result }atomic.swift:101 public func ><T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value > rhs.value; unlock(lhs, rhs); return result }atomic.swift:102 public func ><T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs > rhs.value; unlock(rhs); return result }atomic.swift:103 public func ><T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value > rhs; unlock(lhs); return result }atomic.swift:104 public func <<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value < rhs.value; unlock(lhs, rhs); return result }atomic.swift:104 public func <<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value < rhs.value; unlock(lhs, rhs); return result }atomic.swift:105 public func <<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs < rhs.value; unlock(rhs); return result }atomic.swift:106 public func <<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value < rhs; unlock(lhs); return result }atomic.swift:107 public prefix func !<T : BooleanType>(x: Atomic<T>) -> Atomic<Bool> { lock(x); let result = !x.value; unlock(x); return Atomic(result) }atomic.swift:107 public prefix func !<T : BooleanType>(x: Atomic<T>) -> Atomic<Bool> { lock(x); let result = !x.value; unlock(x); return Atomic(result) }atomic.swift:107 public prefix func !<T : BooleanType>(x: Atomic<T>) -> Atomic<Bool> { lock(x); let result = !x.value; unlock(x); return Atomic(result) }atomic.swift:109 atomic.swift:110 atomic.swift:111 atomic.swift:112 atomic.swift:113 atomic.swift:114 atomic.swift:115 atomic.swift:116 atomic.swift:117 atomic.swift:118 atomic.swift:119 atomic.swift:120 atomic.swift:121 atomic.swift:122 atomic.swift:299 public func +(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:300 public func +(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:301 public func +(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:302 public func +(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:303 public func +(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:304 public func +(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:305 public func +(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:306 public func +(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:307 public func +(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:308 public func +(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:309 public func +(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:310 public func +(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:311 public func +(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:312 public func +(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:313 public func +(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:314 public func +(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:315 public func +(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:316 public func +(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:317 public func +(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:318 public func +(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:319 public func +(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:320 public func +(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:321 public func +(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:322 public func +(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:323 public func +(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:324 public func +(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:325 public func +(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:326 public func +(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:327 public func +(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:328 public func +(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:329 public func +(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:330 public func +(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:331 public func +(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:332 public func +(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:333 public func +(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:334 public func +(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:335 public func -(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:336 public func -(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:337 public func -(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:338 public func -(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:339 public func -(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:340 public func -(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:341 public func -(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:342 public func -(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:343 public func -(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:344 public func -(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:345 public func -(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:346 public func -(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:347 public func -(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:348 public func -(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:349 public func -(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:350 public func -(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:351 public func -(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:352 public func -(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:353 public func -(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:354 public func -(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:355 public func -(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:356 public func -(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:357 public func -(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:358 public func -(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:359 public func -(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:360 public func -(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:361 public func -(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:362 public func -(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:363 public func -(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:364 public func -(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:365 public func -(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:366 public func -(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:367 public func -(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:368 public func -(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:369 public func -(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:370 public func -(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:371 public func *(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:372 public func *(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:373 public func *(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:374 public func *(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:375 public func *(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:376 public func *(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:377 public func *(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:378 public func *(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:379 public func *(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:380 public func *(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:381 public func *(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:382 public func *(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:383 public func *(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:384 public func *(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:385 public func *(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:386 public func *(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:387 public func *(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:388 public func *(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:389 public func *(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:390 public func *(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:391 public func *(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:392 public func *(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:393 public func *(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:394 public func *(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:395 public func *(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:396 public func *(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:397 public func *(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:398 public func *(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:399 public func *(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:400 public func *(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:401 public func *(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:402 public func *(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:403 public func *(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:404 public func *(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:405 public func *(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:406 public func *(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:407 public func /(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:408 public func /(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:409 public func /(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:410 public func /(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:411 public func /(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:412 public func /(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:413 public func /(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:414 public func /(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:415 public func /(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:416 public func /(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:417 public func /(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:418 public func /(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:419 public func /(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:420 public func /(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:421 public func /(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:422 public func /(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:423 public func /(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:424 public func /(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:425 public func /(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:426 public func /(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:427 public func /(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:428 public func /(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:429 public func /(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:430 public func /(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:431 public func /(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:432 public func /(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:433 public func /(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:434 public func /(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:435 public func /(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:436 public func /(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:437 public func /(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:438 public func /(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:439 public func /(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:440 public func /(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:441 public func /(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:442 public func /(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:443 public func %(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:444 public func %(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:445 public func %(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:446 public func %(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:447 public func %(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:448 public func %(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:449 public func %(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:450 public func %(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:451 public func %(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:452 public func %(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:453 public func %(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:454 public func %(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:455 public func %(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:456 public func %(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:457 public func %(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:458 public func %(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:459 public func %(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:460 public func %(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:461 public func %(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:462 public func %(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:463 public func %(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:464 public func %(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:465 public func %(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:466 public func %(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:467 public func %(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:468 public func %(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:469 public func %(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:470 public func %(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:471 public func %(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:472 public func %(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:473 public func %(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:474 public func %(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:475 public func %(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:476 public func %(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:477 public func %(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:478 public func %(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:479 public func <<(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:480 public func <<(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:481 public func <<(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:482 public func <<(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:483 public func <<(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:484 public func <<(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:485 public func <<(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:486 public func <<(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:487 public func <<(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:488 public func <<(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:489 public func <<(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:490 public func <<(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:491 public func <<(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:492 public func <<(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:493 public func <<(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:494 public func <<(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:495 public func <<(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:496 public func <<(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:497 public func <<(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:498 public func <<(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:499 public func <<(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:500 public func <<(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:501 public func <<(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:502 public func <<(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:503 public func <<(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:504 public func <<(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:505 public func <<(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:506 public func <<(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:507 public func <<(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:508 public func <<(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:509 public func >>(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:510 public func >>(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:511 public func >>(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:512 public func >>(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:513 public func >>(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:514 public func >>(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:515 public func >>(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:516 public func >>(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:517 public func >>(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:518 public func >>(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:519 public func >>(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:520 public func >>(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:521 public func >>(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:522 public func >>(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:523 public func >>(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:524 public func >>(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:525 public func >>(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:526 public func >>(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:527 public func >>(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:528 public func >>(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:529 public func >>(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:530 public func >>(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:531 public func >>(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:532 public func >>(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:533 public func >>(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:534 public func >>(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:535 public func >>(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:536 public func >>(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:537 public func >>(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:538 public func >>(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:539 public func ^(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:540 public func ^(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:541 public func ^(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:542 public func ^(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:543 public func ^(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:544 public func ^(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:545 public func ^(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:546 public func ^(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:547 public func ^(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:548 public func ^(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:549 public func ^(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:550 public func ^(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:551 public func ^(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:552 public func ^(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:553 public func ^(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:554 public func ^(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:555 public func ^(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:556 public func ^(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:557 public func ^(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:558 public func ^(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:559 public func ^(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:560 public func ^(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:561 public func ^(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:562 public func ^(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:563 public func ^(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:564 public func ^(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:565 public func ^(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:566 public func ^(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:567 public func ^(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:568 public func ^(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:569 public func &(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:570 public func &(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:571 public func &(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:572 public func &(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:573 public func &(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:574 public func &(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:575 public func &(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:576 public func &(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:577 public func &(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:578 public func &(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:579 public func &(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:580 public func &(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:581 public func &(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:582 public func &(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:583 public func &(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:584 public func &(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:585 public func &(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:586 public func &(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:587 public func &(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:588 public func &(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:589 public func &(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:590 public func &(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:591 public func &(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:592 public func &(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:593 public func &(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:594 public func &(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:595 public func &(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:596 public func &(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:597 public func &(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:598 public func &(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:599 public func &+(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:600 public func &+(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:601 public func &+(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:602 public func &+(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:603 public func &+(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:604 public func &+(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:605 public func &+(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:606 public func &+(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:607 public func &+(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:608 public func &+(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:609 public func &+(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:610 public func &+(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:611 public func &+(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:612 public func &+(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:613 public func &+(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:614 public func &+(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:615 public func &+(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:616 public func &+(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:617 public func &+(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:618 public func &+(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:619 public func &+(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:620 public func &+(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:621 public func &+(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:622 public func &+(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:623 public func &+(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:624 public func &+(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:625 public func &+(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:626 public func &+(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:627 public func &+(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:628 public func &+(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:629 public func &-(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:630 public func &-(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:631 public func &-(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:632 public func &-(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:633 public func &-(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:634 public func &-(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:635 public func &-(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:636 public func &-(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:637 public func &-(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:638 public func &-(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:639 public func &-(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:640 public func &-(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:641 public func &-(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:642 public func &-(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:643 public func &-(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:644 public func &-(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:645 public func &-(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:646 public func &-(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:647 public func &-(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:648 public func &-(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:649 public func &-(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:650 public func &-(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:651 public func &-(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:652 public func &-(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:653 public func &-(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:654 public func &-(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:655 public func &-(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:656 public func &-(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:657 public func &-(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:658 public func &-(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:659 public func &*(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:660 public func &*(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:661 public func &*(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:662 public func &*(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:663 public func &*(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:664 public func &*(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:665 public func &*(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:666 public func &*(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:667 public func &*(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:668 public func &*(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:669 public func &*(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:670 public func &*(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:671 public func &*(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:672 public func &*(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:673 public func &*(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:674 public func &*(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:675 public func &*(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:676 public func &*(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:677 public func &*(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:678 public func &*(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:679 public func &*(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:680 public func &*(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:681 public func &*(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:682 public func &*(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:683 public func &*(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:684 public func &*(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:685 public func &*(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:686 public func &*(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:687 public func &*(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:688 public func &*(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:689 public func +(lhs: StringA, rhs: StringA) -> StringA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:690 public func +(lhs: String, rhs: StringA) -> StringA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:691 public func +(lhs: StringA, rhs: String) -> StringA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:692 public prefix func ++(x: IntA) -> IntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:693 public prefix func ++(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:694 public prefix func ++(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:695 public prefix func ++(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:696 public prefix func ++(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:697 public prefix func ++(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:698 public prefix func ++(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:699 public prefix func ++(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:700 public prefix func ++(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:701 public prefix func ++(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:702 public prefix func ++(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:703 public prefix func ++(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:704 public prefix func --(x: IntA) -> IntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:705 public prefix func --(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:706 public prefix func --(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:707 public prefix func --(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:708 public prefix func --(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:709 public prefix func --(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:710 public prefix func --(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:711 public prefix func --(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:712 public prefix func --(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:713 public prefix func --(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:714 public prefix func --(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:715 public prefix func --(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:716 public prefix func +(x: IntA) -> IntA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:717 public prefix func +(x: Int64A) -> Int64A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:718 public prefix func +(x: Int32A) -> Int32A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:719 public prefix func +(x: Int16A) -> Int16A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:720 public prefix func +(x: Int8A) -> Int8A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:721 public prefix func +(x: DoubleA) -> DoubleA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:722 public prefix func +(x: FloatA) -> FloatA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:723 public prefix func -(x: IntA) -> IntA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:724 public prefix func -(x: Int64A) -> Int64A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:725 public prefix func -(x: Int32A) -> Int32A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:726 public prefix func -(x: Int16A) -> Int16A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:727 public prefix func -(x: Int8A) -> Int8A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:728 public prefix func -(x: DoubleA) -> DoubleA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:729 public prefix func -(x: FloatA) -> FloatA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:730 public prefix func ~(x: IntA) -> IntA { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:731 public prefix func ~(x: Int64A) -> Int64A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:732 public prefix func ~(x: Int32A) -> Int32A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:733 public prefix func ~(x: Int16A) -> Int16A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:734 public prefix func ~(x: Int8A) -> Int8A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:735 public postfix func ++(x: IntA) -> IntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:736 public postfix func ++(x: Int64A) -> Int64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:737 public postfix func ++(x: Int32A) -> Int32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:738 public postfix func ++(x: Int16A) -> Int16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:739 public postfix func ++(x: Int8A) -> Int8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:740 public postfix func ++(x: UIntA) -> UIntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:741 public postfix func ++(x: UInt64A) -> UInt64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:742 public postfix func ++(x: UInt32A) -> UInt32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:743 public postfix func ++(x: UInt16A) -> UInt16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:744 public postfix func ++(x: UInt8A) -> UInt8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:745 public postfix func ++(x: DoubleA) -> DoubleA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:746 public postfix func ++(x: FloatA) -> FloatA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:747 public postfix func --(x: IntA) -> IntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:748 public postfix func --(x: Int64A) -> Int64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:749 public postfix func --(x: Int32A) -> Int32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:750 public postfix func --(x: Int16A) -> Int16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:751 public postfix func --(x: Int8A) -> Int8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:752 public postfix func --(x: UIntA) -> UIntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:753 public postfix func --(x: UInt64A) -> UInt64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:754 public postfix func --(x: UInt32A) -> UInt32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:755 public postfix func --(x: UInt16A) -> UInt16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:756 public postfix func --(x: UInt8A) -> UInt8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:757 public postfix func --(x: DoubleA) -> DoubleA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:758 public postfix func --(x: FloatA) -> FloatA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }> : CustomStringConvertible { 0032 private var mutex
atomic.swift:33 atomic.swift:35 public init(_ value : T) {atomic.swift:39 public func load() -> T {atomic.swift:45 public func store(value : T) {atomic.swift:51 public func exchange(atomic : Atomic<T>) {= Mutex() 0033 private var value
atomic.swift:40 atomic.swift:41 defer { mutex.unlock() }atomic.swift:46 atomic.swift:47 defer { mutex.unlock() }atomic.swift:52 atomic.swift:53 defer { atomic.mutex.unlock() }atomic.swift:54 atomic.swift:55 defer { mutex.unlock() }atomic.swift:61 atomic.swift:62 defer { mutex.unlock() }atomic.swift:68 atomic.swift:69 if lhs !== rhs { rhs.mutex.lock() }atomic.swift:72 atomic.swift:75 atomic.swift:76 if lhs !== rhs { rhs.mutex.unlock() }atomic.swift:79 : T 0034 /// Returns an atomic object. 0035 public init
atomic.swift:36 atomic.swift:42 atomic.swift:48 atomic.swift:56 atomic.swift:57 atomic.swift:57 atomic.swift:58 atomic.swift:63 atomic.swift:83 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value == rhs.value; unlock(lhs, rhs); return result }atomic.swift:83 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value == rhs.value; unlock(lhs, rhs); return result }atomic.swift:84 public func ==<T : Equatable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs == rhs.value; unlock(rhs); return result }atomic.swift:85 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value == rhs; unlock(lhs); return result }atomic.swift:86 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value != rhs.value; unlock(lhs, rhs); return result }atomic.swift:86 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value != rhs.value; unlock(lhs, rhs); return result }atomic.swift:87 public func !=<T : Equatable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs != rhs.value; unlock(rhs); return result }atomic.swift:88 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value != rhs; unlock(lhs); return result }atomic.swift:89 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value && rhs.value; unlock(lhs, rhs); return result }atomic.swift:89 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value && rhs.value; unlock(lhs, rhs); return result }atomic.swift:90 public func &&<T : BooleanType>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs && rhs.value; unlock(rhs); return result }atomic.swift:91 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value && rhs; unlock(lhs); return result }atomic.swift:92 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value || rhs.value; unlock(lhs, rhs); return result }atomic.swift:92 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value || rhs.value; unlock(lhs, rhs); return result }atomic.swift:93 public func ||<T : BooleanType>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs || rhs.value; unlock(rhs); return result }atomic.swift:94 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value || rhs; unlock(lhs); return result }atomic.swift:95 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value <= rhs.value; unlock(lhs, rhs); return result }atomic.swift:95 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value <= rhs.value; unlock(lhs, rhs); return result }atomic.swift:96 public func <=<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs <= rhs.value; unlock(rhs); return result }atomic.swift:97 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value <= rhs; unlock(lhs); return result }atomic.swift:98 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value >= rhs.value; unlock(lhs, rhs); return result }atomic.swift:98 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value >= rhs.value; unlock(lhs, rhs); return result }atomic.swift:99 public func >=<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs >= rhs.value; unlock(rhs); return result }atomic.swift:100 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value >= rhs; unlock(lhs); return result }atomic.swift:101 public func ><T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value > rhs.value; unlock(lhs, rhs); return result }atomic.swift:101 public func ><T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value > rhs.value; unlock(lhs, rhs); return result }atomic.swift:102 public func ><T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs > rhs.value; unlock(rhs); return result }atomic.swift:103 public func ><T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value > rhs; unlock(lhs); return result }atomic.swift:104 public func <<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value < rhs.value; unlock(lhs, rhs); return result }atomic.swift:104 public func <<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value < rhs.value; unlock(lhs, rhs); return result }atomic.swift:105 public func <<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs < rhs.value; unlock(rhs); return result }atomic.swift:106 public func <<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value < rhs; unlock(lhs); return result }atomic.swift:107 public prefix func !<T : BooleanType>(x: Atomic<T>) -> Atomic<Bool> { lock(x); let result = !x.value; unlock(x); return Atomic(result) }atomic.swift:299 public func +(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:299 public func +(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:300 public func +(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:301 public func +(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:302 public func +(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:302 public func +(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:303 public func +(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:304 public func +(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:305 public func +(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:305 public func +(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:306 public func +(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:307 public func +(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:308 public func +(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:308 public func +(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:309 public func +(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:310 public func +(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:311 public func +(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:311 public func +(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:312 public func +(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:313 public func +(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:314 public func +(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:314 public func +(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:315 public func +(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:316 public func +(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:317 public func +(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:317 public func +(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:318 public func +(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:319 public func +(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:320 public func +(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:320 public func +(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:321 public func +(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:322 public func +(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:323 public func +(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:323 public func +(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:324 public func +(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:325 public func +(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:326 public func +(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:326 public func +(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:327 public func +(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:328 public func +(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:329 public func +(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:329 public func +(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:330 public func +(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:331 public func +(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:332 public func +(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:332 public func +(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:333 public func +(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:334 public func +(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:335 public func -(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:335 public func -(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:336 public func -(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:337 public func -(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:338 public func -(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:338 public func -(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:339 public func -(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:340 public func -(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:341 public func -(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:341 public func -(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:342 public func -(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:343 public func -(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:344 public func -(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:344 public func -(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:345 public func -(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:346 public func -(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:347 public func -(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:347 public func -(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:348 public func -(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:349 public func -(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:350 public func -(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:350 public func -(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:351 public func -(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:352 public func -(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:353 public func -(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:353 public func -(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:354 public func -(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:355 public func -(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:356 public func -(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:356 public func -(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:357 public func -(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:358 public func -(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:359 public func -(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:359 public func -(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:360 public func -(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:361 public func -(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:362 public func -(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:362 public func -(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:363 public func -(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:364 public func -(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:365 public func -(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:365 public func -(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:366 public func -(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:367 public func -(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:368 public func -(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:368 public func -(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:369 public func -(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:370 public func -(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:371 public func *(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:371 public func *(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:372 public func *(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:373 public func *(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:374 public func *(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:374 public func *(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:375 public func *(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:376 public func *(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:377 public func *(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:377 public func *(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:378 public func *(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:379 public func *(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:380 public func *(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:380 public func *(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:381 public func *(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:382 public func *(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:383 public func *(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:383 public func *(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:384 public func *(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:385 public func *(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:386 public func *(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:386 public func *(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:387 public func *(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:388 public func *(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:389 public func *(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:389 public func *(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:390 public func *(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:391 public func *(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:392 public func *(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:392 public func *(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:393 public func *(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:394 public func *(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:395 public func *(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:395 public func *(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:396 public func *(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:397 public func *(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:398 public func *(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:398 public func *(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:399 public func *(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:400 public func *(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:401 public func *(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:401 public func *(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:402 public func *(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:403 public func *(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:404 public func *(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:404 public func *(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:405 public func *(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:406 public func *(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:407 public func /(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:407 public func /(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:408 public func /(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:409 public func /(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:410 public func /(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:410 public func /(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:411 public func /(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:412 public func /(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:413 public func /(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:413 public func /(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:414 public func /(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:415 public func /(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:416 public func /(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:416 public func /(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:417 public func /(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:418 public func /(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:419 public func /(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:419 public func /(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:420 public func /(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:421 public func /(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:422 public func /(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:422 public func /(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:423 public func /(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:424 public func /(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:425 public func /(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:425 public func /(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:426 public func /(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:427 public func /(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:428 public func /(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:428 public func /(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:429 public func /(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:430 public func /(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:431 public func /(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:431 public func /(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:432 public func /(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:433 public func /(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:434 public func /(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:434 public func /(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:435 public func /(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:436 public func /(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:437 public func /(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:437 public func /(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:438 public func /(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:439 public func /(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:440 public func /(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:440 public func /(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:441 public func /(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:442 public func /(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:443 public func %(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:443 public func %(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:444 public func %(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:445 public func %(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:446 public func %(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:446 public func %(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:447 public func %(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:448 public func %(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:449 public func %(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:449 public func %(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:450 public func %(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:451 public func %(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:452 public func %(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:452 public func %(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:453 public func %(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:454 public func %(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:455 public func %(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:455 public func %(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:456 public func %(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:457 public func %(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:458 public func %(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:458 public func %(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:459 public func %(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:460 public func %(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:461 public func %(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:461 public func %(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:462 public func %(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:463 public func %(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:464 public func %(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:464 public func %(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:465 public func %(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:466 public func %(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:467 public func %(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:467 public func %(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:468 public func %(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:469 public func %(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:470 public func %(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:470 public func %(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:471 public func %(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:472 public func %(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:473 public func %(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:473 public func %(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:474 public func %(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:475 public func %(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:476 public func %(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:476 public func %(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:477 public func %(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:478 public func %(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:479 public func <<(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:479 public func <<(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:480 public func <<(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:481 public func <<(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:482 public func <<(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:482 public func <<(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:483 public func <<(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:484 public func <<(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:485 public func <<(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:485 public func <<(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:486 public func <<(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:487 public func <<(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:488 public func <<(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:488 public func <<(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:489 public func <<(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:490 public func <<(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:491 public func <<(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:491 public func <<(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:492 public func <<(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:493 public func <<(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:494 public func <<(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:494 public func <<(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:495 public func <<(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:496 public func <<(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:497 public func <<(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:497 public func <<(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:498 public func <<(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:499 public func <<(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:500 public func <<(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:500 public func <<(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:501 public func <<(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:502 public func <<(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:503 public func <<(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:503 public func <<(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:504 public func <<(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:505 public func <<(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:506 public func <<(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:506 public func <<(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:507 public func <<(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:508 public func <<(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:509 public func >>(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:509 public func >>(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:510 public func >>(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:511 public func >>(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:512 public func >>(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:512 public func >>(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:513 public func >>(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:514 public func >>(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:515 public func >>(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:515 public func >>(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:516 public func >>(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:517 public func >>(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:518 public func >>(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:518 public func >>(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:519 public func >>(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:520 public func >>(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:521 public func >>(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:521 public func >>(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:522 public func >>(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:523 public func >>(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:524 public func >>(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:524 public func >>(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:525 public func >>(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:526 public func >>(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:527 public func >>(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:527 public func >>(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:528 public func >>(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:529 public func >>(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:530 public func >>(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:530 public func >>(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:531 public func >>(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:532 public func >>(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:533 public func >>(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:533 public func >>(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:534 public func >>(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:535 public func >>(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:536 public func >>(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:536 public func >>(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:537 public func >>(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:538 public func >>(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:539 public func ^(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:539 public func ^(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:540 public func ^(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:541 public func ^(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:542 public func ^(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:542 public func ^(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:543 public func ^(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:544 public func ^(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:545 public func ^(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:545 public func ^(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:546 public func ^(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:547 public func ^(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:548 public func ^(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:548 public func ^(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:549 public func ^(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:550 public func ^(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:551 public func ^(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:551 public func ^(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:552 public func ^(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:553 public func ^(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:554 public func ^(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:554 public func ^(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:555 public func ^(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:556 public func ^(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:557 public func ^(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:557 public func ^(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:558 public func ^(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:559 public func ^(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:560 public func ^(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:560 public func ^(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:561 public func ^(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:562 public func ^(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:563 public func ^(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:563 public func ^(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:564 public func ^(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:565 public func ^(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:566 public func ^(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:566 public func ^(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:567 public func ^(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:568 public func ^(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:569 public func &(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:569 public func &(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:570 public func &(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:571 public func &(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:572 public func &(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:572 public func &(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:573 public func &(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:574 public func &(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:575 public func &(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:575 public func &(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:576 public func &(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:577 public func &(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:578 public func &(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:578 public func &(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:579 public func &(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:580 public func &(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:581 public func &(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:581 public func &(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:582 public func &(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:583 public func &(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:584 public func &(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:584 public func &(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:585 public func &(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:586 public func &(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:587 public func &(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:587 public func &(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:588 public func &(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:589 public func &(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:590 public func &(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:590 public func &(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:591 public func &(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:592 public func &(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:593 public func &(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:593 public func &(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:594 public func &(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:595 public func &(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:596 public func &(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:596 public func &(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:597 public func &(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:598 public func &(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:599 public func &+(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:599 public func &+(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:600 public func &+(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:601 public func &+(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:602 public func &+(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:602 public func &+(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:603 public func &+(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:604 public func &+(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:605 public func &+(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:605 public func &+(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:606 public func &+(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:607 public func &+(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:608 public func &+(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:608 public func &+(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:609 public func &+(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:610 public func &+(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:611 public func &+(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:611 public func &+(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:612 public func &+(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:613 public func &+(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:614 public func &+(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:614 public func &+(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:615 public func &+(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:616 public func &+(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:617 public func &+(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:617 public func &+(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:618 public func &+(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:619 public func &+(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:620 public func &+(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:620 public func &+(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:621 public func &+(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:622 public func &+(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:623 public func &+(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:623 public func &+(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:624 public func &+(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:625 public func &+(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:626 public func &+(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:626 public func &+(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:627 public func &+(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:628 public func &+(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:629 public func &-(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:629 public func &-(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:630 public func &-(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:631 public func &-(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:632 public func &-(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:632 public func &-(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:633 public func &-(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:634 public func &-(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:635 public func &-(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:635 public func &-(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:636 public func &-(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:637 public func &-(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:638 public func &-(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:638 public func &-(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:639 public func &-(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:640 public func &-(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:641 public func &-(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:641 public func &-(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:642 public func &-(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:643 public func &-(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:644 public func &-(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:644 public func &-(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:645 public func &-(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:646 public func &-(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:647 public func &-(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:647 public func &-(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:648 public func &-(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:649 public func &-(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:650 public func &-(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:650 public func &-(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:651 public func &-(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:652 public func &-(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:653 public func &-(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:653 public func &-(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:654 public func &-(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:655 public func &-(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:656 public func &-(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:656 public func &-(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:657 public func &-(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:658 public func &-(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:659 public func &*(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:659 public func &*(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:660 public func &*(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:661 public func &*(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:662 public func &*(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:662 public func &*(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:663 public func &*(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:664 public func &*(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:665 public func &*(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:665 public func &*(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:666 public func &*(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:667 public func &*(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:668 public func &*(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:668 public func &*(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:669 public func &*(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:670 public func &*(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:671 public func &*(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:671 public func &*(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:672 public func &*(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:673 public func &*(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:674 public func &*(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:674 public func &*(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:675 public func &*(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:676 public func &*(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:677 public func &*(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:677 public func &*(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:678 public func &*(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:679 public func &*(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:680 public func &*(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:680 public func &*(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:681 public func &*(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:682 public func &*(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:683 public func &*(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:683 public func &*(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:684 public func &*(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:685 public func &*(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:686 public func &*(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:686 public func &*(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:687 public func &*(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:688 public func &*(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:689 public func +(lhs: StringA, rhs: StringA) -> StringA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:689 public func +(lhs: StringA, rhs: StringA) -> StringA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:690 public func +(lhs: String, rhs: StringA) -> StringA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:691 public func +(lhs: StringA, rhs: String) -> StringA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:692 public prefix func ++(x: IntA) -> IntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:692 public prefix func ++(x: IntA) -> IntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:693 public prefix func ++(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:693 public prefix func ++(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:694 public prefix func ++(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:694 public prefix func ++(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:695 public prefix func ++(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:695 public prefix func ++(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:696 public prefix func ++(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:696 public prefix func ++(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:697 public prefix func ++(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:697 public prefix func ++(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:698 public prefix func ++(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:698 public prefix func ++(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:699 public prefix func ++(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:699 public prefix func ++(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:700 public prefix func ++(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:700 public prefix func ++(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:701 public prefix func ++(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:701 public prefix func ++(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:702 public prefix func ++(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:702 public prefix func ++(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:703 public prefix func ++(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:703 public prefix func ++(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:704 public prefix func --(x: IntA) -> IntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:704 public prefix func --(x: IntA) -> IntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:705 public prefix func --(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:705 public prefix func --(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:706 public prefix func --(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:706 public prefix func --(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:707 public prefix func --(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:707 public prefix func --(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:708 public prefix func --(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:708 public prefix func --(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:709 public prefix func --(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:709 public prefix func --(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:710 public prefix func --(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:710 public prefix func --(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:711 public prefix func --(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:711 public prefix func --(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:712 public prefix func --(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:712 public prefix func --(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:713 public prefix func --(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:713 public prefix func --(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:714 public prefix func --(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:714 public prefix func --(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:715 public prefix func --(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:715 public prefix func --(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:716 public prefix func +(x: IntA) -> IntA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:717 public prefix func +(x: Int64A) -> Int64A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:718 public prefix func +(x: Int32A) -> Int32A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:719 public prefix func +(x: Int16A) -> Int16A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:720 public prefix func +(x: Int8A) -> Int8A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:721 public prefix func +(x: DoubleA) -> DoubleA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:722 public prefix func +(x: FloatA) -> FloatA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:723 public prefix func -(x: IntA) -> IntA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:724 public prefix func -(x: Int64A) -> Int64A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:725 public prefix func -(x: Int32A) -> Int32A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:726 public prefix func -(x: Int16A) -> Int16A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:727 public prefix func -(x: Int8A) -> Int8A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:728 public prefix func -(x: DoubleA) -> DoubleA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:729 public prefix func -(x: FloatA) -> FloatA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:730 public prefix func ~(x: IntA) -> IntA { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:731 public prefix func ~(x: Int64A) -> Int64A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:732 public prefix func ~(x: Int32A) -> Int32A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:733 public prefix func ~(x: Int16A) -> Int16A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:734 public prefix func ~(x: Int8A) -> Int8A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:735 public postfix func ++(x: IntA) -> IntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:735 public postfix func ++(x: IntA) -> IntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:736 public postfix func ++(x: Int64A) -> Int64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:736 public postfix func ++(x: Int64A) -> Int64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:737 public postfix func ++(x: Int32A) -> Int32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:737 public postfix func ++(x: Int32A) -> Int32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:738 public postfix func ++(x: Int16A) -> Int16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:738 public postfix func ++(x: Int16A) -> Int16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:739 public postfix func ++(x: Int8A) -> Int8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:739 public postfix func ++(x: Int8A) -> Int8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:740 public postfix func ++(x: UIntA) -> UIntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:740 public postfix func ++(x: UIntA) -> UIntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:741 public postfix func ++(x: UInt64A) -> UInt64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:741 public postfix func ++(x: UInt64A) -> UInt64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:742 public postfix func ++(x: UInt32A) -> UInt32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:742 public postfix func ++(x: UInt32A) -> UInt32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:743 public postfix func ++(x: UInt16A) -> UInt16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:743 public postfix func ++(x: UInt16A) -> UInt16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:744 public postfix func ++(x: UInt8A) -> UInt8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:744 public postfix func ++(x: UInt8A) -> UInt8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:745 public postfix func ++(x: DoubleA) -> DoubleA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:745 public postfix func ++(x: DoubleA) -> DoubleA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:746 public postfix func ++(x: FloatA) -> FloatA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:746 public postfix func ++(x: FloatA) -> FloatA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:747 public postfix func --(x: IntA) -> IntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:747 public postfix func --(x: IntA) -> IntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:748 public postfix func --(x: Int64A) -> Int64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:748 public postfix func --(x: Int64A) -> Int64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:749 public postfix func --(x: Int32A) -> Int32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:749 public postfix func --(x: Int32A) -> Int32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:750 public postfix func --(x: Int16A) -> Int16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:750 public postfix func --(x: Int16A) -> Int16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:751 public postfix func --(x: Int8A) -> Int8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:751 public postfix func --(x: Int8A) -> Int8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:752 public postfix func --(x: UIntA) -> UIntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:752 public postfix func --(x: UIntA) -> UIntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:753 public postfix func --(x: UInt64A) -> UInt64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:753 public postfix func --(x: UInt64A) -> UInt64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:754 public postfix func --(x: UInt32A) -> UInt32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:754 public postfix func --(x: UInt32A) -> UInt32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:755 public postfix func --(x: UInt16A) -> UInt16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:755 public postfix func --(x: UInt16A) -> UInt16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:756 public postfix func --(x: UInt8A) -> UInt8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:756 public postfix func --(x: UInt8A) -> UInt8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:757 public postfix func --(x: DoubleA) -> DoubleA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:757 public postfix func --(x: DoubleA) -> DoubleA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:758 public postfix func --(x: FloatA) -> FloatA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:758 public postfix func --(x: FloatA) -> FloatA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:759 public func +=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:759 public func +=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:760 public func +=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:761 public func +=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:762 public func +=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:762 public func +=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:763 public func +=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:764 public func +=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:765 public func +=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:765 public func +=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:766 public func +=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:767 public func +=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:768 public func +=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:768 public func +=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:769 public func +=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:770 public func +=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:771 public func +=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:771 public func +=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:772 public func +=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:773 public func +=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:774 public func +=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:774 public func +=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:775 public func +=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:776 public func +=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:777 public func +=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:777 public func +=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:778 public func +=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:779 public func +=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:780 public func +=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:780 public func +=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:781 public func +=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:782 public func +=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:783 public func +=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:783 public func +=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:784 public func +=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:785 public func +=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:786 public func +=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:786 public func +=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:787 public func +=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:788 public func +=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:789 public func +=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:789 public func +=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:790 public func +=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:791 public func +=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:792 public func +=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:792 public func +=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:793 public func +=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:794 public func +=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:795 public func -=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:795 public func -=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:796 public func -=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:797 public func -=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:798 public func -=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:798 public func -=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:799 public func -=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:800 public func -=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:801 public func -=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:801 public func -=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:802 public func -=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:803 public func -=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:804 public func -=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:804 public func -=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:805 public func -=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:806 public func -=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:807 public func -=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:807 public func -=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:808 public func -=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:809 public func -=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:810 public func -=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:810 public func -=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:811 public func -=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:812 public func -=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:813 public func -=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:813 public func -=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:814 public func -=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:815 public func -=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:816 public func -=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:816 public func -=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:817 public func -=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:818 public func -=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:819 public func -=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:819 public func -=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:820 public func -=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:821 public func -=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:822 public func -=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:822 public func -=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:823 public func -=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:824 public func -=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:825 public func -=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:825 public func -=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:826 public func -=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:827 public func -=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:828 public func -=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:828 public func -=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:829 public func -=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:830 public func -=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:831 public func *=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:831 public func *=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:832 public func *=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:833 public func *=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:834 public func *=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:834 public func *=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:835 public func *=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:836 public func *=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:837 public func *=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:837 public func *=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:838 public func *=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:839 public func *=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:840 public func *=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:840 public func *=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:841 public func *=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:842 public func *=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:843 public func *=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:843 public func *=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:844 public func *=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:845 public func *=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:846 public func *=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:846 public func *=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:847 public func *=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:848 public func *=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:849 public func *=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:849 public func *=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:850 public func *=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:851 public func *=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:852 public func *=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:852 public func *=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:853 public func *=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:854 public func *=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:855 public func *=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:855 public func *=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:856 public func *=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:857 public func *=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:858 public func *=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:858 public func *=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:859 public func *=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:860 public func *=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:861 public func *=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:861 public func *=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:862 public func *=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:863 public func *=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:864 public func *=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:864 public func *=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:865 public func *=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:866 public func *=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:867 public func /=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:867 public func /=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:868 public func /=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:869 public func /=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:870 public func /=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:870 public func /=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:871 public func /=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:872 public func /=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:873 public func /=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:873 public func /=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:874 public func /=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:875 public func /=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:876 public func /=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:876 public func /=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:877 public func /=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:878 public func /=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:879 public func /=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:879 public func /=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:880 public func /=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:881 public func /=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:882 public func /=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:882 public func /=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:883 public func /=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:884 public func /=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:885 public func /=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:885 public func /=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:886 public func /=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:887 public func /=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:888 public func /=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:888 public func /=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:889 public func /=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:890 public func /=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:891 public func /=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:891 public func /=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:892 public func /=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:893 public func /=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:894 public func /=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:894 public func /=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:895 public func /=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:896 public func /=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:897 public func /=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:897 public func /=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:898 public func /=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:899 public func /=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:900 public func /=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:900 public func /=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:901 public func /=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:902 public func /=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:903 public func %=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:903 public func %=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:904 public func %=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:905 public func %=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:906 public func %=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:906 public func %=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:907 public func %=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:908 public func %=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:909 public func %=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:909 public func %=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:910 public func %=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:911 public func %=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:912 public func %=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:912 public func %=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:913 public func %=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:914 public func %=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:915 public func %=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:915 public func %=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:916 public func %=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:917 public func %=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:918 public func %=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:918 public func %=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:919 public func %=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:920 public func %=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:921 public func %=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:921 public func %=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:922 public func %=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:923 public func %=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:924 public func %=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:924 public func %=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:925 public func %=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:926 public func %=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:927 public func %=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:927 public func %=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:928 public func %=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:929 public func %=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:930 public func %=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:930 public func %=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:931 public func %=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:932 public func %=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:933 public func %=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:933 public func %=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:934 public func %=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:935 public func %=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:936 public func %=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:936 public func %=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:937 public func %=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:938 public func %=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:939 public func +=(lhs: StringA, rhs: StringA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:939 public func +=(lhs: StringA, rhs: StringA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:940 public func +=(inout lhs: String, rhs: StringA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:941 public func +=(lhs: StringA, rhs: String) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:942 public func <<=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:942 public func <<=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:943 public func <<=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:944 public func <<=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:945 public func <<=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:945 public func <<=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:946 public func <<=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:947 public func <<=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:948 public func <<=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:948 public func <<=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:949 public func <<=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:950 public func <<=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:951 public func <<=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:951 public func <<=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:952 public func <<=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:953 public func <<=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:954 public func <<=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:954 public func <<=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:955 public func <<=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:956 public func <<=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:957 public func <<=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:957 public func <<=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:958 public func <<=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:959 public func <<=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:960 public func <<=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:960 public func <<=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:961 public func <<=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:962 public func <<=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:963 public func <<=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:963 public func <<=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:964 public func <<=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:965 public func <<=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:966 public func <<=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:966 public func <<=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:967 public func <<=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:968 public func <<=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:969 public func <<=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:969 public func <<=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:970 public func <<=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:971 public func <<=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:972 public func >>=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:972 public func >>=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:973 public func >>=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:974 public func >>=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:975 public func >>=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:975 public func >>=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:976 public func >>=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:977 public func >>=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:978 public func >>=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:978 public func >>=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:979 public func >>=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:980 public func >>=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:981 public func >>=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:981 public func >>=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:982 public func >>=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:983 public func >>=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:984 public func >>=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:984 public func >>=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:985 public func >>=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:986 public func >>=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:987 public func >>=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:987 public func >>=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:988 public func >>=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:989 public func >>=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:990 public func >>=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:990 public func >>=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:991 public func >>=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:992 public func >>=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:993 public func >>=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:993 public func >>=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:994 public func >>=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:995 public func >>=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:996 public func >>=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:996 public func >>=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:997 public func >>=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:998 public func >>=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:999 public func >>=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:999 public func >>=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:1000 public func >>=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:1001 public func >>=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1002 public func ^=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1002 public func ^=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1003 public func ^=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1004 public func ^=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1005 public func ^=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1005 public func ^=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1006 public func ^=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1007 public func ^=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1008 public func ^=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1008 public func ^=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1009 public func ^=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1010 public func ^=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1011 public func ^=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1011 public func ^=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1012 public func ^=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1013 public func ^=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1014 public func ^=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1014 public func ^=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1015 public func ^=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1016 public func ^=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1017 public func ^=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1017 public func ^=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1018 public func ^=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1019 public func ^=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1020 public func ^=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1020 public func ^=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1021 public func ^=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1022 public func ^=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1023 public func ^=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1023 public func ^=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1024 public func ^=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1025 public func ^=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1026 public func ^=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1026 public func ^=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1027 public func ^=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1028 public func ^=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1029 public func ^=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1029 public func ^=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1030 public func ^=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1031 public func ^=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1032 public func &=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1032 public func &=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1033 public func &=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1034 public func &=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1035 public func &=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1035 public func &=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1036 public func &=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1037 public func &=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1038 public func &=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1038 public func &=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1039 public func &=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1040 public func &=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1041 public func &=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1041 public func &=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1042 public func &=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1043 public func &=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1044 public func &=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1044 public func &=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1045 public func &=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1046 public func &=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1047 public func &=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1047 public func &=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1048 public func &=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1049 public func &=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1050 public func &=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1050 public func &=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1051 public func &=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1052 public func &=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1053 public func &=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1053 public func &=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1054 public func &=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1055 public func &=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1056 public func &=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1056 public func &=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1057 public func &=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1058 public func &=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1059 public func &=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1059 public func &=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1060 public func &=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1061 public func &=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value &= rhs; unlock(lhs) }(_ value : T) { 0036 self.value = value 0037 } 0038 /// Loads the value atomically. 0039 public func load
atomic.swift:107 public prefix func !<T : BooleanType>(x: Atomic<T>) -> Atomic<Bool> { lock(x); let result = !x.value; unlock(x); return Atomic(result) }atomic.swift:299 public func +(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:300 public func +(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:301 public func +(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:302 public func +(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:303 public func +(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:304 public func +(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:305 public func +(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:306 public func +(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:307 public func +(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:308 public func +(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:309 public func +(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:310 public func +(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:311 public func +(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:312 public func +(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:313 public func +(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:314 public func +(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:315 public func +(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:316 public func +(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:317 public func +(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:318 public func +(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:319 public func +(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:320 public func +(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:321 public func +(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:322 public func +(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:323 public func +(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:324 public func +(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:325 public func +(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:326 public func +(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:327 public func +(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:328 public func +(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:329 public func +(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:330 public func +(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:331 public func +(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:332 public func +(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:333 public func +(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:334 public func +(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:335 public func -(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:336 public func -(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:337 public func -(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:338 public func -(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:339 public func -(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:340 public func -(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:341 public func -(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:342 public func -(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:343 public func -(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:344 public func -(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:345 public func -(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:346 public func -(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:347 public func -(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:348 public func -(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:349 public func -(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:350 public func -(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:351 public func -(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:352 public func -(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:353 public func -(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:354 public func -(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:355 public func -(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:356 public func -(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:357 public func -(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:358 public func -(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:359 public func -(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:360 public func -(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:361 public func -(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:362 public func -(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:363 public func -(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:364 public func -(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:365 public func -(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:366 public func -(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:367 public func -(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:368 public func -(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:369 public func -(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:370 public func -(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:371 public func *(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:372 public func *(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:373 public func *(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:374 public func *(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:375 public func *(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:376 public func *(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:377 public func *(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:378 public func *(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:379 public func *(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:380 public func *(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:381 public func *(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:382 public func *(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:383 public func *(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:384 public func *(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:385 public func *(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:386 public func *(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:387 public func *(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:388 public func *(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:389 public func *(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:390 public func *(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:391 public func *(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:392 public func *(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:393 public func *(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:394 public func *(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:395 public func *(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:396 public func *(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:397 public func *(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:398 public func *(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:399 public func *(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:400 public func *(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:401 public func *(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:402 public func *(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:403 public func *(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:404 public func *(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:405 public func *(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:406 public func *(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:407 public func /(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:408 public func /(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:409 public func /(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:410 public func /(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:411 public func /(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:412 public func /(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:413 public func /(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:414 public func /(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:415 public func /(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:416 public func /(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:417 public func /(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:418 public func /(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:419 public func /(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:420 public func /(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:421 public func /(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:422 public func /(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:423 public func /(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:424 public func /(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:425 public func /(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:426 public func /(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:427 public func /(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:428 public func /(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:429 public func /(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:430 public func /(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:431 public func /(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:432 public func /(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:433 public func /(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:434 public func /(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:435 public func /(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:436 public func /(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:437 public func /(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:438 public func /(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:439 public func /(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:440 public func /(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:441 public func /(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:442 public func /(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:443 public func %(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:444 public func %(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:445 public func %(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:446 public func %(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:447 public func %(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:448 public func %(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:449 public func %(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:450 public func %(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:451 public func %(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:452 public func %(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:453 public func %(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:454 public func %(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:455 public func %(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:456 public func %(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:457 public func %(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:458 public func %(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:459 public func %(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:460 public func %(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:461 public func %(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:462 public func %(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:463 public func %(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:464 public func %(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:465 public func %(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:466 public func %(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:467 public func %(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:468 public func %(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:469 public func %(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:470 public func %(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:471 public func %(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:472 public func %(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:473 public func %(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:474 public func %(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:475 public func %(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:476 public func %(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:477 public func %(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:478 public func %(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:479 public func <<(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:480 public func <<(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:481 public func <<(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:482 public func <<(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:483 public func <<(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:484 public func <<(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:485 public func <<(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:486 public func <<(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:487 public func <<(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:488 public func <<(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:489 public func <<(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:490 public func <<(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:491 public func <<(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:492 public func <<(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:493 public func <<(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:494 public func <<(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:495 public func <<(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:496 public func <<(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:497 public func <<(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:498 public func <<(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:499 public func <<(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:500 public func <<(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:501 public func <<(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:502 public func <<(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:503 public func <<(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:504 public func <<(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:505 public func <<(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:506 public func <<(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:507 public func <<(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:508 public func <<(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:509 public func >>(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:510 public func >>(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:511 public func >>(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:512 public func >>(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:513 public func >>(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:514 public func >>(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:515 public func >>(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:516 public func >>(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:517 public func >>(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:518 public func >>(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:519 public func >>(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:520 public func >>(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:521 public func >>(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:522 public func >>(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:523 public func >>(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:524 public func >>(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:525 public func >>(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:526 public func >>(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:527 public func >>(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:528 public func >>(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:529 public func >>(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:530 public func >>(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:531 public func >>(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:532 public func >>(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:533 public func >>(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:534 public func >>(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:535 public func >>(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:536 public func >>(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:537 public func >>(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:538 public func >>(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:539 public func ^(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:540 public func ^(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:541 public func ^(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:542 public func ^(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:543 public func ^(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:544 public func ^(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:545 public func ^(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:546 public func ^(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:547 public func ^(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:548 public func ^(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:549 public func ^(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:550 public func ^(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:551 public func ^(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:552 public func ^(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:553 public func ^(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:554 public func ^(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:555 public func ^(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:556 public func ^(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:557 public func ^(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:558 public func ^(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:559 public func ^(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:560 public func ^(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:561 public func ^(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:562 public func ^(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:563 public func ^(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:564 public func ^(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:565 public func ^(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:566 public func ^(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:567 public func ^(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:568 public func ^(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:569 public func &(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:570 public func &(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:571 public func &(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:572 public func &(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:573 public func &(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:574 public func &(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:575 public func &(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:576 public func &(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:577 public func &(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:578 public func &(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:579 public func &(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:580 public func &(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:581 public func &(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:582 public func &(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:583 public func &(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:584 public func &(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:585 public func &(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:586 public func &(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:587 public func &(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:588 public func &(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:589 public func &(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:590 public func &(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:591 public func &(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:592 public func &(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:593 public func &(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:594 public func &(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:595 public func &(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:596 public func &(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:597 public func &(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:598 public func &(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:599 public func &+(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:600 public func &+(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:601 public func &+(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:602 public func &+(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:603 public func &+(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:604 public func &+(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:605 public func &+(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:606 public func &+(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:607 public func &+(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:608 public func &+(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:609 public func &+(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:610 public func &+(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:611 public func &+(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:612 public func &+(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:613 public func &+(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:614 public func &+(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:615 public func &+(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:616 public func &+(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:617 public func &+(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:618 public func &+(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:619 public func &+(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:620 public func &+(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:621 public func &+(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:622 public func &+(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:623 public func &+(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:624 public func &+(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:625 public func &+(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:626 public func &+(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:627 public func &+(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:628 public func &+(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:629 public func &-(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:630 public func &-(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:631 public func &-(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:632 public func &-(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:633 public func &-(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:634 public func &-(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:635 public func &-(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:636 public func &-(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:637 public func &-(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:638 public func &-(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:639 public func &-(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:640 public func &-(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:641 public func &-(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:642 public func &-(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:643 public func &-(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:644 public func &-(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:645 public func &-(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:646 public func &-(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:647 public func &-(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:648 public func &-(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:649 public func &-(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:650 public func &-(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:651 public func &-(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:652 public func &-(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:653 public func &-(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:654 public func &-(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:655 public func &-(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:656 public func &-(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:657 public func &-(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:658 public func &-(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:659 public func &*(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:660 public func &*(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:661 public func &*(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:662 public func &*(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:663 public func &*(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:664 public func &*(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:665 public func &*(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:666 public func &*(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:667 public func &*(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:668 public func &*(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:669 public func &*(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:670 public func &*(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:671 public func &*(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:672 public func &*(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:673 public func &*(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:674 public func &*(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:675 public func &*(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:676 public func &*(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:677 public func &*(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:678 public func &*(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:679 public func &*(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:680 public func &*(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:681 public func &*(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:682 public func &*(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:683 public func &*(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:684 public func &*(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:685 public func &*(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:686 public func &*(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:687 public func &*(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:688 public func &*(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:689 public func +(lhs: StringA, rhs: StringA) -> StringA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:690 public func +(lhs: String, rhs: StringA) -> StringA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:691 public func +(lhs: StringA, rhs: String) -> StringA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:692 public prefix func ++(x: IntA) -> IntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:693 public prefix func ++(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:694 public prefix func ++(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:695 public prefix func ++(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:696 public prefix func ++(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:697 public prefix func ++(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:698 public prefix func ++(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:699 public prefix func ++(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:700 public prefix func ++(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:701 public prefix func ++(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:702 public prefix func ++(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:703 public prefix func ++(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:704 public prefix func --(x: IntA) -> IntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:705 public prefix func --(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:706 public prefix func --(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:707 public prefix func --(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:708 public prefix func --(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:709 public prefix func --(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:710 public prefix func --(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:711 public prefix func --(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:712 public prefix func --(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:713 public prefix func --(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:714 public prefix func --(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:715 public prefix func --(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:716 public prefix func +(x: IntA) -> IntA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:717 public prefix func +(x: Int64A) -> Int64A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:718 public prefix func +(x: Int32A) -> Int32A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:719 public prefix func +(x: Int16A) -> Int16A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:720 public prefix func +(x: Int8A) -> Int8A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:721 public prefix func +(x: DoubleA) -> DoubleA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:722 public prefix func +(x: FloatA) -> FloatA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:723 public prefix func -(x: IntA) -> IntA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:724 public prefix func -(x: Int64A) -> Int64A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:725 public prefix func -(x: Int32A) -> Int32A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:726 public prefix func -(x: Int16A) -> Int16A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:727 public prefix func -(x: Int8A) -> Int8A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:728 public prefix func -(x: DoubleA) -> DoubleA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:729 public prefix func -(x: FloatA) -> FloatA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:730 public prefix func ~(x: IntA) -> IntA { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:731 public prefix func ~(x: Int64A) -> Int64A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:732 public prefix func ~(x: Int32A) -> Int32A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:733 public prefix func ~(x: Int16A) -> Int16A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:734 public prefix func ~(x: Int8A) -> Int8A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:735 public postfix func ++(x: IntA) -> IntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:736 public postfix func ++(x: Int64A) -> Int64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:737 public postfix func ++(x: Int32A) -> Int32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:738 public postfix func ++(x: Int16A) -> Int16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:739 public postfix func ++(x: Int8A) -> Int8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:740 public postfix func ++(x: UIntA) -> UIntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:741 public postfix func ++(x: UInt64A) -> UInt64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:742 public postfix func ++(x: UInt32A) -> UInt32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:743 public postfix func ++(x: UInt16A) -> UInt16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:744 public postfix func ++(x: UInt8A) -> UInt8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:745 public postfix func ++(x: DoubleA) -> DoubleA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:746 public postfix func ++(x: FloatA) -> FloatA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:747 public postfix func --(x: IntA) -> IntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:748 public postfix func --(x: Int64A) -> Int64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:749 public postfix func --(x: Int32A) -> Int32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:750 public postfix func --(x: Int16A) -> Int16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:751 public postfix func --(x: Int8A) -> Int8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:752 public postfix func --(x: UIntA) -> UIntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:753 public postfix func --(x: UInt64A) -> UInt64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:754 public postfix func --(x: UInt32A) -> UInt32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:755 public postfix func --(x: UInt16A) -> UInt16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:756 public postfix func --(x: UInt8A) -> UInt8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:757 public postfix func --(x: DoubleA) -> DoubleA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:758 public postfix func --(x: FloatA) -> FloatA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }() -> T { 0040 mutex.lock() 0041 defer { mutex.unlock() } 0042 return value 0043 } 0044 /// Stores a value atomically. 0045 public func store(value : T) { 0046 mutex.lock() 0047 defer { mutex.unlock() } 0048 self.value = value 0049 } 0050 /// Exchanges / Swaps values atomically. 0051 public func exchange(atomic : Atomic<T>) { 0052 atomic.mutex.lock() 0053 defer { atomic.mutex.unlock() } 0054 mutex.lock() 0055 defer { mutex.unlock() } 0056 let temp = value 0057 value = atomic.value 0058 atomic.value = temp 0059 } 0060 public var description : String { 0061 mutex.lock() 0062 defer { mutex.unlock() } 0063 return "\(value)" 0064 } 0065 } 0066 0067 @inline(__always) private func lock
atomic.swift:125 public init (_ atomic : IntA){ self = Int(atomic.load()) }atomic.swift:126 public init (_ atomic : Int64A){ self = Int(atomic.load()) }atomic.swift:127 public init (_ atomic : Int32A){ self = Int(atomic.load()) }atomic.swift:128 public init (_ atomic : Int16A){ self = Int(atomic.load()) }atomic.swift:129 public init (_ atomic : Int8A){ self = Int(atomic.load()) }atomic.swift:130 public init (_ atomic : UIntA){ self = Int(atomic.load()) }atomic.swift:131 public init (_ atomic : UInt64A){ self = Int(atomic.load()) }atomic.swift:132 public init (_ atomic : UInt32A){ self = Int(atomic.load()) }atomic.swift:133 public init (_ atomic : UInt16A){ self = Int(atomic.load()) }atomic.swift:134 public init (_ atomic : UInt8A){ self = Int(atomic.load()) }atomic.swift:135 public init (_ atomic : DoubleA){ self = Int(atomic.load()) }atomic.swift:136 public init (_ atomic : FloatA){ self = Int(atomic.load()) }atomic.swift:139 public init (_ atomic : Int64A){ self = Int64(atomic.load()) }atomic.swift:140 public init (_ atomic : IntA){ self = Int64(atomic.load()) }atomic.swift:141 public init (_ atomic : Int32A){ self = Int64(atomic.load()) }atomic.swift:142 public init (_ atomic : Int16A){ self = Int64(atomic.load()) }atomic.swift:143 public init (_ atomic : Int8A){ self = Int64(atomic.load()) }atomic.swift:144 public init (_ atomic : UIntA){ self = Int64(atomic.load()) }atomic.swift:145 public init (_ atomic : UInt64A){ self = Int64(atomic.load()) }atomic.swift:146 public init (_ atomic : UInt32A){ self = Int64(atomic.load()) }atomic.swift:147 public init (_ atomic : UInt16A){ self = Int64(atomic.load()) }atomic.swift:148 public init (_ atomic : UInt8A){ self = Int64(atomic.load()) }atomic.swift:149 public init (_ atomic : DoubleA){ self = Int64(atomic.load()) }atomic.swift:150 public init (_ atomic : FloatA){ self = Int64(atomic.load()) }atomic.swift:153 public init (_ atomic : Int32A){ self = Int32(atomic.load()) }atomic.swift:154 public init (_ atomic : IntA){ self = Int32(atomic.load()) }atomic.swift:155 public init (_ atomic : Int64A){ self = Int32(atomic.load()) }atomic.swift:156 public init (_ atomic : Int16A){ self = Int32(atomic.load()) }atomic.swift:157 public init (_ atomic : Int8A){ self = Int32(atomic.load()) }atomic.swift:158 public init (_ atomic : UIntA){ self = Int32(atomic.load()) }atomic.swift:159 public init (_ atomic : UInt64A){ self = Int32(atomic.load()) }atomic.swift:160 public init (_ atomic : UInt32A){ self = Int32(atomic.load()) }atomic.swift:161 public init (_ atomic : UInt16A){ self = Int32(atomic.load()) }atomic.swift:162 public init (_ atomic : UInt8A){ self = Int32(atomic.load()) }atomic.swift:163 public init (_ atomic : DoubleA){ self = Int32(atomic.load()) }atomic.swift:164 public init (_ atomic : FloatA){ self = Int32(atomic.load()) }atomic.swift:167 public init (_ atomic : Int16A){ self = Int16(atomic.load()) }atomic.swift:168 public init (_ atomic : IntA){ self = Int16(atomic.load()) }atomic.swift:169 public init (_ atomic : Int64A){ self = Int16(atomic.load()) }atomic.swift:170 public init (_ atomic : Int32A){ self = Int16(atomic.load()) }atomic.swift:171 public init (_ atomic : Int8A){ self = Int16(atomic.load()) }atomic.swift:172 public init (_ atomic : UIntA){ self = Int16(atomic.load()) }atomic.swift:173 public init (_ atomic : UInt64A){ self = Int16(atomic.load()) }atomic.swift:174 public init (_ atomic : UInt32A){ self = Int16(atomic.load()) }atomic.swift:175 public init (_ atomic : UInt16A){ self = Int16(atomic.load()) }atomic.swift:176 public init (_ atomic : UInt8A){ self = Int16(atomic.load()) }atomic.swift:177 public init (_ atomic : DoubleA){ self = Int16(atomic.load()) }atomic.swift:178 public init (_ atomic : FloatA){ self = Int16(atomic.load()) }atomic.swift:181 public init (_ atomic : Int8A){ self = Int8(atomic.load()) }atomic.swift:182 public init (_ atomic : IntA){ self = Int8(atomic.load()) }atomic.swift:183 public init (_ atomic : Int64A){ self = Int8(atomic.load()) }atomic.swift:184 public init (_ atomic : Int32A){ self = Int8(atomic.load()) }atomic.swift:185 public init (_ atomic : Int16A){ self = Int8(atomic.load()) }atomic.swift:186 public init (_ atomic : UIntA){ self = Int8(atomic.load()) }atomic.swift:187 public init (_ atomic : UInt64A){ self = Int8(atomic.load()) }atomic.swift:188 public init (_ atomic : UInt32A){ self = Int8(atomic.load()) }atomic.swift:189 public init (_ atomic : UInt16A){ self = Int8(atomic.load()) }atomic.swift:190 public init (_ atomic : UInt8A){ self = Int8(atomic.load()) }atomic.swift:191 public init (_ atomic : DoubleA){ self = Int8(atomic.load()) }atomic.swift:192 public init (_ atomic : FloatA){ self = Int8(atomic.load()) }atomic.swift:195 public init (_ atomic : UIntA){ self = UInt(atomic.load()) }atomic.swift:196 public init (_ atomic : IntA){ self = UInt(atomic.load()) }atomic.swift:197 public init (_ atomic : Int64A){ self = UInt(atomic.load()) }atomic.swift:198 public init (_ atomic : Int32A){ self = UInt(atomic.load()) }atomic.swift:199 public init (_ atomic : Int16A){ self = UInt(atomic.load()) }atomic.swift:200 public init (_ atomic : Int8A){ self = UInt(atomic.load()) }atomic.swift:201 public init (_ atomic : UInt64A){ self = UInt(atomic.load()) }atomic.swift:202 public init (_ atomic : UInt32A){ self = UInt(atomic.load()) }atomic.swift:203 public init (_ atomic : UInt16A){ self = UInt(atomic.load()) }atomic.swift:204 public init (_ atomic : UInt8A){ self = UInt(atomic.load()) }atomic.swift:205 public init (_ atomic : DoubleA){ self = UInt(atomic.load()) }atomic.swift:206 public init (_ atomic : FloatA){ self = UInt(atomic.load()) }atomic.swift:209 public init (_ atomic : UInt64A){ self = UInt64(atomic.load()) }atomic.swift:210 public init (_ atomic : IntA){ self = UInt64(atomic.load()) }atomic.swift:211 public init (_ atomic : Int64A){ self = UInt64(atomic.load()) }atomic.swift:212 public init (_ atomic : Int32A){ self = UInt64(atomic.load()) }atomic.swift:213 public init (_ atomic : Int16A){ self = UInt64(atomic.load()) }atomic.swift:214 public init (_ atomic : Int8A){ self = UInt64(atomic.load()) }atomic.swift:215 public init (_ atomic : UIntA){ self = UInt64(atomic.load()) }atomic.swift:216 public init (_ atomic : UInt32A){ self = UInt64(atomic.load()) }atomic.swift:217 public init (_ atomic : UInt16A){ self = UInt64(atomic.load()) }atomic.swift:218 public init (_ atomic : UInt8A){ self = UInt64(atomic.load()) }atomic.swift:219 public init (_ atomic : DoubleA){ self = UInt64(atomic.load()) }atomic.swift:220 public init (_ atomic : FloatA){ self = UInt64(atomic.load()) }atomic.swift:223 public init (_ atomic : UInt32A){ self = UInt32(atomic.load()) }atomic.swift:224 public init (_ atomic : IntA){ self = UInt32(atomic.load()) }atomic.swift:225 public init (_ atomic : Int64A){ self = UInt32(atomic.load()) }atomic.swift:226 public init (_ atomic : Int32A){ self = UInt32(atomic.load()) }atomic.swift:227 public init (_ atomic : Int16A){ self = UInt32(atomic.load()) }atomic.swift:228 public init (_ atomic : Int8A){ self = UInt32(atomic.load()) }atomic.swift:229 public init (_ atomic : UIntA){ self = UInt32(atomic.load()) }atomic.swift:230 public init (_ atomic : UInt64A){ self = UInt32(atomic.load()) }atomic.swift:231 public init (_ atomic : UInt16A){ self = UInt32(atomic.load()) }atomic.swift:232 public init (_ atomic : UInt8A){ self = UInt32(atomic.load()) }atomic.swift:233 public init (_ atomic : DoubleA){ self = UInt32(atomic.load()) }atomic.swift:234 public init (_ atomic : FloatA){ self = UInt32(atomic.load()) }atomic.swift:237 public init (_ atomic : UInt16A){ self = UInt16(atomic.load()) }atomic.swift:238 public init (_ atomic : IntA){ self = UInt16(atomic.load()) }atomic.swift:239 public init (_ atomic : Int64A){ self = UInt16(atomic.load()) }atomic.swift:240 public init (_ atomic : Int32A){ self = UInt16(atomic.load()) }atomic.swift:241 public init (_ atomic : Int16A){ self = UInt16(atomic.load()) }atomic.swift:242 public init (_ atomic : Int8A){ self = UInt16(atomic.load()) }atomic.swift:243 public init (_ atomic : UIntA){ self = UInt16(atomic.load()) }atomic.swift:244 public init (_ atomic : UInt64A){ self = UInt16(atomic.load()) }atomic.swift:245 public init (_ atomic : UInt32A){ self = UInt16(atomic.load()) }atomic.swift:246 public init (_ atomic : UInt8A){ self = UInt16(atomic.load()) }atomic.swift:247 public init (_ atomic : DoubleA){ self = UInt16(atomic.load()) }atomic.swift:248 public init (_ atomic : FloatA){ self = UInt16(atomic.load()) }atomic.swift:251 public init (_ atomic : UInt8A){ self = UInt8(atomic.load()) }atomic.swift:252 public init (_ atomic : IntA){ self = UInt8(atomic.load()) }atomic.swift:253 public init (_ atomic : Int64A){ self = UInt8(atomic.load()) }atomic.swift:254 public init (_ atomic : Int32A){ self = UInt8(atomic.load()) }atomic.swift:255 public init (_ atomic : Int16A){ self = UInt8(atomic.load()) }atomic.swift:256 public init (_ atomic : Int8A){ self = UInt8(atomic.load()) }atomic.swift:257 public init (_ atomic : UIntA){ self = UInt8(atomic.load()) }atomic.swift:258 public init (_ atomic : UInt64A){ self = UInt8(atomic.load()) }atomic.swift:259 public init (_ atomic : UInt32A){ self = UInt8(atomic.load()) }atomic.swift:260 public init (_ atomic : UInt16A){ self = UInt8(atomic.load()) }atomic.swift:261 public init (_ atomic : DoubleA){ self = UInt8(atomic.load()) }atomic.swift:262 public init (_ atomic : FloatA){ self = UInt8(atomic.load()) }atomic.swift:265 public init (_ atomic : DoubleA){ self = Double(atomic.load()) }atomic.swift:266 public init (_ atomic : IntA){ self = Double(atomic.load()) }atomic.swift:267 public init (_ atomic : Int64A){ self = Double(atomic.load()) }atomic.swift:268 public init (_ atomic : Int32A){ self = Double(atomic.load()) }atomic.swift:269 public init (_ atomic : Int16A){ self = Double(atomic.load()) }atomic.swift:270 public init (_ atomic : Int8A){ self = Double(atomic.load()) }atomic.swift:271 public init (_ atomic : UIntA){ self = Double(atomic.load()) }atomic.swift:272 public init (_ atomic : UInt64A){ self = Double(atomic.load()) }atomic.swift:273 public init (_ atomic : UInt32A){ self = Double(atomic.load()) }atomic.swift:274 public init (_ atomic : UInt16A){ self = Double(atomic.load()) }atomic.swift:275 public init (_ atomic : UInt8A){ self = Double(atomic.load()) }atomic.swift:276 public init (_ atomic : FloatA){ self = Double(atomic.load()) }atomic.swift:279 public init (_ atomic : FloatA){ self = Float(atomic.load()) }atomic.swift:280 public init (_ atomic : IntA){ self = Float(atomic.load()) }atomic.swift:281 public init (_ atomic : Int64A){ self = Float(atomic.load()) }atomic.swift:282 public init (_ atomic : Int32A){ self = Float(atomic.load()) }atomic.swift:283 public init (_ atomic : Int16A){ self = Float(atomic.load()) }atomic.swift:284 public init (_ atomic : Int8A){ self = Float(atomic.load()) }atomic.swift:285 public init (_ atomic : UIntA){ self = Float(atomic.load()) }atomic.swift:286 public init (_ atomic : UInt64A){ self = Float(atomic.load()) }atomic.swift:287 public init (_ atomic : UInt32A){ self = Float(atomic.load()) }atomic.swift:288 public init (_ atomic : UInt16A){ self = Float(atomic.load()) }atomic.swift:289 public init (_ atomic : UInt8A){ self = Float(atomic.load()) }atomic.swift:290 public init (_ atomic : DoubleA){ self = Float(atomic.load()) }atomic.swift:293 public init (_ atomic : BoolA){ self = Bool(atomic.load()) }atomic.swift:296 public init (_ atomic : StringA){ self = String(atomic.load()) }<T>(lhs: Atomic<T>, _ rhs: Atomic<T>){ 0068 lhs.mutex.lock() 0069 if lhs !== rhs { rhs.mutex.lock() } 0070 } 0071 @inline(__always) private func lock
atomic.swift:83 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value == rhs.value; unlock(lhs, rhs); return result }atomic.swift:86 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value != rhs.value; unlock(lhs, rhs); return result }atomic.swift:89 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value && rhs.value; unlock(lhs, rhs); return result }atomic.swift:92 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value || rhs.value; unlock(lhs, rhs); return result }atomic.swift:95 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value <= rhs.value; unlock(lhs, rhs); return result }atomic.swift:98 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value >= rhs.value; unlock(lhs, rhs); return result }atomic.swift:101 public func ><T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value > rhs.value; unlock(lhs, rhs); return result }atomic.swift:104 public func <<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value < rhs.value; unlock(lhs, rhs); return result }atomic.swift:299 public func +(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:302 public func +(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:305 public func +(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:308 public func +(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:311 public func +(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:314 public func +(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:317 public func +(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:320 public func +(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:323 public func +(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:326 public func +(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:329 public func +(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:332 public func +(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:335 public func -(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:338 public func -(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:341 public func -(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:344 public func -(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:347 public func -(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:350 public func -(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:353 public func -(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:356 public func -(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:359 public func -(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:362 public func -(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:365 public func -(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:368 public func -(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:371 public func *(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:374 public func *(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:377 public func *(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:380 public func *(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:383 public func *(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:386 public func *(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:389 public func *(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:392 public func *(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:395 public func *(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:398 public func *(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:401 public func *(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:404 public func *(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:407 public func /(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:410 public func /(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:413 public func /(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:416 public func /(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:419 public func /(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:422 public func /(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:425 public func /(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:428 public func /(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:431 public func /(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:434 public func /(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:437 public func /(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:440 public func /(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:443 public func %(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:446 public func %(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:449 public func %(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:452 public func %(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:455 public func %(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:458 public func %(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:461 public func %(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:464 public func %(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:467 public func %(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:470 public func %(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:473 public func %(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:476 public func %(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:479 public func <<(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:482 public func <<(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:485 public func <<(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:488 public func <<(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:491 public func <<(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:494 public func <<(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:497 public func <<(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:500 public func <<(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:503 public func <<(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:506 public func <<(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:509 public func >>(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:512 public func >>(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:515 public func >>(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:518 public func >>(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:521 public func >>(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:524 public func >>(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:527 public func >>(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:530 public func >>(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:533 public func >>(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:536 public func >>(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:539 public func ^(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:542 public func ^(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:545 public func ^(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:548 public func ^(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:551 public func ^(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:554 public func ^(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:557 public func ^(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:560 public func ^(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:563 public func ^(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:566 public func ^(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:569 public func &(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:572 public func &(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:575 public func &(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:578 public func &(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:581 public func &(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:584 public func &(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:587 public func &(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:590 public func &(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:593 public func &(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:596 public func &(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:599 public func &+(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:602 public func &+(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:605 public func &+(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:608 public func &+(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:611 public func &+(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:614 public func &+(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:617 public func &+(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:620 public func &+(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:623 public func &+(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:626 public func &+(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:629 public func &-(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:632 public func &-(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:635 public func &-(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:638 public func &-(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:641 public func &-(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:644 public func &-(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:647 public func &-(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:650 public func &-(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:653 public func &-(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:656 public func &-(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:659 public func &*(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:662 public func &*(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:665 public func &*(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:668 public func &*(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:671 public func &*(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:674 public func &*(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:677 public func &*(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:680 public func &*(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:683 public func &*(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:686 public func &*(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:689 public func +(lhs: StringA, rhs: StringA) -> StringA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:759 public func +=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:762 public func +=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:765 public func +=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:768 public func +=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:771 public func +=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:774 public func +=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:777 public func +=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:780 public func +=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:783 public func +=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:786 public func +=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:789 public func +=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:792 public func +=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:795 public func -=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:798 public func -=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:801 public func -=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:804 public func -=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:807 public func -=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:810 public func -=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:813 public func -=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:816 public func -=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:819 public func -=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:822 public func -=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:825 public func -=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:828 public func -=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:831 public func *=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:834 public func *=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:837 public func *=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:840 public func *=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:843 public func *=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:846 public func *=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:849 public func *=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:852 public func *=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:855 public func *=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:858 public func *=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:861 public func *=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:864 public func *=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:867 public func /=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:870 public func /=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:873 public func /=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:876 public func /=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:879 public func /=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:882 public func /=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:885 public func /=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:888 public func /=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:891 public func /=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:894 public func /=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:897 public func /=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:900 public func /=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:903 public func %=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:906 public func %=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:909 public func %=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:912 public func %=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:915 public func %=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:918 public func %=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:921 public func %=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:924 public func %=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:927 public func %=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:930 public func %=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:933 public func %=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:936 public func %=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:939 public func +=(lhs: StringA, rhs: StringA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:942 public func <<=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:945 public func <<=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:948 public func <<=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:951 public func <<=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:954 public func <<=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:957 public func <<=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:960 public func <<=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:963 public func <<=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:966 public func <<=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:969 public func <<=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:972 public func >>=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:975 public func >>=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:978 public func >>=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:981 public func >>=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:984 public func >>=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:987 public func >>=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:990 public func >>=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:993 public func >>=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:996 public func >>=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:999 public func >>=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:1002 public func ^=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1005 public func ^=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1008 public func ^=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1011 public func ^=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1014 public func ^=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1017 public func ^=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1020 public func ^=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1023 public func ^=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1026 public func ^=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1029 public func ^=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1032 public func &=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1035 public func &=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1038 public func &=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1041 public func &=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1044 public func &=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1047 public func &=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1050 public func &=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1053 public func &=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1056 public func &=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1059 public func &=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }<T>(lhs: Atomic<T>){ 0072 lhs.mutex.lock() 0073 } 0074 @inline(__always) private func unlock
atomic.swift:84 public func ==<T : Equatable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs == rhs.value; unlock(rhs); return result }atomic.swift:85 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value == rhs; unlock(lhs); return result }atomic.swift:87 public func !=<T : Equatable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs != rhs.value; unlock(rhs); return result }atomic.swift:88 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value != rhs; unlock(lhs); return result }atomic.swift:90 public func &&<T : BooleanType>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs && rhs.value; unlock(rhs); return result }atomic.swift:91 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value && rhs; unlock(lhs); return result }atomic.swift:93 public func ||<T : BooleanType>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs || rhs.value; unlock(rhs); return result }atomic.swift:94 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value || rhs; unlock(lhs); return result }atomic.swift:96 public func <=<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs <= rhs.value; unlock(rhs); return result }atomic.swift:97 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value <= rhs; unlock(lhs); return result }atomic.swift:99 public func >=<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs >= rhs.value; unlock(rhs); return result }atomic.swift:100 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value >= rhs; unlock(lhs); return result }atomic.swift:102 public func ><T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs > rhs.value; unlock(rhs); return result }atomic.swift:103 public func ><T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value > rhs; unlock(lhs); return result }atomic.swift:105 public func <<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs < rhs.value; unlock(rhs); return result }atomic.swift:106 public func <<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value < rhs; unlock(lhs); return result }atomic.swift:107 public prefix func !<T : BooleanType>(x: Atomic<T>) -> Atomic<Bool> { lock(x); let result = !x.value; unlock(x); return Atomic(result) }atomic.swift:300 public func +(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:301 public func +(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:303 public func +(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:304 public func +(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:306 public func +(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:307 public func +(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:309 public func +(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:310 public func +(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:312 public func +(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:313 public func +(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:315 public func +(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:316 public func +(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:318 public func +(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:319 public func +(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:321 public func +(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:322 public func +(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:324 public func +(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:325 public func +(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:327 public func +(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:328 public func +(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:330 public func +(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:331 public func +(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:333 public func +(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:334 public func +(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:336 public func -(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:337 public func -(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:339 public func -(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:340 public func -(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:342 public func -(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:343 public func -(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:345 public func -(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:346 public func -(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:348 public func -(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:349 public func -(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:351 public func -(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:352 public func -(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:354 public func -(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:355 public func -(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:357 public func -(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:358 public func -(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:360 public func -(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:361 public func -(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:363 public func -(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:364 public func -(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:366 public func -(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:367 public func -(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:369 public func -(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:370 public func -(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:372 public func *(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:373 public func *(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:375 public func *(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:376 public func *(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:378 public func *(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:379 public func *(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:381 public func *(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:382 public func *(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:384 public func *(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:385 public func *(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:387 public func *(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:388 public func *(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:390 public func *(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:391 public func *(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:393 public func *(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:394 public func *(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:396 public func *(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:397 public func *(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:399 public func *(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:400 public func *(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:402 public func *(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:403 public func *(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:405 public func *(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:406 public func *(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:408 public func /(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:409 public func /(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:411 public func /(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:412 public func /(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:414 public func /(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:415 public func /(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:417 public func /(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:418 public func /(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:420 public func /(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:421 public func /(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:423 public func /(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:424 public func /(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:426 public func /(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:427 public func /(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:429 public func /(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:430 public func /(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:432 public func /(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:433 public func /(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:435 public func /(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:436 public func /(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:438 public func /(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:439 public func /(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:441 public func /(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:442 public func /(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:444 public func %(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:445 public func %(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:447 public func %(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:448 public func %(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:450 public func %(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:451 public func %(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:453 public func %(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:454 public func %(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:456 public func %(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:457 public func %(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:459 public func %(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:460 public func %(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:462 public func %(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:463 public func %(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:465 public func %(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:466 public func %(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:468 public func %(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:469 public func %(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:471 public func %(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:472 public func %(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:474 public func %(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:475 public func %(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:477 public func %(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:478 public func %(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:480 public func <<(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:481 public func <<(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:483 public func <<(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:484 public func <<(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:486 public func <<(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:487 public func <<(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:489 public func <<(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:490 public func <<(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:492 public func <<(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:493 public func <<(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:495 public func <<(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:496 public func <<(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:498 public func <<(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:499 public func <<(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:501 public func <<(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:502 public func <<(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:504 public func <<(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:505 public func <<(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:507 public func <<(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:508 public func <<(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:510 public func >>(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:511 public func >>(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:513 public func >>(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:514 public func >>(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:516 public func >>(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:517 public func >>(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:519 public func >>(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:520 public func >>(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:522 public func >>(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:523 public func >>(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:525 public func >>(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:526 public func >>(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:528 public func >>(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:529 public func >>(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:531 public func >>(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:532 public func >>(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:534 public func >>(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:535 public func >>(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:537 public func >>(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:538 public func >>(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:540 public func ^(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:541 public func ^(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:543 public func ^(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:544 public func ^(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:546 public func ^(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:547 public func ^(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:549 public func ^(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:550 public func ^(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:552 public func ^(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:553 public func ^(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:555 public func ^(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:556 public func ^(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:558 public func ^(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:559 public func ^(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:561 public func ^(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:562 public func ^(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:564 public func ^(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:565 public func ^(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:567 public func ^(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:568 public func ^(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:570 public func &(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:571 public func &(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:573 public func &(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:574 public func &(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:576 public func &(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:577 public func &(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:579 public func &(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:580 public func &(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:582 public func &(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:583 public func &(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:585 public func &(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:586 public func &(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:588 public func &(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:589 public func &(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:591 public func &(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:592 public func &(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:594 public func &(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:595 public func &(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:597 public func &(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:598 public func &(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:600 public func &+(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:601 public func &+(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:603 public func &+(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:604 public func &+(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:606 public func &+(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:607 public func &+(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:609 public func &+(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:610 public func &+(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:612 public func &+(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:613 public func &+(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:615 public func &+(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:616 public func &+(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:618 public func &+(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:619 public func &+(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:621 public func &+(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:622 public func &+(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:624 public func &+(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:625 public func &+(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:627 public func &+(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:628 public func &+(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:630 public func &-(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:631 public func &-(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:633 public func &-(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:634 public func &-(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:636 public func &-(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:637 public func &-(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:639 public func &-(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:640 public func &-(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:642 public func &-(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:643 public func &-(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:645 public func &-(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:646 public func &-(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:648 public func &-(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:649 public func &-(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:651 public func &-(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:652 public func &-(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:654 public func &-(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:655 public func &-(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:657 public func &-(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:658 public func &-(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:660 public func &*(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:661 public func &*(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:663 public func &*(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:664 public func &*(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:666 public func &*(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:667 public func &*(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:669 public func &*(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:670 public func &*(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:672 public func &*(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:673 public func &*(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:675 public func &*(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:676 public func &*(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:678 public func &*(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:679 public func &*(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:681 public func &*(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:682 public func &*(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:684 public func &*(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:685 public func &*(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:687 public func &*(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:688 public func &*(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:690 public func +(lhs: String, rhs: StringA) -> StringA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:691 public func +(lhs: StringA, rhs: String) -> StringA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:692 public prefix func ++(x: IntA) -> IntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:693 public prefix func ++(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:694 public prefix func ++(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:695 public prefix func ++(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:696 public prefix func ++(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:697 public prefix func ++(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:698 public prefix func ++(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:699 public prefix func ++(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:700 public prefix func ++(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:701 public prefix func ++(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:702 public prefix func ++(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:703 public prefix func ++(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:704 public prefix func --(x: IntA) -> IntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:705 public prefix func --(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:706 public prefix func --(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:707 public prefix func --(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:708 public prefix func --(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:709 public prefix func --(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:710 public prefix func --(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:711 public prefix func --(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:712 public prefix func --(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:713 public prefix func --(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:714 public prefix func --(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:715 public prefix func --(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:716 public prefix func +(x: IntA) -> IntA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:717 public prefix func +(x: Int64A) -> Int64A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:718 public prefix func +(x: Int32A) -> Int32A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:719 public prefix func +(x: Int16A) -> Int16A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:720 public prefix func +(x: Int8A) -> Int8A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:721 public prefix func +(x: DoubleA) -> DoubleA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:722 public prefix func +(x: FloatA) -> FloatA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:723 public prefix func -(x: IntA) -> IntA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:724 public prefix func -(x: Int64A) -> Int64A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:725 public prefix func -(x: Int32A) -> Int32A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:726 public prefix func -(x: Int16A) -> Int16A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:727 public prefix func -(x: Int8A) -> Int8A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:728 public prefix func -(x: DoubleA) -> DoubleA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:729 public prefix func -(x: FloatA) -> FloatA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:730 public prefix func ~(x: IntA) -> IntA { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:731 public prefix func ~(x: Int64A) -> Int64A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:732 public prefix func ~(x: Int32A) -> Int32A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:733 public prefix func ~(x: Int16A) -> Int16A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:734 public prefix func ~(x: Int8A) -> Int8A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:735 public postfix func ++(x: IntA) -> IntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:736 public postfix func ++(x: Int64A) -> Int64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:737 public postfix func ++(x: Int32A) -> Int32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:738 public postfix func ++(x: Int16A) -> Int16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:739 public postfix func ++(x: Int8A) -> Int8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:740 public postfix func ++(x: UIntA) -> UIntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:741 public postfix func ++(x: UInt64A) -> UInt64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:742 public postfix func ++(x: UInt32A) -> UInt32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:743 public postfix func ++(x: UInt16A) -> UInt16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:744 public postfix func ++(x: UInt8A) -> UInt8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:745 public postfix func ++(x: DoubleA) -> DoubleA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:746 public postfix func ++(x: FloatA) -> FloatA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:747 public postfix func --(x: IntA) -> IntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:748 public postfix func --(x: Int64A) -> Int64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:749 public postfix func --(x: Int32A) -> Int32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:750 public postfix func --(x: Int16A) -> Int16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:751 public postfix func --(x: Int8A) -> Int8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:752 public postfix func --(x: UIntA) -> UIntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:753 public postfix func --(x: UInt64A) -> UInt64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:754 public postfix func --(x: UInt32A) -> UInt32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:755 public postfix func --(x: UInt16A) -> UInt16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:756 public postfix func --(x: UInt8A) -> UInt8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:757 public postfix func --(x: DoubleA) -> DoubleA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:758 public postfix func --(x: FloatA) -> FloatA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:760 public func +=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:761 public func +=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:763 public func +=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:764 public func +=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:766 public func +=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:767 public func +=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:769 public func +=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:770 public func +=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:772 public func +=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:773 public func +=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:775 public func +=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:776 public func +=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:778 public func +=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:779 public func +=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:781 public func +=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:782 public func +=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:784 public func +=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:785 public func +=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:787 public func +=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:788 public func +=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:790 public func +=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:791 public func +=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:793 public func +=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:794 public func +=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:796 public func -=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:797 public func -=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:799 public func -=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:800 public func -=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:802 public func -=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:803 public func -=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:805 public func -=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:806 public func -=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:808 public func -=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:809 public func -=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:811 public func -=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:812 public func -=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:814 public func -=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:815 public func -=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:817 public func -=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:818 public func -=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:820 public func -=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:821 public func -=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:823 public func -=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:824 public func -=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:826 public func -=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:827 public func -=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:829 public func -=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:830 public func -=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:832 public func *=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:833 public func *=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:835 public func *=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:836 public func *=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:838 public func *=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:839 public func *=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:841 public func *=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:842 public func *=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:844 public func *=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:845 public func *=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:847 public func *=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:848 public func *=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:850 public func *=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:851 public func *=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:853 public func *=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:854 public func *=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:856 public func *=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:857 public func *=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:859 public func *=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:860 public func *=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:862 public func *=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:863 public func *=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:865 public func *=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:866 public func *=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:868 public func /=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:869 public func /=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:871 public func /=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:872 public func /=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:874 public func /=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:875 public func /=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:877 public func /=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:878 public func /=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:880 public func /=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:881 public func /=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:883 public func /=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:884 public func /=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:886 public func /=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:887 public func /=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:889 public func /=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:890 public func /=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:892 public func /=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:893 public func /=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:895 public func /=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:896 public func /=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:898 public func /=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:899 public func /=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:901 public func /=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:902 public func /=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:904 public func %=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:905 public func %=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:907 public func %=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:908 public func %=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:910 public func %=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:911 public func %=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:913 public func %=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:914 public func %=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:916 public func %=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:917 public func %=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:919 public func %=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:920 public func %=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:922 public func %=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:923 public func %=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:925 public func %=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:926 public func %=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:928 public func %=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:929 public func %=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:931 public func %=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:932 public func %=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:934 public func %=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:935 public func %=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:937 public func %=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:938 public func %=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:940 public func +=(inout lhs: String, rhs: StringA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:941 public func +=(lhs: StringA, rhs: String) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:943 public func <<=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:944 public func <<=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:946 public func <<=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:947 public func <<=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:949 public func <<=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:950 public func <<=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:952 public func <<=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:953 public func <<=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:955 public func <<=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:956 public func <<=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:958 public func <<=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:959 public func <<=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:961 public func <<=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:962 public func <<=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:964 public func <<=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:965 public func <<=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:967 public func <<=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:968 public func <<=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:970 public func <<=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:971 public func <<=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:973 public func >>=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:974 public func >>=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:976 public func >>=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:977 public func >>=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:979 public func >>=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:980 public func >>=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:982 public func >>=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:983 public func >>=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:985 public func >>=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:986 public func >>=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:988 public func >>=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:989 public func >>=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:991 public func >>=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:992 public func >>=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:994 public func >>=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:995 public func >>=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:997 public func >>=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:998 public func >>=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1000 public func >>=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:1001 public func >>=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1003 public func ^=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1004 public func ^=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1006 public func ^=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1007 public func ^=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1009 public func ^=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1010 public func ^=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1012 public func ^=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1013 public func ^=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1015 public func ^=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1016 public func ^=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1018 public func ^=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1019 public func ^=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1021 public func ^=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1022 public func ^=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1024 public func ^=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1025 public func ^=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1027 public func ^=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1028 public func ^=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1030 public func ^=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1031 public func ^=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1033 public func &=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1034 public func &=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1036 public func &=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1037 public func &=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1039 public func &=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1040 public func &=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1042 public func &=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1043 public func &=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1045 public func &=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1046 public func &=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1048 public func &=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1049 public func &=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1051 public func &=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1052 public func &=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1054 public func &=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1055 public func &=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1057 public func &=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1058 public func &=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1060 public func &=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1061 public func &=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value &= rhs; unlock(lhs) }<T>(lhs: Atomic<T>, _ rhs: Atomic<T>){ 0075 lhs.mutex.unlock() 0076 if lhs !== rhs { rhs.mutex.unlock() } 0077 } 0078 @inline(__always) private func unlock
atomic.swift:83 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value == rhs.value; unlock(lhs, rhs); return result }atomic.swift:86 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value != rhs.value; unlock(lhs, rhs); return result }atomic.swift:89 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value && rhs.value; unlock(lhs, rhs); return result }atomic.swift:92 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value || rhs.value; unlock(lhs, rhs); return result }atomic.swift:95 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value <= rhs.value; unlock(lhs, rhs); return result }atomic.swift:98 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value >= rhs.value; unlock(lhs, rhs); return result }atomic.swift:101 public func ><T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value > rhs.value; unlock(lhs, rhs); return result }atomic.swift:104 public func <<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value < rhs.value; unlock(lhs, rhs); return result }atomic.swift:299 public func +(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:302 public func +(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:305 public func +(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:308 public func +(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:311 public func +(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:314 public func +(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:317 public func +(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:320 public func +(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:323 public func +(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:326 public func +(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:329 public func +(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:332 public func +(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:335 public func -(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:338 public func -(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:341 public func -(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:344 public func -(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:347 public func -(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:350 public func -(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:353 public func -(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:356 public func -(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:359 public func -(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:362 public func -(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:365 public func -(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:368 public func -(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:371 public func *(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:374 public func *(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:377 public func *(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:380 public func *(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:383 public func *(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:386 public func *(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:389 public func *(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:392 public func *(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:395 public func *(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:398 public func *(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:401 public func *(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:404 public func *(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:407 public func /(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:410 public func /(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:413 public func /(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:416 public func /(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:419 public func /(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:422 public func /(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:425 public func /(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:428 public func /(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:431 public func /(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:434 public func /(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:437 public func /(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:440 public func /(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:443 public func %(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:446 public func %(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:449 public func %(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:452 public func %(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:455 public func %(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:458 public func %(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:461 public func %(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:464 public func %(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:467 public func %(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:470 public func %(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:473 public func %(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:476 public func %(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:479 public func <<(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:482 public func <<(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:485 public func <<(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:488 public func <<(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:491 public func <<(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:494 public func <<(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:497 public func <<(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:500 public func <<(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:503 public func <<(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:506 public func <<(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:509 public func >>(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:512 public func >>(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:515 public func >>(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:518 public func >>(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:521 public func >>(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:524 public func >>(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:527 public func >>(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:530 public func >>(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:533 public func >>(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:536 public func >>(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:539 public func ^(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:542 public func ^(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:545 public func ^(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:548 public func ^(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:551 public func ^(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:554 public func ^(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:557 public func ^(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:560 public func ^(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:563 public func ^(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:566 public func ^(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:569 public func &(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:572 public func &(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:575 public func &(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:578 public func &(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:581 public func &(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:584 public func &(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:587 public func &(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:590 public func &(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:593 public func &(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:596 public func &(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:599 public func &+(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:602 public func &+(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:605 public func &+(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:608 public func &+(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:611 public func &+(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:614 public func &+(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:617 public func &+(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:620 public func &+(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:623 public func &+(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:626 public func &+(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:629 public func &-(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:632 public func &-(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:635 public func &-(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:638 public func &-(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:641 public func &-(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:644 public func &-(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:647 public func &-(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:650 public func &-(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:653 public func &-(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:656 public func &-(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:659 public func &*(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:662 public func &*(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:665 public func &*(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:668 public func &*(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:671 public func &*(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:674 public func &*(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:677 public func &*(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:680 public func &*(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:683 public func &*(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:686 public func &*(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:689 public func +(lhs: StringA, rhs: StringA) -> StringA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:759 public func +=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:762 public func +=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:765 public func +=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:768 public func +=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:771 public func +=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:774 public func +=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:777 public func +=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:780 public func +=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:783 public func +=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:786 public func +=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:789 public func +=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:792 public func +=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:795 public func -=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:798 public func -=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:801 public func -=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:804 public func -=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:807 public func -=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:810 public func -=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:813 public func -=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:816 public func -=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:819 public func -=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:822 public func -=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:825 public func -=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:828 public func -=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:831 public func *=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:834 public func *=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:837 public func *=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:840 public func *=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:843 public func *=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:846 public func *=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:849 public func *=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:852 public func *=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:855 public func *=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:858 public func *=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:861 public func *=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:864 public func *=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:867 public func /=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:870 public func /=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:873 public func /=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:876 public func /=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:879 public func /=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:882 public func /=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:885 public func /=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:888 public func /=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:891 public func /=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:894 public func /=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:897 public func /=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:900 public func /=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:903 public func %=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:906 public func %=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:909 public func %=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:912 public func %=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:915 public func %=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:918 public func %=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:921 public func %=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:924 public func %=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:927 public func %=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:930 public func %=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:933 public func %=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:936 public func %=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:939 public func +=(lhs: StringA, rhs: StringA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:942 public func <<=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:945 public func <<=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:948 public func <<=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:951 public func <<=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:954 public func <<=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:957 public func <<=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:960 public func <<=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:963 public func <<=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:966 public func <<=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:969 public func <<=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:972 public func >>=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:975 public func >>=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:978 public func >>=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:981 public func >>=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:984 public func >>=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:987 public func >>=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:990 public func >>=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:993 public func >>=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:996 public func >>=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:999 public func >>=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:1002 public func ^=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1005 public func ^=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1008 public func ^=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1011 public func ^=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1014 public func ^=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1017 public func ^=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1020 public func ^=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1023 public func ^=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1026 public func ^=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1029 public func ^=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1032 public func &=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1035 public func &=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1038 public func &=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1041 public func &=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1044 public func &=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1047 public func &=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1050 public func &=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1053 public func &=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1056 public func &=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1059 public func &=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }<T>(lhs: Atomic<T>){ 0079 lhs.mutex.unlock() 0080 } 0081 0082 0083 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value == rhs.value; unlock(lhs, rhs); return result } 0084 public func ==<T : Equatable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs == rhs.value; unlock(rhs); return result } 0085 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value == rhs; unlock(lhs); return result } 0086 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value != rhs.value; unlock(lhs, rhs); return result } 0087 public func !=<T : Equatable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs != rhs.value; unlock(rhs); return result } 0088 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value != rhs; unlock(lhs); return result } 0089 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value && rhs.value; unlock(lhs, rhs); return result } 0090 public func &&<T : BooleanType>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs && rhs.value; unlock(rhs); return result } 0091 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value && rhs; unlock(lhs); return result } 0092 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value || rhs.value; unlock(lhs, rhs); return result } 0093 public func ||<T : BooleanType>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs || rhs.value; unlock(rhs); return result } 0094 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value || rhs; unlock(lhs); return result } 0095 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value <= rhs.value; unlock(lhs, rhs); return result } 0096 public func <=<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs <= rhs.value; unlock(rhs); return result } 0097 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value <= rhs; unlock(lhs); return result } 0098 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value >= rhs.value; unlock(lhs, rhs); return result } 0099 public func >=<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs >= rhs.value; unlock(rhs); return result } 0100 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value >= rhs; unlock(lhs); return result } 0101 public func ><T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value > rhs.value; unlock(lhs, rhs); return result } 0102 public func ><T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs > rhs.value; unlock(rhs); return result } 0103 public func ><T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value > rhs; unlock(lhs); return result } 0104 public func <<T : Comparable>(lhs: Atomic<T>, rhs: Atomic<T>) -> Bool { lock(lhs, rhs); let result = lhs.value < rhs.value; unlock(lhs, rhs); return result } 0105 public func <<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs < rhs.value; unlock(rhs); return result } 0106 public func <<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value < rhs; unlock(lhs); return result } 0107 public prefix func !<T : BooleanType>(x: Atomic<T>) -> Atomic<Bool> { lock(x); let result = !x.value; unlock(x); return Atomic(result) } 0108 0109 public typealias IntA
atomic.swift:84 public func ==<T : Equatable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs == rhs.value; unlock(rhs); return result }atomic.swift:85 public func ==<T : Equatable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value == rhs; unlock(lhs); return result }atomic.swift:87 public func !=<T : Equatable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs != rhs.value; unlock(rhs); return result }atomic.swift:88 public func !=<T : Equatable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value != rhs; unlock(lhs); return result }atomic.swift:90 public func &&<T : BooleanType>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs && rhs.value; unlock(rhs); return result }atomic.swift:91 public func &&<T : BooleanType>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value && rhs; unlock(lhs); return result }atomic.swift:93 public func ||<T : BooleanType>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs || rhs.value; unlock(rhs); return result }atomic.swift:94 public func ||<T : BooleanType>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value || rhs; unlock(lhs); return result }atomic.swift:96 public func <=<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs <= rhs.value; unlock(rhs); return result }atomic.swift:97 public func <=<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value <= rhs; unlock(lhs); return result }atomic.swift:99 public func >=<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs >= rhs.value; unlock(rhs); return result }atomic.swift:100 public func >=<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value >= rhs; unlock(lhs); return result }atomic.swift:102 public func ><T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs > rhs.value; unlock(rhs); return result }atomic.swift:103 public func ><T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value > rhs; unlock(lhs); return result }atomic.swift:105 public func <<T : Comparable>(lhs: T, rhs: Atomic<T>) -> Bool { lock(rhs); let result = lhs < rhs.value; unlock(rhs); return result }atomic.swift:106 public func <<T : Comparable>(lhs: Atomic<T>, rhs: T) -> Bool { lock(lhs); let result = lhs.value < rhs; unlock(lhs); return result }atomic.swift:107 public prefix func !<T : BooleanType>(x: Atomic<T>) -> Atomic<Bool> { lock(x); let result = !x.value; unlock(x); return Atomic(result) }atomic.swift:300 public func +(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:301 public func +(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:303 public func +(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:304 public func +(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:306 public func +(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:307 public func +(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:309 public func +(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:310 public func +(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:312 public func +(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:313 public func +(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:315 public func +(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:316 public func +(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:318 public func +(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:319 public func +(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:321 public func +(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:322 public func +(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:324 public func +(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:325 public func +(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:327 public func +(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:328 public func +(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:330 public func +(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:331 public func +(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:333 public func +(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:334 public func +(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:336 public func -(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:337 public func -(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:339 public func -(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:340 public func -(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:342 public func -(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:343 public func -(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:345 public func -(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:346 public func -(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:348 public func -(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:349 public func -(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:351 public func -(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:352 public func -(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:354 public func -(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:355 public func -(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:357 public func -(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:358 public func -(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:360 public func -(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:361 public func -(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:363 public func -(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:364 public func -(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:366 public func -(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:367 public func -(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:369 public func -(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:370 public func -(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:372 public func *(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:373 public func *(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:375 public func *(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:376 public func *(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:378 public func *(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:379 public func *(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:381 public func *(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:382 public func *(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:384 public func *(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:385 public func *(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:387 public func *(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:388 public func *(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:390 public func *(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:391 public func *(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:393 public func *(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:394 public func *(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:396 public func *(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:397 public func *(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:399 public func *(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:400 public func *(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:402 public func *(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:403 public func *(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:405 public func *(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:406 public func *(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:408 public func /(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:409 public func /(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:411 public func /(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:412 public func /(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:414 public func /(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:415 public func /(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:417 public func /(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:418 public func /(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:420 public func /(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:421 public func /(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:423 public func /(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:424 public func /(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:426 public func /(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:427 public func /(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:429 public func /(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:430 public func /(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:432 public func /(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:433 public func /(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:435 public func /(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:436 public func /(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:438 public func /(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:439 public func /(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:441 public func /(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:442 public func /(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:444 public func %(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:445 public func %(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:447 public func %(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:448 public func %(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:450 public func %(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:451 public func %(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:453 public func %(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:454 public func %(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:456 public func %(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:457 public func %(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:459 public func %(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:460 public func %(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:462 public func %(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:463 public func %(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:465 public func %(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:466 public func %(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:468 public func %(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:469 public func %(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:471 public func %(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:472 public func %(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:474 public func %(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:475 public func %(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:477 public func %(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:478 public func %(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:480 public func <<(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:481 public func <<(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:483 public func <<(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:484 public func <<(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:486 public func <<(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:487 public func <<(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:489 public func <<(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:490 public func <<(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:492 public func <<(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:493 public func <<(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:495 public func <<(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:496 public func <<(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:498 public func <<(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:499 public func <<(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:501 public func <<(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:502 public func <<(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:504 public func <<(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:505 public func <<(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:507 public func <<(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:508 public func <<(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:510 public func >>(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:511 public func >>(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:513 public func >>(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:514 public func >>(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:516 public func >>(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:517 public func >>(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:519 public func >>(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:520 public func >>(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:522 public func >>(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:523 public func >>(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:525 public func >>(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:526 public func >>(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:528 public func >>(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:529 public func >>(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:531 public func >>(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:532 public func >>(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:534 public func >>(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:535 public func >>(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:537 public func >>(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:538 public func >>(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:540 public func ^(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:541 public func ^(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:543 public func ^(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:544 public func ^(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:546 public func ^(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:547 public func ^(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:549 public func ^(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:550 public func ^(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:552 public func ^(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:553 public func ^(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:555 public func ^(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:556 public func ^(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:558 public func ^(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:559 public func ^(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:561 public func ^(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:562 public func ^(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:564 public func ^(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:565 public func ^(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:567 public func ^(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:568 public func ^(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:570 public func &(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:571 public func &(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:573 public func &(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:574 public func &(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:576 public func &(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:577 public func &(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:579 public func &(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:580 public func &(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:582 public func &(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:583 public func &(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:585 public func &(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:586 public func &(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:588 public func &(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:589 public func &(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:591 public func &(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:592 public func &(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:594 public func &(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:595 public func &(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:597 public func &(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:598 public func &(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:600 public func &+(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:601 public func &+(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:603 public func &+(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:604 public func &+(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:606 public func &+(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:607 public func &+(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:609 public func &+(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:610 public func &+(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:612 public func &+(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:613 public func &+(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:615 public func &+(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:616 public func &+(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:618 public func &+(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:619 public func &+(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:621 public func &+(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:622 public func &+(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:624 public func &+(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:625 public func &+(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:627 public func &+(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:628 public func &+(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:630 public func &-(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:631 public func &-(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:633 public func &-(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:634 public func &-(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:636 public func &-(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:637 public func &-(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:639 public func &-(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:640 public func &-(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:642 public func &-(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:643 public func &-(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:645 public func &-(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:646 public func &-(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:648 public func &-(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:649 public func &-(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:651 public func &-(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:652 public func &-(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:654 public func &-(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:655 public func &-(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:657 public func &-(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:658 public func &-(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:660 public func &*(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:661 public func &*(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:663 public func &*(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:664 public func &*(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:666 public func &*(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:667 public func &*(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:669 public func &*(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:670 public func &*(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:672 public func &*(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:673 public func &*(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:675 public func &*(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:676 public func &*(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:678 public func &*(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:679 public func &*(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:681 public func &*(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:682 public func &*(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:684 public func &*(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:685 public func &*(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:687 public func &*(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:688 public func &*(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:690 public func +(lhs: String, rhs: StringA) -> StringA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:691 public func +(lhs: StringA, rhs: String) -> StringA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:692 public prefix func ++(x: IntA) -> IntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:693 public prefix func ++(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:694 public prefix func ++(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:695 public prefix func ++(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:696 public prefix func ++(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:697 public prefix func ++(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:698 public prefix func ++(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:699 public prefix func ++(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:700 public prefix func ++(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:701 public prefix func ++(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:702 public prefix func ++(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:703 public prefix func ++(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:704 public prefix func --(x: IntA) -> IntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:705 public prefix func --(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:706 public prefix func --(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:707 public prefix func --(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:708 public prefix func --(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:709 public prefix func --(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:710 public prefix func --(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:711 public prefix func --(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:712 public prefix func --(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:713 public prefix func --(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:714 public prefix func --(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:715 public prefix func --(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:716 public prefix func +(x: IntA) -> IntA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:717 public prefix func +(x: Int64A) -> Int64A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:718 public prefix func +(x: Int32A) -> Int32A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:719 public prefix func +(x: Int16A) -> Int16A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:720 public prefix func +(x: Int8A) -> Int8A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:721 public prefix func +(x: DoubleA) -> DoubleA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:722 public prefix func +(x: FloatA) -> FloatA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:723 public prefix func -(x: IntA) -> IntA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:724 public prefix func -(x: Int64A) -> Int64A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:725 public prefix func -(x: Int32A) -> Int32A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:726 public prefix func -(x: Int16A) -> Int16A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:727 public prefix func -(x: Int8A) -> Int8A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:728 public prefix func -(x: DoubleA) -> DoubleA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:729 public prefix func -(x: FloatA) -> FloatA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:730 public prefix func ~(x: IntA) -> IntA { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:731 public prefix func ~(x: Int64A) -> Int64A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:732 public prefix func ~(x: Int32A) -> Int32A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:733 public prefix func ~(x: Int16A) -> Int16A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:734 public prefix func ~(x: Int8A) -> Int8A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:735 public postfix func ++(x: IntA) -> IntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:736 public postfix func ++(x: Int64A) -> Int64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:737 public postfix func ++(x: Int32A) -> Int32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:738 public postfix func ++(x: Int16A) -> Int16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:739 public postfix func ++(x: Int8A) -> Int8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:740 public postfix func ++(x: UIntA) -> UIntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:741 public postfix func ++(x: UInt64A) -> UInt64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:742 public postfix func ++(x: UInt32A) -> UInt32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:743 public postfix func ++(x: UInt16A) -> UInt16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:744 public postfix func ++(x: UInt8A) -> UInt8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:745 public postfix func ++(x: DoubleA) -> DoubleA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:746 public postfix func ++(x: FloatA) -> FloatA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:747 public postfix func --(x: IntA) -> IntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:748 public postfix func --(x: Int64A) -> Int64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:749 public postfix func --(x: Int32A) -> Int32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:750 public postfix func --(x: Int16A) -> Int16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:751 public postfix func --(x: Int8A) -> Int8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:752 public postfix func --(x: UIntA) -> UIntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:753 public postfix func --(x: UInt64A) -> UInt64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:754 public postfix func --(x: UInt32A) -> UInt32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:755 public postfix func --(x: UInt16A) -> UInt16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:756 public postfix func --(x: UInt8A) -> UInt8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:757 public postfix func --(x: DoubleA) -> DoubleA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:758 public postfix func --(x: FloatA) -> FloatA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:760 public func +=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:761 public func +=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:763 public func +=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:764 public func +=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:766 public func +=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:767 public func +=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:769 public func +=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:770 public func +=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:772 public func +=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:773 public func +=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:775 public func +=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:776 public func +=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:778 public func +=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:779 public func +=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:781 public func +=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:782 public func +=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:784 public func +=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:785 public func +=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:787 public func +=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:788 public func +=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:790 public func +=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:791 public func +=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:793 public func +=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:794 public func +=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:796 public func -=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:797 public func -=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:799 public func -=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:800 public func -=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:802 public func -=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:803 public func -=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:805 public func -=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:806 public func -=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:808 public func -=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:809 public func -=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:811 public func -=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:812 public func -=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:814 public func -=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:815 public func -=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:817 public func -=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:818 public func -=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:820 public func -=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:821 public func -=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:823 public func -=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:824 public func -=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:826 public func -=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:827 public func -=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:829 public func -=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:830 public func -=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:832 public func *=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:833 public func *=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:835 public func *=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:836 public func *=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:838 public func *=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:839 public func *=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:841 public func *=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:842 public func *=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:844 public func *=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:845 public func *=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:847 public func *=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:848 public func *=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:850 public func *=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:851 public func *=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:853 public func *=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:854 public func *=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:856 public func *=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:857 public func *=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:859 public func *=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:860 public func *=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:862 public func *=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:863 public func *=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:865 public func *=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:866 public func *=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:868 public func /=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:869 public func /=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:871 public func /=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:872 public func /=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:874 public func /=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:875 public func /=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:877 public func /=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:878 public func /=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:880 public func /=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:881 public func /=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:883 public func /=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:884 public func /=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:886 public func /=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:887 public func /=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:889 public func /=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:890 public func /=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:892 public func /=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:893 public func /=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:895 public func /=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:896 public func /=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:898 public func /=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:899 public func /=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:901 public func /=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:902 public func /=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:904 public func %=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:905 public func %=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:907 public func %=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:908 public func %=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:910 public func %=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:911 public func %=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:913 public func %=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:914 public func %=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:916 public func %=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:917 public func %=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:919 public func %=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:920 public func %=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:922 public func %=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:923 public func %=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:925 public func %=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:926 public func %=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:928 public func %=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:929 public func %=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:931 public func %=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:932 public func %=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:934 public func %=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:935 public func %=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:937 public func %=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:938 public func %=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:940 public func +=(inout lhs: String, rhs: StringA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:941 public func +=(lhs: StringA, rhs: String) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:943 public func <<=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:944 public func <<=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:946 public func <<=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:947 public func <<=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:949 public func <<=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:950 public func <<=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:952 public func <<=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:953 public func <<=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:955 public func <<=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:956 public func <<=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:958 public func <<=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:959 public func <<=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:961 public func <<=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:962 public func <<=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:964 public func <<=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:965 public func <<=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:967 public func <<=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:968 public func <<=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:970 public func <<=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:971 public func <<=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:973 public func >>=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:974 public func >>=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:976 public func >>=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:977 public func >>=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:979 public func >>=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:980 public func >>=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:982 public func >>=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:983 public func >>=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:985 public func >>=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:986 public func >>=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:988 public func >>=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:989 public func >>=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:991 public func >>=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:992 public func >>=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:994 public func >>=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:995 public func >>=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:997 public func >>=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:998 public func >>=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1000 public func >>=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:1001 public func >>=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1003 public func ^=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1004 public func ^=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1006 public func ^=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1007 public func ^=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1009 public func ^=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1010 public func ^=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1012 public func ^=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1013 public func ^=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1015 public func ^=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1016 public func ^=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1018 public func ^=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1019 public func ^=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1021 public func ^=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1022 public func ^=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1024 public func ^=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1025 public func ^=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1027 public func ^=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1028 public func ^=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1030 public func ^=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1031 public func ^=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1033 public func &=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1034 public func &=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1036 public func &=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1037 public func &=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1039 public func &=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1040 public func &=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1042 public func &=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1043 public func &=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1045 public func &=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1046 public func &=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1048 public func &=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1049 public func &=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1051 public func &=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1052 public func &=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1054 public func &=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1055 public func &=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1057 public func &=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1058 public func &=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value &= rhs; unlock(lhs) }atomic.swift:1060 public func &=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1061 public func &=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<Int> 0110 public typealias Int64A
atomic.swift:125 public init (_ atomic : IntA){ self = Int(atomic.load()) }atomic.swift:140 public init (_ atomic : IntA){ self = Int64(atomic.load()) }atomic.swift:154 public init (_ atomic : IntA){ self = Int32(atomic.load()) }atomic.swift:168 public init (_ atomic : IntA){ self = Int16(atomic.load()) }atomic.swift:182 public init (_ atomic : IntA){ self = Int8(atomic.load()) }atomic.swift:196 public init (_ atomic : IntA){ self = UInt(atomic.load()) }atomic.swift:210 public init (_ atomic : IntA){ self = UInt64(atomic.load()) }atomic.swift:224 public init (_ atomic : IntA){ self = UInt32(atomic.load()) }atomic.swift:238 public init (_ atomic : IntA){ self = UInt16(atomic.load()) }atomic.swift:252 public init (_ atomic : IntA){ self = UInt8(atomic.load()) }atomic.swift:266 public init (_ atomic : IntA){ self = Double(atomic.load()) }atomic.swift:280 public init (_ atomic : IntA){ self = Float(atomic.load()) }atomic.swift:299 public func +(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:299 public func +(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:299 public func +(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:300 public func +(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:300 public func +(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:301 public func +(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:301 public func +(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:335 public func -(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:335 public func -(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:335 public func -(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:336 public func -(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:336 public func -(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:337 public func -(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:337 public func -(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:371 public func *(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:371 public func *(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:371 public func *(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:372 public func *(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:372 public func *(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:373 public func *(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:373 public func *(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:407 public func /(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:407 public func /(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:407 public func /(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:408 public func /(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:408 public func /(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:409 public func /(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:409 public func /(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:443 public func %(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:443 public func %(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:443 public func %(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:444 public func %(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:444 public func %(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:445 public func %(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:445 public func %(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:479 public func <<(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:479 public func <<(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:479 public func <<(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:480 public func <<(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:480 public func <<(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:481 public func <<(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:481 public func <<(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:509 public func >>(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:509 public func >>(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:509 public func >>(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:510 public func >>(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:510 public func >>(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:511 public func >>(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:511 public func >>(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:539 public func ^(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:539 public func ^(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:539 public func ^(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:540 public func ^(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:540 public func ^(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:541 public func ^(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:541 public func ^(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:569 public func &(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:569 public func &(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:569 public func &(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:570 public func &(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:570 public func &(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:571 public func &(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:571 public func &(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:599 public func &+(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:599 public func &+(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:599 public func &+(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:600 public func &+(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:600 public func &+(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:601 public func &+(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:601 public func &+(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:629 public func &-(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:629 public func &-(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:629 public func &-(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:630 public func &-(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:630 public func &-(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:631 public func &-(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:631 public func &-(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:659 public func &*(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:659 public func &*(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:659 public func &*(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:660 public func &*(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:660 public func &*(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:661 public func &*(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:661 public func &*(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:692 public prefix func ++(x: IntA) -> IntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:692 public prefix func ++(x: IntA) -> IntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:704 public prefix func --(x: IntA) -> IntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:704 public prefix func --(x: IntA) -> IntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:716 public prefix func +(x: IntA) -> IntA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:716 public prefix func +(x: IntA) -> IntA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:723 public prefix func -(x: IntA) -> IntA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:723 public prefix func -(x: IntA) -> IntA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:730 public prefix func ~(x: IntA) -> IntA { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:730 public prefix func ~(x: IntA) -> IntA { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:735 public postfix func ++(x: IntA) -> IntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:735 public postfix func ++(x: IntA) -> IntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:747 public postfix func --(x: IntA) -> IntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:747 public postfix func --(x: IntA) -> IntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:759 public func +=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:759 public func +=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:760 public func +=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:761 public func +=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:795 public func -=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:795 public func -=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:796 public func -=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:797 public func -=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:831 public func *=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:831 public func *=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:832 public func *=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:833 public func *=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:867 public func /=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:867 public func /=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:868 public func /=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:869 public func /=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:903 public func %=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:903 public func %=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:904 public func %=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:905 public func %=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:942 public func <<=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:942 public func <<=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:943 public func <<=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:944 public func <<=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:972 public func >>=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:972 public func >>=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:973 public func >>=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:974 public func >>=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1002 public func ^=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1002 public func ^=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1003 public func ^=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1004 public func ^=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1032 public func &=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1032 public func &=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1033 public func &=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1034 public func &=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<Int64> 0111 public typealias Int32A
atomic.swift:126 public init (_ atomic : Int64A){ self = Int(atomic.load()) }atomic.swift:139 public init (_ atomic : Int64A){ self = Int64(atomic.load()) }atomic.swift:155 public init (_ atomic : Int64A){ self = Int32(atomic.load()) }atomic.swift:169 public init (_ atomic : Int64A){ self = Int16(atomic.load()) }atomic.swift:183 public init (_ atomic : Int64A){ self = Int8(atomic.load()) }atomic.swift:197 public init (_ atomic : Int64A){ self = UInt(atomic.load()) }atomic.swift:211 public init (_ atomic : Int64A){ self = UInt64(atomic.load()) }atomic.swift:225 public init (_ atomic : Int64A){ self = UInt32(atomic.load()) }atomic.swift:239 public init (_ atomic : Int64A){ self = UInt16(atomic.load()) }atomic.swift:253 public init (_ atomic : Int64A){ self = UInt8(atomic.load()) }atomic.swift:267 public init (_ atomic : Int64A){ self = Double(atomic.load()) }atomic.swift:281 public init (_ atomic : Int64A){ self = Float(atomic.load()) }atomic.swift:302 public func +(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:302 public func +(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:302 public func +(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:303 public func +(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:303 public func +(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:304 public func +(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:304 public func +(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:338 public func -(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:338 public func -(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:338 public func -(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:339 public func -(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:339 public func -(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:340 public func -(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:340 public func -(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:374 public func *(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:374 public func *(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:374 public func *(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:375 public func *(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:375 public func *(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:376 public func *(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:376 public func *(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:410 public func /(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:410 public func /(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:410 public func /(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:411 public func /(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:411 public func /(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:412 public func /(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:412 public func /(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:446 public func %(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:446 public func %(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:446 public func %(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:447 public func %(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:447 public func %(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:448 public func %(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:448 public func %(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:482 public func <<(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:482 public func <<(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:482 public func <<(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:483 public func <<(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:483 public func <<(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:484 public func <<(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:484 public func <<(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:512 public func >>(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:512 public func >>(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:512 public func >>(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:513 public func >>(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:513 public func >>(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:514 public func >>(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:514 public func >>(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:542 public func ^(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:542 public func ^(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:542 public func ^(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:543 public func ^(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:543 public func ^(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:544 public func ^(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:544 public func ^(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:572 public func &(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:572 public func &(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:572 public func &(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:573 public func &(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:573 public func &(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:574 public func &(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:574 public func &(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:602 public func &+(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:602 public func &+(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:602 public func &+(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:603 public func &+(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:603 public func &+(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:604 public func &+(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:604 public func &+(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:632 public func &-(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:632 public func &-(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:632 public func &-(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:633 public func &-(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:633 public func &-(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:634 public func &-(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:634 public func &-(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:662 public func &*(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:662 public func &*(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:662 public func &*(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:663 public func &*(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:663 public func &*(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:664 public func &*(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:664 public func &*(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:693 public prefix func ++(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:693 public prefix func ++(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:705 public prefix func --(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:705 public prefix func --(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:717 public prefix func +(x: Int64A) -> Int64A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:717 public prefix func +(x: Int64A) -> Int64A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:724 public prefix func -(x: Int64A) -> Int64A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:724 public prefix func -(x: Int64A) -> Int64A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:731 public prefix func ~(x: Int64A) -> Int64A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:731 public prefix func ~(x: Int64A) -> Int64A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:736 public postfix func ++(x: Int64A) -> Int64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:736 public postfix func ++(x: Int64A) -> Int64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:748 public postfix func --(x: Int64A) -> Int64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:748 public postfix func --(x: Int64A) -> Int64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:762 public func +=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:762 public func +=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:763 public func +=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:764 public func +=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:798 public func -=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:798 public func -=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:799 public func -=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:800 public func -=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:834 public func *=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:834 public func *=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:835 public func *=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:836 public func *=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:870 public func /=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:870 public func /=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:871 public func /=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:872 public func /=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:906 public func %=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:906 public func %=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:907 public func %=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:908 public func %=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:945 public func <<=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:945 public func <<=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:946 public func <<=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:947 public func <<=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:975 public func >>=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:975 public func >>=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:976 public func >>=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:977 public func >>=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1005 public func ^=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1005 public func ^=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1006 public func ^=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1007 public func ^=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1035 public func &=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1035 public func &=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1036 public func &=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1037 public func &=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<Int32> 0112 public typealias Int16A
atomic.swift:127 public init (_ atomic : Int32A){ self = Int(atomic.load()) }atomic.swift:141 public init (_ atomic : Int32A){ self = Int64(atomic.load()) }atomic.swift:153 public init (_ atomic : Int32A){ self = Int32(atomic.load()) }atomic.swift:170 public init (_ atomic : Int32A){ self = Int16(atomic.load()) }atomic.swift:184 public init (_ atomic : Int32A){ self = Int8(atomic.load()) }atomic.swift:198 public init (_ atomic : Int32A){ self = UInt(atomic.load()) }atomic.swift:212 public init (_ atomic : Int32A){ self = UInt64(atomic.load()) }atomic.swift:226 public init (_ atomic : Int32A){ self = UInt32(atomic.load()) }atomic.swift:240 public init (_ atomic : Int32A){ self = UInt16(atomic.load()) }atomic.swift:254 public init (_ atomic : Int32A){ self = UInt8(atomic.load()) }atomic.swift:268 public init (_ atomic : Int32A){ self = Double(atomic.load()) }atomic.swift:282 public init (_ atomic : Int32A){ self = Float(atomic.load()) }atomic.swift:305 public func +(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:305 public func +(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:305 public func +(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:306 public func +(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:306 public func +(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:307 public func +(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:307 public func +(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:341 public func -(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:341 public func -(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:341 public func -(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:342 public func -(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:342 public func -(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:343 public func -(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:343 public func -(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:377 public func *(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:377 public func *(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:377 public func *(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:378 public func *(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:378 public func *(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:379 public func *(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:379 public func *(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:413 public func /(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:413 public func /(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:413 public func /(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:414 public func /(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:414 public func /(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:415 public func /(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:415 public func /(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:449 public func %(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:449 public func %(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:449 public func %(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:450 public func %(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:450 public func %(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:451 public func %(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:451 public func %(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:485 public func <<(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:485 public func <<(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:485 public func <<(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:486 public func <<(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:486 public func <<(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:487 public func <<(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:487 public func <<(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:515 public func >>(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:515 public func >>(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:515 public func >>(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:516 public func >>(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:516 public func >>(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:517 public func >>(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:517 public func >>(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:545 public func ^(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:545 public func ^(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:545 public func ^(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:546 public func ^(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:546 public func ^(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:547 public func ^(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:547 public func ^(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:575 public func &(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:575 public func &(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:575 public func &(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:576 public func &(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:576 public func &(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:577 public func &(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:577 public func &(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:605 public func &+(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:605 public func &+(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:605 public func &+(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:606 public func &+(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:606 public func &+(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:607 public func &+(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:607 public func &+(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:635 public func &-(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:635 public func &-(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:635 public func &-(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:636 public func &-(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:636 public func &-(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:637 public func &-(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:637 public func &-(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:665 public func &*(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:665 public func &*(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:665 public func &*(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:666 public func &*(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:666 public func &*(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:667 public func &*(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:667 public func &*(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:694 public prefix func ++(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:694 public prefix func ++(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:706 public prefix func --(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:706 public prefix func --(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:718 public prefix func +(x: Int32A) -> Int32A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:718 public prefix func +(x: Int32A) -> Int32A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:725 public prefix func -(x: Int32A) -> Int32A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:725 public prefix func -(x: Int32A) -> Int32A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:732 public prefix func ~(x: Int32A) -> Int32A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:732 public prefix func ~(x: Int32A) -> Int32A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:737 public postfix func ++(x: Int32A) -> Int32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:737 public postfix func ++(x: Int32A) -> Int32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:749 public postfix func --(x: Int32A) -> Int32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:749 public postfix func --(x: Int32A) -> Int32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:765 public func +=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:765 public func +=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:766 public func +=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:767 public func +=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:801 public func -=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:801 public func -=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:802 public func -=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:803 public func -=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:837 public func *=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:837 public func *=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:838 public func *=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:839 public func *=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:873 public func /=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:873 public func /=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:874 public func /=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:875 public func /=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:909 public func %=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:909 public func %=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:910 public func %=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:911 public func %=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:948 public func <<=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:948 public func <<=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:949 public func <<=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:950 public func <<=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:978 public func >>=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:978 public func >>=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:979 public func >>=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:980 public func >>=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1008 public func ^=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1008 public func ^=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1009 public func ^=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1010 public func ^=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1038 public func &=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1038 public func &=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1039 public func &=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1040 public func &=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<Int16> 0113 public typealias Int8A
atomic.swift:128 public init (_ atomic : Int16A){ self = Int(atomic.load()) }atomic.swift:142 public init (_ atomic : Int16A){ self = Int64(atomic.load()) }atomic.swift:156 public init (_ atomic : Int16A){ self = Int32(atomic.load()) }atomic.swift:167 public init (_ atomic : Int16A){ self = Int16(atomic.load()) }atomic.swift:185 public init (_ atomic : Int16A){ self = Int8(atomic.load()) }atomic.swift:199 public init (_ atomic : Int16A){ self = UInt(atomic.load()) }atomic.swift:213 public init (_ atomic : Int16A){ self = UInt64(atomic.load()) }atomic.swift:227 public init (_ atomic : Int16A){ self = UInt32(atomic.load()) }atomic.swift:241 public init (_ atomic : Int16A){ self = UInt16(atomic.load()) }atomic.swift:255 public init (_ atomic : Int16A){ self = UInt8(atomic.load()) }atomic.swift:269 public init (_ atomic : Int16A){ self = Double(atomic.load()) }atomic.swift:283 public init (_ atomic : Int16A){ self = Float(atomic.load()) }atomic.swift:308 public func +(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:308 public func +(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:308 public func +(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:309 public func +(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:309 public func +(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:310 public func +(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:310 public func +(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:344 public func -(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:344 public func -(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:344 public func -(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:345 public func -(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:345 public func -(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:346 public func -(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:346 public func -(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:380 public func *(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:380 public func *(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:380 public func *(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:381 public func *(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:381 public func *(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:382 public func *(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:382 public func *(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:416 public func /(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:416 public func /(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:416 public func /(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:417 public func /(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:417 public func /(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:418 public func /(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:418 public func /(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:452 public func %(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:452 public func %(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:452 public func %(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:453 public func %(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:453 public func %(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:454 public func %(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:454 public func %(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:488 public func <<(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:488 public func <<(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:488 public func <<(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:489 public func <<(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:489 public func <<(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:490 public func <<(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:490 public func <<(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:518 public func >>(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:518 public func >>(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:518 public func >>(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:519 public func >>(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:519 public func >>(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:520 public func >>(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:520 public func >>(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:548 public func ^(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:548 public func ^(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:548 public func ^(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:549 public func ^(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:549 public func ^(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:550 public func ^(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:550 public func ^(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:578 public func &(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:578 public func &(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:578 public func &(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:579 public func &(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:579 public func &(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:580 public func &(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:580 public func &(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:608 public func &+(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:608 public func &+(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:608 public func &+(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:609 public func &+(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:609 public func &+(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:610 public func &+(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:610 public func &+(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:638 public func &-(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:638 public func &-(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:638 public func &-(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:639 public func &-(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:639 public func &-(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:640 public func &-(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:640 public func &-(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:668 public func &*(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:668 public func &*(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:668 public func &*(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:669 public func &*(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:669 public func &*(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:670 public func &*(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:670 public func &*(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:695 public prefix func ++(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:695 public prefix func ++(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:707 public prefix func --(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:707 public prefix func --(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:719 public prefix func +(x: Int16A) -> Int16A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:719 public prefix func +(x: Int16A) -> Int16A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:726 public prefix func -(x: Int16A) -> Int16A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:726 public prefix func -(x: Int16A) -> Int16A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:733 public prefix func ~(x: Int16A) -> Int16A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:733 public prefix func ~(x: Int16A) -> Int16A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:738 public postfix func ++(x: Int16A) -> Int16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:738 public postfix func ++(x: Int16A) -> Int16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:750 public postfix func --(x: Int16A) -> Int16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:750 public postfix func --(x: Int16A) -> Int16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:768 public func +=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:768 public func +=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:769 public func +=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:770 public func +=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:804 public func -=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:804 public func -=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:805 public func -=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:806 public func -=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:840 public func *=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:840 public func *=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:841 public func *=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:842 public func *=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:876 public func /=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:876 public func /=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:877 public func /=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:878 public func /=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:912 public func %=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:912 public func %=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:913 public func %=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:914 public func %=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:951 public func <<=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:951 public func <<=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:952 public func <<=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:953 public func <<=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:981 public func >>=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:981 public func >>=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:982 public func >>=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:983 public func >>=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1011 public func ^=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1011 public func ^=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1012 public func ^=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1013 public func ^=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1041 public func &=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1041 public func &=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1042 public func &=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1043 public func &=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<Int8> 0114 public typealias UIntA
atomic.swift:129 public init (_ atomic : Int8A){ self = Int(atomic.load()) }atomic.swift:143 public init (_ atomic : Int8A){ self = Int64(atomic.load()) }atomic.swift:157 public init (_ atomic : Int8A){ self = Int32(atomic.load()) }atomic.swift:171 public init (_ atomic : Int8A){ self = Int16(atomic.load()) }atomic.swift:181 public init (_ atomic : Int8A){ self = Int8(atomic.load()) }atomic.swift:200 public init (_ atomic : Int8A){ self = UInt(atomic.load()) }atomic.swift:214 public init (_ atomic : Int8A){ self = UInt64(atomic.load()) }atomic.swift:228 public init (_ atomic : Int8A){ self = UInt32(atomic.load()) }atomic.swift:242 public init (_ atomic : Int8A){ self = UInt16(atomic.load()) }atomic.swift:256 public init (_ atomic : Int8A){ self = UInt8(atomic.load()) }atomic.swift:270 public init (_ atomic : Int8A){ self = Double(atomic.load()) }atomic.swift:284 public init (_ atomic : Int8A){ self = Float(atomic.load()) }atomic.swift:311 public func +(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:311 public func +(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:311 public func +(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:312 public func +(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:312 public func +(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:313 public func +(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:313 public func +(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:347 public func -(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:347 public func -(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:347 public func -(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:348 public func -(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:348 public func -(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:349 public func -(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:349 public func -(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:383 public func *(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:383 public func *(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:383 public func *(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:384 public func *(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:384 public func *(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:385 public func *(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:385 public func *(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:419 public func /(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:419 public func /(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:419 public func /(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:420 public func /(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:420 public func /(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:421 public func /(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:421 public func /(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:455 public func %(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:455 public func %(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:455 public func %(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:456 public func %(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:456 public func %(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:457 public func %(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:457 public func %(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:491 public func <<(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:491 public func <<(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:491 public func <<(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:492 public func <<(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:492 public func <<(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:493 public func <<(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:493 public func <<(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:521 public func >>(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:521 public func >>(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:521 public func >>(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:522 public func >>(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:522 public func >>(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:523 public func >>(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:523 public func >>(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:551 public func ^(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:551 public func ^(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:551 public func ^(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:552 public func ^(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:552 public func ^(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:553 public func ^(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:553 public func ^(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:581 public func &(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:581 public func &(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:581 public func &(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:582 public func &(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:582 public func &(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:583 public func &(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:583 public func &(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:611 public func &+(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:611 public func &+(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:611 public func &+(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:612 public func &+(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:612 public func &+(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:613 public func &+(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:613 public func &+(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:641 public func &-(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:641 public func &-(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:641 public func &-(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:642 public func &-(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:642 public func &-(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:643 public func &-(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:643 public func &-(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:671 public func &*(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:671 public func &*(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:671 public func &*(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:672 public func &*(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:672 public func &*(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:673 public func &*(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:673 public func &*(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:696 public prefix func ++(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:696 public prefix func ++(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:708 public prefix func --(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:708 public prefix func --(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:720 public prefix func +(x: Int8A) -> Int8A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:720 public prefix func +(x: Int8A) -> Int8A { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:727 public prefix func -(x: Int8A) -> Int8A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:727 public prefix func -(x: Int8A) -> Int8A { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:734 public prefix func ~(x: Int8A) -> Int8A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:734 public prefix func ~(x: Int8A) -> Int8A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) }atomic.swift:739 public postfix func ++(x: Int8A) -> Int8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:739 public postfix func ++(x: Int8A) -> Int8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:751 public postfix func --(x: Int8A) -> Int8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:751 public postfix func --(x: Int8A) -> Int8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:771 public func +=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:771 public func +=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:772 public func +=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:773 public func +=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:807 public func -=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:807 public func -=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:808 public func -=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:809 public func -=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:843 public func *=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:843 public func *=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:844 public func *=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:845 public func *=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:879 public func /=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:879 public func /=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:880 public func /=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:881 public func /=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:915 public func %=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:915 public func %=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:916 public func %=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:917 public func %=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:954 public func <<=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:954 public func <<=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:955 public func <<=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:956 public func <<=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:984 public func >>=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:984 public func >>=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:985 public func >>=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:986 public func >>=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1014 public func ^=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1014 public func ^=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1015 public func ^=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1016 public func ^=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1044 public func &=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1044 public func &=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1045 public func &=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1046 public func &=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<UInt> 0115 public typealias UInt64A
atomic.swift:130 public init (_ atomic : UIntA){ self = Int(atomic.load()) }atomic.swift:144 public init (_ atomic : UIntA){ self = Int64(atomic.load()) }atomic.swift:158 public init (_ atomic : UIntA){ self = Int32(atomic.load()) }atomic.swift:172 public init (_ atomic : UIntA){ self = Int16(atomic.load()) }atomic.swift:186 public init (_ atomic : UIntA){ self = Int8(atomic.load()) }atomic.swift:195 public init (_ atomic : UIntA){ self = UInt(atomic.load()) }atomic.swift:215 public init (_ atomic : UIntA){ self = UInt64(atomic.load()) }atomic.swift:229 public init (_ atomic : UIntA){ self = UInt32(atomic.load()) }atomic.swift:243 public init (_ atomic : UIntA){ self = UInt16(atomic.load()) }atomic.swift:257 public init (_ atomic : UIntA){ self = UInt8(atomic.load()) }atomic.swift:271 public init (_ atomic : UIntA){ self = Double(atomic.load()) }atomic.swift:285 public init (_ atomic : UIntA){ self = Float(atomic.load()) }atomic.swift:314 public func +(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:314 public func +(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:314 public func +(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:315 public func +(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:315 public func +(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:316 public func +(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:316 public func +(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:350 public func -(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:350 public func -(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:350 public func -(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:351 public func -(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:351 public func -(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:352 public func -(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:352 public func -(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:386 public func *(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:386 public func *(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:386 public func *(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:387 public func *(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:387 public func *(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:388 public func *(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:388 public func *(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:422 public func /(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:422 public func /(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:422 public func /(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:423 public func /(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:423 public func /(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:424 public func /(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:424 public func /(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:458 public func %(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:458 public func %(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:458 public func %(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:459 public func %(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:459 public func %(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:460 public func %(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:460 public func %(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:494 public func <<(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:494 public func <<(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:494 public func <<(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:495 public func <<(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:495 public func <<(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:496 public func <<(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:496 public func <<(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:524 public func >>(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:524 public func >>(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:524 public func >>(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:525 public func >>(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:525 public func >>(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:526 public func >>(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:526 public func >>(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:554 public func ^(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:554 public func ^(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:554 public func ^(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:555 public func ^(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:555 public func ^(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:556 public func ^(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:556 public func ^(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:584 public func &(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:584 public func &(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:584 public func &(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:585 public func &(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:585 public func &(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:586 public func &(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:586 public func &(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:614 public func &+(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:614 public func &+(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:614 public func &+(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:615 public func &+(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:615 public func &+(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:616 public func &+(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:616 public func &+(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:644 public func &-(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:644 public func &-(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:644 public func &-(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:645 public func &-(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:645 public func &-(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:646 public func &-(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:646 public func &-(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:674 public func &*(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:674 public func &*(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:674 public func &*(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:675 public func &*(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:675 public func &*(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:676 public func &*(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:676 public func &*(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:697 public prefix func ++(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:697 public prefix func ++(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:709 public prefix func --(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:709 public prefix func --(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:740 public postfix func ++(x: UIntA) -> UIntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:740 public postfix func ++(x: UIntA) -> UIntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:752 public postfix func --(x: UIntA) -> UIntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:752 public postfix func --(x: UIntA) -> UIntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:774 public func +=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:774 public func +=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:775 public func +=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:776 public func +=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:810 public func -=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:810 public func -=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:811 public func -=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:812 public func -=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:846 public func *=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:846 public func *=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:847 public func *=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:848 public func *=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:882 public func /=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:882 public func /=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:883 public func /=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:884 public func /=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:918 public func %=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:918 public func %=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:919 public func %=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:920 public func %=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:957 public func <<=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:957 public func <<=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:958 public func <<=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:959 public func <<=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:987 public func >>=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:987 public func >>=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:988 public func >>=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:989 public func >>=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1017 public func ^=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1017 public func ^=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1018 public func ^=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1019 public func ^=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1047 public func &=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1047 public func &=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1048 public func &=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1049 public func &=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<UInt64> 0116 public typealias UInt32A
atomic.swift:131 public init (_ atomic : UInt64A){ self = Int(atomic.load()) }atomic.swift:145 public init (_ atomic : UInt64A){ self = Int64(atomic.load()) }atomic.swift:159 public init (_ atomic : UInt64A){ self = Int32(atomic.load()) }atomic.swift:173 public init (_ atomic : UInt64A){ self = Int16(atomic.load()) }atomic.swift:187 public init (_ atomic : UInt64A){ self = Int8(atomic.load()) }atomic.swift:201 public init (_ atomic : UInt64A){ self = UInt(atomic.load()) }atomic.swift:209 public init (_ atomic : UInt64A){ self = UInt64(atomic.load()) }atomic.swift:230 public init (_ atomic : UInt64A){ self = UInt32(atomic.load()) }atomic.swift:244 public init (_ atomic : UInt64A){ self = UInt16(atomic.load()) }atomic.swift:258 public init (_ atomic : UInt64A){ self = UInt8(atomic.load()) }atomic.swift:272 public init (_ atomic : UInt64A){ self = Double(atomic.load()) }atomic.swift:286 public init (_ atomic : UInt64A){ self = Float(atomic.load()) }atomic.swift:317 public func +(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:317 public func +(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:317 public func +(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:318 public func +(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:318 public func +(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:319 public func +(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:319 public func +(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:353 public func -(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:353 public func -(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:353 public func -(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:354 public func -(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:354 public func -(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:355 public func -(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:355 public func -(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:389 public func *(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:389 public func *(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:389 public func *(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:390 public func *(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:390 public func *(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:391 public func *(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:391 public func *(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:425 public func /(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:425 public func /(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:425 public func /(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:426 public func /(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:426 public func /(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:427 public func /(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:427 public func /(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:461 public func %(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:461 public func %(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:461 public func %(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:462 public func %(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:462 public func %(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:463 public func %(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:463 public func %(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:497 public func <<(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:497 public func <<(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:497 public func <<(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:498 public func <<(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:498 public func <<(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:499 public func <<(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:499 public func <<(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:527 public func >>(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:527 public func >>(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:527 public func >>(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:528 public func >>(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:528 public func >>(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:529 public func >>(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:529 public func >>(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:557 public func ^(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:557 public func ^(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:557 public func ^(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:558 public func ^(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:558 public func ^(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:559 public func ^(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:559 public func ^(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:587 public func &(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:587 public func &(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:587 public func &(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:588 public func &(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:588 public func &(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:589 public func &(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:589 public func &(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:617 public func &+(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:617 public func &+(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:617 public func &+(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:618 public func &+(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:618 public func &+(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:619 public func &+(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:619 public func &+(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:647 public func &-(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:647 public func &-(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:647 public func &-(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:648 public func &-(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:648 public func &-(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:649 public func &-(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:649 public func &-(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:677 public func &*(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:677 public func &*(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:677 public func &*(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:678 public func &*(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:678 public func &*(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:679 public func &*(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:679 public func &*(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:698 public prefix func ++(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:698 public prefix func ++(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:710 public prefix func --(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:710 public prefix func --(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:741 public postfix func ++(x: UInt64A) -> UInt64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:741 public postfix func ++(x: UInt64A) -> UInt64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:753 public postfix func --(x: UInt64A) -> UInt64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:753 public postfix func --(x: UInt64A) -> UInt64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:777 public func +=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:777 public func +=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:778 public func +=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:779 public func +=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:813 public func -=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:813 public func -=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:814 public func -=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:815 public func -=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:849 public func *=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:849 public func *=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:850 public func *=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:851 public func *=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:885 public func /=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:885 public func /=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:886 public func /=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:887 public func /=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:921 public func %=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:921 public func %=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:922 public func %=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:923 public func %=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:960 public func <<=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:960 public func <<=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:961 public func <<=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:962 public func <<=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:990 public func >>=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:990 public func >>=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:991 public func >>=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:992 public func >>=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1020 public func ^=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1020 public func ^=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1021 public func ^=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1022 public func ^=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1050 public func &=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1050 public func &=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1051 public func &=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1052 public func &=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<UInt32> 0117 public typealias UInt16A
atomic.swift:132 public init (_ atomic : UInt32A){ self = Int(atomic.load()) }atomic.swift:146 public init (_ atomic : UInt32A){ self = Int64(atomic.load()) }atomic.swift:160 public init (_ atomic : UInt32A){ self = Int32(atomic.load()) }atomic.swift:174 public init (_ atomic : UInt32A){ self = Int16(atomic.load()) }atomic.swift:188 public init (_ atomic : UInt32A){ self = Int8(atomic.load()) }atomic.swift:202 public init (_ atomic : UInt32A){ self = UInt(atomic.load()) }atomic.swift:216 public init (_ atomic : UInt32A){ self = UInt64(atomic.load()) }atomic.swift:223 public init (_ atomic : UInt32A){ self = UInt32(atomic.load()) }atomic.swift:245 public init (_ atomic : UInt32A){ self = UInt16(atomic.load()) }atomic.swift:259 public init (_ atomic : UInt32A){ self = UInt8(atomic.load()) }atomic.swift:273 public init (_ atomic : UInt32A){ self = Double(atomic.load()) }atomic.swift:287 public init (_ atomic : UInt32A){ self = Float(atomic.load()) }atomic.swift:320 public func +(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:320 public func +(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:320 public func +(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:321 public func +(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:321 public func +(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:322 public func +(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:322 public func +(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:356 public func -(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:356 public func -(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:356 public func -(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:357 public func -(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:357 public func -(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:358 public func -(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:358 public func -(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:392 public func *(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:392 public func *(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:392 public func *(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:393 public func *(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:393 public func *(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:394 public func *(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:394 public func *(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:428 public func /(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:428 public func /(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:428 public func /(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:429 public func /(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:429 public func /(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:430 public func /(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:430 public func /(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:464 public func %(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:464 public func %(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:464 public func %(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:465 public func %(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:465 public func %(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:466 public func %(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:466 public func %(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:500 public func <<(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:500 public func <<(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:500 public func <<(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:501 public func <<(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:501 public func <<(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:502 public func <<(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:502 public func <<(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:530 public func >>(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:530 public func >>(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:530 public func >>(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:531 public func >>(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:531 public func >>(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:532 public func >>(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:532 public func >>(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:560 public func ^(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:560 public func ^(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:560 public func ^(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:561 public func ^(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:561 public func ^(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:562 public func ^(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:562 public func ^(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:590 public func &(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:590 public func &(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:590 public func &(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:591 public func &(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:591 public func &(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:592 public func &(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:592 public func &(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:620 public func &+(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:620 public func &+(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:620 public func &+(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:621 public func &+(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:621 public func &+(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:622 public func &+(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:622 public func &+(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:650 public func &-(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:650 public func &-(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:650 public func &-(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:651 public func &-(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:651 public func &-(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:652 public func &-(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:652 public func &-(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:680 public func &*(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:680 public func &*(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:680 public func &*(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:681 public func &*(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:681 public func &*(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:682 public func &*(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:682 public func &*(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:699 public prefix func ++(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:699 public prefix func ++(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:711 public prefix func --(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:711 public prefix func --(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:742 public postfix func ++(x: UInt32A) -> UInt32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:742 public postfix func ++(x: UInt32A) -> UInt32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:754 public postfix func --(x: UInt32A) -> UInt32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:754 public postfix func --(x: UInt32A) -> UInt32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:780 public func +=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:780 public func +=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:781 public func +=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:782 public func +=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:816 public func -=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:816 public func -=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:817 public func -=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:818 public func -=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:852 public func *=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:852 public func *=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:853 public func *=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:854 public func *=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:888 public func /=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:888 public func /=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:889 public func /=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:890 public func /=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:924 public func %=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:924 public func %=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:925 public func %=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:926 public func %=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:963 public func <<=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:963 public func <<=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:964 public func <<=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:965 public func <<=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:993 public func >>=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:993 public func >>=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:994 public func >>=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:995 public func >>=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1023 public func ^=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1023 public func ^=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1024 public func ^=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1025 public func ^=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1053 public func &=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1053 public func &=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1054 public func &=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1055 public func &=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<UInt16> 0118 public typealias UInt8A
atomic.swift:133 public init (_ atomic : UInt16A){ self = Int(atomic.load()) }atomic.swift:147 public init (_ atomic : UInt16A){ self = Int64(atomic.load()) }atomic.swift:161 public init (_ atomic : UInt16A){ self = Int32(atomic.load()) }atomic.swift:175 public init (_ atomic : UInt16A){ self = Int16(atomic.load()) }atomic.swift:189 public init (_ atomic : UInt16A){ self = Int8(atomic.load()) }atomic.swift:203 public init (_ atomic : UInt16A){ self = UInt(atomic.load()) }atomic.swift:217 public init (_ atomic : UInt16A){ self = UInt64(atomic.load()) }atomic.swift:231 public init (_ atomic : UInt16A){ self = UInt32(atomic.load()) }atomic.swift:237 public init (_ atomic : UInt16A){ self = UInt16(atomic.load()) }atomic.swift:260 public init (_ atomic : UInt16A){ self = UInt8(atomic.load()) }atomic.swift:274 public init (_ atomic : UInt16A){ self = Double(atomic.load()) }atomic.swift:288 public init (_ atomic : UInt16A){ self = Float(atomic.load()) }atomic.swift:323 public func +(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:323 public func +(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:323 public func +(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:324 public func +(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:324 public func +(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:325 public func +(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:325 public func +(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:359 public func -(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:359 public func -(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:359 public func -(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:360 public func -(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:360 public func -(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:361 public func -(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:361 public func -(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:395 public func *(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:395 public func *(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:395 public func *(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:396 public func *(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:396 public func *(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:397 public func *(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:397 public func *(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:431 public func /(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:431 public func /(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:431 public func /(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:432 public func /(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:432 public func /(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:433 public func /(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:433 public func /(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:467 public func %(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:467 public func %(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:467 public func %(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:468 public func %(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:468 public func %(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:469 public func %(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:469 public func %(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:503 public func <<(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:503 public func <<(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:503 public func <<(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:504 public func <<(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:504 public func <<(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:505 public func <<(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:505 public func <<(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:533 public func >>(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:533 public func >>(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:533 public func >>(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:534 public func >>(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:534 public func >>(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:535 public func >>(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:535 public func >>(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:563 public func ^(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:563 public func ^(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:563 public func ^(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:564 public func ^(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:564 public func ^(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:565 public func ^(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:565 public func ^(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:593 public func &(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:593 public func &(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:593 public func &(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:594 public func &(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:594 public func &(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:595 public func &(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:595 public func &(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:623 public func &+(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:623 public func &+(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:623 public func &+(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:624 public func &+(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:624 public func &+(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:625 public func &+(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:625 public func &+(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:653 public func &-(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:653 public func &-(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:653 public func &-(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:654 public func &-(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:654 public func &-(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:655 public func &-(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:655 public func &-(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:683 public func &*(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:683 public func &*(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:683 public func &*(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:684 public func &*(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:684 public func &*(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:685 public func &*(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:685 public func &*(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:700 public prefix func ++(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:700 public prefix func ++(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:712 public prefix func --(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:712 public prefix func --(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:743 public postfix func ++(x: UInt16A) -> UInt16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:743 public postfix func ++(x: UInt16A) -> UInt16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:755 public postfix func --(x: UInt16A) -> UInt16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:755 public postfix func --(x: UInt16A) -> UInt16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:783 public func +=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:783 public func +=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:784 public func +=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:785 public func +=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:819 public func -=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:819 public func -=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:820 public func -=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:821 public func -=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:855 public func *=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:855 public func *=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:856 public func *=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:857 public func *=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:891 public func /=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:891 public func /=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:892 public func /=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:893 public func /=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:927 public func %=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:927 public func %=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:928 public func %=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:929 public func %=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:966 public func <<=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:966 public func <<=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:967 public func <<=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:968 public func <<=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:996 public func >>=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:996 public func >>=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:997 public func >>=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:998 public func >>=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1026 public func ^=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1026 public func ^=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1027 public func ^=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1028 public func ^=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1056 public func &=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1056 public func &=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1057 public func &=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1058 public func &=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<UInt8> 0119 public typealias DoubleA
atomic.swift:134 public init (_ atomic : UInt8A){ self = Int(atomic.load()) }atomic.swift:148 public init (_ atomic : UInt8A){ self = Int64(atomic.load()) }atomic.swift:162 public init (_ atomic : UInt8A){ self = Int32(atomic.load()) }atomic.swift:176 public init (_ atomic : UInt8A){ self = Int16(atomic.load()) }atomic.swift:190 public init (_ atomic : UInt8A){ self = Int8(atomic.load()) }atomic.swift:204 public init (_ atomic : UInt8A){ self = UInt(atomic.load()) }atomic.swift:218 public init (_ atomic : UInt8A){ self = UInt64(atomic.load()) }atomic.swift:232 public init (_ atomic : UInt8A){ self = UInt32(atomic.load()) }atomic.swift:246 public init (_ atomic : UInt8A){ self = UInt16(atomic.load()) }atomic.swift:251 public init (_ atomic : UInt8A){ self = UInt8(atomic.load()) }atomic.swift:275 public init (_ atomic : UInt8A){ self = Double(atomic.load()) }atomic.swift:289 public init (_ atomic : UInt8A){ self = Float(atomic.load()) }atomic.swift:326 public func +(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:326 public func +(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:326 public func +(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:327 public func +(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:327 public func +(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:328 public func +(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:328 public func +(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:362 public func -(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:362 public func -(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:362 public func -(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:363 public func -(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:363 public func -(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:364 public func -(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:364 public func -(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:398 public func *(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:398 public func *(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:398 public func *(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:399 public func *(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:399 public func *(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:400 public func *(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:400 public func *(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:434 public func /(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:434 public func /(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:434 public func /(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:435 public func /(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:435 public func /(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:436 public func /(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:436 public func /(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:470 public func %(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:470 public func %(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:470 public func %(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:471 public func %(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:471 public func %(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:472 public func %(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:472 public func %(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:506 public func <<(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:506 public func <<(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:506 public func <<(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:507 public func <<(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:507 public func <<(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:508 public func <<(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:508 public func <<(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) }atomic.swift:536 public func >>(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:536 public func >>(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:536 public func >>(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:537 public func >>(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:537 public func >>(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:538 public func >>(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:538 public func >>(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) }atomic.swift:566 public func ^(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:566 public func ^(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:566 public func ^(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:567 public func ^(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:567 public func ^(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:568 public func ^(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:568 public func ^(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) }atomic.swift:596 public func &(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:596 public func &(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:596 public func &(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:597 public func &(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:597 public func &(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:598 public func &(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:598 public func &(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) }atomic.swift:626 public func &+(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:626 public func &+(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:626 public func &+(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:627 public func &+(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:627 public func &+(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:628 public func &+(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:628 public func &+(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) }atomic.swift:656 public func &-(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:656 public func &-(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:656 public func &-(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:657 public func &-(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:657 public func &-(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:658 public func &-(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:658 public func &-(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) }atomic.swift:686 public func &*(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:686 public func &*(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:686 public func &*(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:687 public func &*(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:687 public func &*(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:688 public func &*(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:688 public func &*(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) }atomic.swift:701 public prefix func ++(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:701 public prefix func ++(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:713 public prefix func --(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:713 public prefix func --(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:744 public postfix func ++(x: UInt8A) -> UInt8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:744 public postfix func ++(x: UInt8A) -> UInt8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:756 public postfix func --(x: UInt8A) -> UInt8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:756 public postfix func --(x: UInt8A) -> UInt8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:786 public func +=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:786 public func +=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:787 public func +=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:788 public func +=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:822 public func -=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:822 public func -=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:823 public func -=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:824 public func -=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:858 public func *=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:858 public func *=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:859 public func *=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:860 public func *=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:894 public func /=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:894 public func /=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:895 public func /=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:896 public func /=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:930 public func %=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:930 public func %=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:931 public func %=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:932 public func %=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value %= rhs; unlock(lhs) }atomic.swift:969 public func <<=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:969 public func <<=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) }atomic.swift:970 public func <<=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) }atomic.swift:971 public func <<=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value <<= rhs; unlock(lhs) }atomic.swift:999 public func >>=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:999 public func >>=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) }atomic.swift:1000 public func >>=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) }atomic.swift:1001 public func >>=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value >>= rhs; unlock(lhs) }atomic.swift:1029 public func ^=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1029 public func ^=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) }atomic.swift:1030 public func ^=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) }atomic.swift:1031 public func ^=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value ^= rhs; unlock(lhs) }atomic.swift:1059 public func &=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1059 public func &=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) }atomic.swift:1060 public func &=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs &= rhs.value; unlock(rhs) }atomic.swift:1061 public func &=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value &= rhs; unlock(lhs) }= Atomic<Double> 0120 public typealias FloatA
atomic.swift:135 public init (_ atomic : DoubleA){ self = Int(atomic.load()) }atomic.swift:149 public init (_ atomic : DoubleA){ self = Int64(atomic.load()) }atomic.swift:163 public init (_ atomic : DoubleA){ self = Int32(atomic.load()) }atomic.swift:177 public init (_ atomic : DoubleA){ self = Int16(atomic.load()) }atomic.swift:191 public init (_ atomic : DoubleA){ self = Int8(atomic.load()) }atomic.swift:205 public init (_ atomic : DoubleA){ self = UInt(atomic.load()) }atomic.swift:219 public init (_ atomic : DoubleA){ self = UInt64(atomic.load()) }atomic.swift:233 public init (_ atomic : DoubleA){ self = UInt32(atomic.load()) }atomic.swift:247 public init (_ atomic : DoubleA){ self = UInt16(atomic.load()) }atomic.swift:261 public init (_ atomic : DoubleA){ self = UInt8(atomic.load()) }atomic.swift:265 public init (_ atomic : DoubleA){ self = Double(atomic.load()) }atomic.swift:290 public init (_ atomic : DoubleA){ self = Float(atomic.load()) }atomic.swift:329 public func +(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:329 public func +(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:329 public func +(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:330 public func +(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:330 public func +(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:331 public func +(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:331 public func +(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:365 public func -(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:365 public func -(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:365 public func -(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:366 public func -(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:366 public func -(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:367 public func -(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:367 public func -(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:401 public func *(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:401 public func *(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:401 public func *(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:402 public func *(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:402 public func *(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:403 public func *(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:403 public func *(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:437 public func /(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:437 public func /(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:437 public func /(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:438 public func /(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:438 public func /(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:439 public func /(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:439 public func /(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:473 public func %(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:473 public func %(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:473 public func %(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:474 public func %(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:474 public func %(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:475 public func %(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:475 public func %(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:702 public prefix func ++(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:702 public prefix func ++(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:714 public prefix func --(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:714 public prefix func --(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:721 public prefix func +(x: DoubleA) -> DoubleA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:721 public prefix func +(x: DoubleA) -> DoubleA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:728 public prefix func -(x: DoubleA) -> DoubleA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:728 public prefix func -(x: DoubleA) -> DoubleA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:745 public postfix func ++(x: DoubleA) -> DoubleA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:745 public postfix func ++(x: DoubleA) -> DoubleA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:757 public postfix func --(x: DoubleA) -> DoubleA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:757 public postfix func --(x: DoubleA) -> DoubleA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:789 public func +=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:789 public func +=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:790 public func +=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:791 public func +=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:825 public func -=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:825 public func -=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:826 public func -=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:827 public func -=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:861 public func *=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:861 public func *=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:862 public func *=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:863 public func *=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:897 public func /=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:897 public func /=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:898 public func /=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:899 public func /=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:933 public func %=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:933 public func %=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:934 public func %=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:935 public func %=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value %= rhs; unlock(lhs) }= Atomic<Float> 0121 public typealias BoolA
atomic.swift:136 public init (_ atomic : FloatA){ self = Int(atomic.load()) }atomic.swift:150 public init (_ atomic : FloatA){ self = Int64(atomic.load()) }atomic.swift:164 public init (_ atomic : FloatA){ self = Int32(atomic.load()) }atomic.swift:178 public init (_ atomic : FloatA){ self = Int16(atomic.load()) }atomic.swift:192 public init (_ atomic : FloatA){ self = Int8(atomic.load()) }atomic.swift:206 public init (_ atomic : FloatA){ self = UInt(atomic.load()) }atomic.swift:220 public init (_ atomic : FloatA){ self = UInt64(atomic.load()) }atomic.swift:234 public init (_ atomic : FloatA){ self = UInt32(atomic.load()) }atomic.swift:248 public init (_ atomic : FloatA){ self = UInt16(atomic.load()) }atomic.swift:262 public init (_ atomic : FloatA){ self = UInt8(atomic.load()) }atomic.swift:276 public init (_ atomic : FloatA){ self = Double(atomic.load()) }atomic.swift:279 public init (_ atomic : FloatA){ self = Float(atomic.load()) }atomic.swift:332 public func +(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:332 public func +(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:332 public func +(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:333 public func +(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:333 public func +(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:334 public func +(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:334 public func +(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:368 public func -(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:368 public func -(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:368 public func -(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:369 public func -(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:369 public func -(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:370 public func -(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:370 public func -(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) }atomic.swift:404 public func *(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:404 public func *(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:404 public func *(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:405 public func *(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:405 public func *(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:406 public func *(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:406 public func *(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) }atomic.swift:440 public func /(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:440 public func /(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:440 public func /(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:441 public func /(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:441 public func /(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:442 public func /(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:442 public func /(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) }atomic.swift:476 public func %(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:476 public func %(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:476 public func %(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:477 public func %(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:477 public func %(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:478 public func %(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:478 public func %(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) }atomic.swift:703 public prefix func ++(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:703 public prefix func ++(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) }atomic.swift:715 public prefix func --(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:715 public prefix func --(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) }atomic.swift:722 public prefix func +(x: FloatA) -> FloatA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:722 public prefix func +(x: FloatA) -> FloatA { lock(x); let result = +x.value; unlock(x); return Atomic(result) }atomic.swift:729 public prefix func -(x: FloatA) -> FloatA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:729 public prefix func -(x: FloatA) -> FloatA { lock(x); let result = -x.value; unlock(x); return Atomic(result) }atomic.swift:746 public postfix func ++(x: FloatA) -> FloatA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:746 public postfix func ++(x: FloatA) -> FloatA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:758 public postfix func --(x: FloatA) -> FloatA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:758 public postfix func --(x: FloatA) -> FloatA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) }atomic.swift:792 public func +=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:792 public func +=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:793 public func +=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:794 public func +=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value += rhs; unlock(lhs) }atomic.swift:828 public func -=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:828 public func -=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) }atomic.swift:829 public func -=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs -= rhs.value; unlock(rhs) }atomic.swift:830 public func -=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value -= rhs; unlock(lhs) }atomic.swift:864 public func *=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:864 public func *=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) }atomic.swift:865 public func *=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs *= rhs.value; unlock(rhs) }atomic.swift:866 public func *=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value *= rhs; unlock(lhs) }atomic.swift:900 public func /=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:900 public func /=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) }atomic.swift:901 public func /=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs /= rhs.value; unlock(rhs) }atomic.swift:902 public func /=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value /= rhs; unlock(lhs) }atomic.swift:936 public func %=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:936 public func %=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) }atomic.swift:937 public func %=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs %= rhs.value; unlock(rhs) }atomic.swift:938 public func %=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value %= rhs; unlock(lhs) }= Atomic<Bool> 0122 public typealias StringA
atomic.swift:293 public init (_ atomic : BoolA){ self = Bool(atomic.load()) }= Atomic<String> 0123 0124 public extension Int { 0125 public init (_ atomic : IntA){ self = Int(atomic.load()) } 0126 public init (_ atomic : Int64A){ self = Int(atomic.load()) } 0127 public init (_ atomic : Int32A){ self = Int(atomic.load()) } 0128 public init (_ atomic : Int16A){ self = Int(atomic.load()) } 0129 public init (_ atomic : Int8A){ self = Int(atomic.load()) } 0130 public init (_ atomic : UIntA){ self = Int(atomic.load()) } 0131 public init (_ atomic : UInt64A){ self = Int(atomic.load()) } 0132 public init (_ atomic : UInt32A){ self = Int(atomic.load()) } 0133 public init (_ atomic : UInt16A){ self = Int(atomic.load()) } 0134 public init (_ atomic : UInt8A){ self = Int(atomic.load()) } 0135 public init (_ atomic : DoubleA){ self = Int(atomic.load()) } 0136 public init (_ atomic : FloatA){ self = Int(atomic.load()) } 0137 } 0138 public extension Int64 { 0139 public init (_ atomic : Int64A){ self = Int64(atomic.load()) } 0140 public init (_ atomic : IntA){ self = Int64(atomic.load()) } 0141 public init (_ atomic : Int32A){ self = Int64(atomic.load()) } 0142 public init (_ atomic : Int16A){ self = Int64(atomic.load()) } 0143 public init (_ atomic : Int8A){ self = Int64(atomic.load()) } 0144 public init (_ atomic : UIntA){ self = Int64(atomic.load()) } 0145 public init (_ atomic : UInt64A){ self = Int64(atomic.load()) } 0146 public init (_ atomic : UInt32A){ self = Int64(atomic.load()) } 0147 public init (_ atomic : UInt16A){ self = Int64(atomic.load()) } 0148 public init (_ atomic : UInt8A){ self = Int64(atomic.load()) } 0149 public init (_ atomic : DoubleA){ self = Int64(atomic.load()) } 0150 public init (_ atomic : FloatA){ self = Int64(atomic.load()) } 0151 } 0152 public extension Int32 { 0153 public init (_ atomic : Int32A){ self = Int32(atomic.load()) } 0154 public init (_ atomic : IntA){ self = Int32(atomic.load()) } 0155 public init (_ atomic : Int64A){ self = Int32(atomic.load()) } 0156 public init (_ atomic : Int16A){ self = Int32(atomic.load()) } 0157 public init (_ atomic : Int8A){ self = Int32(atomic.load()) } 0158 public init (_ atomic : UIntA){ self = Int32(atomic.load()) } 0159 public init (_ atomic : UInt64A){ self = Int32(atomic.load()) } 0160 public init (_ atomic : UInt32A){ self = Int32(atomic.load()) } 0161 public init (_ atomic : UInt16A){ self = Int32(atomic.load()) } 0162 public init (_ atomic : UInt8A){ self = Int32(atomic.load()) } 0163 public init (_ atomic : DoubleA){ self = Int32(atomic.load()) } 0164 public init (_ atomic : FloatA){ self = Int32(atomic.load()) } 0165 } 0166 public extension Int16 { 0167 public init (_ atomic : Int16A){ self = Int16(atomic.load()) } 0168 public init (_ atomic : IntA){ self = Int16(atomic.load()) } 0169 public init (_ atomic : Int64A){ self = Int16(atomic.load()) } 0170 public init (_ atomic : Int32A){ self = Int16(atomic.load()) } 0171 public init (_ atomic : Int8A){ self = Int16(atomic.load()) } 0172 public init (_ atomic : UIntA){ self = Int16(atomic.load()) } 0173 public init (_ atomic : UInt64A){ self = Int16(atomic.load()) } 0174 public init (_ atomic : UInt32A){ self = Int16(atomic.load()) } 0175 public init (_ atomic : UInt16A){ self = Int16(atomic.load()) } 0176 public init (_ atomic : UInt8A){ self = Int16(atomic.load()) } 0177 public init (_ atomic : DoubleA){ self = Int16(atomic.load()) } 0178 public init (_ atomic : FloatA){ self = Int16(atomic.load()) } 0179 } 0180 public extension Int8 { 0181 public init (_ atomic : Int8A){ self = Int8(atomic.load()) } 0182 public init (_ atomic : IntA){ self = Int8(atomic.load()) } 0183 public init (_ atomic : Int64A){ self = Int8(atomic.load()) } 0184 public init (_ atomic : Int32A){ self = Int8(atomic.load()) } 0185 public init (_ atomic : Int16A){ self = Int8(atomic.load()) } 0186 public init (_ atomic : UIntA){ self = Int8(atomic.load()) } 0187 public init (_ atomic : UInt64A){ self = Int8(atomic.load()) } 0188 public init (_ atomic : UInt32A){ self = Int8(atomic.load()) } 0189 public init (_ atomic : UInt16A){ self = Int8(atomic.load()) } 0190 public init (_ atomic : UInt8A){ self = Int8(atomic.load()) } 0191 public init (_ atomic : DoubleA){ self = Int8(atomic.load()) } 0192 public init (_ atomic : FloatA){ self = Int8(atomic.load()) } 0193 } 0194 public extension UInt { 0195 public init (_ atomic : UIntA){ self = UInt(atomic.load()) } 0196 public init (_ atomic : IntA){ self = UInt(atomic.load()) } 0197 public init (_ atomic : Int64A){ self = UInt(atomic.load()) } 0198 public init (_ atomic : Int32A){ self = UInt(atomic.load()) } 0199 public init (_ atomic : Int16A){ self = UInt(atomic.load()) } 0200 public init (_ atomic : Int8A){ self = UInt(atomic.load()) } 0201 public init (_ atomic : UInt64A){ self = UInt(atomic.load()) } 0202 public init (_ atomic : UInt32A){ self = UInt(atomic.load()) } 0203 public init (_ atomic : UInt16A){ self = UInt(atomic.load()) } 0204 public init (_ atomic : UInt8A){ self = UInt(atomic.load()) } 0205 public init (_ atomic : DoubleA){ self = UInt(atomic.load()) } 0206 public init (_ atomic : FloatA){ self = UInt(atomic.load()) } 0207 } 0208 public extension UInt64 { 0209 public init (_ atomic : UInt64A){ self = UInt64(atomic.load()) } 0210 public init (_ atomic : IntA){ self = UInt64(atomic.load()) } 0211 public init (_ atomic : Int64A){ self = UInt64(atomic.load()) } 0212 public init (_ atomic : Int32A){ self = UInt64(atomic.load()) } 0213 public init (_ atomic : Int16A){ self = UInt64(atomic.load()) } 0214 public init (_ atomic : Int8A){ self = UInt64(atomic.load()) } 0215 public init (_ atomic : UIntA){ self = UInt64(atomic.load()) } 0216 public init (_ atomic : UInt32A){ self = UInt64(atomic.load()) } 0217 public init (_ atomic : UInt16A){ self = UInt64(atomic.load()) } 0218 public init (_ atomic : UInt8A){ self = UInt64(atomic.load()) } 0219 public init (_ atomic : DoubleA){ self = UInt64(atomic.load()) } 0220 public init (_ atomic : FloatA){ self = UInt64(atomic.load()) } 0221 } 0222 public extension UInt32 { 0223 public init (_ atomic : UInt32A){ self = UInt32(atomic.load()) } 0224 public init (_ atomic : IntA){ self = UInt32(atomic.load()) } 0225 public init (_ atomic : Int64A){ self = UInt32(atomic.load()) } 0226 public init (_ atomic : Int32A){ self = UInt32(atomic.load()) } 0227 public init (_ atomic : Int16A){ self = UInt32(atomic.load()) } 0228 public init (_ atomic : Int8A){ self = UInt32(atomic.load()) } 0229 public init (_ atomic : UIntA){ self = UInt32(atomic.load()) } 0230 public init (_ atomic : UInt64A){ self = UInt32(atomic.load()) } 0231 public init (_ atomic : UInt16A){ self = UInt32(atomic.load()) } 0232 public init (_ atomic : UInt8A){ self = UInt32(atomic.load()) } 0233 public init (_ atomic : DoubleA){ self = UInt32(atomic.load()) } 0234 public init (_ atomic : FloatA){ self = UInt32(atomic.load()) } 0235 } 0236 public extension UInt16 { 0237 public init (_ atomic : UInt16A){ self = UInt16(atomic.load()) } 0238 public init (_ atomic : IntA){ self = UInt16(atomic.load()) } 0239 public init (_ atomic : Int64A){ self = UInt16(atomic.load()) } 0240 public init (_ atomic : Int32A){ self = UInt16(atomic.load()) } 0241 public init (_ atomic : Int16A){ self = UInt16(atomic.load()) } 0242 public init (_ atomic : Int8A){ self = UInt16(atomic.load()) } 0243 public init (_ atomic : UIntA){ self = UInt16(atomic.load()) } 0244 public init (_ atomic : UInt64A){ self = UInt16(atomic.load()) } 0245 public init (_ atomic : UInt32A){ self = UInt16(atomic.load()) } 0246 public init (_ atomic : UInt8A){ self = UInt16(atomic.load()) } 0247 public init (_ atomic : DoubleA){ self = UInt16(atomic.load()) } 0248 public init (_ atomic : FloatA){ self = UInt16(atomic.load()) } 0249 } 0250 public extension UInt8 { 0251 public init (_ atomic : UInt8A){ self = UInt8(atomic.load()) } 0252 public init (_ atomic : IntA){ self = UInt8(atomic.load()) } 0253 public init (_ atomic : Int64A){ self = UInt8(atomic.load()) } 0254 public init (_ atomic : Int32A){ self = UInt8(atomic.load()) } 0255 public init (_ atomic : Int16A){ self = UInt8(atomic.load()) } 0256 public init (_ atomic : Int8A){ self = UInt8(atomic.load()) } 0257 public init (_ atomic : UIntA){ self = UInt8(atomic.load()) } 0258 public init (_ atomic : UInt64A){ self = UInt8(atomic.load()) } 0259 public init (_ atomic : UInt32A){ self = UInt8(atomic.load()) } 0260 public init (_ atomic : UInt16A){ self = UInt8(atomic.load()) } 0261 public init (_ atomic : DoubleA){ self = UInt8(atomic.load()) } 0262 public init (_ atomic : FloatA){ self = UInt8(atomic.load()) } 0263 } 0264 public extension Double { 0265 public init (_ atomic : DoubleA){ self = Double(atomic.load()) } 0266 public init (_ atomic : IntA){ self = Double(atomic.load()) } 0267 public init (_ atomic : Int64A){ self = Double(atomic.load()) } 0268 public init (_ atomic : Int32A){ self = Double(atomic.load()) } 0269 public init (_ atomic : Int16A){ self = Double(atomic.load()) } 0270 public init (_ atomic : Int8A){ self = Double(atomic.load()) } 0271 public init (_ atomic : UIntA){ self = Double(atomic.load()) } 0272 public init (_ atomic : UInt64A){ self = Double(atomic.load()) } 0273 public init (_ atomic : UInt32A){ self = Double(atomic.load()) } 0274 public init (_ atomic : UInt16A){ self = Double(atomic.load()) } 0275 public init (_ atomic : UInt8A){ self = Double(atomic.load()) } 0276 public init (_ atomic : FloatA){ self = Double(atomic.load()) } 0277 } 0278 public extension Float { 0279 public init (_ atomic : FloatA){ self = Float(atomic.load()) } 0280 public init (_ atomic : IntA){ self = Float(atomic.load()) } 0281 public init (_ atomic : Int64A){ self = Float(atomic.load()) } 0282 public init (_ atomic : Int32A){ self = Float(atomic.load()) } 0283 public init (_ atomic : Int16A){ self = Float(atomic.load()) } 0284 public init (_ atomic : Int8A){ self = Float(atomic.load()) } 0285 public init (_ atomic : UIntA){ self = Float(atomic.load()) } 0286 public init (_ atomic : UInt64A){ self = Float(atomic.load()) } 0287 public init (_ atomic : UInt32A){ self = Float(atomic.load()) } 0288 public init (_ atomic : UInt16A){ self = Float(atomic.load()) } 0289 public init (_ atomic : UInt8A){ self = Float(atomic.load()) } 0290 public init (_ atomic : DoubleA){ self = Float(atomic.load()) } 0291 } 0292 public extension Bool { 0293 public init (_ atomic : BoolA){ self = Bool(atomic.load()) } 0294 } 0295 public extension String { 0296 public init (_ atomic : StringA){ self = String(atomic.load()) } 0297 } 0298 0299 public func +(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0300 public func +(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0301 public func +(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0302 public func +(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0303 public func +(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0304 public func +(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0305 public func +(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0306 public func +(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0307 public func +(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0308 public func +(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0309 public func +(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0310 public func +(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0311 public func +(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0312 public func +(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0313 public func +(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0314 public func +(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0315 public func +(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0316 public func +(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0317 public func +(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0318 public func +(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0319 public func +(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0320 public func +(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0321 public func +(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0322 public func +(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0323 public func +(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0324 public func +(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0325 public func +(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0326 public func +(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0327 public func +(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0328 public func +(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0329 public func +(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0330 public func +(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0331 public func +(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0332 public func +(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0333 public func +(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0334 public func +(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0335 public func -(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0336 public func -(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0337 public func -(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0338 public func -(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0339 public func -(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0340 public func -(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0341 public func -(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0342 public func -(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0343 public func -(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0344 public func -(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0345 public func -(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0346 public func -(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0347 public func -(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0348 public func -(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0349 public func -(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0350 public func -(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0351 public func -(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0352 public func -(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0353 public func -(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0354 public func -(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0355 public func -(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0356 public func -(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0357 public func -(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0358 public func -(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0359 public func -(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0360 public func -(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0361 public func -(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0362 public func -(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0363 public func -(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0364 public func -(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0365 public func -(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0366 public func -(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0367 public func -(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0368 public func -(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value - rhs.value; unlock(lhs, rhs); return Atomic(result) } 0369 public func -(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs - rhs.value; unlock(rhs); return Atomic(result) } 0370 public func -(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value - rhs; unlock(lhs); return Atomic(result) } 0371 public func *(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0372 public func *(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0373 public func *(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0374 public func *(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0375 public func *(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0376 public func *(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0377 public func *(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0378 public func *(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0379 public func *(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0380 public func *(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0381 public func *(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0382 public func *(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0383 public func *(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0384 public func *(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0385 public func *(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0386 public func *(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0387 public func *(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0388 public func *(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0389 public func *(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0390 public func *(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0391 public func *(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0392 public func *(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0393 public func *(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0394 public func *(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0395 public func *(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0396 public func *(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0397 public func *(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0398 public func *(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0399 public func *(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0400 public func *(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0401 public func *(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0402 public func *(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0403 public func *(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0404 public func *(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value * rhs.value; unlock(lhs, rhs); return Atomic(result) } 0405 public func *(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs * rhs.value; unlock(rhs); return Atomic(result) } 0406 public func *(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value * rhs; unlock(lhs); return Atomic(result) } 0407 public func /(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0408 public func /(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0409 public func /(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0410 public func /(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0411 public func /(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0412 public func /(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0413 public func /(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0414 public func /(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0415 public func /(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0416 public func /(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0417 public func /(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0418 public func /(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0419 public func /(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0420 public func /(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0421 public func /(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0422 public func /(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0423 public func /(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0424 public func /(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0425 public func /(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0426 public func /(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0427 public func /(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0428 public func /(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0429 public func /(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0430 public func /(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0431 public func /(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0432 public func /(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0433 public func /(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0434 public func /(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0435 public func /(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0436 public func /(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0437 public func /(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0438 public func /(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0439 public func /(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0440 public func /(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value / rhs.value; unlock(lhs, rhs); return Atomic(result) } 0441 public func /(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs / rhs.value; unlock(rhs); return Atomic(result) } 0442 public func /(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value / rhs; unlock(lhs); return Atomic(result) } 0443 public func %(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0444 public func %(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0445 public func %(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0446 public func %(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0447 public func %(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0448 public func %(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0449 public func %(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0450 public func %(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0451 public func %(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0452 public func %(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0453 public func %(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0454 public func %(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0455 public func %(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0456 public func %(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0457 public func %(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0458 public func %(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0459 public func %(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0460 public func %(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0461 public func %(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0462 public func %(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0463 public func %(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0464 public func %(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0465 public func %(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0466 public func %(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0467 public func %(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0468 public func %(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0469 public func %(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0470 public func %(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0471 public func %(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0472 public func %(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0473 public func %(lhs: DoubleA, rhs: DoubleA) -> DoubleA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0474 public func %(lhs: Double, rhs: DoubleA) -> DoubleA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0475 public func %(lhs: DoubleA, rhs: Double) -> DoubleA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0476 public func %(lhs: FloatA, rhs: FloatA) -> FloatA { lock(lhs, rhs); let result = lhs.value % rhs.value; unlock(lhs, rhs); return Atomic(result) } 0477 public func %(lhs: Float, rhs: FloatA) -> FloatA { lock(rhs); let result = lhs % rhs.value; unlock(rhs); return Atomic(result) } 0478 public func %(lhs: FloatA, rhs: Float) -> FloatA { lock(lhs); let result = lhs.value % rhs; unlock(lhs); return Atomic(result) } 0479 public func <<(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) } 0480 public func <<(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) } 0481 public func <<(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) } 0482 public func <<(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) } 0483 public func <<(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) } 0484 public func <<(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) } 0485 public func <<(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) } 0486 public func <<(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) } 0487 public func <<(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) } 0488 public func <<(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) } 0489 public func <<(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) } 0490 public func <<(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) } 0491 public func <<(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) } 0492 public func <<(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) } 0493 public func <<(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) } 0494 public func <<(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) } 0495 public func <<(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) } 0496 public func <<(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) } 0497 public func <<(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) } 0498 public func <<(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) } 0499 public func <<(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) } 0500 public func <<(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) } 0501 public func <<(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) } 0502 public func <<(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) } 0503 public func <<(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) } 0504 public func <<(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) } 0505 public func <<(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) } 0506 public func <<(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value << rhs.value; unlock(lhs, rhs); return Atomic(result) } 0507 public func <<(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs << rhs.value; unlock(rhs); return Atomic(result) } 0508 public func <<(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value << rhs; unlock(lhs); return Atomic(result) } 0509 public func >>(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) } 0510 public func >>(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) } 0511 public func >>(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) } 0512 public func >>(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) } 0513 public func >>(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) } 0514 public func >>(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) } 0515 public func >>(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) } 0516 public func >>(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) } 0517 public func >>(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) } 0518 public func >>(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) } 0519 public func >>(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) } 0520 public func >>(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) } 0521 public func >>(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) } 0522 public func >>(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) } 0523 public func >>(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) } 0524 public func >>(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) } 0525 public func >>(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) } 0526 public func >>(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) } 0527 public func >>(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) } 0528 public func >>(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) } 0529 public func >>(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) } 0530 public func >>(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) } 0531 public func >>(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) } 0532 public func >>(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) } 0533 public func >>(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) } 0534 public func >>(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) } 0535 public func >>(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) } 0536 public func >>(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value >> rhs.value; unlock(lhs, rhs); return Atomic(result) } 0537 public func >>(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs >> rhs.value; unlock(rhs); return Atomic(result) } 0538 public func >>(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value >> rhs; unlock(lhs); return Atomic(result) } 0539 public func ^(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0540 public func ^(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) } 0541 public func ^(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) } 0542 public func ^(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0543 public func ^(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) } 0544 public func ^(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) } 0545 public func ^(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0546 public func ^(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) } 0547 public func ^(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) } 0548 public func ^(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0549 public func ^(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) } 0550 public func ^(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) } 0551 public func ^(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0552 public func ^(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) } 0553 public func ^(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) } 0554 public func ^(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0555 public func ^(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) } 0556 public func ^(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) } 0557 public func ^(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0558 public func ^(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) } 0559 public func ^(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) } 0560 public func ^(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0561 public func ^(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) } 0562 public func ^(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) } 0563 public func ^(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0564 public func ^(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) } 0565 public func ^(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) } 0566 public func ^(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value ^ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0567 public func ^(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs ^ rhs.value; unlock(rhs); return Atomic(result) } 0568 public func ^(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value ^ rhs; unlock(lhs); return Atomic(result) } 0569 public func &(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) } 0570 public func &(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) } 0571 public func &(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) } 0572 public func &(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) } 0573 public func &(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) } 0574 public func &(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) } 0575 public func &(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) } 0576 public func &(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) } 0577 public func &(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) } 0578 public func &(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) } 0579 public func &(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) } 0580 public func &(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) } 0581 public func &(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) } 0582 public func &(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) } 0583 public func &(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) } 0584 public func &(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) } 0585 public func &(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) } 0586 public func &(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) } 0587 public func &(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) } 0588 public func &(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) } 0589 public func &(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) } 0590 public func &(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) } 0591 public func &(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) } 0592 public func &(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) } 0593 public func &(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) } 0594 public func &(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) } 0595 public func &(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) } 0596 public func &(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value & rhs.value; unlock(lhs, rhs); return Atomic(result) } 0597 public func &(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs & rhs.value; unlock(rhs); return Atomic(result) } 0598 public func &(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value & rhs; unlock(lhs); return Atomic(result) } 0599 public func &+(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0600 public func &+(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) } 0601 public func &+(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) } 0602 public func &+(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0603 public func &+(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) } 0604 public func &+(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) } 0605 public func &+(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0606 public func &+(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) } 0607 public func &+(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) } 0608 public func &+(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0609 public func &+(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) } 0610 public func &+(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) } 0611 public func &+(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0612 public func &+(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) } 0613 public func &+(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) } 0614 public func &+(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0615 public func &+(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) } 0616 public func &+(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) } 0617 public func &+(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0618 public func &+(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) } 0619 public func &+(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) } 0620 public func &+(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0621 public func &+(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) } 0622 public func &+(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) } 0623 public func &+(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0624 public func &+(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) } 0625 public func &+(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) } 0626 public func &+(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &+ rhs.value; unlock(lhs, rhs); return Atomic(result) } 0627 public func &+(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &+ rhs.value; unlock(rhs); return Atomic(result) } 0628 public func &+(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &+ rhs; unlock(lhs); return Atomic(result) } 0629 public func &-(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) } 0630 public func &-(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) } 0631 public func &-(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) } 0632 public func &-(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) } 0633 public func &-(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) } 0634 public func &-(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) } 0635 public func &-(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) } 0636 public func &-(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) } 0637 public func &-(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) } 0638 public func &-(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) } 0639 public func &-(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) } 0640 public func &-(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) } 0641 public func &-(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) } 0642 public func &-(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) } 0643 public func &-(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) } 0644 public func &-(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) } 0645 public func &-(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) } 0646 public func &-(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) } 0647 public func &-(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) } 0648 public func &-(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) } 0649 public func &-(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) } 0650 public func &-(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) } 0651 public func &-(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) } 0652 public func &-(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) } 0653 public func &-(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) } 0654 public func &-(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) } 0655 public func &-(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) } 0656 public func &-(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &- rhs.value; unlock(lhs, rhs); return Atomic(result) } 0657 public func &-(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &- rhs.value; unlock(rhs); return Atomic(result) } 0658 public func &-(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &- rhs; unlock(lhs); return Atomic(result) } 0659 public func &*(lhs: IntA, rhs: IntA) -> IntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) } 0660 public func &*(lhs: Int, rhs: IntA) -> IntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) } 0661 public func &*(lhs: IntA, rhs: Int) -> IntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) } 0662 public func &*(lhs: Int64A, rhs: Int64A) -> Int64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) } 0663 public func &*(lhs: Int64, rhs: Int64A) -> Int64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) } 0664 public func &*(lhs: Int64A, rhs: Int64) -> Int64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) } 0665 public func &*(lhs: Int32A, rhs: Int32A) -> Int32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) } 0666 public func &*(lhs: Int32, rhs: Int32A) -> Int32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) } 0667 public func &*(lhs: Int32A, rhs: Int32) -> Int32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) } 0668 public func &*(lhs: Int16A, rhs: Int16A) -> Int16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) } 0669 public func &*(lhs: Int16, rhs: Int16A) -> Int16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) } 0670 public func &*(lhs: Int16A, rhs: Int16) -> Int16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) } 0671 public func &*(lhs: Int8A, rhs: Int8A) -> Int8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) } 0672 public func &*(lhs: Int8, rhs: Int8A) -> Int8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) } 0673 public func &*(lhs: Int8A, rhs: Int8) -> Int8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) } 0674 public func &*(lhs: UIntA, rhs: UIntA) -> UIntA { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) } 0675 public func &*(lhs: UInt, rhs: UIntA) -> UIntA { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) } 0676 public func &*(lhs: UIntA, rhs: UInt) -> UIntA { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) } 0677 public func &*(lhs: UInt64A, rhs: UInt64A) -> UInt64A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) } 0678 public func &*(lhs: UInt64, rhs: UInt64A) -> UInt64A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) } 0679 public func &*(lhs: UInt64A, rhs: UInt64) -> UInt64A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) } 0680 public func &*(lhs: UInt32A, rhs: UInt32A) -> UInt32A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) } 0681 public func &*(lhs: UInt32, rhs: UInt32A) -> UInt32A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) } 0682 public func &*(lhs: UInt32A, rhs: UInt32) -> UInt32A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) } 0683 public func &*(lhs: UInt16A, rhs: UInt16A) -> UInt16A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) } 0684 public func &*(lhs: UInt16, rhs: UInt16A) -> UInt16A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) } 0685 public func &*(lhs: UInt16A, rhs: UInt16) -> UInt16A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) } 0686 public func &*(lhs: UInt8A, rhs: UInt8A) -> UInt8A { lock(lhs, rhs); let result = lhs.value &* rhs.value; unlock(lhs, rhs); return Atomic(result) } 0687 public func &*(lhs: UInt8, rhs: UInt8A) -> UInt8A { lock(rhs); let result = lhs &* rhs.value; unlock(rhs); return Atomic(result) } 0688 public func &*(lhs: UInt8A, rhs: UInt8) -> UInt8A { lock(lhs); let result = lhs.value &* rhs; unlock(lhs); return Atomic(result) } 0689 public func +(lhs: StringA, rhs: StringA) -> StringA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) } 0690 public func +(lhs: String, rhs: StringA) -> StringA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) } 0691 public func +(lhs: StringA, rhs: String) -> StringA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) } 0692 public prefix func ++(x: IntA) -> IntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0693 public prefix func ++(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0694 public prefix func ++(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0695 public prefix func ++(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0696 public prefix func ++(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0697 public prefix func ++(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0698 public prefix func ++(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0699 public prefix func ++(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0700 public prefix func ++(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0701 public prefix func ++(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0702 public prefix func ++(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0703 public prefix func ++(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value += 1; unlock(x); return Atomic(result) } 0704 public prefix func --(x: IntA) -> IntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0705 public prefix func --(x: Int64A) -> Int64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0706 public prefix func --(x: Int32A) -> Int32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0707 public prefix func --(x: Int16A) -> Int16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0708 public prefix func --(x: Int8A) -> Int8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0709 public prefix func --(x: UIntA) -> UIntA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0710 public prefix func --(x: UInt64A) -> UInt64A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0711 public prefix func --(x: UInt32A) -> UInt32A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0712 public prefix func --(x: UInt16A) -> UInt16A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0713 public prefix func --(x: UInt8A) -> UInt8A { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0714 public prefix func --(x: DoubleA) -> DoubleA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0715 public prefix func --(x: FloatA) -> FloatA { lock(x); let result = x.value; x.value -= 1; unlock(x); return Atomic(result) } 0716 public prefix func +(x: IntA) -> IntA { lock(x); let result = +x.value; unlock(x); return Atomic(result) } 0717 public prefix func +(x: Int64A) -> Int64A { lock(x); let result = +x.value; unlock(x); return Atomic(result) } 0718 public prefix func +(x: Int32A) -> Int32A { lock(x); let result = +x.value; unlock(x); return Atomic(result) } 0719 public prefix func +(x: Int16A) -> Int16A { lock(x); let result = +x.value; unlock(x); return Atomic(result) } 0720 public prefix func +(x: Int8A) -> Int8A { lock(x); let result = +x.value; unlock(x); return Atomic(result) } 0721 public prefix func +(x: DoubleA) -> DoubleA { lock(x); let result = +x.value; unlock(x); return Atomic(result) } 0722 public prefix func +(x: FloatA) -> FloatA { lock(x); let result = +x.value; unlock(x); return Atomic(result) } 0723 public prefix func -(x: IntA) -> IntA { lock(x); let result = -x.value; unlock(x); return Atomic(result) } 0724 public prefix func -(x: Int64A) -> Int64A { lock(x); let result = -x.value; unlock(x); return Atomic(result) } 0725 public prefix func -(x: Int32A) -> Int32A { lock(x); let result = -x.value; unlock(x); return Atomic(result) } 0726 public prefix func -(x: Int16A) -> Int16A { lock(x); let result = -x.value; unlock(x); return Atomic(result) } 0727 public prefix func -(x: Int8A) -> Int8A { lock(x); let result = -x.value; unlock(x); return Atomic(result) } 0728 public prefix func -(x: DoubleA) -> DoubleA { lock(x); let result = -x.value; unlock(x); return Atomic(result) } 0729 public prefix func -(x: FloatA) -> FloatA { lock(x); let result = -x.value; unlock(x); return Atomic(result) } 0730 public prefix func ~(x: IntA) -> IntA { lock(x); let result = ~x.value; unlock(x); return Atomic(result) } 0731 public prefix func ~(x: Int64A) -> Int64A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) } 0732 public prefix func ~(x: Int32A) -> Int32A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) } 0733 public prefix func ~(x: Int16A) -> Int16A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) } 0734 public prefix func ~(x: Int8A) -> Int8A { lock(x); let result = ~x.value; unlock(x); return Atomic(result) } 0735 public postfix func ++(x: IntA) -> IntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0736 public postfix func ++(x: Int64A) -> Int64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0737 public postfix func ++(x: Int32A) -> Int32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0738 public postfix func ++(x: Int16A) -> Int16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0739 public postfix func ++(x: Int8A) -> Int8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0740 public postfix func ++(x: UIntA) -> UIntA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0741 public postfix func ++(x: UInt64A) -> UInt64A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0742 public postfix func ++(x: UInt32A) -> UInt32A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0743 public postfix func ++(x: UInt16A) -> UInt16A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0744 public postfix func ++(x: UInt8A) -> UInt8A { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0745 public postfix func ++(x: DoubleA) -> DoubleA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0746 public postfix func ++(x: FloatA) -> FloatA { lock(x); x.value += 1; let result = x.value; unlock(x); return Atomic(result) } 0747 public postfix func --(x: IntA) -> IntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0748 public postfix func --(x: Int64A) -> Int64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0749 public postfix func --(x: Int32A) -> Int32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0750 public postfix func --(x: Int16A) -> Int16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0751 public postfix func --(x: Int8A) -> Int8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0752 public postfix func --(x: UIntA) -> UIntA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0753 public postfix func --(x: UInt64A) -> UInt64A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0754 public postfix func --(x: UInt32A) -> UInt32A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0755 public postfix func --(x: UInt16A) -> UInt16A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0756 public postfix func --(x: UInt8A) -> UInt8A { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0757 public postfix func --(x: DoubleA) -> DoubleA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0758 public postfix func --(x: FloatA) -> FloatA { lock(x); x.value -= 1; let result = x.value; unlock(x); return Atomic(result) } 0759 public func +=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0760 public func +=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0761 public func +=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0762 public func +=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0763 public func +=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0764 public func +=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0765 public func +=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0766 public func +=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0767 public func +=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0768 public func +=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0769 public func +=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0770 public func +=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0771 public func +=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0772 public func +=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0773 public func +=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0774 public func +=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0775 public func +=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0776 public func +=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0777 public func +=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0778 public func +=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0779 public func +=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0780 public func +=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0781 public func +=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0782 public func +=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0783 public func +=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0784 public func +=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0785 public func +=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0786 public func +=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0787 public func +=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0788 public func +=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0789 public func +=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0790 public func +=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0791 public func +=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0792 public func +=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0793 public func +=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0794 public func +=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0795 public func -=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0796 public func -=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0797 public func -=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0798 public func -=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0799 public func -=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0800 public func -=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0801 public func -=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0802 public func -=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0803 public func -=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0804 public func -=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0805 public func -=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0806 public func -=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0807 public func -=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0808 public func -=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0809 public func -=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0810 public func -=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0811 public func -=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0812 public func -=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0813 public func -=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0814 public func -=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0815 public func -=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0816 public func -=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0817 public func -=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0818 public func -=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0819 public func -=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0820 public func -=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0821 public func -=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0822 public func -=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0823 public func -=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0824 public func -=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0825 public func -=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0826 public func -=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0827 public func -=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0828 public func -=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value -= rhs.value; unlock(lhs, rhs) } 0829 public func -=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs -= rhs.value; unlock(rhs) } 0830 public func -=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value -= rhs; unlock(lhs) } 0831 public func *=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0832 public func *=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0833 public func *=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0834 public func *=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0835 public func *=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0836 public func *=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0837 public func *=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0838 public func *=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0839 public func *=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0840 public func *=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0841 public func *=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0842 public func *=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0843 public func *=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0844 public func *=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0845 public func *=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0846 public func *=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0847 public func *=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0848 public func *=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0849 public func *=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0850 public func *=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0851 public func *=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0852 public func *=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0853 public func *=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0854 public func *=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0855 public func *=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0856 public func *=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0857 public func *=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0858 public func *=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0859 public func *=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0860 public func *=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0861 public func *=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0862 public func *=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0863 public func *=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0864 public func *=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value *= rhs.value; unlock(lhs, rhs) } 0865 public func *=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs *= rhs.value; unlock(rhs) } 0866 public func *=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value *= rhs; unlock(lhs) } 0867 public func /=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0868 public func /=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0869 public func /=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0870 public func /=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0871 public func /=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0872 public func /=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0873 public func /=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0874 public func /=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0875 public func /=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0876 public func /=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0877 public func /=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0878 public func /=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0879 public func /=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0880 public func /=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0881 public func /=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0882 public func /=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0883 public func /=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0884 public func /=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0885 public func /=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0886 public func /=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0887 public func /=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0888 public func /=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0889 public func /=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0890 public func /=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0891 public func /=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0892 public func /=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0893 public func /=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0894 public func /=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0895 public func /=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0896 public func /=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0897 public func /=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0898 public func /=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0899 public func /=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0900 public func /=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value /= rhs.value; unlock(lhs, rhs) } 0901 public func /=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs /= rhs.value; unlock(rhs) } 0902 public func /=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value /= rhs; unlock(lhs) } 0903 public func %=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0904 public func %=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0905 public func %=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0906 public func %=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0907 public func %=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0908 public func %=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0909 public func %=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0910 public func %=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0911 public func %=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0912 public func %=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0913 public func %=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0914 public func %=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0915 public func %=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0916 public func %=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0917 public func %=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0918 public func %=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0919 public func %=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0920 public func %=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0921 public func %=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0922 public func %=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0923 public func %=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0924 public func %=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0925 public func %=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0926 public func %=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0927 public func %=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0928 public func %=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0929 public func %=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0930 public func %=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0931 public func %=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0932 public func %=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0933 public func %=(lhs: DoubleA, rhs: DoubleA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0934 public func %=(inout lhs: Double, rhs: DoubleA) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0935 public func %=(lhs: DoubleA, rhs: Double) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0936 public func %=(lhs: FloatA, rhs: FloatA) { lock(lhs, rhs); lhs.value %= rhs.value; unlock(lhs, rhs) } 0937 public func %=(inout lhs: Float, rhs: FloatA) { lock(rhs); lhs %= rhs.value; unlock(rhs) } 0938 public func %=(lhs: FloatA, rhs: Float) { lock(lhs); lhs.value %= rhs; unlock(lhs) } 0939 public func +=(lhs: StringA, rhs: StringA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) } 0940 public func +=(inout lhs: String, rhs: StringA) { lock(rhs); lhs += rhs.value; unlock(rhs) } 0941 public func +=(lhs: StringA, rhs: String) { lock(lhs); lhs.value += rhs; unlock(lhs) } 0942 public func <<=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) } 0943 public func <<=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs <<= rhs.value; unlock(rhs) } 0944 public func <<=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value <<= rhs; unlock(lhs) } 0945 public func <<=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) } 0946 public func <<=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) } 0947 public func <<=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value <<= rhs; unlock(lhs) } 0948 public func <<=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) } 0949 public func <<=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) } 0950 public func <<=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value <<= rhs; unlock(lhs) } 0951 public func <<=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) } 0952 public func <<=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) } 0953 public func <<=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value <<= rhs; unlock(lhs) } 0954 public func <<=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) } 0955 public func <<=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) } 0956 public func <<=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value <<= rhs; unlock(lhs) } 0957 public func <<=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) } 0958 public func <<=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs <<= rhs.value; unlock(rhs) } 0959 public func <<=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value <<= rhs; unlock(lhs) } 0960 public func <<=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) } 0961 public func <<=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) } 0962 public func <<=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value <<= rhs; unlock(lhs) } 0963 public func <<=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) } 0964 public func <<=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) } 0965 public func <<=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value <<= rhs; unlock(lhs) } 0966 public func <<=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) } 0967 public func <<=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) } 0968 public func <<=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value <<= rhs; unlock(lhs) } 0969 public func <<=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value <<= rhs.value; unlock(lhs, rhs) } 0970 public func <<=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs <<= rhs.value; unlock(rhs) } 0971 public func <<=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value <<= rhs; unlock(lhs) } 0972 public func >>=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) } 0973 public func >>=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs >>= rhs.value; unlock(rhs) } 0974 public func >>=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value >>= rhs; unlock(lhs) } 0975 public func >>=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) } 0976 public func >>=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) } 0977 public func >>=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value >>= rhs; unlock(lhs) } 0978 public func >>=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) } 0979 public func >>=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) } 0980 public func >>=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value >>= rhs; unlock(lhs) } 0981 public func >>=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) } 0982 public func >>=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) } 0983 public func >>=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value >>= rhs; unlock(lhs) } 0984 public func >>=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) } 0985 public func >>=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) } 0986 public func >>=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value >>= rhs; unlock(lhs) } 0987 public func >>=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) } 0988 public func >>=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs >>= rhs.value; unlock(rhs) } 0989 public func >>=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value >>= rhs; unlock(lhs) } 0990 public func >>=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) } 0991 public func >>=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) } 0992 public func >>=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value >>= rhs; unlock(lhs) } 0993 public func >>=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) } 0994 public func >>=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) } 0995 public func >>=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value >>= rhs; unlock(lhs) } 0996 public func >>=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) } 0997 public func >>=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) } 0998 public func >>=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value >>= rhs; unlock(lhs) } 0999 public func >>=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value >>= rhs.value; unlock(lhs, rhs) } 1000 public func >>=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs >>= rhs.value; unlock(rhs) } 1001 public func >>=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value >>= rhs; unlock(lhs) } 1002 public func ^=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) } 1003 public func ^=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs ^= rhs.value; unlock(rhs) } 1004 public func ^=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value ^= rhs; unlock(lhs) } 1005 public func ^=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) } 1006 public func ^=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) } 1007 public func ^=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value ^= rhs; unlock(lhs) } 1008 public func ^=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) } 1009 public func ^=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) } 1010 public func ^=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value ^= rhs; unlock(lhs) } 1011 public func ^=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) } 1012 public func ^=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) } 1013 public func ^=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value ^= rhs; unlock(lhs) } 1014 public func ^=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) } 1015 public func ^=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) } 1016 public func ^=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value ^= rhs; unlock(lhs) } 1017 public func ^=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) } 1018 public func ^=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs ^= rhs.value; unlock(rhs) } 1019 public func ^=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value ^= rhs; unlock(lhs) } 1020 public func ^=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) } 1021 public func ^=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) } 1022 public func ^=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value ^= rhs; unlock(lhs) } 1023 public func ^=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) } 1024 public func ^=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) } 1025 public func ^=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value ^= rhs; unlock(lhs) } 1026 public func ^=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) } 1027 public func ^=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) } 1028 public func ^=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value ^= rhs; unlock(lhs) } 1029 public func ^=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value ^= rhs.value; unlock(lhs, rhs) } 1030 public func ^=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs ^= rhs.value; unlock(rhs) } 1031 public func ^=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value ^= rhs; unlock(lhs) } 1032 public func &=(lhs: IntA, rhs: IntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) } 1033 public func &=(inout lhs: Int, rhs: IntA) { lock(rhs); lhs &= rhs.value; unlock(rhs) } 1034 public func &=(lhs: IntA, rhs: Int) { lock(lhs); lhs.value &= rhs; unlock(lhs) } 1035 public func &=(lhs: Int64A, rhs: Int64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) } 1036 public func &=(inout lhs: Int64, rhs: Int64A) { lock(rhs); lhs &= rhs.value; unlock(rhs) } 1037 public func &=(lhs: Int64A, rhs: Int64) { lock(lhs); lhs.value &= rhs; unlock(lhs) } 1038 public func &=(lhs: Int32A, rhs: Int32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) } 1039 public func &=(inout lhs: Int32, rhs: Int32A) { lock(rhs); lhs &= rhs.value; unlock(rhs) } 1040 public func &=(lhs: Int32A, rhs: Int32) { lock(lhs); lhs.value &= rhs; unlock(lhs) } 1041 public func &=(lhs: Int16A, rhs: Int16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) } 1042 public func &=(inout lhs: Int16, rhs: Int16A) { lock(rhs); lhs &= rhs.value; unlock(rhs) } 1043 public func &=(lhs: Int16A, rhs: Int16) { lock(lhs); lhs.value &= rhs; unlock(lhs) } 1044 public func &=(lhs: Int8A, rhs: Int8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) } 1045 public func &=(inout lhs: Int8, rhs: Int8A) { lock(rhs); lhs &= rhs.value; unlock(rhs) } 1046 public func &=(lhs: Int8A, rhs: Int8) { lock(lhs); lhs.value &= rhs; unlock(lhs) } 1047 public func &=(lhs: UIntA, rhs: UIntA) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) } 1048 public func &=(inout lhs: UInt, rhs: UIntA) { lock(rhs); lhs &= rhs.value; unlock(rhs) } 1049 public func &=(lhs: UIntA, rhs: UInt) { lock(lhs); lhs.value &= rhs; unlock(lhs) } 1050 public func &=(lhs: UInt64A, rhs: UInt64A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) } 1051 public func &=(inout lhs: UInt64, rhs: UInt64A) { lock(rhs); lhs &= rhs.value; unlock(rhs) } 1052 public func &=(lhs: UInt64A, rhs: UInt64) { lock(lhs); lhs.value &= rhs; unlock(lhs) } 1053 public func &=(lhs: UInt32A, rhs: UInt32A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) } 1054 public func &=(inout lhs: UInt32, rhs: UInt32A) { lock(rhs); lhs &= rhs.value; unlock(rhs) } 1055 public func &=(lhs: UInt32A, rhs: UInt32) { lock(lhs); lhs.value &= rhs; unlock(lhs) } 1056 public func &=(lhs: UInt16A, rhs: UInt16A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) } 1057 public func &=(inout lhs: UInt16, rhs: UInt16A) { lock(rhs); lhs &= rhs.value; unlock(rhs) } 1058 public func &=(lhs: UInt16A, rhs: UInt16) { lock(lhs); lhs.value &= rhs; unlock(lhs) } 1059 public func &=(lhs: UInt8A, rhs: UInt8A) { lock(lhs, rhs); lhs.value &= rhs.value; unlock(lhs, rhs) } 1060 public func &=(inout lhs: UInt8, rhs: UInt8A) { lock(rhs); lhs &= rhs.value; unlock(rhs) } 1061 public func &=(lhs: UInt8A, rhs: UInt8) { lock(lhs); lhs.value &= rhs; unlock(lhs) } 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
atomic.swift:296 public init (_ atomic : StringA){ self = String(atomic.load()) }atomic.swift:689 public func +(lhs: StringA, rhs: StringA) -> StringA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:689 public func +(lhs: StringA, rhs: StringA) -> StringA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:689 public func +(lhs: StringA, rhs: StringA) -> StringA { lock(lhs, rhs); let result = lhs.value + rhs.value; unlock(lhs, rhs); return Atomic(result) }atomic.swift:690 public func +(lhs: String, rhs: StringA) -> StringA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:690 public func +(lhs: String, rhs: StringA) -> StringA { lock(rhs); let result = lhs + rhs.value; unlock(rhs); return Atomic(result) }atomic.swift:691 public func +(lhs: StringA, rhs: String) -> StringA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:691 public func +(lhs: StringA, rhs: String) -> StringA { lock(lhs); let result = lhs.value + rhs; unlock(lhs); return Atomic(result) }atomic.swift:939 public func +=(lhs: StringA, rhs: StringA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:939 public func +=(lhs: StringA, rhs: StringA) { lock(lhs, rhs); lhs.value += rhs.value; unlock(lhs, rhs) }atomic.swift:940 public func +=(inout lhs: String, rhs: StringA) { lock(rhs); lhs += rhs.value; unlock(rhs) }atomic.swift:941 public func +=(lhs: StringA, rhs: String) { lock(lhs); lhs.value += rhs; unlock(lhs) }