func (i *Uint64) Add(n uint64) uint64 {
	return atomic.AddUint64(&i.v, n)
}
Add atomically adds to the wrapped uint64 and returns the new value.
package atomic
import (
	"math"
	"sync/atomic"
	"time"
)
type Int32 struct{ v int32 }
func NewInt32(i int32) *Int32 {
	return &Int32{i}
}
func (i *Int32) Load() int32 {
	return atomic.LoadInt32(&i.v)
}
func (i *Int32) Add(n int32) int32 {
	return atomic.AddInt32(&i.v, n)
}
func (i *Int32) Sub(n int32) int32 {
	return atomic.AddInt32(&i.v, -n)
}
func (i *Int32) Inc() int32 {
	return i.Add(1)
}
func (i *Int32) Dec() int32 {
	return i.Sub(1)
}
func (i *Int32) CAS(old, new int32) bool {
	return atomic.CompareAndSwapInt32(&i.v, old, new)
}
func (i *Int32) Store(n int32) {
	atomic.StoreInt32(&i.v, n)
}
func (i *Int32) Swap(n int32) int32 {
	return atomic.SwapInt32(&i.v, n)
}
type Int64 struct{ v int64 }
func NewInt64(i int64) *Int64 {
	return &Int64{i}
}
func (i *Int64) Load() int64 {
	return atomic.LoadInt64(&i.v)
}
func (i *Int64) Add(n int64) int64 {
	return atomic.AddInt64(&i.v, n)
}
func (i *Int64) Sub(n int64) int64 {
	return atomic.AddInt64(&i.v, -n)
}
func (i *Int64) Inc() int64 {
	return i.Add(1)
}
func (i *Int64) Dec() int64 {
	return i.Sub(1)
}
func (i *Int64) CAS(old, new int64) bool {
	return atomic.CompareAndSwapInt64(&i.v, old, new)
}
func (i *Int64) Store(n int64) {
	atomic.StoreInt64(&i.v, n)
}
func (i *Int64) Swap(n int64) int64 {
	return atomic.SwapInt64(&i.v, n)
}
type Uint32 struct{ v uint32 }
func NewUint32(i uint32) *Uint32 {
	return &Uint32{i}
}
func (i *Uint32) Load() uint32 {
	return atomic.LoadUint32(&i.v)
}
func (i *Uint32) Add(n uint32) uint32 {
	return atomic.AddUint32(&i.v, n)
}
func (i *Uint32) Sub(n uint32) uint32 {
	return atomic.AddUint32(&i.v, ^(n - 1))
}
func (i *Uint32) Inc() uint32 {
	return i.Add(1)
}
func (i *Uint32) Dec() uint32 {
	return i.Sub(1)
}
func (i *Uint32) CAS(old, new uint32) bool {
	return atomic.CompareAndSwapUint32(&i.v, old, new)
}
func (i *Uint32) Store(n uint32) {
	atomic.StoreUint32(&i.v, n)
}
func (i *Uint32) Swap(n uint32) uint32 {
	return atomic.SwapUint32(&i.v, n)
}
type Uint64 struct{ v uint64 }
func NewUint64(i uint64) *Uint64 {
	return &Uint64{i}
}
func (i *Uint64) Load() uint64 {
	return atomic.LoadUint64(&i.v)
}