Update dependencies and go1.18 (#1873)

* Update dependencies and go1.18

* Exclude unnecessary linters and update build to go1.18

1 files changed, 382 insertions, 266 deletions

diff --git a/vendor/modernc.org/libc/ccgo.go b/vendor/modernc.org/libc/ccgo.go
index 1ef93fd1..ab1a78e6 100644
--- a/vendor/modernc.org/libc/ccgo.go
+++ b/vendor/modernc.org/libc/ccgo.go
@@ -46,17 +46,19 @@ func AtomicLoadNUint64(ptr uintptr, memorder int32) uint64 {
 func AtomicLoadNUintptr(ptr uintptr, memorder int32) uintptr {
 	return atomic.LoadUintptr((*uintptr)(unsafe.Pointer(ptr)))
 }
-func AssignInt8(p *int8, v int8) int8             { *p = v; return v }
-func AssignInt16(p *int16, v int16) int16         { *p = v; return v }
-func AssignInt32(p *int32, v int32) int32         { *p = v; return v }
-func AssignInt64(p *int64, v int64) int64         { *p = v; return v }
-func AssignUint8(p *uint8, v uint8) uint8         { *p = v; return v }
-func AssignUint16(p *uint16, v uint16) uint16     { *p = v; return v }
-func AssignUint32(p *uint32, v uint32) uint32     { *p = v; return v }
-func AssignUint64(p *uint64, v uint64) uint64     { *p = v; return v }
-func AssignFloat32(p *float32, v float32) float32 { *p = v; return v }
-func AssignFloat64(p *float64, v float64) float64 { *p = v; return v }
-func AssignUintptr(p *uintptr, v uintptr) uintptr { *p = v; return v }
+func AssignInt8(p *int8, v int8) int8                         { *p = v; return v }
+func AssignInt16(p *int16, v int16) int16                     { *p = v; return v }
+func AssignInt32(p *int32, v int32) int32                     { *p = v; return v }
+func AssignInt64(p *int64, v int64) int64                     { *p = v; return v }
+func AssignUint8(p *uint8, v uint8) uint8                     { *p = v; return v }
+func AssignUint16(p *uint16, v uint16) uint16                 { *p = v; return v }
+func AssignUint32(p *uint32, v uint32) uint32                 { *p = v; return v }
+func AssignUint64(p *uint64, v uint64) uint64                 { *p = v; return v }
+func AssignFloat32(p *float32, v float32) float32             { *p = v; return v }
+func AssignFloat64(p *float64, v float64) float64             { *p = v; return v }
+func AssignComplex64(p *complex64, v complex64) complex64     { *p = v; return v }
+func AssignComplex128(p *complex128, v complex128) complex128 { *p = v; return v }
+func AssignUintptr(p *uintptr, v uintptr) uintptr             { *p = v; return v }
 
 func AssignPtrInt8(p uintptr, v int8) int8          { *(*int8)(unsafe.Pointer(p)) = v; return v }
 func AssignPtrInt16(p uintptr, v int16) int16       { *(*int16)(unsafe.Pointer(p)) = v; return v }
@@ -68,31 +70,43 @@ func AssignPtrUint32(p uintptr, v uint32) uint32    { *(*uint32)(unsafe.Pointer(
 func AssignPtrUint64(p uintptr, v uint64) uint64    { *(*uint64)(unsafe.Pointer(p)) = v; return v }
 func AssignPtrFloat32(p uintptr, v float32) float32 { *(*float32)(unsafe.Pointer(p)) = v; return v }
 func AssignPtrFloat64(p uintptr, v float64) float64 { *(*float64)(unsafe.Pointer(p)) = v; return v }
+func AssignPtrComplex64(p uintptr, v complex64) complex64 {
+	*(*complex64)(unsafe.Pointer(p)) = v
+	return v
+}
+func AssignPtrComplex128(p uintptr, v complex128) complex128 {
+	*(*complex128)(unsafe.Pointer(p)) = v
+	return v
+}
 func AssignPtrUintptr(p uintptr, v uintptr) uintptr { *(*uintptr)(unsafe.Pointer(p)) = v; return v }
 
-func AssignMulInt8(p *int8, v int8) int8             { *p *= v; return *p }
-func AssignMulInt16(p *int16, v int16) int16         { *p *= v; return *p }
-func AssignMulInt32(p *int32, v int32) int32         { *p *= v; return *p }
-func AssignMulInt64(p *int64, v int64) int64         { *p *= v; return *p }
-func AssignMulUint8(p *uint8, v uint8) uint8         { *p *= v; return *p }
-func AssignMulUint16(p *uint16, v uint16) uint16     { *p *= v; return *p }
-func AssignMulUint32(p *uint32, v uint32) uint32     { *p *= v; return *p }
-func AssignMulUint64(p *uint64, v uint64) uint64     { *p *= v; return *p }
-func AssignMulFloat32(p *float32, v float32) float32 { *p *= v; return *p }
-func AssignMulFloat64(p *float64, v float64) float64 { *p *= v; return *p }
-func AssignMulUintptr(p *uintptr, v uintptr) uintptr { *p *= v; return *p }
-
-func AssignDivInt8(p *int8, v int8) int8             { *p /= v; return *p }
-func AssignDivInt16(p *int16, v int16) int16         { *p /= v; return *p }
-func AssignDivInt32(p *int32, v int32) int32         { *p /= v; return *p }
-func AssignDivInt64(p *int64, v int64) int64         { *p /= v; return *p }
-func AssignDivUint8(p *uint8, v uint8) uint8         { *p /= v; return *p }
-func AssignDivUint16(p *uint16, v uint16) uint16     { *p /= v; return *p }
-func AssignDivUint32(p *uint32, v uint32) uint32     { *p /= v; return *p }
-func AssignDivUint64(p *uint64, v uint64) uint64     { *p /= v; return *p }
-func AssignDivFloat32(p *float32, v float32) float32 { *p /= v; return *p }
-func AssignDivFloat64(p *float64, v float64) float64 { *p /= v; return *p }
-func AssignDivUintptr(p *uintptr, v uintptr) uintptr { *p /= v; return *p }
+func AssignMulInt8(p *int8, v int8) int8                         { *p *= v; return *p }
+func AssignMulInt16(p *int16, v int16) int16                     { *p *= v; return *p }
+func AssignMulInt32(p *int32, v int32) int32                     { *p *= v; return *p }
+func AssignMulInt64(p *int64, v int64) int64                     { *p *= v; return *p }
+func AssignMulUint8(p *uint8, v uint8) uint8                     { *p *= v; return *p }
+func AssignMulUint16(p *uint16, v uint16) uint16                 { *p *= v; return *p }
+func AssignMulUint32(p *uint32, v uint32) uint32                 { *p *= v; return *p }
+func AssignMulUint64(p *uint64, v uint64) uint64                 { *p *= v; return *p }
+func AssignMulFloat32(p *float32, v float32) float32             { *p *= v; return *p }
+func AssignMulFloat64(p *float64, v float64) float64             { *p *= v; return *p }
+func AssignMulComplex64(p *complex64, v complex64) complex64     { *p *= v; return *p }
+func AssignMulComplex128(p *complex128, v complex128) complex128 { *p *= v; return *p }
+func AssignMulUintptr(p *uintptr, v uintptr) uintptr             { *p *= v; return *p }
+
+func AssignDivInt8(p *int8, v int8) int8                         { *p /= v; return *p }
+func AssignDivInt16(p *int16, v int16) int16                     { *p /= v; return *p }
+func AssignDivInt32(p *int32, v int32) int32                     { *p /= v; return *p }
+func AssignDivInt64(p *int64, v int64) int64                     { *p /= v; return *p }
+func AssignDivUint8(p *uint8, v uint8) uint8                     { *p /= v; return *p }
+func AssignDivUint16(p *uint16, v uint16) uint16                 { *p /= v; return *p }
+func AssignDivUint32(p *uint32, v uint32) uint32                 { *p /= v; return *p }
+func AssignDivUint64(p *uint64, v uint64) uint64                 { *p /= v; return *p }
+func AssignDivFloat32(p *float32, v float32) float32             { *p /= v; return *p }
+func AssignDivFloat64(p *float64, v float64) float64             { *p /= v; return *p }
+func AssignDivComplex64(p *complex64, v complex64) complex64     { *p /= v; return *p }
+func AssignDivComplex128(p *complex128, v complex128) complex128 { *p /= v; return *p }
+func AssignDivUintptr(p *uintptr, v uintptr) uintptr             { *p /= v; return *p }
 
 func AssignRemInt8(p *int8, v int8) int8             { *p %= v; return *p }
 func AssignRemInt16(p *int16, v int16) int16         { *p %= v; return *p }
@@ -104,29 +118,33 @@ func AssignRemUint32(p *uint32, v uint32) uint32     { *p %= v; return *p }
 func AssignRemUint64(p *uint64, v uint64) uint64     { *p %= v; return *p }
 func AssignRemUintptr(p *uintptr, v uintptr) uintptr { *p %= v; return *p }
 
-func AssignAddInt8(p *int8, v int8) int8             { *p += v; return *p }
-func AssignAddInt16(p *int16, v int16) int16         { *p += v; return *p }
-func AssignAddInt32(p *int32, v int32) int32         { *p += v; return *p }
-func AssignAddInt64(p *int64, v int64) int64         { *p += v; return *p }
-func AssignAddUint8(p *uint8, v uint8) uint8         { *p += v; return *p }
-func AssignAddUint16(p *uint16, v uint16) uint16     { *p += v; return *p }
-func AssignAddUint32(p *uint32, v uint32) uint32     { *p += v; return *p }
-func AssignAddUint64(p *uint64, v uint64) uint64     { *p += v; return *p }
-func AssignAddFloat32(p *float32, v float32) float32 { *p += v; return *p }
-func AssignAddFloat64(p *float64, v float64) float64 { *p += v; return *p }
-func AssignAddUintptr(p *uintptr, v uintptr) uintptr { *p += v; return *p }
-
-func AssignSubInt8(p *int8, v int8) int8             { *p -= v; return *p }
-func AssignSubInt16(p *int16, v int16) int16         { *p -= v; return *p }
-func AssignSubInt32(p *int32, v int32) int32         { *p -= v; return *p }
-func AssignSubInt64(p *int64, v int64) int64         { *p -= v; return *p }
-func AssignSubUint8(p *uint8, v uint8) uint8         { *p -= v; return *p }
-func AssignSubUint16(p *uint16, v uint16) uint16     { *p -= v; return *p }
-func AssignSubUint32(p *uint32, v uint32) uint32     { *p -= v; return *p }
-func AssignSubUint64(p *uint64, v uint64) uint64     { *p -= v; return *p }
-func AssignSubFloat32(p *float32, v float32) float32 { *p -= v; return *p }
-func AssignSubFloat64(p *float64, v float64) float64 { *p -= v; return *p }
-func AssignSubUintptr(p *uintptr, v uintptr) uintptr { *p -= v; return *p }
+func AssignAddInt8(p *int8, v int8) int8                         { *p += v; return *p }
+func AssignAddInt16(p *int16, v int16) int16                     { *p += v; return *p }
+func AssignAddInt32(p *int32, v int32) int32                     { *p += v; return *p }
+func AssignAddInt64(p *int64, v int64) int64                     { *p += v; return *p }
+func AssignAddUint8(p *uint8, v uint8) uint8                     { *p += v; return *p }
+func AssignAddUint16(p *uint16, v uint16) uint16                 { *p += v; return *p }
+func AssignAddUint32(p *uint32, v uint32) uint32                 { *p += v; return *p }
+func AssignAddUint64(p *uint64, v uint64) uint64                 { *p += v; return *p }
+func AssignAddFloat32(p *float32, v float32) float32             { *p += v; return *p }
+func AssignAddFloat64(p *float64, v float64) float64             { *p += v; return *p }
+func AssignAddComplex64(p *complex64, v complex64) complex64     { *p += v; return *p }
+func AssignAddComplex128(p *complex128, v complex128) complex128 { *p += v; return *p }
+func AssignAddUintptr(p *uintptr, v uintptr) uintptr             { *p += v; return *p }
+
+func AssignSubInt8(p *int8, v int8) int8                         { *p -= v; return *p }
+func AssignSubInt16(p *int16, v int16) int16                     { *p -= v; return *p }
+func AssignSubInt32(p *int32, v int32) int32                     { *p -= v; return *p }
+func AssignSubInt64(p *int64, v int64) int64                     { *p -= v; return *p }
+func AssignSubUint8(p *uint8, v uint8) uint8                     { *p -= v; return *p }
+func AssignSubUint16(p *uint16, v uint16) uint16                 { *p -= v; return *p }
+func AssignSubUint32(p *uint32, v uint32) uint32                 { *p -= v; return *p }
+func AssignSubUint64(p *uint64, v uint64) uint64                 { *p -= v; return *p }
+func AssignSubFloat32(p *float32, v float32) float32             { *p -= v; return *p }
+func AssignSubFloat64(p *float64, v float64) float64             { *p -= v; return *p }
+func AssignSubComplex64(p *complex64, v complex64) complex64     { *p -= v; return *p }
+func AssignSubComplex128(p *complex128, v complex128) complex128 { *p -= v; return *p }
+func AssignSubUintptr(p *uintptr, v uintptr) uintptr             { *p -= v; return *p }
 
 func AssignAndInt8(p *int8, v int8) int8             { *p &= v; return *p }
 func AssignAndInt16(p *int16, v int16) int16         { *p &= v; return *p }
@@ -208,6 +226,16 @@ func AssignMulPtrFloat64(p uintptr, v float64) float64 {
 	return *(*float64)(unsafe.Pointer(p))
 }
 
+func AssignMulPtrComplex64(p uintptr, v complex64) complex64 {
+	*(*complex64)(unsafe.Pointer(p)) *= v
+	return *(*complex64)(unsafe.Pointer(p))
+}
+
+func AssignMulPtrComplex128(p uintptr, v complex128) complex128 {
+	*(*complex128)(unsafe.Pointer(p)) *= v
+	return *(*complex128)(unsafe.Pointer(p))
+}
+
 func AssignMulPtrUintptr(p uintptr, v uintptr) uintptr {
 	*(*uintptr)(unsafe.Pointer(p)) *= v
 	return *(*uintptr)(unsafe.Pointer(p))
@@ -263,6 +291,16 @@ func AssignDivPtrFloat64(p uintptr, v float64) float64 {
 	return *(*float64)(unsafe.Pointer(p))
 }
 
+func AssignDivPtrComplex64(p uintptr, v complex64) complex64 {
+	*(*complex64)(unsafe.Pointer(p)) /= v
+	return *(*complex64)(unsafe.Pointer(p))
+}
+
+func AssignDivPtrComplex128(p uintptr, v complex128) complex128 {
+	*(*complex128)(unsafe.Pointer(p)) /= v
+	return *(*complex128)(unsafe.Pointer(p))
+}
+
 func AssignDivPtrUintptr(p uintptr, v uintptr) uintptr {
 	*(*uintptr)(unsafe.Pointer(p)) /= v
 	return *(*uintptr)(unsafe.Pointer(p))
@@ -363,6 +401,16 @@ func AssignAddPtrFloat64(p uintptr, v float64) float64 {
 	return *(*float64)(unsafe.Pointer(p))
 }
 
+func AssignAddPtrComplex64(p uintptr, v complex64) complex64 {
+	*(*complex64)(unsafe.Pointer(p)) += v
+	return *(*complex64)(unsafe.Pointer(p))
+}
+
+func AssignAddPtrComplex128(p uintptr, v complex128) complex128 {
+	*(*complex128)(unsafe.Pointer(p)) += v
+	return *(*complex128)(unsafe.Pointer(p))
+}
+
 func AssignAddPtrUintptr(p uintptr, v uintptr) uintptr {
 	*(*uintptr)(unsafe.Pointer(p)) += v
 	return *(*uintptr)(unsafe.Pointer(p))
@@ -418,6 +466,16 @@ func AssignSubPtrFloat64(p uintptr, v float64) float64 {
 	return *(*float64)(unsafe.Pointer(p))
 }
 
+func AssignSubPtrComplex64(p uintptr, v complex64) complex64 {
+	*(*complex64)(unsafe.Pointer(p)) -= v
+	return *(*complex64)(unsafe.Pointer(p))
+}
+
+func AssignSubPtrComplex128(p uintptr, v complex128) complex128 {
+	*(*complex128)(unsafe.Pointer(p)) -= v
+	return *(*complex128)(unsafe.Pointer(p))
+}
+
 func AssignSubPtrUintptr(p uintptr, v uintptr) uintptr {
 	*(*uintptr)(unsafe.Pointer(p)) -= v
 	return *(*uintptr)(unsafe.Pointer(p))
@@ -684,17 +742,19 @@ func AssignShrUint64(p *uint64, v int) uint64 { *p >>= v; return *p }
 
 func AssignShrUintptr(p *uintptr, v int) uintptr { *p >>= v; return *p }
 
-func PreIncInt8(p *int8, d int8) int8             { *p += d; return *p }
-func PreIncInt16(p *int16, d int16) int16         { *p += d; return *p }
-func PreIncInt32(p *int32, d int32) int32         { *p += d; return *p }
-func PreIncInt64(p *int64, d int64) int64         { *p += d; return *p }
-func PreIncUint8(p *uint8, d uint8) uint8         { *p += d; return *p }
-func PreIncUint16(p *uint16, d uint16) uint16     { *p += d; return *p }
-func PreIncUint32(p *uint32, d uint32) uint32     { *p += d; return *p }
-func PreIncUint64(p *uint64, d uint64) uint64     { *p += d; return *p }
-func PreIncFloat32(p *float32, d float32) float32 { *p += d; return *p }
-func PreIncFloat64(p *float64, d float64) float64 { *p += d; return *p }
-func PreIncUintptr(p *uintptr, d uintptr) uintptr { *p += d; return *p }
+func PreIncInt8(p *int8, d int8) int8                         { *p += d; return *p }
+func PreIncInt16(p *int16, d int16) int16                     { *p += d; return *p }
+func PreIncInt32(p *int32, d int32) int32                     { *p += d; return *p }
+func PreIncInt64(p *int64, d int64) int64                     { *p += d; return *p }
+func PreIncUint8(p *uint8, d uint8) uint8                     { *p += d; return *p }
+func PreIncUint16(p *uint16, d uint16) uint16                 { *p += d; return *p }
+func PreIncUint32(p *uint32, d uint32) uint32                 { *p += d; return *p }
+func PreIncUint64(p *uint64, d uint64) uint64                 { *p += d; return *p }
+func PreIncFloat32(p *float32, d float32) float32             { *p += d; return *p }
+func PreIncFloat64(p *float64, d float64) float64             { *p += d; return *p }
+func PreIncComplex64(p *complex64, d complex64) complex64     { *p += d; return *p }
+func PreIncComplex128(p *complex128, d complex128) complex128 { *p += d; return *p }
+func PreIncUintptr(p *uintptr, d uintptr) uintptr             { *p += d; return *p }
 
 func PreIncAtomicInt32(p *int32, d int32) int32         { return atomic.AddInt32(p, d) }
 func PreIncAtomicInt64(p *int64, d int64) int64         { return atomic.AddInt64(p, d) }
@@ -702,17 +762,19 @@ func PreIncAtomicUint32(p *uint32, d uint32) uint32     { return atomic.AddUint3
 func PreIncAtomicUint64(p *uint64, d uint64) uint64     { return atomic.AddUint64(p, d) }
 func PreIncAtomicUintptr(p *uintptr, d uintptr) uintptr { return atomic.AddUintptr(p, d) }
 
-func PreDecInt8(p *int8, d int8) int8             { *p -= d; return *p }
-func PreDecInt16(p *int16, d int16) int16         { *p -= d; return *p }
-func PreDecInt32(p *int32, d int32) int32         { *p -= d; return *p }
-func PreDecInt64(p *int64, d int64) int64         { *p -= d; return *p }
-func PreDecUint8(p *uint8, d uint8) uint8         { *p -= d; return *p }
-func PreDecUint16(p *uint16, d uint16) uint16     { *p -= d; return *p }
-func PreDecUint32(p *uint32, d uint32) uint32     { *p -= d; return *p }
-func PreDecUint64(p *uint64, d uint64) uint64     { *p -= d; return *p }
-func PreDecFloat32(p *float32, d float32) float32 { *p -= d; return *p }
-func PreDecFloat64(p *float64, d float64) float64 { *p -= d; return *p }
-func PreDecUintptr(p *uintptr, d uintptr) uintptr { *p -= d; return *p }
+func PreDecInt8(p *int8, d int8) int8                         { *p -= d; return *p }
+func PreDecInt16(p *int16, d int16) int16                     { *p -= d; return *p }
+func PreDecInt32(p *int32, d int32) int32                     { *p -= d; return *p }
+func PreDecInt64(p *int64, d int64) int64                     { *p -= d; return *p }
+func PreDecUint8(p *uint8, d uint8) uint8                     { *p -= d; return *p }
+func PreDecUint16(p *uint16, d uint16) uint16                 { *p -= d; return *p }
+func PreDecUint32(p *uint32, d uint32) uint32                 { *p -= d; return *p }
+func PreDecUint64(p *uint64, d uint64) uint64                 { *p -= d; return *p }
+func PreDecFloat32(p *float32, d float32) float32             { *p -= d; return *p }
+func PreDecFloat64(p *float64, d float64) float64             { *p -= d; return *p }
+func PreDecComplex64(p *complex64, d complex64) complex64     { *p -= d; return *p }
+func PreDecComplex128(p *complex128, d complex128) complex128 { *p -= d; return *p }
+func PreDecUintptr(p *uintptr, d uintptr) uintptr             { *p -= d; return *p }
 
 func PreDecAtomicInt32(p *int32, d int32) int32         { return atomic.AddInt32(p, -d) }
 func PreDecAtomicInt64(p *int64, d int64) int64         { return atomic.AddInt64(p, -d) }
@@ -720,17 +782,19 @@ func PreDecAtomicUint32(p *uint32, d uint32) uint32     { return atomic.AddUint3
 func PreDecAtomicUint64(p *uint64, d uint64) uint64     { return atomic.AddUint64(p, -d) }
 func PreDecAtomicUintptr(p *uintptr, d uintptr) uintptr { return atomic.AddUintptr(p, -d) }
 
-func PostIncInt8(p *int8, d int8) int8             { r := *p; *p += d; return r }
-func PostIncInt16(p *int16, d int16) int16         { r := *p; *p += d; return r }
-func PostIncInt32(p *int32, d int32) int32         { r := *p; *p += d; return r }
-func PostIncInt64(p *int64, d int64) int64         { r := *p; *p += d; return r }
-func PostIncUint8(p *uint8, d uint8) uint8         { r := *p; *p += d; return r }
-func PostIncUint16(p *uint16, d uint16) uint16     { r := *p; *p += d; return r }
-func PostIncUint32(p *uint32, d uint32) uint32     { r := *p; *p += d; return r }
-func PostIncUint64(p *uint64, d uint64) uint64     { r := *p; *p += d; return r }
-func PostIncFloat32(p *float32, d float32) float32 { r := *p; *p += d; return r }
-func PostIncFloat64(p *float64, d float64) float64 { r := *p; *p += d; return r }
-func PostIncUintptr(p *uintptr, d uintptr) uintptr { r := *p; *p += d; return r }
+func PostIncInt8(p *int8, d int8) int8                         { r := *p; *p += d; return r }
+func PostIncInt16(p *int16, d int16) int16                     { r := *p; *p += d; return r }
+func PostIncInt32(p *int32, d int32) int32                     { r := *p; *p += d; return r }
+func PostIncInt64(p *int64, d int64) int64                     { r := *p; *p += d; return r }
+func PostIncUint8(p *uint8, d uint8) uint8                     { r := *p; *p += d; return r }
+func PostIncUint16(p *uint16, d uint16) uint16                 { r := *p; *p += d; return r }
+func PostIncUint32(p *uint32, d uint32) uint32                 { r := *p; *p += d; return r }
+func PostIncUint64(p *uint64, d uint64) uint64                 { r := *p; *p += d; return r }
+func PostIncFloat32(p *float32, d float32) float32             { r := *p; *p += d; return r }
+func PostIncFloat64(p *float64, d float64) float64             { r := *p; *p += d; return r }
+func PostIncComplex64(p *complex64, d complex64) complex64     { r := *p; *p += d; return r }
+func PostIncComplex128(p *complex128, d complex128) complex128 { r := *p; *p += d; return r }
+func PostIncUintptr(p *uintptr, d uintptr) uintptr             { r := *p; *p += d; return r }
 
 func PostIncAtomicInt32(p *int32, d int32) int32         { return atomic.AddInt32(p, d) - d }
 func PostIncAtomicInt64(p *int64, d int64) int64         { return atomic.AddInt64(p, d) - d }
@@ -738,17 +802,19 @@ func PostIncAtomicUint32(p *uint32, d uint32) uint32     { return atomic.AddUint
 func PostIncAtomicUint64(p *uint64, d uint64) uint64     { return atomic.AddUint64(p, d) - d }
 func PostIncAtomicUintptr(p *uintptr, d uintptr) uintptr { return atomic.AddUintptr(p, d) - d }
 
-func PostDecInt8(p *int8, d int8) int8             { r := *p; *p -= d; return r }
-func PostDecInt16(p *int16, d int16) int16         { r := *p; *p -= d; return r }
-func PostDecInt32(p *int32, d int32) int32         { r := *p; *p -= d; return r }
-func PostDecInt64(p *int64, d int64) int64         { r := *p; *p -= d; return r }
-func PostDecUint8(p *uint8, d uint8) uint8         { r := *p; *p -= d; return r }
-func PostDecUint16(p *uint16, d uint16) uint16     { r := *p; *p -= d; return r }
-func PostDecUint32(p *uint32, d uint32) uint32     { r := *p; *p -= d; return r }
-func PostDecUint64(p *uint64, d uint64) uint64     { r := *p; *p -= d; return r }
-func PostDecFloat32(p *float32, d float32) float32 { r := *p; *p -= d; return r }
-func PostDecFloat64(p *float64, d float64) float64 { r := *p; *p -= d; return r }
-func PostDecUintptr(p *uintptr, d uintptr) uintptr { r := *p; *p -= d; return r }
+func PostDecInt8(p *int8, d int8) int8                         { r := *p; *p -= d; return r }
+func PostDecInt16(p *int16, d int16) int16                     { r := *p; *p -= d; return r }
+func PostDecInt32(p *int32, d int32) int32                     { r := *p; *p -= d; return r }
+func PostDecInt64(p *int64, d int64) int64                     { r := *p; *p -= d; return r }
+func PostDecUint8(p *uint8, d uint8) uint8                     { r := *p; *p -= d; return r }
+func PostDecUint16(p *uint16, d uint16) uint16                 { r := *p; *p -= d; return r }
+func PostDecUint32(p *uint32, d uint32) uint32                 { r := *p; *p -= d; return r }
+func PostDecUint64(p *uint64, d uint64) uint64                 { r := *p; *p -= d; return r }
+func PostDecFloat32(p *float32, d float32) float32             { r := *p; *p -= d; return r }
+func PostDecFloat64(p *float64, d float64) float64             { r := *p; *p -= d; return r }
+func PostDecComplex64(p *complex64, d complex64) complex64     { r := *p; *p -= d; return r }
+func PostDecComplex128(p *complex128, d complex128) complex128 { r := *p; *p -= d; return r }
+func PostDecUintptr(p *uintptr, d uintptr) uintptr             { r := *p; *p -= d; return r }
 
 func PostDecAtomicInt32(p *int32, d int32) int32         { return atomic.AddInt32(p, -d) + d }
 func PostDecAtomicInt64(p *int64, d int64) int64         { return atomic.AddInt64(p, -d) + d }
@@ -756,139 +822,189 @@ func PostDecAtomicUint32(p *uint32, d uint32) uint32     { return atomic.AddUint
 func PostDecAtomicUint64(p *uint64, d uint64) uint64     { return atomic.AddUint64(p, -d) + d }
 func PostDecAtomicUintptr(p *uintptr, d uintptr) uintptr { return atomic.AddUintptr(p, -d) + d }
 
-func Int8FromInt8(n int8) int8             { return int8(n) }
-func Int8FromInt16(n int16) int8           { return int8(n) }
-func Int8FromInt32(n int32) int8           { return int8(n) }
-func Int8FromInt64(n int64) int8           { return int8(n) }
-func Int8FromUint8(n uint8) int8           { return int8(n) }
-func Int8FromUint16(n uint16) int8         { return int8(n) }
-func Int8FromUint32(n uint32) int8         { return int8(n) }
-func Int8FromUint64(n uint64) int8         { return int8(n) }
-func Int8FromFloat32(n float32) int8       { return int8(n) }
-func Int8FromFloat64(n float64) int8       { return int8(n) }
-func Int8FromUintptr(n uintptr) int8       { return int8(n) }
-func Int16FromInt8(n int8) int16           { return int16(n) }
-func Int16FromInt16(n int16) int16         { return int16(n) }
-func Int16FromInt32(n int32) int16         { return int16(n) }
-func Int16FromInt64(n int64) int16         { return int16(n) }
-func Int16FromUint8(n uint8) int16         { return int16(n) }
-func Int16FromUint16(n uint16) int16       { return int16(n) }
-func Int16FromUint32(n uint32) int16       { return int16(n) }
-func Int16FromUint64(n uint64) int16       { return int16(n) }
-func Int16FromFloat32(n float32) int16     { return int16(n) }
-func Int16FromFloat64(n float64) int16     { return int16(n) }
-func Int16FromUintptr(n uintptr) int16     { return int16(n) }
-func Int32FromInt8(n int8) int32           { return int32(n) }
-func Int32FromInt16(n int16) int32         { return int32(n) }
-func Int32FromInt32(n int32) int32         { return int32(n) }
-func Int32FromInt64(n int64) int32         { return int32(n) }
-func Int32FromUint8(n uint8) int32         { return int32(n) }
-func Int32FromUint16(n uint16) int32       { return int32(n) }
-func Int32FromUint32(n uint32) int32       { return int32(n) }
-func Int32FromUint64(n uint64) int32       { return int32(n) }
-func Int32FromFloat32(n float32) int32     { return int32(n) }
-func Int32FromFloat64(n float64) int32     { return int32(n) }
-func Int32FromUintptr(n uintptr) int32     { return int32(n) }
-func Int64FromInt8(n int8) int64           { return int64(n) }
-func Int64FromInt16(n int16) int64         { return int64(n) }
-func Int64FromInt32(n int32) int64         { return int64(n) }
-func Int64FromInt64(n int64) int64         { return int64(n) }
-func Int64FromUint8(n uint8) int64         { return int64(n) }
-func Int64FromUint16(n uint16) int64       { return int64(n) }
-func Int64FromUint32(n uint32) int64       { return int64(n) }
-func Int64FromUint64(n uint64) int64       { return int64(n) }
-func Int64FromFloat32(n float32) int64     { return int64(n) }
-func Int64FromFloat64(n float64) int64     { return int64(n) }
-func Int64FromUintptr(n uintptr) int64     { return int64(n) }
-func Uint8FromInt8(n int8) uint8           { return uint8(n) }
-func Uint8FromInt16(n int16) uint8         { return uint8(n) }
-func Uint8FromInt32(n int32) uint8         { return uint8(n) }
-func Uint8FromInt64(n int64) uint8         { return uint8(n) }
-func Uint8FromUint8(n uint8) uint8         { return uint8(n) }
-func Uint8FromUint16(n uint16) uint8       { return uint8(n) }
-func Uint8FromUint32(n uint32) uint8       { return uint8(n) }
-func Uint8FromUint64(n uint64) uint8       { return uint8(n) }
-func Uint8FromFloat32(n float32) uint8     { return uint8(n) }
-func Uint8FromFloat64(n float64) uint8     { return uint8(n) }
-func Uint8FromUintptr(n uintptr) uint8     { return uint8(n) }
-func Uint16FromInt8(n int8) uint16         { return uint16(n) }
-func Uint16FromInt16(n int16) uint16       { return uint16(n) }
-func Uint16FromInt32(n int32) uint16       { return uint16(n) }
-func Uint16FromInt64(n int64) uint16       { return uint16(n) }
-func Uint16FromUint8(n uint8) uint16       { return uint16(n) }
-func Uint16FromUint16(n uint16) uint16     { return uint16(n) }
-func Uint16FromUint32(n uint32) uint16     { return uint16(n) }
-func Uint16FromUint64(n uint64) uint16     { return uint16(n) }
-func Uint16FromFloat32(n float32) uint16   { return uint16(n) }
-func Uint16FromFloat64(n float64) uint16   { return uint16(n) }
-func Uint16FromUintptr(n uintptr) uint16   { return uint16(n) }
-func Uint32FromInt8(n int8) uint32         { return uint32(n) }
-func Uint32FromInt16(n int16) uint32       { return uint32(n) }
-func Uint32FromInt32(n int32) uint32       { return uint32(n) }
-func Uint32FromInt64(n int64) uint32       { return uint32(n) }
-func Uint32FromUint8(n uint8) uint32       { return uint32(n) }
-func Uint32FromUint16(n uint16) uint32     { return uint32(n) }
-func Uint32FromUint32(n uint32) uint32     { return uint32(n) }
-func Uint32FromUint64(n uint64) uint32     { return uint32(n) }
-func Uint32FromFloat32(n float32) uint32   { return uint32(n) }
-func Uint32FromFloat64(n float64) uint32   { return uint32(n) }
-func Uint32FromUintptr(n uintptr) uint32   { return uint32(n) }
-func Uint64FromInt8(n int8) uint64         { return uint64(n) }
-func Uint64FromInt16(n int16) uint64       { return uint64(n) }
-func Uint64FromInt32(n int32) uint64       { return uint64(n) }
-func Uint64FromInt64(n int64) uint64       { return uint64(n) }
-func Uint64FromUint8(n uint8) uint64       { return uint64(n) }
-func Uint64FromUint16(n uint16) uint64     { return uint64(n) }
-func Uint64FromUint32(n uint32) uint64     { return uint64(n) }
-func Uint64FromUint64(n uint64) uint64     { return uint64(n) }
-func Uint64FromFloat32(n float32) uint64   { return uint64(n) }
-func Uint64FromFloat64(n float64) uint64   { return uint64(n) }
-func Uint64FromUintptr(n uintptr) uint64   { return uint64(n) }
-func Float32FromInt8(n int8) float32       { return float32(n) }
-func Float32FromInt16(n int16) float32     { return float32(n) }
-func Float32FromInt32(n int32) float32     { return float32(n) }
-func Float32FromInt64(n int64) float32     { return float32(n) }
-func Float32FromUint8(n uint8) float32     { return float32(n) }
-func Float32FromUint16(n uint16) float32   { return float32(n) }
-func Float32FromUint32(n uint32) float32   { return float32(n) }
-func Float32FromUint64(n uint64) float32   { return float32(n) }
-func Float32FromFloat32(n float32) float32 { return float32(n) }
-func Float32FromFloat64(n float64) float32 { return float32(n) }
-func Float32FromUintptr(n uintptr) float32 { return float32(n) }
-func Float64FromInt8(n int8) float64       { return float64(n) }
-func Float64FromInt16(n int16) float64     { return float64(n) }
-func Float64FromInt32(n int32) float64     { return float64(n) }
-func Float64FromInt64(n int64) float64     { return float64(n) }
-func Float64FromUint8(n uint8) float64     { return float64(n) }
-func Float64FromUint16(n uint16) float64   { return float64(n) }
-func Float64FromUint32(n uint32) float64   { return float64(n) }
-func Float64FromUint64(n uint64) float64   { return float64(n) }
-func Float64FromFloat32(n float32) float64 { return float64(n) }
-func Float64FromFloat64(n float64) float64 { return float64(n) }
-func Float64FromUintptr(n uintptr) float64 { return float64(n) }
-func UintptrFromInt8(n int8) uintptr       { return uintptr(n) }
-func UintptrFromInt16(n int16) uintptr     { return uintptr(n) }
-func UintptrFromInt32(n int32) uintptr     { return uintptr(n) }
-func UintptrFromInt64(n int64) uintptr     { return uintptr(n) }
-func UintptrFromUint8(n uint8) uintptr     { return uintptr(n) }
-func UintptrFromUint16(n uint16) uintptr   { return uintptr(n) }
-func UintptrFromUint32(n uint32) uintptr   { return uintptr(n) }
-func UintptrFromUint64(n uint64) uintptr   { return uintptr(n) }
-func UintptrFromFloat32(n float32) uintptr { return uintptr(n) }
-func UintptrFromFloat64(n float64) uintptr { return uintptr(n) }
-func UintptrFromUintptr(n uintptr) uintptr { return uintptr(n) }
-
-func Int8(n int8) int8          { return n }
-func Int16(n int16) int16       { return n }
-func Int32(n int32) int32       { return n }
-func Int64(n int64) int64       { return n }
-func Uint8(n uint8) uint8       { return n }
-func Uint16(n uint16) uint16    { return n }
-func Uint32(n uint32) uint32    { return n }
-func Uint64(n uint64) uint64    { return n }
-func Float32(n float32) float32 { return n }
-func Float64(n float64) float64 { return n }
-func Uintptr(n uintptr) uintptr { return n }
+func Int8FromInt8(n int8) int8                         { return int8(n) }
+func Int8FromInt16(n int16) int8                       { return int8(n) }
+func Int8FromInt32(n int32) int8                       { return int8(n) }
+func Int8FromInt64(n int64) int8                       { return int8(n) }
+func Int8FromUint8(n uint8) int8                       { return int8(n) }
+func Int8FromUint16(n uint16) int8                     { return int8(n) }
+func Int8FromUint32(n uint32) int8                     { return int8(n) }
+func Int8FromUint64(n uint64) int8                     { return int8(n) }
+func Int8FromFloat32(n float32) int8                   { return int8(n) }
+func Int8FromFloat64(n float64) int8                   { return int8(n) }
+func Int8FromComplex64(n complex64) int8               { return int8(real(n)) }
+func Int8FromComplex128(n complex128) int8             { return int8(real(n)) }
+func Int8FromUintptr(n uintptr) int8                   { return int8(n) }
+func Int16FromInt8(n int8) int16                       { return int16(n) }
+func Int16FromInt16(n int16) int16                     { return int16(n) }
+func Int16FromInt32(n int32) int16                     { return int16(n) }
+func Int16FromInt64(n int64) int16                     { return int16(n) }
+func Int16FromUint8(n uint8) int16                     { return int16(n) }
+func Int16FromUint16(n uint16) int16                   { return int16(n) }
+func Int16FromUint32(n uint32) int16                   { return int16(n) }
+func Int16FromUint64(n uint64) int16                   { return int16(n) }
+func Int16FromFloat32(n float32) int16                 { return int16(n) }
+func Int16FromFloat64(n float64) int16                 { return int16(n) }
+func Int16FromComplex64(n complex64) int16             { return int16(real(n)) }
+func Int16FromComplex128(n complex128) int16           { return int16(real(n)) }
+func Int16FromUintptr(n uintptr) int16                 { return int16(n) }
+func Int32FromInt8(n int8) int32                       { return int32(n) }
+func Int32FromInt16(n int16) int32                     { return int32(n) }
+func Int32FromInt32(n int32) int32                     { return int32(n) }
+func Int32FromInt64(n int64) int32                     { return int32(n) }
+func Int32FromUint8(n uint8) int32                     { return int32(n) }
+func Int32FromUint16(n uint16) int32                   { return int32(n) }
+func Int32FromUint32(n uint32) int32                   { return int32(n) }
+func Int32FromUint64(n uint64) int32                   { return int32(n) }
+func Int32FromFloat32(n float32) int32                 { return int32(n) }
+func Int32FromFloat64(n float64) int32                 { return int32(n) }
+func Int32FromComplex64(n complex64) int32             { return int32(real(n)) }
+func Int32FromComplex128(n complex128) int32           { return int32(real(n)) }
+func Int32FromUintptr(n uintptr) int32                 { return int32(n) }
+func Int64FromInt8(n int8) int64                       { return int64(n) }
+func Int64FromInt16(n int16) int64                     { return int64(n) }
+func Int64FromInt32(n int32) int64                     { return int64(n) }
+func Int64FromInt64(n int64) int64                     { return int64(n) }
+func Int64FromUint8(n uint8) int64                     { return int64(n) }
+func Int64FromUint16(n uint16) int64                   { return int64(n) }
+func Int64FromUint32(n uint32) int64                   { return int64(n) }
+func Int64FromUint64(n uint64) int64                   { return int64(n) }
+func Int64FromFloat32(n float32) int64                 { return int64(n) }
+func Int64FromFloat64(n float64) int64                 { return int64(n) }
+func Int64FromComplex64(n complex64) int64             { return int64(real(n)) }
+func Int64FromComplex128(n complex128) int64           { return int64(real(n)) }
+func Int64FromUintptr(n uintptr) int64                 { return int64(n) }
+func Uint8FromInt8(n int8) uint8                       { return uint8(n) }
+func Uint8FromInt16(n int16) uint8                     { return uint8(n) }
+func Uint8FromInt32(n int32) uint8                     { return uint8(n) }
+func Uint8FromInt64(n int64) uint8                     { return uint8(n) }
+func Uint8FromUint8(n uint8) uint8                     { return uint8(n) }
+func Uint8FromUint16(n uint16) uint8                   { return uint8(n) }
+func Uint8FromUint32(n uint32) uint8                   { return uint8(n) }
+func Uint8FromUint64(n uint64) uint8                   { return uint8(n) }
+func Uint8FromFloat32(n float32) uint8                 { return uint8(n) }
+func Uint8FromFloat64(n float64) uint8                 { return uint8(n) }
+func Uint8FromComplex64(n complex64) uint8             { return uint8(real(n)) }
+func Uint8FromComplex128(n complex128) uint8           { return uint8(real(n)) }
+func Uint8FromUintptr(n uintptr) uint8                 { return uint8(n) }
+func Uint16FromInt8(n int8) uint16                     { return uint16(n) }
+func Uint16FromInt16(n int16) uint16                   { return uint16(n) }
+func Uint16FromInt32(n int32) uint16                   { return uint16(n) }
+func Uint16FromInt64(n int64) uint16                   { return uint16(n) }
+func Uint16FromUint8(n uint8) uint16                   { return uint16(n) }
+func Uint16FromUint16(n uint16) uint16                 { return uint16(n) }
+func Uint16FromUint32(n uint32) uint16                 { return uint16(n) }
+func Uint16FromUint64(n uint64) uint16                 { return uint16(n) }
+func Uint16FromFloat32(n float32) uint16               { return uint16(n) }
+func Uint16FromFloat64(n float64) uint16               { return uint16(n) }
+func Uint16FromComplex64(n complex64) uint16           { return uint16(real(n)) }
+func Uint16FromComplex128(n complex128) uint16         { return uint16(real(n)) }
+func Uint16FromUintptr(n uintptr) uint16               { return uint16(n) }
+func Uint32FromInt8(n int8) uint32                     { return uint32(n) }
+func Uint32FromInt16(n int16) uint32                   { return uint32(n) }
+func Uint32FromInt32(n int32) uint32                   { return uint32(n) }
+func Uint32FromInt64(n int64) uint32                   { return uint32(n) }
+func Uint32FromUint8(n uint8) uint32                   { return uint32(n) }
+func Uint32FromUint16(n uint16) uint32                 { return uint32(n) }
+func Uint32FromUint32(n uint32) uint32                 { return uint32(n) }
+func Uint32FromUint64(n uint64) uint32                 { return uint32(n) }
+func Uint32FromFloat32(n float32) uint32               { return uint32(n) }
+func Uint32FromFloat64(n float64) uint32               { return uint32(n) }
+func Uint32FromComplex64(n complex64) uint32           { return uint32(real(n)) }
+func Uint32FromComplex128(n complex128) uint32         { return uint32(real(n)) }
+func Uint32FromUintptr(n uintptr) uint32               { return uint32(n) }
+func Uint64FromInt8(n int8) uint64                     { return uint64(n) }
+func Uint64FromInt16(n int16) uint64                   { return uint64(n) }
+func Uint64FromInt32(n int32) uint64                   { return uint64(n) }
+func Uint64FromInt64(n int64) uint64                   { return uint64(n) }
+func Uint64FromUint8(n uint8) uint64                   { return uint64(n) }
+func Uint64FromUint16(n uint16) uint64                 { return uint64(n) }
+func Uint64FromUint32(n uint32) uint64                 { return uint64(n) }
+func Uint64FromUint64(n uint64) uint64                 { return uint64(n) }
+func Uint64FromFloat32(n float32) uint64               { return uint64(n) }
+func Uint64FromFloat64(n float64) uint64               { return uint64(n) }
+func Uint64FromComplex64(n complex64) uint64           { return uint64(real(n)) }
+func Uint64FromComplex128(n complex128) uint64         { return uint64(real(n)) }
+func Uint64FromUintptr(n uintptr) uint64               { return uint64(n) }
+func Float32FromInt8(n int8) float32                   { return float32(n) }
+func Float32FromInt16(n int16) float32                 { return float32(n) }
+func Float32FromInt32(n int32) float32                 { return float32(n) }
+func Float32FromInt64(n int64) float32                 { return float32(n) }
+func Float32FromUint8(n uint8) float32                 { return float32(n) }
+func Float32FromUint16(n uint16) float32               { return float32(n) }
+func Float32FromUint32(n uint32) float32               { return float32(n) }
+func Float32FromUint64(n uint64) float32               { return float32(n) }
+func Float32FromFloat32(n float32) float32             { return float32(n) }
+func Float32FromFloat64(n float64) float32             { return float32(n) }
+func Float32FromComplex64(n complex64) float32         { return float32(real(n)) }
+func Float32FromComplex128(n complex128) float32       { return float32(real(n)) }
+func Float32FromUintptr(n uintptr) float32             { return float32(n) }
+func Float64FromInt8(n int8) float64                   { return float64(n) }
+func Float64FromInt16(n int16) float64                 { return float64(n) }
+func Float64FromInt32(n int32) float64                 { return float64(n) }
+func Float64FromInt64(n int64) float64                 { return float64(n) }
+func Float64FromUint8(n uint8) float64                 { return float64(n) }
+func Float64FromUint16(n uint16) float64               { return float64(n) }
+func Float64FromUint32(n uint32) float64               { return float64(n) }
+func Float64FromUint64(n uint64) float64               { return float64(n) }
+func Float64FromFloat32(n float32) float64             { return float64(n) }
+func Float64FromFloat64(n float64) float64             { return float64(n) }
+func Float64FromComplex64(n complex64) float64         { return float64(real(n)) }
+func Float64FromComplex128(n complex128) float64       { return float64(real(n)) }
+func Float64FromUintptr(n uintptr) float64             { return float64(n) }
+func Complex64FromInt8(n int8) complex64               { return complex64(complex(float32(n), 0)) }
+func Complex64FromInt16(n int16) complex64             { return complex64(complex(float32(n), 0)) }
+func Complex64FromInt32(n int32) complex64             { return complex64(complex(float32(n), 0)) }
+func Complex64FromInt64(n int64) complex64             { return complex64(complex(float32(n), 0)) }
+func Complex64FromUint8(n uint8) complex64             { return complex64(complex(float32(n), 0)) }
+func Complex64FromUint16(n uint16) complex64           { return complex64(complex(float32(n), 0)) }
+func Complex64FromUint32(n uint32) complex64           { return complex64(complex(float32(n), 0)) }
+func Complex64FromUint64(n uint64) complex64           { return complex64(complex(float32(n), 0)) }
+func Complex64FromFloat32(n float32) complex64         { return complex64(complex(float32(n), 0)) }
+func Complex64FromFloat64(n float64) complex64         { return complex64(complex(float32(n), 0)) }
+func Complex64FromComplex64(n complex64) complex64     { return complex64(n) }
+func Complex64FromComplex128(n complex128) complex64   { return complex64(n) }
+func Complex64FromUintptr(n uintptr) complex64         { return complex64(complex(float32(n), 0)) }
+func Complex128FromInt8(n int8) complex128             { return complex128(complex(float64(n), 0)) }
+func Complex128FromInt16(n int16) complex128           { return complex128(complex(float64(n), 0)) }
+func Complex128FromInt32(n int32) complex128           { return complex128(complex(float64(n), 0)) }
+func Complex128FromInt64(n int64) complex128           { return complex128(complex(float64(n), 0)) }
+func Complex128FromUint8(n uint8) complex128           { return complex128(complex(float64(n), 0)) }
+func Complex128FromUint16(n uint16) complex128         { return complex128(complex(float64(n), 0)) }
+func Complex128FromUint32(n uint32) complex128         { return complex128(complex(float64(n), 0)) }
+func Complex128FromUint64(n uint64) complex128         { return complex128(complex(float64(n), 0)) }
+func Complex128FromFloat32(n float32) complex128       { return complex128(complex(float64(n), 0)) }
+func Complex128FromFloat64(n float64) complex128       { return complex128(complex(float64(n), 0)) }
+func Complex128FromComplex64(n complex64) complex128   { return complex128(n) }
+func Complex128FromComplex128(n complex128) complex128 { return complex128(n) }
+func Complex128FromUintptr(n uintptr) complex128       { return complex128(complex(float64(n), 0)) }
+func UintptrFromInt8(n int8) uintptr                   { return uintptr(n) }
+func UintptrFromInt16(n int16) uintptr                 { return uintptr(n) }
+func UintptrFromInt32(n int32) uintptr                 { return uintptr(n) }
+func UintptrFromInt64(n int64) uintptr                 { return uintptr(n) }
+func UintptrFromUint8(n uint8) uintptr                 { return uintptr(n) }
+func UintptrFromUint16(n uint16) uintptr               { return uintptr(n) }
+func UintptrFromUint32(n uint32) uintptr               { return uintptr(n) }
+func UintptrFromUint64(n uint64) uintptr               { return uintptr(n) }
+func UintptrFromFloat32(n float32) uintptr             { return uintptr(n) }
+func UintptrFromFloat64(n float64) uintptr             { return uintptr(n) }
+func UintptrFromComplex64(n complex64) uintptr         { return uintptr(real(n)) }
+func UintptrFromComplex128(n complex128) uintptr       { return uintptr(real(n)) }
+func UintptrFromUintptr(n uintptr) uintptr             { return uintptr(n) }
+
+func Int8(n int8) int8                   { return n }
+func Int16(n int16) int16                { return n }
+func Int32(n int32) int32                { return n }
+func Int64(n int64) int64                { return n }
+func Uint8(n uint8) uint8                { return n }
+func Uint16(n uint16) uint16             { return n }
+func Uint32(n uint32) uint32             { return n }
+func Uint64(n uint64) uint64             { return n }
+func Float32(n float32) float32          { return n }
+func Float64(n float64) float64          { return n }
+func Complex64(n complex64) complex64    { return n }
+func Complex128(n complex128) complex128 { return n }
+func Uintptr(n uintptr) uintptr          { return n }
 
 func NegInt8(n int8) int8          { return -n }
 func NegInt16(n int16) int16       { return -n }
@@ -1272,7 +1388,7 @@ func AssignBitFieldPtr64Uint64(p uintptr, v uint64, w, off int, mask uint64) uin
 
 func PostDecBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8) {
 	x0 := *(*uint8)(unsafe.Pointer(p))
-	s := 8 - w
+	s := 8 - w - off
 	r = int8(x0) & int8(mask) << s >> (s + off)
 	*(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
 	return r
@@ -1280,7 +1396,7 @@ func PostDecBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8)
 
 func PostDecBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int16) {
 	x0 := *(*uint8)(unsafe.Pointer(p))
-	s := 16 - w
+	s := 16 - w - off
 	r = int16(x0) & int16(mask) << s >> (s + off)
 	*(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
 	return r
@@ -1288,7 +1404,7 @@ func PostDecBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int
 
 func PostDecBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int32) {
 	x0 := *(*uint8)(unsafe.Pointer(p))
-	s := 32 - w
+	s := 32 - w - off
 	r = int32(x0) & int32(mask) << s >> (s + off)
 	*(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
 	return r
@@ -1296,7 +1412,7 @@ func PostDecBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int
 
 func PostDecBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int64) {
 	x0 := *(*uint8)(unsafe.Pointer(p))
-	s := 64 - w
+	s := 64 - w - off
 	r = int64(x0) & int64(mask) << s >> (s + off)
 	*(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r-d)<<off&mask
 	return r
@@ -1304,7 +1420,7 @@ func PostDecBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int
 
 func PostDecBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int8) {
 	x0 := *(*uint16)(unsafe.Pointer(p))
-	s := 8 - w
+	s := 8 - w - off
 	r = int8(x0) & int8(mask) << s >> (s + off)
 	*(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
 	return r
@@ -1312,7 +1428,7 @@ func PostDecBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int
 
 func PostDecBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r int16) {
 	x0 := *(*uint16)(unsafe.Pointer(p))
-	s := 16 - w
+	s := 16 - w - off
 	r = int16(x0) & int16(mask) << s >> (s + off)
 	*(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
 	return r
@@ -1320,7 +1436,7 @@ func PostDecBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r i
 
 func PostDecBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r int32) {
 	x0 := *(*uint16)(unsafe.Pointer(p))
-	s := 32 - w
+	s := 32 - w - off
 	r = int32(x0) & int32(mask) << s >> (s + off)
 	*(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
 	return r
@@ -1328,7 +1444,7 @@ func PostDecBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r i
 
 func PostDecBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r int64) {
 	x0 := *(*uint16)(unsafe.Pointer(p))
-	s := 64 - w
+	s := 64 - w - off
 	r = int64(x0) & int64(mask) << s >> (s + off)
 	*(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r-d)<<off&mask
 	return r
@@ -1336,7 +1452,7 @@ func PostDecBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r i
 
 func PostDecBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int8) {
 	x0 := *(*uint32)(unsafe.Pointer(p))
-	s := 8 - w
+	s := 8 - w - off
 	r = int8(x0) & int8(mask) << s >> (s + off)
 	*(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
 	return r
@@ -1344,7 +1460,7 @@ func PostDecBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int
 
 func PostDecBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r int16) {
 	x0 := *(*uint32)(unsafe.Pointer(p))
-	s := 16 - w
+	s := 16 - w - off
 	r = int16(x0) & int16(mask) << s >> (s + off)
 	*(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
 	return r
@@ -1352,7 +1468,7 @@ func PostDecBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r i
 
 func PostDecBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r int32) {
 	x0 := *(*uint32)(unsafe.Pointer(p))
-	s := 32 - w
+	s := 32 - w - off
 	r = int32(x0) & int32(mask) << s >> (s + off)
 	*(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
 	return r
@@ -1360,7 +1476,7 @@ func PostDecBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r i
 
 func PostDecBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r int64) {
 	x0 := *(*uint32)(unsafe.Pointer(p))
-	s := 64 - w
+	s := 64 - w - off
 	r = int64(x0) & int64(mask) << s >> (s + off)
 	*(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r-d)<<off&mask
 	return r
@@ -1368,7 +1484,7 @@ func PostDecBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r i
 
 func PostDecBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int8) {
 	x0 := *(*uint64)(unsafe.Pointer(p))
-	s := 8 - w
+	s := 8 - w - off
 	r = int8(x0) & int8(mask) << s >> (s + off)
 	*(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
 	return r
@@ -1376,7 +1492,7 @@ func PostDecBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int
 
 func PostDecBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r int16) {
 	x0 := *(*uint64)(unsafe.Pointer(p))
-	s := 16 - w
+	s := 16 - w - off
 	r = int16(x0) & int16(mask) << s >> (s + off)
 	*(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
 	return r
@@ -1384,7 +1500,7 @@ func PostDecBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r i
 
 func PostDecBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r int32) {
 	x0 := *(*uint64)(unsafe.Pointer(p))
-	s := 32 - w
+	s := 32 - w - off
 	r = int32(x0) & int32(mask) << s >> (s + off)
 	*(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
 	return r
@@ -1392,7 +1508,7 @@ func PostDecBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r i
 
 func PostDecBitFieldPtr64Int64(p uintptr, d int64, w, off int, mask uint64) (r int64) {
 	x0 := *(*uint64)(unsafe.Pointer(p))
-	s := 64 - w
+	s := 64 - w - off
 	r = int64(x0) & int64(mask) << s >> (s + off)
 	*(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r-d)<<off&mask
 	return r
@@ -1512,7 +1628,7 @@ func PostDecBitFieldPtr64Uint64(p uintptr, d uint64, w, off int, mask uint64) (r
 
 func PostIncBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8) {
 	x0 := *(*uint8)(unsafe.Pointer(p))
-	s := 8 - w
+	s := 8 - w - off
 	r = int8(x0) & int8(mask) << s >> (s + off)
 	*(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
 	return r
@@ -1520,7 +1636,7 @@ func PostIncBitFieldPtr8Int8(p uintptr, d int8, w, off int, mask uint8) (r int8)
 
 func PostIncBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int16) {
 	x0 := *(*uint8)(unsafe.Pointer(p))
-	s := 16 - w
+	s := 16 - w - off
 	r = int16(x0) & int16(mask) << s >> (s + off)
 	*(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
 	return r
@@ -1528,7 +1644,7 @@ func PostIncBitFieldPtr8Int16(p uintptr, d int16, w, off int, mask uint8) (r int
 
 func PostIncBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int32) {
 	x0 := *(*uint8)(unsafe.Pointer(p))
-	s := 32 - w
+	s := 32 - w - off
 	r = int32(x0) & int32(mask) << s >> (s + off)
 	*(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
 	return r
@@ -1536,7 +1652,7 @@ func PostIncBitFieldPtr8Int32(p uintptr, d int32, w, off int, mask uint8) (r int
 
 func PostIncBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int64) {
 	x0 := *(*uint8)(unsafe.Pointer(p))
-	s := 64 - w
+	s := 64 - w - off
 	r = int64(x0) & int64(mask) << s >> (s + off)
 	*(*uint8)(unsafe.Pointer(p)) = x0&^uint8(mask) | uint8(r+d)<<off&mask
 	return r
@@ -1544,7 +1660,7 @@ func PostIncBitFieldPtr8Int64(p uintptr, d int64, w, off int, mask uint8) (r int
 
 func PostIncBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int8) {
 	x0 := *(*uint16)(unsafe.Pointer(p))
-	s := 8 - w
+	s := 8 - w - off
 	r = int8(x0) & int8(mask) << s >> (s + off)
 	*(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
 	return r
@@ -1552,7 +1668,7 @@ func PostIncBitFieldPtr16Int8(p uintptr, d int8, w, off int, mask uint16) (r int
 
 func PostIncBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r int16) {
 	x0 := *(*uint16)(unsafe.Pointer(p))
-	s := 16 - w
+	s := 16 - w - off
 	r = int16(x0) & int16(mask) << s >> (s + off)
 	*(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
 	return r
@@ -1560,7 +1676,7 @@ func PostIncBitFieldPtr16Int16(p uintptr, d int16, w, off int, mask uint16) (r i
 
 func PostIncBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r int32) {
 	x0 := *(*uint16)(unsafe.Pointer(p))
-	s := 32 - w
+	s := 32 - w - off
 	r = int32(x0) & int32(mask) << s >> (s + off)
 	*(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
 	return r
@@ -1568,7 +1684,7 @@ func PostIncBitFieldPtr16Int32(p uintptr, d int32, w, off int, mask uint16) (r i
 
 func PostIncBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r int64) {
 	x0 := *(*uint16)(unsafe.Pointer(p))
-	s := 64 - w
+	s := 64 - w - off
 	r = int64(x0) & int64(mask) << s >> (s + off)
 	*(*uint16)(unsafe.Pointer(p)) = x0&^uint16(mask) | uint16(r+d)<<off&mask
 	return r
@@ -1576,7 +1692,7 @@ func PostIncBitFieldPtr16Int64(p uintptr, d int64, w, off int, mask uint16) (r i
 
 func PostIncBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int8) {
 	x0 := *(*uint32)(unsafe.Pointer(p))
-	s := 8 - w
+	s := 8 - w - off
 	r = int8(x0) & int8(mask) << s >> (s + off)
 	*(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
 	return r
@@ -1584,7 +1700,7 @@ func PostIncBitFieldPtr32Int8(p uintptr, d int8, w, off int, mask uint32) (r int
 
 func PostIncBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r int16) {
 	x0 := *(*uint32)(unsafe.Pointer(p))
-	s := 16 - w
+	s := 16 - w - off
 	r = int16(x0) & int16(mask) << s >> (s + off)
 	*(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
 	return r
@@ -1592,7 +1708,7 @@ func PostIncBitFieldPtr32Int16(p uintptr, d int16, w, off int, mask uint32) (r i
 
 func PostIncBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r int32) {
 	x0 := *(*uint32)(unsafe.Pointer(p))
-	s := 32 - w
+	s := 32 - w - off
 	r = int32(x0) & int32(mask) << s >> (s + off)
 	*(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
 	return r
@@ -1600,7 +1716,7 @@ func PostIncBitFieldPtr32Int32(p uintptr, d int32, w, off int, mask uint32) (r i
 
 func PostIncBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r int64) {
 	x0 := *(*uint32)(unsafe.Pointer(p))
-	s := 64 - w
+	s := 64 - w - off
 	r = int64(x0) & int64(mask) << s >> (s + off)
 	*(*uint32)(unsafe.Pointer(p)) = x0&^uint32(mask) | uint32(r+d)<<off&mask
 	return r
@@ -1608,7 +1724,7 @@ func PostIncBitFieldPtr32Int64(p uintptr, d int64, w, off int, mask uint32) (r i
 
 func PostIncBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int8) {
 	x0 := *(*uint64)(unsafe.Pointer(p))
-	s := 8 - w
+	s := 8 - w - off
 	r = int8(x0) & int8(mask) << s >> (s + off)
 	*(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
 	return r
@@ -1616,7 +1732,7 @@ func PostIncBitFieldPtr64Int8(p uintptr, d int8, w, off int, mask uint64) (r int
 
 func PostIncBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r int16) {
 	x0 := *(*uint64)(unsafe.Pointer(p))
-	s := 16 - w
+	s := 16 - w - off
 	r = int16(x0) & int16(mask) << s >> (s + off)
 	*(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
 	return r
@@ -1624,7 +1740,7 @@ func PostIncBitFieldPtr64Int16(p uintptr, d int16, w, off int, mask uint64) (r i
 
 func PostIncBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r int32) {
 	x0 := *(*uint64)(unsafe.Pointer(p))
-	s := 32 - w
+	s := 32 - w - off
 	r = int32(x0) & int32(mask) << s >> (s + off)
 	*(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
 	return r
@@ -1632,7 +1748,7 @@ func PostIncBitFieldPtr64Int32(p uintptr, d int32, w, off int, mask uint64) (r i
 
 func PostIncBitFieldPtr64Int64(p uintptr, d int64, w, off int, mask uint64) (r int64) {
 	x0 := *(*uint64)(unsafe.Pointer(p))
-	s := 64 - w
+	s := 64 - w - off
 	r = int64(x0) & int64(mask) << s >> (s + off)
 	*(*uint64)(unsafe.Pointer(p)) = x0&^uint64(mask) | uint64(r+d)<<off&mask
 	return r